@softerist/heuristic-mcp 2.1.47 → 3.0.0

package/test/hybrid-search-basic.test.js

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi } from 'vitest';
+import { HybridSearch } from '../features/hybrid-search.js';
+import { createHybridSearchCacheStub } from './helpers.js';
+
+describe('HybridSearch coverage', () => {
+  it('skips duplicate chunks during exact match fallback (line 113 coverage)', async () => {
+    const vectorStore = [
+      {
+        file: 'duplicate.js',
+        content: 'exact match',
+        startLine: 1,
+        endLine: 2,
+        vector: [1, 0]
+      },
+      {
+        file: 'new.js',
+        content: 'exact match',
+        startLine: 1,
+        endLine: 2,
+        vector: [0, 1]
+      }
+    ];
+
+    const cache = createHybridSearchCacheStub({
+      vectorStore,
+      // ANN returns only the first chunk
+      queryAnn: async () => [0],
+    });
+
+    const config = {
+      annEnabled: true,
+      // Ensure we get into the ANN path
+      annMinCandidates: 0,
+      annMaxCandidates: 10,
+      annCandidateMultiplier: 1,
+      // Need maxResults > exactMatchCount (which will be 1)
+      maxResults: 5,
+      semanticWeight: 1,
+      exactMatchBoost: 1,
+      recencyBoost: 0,
+      callGraphEnabled: false,
+      searchDirectory: '/test'
+    };
+
+    const embedder = async () => ({ data: new Float32Array([1, 0]) });
+    
+    const hybridSearch = new HybridSearch(embedder, cache, config);
+    
+    // Search for "exact match"
+    // 1. ANN returns Chunk 0.
+    // 2. exactMatchCount = 1 (Chunk 0 has "exact match").
+    // 3. maxResults = 5. 1 < 5.
+    // 4. Fallback loop starts.
+    // 5. Checks Chunk 0. content matches. Key is in seen set. Line 113 -> continue.
+    // 6. Checks Chunk 1. content matches. Key not in seen set. Added.
+    
+    const { results } = await hybridSearch.search('exact match', 5);
+    
+    expect(results).toHaveLength(2);
+    expect(results.map(r => r.file).sort()).toEqual(['duplicate.js', 'new.js']);
+  });
+});

package/test/hybrid-search-branch.test.js

