om-memory-system 3.5.0 → 3.6.0-next.38

package/dist/importer/web-import-jobs.js

@@ -33,8 +33,9 @@ export function validateWebImportRequest(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         throw new Error("Invalid import request");
     const input = value;
-    if (input.host !== "pi" && input.host !== "opencode")
-        throw new Error("Choose Pi or OpenCode");
+    if (input.host !== "pi" && input.host !== "opencode" && input.host !== "claude-code") {
+        throw new Error("Choose Pi, OpenCode, or Claude Code");
+    }
     if (!input.options || typeof input.options !== "object" || Array.isArray(input.options))
         throw new Error("Invalid import options");
     const options = input.options;
@@ -72,12 +73,18 @@ export function validateWebImportRequest(value) {
         (typeof input.modelChoice !== "string" ||
             (input.modelChoice !== "external" && !/^[^/]+\/.+$/.test(input.modelChoice))))
         throw new Error("Choose a signed-in provider/model or the external API");
+    // Claude Code has no session model: its imports always use the external API.
+    if (input.host === "claude-code" &&
+        input.modelChoice !== undefined &&
+        input.modelChoice !== "external")
+        throw new Error("Claude Code imports use the external API");
+    const modelChoice = input.host === "claude-code" ? "external" : input.modelChoice;
     return {
         host: input.host,
         source: input.source,
         selection: validateImportSelection(input.selection),
         options: options,
-        modelChoice: input.modelChoice,
+        modelChoice,
     };
 }
 /** One in-memory slot per web server, shared by previews and imports. */

package/dist/index.js

@@ -1,13 +1,12 @@
 import { tool } from "@opencode-ai/plugin";
 import { memoryClient } from "./services/client.js";
-import { formatContextForPrompt } from "./services/context.js";
 import { getTags } from "./services/tags.js";
 import { performAutoCapture } from "./services/auto-capture.js";
 import { createOpenCodeAutoCaptureHost } from "./adapters/opencode/auto-capture-host.js";
 import { isInternalPrompt, isStructuredSummaryPromptMessage, recordUserPrompt, } from "./adapters/opencode/user-prompt.js";
 import { executeMemoryOperation } from "./core/memory-operations.js";
 import { OPENCODE_IMPORT_COMMAND, OPENCODE_IMPORT_DESCRIPTION, latestUserMessageModel, runOpencodeImportCommand, } from "./adapters/opencode/import-command.js";
-import { formatMemoriesForCompaction } from "./core/retrieval.js";
+import { buildRecentMemoriesSection, formatMemoriesForCompaction } from "./core/retrieval.js";
 import { performUserProfileLearning } from "./adapters/opencode/profile-learning.js";
 import { userPromptManager } from "./services/user-prompt/user-prompt-manager.js";
 import { startWebServer, WebServer } from "./services/web-server.js";
@@ -489,27 +488,14 @@ export const OmmsPlugin = async (ctx) => {
                             !m.parts.every((p) => p.type !== "text" || p.synthetic === true)).length === 1);
                 if (!shouldInject)
                     return;
