autonomous-flow-daemon 1.1.0 → 1.6.0

package/src/core/immune.ts

@@ -1,4 +1,6 @@
-import { existsSync, readFileSync } from "fs";
+import { diagnoseWithRules, loadAllRules, evaluateRules } from "./rule-engine";
+export type { DiagnosticRule } from "./rule-engine";
+export { loadAllRules, evaluateRules };
 
 // RFC 6902 JSON-Patch operation
 export interface PatchOp {
@@ -24,127 +26,10 @@ export interface DiagnosisResult {
   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;
-  },
-];
-
+/**
+ * Run diagnosis using the rule engine.
+ * Loads built-in rules + custom .afd/rules/*.yml rules.
+ */
 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 };
+  return diagnoseWithRules(knownAntibodies, opts);
 }

package/src/core/log-rotate.ts

@@ -0,0 +1,33 @@
+import { existsSync, statSync, renameSync, unlinkSync } from "fs";
+
+const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5 MB
+const MAX_ROTATED_FILES = 3;           // daemon.log.1, .2, .3
+
+/**
+ * Rotate log file if it exceeds MAX_LOG_SIZE.
+ * Keeps up to MAX_ROTATED_FILES old logs.
+ *
+ * daemon.log → daemon.log.1 → daemon.log.2 → daemon.log.3 (deleted)
+ */
+export function rotateLogIfNeeded(logPath: string): void {
+  if (!existsSync(logPath)) return;
+
+  try {
+    const { size } = statSync(logPath);
+    if (size < MAX_LOG_SIZE) return;
+
+    // Shift existing rotated files: .3→delete, .2→.3, .1→.2
+    for (let i = MAX_ROTATED_FILES; i >= 1; i--) {
+      const src = i === 1 ? logPath : `${logPath}.${i - 1}`;
+      const dst = `${logPath}.${i}`;
+      if (!existsSync(src)) continue;
+      if (i === MAX_ROTATED_FILES && existsSync(dst)) {
+        unlinkSync(dst);
+      }
+      renameSync(src, dst);
+    }
+    // logPath has been renamed to logPath.1, fresh log will be created on open
+  } catch {
+    // Non-critical: if rotation fails, just keep appending
+  }
+}

package/src/core/log-utils.ts

@@ -0,0 +1,38 @@
+/**
+ * Logging utilities for the afd daemon.
+ * Extracted for testability and reuse.
+ */
+
+/** Format current time as HH:MM:SS.mmm */
+export function formatTimestamp(date: Date = new Date()): string {
+  const hh = String(date.getHours()).padStart(2, "0");
+  const mm = String(date.getMinutes()).padStart(2, "0");
+  const ss = String(date.getSeconds()).padStart(2, "0");
+  const ms = String(date.getMilliseconds()).padStart(3, "0");
+  return `${hh}:${mm}:${ss}.${ms}`;
+}
+
+/**
+ * Build a concise line-diff between old and new content.
+ * Returns at most `maxLines` diff entries (default 10).
+ */
+export function lineDiff(oldText: string, newText: string, maxLines = 10): string[] {
+  const oldLines = oldText.split("\n");
+  const newLines = newText.split("\n");
+  const diffs: string[] = [];
+  const maxLen = Math.max(oldLines.length, newLines.length);
+  for (let i = 0; i < maxLen; i++) {
+    if (oldLines[i] !== newLines[i]) {
+      const ln = i + 1;
+      if (i < oldLines.length && i < newLines.length) {
+        diffs.push(`  L${ln}: "${oldLines[i].trimEnd()}" → "${newLines[i].trimEnd()}"`);
+      } else if (i < oldLines.length) {
+        diffs.push(`  L${ln}: - "${oldLines[i].trimEnd()}"`);
+      } else {
+        diffs.push(`  L${ln}: + "${newLines[i]!.trimEnd()}"`);
+      }
+    }
+    if (diffs.length >= maxLines) { diffs.push("  ... (truncated)"); break; }
+  }
+  return diffs;
+}

package/src/core/lru-map.ts

