agentic-orchestrator 0.1.0

package/apps/control-plane/test/cli.unit.spec.ts

@@ -0,0 +1,609 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import { TOOLS } from '../src/core/constants.js';
+
+const ensureLoadedMock = vi.hoisted(() => vi.fn(async () => undefined));
+const recoverFromStateMock = vi.hoisted(
+  () =>
+    vi.fn(async () => ({
+      data: {
+        recovered: true,
+        stale_features: [] as string[],
+        active: {}
+      }
+    }))
+);
+const createToolingRuntimeMock = vi.hoisted(() => vi.fn(async () => ({ runtime: 'ok' })));
+const resolveToolClientMock = vi.hoisted(() => vi.fn());
+const toolCallMock = vi.hoisted(() => vi.fn());
+const readIndexMock = vi.hoisted(
+  () =>
+    vi.fn(async () => ({
+      version: 1,
+      active: ['feature_resume'],
+      blocked: [],
+      blocked_queue: []
+    }))
+);
+const getRuntimeSessionsMock = vi.hoisted(
+  () =>
+    vi.fn(async () => ({
+      run_id: 'run:resume',
+      owner_instance_id: 'owner:resume',
+      feature_sessions: {}
+    }))
+);
+const featureDiscoverSpecsMock = vi.hoisted(
+  () =>
+    vi.fn(async () => ({
+      data: {
+        specs: [{ feature_id: 'feature_resume', spec_path: '.aop/features/feature_resume/spec.md' }]
+      }
+    }))
+);
+const featureStateGetMock = vi.hoisted(
+  () =>
+    vi.fn(async (_featureId?: string) => ({
+      data: {
+        front_matter: {
+          status: 'planning'
+        }
+      }
+    }))
+);
+const resolveProviderSelectionMock = vi.hoisted(
+  () =>
+    vi.fn(() => ({
+      provider: 'custom',
+      model: 'model',
+      provider_config_env: null,
+      provider_config_ref: null
+    }))
+);
+const supervisorConstructorOptionsMock = vi.hoisted(() => vi.fn());
+const supervisorStartMock = vi.hoisted(
+  () =>
+    vi.fn(async (..._args: unknown[]) => ({
+      queue_depth: 0,
+      status: 'running',
+      run_metadata: { started_at: 'now' } as Record<string, unknown>,
+      dashboard: { features: [] }
+    }))
+);
+
+vi.mock('../src/core/kernel.js', () => {
+  class AopKernel {
+    private readonly repoRoot: string;
+    private readonly agentsConfig: Record<string, unknown>;
+
+    constructor(repoRoot: string) {
+      this.repoRoot = repoRoot;
+      this.agentsConfig = {};
+    }
+
+    async ensureLoaded() {
+      await ensureLoadedMock();
+    }
+
+    async recoverFromState() {
+      return await recoverFromStateMock();
+    }
+
+    getRepoRoot() {
+      return this.repoRoot;
+    }
+
+    getAgentsConfig() {
+      return this.agentsConfig;
+    }
+
+    getRbacPolicy() {
+      return {};
+    }
+
+    async readIndex() {
+      return await readIndexMock();
+    }
+
+    async getRuntimeSessions() {
+      return await getRuntimeSessionsMock();
+    }
+
+    async featureDiscoverSpecs() {
+      return await featureDiscoverSpecsMock();
+    }
+
+    async featureStateGet(featureId: string) {
+      return await featureStateGetMock(featureId);
+    }
+  }
+
+  return { AopKernel };
+});
+
+vi.mock('../src/mcp/runtime-factory.js', () => ({
+  createToolingRuntime: createToolingRuntimeMock,
+  resolveToolClient: resolveToolClientMock
+}));
+
+vi.mock('../src/providers/providers.js', () => ({
+  resolveProviderSelection: resolveProviderSelectionMock,
+  NullWorkerProvider: class NullWorkerProvider {
+    selection: unknown;
+
+    constructor(selection: unknown) {
+      this.selection = selection;
+    }
+  }
+}));
+
+vi.mock('../src/supervisor/runtime.js', () => {
+  class SupervisorRuntime {
+    private readonly options: unknown;
+
+    constructor(
+      _kernel: unknown,
+      _provider: unknown,
+      _toolClient: unknown,
+      options: unknown
+    ) {
+      this.options = options;
+      supervisorConstructorOptionsMock(options);
+    }
+
+    async start(features: Array<{ feature_id: string }>) {
+      return await supervisorStartMock(features, this.options);
+    }
+  }
+
+  return { SupervisorRuntime };
+});
+
+import { main } from '../src/cli/aop.js';
+
+function asJsonWrites(writeSpy: ReturnType<typeof vi.spyOn>): any[] {
+  return writeSpy.mock.calls
+    .map((call) => call[0])
+    .filter((payload) => typeof payload === 'string')
+    .map((payload) => JSON.parse(String(payload).trim()));
+}
+
+describe('aop CLI unit', () => {
+  let cwd: string;
+  let stdoutSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(async () => {
+    cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-cli-unit-'));
+    await fs.mkdir(path.join(cwd, '.aop', 'features'), { recursive: true });
+    resolveToolClientMock.mockReturnValue({ call: toolCallMock });
+    toolCallMock.mockReset();
+    ensureLoadedMock.mockClear();
+    recoverFromStateMock.mockClear();
+    readIndexMock.mockClear();
+    getRuntimeSessionsMock.mockClear();
+    featureDiscoverSpecsMock.mockClear();
+    featureStateGetMock.mockClear();
+    createToolingRuntimeMock.mockClear();
+    resolveProviderSelectionMock.mockClear();
+    supervisorConstructorOptionsMock.mockClear();
+    supervisorStartMock.mockClear();
+    stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  });
+
+  afterEach(async () => {
+    stdoutSpy.mockRestore();
+    await fs.rm(cwd, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('GIVEN_unknown_command_WHEN_main_runs_THEN_returns_invalid_cli_args', async () => {
+    const code = await main(['bogus'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.INVALID_CLI_ARGS
+      }
+    });
+  });
+
+  it('GIVEN_invalid_transport_WHEN_main_runs_THEN_returns_invalid_cli_args', async () => {
+    const code = await main(['run', '--transport', 'ssh'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.INVALID_CLI_ARGS
+      }
+    });
+  });
+
+  it('GIVEN_status_command_WHEN_main_runs_THEN_calls_dashboard_and_returns_zero', async () => {
+    toolCallMock.mockResolvedValue({ ok: true, data: { healthy: true } });
+    const code = await main(['status'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(0);
+    expect(resolveToolClientMock).toHaveBeenCalledWith('mcp', expect.any(Object));
+    expect(toolCallMock).toHaveBeenCalledWith(
+      TOOLS.REPORT_DASHBOARD,
+      expect.any(Object),
+      expect.objectContaining({ actor_type: 'system' })
+    );
+    expect(writes[0]).toMatchObject({ ok: true, data: { healthy: true } });
+  });
+
+  it('GIVEN_resume_command_WHEN_main_runs_THEN_resumes_non_terminal_features_from_persisted_state', async () => {
+    recoverFromStateMock.mockResolvedValue({ data: { recovered: true, stale_features: ['f1'], active: {} } });
+    supervisorStartMock.mockResolvedValue({
+      queue_depth: 0,
+      status: 'running',
+      run_metadata: { resumed: true },
+      dashboard: { features: ['feature_resume'] }
+    });
+    const code = await main(['resume'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(0);
+    expect(recoverFromStateMock).toHaveBeenCalledTimes(1);
+    expect(featureDiscoverSpecsMock).toHaveBeenCalledTimes(1);
+    expect(featureStateGetMock).toHaveBeenCalledWith('feature_resume');
+    expect(supervisorStartMock).toHaveBeenCalledWith([{ feature_id: 'feature_resume' }], expect.any(Object));
+    expect(writes[0]).toMatchObject({
+      ok: true,
+      data: {
+        command: 'resume',
+        resumed: true,
+        resumed_features: [
+          expect.objectContaining({
+            feature_id: 'feature_resume',
+            resume_phase: 'planning'
+          })
+        ],
+        recovery: { stale_features: ['f1'] }
+      }
+    });
+  });
+
+  it('GIVEN_stop_command_WHEN_main_runs_THEN_returns_not_implemented_status', async () => {
+    const code = await main(['stop'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(0);
+    expect(writes[0]).toMatchObject({
+      ok: true,
+      data: { status: 'stop_not_implemented_yet' }
+    });
+  });
+
+  it('GIVEN_delete_without_feature_id_WHEN_main_runs_THEN_returns_invalid_cli_args', async () => {
+    const code = await main(['delete'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.INVALID_CLI_ARGS
+      }
+    });
+    expect(toolCallMock).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_delete_without_yes_WHEN_main_runs_THEN_executes_preview_mode', async () => {
+    toolCallMock.mockResolvedValue({
+      ok: true,
+      data: {
+        feature_id: 'feature_delete',
+        dry_run: true,
+        plan: { feature_dir_exists: true },
+        summary: { feature_dir_removed: false }
+      }
+    });
+
+    const code = await main(['delete', '--feature-id', 'feature_delete'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(0);
+    expect(toolCallMock).toHaveBeenCalledWith(
+      TOOLS.FEATURE_DELETE,
+      expect.objectContaining({
+        feature_id: 'feature_delete',
+        dry_run: true,
+        confirm: false,
+        remove_worktree: true,
+        remove_branch: 'none'
+      }),
+      expect.objectContaining({ actor_type: 'system' })
+    );
+    expect(writes[0]).toMatchObject({
+      ok: true,
+      data: {
+        command: 'delete',
+        feature_id: 'feature_delete',
+        dry_run: true
+      }
+    });
+  });
+
+  it('GIVEN_delete_with_yes_and_remove_options_WHEN_main_runs_THEN_executes_destructive_mode', async () => {
+    toolCallMock.mockResolvedValue({
+      ok: true,
+      data: {
+        feature_id: 'feature_delete',
+        dry_run: false,
+        plan: { feature_dir_exists: true },
+        applied: { feature_dir_removed: true },
+        summary: { feature_dir_removed: true }
+      }
+    });
+
+    const code = await main(
+      [
+        'delete',
+        '--feature-id',
+        'feature_delete',
+        '--yes',
+        '--remove-worktree',
+        'false',
+        '--remove-branch',
+        'force'
+      ],
+      { cwd, env: {} as NodeJS.ProcessEnv }
+    );
+
+    expect(code).toBe(0);
+    expect(toolCallMock).toHaveBeenCalledWith(
+      TOOLS.FEATURE_DELETE,
+      expect.objectContaining({
+        feature_id: 'feature_delete',
+        dry_run: false,
+        confirm: true,
+        remove_worktree: false,
+        remove_branch: 'force'
+      }),
+      expect.objectContaining({ actor_type: 'system' })
+    );
+  });
+
+  it('GIVEN_delete_with_invalid_remove_branch_WHEN_main_runs_THEN_returns_invalid_cli_args', async () => {
+    const code = await main(
+      ['delete', '--feature-id', 'feature_delete', '--remove-branch', 'hard'],
+      { cwd, env: {} as NodeJS.ProcessEnv }
+    );
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.INVALID_CLI_ARGS
+      }
+    });
+    expect(toolCallMock).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_missing_file_input_WHEN_run_command_THEN_returns_input_path_not_found', async () => {
+    const code = await main(['run', '-fi', 'missing.md'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.INPUT_PATH_NOT_FOUND
+      }
+    });
+  });
+
+  it('GIVEN_empty_folder_input_WHEN_run_command_THEN_returns_no_specs_found', async () => {
+    await fs.mkdir(path.join(cwd, 'incoming'), { recursive: true });
+    const code = await main(['run', '-fl', 'incoming'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.NO_SPECS_FOUND
+      }
+    });
+  });
+
+  it('GIVEN_duplicate_slug_files_WHEN_run_command_THEN_returns_feature_slug_collision', async () => {
+    const folder = path.join(cwd, 'incoming');
+    await fs.mkdir(folder, { recursive: true });
+    await fs.writeFile(path.join(folder, 'alpha.spec.md'), '# A\n', 'utf8');
+    await fs.writeFile(path.join(folder, 'alpha-spec.md'), '# B\n', 'utf8');
+
+    toolCallMock.mockResolvedValue({ ok: true, data: { front_matter: { version: 1 } } });
+    const code = await main(['run', '-fl', 'incoming'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.FEATURE_SLUG_COLLISION
+      }
+    });
+  });
+
+  it('GIVEN_successful_file_ingest_WHEN_run_command_THEN_starts_supervisor', async () => {
+    const incoming = path.join(cwd, 'incoming');
+    await fs.mkdir(incoming, { recursive: true });
+    await fs.writeFile(path.join(incoming, 'feature_one.md'), '# Spec\n\nBuild.\n', 'utf8');
+
+    toolCallMock.mockImplementation(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 1 } } };
+      }
+      return { ok: true, data: {} };
+    });
+
+    const code = await main(
+      ['run', '-fi', path.join('incoming', 'feature_one.md'), '--agent-provider', 'custom'],
+      { cwd, env: {} as NodeJS.ProcessEnv }
+    );
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(0);
+    expect(supervisorStartMock).toHaveBeenCalledWith(
+      [expect.objectContaining({ feature_id: 'feature_one' })],
+      expect.any(Object)
+    );
+    expect(resolveProviderSelectionMock).toHaveBeenCalledTimes(1);
+    expect(writes.at(-1)).toMatchObject({
+      ok: true,
+      data: {
+        command: 'run',
+        runtime_status: 'running'
+      }
+    });
+    await expect(
+      fs.stat(path.join(cwd, '.aop', 'features', 'feature_one', 'spec.md'))
+    ).resolves.toBeTruthy();
+  });
+
+  it('GIVEN_takeover_flag_WHEN_run_command_THEN_forwards_takeover_option_to_supervisor', async () => {
+    const incoming = path.join(cwd, 'incoming');
+    await fs.mkdir(incoming, { recursive: true });
+    await fs.writeFile(path.join(incoming, 'feature_takeover.md'), '# Spec\n\nRecover stale run.\n', 'utf8');
+
+    toolCallMock.mockImplementation(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 1 } } };
+      }
+      return { ok: true, data: {} };
+    });
+
+    const code = await main(
+      ['run', '-fi', path.join('incoming', 'feature_takeover.md'), '--agent-provider', 'custom', '--takeover-stale-run'],
+      { cwd, env: {} as NodeJS.ProcessEnv }
+    );
+
+    expect(code).toBe(0);
+    expect(supervisorConstructorOptionsMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        takeover_stale_run: true
+      })
+    );
+  });
+
+  it('GIVEN_stale_takeover_contract_WHEN_run_without_and_with_flag_THEN_returns_run_already_active_then_succeeds', async () => {
+    const incoming = path.join(cwd, 'incoming');
+    await fs.mkdir(incoming, { recursive: true });
+    await fs.writeFile(path.join(incoming, 'feature_stale.md'), '# Spec\n\nHandle takeover.\n', 'utf8');
+
+    toolCallMock.mockImplementation(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 1 } } };
+      }
+      return { ok: true, data: {} };
+    });
+
+    supervisorStartMock.mockImplementation(async (_features: Array<{ feature_id: string }>, options?: any) => {
+      if (!options?.takeover_stale_run) {
+        const error = new Error('run_already_active');
+        (error as any).code = ERROR_CODES.RUN_ALREADY_ACTIVE;
+        throw error;
+      }
+      return {
+        queue_depth: 0,
+        status: 'running',
+        run_metadata: { started_at: 'now', took_over_stale: true },
+        dashboard: { features: [] }
+      };
+    });
+
+    const noTakeoverCode = await main(
+      ['run', '-fi', path.join('incoming', 'feature_stale.md'), '--agent-provider', 'custom'],
+      { cwd, env: {} as NodeJS.ProcessEnv }
+    );
+    const noTakeoverWrites = asJsonWrites(stdoutSpy);
+    expect(noTakeoverCode).toBe(1);
+    expect(noTakeoverWrites.at(-1)).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.RUN_ALREADY_ACTIVE
+      }
+    });
+
+    stdoutSpy.mockClear();
+
+    const withTakeoverCode = await main(
+      ['run', '-fi', path.join('incoming', 'feature_stale.md'), '--agent-provider', 'custom', '--takeover-stale-run'],
+      { cwd, env: {} as NodeJS.ProcessEnv }
+    );
+    const withTakeoverWrites = asJsonWrites(stdoutSpy);
+    expect(withTakeoverCode).toBe(0);
+    expect(withTakeoverWrites.at(-1)).toMatchObject({
+      ok: true,
+      data: {
+        command: 'run',
+        runtime_status: 'running'
+      }
+    });
+  });
+
+  it('GIVEN_discovery_returns_no_specs_WHEN_run_command_without_inputs_THEN_returns_no_specs_found', async () => {
+    toolCallMock.mockImplementation(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_DISCOVER_SPECS) {
+        return { ok: true, data: { specs: [] } };
+      }
+      return { ok: true, data: {} };
+    });
+
+    const code = await main(['run'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.NO_SPECS_FOUND
+      }
+    });
+  });
+
+  it('GIVEN_inprocess_transport_flag_WHEN_status_runs_THEN_uses_inprocess_transport_override', async () => {
+    toolCallMock.mockResolvedValue({ ok: true, data: { healthy: true } });
+
+    const code = await main(['status', '--transport', 'inprocess'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(0);
+    expect(resolveToolClientMock).toHaveBeenCalledWith('inprocess', expect.any(Object));
+    expect(writes[0]).toMatchObject({ ok: true, data: { healthy: true } });
+  });
+
+  it('GIVEN_tool_error_WHEN_discovering_specs_THEN_returns_error_code_from_tool', async () => {
+    toolCallMock.mockResolvedValue({
+      ok: false,
+      error: {
+        code: ERROR_CODES.INTERNAL_ERROR,
+        message: 'tool failure',
+        details: { reason: 'simulated' }
+      }
+    });
+
+    const code = await main(['run'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.INTERNAL_ERROR,
+        message: 'tool failure'
+      }
+    });
+  });
+});