@softerist/heuristic-mcp 2.1.47 → 3.0.0

package/test/embedding-worker.test.js

@@ -0,0 +1,158 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('@xenova/transformers', () => ({
+  pipeline: vi.fn(),
+  env: {
+    backends: {
+      onnx: {
+        wasm: { numThreads: null },
+        numThreads: null,
+      },
+    },
+  },
+}));
+vi.mock('worker_threads', () => ({
+  parentPort: {
+    on: vi.fn(),
+    postMessage: vi.fn(),
+  },
+  workerData: {
+    embeddingModel: 'test-model',
+  },
+}));
+
+import { pipeline } from '@xenova/transformers';
+import { parentPort, workerData } from 'worker_threads';
+
+const tick = () => new Promise((resolve) => setImmediate(resolve));
+
+describe('embedding-worker', () => {
+  let exitSpy;
+  let messageHandler;
+
+  beforeEach(() => {
+    vi.resetModules();
+    messageHandler = null;
+    parentPort.on.mockReset();
+    parentPort.on.mockImplementation((event, handler) => {
+      if (event === 'message') messageHandler = handler;
+    });
+    parentPort.postMessage.mockReset();
+    workerData.embeddingModel = 'test-model';
+    pipeline.mockReset();
+    pipeline.mockImplementation(() => Promise.resolve({}));
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    exitSpy.mockRestore();
+  });
+
+  it('processes chunks and posts results', async () => {
+    pipeline.mockResolvedValue(async () => ({
+      data: Float32Array.from([1, 2]),
+    }));
+
+    await import('../lib/embedding-worker.js');
+    await tick();
+
+    expect(parentPort.postMessage).toHaveBeenCalledWith({ type: 'ready' });
+
+    await messageHandler({
+      type: 'process',
+      chunks: [{ file: 'a.js', startLine: 1, endLine: 2, text: 'code' }],
+      batchId: 'batch-1',
+    });
+
+    const resultsCall = parentPort.postMessage.mock.calls.find(
+      (call) => call[0]?.type === 'results'
+    );
+    expect(resultsCall).toBeDefined();
+    const [payload, transferList] = resultsCall;
+    expect(payload.batchId).toBe('batch-1');
+    expect(payload.done).toBe(true);
+    expect(payload.results).toHaveLength(1);
+    const result = payload.results[0];
+    expect(result.vector).toBeInstanceOf(Float32Array);
+    expect(Array.from(result.vector)).toEqual([1, 2]);
+    expect(transferList).toEqual([result.vector.buffer]);
+  });
+
+  it('captures embedding errors per chunk', async () => {
+    pipeline.mockResolvedValue(async () => {
+      throw new Error('embed fail');
+    });
+
+    await import('../lib/embedding-worker.js');
+    await tick();
+
+    await messageHandler({
+      type: 'process',
+      chunks: [{ file: 'b.js', startLine: 3, endLine: 4, text: 'bad' }],
+      batchId: 'batch-2',
+    });
+
+    const message = parentPort.postMessage.mock.calls.find((call) => call[0].type === 'results')[0];
+    expect(message.results[0].success).toBe(false);
+    expect(message.results[0].error).toBe('embed fail');
+  });
+
+  it('reports initialization failures', async () => {
+    pipeline.mockRejectedValue(new Error('init fail'));
+
+    await import('../lib/embedding-worker.js');
+    await tick();
+
+    expect(parentPort.postMessage).toHaveBeenCalledWith({
+      type: 'error',
+      error: 'init fail',
+    });
+  });
+
+  it('reports process errors when initialization fails', async () => {
+    pipeline.mockRejectedValue(new Error('init fail'));
+
+    await import('../lib/embedding-worker.js');
+    await tick();
+
+    await messageHandler({
+      type: 'process',
+      chunks: [{ file: 'c.js', startLine: 1, endLine: 2, text: 'x' }],
+      batchId: 'batch-3',
+    });
+
+    expect(parentPort.postMessage).toHaveBeenCalledWith({
+      type: 'error',
+      error: 'init fail',
+      batchId: 'batch-3',
+    });
+  });
+
+  it('shuts down on shutdown messages', async () => {
+    pipeline.mockResolvedValue(async () => ({
+      data: Float32Array.from([1, 2]),
+    }));
+
+    await import('../lib/embedding-worker.js');
+    await tick();
+
+    await messageHandler({ type: 'shutdown' });
+
+    expect(exitSpy).toHaveBeenCalledWith(0);
+  });
+
+  it('ignores unknown message types', async () => {
+    await import('../lib/embedding-worker.js');
+    await tick();
+
+    await messageHandler({ type: 'unknown' });
+
+    // Should throw error for unknown message type
+    expect(parentPort.postMessage).toHaveBeenCalledTimes(2);
+    expect(parentPort.postMessage).toHaveBeenCalledWith({ type: 'ready' });
+    expect(parentPort.postMessage).toHaveBeenCalledWith({ 
+      type: 'error', 
+      error: 'Unknown message type: unknown' 
+    });
+  });
+});

