autonomous-flow-daemon 1.6.0 → 1.9.0

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

@@ -1,132 +1,132 @@
-import type { Node, Tree } from "web-tree-sitter";
-import type { LanguageExtractor, HologramOptions } from "./types";
-
-/** Stub a Python function/method body — keep signature + "..." */
-function stubPythonBody(node: Node, source: string): string {
-  const body = node.childForFieldName("body");
-  if (!body) return node.text;
-  return source.slice(node.startIndex, body.startIndex).trimEnd() + " ...";
-}
-
-/** Extract a Python function definition */
-function extractFunction(node: Node, source: string): string {
-  // Decorators
-  const decorators = collectDecorators(node, source);
-  const sig = stubPythonBody(node, source);
-  return decorators + sig;
-}
-
-/** Extract a Python class with method signatures */
-function extractClass(node: Node, source: string): string {
-  const decorators = collectDecorators(node, source);
-  const nameNode = node.childForFieldName("name");
-  const name = nameNode?.text ?? "?";
-  const superclasses = node.childForFieldName("superclasses");
-  const sup = superclasses ? superclasses.text : "";
-  const body = node.childForFieldName("body");
-
-  const header = `class ${name}${sup ? `(${sup.replace(/^\(|\)$/g, "")})` : ""}:`;
-
-  if (!body) return decorators + header;
-
-  const members: string[] = [];
-  for (const child of body.namedChildren) {
-    switch (child.type) {
-      case "function_definition": {
-        const memberDecorators = collectDecorators(child, source);
-        members.push(indent(memberDecorators + stubPythonBody(child, source)));
-        break;
-      }
-      case "expression_statement": {
-        // Type-annotated assignments: x: int = 42
-        const expr = child.namedChildren[0];
-        if (expr?.type === "assignment" || expr?.type === "type") {
-          members.push(indent(child.text.split("\n")[0]));
-        }
-        break;
-      }
-      case "class_definition": {
-        // Nested class — just show header
-        const nestedName = child.childForFieldName("name")?.text ?? "?";
-        members.push(indent(`class ${nestedName}: ...`));
-        break;
-      }
-    }
-  }
-
-  if (members.length === 0) {
-    return decorators + header + "\n    ...";
-  }
-
-  return decorators + header + "\n" + members.join("\n");
-}
-
-/** Collect decorator lines above a node */
-function collectDecorators(node: Node, source: string): string {
-  const decorators: string[] = [];
-  // In tree-sitter-python, decorators are children of the decorated_definition
-  // or are 'decorator' type children of the function/class
-  const parent = node.parent;
-  if (parent?.type === "decorated_definition") {
-    for (const child of parent.namedChildren) {
-      if (child.type === "decorator") {
-        decorators.push(child.text);
-      }
-    }
-  }
-  return decorators.length > 0 ? decorators.join("\n") + "\n" : "";
-}
-
-function indent(s: string): string {
-  return s.split("\n").map(line => "    " + line).join("\n");
-}
-
-/** Process a single top-level statement */
-function extractTopLevel(node: Node, source: string): string | null {
-  switch (node.type) {
-    case "import_statement":
-    case "import_from_statement":
-      return node.text;
-    case "function_definition":
-      return extractFunction(node, source);
-    case "class_definition":
-      return extractClass(node, source);
-    case "decorated_definition": {
-      // Unwrap to get the inner function/class
-      const inner = node.namedChildren.find(c =>
-        c.type === "function_definition" || c.type === "class_definition");
-      if (inner) return extractTopLevel(inner, source);
-      return null;
-    }
-    case "expression_statement": {
-      // Module-level type annotations or assignments
-      const expr = node.namedChildren[0];
-      if (expr?.type === "assignment" || expr?.type === "type") {
-        return node.text.split("\n")[0];
-      }
-      // __all__ = [...]
-      if (node.text.startsWith("__all__")) {
-        return node.text;
-      }
-      return null;
-    }
-    default:
-      return null;
-  }
-}
-
-export const pyExtractor: LanguageExtractor = {
-  extensions: ["py", "pyi"],
-  grammarName: "python",
-
-  extract(tree: Tree, source: string, _options?: HologramOptions): string[] {
-    const lines: string[] = [];
-
-    for (const stmt of tree.rootNode.namedChildren) {
-      const line = extractTopLevel(stmt, source);
-      if (line) lines.push(line);
-    }
-
-    return lines;
-  },
-};
+import type { Node, Tree } from "web-tree-sitter";
+import type { LanguageExtractor, HologramOptions } from "./types";
+
+/** Stub a Python function/method body — keep signature + "..." */
+function stubPythonBody(node: Node, source: string): string {
+  const body = node.childForFieldName("body");
+  if (!body) return node.text;
+  return source.slice(node.startIndex, body.startIndex).trimEnd() + " ...";
+}
+
+/** Extract a Python function definition */
+function extractFunction(node: Node, source: string): string {
+  // Decorators
+  const decorators = collectDecorators(node, source);
+  const sig = stubPythonBody(node, source);
+  return decorators + sig;
+}
+
+/** Extract a Python class with method signatures */
+function extractClass(node: Node, source: string): string {
+  const decorators = collectDecorators(node, source);
+  const nameNode = node.childForFieldName("name");
+  const name = nameNode?.text ?? "?";
+  const superclasses = node.childForFieldName("superclasses");
+  const sup = superclasses ? superclasses.text : "";
+  const body = node.childForFieldName("body");
+
+  const header = `class ${name}${sup ? `(${sup.replace(/^\(|\)$/g, "")})` : ""}:`;
+
+  if (!body) return decorators + header;
+
+  const members: string[] = [];
+  for (const child of body.namedChildren) {
+    switch (child.type) {
+      case "function_definition": {
+        const memberDecorators = collectDecorators(child, source);
+        members.push(indent(memberDecorators + stubPythonBody(child, source)));
+        break;
+      }
+      case "expression_statement": {
+        // Type-annotated assignments: x: int = 42
+        const expr = child.namedChildren[0];
+        if (expr?.type === "assignment" || expr?.type === "type") {
+          members.push(indent(child.text.split("\n")[0]));
+        }
+        break;
+      }
+      case "class_definition": {
+        // Nested class — just show header
+        const nestedName = child.childForFieldName("name")?.text ?? "?";
+        members.push(indent(`class ${nestedName}: ...`));
+        break;
+      }
+    }
+  }
+
+  if (members.length === 0) {
+    return decorators + header + "\n    ...";
+  }
+
+  return decorators + header + "\n" + members.join("\n");
+}
+
+/** Collect decorator lines above a node */
+function collectDecorators(node: Node, source: string): string {
+  const decorators: string[] = [];
+  // In tree-sitter-python, decorators are children of the decorated_definition
+  // or are 'decorator' type children of the function/class
+  const parent = node.parent;
+  if (parent?.type === "decorated_definition") {
+    for (const child of parent.namedChildren) {
+      if (child.type === "decorator") {
+        decorators.push(child.text);
+      }
+    }
+  }
+  return decorators.length > 0 ? decorators.join("\n") + "\n" : "";
+}
+
+function indent(s: string): string {
+  return s.split("\n").map(line => "    " + line).join("\n");
+}
+
+/** Process a single top-level statement */
+function extractTopLevel(node: Node, source: string): string | null {
+  switch (node.type) {
+    case "import_statement":
+    case "import_from_statement":
+      return node.text;
+    case "function_definition":
+      return extractFunction(node, source);
+    case "class_definition":
+      return extractClass(node, source);
+    case "decorated_definition": {
+      // Unwrap to get the inner function/class
+      const inner = node.namedChildren.find(c =>
+        c.type === "function_definition" || c.type === "class_definition");
+      if (inner) return extractTopLevel(inner, source);
+      return null;
+    }
+    case "expression_statement": {
+      // Module-level type annotations or assignments
+      const expr = node.namedChildren[0];
+      if (expr?.type === "assignment" || expr?.type === "type") {
+        return node.text.split("\n")[0];
+      }
+      // __all__ = [...]
+      if (node.text.startsWith("__all__")) {
+        return node.text;
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+
+export const pyExtractor: LanguageExtractor = {
+  extensions: ["py", "pyi"],
+  grammarName: "python",
+
+  extract(tree: Tree, source: string, _options?: HologramOptions): string[] {
+    const lines: string[] = [];
+
+    for (const stmt of tree.rootNode.namedChildren) {
+      const line = extractTopLevel(stmt, source);
+      if (line) lines.push(line);
+    }
+
+    return lines;
+  },
+};

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

@@ -0,0 +1,244 @@
+import type { Node, Tree } from "web-tree-sitter";
+import type { LanguageExtractor, HologramOptions } from "./types";
+
+/**
+ * Collapse multiple whitespace/newlines into a single space.
+ */
+function collapse(s: string): string {
+  return s.replace(/\s+/g, " ").trim();
+}
+
+/**
+ * Stub a function body: slice source up to (but not including) the `block` node.
+ * Returns `fn signature(…) -> ReturnType {…}`.
+ */
+function stubFnBody(node: Node, source: string): string {
+  const block = node.childForFieldName("body") ?? node.namedChildren.find(c => c.type === "block");
+  if (!block) return collapse(node.text);
+  return collapse(source.slice(node.startIndex, block.startIndex).trimEnd()) + " {…}";
+}
+
+/**
+ * Extract a `use_declaration`:
+ *   use std::collections::HashMap;
+ */
+function extractUse(node: Node): string {
+  return collapse(node.text);
+}
+
+/**
+ * Extract a `mod_item`:
+ *   mod utils;                          (external module declaration)
+ *   mod config { pub fn default() {} }  (inline module — show header + {…})
+ */
+function extractMod(node: Node, source: string): string {
+  const body = node.namedChildren.find(c => c.type === "declaration_list");
+  if (!body) return collapse(node.text); // `mod utils;` — preserve as-is
+  // Inline mod: show header only
+  return collapse(source.slice(node.startIndex, body.startIndex).trimEnd()) + " {…}";
+}
+
+/**
+ * Extract a `struct_item` with all field declarations.
+ *
+ * Example output:
+ *   pub struct Config {
+ *     pub host: String,
+ *     pub port: u16,
+ *     enabled: bool,
+ *   }
+ */
+function extractStruct(node: Node, source: string): string {
+  const fieldList = node.namedChildren.find(c => c.type === "field_declaration_list");
+
+  // Tuple struct or unit struct — no braced field list
+  if (!fieldList) return collapse(node.text);
+
+  // Build header: everything before the field list
+  const header = collapse(source.slice(node.startIndex, fieldList.startIndex).trimEnd());
+
+  const fields = fieldList.namedChildren
+    .filter(c => c.type === "field_declaration")
+    .map(f => "  " + collapse(f.text) + ",");
+
+  if (fields.length === 0) return `${header} {}`;
+  return `${header} {\n${fields.join("\n")}\n}`;
+}
+
+/**
+ * Extract an `enum_item` with all variants.
+ *
+ * Example output:
+ *   pub enum Status {
+ *     Active,
+ *     Inactive,
+ *     Error(String),
+ *   }
+ */
+function extractEnum(node: Node, source: string): string {
+  const variantList = node.namedChildren.find(c => c.type === "enum_variant_list");
+  if (!variantList) return collapse(node.text);
+
+  const header = collapse(source.slice(node.startIndex, variantList.startIndex).trimEnd());
+
+  const variants = variantList.namedChildren
+    .filter(c => c.type === "enum_variant")
+    .map(v => "  " + collapse(v.text) + ",");
+
+  if (variants.length === 0) return `${header} {}`;
+  return `${header} {\n${variants.join("\n")}\n}`;
+}
+
+/**
+ * Extract a `trait_item` with method signatures (no bodies — traits only contain signatures).
+ *
+ * Example output:
+ *   pub trait Handler {
+ *     fn handle(&self, req: &Request) -> Response;
+ *     fn name(&self) -> &str;
+ *   }
+ */
+function extractTrait(node: Node, source: string): string {
+  const body = node.namedChildren.find(c => c.type === "declaration_list");
+  if (!body) return collapse(node.text);
+
+  const header = collapse(source.slice(node.startIndex, body.startIndex).trimEnd());
+
+  const members: string[] = [];
+  for (const child of body.namedChildren) {
+    switch (child.type) {
+      case "function_signature_item":
+        // Already a pure signature (no body)
+        members.push("  " + collapse(child.text));
+        break;
+      case "function_item":
+        // Default implementation — stub body
+        members.push("  " + stubFnBody(child, source));
+        break;
+      case "type_item":
+        // Associated type: `type Output;`
+        members.push("  " + collapse(child.text));
+        break;
+      case "const_item":
+        // Associated const: `const N: usize;`
+        members.push("  " + collapse(child.text));
+        break;
+      case "comment":
+        break;
+      default:
+        members.push("  " + collapse(child.text));
+    }
+  }
+
+  if (members.length === 0) return `${header} {}`;
+  return `${header} {\n${members.join("\n")}\n}`;
+}
+
+/**
+ * Extract a `type_item` (type alias).
+ *   pub type Result<T> = std::result::Result<T, Box<dyn Error>>;
+ */
+function extractTypeAlias(node: Node): string {
+  return collapse(node.text);
+}
+
+/**
+ * Extract an `impl_item` with stubbed method bodies.
+ *
+ * Handles:
+ *   impl Config { ... }
+ *   impl Handler for MyHandler { ... }
+ *   impl<T: Trait> OtherTrait for Wrapper<T> { ... }
+ *
+ * Example output:
+ *   impl Config {
+ *     pub fn new(host: String, port: u16) -> Self {…}
+ *     pub fn is_enabled(&self) -> bool {…}
+ *   }
+ */
+function extractImpl(node: Node, source: string): string {
+  const body = node.namedChildren.find(c => c.type === "declaration_list");
+  if (!body) return collapse(node.text);
+
+  const header = collapse(source.slice(node.startIndex, body.startIndex).trimEnd());
+
+  const methods: string[] = [];
+  for (const child of body.namedChildren) {
+    switch (child.type) {
+      case "function_item":
+        methods.push("  " + stubFnBody(child, source));
+        break;
+      case "type_item":
+        // Associated type implementation: `type Output = i32;`
+        methods.push("  " + collapse(child.text));
+        break;
+      case "const_item":
+        // Associated const implementation
+        methods.push("  " + collapse(child.text));
+        break;
+      case "comment":
+        break;
+      default:
+        methods.push("  " + collapse(child.text));
+    }
+  }
+
+  if (methods.length === 0) return `${header} {}`;
+  return `${header} {\n${methods.join("\n")}\n}`;
+}
+
+/**
+ * Extract a standalone `function_item` with stubbed body.
+ *   pub fn parse_args(args: &[String]) -> Result<Config> {…}
+ */
+function extractFn(node: Node, source: string): string {
+  return stubFnBody(node, source);
+}
+
+/**
+ * Process a single top-level item node.
+ */
+function extractTopLevel(node: Node, source: string): string | null {
+  switch (node.type) {
+    case "use_declaration":
+      return extractUse(node);
+    case "mod_item":
+      return extractMod(node, source);
+    case "struct_item":
+      return extractStruct(node, source);
+    case "enum_item":
+      return extractEnum(node, source);
+    case "trait_item":
+      return extractTrait(node, source);
+    case "type_item":
+      return extractTypeAlias(node);
+    case "impl_item":
+      return extractImpl(node, source);
+    case "function_item":
+      return extractFn(node, source);
+    case "comment":
+    case "line_comment":
+    case "block_comment":
+      // Skip top-level comments for compression
+      return null;
+    default:
+      // const_item, static_item, macro_definition, attribute_item, etc. — skip
+      return null;
+  }
+}
+
+export const rustExtractor: LanguageExtractor = {
+  extensions: ["rs"],
+  grammarName: "rust",
+
+  extract(tree: Tree, source: string, _options?: HologramOptions): string[] {
+    const lines: string[] = [];
+
+    for (const node of tree.rootNode.namedChildren) {
+      const extracted = extractTopLevel(node, source);
+      if (extracted) lines.push(extracted);
+    }
+
+    return lines;
+  },
+};