@mrxkun/mcfast-mcp 4.0.0 → 4.0.1

package/src/memory/watchers/file-watcher.js

@@ -0,0 +1,61 @@
+import chokidar from 'chokidar';
+
+// Simple debounce implementation to avoid lodash dependency
+function debounce(func, wait) {
+  let timeout;
+  return function executedFunction(...args) {
+    const later = () => {
+      clearTimeout(timeout);
+      func(...args);
+    };
+    clearTimeout(timeout);
+    timeout = setTimeout(later, wait);
+  };
+}
+
+export class FileWatcher {
+  constructor(projectPath, memoryEngine) {
+    this.projectPath = projectPath;
+    this.memory = memoryEngine;
+    this.watcher = null;
+    this.pendingUpdates = new Map();
+  }
+
+  async start() {
+    this.watcher = chokidar.watch(this.projectPath, {
+      ignored: ['**/node_modules/**', '**/.git/**', '**/dist/**'],
+      persistent: true
+    });
+
+    this.watcher.on('add', path => this.queueUpdate(path, 'add'));
+    this.watcher.on('change', path => this.queueUpdate(path, 'change'));
+    this.watcher.on('unlink', path => this.handleDelete(path));
+
+    this.processQueue = debounce(() => this.flushQueue(), 1500);
+  }
+
+  queueUpdate(filePath, type) {
+    this.pendingUpdates.set(filePath, { path: filePath, type, timestamp: Date.now() });
+    this.processQueue();
+  }
+
+  async flushQueue() {
+    const updates = Array.from(this.pendingUpdates.values());
+    this.pendingUpdates.clear();
+    await Promise.all(updates.map(u => this.processUpdate(u)));
+  }
+
+  async processUpdate(update) {
+    console.log(`[Watcher] ${update.type}: ${update.path}`);
+  }
+
+  async handleDelete(filePath) {
+    console.log(`[Watcher] Deleted: ${filePath}`);
+  }
+
+  async stop() {
+    if (this.watcher) await this.watcher.close();
+  }
+}
+
+export default FileWatcher;

package/src/tools/memory_get.js

