@softerist/heuristic-mcp 2.0.0 → 2.1.1

package/lib/call-graph.js

@@ -0,0 +1,281 @@
+/**
+ * Call Graph Extractor
+ *
+ * Lightweight regex-based extraction of function definitions and calls.
+ * Works across multiple languages without external dependencies.
+ */
+
+import path from "path";
+
+// Language-specific patterns for function/method definitions
+const DEFINITION_PATTERNS = {
+  javascript: [
+    // function declarations: function name() or async function name()
+    /(?:async\s+)?function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g,
+    // arrow functions: const name = () => or const name = async () =>
+    /(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/g,
+    // class declarations
+    /class\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g,
+    // method definitions: name() { or async name() {
+    /^\s*(?:async\s+)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\([^)]*\)\s*\{/gm,
+    // object method shorthand: name() { inside object
+    /([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\([^)]*\)\s*\{/g
+  ],
+  python: [
+    // def name():
+    /def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/g,
+    // class Name:
+    /class\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*[:(]/g
+  ],
+  go: [
+    // func name() or func (r Receiver) name()
+    /func\s+(?:\([^)]*\)\s+)?([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/g
+  ],
+  rust: [
+    // fn name()
+    /fn\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*[<(]/g,
+    // impl Name
+    /impl(?:\s*<[^>]*>)?\s+([a-zA-Z_][a-zA-Z0-9_]*)/g
+  ],
+  java: [
+    // public void name() or private static String name()
+    /(?:public|private|protected)?\s*(?:static)?\s*(?:\w+)\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/g,
+    // class Name
+    /class\s+([a-zA-Z_][a-zA-Z0-9_]*)/g
+  ]
+};
+
+// Pattern for function calls (language-agnostic, catches most cases)
+const CALL_PATTERN = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g;
+
+// Common built-ins to exclude from call detection (all lowercase for case-insensitive matching)
+const BUILTIN_EXCLUSIONS = new Set([
+  // JavaScript
+  "if", "for", "while", "switch", "catch", "function", "async", "await",
+  "return", "throw", "new", "typeof", "instanceof", "delete", "void",
+  "console", "require", "import", "export", "super", "this",
+  // Common functions that aren't meaningful for call graphs
+  "parseint", "parsefloat", "string", "number", "boolean", "array", "object",
+  "map", "set", "promise", "error", "json", "math", "date", "regexp",
+  // Python
+  "def", "class", "print", "len", "range", "str", "int", "float", "list", "dict",
+  "tuple", "bool", "type", "isinstance", "hasattr", "getattr", "setattr",
+  // Go
+  "func", "make", "append", "cap", "panic", "recover",
+  // Control flow that looks like function calls
+  "else", "try", "finally", "with", "assert", "raise", "yield"
+]);
+
+/**
+ * Detect language from file extension
+ */
+function detectLanguage(file) {
+  const ext = path.extname(file).toLowerCase();
+  const langMap = {
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".ts": "javascript",
+    ".tsx": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".py": "python",
+    ".pyw": "python",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".kt": "java",
+    ".scala": "java"
+  };
+  return langMap[ext] || "javascript"; // Default to JS patterns
+}
+
+/**
+ * Extract function/class definitions from content
+ */
+export function extractDefinitions(content, file) {
+  const language = detectLanguage(file);
+  const patterns = DEFINITION_PATTERNS[language] || DEFINITION_PATTERNS.javascript;
+  const definitions = new Set();
+
+  for (const pattern of patterns) {
+    // Reset regex state
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const name = match[1];
+      if (name && name.length > 1 && !BUILTIN_EXCLUSIONS.has(name.toLowerCase())) {
+        definitions.add(name);
+      }
+    }
+  }
+
+  return Array.from(definitions);
+}
+
+/**
+ * Extract function calls from content
+ */
+export function extractCalls(content, file) {
+  const calls = new Set();
+
+  // Remove string literals and comments to avoid false positives
+  const cleanContent = removeStringsAndComments(content, file);
+
+  CALL_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = CALL_PATTERN.exec(cleanContent)) !== null) {
+    const name = match[1];
+    if (name && name.length > 1 && !BUILTIN_EXCLUSIONS.has(name.toLowerCase())) {
+      calls.add(name);
+    }
+  }
+
+  return Array.from(calls);
+}
+
+/**
+ * Remove string literals and comments to improve extraction accuracy
+ */
+function removeStringsAndComments(content, file) {
+  const ext = path.extname(file).toLowerCase();
+
+  // Remove single-line comments
+  let cleaned = content.replace(/\/\/.*$/gm, "");
+
+  // Remove multi-line comments
+  cleaned = cleaned.replace(/\/\*[\s\S]*?\*\//g, "");
+
+  // Remove Python comments
+  if (ext === ".py" || ext === ".pyw") {
+    cleaned = cleaned.replace(/#.*$/gm, "");
+    // Remove triple-quoted strings (docstrings)
+    cleaned = cleaned.replace(/"""[\s\S]*?"""/g, "");
+    cleaned = cleaned.replace(/'''[\s\S]*?'''/g, "");
+  }
+
+  // Remove string literals (simplified - handles most cases)
+  cleaned = cleaned.replace(/"(?:[^"\\]|\\.)*"/g, '""');
+  cleaned = cleaned.replace(/'(?:[^'\\]|\\.)*'/g, "''");
+  cleaned = cleaned.replace(/`(?:[^`\\]|\\.)*`/g, "``");
+
+  return cleaned;
+}
+
+/**
+ * Extract both definitions and calls from a file
+ */
+export function extractCallData(content, file) {
+  const definitions = extractDefinitions(content, file);
+  const calls = extractCalls(content, file);
+
+  // Remove self-references (calls to functions defined in same file)
+  const definitionSet = new Set(definitions);
+  const externalCalls = calls.filter(c => !definitionSet.has(c));
+
+  return {
+    definitions,
+    calls: externalCalls
+  };
+}
+
+/**
+ * Build a call graph from file data
+ */
+export function buildCallGraph(fileCallData) {
+  const defines = new Map();  // symbol -> files that define it
+  const calledBy = new Map(); // symbol -> files that call it
+  const fileCalls = new Map(); // file -> symbols it calls
+
+  for (const [file, data] of fileCallData.entries()) {
+    // Record definitions
+    for (const def of data.definitions) {
+      if (!defines.has(def)) {
+        defines.set(def, []);
+      }
+      defines.get(def).push(file);
+    }
+
+    // Record calls
+    fileCalls.set(file, data.calls);
+    for (const call of data.calls) {
+      if (!calledBy.has(call)) {
+        calledBy.set(call, []);
+      }
+      calledBy.get(call).push(file);
+    }
+  }
+
+  return { defines, calledBy, fileCalls };
+}
+
+/**
+ * Get files related to a set of symbols (callers + callees)
+ */
+export function getRelatedFiles(callGraph, symbols, maxHops = 1) {
+  const related = new Map(); // file -> proximity score (1 = direct, 0.5 = indirect)
+  const visited = new Set();
+
+  function explore(currentSymbols, hop) {
+    if (hop > maxHops) return;
+    const score = 1 / (hop + 1); // Decay with distance
+
+    for (const symbol of currentSymbols) {
+      // Files that define this symbol
+      const definers = callGraph.defines.get(symbol) || [];
+      for (const file of definers) {
+        if (!visited.has(file)) {
+          related.set(file, Math.max(related.get(file) || 0, score));
+        }
+      }
+
+      // Files that call this symbol
+      const callers = callGraph.calledBy.get(symbol) || [];
+      for (const file of callers) {
+        if (!visited.has(file)) {
+          related.set(file, Math.max(related.get(file) || 0, score));
+        }
+      }
+
+      // For next hop, find what these files call/define
+      if (hop < maxHops) {
+        const nextSymbols = new Set();
+        for (const file of [...definers, ...callers]) {
+          visited.add(file);
+          const calls = callGraph.fileCalls.get(file) || [];
+          for (const c of calls) nextSymbols.add(c);
+        }
+        explore(nextSymbols, hop + 1);
+      }
+    }
+  }
+
+  explore(symbols, 0);
+  return related;
+}
+
+/**
+ * Extract symbols (function/class names) from search results
+ */
+export function extractSymbolsFromContent(content) {
+  const symbols = new Set();
+
+  // Look for function/class definitions in the content
+  const patterns = [
+    /function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g,
+    /class\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g,
+    /def\s+([a-zA-Z_][a-zA-Z0-9_]*)/g,
+    /(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/g
+  ];
+
+  for (const pattern of patterns) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      if (match[1] && match[1].length > 2) {
+        symbols.add(match[1]);
+      }
+    }
+  }
+
+  return Array.from(symbols);
+}

package/lib/config.js

@@ -67,7 +67,20 @@ const DEFAULT_CONFIG = {
   exactMatchBoost: 1.5,
   recencyBoost: 0.1, // Boost for recently modified files (max 0.1 added to score)
   recencyDecayDays: 30, // After this many days, recency boost is 0
-  smartIndexing: true
+  smartIndexing: true,
+  callGraphEnabled: true, // Enable call graph extraction for proximity boosting
+  callGraphBoost: 0.15,   // Boost for files related via call graph (0-1)
+  callGraphMaxHops: 1,    // How many levels of calls to follow (1 = direct only)
+  annEnabled: true,
+  annMinChunks: 5000,
+  annMinCandidates: 50,
+  annMaxCandidates: 200,
+  annCandidateMultiplier: 20,
+  annEfConstruction: 200,
+  annEfSearch: 64,
+  annM: 16,
+  annIndexCache: true,
+  annMetric: "cosine"
 };
 
 let config = { ...DEFAULT_CONFIG };
@@ -84,10 +97,12 @@ export async function loadConfig(workspaceDir = null) {
       configPath = path.join(baseDir, "config.json");
       console.error(`[Config] Workspace mode: ${baseDir}`);
     } else {
-      // Server mode: load config from server directory
+      // Server mode: load config from server directory for global settings,
+      // but use process.cwd() as base for searching if not specified otherwise
       const scriptDir = path.dirname(fileURLToPath(import.meta.url));
-      baseDir = path.resolve(scriptDir, '..');
-      configPath = path.join(baseDir, "config.json");
+      const serverDir = path.resolve(scriptDir, '..');
+      configPath = path.join(serverDir, "config.json");
+      baseDir = process.cwd();
     }
 
     let userConfig = {};
@@ -95,23 +110,24 @@ export async function loadConfig(workspaceDir = null) {
       const configData = await fs.readFile(configPath, "utf-8");
       userConfig = JSON.parse(configData);
     } catch (configError) {
-      if (workspaceDir) {
-        console.error(`[Config] No config.json in workspace, using defaults`);
-      } else {
-        console.error(`[Config] No config.json found: ${configError.message}`);
+      // If config not found in server dir, try CWD
+      if (!workspaceDir) {
+        try {
+          const localConfigPath = path.join(baseDir, "config.json");
+          const configData = await fs.readFile(localConfigPath, "utf-8");
+          userConfig = JSON.parse(configData);
+          configPath = localConfigPath;
+        } catch {
+          // ignore
+        }
       }
     }
 
     config = { ...DEFAULT_CONFIG, ...userConfig };
 
-    // Set workspace-specific directories
-    if (workspaceDir) {
-      config.searchDirectory = baseDir;
-      config.cacheDirectory = path.join(baseDir, ".smart-coding-cache");
-    } else {
-      config.searchDirectory = path.resolve(baseDir, config.searchDirectory);
-      config.cacheDirectory = path.resolve(baseDir, config.cacheDirectory);
-    }
+    // Set search and cache directories
+    config.searchDirectory = baseDir;
+    config.cacheDirectory = path.join(baseDir, ".smart-coding-cache");
 
     // Smart project detection
     if (config.smartIndexing !== false) {
@@ -192,6 +208,24 @@ export async function loadConfig(workspaceDir = null) {
     }
   }
 
+  if (process.env.SMART_CODING_RECENCY_BOOST !== undefined) {
+    const value = parseFloat(process.env.SMART_CODING_RECENCY_BOOST);
+    if (!isNaN(value) && value >= 0 && value <= 1) {
+      config.recencyBoost = value;
+    } else {
+      console.error(`[Config] Invalid SMART_CODING_RECENCY_BOOST: ${process.env.SMART_CODING_RECENCY_BOOST}, using default`);
+    }
+  }
+
+  if (process.env.SMART_CODING_RECENCY_DECAY_DAYS !== undefined) {
+    const value = parseInt(process.env.SMART_CODING_RECENCY_DECAY_DAYS, 10);
+    if (!isNaN(value) && value > 0 && value <= 365) {
+      config.recencyDecayDays = value;
+    } else {
+      console.error(`[Config] Invalid SMART_CODING_RECENCY_DECAY_DAYS: ${process.env.SMART_CODING_RECENCY_DECAY_DAYS}, using default`);
+    }
+  }
+
   if (process.env.SMART_CODING_WATCH_FILES !== undefined) {
     const value = process.env.SMART_CODING_WATCH_FILES;
     if (value === 'true' || value === 'false') {
@@ -239,6 +273,97 @@ export async function loadConfig(workspaceDir = null) {
     }
   }
 
+  if (process.env.SMART_CODING_ANN_ENABLED !== undefined) {
+    const value = process.env.SMART_CODING_ANN_ENABLED;
+    if (value === 'true' || value === 'false') {
+      config.annEnabled = value === 'true';
+    }
+  }
+
+  if (process.env.SMART_CODING_ANN_MIN_CHUNKS !== undefined) {
+    const value = parseInt(process.env.SMART_CODING_ANN_MIN_CHUNKS, 10);
+    if (!isNaN(value) && value >= 0) {
+      config.annMinChunks = value;
+    } else {
+      console.error(`[Config] Invalid SMART_CODING_ANN_MIN_CHUNKS: ${process.env.SMART_CODING_ANN_MIN_CHUNKS}, using default`);
+    }
+  }
+
+  if (process.env.SMART_CODING_ANN_MIN_CANDIDATES !== undefined) {
+    const value = parseInt(process.env.SMART_CODING_ANN_MIN_CANDIDATES, 10);
+    if (!isNaN(value) && value >= 0) {
+      config.annMinCandidates = value;
+    } else {
+      console.error(`[Config] Invalid SMART_CODING_ANN_MIN_CANDIDATES: ${process.env.SMART_CODING_ANN_MIN_CANDIDATES}, using default`);
+    }
+  }
+
+  if (process.env.SMART_CODING_ANN_MAX_CANDIDATES !== undefined) {
+    const value = parseInt(process.env.SMART_CODING_ANN_MAX_CANDIDATES, 10);
+    if (!isNaN(value) && value > 0) {
+      config.annMaxCandidates = value;
+    } else {
+      console.error(`[Config] Invalid SMART_CODING_ANN_MAX_CANDIDATES: ${process.env.SMART_CODING_ANN_MAX_CANDIDATES}, using default`);
+    }
+  }
+
+  if (process.env.SMART_CODING_ANN_CANDIDATE_MULTIPLIER !== undefined) {
+    const value = parseFloat(process.env.SMART_CODING_ANN_CANDIDATE_MULTIPLIER);
+    if (!isNaN(value) && value > 0) {
+      config.annCandidateMultiplier = value;
+    } else {
+      console.error(`[Config] Invalid SMART_CODING_ANN_CANDIDATE_MULTIPLIER: ${process.env.SMART_CODING_ANN_CANDIDATE_MULTIPLIER}, using default`);
+    }
+  }
+
+  if (process.env.SMART_CODING_ANN_EF_CONSTRUCTION !== undefined) {
+    const value = parseInt(process.env.SMART_CODING_ANN_EF_CONSTRUCTION, 10);
+    if (!isNaN(value) && value > 0) {
+      config.annEfConstruction = value;
+    } else {
+      console.error(`[Config] Invalid SMART_CODING_ANN_EF_CONSTRUCTION: ${process.env.SMART_CODING_ANN_EF_CONSTRUCTION}, using default`);
+    }
+  }
+
+  if (process.env.SMART_CODING_ANN_EF_SEARCH !== undefined) {
+    const value = parseInt(process.env.SMART_CODING_ANN_EF_SEARCH, 10);
+    if (!isNaN(value) && value > 0) {
+      config.annEfSearch = value;
+    } else {
+      console.error(`[Config] Invalid SMART_CODING_ANN_EF_SEARCH: ${process.env.SMART_CODING_ANN_EF_SEARCH}, using default`);
+    }
+  }
+
+  if (process.env.SMART_CODING_ANN_M !== undefined) {
+    const value = parseInt(process.env.SMART_CODING_ANN_M, 10);
+    if (!isNaN(value) && value > 0 && value <= 64) {
+      config.annM = value;
+    } else {
+      console.error(`[Config] Invalid SMART_CODING_ANN_M: ${process.env.SMART_CODING_ANN_M}, using default`);
+    }
+  }
+
+  if (process.env.SMART_CODING_ANN_INDEX_CACHE !== undefined) {
+    const value = process.env.SMART_CODING_ANN_INDEX_CACHE;
+    if (value === 'true' || value === 'false') {
+      config.annIndexCache = value === 'true';
+    }
+  }
+
+  if (process.env.SMART_CODING_ANN_METRIC !== undefined) {
+    const value = process.env.SMART_CODING_ANN_METRIC.trim().toLowerCase();
+    if (value === "cosine" || value === "ip" || value === "l2") {
+      config.annMetric = value;
+    } else {
+      console.error(`[Config] Invalid SMART_CODING_ANN_METRIC: ${process.env.SMART_CODING_ANN_METRIC}, using default`);
+    }
+  }
+
+  if (config.annMetric !== "cosine") {
+    console.error(`[Config] ANN metric locked to cosine, overriding "${config.annMetric}"`);
+    config.annMetric = "cosine";
+  }
+
   // Safety cap for auto workers
   if (config.workerThreads === 'auto') {
     // Cap at 4 workers max by default to prevent OOM (each model ~150MB)

package/lib/project-detector.js

@@ -10,52 +10,65 @@ export class ProjectDetector {
 
   async detectProjectTypes() {
     const markerFiles = Object.keys(FILE_TYPE_MAP);
-    
-    for (const marker of markerFiles) {
-      // Handle wildcard patterns like *.csproj
-      if (marker.includes('*')) {
-        await this.detectWithWildcard(marker);
-      } else {
-        await this.detectExactFile(marker);
-      }
-    }
+    const discoveredTypes = new Map(); // type -> first marker found
 
-    return Array.from(this.detectedTypes);
-  }
+    const checkDir = async (dir, depth) => {
+      if (depth > 2) return;
 
-  async detectExactFile(markerFile) {
-    const markerPath = path.join(this.searchDirectory, markerFile);
-    try {
-      await fs.access(markerPath);
-      const projectType = FILE_TYPE_MAP[markerFile];
-      this.detectedTypes.add(projectType);
-      console.error(`[Detector] Detected ${projectType} project (${markerFile})`);
-    } catch {
-      // File doesn't exist, continue
-    }
-  }
+      const items = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+      const itemNames = items.map(i => i.name);
+      const itemSet = new Set(itemNames);
+
+      for (const marker of markerFiles) {
+        let found = false;
+        if (marker.includes('*')) {
+          const regex = new RegExp('^' + marker.replace('*', '.*') + '$');
+          found = itemNames.some(file => regex.test(file));
+        } else {
+          found = itemSet.has(marker);
+        }
 
-  async detectWithWildcard(pattern) {
-    try {
-      const files = await fs.readdir(this.searchDirectory);
-      const regex = new RegExp('^' + pattern.replace('*', '.*') + '$');
-      
-      for (const file of files) {
-        if (regex.test(file)) {
-          const projectType = FILE_TYPE_MAP[pattern];
-          this.detectedTypes.add(projectType);
-          console.error(`[Detector] Detected ${projectType} project (${file})`);
-          break;
+        if (found) {
+          const type = FILE_TYPE_MAP[marker];
+          if (!discoveredTypes.has(type)) {
+            discoveredTypes.set(type, path.relative(this.searchDirectory, path.join(dir, marker)));
+          }
         }
       }
-    } catch {
-      // Directory read failed, continue
+
+      // Recurse into subdirectories
+      if (depth < 2) {
+        for (const item of items) {
+          if (item.isDirectory()) {
+            const name = item.name;
+            if (name.startsWith('.') || [
+              'node_modules', 'dist', 'build', 'target', 'vendor',  // Build outputs
+              'coverage', 'htmlcov',                                 // Test coverage
+              'typings', 'nltk_data', 'secrets',                     // Data/secrets
+              'venv', 'env',                                         // Python envs (non-dot)
+              '__pycache__', 'eggs', '.eggs'                         // Python artifacts
+            ].includes(name)) {
+              continue;
+            }
+            await checkDir(path.join(dir, name), depth + 1);
+          }
+        }
+      }
+    };
+
+    await checkDir(this.searchDirectory, 0);
+
+    for (const [type, marker] of discoveredTypes) {
+      this.detectedTypes.add(type);
+      console.error(`[Detector] Detected ${type} project (${marker})`);
     }
+
+    return Array.from(this.detectedTypes);
   }
 
   getSmartIgnorePatterns() {
     const patterns = [...IGNORE_PATTERNS.common];
-    
+
     for (const type of this.detectedTypes) {
       if (IGNORE_PATTERNS[type]) {
         patterns.push(...IGNORE_PATTERNS[type]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softerist/heuristic-mcp",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "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",
@@ -35,14 +35,8 @@
   ],
   "author": {
     "name": "Softerist",
-    "url": "https://softerist.com"
+    "url": "https://github.com/softerist"
   },
-  "contributors": [
-    {
-      "name": "Omar Haris",
-      "url": "https://www.linkedin.com/in/omarharis/"
-    }
-  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/softerist/heuristic-mcp"
@@ -56,6 +50,9 @@
     "fdir": "^6.5.0",
     "glob": "^10.3.10"
   },
+  "optionalDependencies": {
+    "hnswlib-node": "^3.0.0"
+  },
   "engines": {
     "node": ">=18.0.0"
   },

package/test/ann-fallback.test.js

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('hnswlib-node', () => ({}));
+import { EmbeddingsCache } from '../lib/cache.js';
+import { HybridSearch } from '../features/hybrid-search.js';
+import { DEFAULT_CONFIG } from '../lib/config.js';
+
+describe('ANN Fallback (Missing hnswlib-node)', () => {
+  let cache;
+  let hybridSearch;
+  let embedder;
+
+  beforeEach(() => {
+    // Mock configuration with ANN enabled
+    const config = {
+      ...DEFAULT_CONFIG,
+      enableCache: false,
+      cacheDirectory: './test-cache-ann',
+      annEnabled: true,
+      annMinChunks: 5, // Low threshold for testing
+      annIndexCache: false,
+      embeddingModel: 'test-model'
+    };
+
+    // Mock embedder
+    embedder = vi.fn().mockResolvedValue({
+      data: new Float32Array([0.1, 0.2, 0.3])
+    });
+
+    cache = new EmbeddingsCache(config);
+
+    // Populate vector store with dummy data
+    const vectors = [];
+    for (let i = 0; i < 10; i++) {
+      vectors.push({
+        file: `file${i}.js`,
+        content: `content ${i}`,
+        startLine: 1,
+        endLine: 5,
+        vector: [0.1, 0.2, 0.3] // simple dummy vector
+      });
+    }
+    cache.setVectorStore(vectors);
+
+    hybridSearch = new HybridSearch(embedder, cache, config);
+  });
+
+  it('should fall back to linear search when ANN index is unavailable', async () => {
+    const query = "test query";
+    const maxResults = 5;
+
+    const result = await hybridSearch.search(query, maxResults);
+
+    expect(result).toBeDefined();
+    expect(result.results.length).toBe(5);
+    expect(embedder).toHaveBeenCalledWith(query, expect.any(Object));
+    // Verify it didn't throw and ANN attempt doesn't prevent results
+    const annAttempt = await cache.queryAnn([0.1, 0.2, 0.3], 5);
+    expect(annAttempt).toBeNull();
+  });
+
+  it('should handle ANN loading failure gracefully', async () => {
+    const index = await cache.ensureAnnIndex();
+    expect(index).toBeNull();
+
+    const annResults = await cache.queryAnn([0.1, 0.2, 0.3], 5);
+    expect(annResults).toBeNull();
+  });
+});