toolnet-memory 0.2.1 → 0.2.3

package/dist/src/security/file-filter.js

@@ -1,30 +0,0 @@
-import { basename, } from "node:path";
-const BLOCKED_NAMES = new Set([
-    ".env",
-    ".env.local",
-    ".env.production",
-    ".env.development",
-    "id_rsa",
-    "id_ed25519",
-    "credentials",
-    "credentials.json",
-    "service-account.json",
-]);
-const BLOCKED_EXTENSIONS = new Set([
-    ".pem",
-    ".key",
-    ".p12",
-    ".pfx",
-]);
-export function isSensitiveFile(filePath) {
-    const name = basename(filePath).toLowerCase();
-    if (BLOCKED_NAMES.has(name)) {
-        return true;
-    }
-    for (const extension of BLOCKED_EXTENSIONS) {
-        if (name.endsWith(extension)) {
-            return true;
-        }
-    }
-    return false;
-}

package/dist/src/security/index.js

@@ -1,3 +0,0 @@
-export * from "./secret-scanner.js";
-export * from "./sanitizer.js";
-export * from "./file-filter.js";

package/dist/src/security/sanitizer.js

@@ -1,49 +0,0 @@
-import { SecretScanner } from "./secret-scanner.js";
-export class Sanitizer {
-    scanner = new SecretScanner();
-    sanitize(text) {
-        let output = text;
-        const matches = this.scanner.scan(text);
-        const secretTypes = new Set();
-        for (const match of matches) {
-            secretTypes.add(match.type);
-            output = output
-                .split(match.value)
-                .join(`[REDACTED:${match.type}]`);
-        }
-        return {
-            text: output,
-            redacted: matches.length,
-            secretTypes: [...secretTypes],
-        };
-    }
-    sanitizeValue(value) {
-        if (typeof value === "string") {
-            return this.sanitize(value).text;
-        }
-        if (Array.isArray(value)) {
-            return value.map((item) => this.sanitizeValue(item));
-        }
-        if (value &&
-            typeof value === "object") {
-            const output = {};
-            for (const [key, item] of Object.entries(value)) {
-                const normalized = key.toLowerCase();
-                if (normalized.includes("password") ||
-                    normalized.includes("secret") ||
-                    normalized.includes("token") ||
-                    normalized.includes("cookie") ||
-                    normalized.includes("authorization")) {
-                    output[key] =
-                        "[REDACTED]";
-                }
-                else {
-                    output[key] =
-                        this.sanitizeValue(item);
-                }
-            }
-            return output;
-        }
-        return value;
-    }
-}

package/dist/src/security/secret-scanner.js

@@ -1,56 +0,0 @@
-const PATTERNS = [
-    {
-        type: "openai_key",
-        regex: /\bsk-[A-Za-z0-9_\-]{20,}\b/g,
-    },
-    {
-        type: "huggingface_token",
-        regex: /\bhf_[A-Za-z0-9]{20,}\b/g,
-    },
-    {
-        type: "hf_s3_access_key",
-        regex: /\bHFAK[A-Za-z0-9]{8,}\b/g,
-    },
-    {
-        type: "bearer_token",
-        regex: /\bBearer\s+[A-Za-z0-9._\-]{16,}\b/gi,
-    },
-    {
-        type: "jwt",
-        regex: /\beyJ[A-Za-z0-9_\-]{8,}\.[A-Za-z0-9_\-]{8,}\.[A-Za-z0-9_\-]{8,}\b/g,
-    },
-    {
-        type: "private_key",
-        regex: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g,
-    },
-    {
-        type: "password_assignment",
-        regex: /\b(password|passwd|pwd)\s*[:=]\s*["']?[^"'\s]{6,}["']?/gi,
-    },
-    {
-        type: "secret_assignment",
-        regex: /\b(secret|api[_-]?key|access[_-]?token|refresh[_-]?token)\s*[:=]\s*["']?[^"'\s]{8,}["']?/gi,
-    },
-    {
-        type: "cookie",
-        regex: /\b(cookie|set-cookie)\s*[:=]\s*[^;\n]{8,}/gi,
-    },
-];
-export class SecretScanner {
-    scan(text) {
-        const matches = [];
-        for (const pattern of PATTERNS) {
-            const regex = new RegExp(pattern.regex.source, pattern.regex.flags);
-            for (const match of text.matchAll(regex)) {
-                matches.push({
-                    type: pattern.type,
-                    value: match[0],
-                });
-            }
-        }
-        return matches;
-    }
-    hasSecrets(text) {
-        return this.scan(text).length > 0;
-    }
-}

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

