autonomous-flow-daemon 1.0.0 → 1.6.0

package/src/core/hologram/ts-extractor.ts

@@ -0,0 +1,320 @@
+import type { Node, Tree } from "web-tree-sitter";
+import type { LanguageExtractor, HologramOptions } from "./types";
+import { readFileSync } from "fs";
+
+/** Extract imported symbols from a context file using regex (L1 filtering) */
+function extractImportedSymbols(contextSource: string, targetPath: string): Set<string> | "all" {
+  const symbols = new Set<string>();
+  const targetBase = targetPath.replace(/\.[tj]sx?$/, "").replace(/\\/g, "/");
+  const targetName = targetBase.split("/").pop() ?? targetBase;
+
+  function matchesTarget(from: string): boolean {
+    const normalized = from.replace(/\.[tj]sx?$/, "").replace(/\\/g, "/");
+    return normalized.endsWith(targetName) || normalized.endsWith(targetBase);
+  }
+
+  // Namespace import
+  const nsRe = /import\s+\*\s+as\s+\w+\s+from\s+["']([^"']+)["']/g;
+  for (const m of contextSource.matchAll(nsRe)) {
+    if (matchesTarget(m[1])) return "all";
+  }
+
+  // Named imports
+  const namedRe = /import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["']/g;
+  for (const m of contextSource.matchAll(namedRe)) {
+    if (matchesTarget(m[2])) {
+      m[1].split(",").forEach(s => {
+        const name = s.trim().split(/\s+as\s+/)[0].trim();
+        if (name) symbols.add(name);
+      });
+    }
+  }
+
+  // Default import
+  const defaultRe = /import\s+(\w+)\s+from\s+["']([^"']+)["']/g;
+  for (const m of contextSource.matchAll(defaultRe)) {
+    if (matchesTarget(m[2])) symbols.add("default");
+  }
+
+  // Combined: import X, { A, B } from "./target"
+  const combinedRe = /import\s+(\w+)\s*,\s*\{([^}]+)\}\s+from\s+["']([^"']+)["']/g;
+  for (const m of contextSource.matchAll(combinedRe)) {
+    if (matchesTarget(m[3])) {
+      symbols.add("default");
+      m[2].split(",").forEach(s => {
+        const name = s.trim().split(/\s+as\s+/)[0].trim();
+        if (name) symbols.add(name);
+      });
+    }
+  }
+
+  return symbols;
+}
+
+/** Get the exported name from a top-level declaration node */
+function getExportedName(node: Node): string | null {
+  // Check if wrapped in export_statement
+  const parent = node.parent;
+  const isExported = parent?.type === "export_statement" || node.type === "export_statement";
+  if (!isExported && parent?.type !== "program") return null;
+  if (!isExported) return null;
+
+  const decl = node.type === "export_statement"
+    ? node.namedChildren.find(c =>
+        c.type === "function_declaration" ||
+        c.type === "class_declaration" ||
+        c.type === "interface_declaration" ||
+        c.type === "type_alias_declaration" ||
+        c.type === "enum_declaration" ||
+        c.type === "lexical_declaration")
+    : node;
+
+  if (!decl) return null;
+
+  const nameNode = decl.childForFieldName("name");
+  if (nameNode) return nameNode.text;
+
+  // Variable declarations
+  if (decl.type === "lexical_declaration") {
+    const declarator = decl.namedChildren.find(c => c.type === "variable_declarator");
+    return declarator?.childForFieldName("name")?.text ?? null;
+  }
+
+  return null;
+}
+
+/** Stub a node's body, keeping only the signature */
+function stubBody(node: Node, source: string): string {
+  const body = node.childForFieldName("body");
+  if (!body) return collapseWhitespace(node.text);
+  return collapseWhitespace(source.slice(node.startIndex, body.startIndex).trimEnd()) + " {…}";
+}
+
+/** Extract function signature */
+function extractFunction(node: Node, source: string): string {
+  return stubBody(node, source);
+}
+
+/** Extract class with member signatures */
+function extractClass(node: Node, source: string): string {
+  const nameNode = node.childForFieldName("name");
+  const name = nameNode?.text ?? "Anonymous";
+  const body = node.childForFieldName("body");
+
+  // Heritage (extends/implements)
+  let heritage = "";
+  const heritageNodes = node.children.filter(c =>
+    c.type === "extends_clause" || c.type === "implements_clause" ||
+    c.type === "class_heritage");
+  if (heritageNodes.length > 0) {
+    heritage = " " + heritageNodes.map(h => collapseWhitespace(h.text)).join(" ");
+  }
+
+  // Prefix (export, abstract, etc.)
+  const prefix = collapseWhitespace(
+    source.slice(node.startIndex, (nameNode ?? body ?? node).startIndex).trimEnd()
+  ).replace(name, "").trimEnd();
+  const classPrefix = prefix ? `${prefix} ${name}` : `class ${name}`;
+
+  if (!body) return `${classPrefix}${heritage} {}`;
+
+  const members: string[] = [];
+  for (const member of body.namedChildren) {
+    switch (member.type) {
+      case "public_field_definition":
+      case "property_definition": {
+        members.push("  " + collapseWhitespace(member.text).replace(/;$/, "") + ";");
+        break;
+      }
+      case "method_definition": {
+        const methodBody = member.childForFieldName("body");
+        if (methodBody) {
+          const sig = collapseWhitespace(source.slice(member.startIndex, methodBody.startIndex).trimEnd());
+          members.push("  " + sig + ";");
+        } else {
+          members.push("  " + collapseWhitespace(member.text) + ";");
+        }
+        break;
+      }
+    }
+  }
+
+  return `${classPrefix}${heritage} {\n${members.join("\n")}\n}`;
+}
+
+/** Extract interface with all members */
+function extractInterface(node: Node, source: string): string {
+  const nameNode = node.childForFieldName("name");
+  const name = nameNode?.text ?? "Anonymous";
+  const body = node.childForFieldName("body");
+
+  // Heritage (extends)
+  const extendsClause = node.children.find(c => c.type === "extends_type_clause");
+  const ext = extendsClause ? " " + collapseWhitespace(extendsClause.text) : "";
+
+  // Prefix
+  const prefixEnd = (nameNode ?? body ?? node).startIndex;
+  const rawPrefix = source.slice(node.startIndex, prefixEnd).trimEnd();
+  const prefix = collapseWhitespace(rawPrefix).replace(name, "").trimEnd();
+  const ifacePrefix = prefix ? `${prefix} ${name}` : `interface ${name}`;
+
+  if (!body) return `${ifacePrefix}${ext} {}`;
+
+  const members = body.namedChildren.map(m => {
+    const text = collapseWhitespace(m.text).replace(/;$/, "");
+    return "  " + text + ";";
+  });
+
+  return `${ifacePrefix}${ext} {\n${members.join("\n")}\n}`;
+}
+
+/** Extract enum */
+function extractEnum(node: Node): string {
+  const nameNode = node.childForFieldName("name");
+  const name = nameNode?.text ?? "Anonymous";
+  const body = node.childForFieldName("body");
+
+  const isExport = node.parent?.type === "export_statement" ? "export " : "";
+  const isConst = node.children.some(c => c.text === "const") ? "const " : "";
+
+  if (!body) return `${isExport}${isConst}enum ${name} {}`;
+
+  const members = body.namedChildren
+    .filter(m => m.type === "enum_member" || m.type === "property_identifier")
+    .map(m => collapseWhitespace(m.text));
+
+  return `${isExport}${isConst}enum ${name} { ${members.join(", ")} }`;
+}
+
+/** Extract variable statement (const/let/var with possible arrow functions) */
+function extractVariable(node: Node, source: string): string {
+  const keyword = node.children[0]?.text ?? "const";
+  const isExport = node.parent?.type === "export_statement" ? "export " : "";
+
+  const declarators = node.namedChildren.filter(c => c.type === "variable_declarator");
+  const parts = declarators.map(d => {
+    const name = d.childForFieldName("name")?.text ?? "?";
+    const typeAnn = d.childForFieldName("type")
+      ? ": " + collapseWhitespace(d.childForFieldName("type")!.text)
+      : "";
+    const value = d.childForFieldName("value");
+
+    if (value && (value.type === "arrow_function" || value.type === "function_expression" || value.type === "function")) {
+      return `${name} = ${stubBody(value, source)}`;
+    }
+    if (typeAnn) return `${name}${typeAnn}`;
+    if (value) return `${name} = …`;
+    return name;
+  });
+
+  return `${isExport}${keyword} ${parts.join(", ")};`;
+}
+
+/** Extract type alias */
+function extractTypeAlias(node: Node): string {
+  const isExport = node.parent?.type === "export_statement" ? "export " : "";
+  return isExport + collapseWhitespace(node.text);
+}
+
+function collapseWhitespace(s: string): string {
+  return s.replace(/\s+/g, " ").trim();
+}
+
+/** Process a single top-level statement */
+function extractTopLevel(node: Node, source: string): string | null {
+  // Unwrap export_statement to get the inner declaration
+  if (node.type === "export_statement") {
+    // Re-export: export { ... } from "..."
+    const exportClause = node.namedChildren.find(c => c.type === "export_clause");
+    if (exportClause) return collapseWhitespace(node.text);
+
+    // export default expression
+    const defaultKw = node.children.find(c => c.text === "default");
+    if (defaultKw) {
+      const inner = node.namedChildren.find(c => c.type !== "export_clause");
+      if (inner && (inner.type === "function_declaration" || inner.type === "class_declaration")) {
+        return "export default " + extractTopLevel(inner, source);
+      }
+      return `export default …;`;
+    }
+
+    // export <declaration>
+    const inner = node.namedChildren[0];
+    if (inner) {
+      const result = extractTopLevel(inner, source);
+      if (result) {
+        const alreadyHasExport = result.startsWith("export ");
+        return alreadyHasExport ? result : "export " + result;
+      }
+    }
+    return collapseWhitespace(node.text);
+  }
+
+  switch (node.type) {
+    case "import_statement":
+      return collapseWhitespace(node.text);
+    case "function_declaration":
+    case "generator_function_declaration":
+      return extractFunction(node, source);
+    case "class_declaration":
+      return extractClass(node, source);
+    case "interface_declaration":
+      return extractInterface(node, source);
+    case "type_alias_declaration":
+      return extractTypeAlias(node);
+    case "enum_declaration":
+      return extractEnum(node);
+    case "lexical_declaration":
+    case "variable_declaration":
+      return extractVariable(node, source);
+    case "export_statement":
+      return collapseWhitespace(node.text);
+    default:
+      return null;
+  }
+}
+
+export const tsExtractor: LanguageExtractor = {
+  extensions: ["ts", "tsx", "js", "jsx", "mts", "cts"],
+  grammarName: "typescript",
+
+  extract(tree: Tree, source: string, options?: HologramOptions): string[] {
+    const lines: string[] = [];
+
+    // L1 filtering setup
+    let importedSymbols: Set<string> | "all" | null = null;
+    if (options?.contextFile) {
+      try {
+        const contextSource = readFileSync(options.contextFile, "utf-8");
+        importedSymbols = extractImportedSymbols(contextSource, "");
+        if (importedSymbols !== "all" && importedSymbols.size === 0) importedSymbols = null;
+      } catch {
+        importedSymbols = null;
+      }
+    }
+
+    for (const stmt of tree.rootNode.namedChildren) {
+      // L1: filter non-imported exports
+      if (importedSymbols && importedSymbols !== "all") {
+        const exportedName = getExportedName(stmt);
+        if (exportedName !== null && !importedSymbols.has(exportedName)) {
+          const line = extractTopLevel(stmt, source);
+          if (line) {
+            const stub = line.split("\n")[0].replace(/\{[^}]*\}?\s*$/, "").trimEnd();
+            lines.push(`${stub} // details omitted — read directly if needed`);
+          }
+          continue;
+        }
+      }
+
+      const line = extractTopLevel(stmt, source);
+      if (line) lines.push(line);
+    }
+
+    if (importedSymbols && importedSymbols !== "all") {
+      lines.push("\n// [afd L1] Non-imported exports are shown as stubs. Use afd_read for full details.");
+    }
+
+    return lines;
+  },
+};

package/src/core/hologram/types.ts

@@ -0,0 +1,25 @@
+import type { Tree } from "web-tree-sitter";
+
+export interface HologramResult {
+  hologram: string;
+  originalLength: number;
+  hologramLength: number;
+  savings: number; // percentage 0-100
+  language?: string;
+  isDiff?: boolean;
+  changedNodes?: number;
+}
+
+export interface HologramOptions {
+  contextFile?: string;
+  diffOnly?: boolean;
+}
+
+export interface LanguageExtractor {
+  /** Supported file extensions (without dot) */
+  extensions: string[];
+  /** Tree-sitter grammar name for WASM resolution */
+  grammarName: string;
+  /** Extract type signatures from AST */
+  extract(tree: Tree, source: string, options?: HologramOptions): string[];
+}

package/src/core/hologram.ts

@@ -1,243 +1,71 @@
-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());
+/**
+ * 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 { 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];
+
+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);
   }
 
-  // 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});`);
+  // Incremental diff mode
+  if (options?.diffOnly) {
+    try {
+      return await generateIncrementalHologram(filePath, source, extractor, options);
+    } catch {
+      return fallbackL0(filePath, source);
     }
   }
 
-  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})`;
+  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);
   }
-
-  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();
 }