@softerist/heuristic-mcp 2.1.47 → 3.0.0

package/test/cache-helpers.test.js

@@ -0,0 +1,205 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { EmbeddingsCache } from '../lib/cache.js';
+import fs from 'fs/promises';
+
+vi.mock('fs/promises');
+
+// Basic mock index for stats
+const mockIndex = {
+  setEf: vi.fn(),
+  efConstruction: 200,
+  m: 48,
+  getK: vi.fn(),
+};
+
+describe('EmbeddingsCache Helper Methods', () => {
+  let cache;
+  let config;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    config = {
+      enableCache: true,
+      cacheDirectory: '/mock/cache',
+      annEnabled: true,
+      annEfSearch: 10,
+
+      callGraphEnabled: true,
+      callGraphMaxHops: 2,
+      verbose: true,
+    };
+    cache = new EmbeddingsCache(config);
+
+    // Spy on console
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  describe('EF Search Configuration', () => {
+    it('should validate efSearch input', () => {
+      expect(cache.setEfSearch('invalid').success).toBe(false);
+      expect(cache.setEfSearch(0).success).toBe(false);
+      expect(cache.setEfSearch(1001).success).toBe(false);
+    });
+
+    it('should update config when index not loaded', () => {
+      const result = cache.setEfSearch(100);
+      expect(result.success).toBe(true);
+      expect(result.applied).toBe(false);
+      expect(cache.config.annEfSearch).toBe(100);
+    });
+
+    it('should update active index if loaded', () => {
+      cache.annIndex = mockIndex;
+      const result = cache.setEfSearch(50);
+      expect(result.success).toBe(true);
+      expect(result.applied).toBe(true);
+      expect(mockIndex.setEf).toHaveBeenCalledWith(50);
+    });
+  });
+
+  describe('ANN Stats', () => {
+    it('should return stats with no index', () => {
+      const stats = cache.getAnnStats();
+      expect(stats.indexLoaded).toBe(false);
+      expect(stats.enabled).toBe(true);
+    });
+
+    it('should return stats with index meta', () => {
+      cache.annMeta = {
+        metric: 'cosine',
+        dim: 128,
+        count: 10,
+        m: 16,
+        efConstruction: 100,
+      };
+      cache.annIndex = {};
+      const stats = cache.getAnnStats();
+      expect(stats.indexLoaded).toBe(true);
+      expect(stats.config.metric).toBe('cosine');
+    });
+  });
+
+  describe('Vector Store Helpers', () => {
+    it('normalizes vectors when setting the store', () => {
+      const store = [{ file: 'a.js', vector: [1, 2, 3] }];
+      cache.setVectorStore(store);
+
+      const [chunk] = cache.getVectorStore();
+      expect(chunk.vector).toBeInstanceOf(Float32Array);
+    });
+  });
+
+  describe('Call Graph Helper Methods', () => {
+    it('should manage file call data', () => {
+      const file = 'test.js';
+      const data = { valid: true };
+
+      cache.setFileCallData(file, data);
+      expect(cache.getFileCallData(file)).toBe(data);
+      expect(cache.callGraph).toBeNull(); // invalidation
+
+      cache.removeFileCallData(file);
+      expect(cache.getFileCallData(file)).toBeUndefined();
+    });
+
+    it('should clear call graph data and file', async () => {
+      cache.setFileCallData('a.js', {});
+      await cache.clearCallGraphData({ removeFile: true });
+
+      expect(cache.getFileCallDataCount()).toBe(0);
+      expect(fs.rm).toHaveBeenCalledWith(
+        expect.stringContaining('call-graph.json'),
+        expect.any(Object)
+      );
+    });
+
+    it('should handle pruning', () => {
+      cache.setFileCallData('a.js', {});
+      cache.setFileCallData('b.js', {});
+
+      const validFiles = new Set(['a.js']);
+      const pruned = cache.pruneCallGraphData(validFiles);
+
+      expect(pruned).toBe(1);
+      expect(cache.getFileCallData('b.js')).toBeUndefined();
+      expect(cache.getFileCallData('a.js')).toBeDefined();
+    });
+
+    it('should handle pruning with no valid files set (guard)', () => {
+      expect(cache.pruneCallGraphData(null)).toBe(0);
+    });
+  });
+
+  describe('Call Graph Lazy Loading', () => {
+    beforeEach(() => {
+      vi.resetModules();
+      // We need to re-import CodebaseIndexer or Cache if we were testing its internal dynamic imports,
+      // but we are testing cache.js which does dynamic imports of call-graph.js.
+      // We mock call-graph.js
+      const fakeGraph = { defines: new Map(), calledBy: new Map() };
+      vi.doMock('../lib/call-graph.js', () => ({
+        buildCallGraph: vi.fn(() => fakeGraph),
+        getRelatedFiles: vi.fn(() => new Map([['related.js', 1]])),
+      }));
+    });
+
+    it('rebuildCallGraph should handle import and build', async () => {
+      // Re-instantiate to ensure clean state
+      const { EmbeddingsCache } = await import('../lib/cache.js');
+      const cache = new EmbeddingsCache({ ...config, verbose: true });
+
+      cache.setFileCallData('f.js', {});
+
+      // Spy on console to verify success
+      const logSpy = vi.spyOn(console, 'info');
+
+      // Trigger rebuild
+      await cache.rebuildCallGraph();
+
+      // Wait for microtask resolution of dynamic import
+      await new Promise((r) => setTimeout(r, 10));
+
+      expect(cache.callGraph).toBeDefined();
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Built graph'));
+    });
+
+    it('rebuildCallGraph should handle errors', async () => {
+      vi.doMock('../lib/call-graph.js', () => ({
+        buildCallGraph: vi.fn(() => {
+          throw new Error('Build failed');
+        }),
+      }));
+
+      const { EmbeddingsCache } = await import('../lib/cache.js');
+      const cache = new EmbeddingsCache({ ...config, verbose: true });
+
+      const logSpy = vi.spyOn(console, 'error');
+      cache.rebuildCallGraph();
+
+      await new Promise((r) => setTimeout(r, 10));
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to build'));
+    });
+
+    it('getRelatedFiles should rebuild graph if missing', async () => {
+      const { EmbeddingsCache } = await import('../lib/cache.js');
+      const cache = new EmbeddingsCache(config);
+      cache.setFileCallData('f.js', {});
+
+      const result = await cache.getRelatedFiles(['sym']);
+
+      expect(result.size).toBe(1); // Mock returns 1 item
+      expect(cache.callGraph).toBeDefined();
+    });
+
+    it('getRelatedFiles should return empty if disabled or empty', async () => {
+      const { EmbeddingsCache } = await import('../lib/cache.js');
+      // Disabled
+      let c = new EmbeddingsCache({ ...config, callGraphEnabled: false });
+      expect((await c.getRelatedFiles(['s'])).size).toBe(0);
+
+      // Empty symbols
+      c = new EmbeddingsCache(config);
+      expect((await c.getRelatedFiles([])).size).toBe(0);
+    });
+  });
+});

