chati-dev 2.1.2 → 3.0.0

package/src/terminal/cli-registry.js

@@ -0,0 +1,218 @@
+/**
+ * @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 { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import * as adapters from './adapters/index.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: ['--prompt'],
+    modelFlag: '--model',
+    stdinSupport: true,
+    hooksSupport: true,
+    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: 'gpt-5.1-codex-mini',
+    },
+    adapter: adapters.codex,
+  },
+  copilot: {
+    name: 'copilot',
+    command: 'copilot',
+    baseArgs: ['-p'],
+    modelFlag: '--model',
+    stdinSupport: true,
+    hooksSupport: true,
+    mcpSupport: true,
+    contextFile: null,
+    modelMap: {
+      'claude-sonnet': 'claude-sonnet-4.5',
+      'gpt-5': 'gpt-5.1',
+    },
+    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 configPath = join(projectDir, 'chati.dev', 'config.yaml');
+  if (!existsSync(configPath)) {
+    return { primary: 'claude', enabled: ['claude'] };
+  }
+
+  const raw = readFileSync(configPath, 'utf-8');
+
+  // Lightweight YAML extraction (avoid dependency in spawning path)
+  const enabled = [];
+  let primary = 'claude';
+
+  for (const name of Object.keys(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 };
+}
+
+/**
+ * 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
+  const configPath = join(projectDir, 'chati.dev', 'config.yaml');
+  if (existsSync(configPath)) {
+    const raw = readFileSync(configPath, 'utf-8');
+    const overrideMatch = raw.match(new RegExp(`${agent}:\\s*\\{[^}]*provider:\\s*(\\w+)[^}]*model:\\s*(\\w+)`, 'm'));
+    if (overrideMatch) {
+      const overrideProvider = overrideMatch[1];
+      if (enabled.includes(overrideProvider)) {
+        return { provider: overrideProvider, model: overrideMatch[2] };
+      }
+    }
+  }
+
+  // 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
+  return { provider: primary, model: 'sonnet' };
+}
+
+/**
+ * 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 { execSync } = await import('child_process');
+  try {
+    execSync(`which ${provider.command}`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export { PROVIDERS };

package/src/terminal/prompt-builder.js

@@ -18,19 +18,19 @@ import { getWriteScope } from './isolation.js';
 // 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',
+  orchestrator: { provider: 'claude', model: 'sonnet', tier: 'sonnet' },
+  'greenfield-wu': { provider: 'claude', model: 'haiku', tier: 'haiku' },
+  'brownfield-wu': { provider: 'claude', model: 'opus', tier: 'opus' },
+  brief: { provider: 'claude', model: 'sonnet', tier: 'sonnet' },
+  detail: { provider: 'claude', model: 'opus', tier: 'opus' },
+  architect: { provider: 'claude', model: 'opus', tier: 'opus' },
+  ux: { provider: 'claude', model: 'sonnet', tier: 'sonnet' },
+  phases: { provider: 'claude', model: 'sonnet', tier: 'sonnet' },
+  tasks: { provider: 'claude', model: 'sonnet', tier: 'sonnet' },
+  'qa-planning': { provider: 'claude', model: 'opus', tier: 'opus' },
+  'qa-implementation': { provider: 'claude', model: 'opus', tier: 'opus' },
+  dev: { provider: 'claude', model: 'opus', tier: 'opus' },
+  devops: { provider: 'claude', model: 'sonnet', tier: 'sonnet' },
 };
 
 /**
@@ -116,11 +116,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 +268,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/spawner.js

@@ -9,6 +9,7 @@
 
 import { spawn } from 'child_process';
 import { validateWriteScopes, buildIsolationEnv } from './isolation.js';
+import { getProvider } from './cli-registry.js';
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -103,17 +104,26 @@ 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 {
+    // Fallback to claude if provider resolution fails (backwards compatibility)
+    command = 'claude';
+    args = ['--print', '--dangerously-skip-permissions'];
+    if (config.model) {
+      args.push('--model', config.model);
+    }
+    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 };
 }
 

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 = [];
+  let 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/framework/manifest.json

@@ -1,5 +0,0 @@
-{
-  "createdAt": "2026-02-17T14:15:05.931Z",
-  "files": {},
-  "version": "2.1.2"
-}

package/framework/manifest.sig

@@ -1 +0,0 @@
-Wjy+M0Wcyt+KTzRu0E4fc8sB97cTe7ye+qEtNGq/av7AzcB2GsSNlwrOhfMV64ukMBHSrBMQ995sDbTtzNKADA==