chati-dev 2.0.4 → 2.0.6

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,

package/src/wizard/i18n.js

@@ -15,15 +15,13 @@ const FALLBACK_EN = {
     brownfield: 'Brownfield (existing project integration)',
     detected_brownfield: 'Detected package.json and src/ in current directory',
     suggestion_brownfield: 'Suggestion: Brownfield',
-    select_ides: 'Select IDE(s) for Chati.dev configuration:',
-    select_mcps: 'Select MCPs to install (project-level):',
     confirmation_title: 'Installation Summary',
     project_label: 'Project',
     language_label: 'Language',
     ides_label: 'IDEs',
     mcps_label: 'MCPs',
     will_install: 'Will install:',
-    agents_count: '13 agent definitions (CLARITY, BUILD, DEPLOY phases)',
+    agents_count: '13 agent definitions (PLANNING, BUILD, DEPLOY phases)',
     workflows_count: '5 workflow blueprints',
     templates_count: '5 templates (PRD, Brownfield PRD, Architecture, Task, QA Gate)',
     constitution: 'Constitution (17 Articles + Preamble)',

package/src/wizard/index.js

@@ -3,17 +3,18 @@ import { readFileSync } from 'fs';
 import { join, dirname, basename } from 'path';
 import { fileURLToPath } from 'url';
 import { logBanner } from '../utils/logger.js';
-import { stepLanguage, stepProjectType, stepIDEs, stepMCPs, stepConfirmation } from './questions.js';
+import { stepLanguage, stepProjectType, stepConfirmation } from './questions.js';
 import { createSpinner, showStep, showValidation, showQuickStart } from './feedback.js';
 import { installFramework } from '../installer/core.js';
 import { validateInstallation } from '../installer/validator.js';
 import { t } from './i18n.js';
+import { DEFAULT_MCPS } from '../config/mcp-configs.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf-8')).version;
 
 /**
- * Run the 6-step installer wizard
+ * Run the 4-step installer wizard
  */
 export async function runWizard(targetDir, options = {}) {
   // Load ASCII logo
@@ -34,13 +35,11 @@ export async function runWizard(targetDir, options = {}) {
   // Step 2: Project Type
   const projectType = options.projectType || await stepProjectType(targetDir);
 
-  // Step 3: IDE Selection
-  const selectedIDEs = options.ides || await stepIDEs();
+  // Auto-configured: Claude Code + default MCPs
+  const selectedIDEs = options.ides || ['claude-code'];
+  const selectedMCPs = options.mcps || DEFAULT_MCPS;
 
-  // Step 4: MCP Selection
-  const selectedMCPs = options.mcps || await stepMCPs(projectType);
-
-  // Step 5: Confirmation
+  // Step 3: Confirmation
   const projectName = basename(targetDir);
   const config = {
     projectName,
@@ -54,7 +53,7 @@ export async function runWizard(targetDir, options = {}) {
 
   await stepConfirmation(config);
 
-  // Step 6: Installation + Validation
+  // Step 4: Installation + Validation
   console.log();
   const installSpinner = createSpinner(t('installer.installing'));
   installSpinner.start();
@@ -71,10 +70,7 @@ export async function runWizard(targetDir, options = {}) {
     showStep(t('installer.created_claude_md'));
     showStep(t('installer.created_memories'));
     showStep(t('installer.installed_intelligence'));
-
-    if (selectedMCPs.length > 0) {
-      showStep(`${t('installer.configured_mcps')} ${selectedMCPs.join(', ')}`);
-    }
+    showStep(`${t('installer.configured_mcps')} ${selectedMCPs.join(', ')}`);
 
     // Validation
     console.log();
@@ -96,9 +92,8 @@ export async function runWizard(targetDir, options = {}) {
     console.log();
     p.outro(t('installer.success'));
 
-    const primaryIDE = selectedIDEs[0] || 'your IDE';
     showQuickStart(t('installer.quick_start_title'), [
-      `${t('installer.quick_start_1')} (${primaryIDE})`,
+      `${t('installer.quick_start_1')} (Claude Code)`,
       t('installer.quick_start_2'),
       t('installer.quick_start_3'),
     ]);

package/src/wizard/questions.js

@@ -1,10 +1,8 @@
 import * as p from '@clack/prompts';
 import { t, SUPPORTED_LANGUAGES, loadLanguage } from './i18n.js';
-import { getIDEChoices } from '../config/ide-configs.js';
-import { getMCPChoices, getMCPWarnings } from '../config/mcp-configs.js';
 import { detectProjectType } from '../utils/detector.js';
 import { showSummary, showChecklist } from './feedback.js';
-import { brand, dim, success, yellow } from '../utils/colors.js';
+import { brand, dim, success } from '../utils/colors.js';
 
 /**
  * Step 1: Language Selection (always in English)
@@ -60,77 +58,16 @@ export async function stepProjectType(targetDir) {
 }
 
 /**
- * Step 3: IDE Selection (Multi-select)
- */
-export async function stepIDEs() {
-  const ideChoices = getIDEChoices();
-
-  const selectedIDEs = await p.multiselect({
-    message: t('installer.select_ides'),
-    options: ideChoices.map(ide => ({
-      value: ide.value,
-      label: `${ide.label}  ${dim('--')} ${dim(ide.hint)}`,
-    })),
-    initialValues: ['claude-code'],
-    required: true,
-  });
-
-  if (p.isCancel(selectedIDEs)) {
-    p.cancel('Installation cancelled.');
-    process.exit(0);
-  }
-
-  return selectedIDEs;
-}
-
-/**
- * Step 4: MCP Selection (Multi-select)
- */
-export async function stepMCPs(projectType) {
-  const mcpChoices = getMCPChoices();
-
-  const selectedMCPs = await p.multiselect({
-    message: t('installer.select_mcps'),
-    options: mcpChoices.map(mcp => ({
-      value: mcp.value,
-      label: `${mcp.label}  ${dim('--')} ${dim(mcp.hint)}`,
-    })),
-    initialValues: mcpChoices.filter(m => m.initialValue).map(m => m.value),
-    required: false,
-  });
-
-  if (p.isCancel(selectedMCPs)) {
-    p.cancel('Installation cancelled.');
-    process.exit(0);
-  }
-
-  // Check for MCP warnings
-  const warnings = getMCPWarnings(projectType, selectedMCPs);
-  for (const warn of warnings) {
-    if (warn.level === 'critical') {
-      const continueAnyway = await p.confirm({
-        message: `${yellow('Warning:')} ${warn.message}\nContinue anyway?`,
-        initialValue: false,
-      });
-
-      if (p.isCancel(continueAnyway) || !continueAnyway) {
-        return stepMCPs(projectType); // Re-prompt
-      }
-    }
-  }
-
-  return selectedMCPs;
-}
-
-/**
- * Step 5: Confirmation
+ * Step 3: Confirmation
  */
 export async function stepConfirmation(config) {
-  const { projectName, projectType, language, selectedIDEs, selectedMCPs } = config;
+  const { projectName, projectType, language, selectedMCPs } = config;
 
   const langName = SUPPORTED_LANGUAGES.find(l => l.value === language)?.label || language;
-  const ideNames = selectedIDEs.join(', ');
-  const mcpNames = selectedMCPs.length > 0 ? selectedMCPs.join(', ') : 'None';
+  const ideNames = 'Claude Code (auto-configured)';
+  const mcpNames = selectedMCPs.length > 0
+    ? `${selectedMCPs.join(', ')} (auto-installed)`
+    : 'None';
 
   console.log();
   console.log(brand(t('installer.confirmation_title') + ':'));