@mrxkun/mcfast-mcp 4.0.14 → 4.1.0

package/src/tools/memory_get.js

@@ -1,32 +1,37 @@
 /**
- * memory_get Tool v2.0
- * Read content from memory storage using MemoryEngine
- * Version: 2.0.0
+ * memory_get Tool v3.0
+ * Read content from memory storage using MemoryEngine v4.1.0
+ * Supports: Two-tier memory (daily logs + curated), AGENTS.md
  */
 
 import fs from 'fs/promises';
 import path from 'path';
-import os from 'os';
 import { MemoryEngine } from '../memory/index.js';
 
 // Memory engine instance (initialized lazily)
 let memoryEngine = null;
+let enginePromise = null;
 
 async function getMemoryEngine() {
-    if (!memoryEngine) {
+    if (memoryEngine) return memoryEngine;
+    if (enginePromise) return enginePromise;
+    
+    enginePromise = (async () => {
         memoryEngine = new MemoryEngine({
             apiKey: process.env.MCFAST_TOKEN,
             enableSync: true
         });
         await memoryEngine.initialize(process.cwd());
-    }
-    return memoryEngine;
+        return memoryEngine;
+    })();
+    
+    return enginePromise;
 }
 
 /**
  * Execute memory get
  * @param {Object} args - Tool arguments
- * @param {string} args.path - Path to memory file (relative to ~/.mcfast/memory/)
+ * @param {string} args.path - Path to memory file
  * @param {number} [args.from=1] - Start line
  * @param {number} [args.lines=50] - Number of lines to read
  * @returns {Promise<Object>} File content
@@ -50,43 +55,48 @@ export async function execute(args) {
 
     try {
         // Special paths
-        if (relativePath === 'logs' || relativePath === 'memory/logs') {
-            return await getMemoryLogs(from, lines);
-        }
-
-        if (relativePath === 'stats' || relativePath === 'memory/stats') {
-            return await getMemoryStats();
+        if (relativePath === 'agents' || relativePath === 'AGENTS.md') {
+            return await getAgentsMd();
         }
 
         if (relativePath === 'today' || relativePath === 'memory/today') {
             return await getTodayLog();
         }
 
-        if (relativePath === 'curated' || relativePath === 'memory/curated') {
-            return await getCuratedMemories();
+        if (relativePath === 'yesterday' || relativePath === 'memory/yesterday') {
+            return await getYesterdayLog();
         }
 
-        // Security: Only allow reading from memory directory
-        if (!relativePath.startsWith('memory/') && !relativePath.startsWith('/')) {
-            return {
-                content: [{
-                    type: "text",
-                    text: "❌ Error: Invalid path. Must be in memory/ directory"
-                }],
-                isError: true
-            };
+        if (relativePath === 'curated' || relativePath === 'MEMORY.md') {
+            return await getCuratedMemory();
+        }
+
+        if (relativePath === 'stats' || relativePath === 'memory/stats') {
+            return await getMemoryStats();
         }
 
+        // Regular file path - resolve relative to project
+        const projectPath = process.cwd();
+        const mcfastPath = path.join(projectPath, '.mcfast');
+        
         // Construct full path
-        const memoryDir = path.join(os.homedir(), '.mcfast', 'memory');
-        const fullPath = path.join(memoryDir, relativePath.replace(/^\//, ''));
+        let fullPath;
+        if (relativePath.startsWith('/')) {
+            fullPath = relativePath;
+        } else if (relativePath.startsWith('memory/')) {
+            fullPath = path.join(mcfastPath, relativePath);
+        } else if (relativePath.startsWith('.mcfast/')) {
+            fullPath = path.join(projectPath, relativePath);
+        } else {
+            fullPath = path.join(mcfastPath, relativePath);
+        }
 
-        // Security: Ensure path is within memory directory
-        if (!fullPath.startsWith(memoryDir)) {
+        // Security: Ensure path is within .mcfast directory
+        if (!fullPath.startsWith(mcfastPath)) {
             return {
                 content: [{
                     type: "text",
-                    text: "❌ Error: Path traversal not allowed"
+                    text: "❌ Error: Path must be within .mcfast directory"
                 }],
                 isError: true
             };
@@ -108,7 +118,7 @@ export async function execute(args) {
             return {
                 content: [{
                     type: "text",
-                    text: `❌ File not found: ${relativePath}`
+                    text: `❌ File not found: ${relativePath}\n\nTip: Use 'memory_search' to find available files.`
                 }],
                 isError: true
             };
@@ -125,11 +135,16 @@ export async function execute(args) {
         const extractedContent = extractedLines.join('\n');
 
         // Format output
-        let output = `📄 Memory: ${relativePath}\n`;
+        let output = `📄 ${path.basename(fullPath)}\n`;
+        output += `Path: ${relativePath}\n`;
         output += `Lines: ${startLine}-${endLine} of ${allLines.length}\n`;
-        output += '─'.repeat(40) + '\n';
+        output += '─'.repeat(40) + '\n\n';
         output += extractedContent;
 
+        if (endLine < allLines.length) {
+            output += `\n\n... (${allLines.length - endLine} more lines)`;
+        }
+
         return {
             content: [{
                 type: "text",
@@ -138,7 +153,9 @@ export async function execute(args) {
             metadata: {
                 path: relativePath,
                 lines: extractedLines.length,
-                totalLines: allLines.length
+                totalLines: allLines.length,
+                from: startLine,
+                to: endLine
             }
         };
     } catch (error) {
@@ -153,19 +170,47 @@ export async function execute(args) {
     }
 }
 
+/**
+ * Get AGENTS.md content
+ */
+async function getAgentsMd() {
+    try {
+        const projectPath = process.cwd();
+        const agentsPath = path.join(projectPath, '.mcfast', 'AGENTS.md');
+        
+        const content = await fs.readFile(agentsPath, 'utf8');
+        
+        return {
+            content: [{
+                type: "text",
+                text: `📋 Agent Instructions (AGENTS.md)\n\n${content}`
+            }],
+            metadata: { path: 'AGENTS.md' }
+        };
+    } catch (error) {
+        return {
+            content: [{
+                type: "text",
+                text: "❌ AGENTS.md not found. Run initialization first."
+            }],
+            isError: true
+        };
+    }
+}
+
 /**
  * Get today's daily log
  */
 async function getTodayLog() {
     try {
         const engine = await getMemoryEngine();
-        const todayLog = engine.getTodayLog();
+        const todayLog = await engine.getTodayLog();
         
-        if (!todayLog || todayLog.length === 0) {
+        if (!todayLog) {
             return {
                 content: [{
                     type: "text",
-                    text: "📝 No activity logged today"
+                    text: "📝 No activity logged today\n\nToday's log will be created when events are recorded."
                 }],
                 metadata: { empty: true }
             };
@@ -179,7 +224,8 @@ async function getTodayLog() {
             content: [{
                 type: "text",
                 text: output
-            }]
+            }],
+            metadata: { path: 'memory/YYYY-MM-DD.md' }
         };
     } catch (error) {
         return {
@@ -193,44 +239,39 @@ async function getTodayLog() {
 }
 
 /**
- * Get curated memories
+ * Get yesterday's daily log
  */
-async function getCuratedMemories() {
+async function getYesterdayLog() {
     try {
         const engine = await getMemoryEngine();
-        const memories = engine.getCuratedMemories();
+        const yesterdayLog = await engine.getYesterdayLog();
         
-        if (!memories || memories.length === 0) {
+        if (!yesterdayLog) {
             return {
                 content: [{
                     type: "text",
-                    text: "📝 No curated memories found"
+                    text: "📝 No activity logged yesterday"
                 }],
                 metadata: { empty: true }
             };
         }
 
-        let output = `📚 Curated Memories\n`;
-        output += `Found: ${memories.length} memory(s)\n`;
+        let output = `📅 Yesterday's Activity Log\n`;
         output += '─'.repeat(40) + '\n\n';
-
-        memories.forEach((memory, idx) => {
-            output += `[${idx + 1}] ${memory.title}\n`;
-            output += `Tags: ${memory.tags?.join(', ') || 'none'}\n`;
-            output += `${memory.content?.substring(0, 200) || ''}...\n\n`;
-        });
+        output += yesterdayLog;
 
         return {
             content: [{
                 type: "text",
                 text: output
-            }]
+            }],
+            metadata: { path: 'memory/YYYY-MM-DD.md' }
         };
     } catch (error) {
         return {
             content: [{
                 type: "text",
-                text: `❌ Error getting curated memories: ${error.message}`
+                text: `❌ Error getting yesterday's log: ${error.message}`
             }],
             isError: true
         };
@@ -238,58 +279,41 @@ async function getCuratedMemories() {
 }
 
 /**
- * Get memory logs (daily logs)
+ * Get curated memory (MEMORY.md)
  */
-async function getMemoryLogs(from, lines) {
-    const memoryDir = path.join(os.homedir(), '.mcfast', 'memory');
-    const logsDir = path.join(memoryDir, 'logs');
-
+async function getCuratedMemory() {
     try {
-        const entries = await fs.readdir(logsDir);
-        const logFiles = entries
-            .filter(f => f.endsWith('.md'))
-            .sort()
-            .reverse();
-
-        if (logFiles.length === 0) {
+        const engine = await getMemoryEngine();
+        const content = await engine.getCuratedMemory();
+        
+        if (!content) {
             return {
                 content: [{
                     type: "text",
-                    text: "📝 No memory logs found"
+                    text: "📚 MEMORY.md\n\nNo curated memory found. This file stores long-term knowledge."
                 }],
                 metadata: { empty: true }
             };
         }
 
-        // Read latest logs
-        let output = `📝 Memory Logs\n`;
-        output += `Found: ${logFiles.length} log file(s)\n`;
+        let output = `📚 Curated Memory (MEMORY.md)\n`;
         output += '─'.repeat(40) + '\n\n';
-
-        const filesToRead = logFiles.slice(0, 5);
-        for (const file of filesToRead) {
-            const filePath = path.join(logsDir, file);
-            const content = await fs.readFile(filePath, 'utf8');
-            const fileLines = content.split('\n').slice(0, 20);
-
-            output += `📅 ${file.replace('.md', '')}\n`;
-            output += fileLines.join('\n');
-            output += '\n\n---\n\n';
-        }
+        output += content;
 
         return {
             content: [{
                 type: "text",
                 text: output
-            }]
+            }],
+            metadata: { path: 'MEMORY.md' }
         };
-    } catch (e) {
+    } catch (error) {
         return {
             content: [{
                 type: "text",
-                text: "📝 No memory logs found"
+                text: `❌ Error getting curated memory: ${error.message}`
             }],
-            metadata: { empty: true }
+            isError: true
         };
     }
 }
@@ -301,25 +325,40 @@ async function getMemoryStats() {
     try {
         const engine = await getMemoryEngine();
         const stats = engine.getStats();
-        const syncStatus = engine.getSyncStatus();
-
-        let output = `📊 Memory Statistics\n`;
-        output += '─'.repeat(40) + '\n';
-        output += `Indexed Files: ${stats.files || 0}\n`;
-        output += `Facts Stored: ${stats.facts || 0}\n`;
-        output += `Code Chunks: ${stats.chunks || 0}\n`;
-        output += `Embeddings: ${stats.embeddings || 0}\n`;
-        output += `Edit History: ${stats.edits || 0}\n\n`;
         
-        output += `Sync Engine: ${syncStatus.enabled ? '✅ Enabled' : '❌ Disabled'}\n`;
-        if (syncStatus.enabled) {
-            output += `Sync Status: ${syncStatus.status || 'unknown'}\n`;
-            output += `Last Sync: ${syncStatus.lastSync ? new Date(syncStatus.lastSync).toISOString() : 'Never'}\n`;
-            output += `Pending Changes: ${syncStatus.pendingChanges || 0}\n`;
+        let output = `📊 Memory System Statistics\n`;
+        output += '─'.repeat(40) + '\n\n';
+        
+        // Memory stats
+        output += `📝 Memory Index\n`;
+        output += `  Files: ${stats.memory?.files || 0}\n`;
+        output += `  Chunks: ${stats.memory?.chunks || 0}\n`;
+        output += `  Embeddings: ${stats.memory?.embeddings || 0}\n\n`;
+        
+        // Codebase stats
+        output += `💻 Codebase Index\n`;
+        output += `  Files: ${stats.codebase?.files || 0}\n`;
+        output += `  Facts: ${stats.codebase?.facts || 0}\n`;
+        output += `  Chunks: ${stats.codebase?.chunks || 0}\n`;
+        output += `  Embeddings: ${stats.codebase?.embeddings || 0}\n`;
+        output += `  Edits: ${stats.codebase?.edits || 0}\n\n`;
+        
+        // Indexing status
+        if (stats.indexing?.is_complete !== undefined) {
+            output += `🔄 Indexing\n`;
+            output += `  Complete: ${stats.indexing.is_complete ? '✅' : '⏳'}\n`;
+            output += `  Indexed: ${stats.indexing.indexed_files || 0}/${stats.indexing.total_files || 0}\n`;
+            output += `  Failed: ${stats.indexing.failed_files || 0}\n\n`;
         }
         
-        output += `\nProject: ${stats.projectPath || 'N/A'}\n`;
-        output += `Smart Routing: ${engine.smartRoutingEnabled ? '✅ Enabled' : '❌ Disabled'}\n`;
+        // Sync status
+        const syncStatus = engine.getSyncStatus();
+        output += `☁️ Sync\n`;
+        output += `  Enabled: ${syncStatus.enabled ? '✅' : '❌'}\n`;
+        if (syncStatus.enabled) {
+            output += `  Status: ${syncStatus.status || 'unknown'}\n`;
+            output += `  Pending: ${syncStatus.pendingChanges || 0}\n`;
+        }
 
         return {
             content: [{