-                const listResult = await memoryClient.listMemories(tags.project.tag, CONFIG.chatMessage.maxMemories);
-                let memories = listResult.success ? listResult.memories : [];
-                if (CONFIG.chatMessage.excludeCurrentSession) {
-                    memories = memories.filter((m) => m.metadata?.sessionID !== input.sessionID);
-                }
-                if (CONFIG.chatMessage.maxAgeDays) {
-                    const cutoffDate = Date.now() - CONFIG.chatMessage.maxAgeDays * 86400000;
-                    memories = memories.filter((m) => new Date(m.createdAt).getTime() > cutoffDate);
-                }
-                if (memories.length === 0)
-                    return;
-                const projectMemories = {
-                    results: memories.map((m) => ({
-                        similarity: 1.0,
-                        memory: m.summary,
-                    })),
-                    total: memories.length,
-                    timing: 0,
-                };
-                const userId = tags.user.userEmail || null;
-                const memoryContext = await formatContextForPrompt(userId, projectMemories);
+                const memoryContext = await buildRecentMemoriesSection({
+                    projectTag: tags.project.tag,
+                    userEmail: tags.user.userEmail,
+                    sessionId: input.sessionID,
+                    maxMemories: CONFIG.chatMessage.maxMemories,
+                    excludeCurrentSession: CONFIG.chatMessage.excludeCurrentSession,
+                    maxAgeDays: CONFIG.chatMessage.maxAgeDays,
+                });
                 if (memoryContext) {
                     const contextPart = {
                         id: `prt-memory-context-${Date.now()}`,

package/dist/services/ai/live-model-choice.d.ts

@@ -49,6 +49,11 @@ export declare function resolvePiLiveModel(config: AutoCaptureProviderRuntimeCon
     piProvider?: string;
     piModel?: string;
 }): PiLiveModelChoice;
+/**
+ * Claude Code's live model: the external API only. Its hooks cannot call the
+ * session's model, so there is no host model and no session fallback.
+ */
+export declare function resolveClaudeCodeLiveModel(config: AutoCaptureProviderRuntimeConfig): AutoCaptureProviderStatus;
 /** True when the external API is fully configured and can serve as a fallback. */
 export declare function isExternalModelReady(config: AutoCaptureProviderRuntimeConfig): boolean;
 /** Why the external API cannot be used as a host's chosen model, or an empty list. */

package/dist/services/ai/live-model-choice.js

@@ -93,6 +93,13 @@ export function resolvePiLiveModel(config) {
         return { kind: "session" };
     return { kind: "unready", issues: manual.issues };
 }
+/**
+ * Claude Code's live model: the external API only. Its hooks cannot call the
+ * session's model, so there is no host model and no session fallback.
+ */
+export function resolveClaudeCodeLiveModel(config) {
+    return externalChoiceStatus(config);
+}
 /** True when the external API is fully configured and can serve as a fallback. */
 export function isExternalModelReady(config) {
     return getManualProviderStatus(config).ready;

package/dist/services/backfill-state.d.ts

@@ -1,4 +1,4 @@
-type BackfillHost = "pi" | "opencode";
+type BackfillHost = "pi" | "opencode" | "claude-code";
 export type BackfillStatus = {
     host: BackfillHost;
     cutoff: number;

package/dist/services/capture-retry-queue.js

@@ -179,11 +179,12 @@ export async function deleteCaptureRetry(id, config) {
 export async function countCaptureRetries(config) {
     const db = await database(config);
     const rows = await db.all("SELECT host, COUNT(*) AS count FROM capture_retry_queue GROUP BY host");
-    const counts = { opencode: 0, pi: 0 };
+    const counts = { opencode: 0, pi: 0, "claude-code": 0 };
     for (const row of rows) {
         const host = String(row.host);
-        if (host === "opencode" || host === "pi")
+        if (host === "opencode" || host === "pi" || host === "claude-code") {
             counts[host] = Number(row.count);
+        }
     }
     return counts;
 }

package/dist/services/claude-capture-cursor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The last Claude Code user entry that live capture handled, per session. It
+ * lives in `user-prompts.db` next to the capture retry queue, so a web app
+ * restart does not capture the last turn again. Callers pass `CONFIG`.
+ */
+export interface ClaudeCaptureCursorConfig {
+    storagePath: string;
+}
+export declare function readClaudeCaptureCursor(sessionId: string, config: ClaudeCaptureCursorConfig): Promise<string | null>;
+export declare function writeClaudeCaptureCursor(sessionId: string, userEntryId: string, config: ClaudeCaptureCursorConfig, now?: number): Promise<void>;

package/dist/services/claude-capture-cursor.js

@@ -0,0 +1,44 @@
+import { join } from "node:path";
+import { tursoConnectionManager } from "./turso/connection-manager.js";
+/** A session with no capture for this long loses its cursor. */
+const CURSOR_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+const prepared = new Map();
+async function database(config) {
+    const path = join(config.storagePath, "user-prompts.db");
+    const db = await tursoConnectionManager.getConnection(path);
+    let ready = prepared.get(path);
+    if (!ready) {
+        ready = db
+            .batch([
+            {
+                sql: `CREATE TABLE IF NOT EXISTS claude_capture_cursors (
+          session_id TEXT PRIMARY KEY,
+          last_user_entry_id TEXT NOT NULL,
+          updated_at INTEGER NOT NULL
+        )`,
+            },
+            {
+                sql: "DELETE FROM claude_capture_cursors WHERE updated_at < ?",
+                args: [Date.now() - CURSOR_RETENTION_MS],
+            },
+        ])
+            .then(() => undefined);
+        // A failed preparation is tried again on the next call.
+        ready.catch(() => prepared.delete(path));
+        prepared.set(path, ready);
+    }
+    await ready;
+    return db;
+}
+export async function readClaudeCaptureCursor(sessionId, config) {
+    const db = await database(config);
+    const row = await db.get("SELECT last_user_entry_id FROM claude_capture_cursors WHERE session_id = ?", [sessionId]);
+    return row ? String(row.last_user_entry_id) : null;
+}
+export async function writeClaudeCaptureCursor(sessionId, userEntryId, config, now = Date.now()) {
+    const db = await database(config);
+    await db.run(`INSERT INTO claude_capture_cursors (session_id, last_user_entry_id, updated_at)
+     VALUES (?, ?, ?)
+     ON CONFLICT(session_id) DO UPDATE SET
+       last_user_entry_id = excluded.last_user_entry_id, updated_at = excluded.updated_at`, [sessionId, userEntryId, now]);
+}

package/dist/services/settings-snapshot.d.ts

@@ -27,6 +27,7 @@ export declare function getSettingsSnapshot(directory: string): {
     effective: {
         opencode: import("./ai/live-model-choice.js").AutoCaptureProviderStatus;
         pi: import("./ai/live-model-choice.js").PiLiveModelChoice;
+        "claude-code": import("./ai/live-model-choice.js").AutoCaptureProviderStatus;
     };
 };
 /**

package/dist/services/settings-snapshot.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { parse } from "jsonc-parser";
 import { CONFIG, getGlobalConfigSourcePath } from "../config.js";
 import { readGlobalConfigRevision } from "./global-config-writer.js";
-import { getAutoCaptureProviderStatus, isExternalModelReady, resolvePiLiveModel, } from "./ai/live-model-choice.js";
+import { getAutoCaptureProviderStatus, isExternalModelReady, resolveClaudeCodeLiveModel, resolvePiLiveModel, } from "./ai/live-model-choice.js";
 const editable = [
     "opencodeProvider",
     "opencodeModel",
@@ -92,6 +92,8 @@ export function getSettingsSnapshot(directory) {
         effective: {
             opencode: getAutoCaptureProviderStatus(CONFIG),
             pi: resolvePiLiveModel(CONFIG),
+            // Claude Code capture uses the external API only; `issues` names each missing setting.
+            "claude-code": resolveClaudeCodeLiveModel(CONFIG),
         },
     };
 }

package/dist/services/web-server.d.ts

@@ -39,6 +39,8 @@ export declare class WebServer {
     private backfillControlsInstance?;
     /** Run an import-page action; errors carry their own status and never file contents. */
     private importResponse;
+    /** Claude Code hook requests; they reach this point only with a valid API token. */
+    private claudeHookResponse;
     private backfillControls;
     private importJobs;
     constructor(config: WebServerConfig);

package/dist/services/web-server.js

@@ -36,7 +36,7 @@ function serveFetch(opts) {
             hostname: opts.hostname,
             fetch: opts.fetch,
         });
-        return { stop: () => bunHandle.stop() };
+        return Promise.resolve({ stop: () => bunHandle.stop() });
     }
     // Node path: wrap node:http around the fetch-style handler. The adapter
     // converts IncomingMessage → Web Request and Web Response → ServerResponse.
@@ -95,30 +95,34 @@ function serveFetch(opts) {
             }
         }
     });
