@softerist/heuristic-mcp 3.2.12 → 3.2.13

package/features/hybrid-search.js

@@ -3,6 +3,7 @@ import fs from 'fs/promises';
 import { dotSimilarity } from '../lib/utils.js';
 import { extractSymbolsFromContent } from '../lib/call-graph.js';
 import { embedQueryInChildProcess } from '../lib/embed-query-process.js';
+import { normalizePathKey } from '../lib/path-utils.js';
 import {
   STAT_CONCURRENCY_LIMIT,
   SEARCH_BATCH_SIZE,
@@ -27,6 +28,10 @@ function alignQueryVectorDimension(vector, targetDim) {
   return sliced;
 }
 
+function toFileKey(file) {
+  return normalizePathKey(file);
+}
+
 export class HybridSearch {
   constructor(embedder, cache, config) {
     this.embedder = embedder;
@@ -36,6 +41,13 @@ export class HybridSearch {
     this._lastAccess = new Map();
   }
 
+  setFileModTime(file, mtimeMs) {
+    const key = toFileKey(file);
+    if (!key) return;
+    this.fileModTimes.set(key, mtimeMs);
+    this._lastAccess.set(key, Date.now());
+  }
+
   async getChunkContent(chunkOrIndex) {
     return await this.cache.getChunkContent(chunkOrIndex);
   }
@@ -54,20 +66,28 @@ export class HybridSearch {
   }
 
   async populateFileModTimes(files) {
-    const uniqueFiles = new Set(files);
+    const uniqueFilesByKey = new Map();
+    for (const file of files) {
+      const key = toFileKey(file);
+      if (!key) continue;
+      if (!uniqueFilesByKey.has(key)) {
+        uniqueFilesByKey.set(key, file);
+      }
+    }
     const missing = [];
+    const now = Date.now();
 
-    for (const file of uniqueFiles) {
-      if (!this.fileModTimes.has(file)) {
+    for (const [key, file] of uniqueFilesByKey) {
+      if (!this.fileModTimes.has(key)) {
         const meta = this.cache.getFileMeta(file);
         if (meta && typeof meta.mtimeMs === 'number') {
-          this.fileModTimes.set(file, meta.mtimeMs);
-          this._lastAccess.set(file, Date.now());
+          this.fileModTimes.set(key, meta.mtimeMs);
+          this._lastAccess.set(key, now);
         } else {
-          missing.push(file);
+          missing.push({ key, file });
         }
       } else {
-        this._lastAccess.set(file, Date.now());
+        this._lastAccess.set(key, now);
       }
     }
 
@@ -79,13 +99,15 @@ export class HybridSearch {
 
     const worker = async (startIdx) => {
       for (let i = startIdx; i < missing.length; i += workerCount) {
-        const file = missing[i];
+        const item = missing[i];
+        if (!item) continue;
+        const { key, file } = item;
         try {
           const stats = await fs.stat(file);
-          this.fileModTimes.set(file, stats.mtimeMs);
-          this._lastAccess.set(file, Date.now());
+          this.fileModTimes.set(key, stats.mtimeMs);
+          this._lastAccess.set(key, Date.now());
         } catch {
-          this.fileModTimes.set(file, null);
+          this.fileModTimes.set(key, null);
         }
       }
     };
@@ -109,7 +131,10 @@ export class HybridSearch {
   }
 
   clearFileModTime(file) {
-    this.fileModTimes.delete(file);
+    const key = toFileKey(file);
+    if (!key) return;
+    this.fileModTimes.delete(key);
+    this._lastAccess.delete(key);
   }
 
   async search(query, maxResults) {
@@ -259,11 +284,11 @@ export class HybridSearch {
           await this.populateFileModTimes(candidates.map((chunk) => chunk.file));
         } else {
           for (const chunk of candidates) {
-            if (!this.fileModTimes.has(chunk.file)) {
-              const meta = this.cache.getFileMeta(chunk.file);
-              if (meta && typeof meta.mtimeMs === 'number') {
-                this.fileModTimes.set(chunk.file, meta.mtimeMs);
-              }
+            const chunkKey = toFileKey(chunk.file);
+            if (!chunkKey || this.fileModTimes.has(chunkKey)) continue;
+            const meta = this.cache.getFileMeta(chunk.file);
+            if (meta && typeof meta.mtimeMs === 'number') {
+              this.setFileModTime(chunk.file, meta.mtimeMs);
             }
           }
         }
@@ -323,7 +348,8 @@ export class HybridSearch {
           }
 
           if (recencyBoostEnabled) {
-            const mtime = this.fileModTimes.get(chunkInfo.file);
+            const chunkKey = toFileKey(chunkInfo.file);
+            const mtime = chunkKey ? this.fileModTimes.get(chunkKey) : undefined;
             if (typeof mtime === 'number') {
               const ageMs = now - mtime;
               const recencyFactor = Math.max(0, 1 - ageMs / recencyDecayMs);
@@ -380,7 +406,9 @@ export class HybridSearch {
           const relatedFiles = await this.cache.getRelatedFiles(Array.from(symbolsFromTop));
 
           for (const chunk of scoredChunks) {
-            const proximity = relatedFiles.get(chunk.file);
+            const chunkKey = toFileKey(chunk.file);
+            const proximity =
+              relatedFiles.get(chunk.file) ?? (chunkKey ? relatedFiles.get(chunkKey) : undefined);
             if (proximity) {
               chunk.score += proximity * this.config.callGraphBoost;
             }

package/features/index-codebase.js

@@ -10,6 +10,7 @@ import { fileURLToPath } from 'url';
 import { smartChunk, hashContent } from '../lib/utils.js';
 import { extractCallData } from '../lib/call-graph.js';
 import { forceShutdownEmbeddingPool, isEmbeddingPoolActive } from '../lib/embed-query-process.js';
+import { normalizePathKey } from '../lib/path-utils.js';
 
 import ignore from 'ignore';
 
@@ -31,6 +32,10 @@ function normalizePath(value) {
   return value.split(path.sep).join('/');
 }
 
+function toFileKey(value) {
+  return normalizePathKey(value);
+}
+
 function globToRegExp(pattern) {
   let regex = '^';
   for (let i = 0; i < pattern.length; i += 1) {
@@ -2149,7 +2154,14 @@ export class CodebaseIndexer {
       if (this.server && this.server.hybridSearch && this.server.hybridSearch.fileModTimes) {
         for (const stat of fileStats) {
           if (stat && stat.file && typeof stat.mtimeMs === 'number') {
-            this.server.hybridSearch.fileModTimes.set(stat.file, stat.mtimeMs);
+            if (typeof this.server.hybridSearch.setFileModTime === 'function') {
+              this.server.hybridSearch.setFileModTime(stat.file, stat.mtimeMs);
+            } else {
+              const key = toFileKey(stat.file);
+              if (key) {
+                this.server.hybridSearch.fileModTimes.set(key, stat.mtimeMs);
+              }
+            }
           }
         }
       }
@@ -2233,7 +2245,16 @@ export class CodebaseIndexer {
 
       this.sendProgress(5, 100, `Discovered ${files.length} files`);
 
-      const currentFilesSet = new Set(files);
+      const currentFileKeySet = new Set();
+      const currentFilePathByKey = new Map();
+      for (const file of files) {
+        const key = toFileKey(file);
+        if (!key) continue;
+        currentFileKeySet.add(key);
+        if (!currentFilePathByKey.has(key)) {
+          currentFilePathByKey.set(key, file);
+        }
+      }
 
       if (!force) {
         const cachedFiles =
@@ -2241,7 +2262,8 @@ export class CodebaseIndexer {
         let prunedCount = 0;
 
         for (const cachedFile of cachedFiles) {
-          if (!currentFilesSet.has(cachedFile)) {
+          const cachedKey = toFileKey(cachedFile);
+          if (!cachedKey || !currentFileKeySet.has(cachedKey)) {
             this.cache.removeFileFromStore(cachedFile);
             this.cache.deleteFileHash(cachedFile);
             prunedCount++;
@@ -2254,26 +2276,48 @@ export class CodebaseIndexer {
           }
         }
 
-        const prunedCallGraph = this.cache.pruneCallGraphData(currentFilesSet);
+        const prunedCallGraph = this.cache.pruneCallGraphData(currentFileKeySet);
         if (prunedCallGraph > 0 && this.config.verbose) {
           console.info(`[Indexer] Pruned ${prunedCallGraph} call-graph entries`);
         }
       }
 
       const filesToProcess = await this.preFilterFiles(files);
-      const filesToProcessSet = new Set(filesToProcess.map((entry) => entry.file));
-      const filesToProcessByFile = new Map(filesToProcess.map((entry) => [entry.file, entry]));
+      const filesToProcessKeys = new Set();
+      const filesToProcessByKey = new Map();
+      for (const entry of filesToProcess) {
+        const key = toFileKey(entry?.file);
+        if (!key) continue;
+        filesToProcessKeys.add(key);
+        if (!filesToProcessByKey.has(key)) {
+          filesToProcessByKey.set(key, entry);
+        }
+      }
 
       if (this.config.callGraphEnabled && this.cache.getVectorStore().length > 0) {
-        const cachedFiles = new Set(this.cache.getVectorStore().map((c) => c.file));
-        const callDataFiles = new Set(this.cache.getFileCallDataKeys());
+        const cachedFileKeys = new Set();
+        for (const chunk of this.cache.getVectorStore()) {
+          const key = toFileKey(chunk?.file);
+          if (key) cachedFileKeys.add(key);
+        }
+        const callDataFiles = new Set();
+        for (const file of this.cache.getFileCallDataKeys()) {
+          const key = toFileKey(file);
+          if (key) callDataFiles.add(key);
+        }
 
         const missingCallData = [];
-        for (const file of cachedFiles) {
-          if (!callDataFiles.has(file) && currentFilesSet.has(file)) {
-            missingCallData.push(file);
-            const existing = filesToProcessByFile.get(file);
-            if (existing) existing.force = true;
+        for (const key of cachedFileKeys) {
+          if (!callDataFiles.has(key) && currentFileKeySet.has(key)) {
+            const existing = filesToProcessByKey.get(key);
+            if (existing) {
+              existing.force = true;
+              continue;
+            }
+            const concretePath = currentFilePathByKey.get(key);
+            if (concretePath) {
+              missingCallData.push({ key, file: concretePath });
+            }
           }
         }
 
@@ -2285,7 +2329,7 @@ export class CodebaseIndexer {
           for (let i = 0; i < missingCallData.length; i += BATCH_SIZE) {
             const batch = missingCallData.slice(i, i + BATCH_SIZE);
             const results = await Promise.all(
-              batch.map(async (file) => {
+              batch.map(async ({ file }) => {
                 try {
                   const stats = await fs.stat(file);
                   if (!stats || typeof stats.isDirectory !== 'function') {
@@ -2304,9 +2348,15 @@ export class CodebaseIndexer {
 
             for (const result of results) {
               if (!result) continue;
-              if (!filesToProcessSet.has(result.file)) {
+              const key = toFileKey(result.file);
+              if (!key) continue;
+              if (!filesToProcessKeys.has(key)) {
                 filesToProcess.push(result);
-                filesToProcessSet.add(result.file);
+                filesToProcessKeys.add(key);
+                filesToProcessByKey.set(key, result);
+              } else {
+                const existing = filesToProcessByKey.get(key);
+                if (existing) existing.force = existing.force || result.force === true;
               }
             }
           }

package/lib/cache.js

@@ -9,6 +9,7 @@ import {
 } from './vector-store-binary.js';
 import { SqliteVectorStore } from './vector-store-sqlite.js';
 import { isNonProjectDirectory } from './config.js';
+import { normalizePathKey } from './path-utils.js';
 import {
   JSON_WORKER_THRESHOLD_BYTES,
   ANN_DIMENSION_SAMPLE_SIZE,
@@ -226,6 +227,26 @@ function serializeFileHashEntry(entry) {
   return normalizeFileHashEntry(entry);
 }
 
+function fileKey(filePath) {
+  return normalizePathKey(filePath);
+}
+
+function numericOrNegInfinity(value) {
+  return Number.isFinite(value) ? value : Number.NEGATIVE_INFINITY;
+}
+
+function shouldPreferFileHashEntry(candidate, current) {
+  const candidateMtime = numericOrNegInfinity(candidate?.mtimeMs);
+  const currentMtime = numericOrNegInfinity(current?.mtimeMs);
+  if (candidateMtime !== currentMtime) return candidateMtime > currentMtime;
+
+  const candidateSize = numericOrNegInfinity(candidate?.size);
+  const currentSize = numericOrNegInfinity(current?.size);
+  if (candidateSize !== currentSize) return candidateSize > currentSize;
+
+  return false;
+}
+
 function computeAnnCapacity(total, config) {
   const factor = typeof config.annCapacityFactor === 'number' ? config.annCapacityFactor : 1.2;
   const extra = Number.isInteger(config.annCapacityExtra) ? config.annCapacityExtra : 1024;
@@ -674,20 +695,29 @@ export class EmbeddingsCache {
 
       const hasCacheData = Array.isArray(cacheData);
       const hasHashData = hashData && typeof hashData === 'object';
+      let normalizedHashAliasCollapses = 0;
+      let normalizedCallGraphAliasCollapses = 0;
 
       if (hasCacheData) {
+        const isWin32 = process.platform === 'win32';
         const allowedExtensions = new Set(
-          (this.config.fileExtensions || []).map((ext) => `.${ext}`)
+          (this.config.fileExtensions || []).map((ext) => `.${String(ext).toLowerCase()}`)
+        );
+        const allowedFileNames = new Set(
+          (this.config.fileNames || []).map((name) =>
+            isWin32 ? String(name).toLowerCase() : String(name)
+          )
         );
-        const allowedFileNames = new Set(this.config.fileNames || []);
         const applyExtensionFilter = !this.binaryStore;
         const shouldKeepFile = (filePath) => {
-          const ext = path.extname(filePath);
+          const ext = path.extname(filePath).toLowerCase();
           if (allowedExtensions.has(ext)) return true;
-          return allowedFileNames.has(path.basename(filePath));
+          const baseName = path.basename(filePath);
+          const normalizedBaseName = isWin32 ? baseName.toLowerCase() : baseName;
+          return allowedFileNames.has(normalizedBaseName);
         };
 
-        const rawHashes = hasHashData ? new Map(Object.entries(hashData)) : new Map();
+        const rawHashes = hasHashData ? Object.entries(hashData) : [];
         this.vectorStore = [];
         this.fileHashes.clear();
 
@@ -707,8 +737,17 @@ export class EmbeddingsCache {
           for (const [file, entry] of rawHashes) {
             if (!applyExtensionFilter || shouldKeepFile(file)) {
               const normalized = normalizeFileHashEntry(entry);
-              if (normalized) {
-                this.fileHashes.set(file, normalized);
+              const key = fileKey(file);
+              if (normalized && key) {
+                const existing = this.fileHashes.get(key);
+                if (existing) {
+                  normalizedHashAliasCollapses += 1;
+                  if (shouldPreferFileHashEntry(normalized, existing)) {
+                    this.fileHashes.set(key, normalized);
+                  }
+                } else {
+                  this.fileHashes.set(key, normalized);
+                }
               }
             }
           }
@@ -739,11 +778,31 @@ export class EmbeddingsCache {
       try {
         const callGraphData = await fs.readFile(callGraphFile, 'utf8');
         const parsed = JSON.parse(callGraphData);
-        this.fileCallData = new Map(Object.entries(parsed));
+        const normalizedCallData = new Map();
+        if (parsed && typeof parsed === 'object') {
+          for (const [file, data] of Object.entries(parsed)) {
+            const key = fileKey(file);
+            if (!key) continue;
+            if (normalizedCallData.has(key)) {
+              normalizedCallGraphAliasCollapses += 1;
+            }
+            normalizedCallData.set(key, data);
+          }
+        }
+        this.fileCallData = normalizedCallData;
         if (this.config.verbose) {
           console.info(`[Cache] Loaded call-graph data for ${this.fileCallData.size} files`);
         }
       } catch {}
+
+      if (
+        this.config.verbose &&
+        (normalizedHashAliasCollapses > 0 || normalizedCallGraphAliasCollapses > 0)
+      ) {
+        console.info(
+          `[Cache] Normalized path-key aliases on load (file-hashes=${normalizedHashAliasCollapses}, call-graph=${normalizedCallGraphAliasCollapses})`
+        );
+      }
     } catch (error) {
       console.warn('[Cache] Failed to load cache:', error.message);
       this.clearInMemoryState();
@@ -943,8 +1002,9 @@ export class EmbeddingsCache {
       const hashEntries = {};
       for (const [file, entry] of this.fileHashes) {
         const serialized = serializeFileHashEntry(entry);
-        if (serialized) {
-          hashEntries[file] = serialized;
+        const key = fileKey(file);
+        if (serialized && key) {
+          hashEntries[key] = serialized;
         }
       }
 
@@ -955,9 +1015,15 @@ export class EmbeddingsCache {
 
       const callGraphFile = path.join(this.config.cacheDirectory, CALL_GRAPH_FILE);
       if (this.fileCallData.size > 0) {
+        const callGraphEntries = {};
+        for (const [file, data] of this.fileCallData) {
+          const key = fileKey(file);
+          if (!key) continue;
+          callGraphEntries[key] = data;
+        }
         await fs.writeFile(
           callGraphFile,
-          JSON.stringify(Object.fromEntries(this.fileCallData), null, 2)
+          JSON.stringify(callGraphEntries, null, 2)
         );
       } else {
         await fs.rm(callGraphFile, { force: true });
@@ -1071,7 +1137,9 @@ export class EmbeddingsCache {
   }
 
   getFileHash(file) {
-    const entry = this.fileHashes.get(file);
+    const key = fileKey(file);
+    if (!key) return undefined;
+    const entry = this.fileHashes.get(key);
     if (typeof entry === 'string') return entry;
     return entry?.hash;
   }
@@ -1095,23 +1163,31 @@ export class EmbeddingsCache {
     if (!iterator) return;
     for (const [file, entry] of iterator) {
       const normalized = normalizeFileHashEntry(entry);
-      if (normalized) {
-        this.fileHashes.set(file, normalized);
+      const key = fileKey(file);
+      if (normalized && key) {
+        const existing = this.fileHashes.get(key);
+        if (!existing || shouldPreferFileHashEntry(normalized, existing)) {
+          this.fileHashes.set(key, normalized);
+        }
       }
     }
   }
 
   setFileHash(file, hash, meta = null) {
+    const key = fileKey(file);
+    if (!key) return;
     const entry = { hash };
     if (meta && typeof meta === 'object') {
       if (Number.isFinite(meta.mtimeMs)) entry.mtimeMs = meta.mtimeMs;
       if (Number.isFinite(meta.size)) entry.size = meta.size;
     }
-    this.fileHashes.set(file, entry);
+    this.fileHashes.set(key, entry);
   }
 
   getFileMeta(file) {
-    const entry = this.fileHashes.get(file);
+    const key = fileKey(file);
+    if (!key) return null;
+    const entry = this.fileHashes.get(key);
     if (!entry) return null;
     if (typeof entry === 'string') return { hash: entry };
     return entry;
@@ -1194,16 +1270,20 @@ export class EmbeddingsCache {
   }
 
   deleteFileHash(file) {
-    this.fileHashes.delete(file);
+    const key = fileKey(file);
+    if (!key) return;
+    this.fileHashes.delete(key);
   }
 
   async removeFileFromStore(file) {
     if (!Array.isArray(this.vectorStore)) return;
+    const targetKey = fileKey(file);
+    if (!targetKey) return;
 
     let w = 0;
     for (let r = 0; r < this.vectorStore.length; r++) {
       const chunk = this.vectorStore[r];
-      if (chunk.file !== file) {
+      if (fileKey(chunk.file) !== targetKey) {
         chunk._index = w;
         this.vectorStore[w++] = chunk;
       }
@@ -1213,7 +1293,7 @@ export class EmbeddingsCache {
     this.invalidateAnnIndex();
     this.removeFileCallData(file);
 
-    this.fileHashes.delete(file);
+    this.deleteFileHash(file);
   }
 
   addToStore(chunk) {
@@ -1627,10 +1707,15 @@ export class EmbeddingsCache {
 
   pruneCallGraphData(validFiles) {
     if (!validFiles || this.fileCallData.size === 0) return 0;
+    const validKeys = new Set();
+    for (const file of validFiles) {
+      const key = fileKey(file);
+      if (key) validKeys.add(key);
+    }
 
     let pruned = 0;
     for (const file of Array.from(this.fileCallData.keys())) {
-      if (!validFiles.has(file)) {
+      if (!validKeys.has(fileKey(file))) {
         this.fileCallData.delete(file);
         pruned++;
       }
@@ -1641,11 +1726,15 @@ export class EmbeddingsCache {
   }
 
   getFileCallData(file) {
-    return this.fileCallData.get(file);
+    const key = fileKey(file);
+    if (!key) return undefined;
+    return this.fileCallData.get(key);
   }
 
   hasFileCallData(file) {
-    return this.fileCallData.has(file);
+    const key = fileKey(file);
+    if (!key) return false;
+    return this.fileCallData.has(key);
   }
 
   getFileCallDataKeys() {
@@ -1657,21 +1746,21 @@ export class EmbeddingsCache {
   }
 
   setFileCallData(file, data) {
-    this.fileCallData.set(file, data);
+    const key = fileKey(file);
+    if (!key) return;
+    this.fileCallData.set(key, data);
     this.callGraph = null;
   }
 
   setFileCallDataEntries(entries) {
-    if (entries instanceof Map) {
-      this.fileCallData = entries;
-    } else {
-      this.fileCallData.clear();
-      if (entries && typeof entries === 'object') {
-        for (const [file, data] of Object.entries(entries)) {
-          this.fileCallData.set(file, data);
-        }
-      }
-    }
+    const normalized = new Map();
+    const iterator = entries instanceof Map ? entries.entries() : Object.entries(entries || {});
+    for (const [file, data] of iterator) {
+      const key = fileKey(file);
+      if (!key) continue;
+      normalized.set(key, data);
+    }
+    this.fileCallData = normalized;
     this.callGraph = null;
   }
 
@@ -1681,7 +1770,9 @@ export class EmbeddingsCache {
   }
 
   removeFileCallData(file) {
-    this.fileCallData.delete(file);
+    const key = fileKey(file);
+    if (!key) return;
+    this.fileCallData.delete(key);
     this.callGraph = null;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softerist/heuristic-mcp",
-  "version": "3.2.12",
+  "version": "3.2.13",
   "description": "An enhanced MCP server providing intelligent semantic code search with find-similar-code, recency ranking, and improved chunking. Fork of smart-coding-mcp.",
   "type": "module",
   "main": "index.js",