@mrxkun/mcfast-mcp 3.5.2 → 3.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "3.5.2",
+  "version": "3.5.4",
   "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.",
   "type": "module",
   "bin": {

package/src/index.js

@@ -502,6 +502,227 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     return result;
 });
 
+// ============================================
+// AUDIT LOGGING - Dashboard Integration
+// ============================================
+
+/**
+ * Report audit log to Dashboard
+ * Sends operation logs to mcfast Dashboard for monitoring
+ */
+async function reportAudit(data) {
+    try {
+        // Only report if dashboard logging is enabled
+        if (process.env.MCFAST_ENABLE_AUDIT !== 'true') {
+            if (VERBOSE) {
+                console.error(`${colors.dim}[Audit] Skipped - MCFAST_ENABLE_AUDIT not set to 'true'${colors.reset}`);
+            }
+            return;
+        }
+
+        // Check if we have a token
+        if (!TOKEN) {
+            if (VERBOSE) {
+                console.error(`${colors.yellow}[Audit] Skipped - No MCFAST_TOKEN provided${colors.reset}`);
+            }
+            return;
+        }
+
+        const auditData = {
+            timestamp: new Date().toISOString(),
+            session_id: process.env.MCFAST_SESSION_ID || 'local',
+            tool: data.tool || 'unknown',
+            status: data.status || 'unknown',
+            latency_ms: data.latency_ms || 0,
+            instruction: data.instruction || '',
+            files_count: data.files_count || 0,
+            input_tokens: data.input_tokens || 0,
+            output_tokens: data.output_tokens || 0,
+            strategy: data.strategy || null,
+            error: data.error || null,
+            metadata: data.metadata || {}
+        };
+
+        // Send to dashboard API
+        const DASHBOARD_API_URL = process.env.MCFAST_DASHBOARD_URL || 'https://mcfast.vercel.app/api/v1/logs/audit';
+        
+        if (VERBOSE) {
+            console.error(`${colors.dim}[Audit] Sending to: ${DASHBOARD_API_URL}${colors.reset}`);
+            console.error(`${colors.dim}[Audit] Tool: ${auditData.tool}, Status: ${auditData.status}${colors.reset}`);
+        }
+        
+        const response = await fetch(DASHBOARD_API_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${TOKEN}`
+            },
+            body: JSON.stringify(auditData)
+        });
+
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => 'Unknown error');
+            if (VERBOSE) {
+                console.error(`${colors.yellow}[Audit] Failed - HTTP ${response.status}: ${errorText}${colors.reset}`);
+            }
+        } else {
+            if (VERBOSE) {
+                console.error(`${colors.green}[Audit] Logged successfully ✓${colors.reset}`);
+            }
+        }
+
+        // Also log to local file if configured
+        if (process.env.MCFAST_AUDIT_FILE) {
+            const logLine = JSON.stringify(auditData) + '\n';
+            await fs.appendFile(process.env.MCFAST_AUDIT_FILE, logLine).catch((err) => {
+                if (VERBOSE) {
+                    console.error(`${colors.yellow}[Audit] Failed to write to file:${colors.reset}`, err.message);
+                }
+            });
+        }
+    } catch (error) {
+        // Silent fail - audit should never break the tool
+        if (VERBOSE) {
+            console.error(`${colors.yellow}[Audit] Error (non-critical):${colors.reset}`, error.message);
+        }
+    }
+}
+
+// ============================================
+// FILESYSTEM SEARCH HANDLER
+// ============================================
+
+/**
+ * Handle filesystem search using fast-glob and pattern matching
+ * Fast alternative to API-based search for local files
+ */
+async function handleSearchFilesystem({ query, path: searchPath, isRegex = false, caseSensitive = false }) {
+    const start = Date.now();
+    
+    try {
+        // Determine search pattern
+        let pattern = query;
+        if (!isRegex) {
+            // Convert literal query to glob pattern for file search
+            pattern = `**/*${query}*`;
+        }
+        
+        // Default to current directory if no path specified
+        const cwd = searchPath || process.cwd();
+        
+        // Use fast-glob to find files
+        const files = await fg([pattern], {
+            cwd,
+            ignore: ['node_modules/**', '.git/**', 'dist/**', 'build/**'],
+            dot: false,
+            caseSensitive,
+            absolute: false
+        });
+
+        // Also search file contents if it's not a file pattern
+        const contentMatches = [];
+        
+        // For simple queries, also search in common code files
+        if (!isRegex && query.length > 1) {
+            const codeFiles = await fg(['**/*.{js,ts,jsx,tsx,py,go,rs,java,rb,php}'], {
+                cwd,
+                ignore: ['node_modules/**', '.git/**'],
+                absolute: false
+            });
+            
+            // Search in first 50 files to avoid performance issues
+            for (const file of codeFiles.slice(0, 50)) {
+                try {
+                    const content = await fs.readFile(path.join(cwd, file), 'utf-8');
+                    if (content.includes(query)) {
+                        const lines = content.split('\n');
+                        const matches = [];
+                        
+                        lines.forEach((line, idx) => {
+                            if (line.includes(query)) {
+                                matches.push({
+                                    line: idx + 1,
+                                    content: line.trim()
+                                });
+                            }
+                        });
+                        
+                        if (matches.length > 0) {
+                            contentMatches.push({
+                                file,
+                                matches: matches.slice(0, 5) // Limit to 5 matches per file
+                            });
+                        }
+                    }
+                } catch (e) {
+                    // Skip files that can't be read
+                }
+            }
+        }
+
+        const latency = Date.now() - start;
+        
+        // Format output
+        let output = `${colors.bold}Filesystem Search Results${colors.reset}\n\n`;
+        output += `Query: "${query}"\n`;
+        output += `Path: ${cwd}\n`;
+        output += `Files found: ${files.length}\n`;
+        output += `Content matches: ${contentMatches.length} files\n`;
+        output += `Latency: ${latency}ms\n\n`;
+
+        if (files.length > 0) {
+            output += `${colors.bold}Matching Files:${colors.reset}\n`;
+            files.slice(0, 20).forEach(file => {
+                output += `  ${colors.cyan}•${colors.reset} ${file}\n`;
+            });
+            if (files.length > 20) {
+                output += `  ${colors.dim}... and ${files.length - 20} more${colors.reset}\n`;
+            }
+            output += '\n';
+        }
+
+        if (contentMatches.length > 0) {
+            output += `${colors.bold}Content Matches:${colors.reset}\n`;
+            contentMatches.slice(0, 10).forEach(({ file, matches }) => {
+                output += `\n${colors.yellow}${file}${colors.reset}\n`;
+                matches.forEach(match => {
+                    output += `  ${colors.dim}${match.line}:${colors.reset} ${match.content}\n`;
+                });
+            });
+        }
+
+        // Report audit
+        reportAudit({
+            tool: 'search_filesystem',
+            instruction: `Search: ${query}`,
+            status: 'success',
+            latency_ms: latency,
+            files_count: files.length,
+            input_tokens: Math.ceil(query.length / 4),
+            output_tokens: Math.ceil(output.length / 4)
+        });
+
+        return {
+            content: [{ type: "text", text: output }]
+        };
+    } catch (error) {
+        const latency = Date.now() - start;
+        
+        reportAudit({
+            tool: 'search_filesystem',
+            instruction: `Search: ${query}`,
+            status: 'error',
+            latency_ms: latency,
+            error: error.message
+        });
+
+        return {
+            content: [{ type: "text", text: `❌ Search error: ${error.message}` }],
+            isError: true
+        };
+    }
+}
+
 // Smart retry handler
 async function handleReapply({ instruction, files, errorContext = "", attempt = 1 }) {
     const MAX_ATTEMPTS = 3;
@@ -941,8 +1162,7 @@ async function handleBatchRead(filePaths, start_line, end_line, max_lines_per_fi
     let output = `📚 Batch Read Complete (${filePaths.length} files)\n`;
     output += `✅ Successful: ${successful}  ❌ Failed: ${failed}\n`;
     output += `📊 Total: ${totalLines} lines, ${(totalSize / 1024).toFixed(1)} KB\n`;
-    output += `⏱️ Latency: ${Date.now() - start}ms\n`;
-    output += `========================================\n\n`;
+    output += `⏱️ Latency: ${Date.now() - start}ms\n\n`;
     
     // Add each file's content
     results.forEach((result, index) => {