autonomous-flow-daemon 1.1.0 → 1.9.0

package/src/cli.ts

@@ -1,57 +1,162 @@
-#!/usr/bin/env bun
-import { Command } from "commander";
-import { startCommand } from "./commands/start";
-import { stopCommand } from "./commands/stop";
-import { scoreCommand } from "./commands/score";
-import { fixCommand } from "./commands/fix";
-import { syncCommand } from "./commands/sync";
-import { diagnoseCommand } from "./commands/diagnose";
-import { langCommand } from "./commands/lang";
-
-const program = new Command();
-
-program
-  .name("afd")
-  .description("Autonomous Flow Daemon - The Immune System for AI Workflows")
-  .version("1.1.0");
-
-program
-  .command("start")
-  .description("Start the afd daemon (background file watcher)")
-  .option("--mcp", "Run in MCP stdio mode (for Claude Code tool integration)")
-  .action(startCommand);
-
-program
-  .command("stop")
-  .description("Stop the afd daemon")
-  .action(stopCommand);
-
-program
-  .command("score")
-  .description("Show current diagnostic stats from the daemon")
-  .action(scoreCommand);
-
-program
-  .command("fix")
-  .description("Auto-fix detected issues in AI workflow config")
-  .action(fixCommand);
-
-program
-  .command("sync")
-  .description("Synchronize AI agent configs across team")
-  .action(syncCommand);
-
-program
-  .command("diagnose")
-  .description("Run headless diagnosis (used by auto-heal hooks)")
-  .option("--format <type>", "Output format: a2a or human", "human")
-  .option("--auto-heal", "Auto-apply patches for known antibodies")
-  .action(diagnoseCommand);
-
-program
-  .command("lang [language]")
-  .description("Show or change display language (en, ko)")
-  .option("--list", "Show all supported languages")
-  .action(langCommand);
-
-program.parse();
+#!/usr/bin/env bun
+import { Command } from "commander";
+import { startCommand } from "./commands/start";
+import { stopCommand } from "./commands/stop";
+import { restartCommand } from "./commands/restart";
+import { statusCommand } from "./commands/status";
+import { scoreCommand } from "./commands/score";
+import { dashboardCommand } from "./commands/dashboard";
+import { fixCommand } from "./commands/fix";
+import { syncCommand } from "./commands/sync";
+import { diagnoseCommand } from "./commands/diagnose";
+import { doctorCommand } from "./commands/doctor";
+
+import { vaccineCommand } from "./commands/vaccine";
+import { langCommand } from "./commands/lang";
+import { evolutionCommand } from "./commands/evolution";
+import { mcpCommand } from "./commands/mcp";
+import { statsCommand } from "./commands/stats";
+import { hooksCommand } from "./commands/hooks";
+import { benchmarkCommand } from "./commands/benchmark";
+import { suggestCommand } from "./commands/suggest";
+import { correlateCommand } from "./commands/correlate";
+import { pluginCommand } from "./commands/plugin";
+import { APP_VERSION } from "./version";
+import { trackCliCommand } from "./core/telemetry";
+
+const program = new Command();
+
+program
+  .name("afd")
+  .description("Autonomous Flow Daemon - The Immune System for AI Workflows")
+  .version(APP_VERSION);
+
+program.hook("preAction", (thisCommand) => {
+  trackCliCommand(thisCommand.name());
+});
+
+program
+  .command("start")
+  .description("Start the afd daemon (background file watcher)")
+  .option("--mcp", "Run in MCP stdio mode (for Claude Code tool integration)")
+  .action(startCommand);
+
+program
+  .command("stop")
+  .description("Stop the afd daemon")
+  .option("--clean", "Remove all injected hooks and MCP registrations")
+  .action(stopCommand);
+
+program
+  .command("restart")
+  .description("Restart the afd daemon (stop + start)")
+  .action(restartCommand);
+
+program
+  .command("status")
+  .description("Quick health check — daemon, hooks, defenses, quarantine")
+  .action(statusCommand);
+
+program
+  .command("score")
+  .description("Show current diagnostic stats from the daemon")
+  .action(scoreCommand);
+
+program
+  .command("dashboard")
+  .description("Live token savings dashboard — real-time TUI (Ctrl+C to exit)")
+  .action(dashboardCommand);
+
+program
+  .command("fix")
+  .description("Auto-fix detected issues in AI workflow config")
+  .action(fixCommand);
+
+program
+  .command("sync")
+  .description("Synchronize AI agent configs across team")
+  .option("--push", "Push local antibodies to team vaccine store")
+  .option("--pull", "Pull antibodies from team vaccine store")
+  .option("--remote <url>", "Remote vaccine store URL for push/pull")
+  .option("--local-mesh", "Bidirectional sync with all live mesh peers (monorepo)")
+  .action(syncCommand);
+
+program
+  .command("doctor")
+  .description("Deep health analysis with recommendations and auto-fix")
+  .option("--fix", "Auto-fix detected issues")
+  .action(doctorCommand);
+
+program
+  .command("diagnose")
+  .description("Run headless diagnosis (used by auto-heal hooks)")
+  .option("--format <type>", "Output format: a2a or human", "human")
+  .option("--auto-heal", "Auto-apply patches for known antibodies")
+  .action(diagnoseCommand);
+
+program
+  .command("vaccine [subcommand] [arg]")
+  .description("Vaccine registry: list, search, install, publish")
+  .action(vaccineCommand);
+
+program
+  .command("evolution")
+  .description("Self-Evolution: analyze quarantined failures and generate lessons for AI agents")
+  .option("--generate", "Auto-generate validators from all quarantine patterns")
+  .action(evolutionCommand);
+
+program
+  .command("suggest")
+  .description("Suggest validators based on recurring failure patterns in mistake history")
+  .option("--days <n>", "Analysis window in days", "30")
+  .option("--min <n>", "Minimum frequency threshold", "3")
+  .option("--apply", "Auto-generate validators for uncovered patterns")
+  .option("--cross", "Annotate suggestions matching cross-project hotspots as Community Verified")
+  .action(suggestCommand);
+
+program
+  .command("correlate")
+  .description("Cross-project pattern correlation — surface Global Hotspot patterns across federated scopes")
+  .option("--min-scopes <n>", "Minimum distinct scopes to qualify as a global hotspot", "2")
+  .option("--apply", "Auto-generate global validators for uncovered hotspots")
+  .option("--include-local", "Include local-scope antibodies in the analysis")
+  .action(correlateCommand);
+
+program
+  .command("mcp [subcommand]")
+  .description("MCP server management (install)")
+  .action(mcpCommand);
+
+program
+  .command("lang [language]")
+  .description("Show or change display language (en, ko)")
+  .option("--list", "Show all supported languages")
+  .action(langCommand);
+
+program
+  .command("stats")
+  .description("Feature usage telemetry dashboard (developer-only)")
+  .option("--days <n>", "Number of days to aggregate", "7")
+  .action(statsCommand);
+
+program
+  .command("hooks [subcommand]")
+  .description("Hook Manager: inspect and sync hook ordering (afd → omc → user)")
+  .action(hooksCommand);
+
+program
+  .command("benchmark")
+  .description("Hologram AST compression benchmark across all source files")
+  .option("--sort <key>", "Sort by: savings (default), size, name")
+  .option("--top <n>", "Show only top N files")
+  .option("--json", "Output raw JSON for programmatic use")
+  .action(benchmarkCommand);
+
+program
+  .command("plugin")
+  .description("Manage third-party validator plugins (install, list, remove)")
+  .argument("[subcommand]", "install | list | remove")
+  .argument("[arg]", "npm package name or plugin name")
+  .action(pluginCommand);
+
+program.parse();

