local-agent-memory 0.0.0-stage → 1.0.0

package/dist/cli/commands/sync.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doSyncProject = doSyncProject;
+exports.syncProject = syncProject;
+exports.computeSha256 = computeSha256;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const ora_1 = __importDefault(require("ora"));
+const sync_1 = require("../../core/sync");
+const project_1 = require("../../db/project");
+async function doSyncProject(cwd) {
+    const memoryDir = node_path_1.default.join(cwd, ".memory");
+    if (!node_fs_1.default.existsSync(memoryDir)) {
+        throw new Error("Project not initialized. Run memory init first.");
+    }
+    const localDbPath = (0, project_1.getLocalDbPath)(cwd);
+    const db = (0, project_1.initLocalDb)(localDbPath);
+    const _asyncDb = new sync_1.AsyncDatabase(db);
+    const manifests = await (0, project_1.getAllManifests)(localDbPath);
+    const manifestMap = new Map(manifests.map((m) => [m.file_path, m]));
+    const configPath = node_path_1.default.join(memoryDir, "config.json");
+    let includePaths = [".memory"];
+    if (node_fs_1.default.existsSync(configPath)) {
+        try {
+            const configData = JSON.parse(await node_fs_1.default.promises.readFile(configPath, "utf8"));
+            if (configData.include_paths && Array.isArray(configData.include_paths)) {
+                includePaths = configData.include_paths;
+            }
+        }
+        catch (_e) {
+            // Ignore parse errors, fallback to default
+        }
+    }
+    let currentFiles = [];
+    for (const inc of includePaths) {
+        const fullPath = node_path_1.default.join(cwd, inc);
+        if (node_fs_1.default.existsSync(fullPath)) {
+            const stat = await node_fs_1.default.promises.stat(fullPath);
+            if (stat.isDirectory()) {
+                const files = await getAllMarkdownFiles(fullPath);
+                currentFiles.push(...files);
+            }
+            else if (fullPath.endsWith(".md")) {
+                currentFiles.push(fullPath);
+            }
+        }
+    }
+    // Deduplicate files
+    currentFiles = Array.from(new Set(currentFiles));
+    let newCount = 0;
+    let modCount = 0;
+    let delCount = 0;
+    try {
+        // Check for new and modified
+        for (const file of currentFiles) {
+            const stats = await node_fs_1.default.promises.stat(file);
+            const mtime = stats.mtimeMs;
+            const relativePath = node_path_1.default.relative(cwd, file);
+            const existing = manifestMap.get(relativePath);
+            if (!existing) {
+                // New file
+                const sha256 = await computeSha256(file);
+                await (0, project_1.upsertFileManifest)(localDbPath, relativePath, mtime, sha256);
+                const content = await node_fs_1.default.promises.readFile(file, "utf8");
+                await (0, sync_1.syncFile)(relativePath, content, db);
+                newCount++;
+            }
+            else if (existing.mtime !== mtime) {
+                // Potentially modified, check hash
+                const sha256 = await computeSha256(file);
+                if (sha256 !== existing.sha256) {
+                    await (0, project_1.upsertFileManifest)(localDbPath, relativePath, mtime, sha256);
+                    const content = await node_fs_1.default.promises.readFile(file, "utf8");
+                    await (0, sync_1.syncFile)(relativePath, content, db);
+                    modCount++;
+                }
+            }
+            // Remove from map to track deletions
+            manifestMap.delete(relativePath);
+        }
+        // Anything left in map was deleted from disk
+        for (const [deletedPath] of manifestMap.entries()) {
+            await (0, sync_1.removeFile)(deletedPath, db);
+            delCount++;
+        }
+    }
+    finally {
+        db.close();
+    }
+    return { newCount, modCount, delCount };
+}
+async function syncProject() {
+    const cwd = process.cwd();
+    const memoryDir = node_path_1.default.join(cwd, ".memory");
+    if (!node_fs_1.default.existsSync(memoryDir)) {
+        console.error("Project not initialized. Run memory init first.");
+        process.exit(1);
+    }
+    const spinner = (0, ora_1.default)("Syncing project memory...").start();
+    try {
+        const { newCount, modCount, delCount } = await doSyncProject(cwd);
+        spinner.succeed(`Sync complete: ${newCount} new, ${modCount} modified, ${delCount} deleted.`);
+    }
+    catch (err) {
+        spinner.fail("Sync failed.");
+        console.error(err.message);
+        process.exit(1);
+    }
+}
+async function getAllMarkdownFiles(dirPath, arrayOfFiles = []) {
+    const files = await node_fs_1.default.promises.readdir(dirPath, { withFileTypes: true });
+    for (const file of files) {
+        if (file.isDirectory()) {
+            arrayOfFiles = await getAllMarkdownFiles(node_path_1.default.join(dirPath, file.name), arrayOfFiles);
+        }
+        else if (file.name.endsWith(".md")) {
+            arrayOfFiles.push(node_path_1.default.join(dirPath, file.name));
+        }
+    }
+    return arrayOfFiles;
+}
+function computeSha256(filePath) {
+    return new Promise((resolve, reject) => {
+        const hash = node_crypto_1.default.createHash("sha256");
+        const rs = node_fs_1.default.createReadStream(filePath);
+        rs.on("error", reject);
+        rs.on("data", (chunk) => hash.update(chunk));
+        rs.on("end", () => resolve(hash.digest("hex")));
+    });
+}