-    // Surface EADDRINUSE synchronously so callers can detect the
-    // already-running-instance case the same way they do under Bun.
-    let listenError;
-    server.on("error", (err) => {
-        if (err.code === "EADDRINUSE") {
-            listenError = err;
-        }
-    });
-    // exclusive: false disables SO_EXCLUSIVEADDRUSE on Windows, allowing
-    // rebind after a crashed predecessor left orphaned sockets behind.
-    server.listen({ port: opts.port, host: opts.hostname, reuseAddr: true, exclusive: false });
     server.unref();
     server.timeout = NODE_HTTP_IDLE_TIMEOUT_MS;
     server.keepAliveTimeout = 10000;
     server.headersTimeout = 11000;
-    if (listenError) {
-        throw listenError;
-    }
-    return {
-        stop: () => {
-            server.closeAllConnections();
-            server.close();
-        },
-    };
+    // Node reports EADDRINUSE after listen() returns, so wait for the outcome.
+    // Callers then see a busy port the same way they do under Bun.
+    return new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off("listening", onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off("error", onError);
+            // Keep a listener, so a later server error is logged instead of crashing the process.
+            server.on("error", (error) => log("Web server error", { error: String(error) }));
+            resolve({
+                stop: () => {
+                    server.closeAllConnections();
+                    server.close();
+                },
+            });
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        // exclusive: false disables SO_EXCLUSIVEADDRUSE on Windows, allowing
+        // rebind after a crashed predecessor left orphaned sockets behind.
+        server.listen({ port: opts.port, host: opts.hostname, reuseAddr: true, exclusive: false });
+    });
 }
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -157,6 +161,26 @@ export class WebServer {
             return this.jsonResponse({ error: error instanceof Error ? error.message : "Import request failed" }, typeof code === "number" ? code : 400);
         }
     }
