@softerist/heuristic-mcp 2.1.46 → 3.0.0

package/debug-pids.js

@@ -0,0 +1,27 @@
+import { exec } from 'child_process';
+import util from 'util';
+
+const execPromise = util.promisify(exec);
+
+async function check() {
+  console.info('Checking processes...');
+  try {
+    const { stdout } = await execPromise(
+      `powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object { $_.Name -eq 'node.exe' } | Select-Object ProcessId, CommandLine, ParentProcessId | ConvertTo-Json"`
+    );
+    const processes = JSON.parse(stdout);
+    const list = Array.isArray(processes) ? processes : [processes];
+    
+    for (const p of list) {
+      if (p.CommandLine && (p.CommandLine.includes('heuristic-mcp') || p.CommandLine.includes('index.js'))) {
+        console.info(`PID: ${p.ProcessId}, Parent: ${p.ParentProcessId}`);
+        console.info(`CMD: ${p.CommandLine}`);
+        console.info('---');
+      }
+    }
+  } catch (err) {
+    console.error('Error:', err.message);
+  }
+}
+
+check();

package/eslint.config.js

@@ -0,0 +1,36 @@
+import js from '@eslint/js';
+import globals from 'globals';
+
+export default [
+  {
+    ignores: ['node_modules/**', 'coverage/**', '.vitest-coverage/**'],
+  },
+  js.configs.recommended,
+  {
+    files: ['**/*.js'],
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'module',
+      globals: {
+        ...globals.node,
+        ...globals.es2021,
+      },
+    },
+    rules: {
+      'no-unused-vars': ['warn', { argsIgnorePattern: '^_', caughtErrorsIgnorePattern: '^_' }],
+      'no-console': ['warn', { allow: ['warn', 'error', 'info'] }],
+    },
+  },
+  {
+    files: ['scripts/**/*.js', 'test/**/*.js'],
+    rules: {
+      'no-console': 'off',
+    },
+  },
+  {
+    files: ['test/**/*.js'],
+    rules: {
+      'no-unused-vars': 'off',
+    },
+  },
+];

package/features/ann-config.js

