local-agent-memory 1.0.8 → 1.0.10

package/dist/mcp/tools.js

@@ -43,221 +43,478 @@ const logger_1 = require("./logger");
 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.", {
+    const mcp = server;
+    const recallContextSchema = {
+        projectPath: zod_1.z
+            .string()
+            .optional()
+            .describe("Absolute path to the root directory of the current workspace/project."),
         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);
-        (0, logger_1.logUsage)(cwd, "TOOL_CALL: get_project_context", {
-            projectRoot: args.projectRoot,
+            .describe("Alternative alias for projectPath."),
+        query: zod_1.z
+            .string()
+            .optional()
+            .describe("Optional keywords, technical concepts, or file names to query in context."),
+    };
+    const recallContextDescription = "CRITICAL MANDATORY FIRST STEP: You MUST call this tool BEFORE starting any task, answering architectural questions, writing code, or debugging. " +
+        "It retrieves vital project context, architectural decisions, conventions, and historical bug fixes from local memory. " +
+        "Never assume project rules without calling this tool first.";
+    const recallContextHandler = async (args, toolName) => {
+        const startTime = Date.now();
+        const projectArg = args.projectPath || args.projectRoot;
+        const { cwd, fallbackUsed } = await (0, utils_1.resolveCwd)(projectArg, server);
+        (0, logger_1.logUsage)(cwd, `TOOL_CALL: ${toolName}`, {
+            projectPath: projectArg,
+            query: args.query,
         });
-        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");
+        try {
+            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}`);
+            }
+            let extraQuerySection = "";
+            if (args.query && args.query.trim().length > 0) {
+                const dbPath = (0, project_1.getLocalDbPath)(cwd);
+                if (fs.existsSync(dbPath)) {
+                    const db = (0, project_1.initLocalDb)(dbPath);
+                    try {
+                        const queryHits = await (0, search_1.hybridSearch)(args.query, 3, db);
+                        if (queryHits.length > 0) {
+                            extraQuerySection = `\n\n## Relevant Context for "${args.query}"\n${queryHits
+                                .map((h) => `[${h.path}:${h.startLine}-${h.endLine}] ${h.breadcrumbs}\n${h.text}`)
+                                .join("\n\n---\n\n")}`;
+                        }
+                    }
+                    finally {
+                        db.close();
+                    }
+                }
+            }
+            await (0, logger_1.recordMcpEvent)(cwd, "tool_call", toolName, args.query || "recall context", Date.now() - startTime, true);
+            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")}${extraQuerySection}`,
+                    },
+                ],
+            };
         }
