@softerist/heuristic-mcp 2.0.0 → 2.1.1

package/test/call-graph.test.js

@@ -0,0 +1,142 @@
+import { describe, it, expect } from 'vitest';
+import { extractCallData, extractDefinitions, extractCalls, buildCallGraph, getRelatedFiles } from '../lib/call-graph.js';
+
+describe('Call Graph Extractor', () => {
+  describe('extractDefinitions', () => {
+    it('should extract JavaScript function declarations', () => {
+      const content = `
+        function foo() {}
+        async function bar() {}
+        const baz = () => {};
+        let qux = async () => {};
+      `;
+      const defs = extractDefinitions(content, 'test.js');
+      expect(defs).toContain('foo');
+      expect(defs).toContain('bar');
+      expect(defs).toContain('baz');
+      expect(defs).toContain('qux');
+    });
+
+    it('should extract JavaScript class declarations', () => {
+      const content = `
+        class MyClass {
+          myMethod() {}
+        }
+      `;
+      const defs = extractDefinitions(content, 'test.js');
+      expect(defs).toContain('MyClass');
+      expect(defs).toContain('myMethod');
+    });
+
+    it('should extract Python definitions', () => {
+      const content = `
+        def my_function():
+            pass
+
+        class MyClass:
+            def method(self):
+                pass
+      `;
+      const defs = extractDefinitions(content, 'test.py');
+      expect(defs).toContain('my_function');
+      expect(defs).toContain('MyClass');
+      expect(defs).toContain('method');
+    });
+
+    it('should extract Go function declarations', () => {
+      const content = `
+        func main() {}
+        func (s *Server) Start() {}
+      `;
+      const defs = extractDefinitions(content, 'test.go');
+      expect(defs).toContain('main');
+      expect(defs).toContain('Start');
+    });
+  });
+
+  describe('extractCalls', () => {
+    it('should extract function calls', () => {
+      const content = `
+        function main() {
+          foo();
+          bar.baz();
+          await asyncFunc();
+        }
+      `;
+      const calls = extractCalls(content, 'test.js');
+      expect(calls).toContain('foo');
+      expect(calls).toContain('baz'); // bar.baz() -> extracts 'baz'
+      expect(calls).toContain('asyncFunc');
+    });
+
+    it('should exclude built-in keywords', () => {
+      const content = `
+        if (condition) {}
+        for (let i = 0; i < 10; i++) {}
+        while (true) {}
+      `;
+      const calls = extractCalls(content, 'test.js');
+      expect(calls).not.toContain('if');
+      expect(calls).not.toContain('for');
+      expect(calls).not.toContain('while');
+    });
+
+    it('should not extract calls from strings', () => {
+      const content = `
+        const str = "someFunction()";
+        const template = \`anotherFunction()\`;
+      `;
+      const calls = extractCalls(content, 'test.js');
+      expect(calls).not.toContain('someFunction');
+      expect(calls).not.toContain('anotherFunction');
+    });
+  });
+
+  describe('extractCallData', () => {
+    it('should separate definitions from external calls', () => {
+      const content = `
+        function localFunc() {
+          externalFunc();
+          localFunc(); // self-reference
+        }
+      `;
+      const result = extractCallData(content, 'test.js');
+      expect(result.definitions).toContain('localFunc');
+      expect(result.calls).toContain('externalFunc');
+      expect(result.calls).not.toContain('localFunc'); // Filtered as self-reference
+    });
+  });
+
+  describe('buildCallGraph', () => {
+    it('should build graph from file data', () => {
+      const fileData = new Map([
+        ['/path/a.js', { definitions: ['funcA'], calls: ['funcB'] }],
+        ['/path/b.js', { definitions: ['funcB'], calls: ['funcC'] }],
+        ['/path/c.js', { definitions: ['funcC'], calls: [] }]
+      ]);
+
+      const graph = buildCallGraph(fileData);
+
+      expect(graph.defines.get('funcA')).toContain('/path/a.js');
+      expect(graph.defines.get('funcB')).toContain('/path/b.js');
+      expect(graph.calledBy.get('funcB')).toContain('/path/a.js');
+      expect(graph.calledBy.get('funcC')).toContain('/path/b.js');
+    });
+  });
+
+  describe('getRelatedFiles', () => {
+    it('should find callers and callees', () => {
+      const fileData = new Map([
+        ['/path/a.js', { definitions: ['funcA'], calls: ['funcB'] }],
+        ['/path/b.js', { definitions: ['funcB'], calls: [] }]
+      ]);
+
+      const graph = buildCallGraph(fileData);
+      const related = getRelatedFiles(graph, ['funcB'], 1);
+
+      // funcB is defined in b.js and called by a.js
+      expect(related.has('/path/a.js')).toBe(true);
+      expect(related.has('/path/b.js')).toBe(true);
+    });
+  });
+});

