remem-mcp 0.6.3 → 0.6.4

package/dist/resolver-AVK7XKX7.js

@@ -0,0 +1,300 @@
+import {
+  __esm,
+  init_esm_shims
+} from "./chunk-XK4Y53J2.js";
+
+// src/codegraph/resolver.ts
+function resolveCall(calleeName, callerFilePath, registry, importMap) {
+  const parts = calleeName.split(".");
+  if (parts.length >= 2) {
+    const prefix = parts[0];
+    const suffix = parts.slice(1).join(".");
+    const modulePath = importMap.lookup(callerFilePath, prefix);
+    if (modulePath) {
+      const qualifiedName = `${modulePath}/${suffix}`;
+      const sym = registry.exactLookup(qualifiedName);
+      if (sym) {
+        return { calleeId: sym.id, confidence: 0.95, strategy: "import-map" };
+      }
+      const fullQualified = `${modulePath}/${calleeName}`;
+      const symFull = registry.exactLookup(fullQualified);
+      if (symFull) {
+        return { calleeId: symFull.id, confidence: 0.95, strategy: "import-map" };
+      }
+    }
+  }
+  if (parts.length >= 2) {
+    const prefix = parts[0];
+    const suffix = parts[parts.length - 1];
+    const modulePath = importMap.lookup(callerFilePath, prefix);
+    if (modulePath) {
+      const candidates2 = registry.reverseLookup(suffix);
+      for (const c of candidates2) {
+        const cModule = registry.getModuleForFile(c.file_path);
+        if (cModule === modulePath || cModule.endsWith(`/${modulePath}`)) {
+          return { calleeId: c.id, confidence: 0.85, strategy: "import-map-suffix" };
+        }
+      }
+    }
+  }
+  const callerModule = registry.getModuleForFile(callerFilePath);
+  const sameModuleQualified = `${callerModule}/${calleeName}`;
+  const symSame = registry.exactLookup(sameModuleQualified);
+  if (symSame) {
+    return { calleeId: symSame.id, confidence: 0.9, strategy: "same-module" };
+  }
+  const sameModuleSimple = registry.reverseLookup(calleeName).find(
+    (s) => registry.getModuleForFile(s.file_path) === callerModule
+  );
+  if (sameModuleSimple) {
+    return { calleeId: sameModuleSimple.id, confidence: 0.9, strategy: "same-module" };
+  }
+  const candidates = registry.reverseLookup(calleeName);
+  if (candidates.length === 1) {
+    return { calleeId: candidates[0].id, confidence: 0.75, strategy: "unique-name" };
+  }
+  if (candidates.length > 1) {
+    const fileImports = importMap.getImportsForFile(callerFilePath);
+    if (fileImports) {
+      for (const c of candidates) {
+        const cModule = registry.getModuleForFile(c.file_path);
+        for (const [, impModule] of fileImports) {
+          if (cModule === impModule || cModule.startsWith(`${impModule}/`)) {
+            return { calleeId: c.id, confidence: 0.55, strategy: "suffix-match" };
+          }
+        }
+      }
+    }
+    const callerDir = callerFilePath.slice(0, callerFilePath.lastIndexOf("/"));
+    let best = candidates[0];
+    let bestDist = Infinity;
+    for (const c of candidates) {
+      const cDir = c.file_path.slice(0, c.file_path.lastIndexOf("/"));
+      const dist = pathDistance(callerDir, cDir);
+      if (dist < bestDist) {
+        bestDist = dist;
+        best = c;
+      }
+    }
+    return { calleeId: best.id, confidence: 0.55, strategy: "suffix-match" };
+  }
+  const fuzzyMatch = fuzzyLookup(calleeName, registry);
+  if (fuzzyMatch) {
+    return { calleeId: fuzzyMatch.id, confidence: 0.35, strategy: "fuzzy" };
+  }
+  return { calleeId: null, confidence: 0, strategy: "unresolved" };
+}
+function shouldSkipResolution(calleeName) {
+  if (calleeName.length <= 2) return true;
+  if (SKIP_NAMES.has(calleeName)) return true;
+  const parts = calleeName.split(".");
+  if (parts.length >= 2 && parts[0].length <= 1) return true;
+  return false;
+}
+function resolveAllCalls(db) {
+  try {
+    db.exec("CREATE INDEX IF NOT EXISTS idx_calls_callee_name ON calls(callee_name)");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name)");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_symbols_module ON symbols(module_path)");
+  } catch {
+  }
+  const symbols = db.prepare("SELECT id, name, kind, file_path, module_path, language, parent_id FROM symbols").all();
+  const registry = new FunctionRegistry(symbols);
+  const imports = db.prepare("SELECT file_path, symbol_name, source_path FROM imports").all();
+  const importMap = new ImportMap(imports);
+  const calls = db.prepare("SELECT id, caller_id, callee_name, callee_id, line, call_type FROM calls WHERE callee_id IS NULL").all();
+  const stats = { total: calls.length, resolved: 0, byStrategy: {} };
+  let skipped = 0;
+  const callerFiles = /* @__PURE__ */ new Map();
+  const callerIds = [...new Set(calls.map((c) => c.caller_id))];
+  if (callerIds.length > 0) {
+    for (let i = 0; i < callerIds.length; i += 500) {
+      const chunk = callerIds.slice(i, i + 500);
+      const placeholders = chunk.map(() => "?").join(",");
+      const rows = db.prepare(`SELECT id, file_path FROM symbols WHERE id IN (${placeholders})`).all(...chunk);
+      for (const r of rows) {
+        callerFiles.set(r.id, r.file_path);
+      }
+    }
+  }
+  const updateStmt = db.prepare(
+    "UPDATE calls SET callee_id = ?, confidence = ? WHERE id = ?"
+  );
+  const batch = db.transaction(() => {
+    for (const call of calls) {
+      if (shouldSkipResolution(call.callee_name)) {
+        skipped++;
+        continue;
+      }
+      const callerFile = callerFiles.get(call.caller_id) ?? "";
+      const result = resolveCall(call.callee_name, callerFile, registry, importMap);
+      if (result.calleeId) {
+        updateStmt.run(result.calleeId, result.confidence, call.id);
+        stats.resolved++;
+        stats.byStrategy[result.strategy] = (stats.byStrategy[result.strategy] ?? 0) + 1;
+      }
+    }
+  });
+  batch();
+  if (skipped > 0) {
+    console.error(`[remem-mcp] resolveAllCalls: skipped ${skipped} short/builtin names`);
+  }
+  return stats;
+}
+function deriveModulePath(filePath) {
+  return filePath.replace(/\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|c|cpp|cc|cxx|hpp|cs)$/, "");
+}
+function pathDistance(a, b) {
+  if (a === b) return 0;
+  const aParts = a.split("/");
+  const bParts = b.split("/");
+  let common = 0;
+  for (let i = 0; i < Math.min(aParts.length, bParts.length); i++) {
+    if (aParts[i] === bParts[i]) common++;
+    else break;
+  }
+  return aParts.length + bParts.length - 2 * common;
+}
+function fuzzyLookup(name, registry) {
+  let best = null;
+  let bestScore = 0;
+  for (const [symName, candidates] of registry.reverseLookupEntries()) {
+    const score = similarity(name, symName);
+    if (score > bestScore && score > 0.6) {
+      bestScore = score;
+      best = candidates[0];
+    }
+  }
+  return best;
+}
+function similarity(a, b) {
+  if (a === b) return 1;
+  const aBigrams = bigrams(a);
+  const bBigrams = bigrams(b);
+  const intersection = aBigrams.filter((bg) => bBigrams.includes(bg)).length;
+  const union = aBigrams.length + bBigrams.length - intersection;
+  return union > 0 ? intersection / union : 0;
+}
+function bigrams(s) {
+  const result = [];
+  for (let i = 0; i < s.length - 1; i++) {
+    result.push(s.slice(i, i + 2));
+  }
+  return result;
+}
+var FunctionRegistry, ImportMap, SKIP_NAMES;
+var init_resolver = __esm({
+  "src/codegraph/resolver.ts"() {
+    init_esm_shims();
+    FunctionRegistry = class {
+      exactMap = /* @__PURE__ */ new Map();
+      reverseIndex = /* @__PURE__ */ new Map();
+      fileModules = /* @__PURE__ */ new Map();
+      // file_path → module_path
+      constructor(symbols) {
+        for (const sym of symbols) {
+          const modulePath = sym.module_path ?? deriveModulePath(sym.file_path);
+          this.fileModules.set(sym.file_path, modulePath);
+          const qualifiedName = `${modulePath}/${sym.name}`;
+          this.exactMap.set(qualifiedName, sym);
+          this.exactMap.set(`${sym.file_path}/${sym.name}`, sym);
+          const existing = this.reverseIndex.get(sym.name);
+          if (existing) {
+            existing.push(sym);
+          } else {
+            this.reverseIndex.set(sym.name, [sym]);
+          }
+        }
+      }
+      /** Look up by qualified name (module_path/name). */
+      exactLookup(qualifiedName) {
+        return this.exactMap.get(qualifiedName);
+      }
+      /** Look up by simple name — returns all candidates. */
+      reverseLookup(simpleName) {
+        return this.reverseIndex.get(simpleName) ?? [];
+      }
+      /** Get all reverse index entries (for fuzzy lookup). */
+      reverseLookupEntries() {
+        return this.reverseIndex.entries();
+      }
+      /** Get module_path for a file. */
+      getModuleForFile(filePath) {
+        return this.fileModules.get(filePath) ?? deriveModulePath(filePath);
+      }
+    };
+    ImportMap = class {
+      fileImports = /* @__PURE__ */ new Map();
+      constructor(imports) {
+        for (const imp of imports) {
+          if (!imp.source_path) continue;
+          let fileMap = this.fileImports.get(imp.file_path);
+          if (!fileMap) {
+            fileMap = /* @__PURE__ */ new Map();
+            this.fileImports.set(imp.file_path, fileMap);
+          }
+          const prefix = imp.symbol_name.split(".")[0] ?? imp.symbol_name;
+          const modulePath = deriveModulePath(imp.source_path);
+          fileMap.set(prefix, modulePath);
+          fileMap.set(imp.symbol_name, modulePath);
+        }
+      }
+      /** Look up module path for an import prefix in a given file. */
+      lookup(filePath, prefix) {
+        return this.fileImports.get(filePath)?.get(prefix);
+      }
+      /** Get all imports for a file. */
+      getImportsForFile(filePath) {
+        return this.fileImports.get(filePath);
+      }
+    };
+    SKIP_NAMES = /* @__PURE__ */ new Set([
+      "T",
+      "L",
+      "R",
+      "S",
+      "P",
+      "C",
+      "D",
+      "E",
+      "F",
+      "M",
+      "N",
+      "V",
+      "X",
+      "Y",
+      "String",
+      "Array",
+      "Object",
+      "Number",
+      "Boolean",
+      "Map",
+      "Set",
+      "Date",
+      "Error",
+      "RegExp",
+      "Promise",
+      "Symbol",
+      "Buffer",
+      "Vec",
+      "Box",
+      "Option",
+      "Result",
+      "Some",
+      "None",
+      "Ok",
+      "Err",
+      "List",
+      "Dict",
+      "Tuple"
+    ]);
+  }
+});
+init_resolver();
+export {
+  FunctionRegistry,
+  ImportMap,
+  resolveAllCalls,
+  resolveCall
+};
+//# sourceMappingURL=resolver-AVK7XKX7.js.map

