engramx 1.0.1 → 2.0.1

package/dist/{chunk-6SFMVYUN.js → chunk-SJT7VS2G.js}

@@ -1,10 +1,10 @@
 import {
   runMigrations
-} from "./chunk-SBHGK5WA.js";
+} from "./chunk-PEH54LYC.js";
 
 // src/core.ts
 import { join as join4, resolve as resolve2, relative as relative2 } from "path";
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2, unlinkSync, statSync as statSync2 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2, unlinkSync, statSync as statSync3 } from "fs";
 import { homedir } from "os";
 
 // src/graph/store.ts
@@ -326,6 +326,15 @@ var GraphStore = class _GraphStore {
       [key, value]
     );
   }
+  /** Remove all nodes and edges originating from a specific source file. */
+  removeNodesForFile(sourceFile) {
+    this.db.run(
+      `DELETE FROM edges WHERE source IN (SELECT id FROM nodes WHERE source_file = ?)
+       OR target IN (SELECT id FROM nodes WHERE source_file = ?)`,
+      [sourceFile, sourceFile]
+    );
+    this.db.run("DELETE FROM nodes WHERE source_file = ?", [sourceFile]);
+  }
   clearAll() {
     this.db.run("DELETE FROM nodes");
     this.db.run("DELETE FROM edges");
@@ -458,6 +467,22 @@ var GraphStore = class _GraphStore {
       ttl: row.ttl ?? 3600
     };
   }
+  // ─── Low-level DB access (for cache module) ──────────────────
+  /** Run raw SQL (DDL, DML). For cache table creation and updates. */
+  runSql(sql, params) {
+    if (params && params.length > 0) {
+      const stmt = this.db.prepare(sql);
+      stmt.bind(params);
+      stmt.step();
+      stmt.free();
+    } else {
+      this.db.run(sql);
+    }
+  }
+  /** Prepare a statement for row-by-row iteration. Caller must free(). */
+  prepare(sql) {
+    return this.db.prepare(sql);
+  }
   // ─── Lifecycle ────────────────────────────────────────────────
   close() {
     this.save();
@@ -865,7 +890,7 @@ function toPosixPath(p) {
 }
 
 // src/miners/ast-miner.ts
-import { readFileSync as readFileSync2, readdirSync, realpathSync } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync, realpathSync, statSync } from "fs";
 import { basename, extname, join, relative } from "path";
 var LANG_CONFIGS = {
   typescript: {
@@ -950,7 +975,7 @@ function makeId(...parts) {
 function extractFile(filePath, rootDir) {
   const ext = extname(filePath).toLowerCase();
   const lang = EXT_TO_LANG[ext];
-  if (!lang) return { nodes: [], edges: [] };
+  if (!lang) return { nodes: [], edges: [], lineCount: 0 };
   const content = readFileSync2(filePath, "utf-8");
   const lines = content.split("\n");
   const relPath = toPosixPath(relative(rootDir, filePath));
@@ -1019,7 +1044,7 @@ function extractFile(filePath, rootDir) {
       addEdge
     );
   }
-  return { nodes, edges };
+  return { nodes, edges, lineCount: lines.length };
 }
 function extractWithPatterns(content, lines, lang, fileId, stem, relPath, addNode, addEdge) {
   const patterns = getPatterns(lang);
@@ -1205,13 +1230,57 @@ function getPatterns(lang) {
       return { classes: [], functions: [], imports: [], exports: [] };
   }
 }
-function extractDirectory(dirPath, rootDir) {
+var DEFAULT_SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "__pycache__",
+  "vendor",
+  ".engram",
+  ".git",
+  ".next",
+  ".nuxt",
+  ".output",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "target",
+  // Rust
+  "venv",
+  ".venv",
+  "env"
+]);
+function loadIgnorePatterns(rootDir) {
+  const ignorePath = join(rootDir, ".engramignore");
+  const patterns = /* @__PURE__ */ new Set();
+  if (!existsSync2(ignorePath)) return patterns;
+  try {
+    const content = readFileSync2(ignorePath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      patterns.add(trimmed.replace(/\/+$/, ""));
+    }
+  } catch {
+  }
+  return patterns;
+}
+function extractDirectory(dirPath, rootDir, options = {}) {
   const root = rootDir ?? dirPath;
   const allNodes = [];
   const allEdges = [];
   let fileCount = 0;
   let totalLines = 0;
+  let skippedCount = 0;
+  const mtimes = /* @__PURE__ */ new Map();
   const visitedDirs = /* @__PURE__ */ new Set();
+  const ignorePatterns = loadIgnorePatterns(root);
+  function shouldSkipDir(name) {
+    if (name.startsWith(".")) return true;
+    if (DEFAULT_SKIP_DIRS.has(name)) return true;
+    if (ignorePatterns.has(name)) return true;
+    return false;
+  }
   function walk(dir) {
     let realDir;
     try {
@@ -1225,28 +1294,35 @@ function extractDirectory(dirPath, rootDir) {
     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;
-        }
+        if (shouldSkipDir(entry.name)) 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);
+      const relPath = toPosixPath(relative(root, fullPath));
+      if (ignorePatterns.has(entry.name) || ignorePatterns.has(relPath)) continue;
+      const fileMtime = statSync(fullPath).mtimeMs;
+      mtimes.set(relPath, fileMtime);
+      if (options.previousMtimes) {
+        const prevMtime = options.previousMtimes.get(relPath);
+        if (prevMtime !== void 0 && prevMtime === fileMtime) {
+          skippedCount++;
+          options.onProgress?.(fileCount, skippedCount, relPath);
+          continue;
+        }
+      }
+      const { nodes, edges, lineCount } = extractFile(fullPath, root);
       allNodes.push(...nodes);
       allEdges.push(...edges);
       fileCount++;
-      try {
-        const content = readFileSync2(fullPath, "utf-8");
-        totalLines += content.split("\n").length;
-      } catch {
-      }
+      totalLines += lineCount;
+      options.onProgress?.(fileCount, skippedCount, relPath);
     }
   }
   walk(dirPath);
-  return { nodes: allNodes, edges: allEdges, fileCount, totalLines };
+  return { nodes: allNodes, edges: allEdges, fileCount, totalLines, mtimes, skippedCount };
 }
 
 // src/miners/git-miner.ts