package/test/features.test.js

@@ -0,0 +1,139 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as annConfig from '../features/ann-config.js';
+import * as findSimilar from '../features/find-similar-code.js';
+
+describe('Features Coverage Maximizer', () => {
+  describe('ann-config.js', () => {
+    it('covers tool definition and handleToolCall actions', async () => {
+      expect(annConfig.getToolDefinition()).toBeDefined();
+
+      const mockCache = {
+        getAnnStats: () => ({
+          enabled: true,
+          indexLoaded: true,
+          dirty: false,
+          vectorCount: 10,
+          minChunksForAnn: 5000,
+          config: {
+            metric: 'l2',
+            dim: 128,
+            count: 10,
+            m: 16,
+            efConstruction: 200,
+            efSearch: 50,
+          },
+        }),
+        setEfSearch: vi.fn().mockReturnValue({ success: true }),
+        invalidateAnnIndex: vi.fn(),
+        ensureAnnIndex: vi.fn().mockResolvedValue({}),
+      };
+
+      const tool = new annConfig.AnnConfigTool(mockCache, {});
+
+      // Action: stats
+      const r1 = await annConfig.handleToolCall(
+        { params: { arguments: { action: 'stats' } } },
+        tool
+      );
+      expect(r1.content[0].text).toContain('ANN Index Statistics');
+
+      // Action: set_ef_search
+      const r2 = await annConfig.handleToolCall(
+        { params: { arguments: { action: 'set_ef_search', efSearch: 100 } } },
+        tool
+      );
+      expect(r2.content[0].text).toContain('true');
+
+      // Action: rebuild
+      const r3 = await annConfig.handleToolCall(
+        { params: { arguments: { action: 'rebuild' } } },
+        tool
+      );
+      expect(r3.content[0].text).toContain('true');
+
+      // Error path: Unknown action
+      const r4 = await tool.execute({ action: 'unknown' });
+      expect(r4.success).toBe(false);
+      expect(tool.formatResults(r4)).toContain('Error');
+
+      // Missing parameter for set_ef_search (line 27)
+      const r5 = await tool.execute({ action: 'set_ef_search' });
+      expect(r5.success).toBe(false);
+
+      // No active ANN index output (line 68)
+      const r6 = tool.formatResults({
+        enabled: true,
+        indexLoaded: false,
+        config: null,
+      });
+      expect(r6).toContain('No active ANN index');
+    });
+  });
+
+  describe('find-similar-code.js', () => {
+    it('covers tool definition and handleToolCall search', async () => {
+      expect(findSimilar.getToolDefinition({})).toBeDefined();
+
+      const mockCache = {
+        getVectorStore: () => [
+          {
+            file: 'a.js',
+            content: 'test code line',
+            vector: [1, 0],
+            startLine: 1,
+            endLine: 1,
+          },
+        ],
+        queryAnn: vi.fn().mockResolvedValue([0]),
+        getChunkVector: (c) => c.vector,
+        getChunkContent: (c) => c.content,
+      };
+
+      const mockEmbedder = vi.fn().mockResolvedValue({ data: new Float32Array([1, 0]) });
+      const tool = new findSimilar.FindSimilarCode(mockEmbedder, mockCache, {
+        annEnabled: true,
+        searchDirectory: '/root',
+      });
+
+      const request = {
+        params: {
+          arguments: {
+            code: 'different search',
+            maxResults: 1,
+            minSimilarity: 0.1,
+          },
+        },
+      };
+      const result = await findSimilar.handleToolCall(request, tool);
+      if (!result.content[0].text.includes('Similar Code')) {
+        console.info('DEBUG [features]: Result text:', result.content[0].text);
+      }
+      expect(result.content[0].text).toContain('Similar Code');
+    });
+
+    it('handles search with no results', async () => {
+      const mockCache = {
+        getVectorStore: () => [],
+        queryAnn: vi.fn().mockResolvedValue([]),
+        getChunkVector: (c) => c.vector,
+        getChunkContent: (c) => c.content,
+      };
+      const mockEmbedder = vi.fn().mockResolvedValue({ data: [0.1] });
+      const tool = new findSimilar.FindSimilarCode(mockEmbedder, mockCache, {
+        searchDirectory: '/root',
+      });
+
+      const result = await findSimilar.handleToolCall(
+        { params: { arguments: { code: 'x' } } },
+        tool
+      );
+      expect(result.content[0].text).toContain('No code has been indexed yet');
+
+      // Force "No similar code found" message (line 96)
+      tool.config.annEnabled = false;
+      mockCache.getVectorStore = () => [{ file: 'a.js', content: 'y', vector: [0, 1] }]; // No match
+      const r3 = await tool.execute({ code: 'z', minSimilarity: 0.9 });
+      await expect(tool.formatResults(r3.results)).resolves.toContain('No similar code patterns found');
+    });
+  });
+});

