om-memory-system 5.10.1 → 6.1.0-next.237

package/dist/v2/startup.js

@@ -0,0 +1,210 @@
+import { memoryClient } from "../services/client.js";
+import { getTags } from "../services/tags.js";
+import { createOpenCodeAutoCaptureHost } from "../adapters/opencode/auto-capture-host.js";
+import { pruneTraces } from "../services/capture-diagnostics.js";
+import { ensureTursoReady } from "../services/turso/ready.js";
+import { tursoConnectionManager } from "../services/turso/connection-manager.js";
+import { isConfigured, CONFIG, initConfigWithLegacyMigration } from "../config.js";
+import { log } from "../services/logger.js";
+import { loadOpencodeProvider } from "../adapters/opencode/opencode-provider-loader.js";
+import { registerOpencodeProfileModel } from "../adapters/opencode/profile-model.js";
+import { showOpencodeNotice } from "../adapters/opencode/toast.js";
+const GLOBAL_PLUGIN_WARMUP_KEY = Symbol.for("omms.plugin.warmedup");
+function logAutoCaptureProviderStatus() {
+    if (!CONFIG.autoCaptureEnabled || CONFIG.autoCaptureProviderStatus.ready)
+        return;
+    log(`Auto-capture disabled by configuration. Issues: ${CONFIG.autoCaptureProviderStatus.issues.join("; ")}.`);
+}
+/** OpenCode's default model as `provider/model`, read through the V2 model API. */
+async function defaultModel(ctx) {
+    const result = await ctx.model.default();
+    const model = result?.data;
+    return model?.providerID && model?.id ? `${model.providerID}/${model.id}` : null;
+}
+/** Connected provider ids from the V2 model list. */
+async function connectedProviders(ctx) {
+    const models = await ctx.model.list();
+    return [...new Set(models.data.map((model) => model.providerID).filter(Boolean))];
+}
+/** Check providers, then register backfill models and start the automatic backfill. */
+async function startProviderWork(ctx, directory) {
+    let connected = [];
+    try {
+        connected = await connectedProviders(ctx);
+        if (connected.length > 0) {
+            const { setConnectedProviders } = await loadOpencodeProvider();
+            setConnectedProviders(connected);
+            log("opencode providers connected", {
+                list: connected,
+                configured: CONFIG.opencodeProvider || "(not set)",
+            });
+        }
+        else {
+            log("opencode provider list empty", undefined, "warn");
+        }
+    }
+    catch (error) {
+        log("Failed to initialize opencode provider state", { error: String(error) }, "error");
+    }
+    const configModel = () => defaultModel(ctx);
+    // Run now on a Settings page served by this process can use OpenCode's signed-in models.
+    void import("../adapters/opencode/backfill-startup.js")
+        .then(({ registerOpencodeBackfillModels }) => registerOpencodeBackfillModels({ connected, directory, configModel }))
+        .catch(() => { });
+    if (CONFIG.autoBackfill && process.env.OMMS_DISABLE_AUTO_BACKFILL !== "1" && isConfigured()) {
+        void import("../adapters/opencode/backfill-startup.js")
+            .then(({ startOpencodeBackfill }) => startOpencodeBackfill({
+            connected,
+            directory,
+            configModel,
+            notify: (message) => showOpencodeNotice({ title: "Automatic import", message, variant: "info" }),
+        }))
+            .catch((error) => log("OpenCode backfill failed", { error: error instanceof Error ? error.message : String(error) }, "error"));
+    }
+}
+/** Start the shared web app unless one already runs. */
+async function startWebApp() {
+    let tursoReadyForWeb = !isConfigured();
+    if (CONFIG.webServerEnabled && isConfigured()) {
+        try {
+            await ensureTursoReady();
+            tursoReadyForWeb = true;
+        }
+        catch (error) {
+            log("Turso ready gate failed before web server start", { error: String(error) }, "error");
+            showOpencodeNotice({
+                title: "Memory Explorer",
+                message: "Database migration failed; web UI not started",
+                variant: "error",
+            });
+        }
+    }
+    if (!CONFIG.webServerEnabled ||
+        !tursoReadyForWeb ||
+        process.env.OMMS_DISABLE_WEB_AUTOSTART === "1") {
+        return;
+    }
+    const notice = (message, variant) => showOpencodeNotice({ title: "Memory Explorer", message, variant });
+    // The shared web app serves the page. This plugin starts it only when none runs.
+    void Promise.all([
+        import("../services/web-ensure.js"),
+        import("../services/web-api-auth.js"),
+        import("../services/runtime-handoff.js"),
+    ])
+        .then(async ([{ ensureWebApp }, { webServerUrl }, { hostReplaceOlder }]) => {
+        const baseUrl = webServerUrl(CONFIG.webServerHost, CONFIG.webServerPort);
+        // A web app older than the newest recorded copy steps aside for it.
+        const replaceOlder = await hostReplaceOlder(CONFIG).catch(() => undefined);
+        return ensureWebApp({
+            settings: { enabled: CONFIG.webServerEnabled, baseUrl },
+            budgetMs: 10_000,
+            ...(replaceOlder ? { replaceOlder } : {}),
+        }).then((result) => {
+            if (result === "running" || result === "started") {
+                notice(`Web UI available at ${baseUrl}`, "info");
+            }
+            else if (result === "port-busy") {
+                notice(`Web UI unavailable: another program uses port ${CONFIG.webServerPort}`, "error");
+            }
+            else if (result === "no-runtime") {
+                notice("Web UI unavailable: no Node or Bun runtime found to start it", "error");
+            }
+        });
+    })
+        .catch((error) => log("Web app start failed", { error: String(error) }, "error"));
+}
+/**
+ * Start OMMS for an OpenCode V2 plugin: config, traces, runtime record, warm-up, models,
+ * backfill, web app and shutdown handlers. Returns the dispose function for plugin unload.
+ */
+export async function startOpencodeRuntime(ctx, onCleanup = () => { }) {
+    const directory = ctx.location.directory;
+    initConfigWithLegacyMigration(directory);
+    // Runs even with tracing off, so turning it off does not leave old traces behind.
+    pruneTraces(CONFIG);
+    // Record this copy first: the login item and the other hosts run the newest recorded copy.
+    void import("../services/runtime-handoff.js")
+        .then(({ registerOwnCopy }) => registerOwnCopy())
+        .catch((error) => log("OpenCode runtime record failed", { code: error instanceof Error ? error.name : "unknown" }, "error"));
+    if (CONFIG.webServerAutoStart !== undefined && process.env.OMMS_DISABLE_WEB_AUTOSTART !== "1") {
+        void import("../services/web-autostart.js")
+            .then(({ reconcileWebAutostart }) => reconcileWebAutostart(CONFIG))
+            .catch((error) => log("OpenCode login item reconciliation failed", { code: error instanceof Error ? error.name : "unknown" }, "error"));
+    }
+    logAutoCaptureProviderStatus();
+    const tags = getTags(directory);
+    const autoCaptureHost = createOpenCodeAutoCaptureHost(ctx);
+    if (!globalThis[GLOBAL_PLUGIN_WARMUP_KEY] && isConfigured()) {
+        // Fire-and-forget: DB ready + embedding model must not block plugin init.
+        void (async () => {
+            try {
+                await memoryClient.warmup();
+                globalThis[GLOBAL_PLUGIN_WARMUP_KEY] = true;
+            }
+            catch (error) {
+                log("Plugin memory warmup failed", { error: String(error) }, "error");
+            }
+        })();
+    }
+    // Shared profile dedup, conflict, description, and cleanup calls use OpenCode's host model.
+    registerOpencodeProfileModel();
+    // In-process backfill, capture, and the capture retry drain use OpenCode's models.
+    // Awaited so those paths never run before the registry is filled.
+    await import("../adapters/opencode/backfill-startup.js")
+        .then(({ registerOpencodeImportModels, registerOpencodeCaptureRetryDrain }) => {
+        registerOpencodeImportModels();
+        registerOpencodeCaptureRetryDrain(autoCaptureHost, directory);
+    })
+        .catch(() => { });
+    void startProviderWork(ctx, directory);
+    await startWebApp();
+    let cleanedUp = false;
+    const cleanup = async () => {
+        if (cleanedUp)
+            return;
+        cleanedUp = true;
+        onCleanup();
+        if (memoryClient)
+            await memoryClient.close();
+    };
+    const shutdownHandler = async () => {
+        try {
+            await cleanup();
+        }
+        catch (error) {
+            log("Shutdown error", { error: String(error) }, "error");
+            process.exitCode = 1;
+        }
+    };
+    const beforeExitHandler = () => {
+        if (!cleanedUp)
+            void cleanup();
+    };
+    const exitHandler = () => {
+        // Best-effort sync close when the host exits without SIGINT/SIGTERM.
+        if (cleanedUp)
+            return;
+        try {
+            tursoConnectionManager.closeAllSync();
+        }
+        catch {
+            // ignore: the module may already be torn down
+        }
+    };
+    process.on("SIGINT", shutdownHandler);
+    process.on("SIGTERM", shutdownHandler);
+    process.on("beforeExit", beforeExitHandler);
+    process.on("exit", exitHandler);
+    return {
+        directory,
+        tags,
+        autoCaptureHost,
+        async dispose() {
+            process.off("SIGINT", shutdownHandler);
+            process.off("SIGTERM", shutdownHandler);
+            process.off("beforeExit", beforeExitHandler);
+            process.off("exit", exitHandler);
+            await cleanup();
+        },
+    };
+}