package/test/cache-hnsw-failure.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock fs to avoid actual file I/O
+vi.mock('fs/promises');
+
+// Mock hnswlib-node to fail loading
+vi.mock('hnswlib-node', () => {
+  throw new Error('Module not found or load error');
+});
+
+describe('EmbeddingsCache HNSW Failures', () => {
+  it('should handle hnswlib import failure gracefully', async () => {
+    // Need to dynamic import cache to trigger the hnswlib import attempt (if it wasn't already cached by other tests, but Vitest isolates files)
+    const { EmbeddingsCache } = await import('../lib/cache.js');
+
+    const config = {
+      enableCache: true,
+      annEnabled: true,
+      annMinChunks: 1,
+      cacheDirectory: '/tmp/test-hnsw-fail',
+      fileExtensions: ['js'],
+      embeddingModel: 'test',
+    };
+    const cache = new EmbeddingsCache(config);
+
+    // Add chunks to trigger ANN condition
+    cache.vectorStore = [
+      { file: 'a.js', vector: [1, 0] },
+      { file: 'b.js', vector: [0, 1] },
+    ];
+
+    // Attempt to ensure index
+    const index = await cache.ensureAnnIndex();
+
+    // Should be null because hnswlib failed to load
+    expect(index).toBeNull();
+
+    // Should also check console.error behavior if desired
+  });
+});

package/test/cache-json-worker.test.js

