claude-memory-layer 1.0.22 → 1.0.24

package/dist/hooks/stop.js

@@ -1838,6 +1838,21 @@ var SQLiteEventStore = class {
       [id, eventId, sessionId, score, query.slice(0, 100)]
     );
   }
+  /**
+   * Get session IDs that have unevaluated retrievals (measured_at IS NULL).
+   * Excludes the current session. Used to backfill sessions that ended without Stop hook.
+   */
+  async getUnevaluatedSessions(currentSessionId, limit = 5) {
+    await this.initialize();
+    const rows = sqliteAll(
+      this.db,
+      `SELECT DISTINCT session_id FROM memory_helpfulness
+       WHERE measured_at IS NULL AND session_id != ?
+       ORDER BY created_at DESC LIMIT ?`,
+      [currentSessionId, limit]
+    );
+    return rows.map((r) => r.session_id);
+  }
   /**
    * Evaluate helpfulness for all retrievals in a session
    * Called at session end - uses behavioral signals to compute score
@@ -2625,7 +2640,7 @@ var VectorStore = class {
 
 // src/core/embedder.ts
 import { pipeline } from "@huggingface/transformers";
-var Embedder = class {
+var Embedder = class _Embedder {
   pipeline = null;
   modelName;
   activeModelName;
@@ -2656,6 +2671,11 @@ var Embedder = class {
       this.initialized = true;
     }
   }
+  // ~4 chars per token; 512 tokens * 4 = 2048, use 2000 to be safe
+  static MAX_CHARS = 2e3;
+  truncate(text) {
+    return text.length > _Embedder.MAX_CHARS ? text.slice(0, _Embedder.MAX_CHARS) : text;
+  }
   /**
    * Generate embedding for a single text
    */