@@ -0,0 +1,61 @@
+/**
+ * Size-bounded LRU Map that evicts by total byte size of values.
+ * Uses Map insertion order for LRU eviction (oldest first).
+ */
+export class LruStringMap {
+  private map = new Map<string, string>();
+  private currentBytes = 0;
+
+  constructor(private readonly maxBytes: number) {}
+
+  get(key: string): string | undefined {
+    const val = this.map.get(key);
+    if (val !== undefined) {
+      // Move to end (most recently used)
+      this.map.delete(key);
+      this.map.set(key, val);
+    }
+    return val;
+  }
+
+  /** Returns false if the value was too large to store (exceeds maxBytes). */
+  set(key: string, value: string): boolean {
+    const valueBytes = value.length * 2;
+
+    // Skip if single value exceeds budget (check BEFORE removing old entry)
+    if (valueBytes > this.maxBytes) return false;
+
+    // Remove old entry if exists
+    const old = this.map.get(key);
+    if (old !== undefined) {
+      this.currentBytes -= old.length * 2; // JS string ≈ 2 bytes per char
+      this.map.delete(key);
+    }
+
+    // Evict oldest entries until we have room
+    while (this.currentBytes + valueBytes > this.maxBytes && this.map.size > 0) {
+      const first = this.map.keys().next();
+      if (first.done) break;
+      const evicted = this.map.get(first.value)!;
+      this.currentBytes -= evicted.length * 2;
+      this.map.delete(first.value);
+    }
+
+    this.map.set(key, value);
+    this.currentBytes += valueBytes;
+    return true;
+  }
+
+  delete(key: string): boolean {
+    const val = this.map.get(key);
+    if (val !== undefined) {
+      this.currentBytes -= val.length * 2;
+      this.map.delete(key);
+      return true;
+    }
+    return false;
+  }
+
+  get size(): number { return this.map.size; }
+  get bytes(): number { return this.currentBytes; }
+}

package/src/core/notify.ts

@@ -26,13 +26,33 @@ export function notifyAutoHeal(patternId: string): void {
   }
 }
 
