autonomous-flow-daemon 1.0.0

package/src/commands/stop.ts

@@ -0,0 +1,35 @@
+import { getDaemonInfo, isDaemonAlive, daemonRequest } from "../daemon/client";
+import { unlinkSync } from "fs";
+import { PID_FILE, PORT_FILE } from "../constants";
+
+function cleanupFiles() {
+  try { unlinkSync(PID_FILE); } catch {}
+  try { unlinkSync(PORT_FILE); } catch {}
+}
+
+export async function stopCommand() {
+  const info = getDaemonInfo();
+  if (!info) {
+    console.log("[afd] No daemon running.");
+    return;
+  }
+
+  if (await isDaemonAlive(info)) {
+    try {
+      await daemonRequest("/stop");
+      console.log(`[afd] Daemon stopped (pid=${info.pid})`);
+    } catch {
+      // Force kill if graceful stop fails
+      try {
+        process.kill(info.pid, "SIGTERM");
+        console.log(`[afd] Daemon killed (pid=${info.pid})`);
+      } catch {
+        console.log("[afd] Daemon process already gone.");
+      }
+    }
+  } else {
+    console.log("[afd] Daemon not responding. Cleaning up stale PID files.");
+  }
+
+  cleanupFiles();
+}

package/src/commands/sync.ts

