chati-dev 4.3.1 → 4.4.1

package/src/autonomy/cause-analyzer.js

@@ -1,177 +0,0 @@
-/**
- * @fileoverview Cause analysis for failed build loop tasks.
- *
- * Analyzes agent output to classify failure categories, detect
- * repetitive patterns, and generate retry guidance.
- *
- * Constitution Article XVII — Execution Mode Governance.
- */
-
-// ---------------------------------------------------------------------------
-// Failure Categories
-// ---------------------------------------------------------------------------
-
-/**
- * Categories of task failures.
- * @enum {string}
- */
-export const FAILURE_CATEGORIES = {
-  SYNTAX_ERROR: 'syntax_error',
-  TEST_FAILURE: 'test_failure',
-  LINT_VIOLATION: 'lint_violation',
-  TYPE_ERROR: 'type_error',
-  TIMEOUT: 'timeout',
-  SCOPE_VIOLATION: 'scope_violation',
-  DEPENDENCY: 'dependency',
-  RUNTIME_ERROR: 'runtime_error',
-  UNKNOWN: 'unknown',
-};
-
-/**
- * Patterns for classifying failure output.
- */
-const CATEGORY_PATTERNS = [
-  { regex: /SyntaxError|Unexpected token|parsing error|unterminated/i, category: FAILURE_CATEGORIES.SYNTAX_ERROR },
-  { regex: /test.*fail|assertion.*fail|expect.*receive|expected.*but got/i, category: FAILURE_CATEGORIES.TEST_FAILURE },
-  { regex: /lint.*error|eslint|prettier.*error|formatting/i, category: FAILURE_CATEGORIES.LINT_VIOLATION },
-  { regex: /TypeError|type.*mismatch|cannot read propert|is not a function/i, category: FAILURE_CATEGORIES.TYPE_ERROR },
-  { regex: /timeout|ETIMEDOUT|exceeded.*time|timed out/i, category: FAILURE_CATEGORIES.TIMEOUT },
-  { regex: /scope.*violation|cannot write|not allowed.*mode|Article XI/i, category: FAILURE_CATEGORIES.SCOPE_VIOLATION },
-  { regex: /Cannot find module|ENOENT|module not found|import.*failed|missing dependency/i, category: FAILURE_CATEGORIES.DEPENDENCY },
-  { regex: /ReferenceError|RangeError|Error:|runtime error|ENOMEM/i, category: FAILURE_CATEGORIES.RUNTIME_ERROR },
-];
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * Analyze the cause of a task failure.
- *
- * @param {string} output - Agent output/error text
- * @param {Array<{category: string, output: string}>} [previousAttempts=[]] - History of prior attempts
- * @returns {{ category: string, rootCause: string, suggestion: string, isRepetitive: boolean }}
- */
-export function analyzeCause(output, previousAttempts = []) {
-  const text = output || '';
-  const category = classifyOutput(text);
-  const rootCause = extractRootCause(text, category);
-  const suggestion = generateSuggestion(category, rootCause);
-  const isRepetitive = checkRepetitive(category, previousAttempts);
-
-  return { category, rootCause, suggestion, isRepetitive };
-}
-
-/**
- * Build retry guidance for the next attempt based on cause analysis.
- *
- * @param {{ category: string, rootCause: string, suggestion: string, isRepetitive: boolean }} analysis
- * @param {number} attempt - Current attempt number
- * @returns {string} Guidance text for the agent
- */
-export function buildRetryGuidance(analysis, attempt) {
-  const parts = [];
-
-  parts.push(`## Retry Guidance (Attempt ${attempt})`);
-  parts.push('');
-  parts.push(`**Previous failure**: ${analysis.category}`);
-
-  if (analysis.rootCause) {
-    parts.push(`**Root cause**: ${analysis.rootCause}`);
-  }
-
-  parts.push(`**Suggestion**: ${analysis.suggestion}`);
-
-  if (analysis.isRepetitive) {
-    parts.push('');
-    parts.push('**WARNING**: This is a REPETITIVE failure. The same category of error occurred in previous attempts.');
-    parts.push('You MUST try a fundamentally different approach — do not repeat the same fix.');
-  }
-
-  return parts.join('\n');
-}
-
-// ---------------------------------------------------------------------------
-// Internal Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Classify output text into a failure category.
- *
- * @param {string} text
- * @returns {string}
- */
-function classifyOutput(text) {
-  for (const { regex, category } of CATEGORY_PATTERNS) {
-    if (regex.test(text)) {
-      return category;
-    }
-  }
-  return FAILURE_CATEGORIES.UNKNOWN;
-}
-
-/**
- * Extract a concise root cause from the output.
- *
- * @param {string} text
- * @param {string} category
- * @returns {string}
- */
-function extractRootCause(text, category) {
-  if (!text) return 'No output available';
-
-  // Try to find the most informative error line
-  const lines = text.split('\n').filter(l => l.trim());
-
-  // Look for lines containing "Error:" or similar markers
-  const errorLine = lines.find(l =>
-    /error:|Error:|ERR!|FAIL|failed/i.test(l)
-  );
-
-  if (errorLine) {
-    return errorLine.trim().slice(0, 200);
-  }
-
-  // Fall back to last non-empty line (often the summary)
-  if (lines.length > 0) {
-    return lines[lines.length - 1].trim().slice(0, 200);
-  }
-
-  return `${category} detected (no specific error line found)`;
-}
-
-/**
- * Generate a suggestion based on the failure category.
- *
- * @param {string} category
- * @param {string} rootCause
- * @returns {string}
- */
-function generateSuggestion(category, _rootCause) {
-  const suggestions = {
-    [FAILURE_CATEGORIES.SYNTAX_ERROR]: 'Check for missing brackets, semicolons, or malformed expressions. Review the exact line mentioned in the error.',
-    [FAILURE_CATEGORIES.TEST_FAILURE]: 'Review the failing test assertions. Ensure the implementation matches the expected behavior described in the test.',
-    [FAILURE_CATEGORIES.LINT_VIOLATION]: 'Fix formatting and style issues. Check import ordering, unused variables, and indentation.',
-    [FAILURE_CATEGORIES.TYPE_ERROR]: 'Verify that variable types match expected types. Check for null/undefined access and incorrect function signatures.',
-    [FAILURE_CATEGORIES.TIMEOUT]: 'The operation took too long. Consider optimizing the approach or breaking the task into smaller pieces.',
-    [FAILURE_CATEGORIES.SCOPE_VIOLATION]: 'The write operation is outside the allowed scope for the current mode. Only modify files within the permitted directories.',
-    [FAILURE_CATEGORIES.DEPENDENCY]: 'A required module or dependency is missing. Ensure all imports reference existing files and packages are installed.',
-    [FAILURE_CATEGORIES.RUNTIME_ERROR]: 'A runtime error occurred during execution. Check for logic errors, invalid operations, and edge cases.',
-    [FAILURE_CATEGORIES.UNKNOWN]: 'Review the full output to identify the issue. The error does not match known patterns.',
-  };
-
-  return suggestions[category] || suggestions[FAILURE_CATEGORIES.UNKNOWN];
-}
-
-/**
- * Check if the same failure category appeared in previous attempts.
- *
- * @param {string} category
- * @param {Array<{category: string}>} previousAttempts
- * @returns {boolean}
- */
-function checkRepetitive(category, previousAttempts) {
-  if (category === FAILURE_CATEGORIES.UNKNOWN) return false;
-  const sameCategory = previousAttempts.filter(a => a.category === category);
-  return sameCategory.length >= 2;
-}

