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

package/dist/cli/memory-command.js

@@ -0,0 +1,180 @@
+import { resolve } from "node:path";
+const MODES = {
+    add: "Store a memory (--content, optional --type and --tags)",
+    search: "Search project memories (query as an argument or --query)",
+    profile: "Show the user profile, or save a preference with --content",
+    list: "List recent memories (--limit, default 20)",
+    forget: "Remove a memory (--id)",
+    help: "Print the memory tool guide as JSON",
+    "list-shards": "List project memory shards and orphaned path associations",
+    migrate: "Reassociate orphaned shards after a directory move (--from-path or --from-hash)",
+    export: "Export project memories to a portable JSON file (--output)",
+    import: "Import memories from a portable JSON file (--input)",
+};
+const VALUE_FLAGS = {
+    "--content": "content",
+    "--query": "query",
+    "--type": "type",
+    "--tags": "tags",
+    "--id": "memoryId",
+    "--limit": "limit",
+    "--scope": "scope",
+    "--from-path": "fromPath",
+    "--from-hash": "fromHash",
+    "--output": "outputPath",
+    "--input": "inputPath",
+    "--directory": "directory",
+};
+const BOOLEAN_FLAGS = {
+    "--dry-run": "dryRun",
+    "--allow-linked-source": "allowLinkedSource",
+};
+export const memoryCommandUsage = `Usage: om-memory-system memory <mode> [options]
+
+Runs one memory operation for the current project and prints one JSON
+document. Memories added here are stored with host claude-code.
+
+Modes:
+${Object.entries(MODES)
+    .map(([mode, description]) => `  ${mode.padEnd(13)} ${description}`)
+    .join("\n")}
+
+Options:
+  --content <text>        Memory text (add) or preference text (profile)
+  --query <text>          Search text (search)
+  --type <type>           Memory type, for example decision or bug-fix (add)
+  --tags <a,b>            Comma-separated tags (add)
+  --id <id>               Memory id (forget)
+  --limit <n>             Maximum results (search, list)
+  --scope <scope>         project or all-projects (search, list)
+  --from-path <path>      Old project path (migrate)
+  --from-hash <hash>      Old project hash (migrate)
+  --output <file>         Export file (export)
+  --input <file>          Import file (import)
+  --dry-run               Report without writing (migrate, import)
+  --allow-linked-source   Allow a linked source directory (migrate)
+  --directory <path>      Project directory (default: the working directory)
+  --help, -h              Print this help
+
+Text inside <private>...</private> is removed before storage.
+
+Examples:
+  om-memory-system memory search "database choice"
+  om-memory-system memory add --content "Use libSQL for the store" --type decision`;
+function isMode(value) {
+    return Object.hasOwn(MODES, value);
+}
+/** Parse `<mode> [options]` into memory tool arguments. Throws on bad input. */
+export function parseMemoryCommandArgs(argv) {
+    const isHelpFlag = (value) => value === "--help" || value === "-h";
+    if (argv.length === 0 || isHelpFlag(argv[0]))
+        return { help: true, args: {} };
+    const [mode, ...rest] = argv;
+    if (!mode || !isMode(mode)) {
+        throw new Error(`Unknown memory mode "${mode}". Modes: ${Object.keys(MODES).join(", ")}`);
+    }
+    const args = { mode };
+    const values = {};
+    const positionals = [];
+    for (let index = 0; index < rest.length; index++) {
+        const token = rest[index];
+        if (isHelpFlag(token))
+            return { help: true, args: {} };
+        if (!token.startsWith("--")) {
+            positionals.push(token);
+            continue;
+        }
+        const equals = token.indexOf("=");
+        const flag = equals === -1 ? token : token.slice(0, equals);
+        const booleanKey = BOOLEAN_FLAGS[flag];
+        if (booleanKey) {
+            if (equals !== -1)
+                throw new Error(`${flag} takes no value`);
+            args[booleanKey] = true;
+            continue;
+        }
+        const key = VALUE_FLAGS[flag];
+        if (!key)
+            throw new Error(`Unknown option ${flag}`);
+        // A following flag is not a value; literal text that starts with "--" needs `--flag=value`.
+        const next = rest[index + 1];
+        const value = equals !== -1
+            ? token.slice(equals + 1)
+            : next !== undefined && !next.startsWith("--")
+                ? rest[++index]
+                : undefined;
+        if (value === undefined)
+            throw new Error(`${flag} needs a value`);
+        values[key] = value;
+    }
+    if (positionals.length > 0) {
+        if (mode !== "search" || positionals.length > 1 || values.query !== undefined) {
+            throw new Error(`Unexpected argument "${positionals[0]}"`);
+        }
+        values.query = positionals[0];
+    }
+    for (const [key, value] of Object.entries(values)) {
+        if (key === "limit") {
+            const limit = Number(value);
+            if (!Number.isInteger(limit) || limit <= 0) {
+                throw new Error("--limit needs a positive whole number");
+            }
+            args.limit = limit;
+        }
+        else if (key === "scope") {
+            if (value !== "project" && value !== "all-projects") {
+                throw new Error("--scope must be project or all-projects");
+            }
+            args.scope = value;
+        }
+        else if (key !== "directory") {
+            args[key] = value;
+        }
+    }
+    return { help: false, args, directory: values.directory };
+}
+/** Run `om-memory-system memory ...` and return the process exit code. */
+export async function runMemoryCommand(argv, io = {}) {
+    const stdout = io.stdout ?? ((text) => console.log(text));
+    const stderr = io.stderr ?? ((text) => console.error(text));
+    let parsed;
+    try {
+        parsed = parseMemoryCommandArgs(argv);
+    }
+    catch (error) {
+        stderr(`${error instanceof Error ? error.message : String(error)}\n\n${memoryCommandUsage}`);
+        return 1;
+    }
+    if (parsed.help) {
+        stdout(memoryCommandUsage);
+        return 0;
+    }
+    const directory = resolve(io.cwd ?? process.cwd(), parsed.directory ?? ".");
+    let result;
+    const secrets = [];
+    try {
+        const { CONFIG, initConfigWithLegacyMigration } = await import("../config.js");
+        initConfigWithLegacyMigration(directory);
+        for (const secret of [CONFIG.memoryApiKey, CONFIG.embeddingApiKey]) {
+            if (secret)
+                secrets.push(secret);
+        }
+        const { executeMemoryOperation } = await import("../core/memory-operations.js");
+        const { memoryClient } = await import("../services/client.js");
+        try {
+            result = await executeMemoryOperation(parsed.args, { directory, host: "claude-code" });
+        }
+        finally {
+            // Release the store so the process can exit once the reply is printed.
+            await memoryClient.close().catch(() => { });
+        }
+    }
+    catch (error) {
+        result = { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    let output = JSON.stringify(result, null, 2);
+    for (const secret of secrets)
+        output = output.replaceAll(secret, "[redacted]");
+    stdout(output);
+    return result.success === false ? 1 : 0;
+}

package/dist/core/retrieval.d.ts

@@ -6,7 +6,28 @@ export declare const RETRIEVAL_SECTION_TAG = "omms-retrieval";
  * profile). Returns null when nothing relevant is found.
  */
 export declare function buildRetrievalSection(prompt: string, directory: string, sessionId: string): Promise<string | null>;
+export interface RecentMemoriesOptions {
+    /** Project container tag, from `getTags(directory).project.tag`. */
+    projectTag: string;
+    /** Profile owner, from `getTags(directory).user.userEmail`. */
+    userEmail: string | null | undefined;
+    sessionId: string;
+    /** `CONFIG.chatMessage.maxMemories` */
+    maxMemories?: number;
+    /** `CONFIG.chatMessage.excludeCurrentSession` */
+    excludeCurrentSession?: boolean;
+    /** `CONFIG.chatMessage.maxAgeDays` */
+    maxAgeDays?: number;
+}
+/**
+ * The project's most recent memories as a context section, shared by every host
+ * that injects them at session start (OpenCode's first `chat.message`, Claude
+ * Code `SessionStart`). Returns null when no memory qualifies.
+ */
+export declare function buildRecentMemoriesSection(options: RecentMemoriesOptions): Promise<string | null>;
 /** Delimit a retrieval section so it is recognisable as injected memory, not user text. */
 export declare function wrapRetrievalSection(section: string): string;
+/** Remove injected retrieval sections, so injected memories are never captured as user text. */
+export declare function stripRetrievalSections(text: string): string;
 /** Format a session's own memories for re-injection after compaction. */
 export declare function formatMemoriesForCompaction(memories: any[]): string;

package/dist/core/retrieval.js

@@ -26,10 +26,45 @@ export async function buildRetrievalSection(prompt, directory, sessionId) {
     });
     return memoryContext || null;
 }