package/dist/v2/tools.d.ts

@@ -0,0 +1,106 @@
+import type { Context } from "@opencode/plugin/promise/plugin";
+import type { MemoryOperationContext } from "../core/memory-operations.js";
+export declare const memoryInput: {
+    readonly type: "object";
+    readonly properties: {
+        readonly mode: {
+            readonly type: "string";
+            readonly enum: readonly ["add", "memorise", "memorize", "recall", "search", "profile", "list", "forget", "help", "migrate", "list-shards", "export", "import", "space"];
+        };
+        readonly content: {
+            readonly type: "string";
+        };
+        readonly query: {
+            readonly type: "string";
+        };
+        readonly tags: {
+            readonly type: "string";
+        };
+        readonly type: {
+            readonly type: "string";
+        };
+        readonly topic: {
+            readonly type: "string";
+        };
+        readonly done: {
+            readonly type: "string";
+        };
+        readonly doing: {
+            readonly type: "string";
+        };
+        readonly next: {
+            readonly type: "string";
+        };
+        readonly memoryId: {
+            readonly type: "string";
+        };
+        readonly limit: {
+            readonly type: "number";
+        };
+        readonly scope: {
+            readonly type: "string";
+            readonly enum: readonly ["project", "all-projects"];
+        };
+        readonly fromPath: {
+            readonly type: "string";
+        };
+        readonly fromHash: {
+            readonly type: "string";
+        };
+        readonly outputPath: {
+            readonly type: "string";
+        };
+        readonly inputPath: {
+            readonly type: "string";
+        };
+        readonly dryRun: {
+            readonly type: "boolean";
+        };
+        readonly allowLinkedSource: {
+            readonly type: "boolean";
+        };
+        readonly spaceAction: {
+            readonly type: "string";
+        };
+        readonly spaceName: {
+            readonly type: "string";
+        };
+        readonly spaceTo: {
+            readonly type: "string";
+        };
+        readonly spaceSince: {
+            readonly type: "string";
+        };
+        readonly spaceUntil: {
+            readonly type: "string";
+        };
+        readonly spaceProject: {
+            readonly type: "string";
+        };
+        readonly spaceIn: {
+            readonly type: "string";
+        };
+    };
+    readonly additionalProperties: false;
+};
+/** What OpenCode passes to a tool call that the executors read. */
+export type OpencodeToolCall = {
+    readonly sessionID?: string;
+    readonly messageID?: string;
+    readonly agent?: string;
+};
+export type OpencodeToolExecutor = {
+    readonly description: string;
+    readonly execute: (args: any, call: OpencodeToolCall) => Promise<string>;
+};
+export type OpencodeTools = {
+    readonly memory: OpencodeToolExecutor;
+    readonly skills: OpencodeToolExecutor;
+};
+/** The `memory` and `skills` executors over the shared operations. */
+export declare function createOpencodeTools(base: Pick<MemoryOperationContext, "directory" | "tags">, languageName: string): OpencodeTools;
+/**
+ * Register each tool as a direct V2 tool, like OpenCode's own read/grep/skill, not a
+ * Code Mode catalog entry, so the model can always see and call it (as on Pi).
+ */
+export declare function registerOpencodeTools(ctx: Context, tools: OpencodeTools): Promise<void>;