package/src/autonomy/escalation.js

@@ -1,214 +0,0 @@
-/**
- * @fileoverview Progressive escalation for build loop retries.
- *
- * When a task fails repeatedly, escalation progressively increases
- * the resources (model tier, context enrichment) and ultimately
- * pauses for human intervention.
- *
- * Constitution Article XVII — Execution Mode Governance.
- */
-
-// ---------------------------------------------------------------------------
-// Escalation Levels
-// ---------------------------------------------------------------------------
-
-/**
- * Escalation level definitions.
- * @enum {number}
- */
-export const ESCALATION_LEVELS = {
-  /** Standard — use configured model, no extra context. */
-  STANDARD: 0,
-  /** Enriched — same model, inject cause analysis + retry guidance. */
-  ENRICHED: 1,
-  /** Upgraded — escalate to higher-tier model (e.g. sonnet → opus). */
-  UPGRADED: 2,
-  /** Max — pause execution and request human intervention. */
-  MAX: 3,
-};
-
-/**
- * Model upgrade map — maps current model tier to the next tier.
- * Keys are logical tier names used in chati config.
- */
-const MODEL_UPGRADE_MAP = {
-  haiku: 'sonnet',
-  sonnet: 'opus',
-  opus: 'opus', // opus is ceiling
-  // Gemini equivalents
-  flash: 'pro',
-  pro: 'pro',
-  // Codex equivalents
-  codex: 'codex',
-};
-
-/**
- * Thresholds for automatic escalation.
- */
-const ESCALATION_THRESHOLDS = {
-  /** Attempts before escalating from STANDARD to ENRICHED. */
-  ENRICHED_AFTER: 2,
-  /** Attempts before escalating from ENRICHED to UPGRADED. */
-  UPGRADED_AFTER: 4,
-  /** Attempts before escalating from UPGRADED to MAX. */
-  MAX_AFTER: 7,
-};
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * Get the current escalation level for a task checkpoint.
- *
- * @param {{ attempts: number, escalationLevel?: number }} checkpoint
- * @returns {number} Current escalation level (0-3)
- */
-export function getEscalationLevel(checkpoint) {
-  if (!checkpoint) return ESCALATION_LEVELS.STANDARD;
-
-  // Explicit level takes precedence (set by previous escalation)
-  if (typeof checkpoint.escalationLevel === 'number') {
-    return checkpoint.escalationLevel;
-  }
-
-  // Derive from attempt count
-  const attempts = checkpoint.attempts || 0;
-
-  if (attempts >= ESCALATION_THRESHOLDS.MAX_AFTER) {
-    return ESCALATION_LEVELS.MAX;
-  }
-  if (attempts >= ESCALATION_THRESHOLDS.UPGRADED_AFTER) {
-    return ESCALATION_LEVELS.UPGRADED;
-  }
-  if (attempts >= ESCALATION_THRESHOLDS.ENRICHED_AFTER) {
-    return ESCALATION_LEVELS.ENRICHED;
-  }
-
-  return ESCALATION_LEVELS.STANDARD;
-}
-
-/**
- * Determine whether escalation should occur based on checkpoint
- * state and cause analysis.
- *
- * @param {{ attempts: number, escalationLevel?: number }} checkpoint
- * @param {{ isRepetitive: boolean, category: string }} analysis - Cause analysis result
- * @returns {{ escalate: boolean, newLevel: number, reason: string }}
- */
-export function shouldEscalate(checkpoint, analysis) {
-  const currentLevel = getEscalationLevel(checkpoint);
-  const attempts = checkpoint?.attempts || 0;
-
-  // Already at max — no further escalation
-  if (currentLevel >= ESCALATION_LEVELS.MAX) {
-    return {
-      escalate: false,
-      newLevel: ESCALATION_LEVELS.MAX,
-      reason: 'Already at maximum escalation level',
-    };
-  }
-
-  // Repetitive failures trigger immediate escalation (+1 level)
-  if (analysis?.isRepetitive) {
-    const newLevel = Math.min(currentLevel + 1, ESCALATION_LEVELS.MAX);
-    return {
-      escalate: true,
-      newLevel,
-      reason: `Repetitive ${analysis.category} failure — escalating to level ${newLevel}`,
-    };
-  }
-
-  // Threshold-based escalation
-  let targetLevel = ESCALATION_LEVELS.STANDARD;
-  if (attempts >= ESCALATION_THRESHOLDS.MAX_AFTER) {
-    targetLevel = ESCALATION_LEVELS.MAX;
-  } else if (attempts >= ESCALATION_THRESHOLDS.UPGRADED_AFTER) {
-    targetLevel = ESCALATION_LEVELS.UPGRADED;
-  } else if (attempts >= ESCALATION_THRESHOLDS.ENRICHED_AFTER) {
-    targetLevel = ESCALATION_LEVELS.ENRICHED;
-  }
-
-  if (targetLevel > currentLevel) {
-    return {
-      escalate: true,
-      newLevel: targetLevel,
-      reason: `Attempt ${attempts} reached threshold for level ${targetLevel}`,
-    };
-  }
-
-  return {
-    escalate: false,
-    newLevel: currentLevel,
-    reason: 'No escalation needed',
-  };
-}
-
-/**
- * Get configuration for a given escalation level.
- *
- * @param {number} level - Escalation level (0-3)
- * @param {string} [currentModel='sonnet'] - Current model tier name
- * @returns {{ model: string|null, contextBoost: boolean, shouldPause: boolean, description: string }}
- */
-export function getEscalationConfig(level, currentModel = 'sonnet') {
-  switch (level) {
-    case ESCALATION_LEVELS.STANDARD:
-      return {
-        model: null, // no override
-        contextBoost: false,
-        shouldPause: false,
-        description: 'Standard execution — no escalation',
-      };
-
-    case ESCALATION_LEVELS.ENRICHED:
-      return {
-        model: null, // same model
-        contextBoost: true,
-        shouldPause: false,
-        description: 'Enriched context — cause analysis + retry guidance injected',
-      };
-
-    case ESCALATION_LEVELS.UPGRADED:
-      return {
-        model: MODEL_UPGRADE_MAP[currentModel] || currentModel,
-        contextBoost: true,
-        shouldPause: false,
-        description: `Model upgraded from ${currentModel} to ${MODEL_UPGRADE_MAP[currentModel] || currentModel}`,
-      };
-
-    case ESCALATION_LEVELS.MAX:
-      return {
-        model: MODEL_UPGRADE_MAP[currentModel] || currentModel,
-        contextBoost: true,
-        shouldPause: true,
-        description: 'Maximum escalation — pausing for human intervention',
-      };
-
-    default:
-      return {
-        model: null,
-        contextBoost: false,
-        shouldPause: false,
-        description: `Unknown escalation level: ${level}`,
-      };
-  }
-}
-
-/**
- * Build a human-readable escalation summary.
- *
- * @param {number} level - Escalation level
- * @param {string} reason - Escalation reason
- * @returns {string}
- */
-export function buildEscalationSummary(level, reason) {
-  const levelNames = ['STANDARD', 'ENRICHED', 'UPGRADED', 'MAX'];
-  const name = levelNames[level] || 'UNKNOWN';
-  return `[Escalation ${name}] ${reason}`;
-}
-
-/**
- * Exported for testing — escalation thresholds.
- */
-export { ESCALATION_THRESHOLDS };

