hungry-ghost-hive 0.47.2 → 0.47.3

package/src/utils/auto-merge.test.ts

@@ -27,7 +27,7 @@ vi.mock('../connectors/project-management/operations.js', () => ({
 }));
 
 import { loadConfig } from '../config/loader.js';
-import { autoMergeApprovedPRs } from './auto-merge.js';
+import { autoMergeApprovedPRs, checkPreexistingCIFailures } from './auto-merge.js';
 
 const mockLoadConfig = vi.mocked(loadConfig);
 
@@ -380,5 +380,217 @@ describe('auto-merge functionality', () => {
       expect(result).toBe(0);
       expect(getPullRequestById(db, pr.id)?.status).toBe('approved');
     });
+
+    it('should bypass BLOCKED status when all CI failures are pre-existing on base branch', async () => {
+      const pr = createPullRequest(db, {
+        storyId,
+        teamId,
+        branchName: 'feature/preexisting-ci',
+        githubPrNumber: 555,
+      });
+      updatePullRequest(db, pr.id, { status: 'approved' });
+
+      mockLoadConfig.mockReturnValue({
+        integrations: {
+          autonomy: { level: 'full', allow_preexisting_ci_failures: true },
+          source_control: { provider: 'github' },
+          project_management: { provider: 'none' },
+        },
+      } as any);
+
+      const mockExecSync = vi.fn();
+      // 1. gh pr view → BLOCKED but MERGEABLE
+      mockExecSync.mockReturnValueOnce(
+        JSON.stringify({ state: 'OPEN', mergeable: 'MERGEABLE', mergeStateStatus: 'BLOCKED' })
+      );
+      // 2. gh pr checks → one failing check
+      mockExecSync.mockReturnValueOnce(
+        JSON.stringify([
+          { name: 'build', state: 'SUCCESS' },
+          { name: 'lint', state: 'FAIL' },
+        ])
+      );
+      // 3. gh pr view baseRefName
+      mockExecSync.mockReturnValueOnce(JSON.stringify({ baseRefName: 'main' }));
+      // 4. gh api base branch check-runs → same check failing
+      mockExecSync.mockReturnValueOnce(
+        JSON.stringify([
+          { name: 'build', conclusion: 'success' },
+          { name: 'lint', conclusion: 'failure' },
+        ])
+      );
+      // 5. gh pr merge --admin → success
+      mockExecSync.mockReturnValueOnce(undefined);
+
+      vi.doMock('child_process', () => ({ execSync: mockExecSync }));
+
+      const dbClient = { db, save: vi.fn(), close: vi.fn(), runMigrations: vi.fn() };
+      const result = await autoMergeApprovedPRs('/mock/root', dbClient);
+
+      expect(result).toBe(1);
+      expect(getPullRequestById(db, pr.id)?.status).toBe('merged');
+    });
+
+    it('should not bypass BLOCKED status when PR has new CI failures not on base branch', async () => {
+      const pr = createPullRequest(db, {
+        storyId,
+        teamId,
+        branchName: 'feature/new-ci-failure',
+        githubPrNumber: 556,
+      });
+      updatePullRequest(db, pr.id, { status: 'approved' });
+
+      mockLoadConfig.mockReturnValue({
+        integrations: {
+          autonomy: { level: 'full', allow_preexisting_ci_failures: true },
+          source_control: { provider: 'github' },
+          project_management: { provider: 'none' },
+        },
+      } as any);
+
+      const mockExecSync = vi.fn();
+      // 1. gh pr view → BLOCKED but MERGEABLE
+      mockExecSync.mockReturnValueOnce(
+        JSON.stringify({ state: 'OPEN', mergeable: 'MERGEABLE', mergeStateStatus: 'BLOCKED' })
+      );
+      // 2. gh pr checks → two failing checks
+      mockExecSync.mockReturnValueOnce(
+        JSON.stringify([
+          { name: 'build', state: 'FAIL' },
+          { name: 'lint', state: 'FAIL' },
+        ])
+      );
+      // 3. gh pr view baseRefName
+      mockExecSync.mockReturnValueOnce(JSON.stringify({ baseRefName: 'main' }));
+      // 4. gh api base branch check-runs → only lint fails on base
+      mockExecSync.mockReturnValueOnce(
+        JSON.stringify([
+          { name: 'build', conclusion: 'success' },
+          { name: 'lint', conclusion: 'failure' },
+        ])
+      );
+
+      vi.doMock('child_process', () => ({ execSync: mockExecSync }));
+
+      const dbClient = { db, save: vi.fn(), close: vi.fn(), runMigrations: vi.fn() };
+      const result = await autoMergeApprovedPRs('/mock/root', dbClient);
+
+      // Should not merge — 'build' is a new failure
+      expect(result).toBe(0);
+      // PR should be reset to approved (ci_blocked outcome)
+      expect(getPullRequestById(db, pr.id)?.status).toBe('approved');
+    });
+
+    it('should skip BLOCKED PR when allow_preexisting_ci_failures is false', async () => {
+      const pr = createPullRequest(db, {
+        storyId,
+        teamId,
+        branchName: 'feature/ci-blocked-no-bypass',
+        githubPrNumber: 557,
+      });
+      updatePullRequest(db, pr.id, { status: 'approved' });
+
+      mockLoadConfig.mockReturnValue({
+        integrations: {
+          autonomy: { level: 'full', allow_preexisting_ci_failures: false },
+          source_control: { provider: 'github' },
+          project_management: { provider: 'none' },
+        },
+      } as any);
+
+      const mockExecSync = vi.fn();
+      // gh pr view → BLOCKED but MERGEABLE
+      mockExecSync.mockReturnValueOnce(
+        JSON.stringify({ state: 'OPEN', mergeable: 'MERGEABLE', mergeStateStatus: 'BLOCKED' })
+      );
+
+      vi.doMock('child_process', () => ({ execSync: mockExecSync }));
+
+      const dbClient = { db, save: vi.fn(), close: vi.fn(), runMigrations: vi.fn() };
+      const result = await autoMergeApprovedPRs('/mock/root', dbClient);
+
+      expect(result).toBe(0);
+      expect(getPullRequestById(db, pr.id)?.status).toBe('approved');
+    });
+  });
+
+  describe('checkPreexistingCIFailures', () => {
+    it('should return bypassed=true when all PR failures exist on base branch', () => {
+      const mockExecSync = vi.fn();
+      // gh pr checks
+      mockExecSync.mockReturnValueOnce(
+        JSON.stringify([
+          { name: 'build', state: 'SUCCESS' },
+          { name: 'lint', state: 'FAIL' },
+          { name: 'test', state: 'FAIL' },
+        ])
+      );
+      // gh pr view baseRefName
+      mockExecSync.mockReturnValueOnce(JSON.stringify({ baseRefName: 'main' }));
+      // gh api check-runs
+      mockExecSync.mockReturnValueOnce(
+        JSON.stringify([
+          { name: 'build', conclusion: 'success' },
+          { name: 'lint', conclusion: 'failure' },
+          { name: 'test', conclusion: 'failure' },
+        ])
+      );
+
+      const result = checkPreexistingCIFailures(
+        123,
+        '/repo',
+        '',
+        'owner/repo',
+        mockExecSync as any
+      );
+      expect(result.bypassed).toBe(true);
+      expect(result.bypassedChecks).toEqual(expect.arrayContaining(['lint', 'test']));
+    });
+
+    it('should return bypassed=false when PR has unique failures', () => {
+      const mockExecSync = vi.fn();
+      mockExecSync.mockReturnValueOnce(JSON.stringify([{ name: 'build', state: 'FAIL' }]));
+      mockExecSync.mockReturnValueOnce(JSON.stringify({ baseRefName: 'main' }));
+      mockExecSync.mockReturnValueOnce(JSON.stringify([{ name: 'build', conclusion: 'success' }]));
+
+      const result = checkPreexistingCIFailures(
+        123,
+        '/repo',
+        '',
+        'owner/repo',
+        mockExecSync as any
+      );
+      expect(result.bypassed).toBe(false);
+    });
+
+    it('should return bypassed=false when no PR checks are failing', () => {
+      const mockExecSync = vi.fn();
+      mockExecSync.mockReturnValueOnce(JSON.stringify([{ name: 'build', state: 'SUCCESS' }]));
+
+      const result = checkPreexistingCIFailures(
+        123,
+        '/repo',
+        '',
+        'owner/repo',
+        mockExecSync as any
+      );
+      expect(result.bypassed).toBe(false);
+      expect(result.bypassedChecks).toEqual([]);
+    });
+
+    it('should return bypassed=false when execSync throws', () => {
+      const mockExecSync = vi.fn().mockImplementation(() => {
+        throw new Error('gh not found');
+      });
+
+      const result = checkPreexistingCIFailures(
+        123,
+        '/repo',
+        '',
+        'owner/repo',
+        mockExecSync as any
+      );
+      expect(result.bypassed).toBe(false);
+    });
   });
 });

