chati-dev 2.0.3 → 2.0.5

package/src/terminal/run-parallel.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+/**
+ * CLI runner for parallel agent terminal execution.
+ *
+ * Called by the orchestrator via the Bash tool to spawn multiple agents
+ * simultaneously in separate Claude Code processes.
+ *
+ * Usage:
+ *   node run-parallel.js --agents detail,architect,ux \
+ *     --task-ids expand-prd,architect-design,ux-wireframe \
+ *     --project-dir /path/to/project --previous-agent brief \
+ *     --timeout 900000
+ *
+ * Outputs consolidated JSON to stdout for the orchestrator to parse.
+ */
+
+import { fileURLToPath } from 'url';
+import { buildAgentPrompt } from './prompt-builder.js';
+import { spawnParallelGroup } from './spawner.js';
+import { TerminalMonitor } from './monitor.js';
+import { collectResults, mergeHandoffs, buildConsolidatedHandoff } from './collector.js';
+import { parseAgentOutput } from './handoff-parser.js';
+
+// ---------------------------------------------------------------------------
+// CLI argument parsing
+// ---------------------------------------------------------------------------
+
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith('--')) {
+        args[key] = next;
+        i++;
+      } else {
+        args[key] = 'true';
+      }
+    }
+  }
+  return args;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const args = parseArgs(process.argv);
+
+  if (!args.agents) {
+    outputError('Missing required argument: --agents (comma-separated)');
+    process.exit(1);
+  }
+  if (!args['task-ids']) {
+    outputError('Missing required argument: --task-ids (comma-separated)');
+    process.exit(1);
+  }
+
+  const agents = args.agents.split(',').map(s => s.trim());
+  const taskIds = args['task-ids'].split(',').map(s => s.trim());
+
+  if (agents.length !== taskIds.length) {
+    outputError(`Agent count (${agents.length}) must match task-id count (${taskIds.length})`);
+    process.exit(1);
+  }
+
+  const projectDir = args['project-dir'] || process.cwd();
+  const previousAgent = args['previous-agent'] || null;
+  const timeout = parseInt(args.timeout, 10) || 900_000; // default 15 minutes
+
+  // Load session state
+  let sessionState = {};
+  try {
+    const { existsSync, readFileSync } = await import('fs');
+    const { join } = await import('path');
+    const sessionPath = join(projectDir, '.chati', 'session.yaml');
+    if (existsSync(sessionPath)) {
+      const raw = readFileSync(sessionPath, 'utf-8');
+      // Minimal parse
+      sessionState = {};
+      for (const line of raw.split('\n')) {
+        const m = line.trim().match(/^([\w_-]+):\s*(.+)/);
+        if (m) sessionState[m[1]] = m[2].trim().replace(/^["']|["']$/g, '');
+      }
+    }
+  } catch { /* optional */ }
+
+  // Build prompts for all agents
+  const configs = [];
+  const startTime = Date.now();
+
+  for (let i = 0; i < agents.length; i++) {
+    try {
+      const promptResult = buildAgentPrompt({
+        agent: agents[i],
+        taskId: taskIds[i],
+        projectDir,
+        previousAgent,
+        sessionState,
+      });
+
+      configs.push({
+        agent: agents[i],
+        taskId: taskIds[i],
+        model: promptResult.model,
+        prompt: promptResult.prompt,
+        workingDir: projectDir,
+        timeout,
+      });
+    } catch (err) {
+      outputError(`Failed to build prompt for ${agents[i]}: ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  // Spawn all terminals in parallel
+  let group;
+  try {
+    group = spawnParallelGroup(configs);
+  } catch (err) {
+    outputError(`Failed to spawn parallel group: ${err.message}`);
+    process.exit(1);
+  }
+
+  // Monitor until completion
+  const monitor = new TerminalMonitor({ pollInterval: 2000, timeout });
+
+  for (const terminal of group.terminals) {
+    monitor.addTerminal(terminal);
+  }
+
+  await new Promise((resolve) => {
+    monitor.onComplete(() => {
+      monitor.stopMonitoring();
+      resolve();
+    });
+
+    // Safety timeout
+    const safetyTimer = setTimeout(() => {
+      monitor.stopMonitoring();
+      resolve();
+    }, timeout + 10_000);
+
+    monitor.onComplete(() => clearTimeout(safetyTimer));
+    monitor.startMonitoring();
+  });
+
+  const elapsed = Date.now() - startTime;
+
+  // Collect and merge results
+  const rawResults = collectResults(group.groupId, group.terminals);
+
+  // Parse handoffs from each terminal's stdout
+  const agentResults = rawResults.results.map(r => {
+    const parsed = parseAgentOutput(r.stdout);
+    return {
+      ...r,
+      handoff: parsed.found ? parsed.handoff : null,
+      handoffFound: parsed.found,
+    };
+  });
+
+  // Merge handoffs
+  const mergeInput = agentResults.map(r => ({
+    agent: r.agent,
+    status: r.handoff?.status || (r.exitCode === 0 ? 'complete' : 'failed'),
+    outputs: r.handoff?.outputs || [],
+    decisions: r.handoff?.decisions || {},
+    blockers: r.handoff?.blockers || [],
+    summary: r.handoff?.summary || '',
+  }));
+
+  const merged = mergeHandoffs(mergeInput);
+  const nextAgent = determineNextAgent(agents);
+  const consolidated = buildConsolidatedHandoff(merged, nextAgent);
+
+  // Output consolidated result
+  const output = {
+    status: rawResults.summary.failed === 0 ? 'complete' : 'partial',
+    groupId: group.groupId,
+    agents: agents.map((a, i) => ({
+      agent: a,
+      model: configs[i].model,
+      status: agentResults[i].handoff?.status || (agentResults[i].exitCode === 0 ? 'complete' : 'failed'),
+      score: agentResults[i].handoff?.score || null,
+      exitCode: agentResults[i].exitCode,
+      handoffFound: agentResults[i].handoffFound,
+    })),
+    mergedHandoff: consolidated,
+    summary: rawResults.summary,
+    elapsed,
+    performance: {
+      sequentialEstimate: elapsed * agents.length,
+      parallelActual: elapsed,
+      timeSaved: elapsed * (agents.length - 1),
+    },
+  };
+
+  process.stdout.write(JSON.stringify(output, null, 2) + '\n');
+  process.exit(rawResults.summary.failed > 0 ? 1 : 0);
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Determine the next sequential agent after a parallel group.
+ * GROUP 1 (detail+architect+ux) → phases
+ * GROUP 2 (dev tasks) → qa-implementation
+ */
+function determineNextAgent(agents) {
+  const groupKey = agents.sort().join(',');
+  if (groupKey.includes('architect') && groupKey.includes('detail') && groupKey.includes('ux')) {
+    return 'phases';
+  }
+  if (agents.every(a => a === 'dev')) {
+    return 'qa-implementation';
+  }
+  return null;
+}
+
+function outputError(message) {
+  process.stdout.write(JSON.stringify({ status: 'error', error: message }) + '\n');
+}
+
+// Guard pattern
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  main().catch(err => {
+    outputError(err.message);
+    process.exit(1);
+  });
+}
+
+export { parseArgs, determineNextAgent };

package/src/terminal/spawner.js

@@ -40,8 +40,10 @@ export function _resetCounter() {
 
 /**
  * @typedef {object} SpawnConfig
- * @property {string} agent       - Agent name (e.g. "architect")
- * @property {string} taskId      - Task identifier
+ * @property {string} agent           - Agent name (e.g. "architect")
+ * @property {string} taskId          - Task identifier
+ * @property {string} [model]         - LLM model (haiku/sonnet/opus)
+ * @property {string} [prompt]        - Full prompt string (from prompt-builder, piped via stdin)
  * @property {object} [contextPayload] - Context to inject via env var
  * @property {string[]} [writeScope]   - Override write scope
  * @property {string} [workingDir]     - Working directory for the process
@@ -54,6 +56,7 @@ export function _resetCounter() {
  * @property {object|null} process - child_process.ChildProcess (null when dry)
  * @property {string} agent      - Agent name
  * @property {string} taskId     - Task identifier
+ * @property {string} model      - Model used for this terminal
  * @property {string} startedAt  - ISO timestamp
  * @property {string} status     - "running" | "exited" | "killed"
  * @property {number|null} exitCode - Process exit code (null while running)
@@ -68,7 +71,7 @@ export function _resetCounter() {
  * perform any I/O and is therefore fully testable in isolation.
  *
  * @param {SpawnConfig} config
- * @returns {{ command: string, args: string[], env: Record<string, string> }}
+ * @returns {{ command: string, args: string[], env: Record<string, string>, terminalId: string, prompt: string|null }}
  */
 export function buildSpawnCommand(config) {
   if (!config || typeof config !== 'object') {
@@ -89,6 +92,7 @@ export function buildSpawnCommand(config) {
     CHATI_TERMINAL_ID: terminalId,
     CHATI_AGENT: config.agent,
     CHATI_TASK_ID: config.taskId,
+    CHATI_SPAWNED: 'true',
   };
 
   if (config.contextPayload) {
@@ -99,19 +103,18 @@ export function buildSpawnCommand(config) {
     }
   }
 
-  // Build the prompt that will be sent to claude CLI
-  const prompt = `Execute task ${config.taskId} as agent ${config.agent}. ` +
-    `Write scope: ${isolationEnv.CHATI_WRITE_SCOPE || 'none'}. ` +
-    `Terminal ID: ${terminalId}.`;
-
+  // Build CLI args — prompt is piped via stdin, NOT as a CLI argument
   const command = 'claude';
-  const args = [
-    '--print',
-    '--dangerously-skip-permissions',
-    prompt,
-  ];
+  const args = ['--print', '--dangerously-skip-permissions'];
+
+  if (config.model) {
+    args.push('--model', config.model);
+  }
 
-  return { command, args, env, terminalId };
+  // Prompt is returned separately for stdin piping (avoids ARG_MAX limits)
+  const prompt = config.prompt || null;
+
+  return { command, args, env, terminalId, prompt };
 }
 
 /**
@@ -121,7 +124,7 @@ export function buildSpawnCommand(config) {
  * @returns {TerminalHandle}
  */
 export function spawnTerminal(config) {
-  const { command, args, env, terminalId } = buildSpawnCommand(config);
+  const { command, args, env, terminalId, prompt } = buildSpawnCommand(config);
 
   const cwd = config.workingDir || process.cwd();
   const timeout = config.timeout || 300_000; // default 5 minutes
@@ -129,15 +132,22 @@ export function spawnTerminal(config) {
   const child = spawn(command, args, {
     cwd,
     env: { ...process.env, ...env },
-    stdio: ['ignore', 'pipe', 'pipe'],
+    stdio: ['pipe', 'pipe', 'pipe'],
   });
 
+  // Pipe prompt via stdin (avoids shell argument length limits)
+  if (prompt) {
+    child.stdin.write(prompt);
+  }
+  child.stdin.end();
+
   /** @type {TerminalHandle} */
   const handle = {
     id: terminalId,
     process: child,
     agent: config.agent,
     taskId: config.taskId,
+    model: config.model || 'sonnet',
     startedAt: new Date().toISOString(),
     status: 'running',
     exitCode: null,
@@ -250,11 +260,11 @@ export function killTerminal(handle) {
  * Return the current status snapshot of a terminal.
  *
  * @param {TerminalHandle} handle
- * @returns {{ id: string, agent: string, status: string, elapsed: number, exitCode: number|null }}
+ * @returns {{ id: string, agent: string, model: string, status: string, elapsed: number, exitCode: number|null }}
  */
 export function getTerminalStatus(handle) {
   if (!handle) {
-    return { id: 'unknown', agent: 'unknown', status: 'unknown', elapsed: 0, exitCode: null };
+    return { id: 'unknown', agent: 'unknown', model: 'unknown', status: 'unknown', elapsed: 0, exitCode: null };
   }
 
   const elapsed = Date.now() - new Date(handle.startedAt).getTime();
@@ -262,6 +272,7 @@ export function getTerminalStatus(handle) {
   return {
     id: handle.id,
     agent: handle.agent,
+    model: handle.model || 'unknown',
     status: handle.status,
     elapsed,
     exitCode: handle.exitCode,