@mrxkun/mcfast-mcp 1.4.2 → 1.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrxkun/mcfast-mcp",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "description": "Ultra-fast code editing via Mercury Coder Cloud API.",
   "type": "module",
   "bin": {

package/src/index.js

@@ -560,52 +560,115 @@ async function handleSearchCode({ query, files, regex = false, caseSensitive = f
     const start = Date.now();
     try {
         const results = [];
-        const flags = caseSensitive ? 'm' : 'im';
-        const pattern = regex ? new RegExp(query, flags) : null;
-        const queryLower = query.toLowerCase();
         let totalInputChars = 0;
 
-        for (const [filePath, content] of Object.entries(files)) {
-            if (typeof content !== 'string') continue;
-            totalInputChars += content.length;
-
-            const lines = content.split('\n');
-            lines.forEach((line, index) => {
-                let isMatch = false;
-                if (regex && pattern) {
-                    isMatch = pattern.test(line);
-                    pattern.lastIndex = 0;
-                } else {
-                    if (caseSensitive) {
-                        isMatch = line.includes(query);
-                    } else {
-                        isMatch = line.toLowerCase().includes(queryLower);
+        // If regex mode, use original regex logic
+        if (regex) {
+            const flags = caseSensitive ? 'm' : 'im';
+            const pattern = new RegExp(query, flags);
+
+            for (const [filePath, content] of Object.entries(files)) {
+                if (typeof content !== 'string') continue;
+                totalInputChars += content.length;
+
+                const lines = content.split('\n');
+                lines.forEach((line, index) => {
+                    if (pattern.test(line)) {
+                        pattern.lastIndex = 0;
+                        const startLine = Math.max(0, index - contextLines);
+                        const endLine = Math.min(lines.length - 1, index + contextLines);
+
+                        const contextSnippet = lines
+                            .slice(startLine, endLine + 1)
+                            .map((l, i) => ({
+                                lineNumber: startLine + i + 1,
+                                content: l,
+                                isMatch: startLine + i === index
+                            }));
+
+                        results.push({
+                            file: filePath,
+                            lineNumber: index + 1,
+                            matchedLine: line.trim(),
+                            context: contextSnippet,
+                            matchType: 'regex'
+                        });
                     }
-                }
+                });
+            }
+        } else {
+            // Semantic search with stop words filtering
+            const queryLower = query.toLowerCase();
+
+            // Common English stop words to filter out
+            const stopWords = new Set([
+                'a', 'an', 'and', 'are', 'as', 'at', 'be', 'by', 'for', 'from', 'has', 'he',
+                'in', 'is', 'it', 'its', 'of', 'on', 'that', 'the', 'to', 'was', 'will', 'with',
+                'how', 'what', 'when', 'where', 'who', 'why', 'does', 'do', 'this', 'these', 'those'
+            ]);
+
+            // Extract significant words (3+ chars, not stop words)
+            const words = queryLower
+                .split(/\W+/)
+                .filter(w => w.length >= 3 && !stopWords.has(w));
+
+            // If no significant words, fall back to whole query
+            const searchTerms = words.length > 0 ? words : [queryLower];
+
+            for (const [filePath, content] of Object.entries(files)) {
+                if (typeof content !== 'string') continue;
+                totalInputChars += content.length;
+
+                const lines = content.split('\n');
+                lines.forEach((line, index) => {
+                    const lineLower = caseSensitive ? line : line.toLowerCase();
+                    const searchQuery = caseSensitive ? query : queryLower;
+
+                    // Check 1: Exact phrase match (highest priority)
+                    const exactMatch = lineLower.includes(searchQuery);
+
+                    // Check 2: All significant words present (semantic match)
+                    const allWordsMatch = searchTerms.every(term => lineLower.includes(term));
+
+                    // Check 3: At least half of significant words present (fuzzy match)
+                    const matchCount = searchTerms.filter(term => lineLower.includes(term)).length;
+                    const fuzzyMatch = matchCount >= Math.ceil(searchTerms.length / 2);
+
+                    if (exactMatch || allWordsMatch || (searchTerms.length > 1 && fuzzyMatch)) {
+                        const startLine = Math.max(0, index - contextLines);
+                        const endLine = Math.min(lines.length - 1, index + contextLines);
+
+                        const contextSnippet = lines
+                            .slice(startLine, endLine + 1)
+                            .map((l, i) => ({
+                                lineNumber: startLine + i + 1,
+                                content: l,
+                                isMatch: startLine + i === index
+                            }));
+
+                        results.push({
+                            file: filePath,
+                            lineNumber: index + 1,
+                            matchedLine: line.trim(),
+                            context: contextSnippet,
+                            matchType: exactMatch ? 'exact' : allWordsMatch ? 'semantic' : 'fuzzy',
+                            matchScore: exactMatch ? 100 : allWordsMatch ? 80 : matchCount * 10
+                        });
+                    }
+                });
+            }
 
-                if (isMatch) {
-                    const startLine = Math.max(0, index - contextLines);
-                    const endLine = Math.min(lines.length - 1, index + contextLines);
-
-                    const contextSnippet = lines
-                        .slice(startLine, endLine + 1)
-                        .map((l, i) => ({
-                            lineNumber: startLine + i + 1,
-                            content: l,
-                            isMatch: startLine + i === index
-                        }));
-
-                    results.push({
-                        file: filePath,
-                        lineNumber: index + 1,
-                        matchedLine: line.trim(),
-                        context: contextSnippet
-                    });
+            // Sort results: by score (highest first), then by file
+            results.sort((a, b) => {
+                if (a.matchScore !== b.matchScore) {
+                    return b.matchScore - a.matchScore;
                 }
+                return a.file.localeCompare(b.file);
             });
         }
 
-        let output = `🔍 Found ${results.length} matches for "${query}" (literal search)\n\n`;
+        const searchType = regex ? 'regex' : 'semantic';
+        let output = `🔍 Found ${results.length} matches for "${query}" (${searchType} search)\n\n`;
         if (results.length === 0) {
             output += "No matches found in provided context.";
         } else {
@@ -691,12 +754,16 @@ async function handleEditFile({ path: filePath, content, instruction = "" }) {
     try {
         await fs.writeFile(filePath, content, 'utf8');
 
+        const estimatedTokens = Math.ceil(content.length / 4);
+
         reportAudit({
             tool: 'edit_file',
             instruction: instruction || `Written ${filePath}`,
             status: 'success',
             latency_ms: Date.now() - start,
-            files_count: 1
+            files_count: 1,
+            input_tokens: estimatedTokens,
+            output_tokens: 10 // Minimal output (success message)
         });
 
         return {
@@ -708,7 +775,9 @@ async function handleEditFile({ path: filePath, content, instruction = "" }) {
             instruction: instruction || `Failed write ${filePath}`,
             status: 'error',
             error_message: error.message,
-            latency_ms: Date.now() - start
+            latency_ms: Date.now() - start,
+            input_tokens: Math.ceil((content?.length || 0) / 4),
+            output_tokens: 0
         });
         return {
             content: [{ type: "text", text: `❌ Failed to write file: ${error.message}` }],