local-agent-memory 0.0.0-stage → 1.0.1

package/dist/mcp/middleware.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncMiddleware = syncMiddleware;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const sync_1 = require("../cli/commands/sync");
+async function syncMiddleware(cwd = process.cwd()) {
+    const memoryDir = path.join(cwd, ".memory");
+    if (!fs.existsSync(memoryDir)) {
+        throw new Error("Project not initialized. Run memory init first.");
+    }
+    await (0, sync_1.doSyncProject)(cwd);
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function setupMCPServer(): Promise<McpServer>;

package/dist/mcp/server.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupMCPServer = setupMCPServer;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const tools_1 = require("./tools");
+const utils_1 = require("./utils");
+async function setupMCPServer() {
+    const { cwd } = await (0, utils_1.resolveCwd)();
+    const memoryDir = path.join(cwd, ".memory");
+    if (!fs.existsSync(memoryDir)) {
+        fs.mkdirSync(memoryDir, { recursive: true });
+    }
+    const logFile = path.join(memoryDir, "mcp-debug.log");
+    const log = (msg) => {
+        fs.appendFileSync(logFile, `[${new Date().toISOString()}] ${msg}\n`);
+    };
+    log("Starting MCP Server");
+    const server = new mcp_js_1.McpServer({
+        name: "local-agent-memory",
+        version: "1.0.0",
+    });
+    server.resource("agent-guidelines", "memory://agent-guidelines", { description: "Agent guidelines and memory core rules" }, async (uri) => {
+        const { cwd: resolvedCwd } = await (0, utils_1.resolveCwd)();
+        const corePath = path.join(resolvedCwd, ".memory", "core.md");
+        const text = fs.existsSync(corePath)
+            ? fs.readFileSync(corePath, "utf8")
+            : "No core memory found.";
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    text,
+                    mimeType: "text/markdown",
+                },
+            ],
+        };
+    });
+    server.prompt("agent-guidelines", "Get the agent guidelines and memory core rules", async () => {
+        const { cwd: resolvedCwd } = await (0, utils_1.resolveCwd)();
+        const corePath = path.join(resolvedCwd, ".memory", "core.md");
+        const text = fs.existsSync(corePath)
+            ? fs.readFileSync(corePath, "utf8")
+            : "No core memory found.";
+        return {
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: `Here are the core rules for this project:\n\n${text}`,
+                    },
+                },
+            ],
+        };
+    });
+    (0, tools_1.registerTools)(server);
+    const transport = new stdio_js_1.StdioServerTransport();
+    transport.onerror = (err) => {
+        log(`Transport error: ${err}`);
+    };
+    await server.connect(transport);
+    log("MCP Server connected via stdio");
+    // Opcionalmente podemos exponer log para ser usado por tools si se lo pasamos,
+    // pero el servidor ya está funcionando y registrando arranque y errores.
+    return server;
+}

package/dist/mcp/tools.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerTools(server: McpServer): void;

package/dist/mcp/tools.js