+/** Escape single quotes for PowerShell string literals */
+function escapePS(s: string): string {
+  return s.replace(/'/g, "''");
+}
+
+/** Escape double quotes and backslashes for AppleScript string literals */
+function escapeAS(s: string): string {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+function safeSpawn(cmd: string, args: string[], opts: Record<string, unknown> = {}): void {
+  try {
+    const child = spawn(cmd, args, { detached: true, stdio: "ignore", ...opts });
+    child.on("error", () => {}); // Swallow async ENOENT when binary is missing
+    child.unref();
+  } catch {
+    // Binary not found or spawn failed — silently ignore
+  }
+}
+
 function notifyWindows(title: string, body: string): void {
   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.BalloonTipTitle = '${escapePS(title)}'
+    $n.BalloonTipText = '${escapePS(body)}'
     $n.BalloonTipIcon = 'Info'
     $n.Visible = $true
     $n.ShowBalloonTip(3000)
@@ -40,27 +60,15 @@ function notifyWindows(title: string, body: string): void {
     $n.Dispose()
   `.replace(/\n\s*/g, " ");
 
-  const child = spawn("powershell", ["-NoProfile", "-NonInteractive", "-Command", ps], {
-    detached: true,
-    stdio: "ignore",
-    windowsHide: true,
-  });
-  child.unref();
+  safeSpawn("powershell", ["-NoProfile", "-NonInteractive", "-Command", ps], { windowsHide: true });
 }
 
 function notifyMacOS(title: string, body: string): void {
-  const script = `display notification "${body}" with title "${title}"`;
-  const child = spawn("osascript", ["-e", script], {
-    detached: true,
-    stdio: "ignore",
-  });
-  child.unref();
+  const script = `display notification "${escapeAS(body)}" with title "${escapeAS(title)}"`;
+
+  safeSpawn("osascript", ["-e", script]);
 }
 
 function notifyLinux(title: string, body: string): void {
-  const child = spawn("notify-send", [title, body, "--icon=dialog-information"], {
-    detached: true,
-    stdio: "ignore",
-  });
-  child.unref();
+  safeSpawn("notify-send", [title, body, "--icon=dialog-information"]);
 }

package/src/core/rule-engine.ts

@@ -0,0 +1,287 @@
+/**
+ * Custom Diagnostic Rule Engine
+ *
+ * Loads diagnostic rules from:
+ *   1. Built-in rules (hardcoded IMM-001~003 equivalents)
+ *   2. Project rules: .afd/rules/*.yml
+ *
+ * Each rule defines a condition + severity + auto-heal patches.
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join, extname } from "path";
+import { parse as parseYaml } from "./yaml-minimal";
+
+// Re-declare types locally to avoid circular import with immune.ts
+interface Symptom {
+  id: string;
+  patternType: string;
+  fileTarget: string;
+  title: string;
+  description: string;
+  severity: "critical" | "warning" | "info";
+  patches: PatchOp[];
+}
+
+interface PatchOp {
+  op: "add" | "remove" | "replace" | "move" | "copy" | "test";
+  path: string;
+  value?: string;
+}
+
+// ── Rule Definition ──
+
+export interface DiagnosticRule {
+  id: string;
+  title: string;
+  description: string;
+  severity: "critical" | "warning" | "info";
+  condition: RuleCondition;
+  patches: PatchOp[];
+}
+
+export type RuleCondition =
+  | { type: "file-missing"; path: string }
+  | { type: "file-empty"; path: string; minLength?: number }
+  | { type: "file-invalid-json"; path: string }
+  | { type: "file-missing-line"; path: string; pattern: string }
+  | { type: "file-contains"; path: string; pattern: string }; // inverse: triggers when pattern IS found
+
+// ── Built-in Rules (IMM-001~003) ──
+
+const CLAUDEIGNORE_DEFAULT = `# Autonomous Flow Daemon defaults
+node_modules/
+dist/
+.afd/
+*.log
+.env
+`;
+
+const HOOKS_DEFAULT = `{
+  "hooks": []
+}
+`;
+
+const BUILTIN_RULES: DiagnosticRule[] = [
+  {
+    id: "IMM-001",
+    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",
+    condition: { type: "file-missing", path: ".claudeignore" },
+    patches: [{ op: "add", path: "/.claudeignore", value: CLAUDEIGNORE_DEFAULT }],
+  },
+  {
+    id: "IMM-002",
+    title: "Missing or invalid hooks.json",
+    description:
+      "No valid .claude/hooks.json found. Without a hooks file, pre/post-command automation cannot be configured.",
+    severity: "warning",
+    condition: { type: "file-invalid-json", path: ".claude/hooks.json" },
+    patches: [{ op: "add", path: "/.claude/hooks.json", value: HOOKS_DEFAULT }],
+  },
+  {
+    id: "IMM-003",
+    title: "Missing or empty CLAUDE.md",
+    description:
+      "No CLAUDE.md found or content is too short. AI agents have no project constitution to follow.",
+    severity: "critical",
+    condition: { type: "file-empty", path: "CLAUDE.md", minLength: 20 },
+    patches: [{ op: "add", path: "/CLAUDE.md", value: "# Project Constitution\n\n<!-- Add project rules here -->\n" }],
+  },
+];
+
+// ── Condition Evaluator ──
+
+function evaluateCondition(cond: RuleCondition): { triggered: boolean; detail?: string } {
+  switch (cond.type) {
+    case "file-missing":
+      return { triggered: !existsSync(cond.path) };
+
+    case "file-empty": {
+      if (!existsSync(cond.path)) return { triggered: true, detail: "file not found" };
+      try {
+        const content = readFileSync(cond.path, "utf-8").trim();
+        const min = cond.minLength ?? 1;
+        return {
+          triggered: content.length < min,
+          detail: `${content.length} chars (min: ${min})`,
+        };
+      } catch {
+        return { triggered: true, detail: "unreadable" };
+      }
+    }
+
+    case "file-invalid-json": {
+      if (!existsSync(cond.path)) return { triggered: true, detail: "file not found" };
+      try {
+        JSON.parse(readFileSync(cond.path, "utf-8"));
+        return { triggered: false };
+      } catch {
+        return { triggered: true, detail: "invalid JSON" };
+      }
+    }
+
+    case "file-missing-line": {
+      if (!existsSync(cond.path)) return { triggered: true, detail: "file not found" };
+      try {
+        const content = readFileSync(cond.path, "utf-8");
+        const regex = new RegExp(cond.pattern);
+        return { triggered: !regex.test(content), detail: `pattern /${cond.pattern}/ not found` };
+      } catch {
+        return { triggered: true, detail: "unreadable" };
+      }
+    }
+
+    case "file-contains": {
+      if (!existsSync(cond.path)) return { triggered: false }; // file doesn't exist → pattern can't be found
+      try {
+        const content = readFileSync(cond.path, "utf-8");
+        const regex = new RegExp(cond.pattern);
+        return { triggered: regex.test(content), detail: `pattern /${cond.pattern}/ found` };
+      } catch {
+        return { triggered: false };
+      }
+    }
+
+    default:
+      return { triggered: false };
+  }
+}
+
+// ── Rule Loader ──
+
+function loadYamlRules(rulesDir: string): DiagnosticRule[] {
+  if (!existsSync(rulesDir)) return [];
+
+  const rules: DiagnosticRule[] = [];
+
+  let files: string[];
+  try {
+    files = readdirSync(rulesDir).filter(f => extname(f) === ".yml" || extname(f) === ".yaml");
+  } catch {
+    return [];
+  }
+
+  for (const file of files) {
+    const filePath = join(rulesDir, file);
+    try {
+      if (!statSync(filePath).isFile()) continue;
+      const content = readFileSync(filePath, "utf-8");
+      const parsed = parseYaml(content);
+      if (!parsed || !parsed.id || !parsed.condition) continue;
+
+      const rule: DiagnosticRule = {
+        id: String(parsed.id),
+        title: String(parsed.title ?? parsed.id),
+        description: String(parsed.description ?? ""),
+        severity: validateSeverity(parsed.severity),
+        condition: parseCondition(parsed.condition),
+        patches: parsePatchOps(parsed.patches),
+      };
+      rules.push(rule);
+    } catch {
+      // Skip malformed rule files — crash-only design
+    }
+  }
+
+  return rules;
+}
+
+function validateSeverity(val: unknown): "critical" | "warning" | "info" {
+  if (val === "critical" || val === "warning" || val === "info") return val;
+  return "warning";
+}
+
+function parseCondition(raw: unknown): RuleCondition {
+  if (!raw || typeof raw !== "object") return { type: "file-missing", path: "" };
+  const obj = raw as Record<string, unknown>;
+  const type = String(obj.type ?? "file-missing");
+  const path = String(obj.path ?? "");
+
+  switch (type) {
+    case "file-missing":
+      return { type: "file-missing", path };
+    case "file-empty":
+      return { type: "file-empty", path, minLength: Number(obj.minLength ?? 1) };
+    case "file-invalid-json":
+      return { type: "file-invalid-json", path };
+    case "file-missing-line":
+      return { type: "file-missing-line", path, pattern: String(obj.pattern ?? "") };
+    case "file-contains":
+      return { type: "file-contains", path, pattern: String(obj.pattern ?? "") };
+    default:
+      return { type: "file-missing", path };
+  }
+}
+
+function parsePatchOps(raw: unknown): PatchOp[] {
+  if (!Array.isArray(raw)) return [];
+  return raw
+    .filter((p): p is Record<string, unknown> => p && typeof p === "object")
+    .map(p => ({
+      op: (String(p.op ?? "add")) as PatchOp["op"],
+      path: String(p.path ?? ""),
+      value: p.value !== undefined ? String(p.value) : undefined,
+    }));
+}
+
+// ── Public API ──
+
+const RULES_DIR = join(".afd", "rules");
+
+export function loadAllRules(): DiagnosticRule[] {
+  const custom = loadYamlRules(RULES_DIR);
+  // Custom rules can override built-in by ID
+  const customIds = new Set(custom.map(r => r.id));
+  const builtins = BUILTIN_RULES.filter(r => !customIds.has(r.id));
+  return [...builtins, ...custom];
+}
+
+export function evaluateRules(
+  rules: DiagnosticRule[],
+  knownAntibodies: string[],
+  opts?: { raw?: boolean },
+): { symptoms: Symptom[]; healthy: string[] } {
+  const symptoms: Symptom[] = [];
+  const healthy: string[] = [];
+
+  for (const rule of rules) {
+    const result = evaluateCondition(rule.condition);
+
+    if (!result.triggered) {
+      healthy.push("OK");
+      continue;
+    }
+
+    // In raw mode, report all symptoms regardless of antibodies
+    if (!opts?.raw && knownAntibodies.includes(rule.id)) {
+      healthy.push(`${rule.id} (immunized)`);
+      continue;
+    }
+
+    symptoms.push({
+      id: rule.id,
+      patternType: rule.condition.type,
+      fileTarget: "path" in rule.condition ? rule.condition.path : "",
+      title: rule.title,
+      description: result.detail
+        ? `${rule.description} (${result.detail})`
+        : rule.description,
+      severity: rule.severity,
+      patches: rule.patches,
+    });
+  }
+
+  return { symptoms, healthy };
+}
+
+/** Convenience: load rules + evaluate in one call (replaces old diagnose()) */
+export function diagnoseWithRules(
+  knownAntibodies: string[],
+  opts?: { raw?: boolean },
+): { symptoms: Symptom[]; healthy: string[] } {
+  const rules = loadAllRules();
+  return evaluateRules(rules, knownAntibodies, opts);
+}