agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/test/pr-monitor.spec.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it, vi } from 'vitest';
 import {
   PrMonitorService,
-  createGhRunner
+  createGhRunner,
 } from '../src/application/services/pr-monitor-service.js';
 import type { GhRunner, PrInfo } from '../src/application/services/pr-monitor-service.js';
 import { TOOLS } from '../src/core/constants.js';
@@ -17,7 +17,7 @@ function makeToolCaller(frontMatter: Record<string, unknown> = { version: 1, sta
         return { ok: true, data: { front_matter: { version: 1, ...frontMatter } } };
       }
       return { ok: true, data: {} };
-    })
+    }),
   };
 }
 
@@ -27,7 +27,7 @@ const PR_JSON = JSON.stringify({
   statusCheckRollup: [{ state: 'SUCCESS' }, { state: 'SUCCESS' }],
   reviewDecision: 'APPROVED',
   mergeable: 'MERGEABLE',
-  reviewThreads: []
+  reviewThreads: [],
 });
 
 const FAILING_CI_JSON = JSON.stringify({
@@ -36,7 +36,7 @@ const FAILING_CI_JSON = JSON.stringify({
   statusCheckRollup: [{ state: 'SUCCESS' }, { state: 'FAILURE' }],
   reviewDecision: null,
   mergeable: 'MERGEABLE',
-  reviewThreads: []
+  reviewThreads: [],
 });
 
 const APPROVED_PR: PrInfo = {
@@ -47,14 +47,14 @@ const APPROVED_PR: PrInfo = {
   merge_ready: true,
   pending_review_threads: 0,
   has_conflicts: false,
-  merge_score: 0
+  merge_score: 0,
 };
 
 describe('PrMonitorService', () => {
   it('GIVEN gh not available WHEN detectPr called THEN returns null gracefully', async () => {
     const service = new PrMonitorService({
       toolCaller: makeToolCaller() as never,
-      ghRunner: makeGhRunner('', 127)
+      ghRunner: makeGhRunner('', 127),
     });
 
     const result = await service.detectPr('my-feature', 'feature/my-feature');
@@ -63,27 +63,25 @@ describe('PrMonitorService', () => {
   });
 
   it('GIVEN_primary_branch_lookup_misses_WHEN_detectPr_called_THEN_falls_back_to_feature_id_branch', async () => {
-    const ghRunner = vi.fn()
+    const ghRunner = vi
+      .fn()
       .mockResolvedValueOnce({ stdout: '', exitCode: 1 })
       .mockResolvedValueOnce({ stdout: PR_JSON, exitCode: 0 });
     const service = new PrMonitorService({
       toolCaller: makeToolCaller() as never,
-      ghRunner
+      ghRunner,
     });
 
     const result = await service.detectPr('my-feature', 'mismatched-branch');
 
     expect(result?.number).toBe(42);
-    expect(ghRunner).toHaveBeenNthCalledWith(
-      2,
-      expect.arrayContaining(['--head', 'my-feature'])
-    );
+    expect(ghRunner).toHaveBeenNthCalledWith(2, expect.arrayContaining(['--head', 'my-feature']));
   });
 
   it('GIVEN PR found with all CI passing WHEN detectPr called THEN ci_status=passing', async () => {
     const service = new PrMonitorService({
       toolCaller: makeToolCaller() as never,
-      ghRunner: makeGhRunner(PR_JSON)
+      ghRunner: makeGhRunner(PR_JSON),
     });
 
     const result = await service.detectPr('my-feature', 'feature/my-feature');
@@ -96,7 +94,7 @@ describe('PrMonitorService', () => {
   it('GIVEN PR found with failed CI WHEN detectPr called THEN ci_status=failing', async () => {
     const service = new PrMonitorService({
       toolCaller: makeToolCaller() as never,
-      ghRunner: makeGhRunner(FAILING_CI_JSON)
+      ghRunner: makeGhRunner(FAILING_CI_JSON),
     });
 
     const result = await service.detectPr('my-feature', 'feature/my-feature');
@@ -108,7 +106,7 @@ describe('PrMonitorService', () => {
   it('GIVEN PR approved WHEN computeMergeScore called THEN score >= 80', () => {
     const service = new PrMonitorService({
       toolCaller: makeToolCaller() as never,
-      ghRunner: makeGhRunner('')
+      ghRunner: makeGhRunner(''),
     });
 
     const score = service.computeMergeScore(APPROVED_PR);
@@ -118,7 +116,7 @@ describe('PrMonitorService', () => {
 
   it('GIVEN PR has changes_requested WHEN handleChangesRequested called THEN feature log updated', async () => {
     const reviewJson = JSON.stringify({
-      reviews: [{ body: 'Please fix the tests', state: 'CHANGES_REQUESTED' }]
+      reviews: [{ body: 'Please fix the tests', state: 'CHANGES_REQUESTED' }],
     });
     const ghRunner = vi.fn().mockResolvedValue({ stdout: reviewJson, exitCode: 0 });
     const toolCaller = makeToolCaller();
@@ -126,8 +124,12 @@ describe('PrMonitorService', () => {
       toolCaller: toolCaller as never,
       ghRunner,
       reactionsPolicy: {
-        changes_requested: { enabled: true, action: 'send_review_context_to_agent', escalate_after: 2 }
-      }
+        changes_requested: {
+          enabled: true,
+          action: 'send_review_context_to_agent',
+          escalate_after: 2,
+        },
+      },
     });
 
     const prInfo: PrInfo = {
@@ -138,7 +140,7 @@ describe('PrMonitorService', () => {
       merge_ready: false,
       pending_review_threads: 0,
       has_conflicts: false,
-      merge_score: 40
+      merge_score: 40,
     };
 
     await service.handleChangesRequested('my-feature', prInfo);
@@ -146,7 +148,7 @@ describe('PrMonitorService', () => {
     expect(toolCaller.callTool).toHaveBeenCalledWith(
       'orchestrator',
       TOOLS.FEATURE_LOG_APPEND,
-      expect.objectContaining({ feature_id: 'my-feature' })
+      expect.objectContaining({ feature_id: 'my-feature' }),
     );
   });
 
@@ -156,8 +158,12 @@ describe('PrMonitorService', () => {
       toolCaller: toolCaller as never,
       ghRunner: makeGhRunner(''),
       reactionsPolicy: {
-        changes_requested: { enabled: false, action: 'send_review_context_to_agent', escalate_after: 2 }
-      }
+        changes_requested: {
+          enabled: false,
+          action: 'send_review_context_to_agent',
+          escalate_after: 2,
+        },
+      },
     });
 
     const prInfo: PrInfo = {
@@ -168,7 +174,7 @@ describe('PrMonitorService', () => {
       merge_ready: false,
       pending_review_threads: 0,
       has_conflicts: false,
-      merge_score: 40
+      merge_score: 40,
     };
 
     await service.handleChangesRequested('my-feature', prInfo);
@@ -176,14 +182,14 @@ describe('PrMonitorService', () => {
     expect(toolCaller.callTool).not.toHaveBeenCalledWith(
       'orchestrator',
       TOOLS.FEATURE_LOG_APPEND,
-      expect.anything()
+      expect.anything(),
     );
   });
 
   it('GIVEN PR with conflicts WHEN computeMergeScore called THEN score penalized', () => {
     const service = new PrMonitorService({
       toolCaller: makeToolCaller() as never,
-      ghRunner: makeGhRunner('')
+      ghRunner: makeGhRunner(''),
     });
 
     const prWithConflict: PrInfo = { ...APPROVED_PR, has_conflicts: true, merge_ready: false };
@@ -199,7 +205,7 @@ describe('PrMonitorService', () => {
     const toolCaller = makeToolCaller();
     const service = new PrMonitorService({
       toolCaller: toolCaller as never,
-      ghRunner: makeGhRunner(PR_JSON)
+      ghRunner: makeGhRunner(PR_JSON),
     });
 
     const result = await service.checkAndUpdate('my-feature', 'feature/my-feature');
@@ -215,11 +221,11 @@ describe('PrMonitorService', () => {
           front_matter: expect.objectContaining({
             pr: expect.objectContaining({
               number: 42,
-              url: 'https://github.com/org/repo/pull/42'
-            })
-          })
-        })
-      })
+              url: 'https://github.com/org/repo/pull/42',
+            }),
+          }),
+        }),
+      }),
     );
   });
 
@@ -238,7 +244,7 @@ describe('PrMonitorService', () => {
     const toolCaller = makeToolCaller();
     const service = new PrMonitorService({
       toolCaller: toolCaller as never,
-      ghRunner: makeGhRunner('', 1)
+      ghRunner: makeGhRunner('', 1),
     });
 
     const result = await service.checkAndUpdate('no-pr-feature', 'feature/no-pr-feature');
@@ -254,28 +260,38 @@ describe('PrMonitorService', () => {
       statusCheckRollup: [{ state: 'SUCCESS' }],
       reviewDecision: 'CHANGES_REQUESTED',
       mergeable: 'MERGEABLE',
-      reviewThreads: []
+      reviewThreads: [],
     });
-    const reviewJson = JSON.stringify({ reviews: [{ body: 'Fix typo', state: 'CHANGES_REQUESTED' }] });
-    const ghRunner = vi.fn()
-      .mockResolvedValueOnce({ stdout: CHANGES_REQUESTED_JSON, exitCode: 0 })  // detectPr
-      .mockResolvedValueOnce({ stdout: reviewJson, exitCode: 0 });               // handleChangesRequested
+    const reviewJson = JSON.stringify({
+      reviews: [{ body: 'Fix typo', state: 'CHANGES_REQUESTED' }],
+    });
+    const ghRunner = vi
+      .fn()
+      .mockResolvedValueOnce({ stdout: CHANGES_REQUESTED_JSON, exitCode: 0 }) // detectPr
+      .mockResolvedValueOnce({ stdout: reviewJson, exitCode: 0 }); // handleChangesRequested
     const toolCaller = makeToolCaller();
     const notifier = { notify: vi.fn(async () => {}) };
     const service = new PrMonitorService({
       toolCaller: toolCaller as never,
       ghRunner,
       reactionsPolicy: {
-        changes_requested: { enabled: true, action: 'send_review_context_to_agent', escalate_after: 2 }
+        changes_requested: {
+          enabled: true,
+          action: 'send_review_context_to_agent',
+          escalate_after: 2,
+        },
       },
-      notifier: notifier as never
+      notifier: notifier as never,
     });
 
     const result = await service.checkAndUpdate('my-feature', 'feature/my-feature');
 
     expect(result).not.toBeNull();
     expect(result?.review_decision).toBe('changes_requested');
-    expect(notifier.notify).toHaveBeenCalledWith('changes_requested', expect.objectContaining({ feature_id: 'my-feature' }));
+    expect(notifier.notify).toHaveBeenCalledWith(
+      'changes_requested',
+      expect.objectContaining({ feature_id: 'my-feature' }),
+    );
   });
 
   it('GIVEN_invalid_JSON_in_reviews_response_WHEN_handleChangesRequested_called_THEN_logs_empty_review_body', async () => {
@@ -285,8 +301,12 @@ describe('PrMonitorService', () => {
       toolCaller: toolCaller as never,
       ghRunner,
       reactionsPolicy: {
-        changes_requested: { enabled: true, action: 'send_review_context_to_agent', escalate_after: 2 }
-      }
+        changes_requested: {
+          enabled: true,
+          action: 'send_review_context_to_agent',
+          escalate_after: 2,
+        },
+      },
     });
 
     const prInfo: PrInfo = {
@@ -297,14 +317,14 @@ describe('PrMonitorService', () => {
       merge_ready: false,
       pending_review_threads: 0,
       has_conflicts: false,
-      merge_score: 40
+      merge_score: 40,
     };
 
     await expect(service.handleChangesRequested('my-feature', prInfo)).resolves.toBeUndefined();
     expect(toolCaller.callTool).toHaveBeenCalledWith(
       'orchestrator',
       TOOLS.FEATURE_LOG_APPEND,
-      expect.objectContaining({ note: expect.stringContaining('PR #42 changes requested') })
+      expect.objectContaining({ note: expect.stringContaining('PR #42 changes requested') }),
     );
   });
 });
@@ -313,7 +333,16 @@ describe('PrMonitorService branch coverage', () => {
   it('GIVEN_detectPr_returns_parsed_number_zero_WHEN_called_THEN_returns_null', async () => {
     const service = new PrMonitorService({
       toolCaller: makeToolCaller() as never,
-      ghRunner: makeGhRunner(JSON.stringify({ number: 0, url: '', statusCheckRollup: null, reviewDecision: null, mergeable: 'UNKNOWN', reviewThreads: null }))
+      ghRunner: makeGhRunner(
+        JSON.stringify({
+          number: 0,
+          url: '',
+          statusCheckRollup: null,
+          reviewDecision: null,
+          mergeable: 'UNKNOWN',
+          reviewThreads: null,
+        }),
+      ),
     });
     const result = await service.detectPr('f1', 'branch');
     expect(result).toBeNull();
@@ -322,7 +351,7 @@ describe('PrMonitorService branch coverage', () => {
   it('GIVEN_invalid_JSON_WHEN_detectPr_called_THEN_returns_null', async () => {
     const service = new PrMonitorService({
       toolCaller: makeToolCaller() as never,
-      ghRunner: makeGhRunner('not-json')
+      ghRunner: makeGhRunner('not-json'),
     });
     const result = await service.detectPr('f1', 'branch');
     expect(result).toBeNull();
@@ -331,13 +360,16 @@ describe('PrMonitorService branch coverage', () => {
   it('GIVEN_REVIEW_REQUIRED_review_decision_WHEN_detectPr_called_THEN_review_decision_is_pending', async () => {
     const service = new PrMonitorService({
       toolCaller: makeToolCaller() as never,
-      ghRunner: makeGhRunner(JSON.stringify({
-        number: 5, url: 'https://example.com/pr/5',
-        statusCheckRollup: [{ state: 'PENDING' }],
-        reviewDecision: 'REVIEW_REQUIRED',
-        mergeable: 'MERGEABLE',
-        reviewThreads: [{ isResolved: false }, { isResolved: true }]
-      }))
+      ghRunner: makeGhRunner(
+        JSON.stringify({
+          number: 5,
+          url: 'https://example.com/pr/5',
+          statusCheckRollup: [{ state: 'PENDING' }],
+          reviewDecision: 'REVIEW_REQUIRED',
+          mergeable: 'MERGEABLE',
+          reviewThreads: [{ isResolved: false }, { isResolved: true }],
+        }),
+      ),
     });
     const result = await service.detectPr('f1', 'branch');
     expect(result?.review_decision).toBe('pending');
@@ -348,13 +380,16 @@ describe('PrMonitorService branch coverage', () => {
   it('GIVEN_unknown_review_decision_WHEN_detectPr_called_THEN_review_decision_is_none', async () => {
     const service = new PrMonitorService({
       toolCaller: makeToolCaller() as never,
-      ghRunner: makeGhRunner(JSON.stringify({
-        number: 6, url: 'https://example.com/pr/6',
-        statusCheckRollup: null,
-        reviewDecision: 'UNKNOWN_DECISION',
-        mergeable: 'CONFLICTING',
-        reviewThreads: null
-      }))
+      ghRunner: makeGhRunner(
+        JSON.stringify({
+          number: 6,
+          url: 'https://example.com/pr/6',
+          statusCheckRollup: null,
+          reviewDecision: 'UNKNOWN_DECISION',
+          mergeable: 'CONFLICTING',
+          reviewThreads: null,
+        }),
+      ),
     });
     const result = await service.detectPr('f1', 'branch');
     expect(result?.review_decision).toBe('none');
@@ -366,7 +401,9 @@ describe('PrMonitorService branch coverage', () => {
     const toolCaller = makeToolCaller();
     const service = new PrMonitorService({
       toolCaller: toolCaller as never,
-      reactionsPolicy: { changes_requested: { enabled: true, action: 'other_action', escalate_after: 0 } }
+      reactionsPolicy: {
+        changes_requested: { enabled: true, action: 'other_action', escalate_after: 0 },
+      },
     });
     await service.handleChangesRequested('f1', APPROVED_PR);
     expect(toolCaller.callTool).not.toHaveBeenCalled();
@@ -376,10 +413,22 @@ describe('PrMonitorService branch coverage', () => {
     const toolCaller = makeToolCaller();
     const service = new PrMonitorService({
       toolCaller: toolCaller as never,
-      reactionsPolicy: { changes_requested: { enabled: true, action: 'send_review_context_to_agent', escalate_after: 0 } },
-      ghRunner: makeGhRunner(JSON.stringify({ reviews: [{ body: 'review content', state: 'CHANGES_REQUESTED' }] }))
+      reactionsPolicy: {
+        changes_requested: {
+          enabled: true,
+          action: 'send_review_context_to_agent',
+          escalate_after: 0,
+        },
+      },
+      ghRunner: makeGhRunner(
+        JSON.stringify({ reviews: [{ body: 'review content', state: 'CHANGES_REQUESTED' }] }),
+      ),
     });
     await service.handleChangesRequested('f1', { ...APPROVED_PR, number: 10 });
-    expect(toolCaller.callTool).toHaveBeenCalledWith('orchestrator', TOOLS.FEATURE_LOG_APPEND, expect.anything());
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_LOG_APPEND,
+      expect.anything(),
+    );
   });
 });