@@ -0,0 +1,202 @@
+
+import { describe, it, expect, vi } from 'vitest';
+import { HybridSearch } from '../features/hybrid-search.js';
+import { createHybridSearchCacheStub } from './helpers.js';
+import fs from 'fs/promises';
+
+describe('HybridSearch Branch Coverage', () => {
+  it('should handle fs.stat errors in populateFileModTimes', async () => {
+    const config = {
+      annEnabled: false,
+      semanticWeight: 1,
+      exactMatchBoost: 0,
+      recencyBoost: 0.5,
+      recencyDecayDays: 30,
+      callGraphEnabled: false,
+      callGraphBoost: 0,
+      searchDirectory: '/mock',
+    };
+    const embedder = vi.fn();
+    const cache = createHybridSearchCacheStub({
+      vectorStore: [],
+      getFileMeta: () => null,
+    });
+    const hybrid = new HybridSearch(embedder, cache, config);
+
+    // Mock fs.stat to fail for one file and succeed for another
+    const statSpy = vi.spyOn(fs, 'stat').mockImplementation(async (path) => {
+      if (path === 'fail.js') {
+        throw new Error('stat failed');
+      }
+      return { mtimeMs: 1000 };
+    });
+
+    await hybrid.populateFileModTimes(['success.js', 'fail.js']);
+
+    expect(hybrid.fileModTimes.get('success.js')).toBe(1000);
+    expect(hybrid.fileModTimes.get('fail.js')).toBeNull();
+
+    statSpy.mockRestore();
+  });
+
+  it('should return early from populateFileModTimes if no missing files', async () => {
+      const hybrid = new HybridSearch({}, createHybridSearchCacheStub(), {});
+      hybrid.fileModTimes.set('a.js', 100);
+      
+      const statSpy = vi.spyOn(fs, 'stat');
+      await hybrid.populateFileModTimes(['a.js']);
+      
+      expect(statSpy).not.toHaveBeenCalled();
+      statSpy.mockRestore();
+  });
+
+  it('should handle null mtime in scoring', async () => {
+    const vectorStore = [
+      {
+        file: 'null-mtime.js',
+        content: 'content',
+        vector: [1, 0],
+        startLine: 1,
+        endLine: 1,
+      },
+    ];
+    const cache = createHybridSearchCacheStub({
+      vectorStore,
+      queryAnn: async () => null,
+    });
+    const config = {
+      annEnabled: false,
+      semanticWeight: 1,
+      exactMatchBoost: 0,
+      recencyBoost: 0.5,
+      recencyDecayDays: 30,
+      callGraphEnabled: false,
+      callGraphBoost: 0,
+      searchDirectory: '/mock',
+    };
+    const embedder = async () => ({ data: new Float32Array([1, 0]) });
+    const hybrid = new HybridSearch(embedder, cache, config);
+    
+    // Explicitly set null mtime
+    hybrid.fileModTimes.set('null-mtime.js', null);
+
+    const { results } = await hybrid.search('query', 1);
+    expect(results[0].score).toBe(1); // Only semantic weight
+  });
+
+  it('should skip call graph boost if no symbols from top results', async () => {
+    const vectorStore = [
+      {
+        file: 'no-symbols.js',
+        content: '', // Empty content -> no symbols
+        vector: [1, 0],
+        startLine: 1,
+        endLine: 1,
+      },
+    ];
+    const cache = createHybridSearchCacheStub({
+      vectorStore,
+      queryAnn: async () => null,
+      getRelatedFiles: vi.fn(),
+    });
+    const config = {
+      annEnabled: false,
+      semanticWeight: 1,
+      exactMatchBoost: 0,
+      recencyBoost: 0,
+      callGraphEnabled: true,
+      callGraphBoost: 0.5,
+      searchDirectory: '/mock',
+    };
+    const embedder = async () => ({ data: new Float32Array([1, 0]) });
+    const hybrid = new HybridSearch(embedder, cache, config);
+
+    await hybrid.search('query', 1);
+    expect(cache.getRelatedFiles).not.toHaveBeenCalled();
+  });
+
+  it('should skip chunks without content in exact match fallback (line 113)', async () => {
+    const vectorStore = [
+      {
+        file: 'no-content.js',
+        content: null,
+        vector: [1, 0],
+        startLine: 1,
+        endLine: 1,
+      },
+    ];
+    const cache = createHybridSearchCacheStub({
+      vectorStore,
+      queryAnn: async () => [0],
+    });
+    const config = {
+      annEnabled: true,
+      annMinCandidates: 0,
+      annMaxCandidates: 10,
+      annCandidateMultiplier: 1,
+      semanticWeight: 1,
+      exactMatchBoost: 1,
+      recencyBoost: 0,
+      callGraphEnabled: false,
+      callGraphBoost: 0,
+      searchDirectory: '/mock',
+    };
+    const embedder = async () => ({ data: new Float32Array([1, 0]) });
+    const hybrid = new HybridSearch(embedder, cache, config);
+
+    // We need exactMatchCount < maxResults to trigger the fallback block
+    // ANN returns usedAnn = true.
+    // candidates = [chunk0].
+    // exactMatchCount = 0 (chunk0 has no content).
+    // exactMatchCount < maxResults (2).
+    // Fallback block is entered.
+    // Iterates vectorStore. chunk0 is skipped because chunk.content is null.
+    const { results } = await hybrid.search('target', 2);
+    expect(results).toHaveLength(1);
+  });
+
+  it('should cover line 113: skip redundant chunk during exact match fallback', async () => {
+    const vectorStore = [
+      {
+        file: 'match.js',
+        content: 'target match',
+        vector: [1, 0],
+        startLine: 1,
+        endLine: 1,
+      }
+    ];
+    const cache = createHybridSearchCacheStub({
+      vectorStore,
+      queryAnn: async () => [0],
+    });
+    const config = {
+      annEnabled: true,
+      annMinCandidates: 0,
+      annMaxCandidates: 10,
+      annCandidateMultiplier: 1,
+      semanticWeight: 1,
+      exactMatchBoost: 1,
+      recencyBoost: 0,
+      callGraphEnabled: false,
+      callGraphBoost: 0,
+      searchDirectory: '/mock',
+    };
+    const embedder = async () => ({ data: new Float32Array([1, 0]) });
+    const hybrid = new HybridSearch(embedder, cache, config);
+
+    // Flow:
+    // 1. usedAnn = true.
+    // 2. candidates = [chunk0].
+    // 3. exactMatchCount = 1.
+    // 4. maxResults = 2.
+    // 5. exactMatchCount < maxResults -> Fallback entered (line 110).
+    // 6. seen = Set(['match.js:1:1']).
+    // 7. Loop vectorStore:
+    //    - chunk0: content matches 'target'.
+    //    - key = 'match.js:1:1'.
+    //    - seen.has(key) is TRUE -> continues (line 113 COVERAGE).
+    const { results } = await hybrid.search('target', 2);
+    expect(results).toHaveLength(1);
+    expect(results[0].file).toBe('match.js');
+  });
+});

