@mrxkun/mcfast-mcp 4.1.10 → 4.1.12

package/src/tools/project_analyze.js

@@ -0,0 +1,491 @@
+/**
+ * project_analyze Tool
+ * Analyzes project structure and generates comprehensive overview
+ * Calls mcfast API to use Mercury for AI-powered analysis
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { MemoryEngine } from '../memory/index.js';
+
+const API_URL = process.env.MCFAST_API_URL || 'https://mcfast.vercel.app/api/v1';
+
+/**
+ * Execute project analysis
+ * @param {Object} args - Tool arguments
+ * @param {boolean} [args.force=false] - Force re-analysis
+ * @param {boolean} [args.updateMemory=true] - Update MEMORY.md with results
+ * @returns {Promise<Object>} Analysis results
+ */
+export async function execute(args) {
+  const {
+    force = false,
+    updateMemory = true
+  } = args;
+
+  const startTime = Date.now();
+  const projectPath = process.cwd();
+
+  try {
+    // Check for API key
+    const apiKey = process.env.MCFAST_TOKEN;
+    if (!apiKey) {
+      return {
+        content: [{
+          type: 'text',
+          text: `❌ MCFAST_TOKEN not configured
+
+To use project analysis, set MCFAST_TOKEN:
+1. Get your token from https://mcfast.vercel.app
+2. Set environment variable: MCFAST_TOKEN=your_token
+
+Alternatively, use local-only mode with basic detection.`
+        }],
+        isError: true
+      };
+    }
+
+    console.error('[project_analyze] Starting analysis...');
+    console.error('[project_analyze] Project path:', projectPath);
+
+    // Gather project information
+    const projectInfo = await gatherProjectInfo(projectPath);
+
+    // Call mcfast API for analysis
+    const analysisResult = await callProjectAnalyzeAPI(projectInfo, apiKey, force);
+
+    // Update MEMORY.md if requested
+    let memoryUpdated = false;
+    if (updateMemory && analysisResult.success) {
+      memoryUpdated = await updateMemoryWithAnalysis(projectPath, analysisResult.analysis);
+    }
+
+    const latencyMs = Date.now() - startTime;
+
+    // Format output
+    const output = formatAnalysisResult(analysisResult.analysis, latencyMs, memoryUpdated);
+
+    return {
+      content: [{
+        type: 'text',
+        text: output
+      }],
+      metadata: {
+        analysis: analysisResult.analysis,
+        cached: analysisResult.cached,
+        latencyMs,
+        memoryUpdated,
+        projectPath
+      }
+    };
+
+  } catch (error) {
+    console.error('[project_analyze] Error:', error);
+    return {
+      content: [{
+        type: 'text',
+        text: `❌ Project analysis failed: ${error.message}`
+      }],
+      isError: true
+    };
+  }
+}
+
+/**
+ * Gather project information for analysis
+ */
+async function gatherProjectInfo(projectPath) {
+  console.error('[project_analyze] Gathering project info...');
+
+  // Read package.json
+  let packageJson = null;
+  try {
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    const content = await fs.readFile(packageJsonPath, 'utf-8');
+    packageJson = JSON.parse(content);
+  } catch (e) {
+    console.warn('[project_analyze] No package.json found');
+  }
+
+  // Get file structure
+  const fileStructure = await getFileStructure(projectPath);
+
+  // Read key files
+  const keyFiles = await readKeyFiles(projectPath, fileStructure);
+
+  return {
+    projectPath,
+    packageJson,
+    fileStructure,
+    keyFiles
+  };
+}
+
+/**
+ * Get file structure as tree
+ */
+async function getFileStructure(dir, depth = 3, prefix = '') {
+  const lines = [];
+  
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const ignored = ['node_modules', '.git', 'dist', 'build', '.next', '.mcfast', 'coverage'];
+    
+    const filtered = entries
+      .filter(e => !ignored.includes(e.name) && !e.name.startsWith('.'))
+      .sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory()) return -1;
+        if (!a.isDirectory() && b.isDirectory()) return 1;
+        return a.name.localeCompare(b.name);
+      });
+
+    for (let i = 0; i < filtered.length; i++) {
+      const entry = filtered[i];
+      const isLast = i === filtered.length - 1;
+      const connector = isLast ? '└── ' : '├── ';
+      const line = prefix + connector + entry.name + (entry.isDirectory() ? '/' : '');
+      lines.push(line);
+
+      if (entry.isDirectory() && depth > 1) {
+        const newPrefix = prefix + (isLast ? '    ' : '│   ');
+        const subLines = await getFileStructure(
+          path.join(dir, entry.name), 
+          depth - 1, 
+          newPrefix
+        );
+        lines.push(...subLines);
+      }
+    }
+  } catch (e) {
+    // Ignore errors
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Read key files for analysis
+ */
+async function readKeyFiles(projectPath, fileStructure) {
+  const keyFiles = {};
+  
+  // Priority files to read
+  const priorityFiles = [
+    'README.md',
+    'AGENTS.md',
+    'app/page.tsx',
+    'app/layout.tsx',
+    'pages/index.tsx',
+    'pages/index.js',
+    'src/index.ts',
+    'src/index.js',
+    'src/main.ts',
+    'src/app.ts',
+    'server.ts',
+    'server.js',
+    'index.ts',
+    'index.js'
+  ];
+
+  // Find route files
+  const routePatterns = [
+    /app\/api\/.*\/route\.ts$/,
+    /app\/api\/.*\/route\.js$/,
+    /pages\/api\/.*\.ts$/,
+    /pages\/api\/.*\.js$/,
+    /src\/routes\/.*\.ts$/,
+    /src\/routes\/.*\.js$/
+  ];
+
+  // Parse file structure to find routes
+  const lines = fileStructure.split('\n');
+  for (const line of lines) {
+    for (const pattern of routePatterns) {
+      const match = line.match(/[\w\/\-\.]+/);
+      if (match && pattern.test(match[0])) {
+        priorityFiles.push(match[0]);
+      }
+    }
+  }
+
+  // Read files
+  for (const filePath of priorityFiles) {
+    try {
+      const fullPath = path.join(projectPath, filePath);
+      const content = await fs.readFile(fullPath, 'utf-8');
+      keyFiles[filePath] = content.substring(0, 3000); // Limit size
+    } catch (e) {
+      // File doesn't exist, skip
+    }
+  }
+
+  return keyFiles;
+}
+
+/**
+ * Call mcfast API for project analysis
+ */
+async function callProjectAnalyzeAPI(projectInfo, apiKey, force) {
+  const url = `${API_URL}/project/analyze`;
+
+  console.error('[project_analyze] Calling API:', url);
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+      'X-MCP-Client': 'mcfast-mcp-v4'
+    },
+    body: JSON.stringify({
+      projectPath: projectInfo.projectPath,
+      packageJson: projectInfo.packageJson,
+      fileStructure: projectInfo.fileStructure,
+      keyFiles: projectInfo.keyFiles,
+      forceReanalyze: force
+    })
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+    throw new Error(error.error || `API error: ${response.status}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Update MEMORY.md with analysis results
+ */
+async function updateMemoryWithAnalysis(projectPath, analysis) {
+  try {
+    const memoryPath = path.join(projectPath, '.mcfast', 'MEMORY.md');
+    
+    // Read existing memory or create new
+    let content = '';
+    try {
+      content = await fs.readFile(memoryPath, 'utf-8');
+    } catch (e) {
+      content = getDefaultMemoryTemplate();
+    }
+
+    // Build project context section
+    const projectContext = buildProjectContextSection(analysis);
+    
+    // Update Project Context section
+    content = updateSection(content, 'Project Context', projectContext);
+
+    // Update timestamp
+    content = content.replace(
+      /\*Last updated:.*\*/,
+      `*Last updated: ${new Date().toISOString()}*`
+    );
+
+    // Ensure directory exists
+    await fs.mkdir(path.dirname(memoryPath), { recursive: true });
+    await fs.writeFile(memoryPath, content);
+
+    console.error('[project_analyze] Updated MEMORY.md');
+    return true;
+  } catch (error) {
+    console.error('[project_analyze] Failed to update MEMORY.md:', error.message);
+    return false;
+  }
+}
+
+/**
+ * Build Project Context section content
+ */
+function buildProjectContextSection(analysis) {
+  const lines = [];
+  const timestamp = new Date().toISOString().split('T')[0];
+
+  // Project overview
+  if (analysis.projectOverview) {
+    const { name, description, purpose, type } = analysis.projectOverview;
+    lines.push(`- **${timestamp}** Project: **${name || 'Unknown'}**`);
+    if (type) lines.push(`  - Type: ${type}`);
+    if (description) lines.push(`  - Description: ${description}`);
+    if (purpose) lines.push(`  - Purpose: ${purpose}`);
+  }
+
+  // Technologies
+  if (analysis.technologies) {
+    const { languages, frameworks, databases } = analysis.technologies;
+    if (languages?.length) lines.push(`  - Languages: ${languages.join(', ')}`);
+    if (frameworks?.length) lines.push(`  - Frameworks: ${frameworks.join(', ')}`);
+    if (databases?.length) lines.push(`  - Databases: ${databases.join(', ')}`);
+  }
+
+  // API Endpoints
+  if (analysis.apiEndpoints?.length > 0) {
+    lines.push('');
+    lines.push(`- **API Endpoints** (${analysis.apiEndpoints.length} found):`);
+    analysis.apiEndpoints.slice(0, 10).forEach(ep => {
+      lines.push(`  - ${ep.method || 'GET'} ${ep.path}: ${ep.description || 'N/A'}`);
+    });
+    if (analysis.apiEndpoints.length > 10) {
+      lines.push(`  - ... and ${analysis.apiEndpoints.length - 10} more`);
+    }
+  }
+
+  // Main features
+  if (analysis.mainFeatures?.length > 0) {
+    lines.push('');
+    lines.push(`- **Main Features**:`);
+    analysis.mainFeatures.slice(0, 5).forEach(f => {
+      lines.push(`  - ${f.name}: ${f.description || 'N/A'}`);
+    });
+  }
+
+  // Entry points
+  if (analysis.entryPoints?.length > 0) {
+    lines.push('');
+    lines.push(`- **Entry Points**: ${analysis.entryPoints.join(', ')}`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Update a section in markdown content
+ */
+function updateSection(content, sectionName, newContent) {
+  const sectionRegex = new RegExp(`(## ${sectionName}\\n[\\s\\S]*?)(?=\\n## |$)`, 's');
+  const match = content.match(sectionRegex);
+
+  if (match) {
+    // Update existing section
+    return content.replace(
+      sectionRegex,
+      `## ${sectionName}\n\n${newContent}\n\n`
+    );
+  } else {
+    // Add new section before the footer
+    const newSection = `\n## ${sectionName}\n\n${newContent}\n\n`;
+    return content.replace(
+      /(---\n\*Last updated:.*\*)/,
+      `${newSection}$1`
+    );
+  }
+}
+
+/**
+ * Get default memory template
+ */
+function getDefaultMemoryTemplate() {
+  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()}*
+`;
+}
+
+/**
+ * Format analysis result for display
+ */
+function formatAnalysisResult(analysis, latencyMs, memoryUpdated) {
+  let output = `🔍 Project Analysis Results\n`;
+  output += `─`.repeat(50) + `\n\n`;
+
+  // Project Overview
+  if (analysis.projectOverview) {
+    const { name, description, purpose, type } = analysis.projectOverview;
+    output += `📦 **Project Overview**\n`;
+    output += `   Name: ${name || 'Unknown'}\n`;
+    output += `   Type: ${type || 'Unknown'}\n`;
+    if (description) output += `   Description: ${description}\n`;
+    if (purpose) output += `   Purpose: ${purpose}\n`;
+    output += `\n`;
+  }
+
+  // Technologies
+  if (analysis.technologies) {
+    const { languages, frameworks, databases, dependencies } = analysis.technologies;
+    output += `🛠️ **Technologies**\n`;
+    if (languages?.length) output += `   Languages: ${languages.join(', ')}\n`;
+    if (frameworks?.length) output += `   Frameworks: ${frameworks.join(', ')}\n`;
+    if (databases?.length) output += `   Databases: ${databases.join(', ')}\n`;
+    if (dependencies?.main?.length) {
+      output += `   Main Deps: ${dependencies.main.slice(0, 10).join(', ')}\n`;
+    }
+    output += `\n`;
+  }
+
+  // API Endpoints
+  if (analysis.apiEndpoints?.length > 0) {
+    output += `🔌 **API Endpoints** (${analysis.apiEndpoints.length} found)\n`;
+    analysis.apiEndpoints.slice(0, 15).forEach(ep => {
+      const method = (ep.method || 'GET').padEnd(6);
+      output += `   ${method} ${ep.path}\n`;
+      if (ep.description) {
+        output += `          → ${ep.description}\n`;
+      }
+    });
+    if (analysis.apiEndpoints.length > 15) {
+      output += `   ... and ${analysis.apiEndpoints.length - 15} more\n`;
+    }
+    output += `\n`;
+  }
+
+  // Main Features
+  if (analysis.mainFeatures?.length > 0) {
+    output += `✨ **Main Features**\n`;
+    analysis.mainFeatures.forEach((f, i) => {
+      output += `   ${i + 1}. ${f.name}`;
+      if (f.description) output += ` - ${f.description}`;
+      output += `\n`;
+    });
+    output += `\n`;
+  }
+
+  // Entry Points
+  if (analysis.entryPoints?.length > 0) {
+    output += `🚀 **Entry Points**: ${analysis.entryPoints.join(', ')}\n\n`;
+  }
+
+  // Recommendations
+  if (analysis.recommendations?.length > 0) {
+    output += `💡 **Recommendations**\n`;
+    analysis.recommendations.forEach(r => {
+      output += `   • ${r}\n`;
+    });
+    output += `\n`;
+  }
+
+  // Footer
+  output += `─`.repeat(50) + `\n`;
+  output += `⏱️ Analysis time: ${latencyMs}ms\n`;
+  if (memoryUpdated) {
+    output += `📝 MEMORY.md updated with project context\n`;
+  }
+  if (analysis.isFallback) {
+    output += `⚠️ Analysis was generated locally (Mercury unavailable)\n`;
+  }
+
+  return output;
+}
+
+export default { execute };

package/src/utils/audit-queue.js

@@ -16,6 +16,7 @@ export class AuditQueue {
     
     // Start flush timer
     this.flushTimer = setInterval(() => this.flush(), this.flushInterval);
+    this.flushTimer.unref(); // Prevent timer from keeping process alive
     
     // Flush on process exit
     process.on('beforeExit', () => this.flushSync());