toolnet-memory 0.2.1 → 0.2.2

package/dist/src/session/agy/recovery.js

@@ -1,112 +0,0 @@
-import { existsSync, } from "node:fs";
-import { homedir, } from "node:os";
-import { join, resolve, } from "node:path";
-import { DatabaseSync, } from "node:sqlite";
-import { defaultAgyTranscript, syncAgySession, } from "./adapter.js";
-function uriToPath(value) {
-    if (value.startsWith("file://")) {
-        try {
-            return decodeURIComponent(new URL(value).pathname);
-        }
-        catch {
-            return value;
-        }
-    }
-    return value;
-}
-function workspaceList(value) {
-    if (typeof value !==
-        "string" ||
-        !value) {
-        return [];
-    }
-    try {
-        const parsed = JSON.parse(value);
-        if (Array.isArray(parsed)) {
-            return parsed
-                .filter(item => typeof item ===
-                "string")
-                .map(uriToPath);
-        }
-    }
-    catch {
-        // continue
-    }
-    return [
-        uriToPath(value),
-    ];
-}
-function belongs(project, workspaces) {
-    const root = resolve(project.rootPath);
-    return workspaces.some(workspace => {
-        const path = resolve(workspace);
-        return (path === root ||
-            path.startsWith(root +
-                "/") ||
-            root.startsWith(path +
-                "/"));
-    });
-}
-export async function recoverAgyProject(project, storage, limit = 100) {
-    const summaryDb = process.env
-        .AGY_SUMMARY_DB ??
-        join(homedir(), ".gemini", "antigravity-cli", "conversation_summaries.db");
-    if (!existsSync(summaryDb)) {
-        throw new Error(`Agy summary database not found: ${summaryDb}`);
-    }
-    const db = new DatabaseSync(summaryDb, {
-        readOnly: true,
-    });
-    db.exec("PRAGMA query_only = ON");
-    const rows = db.prepare(`
-      SELECT
-        conversation_id,
-        title,
-        workspace_uris,
-        agent_name,
-        last_user_input_time
-      FROM conversation_summaries
-      ORDER BY
-        last_user_input_time DESC
-      `).all();
-    db.close();
-    const results = [];
-    for (const row of rows) {
-        const id = typeof row
-            .conversation_id ===
-            "string"
-            ? row
-                .conversation_id
-            : "";
-        if (!id) {
-            continue;
-        }
-        const workspaces = workspaceList(row.workspace_uris);
-        if (!belongs(project, workspaces)) {
-            continue;
-        }
-        const transcriptPath = defaultAgyTranscript(id);
-        if (!existsSync(transcriptPath)) {
-            continue;
-        }
-        results.push(await syncAgySession({
-            project,
-            storage,
-            conversationId: id,
-            transcriptPath,
-            workspacePaths: workspaces,
-            modelName: typeof row
-                .agent_name ===
-                "string"
-                ? row
-                    .agent_name
-                : undefined,
-            phase: "recover",
-        }));
-        if (results.length >=
-            limit) {
-            break;
-        }
-    }
-    return results;
-}

package/dist/src/session/agy/transcript.js

