autonomous-flow-daemon 1.0.0 → 1.6.0

package/src/daemon/types.ts

@@ -0,0 +1,100 @@
+/**
+ * Shared types for the afd daemon modules.
+ */
+
+import type { DetectionResult } from "../adapters/index";
+import type { PatchOp } from "../core/immune";
+import type { LruStringMap } from "../core/lru-map";
+
+// ── Constants ──
+export const DOUBLE_TAP_WINDOW_MS = 30_000;
+export const MASS_EVENT_THRESHOLD = 3;
+export const MASS_EVENT_WINDOW_MS = 1_000;
+export const TAP_CLEANUP_INTERVAL_MS = 60_000;
+export const SELF_WRITE_DEBOUNCE_MS = 100;
+export const MAX_SSE_CLIENTS = 20;
+export const VALIDATOR_TIMEOUT_MS = 500;
+export const VALIDATORS_DIR = ".afd/validators";
+
+// ── Types ──
+export type ValidatorFn = (newContent: string, filePath: string) => boolean;
+
+export interface HologramStats {
+  totalRequests: number;
+  totalOriginalChars: number;
+  totalHologramChars: number;
+  sessionOriginalChars: number;
+  sessionHologramChars: number;
+}
+
+export interface MistakeEntry {
+  mistake_type: string;
+  description: string;
+  timestamp: number;
+}
+
+export interface DaemonState {
+  startedAt: number;
+  filesDetected: number;
+  lastEvent: string | null;
+  lastEventAt: number | null;
+  watchedFiles: Set<string>;
+  hologramStats: HologramStats;
+  ecosystems: DetectionResult[];
+  autoHealCount: number;
+  autoHealLog: { id: string; at: number }[];
+  recentUnlinks: number[];
+  firstTapTimestamps: Map<string, number>;
+  suppressionSkippedCount: number;
+  dormantTransitions: { antibodyId: string; at: number }[];
+  totalFileBytesSaved: number;
+  totalSavedTokens: number;
+  fileSnapshots: LruStringMap;
+  sseClients: Set<ReadableStreamDefaultController<Uint8Array>>;
+  customValidators: Map<string, ValidatorFn>;
+  mistakeCache: Map<string, MistakeEntry[]>;
+}
+
+export interface DaemonOptions {
+  mcp?: boolean;
+}
+
+export { type PatchOp, type DetectionResult };
+
+/**
+ * DaemonContext — shared dependency bag passed to all daemon modules.
+ * Created once in main() and threaded through MCP/HTTP handlers.
+ */
+export interface DaemonContext {
+  state: DaemonState;
+  db: { query: (sql: string) => { get: () => unknown }; prepare: (sql: string) => { run: (...args: unknown[]) => void; get: (...args: unknown[]) => unknown; all: () => unknown[] } };
+  ws: { root: string; afdDir: string; pidFile: string; portFile: string; dbFile: string; logFile: string; quarantineDir: string };
+
+  // Prepared statements
+  insertEvent: { run: (...args: unknown[]) => void };
+  insertAntibody: { run: (...args: unknown[]) => void };
+  listAntibodies: { all: () => unknown[] };
+  antibodyIds: { all: () => { id: string }[] };
+  countAntibodies: { get: () => { cnt: number } };
+  getDailyAll: { all: () => { date: string; requests: number; original_chars: number; hologram_chars: number }[] };
+  insertTelemetry: { run: (...args: unknown[]) => void };
+  insertMistakeHistory: { run: (...args: unknown[]) => void };
+  queryMistakesByFile: { all: (...args: unknown[]) => MistakeEntry[] };
+  deleteMistakeOverflow: { run: (...args: unknown[]) => void };
+
+  // Helper functions
+  seam: (phase: string, msg: string) => void;
+  persistHologramStats: (originalChars: number, hologramChars: number) => void;
+  safeHologram: (filePath: string, source: string) => Promise<string>;
+  getWorkspaceMap: () => string;
+  today: () => string;
+
+  // Discovery
+  discoveryTargets: string[];
+
+  // Options
+  options: DaemonOptions;
+
+  // Mutable port (set after Bun.serve)
+  port: number;
+}

package/src/daemon/workspace-map.ts

