toolnet-memory 0.2.0

package/dist/src/session/learner/learner.js

@@ -0,0 +1,124 @@
+import { closeSync, existsSync, openSync, readSync, statSync, } from "node:fs";
+import { extractLearnedMemories, } from "./extractor.js";
+import { SessionMemoryJournal, } from "./journal.js";
+function readEvents(filePath, offset) {
+    if (!existsSync(filePath)) {
+        return {
+            events: [],
+            nextOffset: offset,
+        };
+    }
+    const size = statSync(filePath).size;
+    let start = Number.isFinite(offset)
+        ? Math.max(0, offset)
+        : 0;
+    /*
+     * Local WAL was rebuilt.
+     */
+    if (start >
+        size) {
+        start =
+            0;
+    }
+    if (start ===
+        size) {
+        return {
+            events: [],
+            nextOffset: size,
+        };
+    }
+    const length = size -
+        start;
+    const buffer = Buffer.alloc(length);
+    const fd = openSync(filePath, "r");
+    try {
+        readSync(fd, buffer, 0, length, start);
+    }
+    finally {
+        closeSync(fd);
+    }
+    const text = buffer.toString("utf8");
+    const lastNewline = text.lastIndexOf("\n");
+    if (lastNewline <
+        0) {
+        return {
+            events: [],
+            nextOffset: start,
+        };
+    }
+    const complete = text.slice(0, lastNewline +
+        1);
+    const events = complete
+        .split("\n")
+        .filter(Boolean)
+        .flatMap(line => {
+        try {
+            return [
+                JSON.parse(line),
+            ];
+        }
+        catch {
+            return [];
+        }
+    });
+    return {
+        events,
+        nextOffset: start +
+            Buffer.byteLength(complete, "utf8"),
+    };
+}
+export class SessionMemoryLearner {
+    options;
+    journal;
+    constructor(options) {
+        this.options = options;
+        this.journal =
+            new SessionMemoryJournal(options.storage);
+    }
+    async learnNew() {
+        const state = this.options
+            .wal
+            .loadState();
+        const rawOffset = Number(state.sourceCursors["memory.learner.offset"] ??
+            0);
+        const offset = Number.isFinite(rawOffset)
+            ? rawOffset
+            : 0;
+        const read = readEvents(this.options
+            .wal
+            .eventsFile, offset);
+        if (read.events.length ===
+            0) {
+            return {
+                scannedEvents: 0,
+                candidates: 0,
+                journalWritten: false,
+                nextOffset: read.nextOffset,
+            };
+        }
+        const candidates = extractLearnedMemories(this.options
+            .identity, read.events);
+        let journalWritten = false;
+        if (candidates.length >
+            0) {
+            const key = await this.journal
+                .write(this.options
+                .identity, read.events, candidates);
+            journalWritten =
+                Boolean(key);
+        }
+        /*
+         * Advance only after immutable learning journal succeeds.
+         * If journal write throws, next flush retries same range.
+         */
+        this.options
+            .wal
+            .setSourceCursor("memory.learner.offset", read.nextOffset);
+        return {
+            scannedEvents: read.events.length,
+            candidates: candidates.length,
+            journalWritten,
+            nextOffset: read.nextOffset,
+        };
+    }
+}

package/dist/src/session/learner/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/session/opencode/adapter.js

