autonomous-flow-daemon 1.0.0 → 1.6.0

package/src/core/telemetry.ts

@@ -0,0 +1,94 @@
+/**
+ * Lightweight telemetry helpers for CLI-side tracking.
+ * Uses a short-lived DB connection — no daemon required.
+ */
+
+import { Database } from "bun:sqlite";
+import { resolveWorkspacePaths } from "../constants";
+import { existsSync } from "fs";
+
+function openDb(): Database | null {
+  try {
+    const paths = resolveWorkspacePaths();
+    if (!existsSync(paths.dbFile)) return null;
+    const db = new Database(paths.dbFile);
+    db.exec("PRAGMA journal_mode = WAL");
+    return db;
+  } catch { return null; }
+}
+
+/** Track a CLI command invocation (fire-and-forget). */
+export function trackCliCommand(command: string) {
+  const db = openDb();
+  if (!db) return;
+  try {
+    db.prepare("INSERT INTO telemetry (category, action, timestamp) VALUES (?, ?, ?)").run("cli", command, Date.now());
+  } catch { /* table may not exist yet — ignore */ }
+  finally { db.close(); }
+}
+
+export interface TelemetryRow {
+  category: string;
+  action: string;
+  detail: string | null;
+  duration_ms: number | null;
+  timestamp: number;
+}
+
+export interface TelemetrySummary {
+  cli: Record<string, number>;
+  mcp: Record<string, number>;
+  seam: { counts: Record<string, number>; avgDurationMs: Record<string, number> };
+  immune: Record<string, number>;
+  validator: Record<string, number>;
+  totalEvents: number;
+  periodDays: number;
+}
+
+/** Query aggregated telemetry for the last N days. */
+export function queryTelemetry(days: number): TelemetrySummary {
+  const db = openDb();
+  const empty: TelemetrySummary = { cli: {}, mcp: {}, seam: { counts: {}, avgDurationMs: {} }, immune: {}, validator: {}, totalEvents: 0, periodDays: days };
+  if (!db) return empty;
+
+  try {
+    const since = Date.now() - days * 86_400_000;
+    const rows = db.prepare(
+      "SELECT category, action, duration_ms FROM telemetry WHERE timestamp >= ?"
+    ).all(since) as { category: string; action: string; duration_ms: number | null }[];
+
+    const result = { ...empty };
+    const seamDurations: Record<string, number[]> = {};
+
+    for (const row of rows) {
+      result.totalEvents++;
+      switch (row.category) {
+        case "cli":
+          result.cli[row.action] = (result.cli[row.action] ?? 0) + 1;
+          break;
+        case "mcp":
+          result.mcp[row.action] = (result.mcp[row.action] ?? 0) + 1;
+          break;
+        case "seam":
+          result.seam.counts[row.action] = (result.seam.counts[row.action] ?? 0) + 1;
+          if (row.duration_ms != null) {
+            (seamDurations[row.action] ??= []).push(row.duration_ms);
+          }
+          break;
+        case "immune":
+          result.immune[row.action] = (result.immune[row.action] ?? 0) + 1;
+          break;
+        case "validator":
+          result.validator[row.action] = (result.validator[row.action] ?? 0) + 1;
+          break;
+      }
+    }
+
+    for (const [action, durations] of Object.entries(seamDurations)) {
+      result.seam.avgDurationMs[action] = Math.round(durations.reduce((a, b) => a + b, 0) / durations.length);
+    }
+
+    return result;
+  } catch { return empty; }
+  finally { db.close(); }
+}

package/src/core/vaccine-registry.ts