@@ -0,0 +1,190 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { EventEmitter } from 'events';
+
+const baseConfig = {
+  enableCache: true,
+  cacheDirectory: '/cache',
+  embeddingModel: 'test-model',
+  fileExtensions: ['js'],
+  excludePatterns: [],
+  annEnabled: false,
+  callGraphEnabled: false,
+  verbose: true,
+};
+
+afterEach(() => {
+  vi.resetModules();
+  vi.restoreAllMocks();
+});
+
+describe('EmbeddingsCache JSON worker parsing', () => {
+  it('uses a worker to parse large JSON files', async () => {
+    const Worker = vi.fn(function (_url, options) {
+      const worker = new EventEmitter();
+      const filePath = options.workerData.filePath;
+      const data = filePath.endsWith('embeddings.json') ? [] : {};
+      setImmediate(() => {
+        worker.emit('message', { ok: true, data });
+      });
+      return worker;
+    });
+
+    const fsMock = {
+      mkdir: vi.fn().mockResolvedValue(undefined),
+      stat: vi.fn().mockResolvedValue({ size: 6 * 1024 * 1024 }),
+      readFile: vi.fn((filePath) => {
+        if (filePath.endsWith('meta.json')) {
+          return Promise.resolve(
+            JSON.stringify({ version: 1, embeddingModel: baseConfig.embeddingModel })
+          );
+        }
+        return Promise.reject(new Error('missing'));
+      }),
+    };
+
+    vi.doMock('worker_threads', () => ({ Worker }));
+    vi.doMock('fs/promises', () => ({
+      default: fsMock,
+      ...fsMock,
+    }));
+
+    const { EmbeddingsCache } = await import('../lib/cache.js');
+    const cache = new EmbeddingsCache(baseConfig);
+
+    await cache.load();
+
+    expect(Worker).toHaveBeenCalledTimes(2);
+    expect(cache.getVectorStore()).toEqual([]);
+  });
+
+  it('logs when the JSON worker reports a parse error', async () => {
+    const Worker = vi.fn(function () {
+      const worker = new EventEmitter();
+      setImmediate(() => {
+        worker.emit('message', { ok: false, error: 'bad json' });
+      });
+      return worker;
+    });
+
+    const fsMock = {
+      mkdir: vi.fn().mockResolvedValue(undefined),
+      stat: vi.fn().mockResolvedValue({ size: 6 * 1024 * 1024 }),
+      readFile: vi.fn((filePath) => {
+        if (filePath.endsWith('meta.json')) {
+          return Promise.resolve(
+            JSON.stringify({ version: 1, embeddingModel: baseConfig.embeddingModel })
+          );
+        }
+        return Promise.reject(new Error('missing'));
+      }),
+    };
+
+    vi.doMock('worker_threads', () => ({ Worker }));
+    vi.doMock('fs/promises', () => ({
+      default: fsMock,
+      ...fsMock,
+    }));
+
+    const { EmbeddingsCache } = await import('../lib/cache.js');
+    const cache = new EmbeddingsCache(baseConfig);
+    const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    await cache.load();
+
+    const hasParseError = consoleSpy.mock.calls.some(
+      (call) => typeof call[0] === 'string' && call[0].includes('Failed to parse embeddings.json')
+    );
+    expect(hasParseError).toBe(true);
+
+    consoleSpy.mockRestore();
+  });
+
+  it('logs when the JSON worker exits with a failure code', async () => {
+    const Worker = vi.fn(function () {
+      const worker = new EventEmitter();
+      setImmediate(() => {
+        worker.emit('exit', 1);
+      });
+      return worker;
+    });
+
+    const fsMock = {
+      mkdir: vi.fn().mockResolvedValue(undefined),
+      stat: vi.fn().mockResolvedValue({ size: 6 * 1024 * 1024 }),
+      readFile: vi.fn((filePath) => {
+        if (filePath.endsWith('meta.json')) {
+          return Promise.resolve(
+            JSON.stringify({ version: 1, embeddingModel: baseConfig.embeddingModel })
+          );
+        }
+        return Promise.reject(new Error('missing'));
+      }),
+    };
+
+    vi.doMock('worker_threads', () => ({ Worker }));
+    vi.doMock('fs/promises', () => ({
+      default: fsMock,
+      ...fsMock,
+    }));
+
+    const { EmbeddingsCache } = await import('../lib/cache.js');
+    const cache = new EmbeddingsCache(baseConfig);
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await cache.load();
+
+    const hasExitError = consoleSpy.mock.calls.some(
+      (call) => typeof call[0] === 'string' && call[0].includes('JSON worker exited with code')
+    );
+    expect(hasExitError).toBe(true);
+
+    consoleSpy.mockRestore();
+  });
+
+  it('ignores subsequent events after settlement (covers settled guard)', async () => {
+    // This targets the "if (settled) return;" line in the finish function.
+    // We manually invoke the message handler twice to force a second finish call.
+    const Worker = vi.fn(function () {
+      const worker = {
+        once(event, handler) {
+          if (event === 'message') {
+            setImmediate(() => {
+              handler({ ok: true, data: [] });
+              handler({ ok: false, error: 'late' });
+            });
+          }
+          return worker;
+        },
+        removeAllListeners: vi.fn(),
+        terminate: vi.fn(() => Promise.resolve()),
+      };
+      return worker;
+    });
+
+    const fsMock = {
+      mkdir: vi.fn().mockResolvedValue(undefined),
+      stat: vi.fn().mockResolvedValue({ size: 6 * 1024 * 1024 }),
+      readFile: vi.fn((filePath) => {
+        if (filePath.endsWith('meta.json')) {
+          return Promise.resolve(
+            JSON.stringify({ version: 1, embeddingModel: baseConfig.embeddingModel })
+          );
+        }
+        return Promise.reject(new Error('missing'));
+      }),
+    };
+
+    vi.doMock('worker_threads', () => ({ Worker }));
+    vi.doMock('fs/promises', () => ({
+      default: fsMock,
+      ...fsMock,
+    }));
+
+    const { EmbeddingsCache } = await import('../lib/cache.js');
+    const cache = new EmbeddingsCache(baseConfig);
+    // Should not throw or log an error about double-resolution
+    await cache.load();
+    
+    expect(Worker).toHaveBeenCalled();
+  });
+});