-        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}`);
+        catch (err) {
+            await (0, logger_1.recordMcpEvent)(cwd, "tool_call", toolName, `Error: ${err.message}`, Date.now() - startTime, false);
+            throw err;
         }
-        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"),
+    };
+    // Register get_project_context and its alias memory_recall_context
+    mcp.tool("get_project_context", recallContextDescription, recallContextSchema, (args) => recallContextHandler(args, "get_project_context"));
+    mcp.tool("memory_recall_context", recallContextDescription, recallContextSchema, (args) => recallContextHandler(args, "memory_recall_context"));
+    // search_memory
+    const searchMemoryDescription = "CRITICAL STEP: Search local project memory using hybrid search (semantic embeddings and full-text search). " +
+        "Call this whenever looking for architectural patterns, past decisions, error solutions, or domain rules.";
+    mcp.tool("search_memory", searchMemoryDescription, {
+        query: zod_1.z
+            .string()
+            .describe("Technical keywords, concepts, or file names to search"),
+        filter: zod_1.z.string().optional().describe("Filter by file path"),
+        limit: zod_1.z.number().optional().describe("Limit of results (default: 10)"),
+        full_content: zod_1.z
+            .boolean()
+            .optional()
+            .describe("If true, loads and returns the complete text of the matching documents instead of snippets"),
+        projectPath: zod_1.z
+            .string()
+            .optional()
+            .describe("Absolute path to the root directory of the current project"),
         projectRoot: zod_1.z
             .string()
             .optional()
-            .describe("Ruta absoluta del proyecto (usar si MCP es global)"),
+            .describe("Alternative alias for projectPath"),
     }, async (args) => {
-        const { cwd, fallbackUsed } = await (0, utils_1.resolveCwd)(args.projectRoot, server);
+        const startTime = Date.now();
+        const projectArg = args.projectPath || args.projectRoot;
+        const { cwd, fallbackUsed } = await (0, utils_1.resolveCwd)(projectArg, server);
         (0, logger_1.logUsage)(cwd, "TOOL_CALL: search_memory", {
             query: args.query,
             filter: args.filter,
             limit: args.limit,
+            full_content: args.full_content,
         });
-        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]`;
+            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 = "";
+                if (results.length === 0) {
+                    textResults = "No results found.";
+                }
+                else if (args.full_content) {
+                    const uniquePaths = Array.from(new Set(results.map((r) => r.path)));
+                    const fullDocs = [];
+                    for (const filePath of uniquePaths) {
+                        const absPath = path.isAbsolute(filePath)
+                            ? filePath
+                            : path.resolve(cwd, filePath);
+                        if (fs.existsSync(absPath)) {
+                            const docText = fs.readFileSync(absPath, "utf8");
+                            fullDocs.push(`### File: ${filePath}\n\n${docText}`);
+                        }
+                        else {
+                            const fileChunks = results
+                                .filter((r) => r.path === filePath)
+                                .map((r) => `[${r.path}:${r.startLine}-${r.endLine}] ${r.breadcrumbs}\n${r.text}`)
+                                .join("\n\n---\n\n");
+                            fullDocs.push(fileChunks);
+                        }
+                    }
+                    textResults = fullDocs.join("\n\n====================\n\n");
+                }
+                else {
+                    textResults = results
+                        .map((r) => `[${r.path}:${r.startLine}-${r.endLine}] ${r.breadcrumbs}\n${r.text}`)
+                        .join("\n\n---\n\n");
+                }
+                await (0, logger_1.recordMcpEvent)(cwd, "tool_call", "search_memory", args.query, Date.now() - startTime, true);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: (fallbackUsed
+                                ? `[Warning: Used fallback project root at ${cwd}]\n\n`
+                                : "") + textResults,
+                        },
+                    ],
+                };
             }
