@kisev/memomatic 1.0.0-dev.86.g5908817e39ee → 1.0.0-dev.87.g5a92e74c6754

package/README.md

@@ -30,8 +30,9 @@ Nightly runs are scheduled by the systemd user units in `assets/systemd/`
 `memomatic-dream.service`/`.timer` for consolidation).
 
 Configure `sessions.model` (or keep a legacy `dream.model`) and an OpenCode
-provider before expecting session extraction; without a model, the session
-watermark is preserved. Follow the
+V2 provider before expecting session extraction; without a model, the session
+watermark is preserved. Session extraction and its model server require
+OpenCode `2.x`; a pre-V2 session database is not parsed. Follow the
 [setup, first-entry, and scheduling guide](../../docs/how-to/memomatic.md).
 
 ## CLI, Sessions, and Dream

package/README.ru.md

@@ -30,8 +30,9 @@ memomatic dream      # консолидация: inbox + продвижение
 `memomatic-dream.service`/`.timer` для консолидации).
 
 Перед извлечением сессий настройте `sessions.model` (или оставьте старый
-`dream.model`) и провайдера OpenCode; без модели отметка обработанных сессий
-сохраняется. См.
+`dream.model`) и провайдера OpenCode V2; без модели отметка обработанных сессий
+сохраняется. Извлечение сессий и его сервер модели требуют OpenCode `2.x`;
+база сессий до V2 не разбирается. См.
 [настройку, первую запись и расписание](../../docs/ru/how-to/memomatic.md).
 
 ## CLI, Sessions и Dream

package/dist/executor.js

@@ -1,8 +1,9 @@
 import { spawn } from "node:child_process";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { randomBytes } from "node:crypto";
