om-memory-system 3.0.0

package/dist/utils/math.js

@@ -0,0 +1,48 @@
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length)
+        return 0;
+    let dot = 0;
+    let magA = 0;
+    let magB = 0;
+    for (let i = 0; i < a.length; i++) {
+        const av = a[i] ?? 0;
+        const bv = b[i] ?? 0;
+        dot += av * bv;
+        magA += av * av;
+        magB += bv * bv;
+    }
+    if (magA === 0 || magB === 0)
+        return 0;
+    return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+}
+/**
+ * Cosine similarity for number[] (JSON-stored centroids), otherwise
+ * identical to the Float32Array version above.
+ */
+export function cosineSimilarityNumbers(a, b) {
+    if (a.length !== b.length)
+        return 0;
+    let dot = 0;
+    let magA = 0;
+    let magB = 0;
+    for (let i = 0; i < a.length; i++) {
+        const av = a[i] ?? 0;
+        const bv = b[i] ?? 0;
+        dot += av * bv;
+        magA += av * av;
+        magB += bv * bv;
+    }
+    if (magA === 0 || magB === 0)
+        return 0;
+    return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+}
+export function l2Normalize(vec) {
+    let norm = 0;
+    for (let i = 0; i < vec.length; i++) {
+        norm += (vec[i] ?? 0) * (vec[i] ?? 0);
+    }
+    norm = Math.sqrt(norm);
+    if (norm === 0)
+        return vec;
+    return vec.map((v) => v / norm);
+}

package/dist/utils/profile.d.ts

@@ -0,0 +1,2 @@
+export declare function isFrozen(item: any): boolean;
+export declare function sortProfileItems(items: any[], metric: "confidence" | "frequency"): any[];

package/dist/utils/profile.js

@@ -0,0 +1,15 @@
+export function isFrozen(item) {
+    return (item.driftBelowCount || 0) >= 2;
+}
+export function sortProfileItems(items, metric) {
+    return [...items].sort((a, b) => {
+        const aFrozen = isFrozen(a) ? 1 : 0;
+        const bFrozen = isFrozen(b) ? 1 : 0;
+        if (aFrozen !== bFrozen)
+            return aFrozen - bFrozen;
+        if (metric === "confidence") {
+            return (b.confidence || 0) - (a.confidence || 0) || (b.frequency || 1) - (a.frequency || 1);
+        }
+        return (b.frequency || 0) - (a.frequency || 0);
+    });
+}

package/dist/v2/adapter.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from "@opencode/plugin/promise/plugin";
+import type { V2MemoryBridge } from "./memory-bridge.js";
+/** Per-session state is bounded so long-running servers cannot grow it without limit. */
+export declare const MAX_TRACKED_SESSIONS = 256;
+export declare function registerV2Adapter(ctx: Context, legacy: any, memory: V2MemoryBridge): Promise<() => Promise<void>>;

package/dist/v2/adapter.js

