autonomous-flow-daemon 1.0.0 → 1.1.0

package/src/daemon/server.ts

@@ -8,9 +8,11 @@ import { diagnose } from "../core/immune";
 import type { PatchOp } from "../core/immune";
 import { detectEcosystem } from "../adapters/index";
 import type { DetectionResult } from "../adapters/index";
+import { calcHealMetrics, maybeHealBoast, formatHealLog, formatDormantLog, buildShiftSummary } from "../core/boast";
+import { discoverWatchTargets } from "../core/discovery";
 
 // ── Suppression Safety Constants ──
-const DOUBLE_TAP_WINDOW_MS = 60_000; // 60 seconds
+const DOUBLE_TAP_WINDOW_MS = 30_000;  // 30 seconds — balances demo speed and production safety
 const MASS_EVENT_THRESHOLD = 3;       // >3 unlinks in 1 second
 const MASS_EVENT_WINDOW_MS = 1_000;   // 1 second window
 
@@ -36,6 +38,7 @@ interface DaemonState {
   firstTapTimestamps: Map<string, number>;
   suppressionSkippedCount: number;
   dormantTransitions: { antibodyId: string; at: number }[];
+  totalFileBytesSaved: number;
 }
 
 const state: DaemonState = {
@@ -52,6 +55,7 @@ const state: DaemonState = {
   firstTapTimestamps: new Map(),
   suppressionSkippedCount: 0,
   dormantTransitions: [],
+  totalFileBytesSaved: 0,
 };
 
 function cleanup() {
@@ -59,7 +63,11 @@ function cleanup() {
   try { unlinkSync(PORT_FILE); } catch {}
 }
 
-function main() {
+interface DaemonOptions {
+  mcp?: boolean;
+}
+
+export function main(options: DaemonOptions = {}) {
   // Detect ecosystem at startup
   state.ecosystems = detectEcosystem(process.cwd());
 
@@ -75,6 +83,32 @@ function main() {
   const findAntibodyByFile = db.prepare("SELECT id, dormant FROM antibodies WHERE file_target = ? AND dormant = 0");
   const setAntibodyDormant = db.prepare("UPDATE antibodies SET dormant = 1 WHERE id = ?");
 
+  // ── S.E.A.M Cycle Logger ──
+  function seam(phase: string, msg: string) {
+    console.log(`[afd] [${phase}] ${msg}`);
+  }
+
+  // ── Auto-Seed Antibodies on Startup ──
+  // Read existing immune-critical files and learn antibodies so they can be restored on delete
+  function seedAntibodies() {
+    const immuneFiles = [
+      { id: "IMM-001", path: ".claudeignore" },
+      { id: "IMM-002", path: ".claude/hooks.json" },
+      { id: "IMM-003", path: "CLAUDE.md" },
+    ];
+
+    for (const { id, path: filePath } of immuneFiles) {
+      if (existsSync(filePath)) {
+        const content = readFileSync(filePath, "utf-8");
+        const patches: PatchOp[] = [{ op: "add", path: `/${filePath}`, value: content }];
+        insertAntibody.run(id, "auto-seed", filePath, JSON.stringify(patches));
+        seam("Adapt", `Antibody ${id} seeded for ${filePath} (${content.length} bytes)`);
+      }
+    }
+  }
+
+  seedAntibodies();
+
   // ── Suppression Safety: Helper Functions ──
 
   /** Check if we're in a mass-event burst (>3 unlinks within 1 second) */
@@ -89,21 +123,33 @@ function main() {
     state.firstTapTimestamps.clear();
   }
 
-  /** Auto-heal: re-apply patches for a given antibody */
+  /** Auto-heal: re-apply patches for a given antibody, with metrics & boast */
   function autoHealFile(antibodyId: string, fileTarget: string, patchOp: string) {
+    const t0 = performance.now();
     try {
+      seam("Mutate", `Restoring ${fileTarget} via antibody ${antibodyId}...`);
       const patches = JSON.parse(patchOp) as PatchOp[];
+      let bytesWritten = 0;
       for (const patch of patches) {
         if (patch.op === "add" && patch.value) {
           const targetPath = resolve(patch.path.replace(/^\//, ""));
           writeFileSync(targetPath, patch.value, "utf-8");
+          bytesWritten += patch.value.length;
         }
       }
+      const healMs = Math.round(performance.now() - t0);
       state.autoHealCount++;
+      state.totalFileBytesSaved += bytesWritten;
       state.autoHealLog.push({ id: antibodyId, at: Date.now() });
       if (state.autoHealLog.length > 100) state.autoHealLog.shift();
-    } catch {
-      // Crash-only: if healing fails, let it go
+
+      // Delightful logging: metrics + occasional boast
+      const metrics = calcHealMetrics(bytesWritten, healMs);
+      const boast = maybeHealBoast(5); // 1-in-5 chance
+      const fileName = fileTarget.split("/").pop() ?? fileTarget;
+      console.log(formatHealLog(fileName, metrics, boast));
+    } catch (err) {
+      seam("Mutate", `FAILED to restore ${fileTarget}: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
 
@@ -111,7 +157,11 @@ function main() {
    * Handle unlink event with Double-Tap and Mass-Event heuristics.
    * Returns true if the event was handled (healed or made dormant).
    */
-  function handleUnlink(filePath: string, now: number): boolean {
+  /**
+   * Handle unlink event with Double-Tap and Mass-Event heuristics.
+   * Returns: "healed" | "dormant" | null
+   */
+  function handleUnlink(filePath: string, now: number): "healed" | "dormant" | null {
     // Record for mass-event detection
     state.recentUnlinks.push(now);
     insertUnlinkLog.run(filePath, now);
@@ -120,18 +170,18 @@ function main() {
     if (isMassEvent(now)) {
       state.suppressionSkippedCount++;
       clearTapsOnMassEvent();
-      return false; // Do nothing — likely git checkout or bulk operation
+      return null; // Do nothing — likely git checkout or bulk operation
     }
 
     // Find active (non-dormant) antibody protecting this file
     const antibody = findAntibodyByFile.get(filePath) as { id: string; dormant: number } | null;
-    if (!antibody) return false; // No antibody for this file
+    if (!antibody) return null; // No antibody for this file
 
     // Fetch full antibody data for healing
     const fullAntibody = db.prepare("SELECT * FROM antibodies WHERE id = ?").get(antibody.id) as {
       id: string; patch_op: string; file_target: string;
     } | null;
-    if (!fullAntibody) return false;
+    if (!fullAntibody) return null;
 
     // Double-Tap detection
     const previousTap = state.firstTapTimestamps.get(filePath);
@@ -141,19 +191,29 @@ function main() {
       setAntibodyDormant.run(antibody.id);
       state.firstTapTimestamps.delete(filePath);
       state.dormantTransitions.push({ antibodyId: antibody.id, at: now });
-      return true; // Dormant — do NOT heal
+      console.log(formatDormantLog(antibody.id));
+      return "dormant";
     }
 
     // FIRST TAP: record timestamp and auto-heal
     state.firstTapTimestamps.set(filePath, now);
     autoHealFile(fullAntibody.id, fullAntibody.file_target, fullAntibody.patch_op);
-    return true;
+    return "healed";
+  }
+
+  // ── Smart Discovery: scan for AI-context files ──
+  const discovery = discoverWatchTargets(WATCH_TARGETS);
+  seam("Sense", `Smart Discovery: ${discovery.targets.length} targets found in ${discovery.elapsedMs}ms`);
+  if (discovery.discoveredCount > 0) {
+    seam("Sense", `Discovered ${discovery.discoveredCount} extra: ${discovery.targets.filter(t => !WATCH_TARGETS.includes(t)).join(", ")}`);
   }
 
-  // File watcher
-  const watcher = watch(WATCH_TARGETS, {
+  // File watcher — atomic: 100 to handle rapid delete-recreate cycles
+  // watcher.add() after restore ensures re-detection (see handleUnlink caller)
+  const watcher = watch(discovery.targets, {
     ignoreInitial: false,
     persistent: true,
+    atomic: 100,
   });
 
   watcher.on("all", (event, path) => {
@@ -165,12 +225,68 @@ function main() {
     }
     insertEvent.run(event, path, Date.now());
 
-    // Suppression safety: handle unlink events
+    // S.E.A.M cycle logging
+    seam("Sense", `${event} → ${path}`);
+
     if (event === "unlink") {
-      handleUnlink(path, Date.now());
+      seam("Extract", `File deleted: ${path} — checking antibodies`);
+      const result = handleUnlink(path, Date.now());
+      if (result === "healed") {
+        seam("Mutate", `Restore complete for ${path}`);
+        // Re-add to watcher so future deletes are detected
+        watcher.add(path);
+      } else if (result === "dormant") {
+        seam("Adapt", `Double-tap confirmed — ${path} deletion honored`);
+      } else {
+        seam("Extract", `No antibody found for ${path} — skipped`);
+      }
+    } else if (event === "change") {
+      // Re-seed antibody on file change so restore always has latest content
+      const immuneMap: Record<string, string> = {
+        ".claudeignore": "IMM-001",
+        ".claude/hooks.json": "IMM-002",
+        "CLAUDE.md": "IMM-003",
+      };
+      const abId = immuneMap[path];
+      if (abId && existsSync(path)) {
+        const content = readFileSync(path, "utf-8");
+        const patches: PatchOp[] = [{ op: "add", path: `/${path}`, value: content }];
+        insertAntibody.run(abId, "auto-seed", path, JSON.stringify(patches));
+        seam("Adapt", `Antibody ${abId} refreshed for ${path}`);
+      }
     }
   });
 
+  // ── MCP stdio mode: JSON-RPC over stdin/stdout ──
+  if (options.mcp) {
+    console.error("[afd] MCP stdio mode — awaiting JSON-RPC on stdin");
+    (async () => {
+      const decoder = new TextDecoder();
+      for await (const chunk of Bun.stdin.stream()) {
+        const line = decoder.decode(chunk).trim();
+        if (!line) continue;
+        try {
+          const req = JSON.parse(line);
+          const response = {
+            jsonrpc: "2.0",
+            id: req.id,
+            result: {
+              tools: [
+                { name: "afd_diagnose", description: "Run afd health diagnosis" },
+                { name: "afd_score", description: "Get daemon score/stats" },
+                { name: "afd_hologram", description: "Generate hologram for a file" },
+              ],
+            },
+          };
+          process.stdout.write(JSON.stringify(response) + "\n");
+        } catch {
+          // Crash-only: malformed input is ignored
+        }
+      }
+    })();
+    return; // file watcher + stdin loop keep process alive
+  }
+
   // HTTP server for IPC
   const server = Bun.serve({
     port: 0,
@@ -271,7 +387,7 @@ function main() {
           lastEvent: state.lastEvent,
           lastEventAt: state.lastEventAt,
           watchedFiles: state.watchedFiles,
-          watchTargets: WATCH_TARGETS,
+          watchTargets: discovery.targets,
           hologram: {
             requests: hs.totalRequests,
             originalChars: hs.totalOriginalChars,
@@ -340,6 +456,20 @@ function main() {
         return Response.json({ status: "exported", path: payloadPath, count: sanitized.length });
       }
 
+      if (url.pathname === "/shift-summary") {
+        const uptime = Math.floor((Date.now() - state.startedAt) / 1000);
+        const eventCount = db.query("SELECT COUNT(*) as cnt FROM events").get() as { cnt: number };
+        const summary = buildShiftSummary({
+          uptimeSeconds: uptime,
+          totalEvents: eventCount.cnt,
+          healsPerformed: state.autoHealCount,
+          totalFileBytesSaved: state.totalFileBytesSaved,
+          suppressionsSkipped: state.suppressionSkippedCount,
+          dormantTransitions: state.dormantTransitions.length,
+        });
+        return Response.json(summary);
+      }
+
       if (url.pathname === "/stop") {
         cleanup();
         setTimeout(() => process.exit(0), 100);
@@ -368,4 +498,7 @@ function main() {
   process.on("SIGINT", () => { cleanup(); process.exit(0); });
 }
 
-main();
+// Auto-execute when run directly (not imported)
+if (import.meta.main) {
+  main();
+}

package/src/platform.ts

@@ -0,0 +1,39 @@
+import { platform } from "os";
+import type { SpawnOptions } from "child_process";
+
+export const IS_WINDOWS = platform() === "win32";
+export const IS_MACOS = platform() === "darwin";
+export const IS_LINUX = platform() === "linux";
+
+/**
+ * Returns spawn options appropriate for detaching a background daemon.
+ * On Windows, `shell: true` is required for `detached` to create a new console.
+ */
+export function detachedSpawnOptions(
+  logFd: number,
+): SpawnOptions {
+  const base: SpawnOptions = {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    cwd: process.cwd(),
+    env: { ...process.env },
+  };
+
+  if (IS_WINDOWS) {
+    // Windows needs shell:true for detached to work properly
+    // and windowsHide to prevent a console flash
+    return { ...base, shell: true, windowsHide: true };
+  }
+
+  return base;
+}
+
+/**
+ * Resolve the hook command for invoking afd diagnose.
+ * Priority:
+ *   1. Global `afd` binary (npm/bun global install)
+ *   2. `bunx afd` fallback
+ */
+export function resolveHookCommand(): string {
+  return "afd diagnose --format a2a --auto-heal";
+}