package/dist/v2/tools.js

@@ -0,0 +1,89 @@
+import { SKILLS_TOOL_DESCRIPTION, SKILLS_TOOL_INPUT_SCHEMA } from "../core/skills-tool.js";
+import { memoryToolDescription } from "../core/memory-tool-text.js";
+import { runOpencodeMemoryTool } from "../adapters/opencode/memory-tool.js";
+import { runOpencodeSkillsTool } from "../adapters/opencode/skills-tool.js";
+export const memoryInput = {
+    type: "object",
+    properties: {
+        mode: {
+            type: "string",
+            enum: [
+                "add",
+                "memorise",
+                "memorize",
+                "recall",
+                "search",
+                "profile",
+                "list",
+                "forget",
+                "help",
+                "migrate",
+                "list-shards",
+                "export",
+                "import",
+                "space",
+            ],
+        },
+        content: { type: "string" },
+        query: { type: "string" },
+        tags: { type: "string" },
+        type: { type: "string" },
+        topic: { type: "string" },
+        done: { type: "string" },
+        doing: { type: "string" },
+        next: { 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" },
+        spaceAction: { type: "string" },
+        spaceName: { type: "string" },
+        spaceTo: { type: "string" },
+        spaceSince: { type: "string" },
+        spaceUntil: { type: "string" },
+        spaceProject: { type: "string" },
+        spaceIn: { type: "string" },
+    },
+    additionalProperties: false,
+};
+/** The `memory` and `skills` executors over the shared operations. */
+export function createOpencodeTools(base, languageName) {
+    return {
+        memory: {
+            description: memoryToolDescription(languageName),
+            execute: (args, call) => runOpencodeMemoryTool(args, base, call.sessionID),
+        },
+        skills: {
+            description: SKILLS_TOOL_DESCRIPTION,
+            execute: (args) => runOpencodeSkillsTool(args, base.directory),
+        },
+    };
+}
+/**
+ * Register each tool as a direct V2 tool, like OpenCode's own read/grep/skill, not a
+ * Code Mode catalog entry, so the model can always see and call it (as on Pi).
+ */
+export async function registerOpencodeTools(ctx, tools) {
+    const definition = (name, input) => ({
+        name,
+        description: tools[name].description,
+        input: input,
+        options: { codemode: false },
+        execute: async (args, toolContext) => ({
+            content: await tools[name].execute(args, {
+                sessionID: toolContext?.sessionID,
+                messageID: toolContext?.messageID,
+                agent: toolContext?.agent,
+            }),
+        }),
+    });
+    await ctx.tool.transform((editor) => {
+        editor.add(definition("memory", memoryInput));
+        editor.add(definition("skills", SKILLS_TOOL_INPUT_SCHEMA));
+    });
+}