+            finally {
+                db.close();
+            }
+        }
+        catch (err) {
+            await (0, logger_1.recordMcpEvent)(cwd, "tool_call", "search_memory", `Error: ${err.message}`, Date.now() - startTime, false);
+            throw err;
+        }
+    });
+    // get_memory_document & alias read_memory_document
+    const getDocumentDescription = "CRITICAL RETRIEVAL STEP: Retrieve the entire, untruncated content of a specific memory document, decision record, ledger session, or core rule file. Use this when search snippets are insufficient or when full file context is needed.";
+    const getDocumentSchema = {
+        file_path: zod_1.z
+            .string()
+            .describe("Path or filename of the memory document (e.g., 'core.md', 'decisions/2026-10-14-xxx.md', or '.memory/decisions/2026-10-14-xxx.md')"),
+        projectPath: zod_1.z
+            .string()
+            .optional()
+            .describe("Absolute path to the root directory of the current project"),
+        projectRoot: zod_1.z
+            .string()
+            .optional()
+            .describe("Alternative alias for projectPath"),
+    };
+    const getDocumentHandler = async (args, toolName) => {
+        const startTime = Date.now();
+        const projectArg = args.projectPath || args.projectRoot;
+        const { cwd, fallbackUsed } = await (0, utils_1.resolveCwd)(projectArg, server);
+        (0, logger_1.logUsage)(cwd, `TOOL_CALL: ${toolName}`, {
+            file_path: args.file_path,
+        });
+        try {
+            await (0, middleware_1.syncMiddleware)(cwd);
+            const requested = (args.file_path || "").trim();
+            if (!requested) {
+                throw new Error("Parameter 'file_path' is required.");
+            }
+            const memoryDir = path.join(cwd, ".memory");
+            const candidates = [
+                path.isAbsolute(requested) ? requested : path.resolve(cwd, requested),
+                path.resolve(memoryDir, requested),
+                path.resolve(memoryDir, "decisions", requested),
+                path.resolve(memoryDir, "ledger", requested),
+            ];
+            if (!requested.endsWith(".md")) {
+                candidates.push(path.resolve(cwd, `${requested}.md`), path.resolve(memoryDir, `${requested}.md`), path.resolve(memoryDir, "decisions", `${requested}.md`), path.resolve(memoryDir, "ledger", `${requested}.md`));
+            }
+            let foundPath = null;
+            for (const cand of candidates) {
+                if (fs.existsSync(cand) && fs.statSync(cand).isFile()) {
+                    foundPath = cand;
+                    break;
+                }
+            }
+            if (!foundPath && fs.existsSync(memoryDir)) {
+                const baseTarget = path.basename(requested).toLowerCase();
+                const baseTargetWithExt = baseTarget.endsWith(".md")
+                    ? baseTarget
+                    : `${baseTarget}.md`;
+                const findFileRecursive = (dir) => {
+                    const entries = fs.readdirSync(dir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        const full = path.join(dir, entry.name);
+                        if (entry.isDirectory()) {
+                            const res = findFileRecursive(full);
+                            if (res)
+                                return res;
+                        }
+                        else if (entry.name.toLowerCase() === baseTarget ||
+                            entry.name.toLowerCase() === baseTargetWithExt) {
+                            return full;
+                        }
+                    }
+                    return null;
+                };
+                foundPath = findFileRecursive(memoryDir);
+            }
+            if (!foundPath) {
+                const decisionsDir = path.join(memoryDir, "decisions");
+                let available = [];
+                if (fs.existsSync(decisionsDir)) {
+                    available = fs
+                        .readdirSync(decisionsDir)
+                        .filter((f) => f.endsWith(".md"))
+                        .slice(0, 10);
+                }
+                const msg = `Memory document not found: '${requested}'.\n` +
+                    (available.length > 0
+                        ? `Available decisions:\n${available.map((f) => ` - decisions/${f}`).join("\n")}`
+                        : "No decisions found in .memory/decisions.");
+                await (0, logger_1.recordMcpEvent)(cwd, "tool_call", toolName, `Not found: ${requested}`, Date.now() - startTime, false);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `${fallbackUsed ? `[Warning: Used fallback project root at ${cwd}]\n\n` : ""}${msg}`,
+                        },
+                    ],
+                };
+            }
+            const fileContent = fs.readFileSync(foundPath, "utf8");
+            const relativeDisplay = path.relative(cwd, foundPath);
+            await (0, logger_1.recordMcpEvent)(cwd, "tool_call", toolName, relativeDisplay, Date.now() - startTime, true);
             return {
                 content: [
                     {
                         type: "text",
-                        text: (fallbackUsed
-                            ? `[Warning: Used fallback project root at ${cwd}]\n\n`
-                            : "") + (textResults || "No results found."),
+                        text: `${fallbackUsed ? `[Warning: Used fallback project root at ${cwd}]\n\n` : ""}### Document: ${relativeDisplay}\n\n${fileContent}`,
                     },
                 ],
             };
         }