package/test/hybrid-search-callgraph.test.js

@@ -0,0 +1,229 @@
+
+import { describe, it, expect, vi } from 'vitest';
+import { HybridSearch } from '../features/hybrid-search.js';
+import { createHybridSearchCacheStub } from './helpers.js';
+import * as CallGraph from '../lib/call-graph.js';
+
+describe('HybridSearch Final Coverage', () => {
+  describe('Partial Match Logic', () => {
+    it('should handle short words and missing words in partial matching', async () => {
+      const vectorStore = [
+        {
+          file: 'partial.js',
+          content: 'some longcontent here',
+          vector: [1, 0],
+          startLine: 1,
+          endLine: 1,
+        }
+      ];
+      const cache = createHybridSearchCacheStub({
+        vectorStore,
+        queryAnn: async () => null,
+      });
+      const config = {
+        annEnabled: false,
+        semanticWeight: 0, // Disable semantic score to isolate exact/partial match
+        exactMatchBoost: 10,
+        recencyBoost: 0,
+        callGraphEnabled: false,
+        searchDirectory: '/mock',
+      };
+      const embedder = async () => ({ data: new Float32Array([0, 0]) });
+      const hybrid = new HybridSearch(embedder, cache, config);
+
+      // Query: "is missingword"
+      // "is" -> length 2 (skipped)
+      // "missingword" -> length > 2 (checked, but not in content)
+      // matchedWords should be 0. Score should be 0 (since semanticWeight is 0).
+      
+      const { results } = await hybrid.search('is missingword', 1);
+      expect(results[0].score).toBe(0);
+    });
+
+    it('should match words longer than 2 characters', async () => {
+      const vectorStore = [
+        {
+          file: 'partial.js',
+          content: 'some longcontent here',
+          vector: [1, 0],
+          startLine: 1,
+          endLine: 1,
+        }
+      ];
+      const cache = createHybridSearchCacheStub({
+        vectorStore,
+        queryAnn: async () => null,
+      });
+      const config = {
+        annEnabled: false,
+        semanticWeight: 0,
+        exactMatchBoost: 10,
+        recencyBoost: 0,
+        callGraphEnabled: false,
+        searchDirectory: '/mock',
+      };
+      const embedder = async () => ({ data: new Float32Array([0, 0]) });
+      const hybrid = new HybridSearch(embedder, cache, config);
+
+      // Query: "longcontent missing"
+      // Full string "longcontent missing" NOT in content.
+      // "longcontent" -> length > 2 (checked, found)
+      // "missing" -> length > 2 (checked, not found)
+      // matchedWords = 1. Total words = 2.
+      // Score = (1/2) * 0.3 = 0.15
+      
+      const { results } = await hybrid.search('longcontent missing', 1);
+      expect(results[0].score).toBeCloseTo(0.15);
+    });
+  });
+
+  describe('Call Graph Proximity', () => {
+    it('should apply boost only when proximity exists', async () => {
+      const vectorStore = [
+        {
+          file: 'source.js',
+          content: 'function source() {}',
+          vector: [1, 0],
+          startLine: 1,
+          endLine: 1,
+        },
+        {
+          file: 'related.js',
+          content: 'related content',
+          vector: [0.9, 0],
+          startLine: 1,
+          endLine: 1,
+        },
+        {
+          file: 'unrelated.js',
+          content: 'unrelated content',
+          vector: [0.8, 0],
+          startLine: 1,
+          endLine: 1,
+        }
+      ];
+      
+      const relatedMap = new Map();
+      relatedMap.set('related.js', 1); // Boost of 1
+      // unrelated.js is not in the map
+      
+      const cache = createHybridSearchCacheStub({
+        vectorStore,
+        queryAnn: async () => null,
+        getRelatedFiles: async () => relatedMap,
+      });
+      
+      const config = {
+        annEnabled: false,
+        semanticWeight: 1,
+        exactMatchBoost: 0,
+        recencyBoost: 0,
+        callGraphEnabled: true,
+        callGraphBoost: 10, // Large boost to make it obvious
+        searchDirectory: '/mock',
+      };
+      
+      const embedder = async () => ({ data: new Float32Array([1, 0]) });
+      const hybrid = new HybridSearch(embedder, cache, config);
+
+      // Mock extractSymbolsFromContent to return something so we trigger getRelatedFiles
+      vi.spyOn(CallGraph, 'extractSymbolsFromContent').mockReturnValue(['source']);
+
+      const { results } = await hybrid.search('query', 3);
+      
+      // related.js should have a massive score due to boost
+      // unrelated.js should have normal score
+      
+      const related = results.find(r => r.file === 'related.js');
+      const unrelated = results.find(r => r.file === 'unrelated.js');
+      
+      // Base score is semantic similarity. 
+      // related: 0.9 * 1 = 0.9. Boost: 1 * 10 = 10. Total 10.9
+      // unrelated: 0.8 * 1 = 0.8. Boost: 0. Total 0.8
+      
+      expect(related.score).toBeGreaterThan(10);
+      expect(unrelated.score).toBeLessThan(1);
+    });
+  });
+
+  describe('Line 113 Coverage', () => {
+    it('should explicitly hit line 113 (redundant chunk check)', async () => {
+      const chunk = {
+        file: 'hit.js',
+        content: 'hit me',
+        vector: [1],
+        startLine: 1,
+        endLine: 1
+      };
+      const vectorStore = [chunk];
+      
+      const cache = createHybridSearchCacheStub({
+        vectorStore,
+        queryAnn: async () => [0],
+      });
+      
+      const config = {
+        annEnabled: true,
+        annMinCandidates: 0,
+        annMaxCandidates: 10,
+        annCandidateMultiplier: 1,
+        maxResults: 10, 
+        semanticWeight: 1,
+        exactMatchBoost: 1,
+        recencyBoost: 0,
+        callGraphEnabled: false,
+        searchDirectory: '/mock',
+      };
+      
+      const embedder = async () => ({ data: new Float32Array([1]) });
+      const hybrid = new HybridSearch(embedder, cache, config);
+      
+      await hybrid.search('hit', 10);
+    });
+  });
+
+  describe('Edge Case Search Parameters', () => {
+    it('should skip exact match fallback if query is too short', async () => {
+      const vectorStore = [{ file: 'a.js', content: 'a', vector: [1], startLine: 1, endLine: 1 }];
+      const cache = createHybridSearchCacheStub({
+        vectorStore,
+        queryAnn: async () => [0],
+      });
+      const config = {
+        annEnabled: true,
+        maxResults: 2,
+        semanticWeight: 1,
+        exactMatchBoost: 1,
+        recencyBoost: 0,
+        callGraphEnabled: false,
+        searchDirectory: '/mock',
+      };
+      const embedder = async () => ({ data: new Float32Array([1]) });
+      const hybrid = new HybridSearch(embedder, cache, config);
+      
+      // Query 'a' -> length 1. should skip the fallback logic.
+      await hybrid.search('a', 2);
+    });
+
+    it('should skip exact match fallback if exactMatchCount >= maxResults', async () => {
+      const vectorStore = [{ file: 'match.js', content: 'target', vector: [1], startLine: 1, endLine: 1 }];
+      const cache = createHybridSearchCacheStub({
+        vectorStore,
+        queryAnn: async () => [0],
+      });
+      const config = {
+        annEnabled: true,
+        maxResults: 1, // maxResults is 1, exactMatchCount will be 1
+        semanticWeight: 1,
+        exactMatchBoost: 1,
+        recencyBoost: 0,
+        callGraphEnabled: false,
+        searchDirectory: '/mock',
+      };
+      const embedder = async () => ({ data: new Float32Array([1]) });
+      const hybrid = new HybridSearch(embedder, cache, config);
+      
+      await hybrid.search('target', 1);
+    });
+  });
+});