@@ -0,0 +1,244 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTools = registerTools;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const zod_1 = require("zod");
+const search_1 = require("../core/search");
+const project_1 = require("../db/project");
+const middleware_1 = require("./middleware");
+const utils_1 = require("./utils");
+function registerTools(server) {
+    // @ts-expect-error - Bypass TS2589
+    server.tool("get_project_context", "Obtiene el contexto del proyecto actual leyendo el archivo core.md y listando decisiones recientes.", {
+        projectRoot: zod_1.z
+            .string()
+            .optional()
+            .describe("Ruta absoluta del proyecto (usar si MCP es global)"),
+    }, async (args) => {
+        const { cwd, fallbackUsed } = await (0, utils_1.resolveCwd)(args.projectRoot, server);
+        await (0, middleware_1.syncMiddleware)(cwd);
+        const memoryDir = path.join(cwd, ".memory");
+        const corePath = path.join(memoryDir, "core.md");
+        let coreContent = "No core.md found.";
+        if (fs.existsSync(corePath)) {
+            coreContent = fs.readFileSync(corePath, "utf8");
+        }
+        const decisionsDir = path.join(memoryDir, "decisions");
+        let decisionsList = [];
+        if (fs.existsSync(decisionsDir)) {
+            const files = fs
+                .readdirSync(decisionsDir)
+                .filter((f) => f.endsWith(".md"))
+                .sort()
+                .reverse()
+                .slice(0, 5);
+            decisionsList = files.map((f) => `- ${f}`);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `${fallbackUsed ? `[Warning: Used fallback project root at ${cwd}]\n\n` : ""}## Core Rules\n${coreContent}\n\n## Recent Decisions\n${decisionsList.join("\n")}`,
+                },
+            ],
+        };
+    });
+    // @ts-expect-error - Bypass TS2589
+    server.tool("search_memory", "Busca en la memoria usando búsqueda híbrida (semántica y léxica).", {
+        query: zod_1.z.string().describe("La consulta a buscar"),
+        filter: zod_1.z.string().optional().describe("Filtro por ruta de archivo"),
+        limit: zod_1.z.number().optional().describe("Límite de resultados"),
+        projectRoot: zod_1.z
+            .string()
+            .optional()
+            .describe("Ruta absoluta del proyecto (usar si MCP es global)"),
+    }, async (args) => {
+        const { cwd, fallbackUsed } = await (0, utils_1.resolveCwd)(args.projectRoot, server);
+        await (0, middleware_1.syncMiddleware)(cwd);
+        const dbPath = (0, project_1.getLocalDbPath)(cwd);
+        const db = (0, project_1.initLocalDb)(dbPath);
+        try {
+            const results = await (0, search_1.hybridSearch)(args.query, args.limit || 10, db, args.filter);
+            let textResults = results
+                .map((r) => `[${r.path}:${r.startLine}-${r.endLine}] ${r.breadcrumbs}\n${r.text}`)
+                .join("\n\n---\n\n");
+            // Truncar para cumplir con límite de tokens (DR-05: ~1500 tokens por retorno, aprox 6000 caracteres)
+            if (textResults.length > 6000) {
+                textResults = `${textResults.slice(0, 6000)}\n\n...[Truncated due to token limits]`;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: (fallbackUsed
+                            ? `[Warning: Used fallback project root at ${cwd}]\n\n`
+                            : "") + (textResults || "No results found."),
+                    },
+                ],
+            };
+        }
+        finally {
+            db.close();
+        }
+    });
+    server.tool("log_decision", "Registra una nueva decisión arquitectónica (ADR).", {
+        title: zod_1.z.string().describe("Título corto de la decisión"),
+        status: zod_1.z.string().describe("Estado (ej. Aceptado, Rechazado)"),
+        context: zod_1.z.string().describe("Contexto del problema"),
+        decision: zod_1.z.string().describe("La decisión tomada"),
+        consequences: zod_1.z.string().describe("Consecuencias de la decisión"),
+        alternatives_considered: zod_1.z
+            .string()
+            .optional()
+            .describe("Alternativas consideradas"),
+        projectRoot: zod_1.z
+            .string()
+            .optional()
+            .describe("Ruta absoluta del proyecto (usar si MCP es global)"),
+    }, async (args) => {
+        // Create slug
+        const date = new Date().toISOString().split("T")[0];
+        const slug = args.title
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, "-")
+            .replace(/(^-|-$)/g, "");
+        const filename = `${date}-${slug}.md`;
+        const { cwd, fallbackUsed } = await (0, utils_1.resolveCwd)(args.projectRoot, server);
+        const memoryDir = path.join(cwd, ".memory");
+        const decisionsDir = path.join(memoryDir, "decisions");
+        if (!fs.existsSync(decisionsDir)) {
+            fs.mkdirSync(decisionsDir, { recursive: true });
+        }
+        const filePath = path.join(decisionsDir, filename);
+        let content = `---
+title: ${args.title}
+status: ${args.status}
+date: ${date}
+---
+
+# ${args.title}
+
+## Context
+${args.context}
+
+## Decision
+${args.decision}
+
+## Consequences
+${args.consequences}
+`;
+        if (args.alternatives_considered) {
+            content += `\n## Alternatives Considered\n${args.alternatives_considered}\n`;
+        }
+        fs.writeFileSync(filePath, content);
+        // Sincronizar después de escribir
+        await (0, middleware_1.syncMiddleware)(cwd);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `${fallbackUsed ? `[Warning: Used fallback project root at ${cwd}]\n\n` : ""}Decision logged successfully at ${path.join(".memory", "decisions", filename)}`,
+                },
+            ],
+        };
+    });
+    server.tool("update_core_rules", "Añade contenido a las reglas core (core.md).", {
+        changes_to_append: zod_1.z
+            .string()
+            .describe("Contenido a añadir al final del archivo core.md"),
+        projectRoot: zod_1.z
+            .string()
+            .optional()
+            .describe("Ruta absoluta del proyecto (usar si MCP es global)"),
+    }, async (args) => {
+        const { cwd, fallbackUsed } = await (0, utils_1.resolveCwd)(args.projectRoot, server);
+        const memoryDir = path.join(cwd, ".memory");
+        const corePath = path.join(memoryDir, "core.md");
+        if (!fs.existsSync(memoryDir)) {
+            fs.mkdirSync(memoryDir, { recursive: true });
+        }
+        fs.appendFileSync(corePath, `\n${args.changes_to_append}\n`);
+        // Sincronizar después de escribir
+        await (0, middleware_1.syncMiddleware)(cwd);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `${fallbackUsed ? `[Warning: Used fallback project root at ${cwd}]\n\n` : ""}Core rules updated successfully.`,
+                },
+            ],
+        };
+    });
+    server.tool("end_session", "Finaliza una tarea o sesión, sintetizando qué se modificó y qué acuerdos se tomaron, guardándolo en el ledger de la memoria.", {
+        summary: zod_1.z
+            .string()
+            .describe("Resumen de lo que se modificó y qué acuerdos se tomaron en la sesión"),
+        projectRoot: zod_1.z
+            .string()
+            .optional()
+            .describe("Ruta absoluta del proyecto (usar si MCP es global)"),
+    }, async (args) => {
+        const { cwd, fallbackUsed } = await (0, utils_1.resolveCwd)(args.projectRoot, server);
+        const memoryDir = path.join(cwd, ".memory");
+        const ledgerDir = path.join(memoryDir, "ledger");
+        const dateObj = new Date();
+        const year = dateObj.getFullYear();
+        const month = String(dateObj.getMonth() + 1).padStart(2, "0");
+        const day = String(dateObj.getDate()).padStart(2, "0");
+        const hours = String(dateObj.getHours()).padStart(2, "0");
+        const minutes = String(dateObj.getMinutes()).padStart(2, "0");
+        const seconds = String(dateObj.getSeconds()).padStart(2, "0");
+        const filename = `${year}-${month}-${day}-${hours}-${minutes}-${seconds}-session.md`;
+        const summariesPath = path.join(ledgerDir, filename);
+        if (!fs.existsSync(ledgerDir)) {
+            fs.mkdirSync(ledgerDir, { recursive: true });
+        }
+        const date = dateObj.toISOString();
+        const content = `\n## Session ended at ${date}\n\n${args.summary}\n\n---\n`;
+        fs.writeFileSync(summariesPath, content);
+        // Sincronizar después de escribir
+        await (0, middleware_1.syncMiddleware)(cwd);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `${fallbackUsed ? `[Warning: Used fallback project root at ${cwd}]\n\n` : ""}Session summary flushed successfully to .memory/ledger/${filename}`,
+                },
+            ],
+        };
+    });
+}

