autonomous-flow-daemon 1.6.0 → 1.9.0

package/src/core/federation.ts

@@ -0,0 +1,129 @@
+/**
+ * Federation types and scope resolution for Team Antibody Federation (v1.7).
+ *
+ * Namespace: "<scope>/<id>"  (e.g. "myorg/missing-import-guard")
+ * Versioning: monotonic integer + ISO-8601 timestamp (LWW tiebreak)
+ * Conflict policy: Remote-Wins-If-Newer (RWIN) — higher version wins;
+ *   on tie, newer updatedAt wins; on tie, keep local.
+ */
+
+export interface FederatedAntibody {
+  /** Local name portion, e.g. "missing-import-guard" */
+  id: string;
+  /** Namespace slug, e.g. "myorg". Defaults to "local" for non-federated antibodies. */
+  scope: string;
+  /** Globally unique: "<scope>/<id>" */
+  fqid: string;
+  patternType: string;
+  fileTarget: string;
+  patches: { op: string; path: string; value?: string }[];
+  /** Monotonic integer starting at 1; incremented on each content change */
+  version: number;
+  /** ISO 8601 — last mutation time (used as LWW tiebreaker) */
+  updatedAt: string;
+  /** ISO 8601 — original learning time (immutable) */
+  learnedAt: string;
+}
+
+export interface FederatedPayload {
+  /** Payload format version, e.g. "1.7" */
+  version: string;
+  generatedAt: string;
+  ecosystem: string;
+  /** Scope of the publishing team/repo */
+  scope: string;
+  antibodyCount: number;
+  antibodies: FederatedAntibody[];
+}
+
+/**
+ * Resolve the local scope for this workspace:
+ * 1. AFD_SCOPE env var (explicit override)
+ * 2. Git remote origin → org slug
+ * 3. Fallback: "local"
+ */
+export function resolveScope(): string {
+  const envScope = process.env.AFD_SCOPE?.trim();
+  if (envScope) return slugify(envScope);
+
+  try {
+    const proc = Bun.spawnSync(["git", "remote", "get-url", "origin"], { stderr: "ignore" });
+    if (proc.exitCode === 0) {
+      const remoteUrl = new TextDecoder().decode(proc.stdout).trim();
+      return parseGitRemoteScope(remoteUrl) || "local";
+    }
+  } catch {
+    // no git binary or no remote configured
+  }
+
+  return "local";
+}
+
+function parseGitRemoteScope(remoteUrl: string): string {
+  try {
+    if (remoteUrl.startsWith("git@")) {
+      // git@github.com:myorg/repo.git
+      const colonPart = remoteUrl.split(":")[1] ?? "";
+      return slugify(colonPart.split("/")[0]);
+    }
+    const u = new URL(remoteUrl);
+    const firstSegment = u.pathname.replace(/^\//, "").split("/")[0] ?? "";
+    return slugify(firstSegment);
+  } catch {
+    return "";
+  }
+}
+
+function slugify(s: string): string {
+  return s.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+
+/**
+ * RWIN decision: should the incoming (remote) antibody overwrite the local one?
+ * Returns true if remote should win.
+ */
+export function remoteWins(
+  remoteVersion: number,
+  remoteUpdatedAt: string,
+  localVersion: number,
+  localUpdatedAt: string,
+): boolean {
+  if (remoteVersion > localVersion) return true;
+  if (remoteVersion < localVersion) return false;
+  // Same version — use updatedAt as tiebreaker (newer wins)
+  return remoteUpdatedAt > localUpdatedAt;
+}
+
+/**
+ * Conflict arbitration for split-brain scenarios.
+ *
+ * Called when version AND updatedAt are identical but patch content differs
+ * (two daemons learned the same antibody concurrently and produced different patches).
+ *
+ * Strategy: deterministic lexicographic comparison of serialised patch content.
+ * The "larger" content string wins — ensures all peers converge to the same value
+ * without coordination, as long as both sides run the same function.
+ *
+ * Returns true if the remote patch should overwrite the local one.
+ */
+export function arbitrateConflict(remotePatch: string, localPatch: string): boolean {
+  return remotePatch > localPatch;
+}
+
+/**
+ * Full conflict resolution combining RWIN + arbitration.
+ * Use this as the single decision point in /antibodies/learn.
+ */
+export function shouldAcceptRemote(
+  remote: { version: number; updatedAt: string; patch: string },
+  local: { version: number; updatedAt: string; patch: string },
+): { accept: boolean; reason: "newer_version" | "newer_timestamp" | "arbitrated" | "local_wins" } {
+  if (remote.version > local.version) return { accept: true, reason: "newer_version" };
+  if (remote.version < local.version) return { accept: false, reason: "local_wins" };
+  // Same version
+  if (remote.updatedAt > local.updatedAt) return { accept: true, reason: "newer_timestamp" };
+  if (remote.updatedAt < local.updatedAt) return { accept: false, reason: "local_wins" };
+  // True split-brain: identical version + timestamp, different content
+  if (remote.patch === local.patch) return { accept: false, reason: "local_wins" };
+  return { accept: arbitrateConflict(remote.patch, local.patch), reason: "arbitrated" };
+}

package/src/core/hologram/engine.ts

@@ -1,71 +1,71 @@
-import { Parser, Language, type Tree } from "web-tree-sitter";
-import { resolve, dirname } from "path";
-
-/**
- * Singleton Tree-sitter engine with grammar caching.
- * Parser.init() runs once; grammar WASMs are lazy-loaded and cached in-memory.
- */
-export class TreeSitterEngine {
-  private static instance: TreeSitterEngine | null = null;
-  private parser: Parser | null = null;
-  private grammarCache = new Map<string, Language>();
-  private initPromise: Promise<void> | null = null;
-
-  static async getInstance(): Promise<TreeSitterEngine> {
-    if (!this.instance) {
-      this.instance = new TreeSitterEngine();
-      await this.instance.init();
-    }
-    return this.instance;
-  }
-
-  /** Reset singleton — for testing only */
-  static resetForTest(): void {
-    if (this.instance?.parser) {
-      this.instance.parser.delete();
-    }
-    this.instance = null;
-  }
-
-  private async init(): Promise<void> {
-    if (this.initPromise) return this.initPromise;
-    this.initPromise = (async () => {
-      await Parser.init();
-      this.parser = new Parser();
-    })();
-    return this.initPromise;
-  }
-
-  async parse(source: string, grammarName: string): Promise<Tree> {
-    const grammar = await this.loadGrammar(grammarName);
-    this.parser!.setLanguage(grammar);
-    const tree = this.parser!.parse(source);
-    if (!tree) throw new Error(`Failed to parse with grammar: ${grammarName}`);
-    return tree;
-  }
-
-  private async loadGrammar(grammarName: string): Promise<Language> {
-    const cached = this.grammarCache.get(grammarName);
-    if (cached) return cached;
-
-    const wasmPath = resolveGrammarWasm(grammarName);
-    const lang = await Language.load(wasmPath);
-    this.grammarCache.set(grammarName, lang);
-    return lang;
-  }
-}
-
-/** Resolve WASM file path from installed npm grammar package */
-function resolveGrammarWasm(grammarName: string): string {
-  // Grammar packages: tree-sitter-typescript, tree-sitter-python, etc.
-  // WASM file is at package root: node_modules/tree-sitter-{name}/tree-sitter-{name}.wasm
-  const packageName = `tree-sitter-${grammarName}`;
-  try {
-    // require.resolve returns bindings/node/index.js — walk up to package root
-    const pkgJson = require.resolve(`${packageName}/package.json`);
-    return resolve(dirname(pkgJson), `${packageName}.wasm`);
-  } catch {
-    // Fallback: try direct node_modules path
-    return resolve(process.cwd(), "node_modules", packageName, `${packageName}.wasm`);
-  }
-}
+import { Parser, Language, type Tree } from "web-tree-sitter";
+import { resolve, dirname } from "path";
+
+/**
+ * Singleton Tree-sitter engine with grammar caching.
+ * Parser.init() runs once; grammar WASMs are lazy-loaded and cached in-memory.
+ */
+export class TreeSitterEngine {
+  private static instance: TreeSitterEngine | null = null;
+  private parser: Parser | null = null;
+  private grammarCache = new Map<string, Language>();
+  private initPromise: Promise<void> | null = null;
+
+  static async getInstance(): Promise<TreeSitterEngine> {
+    if (!this.instance) {
+      this.instance = new TreeSitterEngine();
+      await this.instance.init();
+    }
+    return this.instance;
+  }
+
+  /** Reset singleton — for testing only */
+  static resetForTest(): void {
+    if (this.instance?.parser) {
+      this.instance.parser.delete();
+    }
+    this.instance = null;
+  }
+
+  private async init(): Promise<void> {
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = (async () => {
+      await Parser.init();
+      this.parser = new Parser();
+    })();
+    return this.initPromise;
+  }
+
+  async parse(source: string, grammarName: string): Promise<Tree> {
+    const grammar = await this.loadGrammar(grammarName);
+    this.parser!.setLanguage(grammar);
+    const tree = this.parser!.parse(source);
+    if (!tree) throw new Error(`Failed to parse with grammar: ${grammarName}`);
+    return tree;
+  }
+
+  private async loadGrammar(grammarName: string): Promise<Language> {
+    const cached = this.grammarCache.get(grammarName);
+    if (cached) return cached;
+
+    const wasmPath = resolveGrammarWasm(grammarName);
+    const lang = await Language.load(wasmPath);
+    this.grammarCache.set(grammarName, lang);
+    return lang;
+  }
+}
+
+/** Resolve WASM file path from installed npm grammar package */
+function resolveGrammarWasm(grammarName: string): string {
+  // Grammar packages: tree-sitter-typescript, tree-sitter-python, etc.
+  // WASM file is at package root: node_modules/tree-sitter-{name}/tree-sitter-{name}.wasm
+  const packageName = `tree-sitter-${grammarName}`;
+  try {
+    // require.resolve returns bindings/node/index.js — walk up to package root
+    const pkgJson = require.resolve(`${packageName}/package.json`);
+    return resolve(dirname(pkgJson), `${packageName}.wasm`);
+  } catch {
+    // Fallback: try direct node_modules path
+    return resolve(process.cwd(), "node_modules", packageName, `${packageName}.wasm`);
+  }
+}

package/src/core/hologram/fallback.ts

@@ -1,11 +1,11 @@
-import type { HologramResult } from "./types";
-
-/** L0 fallback: return full source when tree-sitter cannot parse */
-export function fallbackL0(filePath: string, source: string): HologramResult {
-  return {
-    hologram: source,
-    originalLength: source.length,
-    hologramLength: source.length,
-    savings: 0,
-  };
-}
+import type { HologramResult } from "./types";
+
+/** L0 fallback: return full source when tree-sitter cannot parse */
+export function fallbackL0(filePath: string, source: string): HologramResult {
+  return {
+    hologram: source,
+    originalLength: source.length,
+    hologramLength: source.length,
+    savings: 0,
+  };
+}

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

@@ -0,0 +1,203 @@
+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();
+}
+
+/**
+ * Extract the text of a field, collapsing whitespace.
+ */
+function fieldText(node: Node, field: string): string {
+  return collapse(node.childForFieldName(field)?.text ?? "");
+}
+
+/**
+ * Format a Go function/method signature with stubbed body.
+ * Slices source up to (but not including) the body block.
+ */
+function stubGoBody(node: Node, source: string): string {
+  const body = node.childForFieldName("body");
+  if (!body) return collapse(node.text);
+  return collapse(source.slice(node.startIndex, body.startIndex).trimEnd()) + " {…}";
+}
+
+/**
+ * Extract a `function_declaration`:
+ *   func Name(params) ReturnType {…}
+ */
+function extractFunction(node: Node, source: string): string {
+  return stubGoBody(node, source);
+}
+
+/**
+ * Extract a `method_declaration`:
+ *   func (r ReceiverType) Name(params) ReturnType {…}
+ */
+function extractMethod(node: Node, source: string): string {
+  return stubGoBody(node, source);
+}
+
+/**
+ * Extract a `type_spec` node (the individual name+type inside a type declaration).
+ * Handles struct, interface, and other type aliases/definitions.
+ */
+function extractTypeSpec(node: Node): string {
+  const name = fieldText(node, "name");
+  const typeNode = node.childForFieldName("type");
+  if (!typeNode) return `type ${name}`;
+
+  switch (typeNode.type) {
+    case "struct_type":
+      return extractStructType(name, typeNode);
+    case "interface_type":
+      return extractInterfaceType(name, typeNode);
+    default:
+      // type alias or other: e.g. `type MyInt int`, `type Handler func(...)`
+      return `type ${name} ${collapse(typeNode.text)}`;
+  }
+}
+
+/**
+ * Extract a struct type with all field declarations.
+ *
+ * Example output:
+ *   type DaemonState struct {
+ *     Running bool
+ *     Pid int
+ *   }
+ */
+function extractStructType(name: string, structNode: Node): string {
+  const fieldList = structNode.namedChildren.find(c => c.type === "field_declaration_list");
+  if (!fieldList || fieldList.namedChildCount === 0) {
+    return `type ${name} struct {}`;
+  }
+
+  const fields: string[] = [];
+  for (const field of fieldList.namedChildren) {
+    if (field.type === "field_declaration") {
+      // Collect field names (may be multiple: `X, Y int`)
+      const names: string[] = [];
+      let typeNode: Node | null = null;
+      for (const child of field.namedChildren) {
+        if (child.type === "field_identifier" || child.type === "identifier") {
+          names.push(child.text);
+        } else {
+          typeNode = child;
+        }
+      }
+      const typeStr = typeNode ? collapse(typeNode.text) : "?";
+      if (names.length > 0) {
+        fields.push(`  ${names.join(", ")} ${typeStr}`);
+      } else {
+        // Embedded field: just the type
+        fields.push(`  ${typeStr}`);
+      }
+    } else if (field.type === "comment") {
+      // Skip comments inside struct
+    }
+  }
+
+  return `type ${name} struct {\n${fields.join("\n")}\n}`;
+}
+
+/**
+ * Extract an interface type with method/embedded type signatures.
+ *
+ * Example output:
+ *   type Reader interface {
+ *     Read(p []byte) (n int, err error)
+ *   }
+ */
+function extractInterfaceType(name: string, ifaceNode: Node): string {
+  // In tree-sitter-go, method_elem nodes are direct named children of interface_type
+  // (there is no intermediate interface_body wrapper node)
+  const members: string[] = [];
+  for (const child of ifaceNode.namedChildren) {
+    switch (child.type) {
+      case "method_elem":
+      case "interface_type_name":
+      case "type_constraint":
+      case "type_elem":
+        members.push("  " + collapse(child.text));
+        break;
+      case "comment":
+        break;
+      default:
+        members.push("  " + collapse(child.text));
+    }
+  }
+
+  if (members.length === 0) return `type ${name} interface {}`;
+  return `type ${name} interface {\n${members.join("\n")}\n}`;
+}
+
+/**
+ * Extract a `type_declaration` node.
+ * A single `type_declaration` may contain one or more `type_spec` nodes
+ * (the grouped `type (...)` form).
+ */
+function extractTypeDeclaration(node: Node): string[] {
+  const specs = node.namedChildren.filter(c => c.type === "type_spec");
+  return specs.map(extractTypeSpec);
+}
+
+/**
+ * Extract an `import_declaration`.
+ * Handles both single-spec (`import "fmt"`) and grouped (`import (...)`).
+ */
+function extractImport(node: Node): string {
+  return collapse(node.text);
+}
+
+/**
+ * Extract a `package_clause`.
+ */
+function extractPackage(node: Node): string {
+  return collapse(node.text);
+}
+
+/**
+ * Process a single top-level declaration node.
+ * Returns one or more lines (type declarations may emit multiple lines).
+ */
+function extractTopLevel(node: Node, source: string): string[] {
+  switch (node.type) {
+    case "package_clause":
+      return [extractPackage(node)];
+    case "import_declaration":
+      return [extractImport(node)];
+    case "function_declaration":
+      return [extractFunction(node, source)];
+    case "method_declaration":
+      return [extractMethod(node, source)];
+    case "type_declaration":
+      return extractTypeDeclaration(node);
+    case "comment":
+      // Skip top-level comments (doc comments) for compression
+      return [];
+    default:
+      // Variables, constants, and other top-level declarations: skip bodies,
+      // emit a stub if meaningful.
+      return [];
+  }
+}
+
+export const goExtractor: LanguageExtractor = {
+  extensions: ["go"],
+  grammarName: "go",
+
+  extract(tree: Tree, source: string, _options?: HologramOptions): string[] {
+    const lines: string[] = [];
+
+    for (const node of tree.rootNode.namedChildren) {
+      const extracted = extractTopLevel(node, source);
+      lines.push(...extracted);
+    }
+
+    return lines;
+  },
+};