package/test/hybrid-search-extra.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import { HybridSearch } from '../features/hybrid-search.js';
+import { createHybridSearchCacheStub } from './helpers.js';
+
+describe('HybridSearch extra coverage', () => {
+  it('handles missing chunk content in ANN fallback loop', async () => {
+    const vectorStore = [
+      {
+        file: 'a.js',
+        content: undefined,
+        startLine: 1,
+        endLine: 2,
+        vector: [1, 0],
+      },
+      {
+        file: 'b.js',
+        content: 'no match here',
+        startLine: 3,
+        endLine: 4,
+        vector: [0, 1],
+      },
+    ];
+
+    const cache = createHybridSearchCacheStub({
+      vectorStore,
+      queryAnn: async () => [0, 1],
+    });
+
+    const config = {
+      annEnabled: true,
+      annMinCandidates: 0,
+      annMaxCandidates: 10,
+      annCandidateMultiplier: 1,
+      maxResults: 2,
+      semanticWeight: 1,
+      exactMatchBoost: 1,
+      recencyBoost: 0,
+      callGraphEnabled: false,
+      searchDirectory: '/test',
+    };
+
+    const embedder = async () => ({ data: new Float32Array([1, 0]) });
+    const hybridSearch = new HybridSearch(embedder, cache, config);
+
+    const { results } = await hybridSearch.search('ab', 2);
+
+    expect(results).toHaveLength(2);
+  });
+
+  it('falls back with empty chunk content string', async () => {
+    const vectorStore = [
+      { file: 'x.js', content: undefined, startLine: 1, endLine: 1, vector: [1, 0] },
+      { file: 'y.js', content: 'ab', startLine: 2, endLine: 2, vector: [0, 1] },
+    ];
+
+    const cache = createHybridSearchCacheStub({
+      vectorStore,
+      queryAnn: async () => [0, 1],
+    });
+
+    const config = {
+      annEnabled: true,
+      annMinCandidates: 0,
+      annMaxCandidates: 10,
+      annCandidateMultiplier: 1,
+      maxResults: 2,
+      semanticWeight: 1,
+      exactMatchBoost: 1,
+      recencyBoost: 0,
+      callGraphEnabled: false,
+      searchDirectory: '/test',
+    };
+
+    const embedder = async () => ({ data: new Float32Array([1, 0]) });
+    const hybridSearch = new HybridSearch(embedder, cache, config);
+
+    const { results } = await hybridSearch.search('ab', 2);
+
+    expect(results).toHaveLength(2);
+  });
+});