claude-memory-layer 1.0.33 → 1.0.35

package/dist/mcp/index.js

@@ -13999,6 +13999,16 @@ var SQLiteEventStore = class {
   getDatabase() {
     return this.db;
   }
+  hasTableColumn(tableName, columnName) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(tableName))
+      return false;
+    try {
+      const rows = sqliteAll(this.db, `PRAGMA table_info("${tableName}")`, []);
+      return rows.some((row) => row.name === columnName);
+    } catch {
+      return false;
+    }
+  }
   async recordRetrievalTrace(input) {
     await this.initialize();
     const traceId = randomUUID5();
@@ -14064,17 +14074,18 @@ var SQLiteEventStore = class {
   async getRetrievalTraceStats() {
     await this.initialize();
     try {
+      const rewrittenQueryRewriteKindSql = this.hasTableColumn("retrieval_traces", "query_rewrite_kind") ? REWRITTEN_QUERY_REWRITE_KIND_SQL : "0";
       const row = sqliteGet(
         this.db,
         `SELECT
           COUNT(*) as total_queries,
           AVG(candidate_count) as avg_candidate_count,
           AVG(selected_count) as avg_selected_count,
-          SUM(CASE WHEN ${REWRITTEN_QUERY_REWRITE_KIND_SQL} THEN 1 ELSE 0 END) as rewritten_queries,
-          SUM(CASE WHEN ${REWRITTEN_QUERY_REWRITE_KIND_SQL} AND selected_count > 0 THEN 1 ELSE 0 END) as rewritten_queries_with_selection,
-          SUM(CASE WHEN NOT (${REWRITTEN_QUERY_REWRITE_KIND_SQL}) AND selected_count > 0 THEN 1 ELSE 0 END) as raw_queries_with_selection,
-          AVG(CASE WHEN ${REWRITTEN_QUERY_REWRITE_KIND_SQL} THEN selected_count END) as avg_selected_count_for_rewritten_queries,
-          AVG(CASE WHEN NOT (${REWRITTEN_QUERY_REWRITE_KIND_SQL}) THEN selected_count END) as avg_selected_count_for_raw_queries,
+          SUM(CASE WHEN ${rewrittenQueryRewriteKindSql} THEN 1 ELSE 0 END) as rewritten_queries,
+          SUM(CASE WHEN ${rewrittenQueryRewriteKindSql} AND selected_count > 0 THEN 1 ELSE 0 END) as rewritten_queries_with_selection,
+          SUM(CASE WHEN NOT (${rewrittenQueryRewriteKindSql}) AND selected_count > 0 THEN 1 ELSE 0 END) as raw_queries_with_selection,
+          AVG(CASE WHEN ${rewrittenQueryRewriteKindSql} THEN selected_count END) as avg_selected_count_for_rewritten_queries,
+          AVG(CASE WHEN NOT (${rewrittenQueryRewriteKindSql}) THEN selected_count END) as avg_selected_count_for_raw_queries,
           CASE
             WHEN SUM(candidate_count) > 0 THEN (SUM(selected_count) * 1.0 / SUM(candidate_count))
             ELSE 0
@@ -19859,7 +19870,8 @@ var HermesSessionHistoryImporter = class {
           source: "hermes",
           hermesSource: session.source,
           sourceSessionId: session.id,
-          sourceSessionHash: hashLabel(session.id)
+          sourceSessionHash: hashLabel(session.id),
+          projectPath: effectiveProjectPath
         }
       );
       if (appendResult.success && appendResult.isDuplicate) {
@@ -19896,7 +19908,8 @@ var HermesSessionHistoryImporter = class {
             source: "hermes",
             hermesSource: session.source,
             sourceSessionId: session.id,
-            sourceSessionHash: hashLabel(session.id)
+            sourceSessionHash: hashLabel(session.id),
+            projectPath: effectiveProjectPath
           }
         );
         if (appendResult.success && appendResult.isDuplicate) {
@@ -20445,7 +20458,7 @@ async function handleToolCall(name, args) {
       case "mem-details":
         return await handleMemDetails(memoryService, args);
       case "mem-stats":
-        return await handleMemStats(memoryService);
+        return await handleMemStats(memoryService, args);
       case "mem-context-pack":
         return await handleMemContextPack(memoryService, args);
       case "mem-import-latest":
@@ -20481,19 +20494,19 @@ async function handleExternalMarketContext(args) {
 async function handleMemSearch(memoryService, args) {
   const query = args.query;
   const topK = Math.min(args.topK || 5, 20);
-  const result = await memoryService.retrieveMemories(query, {
-    topK,
-    sessionId: args.sessionId,
-    recordTrace: false
-  });
+  const sessionId = args.sessionId;
+  const search = await retrieveMcpMemories(memoryService, query, { topK, sessionId });
   const lines = [
     "## Memory Search Results",
     "",
-    `Found ${result.memories.length} relevant memories:`,
+    `Found ${search.memories.length} relevant memories:`,
     ""
   ];
-  for (let i = 0; i < result.memories.length; i++) {
-    const m = result.memories[i];
+  if (search.warning) {
+    lines.push(search.warning, "");
+  }
+  for (let i = 0; i < search.memories.length; i++) {
+    const m = search.memories[i];
     const citationId = generateCitationId(m.event.id);
     const date = m.event.timestamp.toISOString().split("T")[0];
     const preview = m.event.content.slice(0, 100) + (m.event.content.length > 100 ? "..." : "");
@@ -20508,6 +20521,52 @@ async function handleMemSearch(memoryService, args) {
     content: [{ type: "text", text: lines.join("\n") }]
   };
 }
+var SEMANTIC_VECTOR_FALLBACK_WARNING = "Warning: semantic/vector retrieval unavailable; used keyword fallback.";
+var SEMANTIC_VECTOR_FALLBACK_FAILED_WARNING = "Warning: semantic/vector retrieval unavailable; keyword fallback failed.";
+async function retrieveMcpMemories(memoryService, query, options) {
+  try {
+    const result = await memoryService.retrieveMemories(query, {
+      topK: options.topK,
+      sessionId: options.sessionId,
+      recordTrace: false
+    });
+    return { memories: result.memories };
+  } catch (error) {
+    if (!isVectorSchemaMismatchError(error)) {
+      throw error;
+    }
+    try {
+      const memories = options.sessionId ? rankSessionKeywordMatches(
+        query,
+        await memoryService.getSessionHistory(options.sessionId),
+        options.topK
+      ) : await memoryService.keywordSearch(query, { topK: options.topK });
+      return { memories, warning: SEMANTIC_VECTOR_FALLBACK_WARNING };
+    } catch {
+      return { memories: [], warning: SEMANTIC_VECTOR_FALLBACK_FAILED_WARNING };
+    }
+  }
+}
+function isVectorSchemaMismatchError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /no vector column/i.test(message) || /query vector dimension/i.test(message) || /vector[^\n]{0,80}dimension/i.test(message) || /dimension[^\n]{0,80}vector/i.test(message) || /lancedb[^\n]{0,120}schema/i.test(message);
+}
+function rankSessionKeywordMatches(query, events, topK) {
+  const queryTokens = tokenizeKeywordQuery(query);
+  if (queryTokens.length === 0)
+    return [];
+  return events.map((event) => ({ event, score: scoreKeywordMatch(event.content, queryTokens) })).filter((match) => match.score > 0).sort((a, b) => b.score - a.score || b.event.timestamp.getTime() - a.event.timestamp.getTime()).slice(0, topK);
+}
+function tokenizeKeywordQuery(value) {
+  return Array.from(new Set(
+    value.toLowerCase().split(/[^a-z0-9가-힣_]+/).map((token) => token.trim()).filter((token) => token.length > 1)
+  ));
+}
+function scoreKeywordMatch(content, queryTokens) {
+  const haystack = content.toLowerCase();
+  const hits = queryTokens.filter((token) => haystack.includes(token)).length;
+  return hits / queryTokens.length;
+}
 async function handleMemTimeline(memoryService, args) {
   const ids = args.ids;
   const windowSize = args.windowSize || 3;
@@ -20599,10 +20658,8 @@ async function handleMemContextPack(memoryService, args) {
     sessionsDir: optionalString(args.sessionsDir),
     stateDb: optionalString(args.stateDb)
   }) : void 0;
-  const [searchResult, recentEvents] = await Promise.all([
-    memoryService.retrieveMemories(query, { topK: retrievalTopK, sessionId, recordTrace: false }),
-    memoryService.getRecentEvents(recentLimit)
-  ]);
+  const search = await retrieveMcpMemories(memoryService, query, { topK: retrievalTopK, sessionId });
+  const recentEvents = await memoryService.getRecentEvents(recentLimit);
   const timelineEvents = selectContextPackTimelineEvents(
     recentEvents,
     projectPath,
@@ -20610,7 +20667,7 @@ async function handleMemContextPack(memoryService, args) {
   );
   const sessions = summarizeSessions(timelineEvents, sessionLimit);
   const recentSessionIds = new Set(sessions.map((session) => session.sessionId));
-  const relevantMemories = selectContextPackMemories(searchResult.memories, {
+  const relevantMemories = selectContextPackMemories(search.memories, {
     genericContinuationQuery,
     topK,
     recentSessionIds,
@@ -20631,6 +20688,9 @@ async function handleMemContextPack(memoryService, args) {
       `- Refresh limits: sessions=${freshnessRun.sessionLimit} messages=${freshnessRun.messageLimit} force=${freshnessRun.force ? "yes" : "no"} embeddings=${freshnessRun.processEmbeddings ? `processed ${freshnessRun.embeddingsProcessed ?? 0}` : "skipped"}`
     );
   }
+  if (search.warning) {
+    lines.push(`- ${search.warning}`);
+  }
   if (genericContinuationQuery) {
     lines.push("- Generic continuation query: recent project timeline prioritized.");
   }
@@ -20870,7 +20930,7 @@ function shouldShowContextPackTimelineEvent(event, projectPath, genericContinuat
     return false;
   if (event.eventType === "tool_observation")
     return false;
-  if (mentionsDifferentWorkspaceProject(content, projectPath))
+  if (eventBelongsToDifferentProject(event, projectPath))
     return false;
   if (genericContinuationQuery && isGenericContinuationQuery(content))
     return false;
@@ -20882,7 +20942,7 @@ function shouldShowContextPackMemory(memory, options) {
     return false;
   if (memory.event.eventType === "tool_observation")
     return false;
-  if (mentionsDifferentWorkspaceProject(content, options.projectPath))
+  if (eventBelongsToDifferentProject(memory.event, options.projectPath))
     return false;
   if (!options.genericContinuationQuery)
     return true;
@@ -20894,6 +20954,54 @@ function shouldShowContextPackMemory(memory, options) {
     return memory.score >= GENERIC_RECENT_MEMORY_MIN_SCORE;
   return memory.score >= GENERIC_STALE_MEMORY_MIN_SCORE;
 }
+function eventBelongsToDifferentProject(event, projectPath) {
+  if (!projectPath)
+    return false;
+  const metadata = event.metadata || {};
+  const metadataProjectRefs = metadataProjectReferenceValues(metadata);
+  if (metadataProjectRefs.length > 0) {
+    return !metadataProjectRefs.some((value) => projectReferenceMatches(value, projectPath));
+  }
+  if (isUnscopedImportedHistory(metadata))
+    return true;
+  return mentionsDifferentWorkspaceProject(event.content || "", projectPath);
+}
+function isUnscopedImportedHistory(metadata) {
+  return typeof metadata.importedFrom === "string" || typeof metadata.sourceSessionId === "string" || typeof metadata.sourceSessionHash === "string" || typeof metadata.transcriptPath === "string";
+}
+var PROJECT_METADATA_KEYS = /* @__PURE__ */ new Set([
+  "projectPath",
+  "sourceProjectPath",
+  "workspacePath",
+  "sourceWorkspacePath",
+  "cwd",
+  "sourceCwd",
+  "currentWorkingDirectory",
+  "projectRoot",
+  "repoPath",
+  "repositoryPath"
+]);
+function metadataProjectReferenceValues(metadata) {
+  const values = [];
+  for (const [key, value] of Object.entries(metadata)) {
+    if (!PROJECT_METADATA_KEYS.has(key))
+      continue;
+    if (typeof value === "string" && value.trim().length > 0) {
+      values.push(value.trim());
+    }
+  }
+  return values;
+}
+function projectReferenceMatches(reference, projectPath) {
+  const normalizedReference = normalizeProjectReference(reference);
+  const normalizedProjectPath = normalizeProjectReference(projectPath);
+  if (normalizedReference === normalizedProjectPath)
+    return true;
+  return normalizedReference.startsWith(`${normalizedProjectPath}/`);
+}
+function normalizeProjectReference(value) {
+  return value.trim().replace(/\\/g, "/").replace(/\/+$/g, "").toLowerCase();
+}
 function mentionsDifferentWorkspaceProject(content, projectPath) {
   const currentProject = basenameOfPath(projectPath);
   if (!currentProject)
@@ -21124,9 +21232,11 @@ function formatMetadataValue(value) {
 function textResult(text) {
   return { content: [{ type: "text", text }] };
 }
-async function handleMemStats(memoryService) {
+async function handleMemStats(memoryService, args) {
   const stats = await memoryService.getStats();
   const recentEvents = await memoryService.getRecentEvents(1e4);
+  const outboxStats = await readMcpOutboxStats(memoryService);
+  const storageView = buildMcpStatsStorageView(optionalString(args.projectPath));
   const uniqueSessions = new Set(recentEvents.map((e) => e.sessionId));
   const lines = [
     "## Memory Statistics",
@@ -21135,6 +21245,19 @@ async function handleMemStats(memoryService) {
     `- **Total Vectors**: ${stats.vectorCount}`,
     `- **Sessions**: ${uniqueSessions.size}`,
     "",
+    "### Storage View / Freshness",
+    "",
+    `- Storage View: ${storageView.storageView}`,
+    `- Storage Path Label: ${storageView.storagePathLabel}`,
+    `- Embedder Model: ${storageView.embedderModel}`,
+    `- Vector Table Dimension: ${storageView.vectorTableDimension}`,
+    `- Pending Embeddings: ${outboxStats.embedding.pending}`,
+    `- Embedding Outbox: pending=${outboxStats.embedding.pending}, processing=${outboxStats.embedding.processing}, failed=${outboxStats.embedding.failed}, total=${outboxStats.embedding.total}`,
+    `- Vector Outbox Pending: ${outboxStats.vector.pending}`,
+    `- Vector Outbox: pending=${outboxStats.vector.pending}, processing=${outboxStats.vector.processing}, failed=${outboxStats.vector.failed}, total=${outboxStats.vector.total}`,
+    "- MCP/CLI parity: CLI `stats -p <project>` and MCP `mem-stats(projectPath=...)` should use this same storage view label.",
+    "- Restart guidance: if CLI and MCP counts differ for this storage view after import/build, restart the long-lived MCP/Hermes gateway process.",
+    "",
     "### Events by Type",
     ""
   ];
@@ -21149,6 +21272,35 @@ async function handleMemStats(memoryService) {
     content: [{ type: "text", text: lines.join("\n") }]
   };
 }
+async function readMcpOutboxStats(memoryService) {
+  try {
+    return await memoryService.getOutboxStats();
+  } catch {
+    return {
+      embedding: { pending: 0, processing: 0, failed: 0, total: 0 },
+      vector: { pending: 0, processing: 0, failed: 0, total: 0 }
+    };
+  }
+}
+function buildMcpStatsStorageView(projectPath) {
+  const embedderModel = process.env.CLAUDE_MEMORY_EMBEDDING_MODEL || DEFAULT_EMBEDDING_MODEL;
+  const requestedProjectPath = projectPath?.trim();
+  if (requestedProjectPath) {
+    const projectHash = hashProjectPath(requestedProjectPath);
+    return {
+      storageView: `project:${projectHash}`,
+      storagePathLabel: `~/.claude-code/memory/projects/${projectHash}`,
+      embedderModel,
+      vectorTableDimension: "unknown (not recorded in current vector metadata)"
+    };
+  }
+  return {
+    storageView: "global",
+    storagePathLabel: "~/.claude-code/memory",
+    embedderModel,
+    vectorTableDimension: "unknown (not recorded in current vector metadata)"
+  };
+}
 
 // src/extensions/mcp/index.ts
 var server = new Server(