chati-dev 2.1.2 → 3.0.0

package/src/config/context-file-generator.js

@@ -0,0 +1,209 @@
+/**
+ * @fileoverview Context file generator for multi-CLI support.
+ *
+ * When alternative CLI providers are enabled, generates provider-specific
+ * context files (GEMINI.md, AGENTS.md) derived from CLAUDE.md content.
+ * Constitution Article XIX — context file generation is automatic.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+// ---------------------------------------------------------------------------
+// Replacement Maps
+// ---------------------------------------------------------------------------
+
+/**
+ * Text replacements for Gemini CLI context file.
+ * Transforms Claude Code-specific references into Gemini CLI equivalents.
+ */
+const GEMINI_REPLACEMENTS = [
+  ['Claude Code', 'Gemini CLI'],
+  ['claude code', 'Gemini CLI'],
+  ['CLAUDE.md', 'GEMINI.md'],
+  ['Claude.md', 'GEMINI.md'],
+  ['.claude/commands/', '.gemini/agents/'],
+  ['.claude/rules/', '.gemini/rules/'],
+  ['.claude/mcp.json', '.gemini/settings.json'],
+  ['claude --print', 'gemini --prompt'],
+  ['claude -p', 'gemini --prompt'],
+  ['CLAUDE.local.md', 'GEMINI.local.md'],
+];
+
+/**
+ * Sections to strip from Codex CLI context file.
+ * Codex does not support hooks, so hook-related content is removed.
+ */
+const CODEX_STRIP_PATTERNS = [
+  /## (?:Hooks?|Hook System)[\s\S]*?(?=\n## |\n---|\n$)/gi,
+  /- \*\*Hooks?\*\*:.*\n/gi,
+  /hook[s]? \(.*?\)/gi,
+];
+
+/**
+ * Text replacements for Codex CLI context file.
+ */
+const CODEX_REPLACEMENTS = [
+  ['Claude Code', 'Codex CLI'],
+  ['claude code', 'Codex CLI'],
+  ['CLAUDE.md', 'AGENTS.md'],
+  ['Claude.md', 'AGENTS.md'],
+  ['.claude/commands/', '.codex/agents/'],
+  ['.claude/rules/', '.codex/rules/'],
+  ['.claude/mcp.json', '.codex/mcp.json'],
+  ['claude --print', 'codex exec'],
+  ['claude -p', 'codex exec'],
+  ['CLAUDE.local.md', 'AGENTS.local.md'],
+];
+
+// ---------------------------------------------------------------------------
+// Generators
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate GEMINI.md content from CLAUDE.md content.
+ *
+ * Adapts the content by replacing Claude Code-specific references with
+ * Gemini CLI equivalents. Preserves structure and formatting.
+ *
+ * @param {string} content - Raw CLAUDE.md content
+ * @returns {string} Adapted content for GEMINI.md
+ */
+export function generateGeminiMd(content) {
+  let result = content;
+
+  for (const [search, replace] of GEMINI_REPLACEMENTS) {
+    result = result.replaceAll(search, replace);
+  }
+
+  // Prepend a header noting this file is auto-generated
+  const header = [
+    '<!-- Auto-generated by chati.dev from CLAUDE.md — do not edit manually -->',
+    '',
+  ].join('\n');
+
+  return header + result;
+}
+
+/**
+ * Generate AGENTS.md content from CLAUDE.md content.
+ *
+ * Simplifies the content for Codex CLI: strips hook references,
+ * replaces CLI-specific paths, and produces a leaner context file
+ * focused on code execution.
+ *
+ * @param {string} content - Raw CLAUDE.md content
+ * @returns {string} Adapted content for AGENTS.md
+ */
+export function generateAgentsMd(content) {
+  let result = content;
+
+  // Strip hook-related sections (Codex has no hooks support)
+  for (const pattern of CODEX_STRIP_PATTERNS) {
+    result = result.replace(pattern, '');
+  }
+
+  // Apply text replacements
+  for (const [search, replace] of CODEX_REPLACEMENTS) {
+    result = result.replaceAll(search, replace);
+  }
+
+  // Clean up any double blank lines left by stripping
+  result = result.replace(/\n{3,}/g, '\n\n');
+
+  // Prepend a header noting this file is auto-generated
+  const header = [
+    '<!-- Auto-generated by chati.dev from CLAUDE.md — do not edit manually -->',
+    '',
+  ].join('\n');
+
+  return header + result;
+}
+
+// ---------------------------------------------------------------------------
+// Orchestrator
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate context files for all enabled alternative providers.
+ *
+ * Reads config.yaml to determine which providers are enabled, reads
+ * CLAUDE.md from the project root, and writes the appropriate context
+ * files (GEMINI.md, AGENTS.md) when their providers are active.
+ *
+ * @param {string} projectDir - Project root directory
+ * @returns {{ generated: string[], skipped: string[], warning: string|null }}
+ */
+export function generateContextFiles(projectDir) {
+  const result = { generated: [], skipped: [], warning: null };
+
+  // Read CLAUDE.md
+  const claudeMdPath = join(projectDir, 'CLAUDE.md');
+  if (!existsSync(claudeMdPath)) {
+    result.warning = 'CLAUDE.md not found — skipping context file generation';
+    return result;
+  }
+
+  const claudeContent = readFileSync(claudeMdPath, 'utf-8');
+
+  // Determine enabled providers from config.yaml
+  const enabledProviders = resolveEnabledProviders(projectDir);
+
+  // Provider-to-generator mapping
+  const generators = {
+    gemini: {
+      filename: 'GEMINI.md',
+      generate: generateGeminiMd,
+    },
+    codex: {
+      filename: 'AGENTS.md',
+      generate: generateAgentsMd,
+    },
+  };
+
+  for (const [provider, config] of Object.entries(generators)) {
+    if (enabledProviders.includes(provider)) {
+      const outputPath = join(projectDir, config.filename);
+      const content = config.generate(claudeContent);
+      writeFileSync(outputPath, content, 'utf-8');
+      result.generated.push(config.filename);
+    } else {
+      result.skipped.push(config.filename);
+    }
+  }
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve which alternative providers are enabled from config.yaml.
+ *
+ * Uses lightweight regex-based YAML extraction (no dependency on a
+ * full YAML parser) consistent with cli-registry.js patterns.
+ *
+ * @param {string} projectDir - Project root directory
+ * @returns {string[]} List of enabled provider names
+ */
+function resolveEnabledProviders(projectDir) {
+  const configPath = join(projectDir, 'chati.dev', 'config.yaml');
+  if (!existsSync(configPath)) {
+    return [];
+  }
+
+  const raw = readFileSync(configPath, 'utf-8');
+  const providers = ['gemini', 'codex', 'copilot'];
+  const enabled = [];
+
+  for (const name of providers) {
+    const match = raw.match(new RegExp(`${name}:[\\s\\S]*?enabled:\\s*(true|false)`, 'm'));
+    if (match && match[1] === 'true') {
+      enabled.push(name);
+    }
+  }
+
+  return enabled;
+}

package/src/gates/g2-qa-planning.js

@@ -7,7 +7,7 @@
 
 import { existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { GateBase } from './gate-base.js';
+import { GateBase, GateVerdict, determineVerdict } from './gate-base.js';
 import { loadSession } from '../orchestrator/session-manager.js';
 import { loadHandoff } from '../tasks/handoff.js';
 
@@ -148,6 +148,8 @@ export class QAPlanningGate extends GateBase {
       ? Math.round((criteriaResults.length / allCriteria.length) * 100)
       : 0;
 
-    return { score, criteriaResults, allCriteria, warnings };
+    const verdict = determineVerdict(score, 95);
+
+    return { score, criteriaResults, allCriteria, warnings, verdict };
   }
 }

package/src/gates/g4-qa-implementation.js

@@ -14,7 +14,7 @@
 
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { GateBase } from './gate-base.js';
+import { GateBase, GateVerdict, determineVerdict } from './gate-base.js';
 import { loadSession } from '../orchestrator/session-manager.js';
 import { loadHandoff } from '../tasks/handoff.js';
 
@@ -202,6 +202,9 @@ export class QAImplementationGate extends GateBase {
       ? Math.round((criteriaResults.length / allCriteria.length) * 100)
       : 0;
 
-    return { score, criteriaResults, allCriteria, warnings };
+    const hasCriticalBlocker = !evidence.noCriticalBugs;
+    const verdict = determineVerdict(score, 95, hasCriticalBlocker);
+
+    return { score, criteriaResults, allCriteria, warnings, verdict };
   }
 }

