toolnet-memory 0.2.0

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

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

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

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

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

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

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

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