-        finally {
-            db.close();
+        catch (err) {
+            await (0, logger_1.recordMcpEvent)(cwd, "tool_call", toolName, `Error: ${err.message}`, Date.now() - startTime, false);
+            throw err;
         }
-    });
-    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"),
+    };
+    mcp.tool("get_memory_document", getDocumentDescription, getDocumentSchema, (args) => getDocumentHandler(args, "get_memory_document"));
+    mcp.tool("read_memory_document", getDocumentDescription, getDocumentSchema, (args) => getDocumentHandler(args, "read_memory_document"));
+    // Decision recording schema & handler supporting both log_decision and memory_record_decision
+    const recordDecisionDescription = "MANDATORY POST-TASK STEP: You MUST call this tool immediately AFTER implementing a feature, fixing a bug, refactoring, or establishing a new pattern. " +
+        "Persist technical decisions, root causes of bugs, and important context so future sessions maintain continuity.";
+    const recordDecisionSchema = {
+        title: zod_1.z
+            .string()
+            .describe("Short, descriptive title of the decision, fix, or component"),
+        status: zod_1.z
+            .string()
+            .optional()
+            .describe("Status (e.g. Accepted, Rejected, Superseded - defaults to Accepted)"),
+        context: zod_1.z.string().optional().describe("Context of the problem"),
+        decision: zod_1.z.string().optional().describe("The decision taken"),
+        consequences: zod_1.z
+            .string()
+            .optional()
+            .describe("Consequences of the decision"),
         alternatives_considered: zod_1.z
             .string()
             .optional()
-            .describe("Alternativas consideradas"),
+            .describe("Alternatives considered"),
+        content: zod_1.z
+            .string()
+            .optional()
+            .describe("Detailed markdown explanation of WHAT changed, WHY it was done, and any constraints discovered."),
+        tags: zod_1.z
+            .array(zod_1.z.string())
+            .optional()
+            .describe("Categorization tags (e.g. ['architecture', 'bugfix', 'auth', 'database'])"),
+        projectPath: zod_1.z
+            .string()
+            .optional()
+            .describe("Absolute path to the root directory of the current workspace/project."),
         projectRoot: zod_1.z
             .string()
             .optional()
-            .describe("Ruta absoluta del proyecto (usar si MCP es global)"),
-    }, async (args) => {
-        // Create slug
+            .describe("Alternative alias for projectPath."),
+    };
+    const recordDecisionHandler = async (args, toolName) => {
+        const startTime = Date.now();
         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);
-        (0, logger_1.logUsage)(cwd, "TOOL_CALL: log_decision", {
+        const projectArg = args.projectPath || args.projectRoot;
+        const { cwd, fallbackUsed } = await (0, utils_1.resolveCwd)(projectArg, server);
+        const status = args.status || "Accepted";
+        (0, logger_1.logUsage)(cwd, `TOOL_CALL: ${toolName}`, {
             title: args.title,
-            status: args.status,
+            status,
         });
-        const memoryDir = path.join(cwd, ".memory");
-        const decisionsDir = path.join(memoryDir, "decisions");
-        if (!fs.existsSync(decisionsDir)) {
-            fs.mkdirSync(decisionsDir, { recursive: true });
+        try {
+            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 frontmatter = `---\ntitle: ${args.title}\nstatus: ${status}\ndate: ${date}\n`;
+            if (args.tags && Array.isArray(args.tags) && args.tags.length > 0) {
+                frontmatter += `tags: [${args.tags.map((t) => JSON.stringify(t)).join(", ")}]\n`;
+            }
+            frontmatter += `---\n\n# ${args.title}\n\n`;
+            let body = "";
+            if (args.content) {
+                body = args.content;
+            }
+            else {
+                body = `## Context\n${args.context || "N/A"}\n\n## Decision\n${args.decision || "N/A"}\n\n## Consequences\n${args.consequences || "N/A"}\n`;
+                if (args.alternatives_considered) {
+                    body += `\n## Alternatives Considered\n${args.alternatives_considered}\n`;
+                }
+            }
+            fs.writeFileSync(filePath, `${frontmatter}${body}`);
+            // Sincronizar después de escribir
+            await (0, middleware_1.syncMiddleware)(cwd);
+            await (0, logger_1.recordMcpEvent)(cwd, "tool_call", toolName, args.title, Date.now() - startTime, true);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `${fallbackUsed ? `[Warning: Used fallback project root at ${cwd}]\n\n` : ""}Decision logged successfully at ${path.join(".memory", "decisions", filename)}`,
+                    },
+                ],
+            };
         }
