agentic-orchestrator 0.1.2 → 0.1.4

package/apps/control-plane/test/reactions.spec.ts

@@ -0,0 +1,392 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ReactionsService } from '../src/application/services/reactions-service.js';
+import type { GateRepairContext, ReactionsPolicy } from '../src/application/services/reactions-service.js';
+import { TOOLS } from '../src/core/constants.js';
+
+function makeToolCaller(statePatchFn?: () => Promise<Record<string, unknown>>) {
+  return {
+    callTool: vi.fn(async (_role: string, toolName: string, _args?: Record<string, unknown>) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 1, status: 'qa', gate_retry_count: 0 } } };
+      }
+      if (toolName === TOOLS.FEATURE_STATE_PATCH) {
+        if (statePatchFn) {
+          await statePatchFn();
+        }
+        return { ok: true, data: { updated: true } };
+      }
+      return { ok: true, data: {} };
+    })
+  };
+}
+
+function makeNotifier() {
+  return {
+    notify: vi.fn(async () => undefined)
+  };
+}
+
+function makeEnabledPolicy(overrides: Partial<ReactionsPolicy['gate_failed']> = {}): ReactionsPolicy {
+  return {
+    gate_failed: {
+      enabled: true,
+      max_retries: 2,
+      action: 'retry_with_agent_repair',
+      escalate_after: 2,
+      retry_delay_ms: 30000,
+      ...overrides
+    }
+  };
+}
+
+describe('ReactionsService', () => {
+  it('GIVEN gate_failed reaction enabled WHEN gate fails THEN retry prompt injected', () => {
+    const toolCaller = makeToolCaller();
+    const service = new ReactionsService({
+      toolCaller: toolCaller as never,
+      policy: makeEnabledPolicy()
+    });
+
+    const ctx: GateRepairContext = {
+      featureId: 'feature_a',
+      gateName: 'full',
+      exitCode: 1,
+      logs: 'Test run failed',
+      evidenceSummary: '.aop/features/feature_a/evidence/full.json',
+      retryCount: 0
+    };
+
+    const shouldRetry = service.shouldRetry('feature_a', 0);
+    const prompt = service.buildRepairPrompt(ctx);
+
+    expect(shouldRetry).toBe(true);
+    expect(prompt).toContain('Gate execution failed');
+    expect(prompt).toContain('Gate: full');
+    expect(prompt).toContain('Test run failed');
+  });
+
+  it('GIVEN max_retries exceeded WHEN gate fails THEN escalation notification sent', async () => {
+    const toolCaller = makeToolCaller();
+    const notifier = makeNotifier();
+    const service = new ReactionsService({
+      toolCaller: toolCaller as never,
+      notifier: notifier as never,
+      policy: makeEnabledPolicy({ max_retries: 2, escalate_after: 2 })
+    });
+
+    const ctx: GateRepairContext = {
+      featureId: 'feature_b',
+      gateName: 'full',
+      exitCode: 1,
+      logs: 'error',
+      evidenceSummary: '',
+      retryCount: 2
+    };
+
+    const shouldEscalate = service.shouldEscalate(2);
+    await service.notifyEscalation('feature_b', ctx);
+
+    expect(shouldEscalate).toBe(true);
+    expect(notifier.notify).toHaveBeenCalledWith(
+      'gate_failed',
+      expect.objectContaining({ feature_id: 'feature_b' })
+    );
+  });
+
+  it('GIVEN gate_failed reaction disabled WHEN gate fails THEN no retry attempted', () => {
+    const toolCaller = makeToolCaller();
+    const service = new ReactionsService({
+      toolCaller: toolCaller as never,
+      policy: {
+        gate_failed: {
+          enabled: false,
+          max_retries: 2,
+          action: 'retry_with_agent_repair',
+          escalate_after: 2,
+          retry_delay_ms: 30000
+        }
+      }
+    });
+
+    const shouldRetry = service.shouldRetry('feature_c', 0);
+    expect(shouldRetry).toBe(false);
+  });
+
+  it('GIVEN retry succeeds WHEN second gate run passes THEN retry count recorded', async () => {
+    let patchCallCount = 0;
+    const toolCaller = makeToolCaller(() => {
+      patchCallCount++;
+      return Promise.resolve({});
+    });
+    const service = new ReactionsService({
+      toolCaller: toolCaller as never,
+      policy: makeEnabledPolicy()
+    });
+
+    await service.recordRetry('feature_d', 1);
+
+    expect(patchCallCount).toBe(1);
+    const patchCall = toolCaller.callTool.mock.calls.find(([, tool]) => tool === TOOLS.FEATURE_STATE_PATCH);
+    expect(patchCall).toBeDefined();
+    const patchArgs = patchCall?.[2] ?? {};
+    const patch = (patchArgs['patch'] ?? {}) as Record<string, unknown>;
+    const frontMatter = (patch['front_matter'] ?? {}) as Record<string, unknown>;
+    expect(frontMatter.gate_retry_count).toBe(1);
+  });
+
+  it('GIVEN force flag WHEN aop retry called THEN gate_retry_count reset to 0', async () => {
+    const toolCaller = makeToolCaller();
+    const service = new ReactionsService({
+      toolCaller: toolCaller as never,
+      policy: makeEnabledPolicy()
+    });
+
+    // Simulate force reset by calling recordRetry with 0
+    await service.recordRetry('feature_e', 0);
+
+    const patchCall = toolCaller.callTool.mock.calls.find(([, tool]) => tool === TOOLS.FEATURE_STATE_PATCH);
+    expect(patchCall).toBeDefined();
+    const patchArgs = patchCall?.[2] ?? {};
+    const patch = (patchArgs['patch'] ?? {}) as Record<string, unknown>;
+    const frontMatter = (patch['front_matter'] ?? {}) as Record<string, unknown>;
+    expect(frontMatter.gate_retry_count).toBe(0);
+  });
+
+  it('GIVEN escalate_after=2 WHEN 3rd failure THEN notification sent to critical channels', async () => {
+    const toolCaller = makeToolCaller();
+    const notifier = makeNotifier();
+    const service = new ReactionsService({
+      toolCaller: toolCaller as never,
+      notifier: notifier as never,
+      policy: makeEnabledPolicy({ escalate_after: 2 })
+    });
+
+    const shouldEscalateAt2 = service.shouldEscalate(2);
+    const shouldEscalateAt3 = service.shouldEscalate(3);
+    const shouldNotEscalateAt1 = service.shouldEscalate(1);
+
+    expect(shouldEscalateAt2).toBe(true);
+    expect(shouldEscalateAt3).toBe(true);
+    expect(shouldNotEscalateAt1).toBe(false);
+
+    const ctx: GateRepairContext = {
+      featureId: 'feature_f',
+      gateName: 'full',
+      exitCode: 1,
+      logs: 'failed',
+      evidenceSummary: 'no evidence',
+      retryCount: 2
+    };
+    await service.notifyEscalation('feature_f', ctx);
+    expect(notifier.notify).toHaveBeenCalledOnce();
+  });
+
+  it('GIVEN reactions service WHEN buildRepairPrompt called THEN prompt contains gate name/logs/evidence', () => {
+    const toolCaller = makeToolCaller();
+    const service = new ReactionsService({
+      toolCaller: toolCaller as never,
+      policy: makeEnabledPolicy()
+    });
+
+    const ctx: GateRepairContext = {
+      featureId: 'feature_g',
+      gateName: 'fast',
+      exitCode: 2,
+      logs: 'compilation error on line 42',
+      evidenceSummary: 'build-fast.json summary',
+      retryCount: 1
+    };
+
+    const prompt = service.buildRepairPrompt(ctx);
+
+    expect(prompt).toContain('Gate: fast');
+    expect(prompt).toContain('Exit Code: 2');
+    expect(prompt).toContain('compilation error on line 42');
+    expect(prompt).toContain('build-fast.json summary');
+    expect(prompt).toContain('Retry: 2 of 2');
+  });
+
+  it('GIVEN policy undefined WHEN reactions service created THEN defaults applied (disabled)', () => {
+    const toolCaller = makeToolCaller();
+    const service = new ReactionsService({
+      toolCaller: toolCaller as never
+    });
+
+    const shouldRetry = service.shouldRetry('feature_h', 0);
+    const shouldEscalate = service.shouldEscalate(0);
+
+    expect(shouldRetry).toBe(false);
+    // Default escalate_after is 2, so at count 0 should NOT escalate
+    expect(shouldEscalate).toBe(false);
+  });
+
+  it('GIVEN notify_only action WHEN shouldRetry called THEN returns false', () => {
+    const toolCaller = makeToolCaller();
+    const service = new ReactionsService({
+      toolCaller: toolCaller as never,
+      policy: {
+        gate_failed: {
+          enabled: true,
+          max_retries: 3,
+          action: 'notify_only',
+          escalate_after: 2,
+          retry_delay_ms: 5000
+        }
+      }
+    });
+
+    const shouldRetry = service.shouldRetry('feature_i', 0);
+    expect(shouldRetry).toBe(false);
+  });
+
+  it('GIVEN_no_notifier_WHEN_notifyEscalation_called_THEN_returns_without_error', async () => {
+    const toolCaller = makeToolCaller();
+    const service = new ReactionsService({
+      toolCaller: toolCaller as never,
+      policy: makeEnabledPolicy()
+      // no notifier provided
+    });
+
+    const ctx: GateRepairContext = {
+      featureId: 'feature_z',
+      gateName: 'full',
+      exitCode: 1,
+      logs: 'error log',
+      evidenceSummary: 'no evidence',
+      retryCount: 3
+    };
+
+    // notifier is undefined → early return, no notification sent
+    await expect(service.notifyEscalation('feature_z', ctx)).resolves.toBeUndefined();
+  });
+});
+
+describe('ReactionsService branch coverage', () => {
+  it('GIVEN_policy_with_retry_delay_ms_WHEN_retryDelayMs_called_THEN_returns_configured_value', () => {
+    const service = new ReactionsService({
+      toolCaller: makeToolCaller(),
+      policy: makeEnabledPolicy({ retry_delay_ms: 5000 })
+    });
+    expect(service.retryDelayMs()).toBe(5000);
+  });
+
+  it('GIVEN_policy_with_invalid_retry_delay_ms_WHEN_retryDelayMs_called_THEN_returns_default', () => {
+    const service = new ReactionsService({
+      toolCaller: makeToolCaller(),
+      policy: makeEnabledPolicy({ retry_delay_ms: -1 })
+    });
+    // Negative → falls through to default (30000)
+    expect(service.retryDelayMs()).toBe(30000);
+  });
+
+  it('GIVEN_policy_with_max_retries_WHEN_maxRetries_called_THEN_returns_configured_value', () => {
+    const service = new ReactionsService({
+      toolCaller: makeToolCaller(),
+      policy: makeEnabledPolicy({ max_retries: 5 })
+    });
+    expect(service.maxRetries()).toBe(5);
+  });
+
+  it('GIVEN_no_policy_WHEN_maxRetries_called_THEN_returns_default', () => {
+    const service = new ReactionsService({
+      toolCaller: makeToolCaller(),
+      policy: {}
+    });
+    expect(service.maxRetries()).toBeGreaterThanOrEqual(0);
+  });
+
+  it('GIVEN_delay_ms_zero_WHEN_waitBeforeRetry_called_THEN_resolves_immediately', async () => {
+    const service = new ReactionsService({
+      toolCaller: makeToolCaller(),
+      policy: makeEnabledPolicy({ retry_delay_ms: 0 })
+    });
+    await expect(service.waitBeforeRetry()).resolves.toBeUndefined();
+  });
+
+  it('GIVEN_delay_ms_positive_WHEN_waitBeforeRetry_called_THEN_waits_then_resolves', async () => {
+    vi.useFakeTimers();
+    const service = new ReactionsService({
+      toolCaller: makeToolCaller(),
+      policy: makeEnabledPolicy({ retry_delay_ms: 1000 })
+    });
+    const waitPromise = service.waitBeforeRetry();
+    vi.advanceTimersByTime(1001);
+    await waitPromise;
+    vi.useRealTimers();
+  });
+
+  it('GIVEN_buildRepairPrompt_with_empty_failure_history_WHEN_called_THEN_shows_none', () => {
+    const service = new ReactionsService({
+      toolCaller: makeToolCaller(),
+      policy: makeEnabledPolicy()
+    });
+    const ctx: GateRepairContext = {
+      gateName: 'unit-tests',
+      exitCode: 1,
+      logs: 'test output',
+      evidenceSummary: 'summary',
+      retryCount: 0
+    };
+    const prompt = service.buildRepairPrompt(ctx);
+    expect(prompt).toContain('(none)');
+  });
+});
+
+describe('ReactionsService additional coverage', () => {
+  it('GIVEN_policy_with_valid_max_retries_number_WHEN_maxRetries_called_THEN_returns_floor_of_value', () => {
+    const service = new ReactionsService({
+      toolCaller: makeToolCaller(),
+      policy: { gate_failed: { enabled: true, action: 'retry_with_agent_repair', max_retries: 3.7, retry_delay_ms: 0 } }
+    });
+    expect(service.maxRetries()).toBe(3);
+  });
+
+  it('GIVEN_non_finite_max_retries_WHEN_maxRetries_called_THEN_returns_default', () => {
+    const service = new ReactionsService({
+      toolCaller: makeToolCaller(),
+      policy: { gate_failed: { enabled: true, action: 'retry_with_agent_repair', max_retries: Infinity, retry_delay_ms: 0 } }
+    });
+    expect(service.maxRetries()).toBeGreaterThanOrEqual(0);
+  });
+
+  it('GIVEN_failure_history_with_items_WHEN_buildRepairPrompt_called_THEN_shows_history', () => {
+    const service = new ReactionsService({
+      toolCaller: makeToolCaller(),
+      policy: makeEnabledPolicy()
+    });
+    const ctx: GateRepairContext = {
+      featureId: 'feat_hist',
+      gateName: 'fast',
+      exitCode: 1,
+      logs: 'some logs',
+      evidenceSummary: 'summary',
+      retryCount: 1,
+      failureHistory: [
+        { attempt: 1, gate_name: 'fast', exit_code: 1, evidence_summary: 'ev1', logs_excerpt: 'log1', failed_at: new Date().toISOString(), retry_delay_ms: 1000 }
+      ]
+    };
+    const prompt = service.buildRepairPrompt(ctx);
+    expect(prompt).toContain('attempt=1');
+    expect(prompt).toContain('gate=fast');
+  });
+
+  it('GIVEN_evidence_summary_empty_in_history_WHEN_buildRepairPrompt_called_THEN_shows_n_a', () => {
+    const service = new ReactionsService({
+      toolCaller: makeToolCaller(),
+      policy: makeEnabledPolicy()
+    });
+    const ctx: GateRepairContext = {
+      featureId: 'feat_hist2',
+      gateName: 'fast',
+      exitCode: 1,
+      logs: '',
+      evidenceSummary: '',
+      retryCount: 1,
+      failureHistory: [
+        { attempt: 1, gate_name: 'fast', exit_code: 1, evidence_summary: '', logs_excerpt: '', failed_at: new Date().toISOString() }
+      ]
+    };
+    const prompt = service.buildRepairPrompt(ctx);
+    expect(prompt).toContain('n/a');
+  });
+});