package/src/gates/gate-base.js

@@ -8,6 +8,33 @@
 
 import { evaluateGate, getGateThreshold, resolveGateAction } from '../autonomy/autonomous-gate.js';
 
+/**
+ * Gate verdict constants (v3.0.0).
+ * APPROVED: Score >= threshold — proceed to next pipeline stage.
+ * NEEDS_REVISION: Score within 5 points below threshold — return to agent for fixes.
+ * BLOCKED: Score significantly below threshold or critical blocker — halt pipeline.
+ */
+export const GateVerdict = {
+  APPROVED: 'approved',
+  NEEDS_REVISION: 'needs_revision',
+  BLOCKED: 'blocked',
+};
+
+/**
+ * Determine the gate verdict from a score and threshold.
+ *
+ * @param {number} score - Gate evaluation score (0-100)
+ * @param {number} threshold - Minimum score to pass
+ * @param {boolean} [hasCriticalBlocker=false] - Whether a critical blocker exists
+ * @returns {string} One of GateVerdict values
+ */
+export function determineVerdict(score, threshold, hasCriticalBlocker = false) {
+  if (hasCriticalBlocker) return GateVerdict.BLOCKED;
+  if (score >= threshold) return GateVerdict.APPROVED;
+  if (score >= threshold - 5) return GateVerdict.NEEDS_REVISION;
+  return GateVerdict.BLOCKED;
+}
+
 /**
  * Abstract base class for quality gates.
  *
@@ -70,14 +97,19 @@ export class GateBase {
 
       const action = resolveGateAction(gateResult.result, mode);
 
+      const threshold = getGateThreshold(this.agent);
+      const hasCriticalBlocker = warnings.some(w => w.toLowerCase().includes('critical'));
+      const verdict = determineVerdict(gateResult.score, threshold, hasCriticalBlocker);
+
       return {
         gateId: this.id,
         gateName: this.name,
         result: gateResult.result,
+        verdict,
         score: gateResult.score,
         evidence,
         recommendation: action.action,
-        canProceed: gateResult.canProceed,
+        canProceed: verdict === GateVerdict.APPROVED,
         details: gateResult.details,
         warnings,
       };

package/src/health/engine.js

@@ -0,0 +1,250 @@
+/**
+ * @fileoverview Health check engine for chati.dev.
+ *
+ * Validates framework integrity, CLI availability, session state,
+ * hook health, dependencies, and provider authentication.
+ * Constitution Article XIV — Framework Registry Governance.
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+// ---------------------------------------------------------------------------
+// Check Result Types
+// ---------------------------------------------------------------------------
+
+/**
+ * @typedef {object} CheckResult
+ * @property {string} name - Check name
+ * @property {'pass'|'warn'|'fail'} status - Check status
+ * @property {string} message - Human-readable result
+ * @property {number} duration - Execution time in ms
+ */
+
+/**
+ * @typedef {object} HealthReport
+ * @property {number} score - Overall score (0-100)
+ * @property {number} total - Total checks run
+ * @property {number} passed - Checks passed
+ * @property {number} warned - Checks with warnings
+ * @property {number} failed - Checks failed
+ * @property {CheckResult[]} checks - Individual check results
+ * @property {string} timestamp - ISO timestamp
+ */
+
+// ---------------------------------------------------------------------------
+// Individual Checks
+// ---------------------------------------------------------------------------
+
+/**
+ * Check if configured CLI providers are available on the system.
+ *
+ * @param {string} projectDir
+ * @returns {Promise<CheckResult>}
+ */
+export async function checkCliAvailability(projectDir) {
+  const start = Date.now();
+  const configPath = join(projectDir, 'chati.dev', 'config.yaml');
+
+  if (!existsSync(configPath)) {
+    return { name: 'cli-availability', status: 'warn', message: 'No config.yaml found', duration: Date.now() - start };
+  }
+
+  const raw = readFileSync(configPath, 'utf-8');
+  const providers = ['claude', 'gemini', 'codex', 'copilot'];
+  const missing = [];
+
+  for (const provider of providers) {
+    const enabledMatch = raw.match(new RegExp(`${provider}:[\\s\\S]*?enabled:\\s*true`, 'm'));
+    if (enabledMatch) {
+      const { execSync } = await import('child_process');
+      try {
+        execSync(`which ${provider}`, { stdio: 'ignore' });
+      } catch {
+        missing.push(provider);
+      }
+    }
+  }
+
+  if (missing.length > 0) {
+    return { name: 'cli-availability', status: 'warn', message: `Missing CLIs: ${missing.join(', ')}`, duration: Date.now() - start };
+  }
+
+  return { name: 'cli-availability', status: 'pass', message: 'All enabled CLIs available', duration: Date.now() - start };
+}
+
+/**
+ * Validate framework file integrity against entity registry.
+ *
+ * @param {string} projectDir
+ * @returns {Promise<CheckResult>}
+ */
+export async function checkFrameworkIntegrity(projectDir) {
+  const start = Date.now();
+  const registryPath = join(projectDir, 'chati.dev', 'data', 'entity-registry.yaml');
+
+  if (!existsSync(registryPath)) {
+    return { name: 'framework-integrity', status: 'warn', message: 'No entity registry found', duration: Date.now() - start };
+  }
+
+  const raw = readFileSync(registryPath, 'utf-8');
+  const pathMatches = raw.match(/path:\s*["']?([^\s"']+)["']?/gm) || [];
+  let missing = 0;
+
+  for (const match of pathMatches) {
+    const filePath = match.replace(/path:\s*["']?/, '').replace(/["']?$/, '');
+    if (!existsSync(join(projectDir, filePath))) {
+      missing++;
+    }
+  }
+
+  if (missing > 0) {
+    return { name: 'framework-integrity', status: 'warn', message: `${missing} registered entities missing from filesystem`, duration: Date.now() - start };
+  }
+
+  return { name: 'framework-integrity', status: 'pass', message: 'All registered entities exist', duration: Date.now() - start };
+}
+
+/**
+ * Validate session.yaml structure.
+ *
+ * @param {string} projectDir
+ * @returns {Promise<CheckResult>}
+ */
+export async function checkSessionState(projectDir) {
+  const start = Date.now();
+  const sessionPath = join(projectDir, '.chati', 'session.yaml');
+
+  if (!existsSync(sessionPath)) {
+    return { name: 'session-state', status: 'pass', message: 'No active session (expected for new projects)', duration: Date.now() - start };
+  }
+
+  const raw = readFileSync(sessionPath, 'utf-8');
+  const requiredFields = ['project', 'language'];
+  const missingFields = requiredFields.filter((f) => !raw.includes(`${f}:`));
+
+  if (missingFields.length > 0) {
+    return { name: 'session-state', status: 'warn', message: `Session missing fields: ${missingFields.join(', ')}`, duration: Date.now() - start };
+  }
+
+  return { name: 'session-state', status: 'pass', message: 'Session state valid', duration: Date.now() - start };
+}
+
+/**
+ * Verify that hooks are functional.
+ *
+ * @param {string} projectDir
+ * @returns {Promise<CheckResult>}
+ */
+export async function checkHooksHealth(projectDir) {
+  const start = Date.now();
+  const hooksDir = join(projectDir, 'chati.dev', 'hooks');
+
+  if (!existsSync(hooksDir)) {
+    return { name: 'hooks-health', status: 'fail', message: 'Hooks directory not found', duration: Date.now() - start };
+  }
+
+  const expectedHooks = ['prism-engine.js', 'model-governance.js', 'mode-governance.js', 'constitution-guard.js', 'read-protection.js', 'session-digest.js'];
+  const missing = expectedHooks.filter((h) => !existsSync(join(hooksDir, h)));
+
+  if (missing.length > 0) {
+    return { name: 'hooks-health', status: 'fail', message: `Missing hooks: ${missing.join(', ')}`, duration: Date.now() - start };
+  }
+
+  return { name: 'hooks-health', status: 'pass', message: 'All 6 hooks present', duration: Date.now() - start };
+}
+
+/**
+ * Verify system dependencies.
+ *
+ * @returns {Promise<CheckResult>}
+ */
+export async function checkDependencies() {
+  const start = Date.now();
+  const issues = [];
+
+  const { execSync } = await import('child_process');
+
+  // Check Node.js version
+  try {
+    const nodeVersion = execSync('node --version', { encoding: 'utf-8' }).trim();
+    const major = parseInt(nodeVersion.replace('v', '').split('.')[0], 10);
+    if (major < 20) {
+      issues.push(`Node.js ${nodeVersion} < required v20`);
+    }
+  } catch {
+    issues.push('Node.js not found');
+  }
+
+  // Check git
+  try {
+    execSync('git --version', { stdio: 'ignore' });
+  } catch {
+    issues.push('git not found');
+  }
+
+  if (issues.length > 0) {
+    return { name: 'dependencies', status: 'fail', message: issues.join('; '), duration: Date.now() - start };
+  }
+
+  return { name: 'dependencies', status: 'pass', message: 'All dependencies satisfied', duration: Date.now() - start };
+}
+
+/**
+ * Check git repository status.
+ *
+ * @param {string} projectDir
+ * @returns {Promise<CheckResult>}
+ */
+export async function checkGitStatus(projectDir) {
+  const start = Date.now();
+
+  if (!existsSync(join(projectDir, '.git'))) {
+    return { name: 'git-status', status: 'warn', message: 'Not a git repository', duration: Date.now() - start };
+  }
+
+  return { name: 'git-status', status: 'pass', message: 'Git repository detected', duration: Date.now() - start };
+}
+
+// ---------------------------------------------------------------------------
+// Health Engine
+// ---------------------------------------------------------------------------
+
+/**
+ * Run all health checks and produce a report.
+ *
+ * @param {string} projectDir - Project root directory
+ * @returns {Promise<HealthReport>}
+ */
+export async function runHealthChecks(projectDir) {
+  const checks = [
+    checkCliAvailability(projectDir),
+    checkFrameworkIntegrity(projectDir),
+    checkSessionState(projectDir),
+    checkHooksHealth(projectDir),
+    checkDependencies(),
+    checkGitStatus(projectDir),
+  ];
+
+  const results = await Promise.allSettled(checks);
+  const checkResults = results.map((r) => {
+    if (r.status === 'fulfilled') return r.value;
+    return { name: 'unknown', status: 'fail', message: r.reason?.message || 'Check failed', duration: 0 };
+  });
+
+  const passed = checkResults.filter((c) => c.status === 'pass').length;
+  const warned = checkResults.filter((c) => c.status === 'warn').length;
+  const failed = checkResults.filter((c) => c.status === 'fail').length;
+  const total = checkResults.length;
+  const score = Math.round((passed / total) * 100);
+
+  return {
+    score,
+    total,
+    passed,
+    warned,
+    failed,
+    checks: checkResults,
+    timestamp: new Date().toISOString(),
+  };
+}

package/src/intelligence/file-tracker.js

@@ -0,0 +1,117 @@
+/**
+ * @fileoverview File evolution tracker.
+ *
+ * Records file modifications by agent for rollback detection,
+ * conflict prevention in parallel execution, and audit trail.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+
+/**
+ * @typedef {object} FileEvent
+ * @property {string} file - Relative file path
+ * @property {string} agent - Agent that modified the file
+ * @property {'create'|'modify'|'delete'} action - Type of modification
+ * @property {string} timestamp - ISO timestamp
+ * @property {string} [provider] - CLI provider used
+ */
+
+const TRACKER_FILE = '.chati/file-evolution.json';
+
+/**
+ * Load file evolution history.
+ *
+ * @param {string} projectDir
+ * @returns {FileEvent[]}
+ */
+export function loadHistory(projectDir) {
+  const trackerPath = join(projectDir, TRACKER_FILE);
+  if (!existsSync(trackerPath)) return [];
+  try {
+    return JSON.parse(readFileSync(trackerPath, 'utf-8'));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Record a file modification event.
+ *
+ * @param {string} projectDir
+ * @param {Omit<FileEvent, 'timestamp'>} event
+ * @returns {FileEvent}
+ */
+export function recordEvent(projectDir, event) {
+  const history = loadHistory(projectDir);
+  const entry = { ...event, timestamp: new Date().toISOString() };
+  history.push(entry);
+
+  const trackerPath = join(projectDir, TRACKER_FILE);
+  mkdirSync(dirname(trackerPath), { recursive: true });
+  writeFileSync(trackerPath, JSON.stringify(history, null, 2));
+
+  return entry;
+}
+
+/**
+ * Get files modified by a specific agent.
+ *
+ * @param {string} projectDir
+ * @param {string} agent
+ * @returns {FileEvent[]}
+ */
+export function getAgentFiles(projectDir, agent) {
+  return loadHistory(projectDir).filter((e) => e.agent === agent);
+}
+
+/**
+ * Detect potential conflicts between parallel agents.
+ * Returns files that were modified by multiple agents.
+ *
+ * @param {string} projectDir
+ * @param {string[]} agents - Active parallel agents
+ * @returns {{ file: string, agents: string[] }[]}
+ */
+export function detectConflicts(projectDir, agents) {
+  const history = loadHistory(projectDir);
+  const fileAgentMap = new Map();
+
+  for (const event of history) {
+    if (agents.includes(event.agent)) {
+      if (!fileAgentMap.has(event.file)) {
+        fileAgentMap.set(event.file, new Set());
+      }
+      fileAgentMap.get(event.file).add(event.agent);
+    }
+  }
+
+  const conflicts = [];
+  for (const [file, agentSet] of fileAgentMap) {
+    if (agentSet.size > 1) {
+      conflicts.push({ file, agents: [...agentSet] });
+    }
+  }
+
+  return conflicts;
+}
+
+/**
+ * Prune history older than specified days.
+ *
+ * @param {string} projectDir
+ * @param {number} [days=30]
+ * @returns {number} Number of entries pruned
+ */
+export function pruneHistory(projectDir, days = 30) {
+  const history = loadHistory(projectDir);
+  const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+  const filtered = history.filter((e) => new Date(e.timestamp).getTime() > cutoff);
+  const pruned = history.length - filtered.length;
+
+  const trackerPath = join(projectDir, TRACKER_FILE);
+  mkdirSync(dirname(trackerPath), { recursive: true });
+  writeFileSync(trackerPath, JSON.stringify(filtered, null, 2));
+
+  return pruned;
+}