autonomous-flow-daemon 1.1.0 → 1.9.0

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/validator-generator.ts

@@ -0,0 +1,224 @@
+/**
+ * Auto-Validator Generator — converts quarantine failure patterns into
+ * executable `.js` validator scripts for `.afd/validators/`.
+ *
+ * Strategy: template-based code generation with heuristic pattern detection.
+ * Each quarantine lesson is classified into a failure category, then a
+ * category-specific template emits a self-contained validator function.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, extname } from "path";
+import { VALIDATORS_DIR } from "../daemon/types";
+
+// ── Header stamped on every generated validator ─────────────────────────────
+
+const AUTO_HEADER = "// [afd auto-generated validator] DO NOT EDIT — regenerate with `afd evolution --generate`\n";
+
+// ── Pattern classification ──────────────────────────────────────────────────
+
+type ValidatorCategory =
+  | "prevent-deletion"
+  | "prevent-empty"
+  | "prevent-truncation"
+  | "require-valid-json"
+  | "prevent-corruption";
+
+interface ClassifiedPattern {
+  category: ValidatorCategory;
+  /** The file path or glob that this validator targets */
+  target: string;
+  /** Extra context for the template (e.g. minimum line count) */
+  meta: Record<string, string | number>;
+}
+
+interface GeneratorResult {
+  filename: string;
+  written: boolean;
+  reason: string;
+}
+
+/**
+ * Classify a quarantine lesson into a generator category.
+ */
+function classify(
+  failureType: "corruption" | "deletion",
+  originalPath: string,
+  corruptedContent: string,
+  restoredContent: string | null,
+): ClassifiedPattern {
+  const target = originalPath;
+
+  if (failureType === "deletion") {
+    return { category: "prevent-deletion", target, meta: {} };
+  }
+
+  // Empty file
+  if (corruptedContent.trim().length === 0) {
+    return { category: "prevent-empty", target, meta: {} };
+  }
+
+  // Severe truncation (>90% content loss)
+  if (restoredContent && corruptedContent.length < restoredContent.length * 0.1) {
+    const minLines = restoredContent.split("\n").length;
+    return { category: "prevent-truncation", target, meta: { minLines: Math.max(1, Math.floor(minLines * 0.3)) } };
+  }
+
+  // JSON syntax error
+  if (originalPath.endsWith(".json")) {
+    try {
+      JSON.parse(corruptedContent);
+    } catch {
+      return { category: "require-valid-json", target, meta: {} };
+    }
+  }
+
+  // Generic corruption fallback
+  return { category: "prevent-corruption", target, meta: {} };
+}
+
+// ── Template emitters ───────────────────────────────────────────────────────
+
+function emitPreventDeletion(target: string): string {
+  return `${AUTO_HEADER}
+// Prevents deletion or complete emptying of: ${target}
+module.exports = function(newContent, filePath) {
+  if (!filePath.endsWith(${JSON.stringify(normalizeTarget(target))})) return false;
+  // Content marked as DELETED or completely empty → corruption
+  if (!newContent || newContent.trim().length === 0) return true;
+  if (newContent.trim() === "DELETED") return true;
+  return false;
+};
+`;
+}
+
+function emitPreventEmpty(target: string): string {
+  return `${AUTO_HEADER}
+// Prevents emptying of: ${target}
+module.exports = function(newContent, filePath) {
+  if (!filePath.endsWith(${JSON.stringify(normalizeTarget(target))})) return false;
+  if (!newContent || newContent.trim().length === 0) return true;
+  return false;
+};
+`;
+}
+
+function emitPreventTruncation(target: string, minLines: number): string {
+  return `${AUTO_HEADER}
+// Prevents severe truncation of: ${target} (minimum ${minLines} lines)
+module.exports = function(newContent, filePath) {
+  if (!filePath.endsWith(${JSON.stringify(normalizeTarget(target))})) return false;
+  if (!newContent) return true;
+  var lineCount = newContent.split("\\n").length;
+  if (lineCount < ${minLines}) return true;
+  return false;
+};
+`;
+}
+
+function emitRequireValidJson(target: string): string {
+  return `${AUTO_HEADER}
+// Ensures valid JSON syntax for: ${target}
+module.exports = function(newContent, filePath) {
+  if (!filePath.endsWith(${JSON.stringify(normalizeTarget(target))})) return false;
+  if (!newContent || newContent.trim().length === 0) return true;
+  try {
+    JSON.parse(newContent);
+    return false;
+  } catch (e) {
+    return true;
+  }
+};
+`;
+}
+
+function emitPreventCorruption(target: string): string {
+  return `${AUTO_HEADER}
+// Generic corruption guard for: ${target}
+module.exports = function(newContent, filePath) {
+  if (!filePath.endsWith(${JSON.stringify(normalizeTarget(target))})) return false;
+  // Block empty or near-empty overwrites
+  if (!newContent || newContent.trim().length < 5) return true;
+  return false;
+};
+`;
+}
+
+/** Normalize path to a suffix for endsWith matching (forward slashes) */
+function normalizeTarget(p: string): string {
+  return p.replace(/\\/g, "/");
+}
+
+// ── Public API ──────────────────────────────────────────────────────────────
+
+export interface ValidatorGenInput {
+  failureType: "corruption" | "deletion";
+  originalPath: string;
+  corruptedContent: string;
+  restoredContent: string | null;
+}
+
+/**
+ * Generate a single validator from a quarantine pattern.
+ * Returns the filename and whether it was written (skips if user-modified).
+ */
+export function generateValidator(input: ValidatorGenInput, baseDir?: string): GeneratorResult {
+  const dir = baseDir ?? VALIDATORS_DIR;
+  mkdirSync(dir, { recursive: true });
+
+  const pattern = classify(input.failureType, input.originalPath, input.corruptedContent, input.restoredContent);
+  const filename = buildFilename(pattern);
+  const filepath = join(dir, filename);
+
+  // Safety: do not overwrite user-modified validators
+  if (existsSync(filepath)) {
+    const existing = readFileSync(filepath, "utf-8");
+    if (!existing.startsWith(AUTO_HEADER)) {
+      return { filename, written: false, reason: "user-modified" };
+    }
+  }
+
+  let code: string;
+  switch (pattern.category) {
+    case "prevent-deletion":
+      code = emitPreventDeletion(pattern.target);
+      break;
+    case "prevent-empty":
+      code = emitPreventEmpty(pattern.target);
+      break;
+    case "prevent-truncation":
+      code = emitPreventTruncation(pattern.target, (pattern.meta.minLines as number) || 5);
+      break;
+    case "require-valid-json":
+      code = emitRequireValidJson(pattern.target);
+      break;
+    case "prevent-corruption":
+      code = emitPreventCorruption(pattern.target);
+      break;
+  }
+
+  writeFileSync(filepath, code, "utf-8");
+  return { filename, written: true, reason: "generated" };
+}
+
+/**
+ * Generate validators for all provided quarantine lessons.
+ * Returns summary of generated files.
+ */
+export function generateValidators(inputs: ValidatorGenInput[], baseDir?: string): GeneratorResult[] {
+  return inputs.map(input => generateValidator(input, baseDir));
+}
+
+function buildFilename(pattern: ClassifiedPattern): string {
+  // Produce a descriptive filename from the target path
+  const ext = extname(pattern.target);
+  const base = pattern.target
+    .replace(/^\./, "")          // strip leading dot
+    .replace(/[/\\]/g, "-")     // path separators to dashes
+    .replace(ext, "")            // strip extension
+    .replace(/[^a-zA-Z0-9-]/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+
+  return `auto-${pattern.category}-${base}${ext ? "-" + ext.slice(1) : ""}.js`;
+}

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