@@ -0,0 +1,92 @@
+/**
+ * Workspace Map — cached project structure with export signatures.
+ * Provides afd://workspace-map MCP resource.
+ */
+
+import { readdirSync, readFileSync, lstatSync } from "fs";
+import { join } from "path";
+
+const MAX_WALK_DEPTH = 8;
+const SKIP_DIRS = new Set(["node_modules", ".afd", ".git", "dist", "coverage"]);
+const CODE_EXTS = /\.[tj]sx?$/;
+const DOC_EXTS = /\.(ts|js|tsx|jsx|json|md)$/;
+
+/** Build a workspace map: file tree with sizes and export signatures */
+function buildWorkspaceMap(): string {
+  const cwd = process.cwd();
+  const lines: string[] = [`# Workspace Map — ${cwd}`, `# Generated: ${new Date().toISOString()}`, ""];
+
+  function walk(dir: string, prefix: string, depth: number) {
+    if (depth > MAX_WALK_DEPTH) return;
+    let entries: string[];
+    try { entries = readdirSync(dir).sort(); } catch { return; }
+    for (const entry of entries) {
+      if (SKIP_DIRS.has(entry)) continue;
+      const fullPath = join(dir, entry);
+      try {
+        const lst = lstatSync(fullPath);
+        if (lst.isSymbolicLink()) continue;
+        if (lst.isDirectory()) {
+          lines.push(`${prefix}${entry}/`);
+          walk(fullPath, prefix + "  ", depth + 1);
+          continue;
+        }
+        if (!DOC_EXTS.test(entry)) continue;
+        const sizeKB = (lst.size / 1024).toFixed(1);
+        if (CODE_EXTS.test(entry) && lst.size < 100 * 1024) {
+          try {
+            const source = readFileSync(fullPath, "utf-8");
+            const exports = source.match(/export\s+(?:async\s+)?(?:function|const|class|interface|type|enum)\s+(\w+)/g);
+            const sigs = exports ? exports.map(e => e.replace(/^export\s+(async\s+)?/, "").trim()).slice(0, 5).join(", ") : "";
+            const extra = exports && exports.length > 5 ? ` +${exports.length - 5} more` : "";
+            lines.push(`${prefix}${entry}  (${sizeKB}KB)${sigs ? `  → ${sigs}${extra}` : ""}`);
+          } catch {
+            lines.push(`${prefix}${entry}  (${sizeKB}KB)`);
+          }
+        } else {
+          lines.push(`${prefix}${entry}  (${sizeKB}KB)`);
+        }
+      } catch { /* skip */ }
+    }
+  }
+
+  walk(join(cwd, "src"), "  ", 0);
+
+  lines.push("", "# Root files");
+  for (const f of ["CLAUDE.md", "package.json", ".claudeignore", ".mcp.json"]) {
+    try {
+      const st = lstatSync(join(cwd, f));
+      lines.push(`  ${f}  (${(st.size / 1024).toFixed(1)}KB)`);
+    } catch { /* not found */ }
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Creates a workspace map manager with lazy caching.
+ * Returns getWorkspaceMap() and markMapDirty() functions.
+ */
+export function createWorkspaceMap() {
+  let cache = "";
+  let dirty = true;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  function get(): string {
+    if (dirty || !cache) {
+      cache = buildWorkspaceMap();
+      dirty = false;
+    }
+    return cache;
+  }
+
+  function markDirty() {
+    dirty = true;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => { get(); }, 5000);
+  }
+
+  function getTimer() { return timer; }
+
+  return { get, markDirty, getTimer };
+}

package/src/platform.ts

@@ -0,0 +1,60 @@
+import { platform } from "os";
+import type { SpawnOptions } from "child_process";
+import { execSync } 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;
+}
+
+const DIAGNOSE_ARGS = "diagnose --format a2a --auto-heal";
+
+/**
+ * Resolve the hook command for invoking afd diagnose.
+ * Priority:
+ *   1. Global `afd` binary (npm/bun global install)
+ *   2. `bunx afd` fallback (Bun environment)
+ *   3. `npx afd` fallback (Node environment)
+ */
+export function resolveHookCommand(): string {
+  if (isCommandAvailable("afd")) {
+    return `afd ${DIAGNOSE_ARGS}`;
+  }
+  if (isCommandAvailable("bunx")) {
+    return `bunx afd ${DIAGNOSE_ARGS}`;
+  }
+  return `npx -y afd ${DIAGNOSE_ARGS}`;
+}
+
+/** Check if a command exists on the system PATH */
+function isCommandAvailable(cmd: string): boolean {
+  try {
+    const check = IS_WINDOWS ? `where ${cmd}` : `command -v ${cmd}`;
+    execSync(check, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/version.ts

@@ -0,0 +1,15 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+let version = "0.0.0-unknown";
+try {
+  const raw = readFileSync(resolve(import.meta.dirname, "..", "package.json"), "utf-8");
+  const pkg = JSON.parse(raw);
+  if (typeof pkg.version === "string" && pkg.version) {
+    version = pkg.version;
+  }
+} catch {
+  // Bundled binary or missing package.json — fallback silently
+}
+
+export const APP_VERSION: string = version;