commit.yml

# GitHub runner workflow for building, verifying and testing the XVM repo.
#
# This is the main CI workflow that runs on every push. It builds the XDK,
# runs tests, and uploads build artifacts. After a successful build, publishing
# workflows (snapshot-release, docker-build, homebrew-update) are automatically
# triggered on master branch or when manually run with test-publishing=true.
#
# PLATFORM NOTES:
# - Ubuntu: ubuntu-latest (currently Ubuntu 22.04)
# - Windows: windows-latest
#
name: Verify Commit

permissions:
    contents: write
    actions: write

on:
    push:
        # Only run on master (after PRs are merged)
        branches: [master]
    pull_request:
        # Test all PRs before merging
        branches: [master]
    # Manual trigger - optionally triggers publishing workflows after successful completion
    # This allows testing the full publishing pipeline (snapshot, docker, homebrew) from any branch
    # without pushing to master. Set publish-snapshots=true to trigger publishing workflows.
    workflow_dispatch:
        inputs:
            publish-snapshots:
                description: 'Trigger publishing workflows after build (snapshot, docker, homebrew)'
                type: boolean
                required: false
                default: false
            platforms:
                description: 'Run only single platform (ubuntu-latest, windows-latest, or all platforms)'
                type: choice
                required: false
                default: 'ubuntu-latest'
                options:
                    - 'ubuntu-latest'
                    - 'windows-latest'
                    - 'all'
            extra-gradle-options:
                description: 'Extra Gradle options to pass to the build'
                required: false
            skip-tests:
                description: 'Skip manual tests'
                type: boolean
                required: false
                default: false
            parallel-test-mode:
                description: 'Run manual tests in parallel mode'
                type: boolean
                required: false
                default: true
            include-lang:
                description: 'Include lang projects in build and run tree-sitter validation'
                type: boolean
                required: false
                default: false

env:
    # Add manual tests as included builds - defaults to true for push/PR, controlled by include-lang for workflow_dispatch
    ORG_GRADLE_PROJECT_includeBuildManualTests: ${{ github.event_name != 'workflow_dispatch' || github.event.inputs.include-lang == true || github.event.inputs.include-lang == 'true' }}
    ORG_GRADLE_PROJECT_includeBuildAttachManualTests: ${{ github.event_name != 'workflow_dispatch' || github.event.inputs.include-lang == true || github.event.inputs.include-lang == 'true' }}
    ORG_GRADLE_PROJECT_xtcPluginOverrideVerboseLogging: true
    RUN_INTEGRATION_TESTS: true

    # Lang build inclusion - overrides gradle.properties default (true) to exclude lang
    # from push/PR CI builds. Only included via workflow_dispatch with include-lang=true.
    # Tree-sitter validation steps have their own path-based gating.
    ORG_GRADLE_PROJECT_includeBuildLang: ${{ github.event_name == 'workflow_dispatch' && (github.event.inputs.include-lang == true || github.event.inputs.include-lang == 'true') }}
    ORG_GRADLE_PROJECT_includeBuildAttachLang: ${{ github.event_name == 'workflow_dispatch' && (github.event.inputs.include-lang == true || github.event.inputs.include-lang == 'true') }}

    skip_manual_tests: ${{ github.event.inputs.skip-tests == true || github.event.inputs.skip-tests == 'true' }}
    # Default to parallel mode (true) for push/PR events; for workflow_dispatch, use the input value
    run_manual_tests_parallel: ${{ github.event_name != 'workflow_dispatch' || github.event.inputs.parallel-test-mode == true || github.event.inputs.parallel-test-mode == 'true' }}
    trigger_publishing: ${{ github.event.inputs.publish-snapshots == true || github.event.inputs.publish-snapshots == 'true' }}

    # Gradle cache inspection function
    GRADLE_CACHE_INSPECT: |
        inspect_gradle_cache() {
            local label="${1:-}"
            local gradle_home="${GRADLE_USER_HOME:-$HOME/.gradle}"
            echo "🔍 Gradle Cache Inspection${label:+ ($label)}:"
            echo "  Cache location: $gradle_home"
            if [ ! -d "$gradle_home" ]; then
                echo "  Cache exists: ❌"
                return 0
            fi
            echo "  Cache exists: ✅"
            local total_size=$(du -sh "$gradle_home" 2>/dev/null | cut -f1 || echo "unknown")
            echo "  Cache size: $total_size"
            for dir in caches wrapper build-cache; do
                if [ -d "$gradle_home/$dir" ]; then
                    local dir_size=$(du -sh "$gradle_home/$dir" 2>/dev/null | cut -f1 || echo "unknown")
                    echo "    $dir: $dir_size"
                fi
            done
        }

