agentic-orchestrator 0.1.2 → 0.1.4

package/apps/control-plane/src/core/tool-caller.ts

@@ -0,0 +1,36 @@
+export type RuntimeRole = 'orchestrator' | 'planner' | 'builder' | 'qa';
+
+export interface ToolCaller {
+  callTool<TData = Record<string, unknown>>(
+    role: RuntimeRole,
+    toolName: string,
+    args: Record<string, unknown>
+  ): Promise<{ ok: true; data: TData }>;
+}
+
+export interface FeatureStateFrontMatter {
+  version: number;
+  status: string;
+  cluster?: Record<string, string>;
+  gate_retry_count?: number;
+  last_retry_at?: string | null;
+  last_heartbeat_at?: string;
+  last_run_at?: string;
+  worktree_branch?: string;
+  branch?: string;
+  pr?: {
+    number: number;
+    url: string;
+    ci_status: string;
+    review_decision: string;
+    merge_ready: boolean;
+    pending_review_threads: number;
+    has_conflicts: boolean;
+    merge_score: number;
+  };
+}
+
+export interface FeatureStatePayload {
+  front_matter: FeatureStateFrontMatter;
+  body?: string;
+}

package/apps/control-plane/src/core/workspace-hooks.ts

@@ -0,0 +1,87 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { runCommand } from './git.js';
+
+export interface WorkspaceHookWarning {
+  kind: 'symlink' | 'post_create';
+  target: string;
+  message: string;
+  command?: string;
+  code?: number;
+  stderr?: string;
+}
+
+export function formatWorkspaceHookWarning(warning: WorkspaceHookWarning): string {
+  if (warning.kind === 'symlink') {
+    return `symlink ${warning.target}: ${warning.message}`;
+  }
+  const command = warning.command ?? warning.target;
+  const codeSegment = typeof warning.code === 'number' ? ` (exit ${warning.code})` : '';
+  const stderrSegment = warning.stderr ? ` stderr=${warning.stderr.trim()}` : '';
+  return `post_create "${command}"${codeSegment}: ${warning.message}${stderrSegment}`;
+}
+
+/**
+ * Creates symlinks in the worktree for each listed file, sourcing from the main repo root.
+ * Failures are non-fatal and do not block worktree creation.
+ */
+export async function applyWorktreeSymlinks(
+  repoRoot: string,
+  worktreePath: string,
+  symlinks: string[],
+  onWarning?: (warning: WorkspaceHookWarning) => void
+): Promise<void> {
+  for (const link of symlinks) {
+    const src = path.join(repoRoot, link);
+    const dst = path.join(worktreePath, link);
+    try {
+      await fs.mkdir(path.dirname(dst), { recursive: true });
+      await fs.symlink(src, dst);
+    } catch (error) {
+      onWarning?.({
+        kind: 'symlink',
+        target: link,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+}
+
+/**
+ * Runs post-create commands in the worktree directory.
+ * Each command string is split on whitespace into executable + args.
+ * Failures are non-fatal and do not block worktree creation.
+ */
+export async function runWorktreePostCreate(
+  worktreePath: string,
+  commands: string[],
+  onWarning?: (warning: WorkspaceHookWarning) => void
+): Promise<void> {
+  for (const cmd of commands) {
+    const parts = cmd.trim().split(/\s+/);
+    const [executable, ...args] = parts;
+    if (!executable) {
+      continue;
+    }
+    try {
+      const result = await runCommand(executable, args, { cwd: worktreePath });
+      if (result.code !== 0) {
+        onWarning?.({
+          kind: 'post_create',
+          target: cmd,
+          command: cmd,
+          message: 'command exited with non-zero status',
+          code: result.code,
+          stderr: result.stderr
+        });
+      }
+    } catch (error) {
+      onWarning?.({
+        kind: 'post_create',
+        target: cmd,
+        command: cmd,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+}

package/apps/control-plane/src/interfaces/cli/bootstrap.ts

@@ -1,18 +1,68 @@
 import crypto from 'node:crypto';
+import path from 'node:path';
+import readline from 'node:readline/promises';
 import { AopKernel } from '../../core/kernel.js';
+import { computeInstanceId, defaultConfigPath } from '../../application/services/instance-isolation-service.js';
 import { ERROR_CODES } from '../../core/error-codes.js';
 import type { AppError } from '../../providers/providers.js';
 import { createToolingRuntime, resolveToolClient } from '../../mcp/runtime-factory.js';
 import { CliArgumentParser } from '../../cli/cli-argument-parser.js';
+import { CliCommand } from '../../cli/types.js';
 import { printError, printPayload } from '../../cli/io.js';
 import { StatusCommandHandler } from '../../cli/status-command-handler.js';
 import { ResumeCommandHandler } from '../../cli/resume-command-handler.js';
 import { StopCommandHandler } from '../../cli/stop-command-handler.js';
 import { DeleteCommandHandler } from '../../cli/delete-command-handler.js';
+import { CleanupCommandHandler } from '../../cli/cleanup-command-handler.js';
 import { RunCommandHandler } from '../../cli/run-command-handler.js';
+import { InitCommandHandler } from '../../cli/init-command-handler.js';
+import { DashboardCommandHandler } from '../../cli/dashboard-command-handler.js';
+import { RetryCommandHandler } from '../../cli/retry-command-handler.js';
+import { SendCommandHandler } from '../../cli/send-command-handler.js';
+import { AttachCommandHandler } from '../../cli/attach-command-handler.js';
+import { HelpCommandHandler } from '../../cli/help-command-handler.js';
+import { MultiProjectLoader } from '../../application/multi-project-loader.js';
+import { NullWorkerProvider, resolveProviderSelection } from '../../providers/providers.js';
 import type { RuntimeContext } from '../../cli/types.js';
+import type { ProjectConfig } from '../../application/multi-project-loader.js';
 
-const SUPPORTED_COMMANDS = new Set(['run', 'status', 'resume', 'stop', 'delete']);
+const SUPPORTED_COMMANDS = new Set<string>(Object.values(CliCommand));
+
+function isPathWithin(parent: string, target: string): boolean {
+  const relative = path.relative(path.resolve(parent), path.resolve(target));
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function selectProjectByCwd(projects: ProjectConfig[], cwd: string): ProjectConfig | null {
+  const matches = projects.filter((project) => isPathWithin(project.path, cwd));
+  if (matches.length === 1) {
+    return matches[0];
+  }
+  return null;
+}
+
+async function promptForProjectSelection(projects: ProjectConfig[]): Promise<string | null> {
+  const sorted = [...projects].sort((a, b) => a.name.localeCompare(b.name));
+  process.stdout.write('Multiple projects configured. Select one:\n');
+  for (let index = 0; index < sorted.length; index += 1) {
+    const project = sorted[index];
+    process.stdout.write(`  ${index + 1}. ${project.name} (${project.path})\n`);
+  }
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = await rl.question('Project number: ');
+    const numeric = Number.parseInt(answer.trim(), 10);
+    if (!Number.isFinite(numeric) || numeric < 1 || numeric > sorted.length) {
+      return null;
+    }
+    return sorted[numeric - 1].name;
+  } finally {
+    rl.close();
+  }
+}
 
 export async function runCli(
   argv: string[] = process.argv.slice(2),
@@ -20,7 +70,73 @@ export async function runCli(
 ): Promise<number> {
   const parser = new CliArgumentParser();
   const options = parser.parse(argv);
-  const repoRoot = runtime.cwd;
+
+  const multiLoader = new MultiProjectLoader();
+  const multiConfig = await multiLoader.load(runtime.cwd);
+
+  // Resolve repo root and project context.
+  let repoRoot = runtime.cwd;
+  let selectedProject: ProjectConfig | null = null;
+
+  if (options.project) {
+    if (!multiConfig) {
+      printError(ERROR_CODES.INVALID_CLI_ARGS, 'No multi-project.yaml found; cannot use --project', {
+        project: options.project
+      });
+      return 1;
+    }
+    selectedProject = multiLoader.getProject(multiConfig, options.project);
+    if (!selectedProject) {
+      printError(ERROR_CODES.INVALID_CLI_ARGS, `Project not found: ${options.project}`, {
+        project: options.project,
+        available: multiConfig.projects.map((p) => p.name)
+      });
+      return 1;
+    }
+    repoRoot = selectedProject.path;
+  } else if (multiConfig && !options.all && options.command !== CliCommand.Init) {
+    if (multiConfig.projects.length === 1) {
+      selectedProject = multiConfig.projects[0];
+      repoRoot = selectedProject.path;
+    } else {
+      const cwdSelection = selectProjectByCwd(multiConfig.projects, runtime.cwd);
+      if (cwdSelection) {
+        selectedProject = cwdSelection;
+        repoRoot = selectedProject.path;
+      } else {
+        const defaultProjectName = multiConfig.defaults?.default_project;
+        const defaultProject =
+          typeof defaultProjectName === 'string' && defaultProjectName.length > 0
+            ? multiLoader.getProject(multiConfig, defaultProjectName)
+            : null;
+        if (defaultProject) {
+          selectedProject = defaultProject;
+          repoRoot = selectedProject.path;
+        } else if (process.stdin.isTTY && process.stdout.isTTY) {
+          const selectedName = await promptForProjectSelection(multiConfig.projects);
+          if (!selectedName) {
+            printError(ERROR_CODES.INVALID_CLI_ARGS, 'Invalid project selection', {
+              available_projects: multiConfig.projects.map((p) => p.name)
+            });
+            return 1;
+          }
+          selectedProject = multiLoader.getProject(multiConfig, selectedName);
+          if (!selectedProject) {
+            printError(ERROR_CODES.INVALID_CLI_ARGS, 'Selected project was not found in configuration', {
+              selected_project: selectedName
+            });
+            return 1;
+          }
+          repoRoot = selectedProject.path;
+        } else {
+          printError(ERROR_CODES.INVALID_CLI_ARGS, 'Multiple projects configured; --project is required', {
+            available_projects: multiConfig.projects.map((p) => p.name)
+          });
+          return 1;
+        }
+      }
+    }
+  }
 
   try {
     if (!SUPPORTED_COMMANDS.has(options.command)) {
@@ -30,23 +146,116 @@ export async function runCli(
       return 1;
     }
 
+    if (options.command === CliCommand.Help) {
+      // The next argv token (if any) is the subcommand to explain
+      const subcommand = argv.find((a) => !a.startsWith('-') && a !== CliCommand.Help);
+      const handler = new HelpCommandHandler();
+      const payload = handler.execute(subcommand);
+      process.stdout.write(payload.data.help + '\n');
+      return 0;
+    }
+
+    if (options.command === CliCommand.Init) {
+      const handler = new InitCommandHandler(repoRoot);
+      const payload = await handler.execute({ auto: options.auto, force: options.force });
+      printPayload(payload);
+      return 0;
+    }
+
+    if (options.command === CliCommand.Dashboard) {
+      const handler = new DashboardCommandHandler();
+      const defaultDashboardPort = selectedProject?.dashboard_port ?? multiConfig?.defaults?.dashboard_port;
+      const payload = await handler.execute({
+        port: options.port ?? defaultDashboardPort,
+        foreground: options.foreground,
+        dev: options.dev
+      });
+      printPayload(payload);
+      return 0;
+    }
+
     const transport = parser.resolveTransport(options.transport);
     const runId = `run:${crypto.randomUUID()}`;
 
-    const kernel = new AopKernel(repoRoot);
+    // Handle --all for status: aggregate across all projects in multi-project.yaml
+    if (options.command === CliCommand.Status && options.all) {
+      if (!multiConfig) {
+        // No multi-project.yaml — fall through to normal single-project status below
+      } else {
+        const projectStatuses: Array<{ name: string; path: string; status: unknown }> = [];
+        for (const project of multiConfig.projects) {
+          try {
+            const projectPolicyPath = multiLoader.resolveProjectPolicyPath(multiConfig, project);
+            const projectGatesPath = multiLoader.resolveProjectGatesPath(multiConfig, project);
+            const projectKernel = new AopKernel(project.path, computeInstanceId(defaultConfigPath(project.path)), {
+              policyPath: projectPolicyPath,
+              gatesPath: projectGatesPath
+            });
+            await projectKernel.ensureLoaded();
+            const projectTooling = await createToolingRuntime(project.path, projectKernel);
+            const projectToolClient = resolveToolClient(transport, projectTooling);
+            const projectHandler = new StatusCommandHandler(projectToolClient, runId);
+            const projectStatus = await projectHandler.execute({ summary: options.summary });
+            projectStatuses.push({ name: project.name, path: project.path, status: projectStatus });
+          } catch (err) {
+            const typed = err as AppError;
+            projectStatuses.push({
+              name: project.name,
+              path: project.path,
+              status: { ok: false, error: { code: typed.code ?? ERROR_CODES.INTERNAL_ERROR, message: typed.message } }
+            });
+          }
+        }
+        const payload = { ok: true, data: { projects: projectStatuses } };
+        printPayload(payload);
+        return 0;
+      }
+    }
+
+    const selectedPolicyPath =
+      selectedProject && multiConfig ? multiLoader.resolveProjectPolicyPath(multiConfig, selectedProject) : undefined;
+    const selectedGatesPath =
+      selectedProject && multiConfig ? multiLoader.resolveProjectGatesPath(multiConfig, selectedProject) : undefined;
+
+    const instanceId = computeInstanceId(defaultConfigPath(repoRoot));
+    const kernel = new AopKernel(repoRoot, instanceId, {
+      policyPath: selectedPolicyPath,
+      gatesPath: selectedGatesPath
+    });
     await kernel.ensureLoaded();
 
     const tooling = await createToolingRuntime(repoRoot, kernel);
     const toolClient = resolveToolClient(transport, tooling);
 
-    if (options.command === 'status') {
+    let commandProvider: NullWorkerProvider | null = null;
+    if (options.command === CliCommand.Send || options.command === CliCommand.Attach) {
+      let selection;
+      try {
+        selection = resolveProviderSelection({
+          cli: options as unknown as Record<string, string | undefined>,
+          env: runtime.env,
+          agentsConfig: kernel.getAgentsConfig()
+        });
+      } catch {
+        selection = {
+          provider: 'custom',
+          model: 'custom-default',
+          provider_config_env: null,
+          provider_config_ref: null
+        };
+      }
+      commandProvider = new NullWorkerProvider(selection);
+      kernel.setProvider(commandProvider);
+    }
+
+    if (options.command === CliCommand.Status) {
       const handler = new StatusCommandHandler(toolClient, runId);
-      const payload = await handler.execute();
+      const payload = await handler.execute({ summary: options.summary });
       printPayload(payload);
       return 0;
     }
 
-    if (options.command === 'resume') {
+    if (options.command === CliCommand.Resume) {
       const handler = new ResumeCommandHandler();
       const payload = await handler.execute({
         repoRoot,
@@ -61,20 +270,58 @@ export async function runCli(
       return 0;
     }
 
-    if (options.command === 'stop') {
+    if (options.command === CliCommand.Stop) {
       const handler = new StopCommandHandler();
       const payload = await handler.execute();
       printPayload(payload);
       return 0;
     }
 
-    if (options.command === 'delete') {
+    if (options.command === CliCommand.Delete) {
       const handler = new DeleteCommandHandler(toolClient, runId);
       const payload = await handler.execute(options);
       printPayload(payload);
       return 0;
     }
 
+    if (options.command === CliCommand.Cleanup) {
+      const policySnapshot = kernel.getPolicySnapshot() as {
+        cleanup?: { grace_period_seconds?: number; auto_after_merge?: boolean };
+      };
+      const gracePeriodSeconds = policySnapshot.cleanup?.grace_period_seconds;
+      const autoAfterMerge = policySnapshot.cleanup?.auto_after_merge === true;
+      const handler = new CleanupCommandHandler(toolClient, runId, repoRoot, gracePeriodSeconds, autoAfterMerge);
+      const payload = await handler.execute(options);
+      printPayload(payload);
+      return 0;
+    }
+
+    if (options.command === CliCommand.Retry) {
+      const handler = new RetryCommandHandler(toolClient, runId);
+      const payload = await handler.execute(options);
+      printPayload(payload);
+      return 0;
+    }
+
+    if (options.command === CliCommand.Send) {
+      const handler = new SendCommandHandler(toolClient, runId);
+      const payload = await handler.execute(options);
+      printPayload(payload);
+      return 0;
+    }
+
+    if (options.command === CliCommand.Attach) {
+      if (!commandProvider) {
+        const error = new Error('attach provider was not initialized') as AppError;
+        error.code = ERROR_CODES.INTERNAL_ERROR;
+        throw error;
+      }
+      const handler = new AttachCommandHandler(toolClient, runId, kernel, commandProvider);
+      const payload = await handler.execute(options);
+      printPayload(payload);
+      return 0;
+    }
+
     const handler = new RunCommandHandler();
     const payload = await handler.execute({
       repoRoot,
@@ -83,7 +330,9 @@ export async function runCli(
       transport,
       options,
       kernel,
-      toolClient
+      toolClient,
+      maxActiveFeatures: multiConfig?.defaults?.max_active_features ?? undefined,
+      maxParallelGateRuns: multiConfig?.defaults?.max_parallel_gate_runs ?? undefined
     });
     printPayload(payload);
     return 0;