@@ -1,191 +0,0 @@
-import { existsSync, openSync, closeSync, readSync, statSync, } from "node:fs";
-function classify(value) {
-    const role = typeof value.role ===
-        "string"
-        ? value.role
-        : "";
-    const type = typeof value.type ===
-        "string"
-        ? value.type
-            .toLowerCase()
-        : "";
-    if (role === "user" ||
-        type.includes("user")) {
-        return "user_prompt";
-    }
-    if (role ===
-        "assistant" ||
-        type.includes("assistant") ||
-        type.includes("model")) {
-        return "assistant_message";
-    }
-    if (type.includes("tool") ||
-        "toolCall" in
-            value ||
-        "tool_call" in
-            value) {
-        return "tool_call";
-    }
-    if (type.includes("error")) {
-        return "error";
-    }
-    return "message";
-}
-function timestampOf(value) {
-    const candidates = [
-        value.timestamp,
-        value.createdAt,
-        value.time,
-        value.created_at,
-    ];
-    for (const candidate of candidates) {
-        if (typeof candidate ===
-            "string") {
-            const date = new Date(candidate);
-            if (!Number.isNaN(date.getTime())) {
-                return date.toISOString();
-            }
-        }
-        if (typeof candidate ===
-            "number") {
-            let time = candidate;
-            if (time <
-                100_000_000_000) {
-                time *= 1000;
-            }
-            const date = new Date(time);
-            if (!Number.isNaN(date.getTime())) {
-                return date.toISOString();
-            }
-        }
-    }
-    return new Date()
-        .toISOString();
-}
-export function readAgyTranscript(transcriptPath, cursor = {
-    offset: 0,
-}) {
-    if (!existsSync(transcriptPath)) {
-        return {
-            events: [],
-            nextOffset: cursor.offset,
-            reset: false,
-        };
-    }
-    const size = statSync(transcriptPath).size;
-    /*
-     * Transcript was truncated/rewritten.
-     * Start a new source epoch.
-     */
-    const reset = cursor.offset >
-        size;
-    const start = reset
-        ? 0
-        : cursor.offset;
-    if (start === size) {
-        return {
-            events: [],
-            nextOffset: size,
-            reset,
-        };
-    }
-    const length = size -
-        start;
-    const buffer = Buffer.alloc(length);
-    const fd = openSync(transcriptPath, "r");
-    try {
-        readSync(fd, buffer, 0, length, start);
-    }
-    finally {
-        closeSync(fd);
-    }
-    const text = buffer.toString("utf8");
-    /*
-     * Do not consume an incomplete final line while Agy
-     * is still appending to transcript.jsonl.
-     */
-    const lastNewline = text.lastIndexOf("\n");
-    if (lastNewline <
-        0) {
-        return {
-            events: [],
-            nextOffset: start,
-            reset,
-        };
-    }
-    const complete = text.slice(0, lastNewline +
-        1);
-    const consumedBytes = Buffer.byteLength(complete, "utf8");
-    const events = [];
-    let relativeOffset = 0;
-    for (const rawLine of complete
-        .split("\n")) {
-        if (!rawLine) {
-            continue;
-        }
-        const lineBytes = Buffer.byteLength(rawLine +
-            "\n", "utf8");
-        const absoluteOffset = start +
-            relativeOffset;
-        relativeOffset +=
-            lineBytes;
-        let parsed;
-        try {
-            parsed =
-                JSON.parse(rawLine);
-        }
-        catch {
-            /*
-             * Preserve malformed but readable trajectory lines.
-             */
-            events.push({
-                type: "custom",
-                sourceEventId: `transcript:${absoluteOffset}`,
-                sourceSequence: absoluteOffset,
-                data: {
-                    format: "raw-line",
-                    content: rawLine,
-                },
-                provenance: {
-                    source: "agy-transcript",
-                    sourcePath: transcriptPath,
-                    sourceOffset: absoluteOffset,
-                },
-            });
-            continue;
-        }
-        const data = parsed &&
-            typeof parsed ===
-                "object" &&
-            !Array.isArray(parsed)
-            ? parsed
-            : {
-                value: parsed,
-            };
-        events.push({
-            type: classify(data),
-            timestamp: timestampOf(data),
-            role: typeof data.role ===
-                "string"
-                ? data.role
-                : undefined,
-            /*
-             * Offset + original payload gives stable provenance.
-             */
-            sourceEventId: `transcript:${absoluteOffset}`,
-            sourceSequence: absoluteOffset,
-            data,
-            provenance: {
-                source: "agy-transcript",
-                sourcePath: transcriptPath,
-                sourceOffset: absoluteOffset,
-            },
-        });
-    }
-    return {
-        events,
-        nextOffset: start +
-            consumedBytes,
-        reset,
-    };
-}

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

