claude-memory-layer 1.0.14 → 1.0.16

package/src/core/sqlite-event-store.ts

@@ -1446,28 +1446,33 @@ export class SQLiteEventStore {
   }>> {
     await this.initialize();
 
-    const rows = sqliteAll<Record<string, unknown>>(
-      this.db,
-      `SELECT * FROM retrieval_traces ORDER BY created_at DESC LIMIT ?`,
-      [limit]
-    );
+    try {
+      const rows = sqliteAll<Record<string, unknown>>(
+        this.db,
+        `SELECT * FROM retrieval_traces ORDER BY created_at DESC LIMIT ?`,
+        [limit]
+      );
 
-    return rows.map((row) => ({
-      traceId: row.trace_id as string,
-      sessionId: (row.session_id as string) || undefined,
-      projectHash: (row.project_hash as string) || undefined,
-      queryText: row.query_text as string,
-      strategy: (row.strategy as string) || undefined,
-      candidateEventIds: row.candidate_event_ids ? JSON.parse(row.candidate_event_ids as string) : [],
-      selectedEventIds: row.selected_event_ids ? JSON.parse(row.selected_event_ids as string) : [],
-      candidateDetails: row.candidate_details_json ? JSON.parse(row.candidate_details_json as string) : [],
-      selectedDetails: row.selected_details_json ? JSON.parse(row.selected_details_json as string) : [],
-      candidateCount: Number(row.candidate_count || 0),
-      selectedCount: Number(row.selected_count || 0),
-      confidence: (row.confidence as string) || undefined,
-      fallbackTrace: row.fallback_trace ? JSON.parse(row.fallback_trace as string) : [],
-      createdAt: toDateFromSQLite(row.created_at),
-    }));
+      return rows.map((row) => ({
+        traceId: row.trace_id as string,
+        sessionId: (row.session_id as string) || undefined,
+        projectHash: (row.project_hash as string) || undefined,
+        queryText: row.query_text as string,
+        strategy: (row.strategy as string) || undefined,
+        candidateEventIds: row.candidate_event_ids ? JSON.parse(row.candidate_event_ids as string) : [],
+        selectedEventIds: row.selected_event_ids ? JSON.parse(row.selected_event_ids as string) : [],
+        candidateDetails: row.candidate_details_json ? JSON.parse(row.candidate_details_json as string) : [],
+        selectedDetails: row.selected_details_json ? JSON.parse(row.selected_details_json as string) : [],
+        candidateCount: Number(row.candidate_count || 0),
+        selectedCount: Number(row.selected_count || 0),
+        confidence: (row.confidence as string) || undefined,
+        fallbackTrace: row.fallback_trace ? JSON.parse(row.fallback_trace as string) : [],
+        createdAt: toDateFromSQLite(row.created_at),
+      }));
+    } catch (err: any) {
+      if (err?.message?.includes('no such table')) return [];
+      throw err;
+    }
   }
 
   async getRetrievalTraceStats(): Promise<{
@@ -1478,26 +1483,33 @@ export class SQLiteEventStore {
   }> {
     await this.initialize();
 
-    const row = sqliteGet<Record<string, unknown>>(
-      this.db,
-      `SELECT
-        COUNT(*) as total_queries,
-        AVG(candidate_count) as avg_candidate_count,
-        AVG(selected_count) as avg_selected_count,
-        CASE
-          WHEN SUM(candidate_count) > 0 THEN (SUM(selected_count) * 1.0 / SUM(candidate_count))
-          ELSE 0
-        END as selection_rate
-       FROM retrieval_traces`,
-      []
-    );
+    try {
+      const row = sqliteGet<Record<string, unknown>>(
+        this.db,
+        `SELECT
+          COUNT(*) as total_queries,
+          AVG(candidate_count) as avg_candidate_count,
+          AVG(selected_count) as avg_selected_count,
+          CASE
+            WHEN SUM(candidate_count) > 0 THEN (SUM(selected_count) * 1.0 / SUM(candidate_count))
+            ELSE 0
+          END as selection_rate
+         FROM retrieval_traces`,
+        []
+      );
 
-    return {
-      totalQueries: Number(row?.total_queries || 0),
-      avgCandidateCount: Number(row?.avg_candidate_count || 0),
-      avgSelectedCount: Number(row?.avg_selected_count || 0),
-      selectionRate: Number(row?.selection_rate || 0),
-    };
+      return {
+        totalQueries: Number(row?.total_queries || 0),
+        avgCandidateCount: Number(row?.avg_candidate_count || 0),
+        avgSelectedCount: Number(row?.avg_selected_count || 0),
+        selectionRate: Number(row?.selection_rate || 0),
+      };
+    } catch (err: any) {
+      if (err?.message?.includes('no such table')) {
+        return { totalQueries: 0, avgCandidateCount: 0, avgSelectedCount: 0, selectionRate: 0 };
+      }
+      throw err;
+    }
   }
 
   /**

package/src/hooks/user-prompt-submit.ts

@@ -17,7 +17,9 @@ import type { UserPromptSubmitInput, UserPromptSubmitOutput } from '../core/type
 
 // Configuration
 const MAX_MEMORIES = parseInt(process.env.CLAUDE_MEMORY_MAX_COUNT || '5');
-const MIN_SCORE = parseFloat(process.env.CLAUDE_MEMORY_MIN_SCORE || '0.3');
+// Tuned default for noise/recall balance on shopping_assistant-like corpus
+const BASE_MIN_SCORE = parseFloat(process.env.CLAUDE_MEMORY_MIN_SCORE || '0.4');
+const FALLBACK_MIN_SCORE = parseFloat(process.env.CLAUDE_MEMORY_FALLBACK_MIN_SCORE || '0.3');
 const ENABLE_SEARCH = process.env.CLAUDE_MEMORY_SEARCH !== 'false';
 
 /**
@@ -32,6 +34,14 @@ function shouldStorePrompt(prompt: string): boolean {
   return true;
 }
 
+
+function getDynamicMinScore(prompt: string): number {
+  const len = prompt.trim().length;
+  if (len <= 20) return Math.min(0.55, BASE_MIN_SCORE + 0.1);   // short query → stricter
+  if (len >= 80) return Math.max(0.3, BASE_MIN_SCORE - 0.05);    // long query → slightly looser
+  return BASE_MIN_SCORE;
+}
+
 async function main(): Promise<void> {
   // Read input from stdin
   const inputData = await readStdin();
@@ -61,11 +71,20 @@ async function main(): Promise<void> {
 
     // Fast keyword search if enabled
     if (ENABLE_SEARCH && input.prompt.length > 10) {
-      const results = await memoryService.keywordSearch(input.prompt, {
+      const minScore = getDynamicMinScore(input.prompt);
+      let results = await memoryService.keywordSearch(input.prompt, {
         topK: MAX_MEMORIES,
-        minScore: MIN_SCORE
+        minScore
       });
 
+      // recall rescue: if nothing found at tuned threshold, retry with fallback floor
+      if (results.length === 0 && FALLBACK_MIN_SCORE < minScore) {
+        results = await memoryService.keywordSearch(input.prompt, {
+          topK: MAX_MEMORIES,
+          minScore: FALLBACK_MIN_SCORE
+        });
+      }
+
       if (results.length > 0) {
         // Increment access count for found memories
         const eventIds = results.map(r => r.event.id);

package/src/services/session-history-importer.ts

@@ -426,24 +426,32 @@ export class SessionHistoryImporter {
       .map(name => path.join(projectsDir, name))
       .filter(p => fs.statSync(p).isDirectory());
 
-    const normalizedPath = projectPath.replace(/\/+/g, '/').replace(/\/$/, '');
-    const normalizedDashed = normalizedPath.replace(/\//g, '-').replace(/^-/, '');
-    const baseName = path.basename(normalizedPath);
+    const normalizedPath = projectPath.replace(/\+/g, '/').replace(/\/$/, '');
+    const normalizeToken = (value: string) => value
+      .toLowerCase()
+      .replace(/[\s_]+/g, '-')
+      .replace(/\/+/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '');
+
+    const normalizedDashed = normalizeToken(normalizedPath);
+    const baseName = normalizeToken(path.basename(normalizedPath));
 
     const scored = projectDirs.map((dir) => {
       const dirName = path.basename(dir);
+      const normalizedDirName = dirName.toLowerCase().replace(/[\s_]+/g, '-');
       let score = 0;
 
       // strong matches
-      if (dirName.includes(normalizedDashed)) score += 100;
-      if (normalizedDashed.includes(dirName)) score += 80;
+      if (normalizedDirName.includes(normalizedDashed)) score += 100;
+      if (normalizedDashed.includes(normalizedDirName)) score += 80;
 
       // basename signal (handles wrappers adding extra suffix)
-      if (baseName && dirName.includes(baseName)) score += 30;
+      if (baseName && normalizedDirName.includes(baseName)) score += 30;
 
       // token overlap signal
       const pathTokens = normalizedDashed.split('-').filter(Boolean);
-      const tokenHits = pathTokens.filter(t => t.length >= 3 && dirName.includes(t)).length;
+      const tokenHits = pathTokens.filter(t => t.length >= 3 && normalizedDirName.includes(t)).length;
       score += Math.min(tokenHits, 20);
 
       return { dir, score, dirName };