@@ -2664,9 +2684,11 @@ var Embedder = class {
     if (!this.pipeline) {
       throw new Error("Embedding pipeline not initialized");
     }
-    const output = await this.pipeline(text, {
+    const output = await this.pipeline(this.truncate(text), {
       pooling: "mean",
-      normalize: true
+      normalize: true,
+      truncation: true,
+      max_length: 512
     });
     const vector = Array.from(output.data);
     return {
@@ -2688,9 +2710,11 @@ var Embedder = class {
     for (let i = 0; i < texts.length; i += batchSize) {
       const batch = texts.slice(i, i + batchSize);
       for (const text of batch) {
-        const output = await this.pipeline(text, {
+        const output = await this.pipeline(this.truncate(text), {
           pooling: "mean",
-          normalize: true
+          normalize: true,
+          truncation: true,
+          max_length: 512
         });
         const vector = Array.from(output.data);
         results.push({
@@ -5960,6 +5984,7 @@ var MemoryService = class {
   projectPath = null;
   readOnly;
   lightweightMode;
+  embeddingOnly;
   mdMirror;
   storagePath;
   constructor(config) {
@@ -5967,6 +5992,7 @@ var MemoryService = class {
     this.storagePath = storagePath;
     this.readOnly = config.readOnly ?? false;
     this.lightweightMode = config.lightweightMode ?? false;
+    this.embeddingOnly = config.embeddingOnly ?? false;
     this.mdMirror = new MarkdownMirror2(process.cwd());
     if (!this.readOnly && !fs4.existsSync(storagePath)) {
       fs4.mkdirSync(storagePath, { recursive: true });
@@ -6040,19 +6066,21 @@ var MemoryService = class {
         this.embedder
       );
       this.vectorWorker.start();
-      this.retriever.setGraduationPipeline(this.graduation);
-      this.graduationWorker = createGraduationWorker(
-        this.sqliteStore,
-        this.graduation
-      );
-      this.graduationWorker.start();
-      if (this.analyticsStore) {
-        this.syncWorker = new SyncWorker(
+      if (!this.embeddingOnly) {
+        this.retriever.setGraduationPipeline(this.graduation);
+        this.graduationWorker = createGraduationWorker(
           this.sqliteStore,
-          this.analyticsStore,
-          { intervalMs: 3e4, batchSize: 500 }
+          this.graduation
         );
-        this.syncWorker.start();
+        this.graduationWorker.start();
+        if (this.analyticsStore) {
+          this.syncWorker = new SyncWorker(
+            this.sqliteStore,
+            this.analyticsStore,
+            { intervalMs: 3e4, batchSize: 500 }
+          );
+          this.syncWorker.start();
+        }
       }
       const savedMode = await this.sqliteStore.getEndlessConfig("mode");
       if (savedMode === "endless") {
@@ -6776,6 +6804,19 @@ var MemoryService = class {
     await this.initialize();
     await this.sqliteStore.recordRetrieval(eventId, sessionId, score, query);
   }
+  /**
+   * Record a query-level retrieval trace (used by user-prompt-submit hook).
+   * Feeds the retrieval_traces table that powers dashboard stats.
+   */
+  async recordQueryTrace(input) {
+    await this.initialize();
+    await this.sqliteStore.recordRetrievalTrace({
+      ...input,
+      candidateDetails: [],
+      selectedDetails: [],
+      fallbackTrace: []
+    });
+  }
   /**
    * Evaluate helpfulness of retrievals in a session (called at session end)
    */
@@ -6783,6 +6824,20 @@ var MemoryService = class {
     await this.initialize();
     await this.sqliteStore.evaluateSessionHelpfulness(sessionId);
   }
+  /**
+   * Backfill helpfulness evaluation for sessions that ended without Stop hook.
+   * Call on first turn of a new session to catch missed evaluations.
+   */
+  async evaluatePendingSessions(currentSessionId) {
+    await this.initialize();
+    const sessions = await this.sqliteStore.getUnevaluatedSessions(currentSessionId, 5);
+    for (const sid of sessions) {
+      try {
+        await this.sqliteStore.evaluateSessionHelpfulness(sid);
+      } catch {
+      }
+    }
+  }
   /**
    * Get most helpful memories ranked by helpfulness score
    */
@@ -7277,6 +7332,24 @@ function clearTurnState(sessionId) {
     }
   }
 }
+var LAST_RESPONSE_SNIPPET_CHARS = 500;
+function getLastResponsePath(sessionId) {
+  return path4.join(TURN_STATE_DIR, `.last-response-${sessionId}.json`);
+}
+function writeLastAssistantSnippet(sessionId, text) {
+  try {
+    if (!fs5.existsSync(TURN_STATE_DIR)) {
+      fs5.mkdirSync(TURN_STATE_DIR, { recursive: true });
+    }
+    const snippet = text.slice(0, LAST_RESPONSE_SNIPPET_CHARS);
+    const state = { sessionId, snippet, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+    const filePath = getLastResponsePath(sessionId);
+    const tempPath = filePath + ".tmp";
+    fs5.writeFileSync(tempPath, JSON.stringify(state));
+    fs5.renameSync(tempPath, filePath);
+  } catch {
+  }
+}
 
 // src/hooks/stop.ts
 var DEFAULT_PRIVACY_CONFIG = {
@@ -7324,13 +7397,19 @@ async function main() {
   try {
     const turnId = readTurnState(input.session_id);
     const assistantMessages = await extractAssistantMessages(input.transcript_path);
-    for (const text of assistantMessages) {
+    const MIN_AGENT_RESPONSE_LEN = parseInt(
+      process.env.CLAUDE_MEMORY_AGENT_RESPONSE_MIN_LEN || "150"
+    );
+    const lastIdx = assistantMessages.length - 1;
+    for (let i = 0; i < assistantMessages.length; i++) {
+      const text = assistantMessages[i];
+      const isLast = i === lastIdx;
       const filterResult = applyPrivacyFilter(text, DEFAULT_PRIVACY_CONFIG);
       let content = filterResult.content;
       if (content.length > 5e3) {
         content = content.slice(0, 5e3) + "...[truncated]";
       }
-      if (content.trim().length < 10)
+      if (!isLast && content.trim().length < MIN_AGENT_RESPONSE_LEN)
         continue;
       await memoryService.storeAgentResponse(
         input.session_id,
@@ -7341,6 +7420,10 @@ async function main() {
         }
       );
     }
+    if (assistantMessages.length > 0) {
+      const lastMessage = assistantMessages[assistantMessages.length - 1];
+      writeLastAssistantSnippet(input.session_id, lastMessage);
+    }
     clearTurnState(input.session_id);
     await memoryService.processPendingEmbeddings();
     console.log(JSON.stringify({}));