@@ -1,138 +0,0 @@
-import { SessionCore, } from "../core.js";
-import { inspectCodexRollout, pathBelongsToProject, } from "./discovery.js";
-import { readCodexRollout, } from "./rollout.js";
-export async function syncCodexSession(options) {
-    const threadId = options.threadId
-        .trim();
-    if (!threadId) {
-        throw new Error("Codex thread ID is required");
-    }
-    const meta = inspectCodexRollout(options.rolloutPath);
-    const cwd = options.cwd ??
-        meta.cwd;
-    if (cwd &&
-        !pathBelongsToProject(options.project
-            .rootPath, cwd)) {
-        throw new Error(`Codex thread does not belong to project: ${cwd}`);
-    }
-    if (meta.threadId &&
-        meta.threadId !==
-            threadId) {
-        throw new Error(`Codex rollout thread mismatch: expected ${threadId}, got ${meta.threadId}`);
-    }
-    const core = new SessionCore({
-        project: options.project,
-        storage: options.storage,
-        agent: "codex",
-        nativeSessionId: threadId,
-        metadata: {
-            source: "codex-rollout",
-            rolloutPath: options.rolloutPath,
-            cwd,
-            client: options.client,
-        },
-    });
-    const state = core.status();
-    const previousPath = state.sourceCursors["codex.rollout.path"];
-    let offset = Number(state.sourceCursors["codex.rollout.offset"] ??
-        0);
-    /*
-     * Future Codex may rotate a resumed thread into another rollout.
-     */
-    if (previousPath &&
-        previousPath !==
-            options.rolloutPath) {
-        offset =
-            0;
-    }
-    if (!Number.isFinite(offset) ||
-        offset < 0) {
-        offset =
-            0;
-    }
-    const rollout = readCodexRollout(options.rolloutPath, offset);
-    const events = [];
-    if (state.lastSequence ===
-        0) {
-        events.push({
-            type: "session_start",
-            sourceEventId: `codex:${threadId}:start`,
-            data: {
-                threadId,
-                cwd,
-                rolloutPath: options.rolloutPath,
-                sessionMeta: meta.raw,
-            },
-            provenance: {
-                source: "codex-rollout",
-                sourcePath: options.rolloutPath,
-            },
-        });
-    }
-    if (previousPath &&
-        previousPath !==
-            options.rolloutPath) {
-        events.push({
-            type: "custom",
-            sourceEventId: `codex:${threadId}:rollout-rotation:${options.rolloutPath}`,
-            data: {
-                event: "rollout_rotation",
-                previousPath,
-                rolloutPath: options.rolloutPath,
-            },
-            provenance: {
-                source: "codex-rollout",
-            },
-        });
-    }
-    if (rollout.reset) {
-        events.push({
-            type: "custom",
-            sourceEventId: `codex:${threadId}:rollout-reset:${rollout.nextOffset}`,
-            data: {
-                event: "rollout_reset",
-            },
-            provenance: {
-                source: "codex-rollout",
-                sourcePath: options.rolloutPath,
-            },
-        });
-    }
-    events.push(...rollout.events);
-    /*
-     * AfterAgent/agent-turn-complete means this TURN is done.
-     * The Codex thread may be resumed later.
-     */
-    if (options.idle &&
-        options.turnId) {
-        events.push({
-            type: "session_idle",
-            sourceEventId: `codex:${threadId}:turn:${options.turnId}:idle`,
-            data: {
-                turnId: options.turnId,
-                client: options.client,
-            },
-            provenance: {
-                source: "codex-notify",
-            },
-        });
-    }
-    const recorded = core.recordMany(events);
-    core.setSourceCursor("codex.rollout.path", options.rolloutPath);
-    core.setSourceCursor("codex.rollout.offset", rollout.nextOffset);
-    if (options.turnId) {
-        core.setSourceCursor("codex.last.turn", options.turnId);
-    }
-    const flushed = await core.flush();
-    return {
-        threadId,
-        imported: recorded.length,
-        rolloutEvents: rollout.events
-            .length,
-        eventCount: flushed.eventCount,
-        chunkCount: flushed.chunkCount,
-        status: flushed.status,
-        rolloutOffset: rollout.nextOffset,
-        reset: rollout.reset,
-    };
-}

package/dist/src/session/codex/cli.js

