autonomous-flow-daemon 1.1.0 → 1.9.0

package/src/core/hologram.ts

@@ -1,243 +1,73 @@
-import ts from "typescript";
-
-export interface HologramResult {
-  hologram: string;
-  originalLength: number;
-  hologramLength: number;
-  savings: number; // percentage 0-100
-}
-
-export function generateHologram(filePath: string, source: string): HologramResult {
-  const sf = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true);
-  const lines: string[] = [];
-
-  for (const stmt of sf.statements) {
-    const line = extractNode(stmt, source);
-    if (line) lines.push(line);
-  }
-
-  const hologram = lines.join("\n");
-  const originalLength = source.length;
-  const hologramLength = hologram.length;
-  const savings = originalLength > 0
-    ? Math.round((originalLength - hologramLength) / originalLength * 1000) / 10
-    : 0;
-
-  return { hologram, originalLength, hologramLength, savings };
-}
-
-function extractNode(node: ts.Node, source: string): string | null {
-  // Import declarations — keep as-is
-  if (ts.isImportDeclaration(node)) {
-    return node.getText().replace(/\s+/g, " ").trim();
-  }
-
-  // Export declarations (re-exports)
-  if (ts.isExportDeclaration(node)) {
-    return node.getText().replace(/\s+/g, " ").trim();
-  }
-
-  // Export assignment (export default ...)
-  if (ts.isExportAssignment(node)) {
-    return `export default ${getTypeName(node.expression)};`;
-  }
-
-  // Type alias
-  if (ts.isTypeAliasDeclaration(node)) {
-    return collapseWhitespace(node.getText());
-  }
-
-  // Interface
-  if (ts.isInterfaceDeclaration(node)) {
-    return extractInterface(node);
-  }
-
-  // Enum
-  if (ts.isEnumDeclaration(node)) {
-    return extractEnum(node);
-  }
-
-  // Class
-  if (ts.isClassDeclaration(node)) {
-    return extractClass(node);
-  }
-
-  // Function declaration
-  if (ts.isFunctionDeclaration(node)) {
-    return extractFunction(node);
-  }
-
-  // Variable statement (const/let/var — may contain arrow functions, objects, etc.)
-  if (ts.isVariableStatement(node)) {
-    return extractVariableStatement(node);
-  }
-
-  // Fallback: skip unknown top-level statements
-  return null;
-}
-
-function extractInterface(node: ts.InterfaceDeclaration): string {
-  const mods = getModifiers(node);
-  const name = node.name.text;
-  const ext = node.heritageClauses
-    ? " " + node.heritageClauses.map(h => h.getText()).join(", ")
-    : "";
-  const members = node.members.map(m => {
-    const text = collapseWhitespace(m.getText()).replace(/;$/, "");
-    return "  " + text + ";";
-  }).join("\n");
-  return `${mods}interface ${name}${ext} {\n${members}\n}`;
-}
-
-function extractEnum(node: ts.EnumDeclaration): string {
-  const mods = getModifiers(node);
-  const name = node.name.text;
-  const members = node.members.map(m => collapseWhitespace(m.getText())).join(", ");
-  return `${mods}enum ${name} { ${members} }`;
-}
-
-function extractClass(node: ts.ClassDeclaration): string {
-  const mods = getModifiers(node);
-  const name = node.name?.text ?? "Anonymous";
-  const ext = node.heritageClauses
-    ? " " + node.heritageClauses.map(h => h.getText()).join(", ")
-    : "";
-
-  const members: string[] = [];
-  for (const member of node.members) {
-    if (ts.isPropertyDeclaration(member)) {
-      members.push("  " + extractProperty(member) + ";");
-    } else if (ts.isMethodDeclaration(member) || ts.isGetAccessor(member) || ts.isSetAccessor(member)) {
-      members.push("  " + extractMethodSignature(member) + ";");
-    } else if (ts.isConstructorDeclaration(member)) {
-      const params = extractParams(member.parameters);
-      members.push(`  constructor(${params});`);
-    }
-  }
-
-  return `${mods}class ${name}${ext} {\n${members.join("\n")}\n}`;
-}
-
-function extractFunction(node: ts.FunctionDeclaration): string {
-  const mods = getModifiers(node);
-  const name = node.name?.text ?? "anonymous";
-  const typeParams = node.typeParameters
-    ? `<${node.typeParameters.map(t => t.getText()).join(", ")}>`
-    : "";
-  const params = extractParams(node.parameters);
-  const ret = node.type ? ": " + collapseWhitespace(node.type.getText()) : "";
-  const async = hasModifier(node, ts.SyntaxKind.AsyncKeyword) ? "async " : "";
-  return `${mods}${async}function ${name}${typeParams}(${params})${ret} {…}`;
-}
-
-function extractVariableStatement(node: ts.VariableStatement): string {
-  const mods = getModifiers(node);
-  const keyword = node.declarationList.flags & ts.NodeFlags.Const ? "const"
-    : node.declarationList.flags & ts.NodeFlags.Let ? "let" : "var";
-
-  const decls = node.declarationList.declarations.map(d => {
-    const name = d.name.getText();
-    const typeAnn = d.type ? ": " + collapseWhitespace(d.type.getText()) : "";
-
-    if (d.initializer) {
-      // Arrow function or function expression
-      if (ts.isArrowFunction(d.initializer) || ts.isFunctionExpression(d.initializer)) {
-        const fn = d.initializer;
-        const async = hasModifier(fn, ts.SyntaxKind.AsyncKeyword) ? "async " : "";
-        const typeParams = fn.typeParameters
-          ? `<${fn.typeParameters.map(t => t.getText()).join(", ")}>`
-          : "";
-        const params = extractParams(fn.parameters);
-        const ret = fn.type ? ": " + collapseWhitespace(fn.type.getText()) : "";
-        return `${name} = ${async}${typeParams}(${params})${ret} => {…}`;
-      }
-      // Object/array/other — just show type or truncated value
-      if (typeAnn) return `${name}${typeAnn}`;
-      return `${name} = …`;
-    }
-
-    return `${name}${typeAnn}`;
-  });
-
-  return `${mods}${keyword} ${decls.join(", ")};`;
-}
-
-function extractProperty(node: ts.PropertyDeclaration): string {
-  const mods = getMemberModifiers(node);
-  const name = node.name.getText();
-  const type = node.type ? ": " + collapseWhitespace(node.type.getText()) : "";
-  const optional = node.questionToken ? "?" : "";
-  return `${mods}${name}${optional}${type}`;
-}
-
-function extractMethodSignature(node: ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration): string {
-  const mods = getMemberModifiers(node);
-  const name = node.name.getText();
-  const async = hasModifier(node, ts.SyntaxKind.AsyncKeyword) ? "async " : "";
-
-  if (ts.isGetAccessor(node)) {
-    const ret = node.type ? ": " + collapseWhitespace(node.type.getText()) : "";
-    return `${mods}get ${name}()${ret}`;
-  }
-  if (ts.isSetAccessor(node)) {
-    const params = extractParams(node.parameters);
-    return `${mods}set ${name}(${params})`;
-  }
-
-  const md = node as ts.MethodDeclaration;
-  const typeParams = md.typeParameters
-    ? `<${md.typeParameters.map(t => t.getText()).join(", ")}>`
-    : "";
-  const params = extractParams(md.parameters);
-  const ret = md.type ? ": " + collapseWhitespace(md.type.getText()) : "";
-  return `${mods}${async}${name}${typeParams}(${params})${ret}`;
-}
-
-function extractParams(params: ts.NodeArray<ts.ParameterDeclaration>): string {
-  return params.map(p => {
-    const name = p.name.getText();
-    const optional = p.questionToken ? "?" : "";
-    const type = p.type ? ": " + collapseWhitespace(p.type.getText()) : "";
-    const rest = p.dotDotDotToken ? "..." : "";
-    return `${rest}${name}${optional}${type}`;
-  }).join(", ");
-}
-
-function getModifiers(node: ts.Node): string {
-  const mods = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
-  if (!mods) return "";
-  const relevant = mods
-    .filter(m => m.kind === ts.SyntaxKind.ExportKeyword || m.kind === ts.SyntaxKind.DefaultKeyword || m.kind === ts.SyntaxKind.DeclareKeyword)
-    .map(m => m.getText());
-  return relevant.length ? relevant.join(" ") + " " : "";
-}
-
-function getMemberModifiers(node: ts.Node): string {
-  const mods = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
-  if (!mods) return "";
-  const relevant = mods
-    .filter(m =>
-      m.kind === ts.SyntaxKind.PublicKeyword ||
-      m.kind === ts.SyntaxKind.PrivateKeyword ||
-      m.kind === ts.SyntaxKind.ProtectedKeyword ||
-      m.kind === ts.SyntaxKind.StaticKeyword ||
-      m.kind === ts.SyntaxKind.ReadonlyKeyword ||
-      m.kind === ts.SyntaxKind.AbstractKeyword
-    )
-    .map(m => m.getText());
-  return relevant.length ? relevant.join(" ") + " " : "";
-}
-
-function hasModifier(node: ts.Node, kind: ts.SyntaxKind): boolean {
-  const mods = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
-  return mods?.some(m => m.kind === kind) ?? false;
-}
-
-function getTypeName(node: ts.Node): string {
-  if (ts.isIdentifier(node)) return node.text;
-  return "…";
-}
-
-function collapseWhitespace(s: string): string {
-  return s.replace(/\s+/g, " ").trim();
-}
+/**
+ * Hologram Engine — Language Dispatcher
+ *
+ * Routes file parsing to the appropriate tree-sitter extractor based on extension.
+ * Falls back to L0 (full source) for unsupported languages or parse errors.
+ */
+
+import { TreeSitterEngine } from "./hologram/engine";
+import { tsExtractor } from "./hologram/ts-extractor";
+import { pyExtractor } from "./hologram/py-extractor";
+import { goExtractor } from "./hologram/go-extractor";
+import { rustExtractor } from "./hologram/rust-extractor";
+import { fallbackL0 } from "./hologram/fallback";
+import { generateIncrementalHologram, setCachedHologram } from "./hologram/incremental";
+import type { HologramResult, HologramOptions, LanguageExtractor } from "./hologram/types";
+
+// Re-export types for backward compatibility
+export type { HologramResult, HologramOptions } from "./hologram/types";
+export { clearHologramCache } from "./hologram/incremental";
+
+const extractors: LanguageExtractor[] = [tsExtractor, pyExtractor, goExtractor, rustExtractor];
+
+function detectExtractor(filePath: string): LanguageExtractor | null {
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+  return extractors.find(e => e.extensions.includes(ext)) ?? null;
+}
+
+export async function generateHologram(
+  filePath: string,
+  source: string,
+  options?: HologramOptions,
+): Promise<HologramResult> {
+  const extractor = detectExtractor(filePath);
+
+  if (!extractor) {
+    return fallbackL0(filePath, source);
+  }
+
+  // Incremental diff mode
+  if (options?.diffOnly) {
+    try {
+      return await generateIncrementalHologram(filePath, source, extractor, options);
+    } catch {
+      return fallbackL0(filePath, source);
+    }
+  }
+
+  try {
+    const engine = await TreeSitterEngine.getInstance();
+    const tree = await engine.parse(source, extractor.grammarName);
+    const lines = extractor.extract(tree, source, options);
+    tree.delete();
+
+    // Cache for future incremental diffs
+    setCachedHologram(filePath, lines);
+
+    const hologram = lines.join("\n");
+    const hologramLength = hologram.length;
+    const savings = source.length > 0
+      ? Math.round((source.length - hologramLength) / source.length * 1000) / 10
+      : 0;
+
+    return {
+      hologram,
+      originalLength: source.length,
+      hologramLength,
+      savings,
+      language: extractor.grammarName,
+    };
+  } catch {
+    return fallbackL0(filePath, source);
+  }
+}

