@mrxkun/mcfast-mcp 4.0.14 → 4.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "4.0.14",
-  "description": "Ultra-fast code editing with WASM acceleration, fuzzy patching, multi-layer caching, and 8 unified tools. Optimized for AI code assistants with 80-98% latency reduction. Phase 4: ML Intelligence Layer.",
+  "version": "4.1.0",
+  "description": "Ultra-fast code editing with WASM acceleration, fuzzy patching, multi-layer caching, and 8 unified tools. Optimized for AI code assistants with 80-98% latency reduction. Phase 5: Memory v4.1.0 - Markdown source, Hybrid Search, Two-tier memory.",
   "type": "module",
   "bin": {
     "mcfast-mcp": "src/index.js"

package/src/memory/bootstrap/agents-md.js

@@ -0,0 +1,173 @@
+/**
+ * AGENTS.md Bootstrap
+ * Tạo file AGENTS.md hướng dẫn agent cách sử dụng memory
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+
+export class AgentsMdBootstrap {
+  constructor(options = {}) {
+    this.projectPath = options.projectPath || process.cwd();
+    this.agentsFile = path.join(this.projectPath, '.mcfast', 'AGENTS.md');
+  }
+
+  /**
+   * Check if AGENTS.md exists
+   */
+  async exists() {
+    try {
+      await fs.access(this.agentsFile);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Create AGENTS.md if it doesn't exist
+   */
+  async bootstrap() {
+    if (await this.exists()) {
+      console.log(`[AgentsMdBootstrap] AGENTS.md already exists`);
+      return false;
+    }
+
+    await fs.mkdir(path.dirname(this.agentsFile), { recursive: true });
+    await fs.writeFile(this.agentsFile, this.getContent());
+    
+    console.log(`[AgentsMdBootstrap] Created ${this.agentsFile}`);
+    return true;
+  }
+
+  /**
+   * Force regenerate AGENTS.md
+   */
+  async regenerate() {
+    await fs.mkdir(path.dirname(this.agentsFile), { recursive: true });
+    await fs.writeFile(this.agentsFile, this.getContent());
+    
+    console.log(`[AgentsMdBootstrap] Regenerated ${this.agentsFile}`);
+    return true;
+  }
+
+  /**
+   * Get AGENTS.md content
+   */
+  getContent() {
+    return `# Agent Instructions
+
+## 🎯 Every Session - MANDATORY
+
+Before doing anything else, you MUST:
+
+1. **Read Recent Context** (ALWAYS)
+   - Read memory/YYYY-MM-DD.md for TODAY
+   - Read memory/YYYY-MM-DD.md for YESTERDAY
+   - This gives you recent context and running notes
+
+2. **Read Long-term Memory** (If in main session)
+   - Read MEMORY.md for curated knowledge
+   - This contains decisions, preferences, contacts
+
+3. **Search Memory** (When relevant)
+   - Use memory_search tool when user asks about:
+     - Previous work or decisions
+     - Dates, people, preferences
+     - Todos or plans
+     - Any prior context
+
+## 📝 Writing to Memory
+
+### Daily Logs (memory/YYYY-MM-DD.md)
+Write here for:
+- Day-to-day activities
+- Temporary notes
+- Running context
+- Session summaries
+
+Example:
+\`\`\`markdown
+## 2:30 PM - API Discussion
+Discussed REST vs GraphQL with user.
+Decision: Use REST for simplicity.
+\`\`\`
+
+### Curated Memory (MEMORY.md)
+Write here for:
+- Important decisions
+- User preferences
+- Key contacts
+- Project context
+- Lessons learned
+
+Example:
+\`\`\`markdown
+## Important Decisions
+- **2026-01-20:** Chose PostgreSQL for database (scales better)
+
+## User Preferences
+- Prefers TypeScript over JavaScript
+- Likes concise explanations
+\`\`\`
+
+## 🧠 Memory Search Strategy
+
+When user asks about past context:
+
+1. **ALWAYS search first**: Use memory_search tool
+2. **Read relevant files**: Use memory_get to read full content
+3. **Reference in response**: Cite the source file
+
+Example workflow:
+\`\`\`
+User: "What did we decide about the API?"
+
+Agent:
+1. memory_search({ query: "API decision REST GraphQL" })
+2. memory_get({ path: "MEMORY.md", from: 1, lines: 50 })
+3. Answer with citation: "According to MEMORY.md (line 15), we decided..."
+\`\`\`
+
+## ⚠️ Important Rules
+
+1. **Don't ask permission** - Just read memory files automatically
+2. **Don't keep it in RAM** - Write important info to disk
+3. **Search before answering** - About past work, always search first
+4. **Cite your sources** - Tell user which memory file you referenced
+5. **Write proactively** - When you learn something important, write it down
+
+## 🔄 Memory Maintenance
+
+- Daily logs are append-only
+- Curated memory is for long-term storage
+- Promote important items from daily logs to MEMORY.md
+- Memory is searchable - trust the search system
+
+---
+
+*This file guides the agent on how to use the memory system effectively.*
+*Generated by mcfast v4.1.0*
+`;
+  }
+
+  /**
+   * Read AGENTS.md content
+   */
+  async read() {
+    try {
+      return await fs.readFile(this.agentsFile, 'utf-8');
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Get file path
+   */
+  getPath() {
+    return this.agentsFile;
+  }
+}
+
+export default AgentsMdBootstrap;

package/src/memory/index.js

@@ -1,17 +1,30 @@
-export { MemoryDatabase } from './stores/database.js';
+/**
+ * Memory System v4.1.0
+ * Export all memory components
+ */
+
+// Main engine
+export { MemoryEngine } from './memory-engine.js';
+
+// Databases
+export { MemoryDatabase } from './stores/memory-database.js';
+export { CodebaseDatabase } from './stores/codebase-database.js';
+
+// Watchers
 export { FileWatcher } from './watchers/file-watcher.js';
+
+// Utils
+export { MarkdownChunker } from './utils/markdown-chunker.js';
+export { CodeIndexer } from './utils/indexer.js';
 export { Chunker } from './utils/chunker.js';
 export { Embedder } from './utils/embedder.js';
-export { SimpleEmbedder } from './utils/simple-embedder.js';
-export { EnhancedSimpleEmbedder } from './utils/enhanced-embedder.js';
-export { UltraEnhancedEmbedder } from './utils/ultra-embedder.js';
-export { SmartRouter } from './utils/smart-router.js';
-export { DashboardClient } from './utils/dashboard-client.js';
-export { CodeIndexer } from './utils/indexer.js';
-export { DailyLogs } from './utils/daily-logs.js';
-export { SyncEngine } from './utils/sync-engine.js';
-export { MemoryEngine } from './memory-engine.js';
-export { MemoryEngine as default } from './memory-engine.js';
 
-// Phase 4: Intelligence Layer
-export { PatternDetector, SuggestionEngine, StrategySelector } from '../intelligence/index.js';
+// Two-tier memory layers
+export { DailyLogs } from './layers/daily-logs.js';
+export { CuratedMemory } from './layers/curated-memory.js';
+
+// Bootstrap
+export { AgentsMdBootstrap } from './bootstrap/agents-md.js';
+
+// Legacy exports for backward compatibility
+export { MemoryEngine as default } from './memory-engine.js';

package/src/memory/layers/curated-memory.js

@@ -0,0 +1,324 @@
+/**
+ * Curated Memory Layer
+ * Layer 2: Long-term curated knowledge
+ * File: MEMORY.md
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+
+export class CuratedMemory {
+  constructor(options = {}) {
+    this.memoryPath = options.memoryPath || '.mcfast';
+    this.memoryFile = path.join(this.memoryPath, 'MEMORY.md');
+    this.sections = new Map();
+  }
+
+  /**
+   * Ensure memory file exists
+   */
+  async ensureFile() {
+    try {
+      await fs.access(this.memoryFile);
+    } catch {
+      // Create default MEMORY.md
+      const defaultContent = this.getDefaultContent();
+      await fs.mkdir(path.dirname(this.memoryFile), { recursive: true });
+      await fs.writeFile(this.memoryFile, defaultContent);
+      console.log(`[CuratedMemory] Created ${this.memoryFile}`);
+    }
+  }
+
+  /**
+   * Get default content for new MEMORY.md
+   */
+  getDefaultContent() {
+    return `# Long-term Memory
+
+This file contains curated, persistent knowledge.
+
+## User Preferences
+
+<!-- Add user preferences here -->
+
+## Important Decisions
+
+<!-- Add important decisions here -->
+
+## Key Contacts
+
+<!-- Add key contacts here -->
+
+## Project Context
+
+<!-- Add project context here -->
+
+## Lessons Learned
+
+<!-- Add lessons learned here -->
+
+---
+*Last updated: ${new Date().toISOString()}*
+`;
+  }
+
+  /**
+   * Read entire memory file
+   */
+  async read() {
+    await this.ensureFile();
+    return await fs.readFile(this.memoryFile, 'utf-8');
+  }
+
+  /**
+   * Read specific section
+   */
+  async readSection(sectionName) {
+    const content = await this.read();
+    const sections = this.parseSections(content);
+    return sections.get(sectionName) || null;
+  }
+
+  /**
+   * Add or update a section
+   */
+  async updateSection(sectionName, content, append = false) {
+    await this.ensureFile();
+    
+    let fileContent = await this.read();
+    const sections = this.parseSections(fileContent);
+    
+    const timestamp = new Date().toISOString();
+    const sectionHeader = `## ${sectionName}`;
+    
+    if (sections.has(sectionName)) {
+      // Update existing section
+      const existingContent = sections.get(sectionName);
+      const newContent = append 
+        ? `${existingContent}\n\n${content}\n\n*Updated: ${timestamp}*`
+        : `${content}\n\n*Updated: ${timestamp}*`;
+      
+      fileContent = fileContent.replace(
+        new RegExp(`${sectionHeader}\\n[\\s\\S]*?(?=\\n## |\\n---|$)`),
+        `${sectionHeader}\n\n${newContent}\n`
+      );
+    } else {
+      // Add new section before the footer
+      const newSection = `${sectionHeader}\n\n${content}\n\n*Added: ${timestamp}*\n\n`;
+      fileContent = fileContent.replace(
+        /(---\n\*Last updated:.*\*)/,
+        `${newSection}$1`
+      );
+    }
+    
+    // Update timestamp
+    fileContent = fileContent.replace(
+      /\*Last updated:.*\*/,
+      `*Last updated: ${timestamp}*`
+    );
+    
+    await fs.writeFile(this.memoryFile, fileContent);
+    console.log(`[CuratedMemory] Updated section: ${sectionName}`);
+    
+    return true;
+  }
+
+  /**
+   * Parse sections from content
+   */
+  parseSections(content) {
+    const sections = new Map();
+    const lines = content.split('\n');
+    let currentSection = null;
+    let currentContent = [];
+
+    for (const line of lines) {
+      const match = line.match(/^##\s+(.+)$/);
+      
+      if (match) {
+        // Save previous section
+        if (currentSection) {
+          sections.set(currentSection, currentContent.join('\n').trim());
+        }
+        
+        // Start new section
+        currentSection = match[1];
+        currentContent = [];
+      } else if (currentSection) {
+        currentContent.push(line);
+      }
+    }
+
+    // Don't forget the last section
+    if (currentSection) {
+      sections.set(currentSection, currentContent.join('\n').trim());
+    }
+
+    return sections;
+  }
+
+  /**
+   * Add user preference
+   */
+  async addUserPreference(key, value) {
+    const content = `- **${key}:** ${value}`;
+    return this.updateSection('User Preferences', content, true);
+  }
+
+  /**
+   * Add important decision
+   */
+  async addDecision(decision, context = '') {
+    const timestamp = new Date().toISOString().split('T')[0];
+    let content = `- **${timestamp}:** ${decision}`;
+    if (context) {
+      content += `\n  - Context: ${context}`;
+    }
+    return this.updateSection('Important Decisions', content, true);
+  }
+
+  /**
+   * Add contact
+   */
+  async addContact(name, info, role = '') {
+    let content = `- **${name}**`;
+    if (role) content += ` (${role})`;
+    content += `: ${info}`;
+    return this.updateSection('Key Contacts', content, true);
+  }
+
+  /**
+   * Add project context
+   */
+  async addProjectContext(key, value) {
+    const content = `- **${key}:** ${value}`;
+    return this.updateSection('Project Context', content, true);
+  }
+
+  /**
+   * Add lesson learned
+   */
+  async addLesson(lesson, context = '') {
+    const timestamp = new Date().toISOString().split('T')[0];
+    let content = `- **${timestamp}:** ${lesson}`;
+    if (context) {
+      content += `\n  - Context: ${context}`;
+    }
+    return this.updateSection('Lessons Learned', content, true);
+  }
+
+  /**
+   * Add curated memory entry
+   * Smart routing to appropriate section
+   */
+  async addEntry(type, title, content) {
+    switch (type.toLowerCase()) {
+      case 'preference':
+      case 'pref':
+        return this.addUserPreference(title, content);
+      
+      case 'decision':
+        return this.addDecision(title, content);
+      
+      case 'contact':
+        return this.addContact(title, content);
+      
+      case 'project':
+      case 'context':
+        return this.addProjectContext(title, content);
+      
+      case 'lesson':
+      case 'learned':
+        return this.addLesson(title, content);
+      
+      default:
+        // Add to custom section
+        return this.updateSection(title, content);
+    }
+  }
+
+  /**
+   * Search in memory file
+   * Simple text search (not using FTS5 here - that's handled by MemoryDatabase)
+   */
+  async search(query) {
+    const content = await this.read();
+    const lines = content.split('\n');
+    const matches = [];
+    
+    const lowerQuery = query.toLowerCase();
+    
+    lines.forEach((line, index) => {
+      if (line.toLowerCase().includes(lowerQuery)) {
+        matches.push({
+          line: index + 1,
+          content: line,
+          context: this.getContext(lines, index)
+        });
+      }
+    });
+    
+    return matches;
+  }
+
+  /**
+   * Get context around a line
+   */
+  getContext(lines, index, contextSize = 2) {
+    const start = Math.max(0, index - contextSize);
+    const end = Math.min(lines.length, index + contextSize + 1);
+    return lines.slice(start, end).join('\n');
+  }
+
+  /**
+   * Get all sections
+   */
+  async getSections() {
+    const content = await this.read();
+    const sections = this.parseSections(content);
+    return Array.from(sections.keys());
+  }
+
+  /**
+   * Check if file exists
+   */
+  async exists() {
+    try {
+      await fs.access(this.memoryFile);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get file stats
+   */
+  async getStats() {
+    await this.ensureFile();
+    const stats = await fs.stat(this.memoryFile);
+    const content = await this.read();
+    const sections = this.parseSections(content);
+    
+    return {
+      path: this.memoryFile,
+      size: stats.size,
+      lastModified: stats.mtime,
+      sections: sections.size,
+      sectionNames: Array.from(sections.keys())
+    };
+  }
+
+  /**
+   * Promote entry from daily log to curated memory
+   */
+  async promoteFromDailyLog(date, entryTitle, sectionName) {
+    // This would require reading from daily log file
+    // Implementation depends on DailyLogs integration
+    console.log(`[CuratedMemory] Promote: ${entryTitle} from ${date} to ${sectionName}`);
+    // TODO: Implement promotion logic
+    return true;
+  }
+}
+
+export default CuratedMemory;