@mrxkun/mcfast-mcp 4.0.1 → 4.0.3

package/src/memory/utils/sync-engine.js

@@ -1,6 +1,7 @@
 /**
  * Sync Engine
  * Local ↔ Cloud synchronization for memory
+ * Uses MCFAST_TOKEN for authentication (same as Dashboard)
  */
 
 import fs from 'fs';
@@ -11,8 +12,11 @@ import crypto from 'crypto';
 export class SyncEngine {
   constructor(options = {}) {
     this.memoryPath = options.memoryPath || path.join(os.homedir(), '.mcfast', 'memory');
-    this.cloudEndpoint = options.cloudEndpoint || null;
-    this.apiKey = options.apiKey || null;
+    
+    // Use Dashboard URL for sync (same as DashboardClient)
+    this.baseUrl = options.baseUrl || process.env.MCFAST_DASHBOARD_URL || 'https://mcfast.vercel.app';
+    this.apiKey = options.apiKey || process.env.MCFAST_TOKEN;
+    
     this.syncInterval = options.syncInterval || 5 * 60 * 1000; // 5 minutes
     this.lastSyncTime = null;
     this.syncQueue = [];
@@ -28,6 +32,17 @@ export class SyncEngine {
     }
   }
 
+  /**
+   * Get headers for API calls
+   */
+  getHeaders() {
+    return {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${this.apiKey}`,
+      'X-MCP-Client': 'mcfast-mcp-v4'
+    };
+  }
+
   /**
    * Initialize sync engine
    */
@@ -144,8 +159,8 @@ export class SyncEngine {
    * Perform sync
    */
   async sync() {
-    if (!this.isOnline || this.isSyncing || !this.cloudEndpoint) {
-      return { status: this.isOnline ? 'idle' : 'offline', queued: this.syncQueue.length };
+    if (!this.isOnline || this.isSyncing || !this.apiKey) {
+      return { status: !this.apiKey ? 'no_token' : this.isOnline ? 'idle' : 'offline', queued: this.syncQueue.length };
     }
 
     this.isSyncing = true;
@@ -155,7 +170,7 @@ export class SyncEngine {
       // 1. Get local changes since last sync
       const localChanges = await this.getLocalChanges();
       
-      // 2. Push local changes to cloud
+      // 2. Push local changes to cloud (via Dashboard API)
       if (localChanges.length > 0) {
         await this.pushToCloud(localChanges);
       }
@@ -233,15 +248,14 @@ export class SyncEngine {
   }
 
   /**
-   * Push changes to cloud
+   * Push changes to cloud via Dashboard API
    */
   async pushToCloud(changes) {
-    const response = await fetch(`${this.cloudEndpoint}/sync/push`, {
+    const url = `${this.baseUrl}/api/v1/memory/sync/push`;
+    
+    const response = await fetch(url, {
       method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${this.apiKey}`
-      },
+      headers: this.getHeaders(),
       body: JSON.stringify({
         changes,
         lastSyncTime: this.lastSyncTime
@@ -256,14 +270,14 @@ export class SyncEngine {
   }
 
   /**
-   * Pull changes from cloud
+   * Pull changes from cloud via Dashboard API
    */
   async pullFromCloud() {
-    const response = await fetch(`${this.cloudEndpoint}/sync/pull?since=${this.lastSyncTime || 0}`, {
+    const url = `${this.baseUrl}/api/v1/memory/sync/pull?since=${this.lastSyncTime || 0}`;
+    
+    const response = await fetch(url, {
       method: 'GET',
-      headers: {
-        'Authorization': `Bearer ${this.apiKey}`
-      }
+      headers: this.getHeaders()
     });
 
     if (!response.ok) {
@@ -327,7 +341,8 @@ export class SyncEngine {
       isSyncing: this.isSyncing,
       lastSyncTime: this.lastSyncTime,
       queueLength: this.syncQueue.length,
-      syncInterval: this.syncInterval
+      syncInterval: this.syncInterval,
+      hasToken: !!this.apiKey
     };
   }
 

package/src/tools/memory_get.js

@@ -1,12 +1,27 @@
 /**
- * memory_get Tool
- * Read content from memory storage
- * Version: 1.0.0
+ * memory_get Tool v2.0
+ * Read content from memory storage using MemoryEngine
+ * Version: 2.0.0
  */
 
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
+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;
+
+async function getMemoryEngine() {
+    if (!memoryEngine) {
+        memoryEngine = new MemoryEngine({
+            apiKey: process.env.MCFAST_TOKEN,
+            enableSync: true
+        });
+        await memoryEngine.initialize(process.cwd());
+    }
+    return memoryEngine;
+}
 
 /**
  * Execute memory get
@@ -14,222 +29,314 @@ const os = require('os');
  * @param {string} args.path - Path to memory file (relative to ~/.mcfast/memory/)
  * @param {number} [args.from=1] - Start line
  * @param {number} [args.lines=50] - Number of lines to read
- * @param {Object} context - Runtime context
  * @returns {Promise<Object>} File content
  */
-async function execute(args, context = {}) {
-  const {
-    path: relativePath,
-    from = 1,
-    lines = 50
-  } = args;
-
-  if (!relativePath) {
-    return {
-      content: [{
-        type: "text",
-        text: "❌ Error: 'path' parameter is required"
-      }],
-      isError: true
-    };
-  }
-
-  try {
-    // 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
-      };
-    }
+export async function execute(args) {
+    const {
+        path: relativePath,
+        from = 1,
+        lines = 50
+    } = args;
 
-    // Construct full path
-    const memoryDir = path.join(os.homedir(), '.mcfast', 'memory');
-    const fullPath = path.join(memoryDir, relativePath.replace(/^\//, ''));
-
-    // Security: Ensure path is within memory directory
-    if (!fullPath.startsWith(memoryDir)) {
-      return {
-        content: [{
-          type: "text",
-          text: "❌ Error: Path traversal not allowed"
-        }],
-        isError: true
-      };
+    if (!relativePath) {
+        return {
+            content: [{
+                type: "text",
+                text: "❌ Error: 'path' parameter is required"
+            }],
+            isError: true
+        };
     }
 
-    // Check if file exists
-    if (!fs.existsSync(fullPath)) {
-      // Check if it's a special memory path
-      if (relativePath === 'memory/logs' || relativePath === 'logs') {
-        return await getMemoryLogs(memoryDir, from, lines);
-      }
-
-      if (relativePath === 'memory/stats' || relativePath === 'stats') {
-        return await getMemoryStats(context.store);
-      }
-
-      return {
-        content: [{
-          type: "text",
-          text: `❌ File not found: ${relativePath}`
-        }],
-        isError: true
-      };
+    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 === 'today' || relativePath === 'memory/today') {
+            return await getTodayLog();
+        }
+
+        if (relativePath === 'curated' || relativePath === 'memory/curated') {
+            return await getCuratedMemories();
+        }
+
+        // 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
+            };
+        }
+
+        // Construct full path
+        const memoryDir = path.join(os.homedir(), '.mcfast', 'memory');
+        const fullPath = path.join(memoryDir, relativePath.replace(/^\//, ''));
+
+        // Security: Ensure path is within memory directory
+        if (!fullPath.startsWith(memoryDir)) {
+            return {
+                content: [{
+                    type: "text",
+                    text: "❌ Error: Path traversal not allowed"
+                }],
+                isError: true
+            };
+        }
+
+        // Check if file exists
+        try {
+            const stats = await fs.stat(fullPath);
+            if (!stats.isFile()) {
+                return {
+                    content: [{
+                        type: "text",
+                        text: "❌ Path is not a file"
+                    }],
+                    isError: true
+                };
+            }
+        } catch (e) {
+            return {
+                content: [{
+                    type: "text",
+                    text: `❌ File not found: ${relativePath}`
+                }],
+                isError: true
+            };
+        }
+
+        // Read file content
+        const content = await fs.readFile(fullPath, 'utf8');
+        const allLines = content.split('\n');
+
+        // Extract specific lines
+        const startLine = Math.max(1, from);
+        const endLine = Math.min(allLines.length, from - 1 + lines);
+        const extractedLines = allLines.slice(startLine - 1, endLine);
+        const extractedContent = extractedLines.join('\n');
+
+        // Format output
+        let output = `📄 Memory: ${relativePath}\n`;
+        output += `Lines: ${startLine}-${endLine} of ${allLines.length}\n`;
+        output += '─'.repeat(40) + '\n';
+        output += extractedContent;
+
+        return {
+            content: [{
+                type: "text",
+                text: output
+            }],
+            metadata: {
+                path: relativePath,
+                lines: extractedLines.length,
+                totalLines: allLines.length
+            }
+        };
+    } catch (error) {
+        console.error('[memory_get] Error:', error);
+        return {
+            content: [{
+                type: "text",
+                text: `❌ Error reading memory: ${error.message}`
+            }],
+            isError: true
+        };
     }
+}
+
+/**
+ * Get today's daily log
+ */
+async function getTodayLog() {
+    try {
+        const engine = await getMemoryEngine();
+        const todayLog = engine.getTodayLog();
+        
+        if (!todayLog || todayLog.length === 0) {
+            return {
+                content: [{
+                    type: "text",
+                    text: "📝 No activity logged today"
+                }],
+                metadata: { empty: true }
+            };
+        }
+
+        let output = `📅 Today's Activity Log\n`;
+        output += '─'.repeat(40) + '\n\n';
+        output += todayLog;
 
-    const stats = fs.statSync(fullPath);
-    if (!stats.isFile()) {
-      return {
-        content: [{
-          type: "text",
-          text: "❌ Path is not a file"
-        }],
-        isError: true
-      };
+        return {
+            content: [{
+                type: "text",
+                text: output
+            }]
+        };
+    } catch (error) {
+        return {
+            content: [{
+                type: "text",
+                text: `❌ Error getting today's log: ${error.message}`
+            }],
+            isError: true
+        };
     }
+}
 
-    // Read file content
-    const content = fs.readFileSync(fullPath, 'utf8');
-    const allLines = content.split('\n');
-
-    // Extract specific lines
-    const startLine = Math.max(1, from);
-    const endLine = Math.min(allLines.length, from - 1 + lines);
-    const extractedLines = allLines.slice(startLine - 1, endLine);
-    const extractedContent = extractedLines.join('\n');
-
-    // Format output
-    const output = `📄 Memory: ${relativePath}\n`;
-    output += `Lines: ${startLine}-${endLine} of ${allLines.length}\n`;
-    output += '─'.repeat(40) + '\n';
-    output += extractedContent;
-
-    return {
-      content: [{
-        type: "text",
-        text: output
-      }],
-      metadata: {
-        path: relativePath,
-        lines: extractedLines.length,
-        totalLines: allLines.length
-      }
-    };
-  } catch (error) {
-    console.error('[memory_get] Error:', error);
-    return {
-      content: [{
-        type: "text",
-        text: `❌ Error reading memory: ${error.message}`
-      }],
-      isError: true
-    };
-  }
+/**
+ * Get curated memories
+ */
+async function getCuratedMemories() {
+    try {
+        const engine = await getMemoryEngine();
+        const memories = engine.getCuratedMemories();
+        
+        if (!memories || memories.length === 0) {
+            return {
+                content: [{
+                    type: "text",
+                    text: "📝 No curated memories found"
+                }],
+                metadata: { empty: true }
+            };
+        }
+
+        let output = `📚 Curated Memories\n`;
+        output += `Found: ${memories.length} memory(s)\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`;
+        });
+
+        return {
+            content: [{
+                type: "text",
+                text: output
+            }]
+        };
+    } catch (error) {
+        return {
+            content: [{
+                type: "text",
+                text: `❌ Error getting curated memories: ${error.message}`
+            }],
+            isError: true
+        };
+    }
 }
 
 /**
  * Get memory logs (daily logs)
  */
-async function getMemoryLogs(memoryDir, from, lines) {
-  const logsDir = path.join(memoryDir, 'logs');
-
-  if (!fs.existsSync(logsDir)) {
-    return {
-      content: [{
-        type: "text",
-        text: "📝 No memory logs found"
-      }],
-      metadata: { empty: true }
-    };
-  }
-
-  // Get all log files
-  const logFiles = fs.readdirSync(logsDir)
-    .filter(f => f.endsWith('.md'))
-    .sort()
-    .reverse();
-
-  if (logFiles.length === 0) {
-    return {
-      content: [{
-        type: "text",
-        text: "📝 No memory logs found"
-      }],
-      metadata: { empty: true }
-    };
-  }
-
-  // Read latest logs
-  let output = `📝 Memory Logs\n`;
-  output += `Found: ${logFiles.length} log file(s)\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 = fs.readFileSync(filePath, 'utf8');
-    const lines = content.split('\n').slice(0, 20);
-
-    output += `📅 ${file.replace('.md', '')}\n`;
-    output += lines.join('\n');
-    output += '\n\n---\n\n';
-  }
-
-  return {
-    content: [{
-      type: "text",
-      text: output
-    }]
-  };
+async function getMemoryLogs(from, lines) {
+    const memoryDir = path.join(os.homedir(), '.mcfast', 'memory');
+    const logsDir = path.join(memoryDir, 'logs');
+
+    try {
+        const entries = await fs.readdir(logsDir);
+        const logFiles = entries
+            .filter(f => f.endsWith('.md'))
+            .sort()
+            .reverse();
+
+        if (logFiles.length === 0) {
+            return {
+                content: [{
+                    type: "text",
+                    text: "📝 No memory logs found"
+                }],
+                metadata: { empty: true }
+            };
+        }
+
+        // Read latest logs
+        let output = `📝 Memory Logs\n`;
+        output += `Found: ${logFiles.length} log file(s)\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';
+        }
+
+        return {
+            content: [{
+                type: "text",
+                text: output
+            }]
+        };
+    } catch (e) {
+        return {
+            content: [{
+                type: "text",
+                text: "📝 No memory logs found"
+            }],
+            metadata: { empty: true }
+        };
+    }
 }
 
 /**
  * Get memory statistics
  */
-async function getMemoryStats(store) {
-  if (!store) {
-    return {
-      content: [{
-        type: "text",
-        text: "❌ Memory store not initialized"
-      }],
-      isError: true
-    };
-  }
-
-  try {
-    const stats = store.getStats();
-    const syncState = store.getSyncState();
-
-    let output = `📊 Memory Statistics\n`;
-    output += '─'.repeat(40) + '\n';
-    output += `Indexed Files: ${stats.fileCount}\n`;
-    output += `Facts Stored: ${stats.factCount}\n`;
-    output += `Code Chunks: ${stats.chunkCount}\n`;
-    output += `Edit History: ${stats.editCount}\n\n`;
-    output += `Last Sync: ${syncState?.last_sync_time ? new Date(syncState.last_sync_time).toISOString() : 'Never'}\n`;
-    output += `Sync Status: ${syncState?.last_sync_status || 'unknown'}\n`;
-
-    return {
-      content: [{
-        type: "text",
-        text: output
-      }],
-      metadata: stats
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: `❌ Error getting stats: ${error.message}`
-      }],
-      isError: true
-    };
-  }
+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`;
+        }
+        
+        output += `\nProject: ${stats.projectPath || 'N/A'}\n`;
+        output += `Smart Routing: ${engine.smartRoutingEnabled ? '✅ Enabled' : '❌ Disabled'}\n`;
+
+        return {
+            content: [{
+                type: "text",
+                text: output
+            }],
+            metadata: stats
+        };
+    } catch (error) {
+        return {
+            content: [{
+                type: "text",
+                text: `❌ Error getting stats: ${error.message}`
+            }],
+            isError: true
+        };
+    }
 }
 
-module.exports = { execute };
+export default { execute };