package/dist/resolver-AVK7XKX7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/codegraph/resolver.ts"],"sourcesContent":["/**\n * Call resolver: 6-strategy cascade for resolving callee names to symbol IDs.\n *\n * Adapted from Codebase-Memory (arXiv:2603.27277, MIT, DeusData 2026).\n * https://github.com/DeusData/codebase-memory-mcp\n *\n * Strategies (in priority order):\n * 1. Import map (0.95): Split callee into prefix.suffix; look up prefix in file's import map\n * 2. Import map suffix (0.85): Suffix-based matching against import-resolved module paths\n * 3. Same module (0.90): Prefix callee with enclosing file's module path\n * 4. Unique name (0.75): Simple name lookup, accept if exactly 1 candidate\n * 5. Suffix match (0.55): Multiple candidates, select by suffix + import-distance\n * 6. Fuzzy (0.30-0.40): String similarity — last resort\n */\n\nimport type { Database } from \"better-sqlite3\";\n\nexport interface SymbolRow {\n  id: string;\n  name: string;\n  kind: string;\n  file_path: string;\n  module_path: string | null;\n  language: string;\n  parent_id: string | null;\n}\n\nexport interface CallRow {\n  id: number;\n  caller_id: string;\n  callee_name: string;\n  callee_id: string | null;\n  line: number;\n  call_type: string;\n}\n\nexport interface ImportRow {\n  file_path: string;\n  symbol_name: string;\n  source_path: string | null;\n}\n\nexport interface ResolutionResult {\n  calleeId: string | null;\n  confidence: number;\n  strategy: string;\n}\n\n/**\n * FunctionRegistry indexes all symbol definitions by:\n * - qualified name (exact map): \"module_path/SymbolName\" → SymbolRow\n * - simple name (reverse index): \"SymbolName\" → SymbolRow[]\n */\nexport class FunctionRegistry {\n  private exactMap = new Map<string, SymbolRow>();\n  private reverseIndex = new Map<string, SymbolRow[]>();\n  private fileModules = new Map<string, string>(); // file_path → module_path\n\n  constructor(symbols: SymbolRow[]) {\n    for (const sym of symbols) {\n      // Build module_path from file_path if not set\n      const modulePath = sym.module_path ?? deriveModulePath(sym.file_path);\n      this.fileModules.set(sym.file_path, modulePath);\n\n      // Exact map: module_path/name\n      const qualifiedName = `${modulePath}/${sym.name}`;\n      this.exactMap.set(qualifiedName, sym);\n      // Also index by file_path/name for same-file resolution\n      this.exactMap.set(`${sym.file_path}/${sym.name}`, sym);\n\n      // Reverse index: simple name → all matching symbols\n      const existing = this.reverseIndex.get(sym.name);\n      if (existing) {\n        existing.push(sym);\n      } else {\n        this.reverseIndex.set(sym.name, [sym]);\n      }\n    }\n  }\n\n  /** Look up by qualified name (module_path/name). */\n  exactLookup(qualifiedName: string): SymbolRow | undefined {\n    return this.exactMap.get(qualifiedName);\n  }\n\n  /** Look up by simple name — returns all candidates. */\n  reverseLookup(simpleName: string): SymbolRow[] {\n    return this.reverseIndex.get(simpleName) ?? [];\n  }\n\n  /** Get all reverse index entries (for fuzzy lookup). */\n  reverseLookupEntries(): IterableIterator<[string, SymbolRow[]]> {\n    return this.reverseIndex.entries();\n  }\n\n  /** Get module_path for a file. */\n  getModuleForFile(filePath: string): string {\n    return this.fileModules.get(filePath) ?? deriveModulePath(filePath);\n  }\n}\n\n/**\n * ImportMap tracks what each file imports: { prefix → module_path }.\n * Built from the imports table.\n */\nexport class ImportMap {\n  private fileImports = new Map<string, Map<string, string>>();\n\n  constructor(imports: ImportRow[]) {\n    for (const imp of imports) {\n      if (!imp.source_path) continue;\n      let fileMap = this.fileImports.get(imp.file_path);\n      if (!fileMap) {\n        fileMap = new Map();\n        this.fileImports.set(imp.file_path, fileMap);\n      }\n      // Map: symbol_name (or prefix) → source module_path\n      const prefix = imp.symbol_name.split(\".\")[0] ?? imp.symbol_name;\n      const modulePath = deriveModulePath(imp.source_path);\n      fileMap.set(prefix, modulePath);\n      fileMap.set(imp.symbol_name, modulePath);\n    }\n  }\n\n  /** Look up module path for an import prefix in a given file. */\n  lookup(filePath: string, prefix: string): string | undefined {\n    return this.fileImports.get(filePath)?.get(prefix);\n  }\n\n  /** Get all imports for a file. */\n  getImportsForFile(filePath: string): Map<string, string> | undefined {\n    return this.fileImports.get(filePath);\n  }\n}\n\n/**\n * Resolve a callee name to a symbol ID using the 6-strategy cascade.\n * Returns { calleeId, confidence, strategy } or { calleeId: null, confidence: 0, strategy: \"unresolved\" }.\n */\nexport function resolveCall(\n  calleeName: string,\n  callerFilePath: string,\n  registry: FunctionRegistry,\n  importMap: ImportMap,\n): ResolutionResult {\n  // Strategy 1: Import map (0.95)\n  // Split callee into prefix.suffix; look up prefix in file's import map\n  const parts = calleeName.split(\".\");\n  if (parts.length >= 2) {\n    const prefix = parts[0];\n    const suffix = parts.slice(1).join(\".\");\n    const modulePath = importMap.lookup(callerFilePath, prefix);\n    if (modulePath) {\n      const qualifiedName = `${modulePath}/${suffix}`;\n      const sym = registry.exactLookup(qualifiedName);\n      if (sym) {\n        return { calleeId: sym.id, confidence: 0.95, strategy: \"import-map\" };\n      }\n      // Also try full callee name in the resolved module\n      const fullQualified = `${modulePath}/${calleeName}`;\n      const symFull = registry.exactLookup(fullQualified);\n      if (symFull) {\n        return { calleeId: symFull.id, confidence: 0.95, strategy: \"import-map\" };\n      }\n    }\n  }\n\n  // Strategy 2: Import map suffix (0.85)\n  // Try suffix-based matching against import-resolved module paths\n  if (parts.length >= 2) {\n    const prefix = parts[0];\n    const suffix = parts[parts.length - 1];\n    const modulePath = importMap.lookup(callerFilePath, prefix);\n    if (modulePath) {\n      const candidates = registry.reverseLookup(suffix);\n      for (const c of candidates) {\n        const cModule = registry.getModuleForFile(c.file_path);\n        if (cModule === modulePath || cModule.endsWith(`/${modulePath}`)) {\n          return { calleeId: c.id, confidence: 0.85, strategy: \"import-map-suffix\" };\n        }\n      }\n    }\n  }\n\n  // Strategy 3: Same module (0.90)\n  // Prefix callee with enclosing file's module path\n  const callerModule = registry.getModuleForFile(callerFilePath);\n  const sameModuleQualified = `${callerModule}/${calleeName}`;\n  const symSame = registry.exactLookup(sameModuleQualified);\n  if (symSame) {\n    return { calleeId: symSame.id, confidence: 0.90, strategy: \"same-module\" };\n  }\n  // Also try just the simple name in same module\n  const sameModuleSimple = registry.reverseLookup(calleeName).find(\n    (s) => registry.getModuleForFile(s.file_path) === callerModule,\n  );\n  if (sameModuleSimple) {\n    return { calleeId: sameModuleSimple.id, confidence: 0.90, strategy: \"same-module\" };\n  }\n\n  // Strategy 4: Unique name (0.75)\n  // Simple name lookup, accept if exactly 1 candidate project-wide\n  const candidates = registry.reverseLookup(calleeName);\n  if (candidates.length === 1) {\n    return { calleeId: candidates[0].id, confidence: 0.75, strategy: \"unique-name\" };\n  }\n\n  // Strategy 5: Suffix match (0.55)\n  // Multiple candidates, select by suffix match with import-distance scoring\n  if (candidates.length > 1) {\n    // Prefer candidates in modules reachable from this file's imports\n    const fileImports = importMap.getImportsForFile(callerFilePath);\n    if (fileImports) {\n      for (const c of candidates) {\n        const cModule = registry.getModuleForFile(c.file_path);\n        for (const [, impModule] of fileImports) {\n          if (cModule === impModule || cModule.startsWith(`${impModule}/`)) {\n            return { calleeId: c.id, confidence: 0.55, strategy: \"suffix-match\" };\n          }\n        }\n      }\n    }\n    // Fallback: pick first candidate (nearest by file path similarity)\n    const callerDir = callerFilePath.slice(0, callerFilePath.lastIndexOf(\"/\"));\n    let best = candidates[0];\n    let bestDist = Infinity;\n    for (const c of candidates) {\n      const cDir = c.file_path.slice(0, c.file_path.lastIndexOf(\"/\"));\n      const dist = pathDistance(callerDir, cDir);\n      if (dist < bestDist) {\n        bestDist = dist;\n        best = c;\n      }\n    }\n    return { calleeId: best.id, confidence: 0.55, strategy: \"suffix-match\" };\n  }\n\n  // Strategy 6: Fuzzy (0.30-0.40)\n  // String similarity — last resort\n  const fuzzyMatch = fuzzyLookup(calleeName, registry);\n  if (fuzzyMatch) {\n    return { calleeId: fuzzyMatch.id, confidence: 0.35, strategy: \"fuzzy\" };\n  }\n\n  return { calleeId: null, confidence: 0, strategy: \"unresolved\" };\n}\n\n/** Names too short or builtin to bother resolving. */\nconst SKIP_NAMES = new Set([\n  \"T\", \"L\", \"R\", \"S\", \"P\", \"C\", \"D\", \"E\", \"F\", \"M\", \"N\", \"V\", \"X\", \"Y\",\n  \"String\", \"Array\", \"Object\", \"Number\", \"Boolean\", \"Map\", \"Set\", \"Date\",\n  \"Error\", \"RegExp\", \"Promise\", \"Symbol\", \"Buffer\", \"Vec\", \"Box\", \"Option\",\n  \"Result\", \"Some\", \"None\", \"Ok\", \"Err\", \"List\", \"Dict\", \"Tuple\",\n]);\n\n/** Check if a callee name should be skipped (too short or builtin type). */\nfunction shouldSkipResolution(calleeName: string): boolean {\n  if (calleeName.length <= 2) return true;\n  if (SKIP_NAMES.has(calleeName)) return true;\n  // Skip single-letter + dot patterns like \"T.foo\"\n  const parts = calleeName.split(\".\");\n  if (parts.length >= 2 && parts[0].length <= 1) return true;\n  return false;\n}\n\n/**\n * Run call resolution on all unresolved calls in the database.\n * Called after indexDirectory() completes.\n */\nexport function resolveAllCalls(db: Database): {\n  total: number;\n  resolved: number;\n  byStrategy: Record<string, number>;\n} {\n  // Create index for faster lookups (idempotent)\n  try {\n    db.exec(\"CREATE INDEX IF NOT EXISTS idx_calls_callee_name ON calls(callee_name)\");\n    db.exec(\"CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name)\");\n    db.exec(\"CREATE INDEX IF NOT EXISTS idx_symbols_module ON symbols(module_path)\");\n  } catch {}\n\n  // Load all symbols into FunctionRegistry\n  const symbols = db\n    .prepare(\"SELECT id, name, kind, file_path, module_path, language, parent_id FROM symbols\")\n    .all() as SymbolRow[];\n  const registry = new FunctionRegistry(symbols);\n\n  // Load all imports into ImportMap\n  const imports = db\n    .prepare(\"SELECT file_path, symbol_name, source_path FROM imports\")\n    .all() as ImportRow[];\n  const importMap = new ImportMap(imports);\n\n  // Get all unresolved calls — skip short/builtin names to save resolution time\n  const calls = db\n    .prepare(\"SELECT id, caller_id, callee_name, callee_id, line, call_type FROM calls WHERE callee_id IS NULL\")\n    .all() as CallRow[];\n\n  const stats = { total: calls.length, resolved: 0, byStrategy: {} as Record<string, number> };\n  let skipped = 0;\n\n  // Get caller file paths — batch query\n  const callerFiles = new Map<string, string>();\n  const callerIds = [...new Set(calls.map((c) => c.caller_id))];\n  if (callerIds.length > 0) {\n    // Batch in chunks of 500 to avoid SQLite param limit\n    for (let i = 0; i < callerIds.length; i += 500) {\n      const chunk = callerIds.slice(i, i + 500);\n      const placeholders = chunk.map(() => \"?\").join(\",\");\n      const rows = db\n        .prepare(`SELECT id, file_path FROM symbols WHERE id IN (${placeholders})`)\n        .all(...chunk) as { id: string; file_path: string }[];\n      for (const r of rows) {\n        callerFiles.set(r.id, r.file_path);\n      }\n    }\n  }\n\n  // Resolve each call — skip short/builtin names\n  const updateStmt = db.prepare(\n    \"UPDATE calls SET callee_id = ?, confidence = ? WHERE id = ?\",\n  );\n  const batch = db.transaction(() => {\n    for (const call of calls) {\n      if (shouldSkipResolution(call.callee_name)) {\n        skipped++;\n        continue;\n      }\n      const callerFile = callerFiles.get(call.caller_id) ?? \"\";\n      const result = resolveCall(call.callee_name, callerFile, registry, importMap);\n      if (result.calleeId) {\n        updateStmt.run(result.calleeId, result.confidence, call.id);\n        stats.resolved++;\n        stats.byStrategy[result.strategy] = (stats.byStrategy[result.strategy] ?? 0) + 1;\n      }\n    }\n  });\n  batch();\n\n  if (skipped > 0) {\n    console.error(`[remem-mcp] resolveAllCalls: skipped ${skipped} short/builtin names`);\n  }\n\n  return stats;\n}\n\n/** Derive a module path from a file path: \"src/storage/sqlite.ts\" → \"src/storage/sqlite\" */\nfunction deriveModulePath(filePath: string): string {\n  return filePath.replace(/\\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|c|cpp|cc|cxx|hpp|cs)$/, \"\");\n}\n\n/** Calculate directory path distance for suffix-match scoring. */\nfunction pathDistance(a: string, b: string): number {\n  if (a === b) return 0;\n  const aParts = a.split(\"/\");\n  const bParts = b.split(\"/\");\n  let common = 0;\n  for (let i = 0; i < Math.min(aParts.length, bParts.length); i++) {\n    if (aParts[i] === bParts[i]) common++;\n    else break;\n  }\n  return aParts.length + bParts.length - 2 * common;\n}\n\n/** Fuzzy lookup: find symbol with most similar name. */\nfunction fuzzyLookup(name: string, registry: FunctionRegistry): SymbolRow | null {\n  let best: SymbolRow | null = null;\n  let bestScore = 0;\n  for (const [symName, candidates] of registry.reverseLookupEntries()) {\n    const score = similarity(name, symName);\n    if (score > bestScore && score > 0.6) {\n      bestScore = score;\n      best = candidates[0];\n    }\n  }\n  return best;\n}\n\n/** Simple string similarity (Jaccard on character bigrams). */\nfunction similarity(a: string, b: string): number {\n  if (a === b) return 1;\n  const aBigrams = bigrams(a);\n  const bBigrams = bigrams(b);\n  const intersection = aBigrams.filter((bg) => bBigrams.includes(bg)).length;\n  const union = aBigrams.length + bBigrams.length - intersection;\n  return union > 0 ? intersection / union : 0;\n}\n\nfunction bigrams(s: string): string[] {\n  const result: string[] = [];\n  for (let i = 0; i < s.length - 1; i++) {\n    result.push(s.slice(i, i + 2));\n  }\n  return result;\n}\n"],"mappings":"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","names":["candidates"]}

