claude-memory-layer 1.0.35 → 1.0.37

package/dist/server/index.js

@@ -2339,6 +2339,14 @@ function normalizeQueryRewriteKind(value) {
   return "none";
 }
 var REWRITTEN_QUERY_REWRITE_KIND_SQL = `LOWER(TRIM(COALESCE(query_rewrite_kind, 'none'))) IN ('follow-up-context', 'intent-rewrite')`;
+var DEFAULT_OUTBOX_STUCK_THRESHOLD_MS = 5 * 60 * 1e3;
+var DEFAULT_OUTBOX_MAX_RETRIES = 3;
+function emptyOutboxRecoveryResult() {
+  return {
+    embedding: { recoveredProcessing: 0, retriedFailed: 0 },
+    vector: { recoveredProcessing: 0, retriedFailed: 0 }
+  };
+}
 var SQLiteEventStore = class {
   db;
   initialized = false;
@@ -3089,7 +3097,9 @@ var SQLiteEventStore = class {
     const placeholders = ids.map(() => "?").join(",");
     sqliteRun(
       this.db,
-      `UPDATE embedding_outbox SET status = 'processing' WHERE id IN (${placeholders})`,
+      `UPDATE embedding_outbox
+       SET status = 'processing', processed_at = datetime('now'), error_message = NULL
+       WHERE id IN (${placeholders})`,
       ids
     );
     return pending.map((row) => ({
@@ -3159,6 +3169,58 @@ var SQLiteEventStore = class {
       [error, ...ids]
     );
   }
+  /**
+   * Recover abandoned outbox work after a worker/process crash.
+   *
+   * Rows in `processing` are claimed work. If the process exits before marking
+   * them done/failed, they otherwise remain invisible to future processing.
+   * Recovery is deliberately age-gated so an active worker is not disturbed.
+   */
+  async recoverStuckOutboxItems(options = {}) {
+    await this.initialize();
+    const thresholdMs = Number.isFinite(options.stuckThresholdMs) && (options.stuckThresholdMs ?? 0) >= 0 ? options.stuckThresholdMs : DEFAULT_OUTBOX_STUCK_THRESHOLD_MS;
+    const maxRetries = Number.isFinite(options.maxRetries) && (options.maxRetries ?? 0) > 0 ? options.maxRetries : DEFAULT_OUTBOX_MAX_RETRIES;
+    const now = options.now ?? /* @__PURE__ */ new Date();
+    const threshold = new Date(now.getTime() - thresholdMs).toISOString();
+    const result = emptyOutboxRecoveryResult();
+    const embeddingRecovered = sqliteRun(
+      this.db,
+      `UPDATE embedding_outbox
+       SET status = 'pending', processed_at = NULL, error_message = NULL
+       WHERE status = 'processing'
+         AND datetime(COALESCE(processed_at, created_at)) < datetime(?)`,
+      [threshold]
+    );
+    result.embedding.recoveredProcessing = Number(embeddingRecovered.changes ?? 0);
+    const embeddingRetried = sqliteRun(
+      this.db,
+      `UPDATE embedding_outbox
+       SET status = 'pending', error_message = NULL
+       WHERE status = 'failed'
+         AND retry_count < ?`,
+      [maxRetries]
+    );
+    result.embedding.retriedFailed = Number(embeddingRetried.changes ?? 0);
+    const vectorRecovered = sqliteRun(
+      this.db,
+      `UPDATE vector_outbox
+       SET status = 'pending', updated_at = ?, error = NULL
+       WHERE status = 'processing'
+         AND datetime(updated_at) < datetime(?)`,
+      [now.toISOString(), threshold]
+    );
+    result.vector.recoveredProcessing = Number(vectorRecovered.changes ?? 0);
+    const vectorRetried = sqliteRun(
+      this.db,
+      `UPDATE vector_outbox
+       SET status = 'pending', updated_at = ?, error = NULL
+       WHERE status = 'failed'
+         AND retry_count < ?`,
+      [now.toISOString(), maxRetries]
+    );
+    result.vector.retriedFailed = Number(vectorRetried.changes ?? 0);
+    return result;
+  }
   /**
    * Get embedding/vector outbox health statistics
    */
@@ -4030,6 +4092,7 @@ var VectorStore = class {
    * Get total count of vectors
    */
   async count() {
+    await this.initialize();
     if (!this.table)
       return 0;
     const result = await this.table.countRows();
@@ -4468,6 +4531,10 @@ var MemoryQueryService = class {
     await this.initialize();
     return this.getMaintenanceStore("getOutboxStats").getOutboxStats();
   }
+  async recoverStuckOutboxItems(options) {
+    await this.initialize();
+    return this.getMaintenanceStore("recoverStuckOutboxItems").recoverStuckOutboxItems(options);
+  }
   async getStats() {
     await this.initialize();
     const deps = this.getStatsDeps();
@@ -7740,6 +7807,9 @@ var MemoryService = class {
   async getOutboxStats() {
     return this.queryService.getOutboxStats();
   }
+  async recoverStuckOutboxItems(options) {
+    return this.queryService.recoverStuckOutboxItems(options);
+  }
   async getRetrievalTraceStats() {
     return this.retrievalAnalyticsService.getRetrievalTraceStats();
   }
@@ -8053,6 +8123,26 @@ function getServiceFromQuery(c) {
   }
   return getReadOnlyMemoryService();
 }
+function getWritableServiceFromQuery(c) {
+  const project = c.req.query("project") || c.req.query("projectId");
+  if (project) {
+    const storagePath = resolveProjectStoragePath(project);
+    return new MemoryService({
+      storagePath,
+      readOnly: false,
+      lightweightMode: true,
+      analyticsEnabled: false,
+      sharedStoreConfig: DISABLED_SHARED_STORE_CONFIG
+    });
+  }
+  return new MemoryService({
+    storagePath: "~/.claude-code/memory",
+    readOnly: false,
+    lightweightMode: true,
+    analyticsEnabled: false,
+    sharedStoreConfig: DISABLED_SHARED_STORE_CONFIG
+  });
+}
 function getLightweightServiceFromQuery(c) {
   const project = c.req.query("project") || c.req.query("projectId");
   if (project) {
@@ -8079,7 +8169,7 @@ var sessionsRouter = new Hono();
 sessionsRouter.get("/", async (c) => {
   const page = parseInt(c.req.query("page") || "1", 10);
   const pageSize = parseInt(c.req.query("pageSize") || "20", 10);
-  const memoryService = getServiceFromQuery(c);
+  const memoryService = getLightweightServiceFromQuery(c);
   try {
     await memoryService.initialize();
     const recentEvents = await memoryService.getRecentEvents(1e3);
@@ -8123,7 +8213,7 @@ sessionsRouter.get("/", async (c) => {
 });
 sessionsRouter.get("/:id", async (c) => {
   const { id } = c.req.param();
-  const memoryService = getServiceFromQuery(c);
+  const memoryService = getLightweightServiceFromQuery(c);
   try {
     await memoryService.initialize();
     const events = await memoryService.getSessionHistory(id);
@@ -8169,7 +8259,7 @@ eventsRouter.get("/", async (c) => {
   const q = (c.req.query("q") || "").trim().toLowerCase();
   const limit = parseInt(c.req.query("limit") || "100", 10);
   const offset = parseInt(c.req.query("offset") || "0", 10);
-  const memoryService = getServiceFromQuery(c);
+  const memoryService = getLightweightServiceFromQuery(c);
   try {
     await memoryService.initialize();
     let events;
@@ -8225,7 +8315,7 @@ eventsRouter.get("/", async (c) => {
 });
 eventsRouter.get("/:id", async (c) => {
   const { id } = c.req.param();
-  const memoryService = getServiceFromQuery(c);
+  const memoryService = getLightweightServiceFromQuery(c);
   try {
     await memoryService.initialize();
     const recentEvents = await memoryService.getRecentEvents(1e4);
@@ -8264,6 +8354,10 @@ eventsRouter.get("/:id", async (c) => {
 // src/apps/server/api/search.ts
 import { Hono as Hono3 } from "hono";
 var searchRouter = new Hono3();
+function isEmbeddingBackendUnavailable(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /model file path or buffer|onnxruntime|transformers|embedding backend/i.test(message);
+}
 searchRouter.post("/", async (c) => {
   const memoryService = getServiceFromQuery(c);
   try {
@@ -8305,15 +8399,41 @@ searchRouter.post("/", async (c) => {
 });
 searchRouter.post("/disclosure", async (c) => {
   let memoryService;
+  let body;
   try {
-    const body = await c.req.json();
+    body = await c.req.json();
     if (!body.query) {
       return c.json({ error: "Query is required" }, 400);
     }
-    memoryService = body.options?.strategy === "fast" ? getLightweightServiceFromQuery(c) : getServiceFromQuery(c);
-    await memoryService.initialize();
-    const result = await memoryService.searchDisclosure(body.query, body.options);
-    return c.json(result);
+    const useFastStrategy = body.options?.strategy === "fast";
+    memoryService = useFastStrategy ? getLightweightServiceFromQuery(c) : getServiceFromQuery(c);
+    try {
+      await memoryService.initialize();
+      const result = await memoryService.searchDisclosure(body.query, body.options);
+      return c.json(result);
+    } catch (error) {
+      if (!useFastStrategy && isEmbeddingBackendUnavailable(error)) {
+        await memoryService.shutdown();
+        memoryService = getLightweightServiceFromQuery(c);
+        await memoryService.initialize();
+        const result = await memoryService.searchDisclosure(body.query, {
+          ...body.options,
+          strategy: "fast"
+        });
+        return c.json({
+          ...result,
+          meta: {
+            ...result.meta,
+            fallbackApplied: true,
+            fallbackTrace: [
+              ...result.meta.fallbackTrace || [],
+              "fallback:embedding-backend-unavailable:fast"
+            ]
+          }
+        });
+      }
+      throw error;
+    }
   } catch (error) {
     return c.json({ error: error.message }, 500);
   } finally {
@@ -8321,7 +8441,7 @@ searchRouter.post("/disclosure", async (c) => {
   }
 });
 searchRouter.get("/disclosure/:resultId/expand", async (c) => {
-  const memoryService = getServiceFromQuery(c);
+  const memoryService = getLightweightServiceFromQuery(c);
   try {
     const resultId = c.req.param("resultId");
     const rawWindowSize = c.req.query("windowSize");
@@ -8341,7 +8461,7 @@ searchRouter.get("/disclosure/:resultId/expand", async (c) => {
   }
 });
 searchRouter.get("/disclosure/:resultId/source", async (c) => {
-  const memoryService = getServiceFromQuery(c);
+  const memoryService = getLightweightServiceFromQuery(c);
   try {
     const resultId = c.req.param("resultId");
     const result = await memoryService.sourceDisclosure(resultId);
@@ -9678,6 +9798,13 @@ import { Hono as Hono8 } from "hono";
 import { streamSSE } from "hono/streaming";
 import { spawn } from "child_process";
 var chatRouter = new Hono8();
+var ProviderFailure = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ProviderFailure";
+  }
+};
 var CLAUDE_TIMEOUT_MS = 12e4;
 chatRouter.post("/", async (c) => {
   let body;
@@ -9689,43 +9816,12 @@ chatRouter.post("/", async (c) => {
   if (!body.message?.trim()) {
     return c.json({ error: "Message is required" }, 400);
   }
-  const memoryService = getServiceFromQuery(c);
+  const memoryOnly = body.mode === "memory-only" || body.memoryOnly === true;
+  const memoryService = memoryOnly ? getLightweightServiceFromQuery(c) : getServiceFromQuery(c);
   try {
     await memoryService.initialize();
-    let memoryContext = "";
-    let statsContext = "";
-    try {
-      const result = await memoryService.retrieveMemories(body.message, {
-        topK: 8,
-        minScore: 0.5
-      });
-      if (result.memories.length > 0) {
-        const parts = ["## Relevant Memories\n"];
-        for (const m of result.memories) {
-          const date = new Date(m.event.timestamp).toISOString().split("T")[0];
-          const content = m.event.content.slice(0, 500);
-          parts.push(`### [${m.event.eventType}] ${date} (score: ${m.score.toFixed(2)})`);
-          parts.push(content);
-          if (m.sessionContext) {
-            parts.push(`_Context: ${m.sessionContext}_`);
-          }
-          parts.push("");
-        }
-        memoryContext = parts.join("\n");
-      }
-    } catch {
-    }
-    try {
-      const stats = await memoryService.getStats();
-      const levels = stats.levelStats.map((l) => `${l.level}: ${l.count}`).join(", ");
-      statsContext = [
-        "## Memory Stats",
-        `- Total events: ${stats.totalEvents}`,
-        `- Vector nodes: ${stats.vectorCount}`,
-        `- By level: ${levels}`
-      ].join("\n");
-    } catch {
-    }
+    const { memoryContext, memoryHits } = await collectMemoryContext(memoryService, body.message);
+    const statsContext = await collectStatsContext(memoryService);
     const fullPrompt = buildPrompt(
       statsContext,
       memoryContext,
@@ -9733,13 +9829,23 @@ chatRouter.post("/", async (c) => {
       body.message
     );
     return streamSSE(c, async (stream) => {
+      if (memoryOnly) {
+        await streamMemoryOnlyResponse(stream, {
+          memoryContext,
+          memoryHits,
+          reason: "memory-only-mode"
+        });
+        return;
+      }
       try {
         await streamClaudeResponse(fullPrompt, stream);
       } catch (err) {
+        const diagnostic = providerDiagnostic(err);
         await stream.writeSSE({
-          event: "error",
-          data: JSON.stringify({ error: err.message })
+          event: "provider_error",
+          data: JSON.stringify(diagnostic)
         });
+        await streamMemoryOnlyFallback(stream, memoryContext, memoryHits);
       }
     });
   } catch (error) {
@@ -9748,6 +9854,115 @@ chatRouter.post("/", async (c) => {
     await memoryService.shutdown();
   }
 });
+async function collectMemoryContext(memoryService, query) {
+  let memoryHits = [];
+  try {
+    const result = await memoryService.retrieveMemories?.(query, {
+      topK: 8,
+      minScore: 0.5
+    });
+    memoryHits = result?.memories ?? [];
+  } catch {
+    memoryHits = [];
+  }
+  if (memoryHits.length === 0) {
+    try {
+      memoryHits = await memoryService.keywordSearch?.(query, { topK: 8, minScore: 0.05 }) ?? [];
+    } catch {
+      memoryHits = [];
+    }
+  }
+  return {
+    memoryContext: formatMemoryContext(memoryHits),
+    memoryHits
+  };
+}
+async function collectStatsContext(memoryService) {
+  try {
+    const stats = await memoryService.getStats?.();
+    if (!stats)
+      return "";
+    const levels = stats.levelStats.map((l) => `${l.level}: ${l.count}`).join(", ");
+    return [
+      "## Memory Stats",
+      `- Total events: ${stats.totalEvents}`,
+      `- Vector nodes: ${stats.vectorCount}`,
+      `- By level: ${levels}`
+    ].join("\n");
+  } catch {
+    return "";
+  }
+}
+function formatMemoryContext(memoryHits) {
+  if (memoryHits.length === 0)
+    return "";
+  const parts = ["## Relevant Memories\n"];
+  for (const m of memoryHits) {
+    const date = m.event.timestamp ? new Date(m.event.timestamp).toISOString().split("T")[0] : "unknown-date";
+    const content = (m.event.content ?? "").slice(0, 500);
+    parts.push(`### [${m.event.eventType ?? "memory"}] ${date} (score: ${m.score.toFixed(2)})`);
+    parts.push(content);
+    if (m.sessionContext) {
+      parts.push(`_Context: ${m.sessionContext}_`);
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+async function streamMemoryOnlyResponse(stream, options) {
+  await stream.writeSSE({
+    event: "diagnostic",
+    data: JSON.stringify({
+      provider: "claude-cli",
+      status: "skipped",
+      mode: "memory-only",
+      reason: options.reason,
+      retrievedMemories: options.memoryHits.length
+    })
+  });
+  await streamMemoryOnlyFallback(stream, options.memoryContext, options.memoryHits);
+}
+async function streamMemoryOnlyFallback(stream, memoryContext, memoryHits) {
+  const content = memoryHits.length > 0 ? [
+    "Provider unavailable or skipped; showing retrieved memory context directly.",
+    "",
+    memoryContext
+  ].join("\n") : "Provider unavailable or skipped, and no directly relevant memories were found for this query.";
+  await stream.writeSSE({
+    event: "message",
+    data: JSON.stringify({ content, mode: "memory-only" })
+  });
+  await stream.writeSSE({ event: "done", data: "{}" });
+}
+function providerDiagnostic(err) {
+  if (err instanceof ProviderFailure) {
+    return {
+      provider: "claude-cli",
+      code: err.code,
+      message: err.message,
+      fallback: "memory-only"
+    };
+  }
+  return {
+    provider: "claude-cli",
+    code: "claude-cli-error",
+    message: err instanceof Error ? err.message : "Unknown Claude CLI failure",
+    fallback: "memory-only"
+  };
+}
+function classifyProviderFailure(message) {
+  const normalized = message.toLowerCase();
+  if (normalized.includes("401") || normalized.includes("unauthorized") || normalized.includes("auth")) {
+    return new ProviderFailure("claude-cli-auth", "Claude CLI authentication failed; showing memory-only context.");
+  }
+  if (normalized.includes("not found") || normalized.includes("enoent")) {
+    return new ProviderFailure("claude-cli-not-found", "Claude CLI was not found; showing memory-only context.");
+  }
+  if (normalized.includes("timed out")) {
+    return new ProviderFailure("claude-cli-timeout", "Claude CLI timed out; showing memory-only context.");
+  }
+  return new ProviderFailure("claude-cli-error", "Claude CLI failed; showing memory-only context.");
+}
 function buildPrompt(statsContext, memoryContext, history, currentMessage) {
   const parts = [];
   parts.push("You are a helpful assistant that answers questions about the user's code memory data.");
@@ -9790,12 +10005,13 @@ function streamClaudeResponse(prompt, stream) {
     });
     const timeout = setTimeout(() => {
       proc.kill("SIGTERM");
-      reject(new Error("Chat response timed out after 2 minutes"));
+      reject(classifyProviderFailure("timed out"));
     }, CLAUDE_TIMEOUT_MS);
     proc.stdin.write(prompt);
     proc.stdin.end();
     let buffer = "";
     let lastSentText = "";
+    let stderrText = "";
     proc.stdout.on("data", async (chunk) => {
       buffer += chunk.toString();
       const lines = buffer.split("\n");
@@ -9824,6 +10040,7 @@ function streamClaudeResponse(prompt, stream) {
       }
     });
     proc.stderr.on("data", (chunk) => {
+      stderrText += chunk.toString();
       if (process.env.CLAUDE_MEMORY_DEBUG) {
         console.error("[chat] claude stderr:", chunk.toString());
       }
@@ -9831,7 +10048,7 @@ function streamClaudeResponse(prompt, stream) {
     proc.on("error", (err) => {
       clearTimeout(timeout);
       if (err.code === "ENOENT") {
-        reject(new Error("Claude CLI not found. Install with: npm install -g @anthropic-ai/claude-code"));
+        reject(classifyProviderFailure("ENOENT not found"));
       } else {
         reject(err);
       }
@@ -9848,7 +10065,7 @@ function streamClaudeResponse(prompt, stream) {
         }
       }
       if (code !== 0 && code !== null) {
-        reject(new Error(`Claude CLI exited with code ${code}`));
+        reject(classifyProviderFailure(stderrText || `Claude CLI exited with code ${code}`));
       } else {
         resolve4();
       }
@@ -9897,6 +10114,49 @@ healthRouter.get("/", async (c) => {
     await memoryService.shutdown();
   }
 });
+healthRouter.post("/recover", async (c) => {
+  const memoryService = getWritableServiceFromQuery(c);
+  try {
+    await memoryService.initialize();
+    const body = await c.req.json().catch(() => ({}));
+    const options = {};
+    if (typeof body.stuckThresholdMs === "number" && Number.isFinite(body.stuckThresholdMs)) {
+      options.stuckThresholdMs = body.stuckThresholdMs;
+    }
+    if (typeof body.maxRetries === "number" && Number.isFinite(body.maxRetries)) {
+      options.maxRetries = body.maxRetries;
+    }
+    const before = await memoryService.getOutboxStats();
+    const recovered = await memoryService.recoverStuckOutboxItems(options);
+    const [stats, outbox] = await Promise.all([
+      memoryService.getStats(),
+      memoryService.getOutboxStats()
+    ]);
+    return c.json({
+      status: "ok",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      recovered,
+      before: {
+        outbox: before
+      },
+      after: {
+        storage: {
+          totalEvents: stats.totalEvents,
+          vectorCount: stats.vectorCount
+        },
+        outbox
+      }
+    });
+  } catch (error) {
+    return c.json({
+      status: "error",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: error.message
+    }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});
 
 // src/apps/server/api/index.ts
 var apiRouter = new Hono10().route("/sessions", sessionsRouter).route("/events", eventsRouter).route("/search", searchRouter).route("/stats", statsRouter).route("/citations", citationsRouter).route("/turns", turnsRouter).route("/projects", projectsRouter).route("/chat", chatRouter).route("/health", healthRouter);