@@ -0,0 +1,218 @@
+import { log } from "../services/logger.js";
+import { eventBelongsToLocation, legacyToolResult, toLegacyEvent } from "./legacy-client.js";
+const memoryInput = {
+    type: "object",
+    properties: {
+        mode: {
+            type: "string",
+            enum: [
+                "add",
+                "search",
+                "profile",
+                "list",
+                "forget",
+                "help",
+                "migrate",
+                "list-shards",
+                "export",
+                "import",
+            ],
+        },
+        content: { type: "string" },
+        query: { type: "string" },
+        tags: { type: "string" },
+        type: { type: "string" },
+        memoryId: { type: "string" },
+        limit: { type: "number" },
+        scope: { type: "string", enum: ["project", "all-projects"] },
+        fromPath: { type: "string" },
+        fromHash: { type: "string" },
+        outputPath: { type: "string" },
+        inputPath: { type: "string" },
+        dryRun: { type: "boolean" },
+        allowLinkedSource: { type: "boolean" },
+    },
+    additionalProperties: false,
+};
+/** Per-session state is bounded so long-running servers cannot grow it without limit. */
+export const MAX_TRACKED_SESSIONS = 256;
+/** Unadmitted prompts kept per session before the oldest is dropped. */
+const MAX_PENDING_PROMPTS = 16;
+/** Compaction is restored natively through the `compaction` hook, never via the V1 event path. */
+const COMPACTION_EVENT_TYPES = new Set(["session.compacted", "session.compaction.ended"]);
+function setBounded(map, key, value) {
+    map.delete(key);
+    map.set(key, value);
+    while (map.size > MAX_TRACKED_SESSIONS) {
+        const oldest = map.keys().next().value;
+        if (oldest === undefined)
+            break;
+        map.delete(oldest);
+    }
+}
+function withTimeout(promise, ms, fallback) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(fallback), ms);
+    });
+    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+function deletedSessionID(event) {
+    if (event.type !== "session.deleted")
+        return undefined;
+    const props = event.properties ?? {};
+    return props.sessionID ?? props.info?.id ?? props.session?.id;
+}
+export async function registerV2Adapter(ctx, legacy, memory) {
+    const retrievals = new Map();
+    const restored = new Map();
+    const messageIDs = new Map();
+    // The prompt hook runs before OpenCode admits a prompt, so prompts wait here
+    // until their message appears in a model request's history (the context
+    // hook), and are only then recorded for auto-capture and profile learning.
+    const pendingPrompts = new Map();
+    const forgetSession = (sessionID) => {
+        retrievals.delete(sessionID);
+        restored.delete(sessionID);
+        messageIDs.delete(sessionID);
+        pendingPrompts.delete(sessionID);
+    };
+    const recordAdmittedPrompts = async (sessionID, messages) => {
+        const pending = pendingPrompts.get(sessionID);
+        if (!pending?.length)
+            return;
+        const admitted = new Set(messages.map((message) => message.id).filter(Boolean));
+        const remaining = [];
+        for (const prompt of pending) {
+            if (!admitted.has(prompt.messageID)) {
+                remaining.push(prompt);
+                continue;
+            }
+            try {
+                await memory.recordPrompt(sessionID, prompt.messageID, prompt.text);
+            }
+            catch (error) {
+                log("v2 context: failed to record user prompt", { sessionID, error: String(error) });
+            }
+        }
+        if (remaining.length > 0)
+            pendingPrompts.set(sessionID, remaining);
+        else
+            pendingPrompts.delete(sessionID);
+    };
+    // Resolve a prompt's retrieval once; every model step for that prompt then
+    // reuses the same section, even if the search finishes after the timeout.
+    const settledRetrieval = async (retrieval) => {
+        if (!retrieval.settled) {
+            const value = await withTimeout(retrieval.promise, memory.retrievalTimeoutMs, null);
+            retrieval.settled ??= { value };
+        }
+        return retrieval.settled.value;
+    };
+    await ctx.tool.transform((editor) => editor.add({
+        name: "memory",
+        description: legacy.tool.memory.description,
+        input: memoryInput,
+        // A direct tool like OpenCode's own read/grep/skill, not a Code Mode catalog entry,
+        // so the model can always see and call it (as it can on V1 and Pi).
+        options: { codemode: false },
+        execute: async (args, toolContext) => legacyToolResult(await legacy.tool.memory.execute(args, {
+            sessionID: toolContext.sessionID,
+            messageID: toolContext.messageID,
+            agent: toolContext.agent,
+            directory: ctx.location.directory,
+            worktree: ctx.location.project.directory,
+            abort: new AbortController().signal,
+            metadata() { },
+            async ask() { },
+        })),
+    }));
+    await ctx.session.hook("prompt", async (event) => {
+        const sessionID = event.sessionID;
+        const text = event.prompt.text ?? "";
+        setBounded(messageIDs, sessionID, event.messageID);
+        retrievals.delete(sessionID);
+        if (!memory.isConfigured() || memory.isInternalPrompt(sessionID, text))
+            return;
+        if (text.trim()) {
+            const pending = [
+                ...(pendingPrompts.get(sessionID) ?? []),
+                { messageID: event.messageID, text },
+            ].slice(-MAX_PENDING_PROMPTS);
+            setBounded(pendingPrompts, sessionID, pending);
+        }
+        if (!memory.isInjectionEnabled() || !text.trim())
+            return;
+        // Start the search now so it overlaps prompt admission; `context` awaits it.
+        const promise = memory.retrieve(text, sessionID).catch((error) => {
+            log("v2 prompt: memory retrieval failed", { sessionID, error: String(error) });
+            return null;
+        });
+        setBounded(retrievals, sessionID, { promise });
+    });
+    await ctx.session.hook("context", async (event) => {
+        const sessionID = event.sessionID;
+        // Before chat.params, which stores the model on the recorded prompt row.
+        await recordAdmittedPrompts(sessionID, event.messages);
+        const retrieval = retrievals.get(sessionID);
+        if (retrieval) {
+            const section = await settledRetrieval(retrieval);
+            if (section)
+                event.system.push({ type: "text", text: section });
+        }
+        const restoredSection = restored.get(sessionID);
+        if (restoredSection)
+            event.system.push({ type: "text", text: restoredSection });
+        if (legacy["chat.params"]) {
+            await legacy["chat.params"]({
+                message: { id: messageIDs.get(sessionID) ?? sessionID },
+                model: { providerID: event.model.providerID, id: event.model.id },
+            });
+        }
+    });
+    await ctx.session.hook("compaction", async (event) => {
+        if (!memory.isCompactionEnabled())
+            return;
+        const sessionID = event.sessionID;
+        try {
+            const section = await memory.restoreSession(sessionID);
+            if (section)
+                setBounded(restored, sessionID, section);
+            else
+                restored.delete(sessionID);
+        }
+        catch (error) {
+            log("v2 compaction: failed to load session memories", { sessionID, error: String(error) });
+        }
+    });
+    const controller = new AbortController();
+    const watcher = (async () => {
+        try {
+            for await (const raw of ctx.event.subscribe({ signal: controller.signal })) {
+                const event = toLegacyEvent(raw);
+                const deleted = deletedSessionID(event);
+                if (deleted)
+                    forgetSession(deleted);
+                if (!legacy.event || COMPACTION_EVENT_TYPES.has(event.type))
+                    continue;
+                if (await eventBelongsToLocation(ctx, raw)) {
+                    await legacy.event({ event });
+                }
+            }
+        }
+        catch (error) {
+            if (!controller.signal.aborted) {
+                log("omms v2 event bridge failed", { error: String(error) });
+            }
+        }
+    })();
+    return async () => {
+        controller.abort();
+        await watcher;
+        retrievals.clear();
+        restored.clear();
+        messageIDs.clear();
+        pendingPrompts.clear();
+        await legacy.dispose?.();
+    };
+}