+import { isolatedProviderConfig } from "./opencode-config.js";
 export function extractJson(response) {
     const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(response);
     for (const candidate of [fenced?.[1], response]) {
@@ -49,30 +50,34 @@ export class OpenCodeExecutor {
             if (!["http:", "https:"].includes(url.protocol) || url.username || url.password)
                 throw new Error("invalid OpenCode URL");
             this.url = url.href.replace(/\/$/, "");
-            if (process.env.OPENCODE_SERVER_PASSWORD)
-                this.authorization = `Basic ${Buffer.from(`${process.env.OPENCODE_SERVER_USERNAME ?? "opencode"}:${process.env.OPENCODE_SERVER_PASSWORD}`).toString("base64")}`;
+            const password = process.env.OPENCODE_PASSWORD ?? process.env.OPENCODE_SERVER_PASSWORD;
+            if (password)
+                this.authorization = `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}`;
             return;
         }
-        let inherited = {};
-        if (process.env.OPENCODE_CONFIG_CONTENT) {
-            try {
-                const value = JSON.parse(process.env.OPENCODE_CONFIG_CONTENT);
-                if (!value || typeof value !== "object" || Array.isArray(value))
-                    throw new Error();
-                inherited = value;
-            }
-            catch {
-                throw new Error("OpenCode inline configuration must be a JSON object");
-            }
-        }
+        const inherited = await isolatedProviderConfig();
         this.directory = await mkdtemp(join(tmpdir(), "memomatic-opencode-"));
+        const configFile = join(this.directory, "opencode.json");
+        await writeFile(configFile, JSON.stringify({
+            ...inherited,
+            plugins: ["-opencode.skill", "-opencode.config.skill", "-opencode.tool.skill"],
+            permissions: [{ action: "*", resource: "*", effect: "deny" }],
+            agents: {
+                memomatic: {
+                    mode: "primary",
+                    description: "Bounded memory extraction",
+                    system: "Return only the requested JSON. Do not use tools.",
+                    permissions: [{ action: "*", resource: "*", effect: "deny" }],
+                },
+            },
+        }), { mode: 0o600 });
         const password = randomBytes(24).toString("hex");
         this.authorization = `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}`;
         this.options.observe?.({
             phase: "opencode.start",
             message: "Starting one isolated OpenCode server for this run",
         });
-        const child = spawn(this.options.binary ?? "opencode", ["serve", "--hostname", "127.0.0.1", "--port", "0", "--pure"], {
+        const child = spawn(this.options.binary ?? "opencode", ["serve", "--hostname", "127.0.0.1", "--port", "0"], {
             cwd: this.directory,
             detached: process.platform !== "win32",
             stdio: ["ignore", "pipe", "pipe"],
@@ -80,25 +85,11 @@ export class OpenCodeExecutor {
                 ...process.env,
                 OPENCODE_SERVER_USERNAME: "opencode",
                 OPENCODE_SERVER_PASSWORD: password,
-                OPENCODE_DISABLE_PROJECT_CONFIG: "1",
-                OPENCODE_DISABLE_EXTERNAL_SKILLS: "1",
-                OPENCODE_DISABLE_CLAUDE_CODE_SKILLS: "1",
-                OPENCODE_DISABLE_DEFAULT_PLUGINS: "1",
-                OPENCODE_CONFIG_CONTENT: JSON.stringify({
-                    ...inherited,
-                    permission: "deny",
-                    tools: { "*": false },
-                    agent: {
-                        ...inherited.agent,
-                        memomatic: {
-                            mode: "primary",
-                            description: "Bounded memory extraction",
-                            prompt: "Return only the requested JSON. Do not use tools.",
-                            permission: "deny",
-                            tools: { "*": false },
-                        },
-                    },
-                }),
+                OPENCODE_CONFIG_PROJECT_DISABLE: "1",
+                OPENCODE_CONFIG_DIR: this.directory,
+                OPENCODE_CONFIG: configFile,
+                OPENCODE_CONFIG_CONTENT: "{}",
+                OPENCODE_PASSWORD: password,
             },
         });
         this.child = child;
@@ -141,9 +132,9 @@ export class OpenCodeExecutor {
         child.stderr?.resume();
         this.options.observe?.({ phase: "opencode.ready", message: "OpenCode server ready" });
     }
-    async request(path, body, signal) {
+    async request(path, body, signal, method = "POST") {
         const response = await fetch(`${this.url}${path}`, {
-            method: "POST",
+            method,
             headers: {
                 "content-type": "application/json",
                 ...(this.authorization ? { authorization: this.authorization } : {}),
@@ -152,8 +143,8 @@ export class OpenCodeExecutor {
             signal,
         });
         if (!response.ok)
-            throw new Error(`OpenCode ${path.includes("message") ? "model request" : "session request"} failed: HTTP ${response.status}`);
-        return (await response.json());
+            throw new Error(`OpenCode ${path.includes("generate") ? "model request" : "session request"} failed: HTTP ${response.status}`);
+        return response.status === 204 ? {} : (await response.json());
     }
     async complete(request) {
         this.options.signal?.throwIfAborted();
@@ -174,56 +165,43 @@ export class OpenCodeExecutor {
             }), 15000);
             heartbeat.unref();
             try {
-                const session = await this.request("/session", {
-                    title: "[memomatic-internal] memory extraction",
-                    permission: [{ permission: "*", pattern: "*", action: "deny" }],
-                }, signal);
-                if (typeof session.id !== "string")
-                    throw new Error("OpenCode session response is malformed");
-                id = session.id;
                 const slash = this.options.model?.indexOf("/") ?? -1;
                 if (this.options.model && slash < 1)
                     throw new Error("model must use provider/model format");
-                this.usage.calls++;
-                this.usage.charactersSent += request.system.length + request.prompt.length;
-                this.options.observe?.({
-                    phase: "model.request",
-                    message: "Sending prepared fragment to OpenCode",
-                    characters: request.prompt.length,
-                    attempt: attempt + 1,
-                });
-                const response = await this.request(`/session/${encodeURIComponent(id)}/message`, {
+                const session = await this.request("/api/session", {
+                    title: "[memomatic-internal] memory extraction",
                     agent: this.options.url ? "build" : "memomatic",
-                    system: request.system,
-                    tools: { "*": false },
+                    ...(this.directory ? { location: { directory: this.directory } } : {}),
+                    permissions: [{ action: "*", resource: "*", effect: "deny" }],
                     ...(this.options.model
                         ? {
                             model: {
                                 providerID: this.options.model.slice(0, slash),
-                                modelID: this.options.model.slice(slash + 1),
+                                id: this.options.model.slice(slash + 1),
+                                ...(this.options.variant ? { variant: this.options.variant } : {}),
                             },
                         }
                         : {}),
-                    ...(this.options.variant ? { variant: this.options.variant } : {}),
-                    parts: [{ type: "text", text: `[memomatic-internal] ${request.prompt}` }],
                 }, signal);
-                const info = response.info;
-                if (info?.error)
-                    throw new Error("OpenCode model returned an error; inspect the configured provider");
-                if (info?.tokens) {
-                    this.usage.usageAvailable = true;
-                    this.usage.inputTokens += info.tokens.input ?? 0;
-                    this.usage.outputTokens += info.tokens.output ?? 0;
-                    this.usage.cacheReadTokens += info.tokens.cache?.read ?? 0;
-                    this.usage.cacheWriteTokens += info.tokens.cache?.write ?? 0;
-                }
-                const parts = response.parts;
-                if (!Array.isArray(parts))
+                const data = session.data;
+                if (typeof data?.id !== "string")
+                    throw new Error("OpenCode session response is malformed");
+                id = data.id;
+                await this.request(`/api/experimental/session/${encodeURIComponent(id)}/instructions/entries/memomatic`, { value: request.system }, signal, "PUT");
+                this.usage.calls++;
+                this.usage.charactersSent += request.system.length + request.prompt.length;
+                this.options.observe?.({
+                    phase: "model.request",
+                    message: "Sending prepared fragment to OpenCode",
+                    characters: request.prompt.length,
+                    attempt: attempt + 1,
+                });
+                const response = await this.request(`/api/session/${encodeURIComponent(id)}/generate`, { prompt: `[memomatic-internal] ${request.prompt}` }, signal);
+                const generated = response.data;
+                if (typeof generated?.text !== "string")
                     throw new Error("OpenCode model response is malformed");
-                const parsed = extractJson(parts
-                    .filter((part) => part.type === "text")
-                    .map((part) => part.text ?? "")
-                    .join("\n"));
+                // V2 transient generation returns text only, not exact token usage.
+                const parsed = extractJson(generated.text);
                 this.options.observe?.({
                     phase: "model.done",
                     message: "Model response received",
@@ -234,7 +212,7 @@ export class OpenCodeExecutor {
             }
             catch (error) {
                 if (id)
-                    await this.request(`/session/${encodeURIComponent(id)}/abort`, {}, AbortSignal.timeout(3000)).catch(() => undefined);
+                    await this.request(`/api/session/${encodeURIComponent(id)}/interrupt?resume=false`, {}, AbortSignal.timeout(3000)).catch(() => undefined);
                 if (this.options.signal?.aborted)
                     throw this.options.signal.reason;
                 if (attempt === (this.options.retries ?? 1))

package/dist/ingest.js

@@ -4,5 +4,12 @@ export function opencodeDatabasePath() {
     const base = process.env.XDG_DATA_HOME ?? join(homedir(), ".local/share");
     if (!isAbsolute(base))
         throw new Error("XDG_DATA_HOME must be an absolute path");
+    if (process.env.OPENCODE_DB) {
+        if (process.env.OPENCODE_DB === ":memory:")
+            throw new Error("An in-memory OpenCode database cannot be ingested from another process");
+        return isAbsolute(process.env.OPENCODE_DB)
+            ? process.env.OPENCODE_DB
+            : join(base, "opencode", process.env.OPENCODE_DB);
+    }
     return join(base, "opencode", "opencode.db");
 }

package/dist/ingestion.js

@@ -21,24 +21,20 @@ export function planIngestion(file, store, options) {
     const db = new DatabaseSync(file, { readOnly: true });
     try {
         db.exec("BEGIN");
-        const hasParts = Boolean(db.prepare("SELECT 1 FROM sqlite_master WHERE name='part' AND type='table'").get());
-        const hasUpdated = db
-            .prepare("PRAGMA table_info(session)")
-            .all()
-            .some((row) => row.name === "time_updated");
-        const fastRevision = hasParts &&
-            hasUpdated &&
-            ["message", "part"].every((table) => db
+        const required = {
+            session_v2: ["id", "title", "directory", "time_created", "time_updated"],
+            session_message: ["id", "session_id", "type", "seq", "data", "time_created", "time_updated"],
+        };
+        for (const [table, fields] of Object.entries(required)) {
+            const columns = new Set(db
                 .prepare(`PRAGMA table_info(${table})`)
                 .all()
-                .some((row) => row.name === "time_updated"));
-        const partHasSession = hasParts &&
-            db
-                .prepare("PRAGMA table_info(part)")
-                .all()
-                .some((row) => row.name === "session_id");
+                .map((row) => row.name));
+            if (!fields.every((field) => columns.has(field)))
+                throw new Error("OpenCode V2 session projections are unavailable; start V2 to migrate history before ingestion");
+        }
         const sessions = db
-            .prepare(`SELECT id,title,directory,time_created,${hasUpdated ? "time_updated" : "time_created"} AS revision FROM session WHERE ${hasUpdated ? "time_updated" : "time_created"} < ? ORDER BY time_created,id`)
+            .prepare("SELECT id,COALESCE(title,'') AS title,directory,time_created,time_updated AS revision FROM session_v2 WHERE time_updated < ? ORDER BY time_created,id")
             .all(options.before);
         for (const [position, session] of sessions.entries()) {
             if (session.title.startsWith("[memomatic-internal]")) {
@@ -47,66 +43,40 @@ export function planIngestion(file, store, options) {
             }
             const sealKey = `ingest-session-v2:${digest(session.id)}`;
             let seal;
-            if (fastRevision) {
-                const messages = db
-                    .prepare("SELECT COUNT(*) AS count,MAX(time_updated) AS updated FROM message WHERE session_id=?")
-                    .get(session.id);
-                const parts = db
-                    .prepare(`SELECT COUNT(*) AS count,MAX(time_updated) AS updated FROM part WHERE ${partHasSession ? "session_id=?" : "message_id IN (SELECT id FROM message WHERE session_id=?)"}`)
-                    .get(session.id);
-                if (Math.max(Number(messages.updated), Number(parts.updated)) >= options.before) {
+            {
+                const revisions = db
+                    .prepare("SELECT id,seq,time_updated FROM session_message WHERE session_id=? ORDER BY seq,id")
+                    .all(session.id);
+                if (revisions.some((message) => Number(message.time_updated) >= options.before)) {
                     result.skipped++;
                     continue;
                 }
-                const revision = digest(JSON.stringify([session.revision, session.title, session.directory, messages, parts]));
+                const revision = digest(JSON.stringify([session.revision, session.title, session.directory, revisions]));
                 if (store.getMeta(sealKey) === revision) {
                     result.cachedSessions++;
                     continue;
                 }
                 seal = [sealKey, revision];
             }
-            const rows = hasParts
-                ? db
-                    .prepare(`SELECT m.id,m.data AS message,p.data AS part FROM message m JOIN part p ON p.message_id=m.id
-                WHERE ${partHasSession ? "p" : "m"}.session_id=?
-                AND CASE WHEN json_valid(p.data) THEN json_extract(p.data,'$.type') END='text'
-                AND CASE WHEN json_valid(m.data) THEN json_extract(m.data,'$.role') END IN ('user','assistant')
-                ORDER BY m.time_created,m.id,p.time_created,p.id`)
-                    .all(session.id)
-                : db
-                    .prepare("SELECT rowid AS id,data FROM message WHERE session_id=? ORDER BY time_created,rowid")
-                    .all(session.id).flatMap((row) => {
-                    try {
-                        const message = JSON.parse(row.data);
-                        return (message.parts ?? []).map((part) => ({
-                            id: String(row.id),
-                            message: row.data,
-                            part: JSON.stringify(part),
-                        }));
-                    }
-                    catch {
-                        return [];
-                    }
-                });
+            const rows = db
+                .prepare(`
+        SELECT id,type AS role,json_extract(data,'$.text') AS text,seq,0 AS part_index
+        FROM session_message WHERE session_id=? AND type='user'
+          AND CASE WHEN json_valid(data) THEN json_type(data,'$.text') END='text'
+        UNION ALL
+        SELECT m.id,m.type AS role,json_extract(p.value,'$.text') AS text,m.seq,CAST(p.key AS INTEGER) AS part_index
+        FROM session_message m JOIN json_each(CASE WHEN json_valid(m.data) THEN json_extract(m.data,'$.content') ELSE '[]' END) p
+        WHERE m.session_id=? AND m.type='assistant'
+          AND CASE WHEN json_valid(p.value) THEN json_extract(p.value,'$.type') END='text'
+          AND CASE WHEN json_valid(p.value) THEN json_type(p.value,'$.text') END='text'
+        ORDER BY seq,part_index
+      `)
+                .all(session.id, session.id);
             const messages = new Map();
             for (const row of rows) {
-                try {
-                    const message = JSON.parse(row.message);
-                    const part = JSON.parse(row.part);
-                    if (!["user", "assistant"].includes(message.role) ||
-                        part.type !== "text" ||
-                        typeof part.text !== "string")
-                        continue;
-                    const item = messages.get(row.id) ?? {
-                        role: message.role,
-                        texts: [],
-                    };
-                    item.texts.push(part.text);
-                    messages.set(row.id, item);
-                }
-                catch {
-                    result.skipped++;
-                }
+                const item = messages.get(row.id) ?? { role: row.role, texts: [] };
+                item.texts.push(row.text);
+                messages.set(row.id, item);
             }
             const firstUser = [...messages.values()].find((message) => message.role === "user");
             if (firstUser?.texts.join("\n").trimStart().startsWith("[memomatic-internal]")) {

package/dist/opencode-config.d.ts

@@ -0,0 +1 @@
+export declare function isolatedProviderConfig(): Promise<Record<string, unknown>>;

package/dist/opencode-config.js

@@ -0,0 +1,84 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { parse } from "jsonc-parser";
+const PROVIDER_FIELDS = [
+    "providers",
+    "provider",
+    "model",
+    "enabled_providers",
+    "disabled_providers",
+    "experimental",
+    "enterprise",
+];
+function record(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function merge(left, right, key = "") {
+    if (key === "policies" && Array.isArray(left) && Array.isArray(right))
+        return [...left, ...right];
+    if (!record(left) || !record(right))
+        return right;
+    return Object.fromEntries([...new Set([...Object.keys(left), ...Object.keys(right)])].map((key) => [
+        key,
+        key in right ? merge(left[key], right[key], key) : left[key],
+    ]));
+}
+function anchorFiles(value, directory) {
+    if (typeof value === "string")
+        return value.replace(/\{file:([^}]+)\}/g, (original, path) => isAbsolute(path) || path.startsWith("~/") ? original : `{file:${resolve(directory, path)}}`);
+    if (Array.isArray(value))
+        return value.map((entry) => anchorFiles(entry, directory));
+    if (record(value))
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, anchorFiles(entry, directory)]));
+    return value;
+}
+export async function isolatedProviderConfig() {
+    const root = process.env.OPENCODE_CONFIG_DIR ??
+        join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "opencode");
+    const paths = [
+        join(root, "opencode.json"),
+        join(root, "opencode.jsonc"),
+        ...(process.env.OPENCODE_CONFIG ? [resolve(process.env.OPENCODE_CONFIG)] : []),
+    ];
+    let result = {};
+    const include = (value, directory) => {
+        if (!record(value))
+            throw new Error("OpenCode configuration must be a JSON object");
+        const selected = Object.fromEntries(PROVIDER_FIELDS.filter((key) => key in value).map((key) => [
+            key,
+            anchorFiles(value[key], directory),
+        ]));
+        if (record(selected.experimental))
+            selected.experimental = { policies: selected.experimental.policies ?? [] };
+        result = merge(result, selected);
+    };
+    for (const path of [...new Set(paths)]) {
+        let text;
+        try {
+            text = await readFile(path, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT" &&
+                path !== (process.env.OPENCODE_CONFIG ? resolve(process.env.OPENCODE_CONFIG) : undefined))
+                continue;
+            throw new Error("Cannot read OpenCode provider configuration");
+        }
+        const errors = [];
+        const value = parse(text, errors, { allowTrailingComma: true });
+        if (errors.length)
+            throw new Error("OpenCode provider configuration is not valid JSON/JSONC");
+        include(value, dirname(path));
+    }
+    if (process.env.OPENCODE_CONFIG_CONTENT) {
+        let value;
+        try {
+            value = JSON.parse(process.env.OPENCODE_CONFIG_CONTENT);
+        }
+        catch {
+            throw new Error("OpenCode inline configuration must be a JSON object");
+        }
+        include(value, process.cwd());
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kisev/memomatic",
-  "version": "1.0.0-dev.86.g5908817e39ee",
+  "version": "1.0.0-dev.87.g5a92e74c6754",
   "description": "Personal learning memory for agents: tiered Markdown corpus, rebuildable index, dream sweep.",
   "homepage": "https://github.com/kisev/skills#readme",
   "bugs": {
@@ -30,12 +30,13 @@
   },
   "scripts": {
     "build": "node scripts/clean-dist.mjs && tsc --project tsconfig.json",
-    "test": "node --test test/",
+    "test": "node --test test/*.test.mjs",
     "pack:check": "node test/pack-allowlist.mjs"
   },
   "dependencies": {
-    "@kisev/safe-fs": "1.0.0-dev.86.g5908817e39ee",
-    "commander": "15.0.0"
+    "@kisev/safe-fs": "1.0.0-dev.87.g5a92e74c6754",
+    "commander": "15.0.0",
+    "jsonc-parser": "3.3.1"
   },
   "devDependencies": {
     "@types/node": "22.15.30",