chati-dev 2.1.2 → 3.0.1

package/src/terminal/cli-registry.js

@@ -0,0 +1,190 @@
+/**
+ * @fileoverview CLI Provider Registry for multi-CLI agent execution.
+ *
+ * Central registry of all supported CLI providers with their capabilities,
+ * command syntax, model maps, and feature support. This is the source of
+ * truth for multi-CLI governance (Constitution Article XIX).
+ */
+
+import * as adapters from './adapters/index.js';
+import { parseProviderConfig, parseAgentOverride } from '../utils/config-parser.js';
+
+// ---------------------------------------------------------------------------
+// Provider Definitions
+// ---------------------------------------------------------------------------
+
+/**
+ * @typedef {object} ProviderConfig
+ * @property {string} name - Provider identifier
+ * @property {string} command - CLI command name
+ * @property {string[]} baseArgs - Default CLI arguments for non-interactive mode
+ * @property {string} modelFlag - CLI flag for model selection
+ * @property {boolean} stdinSupport - Whether prompts can be piped via stdin
+ * @property {boolean} hooksSupport - Whether the CLI supports hooks (event middleware)
+ * @property {boolean} mcpSupport - Whether the CLI supports MCP servers
+ * @property {string|null} contextFile - Project context file name (CLAUDE.md, GEMINI.md, etc.)
+ * @property {Record<string, string>} modelMap - Tier-to-model-id mapping
+ * @property {object} adapter - CLI-specific adapter module
+ */
+
+/** @type {Record<string, ProviderConfig>} */
+const PROVIDERS = {
+  claude: {
+    name: 'claude',
+    command: 'claude',
+    baseArgs: ['--print', '--dangerously-skip-permissions'],
+    modelFlag: '--model',
+    stdinSupport: true,
+    hooksSupport: true,
+    mcpSupport: true,
+    contextFile: 'CLAUDE.md',
+    modelMap: {
+      opus: 'claude-opus-4-6',
+      sonnet: 'claude-sonnet-4-5-20250929',
+      haiku: 'claude-haiku-4-5-20251001',
+    },
+    adapter: adapters.claude,
+  },
+  gemini: {
+    name: 'gemini',
+    command: 'gemini',
+    baseArgs: [],
+    modelFlag: '--model',
+    stdinSupport: true,
+    hooksSupport: false,
+    mcpSupport: true,
+    contextFile: 'GEMINI.md',
+    modelMap: {
+      pro: 'gemini-2.5-pro',
+      flash: 'gemini-2.5-flash',
+    },
+    adapter: adapters.gemini,
+  },
+  codex: {
+    name: 'codex',
+    command: 'codex',
+    baseArgs: ['exec'],
+    modelFlag: '-m',
+    stdinSupport: true,
+    hooksSupport: false,
+    mcpSupport: true,
+    contextFile: 'AGENTS.md',
+    modelMap: {
+      codex: 'gpt-5.3-codex',
+      mini: 'codex-mini-latest',
+    },
+    adapter: adapters.codex,
+  },
+  copilot: {
+    name: 'copilot',
+    command: 'copilot',
+    baseArgs: ['-p'],
+    modelFlag: '--model',
+    stdinSupport: true,
+    hooksSupport: false,
+    mcpSupport: true,
+    contextFile: null,
+    modelMap: {
+      'claude-sonnet': 'claude-sonnet-4.5',
+      'gpt-5': 'gpt-5',
+    },
+    adapter: adapters.copilot,
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Provider Resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Get a provider configuration by name.
+ *
+ * @param {string} name - Provider name (claude, gemini, codex, copilot)
+ * @returns {ProviderConfig}
+ * @throws {Error} When provider is not found
+ */
+export function getProvider(name) {
+  const provider = PROVIDERS[name];
+  if (!provider) {
+    throw new Error(`Unknown CLI provider: "${name}". Available: ${Object.keys(PROVIDERS).join(', ')}`);
+  }
+  return provider;
+}
+
+/**
+ * Get all registered providers.
+ *
+ * @returns {Record<string, ProviderConfig>}
+ */
+export function getAllProviders() {
+  return { ...PROVIDERS };
+}
+
+/**
+ * Load enabled providers from project config.yaml.
+ *
+ * @param {string} projectDir - Project root directory
+ * @returns {{ primary: string, enabled: string[] }}
+ */
+export function loadEnabledProviders(projectDir) {
+  const { primary, enabled } = parseProviderConfig(projectDir);
+  return { primary, enabled };
+}
+
+/**
+ * Resolve which provider should be used for a given agent.
+ * Priority: agent_overrides > agent default > primary provider.
+ *
+ * @param {string} agent - Agent name
+ * @param {string} projectDir - Project root directory
+ * @param {Record<string, {provider: string, model: string, tier: string}>} agentModels - Agent model assignments
+ * @returns {{ provider: string, model: string }}
+ */
+export function resolveProviderForAgent(agent, projectDir, agentModels) {
+  const { primary, enabled } = loadEnabledProviders(projectDir);
+
+  // Check agent_overrides in config.yaml (block-style YAML)
+  const { raw } = parseProviderConfig(projectDir);
+  if (raw) {
+    const override = parseAgentOverride(raw, agent);
+    if (override && enabled.includes(override.provider)) {
+      return override;
+    }
+  }
+
+  // Use agent's default assignment
+  const agentConfig = agentModels[agent];
+  if (agentConfig) {
+    const agentProvider = agentConfig.provider || primary;
+    if (enabled.includes(agentProvider)) {
+      return { provider: agentProvider, model: agentConfig.model };
+    }
+  }
+
+  // Fallback to primary provider with its default light-tier model
+  const provider = PROVIDERS[primary];
+  const defaultModel = provider ? Object.keys(provider.modelMap)[0] : 'sonnet';
+  return { provider: primary, model: defaultModel };
+}
+
+/**
+ * Check if a provider CLI is available on the system.
+ *
+ * @param {string} name - Provider name
+ * @returns {Promise<boolean>}
+ */
+export async function isProviderAvailable(name) {
+  const provider = PROVIDERS[name];
+  if (!provider) return false;
+
+  const { execFileSync } = await import('child_process');
+  try {
+    const cmd = process.platform === 'win32' ? 'where' : 'which';
+    execFileSync(cmd, [provider.command], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export { PROVIDERS };

package/src/terminal/prompt-builder.js

@@ -14,24 +14,10 @@ import { runPrism } from '../context/engine.js';
 import { loadHandoff, formatHandoff } from '../tasks/handoff.js';
 import { getWriteScope } from './isolation.js';
 
-// Re-read at import time so the prompt builder always uses the correct map
-// without circular dependency issues (the hook file runs main() on import
-// which writes to stdout — we only need the data, so we inline the map).
-const AGENT_MODELS = {
-  orchestrator: 'sonnet',
-  'greenfield-wu': 'haiku',
-  'brownfield-wu': 'opus',
-  brief: 'sonnet',
-  detail: 'opus',
-  architect: 'opus',
-  ux: 'sonnet',
-  phases: 'sonnet',
-  tasks: 'sonnet',
-  'qa-planning': 'opus',
-  'qa-implementation': 'opus',
-  dev: 'opus',
-  devops: 'sonnet',
-};
+// Import DEFAULT_AGENT_MODELS from model-governance (safe — named export,
+// does not trigger main() which is guarded by fileURLToPath check).
+import { DEFAULT_AGENT_MODELS } from '../../framework/hooks/model-governance.js';
+const AGENT_MODELS = DEFAULT_AGENT_MODELS;
 
 /**
  * Map of agent names to their definition file paths (relative to project root).
@@ -116,11 +102,13 @@ export function buildAgentPrompt(config) {
   sections.push(buildOutputInstructions());
 
   const prompt = sections.join('\n\n---\n\n');
-  const model = AGENT_MODELS[config.agent] || 'sonnet';
+  const assignment = AGENT_MODELS[config.agent] || { provider: 'claude', model: 'sonnet', tier: 'sonnet' };
+  const model = assignment.model || assignment;
 
   return {
     prompt,
     model,
+    provider: assignment.provider || 'claude',
     metadata: {
       agent: config.agent,
       layers: prismResult.layerCount || 0,
@@ -266,7 +254,8 @@ function buildSessionSection(config) {
     `- **User Level**: ${state.user_level || 'auto'}`,
     `- **Execution Mode**: ${state.execution_mode || 'autonomous'}`,
     `- **Your Agent**: ${config.agent}`,
-    `- **Your Model**: ${AGENT_MODELS[config.agent] || 'sonnet'}`,
+    `- **Your Model**: ${(AGENT_MODELS[config.agent]?.model) || 'sonnet'}`,
+    `- **Your Provider**: ${(AGENT_MODELS[config.agent]?.provider) || 'claude'}`,
   ];
 
   return lines.join('\n');

package/src/terminal/run-agent.js

@@ -160,7 +160,8 @@ async function main() {
 function waitForExit(handle, timeout) {
   return new Promise((resolve, reject) => {
     if (handle.status === 'exited') {
-      return resolve();
+      resolve();
+      return;
     }
 
     const timer = setTimeout(() => {

package/src/terminal/spawner.js

@@ -9,6 +9,7 @@
 
 import { spawn } from 'child_process';
 import { validateWriteScopes, buildIsolationEnv } from './isolation.js';
+import { getProvider } from './cli-registry.js';
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -42,7 +43,8 @@ export function _resetCounter() {
  * @typedef {object} SpawnConfig
  * @property {string} agent           - Agent name (e.g. "architect")
  * @property {string} taskId          - Task identifier
- * @property {string} [model]         - LLM model (haiku/sonnet/opus)
+ * @property {string} [model]         - LLM model tier name (e.g. opus, pro, codex, claude-sonnet)
+ * @property {string} [provider]      - CLI provider name (claude, gemini, codex, copilot)
  * @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
@@ -103,17 +105,29 @@ export function buildSpawnCommand(config) {
     }
   }
 
-  // Build CLI args — prompt is piped via stdin, NOT as a CLI argument
-  const command = 'claude';
-  const args = ['--print', '--dangerously-skip-permissions'];
-
-  if (config.model) {
-    args.push('--model', config.model);
+  // Resolve CLI provider — defaults to claude for backwards compatibility
+  const providerName = config.provider || 'claude';
+  let command, args, prompt;
+
+  try {
+    const provider = getProvider(providerName);
+    const adapterResult = provider.adapter.buildCommand(config, provider);
+    command = adapterResult.command;
+    args = adapterResult.args;
+    prompt = adapterResult.stdinPrompt;
+  } catch (err) {
+    // Fallback to claude if provider resolution fails (backwards compatibility)
+    console.error(`[chati] Provider "${providerName}" resolution failed: ${err.message}. Falling back to claude.`);
+    command = 'claude';
+    args = ['--print', '--dangerously-skip-permissions'];
+    if (config.model) {
+      const claudeProvider = getProvider('claude');
+      const resolvedModel = claudeProvider.modelMap[config.model] || config.model;
+      args.push('--model', resolvedModel);
+    }
+    prompt = config.prompt || null;
   }
 
-  // Prompt is returned separately for stdin piping (avoids ARG_MAX limits)
-  const prompt = config.prompt || null;
-
   return { command, args, env, terminalId, prompt };
 }
 
@@ -147,7 +161,7 @@ export function spawnTerminal(config) {
     process: child,
     agent: config.agent,
     taskId: config.taskId,
-    model: config.model || 'sonnet',
+    model: config.model || 'unknown',
     startedAt: new Date().toISOString(),
     status: 'running',
     exitCode: null,
@@ -156,15 +170,20 @@ export function spawnTerminal(config) {
     timeout,
   };
 
-  // Capture output
+  // Capture output (capped at ~10MB to prevent unbounded memory growth)
+  const MAX_BUFFER_CHUNKS = 10_000;
   if (child.stdout) {
     child.stdout.on('data', (chunk) => {
-      handle.stdout.push(chunk.toString());
+      if (handle.stdout.length < MAX_BUFFER_CHUNKS) {
+        handle.stdout.push(chunk.toString());
+      }
     });
   }
   if (child.stderr) {
     child.stderr.on('data', (chunk) => {
-      handle.stderr.push(chunk.toString());
+      if (handle.stderr.length < MAX_BUFFER_CHUNKS) {
+        handle.stderr.push(chunk.toString());
+      }
     });
   }
 
@@ -179,6 +198,17 @@ export function spawnTerminal(config) {
     handle.stderr.push(`spawn error: ${err.message}`);
   });
 
+  // Enforce timeout — kill process if it exceeds max execution time
+  const timeoutTimer = setTimeout(() => {
+    if (handle.status === 'running') {
+      handle.stderr.push(`timeout: process exceeded ${timeout}ms limit`);
+      killTerminal(handle);
+    }
+  }, timeout);
+
+  // Clear timer when process exits normally
+  child.on('exit', () => clearTimeout(timeoutTimer));
+
   return handle;
 }
 

package/src/terminal/wave-analyzer.js

@@ -0,0 +1,143 @@
+/**
+ * @fileoverview Wave analyzer for task parallelization.
+ *
+ * Analyzes task dependencies to group them into waves —
+ * sets of tasks that can execute in parallel because they
+ * have no inter-dependencies.
+ */
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/**
+ * @typedef {object} TaskNode
+ * @property {string} id - Task identifier
+ * @property {string[]} dependencies - IDs of tasks this depends on
+ * @property {string[]} [writeScope] - Files/dirs this task writes to
+ */
+
+/**
+ * @typedef {object} Wave
+ * @property {number} index - Wave number (0-based)
+ * @property {string[]} taskIds - Task IDs in this wave
+ */
+
+// ---------------------------------------------------------------------------
+// Wave Analysis
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a dependency graph and compute waves using topological sorting.
+ *
+ * @param {TaskNode[]} tasks - Array of tasks with dependencies
+ * @returns {Wave[]}
+ * @throws {Error} When circular dependencies are detected
+ */
+export function analyzeWaves(tasks) {
+  if (!tasks || tasks.length === 0) return [];
+
+  const taskMap = new Map(tasks.map((t) => [t.id, t]));
+  const inDegree = new Map();
+  const adjList = new Map();
+
+  // Initialize
+  for (const task of tasks) {
+    inDegree.set(task.id, 0);
+    adjList.set(task.id, []);
+  }
+
+  // Build adjacency and in-degree
+  for (const task of tasks) {
+    for (const dep of task.dependencies || []) {
+      if (taskMap.has(dep)) {
+        adjList.get(dep).push(task.id);
+        inDegree.set(task.id, (inDegree.get(task.id) || 0) + 1);
+      }
+    }
+  }
+
+  // Kahn's algorithm with wave grouping
+  const waves = [];
+  const remaining = new Set(tasks.map((t) => t.id));
+
+  while (remaining.size > 0) {
+    // Find all tasks with no pending dependencies (in-degree 0)
+    const wave = [];
+    for (const id of remaining) {
+      if ((inDegree.get(id) || 0) === 0) {
+        wave.push(id);
+      }
+    }
+
+    if (wave.length === 0) {
+      const circular = [...remaining].join(', ');
+      throw new Error(`Circular dependency detected among tasks: ${circular}`);
+    }
+
+    waves.push({ index: waves.length, taskIds: wave });
+
+    // Remove wave tasks and update in-degrees
+    for (const id of wave) {
+      remaining.delete(id);
+      for (const dependent of adjList.get(id) || []) {
+        inDegree.set(dependent, (inDegree.get(dependent) || 0) - 1);
+      }
+    }
+  }
+
+  return waves;
+}
+
+/**
+ * Validate that tasks within a wave don't have write scope conflicts.
+ *
+ * @param {TaskNode[]} tasks - All tasks
+ * @param {Wave} wave - Wave to validate
+ * @returns {{ valid: boolean, conflicts: { taskA: string, taskB: string, path: string }[] }}
+ */
+export function validateWaveScopes(tasks, wave) {
+  const taskMap = new Map(tasks.map((t) => [t.id, t]));
+  const conflicts = [];
+
+  const waveTasks = wave.taskIds.map((id) => taskMap.get(id)).filter(Boolean);
+
+  for (let i = 0; i < waveTasks.length; i++) {
+    for (let j = i + 1; j < waveTasks.length; j++) {
+      const scopeA = waveTasks[i].writeScope || [];
+      const scopeB = waveTasks[j].writeScope || [];
+
+      for (const pathA of scopeA) {
+        for (const pathB of scopeB) {
+          if (pathA === pathB || pathA.startsWith(pathB + '/') || pathB.startsWith(pathA + '/')) {
+            conflicts.push({
+              taskA: waveTasks[i].id,
+              taskB: waveTasks[j].id,
+              path: pathA,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  return { valid: conflicts.length === 0, conflicts };
+}
+
+/**
+ * Get a summary of the wave analysis.
+ *
+ * @param {Wave[]} waves
+ * @returns {{ totalWaves: number, totalTasks: number, maxParallel: number, sequential: boolean }}
+ */
+export function getWaveSummary(waves) {
+  const totalTasks = waves.reduce((sum, w) => sum + w.taskIds.length, 0);
+  const maxParallel = Math.max(...waves.map((w) => w.taskIds.length), 0);
+
+  return {
+    totalWaves: waves.length,
+    totalTasks,
+    maxParallel,
+    sequential: waves.every((w) => w.taskIds.length === 1),
+  };
+}

package/src/utils/config-parser.js

@@ -0,0 +1,97 @@
+/**
+ * @fileoverview Shared YAML config parser for provider configuration.
+ *
+ * Extracts provider enabled/primary status and agent overrides from
+ * config.yaml using lightweight regex-based parsing. Used by
+ * cli-registry.js, context-file-generator.js, and health/engine.js.
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Parse provider configuration from config.yaml.
+ *
+ * @param {string} projectDir - Project root directory
+ * @returns {{ primary: string, enabled: string[], raw: string|null }}
+ */
+export function parseProviderConfig(projectDir) {
+  const configPath = join(projectDir, 'chati.dev', 'config.yaml');
+  if (!existsSync(configPath)) {
+    return { primary: 'claude', enabled: ['claude'], raw: null };
+  }
+
+  const raw = readFileSync(configPath, 'utf-8');
+  const providers = ['claude', 'gemini', 'codex', 'copilot'];
+  const enabled = [];
+  let primary = 'claude';
+
+  for (const name of providers) {
+    const enabledMatch = raw.match(new RegExp(`${name}:[\\s\\S]*?enabled:\\s*(true|false)`, 'm'));
+    if (enabledMatch && enabledMatch[1] === 'true') {
+      enabled.push(name);
+    }
+    const primaryMatch = raw.match(new RegExp(`${name}:[\\s\\S]*?primary:\\s*(true|false)`, 'm'));
+    if (primaryMatch && primaryMatch[1] === 'true') {
+      primary = name;
+    }
+  }
+
+  // Claude is always enabled as fallback
+  if (!enabled.includes('claude')) {
+    enabled.unshift('claude');
+  }
+
+  return { primary, enabled, raw };
+}
+
+/**
+ * Parse agent override block from config.yaml.
+ *
+ * @param {string} raw - Raw config.yaml content
+ * @param {string} agent - Agent name
+ * @returns {{ provider: string, model: string }|null}
+ */
+export function parseAgentOverride(raw, agent) {
+  const escaped = agent.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const overrideBlock = raw.match(new RegExp(`^\\s+${escaped}:\\s*\\n((?:\\s+\\w+:.*\\n?)*)`, 'm'));
+  if (!overrideBlock) return null;
+
+  const block = overrideBlock[1];
+  const providerMatch = block.match(/provider:\s*(\S+)/);
+  const modelMatch = block.match(/model:\s*(\S+)/);
+
+  if (providerMatch && modelMatch) {
+    return { provider: providerMatch[1], model: modelMatch[1] };
+  }
+  return null;
+}
+
+/**
+ * Get list of enabled non-Claude providers.
+ *
+ * @param {string} projectDir - Project root directory
+ * @returns {string[]} List of enabled provider names (excludes claude)
+ */
+export function getEnabledNonClaudeProviders(projectDir) {
+  const { enabled } = parseProviderConfig(projectDir);
+  return enabled.filter(p => p !== 'claude');
+}
+
+/**
+ * Check if a CLI command is available on the system.
+ * Cross-platform: uses 'which' on Unix, 'where' on Windows.
+ *
+ * @param {string} command - CLI command name
+ * @returns {Promise<boolean>}
+ */
+export async function isCommandAvailable(command) {
+  const { execFileSync } = await import('child_process');
+  try {
+    const cmd = process.platform === 'win32' ? 'where' : 'which';
+    execFileSync(cmd, [command], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/wizard/feedback.js

@@ -60,7 +60,7 @@ export function showQuickStart(title, steps) {
 export function showSummary(data) {
   console.log();
   for (const [label, value] of Object.entries(data)) {
-    const paddedLabel = label.padEnd(12);
+    const paddedLabel = label.padEnd(16);
     console.log(`  ${dim(paddedLabel)} ${value}`);
   }
 }

package/src/wizard/i18n.js

@@ -20,19 +20,26 @@ const FALLBACK_EN = {
     language_label: 'Language',
     ides_label: 'IDEs',
     mcps_label: 'MCPs',
+    llm_provider_title: 'Select your default AI provider:',
+    llm_provider_claude: 'Claude (Anthropic) — Best for structured reasoning',
+    llm_provider_gemini: 'Gemini (Google) — 1M token context window',
+    llm_provider_codex: 'Codex (OpenAI) — Optimized for code generation',
+    llm_provider_copilot: 'Copilot (GitHub) — Multi-model, GitHub integrated',
+    llm_provider_not_installed: '(CLI not detected)',
+    llm_provider_label: 'AI Provider',
     will_install: 'Will install:',
     agents_count: '13 agent definitions (DISCOVER, PLAN, BUILD, DEPLOY phases)',
     workflows_count: '6 workflow blueprints',
     templates_count: '6 templates (PRD, Brownfield PRD, Architecture, Task, QA Gate, Quick Brief)',
-    constitution: 'Constitution (17 Articles + Preamble)',
+    constitution: 'Constitution (19 Articles + Preamble)',
     session_mgmt: 'Session management system',
-    quality_gates: 'Quality gates (4-tier validation)',
+    quality_gates: 'Quality gates (3-tier verdicts)',
     proceed: 'Proceed with installation?',
     installing: 'Installing Chati.dev...',
     created_chati: 'Created .chati/ session directory',
     created_framework: 'Created chati.dev/ system directory (agents, templates, workflows)',
     created_commands: 'Created .claude/commands/ (thin router)',
-    installed_constitution: 'Installed Constitution (Articles I-XVII)',
+    installed_constitution: 'Installed Constitution (Articles I-XIX)',
     created_session: 'Created session.yaml schema',
     created_claude_md: 'Created CLAUDE.md',
     configured_mcps: 'Configured MCPs:',
@@ -40,7 +47,7 @@ const FALLBACK_EN = {
     agents_valid: 'All 13 agents implement 8 protocols',
     handoff_ok: 'Handoff protocol: OK',
     validation_ok: 'Self-validation criteria: OK',
-    constitution_ok: 'Constitution: 17 articles verified',
+    constitution_ok: 'Constitution: 19 articles verified',
     created_memories: 'Created .chati/memories/ (Memory Layer)',
     installed_intelligence: 'Installed Intelligence Layer (Context Engine, Memory, Registry)',
     intelligence_valid: 'Intelligence: 6 spec files verified',