agentic-orchestrator 0.1.28 → 0.2.0

package/apps/control-plane/src/cli/answer-command-handler.ts

@@ -0,0 +1,113 @@
+import { ERROR_CODES } from '../core/error-codes.js';
+import { TOOLS } from '../core/constants.js';
+import type { AppError } from '../providers/providers.js';
+import type { ToolClient } from '../mcp/tool-client.js';
+import type { CliOptions } from './types.js';
+import { callCliTool } from './tooling.js';
+
+function isValidFeatureId(value: string): boolean {
+  return /^[a-z0-9_][a-z0-9_-]*$/.test(value);
+}
+
+function invalidCliArgs(details: Record<string, unknown>): never {
+  const error = new Error(ERROR_CODES.INVALID_CLI_ARGS) as AppError;
+  error.code = ERROR_CODES.INVALID_CLI_ARGS;
+  error.details = details;
+  throw error;
+}
+
+function parseAnswerValue(rawAnswer: string): string | Record<string, unknown> {
+  const trimmed = rawAnswer.trim();
+  if (trimmed.length === 0) {
+    invalidCliArgs({
+      reason: '--answer is required for answer',
+      expected: '--answer <value>',
+    });
+  }
+
+  if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
+    return trimmed;
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(trimmed) as unknown;
+  } catch {
+    invalidCliArgs({
+      reason: 'Invalid JSON passed to --answer',
+      provided: rawAnswer,
+    });
+  }
+
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    invalidCliArgs({
+      reason: 'JSON answers must decode to an object',
+      expected: '{"key":"value"}',
+    });
+  }
+
+  return parsed as Record<string, unknown>;
+}
+
+export class AnswerCommandHandler {
+  private readonly toolClient: ToolClient;
+  private readonly runId: string;
+
+  constructor(toolClient: ToolClient, runId: string) {
+    this.toolClient = toolClient;
+    this.runId = runId;
+  }
+
+  async execute(options: CliOptions): Promise<unknown> {
+    const featureId = options.feature_id;
+    if (!featureId) {
+      invalidCliArgs({
+        reason: '--feature-id is required for answer',
+        expected: '--feature-id <feature_id>',
+      });
+    }
+    if (!isValidFeatureId(featureId)) {
+      invalidCliArgs({
+        reason: 'Invalid --feature-id value',
+        provided: featureId,
+        expected_pattern: '^[a-z0-9_][a-z0-9_-]*$',
+      });
+    }
+
+    const questionId = options.question_id?.trim();
+    if (!questionId) {
+      invalidCliArgs({
+        reason: '--question-id is required for answer',
+        expected: '--question-id <question_id>',
+      });
+    }
+
+    if (!options.answer) {
+      invalidCliArgs({
+        reason: '--answer is required for answer',
+        expected: '--answer <value>',
+      });
+    }
+
+    const answeredBy =
+      typeof options.answered_by === 'string' && options.answered_by.trim().length > 0
+        ? options.answered_by.trim()
+        : 'human';
+
+    const response = await callCliTool(this.toolClient, this.runId, TOOLS.FEATURE_QUESTION_ANSWER, {
+      feature_id: featureId,
+      question_id: questionId,
+      answer: parseAnswerValue(options.answer),
+      answered_by: answeredBy,
+    });
+
+    return {
+      ok: true,
+      data: {
+        command: 'answer',
+        feature_id: featureId,
+        ...(response.data ?? {}),
+      },
+    };
+  }
+}

package/apps/control-plane/src/cli/attach-command-handler.ts

@@ -1,5 +1,6 @@
 import { ERROR_CODES } from '../core/error-codes.js';
 import { STATUS, TOOLS } from '../core/constants.js';
+import { hasPendingMainlineConflict } from '../core/mainline-conflict.js';
 import type { AppError, WorkerProvider } from '../providers/providers.js';
 import type { AopKernel } from '../core/kernel.js';
 import type { ToolClient } from '../mcp/tool-client.js';
@@ -9,6 +10,7 @@ import { callCliTool } from './tooling.js';
 interface FeatureStatePayload {
   front_matter: {
     status: string;
+    conflicts?: unknown;
   };
 }
 
@@ -23,13 +25,19 @@ function invalidCliArgs(details: Record<string, unknown>): never {
   throw error;
 }
 
