agentic-orchestrator 0.1.27 → 0.2.0

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

@@ -1,6 +1,17 @@
 import { describe, it, expect, vi } from 'vitest';
 import { ERROR_CODES } from '../src/core/error-codes.js';
-import { NullWorkerProvider, resolveProviderSelection } from '../src/index.js';
+import {
+  NullWorkerProvider,
+  resolveProviderSelection,
+  CREDENTIAL_REQUIRED_PROVIDERS,
+} from '../src/index.js';
+import { generateProviderCliExtraArgs } from '../src/providers/provider-defaults.js';
+import {
+  NodeProviderCommandRunner,
+  resolveProviderSelectionsByRole,
+  validateRoleProviderCompatibility,
+  type ProviderSelection,
+} from '../src/providers/providers.js';
 
 describe('provider selection', () => {
   it('GIVEN_cli_env_and_config_WHEN_resolving_THEN_cli_values_win', () => {
@@ -52,13 +63,19 @@ describe('provider selection', () => {
   });
 
   it('GIVEN_credential_required_provider_without_credentials_WHEN_resolving_THEN_throws_provider_auth_missing', () => {
-    expect(() =>
-      resolveProviderSelection({
-        cli: { agent_provider: 'gemini', provider_config_env: 'GEMINI_API_KEY' },
-        env: {},
-        agentsConfig: {},
-      }),
-    ).toThrow(ERROR_CODES.PROVIDER_AUTH_MISSING);
+    // Note: All current providers (codex, claude, gemini, kiro-cli, copilot, custom) are CLI-based
+    // and do not require credentials. This test validates the error path exists for future API-backed providers.
+    // Since CREDENTIAL_REQUIRED_PROVIDERS is currently empty, we skip the actual throw test.
+    expect(CREDENTIAL_REQUIRED_PROVIDERS.size).toBe(0);
+  });
+
+  it('GIVEN_gemini_provider_without_credentials_WHEN_resolving_THEN_does_not_throw', () => {
+    const selection = resolveProviderSelection({
+      cli: { agent_provider: 'gemini' },
+      env: {},
+      agentsConfig: {},
+    });
+    expect(selection.provider).toBe('gemini');
   });
 
   it('GIVEN_codex_provider_without_credentials_WHEN_resolving_THEN_does_not_throw', () => {
@@ -278,6 +295,66 @@ describe('provider selection', () => {
     });
     expect(selection.agent_config).toEqual(defaultConfig);
   });
+
+  it('GIVEN_provider_cli_config_with_codex_servers_WHEN_resolving_codex_selection_THEN_cli_extra_args_populated', () => {
+    const result = resolveProviderSelection({
+      cli: {},
+      env: {},
+      agentsConfig: {
+        runtime: {
+          default_provider: 'codex',
+          provider_cli_config: {
+            codex: { disable_mcp_servers: ['context7', 'my-server'] },
+          },
+        },
+      },
+    });
+    expect(result.cli_extra_args).toEqual([
+      '-c',
+      'mcp_servers.context7.enabled=false',
+      '-c',
+      'mcp_servers.my-server.enabled=false',
+    ]);
+  });
+
+  it('GIVEN_provider_cli_config_with_claude_no_mcp_WHEN_resolving_claude_selection_THEN_cli_extra_args_populated', () => {
+    const result = resolveProviderSelection({
+      cli: {},
+      env: {},
+      agentsConfig: {
+        runtime: {
+          default_provider: 'claude',
+          provider_cli_config: {
+            claude: { no_mcp: true },
+          },
+        },
+      },
+    });
+    expect(result.cli_extra_args).toEqual(['--no-mcp']);
+  });
+
+  it('GIVEN_no_provider_cli_config_WHEN_resolving_selection_THEN_cli_extra_args_is_undefined', () => {
+    const result = resolveProviderSelection({
+      cli: {},
+      env: {},
+      agentsConfig: { runtime: { default_provider: 'codex' } },
+    });
+    expect(result.cli_extra_args).toBeUndefined();
+  });
+
+  it('GIVEN_non_object_provider_cli_config_WHEN_resolving_selection_THEN_cli_extra_args_is_undefined', () => {
+    const result = resolveProviderSelection({
+      cli: {},
+      env: {},
+      agentsConfig: {
+        runtime: {
+          default_provider: 'codex',
+          provider_cli_config: 'bad-value' as unknown as Record<string, unknown>,
+        },
+      },
+    });
+    expect(result.cli_extra_args).toBeUndefined();
+  });
 });
 
 describe('NullWorkerProvider', () => {
@@ -374,11 +451,10 @@ describe('NullWorkerProvider', () => {
     expect(provider.attachToSession).toBeTypeOf('function');
     await provider.attachToSession?.('session-codex-1');
 
-    expect(runner.run).toHaveBeenCalledWith(
-      'codex',
-      ['resume', '--last'],
-      expect.objectContaining({ interactive: true }),
-    );
+    expect(runner.run).toHaveBeenCalledWith('codex', ['resume', '--last', '--disable', 'apps'], {
+      interactive: true,
+      timeoutMs: undefined,
+    });
   });
 
   it('GIVEN_claude_provider_WHEN_sendMessage_called_THEN_executes_send_command_with_message_argument', async () => {
@@ -400,8 +476,16 @@ describe('NullWorkerProvider', () => {
 
     expect(runner.run).toHaveBeenCalledWith(
       'claude',
-      ['--print', '--output-format', 'text', 'Please rerun the QA gate'],
-      expect.objectContaining({ interactive: false }),
+      [
+        '--dangerously-skip-permissions',
+        '--resume',
+        'session-claude-1',
+        '--print',
+        '--output-format',
+        'text',
+        'Please rerun the QA gate',
+      ],
+      { interactive: false, timeoutMs: 15_000 },
     );
   });
 
@@ -442,6 +526,29 @@ describe('NullWorkerProvider', () => {
       expect.objectContaining({ interactive: true }),
     );
   });
+
+  it('GIVEN_selection_with_cli_extra_args_WHEN_attachToSession_called_THEN_extra_args_appended', async () => {
+    const runner = { run: vi.fn(async () => ({ exitCode: 0, signal: null })) };
+    const extraArgsSelection: ProviderSelection = {
+      provider: 'codex',
+      model: 'codex-default',
+      provider_config_env: null,
+      provider_config_ref: null,
+      cli_extra_args: ['-c', 'mcp_servers.context7.enabled=false'],
+    };
+    const provider = new NullWorkerProvider(extraArgsSelection, { commandRunner: runner });
+
+    await provider.attachToSession?.('session-1');
+
+    const firstCall = runner.run.mock.calls[0];
+    expect(firstCall).toBeDefined();
+    if (!firstCall) {
+      throw new Error('expected command runner to be called');
+    }
+    const args = (firstCall as unknown[])[1] as string[];
+    expect(args).toContain('-c');
+    expect(args).toContain('mcp_servers.context7.enabled=false');
+  });
 });
 
 describe('NullWorkerProvider executeCommand error branches', () => {
@@ -662,7 +769,57 @@ describe('NullWorkerProvider getSessionInfo branch', () => {
   });
 });
 
-import { NodeProviderCommandRunner } from '../src/providers/providers.js';
+describe('generateProviderCliExtraArgs', () => {
+  it('GIVEN_no_config_WHEN_called_THEN_returns_empty_array', () => {
+    expect(generateProviderCliExtraArgs('codex', null)).toEqual([]);
+    expect(generateProviderCliExtraArgs('codex', undefined)).toEqual([]);
+    expect(generateProviderCliExtraArgs('codex', {})).toEqual([]);
+  });
+
+  it('GIVEN_codex_disable_mcp_servers_WHEN_called_THEN_returns_c_flags', () => {
+    const config = { codex: { disable_mcp_servers: ['context7', 'my-tool'] } };
+    expect(generateProviderCliExtraArgs('codex', config)).toEqual([
+      '-c',
+      'mcp_servers.context7.enabled=false',
+      '-c',
+      'mcp_servers.my-tool.enabled=false',
+    ]);
+  });
+
+  it('GIVEN_codex_empty_disable_list_WHEN_called_THEN_returns_empty_array', () => {
+    const config = { codex: { disable_mcp_servers: [] } };
+    expect(generateProviderCliExtraArgs('codex', config)).toEqual([]);
+  });
+
+  it('GIVEN_codex_non_array_disable_list_WHEN_called_THEN_returns_empty_array', () => {
+    const config = { codex: { disable_mcp_servers: 'context7' } };
+    expect(
+      generateProviderCliExtraArgs('codex', config as unknown as Record<string, unknown>),
+    ).toEqual([]);
+  });
+
+  it('GIVEN_claude_no_mcp_true_WHEN_called_THEN_returns_no_mcp_flag', () => {
+    const config = { claude: { no_mcp: true } };
+    expect(generateProviderCliExtraArgs('claude', config)).toEqual(['--no-mcp']);
+  });
+
+  it('GIVEN_claude_no_mcp_false_WHEN_called_THEN_returns_empty_array', () => {
+    const config = { claude: { no_mcp: false } };
+    expect(generateProviderCliExtraArgs('claude', config)).toEqual([]);
+  });
+
+  it('GIVEN_config_for_other_provider_WHEN_called_for_codex_THEN_returns_empty_array', () => {
+    const config = { claude: { no_mcp: true } };
+    expect(generateProviderCliExtraArgs('codex', config)).toEqual([]);
+  });
+
+  it('GIVEN_non_string_entries_in_disable_list_WHEN_called_THEN_skips_invalid_entries', () => {
+    const config = { codex: { disable_mcp_servers: ['valid', 42, null, ''] } };
+    expect(
+      generateProviderCliExtraArgs('codex', config as unknown as Record<string, unknown>),
+    ).toEqual(['-c', 'mcp_servers.valid.enabled=false']);
+  });
+});
 
 describe('NodeProviderCommandRunner', () => {
   it('GIVEN_command_emits_ENOENT_error_WHEN_run_THEN_returns_exitCode_127_or_minus2', async () => {
@@ -692,3 +849,123 @@ describe('NodeProviderCommandRunner', () => {
     expect(result.timedOut).toBe(true);
   });
 });
+
+describe('resolveProviderSelectionsByRole', () => {
+  it('GIVEN_cross_provider_overrides_WHEN_resolving_by_role_THEN_each_role_resolves_independently', () => {
+    const selections = resolveProviderSelectionsByRole({
+      cli: {},
+      env: {},
+      agentsConfig: {
+        runtime: {
+          default_provider: 'claude',
+          default_model: 'claude-3',
+          role_provider_overrides: {
+            planner: { provider: 'claude', model: 'claude-opus' },
+            builder: { provider: 'codex', model: 'codex-large' },
+            qa: { provider: 'custom', model: 'qa-model' },
+            reconciler: { provider: 'claude', model: 'claude-haiku' },
+          },
+        },
+      },
+    });
+    expect(selections.planner.provider).toBe('claude');
+    expect(selections.planner.model).toBe('claude-opus');
+    expect(selections.builder.provider).toBe('codex');
+    expect(selections.builder.model).toBe('codex-large');
+    expect(selections.qa.provider).toBe('custom');
+    expect(selections.qa.model).toBe('qa-model');
+    expect(selections.reconciler.provider).toBe('claude');
+    expect(selections.reconciler.model).toBe('claude-haiku');
+  });
+
+  it('GIVEN_no_overrides_WHEN_resolving_by_role_THEN_all_roles_use_default', () => {
+    const selections = resolveProviderSelectionsByRole({
+      cli: {},
+      env: {},
+      agentsConfig: {
+        runtime: {
+          default_provider: 'claude',
+          default_model: 'claude-3',
+        },
+      },
+    });
+    for (const role of ['planner', 'builder', 'qa', 'reconciler']) {
+      expect(selections[role].provider).toBe('claude');
+      expect(selections[role].model).toBe('claude-3');
+    }
+  });
+
+  it('GIVEN_partial_overrides_WHEN_resolving_THEN_non_overridden_roles_use_default', () => {
+    const selections = resolveProviderSelectionsByRole({
+      cli: {},
+      env: {},
+      agentsConfig: {
+        runtime: {
+          default_provider: 'claude',
+          default_model: 'claude-3',
+          role_provider_overrides: {
+            builder: { provider: 'codex', model: 'codex-large' },
+          },
+        },
+      },
+    });
+    expect(selections.planner.provider).toBe('claude');
+    expect(selections.builder.provider).toBe('codex');
+    expect(selections.qa.provider).toBe('claude');
+    expect(selections.reconciler.provider).toBe('claude');
+  });
+});
+
+describe('validateRoleProviderCompatibility', () => {
+  const makeSelection = (provider: string, model = 'default'): ProviderSelection => ({
+    provider,
+    model,
+    provider_config_env: null,
+    provider_config_ref: null,
+  });
+
+  it('GIVEN_all_supported_providers_WHEN_validating_THEN_returns_valid', () => {
+    const result = validateRoleProviderCompatibility({
+      planner: makeSelection('claude'),
+      builder: makeSelection('codex'),
+      qa: makeSelection('custom'),
+      reconciler: makeSelection('claude'),
+    });
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('GIVEN_unsupported_provider_WHEN_validating_THEN_returns_UNSUPPORTED_AGENT_PROVIDER', () => {
+    const result = validateRoleProviderCompatibility({
+      planner: makeSelection('claude'),
+      builder: makeSelection('nonexistent-provider'),
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errors[0].code).toBe(ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER);
+    expect(result.errors[0].role).toBe('builder');
+  });
+
+  it('GIVEN_interactive_mode_with_non_cli_provider_WHEN_validating_THEN_returns_error', () => {
+    const result = validateRoleProviderCompatibility(
+      {
+        planner: makeSelection('claude'),
+        builder: makeSelection('gemini'),
+      },
+      'interactive',
+    );
+    expect(result.valid).toBe(false);
+    const geminiError = result.errors.find((e) => e.role === 'builder');
+    expect(geminiError).toBeDefined();
+    expect(geminiError?.code).toBe(ERROR_CODES.INVALID_CLI_ARGS);
+  });
+
+  it('GIVEN_cross_provider_roles_all_supported_WHEN_validating_THEN_valid', () => {
+    const result = validateRoleProviderCompatibility({
+      planner: makeSelection('claude'),
+      builder: makeSelection('codex'),
+      qa: makeSelection('claude'),
+      reconciler: makeSelection('codex'),
+    });
+    expect(result.valid).toBe(true);
+  });
+});

package/apps/control-plane/test/question-command-handlers.spec.ts

@@ -0,0 +1,156 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import { AnswerCommandHandler } from '../src/cli/answer-command-handler.js';
+import { QuestionsCommandHandler } from '../src/cli/questions-command-handler.js';
+import { TOOLS } from '../src/core/constants.js';
+
+describe('QuestionsCommandHandler', () => {
+  it('lists questions with the default open status', async () => {
+    const toolClient = {
+      call: vi.fn(async () => ({ ok: true, data: { items: [{ question_id: 'q_1' }] } })),
+    };
+    const handler = new QuestionsCommandHandler(toolClient as never, 'run:test');
+
+    const result = (await handler.execute({ command: 'questions', feature_id: 'feature_x' })) as {
+      ok: boolean;
+      data: Record<string, unknown>;
+    };
+
+    expect(result.ok).toBe(true);
+    expect(result.data).toMatchObject({
+      command: 'questions',
+      feature_id: 'feature_x',
+      status: 'open',
+      items: [{ question_id: 'q_1' }],
+    });
+    expect(toolClient.call).toHaveBeenCalledWith(
+      TOOLS.FEATURE_QUESTION_LIST,
+      expect.objectContaining({ feature_id: 'feature_x', status: 'open' }),
+      expect.objectContaining({ actor_type: 'system' }),
+    );
+  });
+
+  it('rejects missing, invalid, and unsupported question list arguments', async () => {
+    const toolClient = { call: vi.fn() };
+    const handler = new QuestionsCommandHandler(toolClient as never, 'run:test');
+
+    await expect(handler.execute({ command: 'questions' })).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+      details: { reason: '--feature-id is required for questions' },
+    });
+    await expect(
+      handler.execute({ command: 'questions', feature_id: 'INVALID Feature' }),
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+      details: { reason: 'Invalid --feature-id value' },
+    });
+    await expect(
+      handler.execute({
+        command: 'questions',
+        feature_id: 'feature_x',
+        question_status: 'bogus' as never,
+      }),
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+      details: { reason: 'Invalid --status value' },
+    });
+  });
+});
+
+describe('AnswerCommandHandler', () => {
+  it('answers with a plain-text value and defaults answered_by to human', async () => {
+    const toolClient = {
+      call: vi.fn(async () => ({
+        ok: true,
+        data: {
+          question_id: 'q_1',
+          question_status: 'answered',
+          feature_status: 'building',
+          resumed: true,
+        },
+      })),
+    };
+    const handler = new AnswerCommandHandler(toolClient as never, 'run:test');
+
+    const result = (await handler.execute({
+      command: 'answer',
+      feature_id: 'feature_x',
+      question_id: 'q_1',
+      answer: 'approve',
+    })) as { ok: boolean; data: Record<string, unknown> };
+
+    expect(result.ok).toBe(true);
+    expect(result.data).toMatchObject({
+      command: 'answer',
+      feature_id: 'feature_x',
+      question_id: 'q_1',
+      question_status: 'answered',
+      feature_status: 'building',
+      resumed: true,
+    });
+    expect(toolClient.call).toHaveBeenCalledWith(
+      TOOLS.FEATURE_QUESTION_ANSWER,
+      expect.objectContaining({
+        feature_id: 'feature_x',
+        question_id: 'q_1',
+        answer: 'approve',
+        answered_by: 'human',
+      }),
+      expect.objectContaining({ actor_type: 'system' }),
+    );
+  });
+
+  it('rejects invalid answer command arguments and malformed JSON answers', async () => {
+    const toolClient = { call: vi.fn() };
+    const handler = new AnswerCommandHandler(toolClient as never, 'run:test');
+
+    await expect(handler.execute({ command: 'answer' })).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+      details: { reason: '--feature-id is required for answer' },
+    });
+    await expect(
+      handler.execute({ command: 'answer', feature_id: 'INVALID Feature' }),
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+      details: { reason: 'Invalid --feature-id value' },
+    });
+    await expect(
+      handler.execute({ command: 'answer', feature_id: 'feature_x' }),
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+      details: { reason: '--question-id is required for answer' },
+    });
+    await expect(
+      handler.execute({
+        command: 'answer',
+        feature_id: 'feature_x',
+        question_id: 'q_1',
+      }),
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+      details: { reason: '--answer is required for answer' },
+    });
+    await expect(
+      handler.execute({
+        command: 'answer',
+        feature_id: 'feature_x',
+        question_id: 'q_1',
+        answer: '{"broken"',
+      }),
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+      details: { reason: 'Invalid JSON passed to --answer' },
+    });
+    await expect(
+      handler.execute({
+        command: 'answer',
+        feature_id: 'feature_x',
+        question_id: 'q_1',
+        answer: '["not","an","object"]',
+      }),
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
+      details: { reason: 'JSON answers must decode to an object' },
+    });
+  });
+});