toolnet-memory 0.2.0 → 0.2.2

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

@@ -1,87 +0,0 @@
-import { loadConfig, ProjectManager, } from "../../core/index.js";
-import { createStorageProvider, ProjectScopedStorageProvider, withStorageRetry, } from "../../storage/index.js";
-import { syncAgySession, } from "./adapter.js";
-import { installAgyHooks, } from "./hook-installer.js";
-import { recoverAgyProject, } from "./recovery.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 main() {
-    const [command = "help", ...args] = process.argv.slice(2);
-    if (command ===
-        "install-hooks") {
-        const file = installAgyHooks({
-            binary: after(args, "--bin"),
-        });
-        console.log(`✅ Agy hooks installed: ${file}`);
-        return;
-    }
-    const projectPath = after(args, "--project") ??
-        process.cwd();
-    const project = new ProjectManager()
-        .detect(projectPath);
-    const storage = storageFor(project);
-    if (command ===
-        "sync") {
-        const conversationId = args[0];
-        const transcriptPath = after(args, "--transcript");
-        if (!conversationId ||
-            !transcriptPath) {
-            throw new Error("Usage: sync <conversation-id> --transcript <path>");
-        }
-        const result = await syncAgySession({
-            project,
-            storage,
-            conversationId,
-            transcriptPath,
-            phase: "recover",
-        });
-        console.log(JSON.stringify(result, null, 2));
-        return;
-    }
-    if (command ===
-        "recover") {
-        const limit = Number(after(args, "--limit") ??
-            100);
-        const results = await recoverAgyProject(project, storage, Number.isFinite(limit)
-            ? limit
-            : 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(`Agy Session Adapter
-
-Commands:
-  install-hooks
-  sync <conversation-id> --transcript <path>
-  recover [--project PATH] [--limit N]
-`);
-}
-main().catch(error => {
-    console.error(error instanceof Error
-        ? error.message
-        : error);
-    process.exit(1);
-});

package/dist/src/session/agy/hook-installer.js

@@ -1,62 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
-import { homedir, } from "node:os";
-import { dirname, join, } from "node:path";
-function quote(value) {
-    return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-export function installAgyHooks(options = {}) {
-    const hooksFile = options.hooksFile ??
-        join(homedir(), ".gemini", "config", "hooks.json");
-    mkdirSync(dirname(hooksFile), {
-        recursive: true,
-    });
-    let root = {};
-    if (existsSync(hooksFile)) {
-        try {
-            root =
-                JSON.parse(readFileSync(hooksFile, "utf8"));
-        }
-        catch (error) {
-            throw new Error(`Invalid existing Agy hooks.json: ${error instanceof Error
-                ? error.message
-                : String(error)}`);
-        }
-    }
-    const binary = options.binary ??
-        "toolnet-memory";
-    const command = `${quote(binary)} session:agy-hook`;
-    /*
-     * Official Antigravity hook schema.
-     * Stop = sync when one execution becomes idle.
-     * It is intentionally NOT treated as permanent SessionEnd.
-     */
-    root["toolnet-memory"] = {
-        enabled: true,
-        PreInvocation: [
-            {
-                type: "command",
-                command: `${command} pre`,
-                timeout: 15,
-            },
-        ],
-        PostInvocation: [
-            {
-                type: "command",
-                command: `${command} post`,
-                timeout: 15,
-            },
-        ],
-        Stop: [
-            {
-                type: "command",
-                command: `${command} stop`,
-                timeout: 30,
-            },
-        ],
-    };
-    writeFileSync(hooksFile, JSON.stringify(root, null, 2) + "\n", {
-        encoding: "utf8",
-        mode: 0o600,
-    });
-    return hooksFile;
-}

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

@@ -1,167 +0,0 @@
-import { loadConfig, } from "../../core/index.js";
-import { createStorageProvider, ProjectScopedStorageProvider, withStorageRetry, } from "../../storage/index.js";
-import { buildAgyPreInvocationOutput, refreshStartupBriefCache, } from "../../work-continuity/index.js";
-import { findToolNetProject, } from "./project-resolver.js";
-import { syncAgySession, } from "./adapter.js";
-async function readStdin() {
-    let content = "";
-    for await (const chunk of process.stdin) {
-        content +=
-            chunk.toString();
-    }
-    if (!content.trim()) {
-        return {};
-    }
-    try {
-        return JSON.parse(content);
-    }
-    catch {
-        return {};
-    }
-}
-function strings(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.filter(item => typeof item ===
-        "string");
-}
-async function main() {
-    const phase = (process.argv[2] ??
-        "post");
-    const input = await readStdin();
-    const conversationId = typeof input
-        .conversationId ===
-        "string"
-        ? input
-            .conversationId
-        : "";
-    const transcriptPath = typeof input
-        .transcriptPath ===
-        "string"
-        ? input
-            .transcriptPath
-        : "";
-    const workspacePaths = strings(input.workspacePaths);
-    const project = findToolNetProject(workspacePaths);
-    let hookOutput = {};
-    if (project &&
-        conversationId) {
-        try {
-            const config = loadConfig();
-            const raw = withStorageRetry(createStorageProvider({
-                provider: config.storage
-                    .provider,
-                huggingface: config.storage
-                    .huggingface,
-                localRoot: config.storage
-                    .localRoot,
-            }), {
-                attempts: 2,
-            });
-            const storage = new ProjectScopedStorageProvider(raw, project.id, project.name, project.remote ??
-                project.name);
-            /*
-             * Session capture remains independent from context
-             * injection. One failure cannot break the other.
-             */
-            if (transcriptPath) {
-                try {
-                    await syncAgySession({
-                        project,
-                        storage,
-                        conversationId,
-                        transcriptPath,
-                        workspacePaths,
-                        artifactDirectoryPath: typeof input
-                            .artifactDirectoryPath ===
-                            "string"
-                            ? input
-                                .artifactDirectoryPath
-                            : undefined,
-                        modelName: typeof input
-                            .modelName ===
-                            "string"
-                            ? input
-                                .modelName
-                            : undefined,
-                        phase,
-                        fullyIdle: input.fullyIdle ===
-                            true,
-                        terminationReason: typeof input
-                            .terminationReason ===
-                            "string"
-                            ? input
-                                .terminationReason
-                            : undefined,
-                        error: typeof input.error ===
-                            "string" &&
-                            input.error
-                            ? input.error
-                            : undefined,
-                    });
-                }
-                catch {
-                    // Capture failure must not block Agy.
-                }
-            }
-            if (phase ===
-                "pre") {
-                try {
-                    hookOutput =
-                        await buildAgyPreInvocationOutput({
-                            project,
-                            storage,
-                            conversationId,
-                            invocationNum: typeof input
-                                .invocationNum ===
-                                "number"
-                                ? input
-                                    .invocationNum
-                                : undefined,
-                        });
-                }
-                catch {
-                    hookOutput =
-                        {};
-                }
-            }
-            /*
-             * End of one Agy execution:
-             * publish the newest compact Startup Brief so another
-             * agent/VPS can resume immediately.
-             */
-            if (phase ===
-                "stop") {
-                try {
-                    await refreshStartupBriefCache(project, storage, 900);
-                }
-                catch {
-                    // Optional derived cache.
-                }
-            }
-        }
-        catch {
-            // ToolNet must never break Agy.
-        }
-    }
-    if (phase ===
-        "stop") {
-        process.stdout.write(JSON.stringify({
-            decision: "stop",
-        }));
-        return;
-    }
-    process.stdout.write(JSON.stringify(hookOutput));
-}
-main().catch(() => {
-    if (process.argv[2] ===
-        "stop") {
-        process.stdout.write('{"decision":"stop"}');
-    }
-    else {
-        process.stdout.write("{}");
-    }
-    process.exitCode =
-        0;
-});

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

@@ -1,5 +0,0 @@
-export * from "./transcript.js";
-export * from "./adapter.js";
-export * from "./project-resolver.js";
-export * from "./hook-installer.js";
-export * from "./recovery.js";

package/dist/src/session/agy/project-resolver.js

@@ -1,27 +0,0 @@
-import { existsSync, } from "node:fs";
-import { dirname, join, parse, resolve, } from "node:path";
-import { ProjectManager, } from "../../core/index.js";
-export function findToolNetProject(workspacePaths) {
-    for (const workspace of workspacePaths) {
-        let current = resolve(workspace);
-        const root = parse(current).root;
-        while (true) {
-            if (existsSync(join(current, ".toolnet", "project.json"))) {
-                return new ProjectManager()
-                    .detect(current);
-            }
-            if (current ===
-                root) {
-                break;
-            }
-            const parent = dirname(current);
-            if (parent ===
-                current) {
-                break;
-            }
-            current =
-                parent;
-        }
-    }
-    return null;
-}

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,
-    };
-}