@softerist/heuristic-mcp 2.1.46 → 3.0.0

package/test/cache.test.js

@@ -0,0 +1,443 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { EmbeddingsCache } from '../lib/cache.js';
+import { loadConfig } from '../lib/config.js';
+
+let lastHnswInstance = null;
+class FakeHnsw {
+  constructor(metric, dim) {
+    this.metric = metric;
+    this.dim = dim;
+    lastHnswInstance = this;
+  }
+  initIndex() {}
+  addPoint() {}
+  writeIndexSync() {}
+  readIndexSync() {}
+  setEf(value) {
+    this.ef = value;
+  }
+  searchKnn() {
+    return { labels: [0] };
+  }
+}
+
+vi.mock('hnswlib-node', () => ({
+  HierarchicalNSW: FakeHnsw,
+}));
+
+async function withTempDir(testFn) {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'heuristic-cache-'));
+  try {
+    await testFn(dir);
+  } finally {
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+}
+
+async function createConfig(cacheDir) {
+  const config = await loadConfig();
+  config.cacheDirectory = cacheDir;
+  config.searchDirectory = cacheDir;
+  config.enableCache = true;
+  config.callGraphEnabled = true;
+  config.embeddingModel = 'test-model';
+  config.fileExtensions = ['js'];
+  config.excludePatterns = [];
+  config.annEnabled = true;
+  config.annMinChunks = 1;
+  return config;
+}
+
+describe('EmbeddingsCache', () => {
+  beforeEach(() => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should cover all lines', async () => {
+    await withTempDir(async (dir) => {
+      const config = await createConfig(dir);
+      const cache = new EmbeddingsCache(config);
+
+      // Line 176
+      const mkdirSpy = vi
+        .spyOn(fs, 'mkdir')
+        .mockRejectedValue(new Error('Failed to create directory'));
+      await cache.load();
+      expect(console.warn).toHaveBeenCalledWith(
+        '[Cache] Failed to load cache:',
+        'Failed to create directory'
+      );
+      mkdirSpy.mockRestore();
+
+      // Line 219
+      await cache.save();
+      expect(cache.isSaving).toBe(false);
+
+      // Line 246
+      cache.setFileCallData('a.js', { defs: [], calls: [] });
+      cache.removeFileFromStore('a.js');
+      expect(cache.getFileCallData('a.js')).toBeUndefined();
+    });
+  });
+
+  it('loads cache data and filters extensions', async () => {
+    await withTempDir(async (dir) => {
+      const config = await createConfig(dir);
+      config.fileExtensions = ['js'];
+      const cache = new EmbeddingsCache(config);
+
+      const meta = { version: 1, embeddingModel: config.embeddingModel };
+      const cacheData = [
+        { file: path.join(dir, 'a.js'), vector: [1, 2] },
+        { file: path.join(dir, 'a.txt'), vector: [3, 4] },
+      ];
+      const hashData = {
+        [path.join(dir, 'a.js')]: 'hash1',
+        [path.join(dir, 'a.txt')]: 'hash2',
+      };
+
+      await fs.writeFile(path.join(dir, 'meta.json'), JSON.stringify(meta));
+      await fs.writeFile(path.join(dir, 'embeddings.json'), JSON.stringify(cacheData));
+      await fs.writeFile(path.join(dir, 'file-hashes.json'), JSON.stringify(hashData));
+
+      await cache.load();
+
+      expect(cache.getVectorStore()).toHaveLength(1);
+      expect(cache.getFileHash(path.join(dir, 'a.js'))).toBe('hash1');
+      expect(cache.getFileHash(path.join(dir, 'a.txt'))).toBeUndefined();
+    });
+  });
+
+  it('persists file hash metadata and reloads', async () => {
+    await withTempDir(async (dir) => {
+      const config = await createConfig(dir);
+      const cache = new EmbeddingsCache(config);
+      const filePath = path.join(dir, 'a.js');
+
+      cache.setFileHash(filePath, 'hash-meta', { mtimeMs: 1234, size: 4567 });
+      await cache.save();
+
+      const hashFile = path.join(dir, 'file-hashes.json');
+      const raw = JSON.parse(await fs.readFile(hashFile, 'utf-8'));
+      expect(raw[filePath]).toEqual({ hash: 'hash-meta', mtimeMs: 1234, size: 4567 });
+
+      const reloaded = new EmbeddingsCache(config);
+      await reloaded.load();
+      expect(reloaded.getFileHash(filePath)).toBe('hash-meta');
+      expect(reloaded.getFileMeta(filePath)).toEqual(
+        expect.objectContaining({ hash: 'hash-meta', mtimeMs: 1234, size: 4567 })
+      );
+    });
+  });
+
+  it('writes and loads binary vector store with content lookup', async () => {
+    await withTempDir(async (dir) => {
+      const config = await createConfig(dir);
+      config.vectorStoreFormat = 'binary';
+      config.vectorStoreContentMode = 'external';
+      config.contentCacheEntries = 2;
+      const cache = new EmbeddingsCache(config);
+      const filePath = path.join(dir, 'b.js');
+
+      cache.vectorStore = [
+        {
+          file: filePath,
+          startLine: 1,
+          endLine: 2,
+          content: 'console.log("hi")',
+          vector: new Float32Array([0.1, 0.2]),
+        },
+      ];
+      cache.setFileHash(filePath, 'hash-binary', { mtimeMs: 10, size: 20 });
+
+      await cache.save();
+
+      const reloaded = new EmbeddingsCache(config);
+      await reloaded.load();
+
+      const store = reloaded.getVectorStore();
+      expect(store.length).toBe(1);
+      await expect(reloaded.getChunkContent(store[0])).resolves.toBe('console.log("hi")');
+      expect(reloaded.getChunkVector(store[0])).toBeInstanceOf(Float32Array);
+      
+      await reloaded.close();
+      await cache.close();
+    });
+  });
+
+  it('loads binary vector store in disk mode without inline vectors', async () => {
+    await withTempDir(async (dir) => {
+      const config = await createConfig(dir);
+      config.vectorStoreFormat = 'binary';
+      config.vectorStoreContentMode = 'external';
+      config.vectorStoreLoadMode = 'disk';
+      config.vectorCacheEntries = 1;
+      const cache = new EmbeddingsCache(config);
+      const filePath = path.join(dir, 'disk.js');
+
+      cache.vectorStore = [
+        {
+          file: filePath,
+          startLine: 1,
+          endLine: 2,
+          content: 'console.log("disk")',
+          vector: new Float32Array([0.3, 0.6]),
+        },
+      ];
+      cache.setFileHash(filePath, 'hash-disk', { mtimeMs: 10, size: 20 });
+
+      await cache.save();
+
+      const reloaded = new EmbeddingsCache(config);
+      await reloaded.load();
+
+      const store = reloaded.getVectorStore();
+      expect(store.length).toBe(1);
+      expect(store[0].vector).toBeUndefined();
+      expect(reloaded.getChunkVector(store[0])).toBeInstanceOf(Float32Array);
+
+      await reloaded.close();
+      await cache.close();
+    });
+  });
+
+  it('migrates from JSON cache to binary store on save', async () => {
+    await withTempDir(async (dir) => {
+      const config = await createConfig(dir);
+      config.vectorStoreFormat = 'binary';
+      config.vectorStoreContentMode = 'external';
+
+      const filePath = path.join(dir, 'migrate.js');
+      const meta = { version: 1, embeddingModel: config.embeddingModel };
+      const cacheData = [
+        {
+          file: filePath,
+          startLine: 1,
+          endLine: 2,
+          content: 'export const x = 1;',
+          vector: [0.3, 0.4],
+        },
+      ];
+      const hashData = { [filePath]: 'hash-migrate' };
+
+      await fs.writeFile(path.join(dir, 'meta.json'), JSON.stringify(meta));
+      await fs.writeFile(path.join(dir, 'embeddings.json'), JSON.stringify(cacheData));
+      await fs.writeFile(path.join(dir, 'file-hashes.json'), JSON.stringify(hashData));
+
+      const cache = new EmbeddingsCache(config);
+      await cache.load();
+      expect(cache.getVectorStore()).toHaveLength(1);
+
+      await cache.save();
+
+      const vectorsPath = path.join(dir, 'vectors.bin');
+      const recordsPath = path.join(dir, 'records.bin');
+      const contentPath = path.join(dir, 'content.bin');
+      const filesPath = path.join(dir, 'files.json');
+
+      await expect(fs.readFile(vectorsPath)).resolves.toBeDefined();
+      await expect(fs.readFile(recordsPath)).resolves.toBeDefined();
+      await expect(fs.readFile(contentPath)).resolves.toBeDefined();
+      await expect(fs.readFile(filesPath)).resolves.toBeDefined();
+      
+      await cache.close();
+    });
+  });
+
+  it('reuses cached ANN vectors', async () => {
+    await withTempDir(async (dir) => {
+      const config = await createConfig(dir);
+      const cache = new EmbeddingsCache(config);
+
+      cache.vectorStore = [{ file: 'a.js', vector: [1, 2, 3] }];
+      const first = cache.getAnnVector(0);
+      const second = cache.getAnnVector(0);
+
+      expect(first).toBeInstanceOf(Float32Array);
+      expect(second).toBe(first);
+    });
+  });
+
+  it('loads ANN index from disk and applies efSearch', async () => {
+    await withTempDir(async (dir) => {
+      const config = await createConfig(dir);
+      config.annEfSearch = 32;
+      const cache = new EmbeddingsCache(config);
+      cache.vectorStore = [{ file: 'a.js', vector: [1, 2] }];
+
+      const meta = {
+        version: 1,
+        embeddingModel: config.embeddingModel,
+        metric: config.annMetric,
+        dim: 2,
+        count: 1,
+        m: config.annM,
+        efConstruction: config.annEfConstruction,
+      };
+      await fs.writeFile(path.join(dir, 'ann-meta.json'), JSON.stringify(meta));
+      await fs.writeFile(path.join(dir, 'ann-index.bin'), '');
+
+      const loaded = await cache.loadAnnIndexFromDisk(FakeHnsw, 2);
+
+      expect(loaded).toBe(true);
+      expect(cache.annIndex).toBeTruthy();
+      expect(lastHnswInstance.ef).toBe(32);
+    });
+  });
+
+  it('builds ANN index and saves when cache is enabled', async () => {
+    await withTempDir(async (dir) => {
+      const config = await createConfig(dir);
+      config.annIndexCache = true;
+      const cache = new EmbeddingsCache(config);
+      cache.vectorStore = [{ file: 'a.js', vector: [1, 2] }];
+
+      const index = await cache.buildAnnIndex(FakeHnsw, 2);
+
+      expect(index).toBeTruthy();
+      expect(cache.annDirty).toBe(false);
+      const metaFile = path.join(dir, 'ann-meta.json');
+      const metaExists = await fs.readFile(metaFile, 'utf-8');
+      expect(JSON.parse(metaExists).count).toBe(1);
+    });
+  });
+
+  it('reuses hnswlib promise across index builds', async () => {
+    await withTempDir(async (dir) => {
+      const config = await createConfig(dir);
+      config.annIndexCache = false;
+      const cache = new EmbeddingsCache(config);
+      cache.vectorStore = [{ file: 'a.js', vector: [1, 2] }];
+
+      const first = await cache.ensureAnnIndex();
+      expect(first).toBeTruthy();
+
+      cache.annIndex = null;
+      cache.annDirty = true;
+      const second = await cache.ensureAnnIndex();
+      expect(second).toBeTruthy();
+    });
+  });
+
+  it('returns null when ANN labels are invalid', async () => {
+    await withTempDir(async (dir) => {
+      const config = await createConfig(dir);
+      const cache = new EmbeddingsCache(config);
+      cache.vectorStore = [{ file: 'a.js', vector: [1, 2] }];
+
+      const mockIndex = {
+        searchKnn: () => ({ labels: [-1, 10] }),
+      };
+      vi.spyOn(cache, 'ensureAnnIndex').mockResolvedValue(mockIndex);
+
+      const result = await cache.queryAnn([1, 2], 2);
+      expect(result).toEqual([]);
+    });
+  });
+
+  it('uses default values in ANN and call-graph stats', async () => {
+    await withTempDir(async (dir) => {
+      const config = await createConfig(dir);
+      delete config.annEnabled;
+      delete config.callGraphEnabled;
+      const cache = new EmbeddingsCache(config);
+
+      const annStats = cache.getAnnStats();
+      const callStats = cache.getCallGraphStats();
+
+      expect(annStats.enabled).toBe(false);
+      expect(callStats.enabled).toBe(false);
+    });
+  });
+
+  it('logs when call-graph cache removal fails', async () => {
+    await withTempDir(async (dir) => {
+      const config = await createConfig(dir);
+      config.verbose = true;
+      const cache = new EmbeddingsCache(config);
+      const rmSpy = vi.spyOn(fs, 'rm').mockRejectedValue(new Error('rm failed'));
+
+      await cache.clearCallGraphData({ removeFile: true });
+
+      const called = console.warn.mock.calls.some(
+        (call) =>
+          typeof call[0] === 'string' && call[0].includes('Failed to remove call-graph cache')
+      );
+      expect(called).toBe(true);
+      rmSpy.mockRestore();
+    });
+  });
+
+  it('handles missing cacheData or hashData in load', async () => {
+    await withTempDir(async (dir) => {
+      const config = await createConfig(dir);
+      const cache = new EmbeddingsCache(config);
+      const meta = { version: 1, embeddingModel: config.embeddingModel };
+      await fs.writeFile(path.join(dir, 'meta.json'), JSON.stringify(meta));
+      // embeddings.json and file-hashes.json are missing
+      await cache.load();
+      expect(cache.getVectorStore()).toEqual([]);
+    });
+  });
+
+  it('handles index without setEf', async () => {
+    await withTempDir(async (dir) => {
+      const config = await createConfig(dir);
+      const cache = new EmbeddingsCache(config);
+      cache.vectorStore = [{ file: 'a.js', vector: [1, 2] }];
+
+      class NoEfIndex {
+        constructor() {}
+        initIndex() {}
+        addPoint() {}
+        readIndexSync() {
+          return true;
+        }
+        writeIndexSync() {}
+      }
+
+      const meta = {
+        version: 1,
+        embeddingModel: config.embeddingModel,
+        metric: config.annMetric,
+        dim: 2,
+        count: 1,
+        m: config.annM,
+        efConstruction: config.annEfConstruction,
+      };
+      await fs.writeFile(path.join(dir, 'ann-meta.json'), JSON.stringify(meta));
+      await fs.writeFile(path.join(dir, 'ann-index.bin'), '');
+
+      await cache.loadAnnIndexFromDisk(NoEfIndex, 2);
+      expect(cache.annIndex).toBeInstanceOf(NoEfIndex);
+
+      cache.annIndex = null;
+      cache.annDirty = true;
+      await cache.buildAnnIndex(NoEfIndex, 2);
+      expect(cache.annIndex).toBeInstanceOf(NoEfIndex);
+    });
+  });
+
+  it('handles verbose false in clearCallGraphData failure', async () => {
+    await withTempDir(async (dir) => {
+      const config = await createConfig(dir);
+      config.verbose = false;
+      const cache = new EmbeddingsCache(config);
+      const rmSpy = vi.spyOn(fs, 'rm').mockRejectedValue(new Error('rm failed'));
+
+      await cache.clearCallGraphData({ removeFile: true });
+
+      expect(console.warn).not.toHaveBeenCalledWith(
+        expect.stringContaining('Failed to remove call-graph cache')
+      );
+      rmSpy.mockRestore();
+    });
+  });
+});