# Concurrency settings: group by workflow and ref to prevent duplicate runs
# Push and pull_request for the same branch will cancel each other (keeping latest)
concurrency:
    group: "${{ github.workflow }}-${{ github.ref }}"
    cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}

jobs:
    build-and-test:
        strategy:
            matrix:
                os: ${{ github.event.inputs.platforms == 'ubuntu-latest' && fromJSON('["ubuntu-latest"]') || github.event.inputs.platforms == 'windows-latest' && fromJSON('["windows-latest"]') || github.event.inputs.platforms == 'all' && fromJSON('["ubuntu-latest", "windows-latest"]') || fromJSON('["ubuntu-latest"]') }}

        runs-on: ${{ matrix.os }}

        steps:
            - name: Fetch Sources
              uses: actions/checkout@v6
              with:
                  fetch-depth: 0  # Need full history for path filtering
                  show-progress: true

            - name: Check for lang-related changes
              id: changes
              uses: dorny/paths-filter@v3
              with:
                  filters: |
                      lang:
                        - 'lang/**'
                        - 'lib_ecstasy/**/*.x'

            - name: 🚀 Publishing Configuration
              shell: bash
              run: |
                  echo ""
                  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"

                  # Determine if publishing will be triggered
                  WILL_PUBLISH=false

                  # Check if this is a Dependabot merge (always skip)
                  if [ "${{ github.actor }}" = "dependabot[bot]" ]; then
                      echo "::notice::⏭️  PUBLISHING DISABLED: Dependabot merge detected"
                      echo -e "\033[1;33m"
                      echo "  ⏭️  NO PUBLISHING WORKFLOWS WILL BE TRIGGERED"
                      echo -e "\033[0m"
                      echo "  📋 Reason: Dependabot merges don't trigger publishing"
                      echo "  📋 Actor: ${{ github.actor }}"
                      echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
                      echo ""
                      exit 0
                  fi

                  # Check if this is master + push
                  if [ "${{ github.ref }}" = "refs/heads/master" ] && [ "${{ github.event_name }}" = "push" ]; then
                      WILL_PUBLISH=true
                      TRIGGER_REASON="Push to master branch"
                  fi

                  # Check if this is manual trigger with publish-snapshots=true
                  if [ "${{ github.event_name }}" = "workflow_dispatch" ] && [ "${{ github.event.inputs.publish-snapshots }}" = "true" ]; then
                      WILL_PUBLISH=true
                      TRIGGER_REASON="Manual trigger with publish-snapshots=true"
                  fi

                  if [ "$WILL_PUBLISH" = "true" ]; then
                      echo "::notice::📦 PUBLISHING ENABLED: Snapshot publishing workflows will be triggered after successful build"
                      echo -e "\033[1;32m"
                      echo "  🚀 PUBLISHING WORKFLOWS WILL BE TRIGGERED"
                      echo -e "\033[0m"
                      echo "  📋 Reason: $TRIGGER_REASON"
                      echo "  📦 Workflows: Publish Snapshots, Publish Docker Images, Update Homebrew"
                  else
                      echo "::notice::⏭️  PUBLISHING DISABLED: No publishing workflows will be triggered"
                      echo -e "\033[1;33m"
                      echo "  ⏭️  NO PUBLISHING WORKFLOWS WILL BE TRIGGERED"
                      echo -e "\033[0m"
                      echo "  📋 Branch: ${{ github.ref_name }}"
                      echo "  📋 Event: ${{ github.event_name }}"
                      if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
                          echo "  📋 publish-snapshots: ${{ github.event.inputs.publish-snapshots }}"
                      fi
                  fi

                  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
                  echo ""

            - name: Setup XVM Project
              id: versions
              uses: ./.github/actions/setup-xvm-project
              with:
                  setup-build: true
                  cache-read-only: false
                  enable-debug: false

            - name: Debug Environment (Windows)
              if: runner.os == 'Windows'
              shell: bash
              run: |
                  echo "=== Windows Debug Information ==="
                  echo "OS: $RUNNER_OS"
                  echo "Operating System: $(uname -a 2>/dev/null || echo 'N/A')"
                  echo "Java version:"
                  java -version 2>&1 || echo "Java not available"
                  echo "=== End Debug Information ==="

            - name: Dump environment info
              shell: bash
              run: |
                  echo "*** Branch (github.ref)    : ${{ github.ref }}"
                  echo "*** Commit (github.sha)    : ${{ github.sha }}"
                  echo "*** Runner OS              : ${{ runner.os }}"
                  echo "*** XDK Version            : ${{ steps.versions.outputs.xdk-version }}"
                  echo "*** Java Version           : ${{ steps.versions.outputs.java-version }}"

            - name: Build the XDK and create a distribution
              shell: bash
              env:
                  GRADLE_OPTS: ${{ steps.versions.outputs.gradle-jvm-opts }}
              run: |
                ${{ env.GRADLE_CACHE_INSPECT }}
                # Combine standard options with optional extra options
                GRADLE_OPTIONS="${{ steps.versions.outputs.gradle-options }} ${{ github.event.inputs.extra-gradle-options }}"

                cwd_path=$(pwd)
                echo "Executing Gradle 'clean', 'check', and 'distZip' tasks from: '$cwd_path'"
                ls -la build/ 2>/dev/null && echo "Build directory exists - will be cleaned" || echo "✅ No previous build outputs"

                inspect_gradle_cache "before build"
                ./gradlew $GRADLE_OPTIONS clean
                ./gradlew $GRADLE_OPTIONS distZip check -Porg.xtclang.java.lint=true -Porg.xtclang.java.warningsAsErrors=false -Porg.xtclang.java.test.stdout=true

                # Run manual tests inline if enabled (avoids cache rebuild)
                if [ "${{ env.skip_manual_tests }}" == "true" ]; then
                    echo "⏭️ Manual tests skipped (disabled)"
                    exit 0
                fi
                
                echo "🧪 Running manual tests inline (cache still hot)..."
                inspect_gradle_cache "before manual tests"
                manual_task_main=$( [ "${{ env.run_manual_tests_parallel }}" = "true" ] && echo "runAllTestTasksParallel" || echo "runAllTestTasks" )
                echo "Running manual tests (main task: $manual_task_main)"
                ./gradlew $GRADLE_OPTIONS manualTests:runXtc manualTests:runOne -PtestName=TestMisc manualTests:runTwoTestsInSequence "manualTests:$manual_task_main"        
                inspect_gradle_cache "after manual tests"
                echo "✅ Manual tests completed"

            - name: Skip Tree-sitter (no lang changes)
              if: |
                  success() &&
                  matrix.os == 'ubuntu-latest' &&
                  env.ORG_GRADLE_PROJECT_includeBuildLang == 'true' &&
                  steps.changes.outputs.lang != 'true'
              run: |
                  echo "⏭️ Skipping Tree-sitter validation - no changes in lang/ or lib_ecstasy/*.x"
                  echo "Changed paths filter result: lang=${{ steps.changes.outputs.lang }}"

            - name: Validate Tree-sitter Grammar and LSP Adapters
              if: |
                  success() &&
                  matrix.os == 'ubuntu-latest' &&
                  env.ORG_GRADLE_PROJECT_includeBuildLang == 'true' &&
                  steps.changes.outputs.lang == 'true'
              shell: bash
              env:
                  GRADLE_OPTS: ${{ steps.versions.outputs.gradle-jvm-opts }}
              run: |
                  GRADLE_OPTIONS="${{ steps.versions.outputs.gradle-options }}"

                  echo ""
                  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
                  echo "🌳 TREE-SITTER GRAMMAR VALIDATION"
                  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"

                  echo "📋 Validating grammar compiles (tree-sitter generate)..."
                  ./gradlew $GRADLE_OPTIONS :lang:tree-sitter:validateTreeSitterGrammar
                  echo "✅ Grammar: VALID"

                  echo ""
                  echo "📋 Testing parser on XDK corpus (with timing)..."
                  ./gradlew $GRADLE_OPTIONS :lang:tree-sitter:testTreeSitterParse
                  echo "✅ Corpus parsing: PASSED"

                  echo ""
                  echo "📋 Building native libraries for all platforms..."
                  ./gradlew $GRADLE_OPTIONS :lang:tree-sitter:buildAllNativeLibrariesOnDemand
                  echo "✅ Native libraries: BUILT (cached by content hash)"

                  echo ""
                  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
                  echo "🔌 LSP ADAPTER TESTS"
                  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"

                  echo ""
                  echo "📋 Running LSP tests with MOCK adapter (-Plsp.adapter=mock)..."
                  ./gradlew $GRADLE_OPTIONS :lang:lsp-server:test -Plsp.adapter=mock
                  echo "✅ Mock adapter tests: PASSED"

                  echo ""
                  echo "📋 Running LSP tests with TREESITTER adapter (-Plsp.adapter=treesitter)..."
                  ./gradlew $GRADLE_OPTIONS :lang:lsp-server:test -Plsp.adapter=treesitter
                  echo "✅ Tree-sitter adapter tests: PASSED"

                  echo ""
                  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
                  echo "🎉 ALL LANG VALIDATION COMPLETE"
                  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"

            # TODO:
            # name: XTC App Template Integration Test
            #  if: success() && matrix.os == 'ubuntu-latest'
            #  ## 1) Clone out xtc-app-template from github.com/xtclang/xtc-app-template or wherever it is.
            #  ## 2) Run gradlew publishLocal on the xvm repo we are testing in this commit.yml file.
            #  ## 3) cd into the xtc-app-template folder and run ./gradlew greet, which should work and not fail
            #  uses: act

            - name: Upload XDK distribution artifact
              if: success() && matrix.os == 'ubuntu-latest'
              uses: actions/upload-artifact@v6
              with:
                  name: xdk-dist-${{ github.sha }}
                  path: xdk/build/distributions/xdk-*.zip
                  retention-days: 10

            - name: Summary
              if: success()
              shell: bash
              run: |
                  echo "### ✅ Build and Test Completed" >> $GITHUB_STEP_SUMMARY
                  echo "" >> $GITHUB_STEP_SUMMARY
                  echo "- **Version:** ${{ steps.versions.outputs.xdk-version }}" >> $GITHUB_STEP_SUMMARY
                  echo "- **Java Version:** ${{ steps.versions.outputs.java-version }}" >> $GITHUB_STEP_SUMMARY
                  echo "- **Commit:** ${{ github.sha }}" >> $GITHUB_STEP_SUMMARY
                  echo "- **Branch:** ${{ github.ref_name }}" >> $GITHUB_STEP_SUMMARY

    # Summary job that always succeeds if build-and-test completes
    # Use this for branch protection instead of individual matrix jobs
    build-complete:
        name: All builds complete
        needs: build-and-test
        runs-on: ubuntu-latest
        if: always()
        steps:
            - name: Check build status
              run: |
                  if [ "${{ needs.build-and-test.result }}" != "success" ]; then
                    echo "❌ Build failed or was cancelled"
                    exit 1
                  fi
                  echo "✅ All builds completed successfully"

    # Integration test: verify the XTC plugin works with external projects
    # Clones xtc-app-template, publishes XDK locally, and runs the template app
    integration-test:
        name: Plugin integration test
        needs: build-and-test
        runs-on: ubuntu-latest
        if: success()

        steps:
            - name: Checkout XVM
              uses: actions/checkout@v6
              with:
                  fetch-depth: 1

            - name: Setup XVM Project
              id: versions
              uses: ./.github/actions/setup-xvm-project
              with:
                  setup-build: true
                  cache-read-only: true
                  enable-debug: false

            - name: Publish XDK to Maven Local
              env:
                  GRADLE_OPTS: ${{ steps.versions.outputs.gradle-jvm-opts }}
              run: |
                  echo "📦 Publishing XDK to Maven Local..."
                  ./gradlew ${{ steps.versions.outputs.gradle-options }} publishLocal
                  echo "✅ XDK published to Maven Local"

            - name: Clone xtc-app-template
              run: |
                  echo "📥 Cloning xtc-app-template..."
                  git clone --depth 1 https://github.com/xtclang/xtc-app-template.git ../xtc-app-template
                  echo "✅ Template cloned"

            - name: Update template to use current XDK version
              run: |
                  XDK_VERSION="${{ steps.versions.outputs.xdk-version }}"
                  echo "🔧 Updating xtc-app-template to use XDK version: $XDK_VERSION"

                  # Update only the version in [versions] section, not the plugin definition
                  # The pattern matches: xtc = "..." (quoted version string)
                  # But not: xtc = { ... } (plugin definition with braces)
                  sed -i 's/^xtc = "[^"]*"/xtc = "'"$XDK_VERSION"'"/' ../xtc-app-template/gradle/libs.versions.toml

                  echo "📄 Updated libs.versions.toml:"
                  cat ../xtc-app-template/gradle/libs.versions.toml

            - name: Run xtc-app-template with local XDK
              working-directory: ../xtc-app-template
              run: |
                  echo "🧪 Running xtc-app-template with locally published XDK..."
                  ./gradlew greet -PlocalOnly=true --no-daemon --refresh-dependencies
                  echo "✅ Integration test passed - plugin works with external projects"

            - name: Summary
              if: success()
              run: |
                  echo "### ✅ Plugin Integration Test Passed" >> $GITHUB_STEP_SUMMARY
                  echo "" >> $GITHUB_STEP_SUMMARY
                  echo "- **XDK Version:** ${{ steps.versions.outputs.xdk-version }}" >> $GITHUB_STEP_SUMMARY
                  echo "- **Template:** xtc-app-template" >> $GITHUB_STEP_SUMMARY
                  echo "- **Test:** \`./gradlew greet -PlocalOnly=true\`" >> $GITHUB_STEP_SUMMARY

    # Trigger publishing workflows for snapshots
    # Runs when:
    # 1. Push to master (automatic snapshot publishing) - BUT NOT for release merges or Dependabot merges
    # 2. Manual trigger with publish-snapshots=true (testing from any branch)
    #
    # Release merges are handled by promote-release.yml workflow instead
    # Dependabot merges are skipped to avoid permission issues
    trigger-publishing:
        name: Trigger snapshot publishing workflows
        needs: [build-and-test, integration-test]
        runs-on: ubuntu-latest
        if: |
            success() &&
            github.actor != 'dependabot[bot]' &&
            (
                (github.ref == 'refs/heads/master' && github.event_name == 'push')
                ||
                (github.event_name == 'workflow_dispatch' &&
                 (github.event.inputs.publish-snapshots == true || github.event.inputs.publish-snapshots == 'true'))
            )

        steps:
            - name: Checkout repository
              uses: actions/checkout@v6
              with:
                  fetch-depth: 10  # Need history to check for release tags

            - name: Check if this is a release merge
              id: check-release
              run: |
                  # Check if current commit has a release tag (v*.*.*)
                  # Release merges should use promote-release.yml, not snapshot publishing
                  RELEASE_TAG=$(git tag --points-at HEAD | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' || true)

                  if [ -n "$RELEASE_TAG" ]; then
                      echo "is-release=true" >> $GITHUB_OUTPUT
                      echo "release-tag=$RELEASE_TAG" >> $GITHUB_OUTPUT
                      echo "🏷️  Detected release tag: $RELEASE_TAG"
                      echo "⏭️  Skipping snapshot publishing (will be handled by promote-release.yml)"
                  else
                      echo "is-release=false" >> $GITHUB_OUTPUT
                      echo "✅ No release tag detected - proceeding with snapshot publishing"
                  fi

            - name: Trigger snapshot publishing
              if: steps.check-release.outputs.is-release != 'true'
              env:
                  GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
              run: |
                  echo "🚀 Triggering Publish Snapshots workflow..."
                  gh workflow run publish-snapshot.yml --repo ${{ github.repository }} --ref ${{ github.ref_name }} --field ci-run-id=${{ github.run_id }}
                  echo "✅ Snapshot publishing triggered"

            - name: Trigger Docker publishing
              if: steps.check-release.outputs.is-release != 'true'
              env:
                  GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
              run: |
                  echo "🚀 Triggering Publish Docker Images workflow..."
                  gh workflow run publish-docker.yml --repo ${{ github.repository }} --ref ${{ github.ref_name }} --field ci-run-id=${{ github.run_id }}
                  echo "✅ Docker publishing triggered"

            - name: Trigger Homebrew update
              if: steps.check-release.outputs.is-release != 'true'
              env:
                  GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
              run: |
                  echo "🚀 Triggering Update Homebrew workflow..."
                  gh workflow run homebrew-update.yml --repo ${{ github.repository }} --ref ${{ github.ref_name }} --field ci-run-id=${{ github.run_id }}
                  echo "✅ Homebrew update triggered"

            - name: Summary - Snapshots Triggered
              if: steps.check-release.outputs.is-release != 'true'
              run: |
                  echo "### 🚀 Publishing Workflows Triggered" >> $GITHUB_STEP_SUMMARY
                  echo "" >> $GITHUB_STEP_SUMMARY
                  echo "The following workflows have been triggered:" >> $GITHUB_STEP_SUMMARY
                  echo "- ✅ Snapshot publishing" >> $GITHUB_STEP_SUMMARY
                  echo "- ✅ Docker publishing" >> $GITHUB_STEP_SUMMARY
                  echo "- ✅ Homebrew update" >> $GITHUB_STEP_SUMMARY
                  echo "" >> $GITHUB_STEP_SUMMARY
                  echo "Check the [Actions tab](https://github.com/${{ github.repository }}/actions) for workflow status." >> $GITHUB_STEP_SUMMARY

            - name: Summary - Release Detected
              if: steps.check-release.outputs.is-release == 'true'
              run: |
                  echo "### 🏷️ Release Merge Detected" >> $GITHUB_STEP_SUMMARY
                  echo "" >> $GITHUB_STEP_SUMMARY
                  echo "**Release Tag:** ${{ steps.check-release.outputs.release-tag }}" >> $GITHUB_STEP_SUMMARY
                  echo "" >> $GITHUB_STEP_SUMMARY
                  echo "Snapshot publishing skipped - release promotion will be handled by promote-release.yml workflow." >> $GITHUB_STEP_SUMMARY
                  echo "" >> $GITHUB_STEP_SUMMARY
                  echo "Check the [Actions tab](https://github.com/${{ github.repository }}/actions) for promote-release workflow status." >> $GITHUB_STEP_SUMMARY