@kisev/memomatic 1.0.0-dev.93.g810c3f0460fa → 1.0.0

package/README.md

@@ -30,9 +30,8 @@ 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
-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
+provider before expecting session extraction; without a model, the session
+watermark is preserved. Follow the
 [setup, first-entry, and scheduling guide](../../docs/how-to/memomatic.md).
 
 ## CLI, Sessions, and Dream

package/README.ru.md

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

package/dist/executor.js

@@ -1,9 +1,8 @@
 import { spawn } from "node:child_process";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, rm } 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]) {
@@ -50,34 +49,30 @@ export class OpenCodeExecutor {
             if (!["http:", "https:"].includes(url.protocol) || url.username || url.password)
                 throw new Error("invalid OpenCode URL");
             this.url = url.href.replace(/\/$/, "");
-            const password = process.env.OPENCODE_PASSWORD ?? process.env.OPENCODE_SERVER_PASSWORD;
-            if (password)
-                this.authorization = `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}`;
+            if (process.env.OPENCODE_SERVER_PASSWORD)
+                this.authorization = `Basic ${Buffer.from(`${process.env.OPENCODE_SERVER_USERNAME ?? "opencode"}:${process.env.OPENCODE_SERVER_PASSWORD}`).toString("base64")}`;
             return;
         }
-        const inherited = await isolatedProviderConfig();
+        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");
+            }
+        }
         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"], {
+        const child = spawn(this.options.binary ?? "opencode", ["serve", "--hostname", "127.0.0.1", "--port", "0", "--pure"], {
             cwd: this.directory,
             detached: process.platform !== "win32",
             stdio: ["ignore", "pipe", "pipe"],
@@ -85,11 +80,25 @@ export class OpenCodeExecutor {
                 ...process.env,
                 OPENCODE_SERVER_USERNAME: "opencode",
                 OPENCODE_SERVER_PASSWORD: password,
-                OPENCODE_CONFIG_PROJECT_DISABLE: "1",
-                OPENCODE_CONFIG_DIR: this.directory,
-                OPENCODE_CONFIG: configFile,
-                OPENCODE_CONFIG_CONTENT: "{}",
-                OPENCODE_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 },
+                        },
+                    },
+                }),
             },
         });
         this.child = child;
@@ -132,9 +141,9 @@ export class OpenCodeExecutor {
         child.stderr?.resume();
         this.options.observe?.({ phase: "opencode.ready", message: "OpenCode server ready" });
     }
-    async request(path, body, signal, method = "POST") {
+    async request(path, body, signal) {
         const response = await fetch(`${this.url}${path}`, {
-            method,
+            method: "POST",
             headers: {
                 "content-type": "application/json",
                 ...(this.authorization ? { authorization: this.authorization } : {}),
@@ -143,8 +152,8 @@ export class OpenCodeExecutor {
             signal,
         });
         if (!response.ok)
-            throw new Error(`OpenCode ${path.includes("generate") ? "model request" : "session request"} failed: HTTP ${response.status}`);
-        return response.status === 204 ? {} : (await response.json());
+            throw new Error(`OpenCode ${path.includes("message") ? "model request" : "session request"} failed: HTTP ${response.status}`);
+        return (await response.json());
     }
     async complete(request) {
         this.options.signal?.throwIfAborted();
@@ -165,43 +174,56 @@ 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");
-                const session = await this.request("/api/session", {
-                    title: "[memomatic-internal] memory extraction",
+                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`, {
                     agent: this.options.url ? "build" : "memomatic",
-                    ...(this.directory ? { location: { directory: this.directory } } : {}),
-                    permissions: [{ action: "*", resource: "*", effect: "deny" }],
+                    system: request.system,
+                    tools: { "*": false },
                     ...(this.options.model
                         ? {
                             model: {
                                 providerID: this.options.model.slice(0, slash),
-                                id: this.options.model.slice(slash + 1),
-                                ...(this.options.variant ? { variant: this.options.variant } : {}),
+                                modelID: this.options.model.slice(slash + 1),
                             },
                         }
                         : {}),
+                    ...(this.options.variant ? { variant: this.options.variant } : {}),
+                    parts: [{ type: "text", text: `[memomatic-internal] ${request.prompt}` }],
                 }, signal);
-                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")
+                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))
                     throw new Error("OpenCode model response is malformed");
-                // V2 transient generation returns text only, not exact token usage.
-                const parsed = extractJson(generated.text);
+                const parsed = extractJson(parts
+                    .filter((part) => part.type === "text")
+                    .map((part) => part.text ?? "")
+                    .join("\n"));
                 this.options.observe?.({
                     phase: "model.done",
                     message: "Model response received",
@@ -212,7 +234,7 @@ export class OpenCodeExecutor {
             }
             catch (error) {
                 if (id)
-                    await this.request(`/api/session/${encodeURIComponent(id)}/interrupt?resume=false`, {}, AbortSignal.timeout(3000)).catch(() => undefined);
+                    await this.request(`/session/${encodeURIComponent(id)}/abort`, {}, 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,12 +4,5 @@ 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,20 +21,24 @@ export function planIngestion(file, store, options) {
     const db = new DatabaseSync(file, { readOnly: true });
     try {
         db.exec("BEGIN");
-        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
+        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
                 .prepare(`PRAGMA table_info(${table})`)
                 .all()
-                .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");
-        }
+                .some((row) => row.name === "time_updated"));
+        const partHasSession = hasParts &&
+            db
+                .prepare("PRAGMA table_info(part)")
+                .all()
+                .some((row) => row.name === "session_id");
         const sessions = db
-            .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")
+            .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`)
             .all(options.before);
         for (const [position, session] of sessions.entries()) {
             if (session.title.startsWith("[memomatic-internal]")) {
@@ -43,40 +47,66 @@ export function planIngestion(file, store, options) {
             }
             const sealKey = `ingest-session-v2:${digest(session.id)}`;
             let seal;
-            {
-                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)) {
+            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) {
                     result.skipped++;
                     continue;
                 }
-                const revision = digest(JSON.stringify([session.revision, session.title, session.directory, revisions]));
+                const revision = digest(JSON.stringify([session.revision, session.title, session.directory, messages, parts]));
                 if (store.getMeta(sealKey) === revision) {
                     result.cachedSessions++;
                     continue;
                 }
                 seal = [sealKey, revision];
             }
-            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 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 messages = new Map();
             for (const row of rows) {
-                const item = messages.get(row.id) ?? { role: row.role, texts: [] };
-                item.texts.push(row.text);
-                messages.set(row.id, item);
+                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 firstUser = [...messages.values()].find((message) => message.role === "user");
             if (firstUser?.texts.join("\n").trimStart().startsWith("[memomatic-internal]")) {

package/package.json

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

package/dist/opencode-config.d.ts

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

package/dist/opencode-config.js

@@ -1,84 +0,0 @@
-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;
-}