-function selectSessionRole(status: string): 'planner' | 'builder' | 'qa' {
-  if (status === STATUS.PLANNING) {
+function selectSessionRole(
+  status: string,
+  conflicts: unknown,
+): 'planner' | 'builder' | 'qa' | 'reconciler' {
+  if (status === STATUS.INTAKE || status === STATUS.PLANNING) {
     return 'planner';
   }
   if (status === STATUS.BUILDING) {
     return 'builder';
   }
+  if (status === STATUS.BLOCKED && hasPendingMainlineConflict(conflicts)) {
+    return 'reconciler';
+  }
   return 'qa';
 }
 
@@ -76,11 +84,12 @@ export class AttachCommandHandler {
     });
     const state = rawState.data as unknown as FeatureStatePayload;
     const status = state.front_matter.status;
-    const role = selectSessionRole(status);
+    const role = selectSessionRole(status, state.front_matter.conflicts);
     const sessionByRole = {
       planner: featureSessions.planner_session_id,
       builder: featureSessions.builder_session_id,
       qa: featureSessions.qa_session_id,
+      reconciler: runtimeSessions.reconciler_session_id,
     };
     const selectedSessionId = sessionByRole[role];
     const sessionId =

package/apps/control-plane/src/cli/cli-argument-parser.ts

@@ -30,12 +30,12 @@ export class CliArgumentParser {
       const token = tokens[index];
       const next = tokens[index + 1];
 
-      if (token === '-fi') {
+      if (token === '-fi' || token === '--fi') {
         options.file_input = next;
         index += 1;
         continue;
       }
-      if (token === '-fl') {
+      if (token === '-fl' || token === '--fl') {
         options.folder_input = next;
         index += 1;
         continue;
@@ -50,8 +50,39 @@ export class CliArgumentParser {
         index += 1;
         continue;
       }
-      if (token === '--message') {
-        options.message = next;
+      if (token === '--with-feature-id') {
+        options.with_feature_id = next;
+        index += 1;
+        continue;
+      }
+      if (token === '--override-id') {
+        options.override_id = next;
+        index += 1;
+        continue;
+      }
+      if (token === '--reason') {
+        options.reason = next;
+        index += 1;
+        continue;
+      }
+      if (token === '--allow') {
+        options.allow = true;
+        continue;
+      }
+      if (token === '--list') {
+        options.list = true;
+        continue;
+      }
+      if (token === '--revoke') {
+        options.revoke = true;
+        continue;
+      }
+      if (token === '--resume') {
+        if (options.command === CliCommand.Collision) {
+          options.resume_after_collision_override = true;
+          continue;
+        }
+        options.resume_feature_id = next;
         index += 1;
         continue;
       }
@@ -60,6 +91,66 @@ export class CliArgumentParser {
         index += 1;
         continue;
       }
+      if (token === '--message') {
+        options.message = next;
+        index += 1;
+        continue;
+      }
+      if (token === '--answer') {
+        options.answer = next;
+        index += 1;
+        continue;
+      }
+      if (token === '--answered-by') {
+        options.answered_by = next;
+        index += 1;
+        continue;
+      }
+      if (token === '--question-id') {
+        options.question_id = next;
+        index += 1;
+        continue;
+      }
+      if (token === '--status' && options.command === CliCommand.Questions) {
+        if (
+          next === 'open' ||
+          next === 'answered' ||
+          next === 'expired' ||
+          next === 'withdrawn' ||
+          next === 'all'
+        ) {
+          options.question_status = next;
+          index += 1;
+        }
+        continue;
+      }
+      if (token === '--approval-token') {
+        options.approval_token = next;
+        index += 1;
+        continue;
+      }
+      if (token === '--execution-mode') {
+        if (next === 'deterministic' || next === 'interactive') {
+          options.execution_mode = next;
+          index += 1;
+        }
+        continue;
+      }
+      if (token === '--sync-remote') {
+        options.sync_remote = next;
+        index += 1;
+        continue;
+      }
+      if (token === '--merge-strategy' || token === '--strategy') {
+        options.merge_strategy = next;
+        index += 1;
+        continue;
+      }
+      if (token === '--commit-message') {
+        options.commit_message = next;
+        index += 1;
+        continue;
+      }
       if (token === '--dry-run') {
         const parsed = parseOptionalBooleanToken(next);
         if (parsed === null) {
@@ -111,13 +202,6 @@ export class CliArgumentParser {
         }
         continue;
       }
-      if (token === '--execution-mode') {
-        if (next === 'deterministic' || next === 'interactive') {
-          options.execution_mode = next;
-          index += 1;
-        }
-        continue;
-      }
       if (token === '--transport') {
         options.transport = next;
         index += 1;
@@ -147,6 +231,10 @@ export class CliArgumentParser {
         options.force = true;
         continue;
       }
+      if (token === '--no-resume') {
+        options.no_resume = true;
+        continue;
+      }
       if (token === '--project') {
         options.project = next;
         index += 1;
@@ -172,12 +260,46 @@ export class CliArgumentParser {
         options.dev = true;
         continue;
       }
+      if (token === '--run-id') {
+        options.run_id = next;
+        index += 1;
+        continue;
+      }
+      if (token === '--from-sequence') {
+        const parsed = Number(next);
+        if (!isNaN(parsed)) {
+          options.from_sequence = parsed;
+          index += 1;
+        }
+        continue;
+      }
+      if (token === '--limit') {
+        const parsed = Number(next);
+        if (!isNaN(parsed)) {
+          options.limit = parsed;
+          index += 1;
+        }
+        continue;
+      }
+      if (token === '--tool') {
+        options.tool_filter = next;
+        index += 1;
+        continue;
+      }
+      if (token === '--json') {
+        options.json_output = true;
+        continue;
+      }
       if (token === '--help' || token === '-h') {
         options.command = CliCommand.Help;
         continue;
       }
 
       if (!token.startsWith('-')) {
+        if (options.command === CliCommand.Completion && !options.shell) {
+          options.shell = token;
+          continue;
+        }
         if (
           (options.command === CliCommand.Send || options.command === CliCommand.Attach) &&
           !options.feature_id

package/apps/control-plane/src/cli/collision-command-handler.ts

@@ -0,0 +1,113 @@
+import { ERROR_CODES } from '../core/error-codes.js';
+import type { AopKernel } from '../core/kernel.js';
+import type { AppError } from '../providers/providers.js';
+import type { CliOptions } from './types.js';
+
+function isValidFeatureId(value: string): boolean {
+  return /^[a-z0-9_][a-z0-9_-]*$/.test(value);
+}
+
+function invalidCliArgs(details: Record<string, unknown>): never {
+  const error = new Error(ERROR_CODES.INVALID_CLI_ARGS) as AppError;
+  error.code = ERROR_CODES.INVALID_CLI_ARGS;
+  error.details = details;
+  throw error;
+}
+
+export class CollisionCommandHandler {
+  private readonly kernel: AopKernel;
+  private readonly runId: string;
+
+  constructor(kernel: AopKernel, runId: string) {
+    this.kernel = kernel;
+    this.runId = runId;
+  }
+
+  async execute(options: CliOptions): Promise<unknown> {
+    const actions = [options.allow === true, options.list === true, options.revoke === true].filter(
+      Boolean,
+    ).length;
+    if (actions !== 1) {
+      invalidCliArgs({
+        reason: 'Exactly one of --allow, --list, or --revoke is required',
+        expected: ['--allow', '--list', '--revoke'],
+      });
+    }
+
+    if (options.allow) {
+      const featureId = options.feature_id;
+      const withFeatureId = options.with_feature_id;
+      const reason = options.reason?.trim();
+      if (!featureId || !withFeatureId || !reason) {
+        invalidCliArgs({
+          reason: '--allow requires --feature-id, --with-feature-id, and --reason',
+          expected:
+            'aop collision --allow --feature-id <feature_id> --with-feature-id <feature_id> --reason "<text>"',
+        });
+      }
+      if (!isValidFeatureId(featureId) || !isValidFeatureId(withFeatureId)) {
+        invalidCliArgs({
+          reason: 'Invalid feature id for collision override',
+          feature_id: featureId,
+          with_feature_id: withFeatureId,
+          expected_pattern: '^[a-z0-9_][a-z0-9_-]*$',
+        });
+      }
+
+      const result = await this.kernel.collisionOverrideAllow(
+        featureId,
+        withFeatureId,
+        reason,
+        options.resume_after_collision_override === true,
+        this.runId,
+      );
+
+      return {
+        ok: true,
+        data: {
+          command: 'collision',
+          action: 'allow',
+          ...result,
+        },
+      };
+    }
+
+    if (options.list) {
+      if (options.feature_id && !isValidFeatureId(options.feature_id)) {
+        invalidCliArgs({
+          reason: 'Invalid --feature-id value',
+          feature_id: options.feature_id,
+          expected_pattern: '^[a-z0-9_][a-z0-9_-]*$',
+        });
+      }
+
+      const overrides = await this.kernel.collisionOverrideList(options.feature_id);
+      return {
+        ok: true,
+        data: {
+          command: 'collision',
+          action: 'list',
+          overrides,
+        },
+      };
+    }
+
+    const overrideId = options.override_id?.trim();
+    if (!overrideId) {
+      invalidCliArgs({
+        reason: '--revoke requires --override-id',
+        expected: 'aop collision --revoke --override-id <override_id>',
+      });
+    }
+
+    const revoked = await this.kernel.collisionOverrideRevoke(overrideId, this.runId);
+    return {
+      ok: true,
+      data: {
+        command: 'collision',
+        action: 'revoke',
+        override: revoked,
+      },
+    };
+  }
+}