agentic-orchestrator 0.1.28 → 0.2.0

package/apps/control-plane/test/merge-command-handler.spec.ts

@@ -0,0 +1,531 @@
+import { describe, expect, it, vi } from 'vitest';
+import { MergeCommandHandler } from '../src/cli/merge-command-handler.js';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import { TOOLS } from '../src/core/constants.js';
+
+type ToolClientCall = ReturnType<typeof vi.fn>;
+
+function makeHandler(callImpl: ToolClientCall) {
+  const toolClient = { call: callImpl };
+  const handler = new MergeCommandHandler(toolClient as never, 'run:test');
+  return { handler, toolClient };
+}
+
+function makeDefaultCall(mergeGateAlreadyPassed = false) {
+  return vi.fn(async (_tool: string, args: Record<string, unknown>) => {
+    if (args['tool_name'] === TOOLS.FEATURE_STATE_GET || _tool === TOOLS.FEATURE_STATE_GET) {
+      return {
+        ok: true,
+        data: {
+          front_matter: {
+            version: 5,
+            gates: { merge: mergeGateAlreadyPassed ? 'pass' : 'na' },
+          },
+        },
+      };
+    }
+    if (_tool === TOOLS.REPO_RECONCILE_MAINLINE) {
+      return { ok: true, data: { status: 'up_to_date' } };
+    }
+    if (_tool === TOOLS.GATES_RUN) {
+      return { ok: true, data: { overall: 'pass' } };
+    }
+    // FEATURE_READY_TO_MERGE
+    return {
+      ok: true,
+      data: {
+        feature_id: 'feature_a',
+        merge_sha: 'abc123',
+        merge_strategy: 'merge_commit',
+        status: 'merged',
+      },
+    };
+  });
+}
+
+describe('MergeCommandHandler', () => {
+  it('GIVEN_merge_gate_not_passed_WHEN_execute_called_THEN_runs_gate_then_merges', async () => {
+    const call = makeDefaultCall(false);
+    const { handler, toolClient } = makeHandler(call);
+
+    const result = await handler.execute({ command: 'merge', feature_id: 'feature_a' });
+
+    const calls = toolClient.call.mock.calls as unknown[][];
+    const toolNames = calls.map((c) => c[0]);
+    expect(toolNames).toContain(TOOLS.FEATURE_STATE_GET);
+    expect(toolNames).toContain(TOOLS.REPO_RECONCILE_MAINLINE);
+    expect(toolNames).toContain(TOOLS.GATES_RUN);
+    expect(toolNames).toContain(TOOLS.FEATURE_READY_TO_MERGE);
+
+    expect(result).toMatchObject({
+      ok: true,
+      data: {
+        command: 'merge',
+        merge_gate_run: true,
+        merge_gate_overall: 'pass',
+        reconciliation_status: 'up_to_date',
+        feature_id: 'feature_a',
+        status: 'merged',
+      },
+    });
+  });
+
+  it('GIVEN_merge_gate_already_passed_WHEN_execute_called_THEN_skips_gate_and_merges', async () => {
+    const call = makeDefaultCall(true);
+    const { handler, toolClient } = makeHandler(call);
+
+    const result = await handler.execute({ command: 'merge', feature_id: 'feature_a' });
+
+    const calls = toolClient.call.mock.calls as unknown[][];
+    const toolNames = calls.map((c) => c[0]);
+    expect(toolNames).toContain(TOOLS.REPO_RECONCILE_MAINLINE);
+    expect(toolNames).not.toContain(TOOLS.GATES_RUN);
+    expect(toolNames).toContain(TOOLS.FEATURE_READY_TO_MERGE);
+
+    expect(result).toMatchObject({
+      ok: true,
+      data: {
+        command: 'merge',
+        merge_gate_run: false,
+        merge_gate_overall: 'pass',
+        reconciliation_status: 'up_to_date',
+      },
+    });
+  });
+
+  it('GIVEN_merge_gate_fails_after_reconciliation_WHEN_execute_called_THEN_returns_error_and_skips_git_merge', async () => {
+    const call = vi.fn(async (tool: string) => {
+      if (tool === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 3, gates: { merge: 'na' } } } };
+      }
+      if (tool === TOOLS.REPO_RECONCILE_MAINLINE) {
+        return { ok: true, data: { status: 'up_to_date' } };
+      }
+      if (tool === TOOLS.GATES_RUN) {
+        return { ok: true, data: { overall: 'fail' } };
+      }
+      return { ok: true, data: {} };
+    });
+    const { handler, toolClient } = makeHandler(call);
+
+    const result = await handler.execute({ command: 'merge', feature_id: 'feature_a' });
+
+    const calls = toolClient.call.mock.calls as unknown[][];
+    expect(calls.map((c) => c[0])).not.toContain(TOOLS.FEATURE_READY_TO_MERGE);
+    expect(result).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.MERGE_DISABLED,
+        details: expect.objectContaining({
+          gate_overall: 'fail',
+          reconciliation_status: 'up_to_date',
+          reconciliation_attempted: true,
+          recovery_available: true,
+        }),
+      },
+    });
+  });
+
+  it('GIVEN_merge_gate_failure_exhausts_repair_budget_WHEN_execute_called_THEN_reports_recovery_unavailable', async () => {
+    const call = vi.fn(async (tool: string) => {
+      if (tool === TOOLS.FEATURE_STATE_GET) {
+        return {
+          ok: true,
+          data: {
+            front_matter: {
+              version: 3,
+              status: 'failed',
+              gates: { merge: 'fail' },
+              merge_repair: { attempts: 5, max_attempts: 5 },
+            },
+          },
+        };
+      }
+      if (tool === TOOLS.REPO_RECONCILE_MAINLINE) {
+        return { ok: true, data: { status: 'up_to_date' } };
+      }
+      if (tool === TOOLS.GATES_RUN) {
+        return { ok: true, data: { overall: 'fail' } };
+      }
+      return { ok: true, data: {} };
+    });
+    const { handler } = makeHandler(call);
+
+    const result = await handler.execute({ command: 'merge', feature_id: 'feature_a' });
+
+    expect(result).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.MERGE_DISABLED,
+        details: expect.objectContaining({
+          recovery_available: false,
+          status_after_gate_failure: 'failed',
+          merge_repair_attempts: 5,
+          merge_repair_max_attempts: 5,
+        }),
+      },
+    });
+  });
+
+  it('GIVEN_reconciliation_merges_mainline_WHEN_merge_gate_previously_passed_THEN_reruns_gate_before_merge', async () => {
+    const call = vi.fn(async (tool: string) => {
+      if (tool === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 3, gates: { merge: 'pass' } } } };
+      }
+      if (tool === TOOLS.REPO_RECONCILE_MAINLINE) {
+        return { ok: true, data: { status: 'merged' } };
+      }
+      if (tool === TOOLS.GATES_RUN) {
+        return { ok: true, data: { overall: 'pass' } };
+      }
+      return {
+        ok: true,
+        data: {
+          feature_id: 'feature_a',
+          merge_sha: 'abc123',
+          merge_strategy: 'merge_commit',
+          status: 'merged',
+        },
+      };
+    });
+    const { handler, toolClient } = makeHandler(call);
+
+    const result = await handler.execute({ command: 'merge', feature_id: 'feature_a' });
+
+    const toolNames = (toolClient.call.mock.calls as unknown[][]).map((c) => c[0]);
+    expect(toolNames).toEqual([
+      TOOLS.FEATURE_STATE_GET,
+      TOOLS.REPO_RECONCILE_MAINLINE,
+      TOOLS.GATES_RUN,
+      TOOLS.FEATURE_READY_TO_MERGE,
+    ]);
+    expect(result).toMatchObject({
+      ok: true,
+      data: {
+        merge_gate_run: true,
+        merge_gate_overall: 'pass',
+        reconciliation_status: 'merged',
+      },
+    });
+  });
+
+  it('GIVEN_reconciliation_detects_conflict_WHEN_execute_called_THEN_returns_reconciliation_error_without_merge', async () => {
+    const call = vi.fn(async (tool: string) => {
+      if (tool === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 3, gates: { merge: 'na' } } } };
+      }
+      if (tool === TOOLS.REPO_RECONCILE_MAINLINE) {
+        return {
+          ok: true,
+          data: {
+            status: 'conflict_detected',
+            merge_base: 'base123',
+            mainline_head: 'main456',
+            worktree_head: 'work789',
+            conflicting_files: ['src/conflict.ts'],
+            reconciler_active_feature_id: 'feature_a',
+            reconciler_queue_position: 0,
+            dispatched_to_reconciler: true,
+            conflict_worktree_prepared: true,
+          },
+        };
+      }
+      return { ok: true, data: {} };
+    });
+    const { handler, toolClient } = makeHandler(call);
+
+    const result = await handler.execute({ command: 'merge', feature_id: 'feature_a' });
+
+    expect((toolClient.call.mock.calls as unknown[][]).map((c) => c[0])).toEqual([
+      TOOLS.FEATURE_STATE_GET,
+      TOOLS.REPO_RECONCILE_MAINLINE,
+    ]);
+    expect(result).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.RECONCILIATION_FAILED,
+        details: expect.objectContaining({
+          conflicting_files: ['src/conflict.ts'],
+          reconciler_active_feature_id: 'feature_a',
+          dispatched_to_reconciler: true,
+        }),
+      },
+    });
+  });
+
+  it('GIVEN_conflict_payload_omits_optional_fields_WHEN_execute_called_THEN_returns_defaulted_reconciliation_details', async () => {
+    const call = vi.fn(async (tool: string) => {
+      if (tool === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 3, gates: { merge: 'na' } } } };
+      }
+      if (tool === TOOLS.REPO_RECONCILE_MAINLINE) {
+        return {
+          ok: true,
+          data: {
+            status: 'conflict_detected',
+          },
+        };
+      }
+      return { ok: true, data: {} };
+    });
+    const { handler } = makeHandler(call);
+
+    const result = await handler.execute({ command: 'merge', feature_id: 'feature_defaults' });
+
+    expect(result).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.RECONCILIATION_FAILED,
+        details: {
+          feature_id: 'feature_defaults',
+          merge_base: null,
+          mainline_head: null,
+          worktree_head: null,
+          conflicting_files: [],
+          reconciler_active_feature_id: null,
+          reconciler_queue_position: null,
+          dispatched_to_reconciler: false,
+          conflict_worktree_prepared: false,
+          retryable: false,
+          requires_human: true,
+        },
+      },
+    });
+  });
+
+  it('GIVEN_explicit_strategy_and_message_WHEN_execute_called_THEN_passes_overrides_to_tool', async () => {
+    const call = makeDefaultCall(true);
+    const { handler, toolClient } = makeHandler(call);
+
+    await handler.execute({
+      command: 'merge',
+      feature_id: 'feature_b',
+      merge_strategy: 'squash',
+      commit_message: 'Custom commit message',
+      approval_token: 'approve_xyz',
+    });
+
+    const calls = toolClient.call.mock.calls as unknown[][];
+    const reconcileCall = calls.find((c) => c[0] === TOOLS.REPO_RECONCILE_MAINLINE);
+    const mergeCall = calls.find((c) => c[0] === TOOLS.FEATURE_READY_TO_MERGE);
+    expect(reconcileCall?.[1]).toMatchObject({
+      feature_id: 'feature_b',
+      commit_message: 'Custom commit message',
+    });
+    expect(mergeCall?.[1]).toMatchObject({
+      feature_id: 'feature_b',
+      commit_message: 'Custom commit message',
+      merge_strategy: 'squash',
+      user_approval_token: 'approve_xyz',
+    });
+  });
+
+  it('GIVEN_sync_remote_auto_WHEN_execute_called_THEN_passes_remote_sync_to_reconcile_and_merge_tools', async () => {
+    const call = makeDefaultCall(true);
+    const { handler, toolClient } = makeHandler(call);
+
+    await handler.execute({
+      command: 'merge',
+      feature_id: 'feature_sync',
+      sync_remote: 'auto',
+    });
+
+    const calls = toolClient.call.mock.calls as unknown[][];
+    const reconcileCall = calls.find((c) => c[0] === TOOLS.REPO_RECONCILE_MAINLINE);
+    const mergeCall = calls.find((c) => c[0] === TOOLS.FEATURE_READY_TO_MERGE);
+
+    expect(reconcileCall?.[1]).toMatchObject({
+      feature_id: 'feature_sync',
+      commit_message: 'Merge feature feature_sync',
+      auto_merge_non_conflicting: true,
+      remote_sync_strategy: 'auto',
+    });
+    expect(mergeCall?.[1]).toMatchObject({
+      feature_id: 'feature_sync',
+      remote_sync_strategy: 'auto',
+    });
+  });
+
+  it('GIVEN_sync_remote_not_provided_WHEN_execute_called_THEN_defaults_remote_sync_to_auto', async () => {
+    const call = makeDefaultCall(true);
+    const { handler, toolClient } = makeHandler(call);
+
+    await handler.execute({
+      command: 'merge',
+      feature_id: 'feature_default_sync',
+    });
+
+    const calls = toolClient.call.mock.calls as unknown[][];
+    const reconcileCall = calls.find((c) => c[0] === TOOLS.REPO_RECONCILE_MAINLINE);
+    const mergeCall = calls.find((c) => c[0] === TOOLS.FEATURE_READY_TO_MERGE);
+
+    expect(reconcileCall?.[1]).toMatchObject({
+      feature_id: 'feature_default_sync',
+      commit_message: 'Merge feature feature_default_sync',
+      remote_sync_strategy: 'auto',
+    });
+    expect(mergeCall?.[1]).toMatchObject({
+      feature_id: 'feature_default_sync',
+      remote_sync_strategy: 'auto',
+    });
+  });
+
+  it('GIVEN_sync_remote_is_empty_WHEN_execute_called_THEN_omits_remote_sync_fields_and_uses_default_merge_payload_values', async () => {
+    const call = vi.fn(async (tool: string) => {
+      if (tool === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 5, gates: { merge: 'pass' } } } };
+      }
+      if (tool === TOOLS.REPO_RECONCILE_MAINLINE) {
+        return { ok: true, data: {} };
+      }
+      if (tool === TOOLS.FEATURE_READY_TO_MERGE) {
+        return { ok: true, data: undefined };
+      }
+      return { ok: true, data: {} };
+    });
+    const { handler, toolClient } = makeHandler(call);
+
+    const result = await handler.execute({
+      command: 'merge',
+      feature_id: 'feature_empty_sync',
+      sync_remote: '',
+    });
+
+    const calls = toolClient.call.mock.calls as unknown[][];
+    const reconcileCall = calls.find((c) => c[0] === TOOLS.REPO_RECONCILE_MAINLINE);
+    const mergeCall = calls.find((c) => c[0] === TOOLS.FEATURE_READY_TO_MERGE);
+
+    expect(reconcileCall?.[1]).toEqual(
+      expect.objectContaining({
+        feature_id: 'feature_empty_sync',
+        commit_message: 'Merge feature feature_empty_sync',
+        auto_merge_non_conflicting: true,
+      }),
+    );
+    expect(reconcileCall?.[1]).not.toHaveProperty('remote_sync_strategy');
+    expect(mergeCall?.[1]).toEqual(
+      expect.objectContaining({
+        feature_id: 'feature_empty_sync',
+        commit_message: 'Merge feature feature_empty_sync',
+        merge_strategy: 'merge_commit',
+        user_approval_token: '',
+      }),
+    );
+    expect(mergeCall?.[1]).not.toHaveProperty('remote_sync_strategy');
+    expect(result).toMatchObject({
+      ok: true,
+      data: {
+        command: 'merge',
+        merge_gate_run: false,
+        merge_gate_overall: 'pass',
+        reconciliation_status: null,
+      },
+    });
+  });
+
+  it('GIVEN_missing_feature_id_WHEN_execute_called_THEN_throws_invalid_cli_args', async () => {
+    const { handler } = makeHandler(makeDefaultCall());
+
+    await expect(handler.execute({ command: 'merge' })).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+      details: expect.objectContaining({ reason: '--feature-id is required for merge' }),
+    });
+  });
+
+  it('GIVEN_invalid_feature_id_WHEN_execute_called_THEN_throws_invalid_cli_args', async () => {
+    const { handler } = makeHandler(makeDefaultCall());
+
+    await expect(
+      handler.execute({ command: 'merge', feature_id: 'Invalid-ID!' }),
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+      details: expect.objectContaining({ reason: 'Invalid --feature-id value' }),
+    });
+  });
+
+  it('GIVEN_invalid_strategy_WHEN_execute_called_THEN_throws_invalid_cli_args', async () => {
+    const { handler } = makeHandler(makeDefaultCall());
+
+    await expect(
+      handler.execute({ command: 'merge', feature_id: 'feature_a', merge_strategy: 'octopus' }),
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+      details: expect.objectContaining({ reason: 'Invalid --strategy value' }),
+    });
+  });
+
+  it('GIVEN_tool_failure_on_ready_to_merge_WHEN_execute_called_THEN_surfaces_normalized_error', async () => {
+    const call = vi.fn(async (tool: string) => {
+      if (tool === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 3, gates: { merge: 'pass' } } } };
+      }
+      return {
+        ok: false,
+        error: {
+          code: ERROR_CODES.INVALID_STATUS_TRANSITION,
+          message: 'Feature must be ready_to_merge before merge',
+          details: { current_status: 'building' },
+        },
+      };
+    });
+    const { handler } = makeHandler(call);
+
+    await expect(
+      handler.execute({ command: 'merge', feature_id: 'feature_a' }),
+    ).rejects.toMatchObject({ code: ERROR_CODES.INVALID_STATUS_TRANSITION });
+  });
+
+  it('GIVEN_merge_gate_returns_no_overall_WHEN_execute_called_THEN_returns_merge_disabled_with_null_reconciliation_status', async () => {
+    const call = vi.fn(async (tool: string) => {
+      if (tool === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 3, gates: { merge: 'na' } } } };
+      }
+      if (tool === TOOLS.REPO_RECONCILE_MAINLINE) {
+        return { ok: true, data: {} };
+      }
+      if (tool === TOOLS.GATES_RUN) {
+        return { ok: true, data: {} };
+      }
+      return { ok: true, data: {} };
+    });
+    const { handler, toolClient } = makeHandler(call);
+
+    const result = await handler.execute({ command: 'merge', feature_id: 'feature_no_overall' });
+
+    expect((toolClient.call.mock.calls as unknown[][]).map((c) => c[0])).toEqual([
+      TOOLS.FEATURE_STATE_GET,
+      TOOLS.REPO_RECONCILE_MAINLINE,
+      TOOLS.GATES_RUN,
+      TOOLS.FEATURE_STATE_GET,
+    ]);
+    expect(result).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.MERGE_DISABLED,
+        details: {
+          feature_id: 'feature_no_overall',
+          gate_overall: undefined,
+          reconciliation_status: null,
+          reconciliation_attempted: true,
+          retryable: true,
+          requires_human: false,
+        },
+      },
+    });
+  });
+
+  it('GIVEN_rebase_strategy_WHEN_execute_called_THEN_passes_rebase_to_tool', async () => {
+    const call = makeDefaultCall(true);
+    const { handler, toolClient } = makeHandler(call);
+
+    await handler.execute({
+      command: 'merge',
+      feature_id: 'feature_c',
+      merge_strategy: 'rebase',
+    });
+
+    const calls = toolClient.call.mock.calls as unknown[][];
+    const mergeCall = calls.find((c) => c[0] === TOOLS.FEATURE_READY_TO_MERGE);
+    expect(mergeCall?.[1]).toMatchObject({ merge_strategy: 'rebase' });
+  });
+});