@@ -0,0 +1,553 @@
+import { existsSync, } from "node:fs";
+import { homedir, } from "node:os";
+import { isAbsolute, join, relative, resolve, } from "node:path";
+import { DatabaseSync, } from "node:sqlite";
+import { SessionCore, } from "../core.js";
+export function defaultOpenCodeDbPath() {
+    return (process.env
+        .OPENCODE_DB_PATH ??
+        join(homedir(), ".local", "share", "opencode", "opencode.db"));
+}
+function valueString(value) {
+    return typeof value ===
+        "string"
+        ? value
+        : "";
+}
+function valueNumber(value) {
+    if (typeof value ===
+        "number" &&
+        Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value ===
+        "bigint") {
+        return Number(value);
+    }
+    if (typeof value ===
+        "string") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return 0;
+}
+function jsonObject(value) {
+    if (value &&
+        typeof value ===
+            "object" &&
+        !Buffer.isBuffer(value)) {
+        return value;
+    }
+    if (typeof value !==
+        "string") {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (parsed &&
+            typeof parsed ===
+                "object" &&
+            !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Non JSON data.
+    }
+    return {};
+}
+function toIso(value) {
+    let time = valueNumber(value);
+    if (time <=
+        0) {
+        return new Date()
+            .toISOString();
+    }
+    /*
+     * Seconds → milliseconds.
+     */
+    if (time <
+        100_000_000_000) {
+        time *=
+            1000;
+    }
+    const date = new Date(time);
+    return Number.isNaN(date.getTime())
+        ? new Date()
+            .toISOString()
+        : date.toISOString();
+}
+function isInsideProject(projectRoot, candidate) {
+    if (!candidate) {
+        return false;
+    }
+    const root = resolve(projectRoot);
+    const target = resolve(candidate);
+    if (root ===
+        target) {
+        return true;
+    }
+    const rel = relative(root, target);
+    return (rel !==
+        "" &&
+        rel !==
+            ".." &&
+        !rel.startsWith(`..${process.platform ===
+            "win32"
+            ? "\\"
+            : "/"}`) &&
+        !isAbsolute(rel));
+}
+function decodeCursor(value) {
+    if (!value) {
+        return {
+            time: -1,
+            id: "",
+        };
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return {
+            time: typeof parsed.time ===
+                "number"
+                ? parsed.time
+                : -1,
+            id: typeof parsed.id ===
+                "string"
+                ? parsed.id
+                : "",
+        };
+    }
+    catch {
+        return {
+            time: -1,
+            id: "",
+        };
+    }
+}
+function encodeCursor(value) {
+    return JSON.stringify(value);
+}
+function openDatabase(dbPath) {
+    if (!existsSync(dbPath)) {
+        throw new Error(`OpenCode database not found: ${dbPath}`);
+    }
+    const db = new DatabaseSync(dbPath, {
+        readOnly: true,
+    });
+    db.exec("PRAGMA query_only = ON");
+    db.exec("PRAGMA busy_timeout = 3000");
+    return db;
+}
+function sessionRow(db, nativeSessionId) {
+    const row = db.prepare(`
+      SELECT *
+      FROM "session"
+      WHERE id = ?
+      LIMIT 1
+      `).get(nativeSessionId);
+    if (!row) {
+        throw new Error(`OpenCode session not found: ${nativeSessionId}`);
+    }
+    return row;
+}
+function sessionBelongsToProject(db, row, project) {
+    const directDirectory = valueString(row.directory);
+    if (directDirectory &&
+        isInsideProject(project.rootPath, directDirectory)) {
+        return true;
+    }
+    const projectId = valueString(row.project_id);
+    if (projectId) {
+        try {
+            const projectRow = db.prepare(`
+          SELECT *
+          FROM "project"
+          WHERE id = ?
+          LIMIT 1
+          `).get(projectId);
+            if (projectRow) {
+                for (const field of [
+                    "worktree",
+                    "directory",
+                    "path",
+                ]) {
+                    const candidate = valueString(projectRow[field]);
+                    if (candidate &&
+                        isInsideProject(project.rootPath, candidate)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        catch {
+            // Older schema.
+        }
+        try {
+            const directories = db.prepare(`
+          SELECT directory
+          FROM "project_directory"
+          WHERE project_id = ?
+          `).all(projectId);
+            if (directories.some(item => isInsideProject(project.rootPath, valueString(item.directory)))) {
+                return true;
+            }
+        }
+        catch {
+            // Older schema.
+        }
+    }
+    /*
+     * Last fallback:
+     * inspect message metadata path.root/cwd,
+     * but not text content.
+     */
+    try {
+        const rows = db.prepare(`
+        SELECT data
+        FROM "message"
+        WHERE session_id = ?
+        ORDER BY time_created DESC
+        LIMIT 20
+        `).all(valueString(row.id));
+        for (const message of rows) {
+            const data = jsonObject(message.data);
+            const path = data.path &&
+                typeof data.path ===
+                    "object"
+                ? data.path
+                : {};
+            for (const candidate of [
+                valueString(path.cwd),
+                valueString(path.root),
+            ]) {
+                if (candidate &&
+                    isInsideProject(project.rootPath, candidate)) {
+                    return true;
+                }
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return false;
+}
+function fetchRowsAfter(db, table, nativeSessionId, cursor) {
+    const sql = `
+    SELECT *,
+      COALESCE(
+        time_updated,
+        time_created,
+        0
+      ) AS __clock
+    FROM "${table}"
+    WHERE session_id = ?
+      AND (
+        COALESCE(
+          time_updated,
+          time_created,
+          0
+        ) > ?
+        OR (
+          COALESCE(
+            time_updated,
+            time_created,
+            0
+          ) = ?
+          AND id > ?
+        )
+      )
+    ORDER BY
+      COALESCE(
+        time_updated,
+        time_created,
+        0
+      ) ASC,
+      id ASC
+    `;
+    return db.prepare(sql).all(nativeSessionId, cursor.time, cursor.time, cursor.id);
+}
+function cursorFromRows(rows, fallback) {
+    const last = rows[rows.length -
+        1];
+    if (!last) {
+        return fallback;
+    }
+    return {
+        time: valueNumber(last.__clock),
+        id: valueString(last.id),
+    };
+}
+function messageEvent(dbPath, row) {
+    const data = jsonObject(row.data);
+    const role = valueString(data.role);
+    const clock = valueNumber(row.__clock);
+    const id = valueString(row.id);
+    let type = "message";
+    if (role ===
+        "user") {
+        type =
+            "user_prompt";
+    }
+    else if (role ===
+        "assistant") {
+        type =
+            "assistant_message";
+    }
+    return {
+        clock,
+        order: 0,
+        event: {
+            type,
+            timestamp: toIso(clock),
+            role: role ||
+                undefined,
+            sourceEventId: `message:${id}:${clock}`,
+            sourceSequence: `${clock}:${id}`,
+            data: {
+                messageId: id,
+                ...data,
+            },
+            provenance: {
+                source: "opencode",
+                sourcePath: dbPath,
+                sourceTable: "message",
+                sourceRowId: id,
+                sourceOffset: `${clock}:${id}`,
+            },
+        },
+    };
+}
+function partEvent(dbPath, row) {
+    const data = jsonObject(row.data);
+    const partType = valueString(data.type);
+    const clock = valueNumber(row.__clock);
+    const id = valueString(row.id);
+    const messageId = valueString(row.message_id);
+    let type = "message_part";
+    if (partType ===
+        "tool") {
+        type =
+            "tool_call";
+    }
+    else if (partType ===
+        "snapshot") {
+        type =
+            "artifact";
+    }
+    return {
+        clock,
+        order: 1,
+        event: {
+            type,
+            timestamp: toIso(clock),
+            sourceEventId: `part:${id}:${clock}`,
+            sourceSequence: `${clock}:${id}`,
+            data: {
+                partId: id,
+                messageId,
+                ...data,
+            },
+            provenance: {
+                source: "opencode",
+                sourcePath: dbPath,
+                sourceTable: "part",
+                sourceRowId: id,
+                sourceOffset: `${clock}:${id}`,
+            },
+        },
+    };
+}
+export async function syncOpenCodeSession(options) {
+    const dbPath = options.dbPath ??
+        defaultOpenCodeDbPath();
+    const db = openDatabase(dbPath);
+    try {
+        const session = sessionRow(db, options
+            .nativeSessionId);
+        if (!sessionBelongsToProject(db, session, options.project)) {
+            throw new Error([
+                "OpenCode session does not belong to current ToolNet project.",
+                `Session: ${options.nativeSessionId}`,
+                `Project: ${options.project.rootPath}`,
+                `Session directory: ${valueString(session.directory) || "unknown"}`,
+            ].join(" "));
+        }
+        const core = new SessionCore({
+            project: options.project,
+            storage: options.storage,
+            agent: "opencode",
+            nativeSessionId: options.nativeSessionId,
+            title: valueString(session.title) ||
+                undefined,
+            metadata: {
+                source: "opencode.db",
+                openCodeProjectId: valueString(session.project_id) ||
+                    undefined,
+                directory: valueString(session.directory) ||
+                    undefined,
+            },
+        });
+        const state = core.status();
+        const messageCursor = decodeCursor(state.sourceCursors["opencode.message"]);
+        const partCursor = decodeCursor(state.sourceCursors["opencode.part"]);
+        const messages = fetchRowsAfter(db, "message", options
+            .nativeSessionId, messageCursor);
+        const parts = fetchRowsAfter(db, "part", options
+            .nativeSessionId, partCursor);
+        const timed = [];
+        if (state.lastSequence ===
+            0) {
+            const created = valueNumber(session
+                .time_created);
+            timed.push({
+                clock: created,
+                order: -1,
+                event: {
+                    type: "session_start",
+                    timestamp: toIso(created),
+                    sourceEventId: `session:${options.nativeSessionId}:created:${created}`,
+                    data: {
+                        title: valueString(session.title) ||
+                            undefined,
+                        directory: valueString(session.directory) ||
+                            undefined,
+                        openCodeProjectId: valueString(session.project_id) ||
+                            undefined,
+                    },
+                    provenance: {
+                        source: "opencode",
+                        sourcePath: dbPath,
+                        sourceTable: "session",
+                        sourceRowId: options
+                            .nativeSessionId,
+                    },
+                },
+            });
+        }
+        timed.push(...messages.map(row => messageEvent(dbPath, row)));
+        timed.push(...parts.map(row => partEvent(dbPath, row)));
+        const updated = valueNumber(session
+            .time_updated) ||
+            valueNumber(session
+                .time_created);
+        if (options.compacted) {
+            timed.push({
+                clock: updated,
+                order: 98,
+                event: {
+                    type: "session_compact",
+                    timestamp: toIso(updated),
+                    sourceEventId: `session:${options.nativeSessionId}:compact:${updated}`,
+                    data: {},
+                    provenance: {
+                        source: "opencode",
+                    },
+                },
+            });
+        }
+        if (options.error) {
+            timed.push({
+                clock: updated,
+                order: 99,
+                event: {
+                    type: "error",
+                    timestamp: toIso(updated),
+                    sourceEventId: `session:${options.nativeSessionId}:error:${updated}`,
+                    data: {
+                        source: "session.error",
+                    },
+                    provenance: {
+                        source: "opencode",
+                    },
+                },
+            });
+        }
+        else if (options.idle) {
+            timed.push({
+                clock: updated,
+                order: 100,
+                event: {
+                    type: "session_idle",
+                    timestamp: toIso(updated),
+                    sourceEventId: `session:${options.nativeSessionId}:idle:${updated}`,
+                    data: {},
+                    provenance: {
+                        source: "opencode",
+                    },
+                },
+            });
+        }
+        timed.sort((left, right) => (left.clock -
+            right.clock) ||
+            (left.order -
+                right.order));
+        const recorded = core.recordMany(timed.map(item => item.event));
+        const nextMessageCursor = cursorFromRows(messages, messageCursor);
+        const nextPartCursor = cursorFromRows(parts, partCursor);
+        core.setSourceCursor("opencode.message", encodeCursor(nextMessageCursor));
+        core.setSourceCursor("opencode.part", encodeCursor(nextPartCursor));
+        const flushed = await core.flush();
+        return {
+            nativeSessionId: options
+                .nativeSessionId,
+            importedMessages: messages.length,
+            importedParts: parts.length,
+            recordedEvents: recorded.length,
+            eventCount: flushed.eventCount,
+            chunkCount: flushed.chunkCount,
+            status: flushed.status,
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+export async function recoverOpenCodeProject(options) {
+    const dbPath = options.dbPath ??
+        defaultOpenCodeDbPath();
+    const db = openDatabase(dbPath);
+    const sessionIds = [];
+    try {
+        const rows = db.prepare(`
+        SELECT *
+        FROM "session"
+        ORDER BY
+          COALESCE(
+            time_updated,
+            time_created,
+            0
+          ) DESC
+        `).all();
+        for (const row of rows) {
+            if (!sessionBelongsToProject(db, row, options.project)) {
+                continue;
+            }
+            const id = valueString(row.id);
+            if (id) {
+                sessionIds.push(id);
+            }
+            if (sessionIds.length >=
+                (options.limit ??
+                    100)) {
+                break;
+            }
+        }
+    }
+    finally {
+        db.close();
+    }
+    const results = [];
+    for (const nativeSessionId of sessionIds) {
+        results.push(await syncOpenCodeSession({
+            project: options.project,
+            storage: options.storage,
+            nativeSessionId,
+            dbPath,
+        }));
+    }
+    return results;
+}