+/**
+ * The project's most recent memories as a context section, shared by every host
+ * that injects them at session start (OpenCode's first `chat.message`, Claude
+ * Code `SessionStart`). Returns null when no memory qualifies.
+ */
+export async function buildRecentMemoriesSection(options) {
+    const listResult = await memoryClient.listMemories(options.projectTag, options.maxMemories);
+    let memories = listResult.success ? listResult.memories : [];
+    if (options.excludeCurrentSession) {
+        memories = memories.filter((m) => m.metadata?.sessionID !== options.sessionId);
+    }
+    if (options.maxAgeDays) {
+        const cutoffDate = Date.now() - options.maxAgeDays * 86400000;
+        memories = memories.filter((m) => new Date(m.createdAt).getTime() > cutoffDate);
+    }
+    if (memories.length === 0)
+        return null;
+    const projectMemories = {
+        results: memories.map((m) => ({
+            similarity: 1.0,
+            memory: m.summary,
+        })),
+        total: memories.length,
+        timing: 0,
+    };
+    const memoryContext = await formatContextForPrompt(options.userEmail || null, projectMemories);
+    return memoryContext || null;
+}
 /** Delimit a retrieval section so it is recognisable as injected memory, not user text. */
 export function wrapRetrievalSection(section) {
     return `<${RETRIEVAL_SECTION_TAG}>\n${section}\n</${RETRIEVAL_SECTION_TAG}>`;
 }