package/src/utils/auto-merge.ts

@@ -44,9 +44,83 @@ interface ClaimedPR {
   pr: PullRequestRow;
   repoCwd: string;
   repoFlag: string;
+  repoSlug: string | null;
   teamId: string | null;
 }
 
+/**
+ * Compare CI check failures between a PR and its base branch.
+ * Returns bypassed=true when every failing check on the PR also fails on the base branch.
+ */
+export function checkPreexistingCIFailures(
+  prNumber: number,
+  repoCwd: string,
+  repoFlag: string,
+  repoSlug: string | null,
+  execSyncFn: typeof import('child_process').execSync
+): { bypassed: boolean; bypassedChecks: string[] } {
+  try {
+    // Get failing checks on the PR
+    const prChecksRaw = execSyncFn(`gh pr checks ${prNumber} --json name,state${repoFlag}`, {
+      stdio: 'pipe',
+      cwd: repoCwd,
+      encoding: 'utf-8',
+      timeout: PR_STATE_CHECK_TIMEOUT_MS,
+    }) as string;
+    const prChecks: Array<{ name: string; state: string }> = JSON.parse(prChecksRaw);
+    const prFailingNames = new Set(prChecks.filter(c => c.state === 'FAIL').map(c => c.name));
+
+    if (prFailingNames.size === 0) return { bypassed: false, bypassedChecks: [] };
+
+    // Get the base branch ref
+    const baseRefRaw = execSyncFn(`gh pr view ${prNumber} --json baseRefName${repoFlag}`, {
+      stdio: 'pipe',
+      cwd: repoCwd,
+      encoding: 'utf-8',
+      timeout: PR_STATE_CHECK_TIMEOUT_MS,
+    }) as string;
+    const { baseRefName } = JSON.parse(baseRefRaw);
+
+    // Determine repo slug for API call
+    let slug = repoSlug;
+    if (!slug) {
+      try {
+        slug = (
+          execSyncFn('gh repo view --json nameWithOwner -q .nameWithOwner', {
+            stdio: 'pipe',
+            cwd: repoCwd,
+            encoding: 'utf-8',
+            timeout: PR_STATE_CHECK_TIMEOUT_MS,
+          }) as string
+        ).trim();
+      } catch {
+        return { bypassed: false, bypassedChecks: [] };
+      }
+    }
+
+    // Get check runs on the base branch
+    const baseChecksRaw = execSyncFn(
+      `gh api repos/${slug}/commits/${baseRefName}/check-runs --jq '.check_runs'`,
+      { stdio: 'pipe', cwd: repoCwd, encoding: 'utf-8', timeout: PR_STATE_CHECK_TIMEOUT_MS }
+    ) as string;
+    const baseCheckRuns: Array<{ name: string; conclusion: string }> = JSON.parse(baseChecksRaw);
+    const baseFailingNames = new Set(
+      baseCheckRuns.filter(c => c.conclusion === 'failure').map(c => c.name)
+    );
+
+    // Check if all PR failures also fail on base
+    const prOnlyFailures = [...prFailingNames].filter(name => !baseFailingNames.has(name));
+
+    if (prOnlyFailures.length === 0) {
+      return { bypassed: true, bypassedChecks: [...prFailingNames] };
+    }
+
+    return { bypassed: false, bypassedChecks: [] };
+  } catch {
+    return { bypassed: false, bypassedChecks: [] };
+  }
+}
+
 /**
  * Auto-merge all approved PRs that are ready to merge.
  * Can be called immediately after PR approval or from manager daemon.
@@ -130,6 +204,7 @@ export async function autoMergeApprovedPRs(
         pr,
         repoCwd,
         repoFlag: repoSlug ? ` -R ${repoSlug}` : '',
+        repoSlug,
         teamId,
       });
     }
@@ -154,6 +229,8 @@ export async function autoMergeApprovedPRs(
       | { type: 'branch_updated' }
       | { type: 'already_closed'; prState: GitHubPRState }
       | { type: 'conflicts' }
+      | { type: 'ci_blocked' }
+      | { type: 'ci_bypassed'; bypassedChecks: string[] }
       | { type: 'unknown_state' }
       | { type: 'merge_failed'; error: Error };
   }
@@ -207,6 +284,44 @@ export async function autoMergeApprovedPRs(
         continue;
       }
 
+      // Handle BLOCKED mergeStateStatus (CI checks failing)
+      if (prState.mergeStateStatus === 'BLOCKED') {
+        if (config.integrations.autonomy.allow_preexisting_ci_failures) {
+          const ciResult = checkPreexistingCIFailures(
+            pr.github_pr_number!,
+            repoCwd,
+            repoFlag,
+            claimed.repoSlug,
+            execSync
+          );
+          if (ciResult.bypassed) {
+            // All CI failures also exist on the base branch — attempt merge with admin bypass
+            try {
+              execSync(
+                `gh pr merge ${pr.github_pr_number} --squash --delete-branch --admin${repoFlag}`,
+                { stdio: 'pipe', cwd: repoCwd, timeout: PR_MERGE_TIMEOUT_MS }
+              );
+              results.push({
+                claimed,
+                outcome: { type: 'ci_bypassed', bypassedChecks: ciResult.bypassedChecks },
+              });
+            } catch (mergeErr) {
+              results.push({
+                claimed,
+                outcome: {
+                  type: 'merge_failed',
+                  error: mergeErr instanceof Error ? mergeErr : new Error(String(mergeErr)),
+                },
+              });
+            }
+            continue;
+          }
+        }
+        // New CI failures or config disabled — skip
+        results.push({ claimed, outcome: { type: 'ci_blocked' } });
+        continue;
+      }
+
       // Attempt merge
       try {
         execSync(`gh pr merge ${pr.github_pr_number} --auto --squash --delete-branch${repoFlag}`, {
@@ -337,6 +452,70 @@ export async function autoMergeApprovedPRs(
           break;
         }
 
+        case 'ci_blocked': {
+          await withTransaction(
+            phaseDb.db,
+            () => {
+              updatePullRequest(phaseDb.db, pr.id, { status: 'approved' });
+              createLog(phaseDb.db, {
+                agentId: 'manager',
+                storyId: pr.story_id || undefined,
+                eventType: 'PR_MERGE_SKIPPED',
+                status: 'warn',
+                message: `Skipped auto-merge of PR #${pr.github_pr_number}: CI checks are failing (not pre-existing on base branch)`,
+                metadata: { pr_id: pr.id },
+              });
+            },
+            () => phaseDb.save()
+          );
+          break;
+        }
+
+        case 'ci_bypassed': {
+          const storyId = pr.story_id;
+          const bypassedChecks = result.outcome.bypassedChecks;
+          await withTransaction(
+            phaseDb.db,
+            () => {
+              updatePullRequest(phaseDb.db, pr.id, { status: 'merged' });
+              if (storyId) {
+                updateStory(phaseDb.db, storyId, { status: 'merged' });
+                const story = getStoryById(phaseDb.db, storyId);
+                if (story?.assigned_agent_id) {
+                  const agent = getAgentById(phaseDb.db, story.assigned_agent_id);
+                  if (agent && agent.current_story_id === storyId) {
+                    updateAgent(phaseDb.db, agent.id, { currentStoryId: null, status: 'idle' });
+                  }
+                }
+                createLog(phaseDb.db, {
+                  agentId: 'manager',
+                  storyId,
+                  eventType: 'STORY_MERGED',
+                  message: `Story auto-merged from GitHub PR #${pr.github_pr_number} (bypassed pre-existing CI failures: ${bypassedChecks.join(', ')})`,
+                });
+              } else {
+                createLog(phaseDb.db, {
+                  agentId: 'manager',
+                  eventType: 'PR_MERGED',
+                  message: `PR ${pr.id} auto-merged (GitHub PR #${pr.github_pr_number}, bypassed pre-existing CI failures: ${bypassedChecks.join(', ')})`,
+                  metadata: { pr_id: pr.id },
+                });
+              }
+            },
+            () => phaseDb.save()
+          );
+
+          mergedCount++;
+
+          if (storyId) {
+            postLifecycleComment(phaseDb.db, paths.hiveDir, config, storyId, 'merged').catch(() => {
+              /* non-fatal */
+            });
+            syncStatusForStory(root, phaseDb.db, storyId, 'merged');
+          }
+          break;
+        }
+
         case 'merged': {
           const storyId = pr.story_id;
           await withTransaction(