toolnet-memory 0.2.1 → 0.2.3

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

@@ -1,124 +0,0 @@
-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

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

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

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