engramx 1.0.1 → 2.0.1

package/dist/chunk-CIQQ5Y3S.js

@@ -0,0 +1,338 @@
+// src/intelligence/cache.ts
+import { statSync } from "fs";
+import { join } from "path";
+var LRUCache = class {
+  map = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const val = this.map.get(key);
+    if (val !== void 0) {
+      this.map.delete(key);
+      this.map.set(key, val);
+    }
+    return val;
+  }
+  set(key, value) {
+    this.map.delete(key);
+    if (this.map.size >= this.maxSize) {
+      const firstKey = this.map.keys().next().value;
+      if (firstKey !== void 0) this.map.delete(firstKey);
+    }
+    this.map.set(key, value);
+  }
+  delete(key) {
+    this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  get size() {
+    return this.map.size;
+  }
+};
+var ContextCache = class {
+  queryLRU = new LRUCache(100);
+  patternLRU = new LRUCache(50);
+  hotFiles = /* @__PURE__ */ new Set();
+  queryHits = 0;
+  queryMisses = 0;
+  patternHits = 0;
+  patternMisses = 0;
+  /**
+   * Initialize cache tables in the store. Call once when the store opens.
+   * Safe to call multiple times (uses IF NOT EXISTS).
+   */
+  static ensureTables(store) {
+    store.runSql(`
+      CREATE TABLE IF NOT EXISTS query_cache (
+        key TEXT PRIMARY KEY,
+        result TEXT NOT NULL,
+        file_path TEXT NOT NULL,
+        file_mtime REAL NOT NULL,
+        created_at INTEGER NOT NULL,
+        hit_count INTEGER NOT NULL DEFAULT 0
+      )
+    `);
+    store.runSql(`
+      CREATE TABLE IF NOT EXISTS pattern_cache (
+        pattern TEXT PRIMARY KEY,
+        result TEXT NOT NULL,
+        graph_version INTEGER NOT NULL,
+        hit_count INTEGER NOT NULL DEFAULT 0
+      )
+    `);
+    store.runSql(
+      "CREATE INDEX IF NOT EXISTS idx_query_cache_file ON query_cache(file_path)"
+    );
+  }
+  // ─── Query Cache (per-file context packets) ─────────────────────
+  /**
+   * Get a cached context packet for a file. Returns null on miss or if
+   * the file has been modified since caching.
+   */
+  getQuery(store, filePath, absPath) {
+    const memResult = this.queryLRU.get(filePath);
+    if (memResult !== void 0) {
+      try {
+        const currentMtime = statSync(absPath).mtimeMs;
+        const cached = this.getQueryEntry(store, filePath);
+        if (cached && cached.fileMtime === currentMtime) {
+          this.queryHits++;
+          this.incrementQueryHitCount(store, filePath);
+          return memResult;
+        }
+      } catch {
+      }
+      this.queryLRU.delete(filePath);
+    }
+    const entry = this.getQueryEntry(store, filePath);
+    if (!entry) {
+      this.queryMisses++;
+      return null;
+    }
+    try {
+      const currentMtime = statSync(absPath).mtimeMs;
+      if (entry.fileMtime !== currentMtime) {
+        this.invalidateFile(store, filePath);
+        this.queryMisses++;
+        return null;
+      }
+    } catch {
+      this.invalidateFile(store, filePath);
+      this.queryMisses++;
+      return null;
+    }
+    this.queryLRU.set(filePath, entry.result);
+    this.queryHits++;
+    this.incrementQueryHitCount(store, filePath);
+    return entry.result;
+  }
+  /**
+   * Store a resolved context packet for a file.
+   */
+  setQuery(store, filePath, absPath, result) {
+    let mtime = 0;
+    try {
+      mtime = statSync(absPath).mtimeMs;
+    } catch {
+      return;
+    }
+    store.runSql(
+      `INSERT OR REPLACE INTO query_cache (key, result, file_path, file_mtime, created_at, hit_count)
+       VALUES (?, ?, ?, ?, ?, 0)`,
+      [filePath, result, filePath, mtime, Date.now()]
+    );
+    this.queryLRU.set(filePath, result);
+  }
+  // ─── Pattern Cache (structural queries) ─────────────────────────
+  /**
+   * Get a cached answer for a structural query pattern.
+   */
+  getPattern(store, pattern, graphVersion) {
+    const memResult = this.patternLRU.get(pattern);
+    if (memResult !== void 0) {
+      if (memResult.graphVersion === graphVersion) {
+        this.patternHits++;
+        try {
+          store.runSql(
+            "UPDATE pattern_cache SET hit_count = hit_count + 1 WHERE pattern = ?",
+            [pattern]
+          );
+        } catch {
+        }
+        return memResult.result;
+      }
+      this.patternLRU.delete(pattern);
+    }
+    const stmt = store.prepare(
+      "SELECT result, graph_version, hit_count FROM pattern_cache WHERE pattern = ?"
+    );
+    stmt.bind([pattern]);
+    if (stmt.step()) {
+      const row = stmt.getAsObject();
+      stmt.free();
+      const cachedVersion = row.graph_version;
+      if (cachedVersion !== graphVersion) {
+        store.runSql("DELETE FROM pattern_cache WHERE pattern = ?", [pattern]);
+        this.patternMisses++;
+        return null;
+      }
+      const result = row.result;
+      this.patternLRU.set(pattern, { result, graphVersion: cachedVersion });
+      this.patternHits++;
+      store.runSql(
+        "UPDATE pattern_cache SET hit_count = hit_count + 1 WHERE pattern = ?",
+        [pattern]
+      );
+      return result;
+    }
+    stmt.free();
+    this.patternMisses++;
+    return null;
+  }
+  /**
+   * Cache a structural query result.
+   */
+  setPattern(store, pattern, result, graphVersion) {
+    store.runSql(
+      `INSERT OR REPLACE INTO pattern_cache (pattern, result, graph_version, hit_count)
+       VALUES (?, ?, ?, 0)`,
+      [pattern, result, graphVersion]
+    );
+    this.patternLRU.set(pattern, { result, graphVersion });
+  }
+  // ─── Hot File Cache ─────────────────────────────────────────────
+  /**
+   * Pre-warm hot files from access frequency data.
+   * Call at SessionStart to eliminate first-hit latency.
+   */
+  warmHotFiles(store, projectRoot, topN = 20) {
+    const stmt = store.prepare(
+      "SELECT file_path, result FROM query_cache ORDER BY hit_count DESC LIMIT ?"
+    );
+    stmt.bind([topN]);
+    let count = 0;
+    while (stmt.step()) {
+      const row = stmt.getAsObject();
+      const filePath = row.file_path;
+      const result = row.result;
+      try {
+        const absPath = join(projectRoot, filePath);
+        const currentMtime = statSync(absPath).mtimeMs;
+        const entry = this.getQueryEntry(store, filePath);
+        if (entry && entry.fileMtime === currentMtime) {
+          this.queryLRU.set(filePath, result);
+          this.hotFiles.add(filePath);
+          count++;
+        }
+      } catch {
+      }
+    }
+    stmt.free();
+    return count;
+  }
+  // ─── Invalidation ───────────────────────────────────────────────
+  /** Invalidate all cache entries for a specific file. */
+  invalidateFile(store, filePath) {
+    store.runSql("DELETE FROM query_cache WHERE file_path = ?", [filePath]);
+    this.queryLRU.delete(filePath);
+    this.hotFiles.delete(filePath);
+  }
+  /** Invalidate all pattern cache entries (on graph mutation). */
+  invalidatePatterns(store) {
+    store.runSql("DELETE FROM pattern_cache");
+    this.patternLRU.clear();
+  }
+  /** Clear all caches completely. */
+  clearAll(store) {
+    store.runSql("DELETE FROM query_cache");
+    store.runSql("DELETE FROM pattern_cache");
+    this.queryLRU.clear();
+    this.patternLRU.clear();
+    this.hotFiles.clear();
+    this.queryHits = 0;
+    this.queryMisses = 0;
+    this.patternHits = 0;
+    this.patternMisses = 0;
+  }
+  // ─── Stats ──────────────────────────────────────────────────────
+  getStats(store) {
+    let queryEntries = 0;
+    let patternEntries = 0;
+    let persistedQueryHits = 0;
+    let persistedPatternHits = 0;
+    try {
+      const stmt1 = store.prepare(
+        "SELECT COUNT(*) as cnt, COALESCE(SUM(hit_count), 0) as hits FROM query_cache"
+      );
+      if (stmt1.step()) {
+        const row = stmt1.getAsObject();
+        queryEntries = row.cnt;
+        persistedQueryHits = row.hits;
+      }
+      stmt1.free();
+    } catch {
+    }
+    try {
+      const stmt2 = store.prepare(
+        "SELECT COUNT(*) as cnt, COALESCE(SUM(hit_count), 0) as hits FROM pattern_cache"
+      );
+      if (stmt2.step()) {
+        const row = stmt2.getAsObject();
+        patternEntries = row.cnt;
+        persistedPatternHits = row.hits;
+      }
+      stmt2.free();
+    } catch {
+    }
+    const queryHits = Math.max(this.queryHits, persistedQueryHits);
+    const patternHits = Math.max(this.patternHits, persistedPatternHits);
+    const totalHits = queryHits + patternHits;
+    const totalMisses = this.queryMisses + this.patternMisses;
+    const total = totalHits + totalMisses;
+    return {
+      queryEntries,
+      queryHits,
+      queryMisses: this.queryMisses,
+      patternEntries,
+      patternHits,
+      patternMisses: this.patternMisses,
+      hotFileCount: this.hotFiles.size,
+      totalHits,
+      totalMisses,
+      hitRate: total > 0 ? totalHits / total : 0
+    };
+  }
+  // ─── Private helpers ────────────────────────────────────────────
+  getQueryEntry(store, filePath) {
+    try {
+      const stmt = store.prepare(
+        "SELECT * FROM query_cache WHERE key = ?"
+      );
+      stmt.bind([filePath]);
+      if (stmt.step()) {
+        const row = stmt.getAsObject();
+        stmt.free();
+        return {
+          key: row.key,
+          result: row.result,
+          filePath: row.file_path,
+          fileMtime: row.file_mtime,
+          createdAt: row.created_at,
+          hitCount: row.hit_count
+        };
+      }
+      stmt.free();
+    } catch {
+    }
+    return null;
+  }
+  incrementQueryHitCount(store, filePath) {
+    try {
+      store.runSql(
+        "UPDATE query_cache SET hit_count = hit_count + 1 WHERE key = ?",
+        [filePath]
+      );
+    } catch {
+    }
+  }
+};
+var _instance = null;
+function getContextCache() {
+  if (!_instance) {
+    _instance = new ContextCache();
+  }
+  return _instance;
+}
+function _resetContextCache() {
+  _instance = null;
+}
+
+export {
+  ContextCache,
+  getContextCache,
+  _resetContextCache
+};

