chati-dev 4.3.1 → 4.4.1

package/src/health/auto-fix.js

@@ -1,216 +0,0 @@
-/**
- * @fileoverview Auto-fix for common health check issues.
- *
- * Automatically repairs stale locks, oversized error logs,
- * missing directories, and other recoverable problems.
- *
- * Constitution Article XIV — Framework Registry Governance.
- */
-
-import { existsSync, mkdirSync, rmSync, statSync, readdirSync, truncateSync } from 'fs';
-import { join } from 'path';
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-/** Maximum error log size before truncation (1 MB). */
-const MAX_ERROR_LOG_SIZE = 1_024 * 1_024;
-
-/** Stale lock file age threshold (30 seconds). */
-const STALE_LOCK_AGE_MS = 30_000;
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * @typedef {object} FixAction
- * @property {string} action - Description of what was fixed
- * @property {boolean} success - Whether the fix was applied
- * @property {string} [error] - Error message if fix failed
- */
-
-/**
- * @typedef {object} AutoFixResult
- * @property {number} fixed - Number of issues fixed
- * @property {number} failed - Number of fixes that failed
- * @property {FixAction[]} actions - Detailed action log
- */
-
-/**
- * Run auto-fix on a project directory.
- *
- * @param {string} projectDir
- * @param {object[]} [checkResults=[]] - Results from health checks (for targeted fixes)
- * @returns {AutoFixResult}
- */
-export function autoFix(projectDir, _checkResults = []) {
-  const actions = [];
-
-  // Fix 1: Ensure required directories exist
-  actions.push(...fixMissingDirectories(projectDir));
-
-  // Fix 2: Remove stale .lock files
-  actions.push(...fixStaleLocks(projectDir));
-
-  // Fix 3: Truncate oversized error logs
-  actions.push(...fixOversizedLogs(projectDir));
-
-  // Fix 4: Clean up orphaned worktrees directory entries
-  actions.push(...fixOrphanedWorktrees(projectDir));
-
-  const fixed = actions.filter(a => a.success).length;
-  const failed = actions.filter(a => !a.success).length;
-
-  return { fixed, failed, actions };
-}
-
-// ---------------------------------------------------------------------------
-// Individual Fixers
-// ---------------------------------------------------------------------------
-
-/**
- * Ensure required .chati/ subdirectories exist.
- *
- * @param {string} projectDir
- * @returns {FixAction[]}
- */
-function fixMissingDirectories(projectDir) {
-  const actions = [];
-  const requiredDirs = [
-    '.chati',
-    '.chati/memory',
-    '.chati/metrics',
-  ];
-
-  for (const dir of requiredDirs) {
-    const fullPath = join(projectDir, dir);
-    if (!existsSync(fullPath)) {
-      try {
-        mkdirSync(fullPath, { recursive: true });
-        actions.push({ action: `Created missing directory: ${dir}`, success: true });
-      } catch (err) {
-        actions.push({ action: `Failed to create ${dir}`, success: false, error: err.message });
-      }
-    }
-  }
-
-  return actions;
-}
-
-/**
- * Remove .lock files that are stale (old + no active PID).
- *
- * @param {string} projectDir
- * @returns {FixAction[]}
- */
-function fixStaleLocks(projectDir) {
-  const actions = [];
-  const chatiDir = join(projectDir, '.chati');
-
-  if (!existsSync(chatiDir)) return actions;
-
-  try {
-    const entries = readdirSync(chatiDir);
-    const lockFiles = entries.filter(e => e.endsWith('.lock'));
-
-    for (const lockFile of lockFiles) {
-      const lockPath = join(chatiDir, lockFile);
-      try {
-        const stat = statSync(lockPath);
-        const age = Date.now() - stat.mtimeMs;
-
-        if (age > STALE_LOCK_AGE_MS) {
-          rmSync(lockPath, { force: true });
-          actions.push({ action: `Removed stale lock: ${lockFile}`, success: true });
-        }
-      } catch (err) {
-        actions.push({ action: `Failed to check lock ${lockFile}`, success: false, error: err.message });
-      }
-    }
-  } catch { /* expected: path may already be removed */
-    // Directory read failed — skip
-  }
-
-  return actions;
-}
-
-/**
- * Truncate oversized error/gotcha logs.
- *
- * @param {string} projectDir
- * @returns {FixAction[]}
- */
-function fixOversizedLogs(projectDir) {
-  const actions = [];
-  const logFiles = [
-    join(projectDir, '.chati', 'memory', 'errors.json'),
-    join(projectDir, '.chati', 'memory', 'gotchas.json'),
-  ];
-
-  for (const logPath of logFiles) {
-    if (!existsSync(logPath)) continue;
-
-    try {
-      const stat = statSync(logPath);
-      if (stat.size > MAX_ERROR_LOG_SIZE) {
-        truncateSync(logPath, 0);
-        actions.push({
-          action: `Truncated oversized log: ${logPath.split('/').pop()} (${Math.round(stat.size / 1024)}KB)`,
-          success: true,
-        });
-      }
-    } catch (err) {
-      actions.push({
-        action: `Failed to truncate ${logPath.split('/').pop()}`,
-        success: false,
-        error: err.message,
-      });
-    }
-  }
-
-  return actions;
-}
-
-/**
- * Clean up orphaned worktree directory entries (empty dirs).
- *
- * @param {string} projectDir
- * @returns {FixAction[]}
- */
-function fixOrphanedWorktrees(projectDir) {
-  const actions = [];
-  const worktreeDir = join(projectDir, '.chati', 'worktrees');
-
-  if (!existsSync(worktreeDir)) return actions;
-
-  try {
-    const entries = readdirSync(worktreeDir);
-
-    for (const entry of entries) {
-      const entryPath = join(worktreeDir, entry);
-      try {
-        const stat = statSync(entryPath);
-        if (stat.isDirectory()) {
-          const contents = readdirSync(entryPath);
-          if (contents.length === 0) {
-            rmSync(entryPath, { recursive: true, force: true });
-            actions.push({ action: `Removed empty worktree dir: ${entry}`, success: true });
-          }
-        }
-      } catch { /* expected: directory may not exist */
-        // Skip entries we can't read
-      }
-    }
-  } catch { /* expected: directory may not exist */
-    // Directory read failed
-  }
-
-  return actions;
-}
-
-/**
- * Exported constants for testing.
- */
-export { MAX_ERROR_LOG_SIZE, STALE_LOCK_AGE_MS };

package/src/health/engine.js

@@ -1,246 +0,0 @@
-/**
- * @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 } from 'fs';
-import { join } from 'path';
-import { isCommandAvailable, parseProviderConfig } from '../utils/config-parser.js';
-import { resolveFrameworkDir } from '../utils/framework-dir.js';
-
-// ---------------------------------------------------------------------------
-// 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, resolveFrameworkDir(projectDir), 'config.yaml');
-
-  if (!existsSync(configPath)) {
-    return { name: 'cli-availability', status: 'warn', message: 'No config.yaml found', duration: Date.now() - start };
-  }
-
-  const { enabled } = parseProviderConfig(projectDir);
-  const missing = [];
-
-  for (const provider of enabled) {
-    const available = await isCommandAvailable(provider);
-    if (!available) {
-      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, resolveFrameworkDir(projectDir), '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, resolveFrameworkDir(projectDir), '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 { /* expected: content may be malformed */
-    issues.push('Node.js not found');
-  }
-
-  // Check git
-  try {
-    execSync('git --version', { stdio: 'ignore' });
-  } catch { /* expected: git command may fail */
-    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(),
-  };
-}