ci-dev.yml

name: CI - Dev

on:
    push:
        branches:
            - 'dev'
    pull_request:
        branches:
            - 'main'
        types: [opened, synchronize, reopened]

concurrency:
    group: ${{ github.workflow }}-${{ github.ref }}
    cancel-in-progress: false

permissions: {}

jobs:
    dev_to_main_pr:
        name: 'Create/Update Dev to Main PR'
        runs-on: ubuntu-latest
        if: github.event_name == 'push' && github.ref_name == 'dev' && !contains(github.event.head_commit.message, '[skip-release-pr]')
        timeout-minutes: 10
        permissions:
            contents: read
            pull-requests: write
        steps:
            - name: Checkout
              uses: actions/checkout@v6
              continue-on-error: true
              with:
                  fetch-depth: 0
                  token: ${{ secrets.GITHUB_TOKEN }}
                  submodules: true

            - name: Init submodules (with retry)
              continue-on-error: true
              run: |
                  for i in 1 2 3; do
                    git submodule update --init --recursive && break
                    echo "Attempt $i failed, retrying in 10s..."
                    sleep 10
                  done

            - name: Verify critical submodules
              run: |
                  failed=0
                  for mod in apps/mc/pumpkin apps/postgres; do
                    if [ ! -f "$mod/.git" ] && [ ! -d "$mod/.git" ]; then
                      echo "::error::Critical submodule missing: $mod"
                      failed=1
                    else
                      echo "OK: $mod"
                    fi
                  done
                  exit $failed

            - name: Check if dev has changes for main
              id: check_changes
              uses: actions/github-script@v8
              with:
                  github-token: ${{ secrets.GITHUB_TOKEN }}
                  script: |
                      // Compare dev with main to see if there are changes to promote
                      try {
                          const comparison = await github.rest.repos.compareCommits({
                              owner: context.repo.owner,
                              repo: context.repo.repo,
                              base: 'main',
                              head: 'dev'
                          });

                          const commitCount = comparison.data.commits.length;
                          console.log(`Found ${commitCount} commits between main and dev`);

                          if (commitCount === 0) {
                              console.log('Dev is up-to-date with main - no PR needed');

                              // Check the reverse - is main ahead of dev?
                              const reverseComparison = await github.rest.repos.compareCommits({
                                  owner: context.repo.owner,
                                  repo: context.repo.repo,
                                  base: 'dev',
                                  head: 'main'
                              });

                              if (reverseComparison.data.commits.length > 0) {
                                  return {
                                      hasChanges: false,
                                      commitCount: 0,
                                      message: `Main is ${reverseComparison.data.commits.length} commits ahead of dev`,
                                      mainAhead: true,
                                      mainAheadBy: reverseComparison.data.commits.length
                                  };
                              } else {
                                  return {
                                      hasChanges: false,
                                      commitCount: 0,
                                      message: 'Dev and main are synchronized',
                                      mainAhead: false
                                  };
                              }
                          }

                          console.log(`Dev has ${commitCount} commits ready for main`);
                          return {
                              hasChanges: true,
                              commitCount: commitCount,
                              commits: comparison.data.commits,
                              mainAhead: false
                          };

                      } catch (error) {
                          console.log(`Error comparing branches: ${error.message}`);
                          return {
                              hasChanges: false,
                              commitCount: 0,
                              error: error.message
                          };
                      }

            - name: Skip PR creation - no changes or main ahead
              if: fromJson(steps.check_changes.outputs.result).hasChanges == false
              run: |
                  echo "Dev to Main PR Status: NOT NEEDED"

                  if [[ "${{ fromJson(steps.check_changes.outputs.result).mainAhead }}" == "true" ]]; then
                      echo "Main is ${{ fromJson(steps.check_changes.outputs.result).mainAheadBy }} commits ahead of dev"
                      echo "This is normal after a release - main contains the latest released code"
                      echo "Dev will catch up when new atomic commits are added"
                  else
                      echo "Dev and main are synchronized"
                      echo "No new atomic commits to promote yet"
                  fi

                  echo ""
                  echo "This is a normal state that indicates:"
                  echo "- No new atomic commits have been merged to dev since last promotion"
                  echo "- System is in a clean, synchronized state"
                  echo "- Ready for new development work"

            - name: Check if dev→main PR exists
              if: fromJson(steps.check_changes.outputs.result).hasChanges == true
              id: check_pr
              uses: actions/github-script@v8
              with:
                  github-token: ${{ secrets.GITHUB_TOKEN }}
                  script: |
                      const existingPRs = await github.rest.pulls.list({
                        owner: context.repo.owner,
                        repo: context.repo.repo,
                        head: `${context.repo.owner}:dev`,
                        base: 'main',
                        state: 'open'
                      });

                      if (existingPRs.data.length > 0) {
                        console.log(`Found existing PR: #${existingPRs.data[0].number}`);
                        return {
                          exists: true,
                          number: existingPRs.data[0].number,
                          url: existingPRs.data[0].html_url
                        };
                      } else {
                        console.log('No existing dev→main PR found');
                        return { exists: false };
                      }

            - name: Create or update dev→main PR
              if: fromJson(steps.check_changes.outputs.result).hasChanges == true
              id: upsert_pr
              uses: actions/github-script@v8
              with:
                  github-token: ${{ secrets.GITHUB_TOKEN }}
                  script: |
                      const path = require('path');
                      const utils = await import(path.resolve('.github/scripts/commit-utils.mjs'));

                      const checkResult = ${{ steps.check_pr.outputs.result || 'null' }};

                      // Get commits between main and dev
                      const comparison = await github.rest.repos.compareCommits({
                        owner: context.repo.owner,
                        repo: context.repo.repo,
                        base: 'main',
                        head: 'dev'
                      });

                      const rawCommits = comparison.data.commits.map(c => ({
                        message: c.commit.message,
                        sha: c.sha
                      }));
                      console.log(`Found ${rawCommits.length} commits`);

                      const { categories } = utils.categorizeCommits(rawCommits);
                      const title = utils.generateTitle(categories, 'Main');
                      const body = utils.formatDevToMainBody(categories, rawCommits.length);

                      let prNumber;
                      if (checkResult && checkResult.exists) {
                        prNumber = checkResult.number;
                      } else {
                        // Create new PR
                        const pr = await github.rest.pulls.create({
                          owner: context.repo.owner,
                          repo: context.repo.repo,
                          title,
                          head: 'dev',
                          base: 'main',
                          body,
                          draft: false
                        });
                        prNumber = pr.data.number;

                        await github.rest.issues.addLabels({
                          owner: context.repo.owner,
                          repo: context.repo.repo,
                          issue_number: prNumber,
                          labels: ['auto-pr', 'dev→main']
                        });

                        console.log(`Created PR #${prNumber}`);
                      }

                      // Always update title and body to reflect latest commits
                      await github.rest.pulls.update({
                        owner: context.repo.owner,
                        repo: context.repo.repo,
                        pull_number: prNumber,
                        title,
                        body
                      });

                      console.log(`Updated PR #${prNumber} — ${title}`);
                      return { number: prNumber };

            - name: Enable auto-merge with clean commit title
              if: fromJson(steps.check_changes.outputs.result).hasChanges == true
              uses: actions/github-script@v8
              with:
                  github-token: ${{ secrets.GITHUB_TOKEN }}
                  script: |
                      const path = require('path');
                      const utils = await import(path.resolve('.github/scripts/commit-utils.mjs'));
                      const prResult = ${{ steps.upsert_pr.outputs.result }};
                      const prNumber = prResult.number;

                      // Get PR node_id and title
                      const pr = await github.rest.pulls.get({
                        owner: context.repo.owner,
                        repo: context.repo.repo,
                        pull_number: prNumber
                      });

                      // Generate clean merge commit body (plain text, no markdown UI)
                      const comparison = await github.rest.repos.compareCommits({
                        owner: context.repo.owner,
                        repo: context.repo.repo,
                        base: 'main',
                        head: 'dev'
                      });
                      const rawCommits = comparison.data.commits.map(c => ({
                        message: c.commit.message,
                        sha: c.sha
                      }));
                      const { categories } = utils.categorizeCommits(rawCommits);
                      const mergeBody = utils.formatMergeCommitBody(categories, rawCommits.length, 'main');

                      try {
                        await github.graphql(`
                          mutation($prId: ID!, $headline: String!, $body: String!) {
                            enablePullRequestAutoMerge(input: {
                              pullRequestId: $prId
                              commitHeadline: $headline
                              commitBody: $body
                              mergeMethod: MERGE
                            }) {
                              pullRequest { number }
                            }
                          }
                        `, {
                          prId: pr.data.node_id,
                          headline: pr.data.title,
                          body: mergeBody
                        });
                        console.log(`Auto-merge enabled for PR #${prNumber} with title: ${pr.data.title}`);
                      } catch (error) {
                        console.log(`Could not enable auto-merge: ${error.message}`);
                        console.log('Ensure "Allow auto-merge" is enabled in repo settings and branch protection is configured on main');
                        console.log('PR will need manual merge — use the PR title as the merge commit message');
                      }

            - name: Summary
              run: |
                  if [[ "${{ fromJson(steps.check_changes.outputs.result).hasChanges }}" == "true" ]]; then
                      echo "Dev→Main PR: CREATED/UPDATED"
                      echo "Atomic commits ready for main: ${{ fromJson(steps.check_changes.outputs.result).commitCount }}"
                  else
                      echo "Dev→Main PR: NOT NEEDED"
                      echo "Branches are synchronized or main is ahead"
                  fi

    alter:
        name: 'Dev File Alterations'
        if: github.repository == 'kbve/kbve'
        permissions:
            contents: read
        uses: KBVE/kbve/.github/workflows/utils-file-alterations.yml@main
        with:
            branch: 'dev'

    dev_docker_mc:
        name: 'Dev Docker Build — MC'
        needs: [alter]
        if: needs.alter.outputs.mc == 'true'
        runs-on: ubuntu-latest
        timeout-minutes: 30
        permissions:
            contents: read
        steps:
            - name: Checkout
              uses: actions/checkout@v6
              continue-on-error: true
              with:
                  submodules: true

            - name: Init submodules (with retry)
              continue-on-error: true
              run: |
                  for i in 1 2 3; do
                    git submodule update --init --recursive && break
                    echo "Attempt $i failed, retrying in 10s..."
                    sleep 10
                  done

            - name: Verify critical submodules
              run: |
                  failed=0
                  for mod in apps/mc/pumpkin apps/postgres; do
                    if [ ! -f "$mod/.git" ] && [ ! -d "$mod/.git" ]; then
                      echo "::error::Critical submodule missing: $mod"
                      failed=1
                    else
                      echo "OK: $mod"
                    fi
                  done
                  exit $failed

            - name: Set up Docker Buildx
              uses: docker/setup-buildx-action@v4

            - name: Build MC dev image
              uses: docker/build-push-action@v7
              with:
                  context: .
                  file: apps/mc/Dockerfile.dev
                  push: false
                  load: true
                  tags: kbve/mc:dev
                  cache-from: type=gha,scope=mc-dev
                  cache-to: type=gha,scope=mc-dev,mode=max

            - name: Create offline test config
              run: |
                  cp apps/mc/data/config/configuration.toml /tmp/configuration.toml
                  sed -i 's/online_mode = true/online_mode = false/' /tmp/configuration.toml
                  sed -i 's/encryption = true/encryption = false/' /tmp/configuration.toml

            - name: Smoke test — server starts
              run: |
                  docker run -d --name mc-dev-test \
                    -p 25565:25565 \
                    -v /tmp/configuration.toml:/pumpkin/config/configuration.toml:ro \
                    kbve/mc:dev
                  sleep 10
                  docker logs mc-dev-test 2>&1
                  docker logs mc-dev-test 2>&1 | grep -q "Started server" || { echo "Server failed to start"; docker logs mc-dev-test 2>&1; exit 1; }
                  docker stop mc-dev-test

    validate_pr:
        name: 'Validate Dev→Main PR'
        if: github.event_name == 'pull_request' && github.base_ref == 'main' && github.head_ref == 'dev'
        permissions:
            contents: read
        uses: ./.github/workflows/utils-ci-lint-test.yml
        with:
            base-ref: origin/main
            head-ref: origin/dev
            check-conflicts: true