@@ -1,159 +0,0 @@
-import { existsSync, } from "node:fs";
-import { homedir, } from "node:os";
-import { join, resolve, } from "node:path";
-import { SessionCore, } from "../core.js";
-import { readAgyTranscript, } from "./transcript.js";
-function expandHome(value) {
-    if (value === "~") {
-        return homedir();
-    }
-    if (value.startsWith("~/")) {
-        return join(homedir(), value.slice(2));
-    }
-    return value;
-}
-export async function syncAgySession(options) {
-    const conversationId = options
-        .conversationId
-        .trim();
-    if (!conversationId) {
-        throw new Error("Agy conversationId is required");
-    }
-    const transcriptPath = resolve(expandHome(options
-        .transcriptPath));
-    const core = new SessionCore({
-        project: options.project,
-        storage: options.storage,
-        agent: "agy",
-        nativeSessionId: conversationId,
-        metadata: {
-            source: "antigravity-hook",
-            transcriptPath,
-            workspacePaths: options
-                .workspacePaths ??
-                [],
-            artifactDirectoryPath: options
-                .artifactDirectoryPath,
-            modelName: options.modelName,
-        },
-    });
-    const state = core.status();
-    const rawCursor = state
-        .sourceCursors["agy.transcript.offset"];
-    const offset = rawCursor
-        ? Number(rawCursor)
-        : 0;
-    const transcript = readAgyTranscript(transcriptPath, {
-        offset: Number.isFinite(offset)
-            ? offset
-            : 0,
-    });
-    const events = [];
-    if (state.lastSequence ===
-        0) {
-        events.push({
-            type: "session_start",
-            sourceEventId: `agy:${conversationId}:start`,
-            data: {
-                workspacePaths: options
-                    .workspacePaths ??
-                    [],
-                transcriptPath,
-                modelName: options.modelName,
-            },
-            provenance: {
-                source: "antigravity-hook",
-                sourcePath: transcriptPath,
-            },
-        });
-    }
-    if (transcript.reset) {
-        events.push({
-            type: "custom",
-            sourceEventId: `agy:${conversationId}:transcript-reset:${transcript.nextOffset}`,
-            data: {
-                event: "transcript_reset",
-                transcriptPath,
-            },
-            provenance: {
-                source: "agy-transcript",
-                sourcePath: transcriptPath,
-            },
-        });
-    }
-    events.push(...transcript.events);
-    if (options.phase ===
-        "stop") {
-        if (options.error) {
-            events.push({
-                type: "error",
-                sourceEventId: [
-                    "agy",
-                    conversationId,
-                    "stop-error",
-                    options
-                        .terminationReason ??
-                        "",
-                    transcript
-                        .nextOffset,
-                ].join(":"),
-                data: {
-                    error: options.error,
-                    terminationReason: options
-                        .terminationReason,
-                    fullyIdle: options
-                        .fullyIdle,
-                },
-                provenance: {
-                    source: "antigravity-stop-hook",
-                },
-            });
-        }
-        /*
-         * Stop is NOT permanent SessionEnd.
-         * The same conversation UUID may be resumed later.
-         */
-        if (options.fullyIdle) {
-            events.push({
-                type: "session_idle",
-                sourceEventId: [
-                    "agy",
-                    conversationId,
-                    "idle",
-                    transcript
-                        .nextOffset,
-                ].join(":"),
-                data: {
-                    terminationReason: options
-                        .terminationReason,
-                    fullyIdle: true,
-                },
-                provenance: {
-                    source: "antigravity-stop-hook",
-                },
-            });
-        }
-    }
-    const recorded = core.recordMany(events);
-    core.setSourceCursor("agy.transcript.offset", transcript.nextOffset);
-    if (options.phase) {
-        core.setSourceCursor("agy.last.phase", options.phase);
-    }
-    const flushed = await core.flush();
-    return {
-        conversationId,
-        imported: recorded.length,
-        eventCount: flushed.eventCount,
-        chunkCount: flushed.chunkCount,
-        status: flushed.status,
-        transcriptOffset: transcript
-            .nextOffset,
-        reset: transcript.reset,
-    };
-}
-export function defaultAgyTranscript(conversationId) {
-    return join(homedir(), ".gemini", "antigravity-cli", "brain", conversationId, ".system_generated", "logs", "transcript.jsonl");
-}
-export function agyTranscriptExists(conversationId) {
-    return existsSync(defaultAgyTranscript(conversationId));
-}

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