package/dist/mcp/utils.d.ts

@@ -0,0 +1,5 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function resolveCwd(argsPath?: string, server?: McpServer): Promise<{
+    cwd: string;
+    fallbackUsed: boolean;
+}>;

package/dist/mcp/utils.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCwd = resolveCwd;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const registry_1 = require("../db/registry");
+async function resolveCwd(argsPath, server) {
+    if (argsPath && fs.existsSync(argsPath)) {
+        return { cwd: argsPath, fallbackUsed: false };
+    }
+    if (server && server.server) {
+        try {
+            const result = await server.server.request({ method: "roots/list" }, require("zod").any());
+            const roots = result?.roots;
+            if (roots && Array.isArray(roots)) {
+                for (const root of roots) {
+                    let rootPath = root.uri.replace(/^file:\/\//i, "");
+                    if (process.platform === "win32" && rootPath.startsWith("/")) {
+                        rootPath = rootPath.slice(1);
+                    }
+                    rootPath = decodeURIComponent(rootPath);
+                    if (fs.existsSync(path.join(rootPath, ".memory"))) {
+                        return { cwd: rootPath, fallbackUsed: false };
+                    }
+                }
+            }
+        }
+        catch (_e) {
+            // Ignore errors if client doesn't support roots/list
+        }
+    }
+    const current = process.cwd();
+    if (fs.existsSync(path.join(current, ".memory"))) {
+        return { cwd: current, fallbackUsed: false };
+    }
+    try {
+        const registryResult = await (0, registry_1.getProjectRootFromRegistry)(current);
+        if (registryResult && fs.existsSync(registryResult.path)) {
+            return {
+                cwd: registryResult.path,
+                fallbackUsed: registryResult.fallback,
+            };
+        }
+    }
+    catch (_err) {
+        // Ignore db errors on fallback
+    }
+    return { cwd: current, fallbackUsed: false };
+}

package/dist/setup/initGlobal.d.ts

@@ -0,0 +1,5 @@
+export declare const getLocalMemoryDir: () => string;
+export declare const getModelsDir: () => string;
+export declare const getBinDir: () => string;
+export declare function downloadFile(url: string, dest: string, retries?: number): Promise<void>;
+export declare function initGlobalEnv(): Promise<void>;

package/dist/setup/initGlobal.js

@@ -0,0 +1,167 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBinDir = exports.getModelsDir = exports.getLocalMemoryDir = void 0;
+exports.downloadFile = downloadFile;
+exports.initGlobalEnv = initGlobalEnv;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_https_1 = __importDefault(require("node:https"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const transformers_1 = require("@xenova/transformers");
+const tar = __importStar(require("tar"));
+const getLocalMemoryDir = () => node_path_1.default.join(node_os_1.default.homedir(), ".local_memory");
+exports.getLocalMemoryDir = getLocalMemoryDir;
+const getModelsDir = () => node_path_1.default.join((0, exports.getLocalMemoryDir)(), "models");
+exports.getModelsDir = getModelsDir;
+const getBinDir = () => node_path_1.default.join((0, exports.getLocalMemoryDir)(), "bin");
+exports.getBinDir = getBinDir;
+async function downloadFile(url, dest, retries = 3) {
+    for (let i = 0; i < retries; i++) {
+        try {
+            await new Promise((resolve, reject) => {
+                const file = node_fs_1.default.createWriteStream(dest);
+                node_https_1.default
+                    .get(url, (response) => {
+                    if (response.statusCode === 301 || response.statusCode === 302) {
+                        // handle redirect
+                        if (!response.headers.location) {
+                            reject(new Error("Redirect with no location"));
+                            return;
+                        }
+                        downloadFile(response.headers.location, dest, retries)
+                            .then(resolve)
+                            .catch(reject);
+                        return;
+                    }
+                    if (response.statusCode !== 200) {
+                        reject(new Error(`Failed to download, status code: ${response.statusCode}`));
+                        return;
+                    }
+                    response.pipe(file);
+                    file.on("finish", () => {
+                        file.close();
+                        resolve();
+                    });
+                })
+                    .on("error", (err) => {
+                    node_fs_1.default.unlink(dest, () => { });
+                    reject(err);
+                });
+            });
+            return; // Success
+        }
+        catch (error) {
+            if (i === retries - 1) {
+                throw error;
+            }
+            // Wait before retry
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+    }
+}
+function getSqliteVecUrl() {
+    const platform = node_os_1.default.platform();
+    const arch = node_os_1.default.arch();
+    const version = "0.1.8";
+    const baseUrl = `https://github.com/asg017/sqlite-vec/releases/download/v${version}`;
+    if (platform === "win32") {
+        return `${baseUrl}/sqlite-vec-${version}-loadable-windows-x86_64.tar.gz`;
+    }
+    else if (platform === "darwin") {
+        if (arch === "arm64")
+            return `${baseUrl}/sqlite-vec-${version}-loadable-macos-aarch64.tar.gz`;
+        return `${baseUrl}/sqlite-vec-${version}-loadable-macos-x86_64.tar.gz`;
+    }
+    else {
+        // linux
+        if (arch === "arm64")
+            return `${baseUrl}/sqlite-vec-${version}-loadable-linux-aarch64.tar.gz`;
+        return `${baseUrl}/sqlite-vec-${version}-loadable-linux-x86_64.tar.gz`;
+    }
+}
+async function initGlobalEnv() {
+    const modelsDir = (0, exports.getModelsDir)();
+    const binDir = (0, exports.getBinDir)();
+    if (!node_fs_1.default.existsSync(modelsDir)) {
+        node_fs_1.default.mkdirSync(modelsDir, { recursive: true });
+    }
+    if (!node_fs_1.default.existsSync(binDir)) {
+        node_fs_1.default.mkdirSync(binDir, { recursive: true });
+    }
+    // Configure xenova transformers cache
+    transformers_1.env.cacheDir = modelsDir;
+    // Download ONNX model (all-MiniLM-L6-v2) if not present
+    try {
+        await (0, transformers_1.pipeline)("feature-extraction", "Xenova/all-MiniLM-L6-v2", {
+            quantized: true,
+        });
+    }
+    catch (error) {
+        console.error("Error downloading ONNX model:", error);
+        throw error;
+    }
+    // Download sqlite-vec
+    const vecUrl = getSqliteVecUrl();
+    const vecFlag = node_path_1.default.join(binDir, ".sqlite-vec-downloaded");
+    if (!node_fs_1.default.existsSync(vecFlag)) {
+        try {
+            const tempDest = node_path_1.default.join(binDir, vecUrl.endsWith(".zip") ? "temp.zip" : "temp.tar.gz");
+            await downloadFile(vecUrl, tempDest, 3);
+            // Extract
+            /* istanbul ignore if */
+            if (vecUrl.endsWith(".zip")) {
+                // simple powershell unzip for win32 without external deps since tar might not handle zip well always
+                (0, node_child_process_1.execSync)(`powershell -command "Expand-Archive -Force '${tempDest}' '${binDir}'"`);
+            }
+            else {
+                await tar.x({
+                    file: tempDest,
+                    cwd: binDir,
+                });
+            }
+            node_fs_1.default.unlinkSync(tempDest);
+            node_fs_1.default.writeFileSync(vecFlag, new Date().toISOString());
+        }
+        catch (error) {
+            console.error("Error downloading sqlite-vec extension:", error);
+            throw error;
+        }
+    }
+}