package/src/autonomy/index.js

@@ -1,51 +0,0 @@
-/**
- * @fileoverview Autonomy module barrel exports
- * Execution modes, quality gates, progress reporting, and safety nets
- */
-
-export {
-  EXECUTION_MODES,
-  getCurrentMode,
-  setExecutionMode,
-  canActAutonomously,
-  getAlwaysHumanAgents,
-  getModeHistory,
-  clearExecutionMode,
-  getModeStatistics,
-} from './mode-manager.js';
-
-export {
-  suggestMode,
-  calculateRiskScore,
-  getHighRiskDomains,
-} from './mode-suggester.js';
-
-export {
-  GATE_RESULTS,
-  evaluateGate,
-  getGateThreshold,
-  resolveGateAction,
-  getGateHistory,
-  recordGateEvaluation,
-  getGateStatistics,
-  getAgentGateStatistics,
-  clearGateHistory,
-} from './autonomous-gate.js';
-
-export {
-  buildProgressReport,
-  formatProgressLine,
-  formatDetailedReport,
-  calculateCompletion,
-  getStageProgress,
-} from './progress-reporter.js';
-
-export {
-  SAFETY_TRIGGERS,
-  checkSafety,
-  evaluateTrigger,
-  getRecommendedAction,
-  getCriticalRiskKeywords,
-  isCriticalRisk,
-  buildSafetyReport,
-} from './safety-net.js';