package/test/call-graph.test.js

@@ -1,5 +1,12 @@
 import { describe, it, expect } from 'vitest';
-import { extractCallData, extractDefinitions, extractCalls, buildCallGraph, getRelatedFiles } from '../lib/call-graph.js';
+import {
+  extractCallData,
+  extractDefinitions,
+  extractCalls,
+  buildCallGraph,
+  getRelatedFiles,
+  extractSymbolsFromContent,
+} from '../lib/call-graph.js';
 
 describe('Call Graph Extractor', () => {
   describe('extractDefinitions', () => {
@@ -52,6 +59,48 @@ describe('Call Graph Extractor', () => {
       expect(defs).toContain('main');
       expect(defs).toContain('Start');
     });
+
+    it('should extract Rust function declarations', () => {
+      const content = `
+        fn main() {}
+        impl Server {
+          fn start() {}
+        }
+      `;
+      const defs = extractDefinitions(content, 'test.rs');
+      expect(defs).toContain('main');
+      expect(defs).toContain('Server');
+      expect(defs).toContain('start');
+    });
+
+    it('should extract Java function declarations', () => {
+      const content = `
+        class Main {
+          public static void main(String[] args) {}
+        }
+      `;
+      const defs = extractDefinitions(content, 'test.java');
+      expect(defs).toContain('Main');
+      expect(defs).toContain('main');
+    });
+
+    it('should extract JavaScript function declarations from jsx', () => {
+      const content = `
+        function foo() {}
+        const bar = () => {};
+      `;
+      const defs = extractDefinitions(content, 'test.jsx');
+      expect(defs).toContain('foo');
+      expect(defs).toContain('bar');
+    });
+
+    it('should default to JavaScript patterns for unknown extensions', () => {
+      const content = `
+        function defaulted() {}
+      `;
+      const defs = extractDefinitions(content, 'notes.txt');
+      expect(defs).toContain('defaulted');
+    });
   });
 
   describe('extractCalls', () => {
@@ -84,12 +133,26 @@ describe('Call Graph Extractor', () => {
     it('should not extract calls from strings', () => {
       const content = `
         const str = "someFunction()";
-        const template = \`anotherFunction()\`;
+        const template = 
       `;
       const calls = extractCalls(content, 'test.js');
       expect(calls).not.toContain('someFunction');
       expect(calls).not.toContain('anotherFunction');
     });
+
+    it('should ignore Python comments and docstrings', () => {
+      const content = `
+        def foo():
+            """docstring call inDocstring()"""
+            bar()
+            # commentCall()
+            return
+      `;
+      const calls = extractCalls(content, 'test.py');
+      expect(calls).toContain('bar');
+      expect(calls).not.toContain('inDocstring');
+      expect(calls).not.toContain('commentCall');
+    });
   });
 
   describe('extractCallData', () => {
@@ -112,7 +175,7 @@ describe('Call Graph Extractor', () => {
       const fileData = new Map([
         ['/path/a.js', { definitions: ['funcA'], calls: ['funcB'] }],
         ['/path/b.js', { definitions: ['funcB'], calls: ['funcC'] }],
-        ['/path/c.js', { definitions: ['funcC'], calls: [] }]
+        ['/path/c.js', { definitions: ['funcC'], calls: [] }],
       ]);
 
       const graph = buildCallGraph(fileData);
@@ -128,7 +191,7 @@ describe('Call Graph Extractor', () => {
     it('should find callers and callees', () => {
       const fileData = new Map([
         ['/path/a.js', { definitions: ['funcA'], calls: ['funcB'] }],
-        ['/path/b.js', { definitions: ['funcB'], calls: [] }]
+        ['/path/b.js', { definitions: ['funcB'], calls: [] }],
       ]);
 
       const graph = buildCallGraph(fileData);
@@ -138,5 +201,41 @@ describe('Call Graph Extractor', () => {
       expect(related.has('/path/a.js')).toBe(true);
       expect(related.has('/path/b.js')).toBe(true);
     });
+
+    it('should stop immediately when maxHops is negative', () => {
+      const graph = buildCallGraph(
+        new Map([['/path/a.js', { definitions: ['funcA'], calls: ['funcB'] }]])
+      );
+
+      const related = getRelatedFiles(graph, ['funcB'], -1);
+
+      expect(related.size).toBe(0);
+    });
+
+    it('should handle missing fileCalls entries on deeper hops', () => {
+      const defines = new Map([['funcA', ['/path/a.js']]]);
+      const calledBy = new Map([['funcA', ['/path/b.js']]]);
+      const fileCalls = new Map([['/path/a.js', ['funcA']]]);
+      const graph = { defines, calledBy, fileCalls };
+
+      const related = getRelatedFiles(graph, ['funcA'], 2);
+
+      expect(related.has('/path/a.js')).toBe(true);
+      expect(related.has('/path/b.js')).toBe(true);
+    });
+  });
+
+  describe('extractSymbolsFromContent', () => {
+    it('should extract symbols from result snippets', () => {
+      const content = `
+        function alpha() {}
+        class Beta {}
+        const gamma = () => {};
+      `;
+      const symbols = extractSymbolsFromContent(content);
+      expect(symbols).toContain('alpha');
+      expect(symbols).toContain('Beta');
+      expect(symbols).toContain('gamma');
+    });
   });
 });