@softerist/heuristic-mcp 3.2.7 → 3.2.9

package/lib/config.js

@@ -4,7 +4,7 @@ import os from 'os';
 import { fileURLToPath } from 'url';
 import { ProjectDetector } from './project-detector.js';
 import { parseJsonc } from './settings-editor.js';
-import { getLegacyWorkspaceCachePath, getWorkspaceCachePath } from './workspace-cache-key.js';
+import { getWorkspaceCachePathCandidates } from './workspace-cache-key.js';
 import {
   EMBEDDING_PROCESS_DEFAULT_GC_MAX_REQUESTS_WITHOUT_COLLECTION,
   EMBEDDING_PROCESS_DEFAULT_GC_MIN_INTERVAL_MS,
@@ -37,6 +37,7 @@ const DEFAULT_INDEXING_CONFIG = {
   maxResults: 5, // Maximum number of semantic search results to return
   watchFiles: true, // Enable file system watcher to re-index changed files in real-time
   indexCheckpointIntervalMs: 5000, // Periodic cache checkpoint during full indexing (0 disables)
+  shutdownIndexWaitMs: 3000, // Max wait during shutdown for cooperative index checkpointing
 };
 
 const DEFAULT_LOGGING_CONFIG = {
@@ -389,6 +390,7 @@ const DEFAULT_CONFIG = {
   },
   watchFiles: DEFAULT_INDEXING_CONFIG.watchFiles,
   indexCheckpointIntervalMs: DEFAULT_INDEXING_CONFIG.indexCheckpointIntervalMs,
+  shutdownIndexWaitMs: DEFAULT_INDEXING_CONFIG.shutdownIndexWaitMs,
   verbose: DEFAULT_LOGGING_CONFIG.verbose,
   memoryLogIntervalMs: DEFAULT_LOGGING_CONFIG.memoryLogIntervalMs,
   saveReaderWaitTimeoutMs: DEFAULT_CACHE_CONFIG.saveReaderWaitTimeoutMs,
@@ -880,23 +882,36 @@ export async function loadConfig(workspaceDir = null) {
         : path.join(baseDir, userConfig.cacheDirectory);
     } else {
       // Use global cache directory to prevent cluttering project root.
-      // Workspace path is normalized for hashing so Windows drive-letter case
-      // differences (e.g. F:\ vs f:\) resolve to the same cache id.
+      // Workspace path is normalized for hashing so Windows case variations map
+      // to one canonical cache key while preserving fallback compatibility.
       const globalCacheRoot = getGlobalCacheDir();
-      const normalizedCachePath = getWorkspaceCachePath(config.searchDirectory, globalCacheRoot);
-      const legacyCachePath = getLegacyWorkspaceCachePath(config.searchDirectory, globalCacheRoot);
-
-      if (
-        normalizedCachePath !== legacyCachePath &&
-        !(await pathExists(normalizedCachePath)) &&
-        (await pathExists(legacyCachePath))
-      ) {
-        config.cacheDirectory = legacyCachePath;
-        console.info(
-          `[Config] Using legacy cache path for compatibility: ${path.basename(legacyCachePath)}`
-        );
-      } else {
-        config.cacheDirectory = normalizedCachePath;
+      const cachePaths = getWorkspaceCachePathCandidates(config.searchDirectory, globalCacheRoot);
+      let cacheResolutionMode = 'canonical';
+
+      config.cacheDirectory = cachePaths.canonical;
+      if (!(await pathExists(cachePaths.canonical))) {
+        if (
+          cachePaths.compatDriveCase !== cachePaths.canonical &&
+          (await pathExists(cachePaths.compatDriveCase))
+        ) {
+          config.cacheDirectory = cachePaths.compatDriveCase;
+          cacheResolutionMode = 'compat-drivecase';
+          console.info(
+            `[Config] Using drive-case compatible cache path: ${path.basename(cachePaths.compatDriveCase)}`
+          );
+        } else if (
+          cachePaths.legacy !== cachePaths.canonical &&
+          (await pathExists(cachePaths.legacy))
+        ) {
+          config.cacheDirectory = cachePaths.legacy;
+          cacheResolutionMode = 'legacy';
+          console.info(
+            `[Config] Using legacy cache path for compatibility: ${path.basename(cachePaths.legacy)}`
+          );
+        }
+      }
+      if (config.verbose || cacheResolutionMode !== 'canonical') {
+        console.info(`[Config] Cache resolution mode: ${cacheResolutionMode}`);
       }
 
       // Support legacy .smart-coding-cache if it already exists in the project root
@@ -1085,6 +1100,17 @@ export async function loadConfig(workspaceDir = null) {
     }
   }
 
+  if (process.env.SMART_CODING_SHUTDOWN_INDEX_WAIT_MS !== undefined) {
+    const value = parseInt(process.env.SMART_CODING_SHUTDOWN_INDEX_WAIT_MS, 10);
+    if (!isNaN(value) && value >= 0) {
+      config.shutdownIndexWaitMs = value;
+    } else {
+      console.warn(
+        `[Config] Invalid SMART_CODING_SHUTDOWN_INDEX_WAIT_MS: ${process.env.SMART_CODING_SHUTDOWN_INDEX_WAIT_MS}, using default`
+      );
+    }
+  }
+
   if (process.env.SMART_CODING_SEMANTIC_WEIGHT !== undefined) {
     const value = parseFloat(process.env.SMART_CODING_SEMANTIC_WEIGHT);
     if (!isNaN(value) && value >= 0 && value <= 1) {

package/lib/workspace-cache-key.js

@@ -7,13 +7,22 @@ export function normalizeWorkspacePathForCacheKey(workspacePath) {
     return resolved;
   }
 
-  // Windows paths are case-insensitive for drive letters; normalize only the
-  // drive prefix so F:\repo and f:\repo map to the same cache key while
-  // preserving existing segment casing for backward compatibility.
+  // Windows paths are case-insensitive. Normalize the whole path so casing
+  // changes (including folder segments) map to one cache key.
+  return resolved.toLowerCase();
+}
+
+export function normalizeWorkspacePathForCompatDriveLetterKey(workspacePath) {
+  const resolved = path.resolve(workspacePath);
+  if (process.platform !== 'win32') {
+    return resolved;
+  }
+
+  // Compatibility behavior used by older versions: normalize drive letter
+  // casing only.
   if (/^[A-Za-z]:/.test(resolved)) {
     return `${resolved[0].toLowerCase()}${resolved.slice(1)}`;
   }
-
   return resolved;
 }
 
@@ -22,6 +31,11 @@ export function getWorkspaceCacheKey(workspacePath) {
   return crypto.createHash('md5').update(normalized).digest('hex').slice(0, 12);
 }
 
+export function getDriveLetterCompatWorkspaceCacheKey(workspacePath) {
+  const normalized = normalizeWorkspacePathForCompatDriveLetterKey(workspacePath);
+  return crypto.createHash('md5').update(normalized).digest('hex').slice(0, 12);
+}
+
 export function getLegacyWorkspaceCacheKey(workspacePath) {
   const resolved = path.resolve(workspacePath);
   return crypto.createHash('md5').update(resolved).digest('hex').slice(0, 12);
@@ -31,6 +45,22 @@ export function getWorkspaceCachePath(workspacePath, globalCacheRoot) {
   return path.join(globalCacheRoot, 'heuristic-mcp', getWorkspaceCacheKey(workspacePath));
 }
 
+export function getDriveLetterCompatWorkspaceCachePath(workspacePath, globalCacheRoot) {
+  return path.join(
+    globalCacheRoot,
+    'heuristic-mcp',
+    getDriveLetterCompatWorkspaceCacheKey(workspacePath)
+  );
+}
+
 export function getLegacyWorkspaceCachePath(workspacePath, globalCacheRoot) {
   return path.join(globalCacheRoot, 'heuristic-mcp', getLegacyWorkspaceCacheKey(workspacePath));
 }
+
+export function getWorkspaceCachePathCandidates(workspacePath, globalCacheRoot) {
+  return {
+    canonical: getWorkspaceCachePath(workspacePath, globalCacheRoot),
+    compatDriveCase: getDriveLetterCompatWorkspaceCachePath(workspacePath, globalCacheRoot),
+    legacy: getLegacyWorkspaceCachePath(workspacePath, globalCacheRoot),
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softerist/heuristic-mcp",
-  "version": "3.2.7",
+  "version": "3.2.9",
   "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",

package/search-configs.js

@@ -1,36 +0,0 @@
-import { loadConfig } from './lib/config.js';
-import { EmbeddingsCache } from './lib/cache.js';
-import { HybridSearch } from './features/hybrid-search.js';
-import { pipeline, env } from '@huggingface/transformers';
-
-// Force same thread config as server
-if (env?.backends?.onnx) {
-  env.backends.onnx.numThreads = 2;
-  if (env.backends.onnx.wasm) {
-    env.backends.onnx.wasm.numThreads = 2;
-  }
-}
-
-async function searchConfigs() {
-  const config = await loadConfig(process.cwd());
-  const cache = new EmbeddingsCache(config);
-  await cache.load();
-
-  const embedder = async (text) => {
-    const pipe = await pipeline('feature-extraction', config.embeddingModel, {
-      session_options: { numThreads: 2 },
-      dtype: 'fp32',
-    });
-    return pipe(text, { pooling: 'mean', normalize: true });
-  };
-
-  const searcher = new HybridSearch(embedder, cache, config);
-  const { results } = await searcher.search('configuration files, config, settings');
-
-  console.info(JSON.stringify(results, null, 2));
-}
-
-searchConfigs().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});