autonomous-flow-daemon 1.0.0 → 1.6.0

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);
+}

package/src/core/semantic-diff.ts

@@ -0,0 +1,432 @@
+/**
+ * Semantic Diff Engine — AST-based change classification for TypeScript/JavaScript.
+ *
+ * Instead of line-by-line text diff, parses both old and new source into AST,
+ * extracts top-level declarations, and classifies changes as:
+ *   - signature-change (breaking)
+ *   - body-change (non-breaking)
+ *   - added / removed
+ *   - renamed
+ *   - comment-only
+ *
+ * Falls back to text diff for non-TS/JS files.
+ */
+
+import ts from "typescript";
+
+export type ChangeKind =
+  | "signature-change"  // function/class signature modified (breaking)
+  | "body-change"       // implementation changed, signature intact
+  | "added"             // new declaration
+  | "removed"           // declaration deleted
+  | "export-change"     // export modifier added/removed
+  | "comment-only"      // only comments changed
+  | "whitespace-only"   // only formatting changed
+  | "type-change"       // type annotation changed
+  | "unknown";
+
+export interface SemanticChange {
+  kind: ChangeKind;
+  name: string;           // declaration name
+  nodeType: string;       // "function", "class", "interface", "variable", etc.
+  breaking: boolean;      // true if this could break consumers
+  detail?: string;        // human-readable description
+}
+
+export interface SemanticDiffResult {
+  changes: SemanticChange[];
+  hasBreakingChanges: boolean;
+  summary: string;        // one-line summary for logging
+}
+
+interface DeclInfo {
+  name: string;
+  nodeType: string;
+  signature: string;      // type signature (no body)
+  body: string;           // full text including body
+  exported: boolean;
+  hasComments: boolean;
+}
+
+/** Check if a file path is TypeScript or JavaScript */
+export function isAstSupported(filePath: string): boolean {
+  return /\.(ts|tsx|js|jsx|mts|mjs|cts|cjs)$/.test(filePath);
+}
+
+/** Generate semantic diff between old and new source */
+export function semanticDiff(filePath: string, oldSource: string, newSource: string): SemanticDiffResult {
+  if (!isAstSupported(filePath)) {
+    return textFallback(oldSource, newSource);
+  }
+
+  try {
+    const oldDecls = extractDeclarations(filePath, oldSource);
+    const newDecls = extractDeclarations(filePath, newSource);
+    return compareDeclarations(oldDecls, newDecls);
+  } catch {
+    // AST parsing failed — fall back to text diff
+    return textFallback(oldSource, newSource);
+  }
+}
+
+function extractDeclarations(filePath: string, source: string): Map<string, DeclInfo> {
+  const sf = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true);
+  const decls = new Map<string, DeclInfo>();
+
+  for (const stmt of sf.statements) {
+    const infos = extractDeclInfos(stmt, source);
+    for (const info of infos) {
+      decls.set(info.name, info);
+    }
+  }
+
+  return decls;
+}
+
+function extractDeclInfos(node: ts.Statement, _source: string): DeclInfo[] {
+  const exported = hasExportModifier(node);
+  const fullText = node.getFullText().trim();
+  const hasComments = /^\s*\/[/*]/.test(node.getFullText());
+
+  if (ts.isFunctionDeclaration(node) && node.name) {
+    return [{
+      name: node.name.text,
+      nodeType: "function",
+      signature: getFunctionSignature(node),
+      body: fullText,
+      exported,
+      hasComments,
+    }];
+  }
+
+  if (ts.isClassDeclaration(node) && node.name) {
+    return [{
+      name: node.name.text,
+      nodeType: "class",
+      signature: getClassSignature(node),
+      body: fullText,
+      exported,
+      hasComments,
+    }];
+  }
+
+  if (ts.isInterfaceDeclaration(node)) {
+    return [{
+      name: node.name.text,
+      nodeType: "interface",
+      signature: normalizeWhitespace(node.getText()),
+      body: fullText,
+      exported,
+      hasComments,
+    }];
+  }
+
+  if (ts.isTypeAliasDeclaration(node)) {
+    return [{
+      name: node.name.text,
+      nodeType: "type",
+      signature: normalizeWhitespace(node.getText()),
+      body: fullText,
+      exported,
+      hasComments,
+    }];
+  }
+
+  if (ts.isEnumDeclaration(node)) {
+    return [{
+      name: node.name.text,
+      nodeType: "enum",
+      signature: normalizeWhitespace(node.getText()),
+      body: fullText,
+      exported,
+      hasComments,
+    }];
+  }
+
+  if (ts.isVariableStatement(node)) {
+    const results: DeclInfo[] = [];
+    for (const decl of node.declarationList.declarations) {
+      if (ts.isIdentifier(decl.name)) {
+        const typeStr = decl.type ? `: ${decl.type.getText()}` : "";
+        const isArrowFn = decl.initializer && ts.isArrowFunction(decl.initializer);
+        results.push({
+          name: decl.name.text,
+          nodeType: isArrowFn ? "function" : "variable",
+          signature: `${decl.name.text}${typeStr}`,
+          body: fullText,
+          exported,
+          hasComments,
+        });
+      }
+    }
+    return results;
+  }
+
+  if (ts.isImportDeclaration(node)) {
+    const importText = normalizeWhitespace(node.getText());
+    return [{
+      name: `import:${importText}`,
+      nodeType: "import",
+      signature: importText,
+      body: fullText,
+      exported: false,
+      hasComments,
+    }];
+  }
+
+  if (ts.isExportDeclaration(node)) {
+    const exportText = normalizeWhitespace(node.getText());
+    return [{
+      name: `export:${exportText}`,
+      nodeType: "export",
+      signature: exportText,
+      body: fullText,
+      exported: true,
+      hasComments,
+    }];
+  }
+
+  return [];
+}
+
+function compareDeclarations(
+  oldDecls: Map<string, DeclInfo>,
+  newDecls: Map<string, DeclInfo>,
+): SemanticDiffResult {
+  const changes: SemanticChange[] = [];
+
+  // Check removed declarations
+  for (const [name, oldInfo] of oldDecls) {
+    if (!newDecls.has(name)) {
+      changes.push({
+        kind: "removed",
+        name,
+        nodeType: oldInfo.nodeType,
+        breaking: oldInfo.exported,
+        detail: oldInfo.exported ? `exported ${oldInfo.nodeType} removed` : `${oldInfo.nodeType} removed`,
+      });
+    }
+  }
+
+  // Check added and modified declarations
+  for (const [name, newInfo] of newDecls) {
+    const oldInfo = oldDecls.get(name);
+
+    if (!oldInfo) {
+      changes.push({
+        kind: "added",
+        name,
+        nodeType: newInfo.nodeType,
+        breaking: false,
+        detail: `new ${newInfo.nodeType}`,
+      });
+      continue;
+    }
+
+    // Same full text → no change
+    if (normalizeWhitespace(oldInfo.body) === normalizeWhitespace(newInfo.body)) {
+      continue;
+    }
+
+    // Check export modifier change
+    if (oldInfo.exported !== newInfo.exported) {
+      changes.push({
+        kind: "export-change",
+        name,
+        nodeType: newInfo.nodeType,
+        breaking: oldInfo.exported && !newInfo.exported, // removing export is breaking
+        detail: newInfo.exported ? "export added" : "export removed",
+      });
+      continue;
+    }
+
+    // Check if only comments changed
+    const oldNoComments = stripComments(oldInfo.body);
+    const newNoComments = stripComments(newInfo.body);
+    if (normalizeWhitespace(oldNoComments) === normalizeWhitespace(newNoComments)) {
+      changes.push({
+        kind: "comment-only",
+        name,
+        nodeType: oldInfo.nodeType,
+        breaking: false,
+        detail: "comments modified",
+      });
+      continue;
+    }
+
+    // Check if only whitespace changed
+    if (oldNoComments.replace(/\s+/g, "") === newNoComments.replace(/\s+/g, "")) {
+      changes.push({
+        kind: "whitespace-only",
+        name,
+        nodeType: oldInfo.nodeType,
+        breaking: false,
+        detail: "formatting changed",
+      });
+      continue;
+    }
+
+    // Signature changed?
+    if (oldInfo.signature !== newInfo.signature) {
+      // Check if it's just a type annotation change
+      const oldSigNoType = stripTypeAnnotations(oldInfo.signature);
+      const newSigNoType = stripTypeAnnotations(newInfo.signature);
+      if (oldSigNoType !== newSigNoType) {
+        changes.push({
+          kind: "signature-change",
+          name,
+          nodeType: oldInfo.nodeType,
+          breaking: oldInfo.exported,
+          detail: `${oldInfo.signature} → ${newInfo.signature}`,
+        });
+      } else {
+        changes.push({
+          kind: "type-change",
+          name,
+          nodeType: oldInfo.nodeType,
+          breaking: oldInfo.exported,
+          detail: "type annotation changed",
+        });
+      }
+      continue;
+    }
+
+    // Signature same, body different → body-only change
+    changes.push({
+      kind: "body-change",
+      name,
+      nodeType: oldInfo.nodeType,
+      breaking: false,
+      detail: "implementation changed",
+    });
+  }
+
+  const hasBreakingChanges = changes.some(c => c.breaking);
+  const summary = buildSummary(changes);
+
+  return { changes, hasBreakingChanges, summary };
+}
+
+function buildSummary(changes: SemanticChange[]): string {
+  if (changes.length === 0) return "no semantic changes";
+
+  const counts: Record<string, number> = {};
+  for (const c of changes) {
+    counts[c.kind] = (counts[c.kind] ?? 0) + 1;
+  }
+
+  const parts: string[] = [];
+  for (const [kind, count] of Object.entries(counts)) {
+    parts.push(`${count} ${kind}`);
+  }
+
+  const breaking = changes.filter(c => c.breaking).length;
+  if (breaking > 0) parts.push(`⚠️ ${breaking} breaking`);
+
+  return parts.join(", ");
+}
+
+// ── Helpers ──
+
+function hasExportModifier(node: ts.Statement): boolean {
+  if (!ts.canHaveModifiers(node)) return false;
+  const mods = ts.getModifiers(node);
+  return mods?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+
+function getFunctionSignature(node: ts.FunctionDeclaration): string {
+  const name = node.name?.text ?? "anonymous";
+  const params = node.parameters.map(p => {
+    const pName = p.name.getText();
+    const pType = p.type ? `: ${p.type.getText()}` : "";
+    const optional = p.questionToken ? "?" : "";
+    return `${pName}${optional}${pType}`;
+  }).join(", ");
+  const ret = node.type ? `: ${node.type.getText()}` : "";
+  return `${name}(${params})${ret}`;
+}
+
+function getClassSignature(node: ts.ClassDeclaration): string {
+  const name = node.name?.text ?? "anonymous";
+  const heritage = node.heritageClauses?.map(h => h.getText()).join(" ") ?? "";
+  const members: string[] = [];
+  for (const member of node.members) {
+    if (ts.isPropertyDeclaration(member) || ts.isMethodDeclaration(member)) {
+      const mName = member.name?.getText() ?? "";
+      if (ts.isMethodDeclaration(member)) {
+        const params = member.parameters.map(p => p.getText()).join(", ");
+        const ret = member.type ? `: ${member.type.getText()}` : "";
+        members.push(`${mName}(${params})${ret}`);
+      } else {
+        const type = (member as ts.PropertyDeclaration).type?.getText() ?? "";
+        members.push(`${mName}: ${type}`);
+      }
+    }
+  }
+  return `class ${name} ${heritage} { ${members.join("; ")} }`;
+}
+
+/** Strip type annotations from a signature, handling nested braces/parens/generics */
+function stripTypeAnnotations(sig: string): string {
+  let result = "";
+  let depth = 0;
+  let inType = false;
+  for (let i = 0; i < sig.length; i++) {
+    const ch = sig[i];
+    if (ch === ":" && depth === 0 && !inType) {
+      inType = true;
+      continue;
+    }
+    if (inType) {
+      if (ch === "<" || ch === "{" || ch === "(") depth++;
+      else if (ch === ">" || ch === "}" || ch === ")") {
+        if (depth > 0) { depth--; continue; }
+        // depth === 0 and closing paren → end of type, keep the paren
+        inType = false;
+        result += ch;
+      } else if (ch === "," && depth === 0) {
+        inType = false;
+        result += ch;
+      }
+      continue;
+    }
+    result += ch;
+  }
+  return result;
+}
+
+function normalizeWhitespace(s: string): string {
+  return s.replace(/\s+/g, " ").trim();
+}
+
+function stripComments(source: string): string {
+  return source
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/\/\/.*$/gm, "")
+    .trim();
+}
+
+/** Fallback for non-TS/JS files */
+function textFallback(oldSource: string, newSource: string): SemanticDiffResult {
+  const oldLines = oldSource.split("\n");
+  const newLines = newSource.split("\n");
+  let added = 0, removed = 0, changed = 0;
+  const maxLen = Math.max(oldLines.length, newLines.length);
+
+  for (let i = 0; i < maxLen; i++) {
+    if (i >= oldLines.length) { added++; continue; }
+    if (i >= newLines.length) { removed++; continue; }
+    if (oldLines[i] !== newLines[i]) changed++;
+  }
+
+  const changes: SemanticChange[] = [];
+  if (added > 0) changes.push({ kind: "added", name: `${added} lines`, nodeType: "text", breaking: false });
+  if (removed > 0) changes.push({ kind: "removed", name: `${removed} lines`, nodeType: "text", breaking: false });
+  if (changed > 0) changes.push({ kind: "body-change", name: `${changed} lines`, nodeType: "text", breaking: false });
+
+  return {
+    changes,
+    hasBreakingChanges: false,
+    summary: `text diff: +${added} -${removed} ~${changed} lines`,
+  };
+}