@softerist/heuristic-mcp 3.0.17 → 3.1.0

package/lib/vector-store-sqlite.js

@@ -1,9 +1,4 @@
-/**
- * SQLite Vector Store
- *
- * An alternative to binary/JSON vector stores using SQLite for persistence.
- * Provides ACID transactions, simpler concurrent access, and query flexibility.
- */
+
 
 import Database from 'better-sqlite3';
 import path from 'path';
@@ -42,7 +37,7 @@ async function bestEffortUnlink(targetPath) {
   try {
     await retryUnlink(targetPath);
   } catch {
-    // ignore cleanup failures (e.g. antivirus locks on Windows)
+    
   }
 }
 
@@ -63,17 +58,14 @@ async function retryRename(fromPath, toPath, retries = SQLITE_FILE_RETRY_COUNT)
   }
 }
 
-/**
- * SQLite-backed vector store for embeddings cache.
- * Follows the same API pattern as BinaryVectorStore for compatibility.
- */
+
 export class SqliteVectorStore {
   constructor({ db, dim, count }) {
     this.db = db;
     this.dim = dim;
     this.count = count;
 
-    // Prepared statements for fast access
+    
     this._stmtGetChunk = db.prepare(`
       SELECT file, startLine, endLine, content, vector FROM chunks WHERE id = ?
     `);
@@ -83,9 +75,7 @@ export class SqliteVectorStore {
     this._stmtGetChunksForFile = db.prepare(`SELECT id FROM chunks WHERE file = ?`);
   }
 
-  /**
-   * Close the database connection
-   */
+  
   close() {
     if (this._closed) return;
     this._closed = true;
@@ -94,44 +84,40 @@ export class SqliteVectorStore {
         this.db.close();
       }
     } catch {
-      // Ignore close errors (e.g., already closed, concurrent close)
+      
     }
   }
 
-  /**
-   * Get the path to the SQLite file
-   */
+  
   static getPath(cacheDir) {
     return path.join(cacheDir, SQLITE_FILE);
   }
 
-  /**
-   * Load an existing SQLite vector store from disk
-   */
+  
   static async load(cacheDir, _options = {}) {
     const dbPath = SqliteVectorStore.getPath(cacheDir);
 
     try {
       await fs.access(dbPath);
     } catch {
-      return null; // File doesn't exist
+      return null; 
     }
 
     let db;
     try {
       db = new Database(dbPath, { readonly: true });
     } catch (err) {
-      // Database file may be corrupted or locked
+      
       console.warn(`[SQLite] Failed to open database: ${err.message}`);
       return null;
     }
 
-    // Read metadata
+    
     let meta;
     try {
       meta = db.prepare(`SELECT key, value FROM metadata`).all();
     } catch (err) {
-      // Database schema may be corrupted
+      
       console.warn(`[SQLite] Failed to read metadata: ${err.message}`);
       db.close();
       return null;
@@ -141,7 +127,7 @@ export class SqliteVectorStore {
     const version = parseInt(metaMap.get('version') || '0', 10);
     if (version !== STORE_VERSION) {
       db.close();
-      return null; // Version mismatch, need reindex
+      return null; 
     }
 
     const dim = parseInt(metaMap.get('dim') || '0', 10);
@@ -150,16 +136,12 @@ export class SqliteVectorStore {
     return new SqliteVectorStore({ db, dim, count });
   }
 
-  /**
-   * Get the number of chunks in the store
-   */
+  
   length() {
     return this.count;
   }
 
-  /**
-   * Get a chunk record by index (0-based)
-   */
+  
   getRecord(index) {
     if (index < 0 || index >= this.count) return null;
 
@@ -173,27 +155,22 @@ export class SqliteVectorStore {
     };
   }
 
-  /**
-   * Get a vector by index (0-based)
-   * Returns Float32Array
-   */
+  
   getVector(index) {
     if (index < 0 || index >= this.count) return null;
 
     const row = this._stmtGetVector.get(index);
     if (!row || !row.vector) return null;
 
-    // Vector is stored as a Buffer of Float32 values
+    
     const expectedBytes = this.dim * Float32Array.BYTES_PER_ELEMENT;
     if (row.vector.byteLength < expectedBytes) return null;
-    // Copy the buffer to avoid issues with SQLite reusing internal buffers
+    
     const view = new Float32Array(row.vector.buffer, row.vector.byteOffset, this.dim);
     return new Float32Array(view);
   }
 
-  /**
-   * Get content by index (0-based)
-   */
+  
   getContent(index) {
     if (index < 0 || index >= this.count) return null;
 
@@ -201,9 +178,7 @@ export class SqliteVectorStore {
     return row ? row.content : null;
   }
 
-  /**
-   * Get all chunks as lightweight views (for search iteration)
-   */
+  
   toChunkViews({ includeContent = false, includeVector = true } = {}) {
     const views = [];
     const stmt = this.db.prepare(`
@@ -227,7 +202,7 @@ export class SqliteVectorStore {
       if (includeVector && row.vector) {
         const expectedBytes = this.dim * Float32Array.BYTES_PER_ELEMENT;
         if (row.vector.byteLength >= expectedBytes) {
-          // Copy the buffer to avoid issues with SQLite reusing internal buffers
+          
           const bufferView = new Float32Array(
             row.vector.buffer,
             row.vector.byteOffset,
@@ -243,9 +218,7 @@ export class SqliteVectorStore {
     return views;
   }
 
-  /**
-   * Get all unique file paths and their chunk indices
-   */
+  
   getAllFileIndices() {
     const fileIndices = new Map();
 
@@ -258,12 +231,7 @@ export class SqliteVectorStore {
     return fileIndices;
   }
 
-  /**
-   * Write chunks to a new SQLite database
-   * @param {string} cacheDir - Directory to write the database
-   * @param {Array} chunks - Array of chunk objects with vector, file, startLine, endLine, content
-   * @param {Object} options - { getContent, preRename }
-   */
+  
   static async write(cacheDir, chunks, { getContent, getVector, preRename } = {}) {
     if (!chunks || chunks.length === 0) {
       return null;
@@ -331,14 +299,14 @@ export class SqliteVectorStore {
         ? (await resolveVector(denseChunks[0], denseSourceIndices[0])).length
         : 0;
 
-    // Create new database
+    
     const db = new Database(writePath);
 
-    // Enable WAL mode for better concurrent read performance (use DELETE on Windows to reduce locks)
+    
     db.pragma(`journal_mode = ${useTemp ? 'WAL' : 'DELETE'}`);
     db.pragma('synchronous = NORMAL');
 
-    // Create tables
+    
     if (!useTemp) {
       db.exec(`
         DROP TABLE IF EXISTS metadata;
@@ -364,14 +332,14 @@ export class SqliteVectorStore {
       CREATE INDEX idx_chunks_file ON chunks(file);
     `);
 
-    // Insert metadata
+    
     const insertMeta = db.prepare(`INSERT INTO metadata (key, value) VALUES (?, ?)`);
     insertMeta.run('version', String(STORE_VERSION));
     insertMeta.run('dim', String(dim));
     insertMeta.run('count', String(denseChunks.length));
     insertMeta.run('createdAt', new Date().toISOString());
 
-    // Insert chunks in a transaction for speed without pre-materializing all vectors/content.
+    
     const insertChunk = db.prepare(`
       INSERT INTO chunks (id, file, startLine, endLine, content, vector)
       VALUES (?, ?, ?, ?, ?, ?)
@@ -405,31 +373,31 @@ export class SqliteVectorStore {
       try {
         db.exec('ROLLBACK');
       } catch {
-        // ignore rollback errors
+        
       }
       throw error;
     }
 
-    // Optimize the database
+    
     db.exec('ANALYZE');
     db.close();
     if (process.platform === 'win32') {
-      // Windows needs more time to release file locks after WAL mode close
+      
       await new Promise((resolve) => setTimeout(resolve, 200));
     }
 
-    // Call preRename hook if provided (for atomicity coordination)
+    
     if (typeof preRename === 'function') {
       await preRename();
     }
 
-    // Atomic rename (temp path only)
+    
     if (useTemp) {
       await retryUnlink(dbPath);
       await retryRename(tempPath, dbPath);
     }
 
-    // Clean up WAL files from temp
+    
     if (useTemp) {
       await bestEffortUnlink(tempPath + '-wal');
       await bestEffortUnlink(tempPath + '-shm');
@@ -438,7 +406,7 @@ export class SqliteVectorStore {
       await bestEffortUnlink(dbPath + '-shm');
     }
 
-    // Return a new instance opened readonly
+    
     return SqliteVectorStore.load(cacheDir);
   }
 }

package/lib/workspace-cache-key.js

@@ -0,0 +1,36 @@
+import crypto from 'crypto';
+import path from 'path';
+
+export function normalizeWorkspacePathForCacheKey(workspacePath) {
+  const resolved = path.resolve(workspacePath);
+  if (process.platform !== 'win32') {
+    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.
+  if (/^[A-Za-z]:/.test(resolved)) {
+    return `${resolved[0].toLowerCase()}${resolved.slice(1)}`;
+  }
+
+  return resolved;
+}
+
+export function getWorkspaceCacheKey(workspacePath) {
+  const normalized = normalizeWorkspacePathForCacheKey(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);
+}
+
+export function getWorkspaceCachePath(workspacePath, globalCacheRoot) {
+  return path.join(globalCacheRoot, 'heuristic-mcp', getWorkspaceCacheKey(workspacePath));
+}
+
+export function getLegacyWorkspaceCachePath(workspacePath, globalCacheRoot) {
+  return path.join(globalCacheRoot, 'heuristic-mcp', getLegacyWorkspaceCacheKey(workspacePath));
+}

package/lib/workspace-env.js

@@ -1,10 +1,26 @@
-import {
-  DYNAMIC_WORKSPACE_ENV_PREFIX,
-  WORKSPACE_ENV_KEY_PATTERN,
-  WORKSPACE_ENV_VARS,
-} from './constants.js';
-
-export function scoreWorkspaceEnvKey(key) {
+import {
+  DYNAMIC_WORKSPACE_ENV_PREFIXES,
+  WORKSPACE_ENV_GENERIC_DISCOVERY_PATTERN,
+  WORKSPACE_ENV_KEY_PATTERN,
+  WORKSPACE_ENV_VARS,
+} from './constants.js';
+
+const EXCLUDED_DYNAMIC_WORKSPACE_ENV_KEYS = new Set([
+  'ANTIGRAVITY_EDITOR_APP_ROOT',
+]);
+
+function isTruthy(value) {
+  return /^(1|true|yes|on)$/i.test(String(value || '').trim());
+}
+
+export function isDynamicWorkspaceEnvEnabled(env = process.env, options = {}) {
+  if (typeof options.enableDynamic === 'boolean') {
+    return options.enableDynamic;
+  }
+  return isTruthy(env.HEURISTIC_MCP_ENABLE_DYNAMIC_WORKSPACE_ENV);
+}
+
+export function scoreWorkspaceEnvKey(key) {
   const upper = String(key || '').toUpperCase();
   let score = 0;
   if (upper.includes('WORKSPACE')) score += 8;
@@ -15,14 +31,39 @@ export function scoreWorkspaceEnvKey(key) {
   return score;
 }
 
-export function getDynamicWorkspaceEnvKeys(env = process.env) {
-  return Object.keys(env)
-    .filter((key) => key.startsWith(DYNAMIC_WORKSPACE_ENV_PREFIX))
-    .filter((key) => WORKSPACE_ENV_KEY_PATTERN.test(key))
-    .filter((key) => !WORKSPACE_ENV_VARS.includes(key))
+function hasDynamicWorkspacePrefix(key) {
+  return DYNAMIC_WORKSPACE_ENV_PREFIXES.some((prefix) => key.startsWith(prefix));
+}
+
+export function getDynamicWorkspaceEnvKeys(env = process.env, options = {}) {
+  if (!isDynamicWorkspaceEnvEnabled(env, options)) {
+    return [];
+  }
+
+  return Object.keys(env)
+    .filter((key) => !EXCLUDED_DYNAMIC_WORKSPACE_ENV_KEYS.has(String(key || '').toUpperCase()))
+    .filter((key) => !WORKSPACE_ENV_VARS.includes(key))
+    .filter((key) => {
+      const providerSpecific = hasDynamicWorkspacePrefix(key) && WORKSPACE_ENV_KEY_PATTERN.test(key);
+      const genericWorkspace = WORKSPACE_ENV_GENERIC_DISCOVERY_PATTERN.test(key);
+      return providerSpecific || genericWorkspace;
+    })
     .sort((a, b) => scoreWorkspaceEnvKey(b) - scoreWorkspaceEnvKey(a));
 }
 
-export function getWorkspaceEnvKeys(env = process.env) {
-  return [...WORKSPACE_ENV_VARS, ...getDynamicWorkspaceEnvKeys(env)];
+export function getWorkspaceEnvKeys(env = process.env, options = {}) {
+  return [...WORKSPACE_ENV_VARS, ...getDynamicWorkspaceEnvKeys(env, options)];
+}
+
+
+export function getWorkspaceEnvDiagnosticKeys(env = process.env, options = {}) {
+  const prioritized = getWorkspaceEnvKeys(env, options);
+  const prioritizedSet = new Set(prioritized);
+
+  const extraKeys = Object.keys(env)
+    .filter((key) => !prioritizedSet.has(key))
+    .filter((key) => WORKSPACE_ENV_KEY_PATTERN.test(key))
+    .sort((a, b) => scoreWorkspaceEnvKey(b) - scoreWorkspaceEnvKey(a));
+
+  return [...prioritized, ...extraKeys];
 }

package/package.json

@@ -1,86 +1,86 @@
-{
-  "name": "@softerist/heuristic-mcp",
-  "version": "3.0.17",
-  "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",
-  "bin": {
-    "heuristic-mcp": "index.js"
-  },
-  "files": [
-    "index.js",
-    "config.jsonc",
-    "mcp_config.json",
-    "search-configs.js",
-    "lib/",
-    "features/",
-    "scripts/",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "start": "node --expose-gc index.js",
-    "dev": "node --expose-gc --watch index.js",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "clean": "node scripts/clear-cache.js",
-    "lint": "eslint .",
-    "format": "prettier --write .",
-    "postinstall": "node scripts/postinstall.js && node scripts/download-model.js"
-  },
-  "keywords": [
-    "mcp",
-    "semantic-search",
-    "code-search",
-    "embeddings",
-    "ai",
-    "model-context-protocol",
-    "hybrid-search",
-    "code-intelligence",
-    "cursor",
-    "vscode",
-    "claude",
-    "codex",
-    "openai",
-    "gemini",
-    "anthropic",
-    "antigravity",
-    "heuristic"
-  ],
-  "author": {
-    "name": "Softerist",
-    "url": "https://github.com/softerist"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/softerist/heuristic-mcp.git"
-  },
-  "homepage": "https://github.com/softerist/heuristic-mcp#readme",
-  "license": "MIT",
-  "dependencies": {
-    "@huggingface/transformers": "^3.8.1",
-    "@modelcontextprotocol/sdk": "^1.0.4",
-    "better-sqlite3": "^12.6.2",
-    "chokidar": "^3.5.3",
-    "fdir": "^6.5.0",
-    "ignore": "^7.0.5",
-    "punycode": "^2.3.1"
-  },
-  "optionalDependencies": {
-    "hnswlib-node": "^3.0.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "overrides": {
-    "punycode": "^2.3.1"
-  },
-  "devDependencies": {
-    "@eslint/js": "^9.39.2",
-    "@vitest/coverage-v8": "^4.0.18",
-    "eslint": "^9.39.2",
-    "globals": "^17.1.0",
-    "prettier": "^3.8.1",
-    "vitest": "^4.0.16"
-  }
-}
+{
+  "name": "@softerist/heuristic-mcp",
+  "version": "3.1.0",
+  "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",
+  "bin": {
+    "heuristic-mcp": "index.js"
+  },
+  "files": [
+    "index.js",
+    "config.jsonc",
+    "mcp_config.json",
+    "search-configs.js",
+    "lib/",
+    "features/",
+    "scripts/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node --expose-gc index.js",
+    "dev": "node --expose-gc --watch index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "node scripts/clear-cache.js",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "postinstall": "node scripts/postinstall.js && node scripts/download-model.js"
+  },
+  "keywords": [
+    "mcp",
+    "semantic-search",
+    "code-search",
+    "embeddings",
+    "ai",
+    "model-context-protocol",
+    "hybrid-search",
+    "code-intelligence",
+    "cursor",
+    "vscode",
+    "claude",
+    "codex",
+    "openai",
+    "gemini",
+    "anthropic",
+    "antigravity",
+    "heuristic"
+  ],
+  "author": {
+    "name": "Softerist",
+    "url": "https://github.com/softerist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/softerist/heuristic-mcp.git"
+  },
+  "homepage": "https://github.com/softerist/heuristic-mcp#readme",
+  "license": "MIT",
+  "dependencies": {
+    "@huggingface/transformers": "^3.8.1",
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "better-sqlite3": "^12.6.2",
+    "chokidar": "^3.5.3",
+    "fdir": "^6.5.0",
+    "ignore": "^7.0.5",
+    "punycode": "^2.3.1"
+  },
+  "optionalDependencies": {
+    "hnswlib-node": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "overrides": {
+    "punycode": "^2.3.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^9.39.2",
+    "globals": "^17.1.0",
+    "prettier": "^3.8.1",
+    "vitest": "^4.0.16"
+  }
+}