@@ -1465,7 +1541,7 @@ import {
   readFileSync as readFileSync4,
   readdirSync as readdirSync3,
   realpathSync as realpathSync2,
-  statSync
+  statSync as statSync2
 } from "fs";
 import { basename as basename3, dirname as dirname2, join as join3 } from "path";
 function makeId4(...parts) {
@@ -1600,7 +1676,7 @@ function discoverSkillFiles(skillsDir) {
     if (entry.isSymbolicLink()) {
       try {
         const resolved = realpathSync2(join3(skillsDir, entry.name));
-        isDir = statSync(resolved).isDirectory();
+        isDir = statSync2(resolved).isDirectory();
       } catch {
         continue;
       }
@@ -1763,7 +1839,22 @@ async function init(projectRoot, options = {}) {
     throw err;
   }
   try {
-    const { nodes, edges, fileCount, totalLines } = extractDirectory(root);
+    let previousMtimes;
+    if (options.incremental) {
+      const store2 = await getStore(root);
+      try {
+        const mtimeJson = store2.getStat("file_mtimes");
+        if (mtimeJson) {
+          previousMtimes = new Map(JSON.parse(mtimeJson));
+        }
+      } finally {
+        store2.close();
+      }
+    }
+    const { nodes, edges, fileCount, totalLines, mtimes, skippedCount } = extractDirectory(root, void 0, {
+      previousMtimes,
+      onProgress: options.onProgress
+    });
     const gitResult = mineGitHistory(root);
     const sessionResult = mineSessionHistory(root);
     let skillCount = 0;
@@ -1790,10 +1881,21 @@ async function init(projectRoot, options = {}) {
     ];
     const store = await getStore(root);
     try {
-      store.clearAll();
+      if (options.incremental && previousMtimes) {
+        const clearedFiles = /* @__PURE__ */ new Set();
+        for (const node of allNodes) {
+          if (node.sourceFile && !clearedFiles.has(node.sourceFile)) {
+            store.removeNodesForFile(node.sourceFile);
+            clearedFiles.add(node.sourceFile);
+          }
+        }
+      } else {
+        store.clearAll();
+      }
       store.bulkUpsert(allNodes, allEdges);
       store.setStat("last_mined", String(Date.now()));
       store.setStat("project_root", root);
+      store.setStat("file_mtimes", JSON.stringify([...mtimes.entries()]));
     } finally {
       store.close();
     }
@@ -1803,7 +1905,9 @@ async function init(projectRoot, options = {}) {
       fileCount,
       totalLines,
       timeMs: Date.now() - start,
-      skillCount
+      skillCount,
+      skippedFiles: skippedCount,
+      incremental: options.incremental ?? false
     };
   } finally {
     try {
@@ -1874,13 +1978,13 @@ async function getFileContext(projectRoot, absFilePath) {
     const dbPath = getDbPath(root);
     let graphMtimeMs = 0;
     try {
-      graphMtimeMs = statSync2(dbPath).mtimeMs;
+      graphMtimeMs = statSync3(dbPath).mtimeMs;
     } catch {
       return empty;
     }
     let fileMtimeMs = null;
     try {
-      fileMtimeMs = statSync2(abs).mtimeMs;
+      fileMtimeMs = statSync3(abs).mtimeMs;
     } catch {
       fileMtimeMs = null;
     }