local-agent-memory 1.0.9 → 1.0.11

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) => {