@@ -15,31 +15,39 @@ export class AnnConfigTool {
    * Adjust efSearch and optionally trigger index rebuild
    */
   async execute(args) {
-    const action = args.action || "stats";
+    const action = args.action || 'stats';
 
-    if (action === "stats") {
+    if (action === 'stats') {
       return this.cache.getAnnStats();
     }
 
-    if (action === "set_ef_search") {
+    if (action === 'set_ef_search') {
       const efSearch = args.efSearch;
       if (efSearch === undefined) {
-        return { success: false, error: "efSearch parameter is required for set_ef_search action" };
+        return {
+          success: false,
+          error: 'efSearch parameter is required for set_ef_search action',
+        };
       }
       return this.cache.setEfSearch(efSearch);
     }
 
-    if (action === "rebuild") {
+    if (action === 'rebuild') {
       // Force invalidate and rebuild the ANN index
       this.cache.invalidateAnnIndex();
       const index = await this.cache.ensureAnnIndex();
       return {
         success: index !== null,
-        message: index ? "ANN index rebuilt successfully" : "ANN index rebuild failed or not available"
+        message: index
+          ? 'ANN index rebuilt successfully'
+          : 'ANN index rebuild failed or not available',
       };
     }
 
-    return { success: false, error: `Unknown action: ${action}. Valid actions: stats, set_ef_search, rebuild` };
+    return {
+      success: false,
+      error: `Unknown action: ${action}. Valid actions: stats, set_ef_search, rebuild`,
+    };
   }
 
   formatResults(result) {
@@ -49,7 +57,7 @@ export class AnnConfigTool {
 
     if (result.enabled !== undefined) {
       // Stats response
-      let output = "## ANN Index Statistics\n\n";
+      let output = '## ANN Index Statistics\n\n';
       output += `- **Enabled**: ${result.enabled}\n`;
       output += `- **Index Loaded**: ${result.indexLoaded}\n`;
       output += `- **Dirty (needs rebuild)**: ${result.dirty}\n`;
@@ -57,7 +65,7 @@ export class AnnConfigTool {
       output += `- **Min Chunks for ANN**: ${result.minChunksForAnn}\n`;
 
       if (result.config) {
-        output += "\n### Current Config\n\n";
+        output += '\n### Current Config\n\n';
         output += `- **Metric**: ${result.config.metric}\n`;
         output += `- **Dimensions**: ${result.config.dim}\n`;
         output += `- **Indexed Vectors**: ${result.config.count}\n`;
@@ -65,7 +73,7 @@ export class AnnConfigTool {
         output += `- **efConstruction**: ${result.config.efConstruction}\n`;
         output += `- **efSearch**: ${result.config.efSearch}\n`;
       } else {
-        output += "\n*No active ANN index.*\n";
+        output += '\n*No active ANN index.*\n';
       }
 
       return output;
@@ -79,32 +87,35 @@ export class AnnConfigTool {
 // MCP Tool definition
 export function getToolDefinition() {
   return {
-    name: "d_ann_config",
-    description: "Configure and monitor the ANN (Approximate Nearest Neighbor) search index. Actions: 'stats' (view current config), 'set_ef_search' (tune search accuracy/speed), 'rebuild' (force index rebuild).",
+    name: 'd_ann_config',
+    description:
+      "Configure and monitor the ANN (Approximate Nearest Neighbor) search index. Actions: 'stats' (view current config), 'set_ef_search' (tune search accuracy/speed), 'rebuild' (force index rebuild).",
     inputSchema: {
-      type: "object",
+      type: 'object',
       properties: {
         action: {
-          type: "string",
-          enum: ["stats", "set_ef_search", "rebuild"],
-          description: "Action to perform. 'stats' shows current config, 'set_ef_search' changes the search parameter, 'rebuild' forces index rebuild.",
-          default: "stats"
+          type: 'string',
+          enum: ['stats', 'set_ef_search', 'rebuild'],
+          description:
+            "Action to perform. 'stats' shows current config, 'set_ef_search' changes the search parameter, 'rebuild' forces index rebuild.",
+          default: 'stats',
         },
         efSearch: {
-          type: "number",
-          description: "New efSearch value (only for set_ef_search action). Higher = more accurate but slower. Typical range: 16-512.",
+          type: 'number',
+          description:
+            'New efSearch value (only for set_ef_search action). Higher = more accurate but slower. Typical range: 16-512.',
           minimum: 1,
-          maximum: 1000
-        }
-      }
+          maximum: 1000,
+        },
+      },
     },
     annotations: {
-      title: "ANN Index Configuration",
+      title: 'ANN Index Configuration',
       readOnlyHint: false,
       destructiveHint: false,
       idempotentHint: true,
-      openWorldHint: false
-    }
+      openWorldHint: false,
+    },
   };
 }
 
@@ -115,6 +126,6 @@ export async function handleToolCall(request, annConfigTool) {
   const formattedText = annConfigTool.formatResults(result);
 
   return {
-    content: [{ type: "text", text: formattedText }]
+    content: [{ type: 'text', text: formattedText }],
   };
 }

package/features/clear-cache.js

@@ -9,17 +9,21 @@ export class CacheClearer {
   async execute() {
     // Check if indexing is in progress
     if (this.indexer && this.indexer.isIndexing) {
-      throw new Error("Cannot clear cache while indexing is in progress. Please wait for indexing to complete.");
+      throw new Error(
+        'Cannot clear cache while indexing is in progress. Please wait for indexing to complete.'
+      );
     }
 
     // Check if cache is currently being saved (race condition prevention)
     if (this.cache.isSaving) {
-      throw new Error("Cannot clear cache while cache is being saved. Please try again in a moment.");
+      throw new Error(
+        'Cannot clear cache while cache is being saved. Please try again in a moment.'
+      );
     }
 
     // Check if a clear operation is already in progress (prevent concurrent clears)
     if (this.isClearing) {
-      throw new Error("Cache clear operation already in progress. Please wait for it to complete.");
+      throw new Error('Cache clear operation already in progress. Please wait for it to complete.');
     }
 
     this.isClearing = true;
@@ -29,7 +33,7 @@ export class CacheClearer {
       return {
         success: true,
         message: `Cache cleared successfully. Next indexing will be a full rebuild.`,
-        cacheDirectory: this.config.cacheDirectory
+        cacheDirectory: this.config.cacheDirectory,
       };
     } finally {
       this.isClearing = false;
@@ -39,19 +43,20 @@ export class CacheClearer {
 
 export function getToolDefinition() {
   return {
-    name: "c_clear_cache",
-    description: "Clears the embeddings cache, forcing a complete reindex on next search or manual index operation. Useful when encountering cache corruption or after major codebase changes.",
+    name: 'c_clear_cache',
+    description:
+      'Clears the embeddings cache, forcing a complete reindex on next search or manual index operation. Useful when encountering cache corruption or after major codebase changes.',
     inputSchema: {
-      type: "object",
-      properties: {}
+      type: 'object',
+      properties: {},
     },
     annotations: {
-      title: "Clear Embeddings Cache",
+      title: 'Clear Embeddings Cache',
       readOnlyHint: false,
       destructiveHint: true,
       idempotentHint: true,
-      openWorldHint: false
-    }
+      openWorldHint: false,
+    },
   };
 }
 
@@ -59,17 +64,21 @@ export async function handleToolCall(request, cacheClearer) {
   try {
     const result = await cacheClearer.execute();
     return {
-      content: [{
-        type: "text",
-        text: `${result.message}\n\nCache directory: ${result.cacheDirectory}`
-      }]
+      content: [
+        {
+          type: 'text',
+          text: `${result.message}\n\nCache directory: ${result.cacheDirectory}`,
+        },
+      ],
     };
   } catch (error) {
     return {
-      content: [{
-        type: "text",
-        text: `Failed to clear cache: ${error.message}`
-      }]
+      content: [
+        {
+          type: 'text',
+          text: `Failed to clear cache: ${error.message}`,
+        },
+      ],
     };
   }
 }

package/features/find-similar-code.js

@@ -1,5 +1,5 @@
-import path from "path";
-import { dotSimilarity } from "../lib/utils.js";
+import path from 'path';
+import { dotSimilarity, smartChunk, estimateTokens, getModelTokenLimit } from '../lib/utils.js';
 
 /**
  * FindSimilarCode feature
@@ -12,6 +12,14 @@ export class FindSimilarCode {
     this.config = config;
   }
 
+  async getChunkContent(chunk) {
+    return this.cache.getChunkContent(chunk);
+  }
+
+  getChunkVector(chunk) {
+    return this.cache.getChunkVector(chunk);
+  }
+
   getAnnCandidateCount(maxResults, totalChunks) {
     const minCandidates = this.config.annMinCandidates ?? 0;
     const maxCandidates = this.config.annMaxCandidates ?? totalChunks;
@@ -22,19 +30,44 @@ export class FindSimilarCode {
   }
 
   async execute({ code, maxResults = 5, minSimilarity = 0.3 }) {
+    if (typeof this.cache.ensureLoaded === 'function') {
+      await this.cache.ensureLoaded();
+    }
     const vectorStore = this.cache.getVectorStore();
 
     if (vectorStore.length === 0) {
       return {
         results: [],
-        message: "No code has been indexed yet. Please wait for initial indexing to complete."
+        message: 'No code has been indexed yet. Please wait for initial indexing to complete.',
       };
     }
 
+    let codeToEmbed = code;
+    let warningMessage = null;
+
+    // Check if input is too large and truncate intelligently
+    const estimatedTokens = estimateTokens(code);
+    const limit = getModelTokenLimit(this.config.embeddingModel);
+    
+    // If input is significantly larger than the model limit, we should chunk it
+    if (estimatedTokens > limit) {
+      // Use smartChunk to get a semantically valid first block
+      // We pass a dummy file name to trigger language detection if possible, or default to .txt
+      // Since we don't know the language, we'll try to guess or just use generic chunking
+      const chunks = smartChunk(code, 'input.txt', this.config);
+      if (chunks.length > 0) {
+        codeToEmbed = chunks[0].text;
+        warningMessage = `Note: Input code was too long (${estimatedTokens} tokens). Searching using the first chunk (${chunks[0].tokenCount} tokens).`;
+      }
+    }
+
     // Generate embedding for the input code
-    const codeEmbed = await this.embedder(code, { pooling: "mean", normalize: true });
-    const codeVector = Array.from(codeEmbed.data);
-    const codeVectorTyped = codeEmbed.data;
+    const codeEmbed = await this.embedder(codeToEmbed, {
+      pooling: 'mean',
+      normalize: true,
+    });
+    const codeVector = codeEmbed.data; // Keep as Float32Array for performance
+    const codeVectorTyped = codeVector;
 
     let candidates = vectorStore;
     let usedAnn = false;
@@ -54,92 +87,131 @@ export class FindSimilarCode {
       }
     }
 
-    // Score all chunks by similarity
-    let scoredChunks = candidates.map(chunk => {
-      const similarity = dotSimilarity(codeVector, chunk.vector);
-      return { ...chunk, similarity };
-    });
-
-    // Filter by minimum similarity and sort
-    let filteredResults = scoredChunks
-      .filter(chunk => chunk.similarity >= minSimilarity)
-      .sort((a, b) => b.similarity - a.similarity);
+    const normalizedInput = codeToEmbed.trim().replace(/\s+/g, ' ');
+    
+    /**
+     * Batch scoring function to prevent blocking the event loop
+     */
+    const scoreAndFilter = async (chunks) => {
+      const BATCH_SIZE = 500;
+      const scored = [];
+      
+      for (let i = 0; i < chunks.length; i += BATCH_SIZE) {
+        const batch = chunks.slice(i, i + BATCH_SIZE);
+        
+        // Yield to event loop between batches
+        if (i > 0) {
+          await new Promise((resolve) => setTimeout(resolve, 0));
+        }
+        
+        for (const chunk of batch) {
+          const vector = this.getChunkVector(chunk);
+          if (!vector) continue;
+          const similarity = dotSimilarity(codeVector, vector);
+          
+          if (similarity >= minSimilarity) {
+            // Deduplicate against input
+            if (normalizedInput) {
+              const content = await this.getChunkContent(chunk);
+              const normalizedChunk = content.trim().replace(/\s+/g, ' ');
+              if (normalizedChunk === normalizedInput) continue;
+            }
+            
+            scored.push({ ...chunk, similarity });
+          }
+        }
+      }
+      
+      return scored.sort((a, b) => b.similarity - a.similarity);
+    };
 
+    let filteredResults = await scoreAndFilter(candidates);
+    
+    // Fallback to full scan if ANN didn't provide enough results
+    // Optimization: Skip full scan on large codebases to avoid long pauses
+    const MAX_FULL_SCAN_SIZE = 5000;
     if (usedAnn && filteredResults.length < maxResults) {
-      scoredChunks = vectorStore.map(chunk => {
-        const similarity = dotSimilarity(codeVector, chunk.vector);
-        return { ...chunk, similarity };
-      });
-      filteredResults = scoredChunks
-        .filter(chunk => chunk.similarity >= minSimilarity)
-        .sort((a, b) => b.similarity - a.similarity);
+      if (vectorStore.length <= MAX_FULL_SCAN_SIZE) {
+        filteredResults = await scoreAndFilter(vectorStore);
+      } else {
+        // Just return what we found via ANN
+      }
     }
-
-    // Deduplicate: if input code is from indexed file, skip exact matches
-    const normalizedInput = code.trim().replace(/\s+/g, ' ');
-    const results = filteredResults
-      .filter(chunk => {
-        const normalizedChunk = chunk.content.trim().replace(/\s+/g, ' ');
-        // Skip if it's essentially the same code (>95% similar text)
-        return normalizedChunk !== normalizedInput;
-      })
-      .slice(0, maxResults);
+    const results = await Promise.all(
+      filteredResults.slice(0, maxResults).map(async (chunk) => {
+        if (chunk.content === undefined || chunk.content === null) {
+          return { ...chunk, content: await this.getChunkContent(chunk) };
+        }
+        return chunk;
+      }),
+    );
 
     return {
       results,
-      message: results.length === 0 ? "No similar code found above the similarity threshold." : null
+      message: warningMessage || (results.length === 0 ? 'No similar code found above the similarity threshold.' : null),
     };
   }
 
-  formatResults(results) {
+  async formatResults(results) {
     if (results.length === 0) {
-      return "No similar code patterns found in the codebase.";
+      return 'No similar code patterns found in the codebase.';
     }
 
-    return results.map((r, idx) => {
-      const relPath = path.relative(this.config.searchDirectory, r.file);
-      return `## Similar Code ${idx + 1} (Similarity: ${(r.similarity * 100).toFixed(1)}%)\n` +
-             `**File:** \`${relPath}\`\n` +
-             `**Lines:** ${r.startLine}-${r.endLine}\n\n` +
-             "```" + path.extname(r.file).slice(1) + "\n" +
-             r.content + "\n" +
-             "```\n";
-    }).join("\n");
+    const formatted = await Promise.all(
+      results.map(async (r, idx) => {
+        const relPath = path.relative(this.config.searchDirectory, r.file);
+        const content = r.content ?? await this.getChunkContent(r);
+        return (
+          `## Similar Code ${idx + 1} (Similarity: ${(r.similarity * 100).toFixed(1)}%)\n` +
+          `**File:** \`${relPath}\`\n` +
+          `**Lines:** ${r.startLine}-${r.endLine}\n\n` +
+          '```' +
+          path.extname(r.file).slice(1) +
+          '\n' +
+          content +
+          '\n' +
+          '```\n'
+        );
+      }),
+    );
+
+    return formatted.join('\n');
   }
 }
 
 // MCP Tool definition
-export function getToolDefinition(config) {
+export function getToolDefinition(_config) {
   return {
-    name: "d_find_similar_code",
-    description: "Find similar code patterns in the codebase. Given a code snippet, returns other code chunks that are semantically similar. Useful for finding duplicate code, understanding patterns, and refactoring opportunities.",
+    name: 'd_find_similar_code',
+    description:
+      'Find similar code patterns in the codebase. Given a code snippet, returns other code chunks that are semantically similar. Useful for finding duplicate code, understanding patterns, and refactoring opportunities.',
     inputSchema: {
-      type: "object",
+      type: 'object',
       properties: {
         code: {
-          type: "string",
-          description: "The code snippet to find similar patterns for"
+          type: 'string',
+          description: 'The code snippet to find similar patterns for',
         },
         maxResults: {
-          type: "number",
-          description: "Maximum number of similar code chunks to return (default: 5)",
-          default: 5
+          type: 'number',
+          description: 'Maximum number of similar code chunks to return (default: 5)',
+          default: 5,
         },
         minSimilarity: {
-          type: "number",
-          description: "Minimum similarity threshold 0-1 (default: 0.3 = 30%)",
-          default: 0.3
-        }
+          type: 'number',
+          description: 'Minimum similarity threshold 0-1 (default: 0.3 = 30%)',
+          default: 0.3,
+        },
       },
-      required: ["code"]
+      required: ['code'],
     },
     annotations: {
-      title: "Find Similar Code",
+      title: 'Find Similar Code',
       readOnlyHint: true,
       destructiveHint: false,
       idempotentHint: true,
-      openWorldHint: false
-    }
+      openWorldHint: false,
+    },
   };
 }
 
@@ -149,17 +221,21 @@ export async function handleToolCall(request, findSimilarCode) {
   const maxResults = request.params.arguments.maxResults || 5;
   const minSimilarity = request.params.arguments.minSimilarity || 0.3;
 
-  const { results, message } = await findSimilarCode.execute({ code, maxResults, minSimilarity });
+  const { results, message } = await findSimilarCode.execute({
+    code,
+    maxResults,
+    minSimilarity,
+  });
 
   if (message) {
     return {
-      content: [{ type: "text", text: message }]
+      content: [{ type: 'text', text: message }],
     };
   }
 
-  const formattedText = findSimilarCode.formatResults(results);
+  const formattedText = await findSimilarCode.formatResults(results);
 
   return {
-    content: [{ type: "text", text: formattedText }]
+    content: [{ type: 'text', text: formattedText }],
   };
 }