package/test/final-boost.test.js

@@ -0,0 +1,271 @@
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { EmbeddingsCache } from '../lib/cache.js';
+import * as callGraph from '../lib/call-graph.js';
+import fs from 'fs/promises';
+import { Worker } from 'worker_threads';
+import EventEmitter from 'events';
+
+// Mock worker_threads
+vi.mock('worker_threads', () => {
+  return {
+    Worker: vi.fn(),
+  };
+});
+
+// Mock fs/promises
+vi.mock('fs/promises', () => {
+  return {
+    default: {
+      stat: vi.fn().mockResolvedValue({ size: 100 }),
+      readFile: vi.fn().mockResolvedValue('{}'),
+      mkdir: vi.fn().mockResolvedValue(undefined),
+      writeFile: vi.fn().mockResolvedValue(undefined),
+      rm: vi.fn().mockResolvedValue(undefined),
+    },
+  };
+});
+
+describe('Final Coverage Boost', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('cache.js - Worker Edge Cases', () => {
+    const config = {
+      enableCache: true,
+      cacheDirectory: '/cache',
+      fileExtensions: ['js'],
+      embeddingModel: 'test-model',
+    };
+
+    beforeEach(() => {
+        // Default fs behavior
+        fs.stat.mockResolvedValue({ size: 100 });
+        fs.readFile.mockResolvedValue('{}');
+    });
+
+    it('should handle worker double-settling guard', { timeout: 1000 }, async () => {
+      // Setup: only cache file triggers worker
+      fs.stat.mockImplementation(async (path) => {
+          if (path && path.includes('embeddings.json')) return { size: 6 * 1024 * 1024 };
+          return { size: 100 };
+      });
+
+      // Provide valid meta to avoid early returns (though not strictly needed for this test)
+      fs.readFile.mockImplementation(async (path) => {
+          if (path.includes('meta.json')) return JSON.stringify({ version: 1, embeddingModel: 'test-model' });
+          return '{}';
+      });
+
+      const mockWorker = new EventEmitter();
+      mockWorker.postMessage = vi.fn();
+      mockWorker.terminate = vi.fn();
+      mockWorker.removeAllListeners = vi.fn(); 
+      Worker.mockImplementation(function() { return mockWorker; });
+
+      const cache = new EmbeddingsCache(config);
+      
+      // Wait for the worker to attach the 'message' listener
+      const workerListenerReady = new Promise((resolve) => {
+        mockWorker.on('newListener', (event) => {
+          if (event === 'message') resolve();
+        });
+      });
+
+      const loadPromise = cache.load();
+      
+      await workerListenerReady;
+
+      // Trigger success message
+      mockWorker.emit('message', { ok: true, data: [] });
+      
+      // Immediately trigger exit - acts as second "settle" attempt
+      mockWorker.emit('exit', 0);
+      
+      await loadPromise;
+      
+      // If it didn't throw, we're good.
+      expect(mockWorker.removeAllListeners).toHaveBeenCalled();
+    });
+
+    it('should handle worker error event', async () => {
+      let embeddingsStatCalls = 0;
+      fs.stat.mockImplementation(async (path) => {
+          if (path && path.includes('embeddings.json')) {
+              embeddingsStatCalls++;
+              // Only trigger worker (large size) on first attempt.
+              // On retry (triggered by load() seeing null result), return small size to use fs.readFile.
+              if (embeddingsStatCalls === 1) return { size: 6 * 1024 * 1024 };
+              return { size: 100 };
+          }
+          return { size: 100 };
+      });
+      fs.readFile.mockImplementation(async (path) => {
+          if (path.includes('meta.json')) return JSON.stringify({ version: 1, embeddingModel: 'test-model' });
+          return '{}';
+      });
+
+      const mockWorker = new EventEmitter();
+      mockWorker.postMessage = vi.fn();
+      mockWorker.terminate = vi.fn();
+      mockWorker.removeAllListeners = vi.fn();
+      Worker.mockImplementation(function() { return mockWorker; });
+
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const cache = new EmbeddingsCache(config);
+      
+      const workerListenerReady = new Promise((resolve) => {
+        mockWorker.on('newListener', (event) => {
+          if (event === 'error') resolve();
+        });
+      });
+
+      const loadPromise = cache.load();
+      await workerListenerReady;
+
+      const error = new Error('Worker exploded');
+      mockWorker.emit('error', error);
+
+      await loadPromise;
+      
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Worker exploded'));
+      consoleSpy.mockRestore();
+    });
+
+    it('should handle worker exit with non-zero code', async () => {
+      let embeddingsStatCalls = 0;
+      fs.stat.mockImplementation(async (path) => {
+          if (path && path.includes('embeddings.json')) {
+              embeddingsStatCalls++;
+              if (embeddingsStatCalls === 1) return { size: 6 * 1024 * 1024 };
+              return { size: 100 };
+          }
+          return { size: 100 };
+      });
+      fs.readFile.mockImplementation(async (path) => {
+          if (path.includes('meta.json')) return JSON.stringify({ version: 1, embeddingModel: 'test-model' });
+          return '{}';
+      });
+
+      const mockWorker = new EventEmitter();
+      mockWorker.postMessage = vi.fn();
+      mockWorker.terminate = vi.fn();
+      mockWorker.removeAllListeners = vi.fn();
+      Worker.mockImplementation(function() { return mockWorker; });
+
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const cache = new EmbeddingsCache(config);
+      
+      const workerListenerReady = new Promise((resolve) => {
+        mockWorker.on('newListener', (event) => {
+          if (event === 'exit') resolve();
+        });
+      });
+
+      const loadPromise = cache.load();
+      await workerListenerReady;
+
+      mockWorker.emit('exit', 1);
+
+      await loadPromise;
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('exited with code 1'));
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('cache.js - Verbose Call Graph Loading', () => {
+    it('should log when loading call graph in verbose mode', async () => {
+        const config = {
+            enableCache: true,
+            cacheDirectory: '/cache',
+            fileExtensions: ['js'],
+            embeddingModel: 'test-model',
+            verbose: true
+        };
+        
+        fs.mkdir.mockResolvedValue(undefined);
+        // readFile needs to return null for meta/cache/hash to skip main logic
+        // but return valid JSON for call-graph
+        fs.readFile.mockImplementation(async (path) => {
+            if (path.endsWith('call-graph.json')) {
+                return JSON.stringify({ 'file.js': { definitions: [], calls: [] } });
+            }
+            return null; // triggers "Missing cache metadata" early return, which is after call-graph load?
+            // Wait, call-graph load is inside load().
+        });
+        
+        // We need main cache load to succeed partially or reach the call-graph part.
+        // Looking at cache.js:163, it reads meta, cache, hash.
+        // If meta missing, it returns. We need meta to exist.
+        
+        fs.readFile.mockImplementation(async (filePath) => {
+            if (filePath.endsWith('meta.json')) {
+                return JSON.stringify({ version: 1, embeddingModel: 'test-model' });
+            }
+            if (filePath.endsWith('embeddings.json')) return '[]';
+            if (filePath.endsWith('file-hashes.json')) return '{}';
+            if (filePath.endsWith('call-graph.json')) {
+                return JSON.stringify({ 'file.js': { definitions: [], calls: [] } });
+            }
+            return null;
+        });
+
+        // Mock fs.stat for readJsonFile to avoid worker
+        fs.stat.mockResolvedValue({ size: 100 });
+
+        const consoleSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
+        
+        const cache = new EmbeddingsCache(config);
+        await cache.load();
+        
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('[Cache] Loaded call-graph data'));
+        consoleSpy.mockRestore();
+    });
+  });
+
+  describe('call-graph.js - Coverage Gaps', () => {
+      it('should ignore single-character definitions', () => {
+          const content = `
+            function a() {} 
+            function b() {}
+            class C {}
+          `;
+          const defs = callGraph.extractDefinitions(content, 'test.js');
+          expect(defs).toHaveLength(0);
+      });
+
+      it('should handle merging multiple definitions and calls in buildCallGraph', () => {
+          const fileCallData = new Map();
+          fileCallData.set('file1.js', { definitions: ['CommonFunc'], calls: ['SharedTarget'] });
+          fileCallData.set('file2.js', { definitions: ['CommonFunc'], calls: ['SharedTarget'] });
+          // logic at lines 253, 262: checks if map.has(key)
+          
+          const graph = callGraph.buildCallGraph(fileCallData);
+          
+          expect(graph.defines.get('CommonFunc')).toHaveLength(2);
+          expect(graph.defines.get('CommonFunc')).toContain('file1.js');
+          expect(graph.defines.get('CommonFunc')).toContain('file2.js');
+
+          expect(graph.calledBy.get('SharedTarget')).toHaveLength(2);
+          expect(graph.calledBy.get('SharedTarget')).toContain('file1.js');
+          expect(graph.calledBy.get('SharedTarget')).toContain('file2.js');
+      });
+
+      it('should ignore short symbols in extractSymbolsFromContent', () => {
+          const content = `
+            function a() {}
+            class B {}
+            let c = 1;
+            function ValidName() {}
+          `;
+          const symbols = callGraph.extractSymbolsFromContent(content);
+          expect(symbols).not.toContain('a');
+          expect(symbols).not.toContain('B');
+          expect(symbols).not.toContain('c');
+          expect(symbols).toContain('ValidName');
+      });
+  });
+});