@@ -1,236 +0,0 @@
-import { existsSync, readFileSync, } from "node:fs";
-import { spawn, } from "node:child_process";
-import { homedir, } from "node:os";
-import { join, } from "node:path";
-import { loadConfig, ProjectManager, } from "../../core/index.js";
-import { createStorageProvider, ProjectScopedStorageProvider, withStorageRetry, } from "../../storage/index.js";
-import { syncCodexSession, } from "./adapter.js";
-import { findCodexRollout, } from "./discovery.js";
-import { findCodexToolNetProject, } from "./project-resolver.js";
-import { recoverCodexProject, } from "./recovery.js";
-import { installCodexNotify, } from "./notify-installer.js";
-import { installCodexContextHook, } from "./context-hook-installer.js";
-import { refreshStartupBriefCache, } from "../../work-continuity/brief-cache.js";
-function after(args, flag) {
-    const index = args.indexOf(flag);
-    return index >=
-        0
-        ? args[index +
-            1]
-        : undefined;
-}
-function storageFor(project) {
-    const config = loadConfig();
-    const raw = withStorageRetry(createStorageProvider({
-        provider: config.storage
-            .provider,
-        huggingface: config.storage
-            .huggingface,
-        localRoot: config.storage
-            .localRoot,
-    }), {
-        attempts: 3,
-    });
-    return new ProjectScopedStorageProvider(raw, project.id, project.name, project.remote ??
-        project.name);
-}
-async function waitForRollout(threadId) {
-    for (let attempt = 0; attempt <
-        10; attempt +=
-        1) {
-        const file = findCodexRollout(threadId);
-        if (file) {
-            return file;
-        }
-        await new Promise(resolve => setTimeout(resolve, 150));
-    }
-    return null;
-}
-function runPreviousNotify(rawPayload) {
-    const previousFile = join(homedir(), ".config", "toolnet-memory", "codex-notify-previous.json");
-    if (!existsSync(previousFile)) {
-        return;
-    }
-    try {
-        const argv = JSON.parse(readFileSync(previousFile, "utf8"));
-        if (!Array.isArray(argv) ||
-            argv.length ===
-                0 ||
-            !argv.every(item => typeof item ===
-                "string")) {
-            return;
-        }
-        const child = spawn(argv[0], [
-            ...argv.slice(1),
-            rawPayload,
-        ], {
-            detached: true,
-            stdio: "ignore",
-        });
-        child.unref();
-    }
-    catch {
-        // Existing notifier must never break Codex.
-    }
-}
-async function notify(raw) {
-    let payload;
-    try {
-        payload =
-            JSON.parse(raw);
-    }
-    catch {
-        return;
-    }
-    const type = payload.type;
-    if (type !==
-        "agent-turn-complete") {
-        return;
-    }
-    const threadId = typeof payload["thread-id"] ===
-        "string"
-        ? payload["thread-id"]
-        : "";
-    const turnId = typeof payload["turn-id"] ===
-        "string"
-        ? payload["turn-id"]
-        : "";
-    const cwd = typeof payload.cwd ===
-        "string"
-        ? payload.cwd
-        : "";
-    const client = typeof payload.client ===
-        "string"
-        ? payload.client
-        : undefined;
-    if (!threadId ||
-        !cwd) {
-        return;
-    }
-    const project = findCodexToolNetProject(cwd);
-    /*
-     * Global Codex notify:
-     * ignore non-ToolNet projects.
-     */
-    if (!project) {
-        return;
-    }
-    const rolloutPath = await waitForRollout(threadId);
-    if (!rolloutPath) {
-        /*
-         * Recovery command will backfill later.
-         */
-        return;
-    }
-    const storage = storageFor(project);
-    await syncCodexSession({
-        project,
-        storage,
-        threadId,
-        rolloutPath,
-        cwd,
-        turnId,
-        client,
-        idle: true,
-    });
-    try {
-        await refreshStartupBriefCache(project, storage, 900);
-    }
-    catch {
-        // Derived cache must never break Codex notify.
-    }
-}
-async function main() {
-    const [command = "help", ...args] = process.argv.slice(2);
-    if (command ===
-        "install-notify") {
-        const binary = after(args, "--bin");
-        const result = installCodexNotify({
-            binary,
-        });
-        const contextHooks = installCodexContextHook({
-            binary,
-        });
-        console.log(`✅ Codex notify installed: ${result.configFile}`);
-        if (result
-            .preservedPrevious) {
-            console.log(`✅ Previous notify preserved: ${result.previousFile}`);
-        }
-        console.log(`✅ Codex SessionStart context hook: ${contextHooks}`);
-        return;
-    }
-    if (command ===
-        "notify") {
-        const raw = args[args.length -
-            1] ??
-            "";
-        try {
-            await notify(raw);
-        }
-        finally {
-            runPreviousNotify(raw);
-        }
-        return;
-    }
-    const projectPath = after(args, "--project") ??
-        process.cwd();
-    const project = new ProjectManager()
-        .detect(projectPath);
-    const storage = storageFor(project);
-    if (command ===
-        "sync") {
-        const threadId = args[0];
-        if (!threadId) {
-            throw new Error("Usage: sync <thread-id>");
-        }
-        const rolloutPath = after(args, "--rollout") ??
-            findCodexRollout(threadId);
-        if (!rolloutPath) {
-            throw new Error(`Codex rollout not found for ${threadId}`);
-        }
-        const result = await syncCodexSession({
-            project,
-            storage,
-            threadId,
-            rolloutPath,
-            idle: args.includes("--idle"),
-        });
-        console.log(JSON.stringify(result, null, 2));
-        return;
-    }
-    if (command ===
-        "recover") {
-        const rawLimit = Number(after(args, "--limit") ??
-            100);
-        const results = await recoverCodexProject(project, storage, Number.isFinite(rawLimit)
-            ? rawLimit
-            : 100);
-        console.log(JSON.stringify({
-            project: project.name,
-            sessions: results.length,
-            imported: results.reduce((total, item) => total +
-                item.imported, 0),
-        }, null, 2));
-        return;
-    }
-    console.log(`Codex Session Adapter
-
-Commands:
-  install-notify
-  sync <thread-id> [--project PATH]
-  recover [--project PATH] [--limit N]
-`);
-}
-main().catch(error => {
-    /*
-     * notify must never make Codex fail.
-     */
-    if (process.argv[2] ===
-        "notify") {
-        process.exit(0);
-    }
-    console.error(error instanceof Error
-        ? error.message
-        : error);
-    process.exit(1);
-});