+// Only a closed section is injected context: `wrapRetrievalSection` always closes it, and the
+// Claude Code hook keeps the closing tag when it truncates. An unclosed tag is user text.
+const RETRIEVAL_SECTION_RE = new RegExp(`<${RETRIEVAL_SECTION_TAG}>[\\s\\S]*?</${RETRIEVAL_SECTION_TAG}>`, "g");
+/** Remove injected retrieval sections, so injected memories are never captured as user text. */
+export function stripRetrievalSections(text) {
+    return text.replace(RETRIEVAL_SECTION_RE, "").trim();
+}
 const EMBEDDED_TAGS_FOOTER_RE = /\n*Tags: ([^\n]*)\s*$/;
 function normalizeTagsKey(tags) {
     return tags

package/dist/importer/backfill-controls.d.ts

@@ -42,6 +42,16 @@ export declare class BackfillControls {
     runNow(host: BackfillHost, cwd: string): Promise<{
         started: true;
     }>;
+    /**
+     * The automatic run after a host start, under the auto-backfill rules: the
+     * start-up delay, `autoBackfill`, pause, and the single-run lock. The web
+     * app calls it on the first Claude Code session start. Returns false when
+     * the run cannot start here.
+     */
+    startAuto(host: BackfillHost, cwd: string): Promise<{
+        started: boolean;
+    }>;
+    private launch;
     /** Stop after the current exchange; a run in another process sees the flag at its next write. */
     pause(host: BackfillHost): Promise<{
         paused: true;

package/dist/importer/backfill-controls.js

@@ -1,6 +1,7 @@
 import { CONFIG } from "../config.js";
 import { log } from "../services/logger.js";
-import { getAutoCaptureProviderStatus, resolvePiLiveModel, } from "../services/ai/live-model-choice.js";
+import { hostLabel } from "../types/host-label.js";
+import { externalModelIssues, getAutoCaptureProviderStatus, resolvePiLiveModel, } from "../services/ai/live-model-choice.js";
 import { parseBackfillModel } from "./backfill-model.js";
 import { readImportRun, setBackfillPaused } from "./import-runs.js";
 /** A host runtime in this process that can resolve its signed-in backfill models. */
@@ -24,7 +25,6 @@ export class BackfillControlError extends Error {
         this.name = "BackfillControlError";
     }
 }
-const label = (host) => (host === "pi" ? "Pi" : "OpenCode");
 /** True when the host's backfill model is the external API, directly or through the live rule. */
 export function backfillUsesExternal(host) {
     const choice = parseBackfillModel(CONFIG, host);
@@ -39,10 +39,15 @@ export function backfillUsesExternal(host) {
 }
 /** Why Run now is not available for the host in this process, or null when it is. */
 export function runNowUnavailableReason(host) {
+    // Claude Code has no host model: its backfill needs the external API, so name the missing setting.
+    if (host === "claude-code") {
+        const issues = externalModelIssues(CONFIG);
+        return issues.length > 0 ? issues.join("; ") : null;
+    }
     if (hostResolvers.has(host))
         return null;
     if (!backfillUsesExternal(host)) {
-        return `Open ${label(host)}, or choose the external API for ${label(host)}'s backfill`;
+        return `Open ${hostLabel(host)}, or choose the external API for ${hostLabel(host)}'s backfill`;
     }
     return null;
 }
@@ -61,7 +66,11 @@ export class BackfillControls {
             run: await readImportRun(host),
             runNowUnavailable: runNowUnavailableReason(host),
         });
-        return { pi: await entry("pi"), opencode: await entry("opencode") };
+        return {
+            pi: await entry("pi"),
+            opencode: await entry("opencode"),
+            "claude-code": await entry("claude-code"),
+        };
     }
     async runNow(host, cwd) {
         const reason = runNowUnavailableReason(host);
@@ -69,10 +78,10 @@ export class BackfillControls {
             throw new BackfillControlError(reason, 409);
         const current = await readImportRun(host);
         if (current?.state === "running" || this.controllers.has(host)) {
-            throw new BackfillControlError(`${host === "pi" ? "A" : "An"} ${label(host)} import is already running`, 409);
+            throw new BackfillControlError(`${host === "opencode" ? "An" : "A"} ${hostLabel(host)} import is already running`, 409);
         }
         if (current?.paused) {
-            throw new BackfillControlError(`${label(host)}'s backfill is paused; resume it first`, 409);
+            throw new BackfillControlError(`${hostLabel(host)}'s backfill is paused; resume it first`, 409);
         }
         // Fail fast with the missing setting instead of starting a run that cannot call a model.
         if (backfillUsesExternal(host) || !hostResolvers.has(host)) {
@@ -81,19 +90,40 @@ export class BackfillControls {
             if (issues.length > 0)
                 throw new BackfillControlError(issues.join("; "), 409);
         }
+        await this.launch(host, cwd, true);
+        return { started: true };
+    }
+    /**
+     * The automatic run after a host start, under the auto-backfill rules: the
+     * start-up delay, `autoBackfill`, pause, and the single-run lock. The web
+     * app calls it on the first Claude Code session start. Returns false when
+     * the run cannot start here.
+     */
+    async startAuto(host, cwd) {
+        if (this.controllers.has(host))
+            return { started: false };
+        const reason = runNowUnavailableReason(host);
+        if (reason) {
+            log("Automatic backfill not started", { host, reason });
+            return { started: false };
+        }
+        await this.launch(host, cwd, false);
+        return { started: true };
+    }
+    async launch(host, cwd, userStarted) {
         const controller = new AbortController();
         this.controllers.set(host, controller);
         const { scheduleAutoBackfill } = await import("./auto-backfill.js");
+        const source = userStarted ? "Backfill from the Settings page" : "Automatic backfill";
         void scheduleAutoBackfill({
             host,
             cwd,
             signal: controller.signal,
-            surface: "web",
-            userStarted: true,
+            ...(userStarted ? { surface: "web", userStarted: true } : {}),
             resolveModels: () => resolveModels(host),
-            notify: (message) => log("Backfill from the Settings page", { host, message: message.slice(0, 200) }),
+            notify: (message) => log(source, { host, message: message.slice(0, 200) }),
         })
-            .catch((error) => log("Backfill from the Settings page failed", {
+            .catch((error) => log(`${source} failed`, {
             host,
             error: error instanceof Error ? error.name : "unknown",
         }))
@@ -101,7 +131,6 @@ export class BackfillControls {
             if (this.controllers.get(host) === controller)
                 this.controllers.delete(host);
         });
-        return { started: true };
     }
     /** Stop after the current exchange; a run in another process sees the flag at its next write. */
     async pause(host) {

package/dist/importer/backfill-model.d.ts

@@ -1,4 +1,4 @@
-export type BackfillHost = "pi" | "opencode";
+export type BackfillHost = "pi" | "opencode" | "claude-code";
 export type BackfillModel = "inherit" | "external" | {
     provider: string;
     model: string;

package/dist/importer/backfill-model.js

@@ -1,5 +1,8 @@
 /** Parse the global backfill model without importing the runtime config. */
 export function parseBackfillModel(config, host) {
+    // Claude Code hooks cannot call a session model, so its backfill has no setting.
+    if (host === "claude-code")
+        return "external";
     const value = host === "pi" ? config.piBackfillModel : config.opencodeBackfillModel;
     if (value === undefined || value === "inherit")
         return "inherit";

package/dist/importer/claude-conversation.d.ts

@@ -0,0 +1,74 @@
+import type { ImportWindow } from "./importer.js";
+/**
+ * Pure parsing of Claude Code session transcripts
+ * (`~/.claude/projects/<project-folder>/<session-id>.jsonl`). The format is
+ * internal to Claude Code and changes between versions, so the view below is
+ * structural and minimal. It was written against Claude Code v2.1.284 and is
+ * pinned by the fixtures in `tests/fixtures/claude-transcripts/`.
+ *
+ * Live capture and the history import both build their work units here.
+ */
+export interface ClaudeContentBlock {
+    type: string;
+    text?: string;
+    thinking?: string;
+    id?: string;
+    name?: string;
+    input?: unknown;
+    tool_use_id?: string;
+    content?: unknown;
+}
+export interface ClaudeTranscriptEntry {
+    type: string;
+    uuid?: string;
+    parentUuid?: string | null;
+    timestamp?: string;
+    cwd?: string;
+    sessionId?: string;
+    isMeta?: boolean;
+    isSidechain?: boolean;
+    version?: string;
+    message?: {
+        id?: string;
+        role?: string;
+        content?: string | ClaudeContentBlock[];
+    };
+}
+export type ClaudeLineResult = {
+    status: "entry";
+    entry: ClaudeTranscriptEntry;
+} | {
+    status: "unknown-type";
+} | {
+    status: "unreadable";
+} | {
+    status: "blank";
+};
+export interface ParsedClaudeTranscript {
+    entries: ClaudeTranscriptEntry[];
+    unreadableLines: number;
+    unknownTypes: number;
+}
+export interface ClaudeConversationWindow extends ImportWindow {
+    /** Working directory recorded on the prompt entry. */
+    cwd: string | null;
+}
+/** Parse one transcript line. A JSON value without a string `type` is unreadable. */
+export declare function parseClaudeTranscriptLine(line: string): ClaudeLineResult;
+/** Parse a whole transcript, counting the lines that were skipped. */
+export declare function parseClaudeTranscript(text: string): ParsedClaudeTranscript;
+/**
+ * All capture windows in a transcript, oldest first: one per user prompt that
+ * produced assistant text or tool work. Sidechain (subagent) entries, meta
+ * entries, and tool results are skipped; tool results and meta entries do not
+ * end a turn. Thinking blocks are never included. Tool inputs are bounded by
+ * the same truncation policy as the other hosts.
+ */
+export declare function extractClaudeConversationWindows(entries: ClaudeTranscriptEntry[]): ClaudeConversationWindow[];
+/**
+ * Windows for live capture: every window whose prompt comes after the cursor
+ * entry. Without a cursor, or when the cursor is no longer in the transcript,
+ * only the last window is returned, so a lost cursor never re-captures a
+ * whole session.
+ */
+export declare function extractClaudeWindowsAfter(entries: ClaudeTranscriptEntry[], cursorUserUuid: string | null): ClaudeConversationWindow[];