package/src/commands/benchmark.ts

@@ -0,0 +1,187 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+import { generateHologram } from "../core/hologram";
+import { getSystemLanguage } from "../core/locale";
+
+// ── ANSI helpers ──
+const C = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+  white: "\x1b[37m",
+};
+
+interface FileResult {
+  path: string;
+  originalLines: number;
+  hologramLines: number;
+  originalChars: number;
+  hologramChars: number;
+  savings: number;
+}
+
+function collectTsFiles(dir: string, base: string): string[] {
+  const results: string[] = [];
+  const skipDirs = new Set(["node_modules", ".git", ".afd", "dist", "coverage", ".omc"]);
+
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      if (!skipDirs.has(entry.name)) {
+        results.push(...collectTsFiles(join(dir, entry.name), base));
+      }
+    } else if (/\.(ts|tsx|js|jsx)$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
+      results.push(join(dir, entry.name));
+    }
+  }
+  return results;
+}
+
+function formatChars(n: number): string {
+  if (n < 1000) return `${n}`;
+  if (n < 1_000_000) return `${(n / 1000).toFixed(1)}K`;
+  return `${(n / 1_000_000).toFixed(1)}M`;
+}
+
+function savingsColor(pct: number): string {
+  if (pct >= 80) return C.green;
+  if (pct >= 50) return C.yellow;
+  return C.red;
+}
+
+function padRight(s: string, w: number): string {
+  const stripped = s.replace(/\x1b\[[0-9;]*m/g, "");
+  return s + " ".repeat(Math.max(0, w - stripped.length));
+}
+
+function padLeft(s: string, w: number): string {
+  const stripped = s.replace(/\x1b\[[0-9;]*m/g, "");
+  return " ".repeat(Math.max(0, w - stripped.length)) + s;
+}
+
+export async function benchmarkCommand(options: { sort?: string; top?: string; json?: boolean }) {
+  const lang = getSystemLanguage();
+  const ko = lang === "ko";
+  const cwd = process.cwd();
+  const files = collectTsFiles(join(cwd, "src"), cwd);
+
+  if (files.length === 0) {
+    console.error(`${C.red}[afd] ${ko ? "src/ 디렉토리에 TS/JS 파일이 없습니다." : "No TS/JS files found in src/."}${C.reset}`);
+    process.exit(1);
+  }
+
+  const results: FileResult[] = [];
+  const startTime = performance.now();
+
+  for (const filePath of files) {
+    try {
+      const source = readFileSync(filePath, "utf-8");
+      const { hologram, originalLength, hologramLength, savings } = await generateHologram(filePath, source);
+      results.push({
+        path: relative(cwd, filePath),
+        originalLines: source.split("\n").length,
+        hologramLines: hologram.split("\n").length,
+        originalChars: originalLength,
+        hologramChars: hologramLength,
+        savings: Math.round(savings * 10) / 10,
+      });
+    } catch {
+      // Skip files that fail to parse
+    }
+  }
+
+  const elapsed = Math.round(performance.now() - startTime);
+
+  // Sort
+  const sortKey = options.sort ?? "savings";
+  results.sort((a, b) => {
+    if (sortKey === "size") return b.originalChars - a.originalChars;
+    if (sortKey === "name") return a.path.localeCompare(b.path);
+    return b.savings - a.savings; // default: savings desc
+  });
+
+  const limit = options.top ? parseInt(options.top, 10) : results.length;
+  const display = results.slice(0, limit);
+
+  // JSON output
+  if (options.json) {
+    const totalOriginal = results.reduce((s, r) => s + r.originalChars, 0);
+    const totalHologram = results.reduce((s, r) => s + r.hologramChars, 0);
+    console.log(JSON.stringify({
+      files: results.length,
+      totalOriginalChars: totalOriginal,
+      totalHologramChars: totalHologram,
+      totalSavedChars: totalOriginal - totalHologram,
+      overallCompression: totalOriginal > 0 ? Math.round((1 - totalHologram / totalOriginal) * 1000) / 10 : 0,
+      estimatedTokensSaved: Math.round((totalOriginal - totalHologram) / 4),
+      elapsedMs: elapsed,
+      results: results.map(r => ({
+        path: r.path,
+        originalLines: r.originalLines,
+        hologramLines: r.hologramLines,
+        originalChars: r.originalChars,
+        hologramChars: r.hologramChars,
+        savings: r.savings,
+      })),
+    }, null, 2));
+    return;
+  }
+
+  // ── Header ──
+  console.log();
+  console.log(`${C.bold}${C.cyan}  ╔══════════════════════════════════════════════════════════════╗${C.reset}`);
+  console.log(`${C.bold}${C.cyan}  ║       ${ko ? "홀로그램 AST 압축 벤치마크" : "Hologram AST Compression Benchmark"}                       ║${C.reset}`);
+  console.log(`${C.bold}${C.cyan}  ╚══════════════════════════════════════════════════════════════╝${C.reset}`);
+  console.log();
+
+  // ── Table Header ──
+  const colFile = ko ? "파일" : "File";
+  const colLines = ko ? "원본줄" : "Lines";
+  const colHolo = ko ? "홀로줄" : "Holo";
+  const colOrig = ko ? "원본" : "Original";
+  const colComp = ko ? "압축" : "Compressed";
+  const colSave = ko ? "절감률" : "Savings";
+
+  console.log(
+    `  ${C.dim}${padRight(colFile, 40)} ${padLeft(colLines, 6)} ${padLeft(colHolo, 6)} ${padLeft(colOrig, 8)} ${padLeft(colComp, 8)} ${padLeft(colSave, 8)}${C.reset}`
+  );
+  console.log(`  ${C.dim}${"─".repeat(80)}${C.reset}`);
+
+  // ── Rows ──
+  for (const r of display) {
+    const sc = savingsColor(r.savings);
+    const savingsStr = `${sc}${r.savings.toFixed(1)}%${C.reset}`;
+    console.log(
+      `  ${padRight(r.path, 40)} ${padLeft(String(r.originalLines), 6)} ${padLeft(String(r.hologramLines), 6)} ${padLeft(formatChars(r.originalChars), 8)} ${padLeft(formatChars(r.hologramChars), 8)} ${padLeft(savingsStr, 8)}`
+    );
+  }
+
+  if (limit < results.length) {
+    console.log(`  ${C.dim}... ${ko ? `외 ${results.length - limit}개 파일` : `and ${results.length - limit} more files`}${C.reset}`);
+  }
+
+  // ── Summary ──
+  const totalOriginal = results.reduce((s, r) => s + r.originalChars, 0);
+  const totalHologram = results.reduce((s, r) => s + r.hologramChars, 0);
+  const totalSaved = totalOriginal - totalHologram;
+  const overallPct = totalOriginal > 0 ? Math.round((1 - totalHologram / totalOriginal) * 1000) / 10 : 0;
+  const estimatedTokens = Math.round(totalSaved / 4);
+  const high = results.filter(r => r.savings >= 70).length;
+
+  console.log();
+  console.log(`  ${C.dim}${"─".repeat(80)}${C.reset}`);
+  console.log(`  ${C.bold}${ko ? "요약" : "Summary"}${C.reset}`);
+  console.log();
+  console.log(`  ${ko ? "분석 파일" : "Files analyzed"}     ${C.bold}${results.length}${C.reset}`);
+  console.log(`  ${ko ? "전체 압축률" : "Overall compression"} ${C.bold}${savingsColor(overallPct)}${overallPct}%${C.reset}`);
+  console.log(`  ${ko ? "원본 크기" : "Original size"}      ${C.bold}${formatChars(totalOriginal)}${C.reset} ${C.dim}(${(totalOriginal / 1024).toFixed(0)} KB)${C.reset}`);
+  console.log(`  ${ko ? "압축 크기" : "Compressed size"}    ${C.bold}${formatChars(totalHologram)}${C.reset} ${C.dim}(${(totalHologram / 1024).toFixed(0)} KB)${C.reset}`);
+  console.log(`  ${ko ? "절약 크기" : "Saved"}              ${C.bold}${C.green}${formatChars(totalSaved)}${C.reset} ${C.dim}(${(totalSaved / 1024).toFixed(0)} KB)${C.reset}`);
+  console.log(`  ${ko ? "추정 토큰 절약" : "Est. tokens saved"}  ${C.bold}${C.green}~${estimatedTokens.toLocaleString()}${C.reset}`);
+  console.log(`  ${ko ? "70%+ 압축 파일" : "70%+ compression"}   ${C.bold}${high}${C.reset}/${results.length} ${C.dim}(${Math.round(high / results.length * 100)}%)${C.reset}`);
+  console.log(`  ${ko ? "처리 시간" : "Elapsed"}            ${C.dim}${elapsed}ms${C.reset}`);
+  console.log();
+}

package/src/commands/correlate.ts

@@ -0,0 +1,180 @@
+/**
+ * afd correlate — Cross-Project Pattern Correlation CLI
+ *
+ * Analyzes federated antibodies (scope != 'local') to surface Global Hotspot
+ * patterns that recur across 2+ distinct project scopes.
+ */
+
+import { correlatePatterns } from "../core/correlation-engine";
+import { generateValidator } from "../core/validator-generator";
+import type { ValidatorGenInput } from "../core/validator-generator";
+import { initDb } from "../core/db";
+import { getSystemLanguage } from "../core/locale";
+
+interface CorrelateOptions {
+  minScopes?: string;
+  apply?: boolean;
+  includeLocal?: boolean;
+}
+
+const msgs = {
+  en: {
+    title: "afd correlate — Cross-Project Pattern Correlation",
+    noData: "No cross-project patterns found. Pull antibodies from a remote store first:\n   afd sync --pull --remote <url>",
+    noDataLocal: "No cross-project patterns found even with local scope included.",
+    header: "Global Hotspot patterns detected across multiple projects:",
+    scopes: "scopes",
+    occurrences: "occurrences",
+    covered: "validator exists",
+    uncovered: "no validator",
+    variants: "variants",
+    scopeList: "projects",
+    applyTitle: "Auto-generating global validators for uncovered hotspots...",
+    applyDone: (n: number) => `${n} global validator(s) generated. Daemon will hot-reload automatically.`,
+    applySkipped: (n: number) => `${n} hotspot(s) already covered — skipped.`,
+    hint: "Run `afd correlate --apply` to generate global validators for uncovered hotspots.",
+    confidence: "confidence",
+    communityVerified: "Community Verified",
+    minScopesLabel: "Min scopes",
+    totalScopes: "Scopes in dataset",
+  },
+  ko: {
+    title: "afd correlate — 크로스 프로젝트 패턴 상관관계",
+    noData: "크로스 프로젝트 패턴을 찾지 못했습니다. 원격 스토어에서 항체를 먼저 Pull 하세요:\n   afd sync --pull --remote <url>",
+    noDataLocal: "로컬 스코프 포함 시에도 크로스 프로젝트 패턴을 찾지 못했습니다.",
+    header: "여러 프로젝트에서 감지된 글로벌 핫스팟 패턴:",
+    scopes: "스코프",
+    occurrences: "발생",
+    covered: "검증기 있음",
+    uncovered: "검증기 없음",
+    variants: "변형",
+    scopeList: "프로젝트",
+    applyTitle: "미보호 핫스팟에 대한 글로벌 검증기 자동 생성 중...",
+    applyDone: (n: number) => `${n}개 글로벌 검증기 생성 완료. 데몬이 자동으로 핫 리로드합니다.`,
+    applySkipped: (n: number) => `${n}개 핫스팟은 이미 보호됨 — 건너뜀.`,
+    hint: "`afd correlate --apply`를 실행하여 미보호 핫스팟의 글로벌 검증기를 자동 생성하세요.",
+    confidence: "신뢰도",
+    communityVerified: "커뮤니티 검증됨",
+    minScopesLabel: "최소 스코프",
+    totalScopes: "데이터셋 내 스코프",
+  },
+};
+
+const BOX = { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│", ml: "├", mr: "┤" };
+const W = 62;
+
+function hline(l: string, r: string) { return `${l}${BOX.h.repeat(W)}${r}`; }
+function row(s: string) {
+  const pad = Math.max(0, W - 2 - s.length);
+  return `${BOX.v} ${s}${" ".repeat(pad)} ${BOX.v}`;
+}
+
+export async function correlateCommand(opts: CorrelateOptions = {}) {
+  const lang = getSystemLanguage();
+  const m = msgs[lang];
+
+  const minScopes = parseInt(opts.minScopes ?? "2", 10) || 2;
+  const includeLocal = opts.includeLocal ?? false;
+
+  const db = initDb();
+  try {
+    const result = correlatePatterns(db, { minScopes, includeLocal, limit: 10 });
+
+    if (result.hotspots.length === 0) {
+      console.log(`[afd correlate] ${includeLocal ? m.noDataLocal : m.noData}`);
+      return;
+    }
+
+    // ── Apply mode ──────────────────────────────────────────────────────────
+    if (opts.apply) {
+      const uncovered = result.hotspots.filter(h => !h.alreadyCovered);
+      const covered = result.hotspots.filter(h => h.alreadyCovered);
+
+      if (uncovered.length === 0) {
+        console.log(`[afd correlate] ${m.applySkipped(covered.length)}`);
+        return;
+      }
+
+      console.log(`[afd correlate] ${m.applyTitle}`);
+      let generated = 0;
+
+      for (const h of uncovered) {
+        const input = buildGlobalValidatorInput(h.canonicalType);
+        if (!input) continue;
+        const res = generateValidator(input);
+        if (res.written) {
+          console.log(`  ✅ ${res.filename}  (${h.scopeCount} ${m.scopes})`);
+          generated++;
+        }
+      }
+
+      console.log(`[afd correlate] ${m.applyDone(generated)}`);
+      if (covered.length > 0) {
+        console.log(`[afd correlate] ${m.applySkipped(covered.length)}`);
+      }
+      return;
+    }
+
+    // ── Display mode ────────────────────────────────────────────────────────
+    console.log("");
+    console.log(hline(BOX.tl, BOX.tr));
+    console.log(row(`🌐 ${m.title}`));
+    console.log(hline(BOX.ml, BOX.mr));
+    console.log(row(`${m.totalScopes}: ${result.totalScopes} | ${m.minScopesLabel}: ${minScopes}`));
+    console.log(hline(BOX.ml, BOX.mr));
+
+    for (let i = 0; i < result.hotspots.length; i++) {
+      const h = result.hotspots[i];
+      const statusIcon = h.alreadyCovered ? "🛡️" : "⚠️";
+      const statusText = h.alreadyCovered ? m.covered : m.uncovered;
+      const rank = `#${i + 1}`;
+      const confStr = `${Math.round(h.confidence * 100)}%`;
+
+      console.log(row(`${rank} ${statusIcon} ${h.canonicalType}`));
+      console.log(row(`   ${h.scopeCount} ${m.scopes} | ${h.totalOccurrences} ${m.occurrences} | ${m.confidence}: ${confStr}`));
+      console.log(row(`   ${m.scopeList}: ${h.scopes.join(", ")}`));
+      console.log(row(`   ${statusText}`));
+
+      if (h.variants.length > 1) {
+        const maxVarW = W - 16;
+        const varStr = h.variants.slice(1).join(", ");
+        const truncated = varStr.length > maxVarW ? varStr.slice(0, maxVarW - 3) + "..." : varStr;
+        console.log(row(`   ↳ ${m.variants}: ${truncated}`));
+      }
+
+      if (i < result.hotspots.length - 1) {
+        console.log(row(""));
+      }
+    }
+
+    const uncoveredCount = result.hotspots.filter(h => !h.alreadyCovered).length;
+    if (uncoveredCount > 0) {
+      console.log(hline(BOX.ml, BOX.mr));
+      console.log(row(`💡 ${m.hint}`));
+    }
+    console.log(hline(BOX.bl, BOX.br));
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Build a ValidatorGenInput for a global hotspot based on its pattern type.
+ */
+function buildGlobalValidatorInput(patternType: string): ValidatorGenInput | null {
+  const pt = patternType.toLowerCase();
+
+  if (pt.includes("delet") || pt.includes("removal")) {
+    return { failureType: "deletion", originalPath: "global", corruptedContent: "DELETED", restoredContent: null };
+  }
+  if (pt.includes("empty") || pt.includes("blank")) {
+    return { failureType: "corruption", originalPath: "global", corruptedContent: "", restoredContent: null };
+  }
+  if (pt.includes("truncat")) {
+    return { failureType: "corruption", originalPath: "global", corruptedContent: "x", restoredContent: null };
+  }
+  if (pt.includes("json") || pt.includes("syntax") || pt.includes("parse")) {
+    return { failureType: "corruption", originalPath: "global.json", corruptedContent: "{invalid", restoredContent: null };
+  }
+  return { failureType: "corruption", originalPath: "global", corruptedContent: "corrupted", restoredContent: null };
+}