package/dist/chunk-KL6NSPVA.js

@@ -0,0 +1,59 @@
+// src/intelligence/hook-log.ts
+import {
+  appendFileSync,
+  existsSync,
+  renameSync,
+  statSync,
+  readFileSync
+} from "fs";
+import { join } from "path";
+var HOOK_LOG_MAX_BYTES = 10 * 1024 * 1024;
+var LOG_FILENAME = "hook-log.jsonl";
+var LOG_ROTATED_FILENAME = "hook-log.jsonl.1";
+function logHookEvent(projectRoot, entry) {
+  if (!projectRoot) return;
+  try {
+    const logPath = join(projectRoot, ".engram", LOG_FILENAME);
+    rotateIfNeeded(projectRoot);
+    const line = JSON.stringify({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      ...entry
+    }) + "\n";
+    appendFileSync(logPath, line);
+  } catch {
+  }
+}
+function rotateIfNeeded(projectRoot) {
+  try {
+    const logPath = join(projectRoot, ".engram", LOG_FILENAME);
+    if (!existsSync(logPath)) return;
+    const size = statSync(logPath).size;
+    if (size < HOOK_LOG_MAX_BYTES) return;
+    const rotatedPath = join(projectRoot, ".engram", LOG_ROTATED_FILENAME);
+    renameSync(logPath, rotatedPath);
+  } catch {
+  }
+}
+function readHookLog(projectRoot) {
+  try {
+    const logPath = join(projectRoot, ".engram", LOG_FILENAME);
+    if (!existsSync(logPath)) return [];
+    const raw = readFileSync(logPath, "utf-8");
+    const entries = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        entries.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+
+export {
+  logHookEvent,
+  readHookLog
+};

package/dist/{chunk-SBHGK5WA.js → chunk-PEH54LYC.js}

@@ -1,6 +1,19 @@
 // src/db/migrate.ts
 import { existsSync, copyFileSync } from "fs";
-var CURRENT_SCHEMA_VERSION = 6;
+var CURRENT_SCHEMA_VERSION = 7;
+var DOWN_MIGRATIONS = {
+  7: `DROP TABLE IF EXISTS query_cache; DROP TABLE IF EXISTS pattern_cache;`,
+  6: `DROP TABLE IF EXISTS engram_config;`,
+  5: `DROP TABLE IF EXISTS provider_cache;`,
+  4: `SELECT 1;`,
+  // hook-log is JSONL, no SQL rollback
+  3: `SELECT 1;`,
+  // skills miner — no schema change
+  2: `SELECT 1;`,
+  // mistake memory — no schema change
+  // 1 → 0 drops the entire schema. We require `engram init` for that.
+  1: `DROP TABLE IF EXISTS stats; DROP TABLE IF EXISTS edges; DROP TABLE IF EXISTS nodes;`
+};
 var MIGRATIONS = {
   // v0.1.0: Initial schema
   1: `
@@ -55,7 +68,24 @@ CREATE TABLE IF NOT EXISTS engram_config (
   key TEXT PRIMARY KEY,
   value TEXT NOT NULL,
   updated_at INTEGER NOT NULL
-);`
+);`,
+  // v2.0.0: Memory cache tables — query_cache + pattern_cache
+  7: `
+CREATE TABLE IF NOT EXISTS query_cache (
+  key TEXT PRIMARY KEY,
+  result TEXT NOT NULL,
+  file_path TEXT NOT NULL,
+  file_mtime REAL NOT NULL,
+  created_at INTEGER NOT NULL,
+  hit_count INTEGER NOT NULL DEFAULT 0
+);
+CREATE TABLE IF NOT EXISTS pattern_cache (
+  pattern TEXT PRIMARY KEY,
+  result TEXT NOT NULL,
+  graph_version INTEGER NOT NULL,
+  hit_count INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_query_cache_file ON query_cache(file_path);`
 };
 function getSchemaVersion(db) {
   try {
@@ -96,9 +126,61 @@ function runMigrations(db, dbPath) {
   db.run(`INSERT INTO schema_version (version) VALUES (?)`, [CURRENT_SCHEMA_VERSION]);
   return { fromVersion, toVersion: CURRENT_SCHEMA_VERSION, migrationsRun, backedUp };
 }
+function rollback(db, dbPath, targetVersion) {
+  const fromVersion = getSchemaVersion(db);
+  if (targetVersion < 0 || targetVersion > CURRENT_SCHEMA_VERSION) {
+    throw new Error(
+      `Invalid target version ${targetVersion}. Must be 0..${CURRENT_SCHEMA_VERSION}.`
+    );
+  }
+  if (targetVersion > fromVersion) {
+    throw new Error(
+      `Cannot roll back to v${targetVersion}: current is v${fromVersion}. Use 'engram db migrate' to move forward.`
+    );
+  }
+  if (targetVersion === fromVersion) {
+    return {
+      fromVersion,
+      toVersion: fromVersion,
+      migrationsReverted: 0,
+      backedUp: false
+    };
+  }
+  let backedUp = false;
+  if (existsSync(dbPath)) {
+    const backupPath = `${dbPath}.bak-v${fromVersion}`;
+    try {
+      copyFileSync(dbPath, backupPath);
+      backedUp = true;
+    } catch {
+    }
+  }
+  const dbExec = db;
+  let migrationsReverted = 0;
+  for (let v = fromVersion; v > targetVersion; v--) {
+    const sql = DOWN_MIGRATIONS[v];
+    if (sql) {
+      dbExec.exec(sql);
+      migrationsReverted++;
+    }
+  }
+  if (targetVersion === 0) {
+    dbExec.exec(`DROP TABLE IF EXISTS schema_version`);
+  } else {
+    dbExec.exec(`DELETE FROM schema_version`);
+    db.run(`INSERT INTO schema_version (version) VALUES (?)`, [targetVersion]);
+  }
+  return {
+    fromVersion,
+    toVersion: targetVersion,
+    migrationsReverted,
+    backedUp
+  };
+}
 
 export {
   CURRENT_SCHEMA_VERSION,
   getSchemaVersion,
-  runMigrations
+  runMigrations,
+  rollback
 };