chati-dev 3.2.4 → 3.3.0

package/src/autonomy/execution-profile.js

@@ -1,151 +0,0 @@
-/**
- * @fileoverview Execution profile manager.
- *
- * Manages 3 execution profiles that govern confirmation requirements:
- * - explore: read-only, no writes
- * - guided: confirm before writes (default)
- * - autonomous: full autonomy with quality gates
- *
- * Profiles are orthogonal to mode governance (Article XI).
- * Modes control WHERE; profiles control WHETHER.
- *
- * Constitution Article XVIII — Execution Profile Governance.
- */
-
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-
-// ---------------------------------------------------------------------------
-// Profile Definitions
-// ---------------------------------------------------------------------------
-
-/**
- * Execution profile enum.
- * @enum {string}
- */
-export const Profile = {
-  /** Read-only. Agents analyze and suggest but perform no writes. */
-  EXPLORE: 'explore',
-  /** Default. Agents propose actions and wait for user confirmation. */
-  GUIDED: 'guided',
-  /** Full autonomy. Agents execute without confirmation when gates pass. */
-  AUTONOMOUS: 'autonomous',
-};
-
-/** Minimum gate score required to activate autonomous profile */
-export const AUTONOMOUS_GATE_THRESHOLD = 90;
-
-/**
- * Operations that ALWAYS require confirmation regardless of profile.
- * Constitution Article XVIII, point 4.
- */
-export const ALWAYS_CONFIRM_OPERATIONS = [
-  'file_delete',
-  'database_drop',
-  'force_push',
-  'deploy_production',
-  'deviation_activate',
-  'backward_transition',
-];
-
-// ---------------------------------------------------------------------------
-// Profile Management
-// ---------------------------------------------------------------------------
-
-/**
- * Get the current execution profile from session state.
- *
- * @param {string} projectDir
- * @returns {string} Current profile (defaults to 'guided')
- */
-export function getCurrentProfile(projectDir) {
-  const sessionPath = join(projectDir, '.chati', 'session.yaml');
-  if (!existsSync(sessionPath)) return Profile.GUIDED;
-
-  const raw = readFileSync(sessionPath, 'utf-8');
-  const match = raw.match(/^\s*execution_profile:\s*(.+)$/m);
-  const profile = match ? match[1].trim().replace(/^["']|["']$/g, '') : Profile.GUIDED;
-
-  return Object.values(Profile).includes(profile) ? profile : Profile.GUIDED;
-}
-
-/**
- * Check if a write operation is allowed under the current profile.
- *
- * @param {string} profile - Current execution profile
- * @param {string} operation - Operation type (e.g., 'file_write', 'file_delete')
- * @returns {{ allowed: boolean, reason: string }}
- */
-export function isWriteAllowed(profile, operation) {
-  // Explore profile blocks ALL writes
-  if (profile === Profile.EXPLORE) {
-    return { allowed: false, reason: '[Article XVIII] Explore profile: read-only mode. No writes permitted.' };
-  }
-
-  // Always-confirm operations need user approval regardless of profile
-  if (ALWAYS_CONFIRM_OPERATIONS.includes(operation)) {
-    return { allowed: false, reason: `[Article XVIII] Operation "${operation}" always requires user confirmation.` };
-  }
-
-  // Guided profile: allowed but requires confirmation (caller handles confirmation)
-  if (profile === Profile.GUIDED) {
-    return { allowed: true, reason: 'Guided profile: confirmation required.' };
-  }
-
-  // Autonomous profile: allowed without confirmation
-  if (profile === Profile.AUTONOMOUS) {
-    return { allowed: true, reason: 'Autonomous profile: proceeding without confirmation.' };
-  }
-
-  return { allowed: true, reason: 'Default: allowed.' };
-}
-
-/**
- * Validate whether autonomous profile can be activated.
- *
- * @param {string} projectDir
- * @returns {{ canActivate: boolean, reason: string, currentScore: number }}
- */
-export function canActivateAutonomous(projectDir) {
-  const sessionPath = join(projectDir, '.chati', 'session.yaml');
-  if (!existsSync(sessionPath)) {
-    return { canActivate: false, reason: 'No active session', currentScore: 0 };
-  }
-
-  const raw = readFileSync(sessionPath, 'utf-8');
-
-  // Look for most recent QA gate score
-  const scoreMatches = raw.match(/score:\s*([\d.]+)/g);
-  if (!scoreMatches || scoreMatches.length === 0) {
-    return { canActivate: false, reason: 'No gate scores found. Run QA gates first.', currentScore: 0 };
-  }
-
-  const scores = scoreMatches.map((m) => parseFloat(m.replace('score:', '').trim()));
-  const latestScore = scores[scores.length - 1];
-
-  if (latestScore < AUTONOMOUS_GATE_THRESHOLD) {
-    return {
-      canActivate: false,
-      reason: `Gate score ${latestScore}% < required ${AUTONOMOUS_GATE_THRESHOLD}%`,
-      currentScore: latestScore,
-    };
-  }
-
-  return { canActivate: true, reason: 'Gate scores meet threshold', currentScore: latestScore };
-}
-
-/**
- * Check if autonomous profile should be downgraded due to quality drop.
- *
- * @param {number} currentScore - Current quality score
- * @returns {{ shouldDowngrade: boolean, reason: string }}
- */
-export function shouldDowngradeAutonomous(currentScore) {
-  if (currentScore < AUTONOMOUS_GATE_THRESHOLD) {
-    return {
-      shouldDowngrade: true,
-      reason: `Quality dropped to ${currentScore}% (< ${AUTONOMOUS_GATE_THRESHOLD}%). Auto-downgrading to guided profile.`,
-    };
-  }
-  return { shouldDowngrade: false, reason: '' };
-}

package/src/intelligence/file-tracker.js

@@ -1,117 +0,0 @@
-/**
- * @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/memory/gotchas-auto-capture.js

@@ -1,253 +0,0 @@
-/**
- * @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 };