package/src/autonomy/mode-manager.js

@@ -1,225 +0,0 @@
-/**
- * @fileoverview Manages execution mode transitions for chati.dev
- * Handles human-in-the-loop vs autonomous execution modes
- */
-
-import { loadSession, updateSession } from '../orchestrator/session-manager.js';
-
-export const EXECUTION_MODES = {
-  HUMAN_IN_THE_LOOP: 'human-in-the-loop',
-  AUTONOMOUS: 'autonomous',
-};
-
-// Agents that ALWAYS require human validation
-const ALWAYS_HUMAN_AGENTS = ['brief', 'deviation'];
-
-/**
- * Get current execution mode from session.
- * @param {string} projectDir
- * @returns {{ mode: string, setAt: string|null, reason: string|null }}
- */
-export function getCurrentMode(projectDir) {
-  const result = loadSession(projectDir);
-
-  if (!result.loaded || !result.session) {
-    return {
-      mode: EXECUTION_MODES.HUMAN_IN_THE_LOOP,
-      setAt: null,
-      reason: null,
-    };
-  }
-
-  const session = result.session;
-
-  if (!session.execution_mode) {
-    return {
-      mode: EXECUTION_MODES.HUMAN_IN_THE_LOOP,
-      setAt: null,
-      reason: null,
-    };
-  }
-
-  return {
-    mode: session.execution_mode.mode || EXECUTION_MODES.HUMAN_IN_THE_LOOP,
-    setAt: session.execution_mode.setAt || null,
-    reason: session.execution_mode.reason || null,
-  };
-}
-
-/**
- * Set execution mode with reason and persist to session.
- * @param {string} projectDir
- * @param {string} mode - 'human-in-the-loop' | 'autonomous'
- * @param {string} reason - Why this mode was selected
- * @returns {{ set: boolean, previous: string }}
- */
-export function setExecutionMode(projectDir, mode, reason) {
-  if (!Object.values(EXECUTION_MODES).includes(mode)) {
-    throw new Error(`Invalid execution mode: ${mode}`);
-  }
-
-  const result = loadSession(projectDir);
-
-  if (!result.loaded || !result.session) {
-    return {
-      set: false,
-      previous: EXECUTION_MODES.HUMAN_IN_THE_LOOP,
-      error: result.error || 'Failed to load session',
-    };
-  }
-
-  const session = result.session;
-  const previous = session.execution_mode?.mode || EXECUTION_MODES.HUMAN_IN_THE_LOOP;
-
-  // Initialize mode_transitions array if it doesn't exist
-  if (!session.mode_transitions) {
-    session.mode_transitions = [];
-  }
-
-  // Record the transition
-  const transition = {
-    from: previous,
-    to: mode,
-    timestamp: new Date().toISOString(),
-    reason,
-  };
-
-  session.mode_transitions.push(transition);
-
-  // Update current mode
-  const updates = {
-    execution_mode: {
-      mode,
-      setAt: transition.timestamp,
-      reason,
-    },
-    mode_transitions: session.mode_transitions,
-  };
-
-  updateSession(projectDir, updates);
-
-  return {
-    set: true,
-    previous,
-  };
-}
-
-/**
- * Check if current mode allows autonomous action for a given agent.
- * Even in autonomous mode, some agents always require human input (brief, deviation).
- * @param {string} mode
- * @param {string} agentName
- * @returns {{ allowed: boolean, reason: string }}
- */
-export function canActAutonomously(mode, agentName) {
-  // Brief and deviation ALWAYS require human input
-  if (ALWAYS_HUMAN_AGENTS.includes(agentName)) {
-    return {
-      allowed: false,
-      reason: `${agentName} always requires human interaction`,
-    };
-  }
-
-  // In human-in-the-loop mode, nothing is autonomous
-  if (mode === EXECUTION_MODES.HUMAN_IN_THE_LOOP) {
-    return {
-      allowed: false,
-      reason: 'Human-in-the-loop mode requires user validation',
-    };
-  }
-
-  // In autonomous mode, all non-always-human agents can act autonomously
-  return {
-    allowed: true,
-    reason: 'Autonomous mode enabled for this agent',
-  };
-}
-
-/**
- * Get agents that ALWAYS require human validation regardless of mode.
- * @returns {string[]}
- */
-export function getAlwaysHumanAgents() {
-  return [...ALWAYS_HUMAN_AGENTS];
-}
-
-/**
- * Get mode transition history.
- * @param {string} projectDir
- * @returns {object[]}
- */
-export function getModeHistory(projectDir) {
-  const result = loadSession(projectDir);
-  if (!result.loaded || !result.session) {
-    return [];
-  }
-  return result.session.mode_transitions || [];
-}
-
-/**
- * Clear execution mode (reset to default).
- * @param {string} projectDir
- * @returns {{ cleared: boolean }}
- */
-export function clearExecutionMode(projectDir) {
-  const result = loadSession(projectDir);
-
-  if (!result.loaded || !result.session) {
-    return {
-      cleared: false,
-      error: result.error || 'Failed to load session',
-    };
-  }
-
-  const previous = result.session.execution_mode;
-
-  updateSession(projectDir, { execution_mode: null });
-
-  return {
-    cleared: true,
-    previous: previous || null,
-  };
-}
-
-/**
- * Get mode statistics from history.
- * @param {string} projectDir
- * @returns {{ totalTransitions: number, timeInAutonomous: number, timeInHuman: number, currentStreak: number }}
- */
-export function getModeStatistics(projectDir) {
-  const history = getModeHistory(projectDir);
-  const current = getCurrentMode(projectDir);
-
-  let timeInAutonomous = 0;
-  let timeInHuman = 0;
-  let currentStreak = 0;
-
-  for (let i = 0; i < history.length; i++) {
-    const transition = history[i];
-    const nextTransition = history[i + 1];
-
-    // Calculate time in each mode
-    if (nextTransition) {
-      const duration = new Date(nextTransition.timestamp) - new Date(transition.timestamp);
-      if (transition.to === EXECUTION_MODES.AUTONOMOUS) {
-        timeInAutonomous += duration;
-      } else {
-        timeInHuman += duration;
-      }
-    }
-
-    // Calculate current streak
-    if (transition.to === current.mode) {
-      currentStreak++;
-    } else {
-      currentStreak = 0;
-    }
-  }
-
-  return {
-    totalTransitions: history.length,
-    timeInAutonomous: Math.floor(timeInAutonomous / 1000), // seconds
-    timeInHuman: Math.floor(timeInHuman / 1000), // seconds
-    currentStreak,
-  };
-}