@@ -0,0 +1,50 @@
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import { daemonRequest } from "../daemon/client";
+import { AFD_DIR } from "../constants";
+
+interface SyncResponse {
+  status: string;
+  path: string;
+  count: number;
+}
+
+export async function syncCommand() {
+  let result: SyncResponse;
+  try {
+    result = await daemonRequest<SyncResponse>("/sync");
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[afd sync] ${msg}`);
+    process.exit(1);
+  }
+
+  if (result.count === 0) {
+    console.log("[afd sync] No antibodies to export. Run `afd fix` first to learn patterns.");
+    return;
+  }
+
+  // Read the generated payload for display
+  const payloadPath = resolve(AFD_DIR, "global-vaccine-payload.json");
+  const payload = JSON.parse(readFileSync(payloadPath, "utf-8"));
+
+  const box = "\u2500".repeat(46);
+  console.log(`\u250C${box}\u2510`);
+  console.log(`\u2502  afd sync \u2014 Vaccine Network                    \u2502`);
+  console.log(`\u251C${box}\u2524`);
+  console.log(`\u2502  Ecosystem  : ${payload.ecosystem.padEnd(31)}\u2502`);
+  console.log(`\u2502  Antibodies : ${String(payload.antibodyCount).padEnd(31)}\u2502`);
+  console.log(`\u2502  Generated  : ${payload.generatedAt.substring(0, 19).padEnd(31)}\u2502`);
+  console.log(`\u251C${box}\u2524`);
+
+  for (const ab of payload.antibodies) {
+    const patches = ab.patches.map((p: { op: string; path: string }) => `${p.op} ${p.path}`).join(", ");
+    console.log(`\u2502  [${ab.id}] ${ab.patternType.padEnd(20)} ${patches.substring(0, 12).padEnd(12)}\u2502`);
+  }
+
+  console.log(`\u251C${box}\u2524`);
+  console.log(`\u2502  Payload: .afd/global-vaccine-payload.json     \u2502`);
+  console.log(`\u2514${box}\u2518`);
+  console.log();
+  console.log(`[afd sync] Vaccine payload generated. ${result.count} antibody(ies) ready for global federation.`);
+}

package/src/constants.ts

@@ -0,0 +1,7 @@
+import { join } from "path";
+
+export const AFD_DIR = ".afd";
+export const PID_FILE = join(AFD_DIR, "daemon.pid");
+export const PORT_FILE = join(AFD_DIR, "daemon.port");
+export const DB_FILE = join(AFD_DIR, "antibodies.sqlite");
+export const WATCH_TARGETS = [".claude/", "CLAUDE.md", ".cursorrules"];

package/src/core/db.ts

@@ -0,0 +1,46 @@
+import { mkdirSync } from "fs";
+import { Database } from "bun:sqlite";
+import { AFD_DIR, DB_FILE } from "../constants";
+
+export function initDb(): Database {
+  mkdirSync(AFD_DIR, { recursive: true });
+  const db = new Database(DB_FILE);
+  db.exec("PRAGMA journal_mode = WAL");
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      type TEXT NOT NULL,
+      path TEXT NOT NULL,
+      timestamp INTEGER NOT NULL
+    )
+  `);
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS antibodies (
+      id TEXT PRIMARY KEY,
+      pattern_type TEXT NOT NULL,
+      file_target TEXT NOT NULL,
+      patch_op TEXT NOT NULL,
+      dormant INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+
+  // Migration: add dormant column if missing (existing DBs)
+  try {
+    db.exec("ALTER TABLE antibodies ADD COLUMN dormant INTEGER NOT NULL DEFAULT 0");
+  } catch {
+    // Column already exists — safe to ignore
+  }
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS unlink_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_path TEXT NOT NULL,
+      timestamp INTEGER NOT NULL
+    )
+  `);
+
+  return db;
+}

package/src/core/hologram.ts

@@ -0,0 +1,243 @@
+import ts from "typescript";
+
+export interface HologramResult {
+  hologram: string;
+  originalLength: number;
+  hologramLength: number;
+  savings: number; // percentage 0-100
+}
+
+export function generateHologram(filePath: string, source: string): HologramResult {
+  const sf = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true);
+  const lines: string[] = [];
+
+  for (const stmt of sf.statements) {
+    const line = extractNode(stmt, source);
+    if (line) lines.push(line);
+  }
+
+  const hologram = lines.join("\n");
+  const originalLength = source.length;
+  const hologramLength = hologram.length;
+  const savings = originalLength > 0
+    ? Math.round((originalLength - hologramLength) / originalLength * 1000) / 10
+    : 0;
+
+  return { hologram, originalLength, hologramLength, savings };
+}
+
+function extractNode(node: ts.Node, source: string): string | null {
+  // Import declarations — keep as-is
+  if (ts.isImportDeclaration(node)) {
+    return node.getText().replace(/\s+/g, " ").trim();
+  }
+
+  // Export declarations (re-exports)
+  if (ts.isExportDeclaration(node)) {
+    return node.getText().replace(/\s+/g, " ").trim();
+  }
+
+  // Export assignment (export default ...)
+  if (ts.isExportAssignment(node)) {
+    return `export default ${getTypeName(node.expression)};`;
+  }
+
+  // Type alias
+  if (ts.isTypeAliasDeclaration(node)) {
+    return collapseWhitespace(node.getText());
+  }
+
+  // Interface
+  if (ts.isInterfaceDeclaration(node)) {
+    return extractInterface(node);
+  }
+
+  // Enum
+  if (ts.isEnumDeclaration(node)) {
+    return extractEnum(node);
+  }
+
+  // Class
+  if (ts.isClassDeclaration(node)) {
+    return extractClass(node);
+  }
+
+  // Function declaration
+  if (ts.isFunctionDeclaration(node)) {
+    return extractFunction(node);
+  }
+
+  // Variable statement (const/let/var — may contain arrow functions, objects, etc.)
+  if (ts.isVariableStatement(node)) {
+    return extractVariableStatement(node);
+  }
+
+  // Fallback: skip unknown top-level statements
+  return null;
+}
+
+function extractInterface(node: ts.InterfaceDeclaration): string {
+  const mods = getModifiers(node);
+  const name = node.name.text;
+  const ext = node.heritageClauses
+    ? " " + node.heritageClauses.map(h => h.getText()).join(", ")
+    : "";
+  const members = node.members.map(m => {
+    const text = collapseWhitespace(m.getText()).replace(/;$/, "");
+    return "  " + text + ";";
+  }).join("\n");
+  return `${mods}interface ${name}${ext} {\n${members}\n}`;
+}
+
+function extractEnum(node: ts.EnumDeclaration): string {
+  const mods = getModifiers(node);
+  const name = node.name.text;
+  const members = node.members.map(m => collapseWhitespace(m.getText())).join(", ");
+  return `${mods}enum ${name} { ${members} }`;
+}
+
+function extractClass(node: ts.ClassDeclaration): string {
+  const mods = getModifiers(node);
+  const name = node.name?.text ?? "Anonymous";
+  const ext = node.heritageClauses
+    ? " " + node.heritageClauses.map(h => h.getText()).join(", ")
+    : "";
+
+  const members: string[] = [];
+  for (const member of node.members) {
+    if (ts.isPropertyDeclaration(member)) {
+      members.push("  " + extractProperty(member) + ";");
+    } else if (ts.isMethodDeclaration(member) || ts.isGetAccessor(member) || ts.isSetAccessor(member)) {
+      members.push("  " + extractMethodSignature(member) + ";");
+    } else if (ts.isConstructorDeclaration(member)) {
+      const params = extractParams(member.parameters);
+      members.push(`  constructor(${params});`);
+    }
+  }
+
+  return `${mods}class ${name}${ext} {\n${members.join("\n")}\n}`;
+}
+
+function extractFunction(node: ts.FunctionDeclaration): string {
+  const mods = getModifiers(node);
+  const name = node.name?.text ?? "anonymous";
+  const typeParams = node.typeParameters
+    ? `<${node.typeParameters.map(t => t.getText()).join(", ")}>`
+    : "";
+  const params = extractParams(node.parameters);
+  const ret = node.type ? ": " + collapseWhitespace(node.type.getText()) : "";
+  const async = hasModifier(node, ts.SyntaxKind.AsyncKeyword) ? "async " : "";
+  return `${mods}${async}function ${name}${typeParams}(${params})${ret} {…}`;
+}
+
+function extractVariableStatement(node: ts.VariableStatement): string {
+  const mods = getModifiers(node);
+  const keyword = node.declarationList.flags & ts.NodeFlags.Const ? "const"
+    : node.declarationList.flags & ts.NodeFlags.Let ? "let" : "var";
+
+  const decls = node.declarationList.declarations.map(d => {
+    const name = d.name.getText();
+    const typeAnn = d.type ? ": " + collapseWhitespace(d.type.getText()) : "";
+
+    if (d.initializer) {
+      // Arrow function or function expression
+      if (ts.isArrowFunction(d.initializer) || ts.isFunctionExpression(d.initializer)) {
+        const fn = d.initializer;
+        const async = hasModifier(fn, ts.SyntaxKind.AsyncKeyword) ? "async " : "";
+        const typeParams = fn.typeParameters
+          ? `<${fn.typeParameters.map(t => t.getText()).join(", ")}>`
+          : "";
+        const params = extractParams(fn.parameters);
+        const ret = fn.type ? ": " + collapseWhitespace(fn.type.getText()) : "";
+        return `${name} = ${async}${typeParams}(${params})${ret} => {…}`;
+      }
+      // Object/array/other — just show type or truncated value
+      if (typeAnn) return `${name}${typeAnn}`;
+      return `${name} = …`;
+    }
+
+    return `${name}${typeAnn}`;
+  });
+
+  return `${mods}${keyword} ${decls.join(", ")};`;
+}
+
+function extractProperty(node: ts.PropertyDeclaration): string {
+  const mods = getMemberModifiers(node);
+  const name = node.name.getText();
+  const type = node.type ? ": " + collapseWhitespace(node.type.getText()) : "";
+  const optional = node.questionToken ? "?" : "";
+  return `${mods}${name}${optional}${type}`;
+}
+
+function extractMethodSignature(node: ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration): string {
+  const mods = getMemberModifiers(node);
+  const name = node.name.getText();
+  const async = hasModifier(node, ts.SyntaxKind.AsyncKeyword) ? "async " : "";
+
+  if (ts.isGetAccessor(node)) {
+    const ret = node.type ? ": " + collapseWhitespace(node.type.getText()) : "";
+    return `${mods}get ${name}()${ret}`;
+  }
+  if (ts.isSetAccessor(node)) {
+    const params = extractParams(node.parameters);
+    return `${mods}set ${name}(${params})`;
+  }
+
+  const md = node as ts.MethodDeclaration;
+  const typeParams = md.typeParameters
+    ? `<${md.typeParameters.map(t => t.getText()).join(", ")}>`
+    : "";
+  const params = extractParams(md.parameters);
+  const ret = md.type ? ": " + collapseWhitespace(md.type.getText()) : "";
+  return `${mods}${async}${name}${typeParams}(${params})${ret}`;
+}
+
+function extractParams(params: ts.NodeArray<ts.ParameterDeclaration>): string {
+  return params.map(p => {
+    const name = p.name.getText();
+    const optional = p.questionToken ? "?" : "";
+    const type = p.type ? ": " + collapseWhitespace(p.type.getText()) : "";
+    const rest = p.dotDotDotToken ? "..." : "";
+    return `${rest}${name}${optional}${type}`;
+  }).join(", ");
+}
+
+function getModifiers(node: ts.Node): string {
+  const mods = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+  if (!mods) return "";
+  const relevant = mods
+    .filter(m => m.kind === ts.SyntaxKind.ExportKeyword || m.kind === ts.SyntaxKind.DefaultKeyword || m.kind === ts.SyntaxKind.DeclareKeyword)
+    .map(m => m.getText());
+  return relevant.length ? relevant.join(" ") + " " : "";
+}
+
+function getMemberModifiers(node: ts.Node): string {
+  const mods = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+  if (!mods) return "";
+  const relevant = mods
+    .filter(m =>
+      m.kind === ts.SyntaxKind.PublicKeyword ||
+      m.kind === ts.SyntaxKind.PrivateKeyword ||
+      m.kind === ts.SyntaxKind.ProtectedKeyword ||
+      m.kind === ts.SyntaxKind.StaticKeyword ||
+      m.kind === ts.SyntaxKind.ReadonlyKeyword ||
+      m.kind === ts.SyntaxKind.AbstractKeyword
+    )
+    .map(m => m.getText());
+  return relevant.length ? relevant.join(" ") + " " : "";
+}
+
+function hasModifier(node: ts.Node, kind: ts.SyntaxKind): boolean {
+  const mods = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+  return mods?.some(m => m.kind === kind) ?? false;
+}
+
+function getTypeName(node: ts.Node): string {
+  if (ts.isIdentifier(node)) return node.text;
+  return "…";
+}
+
+function collapseWhitespace(s: string): string {
+  return s.replace(/\s+/g, " ").trim();
+}

package/src/core/immune.ts

@@ -0,0 +1,150 @@
+import { existsSync, readFileSync } from "fs";
+
+// RFC 6902 JSON-Patch operation
+export interface PatchOp {
+  op: "add" | "remove" | "replace" | "move" | "copy" | "test";
+  path: string;
+  value?: string;
+}
+
+export interface Symptom {
+  id: string;
+  patternType: string;
+  fileTarget: string;
+  // Front-stage: human-readable
+  title: string;
+  description: string;
+  severity: "critical" | "warning" | "info";
+  // Back-stage: AI-optimized
+  patches: PatchOp[];
+}
+
+export interface DiagnosisResult {
+  symptoms: Symptom[];
+  healthy: string[];
+}
+
+const CLAUDEIGNORE_DEFAULT = `# Autonomous Flow Daemon defaults
+node_modules/
+dist/
+.afd/
+*.log
+.env
+`;
+
+const HOOKS_DEFAULT = `{
+  "hooks": []
+}
+`;
+
+type Check = () => Symptom | null;
+
+const checks: Check[] = [
+  // Check 1: Missing .claudeignore
+  () => {
+    if (existsSync(".claudeignore")) return null;
+    return {
+      id: "IMM-001",
+      patternType: "missing-file",
+      fileTarget: ".claudeignore",
+      title: "Missing .claudeignore",
+      description:
+        "No .claudeignore found. Without it, AI agents ingest node_modules, build artifacts, and other noise — wasting tokens and degrading context quality.",
+      severity: "critical",
+      patches: [
+        { op: "add", path: "/.claudeignore", value: CLAUDEIGNORE_DEFAULT },
+      ],
+    };
+  },
+
+  // Check 2: Missing .claude/hooks.json fallback
+  () => {
+    const hooksPath = ".claude/hooks.json";
+    if (existsSync(hooksPath)) {
+      try {
+        const content = readFileSync(hooksPath, "utf-8");
+        JSON.parse(content);
+        return null;
+      } catch {
+        return {
+          id: "IMM-002",
+          patternType: "invalid-json",
+          fileTarget: hooksPath,
+          title: "Invalid hooks.json",
+          description:
+            "hooks.json exists but contains invalid JSON. Agents may fail silently when hooks cannot be parsed.",
+          severity: "critical",
+          patches: [
+            { op: "replace", path: "/.claude/hooks.json", value: HOOKS_DEFAULT },
+          ],
+        };
+      }
+    }
+    return {
+      id: "IMM-002",
+      patternType: "missing-file",
+      fileTarget: hooksPath,
+      title: "No fallback in hooks.json",
+      description:
+        "No .claude/hooks.json found. Without a hooks file, pre/post-command automation cannot be configured.",
+      severity: "warning",
+      patches: [
+        { op: "add", path: "/.claude/hooks.json", value: HOOKS_DEFAULT },
+      ],
+    };
+  },
+
+  // Check 3: CLAUDE.md missing or empty
+  () => {
+    if (!existsSync("CLAUDE.md")) {
+      return {
+        id: "IMM-003",
+        patternType: "missing-file",
+        fileTarget: "CLAUDE.md",
+        title: "Missing CLAUDE.md",
+        description:
+          "No CLAUDE.md found. AI agents have no project constitution to follow.",
+        severity: "critical",
+        patches: [
+          { op: "add", path: "/CLAUDE.md", value: "# Project Constitution\n\n<!-- Add project rules here -->\n" },
+        ],
+      };
+    }
+    const content = readFileSync("CLAUDE.md", "utf-8").trim();
+    if (content.length < 20) {
+      return {
+        id: "IMM-003",
+        patternType: "insufficient-content",
+        fileTarget: "CLAUDE.md",
+        title: "CLAUDE.md is nearly empty",
+        description:
+          `CLAUDE.md has only ${content.length} chars. Agents work better with clear project rules.`,
+        severity: "info",
+        patches: [],
+      };
+    }
+    return null;
+  },
+];
+
+export function diagnose(knownAntibodies: string[], opts?: { raw?: boolean }): DiagnosisResult {
+  const symptoms: Symptom[] = [];
+  const healthy: string[] = [];
+
+  for (const check of checks) {
+    const symptom = check();
+    if (!symptom) {
+      healthy.push("OK");
+      continue;
+    }
+    // In raw mode, report all symptoms regardless of antibodies
+    // (used by auto-heal to detect regressions)
+    if (!opts?.raw && knownAntibodies.includes(symptom.id)) {
+      healthy.push(`${symptom.id} (immunized)`);
+      continue;
+    }
+    symptoms.push(symptom);
+  }
+
+  return { symptoms, healthy };
+}

package/src/core/notify.ts

@@ -0,0 +1,35 @@
+import { spawn } from "child_process";
+
+/**
+ * Fire an OS-native toast notification (Windows 10+).
+ * Runs asynchronously, never blocks, silently ignores all errors.
+ */
+export function notifyAutoHeal(patternId: string): void {
+  const title = "\u{1F6E1}\uFE0F afd Auto-Healed";
+  const body = `Silently fixed: ${patternId}`;
+
+  // PowerShell BalloonTip — fire and forget
+  const ps = `
+    Add-Type -AssemblyName System.Windows.Forms
+    $n = New-Object System.Windows.Forms.NotifyIcon
+    $n.Icon = [System.Drawing.SystemIcons]::Shield
+    $n.BalloonTipTitle = '${title}'
+    $n.BalloonTipText = '${body}'
+    $n.BalloonTipIcon = 'Info'
+    $n.Visible = $true
+    $n.ShowBalloonTip(3000)
+    Start-Sleep -Milliseconds 3500
+    $n.Dispose()
+  `.replace(/\n\s*/g, " ");
+
+  try {
+    const child = spawn("powershell", ["-NoProfile", "-NonInteractive", "-Command", ps], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    child.unref();
+  } catch {
+    // Crash-only: silently ignore notification failures
+  }
+}

package/src/daemon/client.ts

@@ -0,0 +1,37 @@
+import { readFileSync, existsSync } from "fs";
+import { PID_FILE, PORT_FILE } from "../constants";
+
+export interface DaemonInfo {
+  pid: number;
+  port: number;
+}
+
+export function getDaemonInfo(): DaemonInfo | null {
+  if (!existsSync(PID_FILE) || !existsSync(PORT_FILE)) return null;
+  const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
+  const port = parseInt(readFileSync(PORT_FILE, "utf-8").trim(), 10);
+  if (isNaN(pid) || isNaN(port)) return null;
+  return { pid, port };
+}
+
+export async function isDaemonAlive(info: DaemonInfo): Promise<boolean> {
+  try {
+    const res = await fetch(`http://127.0.0.1:${info.port}/health`, {
+      signal: AbortSignal.timeout(2000),
+    });
+    const data = await res.json() as { status: string; pid: number };
+    return data.status === "alive" && data.pid === info.pid;
+  } catch {
+    return false;
+  }
+}
+
+export async function daemonRequest<T = unknown>(path: string): Promise<T> {
+  const info = getDaemonInfo();
+  if (!info) throw new Error("Daemon not running. Run `afd start` first.");
+  const res = await fetch(`http://127.0.0.1:${info.port}${path}`, {
+    signal: AbortSignal.timeout(5000),
+  });
+  if (!res.ok) throw new Error(`Daemon returned ${res.status}`);
+  return res.json() as T;
+}