chati-dev 2.1.2 → 3.0.1

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;
+}

package/src/intelligence/registry-manager.js

@@ -131,8 +131,8 @@ export function runHealthCheck(targetDir) {
   if (existsSync(constitutionPath)) {
     const content = readFileSync(constitutionPath, 'utf-8');
     const articleCount = (content.match(/^## Article/gm) || []).length;
-    checks.constitution.pass = articleCount >= 17;
-    checks.constitution.details = `${articleCount}/17 articles`;
+    checks.constitution.pass = articleCount >= 19;
+    checks.constitution.details = `${articleCount}/19 articles`;
   } else {
     checks.constitution.details = 'Not found';
   }

package/src/intelligence/timeline.js

@@ -0,0 +1,144 @@
+/**
+ * @fileoverview Session timeline manager.
+ *
+ * Maintains a chronological record of all significant events
+ * during a session: agent activations, mode transitions, gate
+ * results, handoffs, and deviations.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+
+/**
+ * @typedef {object} TimelineEvent
+ * @property {string} id - Unique event ID
+ * @property {string} type - Event type
+ * @property {string} agent - Agent involved (or 'orchestrator')
+ * @property {object} data - Event-specific data
+ * @property {string} timestamp - ISO timestamp
+ */
+
+/**
+ * Event type constants.
+ */
+export const EventType = {
+  AGENT_ACTIVATED: 'agent_activated',
+  AGENT_COMPLETED: 'agent_completed',
+  MODE_TRANSITION: 'mode_transition',
+  PROFILE_TRANSITION: 'profile_transition',
+  GATE_EVALUATED: 'gate_evaluated',
+  HANDOFF_CREATED: 'handoff_created',
+  DEVIATION_DETECTED: 'deviation_detected',
+  ERROR_OCCURRED: 'error_occurred',
+  PROVIDER_SELECTED: 'provider_selected',
+  SESSION_STARTED: 'session_started',
+  SESSION_ENDED: 'session_ended',
+};
+
+const TIMELINE_FILE = '.chati/timeline.json';
+let _counter = 0;
+
+/**
+ * Load the timeline from disk.
+ *
+ * @param {string} projectDir
+ * @returns {TimelineEvent[]}
+ */
+export function loadTimeline(projectDir) {
+  const timelinePath = join(projectDir, TIMELINE_FILE);
+  if (!existsSync(timelinePath)) return [];
+  try {
+    return JSON.parse(readFileSync(timelinePath, 'utf-8'));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Save the timeline to disk.
+ *
+ * @param {string} projectDir
+ * @param {TimelineEvent[]} timeline
+ */
+function saveTimeline(projectDir, timeline) {
+  const timelinePath = join(projectDir, TIMELINE_FILE);
+  mkdirSync(dirname(timelinePath), { recursive: true });
+  writeFileSync(timelinePath, JSON.stringify(timeline, null, 2));
+}
+
+/**
+ * Record a new event on the timeline.
+ *
+ * @param {string} projectDir
+ * @param {string} type - Event type from EventType
+ * @param {string} agent - Agent name
+ * @param {object} [data={}] - Event-specific data
+ * @returns {TimelineEvent}
+ */
+export function recordEvent(projectDir, type, agent, data = {}) {
+  const timeline = loadTimeline(projectDir);
+  _counter++;
+
+  const event = {
+    id: `evt-${Date.now()}-${_counter}`,
+    type,
+    agent,
+    data,
+    timestamp: new Date().toISOString(),
+  };
+
+  timeline.push(event);
+  saveTimeline(projectDir, timeline);
+  return event;
+}
+
+/**
+ * Get events filtered by type.
+ *
+ * @param {string} projectDir
+ * @param {string} type
+ * @returns {TimelineEvent[]}
+ */
+export function getEventsByType(projectDir, type) {
+  return loadTimeline(projectDir).filter((e) => e.type === type);
+}
+
+/**
+ * Get events filtered by agent.
+ *
+ * @param {string} projectDir
+ * @param {string} agent
+ * @returns {TimelineEvent[]}
+ */
+export function getEventsByAgent(projectDir, agent) {
+  return loadTimeline(projectDir).filter((e) => e.agent === agent);
+}
+
+/**
+ * Get the most recent event of a given type.
+ *
+ * @param {string} projectDir
+ * @param {string} type
+ * @returns {TimelineEvent|null}
+ */
+export function getLatestEvent(projectDir, type) {
+  const events = getEventsByType(projectDir, type);
+  return events.length > 0 ? events[events.length - 1] : null;
+}
+
+/**
+ * Clear the timeline (used for session reset).
+ *
+ * @param {string} projectDir
+ */
+export function clearTimeline(projectDir) {
+  saveTimeline(projectDir, []);
+  _counter = 0;
+}
+
+/**
+ * Reset counter (for tests).
+ */
+export function _resetCounter() {
+  _counter = 0;
+}

package/src/memory/gotchas-auto-capture.js

@@ -0,0 +1,253 @@
+/**
+ * @fileoverview Gotchas auto-capture engine.
+ *
+ * Monitors agent execution for recurring error patterns.
+ * When an error pattern appears 3+ times, it is automatically
+ * captured as a gotcha and injected before related tasks.
+ *
+ * Constitution Article XIII — Memory Governance.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/** Minimum occurrences before auto-capture triggers */
+const AUTO_CAPTURE_THRESHOLD = 3;
+
+/** Time window for counting occurrences (24 hours) */
+const CAPTURE_WINDOW_MS = 24 * 60 * 60 * 1000;
+
+/** Maximum age before a gotcha is archived (90 days) */
+const ARCHIVE_AGE_MS = 90 * 24 * 60 * 60 * 1000;
+
+/**
+ * Error categories for classification.
+ * @enum {string}
+ */
+const Category = {
+  BUILD: 'build',
+  TEST: 'test',
+  LINT: 'lint',
+  RUNTIME: 'runtime',
+  INTEGRATION: 'integration',
+  SECURITY: 'security',
+};
+
+/**
+ * Severity levels.
+ * @enum {string}
+ */
+const Severity = {
+  INFO: 'info',
+  WARNING: 'warning',
+  CRITICAL: 'critical',
+};
+
+// ---------------------------------------------------------------------------
+// Error Pattern Matching
+// ---------------------------------------------------------------------------
+
+/**
+ * Known error pattern signatures for classification.
+ * Each pattern has a regex, category, and severity.
+ */
+const ERROR_PATTERNS = [
+  { regex: /Cannot find module/i, category: Category.BUILD, severity: Severity.WARNING },
+  { regex: /SyntaxError/i, category: Category.BUILD, severity: Severity.CRITICAL },
+  { regex: /TypeError/i, category: Category.RUNTIME, severity: Severity.WARNING },
+  { regex: /ENOENT/i, category: Category.BUILD, severity: Severity.WARNING },
+  { regex: /EACCES/i, category: Category.SECURITY, severity: Severity.CRITICAL },
+  { regex: /test.*fail/i, category: Category.TEST, severity: Severity.WARNING },
+  { regex: /lint.*error/i, category: Category.LINT, severity: Severity.INFO },
+  { regex: /CORS/i, category: Category.INTEGRATION, severity: Severity.WARNING },
+  { regex: /401|403|unauthorized/i, category: Category.SECURITY, severity: Severity.CRITICAL },
+  { regex: /timeout|ETIMEDOUT/i, category: Category.INTEGRATION, severity: Severity.WARNING },
+  { regex: /out of memory|heap/i, category: Category.RUNTIME, severity: Severity.CRITICAL },
+  { regex: /deprecated/i, category: Category.BUILD, severity: Severity.INFO },
+];
+
+// ---------------------------------------------------------------------------
+// Auto-Capture Engine
+// ---------------------------------------------------------------------------
+
+/**
+ * Normalize an error message into a stable key for deduplication.
+ *
+ * @param {string} message - Raw error message
+ * @returns {string} Normalized key
+ */
+export function normalizeErrorKey(message) {
+  return message
+    .replace(/['"][^'"]*['"]/g, '""')       // Replace string literals
+    .replace(/\d+/g, 'N')                    // Replace numbers
+    .replace(/\/[^\s]+/g, '/PATH')           // Replace file paths
+    .replace(/\s+/g, ' ')                    // Normalize whitespace
+    .trim()
+    .slice(0, 200);                           // Limit length
+}
+
+/**
+ * Classify an error message into category and severity.
+ *
+ * @param {string} message - Error message
+ * @returns {{ category: string, severity: string }}
+ */
+export function classifyError(message) {
+  for (const pattern of ERROR_PATTERNS) {
+    if (pattern.regex.test(message)) {
+      return { category: pattern.category, severity: pattern.severity };
+    }
+  }
+  return { category: Category.RUNTIME, severity: Severity.INFO };
+}
+
+/**
+ * Load the error tracker state from disk.
+ *
+ * @param {string} projectDir - Project root
+ * @returns {{ errors: Record<string, { count: number, firstSeen: string, lastSeen: string, message: string, category: string, severity: string }>, gotchas: string[] }}
+ */
+export function loadTrackerState(projectDir) {
+  const trackerPath = join(projectDir, '.chati', 'error-tracker.json');
+  if (!existsSync(trackerPath)) {
+    return { errors: {}, gotchas: [] };
+  }
+  try {
+    return JSON.parse(readFileSync(trackerPath, 'utf-8'));
+  } catch {
+    return { errors: {}, gotchas: [] };
+  }
+}
+
+/**
+ * Save the error tracker state to disk.
+ *
+ * @param {string} projectDir - Project root
+ * @param {object} state - Tracker state
+ */
+export function saveTrackerState(projectDir, state) {
+  const trackerPath = join(projectDir, '.chati', 'error-tracker.json');
+  mkdirSync(dirname(trackerPath), { recursive: true });
+  writeFileSync(trackerPath, JSON.stringify(state, null, 2));
+}
+
+/**
+ * Track an error occurrence. If threshold is met, auto-create a gotcha.
+ *
+ * @param {string} projectDir - Project root
+ * @param {string} errorMessage - Raw error message
+ * @param {string} [agent] - Agent that encountered the error
+ * @returns {{ captured: boolean, gotcha: object|null }}
+ */
+export function trackError(projectDir, errorMessage, agent) {
+  const state = loadTrackerState(projectDir);
+  const key = normalizeErrorKey(errorMessage);
+  const { category, severity } = classifyError(errorMessage);
+  const now = new Date().toISOString();
+
+  // Initialize or update error entry
+  if (!state.errors[key]) {
+    state.errors[key] = {
+      count: 0,
+      firstSeen: now,
+      lastSeen: now,
+      message: errorMessage.slice(0, 500),
+      category,
+      severity,
+    };
+  }
+
+  const entry = state.errors[key];
+
+  // Only count within the capture window
+  const lastSeen = new Date(entry.lastSeen).getTime();
+  if (Date.now() - lastSeen > CAPTURE_WINDOW_MS) {
+    entry.count = 0; // Reset if outside window
+  }
+
+  entry.count += 1;
+  entry.lastSeen = now;
+
+  // Check if threshold is met and gotcha not already created
+  let gotcha = null;
+  let captured = false;
+
+  if (entry.count >= AUTO_CAPTURE_THRESHOLD && !state.gotchas.includes(key)) {
+    gotcha = {
+      id: `G-AUTO-${Date.now()}`,
+      pattern: key,
+      description: entry.message,
+      category: entry.category,
+      severity: entry.severity,
+      discovered_by: agent || 'auto-capture',
+      discovered_at: now,
+      occurrence_count: entry.count,
+      auto_captured: true,
+    };
+
+    state.gotchas.push(key);
+    captured = true;
+
+    // Append to gotchas runtime file
+    const gotchasPath = join(projectDir, '.chati', 'gotchas.json');
+    let gotchasList = [];
+    if (existsSync(gotchasPath)) {
+      try {
+        gotchasList = JSON.parse(readFileSync(gotchasPath, 'utf-8'));
+      } catch { /* ignore */ }
+    }
+    gotchasList.push(gotcha);
+    writeFileSync(gotchasPath, JSON.stringify(gotchasList, null, 2));
+  }
+
+  saveTrackerState(projectDir, state);
+  return { captured, gotcha };
+}
+
+/**
+ * Prune old errors outside the capture window and archive old gotchas.
+ *
+ * @param {string} projectDir - Project root
+ * @returns {{ pruned: number, archived: number }}
+ */
+export function pruneTracker(projectDir) {
+  const state = loadTrackerState(projectDir);
+  const now = Date.now();
+  let pruned = 0;
+  let archived = 0;
+
+  // Prune old error entries
+  for (const [key, entry] of Object.entries(state.errors)) {
+    const lastSeen = new Date(entry.lastSeen).getTime();
+    if (now - lastSeen > CAPTURE_WINDOW_MS) {
+      delete state.errors[key];
+      pruned++;
+    }
+  }
+
+  // Archive old gotchas
+  const gotchasPath = join(projectDir, '.chati', 'gotchas.json');
+  if (existsSync(gotchasPath)) {
+    try {
+      const gotchasList = JSON.parse(readFileSync(gotchasPath, 'utf-8'));
+      const active = gotchasList.filter((g) => {
+        const age = now - new Date(g.discovered_at).getTime();
+        if (age > ARCHIVE_AGE_MS) {
+          archived++;
+          return false;
+        }
+        return true;
+      });
+      writeFileSync(gotchasPath, JSON.stringify(active, null, 2));
+    } catch { /* ignore */ }
+  }
+
+  saveTrackerState(projectDir, state);
+  return { pruned, archived };
+}
+
+export { AUTO_CAPTURE_THRESHOLD, CAPTURE_WINDOW_MS, ARCHIVE_AGE_MS, Category, Severity, ERROR_PATTERNS };

package/src/preview/detector.js

@@ -191,7 +191,7 @@ export function detectProjectKind(projectDir) {
  * @returns {{ command: string, args: string[], description: string, framework: string, defaultPort: number }}
  */
 function resolveFrameworkCommand(projectDir, detector) {
-  const { framework, defaultPort, kind } = detector;
+  const { framework, defaultPort } = detector;
 
   // Django has its own command
   if (framework === 'django') {

package/src/terminal/adapters/claude-adapter.js

@@ -0,0 +1,33 @@
+/**
+ * @fileoverview Claude Code CLI adapter.
+ *
+ * Translates chati.dev spawning config into Claude Code CLI
+ * command, arguments, and environment variables.
+ */
+
+/**
+ * @typedef {import('../cli-registry.js').ProviderConfig} ProviderConfig
+ * @typedef {import('../spawner.js').SpawnConfig} SpawnConfig
+ */
+
+/**
+ * Build Claude Code CLI command and arguments.
+ *
+ * @param {SpawnConfig} config - Spawn configuration
+ * @param {ProviderConfig} provider - Provider definition from registry
+ * @returns {{ command: string, args: string[], stdinPrompt: string|null }}
+ */
+export function buildCommand(config, provider) {
+  const args = [...provider.baseArgs];
+
+  if (config.model) {
+    const resolvedModel = provider.modelMap[config.model] || config.model;
+    args.push(provider.modelFlag, resolvedModel);
+  }
+
+  return {
+    command: provider.command,
+    args,
+    stdinPrompt: config.prompt || null,
+  };
+}

package/src/terminal/adapters/codex-adapter.js

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview OpenAI Codex CLI adapter.
+ *
+ * Translates chati.dev spawning config into Codex CLI
+ * command, arguments, and environment variables.
+ */
+
+/**
+ * Build Codex CLI command and arguments.
+ *
+ * @param {import('../spawner.js').SpawnConfig} config
+ * @param {import('../cli-registry.js').ProviderConfig} provider
+ * @returns {{ command: string, args: string[], stdinPrompt: string|null }}
+ */
+export function buildCommand(config, provider) {
+  const args = [...provider.baseArgs];
+
+  if (config.model) {
+    const resolvedModel = provider.modelMap[config.model] || config.model;
+    args.push(provider.modelFlag, resolvedModel);
+  }
+
+  // Codex exec reads prompt from stdin when `-` is passed
+  args.push('-');
+
+  return {
+    command: provider.command,
+    args,
+    stdinPrompt: config.prompt || null,
+  };
+}

package/src/terminal/adapters/copilot-adapter.js

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview GitHub Copilot CLI adapter.
+ *
+ * Translates chati.dev spawning config into Copilot CLI
+ * command, arguments, and environment variables.
+ */
+
+/**
+ * Build Copilot CLI command and arguments.
+ *
+ * @param {import('../spawner.js').SpawnConfig} config
+ * @param {import('../cli-registry.js').ProviderConfig} provider
+ * @returns {{ command: string, args: string[], stdinPrompt: string|null }}
+ */
+export function buildCommand(config, provider) {
+  const args = [...provider.baseArgs];
+
+  if (config.model) {
+    const resolvedModel = provider.modelMap[config.model] || config.model;
+    args.push(provider.modelFlag, resolvedModel);
+  }
+
+  return {
+    command: provider.command,
+    args,
+    stdinPrompt: config.prompt || null,
+  };
+}

package/src/terminal/adapters/gemini-adapter.js

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Gemini CLI adapter.
+ *
+ * Translates chati.dev spawning config into Gemini CLI
+ * command, arguments, and environment variables.
+ */
+
+/**
+ * Build Gemini CLI command and arguments.
+ *
+ * @param {import('../spawner.js').SpawnConfig} config
+ * @param {import('../cli-registry.js').ProviderConfig} provider
+ * @returns {{ command: string, args: string[], stdinPrompt: string|null }}
+ */
+export function buildCommand(config, provider) {
+  const args = [...provider.baseArgs];
+
+  if (config.model) {
+    const resolvedModel = provider.modelMap[config.model] || config.model;
+    args.push(provider.modelFlag, resolvedModel);
+  }
+
+  return {
+    command: provider.command,
+    args,
+    stdinPrompt: config.prompt || null,
+  };
+}

package/src/terminal/adapters/index.js

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Barrel export for CLI adapters.
+ */
+
+export * as claude from './claude-adapter.js';
+export * as gemini from './gemini-adapter.js';
+export * as codex from './codex-adapter.js';
+export * as copilot from './copilot-adapter.js';