package/test/clear-cache.test.js

@@ -25,7 +25,7 @@ describe('CacheClearer', () => {
   let fixtures;
   
   beforeAll(async () => {
-    fixtures = await createTestFixtures({ workerThreads: 2 });
+    fixtures = await createTestFixtures({ workerThreads: 1 });
   });
   
   afterAll(async () => {
@@ -90,9 +90,6 @@ describe('CacheClearer', () => {
       fixtures.cache.fileHashes = new Map();
       
       const indexPromise = fixtures.indexer.indexAll(true);
-      
-      // Wait for indexing to start
-      await new Promise(resolve => setTimeout(resolve, 100));
       expect(fixtures.indexer.isIndexing).toBe(true);
       
       // Try to clear - should fail
@@ -207,7 +204,7 @@ describe('Clear Cache Tool Handler', () => {
   let fixtures;
   
   beforeAll(async () => {
-    fixtures = await createTestFixtures({ workerThreads: 2 });
+    fixtures = await createTestFixtures({ workerThreads: 1 });
   });
   
   afterAll(async () => {
@@ -250,7 +247,7 @@ describe('Clear Cache Tool Handler', () => {
       fixtures.cache.fileHashes = new Map();
       
       const indexPromise = fixtures.indexer.indexAll(true);
-      await new Promise(resolve => setTimeout(resolve, 100));
+      expect(fixtures.indexer.isIndexing).toBe(true);
       
       const request = createMockRequest('c_clear_cache', {});
       const result = await ClearCacheFeature.handleToolCall(request, fixtures.cacheClearer);

package/test/helpers.js

@@ -1,5 +1,5 @@
 /**
- * Test helper utilities for Smart Coding MCP tests
+ * Test helper utilities for Heuristic MCP tests
  * Provides shared setup, teardown, and mock utilities
  */
 
@@ -15,6 +15,8 @@ import path from 'path';
 // Cached embedder instance (shared across tests for speed)
 let sharedEmbedder = null;
 
+const DEFAULT_MOCK_DIMENSIONS = 64;
+
 /**
  * Get or initialize the shared embedder instance
  * Loading the model once and reusing saves significant time
@@ -28,6 +30,57 @@ export async function getEmbedder(config) {
   return sharedEmbedder;
 }
 
+function isVitest() {
+  return Boolean(process.env.VITEST || process.env.VITEST_WORKER_ID);
+}
+
+function hashToken(token) {
+  let hash = 2166136261;
+  for (let i = 0; i < token.length; i++) {
+    hash ^= token.charCodeAt(i);
+    hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  }
+  return hash >>> 0;
+}
+
+function normalizeVector(vector) {
+  let sumSquares = 0;
+  for (let i = 0; i < vector.length; i++) {
+    sumSquares += vector[i] * vector[i];
+  }
+  if (sumSquares === 0) {
+    vector[0] = 1;
+    return vector;
+  }
+  const norm = Math.sqrt(sumSquares);
+  for (let i = 0; i < vector.length; i++) {
+    vector[i] /= norm;
+  }
+  return vector;
+}
+
+function createMockEmbedder({ dimensions = DEFAULT_MOCK_DIMENSIONS } = {}) {
+  return async (text, options = {}) => {
+    const vector = new Float32Array(dimensions);
+    const tokens = String(text ?? "")
+      .toLowerCase()
+      .split(/[^a-z0-9_]+/g)
+      .filter(token => token.length > 1);
+
+    for (const token of tokens) {
+      const index = hashToken(token) % dimensions;
+      const weight = 1 + Math.min(4, Math.floor(token.length / 4));
+      vector[index] += weight;
+    }
+
+    if (options.normalize) {
+      normalizeVector(vector);
+    }
+
+    return { data: vector };
+  };
+}
+
 /**
  * Create test fixtures with initialized components
  * @param {Object} options - Options for fixture creation
@@ -35,20 +88,24 @@ export async function getEmbedder(config) {
  */
 export async function createTestFixtures(options = {}) {
   const config = await loadConfig();
-  
+
   // Override config for testing if needed
   if (options.verbose !== undefined) config.verbose = options.verbose;
   if (options.workerThreads !== undefined) config.workerThreads = options.workerThreads;
-  
-  const embedder = await getEmbedder(config);
-  
+  if (isVitest()) config.workerThreads = 1;
+
+  const useRealEmbedder = options.useRealEmbedder === true;
+  const embedder = useRealEmbedder
+    ? await getEmbedder(config)
+    : createMockEmbedder({ dimensions: options.embeddingDimensions });
+
   const cache = new EmbeddingsCache(config);
   await cache.load();
-  
+
   const indexer = new CodebaseIndexer(embedder, cache, config, null);
   const cacheClearer = new CacheClearer(embedder, cache, config, indexer);
   const hybridSearch = new HybridSearch(embedder, cache, config);
-  
+
   return {
     config,
     embedder,

package/test/hybrid-search.test.js

@@ -23,7 +23,7 @@ describe('HybridSearch', () => {
   let fixtures;
   
   beforeAll(async () => {
-    fixtures = await createTestFixtures({ workerThreads: 2 });
+    fixtures = await createTestFixtures({ workerThreads: 1 });
     
     // Ensure we have indexed content
     await clearTestCache(fixtures.config);
@@ -164,7 +164,7 @@ describe('Hybrid Search Tool Handler', () => {
   let fixtures;
   
   beforeAll(async () => {
-    fixtures = await createTestFixtures({ workerThreads: 2 });
+    fixtures = await createTestFixtures({ workerThreads: 1 });
     
     // Ensure indexed content
     await fixtures.indexer.indexAll(false);

package/test/index-codebase.test.js

@@ -24,7 +24,7 @@ describe('CodebaseIndexer', () => {
   let fixtures;
   
   beforeAll(async () => {
-    fixtures = await createTestFixtures({ workerThreads: 2 });
+    fixtures = await createTestFixtures({ workerThreads: 1 });
   });
   
   afterAll(async () => {
@@ -91,9 +91,6 @@ describe('CodebaseIndexer', () => {
       
       // Start first indexing
       const promise1 = fixtures.indexer.indexAll(true);
-      
-      // Wait for it to start
-      await new Promise(resolve => setTimeout(resolve, 100));
       expect(fixtures.indexer.isIndexing).toBe(true);
       
       // Second call should be skipped
@@ -114,9 +111,6 @@ describe('CodebaseIndexer', () => {
       expect(fixtures.indexer.isIndexing).toBe(false);
       
       const promise = fixtures.indexer.indexAll(true);
-      
-      // Should be set during indexing
-      await new Promise(resolve => setTimeout(resolve, 100));
       expect(fixtures.indexer.isIndexing).toBe(true);
       
       await promise;
@@ -170,7 +164,7 @@ describe('Index Codebase Tool Handler', () => {
   let fixtures;
   
   beforeAll(async () => {
-    fixtures = await createTestFixtures({ workerThreads: 2 });
+    fixtures = await createTestFixtures({ workerThreads: 1 });
   });
   
   afterAll(async () => {
@@ -212,8 +206,7 @@ describe('Index Codebase Tool Handler', () => {
         createMockRequest('b_index_codebase', { force: true }), 
         fixtures.indexer
       );
-      
-      await new Promise(resolve => setTimeout(resolve, 100));
+      expect(fixtures.indexer.isIndexing).toBe(true);
       
       // Second concurrent call
       const result2 = await IndexCodebaseFeature.handleToolCall(

package/test/integration.test.js

@@ -22,7 +22,7 @@ describe('Concurrent Indexing', () => {
   let fixtures;
   
   beforeAll(async () => {
-    fixtures = await createTestFixtures({ workerThreads: 2 });
+    fixtures = await createTestFixtures({ workerThreads: 1, useRealEmbedder: true });
   });
   
   afterAll(async () => {
@@ -110,7 +110,7 @@ describe('Clear Cache Operations', () => {
   let fixtures;
   
   beforeAll(async () => {
-    fixtures = await createTestFixtures({ workerThreads: 2 });
+    fixtures = await createTestFixtures({ workerThreads: 1, useRealEmbedder: true });
   });
   
   afterAll(async () => {
@@ -197,7 +197,7 @@ describe('Tool Handler Response Quality', () => {
   let fixtures;
   
   beforeAll(async () => {
-    fixtures = await createTestFixtures({ workerThreads: 2 });
+    fixtures = await createTestFixtures({ workerThreads: 1, useRealEmbedder: true });
   });
   
   afterAll(async () => {