engramx 0.1.0

package/dist/chunk-44GN6IRQ.js

@@ -0,0 +1,1191 @@
+// src/core.ts
+import { join as join3, resolve as resolve2 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "fs";
+
+// src/graph/store.ts
+import initSqlJs from "sql.js";
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "fs";
+import { dirname } from "path";
+var GraphStore = class _GraphStore {
+  db;
+  dbPath;
+  constructor(db, dbPath) {
+    this.db = db;
+    this.dbPath = dbPath;
+    this.migrate();
+  }
+  static async open(dbPath) {
+    mkdirSync(dirname(dbPath), { recursive: true });
+    const SQL = await initSqlJs();
+    let db;
+    if (existsSync(dbPath)) {
+      const buffer = readFileSync(dbPath);
+      db = new SQL.Database(buffer);
+    } else {
+      db = new SQL.Database();
+    }
+    return new _GraphStore(db, dbPath);
+  }
+  migrate() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS nodes (
+        id TEXT PRIMARY KEY,
+        label TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        source_file TEXT NOT NULL DEFAULT '',
+        source_location TEXT,
+        confidence TEXT NOT NULL DEFAULT 'EXTRACTED',
+        confidence_score REAL NOT NULL DEFAULT 1.0,
+        last_verified INTEGER NOT NULL DEFAULT 0,
+        query_count INTEGER NOT NULL DEFAULT 0,
+        metadata TEXT NOT NULL DEFAULT '{}'
+      );
+
+      CREATE TABLE IF NOT EXISTS edges (
+        source TEXT NOT NULL,
+        target TEXT NOT NULL,
+        relation TEXT NOT NULL,
+        confidence TEXT NOT NULL DEFAULT 'EXTRACTED',
+        confidence_score REAL NOT NULL DEFAULT 1.0,
+        source_file TEXT NOT NULL DEFAULT '',
+        source_location TEXT,
+        last_verified INTEGER NOT NULL DEFAULT 0,
+        metadata TEXT NOT NULL DEFAULT '{}',
+        PRIMARY KEY (source, target, relation)
+      );
+
+      CREATE TABLE IF NOT EXISTS stats (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `);
+    const indexes = [
+      "CREATE INDEX IF NOT EXISTS idx_nodes_kind ON nodes(kind)",
+      "CREATE INDEX IF NOT EXISTS idx_nodes_source_file ON nodes(source_file)",
+      "CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source)",
+      "CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target)",
+      "CREATE INDEX IF NOT EXISTS idx_edges_relation ON edges(relation)"
+    ];
+    for (const sql of indexes) {
+      try {
+        this.db.run(sql);
+      } catch {
+      }
+    }
+  }
+  save() {
+    const data = this.db.export();
+    writeFileSync(this.dbPath, Buffer.from(data));
+  }
+  upsertNode(node) {
+    this.db.run(
+      `INSERT OR REPLACE INTO nodes (id, label, kind, source_file, source_location, confidence, confidence_score, last_verified, query_count, metadata)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        node.id,
+        node.label,
+        node.kind,
+        node.sourceFile,
+        node.sourceLocation,
+        node.confidence,
+        node.confidenceScore,
+        node.lastVerified,
+        node.queryCount,
+        JSON.stringify(node.metadata)
+      ]
+    );
+  }
+  upsertEdge(edge) {
+    this.db.run(
+      `INSERT OR REPLACE INTO edges (source, target, relation, confidence, confidence_score, source_file, source_location, last_verified, metadata)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        edge.source,
+        edge.target,
+        edge.relation,
+        edge.confidence,
+        edge.confidenceScore,
+        edge.sourceFile,
+        edge.sourceLocation,
+        edge.lastVerified,
+        JSON.stringify(edge.metadata)
+      ]
+    );
+  }
+  bulkUpsert(nodes, edges) {
+    this.db.run("BEGIN TRANSACTION");
+    for (const node of nodes) this.upsertNode(node);
+    for (const edge of edges) this.upsertEdge(edge);
+    this.db.run("COMMIT");
+    this.save();
+  }
+  getNode(id) {
+    const stmt = this.db.prepare("SELECT * FROM nodes WHERE id = ?");
+    stmt.bind([id]);
+    if (stmt.step()) {
+      const row = stmt.getAsObject();
+      stmt.free();
+      return this.rowToNode(row);
+    }
+    stmt.free();
+    return null;
+  }
+  searchNodes(query2, limit = 20) {
+    const pattern = `%${query2}%`;
+    const results = [];
+    const stmt = this.db.prepare(
+      "SELECT * FROM nodes WHERE label LIKE ? OR id LIKE ? ORDER BY query_count DESC LIMIT ?"
+    );
+    stmt.bind([pattern, pattern, limit]);
+    while (stmt.step()) {
+      results.push(this.rowToNode(stmt.getAsObject()));
+    }
+    stmt.free();
+    return results;
+  }
+  getNeighbors(nodeId, relationFilter) {
+    const sql = relationFilter ? "SELECT * FROM edges WHERE (source = ? OR target = ?) AND relation = ?" : "SELECT * FROM edges WHERE source = ? OR target = ?";
+    const params = relationFilter ? [nodeId, nodeId, relationFilter] : [nodeId, nodeId];
+    const stmt = this.db.prepare(sql);
+    stmt.bind(params);
+    const results = [];
+    while (stmt.step()) {
+      const edge = this.rowToEdge(stmt.getAsObject());
+      const neighborId = edge.source === nodeId ? edge.target : edge.source;
+      const node = this.getNode(neighborId);
+      if (node) results.push({ node, edge });
+    }
+    stmt.free();
+    return results;
+  }
+  getGodNodes(topN = 10) {
+    const results = [];
+    const stmt = this.db.prepare(
+      `SELECT n.*, COUNT(*) as degree
+       FROM nodes n
+       JOIN edges e ON e.source = n.id OR e.target = n.id
+       WHERE n.kind NOT IN ('file', 'import', 'module')
+       GROUP BY n.id
+       ORDER BY degree DESC
+       LIMIT ?`
+    );
+    stmt.bind([topN]);
+    while (stmt.step()) {
+      const row = stmt.getAsObject();
+      results.push({
+        node: this.rowToNode(row),
+        degree: row.degree
+      });
+    }
+    stmt.free();
+    return results;
+  }
+  getAllNodes() {
+    const results = [];
+    const stmt = this.db.prepare("SELECT * FROM nodes");
+    while (stmt.step()) {
+      results.push(this.rowToNode(stmt.getAsObject()));
+    }
+    stmt.free();
+    return results;
+  }
+  getAllEdges() {
+    const results = [];
+    const stmt = this.db.prepare("SELECT * FROM edges");
+    while (stmt.step()) {
+      results.push(this.rowToEdge(stmt.getAsObject()));
+    }
+    stmt.free();
+    return results;
+  }
+  incrementQueryCount(nodeId) {
+    this.db.run(
+      "UPDATE nodes SET query_count = query_count + 1 WHERE id = ?",
+      [nodeId]
+    );
+  }
+  getStats() {
+    const nodeCount = this.db.exec("SELECT COUNT(*) FROM nodes")[0]?.values[0]?.[0] ?? 0;
+    const edgeCount = this.db.exec("SELECT COUNT(*) FROM edges")[0]?.values[0]?.[0] ?? 0;
+    const confRows = this.db.exec(
+      "SELECT confidence, COUNT(*) as c FROM edges GROUP BY confidence"
+    );
+    const total = edgeCount || 1;
+    const confMap = {};
+    if (confRows[0]) {
+      for (const row of confRows[0].values) {
+        confMap[row[0]] = row[1];
+      }
+    }
+    const savedRow = this.db.exec(
+      "SELECT value FROM stats WHERE key = 'tokens_saved'"
+    );
+    const lastMinedRow = this.db.exec(
+      "SELECT value FROM stats WHERE key = 'last_mined'"
+    );
+    return {
+      nodes: nodeCount,
+      edges: edgeCount,
+      communities: 0,
+      extractedPct: Math.round((confMap["EXTRACTED"] ?? 0) / total * 100),
+      inferredPct: Math.round((confMap["INFERRED"] ?? 0) / total * 100),
+      ambiguousPct: Math.round((confMap["AMBIGUOUS"] ?? 0) / total * 100),
+      lastMined: lastMinedRow[0] ? Number(lastMinedRow[0].values[0][0]) : 0,
+      totalQueryTokensSaved: savedRow[0] ? Number(savedRow[0].values[0][0]) : 0
+    };
+  }
+  getStat(key) {
+    const stmt = this.db.prepare("SELECT value FROM stats WHERE key = ?");
+    stmt.bind([key]);
+    if (stmt.step()) {
+      const val = stmt.getAsObject().value;
+      stmt.free();
+      return val;
+    }
+    stmt.free();
+    return null;
+  }
+  getStatNum(key) {
+    const val = this.getStat(key);
+    return val ? Number(val) : 0;
+  }
+  setStat(key, value) {
+    this.db.run(
+      "INSERT OR REPLACE INTO stats (key, value) VALUES (?, ?)",
+      [key, value]
+    );
+  }
+  clearAll() {
+    this.db.run("DELETE FROM nodes");
+    this.db.run("DELETE FROM edges");
+    this.db.run("DELETE FROM stats");
+  }
+  close() {
+    this.save();
+    this.db.close();
+  }
+  rowToNode(row) {
+    return {
+      id: row.id,
+      label: row.label,
+      kind: row.kind,
+      sourceFile: row.source_file ?? "",
+      sourceLocation: row.source_location ?? null,
+      confidence: row.confidence ?? "EXTRACTED",
+      confidenceScore: row.confidence_score ?? 1,
+      lastVerified: row.last_verified ?? 0,
+      queryCount: row.query_count ?? 0,
+      metadata: JSON.parse(row.metadata || "{}")
+    };
+  }
+  rowToEdge(row) {
+    return {
+      source: row.source,
+      target: row.target,
+      relation: row.relation,
+      confidence: row.confidence ?? "EXTRACTED",
+      confidenceScore: row.confidence_score ?? 1,
+      sourceFile: row.source_file ?? "",
+      sourceLocation: row.source_location ?? null,
+      lastVerified: row.last_verified ?? 0,
+      metadata: JSON.parse(row.metadata || "{}")
+    };
+  }
+};
+
+// src/graph/query.ts
+var CHARS_PER_TOKEN = 4;
+function scoreNodes(store, terms) {
+  const allNodes = store.getAllNodes();
+  const scored = [];
+  for (const node of allNodes) {
+    const label = node.label.toLowerCase();
+    const file = node.sourceFile.toLowerCase();
+    let score = 0;
+    for (const t of terms) {
+      if (label.includes(t)) score += 2;
+      if (file.includes(t)) score += 1;
+    }
+    if (score > 0) scored.push({ score, node });
+  }
+  return scored.sort((a, b) => b.score - a.score);
+}
+function queryGraph(store, question, options = {}) {
+  const { mode = "bfs", depth = 3, tokenBudget = 2e3 } = options;
+  const terms = question.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+  const scored = scoreNodes(store, terms);
+  const startNodes = scored.slice(0, 3).map((s) => s.node);
+  if (startNodes.length === 0) {
+    return { nodes: [], edges: [], text: "No matching nodes found.", estimatedTokens: 5 };
+  }
+  for (const n of startNodes) store.incrementQueryCount(n.id);
+  const visited = new Set(startNodes.map((n) => n.id));
+  const collectedEdges = [];
+  if (mode === "bfs") {
+    let frontier = new Set(startNodes.map((n) => n.id));
+    for (let d = 0; d < depth; d++) {
+      const nextFrontier = /* @__PURE__ */ new Set();
+      for (const nid of frontier) {
+        const neighbors = store.getNeighbors(nid);
+        for (const { node, edge } of neighbors) {
+          if (!visited.has(node.id)) {
+            nextFrontier.add(node.id);
+            collectedEdges.push(edge);
+          }
+        }
+      }
+      for (const id of nextFrontier) visited.add(id);
+      frontier = nextFrontier;
+    }
+  } else {
+    const stack = startNodes.map((n) => ({ id: n.id, d: 0 })).reverse();
+    while (stack.length > 0) {
+      const { id, d } = stack.pop();
+      if (d > depth) continue;
+      const neighbors = store.getNeighbors(id);
+      for (const { node, edge } of neighbors) {
+        if (!visited.has(node.id)) {
+          visited.add(node.id);
+          stack.push({ id: node.id, d: d + 1 });
+          collectedEdges.push(edge);
+        }
+      }
+    }
+  }
+  const resultNodes = [];
+  for (const id of visited) {
+    const node = store.getNode(id);
+    if (node) resultNodes.push(node);
+  }
+  const text = renderSubgraph(resultNodes, collectedEdges, tokenBudget);
+  const estimatedTokens = Math.ceil(text.length / CHARS_PER_TOKEN);
+  return { nodes: resultNodes, edges: collectedEdges, text, estimatedTokens };
+}
+function shortestPath(store, sourceTerm, targetTerm, maxHops = 8) {
+  const sourceTerms = sourceTerm.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+  const targetTerms = targetTerm.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+  const sourceScored = scoreNodes(store, sourceTerms);
+  const targetScored = scoreNodes(store, targetTerms);
+  if (sourceScored.length === 0 || targetScored.length === 0) {
+    return {
+      nodes: [],
+      edges: [],
+      text: `No nodes matching "${sourceTerm}" or "${targetTerm}".`,
+      estimatedTokens: 10
+    };
+  }
+  const srcId = sourceScored[0].node.id;
+  const tgtId = targetScored[0].node.id;
+  const queue = [[srcId]];
+  const seen = /* @__PURE__ */ new Set([srcId]);
+  while (queue.length > 0) {
+    const path2 = queue.shift();
+    const current = path2[path2.length - 1];
+    if (current === tgtId) {
+      const pathNodes = [];
+      const pathEdges = [];
+      for (let i = 0; i < path2.length; i++) {
+        const node = store.getNode(path2[i]);
+        if (node) pathNodes.push(node);
+        if (i < path2.length - 1) {
+          const neighbors2 = store.getNeighbors(path2[i]);
+          const edge = neighbors2.find((n) => n.node.id === path2[i + 1])?.edge;
+          if (edge) pathEdges.push(edge);
+        }
+      }
+      const text = renderPath(pathNodes, pathEdges);
+      return {
+        nodes: pathNodes,
+        edges: pathEdges,
+        text,
+        estimatedTokens: Math.ceil(text.length / CHARS_PER_TOKEN)
+      };
+    }
+    if (path2.length > maxHops) continue;
+    const neighbors = store.getNeighbors(current);
+    for (const { node } of neighbors) {
+      if (!seen.has(node.id)) {
+        seen.add(node.id);
+        queue.push([...path2, node.id]);
+      }
+    }
+  }
+  return {
+    nodes: [],
+    edges: [],
+    text: `No path found between "${sourceTerm}" and "${targetTerm}" within ${maxHops} hops.`,
+    estimatedTokens: 15
+  };
+}
+function renderSubgraph(nodes, edges, tokenBudget) {
+  const charBudget = tokenBudget * CHARS_PER_TOKEN;
+  const lines = [];
+  const degreeMap = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    degreeMap.set(e.source, (degreeMap.get(e.source) ?? 0) + 1);
+    degreeMap.set(e.target, (degreeMap.get(e.target) ?? 0) + 1);
+  }
+  const sorted = [...nodes].sort(
+    (a, b) => (degreeMap.get(b.id) ?? 0) - (degreeMap.get(a.id) ?? 0)
+  );
+  for (const n of sorted) {
+    lines.push(
+      `NODE ${n.label} [${n.kind}] src=${n.sourceFile} ${n.sourceLocation ?? ""}`
+    );
+  }
+  for (const e of edges) {
+    const srcNode = nodes.find((n) => n.id === e.source);
+    const tgtNode = nodes.find((n) => n.id === e.target);
+    if (srcNode && tgtNode) {
+      const conf = e.confidence === "EXTRACTED" ? "" : ` [${e.confidence} ${e.confidenceScore}]`;
+      lines.push(
+        `EDGE ${srcNode.label} --${e.relation}--> ${tgtNode.label}${conf}`
+      );
+    }
+  }
+  let output = lines.join("\n");
+  if (output.length > charBudget) {
+    output = output.slice(0, charBudget) + `
+... (truncated to ~${tokenBudget} token budget)`;
+  }
+  return output;
+}
+function renderPath(nodes, edges) {
+  if (nodes.length === 0) return "Empty path.";
+  const segments = [nodes[0].label];
+  for (let i = 0; i < edges.length; i++) {
+    const conf = edges[i].confidence === "EXTRACTED" ? "" : ` [${edges[i].confidence}]`;
+    segments.push(`--${edges[i].relation}${conf}--> ${nodes[i + 1]?.label ?? "?"}`);
+  }
+  return `Path (${edges.length} hops): ${segments.join(" ")}`;
+}
+
+// src/miners/ast-miner.ts
+import { readFileSync as readFileSync2, readdirSync, realpathSync } from "fs";
+import { basename, extname, join, relative } from "path";
+var LANG_CONFIGS = {
+  typescript: {
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
+    classTypes: ["class_declaration"],
+    functionTypes: [
+      "function_declaration",
+      "method_definition",
+      "arrow_function"
+    ],
+    importTypes: ["import_statement"],
+    callTypes: ["call_expression"],
+    nameField: "name",
+    bodyField: "body"
+  },
+  python: {
+    extensions: [".py"],
+    classTypes: ["class_definition"],
+    functionTypes: ["function_definition"],
+    importTypes: ["import_statement", "import_from_statement"],
+    callTypes: ["call"],
+    nameField: "name",
+    bodyField: "body"
+  },
+  go: {
+    extensions: [".go"],
+    classTypes: ["type_declaration"],
+    functionTypes: ["function_declaration", "method_declaration"],
+    importTypes: ["import_declaration"],
+    callTypes: ["call_expression"],
+    nameField: "name",
+    bodyField: "body"
+  },
+  rust: {
+    extensions: [".rs"],
+    classTypes: ["struct_item", "enum_item", "trait_item"],
+    functionTypes: ["function_item"],
+    importTypes: ["use_declaration"],
+    callTypes: ["call_expression"],
+    nameField: "name",
+    bodyField: "body"
+  },
+  java: {
+    extensions: [".java"],
+    classTypes: ["class_declaration", "interface_declaration"],
+    functionTypes: ["method_declaration", "constructor_declaration"],
+    importTypes: ["import_declaration"],
+    callTypes: ["method_invocation"],
+    nameField: "name",
+    bodyField: "body"
+  },
+  ruby: {
+    extensions: [".rb"],
+    classTypes: ["class", "module"],
+    functionTypes: ["method"],
+    importTypes: ["call"],
+    // require/include are calls in Ruby
+    callTypes: ["call"],
+    nameField: "name",
+    bodyField: "body"
+  },
+  php: {
+    extensions: [".php"],
+    classTypes: ["class_declaration", "interface_declaration"],
+    functionTypes: ["function_definition", "method_declaration"],
+    importTypes: ["namespace_use_declaration"],
+    callTypes: ["function_call_expression"],
+    nameField: "name",
+    bodyField: "body"
+  }
+};
+var EXT_TO_LANG = {};
+for (const [lang, config] of Object.entries(LANG_CONFIGS)) {
+  for (const ext of config.extensions) {
+    EXT_TO_LANG[ext] = lang;
+  }
+}
+var SUPPORTED_EXTENSIONS = new Set(Object.keys(EXT_TO_LANG));
+function makeId(...parts) {
+  return parts.filter(Boolean).join("_").replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_|_$/g, "").toLowerCase().slice(0, 120);
+}
+function extractFile(filePath, rootDir) {
+  const ext = extname(filePath).toLowerCase();
+  const lang = EXT_TO_LANG[ext];
+  if (!lang) return { nodes: [], edges: [] };
+  const content = readFileSync2(filePath, "utf-8");
+  const lines = content.split("\n");
+  const relPath = relative(rootDir, filePath);
+  const stem = basename(filePath, ext);
+  const now = Date.now();
+  const nodes = [];
+  const edges = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  const addNode = (id, label, kind, line) => {
+    if (seenIds.has(id)) return;
+    seenIds.add(id);
+    nodes.push({
+      id,
+      label,
+      kind,
+      sourceFile: relPath,
+      sourceLocation: line ? `L${line}` : null,
+      confidence: "EXTRACTED",
+      confidenceScore: 1,
+      lastVerified: now,
+      queryCount: 0,
+      metadata: { lang }
+    });
+  };
+  const addEdge = (source, target, relation, line) => {
+    edges.push({
+      source,
+      target,
+      relation,
+      confidence: "EXTRACTED",
+      confidenceScore: 1,
+      sourceFile: relPath,
+      sourceLocation: line ? `L${line}` : null,
+      lastVerified: now,
+      metadata: {}
+    });
+  };
+  const fileId = makeId(stem);
+  addNode(fileId, basename(filePath), "file", 1);
+  if (lang === "typescript" || lang === "python" || lang === "java") {
+    extractWithPatterns(
+      content,
+      lines,
+      lang,
+      fileId,
+      stem,
+      relPath,
+      addNode,
+      addEdge
+    );
+  } else if (lang === "go") {
+    extractGo(content, lines, fileId, stem, relPath, addNode, addEdge);
+  } else if (lang === "rust") {
+    extractRust(content, lines, fileId, stem, relPath, addNode, addEdge);
+  } else {
+    extractWithPatterns(
+      content,
+      lines,
+      lang,
+      fileId,
+      stem,
+      relPath,
+      addNode,
+      addEdge
+    );
+  }
+  return { nodes, edges };
+}
+function extractWithPatterns(content, lines, lang, fileId, stem, relPath, addNode, addEdge) {
+  const patterns = getPatterns(lang);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    for (const pat of patterns.classes) {
+      const match = line.match(pat);
+      if (match?.[1]) {
+        const name = match[1];
+        const id = makeId(stem, name);
+        addNode(id, name, "class", lineNum);
+        addEdge(fileId, id, "contains", lineNum);
+      }
+    }
+    for (const pat of patterns.functions) {
+      const match = line.match(pat);
+      if (match?.[1]) {
+        const name = match[1];
+        const id = makeId(stem, name);
+        addNode(id, `${name}()`, "function", lineNum);
+        addEdge(fileId, id, "contains", lineNum);
+      }
+    }
+    for (const pat of patterns.imports) {
+      const match = line.match(pat);
+      if (match?.[1]) {
+        const module = match[1].replace(/['"]/g, "").split("/").pop().replace(/\.\w+$/, "");
+        if (module && !module.startsWith(".")) {
+          const id = makeId(module);
+          addEdge(fileId, id, "imports", lineNum);
+        }
+      }
+    }
+    for (const pat of patterns.exports) {
+      const match = line.match(pat);
+      if (match?.[1]) {
+        const name = match[1];
+        const id = makeId(stem, name);
+        addEdge(fileId, id, "exports", lineNum);
+      }
+    }
+  }
+}
+function extractGo(content, lines, fileId, stem, relPath, addNode, addEdge) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    const funcMatch = line.match(
+      /^func\s+(?:\([\w\s*]+\)\s+)?(\w+)\s*\(/
+    );
+    if (funcMatch?.[1]) {
+      const name = funcMatch[1];
+      const id = makeId(stem, name);
+      addNode(id, `${name}()`, "function", lineNum);
+      addEdge(fileId, id, "contains", lineNum);
+    }
+    const typeMatch = line.match(/^type\s+(\w+)\s+(struct|interface)\s*\{/);
+    if (typeMatch?.[1]) {
+      const name = typeMatch[1];
+      const kind = typeMatch[2] === "interface" ? "interface" : "class";
+      const id = makeId(stem, name);
+      addNode(id, name, kind, lineNum);
+      addEdge(fileId, id, "contains", lineNum);
+    }
+    const importMatch = line.match(/^\s*"([^"]+)"/);
+    if (importMatch?.[1] && i > 0 && content.includes("import")) {
+      const module = importMatch[1].split("/").pop();
+      addEdge(fileId, makeId(module), "imports", lineNum);
+    }
+  }
+}
+function extractRust(content, lines, fileId, stem, relPath, addNode, addEdge) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    const fnMatch = line.match(
+      /^\s*(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/
+    );
+    if (fnMatch?.[1]) {
+      const name = fnMatch[1];
+      const id = makeId(stem, name);
+      addNode(id, `${name}()`, "function", lineNum);
+      addEdge(fileId, id, "contains", lineNum);
+    }
+    const structMatch = line.match(
+      /^\s*(?:pub\s+)?(?:struct|enum|trait)\s+(\w+)/
+    );
+    if (structMatch?.[1]) {
+      const name = structMatch[1];
+      const id = makeId(stem, name);
+      addNode(id, name, "class", lineNum);
+      addEdge(fileId, id, "contains", lineNum);
+    }
+    const useMatch = line.match(/^\s*use\s+([\w:]+)/);
+    if (useMatch?.[1]) {
+      const parts = useMatch[1].split("::");
+      const module = parts[parts.length - 1];
+      addEdge(fileId, makeId(module), "imports", lineNum);
+    }
+  }
+}
+function getPatterns(lang) {
+  switch (lang) {
+    case "typescript":
+      return {
+        classes: [/^\s*(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/],
+        functions: [
+          /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/,
+          /^\s*(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(/,
+          /^\s*(?:public|private|protected)\s+(?:async\s+)?(\w+)\s*\(/
+        ],
+        imports: [
+          /^\s*import\s+.*from\s+['"]([^'"]+)['"]/,
+          /^\s*import\s+['"]([^'"]+)['"]/,
+          /require\(\s*['"]([^'"]+)['"]\s*\)/
+        ],
+        exports: [
+          /^\s*export\s+(?:default\s+)?(?:class|function|const|let|var|interface|type|enum)\s+(\w+)/
+        ]
+      };
+    case "python":
+      return {
+        classes: [/^\s*class\s+(\w+)/],
+        functions: [/^\s*(?:async\s+)?def\s+(\w+)/],
+        imports: [
+          /^\s*import\s+(\w[\w.]*)/,
+          /^\s*from\s+(\w[\w.]*)\s+import/
+        ],
+        exports: []
+        // Python doesn't have explicit exports
+      };
+    case "java":
+      return {
+        classes: [
+          /^\s*(?:public\s+)?(?:abstract\s+)?(?:class|interface|enum)\s+(\w+)/
+        ],
+        functions: [
+          /^\s*(?:public|private|protected)\s+(?:static\s+)?(?:\w+\s+)?(\w+)\s*\(/
+        ],
+        imports: [/^\s*import\s+[\w.]+\.(\w+)\s*;/],
+        exports: []
+      };
+    case "ruby":
+      return {
+        classes: [/^\s*(?:class|module)\s+(\w+)/],
+        functions: [/^\s*def\s+(\w+)/],
+        imports: [/^\s*require\s+['"]([^'"]+)['"]/],
+        exports: []
+      };
+    case "php":
+      return {
+        classes: [
+          /^\s*(?:abstract\s+)?(?:class|interface|trait)\s+(\w+)/
+        ],
+        functions: [/^\s*(?:public|private|protected)?\s*function\s+(\w+)/],
+        imports: [/^\s*use\s+([\w\\]+)/],
+        exports: []
+      };
+    default:
+      return { classes: [], functions: [], imports: [], exports: [] };
+  }
+}
+function extractDirectory(dirPath, rootDir) {
+  const root = rootDir ?? dirPath;
+  const allNodes = [];
+  const allEdges = [];
+  let fileCount = 0;
+  let totalLines = 0;
+  const visitedDirs = /* @__PURE__ */ new Set();
+  function walk(dir) {
+    let realDir;
+    try {
+      realDir = realpathSync(dir);
+    } catch {
+      return;
+    }
+    if (visitedDirs.has(realDir)) return;
+    visitedDirs.add(realDir);
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "__pycache__" || entry.name === "vendor" || entry.name === ".engram") {
+          continue;
+        }
+        walk(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const ext = extname(entry.name).toLowerCase();
+      if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
+      const { nodes, edges } = extractFile(fullPath, root);
+      allNodes.push(...nodes);
+      allEdges.push(...edges);
+      fileCount++;
+      try {
+        const content = readFileSync2(fullPath, "utf-8");
+        totalLines += content.split("\n").length;
+      } catch {
+      }
+    }
+  }
+  walk(dirPath);
+  return { nodes: allNodes, edges: allEdges, fileCount, totalLines };
+}
+
+// src/miners/git-miner.ts
+import { execFileSync } from "child_process";
+import { resolve } from "path";
+function runGit(args, cwd) {
+  try {
+    return execFileSync("git", args, {
+      cwd,
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: 15e3
+    }).trim();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("TIMEOUT") || msg.includes("timed out")) {
+      console.error(`[engram] git command timed out: git ${args.join(" ")}`);
+    }
+    return "";
+  }
+}
+function makeId2(...parts) {
+  return parts.filter(Boolean).join("_").replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_|_$/g, "").toLowerCase();
+}
+function mineGitHistory(projectRoot, maxCommits = 200) {
+  const root = resolve(projectRoot);
+  const now = Date.now();
+  const nodes = [];
+  const edges = [];
+  const isGit = runGit(["rev-parse", "--git-dir"], root);
+  if (!isGit) return { nodes, edges };
+  const log = runGit(
+    [
+      "log",
+      `--max-count=${maxCommits}`,
+      "--pretty=format:%H|%an|%s",
+      "--name-only"
+    ],
+    root
+  );
+  if (!log) return { nodes, edges };
+  const coChangeMap = /* @__PURE__ */ new Map();
+  const fileChangeCount = /* @__PURE__ */ new Map();
+  const authorMap = /* @__PURE__ */ new Map();
+  const commitBlocks = log.split("\n\n").filter(Boolean);
+  for (const block of commitBlocks) {
+    const lines = block.split("\n").filter(Boolean);
+    if (lines.length === 0) continue;
+    const [header, ...fileLines] = lines;
+    const parts = header.split("|");
+    if (parts.length < 3) continue;
+    const author = parts[1];
+    const files = fileLines.filter(
+      (f) => f.length > 0 && !f.includes("|") && !f.startsWith(" ") && f.includes(".")
+    );
+    for (const file of files) {
+      fileChangeCount.set(file, (fileChangeCount.get(file) ?? 0) + 1);
+      if (!authorMap.has(file)) authorMap.set(file, /* @__PURE__ */ new Set());
+      authorMap.get(file).add(author);
+    }
+    for (let i = 0; i < files.length; i++) {
+      for (let j = i + 1; j < files.length; j++) {
+        const key = [files[i], files[j]].sort().join("|");
+        const [a, b] = key.split("|");
+        if (!coChangeMap.has(a)) coChangeMap.set(a, /* @__PURE__ */ new Map());
+        coChangeMap.get(a).set(b, (coChangeMap.get(a).get(b) ?? 0) + 1);
+      }
+    }
+  }
+  for (const [fileA, coFiles] of coChangeMap) {
+    for (const [fileB, count] of coFiles) {
+      if (count >= 3) {
+        const confidence = Math.min(0.95, 0.5 + count * 0.05);
+        const stemA = makeId2(fileA.split("/").pop()?.replace(/\.\w+$/, "") ?? fileA);
+        const stemB = makeId2(fileB.split("/").pop()?.replace(/\.\w+$/, "") ?? fileB);
+        edges.push({
+          source: stemA,
+          target: stemB,
+          relation: "depends_on",
+          confidence: "INFERRED",
+          confidenceScore: confidence,
+          sourceFile: fileA,
+          sourceLocation: null,
+          lastVerified: now,
+          metadata: { coChangeCount: count, miner: "git" }
+        });
+      }
+    }
+  }
+  const hotFiles = [...fileChangeCount.entries()].filter(([, count]) => count >= 5).sort((a, b) => b[1] - a[1]).slice(0, 20);
+  for (const [file, changeCount] of hotFiles) {
+    const stem = makeId2(file.split("/").pop()?.replace(/\.\w+$/, "") ?? file);
+    nodes.push({
+      id: `hotfile_${stem}`,
+      label: `\u{1F525} ${file} (${changeCount} changes)`,
+      kind: "pattern",
+      sourceFile: file,
+      sourceLocation: null,
+      confidence: "EXTRACTED",
+      confidenceScore: 1,
+      lastVerified: now,
+      queryCount: 0,
+      metadata: { changeCount, miner: "git", type: "hot_file" }
+    });
+  }
+  return { nodes, edges };
+}
+
+// src/miners/session-miner.ts
+import { readFileSync as readFileSync3, existsSync as existsSync3, readdirSync as readdirSync2 } from "fs";
+import { join as join2, basename as basename2 } from "path";
+var DECISION_PATTERNS = [
+  /(?:decided|chose|picked|selected|went with|using|switched to)\s+(\w[\w\s-]{2,30})\s+(?:over|instead of|rather than|because|for|since)/gi,
+  /(?:don't|do not|never|avoid|stop)\s+(?:use|using)\s+(\w[\w\s-]{2,30})/gi,
+  /(?:always|must|should)\s+(?:use|prefer)\s+(\w[\w\s-]{2,30})/gi
+];
+var MISTAKE_PATTERNS = [
+  /(?:bug|issue|problem|error|broke|breaking|failed|crash):\s*(.{10,80})/gi,
+  /(?:fix|fixed|resolved|solved):\s*(.{10,80})/gi,
+  /(?:caused by|root cause|the issue was)\s+(.{10,80})/gi
+];
+var PATTERN_PATTERNS = [
+  /(?:pattern|convention|approach|technique|strategy):\s*(.{10,80})/gi,
+  /(?:we use|our approach|the way we|standard is)\s+(.{10,60})/gi
+];
+function makeId3(...parts) {
+  return parts.filter(Boolean).join("_").replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_|_$/g, "").toLowerCase().slice(0, 60);
+}
+function mineText(text, sourceFile) {
+  const now = Date.now();
+  const nodes = [];
+  const seenLabels = /* @__PURE__ */ new Set();
+  const addIfNew = (label, kind, confidence) => {
+    const normalized = label.trim().toLowerCase();
+    if (seenLabels.has(normalized) || normalized.length < 5) return;
+    seenLabels.add(normalized);
+    nodes.push({
+      id: makeId3("session", kind, normalized),
+      label: label.trim(),
+      kind,
+      sourceFile,
+      sourceLocation: null,
+      confidence: "INFERRED",
+      confidenceScore: confidence,
+      lastVerified: now,
+      queryCount: 0,
+      metadata: { miner: "session" }
+    });
+  };
+  for (const pattern of DECISION_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      if (match[1]) addIfNew(match[1], "decision", 0.7);
+    }
+  }
+  for (const pattern of MISTAKE_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      if (match[1]) addIfNew(match[1], "mistake", 0.6);
+    }
+  }
+  for (const pattern of PATTERN_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      if (match[1]) addIfNew(match[1], "pattern", 0.65);
+    }
+  }
+  return { nodes, edges: [] };
+}
+function mineSessionHistory(projectRoot) {
+  const allNodes = [];
+  const allEdges = [];
+  const sources = [
+    join2(projectRoot, "CLAUDE.md"),
+    join2(projectRoot, ".claude", "CLAUDE.md"),
+    join2(projectRoot, "AGENTS.md"),
+    join2(projectRoot, ".cursorrules"),
+    join2(projectRoot, ".cursor", "rules")
+  ];
+  for (const source of sources) {
+    if (existsSync3(source)) {
+      try {
+        const { nodes, edges } = mineText(readFileSync3(source, "utf-8"), basename2(source));
+        allNodes.push(...nodes);
+        allEdges.push(...edges);
+      } catch {
+      }
+    }
+  }
+  const sessionsDir = join2(projectRoot, ".engram", "sessions");
+  if (existsSync3(sessionsDir)) {
+    try {
+      for (const file of readdirSync2(sessionsDir).filter((f) => f.endsWith(".md"))) {
+        const { nodes, edges } = mineText(
+          readFileSync3(join2(sessionsDir, file), "utf-8"),
+          `sessions/${file}`
+        );
+        allNodes.push(...nodes);
+        allEdges.push(...edges);
+      }
+    } catch {
+    }
+  }
+  return { nodes: allNodes, edges: allEdges };
+}
+function learnFromSession(text, sourceLabel = "session") {
+  return mineText(text, sourceLabel);
+}
+
+// src/core.ts
+var ENGRAM_DIR = ".engram";
+var DB_FILE = "graph.db";
+function getDbPath(projectRoot) {
+  return join3(projectRoot, ENGRAM_DIR, DB_FILE);
+}
+async function getStore(projectRoot) {
+  return GraphStore.open(getDbPath(projectRoot));
+}
+async function init(projectRoot) {
+  const root = resolve2(projectRoot);
+  const start = Date.now();
+  mkdirSync2(join3(root, ENGRAM_DIR), { recursive: true });
+  const { nodes, edges, fileCount, totalLines } = extractDirectory(root);
+  const gitResult = mineGitHistory(root);
+  const sessionResult = mineSessionHistory(root);
+  const allNodes = [...nodes, ...gitResult.nodes, ...sessionResult.nodes];
+  const allEdges = [...edges, ...gitResult.edges, ...sessionResult.edges];
+  const store = await getStore(root);
+  try {
+    store.clearAll();
+    store.bulkUpsert(allNodes, allEdges);
+    store.setStat("last_mined", String(Date.now()));
+    store.setStat("project_root", root);
+  } finally {
+    store.close();
+  }
+  return { nodes: allNodes.length, edges: allEdges.length, fileCount, totalLines, timeMs: Date.now() - start };
+}
+async function query(projectRoot, question, options = {}) {
+  const store = await getStore(projectRoot);
+  try {
+    const result = queryGraph(store, question, options);
+    return { text: result.text, estimatedTokens: result.estimatedTokens, nodesFound: result.nodes.length };
+  } finally {
+    store.close();
+  }
+}
+async function path(projectRoot, source, target) {
+  const store = await getStore(projectRoot);
+  try {
+    const result = shortestPath(store, source, target);
+    return { text: result.text, hops: result.edges.length };
+  } finally {
+    store.close();
+  }
+}
+async function godNodes(projectRoot, topN = 10) {
+  const store = await getStore(projectRoot);
+  try {
+    return store.getGodNodes(topN).map((g) => ({
+      label: g.node.label,
+      kind: g.node.kind,
+      degree: g.degree,
+      sourceFile: g.node.sourceFile
+    }));
+  } finally {
+    store.close();
+  }
+}
+async function stats(projectRoot) {
+  const store = await getStore(projectRoot);
+  try {
+    return store.getStats();
+  } finally {
+    store.close();
+  }
+}
+async function learn(projectRoot, text, sourceLabel = "manual") {
+  const { nodes, edges } = learnFromSession(text, sourceLabel);
+  if (nodes.length === 0 && edges.length === 0) return { nodesAdded: 0 };
+  const store = await getStore(projectRoot);
+  try {
+    store.bulkUpsert(nodes, edges);
+  } finally {
+    store.close();
+  }
+  return { nodesAdded: nodes.length };
+}
+async function benchmark(projectRoot, questions) {
+  const root = resolve2(projectRoot);
+  const store = await getStore(root);
+  try {
+    const allNodes = store.getAllNodes();
+    let fullCorpusChars = 0;
+    const seenFiles = /* @__PURE__ */ new Set();
+    for (const node of allNodes) {
+      if (node.sourceFile && !seenFiles.has(node.sourceFile)) {
+        seenFiles.add(node.sourceFile);
+        try {
+          const fullPath = join3(root, node.sourceFile);
+          if (existsSync4(fullPath)) fullCorpusChars += readFileSync4(fullPath, "utf-8").length;
+        } catch {
+        }
+      }
+    }
+    const naiveFullCorpus = Math.ceil(fullCorpusChars / 4);
+    const qs = questions ?? [
+      "how does authentication work",
+      "what is the main entry point",
+      "how are errors handled",
+      "what connects the data layer to the api",
+      "what are the core abstractions"
+    ];
+    const perQuestion = [];
+    for (const q of qs) {
+      const result = queryGraph(store, q, { tokenBudget: 2e3 });
+      if (result.estimatedTokens > 0) {
+        const matchedFiles = new Set(result.nodes.map((n) => n.sourceFile).filter(Boolean));
+        let relevantChars = 0;
+        for (const f of matchedFiles) {
+          try {
+            const fullPath = join3(root, f);
+            if (existsSync4(fullPath)) relevantChars += readFileSync4(fullPath, "utf-8").length;
+          } catch {
+          }
+        }
+        const naiveRelevant = Math.ceil(relevantChars / 4) || 1;
+        perQuestion.push({
+          question: q,
+          tokens: result.estimatedTokens,
+          reductionFull: naiveFullCorpus > 0 ? Math.round(naiveFullCorpus / result.estimatedTokens * 10) / 10 : 0,
+          reductionRelevant: Math.round(naiveRelevant / result.estimatedTokens * 10) / 10
+        });
+      }
+    }
+    const avgQueryTokens = perQuestion.length > 0 ? Math.round(perQuestion.reduce((sum, p) => sum + p.tokens, 0) / perQuestion.length) : 0;
+    const avgRelevantChars = perQuestion.length > 0 ? perQuestion.reduce((sum, p) => sum + p.reductionRelevant, 0) / perQuestion.length : 0;
+    return {
+      naiveFullCorpus,
+      naiveRelevantFiles: avgQueryTokens > 0 ? Math.round(avgQueryTokens * avgRelevantChars) : 0,
+      avgQueryTokens,
+      reductionVsFull: avgQueryTokens > 0 ? Math.round(naiveFullCorpus / avgQueryTokens * 10) / 10 : 0,
+      reductionVsRelevant: Math.round(avgRelevantChars * 10) / 10,
+      perQuestion
+    };
+  } finally {
+    store.close();
+  }
+}
+
+export {
+  GraphStore,
+  queryGraph,
+  shortestPath,
+  SUPPORTED_EXTENSIONS,
+  extractFile,
+  extractDirectory,
+  getDbPath,
+  getStore,
+  init,
+  query,
+  path,
+  godNodes,
+  stats,
+  learn,
+  benchmark
+};