remem-mcp 0.7.0 → 0.7.3

package/dist/{resolver-YIFWRNMS.js → resolver-UHU4MBQX.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-ONQHLUGM.js";
 
 // src/codegraph/resolver.ts
-function resolveCall(calleeName, callerFilePath, registry, importMap) {
+function resolveCall(calleeName, callerFilePath, registry, importMap, fuzzyEnabled = true) {
   const parts = calleeName.split(".");
   if (parts.length >= 2) {
     const prefix = parts[0];
@@ -76,9 +76,11 @@ function resolveCall(calleeName, callerFilePath, registry, importMap) {
     }
     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" };
+  if (fuzzyEnabled) {
+    const fuzzyMatch = fuzzyLookup(calleeName, registry);
+    if (fuzzyMatch) {
+      return { calleeId: fuzzyMatch.id, confidence: 0.35, strategy: "fuzzy" };
+    }
   }
   return { calleeId: null, confidence: 0, strategy: "unresolved" };
 }
@@ -89,27 +91,60 @@ function shouldSkipResolution(calleeName) {
   if (parts.length >= 2 && parts[0].length <= 1) return true;
   return false;
 }
-function resolveAllCalls(db) {
+function resolveAllCalls(db, callerIds) {
   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();
+  let symbols;
+  if (callerIds && callerIds.size > 0) {
+    const callerIdList = [...callerIds];
+    const batchLangs = /* @__PURE__ */ new Set();
+    for (let i = 0; i < callerIdList.length; i += 500) {
+      const chunk = callerIdList.slice(i, i + 500);
+      const placeholders = chunk.map(() => "?").join(",");
+      const rows = db.prepare(`SELECT DISTINCT language FROM symbols WHERE id IN (${placeholders})`).all(...chunk);
+      for (const r of rows) batchLangs.add(r.language);
+    }
+    if (batchLangs.size > 0) {
+      const langPlaceholders = [...batchLangs].map(() => "?").join(",");
+      symbols = db.prepare(`SELECT id, name, kind, file_path, module_path, language, parent_id FROM symbols WHERE language IN (${langPlaceholders})`).all(...batchLangs);
+    } else {
+      symbols = db.prepare("SELECT id, name, kind, file_path, module_path, language, parent_id FROM symbols").all();
+    }
+  } else {
+    symbols = db.prepare("SELECT id, name, kind, file_path, module_path, language, parent_id FROM symbols").all();
+  }
   const registry = new FunctionRegistry(symbols);
+  const fuzzyEnabled = symbols.length <= 500;
   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();
+  let calls;
+  if (callerIds && callerIds.size > 0) {
+    const idList = [...callerIds];
+    calls = [];
+    for (let i = 0; i < idList.length; i += 500) {
+      const chunk = idList.slice(i, i + 500);
+      const placeholders = chunk.map(() => "?").join(",");
+      const rows = db.prepare(
+        `SELECT id, caller_id, callee_name, callee_id, line, call_type FROM calls WHERE callee_id IS NULL AND caller_id IN (${placeholders})`
+      ).all(...chunk);
+      calls.push(...rows);
+    }
+  } else {
+    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 callerIdsFromCalls = [...new Set(calls.map((c) => c.caller_id))];
+  if (callerIdsFromCalls.length > 0) {
+    for (let i = 0; i < callerIdsFromCalls.length; i += 500) {
+      const chunk = callerIdsFromCalls.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) {
@@ -125,7 +160,7 @@ function resolveAllCalls(db) {
         continue;
       }
       const callerFile = callerFiles.get(call.caller_id) ?? "";
-      const result = resolveCall(call.callee_name, callerFile, registry, importMap);
+      const result = resolveCall(call.callee_name, callerFile, registry, importMap, fuzzyEnabled);
       if (result.calleeId) {
         updateStmt.run(result.calleeId, result.confidence, call.id);
         stats.resolved++;
@@ -295,4 +330,4 @@ export {
   resolveAllCalls,
   resolveCall
 };
-//# sourceMappingURL=resolver-YIFWRNMS.js.map
+//# sourceMappingURL=resolver-UHU4MBQX.js.map

package/dist/resolver-UHU4MBQX.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  fuzzyEnabled = true,\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.9, strategy: \"same-module\" };\n  }\n  // Also try just the simple name in same module\n  const sameModuleSimple = registry\n    .reverseLookup(calleeName)\n    .find((s) => registry.getModuleForFile(s.file_path) === callerModule);\n  if (sameModuleSimple) {\n    return { calleeId: sameModuleSimple.id, confidence: 0.9, 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. Skip when registry is large (O(n) per call).\n  if (fuzzyEnabled) {\n    const fuzzyMatch = fuzzyLookup(calleeName, registry);\n    if (fuzzyMatch) {\n      return { calleeId: fuzzyMatch.id, confidence: 0.35, strategy: \"fuzzy\" };\n    }\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\",\n  \"L\",\n  \"R\",\n  \"S\",\n  \"P\",\n  \"C\",\n  \"D\",\n  \"E\",\n  \"F\",\n  \"M\",\n  \"N\",\n  \"V\",\n  \"X\",\n  \"Y\",\n  \"String\",\n  \"Array\",\n  \"Object\",\n  \"Number\",\n  \"Boolean\",\n  \"Map\",\n  \"Set\",\n  \"Date\",\n  \"Error\",\n  \"RegExp\",\n  \"Promise\",\n  \"Symbol\",\n  \"Buffer\",\n  \"Vec\",\n  \"Box\",\n  \"Option\",\n  \"Result\",\n  \"Some\",\n  \"None\",\n  \"Ok\",\n  \"Err\",\n  \"List\",\n  \"Dict\",\n  \"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 unresolved calls in the database.\n * Called after indexDirectory() completes.\n *\n * If callerIds is provided, only resolve calls whose caller_id is in the set\n * (i.e., calls from the just-indexed batch). This avoids re-resolving 25K+\n * historical calls on every index run — the O(n²) fuzzy strategy would hang.\n * If callerIds is omitted, resolve all unresolved calls (legacy behavior).\n */\nexport function resolveAllCalls(\n  db: Database,\n  callerIds?: Set<string>,\n): {\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 symbols into FunctionRegistry.\n  // When resolving a batch (callerIds provided), only load symbols matching\n  // the batch's languages — this avoids scanning 4800+ symbols from other\n  // repos/languages during fuzzy lookup (O(n) per call).\n  let symbols: SymbolRow[];\n  if (callerIds && callerIds.size > 0) {\n    // Determine languages of the caller symbols\n    const callerIdList = [...callerIds];\n    const batchLangs = new Set<string>();\n    for (let i = 0; i < callerIdList.length; i += 500) {\n      const chunk = callerIdList.slice(i, i + 500);\n      const placeholders = chunk.map(() => \"?\").join(\",\");\n      const rows = db\n        .prepare(`SELECT DISTINCT language FROM symbols WHERE id IN (${placeholders})`)\n        .all(...chunk) as { language: string }[];\n      for (const r of rows) batchLangs.add(r.language);\n    }\n    if (batchLangs.size > 0) {\n      const langPlaceholders = [...batchLangs].map(() => \"?\").join(\",\");\n      symbols = db\n        .prepare(`SELECT id, name, kind, file_path, module_path, language, parent_id FROM symbols WHERE language IN (${langPlaceholders})`)\n        .all(...batchLangs) as SymbolRow[];\n    } else {\n      symbols = db\n        .prepare(\"SELECT id, name, kind, file_path, module_path, language, parent_id FROM symbols\")\n        .all() as SymbolRow[];\n    }\n  } else {\n    symbols = db\n      .prepare(\"SELECT id, name, kind, file_path, module_path, language, parent_id FROM symbols\")\n      .all() as SymbolRow[];\n  }\n  const registry = new FunctionRegistry(symbols);\n  const fuzzyEnabled = symbols.length <= 500;\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 unresolved calls — skip short/builtin names to save resolution time.\n  // If callerIds is provided, only resolve calls from the just-indexed batch\n  // (avoids re-resolving 25K+ historical calls — fuzzy is O(n²)).\n  let calls: CallRow[];\n  if (callerIds && callerIds.size > 0) {\n    const idList = [...callerIds];\n    calls = [];\n    // Batch in chunks of 500 to avoid SQLite param limit\n    for (let i = 0; i < idList.length; i += 500) {\n      const chunk = idList.slice(i, i + 500);\n      const placeholders = chunk.map(() => \"?\").join(\",\");\n      const rows = db\n        .prepare(\n          `SELECT id, caller_id, callee_name, callee_id, line, call_type FROM calls WHERE callee_id IS NULL AND caller_id IN (${placeholders})`,\n        )\n        .all(...chunk) as CallRow[];\n      calls.push(...rows);\n    }\n  } else {\n    calls = db\n      .prepare(\n        \"SELECT id, caller_id, callee_name, callee_id, line, call_type FROM calls WHERE callee_id IS NULL\",\n      )\n      .all() as CallRow[];\n  }\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 callerIdsFromCalls = [...new Set(calls.map((c) => c.caller_id))];\n  if (callerIdsFromCalls.length > 0) {\n    // Batch in chunks of 500 to avoid SQLite param limit\n    for (let i = 0; i < callerIdsFromCalls.length; i += 500) {\n      const chunk = callerIdsFromCalls.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(\"UPDATE calls SET callee_id = ?, confidence = ? WHERE id = ?\");\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, fuzzyEnabled);\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

@@ -6,7 +6,7 @@ import {
   ingestDirectory,
   ingestFile,
   searchWiki
-} from "./chunk-TGLOMFIE.js";
+} from "./chunk-ITMR6THY.js";
 import {
   SUPPORTED_LANGUAGES,
   detectLanguage,
@@ -17,11 +17,11 @@ import {
   indexFile,
   listSymbols,
   searchSymbols
-} from "./chunk-ZXI67YIV.js";
+} from "./chunk-YU7WBJU5.js";
 import {
   LocalEmbedder,
   SQLiteBackend
-} from "./chunk-OYUNKUZK.js";
+} from "./chunk-4WCDAEPP.js";
 import "./chunk-XJGDYQ34.js";
 import "./chunk-ONQHLUGM.js";
 export {

package/dist/{server-SUKPVQWL.js → server-5PWQTRGZ.js}

@@ -2,7 +2,7 @@ import {
   LocalEmbedder,
   SQLiteBackend,
   init_local
-} from "./chunk-OYUNKUZK.js";
+} from "./chunk-4WCDAEPP.js";
 import {
   generateId,
   init_ulid
@@ -514,4 +514,4 @@ export {
   loadProxyConfig,
   startProxyServer
 };
-//# sourceMappingURL=server-SUKPVQWL.js.map
+//# sourceMappingURL=server-5PWQTRGZ.js.map

package/dist/storage/schema.sql

@@ -1,5 +1,5 @@
 -- Schema for remem-mcp
--- Version: 8
+-- Version: 13
 --
 -- This file runs on the first start. It creates all tables, triggers, and indexes.
 -- It uses CREATE TABLE IF NOT EXISTS and CREATE INDEX IF NOT EXISTS.
@@ -75,7 +75,13 @@ CREATE TABLE IF NOT EXISTS captures (
   retrieved_count   INTEGER NOT NULL DEFAULT 0,
   heeded_count      INTEGER NOT NULL DEFAULT 0,
   recurrence_count  INTEGER NOT NULL DEFAULT 0,
-  last_outcome      TEXT
+  last_outcome      TEXT,
+  -- v10: Authority tier + salience for decay/forget sweep
+  tier              TEXT NOT NULL DEFAULT 'episodic',  -- rule, decision, episodic, test
+  salience          REAL NOT NULL DEFAULT 1.0,          -- decay score, updated by forget sweep
+  -- v12: TTL for time-sensitive captures + feedback-derived salience floor
+  expires_at        INTEGER,                            -- timestamp; forgetSweep hard-deletes past this
+  feedback_salience REAL NOT NULL DEFAULT 1.0           -- multiplier from feedback signals (0.1–2.0)
 );
 
 -- L0 messages: role-based conversation messages linked to a capture.
@@ -114,6 +120,61 @@ CREATE TABLE IF NOT EXISTS scenarios (
   user_id     TEXT
 );
 
+-- v10: Entity index for entity-assisted recall.
+-- Stores <=10 extracted nouns per capture for lexical RRF matching.
+CREATE TABLE IF NOT EXISTS entities (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  capture_id  TEXT NOT NULL REFERENCES captures(id) ON DELETE CASCADE,
+  entity      TEXT NOT NULL,
+  created_at  INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_entities_capture ON entities (capture_id);
+CREATE INDEX IF NOT EXISTS idx_entities_entity ON entities (entity);
+
+-- v11: Memory-to-memory links for link-neighbor RRF expansion.
+-- Auto-linked on capture via shared tags/entities/session-proximity.
+-- Manually linked via link_captures MCP tool.
+CREATE TABLE IF NOT EXISTS memory_links (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  from_id     TEXT NOT NULL REFERENCES captures(id) ON DELETE CASCADE,
+  to_id       TEXT NOT NULL REFERENCES captures(id) ON DELETE CASCADE,
+  link_type   TEXT NOT NULL DEFAULT 'related',  -- shared-tag, shared-entity, session-proximity, related, cause-effect, supersedes, prerequisite
+  auto        INTEGER NOT NULL DEFAULT 0,       -- 1 = auto-generated, 0 = manual
+  weight      REAL NOT NULL DEFAULT 1.0,         -- v13: Hebbian weight, strengthened on co-retrieval
+  created_at  INTEGER NOT NULL,
+  UNIQUE (from_id, to_id, link_type)
+);
+CREATE INDEX IF NOT EXISTS idx_memory_links_from ON memory_links (from_id);
+CREATE INDEX IF NOT EXISTS idx_memory_links_to ON memory_links (to_id);
+CREATE INDEX IF NOT EXISTS idx_memory_links_type ON memory_links (link_type);
+
+-- v12: Capture feedback signals (helpful/not_helpful/stale/wrong).
+-- Adjusts salience score. Creates feedback flywheel.
+CREATE TABLE IF NOT EXISTS capture_feedback (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  capture_id  TEXT NOT NULL REFERENCES captures(id) ON DELETE CASCADE,
+  signal      TEXT NOT NULL,                    -- helpful, not_helpful, stale, wrong
+  reason      TEXT,
+  agent_id    TEXT,
+  created_at  INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_feedback_capture ON capture_feedback (capture_id);
+CREATE INDEX IF NOT EXISTS idx_feedback_signal ON capture_feedback (signal);
+
+-- v12: Mutation log — every storage mutation (put/delete/reject/supersede/feedback/link/forget).
+-- Distinct from audit_log (which logs MCP tool calls).
+CREATE TABLE IF NOT EXISTS mutation_log (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  action      TEXT NOT NULL,                    -- put, delete, reject, supersede, feedback, link, forget, correct, confirm
+  capture_id  TEXT,
+  details     TEXT,                             -- JSON blob with action-specific metadata
+  agent_id    TEXT,
+  created_at  INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_mutation_action ON mutation_log (action);
+CREATE INDEX IF NOT EXISTS idx_mutation_capture ON mutation_log (capture_id);
+CREATE INDEX IF NOT EXISTS idx_mutation_created ON mutation_log (created_at);
+
 -- L3: Persona (long-term user profile, one per team/agent/user)
 CREATE TABLE IF NOT EXISTS persona (
   team_id    TEXT NOT NULL,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "remem-mcp",
   "mcpName": "io.github.tinhien11/remem-mcp",
-  "version": "0.7.0",
+  "version": "0.7.3",
   "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",

package/scripts/verify-codegraph-stats.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+/**
+ * Verify codegraph_stats tool exists in the built server and returns correct stats.
+ */
+import { spawn } from "node:child_process";
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const distPath = join(process.cwd(), "dist", "index.js");
+
+// Create a small test repo with some symbols
+const repoDir = mkdtempSync(join(tmpdir(), "cg-stats-"));
+const srcDir = join(repoDir, "src");
+mkdirSync(srcDir, { recursive: true });
+writeFileSync(join(srcDir, "foo.ts"),
+  `export function alpha() { return 1; }\n` +
+  `export class Beta { gamma() {} }\n`);
+writeFileSync(join(srcDir, "bar.ts"),
+  `export function delta() { alpha(); }\n`);
+
+const proc = spawn("node", [distPath, "--stdio"], {
+  stdio: ["pipe", "pipe", "pipe"],
+  env: { ...process.env, REMEM_DB_PATH: join(repoDir, "test.db") },
+});
+
+let buf = "";
+proc.stdout.on("data", (d) => { buf += d.toString(); });
+proc.stderr.on("data", () => {});
+
+function send(msg) { proc.stdin.write(JSON.stringify(msg) + "\n"); }
+
+function waitForId(id, timeoutMs = 15000) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const iv = setInterval(() => {
+      for (const line of buf.split("\n")) {
+        try {
+          const obj = JSON.parse(line);
+          if (obj.id === id) { clearInterval(iv); resolve(obj); return; }
+        } catch {}
+      }
+      if (Date.now() - start > timeoutMs) { clearInterval(iv); reject(new Error(`timeout id=${id}`)); }
+    }, 50);
+  });
+}
+
+// 1. Check codegraph_stats is in the tools list
+send({ jsonrpc: "2.0", id: 1, method: "initialize",
+  params: { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "test", version: "1.0" } } });
+await waitForId(1);
+send({ jsonrpc: "2.0", method: "notifications/initialized" });
+
+send({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} });
+const toolsResp = await waitForId(2);
+const toolNames = (toolsResp.result?.tools || []).map(t => t.name);
+const hasStats = toolNames.includes("codegraph_stats");
+
+if (!hasStats) {
+  console.error("FAIL: codegraph_stats not in tools list");
+  console.error("Available tools:", toolNames.join(", "));
+  proc.kill();
+  try { rmSync(repoDir, { recursive: true }); } catch {}
+  process.exit(1);
+}
+console.log("OK: codegraph_stats is in tools list");
+
+// 2. Index the test repo first
+send({ jsonrpc: "2.0", id: 3, method: "tools/call",
+  params: { name: "codegraph_index", arguments: { path: srcDir, repo_path: srcDir } } });
+await waitForId(3, 30000);
+
+// 3. Call codegraph_stats and verify it returns numbers
+send({ jsonrpc: "2.0", id: 4, method: "tools/call",
+  params: { name: "codegraph_stats", arguments: { repo_path: srcDir } } });
+
+let failures = 0;
+try {
+  const resp = await waitForId(4, 15000);
+  const text = resp.result?.content?.[0]?.text || "";
+
+  if (text.includes("symbols") && text.includes("calls") && text.includes("files")) {
+    console.log("OK: codegraph_stats returns symbols, calls, files");
+  } else {
+    console.error(`FAIL: codegraph_stats output missing expected fields: ${text.slice(0, 300)}`);
+    failures++;
+  }
+
+  const files = Number((text.match(/files:\s*(\d+)/) || [])[1] || 0);
+  const symbols = Number((text.match(/symbols:\s*(\d+)/) || [])[1] || 0);
+  const calls = Number((text.match(/calls:\s*(\d+)/) || [])[1] || 0);
+  if (files >= 2 && symbols >= 3 && calls >= 1) {
+    console.log(`OK: codegraph_stats is repo-scoped (files=${files}, symbols=${symbols}, calls=${calls})`);
+  } else {
+    console.error(`FAIL: codegraph_stats stats look wrong: ${text.slice(0, 300)}`);
+    failures++;
+  }
+
+  // Should not be an error
+  if (resp.result?.isError) {
+    console.error("FAIL: codegraph_stats returned an error");
+    failures++;
+  } else {
+    console.log("OK: codegraph_stats returned successfully (no error)");
+  }
+
+  console.log(`\nStats output: ${text.slice(0, 500)}`);
+} catch (err) {
+  console.error(`FAIL: codegraph_stats call failed: ${err.message}`);
+  failures++;
+}
+
+proc.kill();
+try { rmSync(repoDir, { recursive: true }); } catch {}
+
+if (failures === 0) {
+  console.log("codegraph_stats verification passed");
+  process.exit(0);
+} else {
+  console.error(`${failures} codegraph_stats check(s) failed`);
+  process.exit(1);
+}

package/skills/remem-mcp/SKILL.md

@@ -7,8 +7,8 @@ You have a long-term memory server via MCP. Use the tools automatically — do n
 
 ## Tools
 
-**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)
+**Core:** `recall` `capture` `search` `feedback` `forget` `resolve` `handoff` `adr` `update` `consolidate` `scenario_create` `persona_update`
+**CodeGraph:** `codegraph_index` (run once per session; idempotent) `codegraph_search` `codegraph_callers` `codegraph_callees` `codegraph_impact` `codegraph_list` `codegraph_stats` `codegraph_detect_changes` (git diff → affected symbols)
 **Wiki:** `wiki_ingest` `wiki_search` `wiki_get` `wiki_outdated`
 **Canvas (F1):** `canvas_get` (Mermaid graph for session) `ref_read` (drill down to raw tool output by node_id)
 **Skills (F3):** `skill_create` (manual skill with auto-versioning) `skill_archive` (force always-inject) `skill_get` `skill_list` `skill_search`
@@ -21,6 +21,14 @@ Hooks auto-inject BM25-only memory (shallow). **MUST call `recall()` at the star
 recall({ "query": "<user's question or task>", "mode": "hybrid", "limit": 5 })
 ```
 
+After using recall results, call `feedback` for the most useful result. This creates a flywheel — useful memories rise, unhelpful ones fade.
+
+```
+feedback({ "capture_id": "<id from recall result>", "signal": "helpful" })
+```
+
+**Signals:** `helpful` (answered question) · `not_helpful` (irrelevant) · `stale` (outdated) · `wrong` (incorrect)
+
 ## Rule 2: Capture after non-trivial work
 
 Call `capture` automatically after completing work. Don't ask. Include `atoms` — short distilled facts that recall returns instead of raw content (90% fewer tokens).
@@ -69,7 +77,7 @@ persona_update({ "trait": "output_style", "value": "concise" })
 
 ## Rule 5: Use CodeGraph instead of grep
 
-For function/class/method definitions, call `codegraph_search` — NOT grep. Auto-indexes `src/` on first use.
+Before code navigation on a non-trivial task, call `codegraph_index({ path: "src" })`. It is idempotent and incrementally updates changed files. Then use `codegraph_search` — NOT grep — for function/class/method definitions.
 
 ```
 codegraph_search({ "query": "handleCapture" })