+    /** Claude Code hook requests; they reach this point only with a valid API token. */
+    async claudeHookResponse(req, path) {
+        const api = await import("../importer/claude-hook-api.js");
+        const body = await req.json().catch(() => null);
+        try {
+            if (path === "/api/claude/capture") {
+                return this.jsonResponse(api.handleClaudeCapture(body), 202);
+            }
+            const cwd = this.config.directory ?? process.cwd();
+            return this.jsonResponse(await api.handleClaudeRetrieve(body, {
+                startBackfill: async () => (await this.backfillControls()).startAuto("claude-code", cwd),
+            }));
+        }
+        catch (error) {
+            if (error instanceof api.ClaudeHookRequestError) {
+                return this.jsonResponse({ error: error.message }, error.status);
+            }
+            throw error;
+        }
+    }
     async backfillControls() {
         const { BackfillControls } = await import("../importer/web-import-api.js");
         return (this.backfillControlsInstance ??= new BackfillControls());
@@ -192,12 +216,16 @@ export class WebServer {
             .catch(() => { });
         assertWebServerNetworkAuth(this.config.host, this.config.apiToken, this.config.auth?.isEnabled() ?? false);
         try {
-            this.server = serveFetch({
+            this.server = await serveFetch({
                 port: this.config.port,
                 hostname: this.config.host,
                 fetch: this.handleRequest.bind(this),
             });
             this.isOwner = true;
+            // This process serves the Claude Code hooks, so it also retries their failed captures.
+            void import("../importer/claude-hook-api.js")
+                .then(({ startClaudeCodeWorker }) => startClaudeCodeWorker())
+                .catch(() => { });
         }
         catch (error) {
             const errorMsg = String(error);
@@ -426,12 +454,13 @@ export class WebServer {
                 return this.jsonResponse({
                     pi: await readBackfillStatus("pi"),
                     opencode: await readBackfillStatus("opencode"),
+                    "claude-code": await readBackfillStatus("claude-code"),
                 });
             }
             if (path === "/api/settings/backfill/runs" && method === "GET") {
                 return this.jsonResponse(await (await this.backfillControls()).status());
             }
-            const backfillAction = /^\/api\/settings\/backfill\/(pi|opencode)\/(run|pause|resume)$/.exec(path);
+            const backfillAction = /^\/api\/settings\/backfill\/(pi|opencode|claude-code)\/(run|pause|resume)$/.exec(path);
             if (backfillAction && method === "POST") {
                 const host = backfillAction[1];
                 const controls = await this.backfillControls();
@@ -569,7 +598,7 @@ export class WebServer {
                     retryQueue: await countCaptureRetries(CONFIG),
                 });
             }
-            const retryNow = /^\/api\/settings\/capture-retry\/(pi|opencode)\/run$/.exec(path);
+            const retryNow = /^\/api\/settings\/capture-retry\/(pi|opencode|claude-code)\/run$/.exec(path);
             if (retryNow && method === "POST") {
                 const [{ CONFIG }, { requestCaptureRetryNow }] = await Promise.all([
                     import("../config.js"),
@@ -620,16 +649,16 @@ export class WebServer {
                     return this.jsonResponse({ error: "Browsing is available only on a loopback bind; enter a path instead" }, 403);
                 }
                 const body = (await req.json());
-                if (body?.host !== "pi" && body?.host !== "opencode") {
-                    return this.jsonResponse({ error: "Choose Pi or OpenCode" }, 400);
+                if (body?.host !== "pi" && body?.host !== "opencode" && body?.host !== "claude-code") {
+                    return this.jsonResponse({ error: "Choose Pi, OpenCode, or Claude Code" }, 400);
                 }
                 const { browseImportSources } = await import("../importer/web-import-api.js");
                 return this.importResponse(() => browseImportSources(body.host, body.path));
             }
             if (path === "/api/settings/imports/sources/validate" && method === "POST") {
                 const body = (await req.json());
-                if (body?.host !== "pi" && body?.host !== "opencode") {
-                    return this.jsonResponse({ error: "Choose Pi or OpenCode" }, 400);
+                if (body?.host !== "pi" && body?.host !== "opencode" && body?.host !== "claude-code") {
+                    return this.jsonResponse({ error: "Choose Pi, OpenCode, or Claude Code" }, 400);
                 }
                 const { validateImportSource } = await import("../importer/web-import-api.js");
                 return this.importResponse(() => validateImportSource(body.host, body.path));
@@ -718,6 +747,10 @@ export class WebServer {
                 const result = await handleSearch(query, tag, page, pageSize);
                 return this.jsonResponse(result);
             }
+            if ((path === "/api/claude/retrieve" || path === "/api/claude/capture") &&
+                method === "POST") {
+                return this.claudeHookResponse(req, path);
+            }
             if (path === "/api/stats" && method === "GET") {
                 const result = await handleStats();
                 return this.jsonResponse(result);

package/dist/types/host-label.d.ts

@@ -0,0 +1,3 @@
+import type { MemoryHost } from "./index.js";
+/** The host's display name in messages and reports. */
+export declare function hostLabel(host: MemoryHost): string;

package/dist/types/host-label.js

@@ -0,0 +1,9 @@
+const HOST_LABELS = {
+    opencode: "OpenCode",
+    pi: "Pi",
+    "claude-code": "Claude Code",
+};
+/** The host's display name in messages and reports. */
+export function hostLabel(host) {
+    return HOST_LABELS[host];
+}

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 export type MemoryType = string;
-export type MemoryHost = "opencode" | "pi";
+export type MemoryHost = "opencode" | "pi" | "claude-code";
 export type MemorySourceType = "live-capture" | "history-import";
 export interface MemoryMetadata {
     type?: MemoryType;