@@ -0,0 +1,235 @@
+/**
+ * memory_get Tool
+ * Read content from memory storage
+ * Version: 1.0.0
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Execute memory get
+ * @param {Object} args - Tool arguments
+ * @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
+      };
+    }
+
+    // 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
+    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
+      };
+    }
+
+    const stats = fs.statSync(fullPath);
+    if (!stats.isFile()) {
+      return {
+        content: [{
+          type: "text",
+          text: "❌ Path is not a file"
+        }],
+        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 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
+    }]
+  };
+}
+
+/**
+ * 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
+    };
+  }
+}
+
+module.exports = { execute };

package/src/tools/memory_search.js

@@ -0,0 +1,296 @@
+/**
+ * memory_search Tool
+ * Hybrid search tool combining vector and keyword search
+ * Version: 1.0.0
+ */
+
+const { LocalMemoryStore } = require('./local-store');
+
+/**
+ * Execute memory search
+ * @param {Object} args - Tool arguments
+ * @param {string} args.query - Search query
+ * @param {string} [args.type='all'] - Filter by type: 'all', 'facts', 'history', 'code'
+ * @param {number} [args.maxResults=6] - Maximum results to return
+ * @param {number} [args.minScore=0.35] - Minimum score threshold
+ * @param {Object} [args.context] - Context information
+ * @param {string} [args.context.currentFile] - Current file being edited
+ * @param {number} [args.context.currentLine] - Current line number
+ * @param {Object} context - Runtime context
+ * @returns {Promise<Object>} Search results
+ */
+async function execute(args, context = {}) {
+  const {
+    query,
+    type = 'all',
+    maxResults = 6,
+    minScore = 0.35,
+    context: contextInfo = {}
+  } = args;
+
+  const startTime = Date.now();
+
+  try {
+    // Initialize store if not provided
+    let store = context.store;
+    if (!store) {
+      store = new LocalMemoryStore();
+      await store.initialize();
+    }
+
+    // Get embedding for query if possible
+    let embedding = null;
+    try {
+      embedding = await getEmbedding(query);
+    } catch (e) {
+      console.log('[memory_search] Embedding not available, using keyword search only');
+    }
+
+    // Perform hybrid search
+    let results;
+
+    if (type === 'facts') {
+      // Search facts table only
+      results = await searchFacts(store, query, { maxResults });
+    } else if (type === 'history') {
+      // Search edit history
+      results = await searchHistory(store, query, { maxResults });
+    } else if (type === 'code') {
+      // Search code chunks only
+      results = store.hybridSearch(query, embedding, {
+        vectorWeight: 0.7,
+        keywordWeight: 0.3,
+        maxResults,
+        minScore
+      });
+    } else {
+      // Search all (hybrid)
+      results = await searchAll(store, query, embedding, { maxResults, minScore });
+    }
+
+    // Format output
+    const formattedResults = formatResults(results, type);
+
+    const latency = Date.now() - startTime;
+
+    return {
+      content: [{
+        type: "text",
+        text: formattedResults
+      }],
+      metadata: {
+        query,
+        type,
+        resultCount: results.length,
+        latency,
+        sources: [...new Set(results.map(r => r.source || 'unknown'))]
+      }
+    };
+  } catch (error) {
+    console.error('[memory_search] Error:', error);
+    return {
+      content: [{
+        type: "text",
+        text: `❌ Memory search error: ${error.message}`
+      }],
+      isError: true
+    };
+  }
+}
+
+/**
+ * Search facts only
+ */
+async function searchFacts(store, query, options) {
+  const { maxResults = 10 } = options;
+
+  const facts = store.searchFacts(query, { maxResults });
+
+  return facts.map(fact => ({
+    type: 'fact',
+    content: `${fact.type}: ${fact.name}${fact.signature ? ` (${fact.signature})' : ''}`,
+    file: fact.file_path,
+    lines: [fact.line_start, fact.line_end],
+    score: fact.confidence || 0.8,
+    source: 'facts'
+  }));
+}
+
+/**
+ * Search edit history
+ */
+async function searchHistory(store, query, options) {
+  const { maxResults = 10 } = options;
+
+  const history = store.getEditHistory({ limit: maxResults * 2 });
+
+  // Filter by query relevance
+  const filtered = history.filter(edit =>
+    edit.instruction.toLowerCase().includes(query.toLowerCase()) ||
+    edit.files.some(f => f.toLowerCase().includes(query.toLowerCase()))
+  );
+
+  return filtered.slice(0, maxResults).map(edit => ({
+    type: 'history',
+    content: edit.instruction,
+    files: edit.files,
+    strategy: edit.strategy,
+    success: edit.success,
+    timestamp: edit.timestamp,
+    score: edit.success ? 0.8 : 0.5,
+    source: 'history'
+  }));
+}
+
+/**
+ * Search all sources (hybrid)
+ */
+async function searchAll(store, query, embedding, options) {
+  const { maxResults = 10, minScore = 0.35 } = options;
+
+  const results = [];
+
+  // Get facts
+  const facts = await searchFacts(store, query, { maxResults: maxResults * 2 });
+  results.push(...facts);
+
+  // Get code chunks via hybrid search
+  if (embedding) {
+    const chunks = store.hybridSearch(query, embedding, {
+      vectorWeight: 0.7,
+      keywordWeight: 0.3,
+      maxResults: maxResults * 2,
+      minScore: minScore * 0.5 // Lower threshold for chunks
+    });
+
+    results.push(...chunks.map(chunk => ({
+      type: 'chunk',
+      content: chunk.content,
+      file: chunk.filePath,
+      lines: [chunk.startLine, chunk.endLine],
+      score: chunk.weightedScore || chunk.score,
+      source: chunk.source
+    })));
+  } else {
+    // Fallback to keyword search only
+    const keywordResults = store.ftsSearch(query, { maxResults: maxResults * 2 });
+    results.push(...keywordResults.map(r => ({
+      type: 'chunk',
+      content: r.content,
+      file: r.file_path,
+      lines: [r.start_line, r.end_line],
+      score: 0.6,
+      source: 'keyword'
+    })));
+  }
+
+  // Get recent history
+  const history = await searchHistory(store, query, { maxResults: Math.floor(maxResults / 2) });
+  results.push(...history);
+
+  // Deduplicate and sort by score
+  const uniqueMap = new Map();
+  for (const result of results) {
+    const key = `${result.type}:${result.file || ''}:${result.content?.substring(0, 50)}`;
+    if (!uniqueMap.has(key) || uniqueMap.get(key).score < result.score) {
+      uniqueMap.set(key, result);
+    }
+  }
+
+  return Array.from(uniqueMap.values())
+    .filter(r => r.score >= minScore)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, maxResults);
+}
+
+/**
+ * Format results for display
+ */
+function formatResults(results, type) {
+  if (!results || results.length === 0) {
+    return `🔍 Memory Search: No results found`;
+  }
+
+  let output = `🔍 Memory Search Results\n`;
+  output += `Found: ${results.length} results\n\n`;
+
+  // Group by type
+  const byType = {};
+  for (const result of results) {
+    if (!byType[result.type]) byType[result.type] = [];
+    byType[result.type].push(result);
+  }
+
+  for (const [resultType, items] of Object.entries(byType)) {
+    output += `${getTypeIcon(resultType)} ${resultType.toUpperCase()} (${items.length})\n`;
+    output += '─'.repeat(40) + '\n';
+
+    for (const item of items.slice(0, 5)) {
+      output += `  ${formatItem(item)}\n\n`;
+    }
+  }
+
+  return output;
+}
+
+function getTypeIcon(type) {
+  const icons = {
+    fact: '📌',
+    chunk: '📝',
+    history: '📜'
+  };
+  return icons[type] || '•';
+}
+
+function formatItem(item) {
+  let text = '';
+
+  if (item.file) {
+    text += `${item.file}`;
+    if (item.lines && item.lines[0]) {
+      text += `:${item.lines[0]}`;
+      if (item.lines[1] && item.lines[1] !== item.lines[0]) {
+        text += `-${item.lines[1]}`;
+      }
+    }
+    text += '\n';
+  }
+
+  // Truncate content
+  const content = item.content?.substring(0, 150) || '';
+  text += `  ${content}${content.length >= 150 ? '...' : ''}`;
+
+  text += `\n  Score: ${(item.score * 100).toFixed(0)}%`;
+
+  if (item.source) {
+    text += ` • ${item.source}`;
+  }
+
+  return text;
+}
+
+/**
+ * Get embedding for query
+ * Placeholder - implement with actual embedding API
+ */
+async function getEmbedding(text) {
+  // Check if OpenAI is available
+  try {
+    const { OpenAI } = require('openai');
+    if (process.env.OPENAI_API_KEY) {
+      const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+      const response = await openai.embeddings.create({
+        model: 'text-embedding-3-small',
+        input: text
+      });
+      return new Float32Array(response.data[0].embedding);
+    }
+  } catch (e) {
+    // OpenAI not available
+  }
+
+  // Return null to fallback to keyword search
+  return null;
+}
+
+module.exports = { execute };