package/src/core/hook-manager.ts

@@ -0,0 +1,259 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname } from "path";
+import { resolveHookCommand } from "../platform";
+
+export type HookOwner = "afd" | "omc" | "user";
+
+export interface HookEntry {
+  id?: string;
+  matcher?: string;
+  command: string;
+  [key: string]: unknown;
+}
+
+export interface HooksConfig {
+  hooks?: Record<string, HookEntry[]>;
+  [key: string]: unknown;
+}
+
+export interface ManagedHook {
+  id: string;
+  matcher: string;
+  command: string;
+  owner: HookOwner;
+}
+
+export interface HookConflict {
+  type: "matcher-overlap" | "duplicate-id";
+  hookA: ManagedHook;
+  hookB: ManagedHook;
+  resolution: string;
+}
+
+export interface MergeResult {
+  merged: HookEntry[];
+  conflicts: HookConflict[];
+  changes: { added: string[]; removed: string[]; reordered: string[] };
+}
+
+export interface HookSummary {
+  zones: Record<HookOwner, ManagedHook[]>;
+  conflicts: HookConflict[];
+  orderingOk: boolean;
+  total: number;
+}
+
+/**
+ * Canonical set of afd-managed hooks.
+ * Only hooks in this set are removed during `stop --clean`.
+ * This prevents accidental deletion of user hooks with an `afd-` prefix
+ * (e.g., project-local `afd-read-gate` scripts).
+ */
+export const KNOWN_AFD_HOOKS = new Set(["afd-auto-heal"]);
+
+/** afd's canonical desired hooks — authoritative source for merge. */
+export function getAfdDesiredHooks(): HookEntry[] {
+  return [
+    {
+      id: "afd-auto-heal",
+      matcher: "Write|Edit|MultiEdit",
+      command: resolveHookCommand(),
+    },
+  ];
+}
+
+/** Classify a hook's owner by id prefix. */
+export function classifyOwner(id: string): HookOwner {
+  if (id.startsWith("afd-")) return "afd";
+  if (id.startsWith("omc-")) return "omc";
+  return "user";
+}
+
+/** Classify a list of hook entries into owner zones. */
+export function classifyHooks(entries: HookEntry[]): Map<HookOwner, ManagedHook[]> {
+  const zones = new Map<HookOwner, ManagedHook[]>([
+    ["afd", []],
+    ["omc", []],
+    ["user", []],
+  ]);
+  let anonIdx = 0;
+  for (const entry of entries) {
+    const id = entry.id ?? `user-anonymous-${anonIdx++}`;
+    const owner = classifyOwner(id);
+    zones.get(owner)!.push({
+      id,
+      matcher: entry.matcher ?? "",
+      command: entry.command,
+      owner,
+    });
+  }
+  return zones;
+}
+
+/** Detect conflicts between hooks from different owners. */
+export function detectConflicts(hooks: ManagedHook[]): HookConflict[] {
+  const conflicts: HookConflict[] = [];
+
+  // 1. Duplicate ID check
+  const idMap = new Map<string, ManagedHook>();
+  for (const hook of hooks) {
+    if (idMap.has(hook.id)) {
+      conflicts.push({
+        type: "duplicate-id",
+        hookA: idMap.get(hook.id)!,
+        hookB: hook,
+        resolution: `Remove or rename one of the duplicate '${hook.id}' hooks`,
+      });
+    } else {
+      idMap.set(hook.id, hook);
+    }
+  }
+
+  // 2. Matcher overlap check (cross-owner only, O(n^2) — safe for <20 hooks)
+  for (let i = 0; i < hooks.length; i++) {
+    for (let j = i + 1; j < hooks.length; j++) {
+      if (hooks[i].owner === hooks[j].owner) continue;
+      const matcherA = hooks[i].matcher || "*";
+      const matcherB = hooks[j].matcher || "*";
+      const setA = new Set(matcherA.split("|").map(s => s.trim()));
+      const setB = new Set(matcherB.split("|").map(s => s.trim()));
+      const aIsWild = setA.has("*") || setA.has("");
+      const bIsWild = setB.has("*") || setB.has("");
+      const overlap =
+        aIsWild || bIsWild || [...setA].some(m => setB.has(m));
+      if (overlap) {
+        const shared =
+          aIsWild || bIsWild
+            ? "*"
+            : [...setA].filter(m => setB.has(m)).join("|");
+        conflicts.push({
+          type: "matcher-overlap",
+          hookA: hooks[i],
+          hookB: hooks[j],
+          resolution: `Both hooks trigger on '${shared}'. Verify they don't conflict in behavior.`,
+        });
+      }
+    }
+  }
+
+  return conflicts;
+}
+
+/** Read hooks.json from disk, returning empty config on missing/invalid file. */
+export function readHooksFile(hooksPath: string): HooksConfig {
+  if (!existsSync(hooksPath)) return { hooks: {} };
+  try {
+    return JSON.parse(readFileSync(hooksPath, "utf-8")) as HooksConfig;
+  } catch {
+    return { hooks: {} };
+  }
+}
+
+/** Write hooks.json to disk, creating parent directory if needed. */
+export function writeHooksFile(hooksPath: string, config: HooksConfig): void {
+  mkdirSync(dirname(hooksPath), { recursive: true });
+  writeFileSync(hooksPath, JSON.stringify(config, null, 2), "utf-8");
+}
+
+/**
+ * Merge current hook entries with the desired afd hooks.
+ * Ordering guarantee: afd → omc → user.
+ * afd zone is fully authoritative — desired list overwrites existing afd hooks.
+ * omc and user zones are preserved as-is from the current file.
+ */
+export function mergeHooks(
+  current: HookEntry[],
+  desiredAfd: HookEntry[],
+): MergeResult {
+  const changes: MergeResult["changes"] = { added: [], removed: [], reordered: [] };
+
+  const zones = classifyHooks(current);
+  const afdExisting = zones.get("afd")!;
+  const omcHooks = zones.get("omc")!;
+  const userHooks = zones.get("user")!;
+
+  // Build merged afd zone from desired list (authoritative)
+  const mergedAfd: HookEntry[] = desiredAfd.map(desired => {
+    const existing = afdExisting.find(h => h.id === desired.id);
+    if (!existing) changes.added.push(desired.id!);
+    return desired;
+  });
+
+  // Track explicitly removed afd hooks (only canonical ones)
+  for (const existing of afdExisting) {
+    if (KNOWN_AFD_HOOKS.has(existing.id) && !desiredAfd.find(d => d.id === existing.id)) {
+      changes.removed.push(existing.id);
+    }
+  }
+
+  // Detect reordering (only if no add/remove)
+  if (changes.added.length === 0 && changes.removed.length === 0) {
+    const originalOrder = current.map(h => h.id ?? "");
+    const newOrder = [
+      ...mergedAfd.map(h => h.id!),
+      ...omcHooks.map(h => h.id),
+      ...userHooks.map(h => h.id),
+    ];
+    const hasReordering =
+      originalOrder.length !== newOrder.length ||
+      originalOrder.some((id, i) => id !== (newOrder[i] ?? ""));
+    if (hasReordering) {
+      changes.reordered.push("hooks reordered to afd → omc → user zones");
+    }
+  }
+
+  const merged: HookEntry[] = [
+    ...mergedAfd,
+    ...omcHooks.map(({ id, matcher, command }) => ({ id, matcher, command })),
+    ...userHooks.map(({ id, matcher, command }) => ({ id, matcher, command })),
+  ];
+
+  const allManaged: ManagedHook[] = [
+    ...mergedAfd.map(h => ({
+      id: h.id!,
+      matcher: h.matcher ?? "",
+      command: h.command,
+      owner: "afd" as HookOwner,
+    })),
+    ...omcHooks,
+    ...userHooks,
+  ];
+  const conflicts = detectConflicts(allManaged);
+
+  return { merged, conflicts, changes };
+}
+
+/** Get a summary of current hook state for display and status commands. */
+export function getHookSummary(hooksPath: string): HookSummary {
+  const config = readHooksFile(hooksPath);
+  const entries = config.hooks?.PreToolUse ?? [];
+  const zones = classifyHooks(entries);
+
+  const allHooks: ManagedHook[] = [
+    ...(zones.get("afd") ?? []),
+    ...(zones.get("omc") ?? []),
+    ...(zones.get("user") ?? []),
+  ];
+  const conflicts = detectConflicts(allHooks);
+
+  // Check ordering invariant: afd(0) → omc(1) → user(2)
+  const ownerPriority: Record<HookOwner, number> = { afd: 0, omc: 1, user: 2 };
+  let orderingOk = true;
+  let lastPriority = -1;
+  for (const entry of entries) {
+    const id = entry.id ?? "";
+    const priority = ownerPriority[classifyOwner(id)];
+    if (priority < lastPriority) {
+      orderingOk = false;
+      break;
+    }
+    lastPriority = priority;
+  }
+
+  return {
+    zones: Object.fromEntries(zones) as Record<HookOwner, ManagedHook[]>,
+    conflicts,
+    orderingOk,
+    total: entries.length,
+  };
+}