package/dist/v2/legacy-client.d.ts

@@ -0,0 +1,15 @@
+import type { Context } from "@opencode/plugin/promise/plugin";
+/**
+ * Adapts the released OpenCode v2 plugin context to the V1 client shape used
+ * by the shared omms implementation.
+ */
+export declare function createLegacyClient(ctx: Context): any;
+export declare function legacyToolResult(value: unknown): {
+    content: string;
+    metadata?: unknown;
+};
+export declare function toLegacyEvent(raw: any): {
+    type: string;
+    properties: any;
+};
+export declare function eventBelongsToLocation(ctx: Context, raw: any): Promise<boolean>;

package/dist/v2/legacy-client.js

@@ -0,0 +1,257 @@
+import { randomUUID } from "node:crypto";
+import { resolve } from "node:path";
+function textFromParts(parts = []) {
+    return parts
+        .filter((part) => part.type === "text")
+        .map((part) => part.text ?? "")
+        .join("\n");
+}
+function parseJson(text) {
+    const trimmed = text.trim();
+    const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i)?.[1];
+    const candidate = fenced ?? trimmed;
+    try {
+        return JSON.parse(candidate);
+    }
+    catch {
+        const start = candidate.indexOf("{");
+        const end = candidate.lastIndexOf("}");
+        if (start >= 0 && end > start) {
+            return JSON.parse(candidate.slice(start, end + 1));
+        }
+        throw new Error("Model did not return a JSON object");
+    }
+}
+function legacyMessage(message, sessionID) {
+    if (message.type === "user" || message.type === "synthetic" || message.type === "system") {
+        return {
+            info: { id: message.id, sessionID, role: "user", agent: message.agent },
+            parts: [
+                {
+                    id: `${message.id}-text`,
+                    sessionID,
+                    messageID: message.id,
+                    type: "text",
+                    text: message.text ?? "",
+                    synthetic: message.type !== "user",
+                },
+            ],
+        };
+    }
+    if (message.type === "assistant") {
+        return {
+            info: {
+                id: message.id,
+                sessionID,
+                role: "assistant",
+                agent: message.agent,
+                mode: message.agent,
+            },
+            parts: (message.content ?? []).map((part, index) => ({
+                id: part.id ?? `${message.id}-${index}`,
+                sessionID,
+                messageID: message.id,
+                ...part,
+            })),
+        };
+    }
+    if (message.type === "compaction") {
+        return {
+            info: {
+                id: message.id,
+                sessionID,
+                role: "assistant",
+                summary: true,
+                mode: "compaction",
+            },
+            parts: [],
+        };
+    }
+    return {
+        info: { id: message.id ?? randomUUID(), sessionID, role: "assistant" },
+        parts: [],
+    };
+}
+function sessionIDFrom(input) {
+    return input?.sessionID ?? input?.path?.id;
+}
+function bodyFrom(input) {
+    return input?.body ?? input ?? {};
+}
+function schemaPrompt(body) {
+    const sections = [body.system, textFromParts(body.parts)];
+    if (body.format?.type === "json_schema" && body.format.schema) {
+        sections.push([
+            "Return only one JSON object matching this JSON Schema.",
+            "Do not wrap the JSON in Markdown.",
+            JSON.stringify(body.format.schema),
+        ].join("\n"));
+    }
+    return sections.filter(Boolean).join("\n\n");
+}
+function toastFallback(input) {
+    const body = bodyFrom(input);
+    const message = [body.title, body.message].filter(Boolean).join(": ");
+    if (message) {
+        const method = body.variant === "error" ? "error" : body.variant === "warning" ? "warn" : "info";
+        console[method](`[omms] ${message}`);
+    }
+    return { data: false };
+}
+/**
+ * Adapts the released OpenCode v2 plugin context to the V1 client shape used
+ * by the shared omms implementation.
+ */
+export function createLegacyClient(ctx) {
+    const generatedSessions = new Set();
+    const client = {
+        app: { log: async () => ({ data: true }) },
+        provider: {
+            list: async () => {
+                const models = await ctx.model.list();
+                const connected = [
+                    ...new Set(models.data.map((model) => model.providerID).filter(Boolean)),
+                ];
+                return { data: { connected } };
+            },
+        },
+        tui: {
+            showToast: async (input) => toastFallback(input),
+            appendPrompt: async () => ({ data: false }),
+            submitPrompt: async () => ({ data: false }),
+        },
+        session: {
+            get: async (input) => {
+                const sessionID = sessionIDFrom(input);
+                if (!sessionID)
+                    throw new Error("session id required");
+                return { data: await ctx.session.get({ sessionID }) };
+            },
+            messages: async (input) => {
+                const sessionID = sessionIDFrom(input);
+                if (!sessionID)
+                    throw new Error("session id required");
+                return {
+                    data: (await ctx.session.context({ sessionID })).map((message) => legacyMessage(message, sessionID)),
+                };
+            },
+            create: async () => {
+                // OpenCode v2's plugin Generate API is intentionally sessionless.
+                // Keep a synthetic id so the existing structured-output lifecycle can
+                // retain its create/prompt/delete contract without polluting history.
+                const id = randomUUID();
+                generatedSessions.add(id);
+                return { data: { id } };
+            },
+            prompt: async (input) => {
+                const sessionID = sessionIDFrom(input);
+                if (!sessionID)
+                    throw new Error("session id required");
+                const body = bodyFrom(input);
+                if (generatedSessions.has(sessionID)) {
+                    const model = body.model?.providerID && body.model?.modelID
+                        ? { providerID: body.model.providerID, id: body.model.modelID }
+                        : undefined;
+                    const generated = await ctx.generate.text({
+                        prompt: schemaPrompt(body),
+                        ...(model ? { model } : {}),
+                    });
+                    const text = generated?.text ?? "";
+                    const structured = body.format?.type === "json_schema" ? parseJson(text) : undefined;
+                    return {
+                        data: {
+                            info: {
+                                id: randomUUID(),
+                                role: "assistant",
+                                structured_output: structured,
+                                structured,
+                            },
+                            parts: [{ type: "text", text }],
+                        },
+                    };
+                }
+                const text = textFromParts(body.parts);
+                if (body.noReply) {
+                    const data = await ctx.session.synthetic({
+                        sessionID,
+                        text,
+                        description: "memory context",
+                        metadata: body.parts?.[0]?.metadata,
+                    });
+                    return { data, response: new Response(null, { status: 200 }) };
+                }
+                const data = await ctx.session.prompt({
+                    sessionID,
+                    text,
+                    delivery: "queue",
+                    metadata: body.parts?.[0]?.metadata,
+                });
+                return { data, response: new Response(null, { status: 200 }) };
+            },
+            abort: async (input) => {
+                const sessionID = sessionIDFrom(input);
+                if (sessionID && generatedSessions.has(sessionID)) {
+                    generatedSessions.delete(sessionID);
+                    return { data: true };
+                }
+                if (sessionID) {
+                    const result = await ctx.session.interrupt({ sessionID });
+                    return { data: result.interrupted };
+                }
+                return { data: false };
+            },
+            delete: async (input) => {
+                const sessionID = sessionIDFrom(input);
+                if (sessionID)
+                    generatedSessions.delete(sessionID);
+                return { data: true };
+            },
+        },
+    };
+    return client;
+}
+export function legacyToolResult(value) {
+    if (typeof value === "string")
+        return { content: value };
+    if (value && typeof value === "object" && typeof value.output === "string") {
+        return { content: value.output, metadata: value.metadata };
+    }
+    return { content: JSON.stringify(value ?? null) };
+}
+export function toLegacyEvent(raw) {
+    const envelope = raw?.payload ?? raw;
+    const source = envelope?.type === "sync" && envelope.syncEvent ? envelope.syncEvent : envelope;
+    const rawType = typeof source?.type === "string" ? source.type.replace(/\.1$/, "") : source?.type;
+    const type = rawType === "session.compaction.ended" ? "session.compacted" : rawType;
+    const data = source?.data ?? {};
+    if (source && typeof source === "object" && "properties" in source) {
+        return { type, properties: source.properties };
+    }
+    if (type === "session.created" || type === "session.updated") {
+        return { type, properties: { info: data.session ?? data.info ?? data } };
+    }
+    return { type, properties: data };
+}
+export async function eventBelongsToLocation(ctx, raw) {
+    const directory = raw?.location?.directory ??
+        raw?.directory ??
+        raw?.payload?.location?.directory ??
+        raw?.payload?.directory ??
+        raw?.data?.info?.directory;
+    if (typeof directory === "string") {
+        return resolve(directory) === resolve(ctx.location.directory);
+    }
+    const data = raw?.data ?? raw?.payload?.data ?? raw?.properties;
+    const sessionID = data?.sessionID ?? data?.session?.id ?? data?.info?.id;
+    if (!sessionID)
+        return false;
+    try {
+        const session = await ctx.session.get({ sessionID });
+        const sessionDirectory = session?.location?.directory ?? session?.directory ?? session?.data?.directory;
+        return (typeof sessionDirectory === "string" &&
+            resolve(sessionDirectory) === resolve(ctx.location.directory));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/v2/memory-bridge.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The memory operations the native OpenCode v2 hooks need, bound to the
+ * plugin's location. Kept separate from the adapter so hook wiring can be
+ * tested without a real store.
+ */
+export interface V2MemoryBridge {
+    readonly retrievalTimeoutMs: number;
+    isConfigured(): boolean;
+    isInjectionEnabled(): boolean;
+    isCompactionEnabled(): boolean;
+    isInternalPrompt(sessionID: string, text: string): boolean;
+    recordPrompt(sessionID: string, messageID: string, text: string): Promise<void>;
+    /** Wrapped per-prompt retrieval section, or null when nothing is relevant. */
+    retrieve(prompt: string, sessionID: string): Promise<string | null>;
+    /** The session's own memories formatted for restore after compaction, or null. */
+    restoreSession(sessionID: string): Promise<string | null>;
+}
+export declare function createV2MemoryBridge(directory: string): V2MemoryBridge;

package/dist/v2/memory-bridge.js

@@ -0,0 +1,29 @@
+import { CONFIG, isConfigured } from "../config.js";
+import { buildRetrievalSection, formatMemoriesForCompaction, wrapRetrievalSection, } from "../core/retrieval.js";
+import { isInternalPrompt, recordUserPrompt } from "../adapters/opencode/user-prompt.js";
+import { memoryClient } from "../services/client.js";
+import { V2_RETRIEVAL_TIMEOUT_MS } from "../services/request-timeouts.js";
+import { getTags } from "../services/tags.js";
+export function createV2MemoryBridge(directory) {
+    return {
+        retrievalTimeoutMs: V2_RETRIEVAL_TIMEOUT_MS,
+        isConfigured,
+        isInjectionEnabled: () => isConfigured() && Boolean(CONFIG.chatMessage.enabled),
+        isCompactionEnabled: () => isConfigured() && Boolean(CONFIG.compaction.enabled),
+        isInternalPrompt,
+        async recordPrompt(sessionID, messageID, text) {
+            await recordUserPrompt(sessionID, messageID, directory, text);
+        },
+        async retrieve(prompt, sessionID) {
+            const section = await buildRetrievalSection(prompt, directory, sessionID);
+            return section ? wrapRetrievalSection(section) : null;
+        },
+        async restoreSession(sessionID) {
+            const tags = getTags(directory);
+            const result = await memoryClient.searchMemoriesBySessionID(sessionID, tags.project.tag, CONFIG.compaction.memoryLimit);
+            if (!result.success || result.results.length === 0)
+                return null;
+            return formatMemoriesForCompaction(result.results);
+        },
+    };
+}

package/dist/v2/plugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode/plugin/promise/plugin";
+declare const OmmsPluginV2: Plugin;
+export default OmmsPluginV2;

package/dist/v2/plugin.js

@@ -0,0 +1,24 @@
+import { OmmsPlugin } from "../index.js";
+import { loadOpencodeProvider } from "../services/ai/opencode-provider-loader.js";
+import { registerV2Adapter } from "./adapter.js";
+import { createV2MemoryBridge } from "./memory-bridge.js";
+import { createLegacyClient } from "./legacy-client.js";
+const OmmsPluginV2 = {
+    id: "omms",
+    async setup(ctx) {
+        const legacyClient = createLegacyClient(ctx);
+        const legacy = (await OmmsPlugin({
+            client: legacyClient,
+            directory: ctx.location.directory,
+            worktree: ctx.location.project.directory,
+            project: ctx.location.project,
+            serverUrl: undefined,
+        }));
+        // The V1 initializer cannot discover a server URL from a native V2
+        // context. Route internal structured-output calls through the adapter.
+        const { setV2Client } = await loadOpencodeProvider();
+        setV2Client(legacyClient);
+        return registerV2Adapter(ctx, legacy, createV2MemoryBridge(ctx.location.directory));
+    },
+};
+export default OmmsPluginV2;