claude-memory-layer 1.0.36 → 1.0.37

package/dist/server/api/index.js

@@ -2327,6 +2327,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;
@@ -3077,7 +3085,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) => ({
@@ -3147,6 +3157,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
    */
@@ -4018,6 +4080,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();
@@ -4456,6 +4519,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();
@@ -7728,6 +7795,9 @@ var MemoryService = class {
   async getOutboxStats() {
     return this.queryService.getOutboxStats();
   }
+  async recoverStuckOutboxItems(options) {
+    return this.queryService.recoverStuckOutboxItems(options);
+  }
   async getRetrievalTraceStats() {
     return this.retrievalAnalyticsService.getRetrievalTraceStats();
   }
@@ -8041,6 +8111,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) {
@@ -9696,6 +9786,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;
@@ -9707,43 +9804,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,
@@ -9751,13 +9817,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) {
@@ -9766,6 +9842,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.");
@@ -9808,12 +9993,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");
@@ -9842,6 +10028,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());
       }
@@ -9849,7 +10036,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);
       }
@@ -9866,7 +10053,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 {
         resolve3();
       }
@@ -9915,6 +10102,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);