local-agent-memory 1.0.8 → 1.0.10

package/dist/db/project.js

@@ -10,6 +10,8 @@ exports.upsertFileManifest = upsertFileManifest;
 exports.getFileManifest = getFileManifest;
 exports.getAllManifests = getAllManifests;
 exports.removeFileManifest = removeFileManifest;
+exports.insertMcpUsageLog = insertMcpUsageLog;
+exports.getMcpUsageStats = getMcpUsageStats;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -34,11 +36,26 @@ function getLocalDbPath(projectRoot) {
     return node_path_1.default.join(projectRoot, ".memory", "local.sqlite");
 }
 function initLocalDb(dbPath) {
-    const db = new sqlite3_1.default.Database(dbPath);
+    const db = new sqlite3_1.default.Database(dbPath, () => { });
+    db.on("error", () => { });
     db.configure("busyTimeout", 5000);
     db.serialize(() => {
         db.run("PRAGMA journal_mode = WAL;");
         db.run("PRAGMA busy_timeout = 5000;");
+        db.run("PRAGMA synchronous = NORMAL;");
+        db.run("PRAGMA foreign_keys = ON;");
+        db.run(`
+      CREATE TABLE IF NOT EXISTS mcp_usage_logs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+        project_path TEXT,
+        event_type TEXT NOT NULL,
+        tool_name TEXT,
+        query_or_summary TEXT,
+        execution_time_ms INTEGER,
+        success BOOLEAN
+      )
+    `);
         db.run(`
       CREATE TABLE IF NOT EXISTS file_manifest (
         file_path TEXT PRIMARY KEY,
@@ -101,11 +118,14 @@ function initLocalDb(dbPath) {
     });
     return db;
 }
-async function upsertFileManifest(dbPath, file_path, mtime, sha256) {
+async function upsertFileManifest(dbOrPath, file_path, mtime, sha256) {
     return new Promise((resolve, reject) => {
-        const db = initLocalDb(dbPath);
+        const isDb = typeof dbOrPath !== "string";
+        const db = isDb ? dbOrPath : initLocalDb(dbOrPath);
         db.run("INSERT OR REPLACE INTO file_manifest (file_path, mtime, sha256, last_synced) VALUES (?, ?, ?, CURRENT_TIMESTAMP)", [file_path, mtime, sha256], (err) => {
-            db.close();
+            if (!isDb) {
+                db.close();
+            }
             if (err)
                 reject(err);
             else
@@ -113,11 +133,14 @@ async function upsertFileManifest(dbPath, file_path, mtime, sha256) {
         });
     });
 }
-async function getFileManifest(dbPath, file_path) {
+async function getFileManifest(dbOrPath, file_path) {
     return new Promise((resolve, reject) => {
-        const db = initLocalDb(dbPath);
+        const isDb = typeof dbOrPath !== "string";
+        const db = isDb ? dbOrPath : initLocalDb(dbOrPath);
         db.get("SELECT file_path, mtime, sha256 FROM file_manifest WHERE file_path = ?", [file_path], (err, row) => {
-            db.close();
+            if (!isDb) {
+                db.close();
+            }
             if (err)
                 reject(err);
             else
@@ -125,11 +148,14 @@ async function getFileManifest(dbPath, file_path) {
         });
     });
 }
-async function getAllManifests(dbPath) {
+async function getAllManifests(dbOrPath) {
     return new Promise((resolve, reject) => {
-        const db = initLocalDb(dbPath);
+        const isDb = typeof dbOrPath !== "string";
+        const db = isDb ? dbOrPath : initLocalDb(dbOrPath);
         db.all("SELECT file_path, mtime, sha256 FROM file_manifest", (err, rows) => {
-            db.close();
+            if (!isDb) {
+                db.close();
+            }
             if (err)
                 reject(err);
             else
@@ -137,11 +163,14 @@ async function getAllManifests(dbPath) {
         });
     });
 }
-async function removeFileManifest(dbPath, file_path) {
+async function removeFileManifest(dbOrPath, file_path) {
     return new Promise((resolve, reject) => {
-        const db = initLocalDb(dbPath);
+        const isDb = typeof dbOrPath !== "string";
+        const db = isDb ? dbOrPath : initLocalDb(dbOrPath);
         db.run("DELETE FROM file_manifest WHERE file_path = ?", [file_path], (err) => {
-            db.close();
+            if (!isDb) {
+                db.close();
+            }
             if (err)
                 reject(err);
             else
@@ -149,3 +178,96 @@ async function removeFileManifest(dbPath, file_path) {
         });
     });
 }
+async function insertMcpUsageLog(dbOrPath, entry) {
+    return new Promise((resolve) => {
+        try {
+            const isDb = typeof dbOrPath !== "string";
+            const db = isDb ? dbOrPath : initLocalDb(dbOrPath);
+            db.run(`INSERT INTO mcp_usage_logs (project_path, event_type, tool_name, query_or_summary, execution_time_ms, success)
+         VALUES (?, ?, ?, ?, ?, ?)`, [
+                entry.project_path,
+                entry.event_type,
+                entry.tool_name ?? null,
+                entry.query_or_summary ?? null,
+                entry.execution_time_ms ?? null,
+                entry.success ?? true,
+            ], (_err) => {
+                if (!isDb) {
+                    try {
+                        db.close();
+                    }
+                    catch { }
+                }
+                resolve();
+            });
+        }
+        catch {
+            resolve();
+        }
+    });
+}
+async function getMcpUsageStats(dbOrPath) {
+    return new Promise((resolve) => {
+        const emptyStats = {
+            totalCalls: 0,
+            readCalls: 0,
+            writeCalls: 0,
+            lastConnection: null,
+            recentQueries: [],
+        };
+        try {
+            const isDb = typeof dbOrPath !== "string";
+            const db = isDb ? dbOrPath : initLocalDb(dbOrPath);
+            db.serialize(() => {
+                db.all(`SELECT
+             COUNT(*) as total_count,
+             SUM(CASE WHEN tool_name IN ('get_project_context', 'memory_recall_context', 'search_memory') THEN 1 ELSE 0 END) as read_count,
+             SUM(CASE WHEN tool_name IN ('log_decision', 'memory_record_decision', 'update_core_rules', 'end_session') THEN 1 ELSE 0 END) as write_count,
+             MAX(timestamp) as last_conn
+           FROM mcp_usage_logs`, [], (err, statsRows) => {
+                    if (err) {
+                        if (!isDb) {
+                            try {
+                                db.close();
+                            }
+                            catch { }
+                        }
+                        return resolve(emptyStats);
+                    }
+                    db.all(`SELECT timestamp, event_type, tool_name, query_or_summary, success
+               FROM mcp_usage_logs
+               WHERE event_type = 'tool_call'
+               ORDER BY id DESC
+               LIMIT 5`, [], (err2, recentRows) => {
+                        if (!isDb) {
+                            try {
+                                db.close();
+                            }
+                            catch { }
+                        }
+                        if (err2) {
+                            return resolve(emptyStats);
+                        }
+                        const row = statsRows?.[0] || {};
+                        resolve({
+                            totalCalls: row.total_count || 0,
+                            readCalls: row.read_count || 0,
+                            writeCalls: row.write_count || 0,
+                            lastConnection: row.last_conn || null,
+                            recentQueries: (recentRows || []).map((r) => ({
+                                timestamp: r.timestamp,
+                                event_type: r.event_type,
+                                tool_name: r.tool_name,
+                                query_or_summary: r.query_or_summary,
+                                success: Boolean(r.success),
+                            })),
+                        });
+                    });
+                });
+            });
+        }
+        catch {
+            resolve(emptyStats);
+        }
+    });
+}

package/dist/db/registry.js

@@ -34,6 +34,8 @@ function initRegistryDb(dbPath = getRegistryDbPath()) {
     db.serialize(() => {
         db.run("PRAGMA journal_mode = WAL;");
         db.run("PRAGMA busy_timeout = 5000;");
+        db.run("PRAGMA synchronous = NORMAL;");
+        db.run("PRAGMA foreign_keys = ON;");
         db.run(`
       CREATE TABLE IF NOT EXISTS projects (
         project_id TEXT PRIMARY KEY,

package/dist/mcp/logger.d.ts

@@ -1,3 +1,4 @@
+export declare const getLocalMemoryDir: () => string;
 export interface MemoryConfig {
     project_id?: string;
     created_at?: string;
@@ -8,3 +9,4 @@ export interface MemoryConfig {
 }
 export declare function getMemoryConfig(cwd: string): MemoryConfig | null;
 export declare function logUsage(cwd: string, action: string, details?: Record<string, unknown>): void;
+export declare function recordMcpEvent(cwd: string, eventType: string, toolName?: string, queryOrSummary?: string, executionTimeMs?: number, success?: boolean): Promise<void>;

package/dist/mcp/logger.js

@@ -33,10 +33,16 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalMemoryDir = void 0;
 exports.getMemoryConfig = getMemoryConfig;
 exports.logUsage = logUsage;
+exports.recordMcpEvent = recordMcpEvent;
 const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
+const project_1 = require("../db/project");
+const getLocalMemoryDir = () => process.env.MEMORY_GLOBAL_DIR || path.join(os.homedir(), ".local_memory");
+exports.getLocalMemoryDir = getLocalMemoryDir;
 function getMemoryConfig(cwd) {
     const configPath = path.join(cwd, ".memory", "config.json");
     if (!fs.existsSync(configPath)) {
@@ -76,3 +82,42 @@ function logUsage(cwd, action, details) {
         // Fail silently to avoid breaking any MCP operation
     }
 }
+async function recordMcpEvent(cwd, eventType, toolName, queryOrSummary, executionTimeMs, success = true) {
+    const timestamp = new Date().toISOString();
+    // 1. Global log to ~/.local_memory/mcp-events.log
+    try {
+        const globalDir = (0, exports.getLocalMemoryDir)();
+        if (!fs.existsSync(globalDir)) {
+            fs.mkdirSync(globalDir, { recursive: true });
+        }
+        const globalLog = path.join(globalDir, "mcp-events.log");
+        const line = `[${timestamp}] cwd=${cwd} event=${eventType} tool=${toolName || "none"} success=${success}${queryOrSummary ? ` summary="${queryOrSummary.slice(0, 100).replace(/\n/g, " ")}"` : ""}\n`;
+        fs.appendFileSync(globalLog, line, "utf8");
+    }
+    catch {
+        // ignore
+    }
+    // 2. Project SQLite log (mcp_usage_logs) if project DB exists
+    try {
+        const localDb = (0, project_1.getLocalDbPath)(cwd);
+        if (fs.existsSync(localDb)) {
+            await (0, project_1.insertMcpUsageLog)(localDb, {
+                project_path: cwd,
+                event_type: eventType,
+                tool_name: toolName ?? null,
+                query_or_summary: queryOrSummary ?? null,
+                execution_time_ms: executionTimeMs ?? null,
+                success,
+            });
+        }
+    }
+    catch {
+        // ignore
+    }
+    // 3. Fallback/compatibility logUsage
+    logUsage(cwd, `${eventType}: ${toolName || "event"}`, {
+        queryOrSummary,
+        executionTimeMs,
+        success,
+    });
+}

package/dist/mcp/server.js

@@ -57,7 +57,8 @@ async function setupMCPServer() {
             // Ignore write errors to prevent server crash
         }
     };
-    log("Starting MCP Server");
+    log(`Starting MCP Server [pid=${process.pid}, cwd=${process.cwd()}, argv=${JSON.stringify(process.argv)}]`);
+    (0, logger_1.recordMcpEvent)(process.cwd(), "init", "server_start", `Started MCP Server (pid: ${process.pid})`).catch(() => { });
     const server = new mcp_js_1.McpServer({
         name: "local-agent-memory",
         version: require("../../package.json").version,
@@ -81,6 +82,43 @@ async function setupMCPServer() {
             ],
         };
     });
+    server.resource("current-project-overview", "memory://current-project/overview", {
+        description: "Overview of current project memory, recent decisions, and status",
+    }, async (uri) => {
+        const { cwd: resolvedCwd } = await (0, utils_1.resolveCwd)();
+        (0, logger_1.recordMcpEvent)(resolvedCwd, "resource_read", "current-project-overview").catch(() => { });
+        const memoryDir = path.join(resolvedCwd, ".memory");
+        const corePath = path.join(memoryDir, "core.md");
+        const coreFound = fs.existsSync(corePath);
+        const decisionsDir = path.join(memoryDir, "decisions");
+        let recentDecisions = [];
+        if (fs.existsSync(decisionsDir)) {
+            recentDecisions = fs
+                .readdirSync(decisionsDir)
+                .filter((f) => f.endsWith(".md"))
+                .sort()
+                .reverse()
+                .slice(0, 10);
+        }
+        const summaryText = [
+            `# Project Memory Overview`,
+            `- Root: ${resolvedCwd}`,
+            `- Core rules: ${coreFound ? "Present" : "Missing"}`,
+            `- Decisions logged: ${recentDecisions.length} recent`,
+            recentDecisions.length > 0
+                ? recentDecisions.map((d) => `  * ${d}`).join("\n")
+                : "  (None recorded yet)",
+        ].join("\n");
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    text: summaryText,
+                    mimeType: "text/markdown",
+                },
+            ],
+        };
+    });
     server.prompt("agent-guidelines", "Get the agent guidelines and memory core rules", async () => {
         const { cwd: resolvedCwd } = await (0, utils_1.resolveCwd)();
         (0, logger_1.logUsage)(resolvedCwd, "PROMPT_GET: agent-guidelines");
@@ -100,6 +138,25 @@ async function setupMCPServer() {
             ],
         };
     });
+    server.prompt("contexto-proyecto", "Obtener el contexto activo, reglas de arquitectura y sincronizar la memoria del proyecto", async () => {
+        const { cwd: resolvedCwd } = await (0, utils_1.resolveCwd)();
+        (0, logger_1.recordMcpEvent)(resolvedCwd, "prompt_get", "contexto-proyecto").catch(() => { });
+        const corePath = path.join(resolvedCwd, ".memory", "core.md");
+        const text = fs.existsSync(corePath)
+            ? fs.readFileSync(corePath, "utf8")
+            : "No se encontró core.md en este proyecto.";
+        return {
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: `Por favor sincroniza el contexto local del proyecto e incorpora estas reglas obligatorias:\n\n${text}`,
+                    },
+                },
+            ],
+        };
+    });
     (0, tools_1.registerTools)(server);
     const transport = new stdio_js_1.StdioServerTransport();
     transport.onerror = (err) => {