@@ -0,0 +1,212 @@
+/**
+ * Vaccine Registry — central antibody package system
+ *
+ * Manages vaccine packages that can be published, searched, and installed.
+ * Registry index is stored at .afd/registry/index.json
+ * Each package is a directory under .afd/registry/packages/<name>/
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "fs";
+import { join } from "path";
+import { AFD_DIR } from "../constants";
+
+export interface VaccinePackage {
+  name: string;
+  version: string;
+  description: string;
+  author: string;
+  ecosystem: string;
+  antibodies: VaccineAntibodyDef[];
+  createdAt: string;
+  signature?: string; // future: cryptographic signature
+}
+
+export interface VaccineAntibodyDef {
+  id: string;
+  title: string;
+  description: string;
+  severity: "critical" | "warning" | "info";
+  condition: {
+    type: string;
+    path: string;
+    pattern?: string;
+    minLength?: number;
+  };
+  patches: { op: string; path: string; value?: string }[];
+}
+
+export interface RegistryIndex {
+  version: string;
+  updatedAt: string;
+  packages: RegistryEntry[];
+}
+
+export interface RegistryEntry {
+  name: string;
+  version: string;
+  description: string;
+  author: string;
+  ecosystem: string;
+  antibodyCount: number;
+}
+
+const REGISTRY_DIR = join(AFD_DIR, "registry");
+const PACKAGES_DIR = join(REGISTRY_DIR, "packages");
+const INDEX_FILE = join(REGISTRY_DIR, "index.json");
+
+function ensureDirs() {
+  mkdirSync(PACKAGES_DIR, { recursive: true });
+}
+
+function loadIndex(): RegistryIndex {
+  if (!existsSync(INDEX_FILE)) {
+    return { version: "1.0.0", updatedAt: new Date().toISOString(), packages: [] };
+  }
+  try {
+    return JSON.parse(readFileSync(INDEX_FILE, "utf-8"));
+  } catch {
+    return { version: "1.0.0", updatedAt: new Date().toISOString(), packages: [] };
+  }
+}
+
+function saveIndex(index: RegistryIndex) {
+  ensureDirs();
+  index.updatedAt = new Date().toISOString();
+  writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2), "utf-8");
+}
+
+/** Publish a vaccine package to the local registry */
+export function publishPackage(pkg: VaccinePackage): { success: boolean; message: string } {
+  ensureDirs();
+
+  const pkgDir = join(PACKAGES_DIR, pkg.name);
+  mkdirSync(pkgDir, { recursive: true });
+  writeFileSync(join(pkgDir, "vaccine.json"), JSON.stringify(pkg, null, 2), "utf-8");
+
+  // Update index
+  const index = loadIndex();
+  const existing = index.packages.findIndex(p => p.name === pkg.name);
+  const entry: RegistryEntry = {
+    name: pkg.name,
+    version: pkg.version,
+    description: pkg.description,
+    author: pkg.author,
+    ecosystem: pkg.ecosystem,
+    antibodyCount: pkg.antibodies.length,
+  };
+
+  if (existing >= 0) {
+    index.packages[existing] = entry;
+  } else {
+    index.packages.push(entry);
+  }
+  saveIndex(index);
+
+  return { success: true, message: `Published ${pkg.name}@${pkg.version} (${pkg.antibodies.length} antibodies)` };
+}
+
+/** Search packages in the registry */
+export function searchPackages(query?: string): RegistryEntry[] {
+  const index = loadIndex();
+  if (!query) return index.packages;
+  const q = query.toLowerCase();
+  return index.packages.filter(p =>
+    p.name.toLowerCase().includes(q) ||
+    p.description.toLowerCase().includes(q) ||
+    p.ecosystem.toLowerCase().includes(q)
+  );
+}
+
+/** Get full package details */
+export function getPackage(name: string): VaccinePackage | null {
+  const pkgFile = join(PACKAGES_DIR, name, "vaccine.json");
+  if (!existsSync(pkgFile)) return null;
+  try {
+    return JSON.parse(readFileSync(pkgFile, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/** Install a package — writes antibody rules to .afd/rules/ */
+export function installPackage(name: string): { success: boolean; installed: number; message: string } {
+  const pkg = getPackage(name);
+  if (!pkg) return { success: false, installed: 0, message: `Package '${name}' not found` };
+
+  const rulesDir = join(AFD_DIR, "rules");
+  mkdirSync(rulesDir, { recursive: true });
+
+  let installed = 0;
+  for (const ab of pkg.antibodies) {
+    const ruleContent = buildYamlRule(ab);
+    const ruleFile = join(rulesDir, `${pkg.name}-${ab.id}.yml`);
+    writeFileSync(ruleFile, ruleContent, "utf-8");
+    installed++;
+  }
+
+  return {
+    success: true,
+    installed,
+    message: `Installed ${pkg.name}@${pkg.version}: ${installed} rules added to .afd/rules/`,
+  };
+}
+
+/** List installed packages (by checking .afd/rules/ for package-prefixed files) */
+export function listInstalled(): string[] {
+  const rulesDir = join(AFD_DIR, "rules");
+  if (!existsSync(rulesDir)) return [];
+  if (!existsSync(PACKAGES_DIR)) return [];
+
+  // Get all known package names from registry
+  let knownPackages: string[];
+  try {
+    knownPackages = readdirSync(PACKAGES_DIR);
+  } catch {
+    return [];
+  }
+
+  const files = readdirSync(rulesDir).filter(f => f.endsWith(".yml") || f.endsWith(".yaml"));
+  const installed = new Set<string>();
+
+  for (const pkgName of knownPackages) {
+    // Check if any rule file starts with this package name
+    if (files.some(f => f.startsWith(`${pkgName}-`))) {
+      installed.add(pkgName);
+    }
+  }
+
+  return [...installed];
+}
+
+function buildYamlRule(ab: VaccineAntibodyDef): string {
+  const lines: string[] = [
+    `# Auto-generated by afd vaccine registry`,
+    `id: ${ab.id}`,
+    `title: "${ab.title}"`,
+    `description: "${ab.description}"`,
+    `severity: ${ab.severity}`,
+    `condition:`,
+    `  type: ${ab.condition.type}`,
+    `  path: ${ab.condition.path}`,
+  ];
+
+  if (ab.condition.pattern) {
+    lines.push(`  pattern: "${ab.condition.pattern}"`);
+  }
+  if (ab.condition.minLength !== undefined) {
+    lines.push(`  minLength: ${ab.condition.minLength}`);
+  }
+
+  if (ab.patches.length > 0) {
+    lines.push(`patches:`);
+    for (const p of ab.patches) {
+      lines.push(`  - op: ${p.op}`);
+      lines.push(`    path: ${p.path}`);
+      if (p.value !== undefined) {
+        lines.push(`    value: "${p.value.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`);
+      }
+    }
+  }
+
+  return lines.join("\n") + "\n";
+}

package/src/core/workspace.ts

@@ -0,0 +1,28 @@
+import { existsSync } from "fs";
+import { join, dirname, resolve } from "path";
+
+/**
+ * Walk upward from `from` to find the nearest directory containing `.afd/` or `.git/`.
+ * Returns the absolute workspace root path, or falls back to `from` itself.
+ */
+export function findWorkspaceRoot(from: string = process.cwd()): string {
+  let dir = resolve(from);
+  const root = dirname(dir) === dir ? dir : undefined; // filesystem root guard
+
+  while (true) {
+    if (existsSync(join(dir, ".afd")) || existsSync(join(dir, ".git"))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break; // reached filesystem root
+    dir = parent;
+  }
+
+  // Fallback: return original directory
+  return resolve(from);
+}
+
+/** Resolve an `.afd/`-relative path against the workspace root */
+export function resolveAfdPath(relativePath: string, from?: string): string {
+  return join(findWorkspaceRoot(from), relativePath);
+}

package/src/core/yaml-minimal.ts

@@ -0,0 +1,176 @@
+/**
+ * Minimal YAML parser — handles flat keys, nested objects, and simple arrays.
+ * No external dependencies. Sufficient for .afd/rules/*.yml diagnostic rule files.
+ *
+ * Supports:
+ *   key: value
+ *   key:
+ *     nested: value
+ *   items:
+ *     - value
+ *   items:
+ *     - op: add
+ *       path: /file
+ *
+ * Does NOT support: anchors, aliases, flow syntax, multi-line strings, tags.
+ */
+
+type YamlValue = string | number | boolean | null | YamlObject | YamlValue[];
+interface YamlObject {
+  [key: string]: YamlValue;
+}
+
+export function parse(text: string): YamlObject {
+  const lines = text.split("\n");
+  return parseBlock(lines, 0, 0).value as YamlObject;
+}
+
+interface ParseResult {
+  value: YamlValue;
+  nextLine: number;
+}
+
+function getIndent(line: string): number {
+  const match = line.match(/^(\s*)/);
+  return match ? match[1].length : 0;
+}
+
+function isComment(line: string): boolean {
+  return line.trimStart().startsWith("#") || line.trim() === "";
+}
+
+function parseScalar(raw: string): YamlValue {
+  const trimmed = raw.trim();
+  if (trimmed === "" || trimmed === "null" || trimmed === "~") return null;
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  // Remove quotes
+  if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+      (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+    return trimmed.slice(1, -1);
+  }
+  const num = Number(trimmed);
+  if (!isNaN(num) && trimmed !== "") return num;
+  return trimmed;
+}
+
+function parseBlock(lines: string[], startLine: number, baseIndent: number): ParseResult {
+  const obj: YamlObject = {};
+  let i = startLine;
+
+  while (i < lines.length) {
+    const line = lines[i];
+
+    if (isComment(line)) { i++; continue; }
+
+    const indent = getIndent(line);
+    if (indent < baseIndent) break; // dedent → end of block
+
+    const content = line.trim();
+
+    // Array item at this level
+    if (content.startsWith("- ")) {
+      // This block is actually an array — delegate to array parser
+      const arr = parseArray(lines, i, indent);
+      return { value: arr.value, nextLine: arr.nextLine };
+    }
+
+    // Key-value pair
+    const colonIdx = content.indexOf(":");
+    if (colonIdx === -1) { i++; continue; }
+
+    const key = content.slice(0, colonIdx).trim();
+    const rest = content.slice(colonIdx + 1).trim();
+
+    if (rest === "" || rest === "|" || rest === ">") {
+      // Check next line indent to determine nested type
+      const nextNonEmpty = findNextNonEmpty(lines, i + 1);
+      if (nextNonEmpty < lines.length) {
+        const nextIndent = getIndent(lines[nextNonEmpty]);
+        if (nextIndent > indent) {
+          const nextContent = lines[nextNonEmpty].trim();
+          if (nextContent.startsWith("- ")) {
+            const arr = parseArray(lines, nextNonEmpty, nextIndent);
+            obj[key] = arr.value;
+            i = arr.nextLine;
+          } else {
+            const nested = parseBlock(lines, nextNonEmpty, nextIndent);
+            obj[key] = nested.value;
+            i = nested.nextLine;
+          }
+        } else {
+          obj[key] = null;
+          i++;
+        }
+      } else {
+        obj[key] = null;
+        i++;
+      }
+    } else {
+      obj[key] = parseScalar(rest);
+      i++;
+    }
+  }
+
+  return { value: obj, nextLine: i };
+}
+
+function parseArray(lines: string[], startLine: number, baseIndent: number): ParseResult {
+  const arr: YamlValue[] = [];
+  let i = startLine;
+
+  while (i < lines.length) {
+    const line = lines[i];
+    if (isComment(line)) { i++; continue; }
+
+    const indent = getIndent(line);
+    if (indent < baseIndent) break;
+
+    const content = line.trim();
+    if (!content.startsWith("- ")) break;
+
+    const itemContent = content.slice(2).trim();
+
+    // Check if this is a simple value or an inline key-value
+    const colonIdx = itemContent.indexOf(":");
+    if (colonIdx > 0 && !itemContent.startsWith('"') && !itemContent.startsWith("'")) {
+      // Inline object start: - key: value
+      const itemObj: YamlObject = {};
+      const key = itemContent.slice(0, colonIdx).trim();
+      const val = itemContent.slice(colonIdx + 1).trim();
+      itemObj[key] = parseScalar(val);
+      i++;
+
+      // Continuation lines at deeper indent
+      const itemIndent = indent + 2;
+      while (i < lines.length) {
+        const nextLine = lines[i];
+        if (isComment(nextLine)) { i++; continue; }
+        const nextIndent = getIndent(nextLine);
+        if (nextIndent < itemIndent) break;
+        const nc = nextLine.trim();
+        if (nc.startsWith("- ")) break; // next array item
+        const ci = nc.indexOf(":");
+        if (ci > 0) {
+          itemObj[nc.slice(0, ci).trim()] = parseScalar(nc.slice(ci + 1).trim());
+        }
+        i++;
+      }
+
+      arr.push(itemObj);
+    } else {
+      // Simple value
+      arr.push(parseScalar(itemContent));
+      i++;
+    }
+  }
+
+  return { value: arr, nextLine: i };
+}
+
+function findNextNonEmpty(lines: string[], start: number): number {
+  for (let i = start; i < lines.length; i++) {
+    if (!isComment(lines[i])) return i;
+  }
+  return lines.length;
+}

package/src/daemon/client.ts

@@ -1,17 +1,45 @@
-import { readFileSync, existsSync } from "fs";
-import { PID_FILE, PORT_FILE } from "../constants";
+import { readFileSync, existsSync, unlinkSync } from "fs";
+import { resolveWorkspacePaths } from "../constants";
 
 export interface DaemonInfo {
   pid: number;
   port: number;
+  workspace: string;
 }
 
+/**
+ * Read daemon PID/port from the workspace-local `.afd/` directory.
+ * Walks up from cwd to find the workspace root, so CLI commands
+ * work correctly even when invoked from subdirectories.
+ *
+ * If PID file exists but process is dead, cleans up stale files.
+ */
 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);
+  const paths = resolveWorkspacePaths();
+  if (!existsSync(paths.pidFile) || !existsSync(paths.portFile)) return null;
+
+  const pid = parseInt(readFileSync(paths.pidFile, "utf-8").trim(), 10);
+  const port = parseInt(readFileSync(paths.portFile, "utf-8").trim(), 10);
   if (isNaN(pid) || isNaN(port)) return null;
-  return { pid, port };
+
+  // Stale PID detection: check if process is alive at OS level
+  if (!isProcessAlive(pid)) {
+    try { unlinkSync(paths.pidFile); } catch {}
+    try { unlinkSync(paths.portFile); } catch {}
+    return null;
+  }
+
+  return { pid, port, workspace: paths.root };
+}
+
+/** Check if a process exists at OS level (does not verify it's afd) */
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0); // signal 0 = existence check
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 export async function isDaemonAlive(info: DaemonInfo): Promise<boolean> {

package/src/daemon/event-batcher.ts

@@ -0,0 +1,108 @@
+/**
+ * EventBatcher — Adaptive debounce for file watcher events.
+ *
+ * Strategy:
+ * - Immune file changes → fast-path (immediate, no debounce)
+ * - All other events → 300ms debounce batch
+ * - Deduplicates: same file multiple events → last event wins
+ * - Cancels out: add + unlink on same file → removed from batch
+ */
+
+export interface BatchedEvent {
+  event: string;
+  path: string;
+  timestamp: number;
+}
+
+export interface EventBatcherOptions {
+  /** Debounce window in ms (default: 300) */
+  debounceMs?: number;
+  /** Check if a path is an immune-protected file (fast-path) */
+  isImmunePath?: (path: string) => boolean;
+  /** Handler for fast-path (immediate) events */
+  onImmediate: (event: string, path: string) => void;
+  /** Handler for batched events (fired after debounce window) */
+  onBatch: (events: BatchedEvent[]) => void;
+}
+
+export class EventBatcher {
+  private readonly debounceMs: number;
+  private readonly isImmunePath: (path: string) => boolean;
+  private readonly onImmediate: (event: string, path: string) => void;
+  private readonly onBatch: (events: BatchedEvent[]) => void;
+
+  private pendingEvents = new Map<string, BatchedEvent>();
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private batchCount = 0;
+
+  constructor(options: EventBatcherOptions) {
+    this.debounceMs = options.debounceMs ?? 300;
+    this.isImmunePath = options.isImmunePath ?? (() => false);
+    this.onImmediate = options.onImmediate;
+    this.onBatch = options.onBatch;
+  }
+
+  /** Push a new file event. Returns true if handled immediately (fast-path). */
+  push(event: string, path: string): boolean {
+    // Fast-path: immune file change → immediate processing for auto-heal responsiveness
+    if (event === "change" && this.isImmunePath(path)) {
+      this.onImmediate(event, path);
+      return true;
+    }
+
+    const now = Date.now();
+    const existing = this.pendingEvents.get(path);
+
+    // Cancel out: add + unlink on same file
+    if (existing) {
+      if ((existing.event === "add" && event === "unlink") ||
+          (existing.event === "unlink" && event === "add")) {
+        this.pendingEvents.delete(path);
+        return false;
+      }
+    }
+
+    // Last event wins for same file
+    this.pendingEvents.set(path, { event, path, timestamp: now });
+
+    // Start/reset debounce timer
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => this.flush(), this.debounceMs);
+
+    return false;
+  }
+
+  /** Flush all pending events immediately */
+  flush(): void {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+
+    if (this.pendingEvents.size === 0) return;
+
+    const events = [...this.pendingEvents.values()];
+    this.pendingEvents.clear();
+    this.batchCount++;
+    this.onBatch(events);
+  }
+
+  /** Get the number of batches processed */
+  get totalBatches(): number {
+    return this.batchCount;
+  }
+
+  /** Get the number of pending events */
+  get pendingCount(): number {
+    return this.pendingEvents.size;
+  }
+
+  /** Destroy the batcher, clearing any pending timers */
+  destroy(): void {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.pendingEvents.clear();
+  }
+}

package/src/daemon/guards.ts

@@ -0,0 +1,13 @@
+import { resolve } from "path";
+
+/**
+ * Guard: reject resolved paths outside the workspace root.
+ * Throws if absPath is not under wsRoot.
+ */
+export function assertInsideWorkspace(absPath: string, wsRoot: string): void {
+  const normalizedPath = absPath.replace(/\\/g, "/").toLowerCase();
+  const normalizedRoot = resolve(wsRoot).replace(/\\/g, "/").toLowerCase();
+  if (!normalizedPath.startsWith(normalizedRoot + "/") && normalizedPath !== normalizedRoot) {
+    throw new Error("Access denied: path outside workspace");
+  }
+}