package/test/cache-worker.test.js

@@ -0,0 +1,102 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { EmbeddingsCache } from '../lib/cache.js';
+
+// Hoist the mock worker
+const { mockWorker } = vi.hoisted(() => {
+    const worker = {
+        on: vi.fn(),
+        once: vi.fn(),
+        removeAllListeners: vi.fn(),
+        terminate: vi.fn(),
+        postMessage: vi.fn(),
+        unref: vi.fn()
+    };
+    return { mockWorker: worker };
+});
+
+// Use a shared variable to track execution
+let terminateCatchCalled = false;
+
+// Mock fs
+vi.mock('fs/promises', async () => {
+    return {
+        default: {
+            stat: vi.fn().mockResolvedValue({ 
+                size: 6 * 1024 * 1024,
+                isDirectory: () => false
+            }),
+            readFile: vi.fn().mockResolvedValue('[]'),
+            mkdir: vi.fn().mockResolvedValue(),
+            writeFile: vi.fn().mockResolvedValue(),
+            rm: vi.fn().mockResolvedValue(),
+        }
+    }
+});
+
+// Mock worker_threads
+vi.mock('worker_threads', () => {
+    return {
+        Worker: class {
+            constructor() {
+                return mockWorker;
+            }
+        }
+    };
+});
+
+describe('Cache Worker Termination', () => {
+    let cache;
+    const config = {
+        enableCache: true,
+        cacheDirectory: '/test/cache',
+        fileExtensions: ['js'],
+        embeddingModel: 'test-model'
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        terminateCatchCalled = false;
+        
+        // Setup worker to simulate successful message
+        mockWorker.once.mockImplementation((event, handler) => {
+            if (event === 'message') {
+                setTimeout(() => {
+                    // cache.js expects ok: true
+                    handler({ ok: true, data: [] });
+                }, 10);
+            }
+        });
+        
+        mockWorker.on.mockImplementation((event, handler) => {
+             if (event === 'message') {
+                setTimeout(() => handler({ ok: true, data: [] }), 10);
+            }
+        });
+        
+        // Default terminate behavior
+        mockWorker.terminate.mockResolvedValue(undefined);
+        
+        cache = new EmbeddingsCache(config);
+    });
+
+    it('should handle worker termination errors (line 29 coverage)', async () => {
+        // Setup terminate to return an object with catch() that sets the flag
+        // We use mockReturnValue to ensure it returns exactly this object
+        const fakePromise = {
+             catch: (cb) => { 
+                 terminateCatchCalled = true; 
+                 if (cb) cb();
+                 return Promise.resolve();
+             },
+             then: (cb) => { if (cb) cb(); return Promise.resolve(); }
+        };
+
+        mockWorker.terminate.mockReturnValue(fakePromise);
+        
+        await cache.load();
+        
+        expect(mockWorker.terminate).toHaveBeenCalled();
+        expect(terminateCatchCalled).toBe(true);
+    });
+});