package/dist/cli/commands/template.d.ts

@@ -0,0 +1 @@
+export declare function manageTemplates(action: string, options?: any): Promise<void>;

package/dist/cli/commands/template.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageTemplates = manageTemplates;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const ora_1 = __importDefault(require("ora"));
+const initGlobal_1 = require("../../setup/initGlobal");
+async function getTemplatesDir() {
+    const dir = node_path_1.default.join((0, initGlobal_1.getLocalMemoryDir)(), "templates");
+    if (!node_fs_1.default.existsSync(dir)) {
+        await node_fs_1.default.promises.mkdir(dir, { recursive: true });
+    }
+    return dir;
+}
+async function manageTemplates(action, options = {}) {
+    const templatesDir = await getTemplatesDir();
+    if (action === "list") {
+        const spinner = (0, ora_1.default)("Fetching templates...").start();
+        try {
+            const entries = await node_fs_1.default.promises.readdir(templatesDir, {
+                withFileTypes: true,
+            });
+            const templates = entries
+                .filter((e) => e.isDirectory())
+                .map((e) => e.name);
+            if (templates.length === 0) {
+                spinner.info("No templates found.");
+            }
+            else {
+                spinner.succeed("Available templates:");
+                for (const t of templates) {
+                    console.log(` - ${t}`);
+                }
+            }
+        }
+        catch (err) {
+            spinner.fail("Failed to list templates.");
+            console.error(err.message);
+        }
+    }
+    else if (action === "create") {
+        const { name, description } = await inquirer_1.default.prompt([
+            { name: "name", message: "Template name:" },
+            { name: "description", message: "Template description:" },
+        ]);
+        const targetDir = node_path_1.default.join(templatesDir, name);
+        if (node_fs_1.default.existsSync(targetDir)) {
+            console.error("Template already exists.");
+            return;
+        }
+        await node_fs_1.default.promises.mkdir(targetDir, { recursive: true });
+        await node_fs_1.default.promises.writeFile(node_path_1.default.join(targetDir, "core.md"), `# ${name}\n\n${description}\n`);
+        console.log(`Template ${name} created successfully.`);
+    }
+    else if (action === "export-from-project") {
+        const cwd = process.cwd();
+        const memoryDir = node_path_1.default.join(cwd, ".memory");
+        if (!node_fs_1.default.existsSync(memoryDir)) {
+            console.error("No .memory directory found in current project.");
+            return;
+        }
+        let templateName = options.name;
+        if (!templateName) {
+            const answers = await inquirer_1.default.prompt([
+                { name: "name", message: "Enter a name for the exported template:" },
+            ]);
+            templateName = answers.name;
+        }
+        const targetDir = node_path_1.default.join(templatesDir, templateName);
+        if (node_fs_1.default.existsSync(targetDir)) {
+            console.error("A template with that name already exists.");
+            return;
+        }
+        await node_fs_1.default.promises.mkdir(targetDir, { recursive: true });
+        // Copy safe files recursively, sanitizing out sensitive or local paths
+        await copyAndSanitize(memoryDir, targetDir);
+        console.log(`Successfully exported project memory to template: ${templateName}`);
+    }
+}
+async function copyAndSanitize(src, dest) {
+    const entries = await node_fs_1.default.promises.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = node_path_1.default.join(src, entry.name);
+        const destPath = node_path_1.default.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await node_fs_1.default.promises.mkdir(destPath, { recursive: true });
+            await copyAndSanitize(srcPath, destPath);
+        }
+        else {
+            // Ignore SQLite databases, index files, or full config.json with hardcoded uuid
+            if (entry.name.endsWith(".sqlite") ||
+                entry.name.endsWith(".sqlite-shm") ||
+                entry.name.endsWith(".sqlite-wal") ||
+                entry.name === "config.json") {
+                continue;
+            }
+            if (entry.name.endsWith(".md")) {
+                const content = await node_fs_1.default.promises.readFile(srcPath, "utf8");
+                // Basic sanitization: strip absolute paths starting with /Users or C:\ or /home and common credentials
+                let sanitized = content.replace(/(?:\/Users|\/home|[C-Z]:\\)[^\s"']+/g, "[REDACTED_LOCAL_PATH]");
+                // Obfuscate potential API keys or tokens (very basic regex)
+                sanitized = sanitized.replace(/(sk-[a-zA-Z0-9]{20,})|(gh[po]_[a-zA-Z0-9]{36,})|([a-zA-Z0-9_-]{20,}:[a-zA-Z0-9_-]{20,})/g, "[REDACTED_CREDENTIAL]");
+                await node_fs_1.default.promises.writeFile(destPath, sanitized);
+            }
+            else if (entry.name.endsWith(".json") ||
+                entry.name.endsWith(".yaml") ||
+                entry.name.endsWith(".yml")) {
+                await node_fs_1.default.promises.copyFile(srcPath, destPath);
+            }
+        }
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function runCLI(): Promise<void>;

package/dist/cli/index.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCLI = runCLI;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const commander_1 = require("commander");
+const inquirer_1 = __importDefault(require("inquirer"));
+const ora_1 = __importDefault(require("ora"));
+const initGlobal_1 = require("../setup/initGlobal");
+const program = new commander_1.Command();
+program.name("memory").description("Local Agent Memory CLI").version("1.0.0");
+const hook_1 = require("./commands/hook");
+const init_1 = require("./commands/init");
+const record_1 = require("./commands/record");
+const status_1 = require("./commands/status");
+const sync_1 = require("./commands/sync");
+const template_1 = require("./commands/template");
+program
+    .command("init")
+    .description("Initialize a new memory project")
+    .option("-f, --force", "Force initialization even if already exists")
+    .option("-r, --rules <rules>", "Comma-separated IDE rules to inject (cursor,claude,copilot,antigravity-ide,antigravity-cli,all)")
+    .option("-d, --docs <path>", "Optional path to an existing docs directory to map/index automatically")
+    .action(init_1.initProject);
+program
+    .command("template <action>")
+    .description("Manage memory templates (list, create, export-from-project)")
+    .option("-n, --name <name>", "Name of the template")
+    .action(template_1.manageTemplates);
+program
+    .command("sync")
+    .description("Sync markdown files to the local memory index")
+    .action(sync_1.syncProject);
+const reindex_1 = require("./commands/reindex");
+program
+    .command("status")
+    .description("Check the sync status of the current memory project")
+    .action(status_1.projectStatus);
+program
+    .command("reindex")
+    .alias("prune")
+    .description("Rebuild the vector and FTS indexes from scratch (in case of corruption)")
+    .action(reindex_1.reindexProject);
+program
+    .command("record-session")
+    .description("Record a summary of the current session into the memory ledger")
+    .option("-s, --summary <summary>", "Summary of the work done in this session")
+    .action(record_1.recordSession);
+program
+    .command("install-hook")
+    .description("Install Git hooks to automatically record sessions or remind developers on commit")
+    .action(hook_1.installGitHook);
+program
+    .command("mcp-setup")
+    .description("Configure the MCP server for Cursor or Claude")
+    .action(async () => {
+    const spinner = (0, ora_1.default)("Setting up global environment...").start();
+    try {
+        await (0, initGlobal_1.initGlobalEnv)();
+        spinner.succeed("Global environment configured (ONNX model, sqlite-vec downloaded).");
+    }
+    catch (error) {
+        spinner.fail("Failed to set up global environment.");
+        console.error("\x1b[31m%s\x1b[0m", error);
+        process.exit(1);
+    }
+    const { client } = await inquirer_1.default.prompt([
+        {
+            type: "list",
+            name: "client",
+            message: "Which client do you want to configure?",
+            choices: [
+                "Claude Desktop",
+                "Cursor",
+                "Antigravity IDE",
+                "Antigravity CLI",
+            ],
+        },
+    ]);
+    let configPath = "";
+    if (client === "Claude Desktop") {
+        if (node_os_1.default.platform() === "win32") {
+            configPath = node_path_1.default.join(node_os_1.default.homedir(), "AppData", "Roaming", "Claude", "claude_desktop_config.json");
+        }
+        else if (node_os_1.default.platform() === "darwin") {
+            configPath = node_path_1.default.join(node_os_1.default.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+        }
+        else {
+            // Fallback for Linux or others if needed
+            configPath = node_path_1.default.join(node_os_1.default.homedir(), ".config", "Claude", "claude_desktop_config.json");
+        }
+    }
+    else if (client === "Antigravity IDE" || client === "Antigravity CLI") {
+        configPath = node_path_1.default.join(node_os_1.default.homedir(), ".gemini", "config", "mcp_config.json");
+    }
+    else {
+        // Cursor logic
+        configPath = node_path_1.default.join(node_os_1.default.homedir(), ".cursor", "mcp.json"); // Assumed path for cursor
+    }
+    // Ensure directory exists
+    const configDir = node_path_1.default.dirname(configPath);
+    if (!node_fs_1.default.existsSync(configDir)) {
+        await node_fs_1.default.promises.mkdir(configDir, { recursive: true });
+    }
+    // Backup config if it exists
+    let configObj = {};
+    if (node_fs_1.default.existsSync(configPath)) {
+        const backupPath = `${configPath}.backup-${Date.now()}`;
+        await node_fs_1.default.promises.copyFile(configPath, backupPath);
+        console.log(`Created backup at: ${backupPath}`);
+        try {
+            const fileContent = await node_fs_1.default.promises.readFile(configPath, "utf8");
+            configObj = JSON.parse(fileContent);
+        }
+        catch (_e) {
+            console.error("Failed to parse existing config, starting fresh.");
+        }
+    }
+    // Modify config (same format for Claude Desktop, Cursor, and Antigravity)
+    configObj.mcpServers = configObj.mcpServers || {};
+    configObj.mcpServers["local-agent-memory"] = {
+        command: "memory-mcp",
+        args: [],
+    };
+    // Write modified config
+    await node_fs_1.default.promises.writeFile(configPath, JSON.stringify(configObj, null, 2));
+    console.log(`Successfully configured MCP for ${client} at ${configPath}`);
+});
+async function runCLI() {
+    await program.parseAsync(process.argv);
+}
+/* istanbul ignore if */
+if (require.main === module) {
+    runCLI().catch(console.error);
+}

package/dist/cli/mcp.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function runMCP(): Promise<void>;

package/dist/cli/mcp.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMCP = runMCP;
+const server_1 = require("../mcp/server");
+async function runMCP() {
+    await (0, server_1.setupMCPServer)();
+}
+// Start MCP server if run directly
+/* istanbul ignore if */
+if (require.main === module) {
+    runMCP().catch(console.error);
+}

package/dist/core/embeddings.d.ts

@@ -0,0 +1,14 @@
+import type { FeatureExtractionPipeline } from "@xenova/transformers";
+/**
+ * Initializes and returns the feature extraction pipeline.
+ * It uses a singleton pattern to only load the model once.
+ */
+export declare function getExtractor(): Promise<FeatureExtractionPipeline>;
+/**
+ * Generates embeddings for a given text.
+ * Uses `@xenova/transformers` with `Xenova/all-MiniLM-L6-v2`
+ *
+ * @param text The input text to vectorise.
+ * @returns An array of floats representing the embedding vector.
+ */
+export declare function generateEmbedding(text: string): Promise<number[]>;

package/dist/core/embeddings.js

@@ -0,0 +1,127 @@
+"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.getExtractor = getExtractor;
+exports.generateEmbedding = generateEmbedding;
+let extractorPromise = null;
+let inactivityTimeout = null;
+const INACTIVITY_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutos
+function resetInactivityTimeout() {
+    if (inactivityTimeout) {
+        clearTimeout(inactivityTimeout);
+    }
+    inactivityTimeout = setTimeout(async () => {
+        if (extractorPromise) {
+            try {
+                const extractor = await extractorPromise;
+                // Si el pipeline soporta dispose, lo llamamos para liberar memoria del runtime ONNX
+                if (typeof extractor.dispose === "function") {
+                    await extractor.dispose();
+                }
+            }
+            catch (_err) {
+                // Ignorar posibles errores en el dispose
+            }
+            extractorPromise = null;
+        }
+    }, INACTIVITY_TIMEOUT_MS);
+    // Evitamos que este timeout mantenga vivo el proceso de Node.js si no hay nada más corriendo
+    if (inactivityTimeout.unref) {
+        inactivityTimeout.unref();
+    }
+}
+/**
+ * Initializes and returns the feature extraction pipeline.
+ * It uses a singleton pattern to only load the model once.
+ */
+async function getExtractor() {
+    resetInactivityTimeout();
+    if (!extractorPromise) {
+        extractorPromise = (async () => {
+            const { pipeline, env } = await Promise.resolve().then(() => __importStar(require("@xenova/transformers")));
+            const os = await Promise.resolve().then(() => __importStar(require("node:os")));
+            const path = await Promise.resolve().then(() => __importStar(require("node:path")));
+            const fs = await Promise.resolve().then(() => __importStar(require("node:fs")));
+            // Ensure we use the correct models directory
+            const modelsDir = path.join(os.homedir(), ".local_memory", "models");
+            env.cacheDir = modelsDir;
+            // Check if the model is corrupted (size < ~22MB) before loading
+            const modelPath = path.join(modelsDir, "Xenova", "all-MiniLM-L6-v2", "onnx", "model_quantized.onnx");
+            if (fs.existsSync(modelPath)) {
+                const stats = fs.statSync(modelPath);
+                if (stats.size < 22000000) {
+                    console.warn("⚠️ Corrupted or incomplete ONNX model found. Removing to trigger re-download...");
+                    fs.rmSync(path.join(modelsDir, "Xenova", "all-MiniLM-L6-v2"), {
+                        recursive: true,
+                        force: true,
+                    });
+                }
+            }
+            try {
+                return (await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2", {
+                    quantized: true,
+                }));
+            }
+            catch (err) {
+                // If it fails to load, it might be corrupted. Clean it up.
+                console.warn("⚠️ Error loading ONNX model, it may be corrupted. Cleaning up cache...", err);
+                if (fs.existsSync(path.join(modelsDir, "Xenova", "all-MiniLM-L6-v2"))) {
+                    fs.rmSync(path.join(modelsDir, "Xenova", "all-MiniLM-L6-v2"), {
+                        recursive: true,
+                        force: true,
+                    });
+                }
+                throw err;
+            }
+        })();
+    }
+    return extractorPromise;
+}
+/**
+ * Generates embeddings for a given text.
+ * Uses `@xenova/transformers` with `Xenova/all-MiniLM-L6-v2`
+ *
+ * @param text The input text to vectorise.
+ * @returns An array of floats representing the embedding vector.
+ */
+async function generateEmbedding(text) {
+    const extractor = await getExtractor();
+    // Await the extraction
+    const output = await extractor(text, { pooling: "mean", normalize: true });
+    // Extend timeout after work is done as well
+    resetInactivityTimeout();
+    // Return the raw float array data
+    return Array.from(output.data);
+}

package/dist/core/parser.d.ts

@@ -0,0 +1,25 @@
+export interface Chunk {
+    path: string;
+    text: string;
+    breadcrumbs: string;
+    startLine: number;
+    endLine: number;
+}
+/**
+ * A very simple token count heuristic (4 chars ~ 1 token)
+ * to avoid depending on tiktoken or similar heavy libraries,
+ * suitable for MiniLM approximation.
+ */
+export declare function countTokens(text: string): number;
+/**
+ * Parses markdown content and breaks it down into chunks of text
+ * bounded by maxTokens, aiming to preserve logical code blocks and headings.
+ * Includes simple breadcrumbs based on headings.
+ *
+ * @param content The markdown text content.
+ * @param path The file path (for metadata).
+ * @param maxTokens Maximum number of tokens per chunk.
+ * @param overlapTokens Target token overlap between chunks.
+ * @returns Array of chunk objects.
+ */
+export declare function parseMarkdown(content: string, path: string, maxTokens?: number, overlapTokens?: number): Promise<Chunk[]>;