-        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`;
+        catch (err) {
+            await (0, logger_1.recordMcpEvent)(cwd, "tool_call", toolName, `Error: ${err.message}`, Date.now() - startTime, false);
+            throw err;
         }
-        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).", {
+    };
+    // Register log_decision and its alias memory_record_decision
+    mcp.tool("log_decision", recordDecisionDescription, recordDecisionSchema, (args) => recordDecisionHandler(args, "log_decision"));
+    mcp.tool("memory_record_decision", recordDecisionDescription, recordDecisionSchema, (args) => recordDecisionHandler(args, "memory_record_decision"));
+    // update_core_rules
+    mcp.tool("update_core_rules", "CRITICAL STEP: Appends permanent project conventions, constraints, or architectural guidelines to core.md. Call whenever a core rule must be permanently established or revised.", {
         changes_to_append: zod_1.z
             .string()
             .describe("Contenido a añadir al final del archivo core.md"),
+        projectPath: zod_1.z
+            .string()
+            .optional()
+            .describe("Absolute path to the root directory of the current project"),
         projectRoot: zod_1.z
             .string()
             .optional()
-            .describe("Ruta absoluta del proyecto (usar si MCP es global)"),
+            .describe("Alternative alias for projectPath"),
     }, async (args) => {
-        const { cwd, fallbackUsed } = await (0, utils_1.resolveCwd)(args.projectRoot, server);
+        const startTime = Date.now();
+        const projectArg = args.projectPath || args.projectRoot;
+        const { cwd, fallbackUsed } = await (0, utils_1.resolveCwd)(projectArg, server);
         (0, logger_1.logUsage)(cwd, "TOOL_CALL: update_core_rules", {
             charsAdded: args.changes_to_append.length,
         });
-        const memoryDir = path.join(cwd, ".memory");
-        const corePath = path.join(memoryDir, "core.md");
-        if (!fs.existsSync(memoryDir)) {
-            fs.mkdirSync(memoryDir, { recursive: true });
+        try {
+            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);
+            await (0, logger_1.recordMcpEvent)(cwd, "tool_call", "update_core_rules", `Appended ${args.changes_to_append.length} chars`, Date.now() - startTime, true);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `${fallbackUsed ? `[Warning: Used fallback project root at ${cwd}]\n\n` : ""}Core rules updated successfully.`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            await (0, logger_1.recordMcpEvent)(cwd, "tool_call", "update_core_rules", `Error: ${err.message}`, Date.now() - startTime, false);
+            throw err;
         }
-        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.", {
+    // end_session
+    mcp.tool("end_session", "MANDATORY SESSION CLOSING STEP: Call this before concluding a task or session. Synthesizes what was modified, root cause of issues solved, and agreements taken, recording it into the memory ledger.", {
         summary: zod_1.z
             .string()
             .describe("Resumen de lo que se modificó y qué acuerdos se tomaron en la sesión"),
+        projectPath: zod_1.z
+            .string()
+            .optional()
+            .describe("Absolute path to the root directory of the current project"),
         projectRoot: zod_1.z
             .string()
             .optional()
-            .describe("Ruta absoluta del proyecto (usar si MCP es global)"),
+            .describe("Alternative alias for projectPath"),
     }, async (args) => {
-        const { cwd, fallbackUsed } = await (0, utils_1.resolveCwd)(args.projectRoot, server);
+        const startTime = Date.now();
+        const projectArg = args.projectPath || args.projectRoot;
+        const { cwd, fallbackUsed } = await (0, utils_1.resolveCwd)(projectArg, server);
         (0, logger_1.logUsage)(cwd, "TOOL_CALL: end_session", {
             summaryLength: args.summary.length,
         });
-        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 });
+        try {
+            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);
+            await (0, logger_1.recordMcpEvent)(cwd, "tool_call", "end_session", args.summary.slice(0, 80), Date.now() - startTime, true);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `${fallbackUsed ? `[Warning: Used fallback project root at ${cwd}]\n\n` : ""}Session summary flushed successfully to .memory/ledger/${filename}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            await (0, logger_1.recordMcpEvent)(cwd, "tool_call", "end_session", `Error: ${err.message}`, Date.now() - startTime, false);
+            throw err;
         }
-        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-agent-memory",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,7 +15,7 @@
   },
   "scripts": {
     "test": "jest --coverage",
-    "build": "node --max-old-space-size=4096 ./node_modules/typescript/bin/tsc",
+    "build": "tsc",
     "lint": "biome check src tests",
     "format": "biome format --write src tests"
   },