package/dist/sdk.js

@@ -8,7 +8,7 @@ import {
   ingestDirectory,
   ingestFile,
   searchWiki
-} from "./chunk-WBGP7QM3.js";
+} from "./chunk-X4ECGLYH.js";
 import {
   SUPPORTED_LANGUAGES,
   detectLanguage,
@@ -19,7 +19,8 @@ import {
   indexFile,
   listSymbols,
   searchSymbols
-} from "./chunk-SHLLMMMU.js";
+} from "./chunk-FA324IBN.js";
+import "./chunk-XK4Y53J2.js";
 export {
   LocalEmbedder,
   Memory,

package/dist/storage/schema.sql

@@ -53,7 +53,8 @@ CREATE TABLE IF NOT EXISTS messages (
   created_at  INTEGER NOT NULL
 );
 
--- L1: Atomic facts (populated by atom-extract pipeline, or CLI extract command)
+-- L1: Atomic facts (phase 2 — populated by atom-extract pipeline or CLI extract command.
+-- Currently written by the extract CLI subcommand; NoopPipeline does not populate this.)
 CREATE TABLE IF NOT EXISTS atoms (
   id          TEXT PRIMARY KEY,
   capture_id  TEXT NOT NULL REFERENCES captures(id) ON DELETE CASCADE,
@@ -65,7 +66,7 @@ CREATE TABLE IF NOT EXISTS atoms (
   user_id     TEXT
 );
 
--- L2: Scenario blocks (populated by scenario pipeline)
+-- L2: Scenario blocks (phase 2 — populated by scenario pipeline, not yet implemented)
 CREATE TABLE IF NOT EXISTS scenarios (
   id           TEXT PRIMARY KEY,
   atom_ids     TEXT NOT NULL,
@@ -179,6 +180,7 @@ CREATE TABLE IF NOT EXISTS symbols (
   team_id      TEXT,
   repo_path    TEXT,                   -- root path of the indexed repo
   content_hash TEXT,                   -- hash of the symbol body for change detection
+  module_path  TEXT,                   -- qualified module path (e.g. src/storage/sqlite) for call resolution
   created_at   INTEGER NOT NULL,
   updated_at   INTEGER NOT NULL
 );
@@ -191,6 +193,8 @@ CREATE TABLE IF NOT EXISTS calls (
   callee_id    TEXT REFERENCES symbols(id), -- resolved callee (null if unresolved)
   line         INTEGER NOT NULL,       -- line where the call occurs
   kind         TEXT NOT NULL DEFAULT 'call', -- call, import, reference
+  confidence   REAL,                   -- resolution confidence (0.0-1.0, null if unresolved)
+  call_type    TEXT NOT NULL DEFAULT 'direct', -- direct, method, qualified, constructor
   team_id      TEXT
 );
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "remem-mcp",
   "mcpName": "io.github.tinhien11/remem-mcp",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "Long-term memory for AI coding agents. Memory + CodeGraph + Wiki in one SQLite file. Auto-recall, auto-capture, no API key, no cloud.",
   "type": "module",
   "license": "MIT",
@@ -68,7 +68,6 @@
     "better-sqlite3": "^13.0.3",
     "gpt-tokenizer": "^3.4.0",
     "sqlite-vec": "^0.1.9",
-    "tree-sitter": "^0.25.1",
     "ulid": "^3.0.2"
   },
   "devDependencies": {

package/skills/remem-mcp/SKILL.md

@@ -1,140 +1,94 @@
 ---
 name: remem-mcp
-description: Long-term memory for coding agents. Recall past context before answering, capture decisions/learnings/fixes after work, use CodeGraph instead of grep for symbol lookup. Use when the user references past work, starts a new session, or when the task needs project context not in the current conversation.
+description: Long-term memory for coding agents. Auto-applies at the start of any coding task — recall past context before answering, capture decisions/learnings/fixes after work, use CodeGraph instead of grep for symbol lookup. Invoke when you see [remem-mcp] in your context or when starting any non-trivial coding work.
 ---
 
 You have a long-term memory server via MCP. Use the tools automatically — do not ask permission.
 
 ## Tools
 
-**Core:** `recall` `capture` `search` `forget` `resolve` `handoff` `adr` `update` `consolidate`
-
-**CodeGraph:** `codegraph_search` (auto-indexes on first use) `codegraph_callers` `codegraph_callees` `codegraph_impact` `codegraph_list`
-
+**Core:** `recall` `capture` `search` `forget` `resolve` `handoff` `adr` `update` `consolidate` `scenario_create` `persona_update`
+**CodeGraph:** `codegraph_search` (auto-indexes on first use) `codegraph_callers` `codegraph_callees` `codegraph_impact` `codegraph_list` `codegraph_detect_changes` (git diff → affected symbols)
 **Wiki:** `wiki_ingest` `wiki_search` `wiki_get` `wiki_outdated`
 
 ## Rule 1: Recall before answering
 
-Call `recall` at session start or when the user references past work. Do this BEFORE you answer or code.
+Hooks auto-inject BM25-only memory (shallow). **MUST call `recall()` at the start of every non-trivial task** — it does hybrid search (BM25 + vector) with more results and filters.
 
 ```
-recall({ "query": "<user's question or task>", "mode": "hybrid" })
+recall({ "query": "<user's question or task>", "mode": "hybrid", "limit": 5 })
 ```
 
-If recall returns nothing, proceed normally. Don't mention the empty result.
-
 ## Rule 2: Capture after non-trivial work
 
-Call `capture` automatically after completing work. Don't ask.
+Call `capture` automatically after completing work. Don't ask. Include `atoms` — short distilled facts that recall returns instead of raw content (90% fewer tokens).
 
 ```
-capture({ "content": "Chose SQLite over Postgres for zero-setup MVP.", "type": "decision", "tags": ["arch"] })
+capture({
+  "content": "Chose SQLite over Postgres for zero-setup MVP. SQLite has FTS5 + sqlite-vec built in, no server needed.",
+  "type": "decision",
+  "tags": ["arch"],
+  "atoms": ["Use SQLite (not Postgres) for zero-setup MVP", "SQLite has FTS5 + sqlite-vec built in"]
+})
 ```
 
-**Types:** `decision` (chose X over Y, include why) · `learning` (non-obvious fact) · `task` (completed work) · `error` (bug + root cause + fix) · `conversation` (multi-turn, pass `messages`)
+**Types:** `decision` (chose X over Y, include why) · `learning` (non-obvious fact) · `task` (completed work) · `error` (bug + root cause + fix)
 
-**Good:** specific, useful later. **Bad:** "We talked about the database."
+**Atoms:** 1-3 short self-contained facts. Each useful on its own without the raw content. Write for decisions, learnings, errors. Skip for conversations.
 
-## Rule 3: Use CodeGraph instead of grep
+## Rule 3: Consolidate atoms into scenarios (L2)
 
-For function/class/method definitions, call `codegraph_search` — NOT grep. It auto-indexes `src/` on first use, no setup needed.
+When you have 5+ atoms about the same topic, call `scenario_create` to create a high-signal summary. Recall injects scenarios automatically (~100 tokens instead of 5+ atoms).
 
 ```
-codegraph_search({ "query": "handleCapture" })
-codegraph_callers({ "symbol_id": "<id from search>" })
-codegraph_impact({ "symbol_id": "<id>" })  // before modifying a function
+scenario_create({
+  "atom_ids": ["01...", "01...", "01..."],
+  "summary": "Database: SQLite chosen for MVP — FTS5 + sqlite-vec built in, zero setup, no server needed.",
+  "persona_tags": ["database", "arch"]
+})
 ```
 
-Use grep only for: string literals, config values, file names.
-
-## Rule 4: Handoff when switching agents
-
-Call `handoff` at session end or before switching agents. Creates a packet the next agent loads via `recall`.
+**When:** After capturing 5+ decisions/learnings about the same topic (e.g., database, hooks, deployment).
 
-```
-handoff({ "task": "Fix auth bug", "status": "in_progress", "progress": "Found root cause", "next_steps": ["Implement fix"] })
-```
+**Auto-pipeline:** The Stop hook spawns a background worker that auto-extracts L1 atoms from uncaptured L0 entries, auto-consolidates 5+ atoms on the same topic into L2 scenarios, and auto-updates L3 persona from repeated tags. You don't need to call `scenario_create` or `persona_update` manually — the worker does it. Only call them manually if you want a specific summary the worker wouldn't generate.
 
-Skip if task is done or trivial.
+## Rule 4: Update persona (L3)
 
-## Rule 5: Forget only on explicit request
-
-Call `forget` ONLY when the user asks to delete. Always require `confirm: true`.
+When you notice a user preference or pattern (2+ occurrences), call `persona_update`. SessionStart AND UserPromptSubmit inject persona automatically every turn (~50 tokens).
 
 ```
-forget({ "id": "<id>", "confirm": true, "reject": true, "reason": "Wrong: port is 9090 not 8080." })
+persona_update({ "trait": "language", "value": "Vietnamese" })
+persona_update({ "trait": "output_style", "value": "concise" })
 ```
 
-`reject: true` tombstones the content hash — blocks re-capture of wrong info.
-
-## Trust states
+**When:** User asks for concise output 2+ times, works in a specific language, prefers a framework, uses a specific project.
 
-- `candidate` (default) → `verified` (confirmed correct) → `stale` (replaced, via `resolve` or `supersedes`) → `rejected` (wrong, via `forget`)
-- Use `resolve` when two captures conflict. Use `supersedes` on `capture` to replace an old value.
-
-## ADR for architectural decisions
-
-Use `adr` (not `capture`) for decisions with context, alternatives, and consequences.
-
-```
-adr({ "title": "Use SQLite", "context": "Need zero-setup", "decision": "SQLite + FTS5 + sqlite-vec", "alternatives": ["Postgres+pgvector", "DuckDB"], "consequences": "Single-writer, no remote access" })
-```
+**Auto-pipeline:** The background worker auto-detects tags appearing 2+ times in captures and appends them to persona. Manual `persona_update` is for explicit user preferences the worker can't detect.
 
-## Search with filters
+## Rule 5: Use CodeGraph instead of grep
 
-Use `search` (not `recall`) when you need specific filters:
+For function/class/method definitions, call `codegraph_search` — NOT grep. Auto-indexes `src/` on first use.
 
 ```
-search({ "query": "auth", "filters": { "type": "decision", "tags": ["arch"] } })
+codegraph_search({ "query": "handleCapture" })
+codegraph_callers({ "symbol_id": "<id from search>" })
+codegraph_detect_changes({ "repo_path": "/abs/path" })  // git diff → affected symbols + risk
 ```
 
-## Update and consolidate
-
-- `update` — correct a capture's content/tags. Preserves ID and created_at.
-- `consolidate` — find and merge duplicates. `consolidate({ "threshold": 0.75 })` to dry-run, add `"confirm": true` to merge.
+CodeGraph uses 6-strategy call resolution (import-map → same-module → unique-name → suffix → fuzzy) with confidence scoring. JSX components (`<FleetMap/>`) and method calls (`obj.method()`) are captured. Stdlib calls (fmt.Printf, console.log) are filtered out.
 
-## Hooks (automatic if installed)
-
-If `npx remem-mcp install-hooks` was run:
-- **SessionStart** — recent captures injected automatically
-- **PreToolUse** — past errors injected before lint/build/test
-- **PostToolUse** — failed commands auto-captured with root cause
-- **SessionEnd** — session summary auto-captured
-
-You can still call tools manually anytime.
+Use grep only for: string literals, config values, file names.
 
-## Multi-tenant
+## Other tools
 
-Pass `team_id`, `agent_id`, `user_id`, or `task_id` to isolate memory between teams/projects.
+- `forget({ "id", "confirm": true })` — only when user asks to delete. `reject: true` blocks re-capture of wrong info.
+- `handoff({ "task", "status", "progress", "next_steps" })` — at session end or before switching agents.
+- `adr({ "title", "context", "decision", "alternatives", "consequences" })` — for architectural decisions.
+- `search({ "query", "filters": { "type", "tags" } })` — when you need specific filters.
+- `resolve` — when two captures conflict. `supersedes` on `capture` replaces old values.
+- `update` — correct a capture's content/tags.
+- `consolidate({ "threshold": 0.75 })` — merge duplicate captures. `scenario_create({ "atom_ids", "summary" })` — create L2 scenario. `persona_update({ "trait", "value" })` — update L3 persona.
 
 ## Global + project memory
 
-Set `REMEM_GLOBAL_SESSION_KEY=global` in MCP config to enable cross-project memory.
-
-**How it works:**
-- `recall` and `search` automatically search both project and global memory. Project results appear first, then global.
-- `session_start` returns recent captures from both project and global sessions.
-- 3 slots are reserved for global results so cross-project knowledge isn't buried when project memory is large.
-
-**When to store global memory:**
-- Pass `session_key="global"` to `capture` for: coding conventions, tool preferences, recurring patterns, lessons that apply to any project.
-- Or pass `auto_global=true` — server auto-classifies: generic rules/learnings → global, content with file paths/line numbers → project.
-- Don't store global: project-specific bugs, file paths, one-off decisions.
-
-**Example:**
-```
-capture(content="Always run tests before committing", type="learning", auto_global=true)
-# → auto-classified as global (no file paths, has "always" signal)
-
-capture(content="Fixed bug in src/server.ts line 1418", type="task", auto_global=true)
-# → stays project (has file path)
-```
-
-## CLI commands
-
-```bash
-npx remem-mcp errors              # Error learning dashboard
-npx remem-mcp extract --limit 50  # L1 atom extraction (needs REMEM_LLM_API_KEY)
-npx remem-mcp sync-export         # Export memory for team (commit to repo)
-npx remem-mcp sync-import         # Import teammate's memory
-```
+Set `REMEM_GLOBAL_SESSION_KEY=global` to enable cross-project memory. `recall`/`search` search both. Pass `auto_global=true` to `capture` for auto-classification (generic → global, file paths → project).