smart-coding-mcp 1.2.4 → 1.3.1

package/test/hybrid-search.test.js

@@ -0,0 +1,243 @@
+/**
+ * Tests for HybridSearch feature
+ * 
+ * Tests the search functionality including:
+ * - Semantic search with embeddings
+ * - Exact match boosting
+ * - Result formatting
+ * - Empty index handling
+ * - Score calculation
+ */
+
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import { 
+  createTestFixtures, 
+  cleanupFixtures, 
+  clearTestCache,
+  createMockRequest 
+} from './helpers.js';
+import * as HybridSearchFeature from '../features/hybrid-search.js';
+import { HybridSearch } from '../features/hybrid-search.js';
+
+describe('HybridSearch', () => {
+  let fixtures;
+  
+  beforeAll(async () => {
+    fixtures = await createTestFixtures({ workerThreads: 2 });
+    
+    // Ensure we have indexed content
+    await clearTestCache(fixtures.config);
+    fixtures.cache.setVectorStore([]);
+    fixtures.cache.fileHashes = new Map();
+    await fixtures.indexer.indexAll(true);
+  });
+  
+  afterAll(async () => {
+    await cleanupFixtures(fixtures);
+  });
+
+  describe('Search Functionality', () => {
+    it('should find relevant code for semantic queries', async () => {
+      // Search for something that should exist in the codebase
+      const { results, message } = await fixtures.hybridSearch.search('embedding model', 5);
+      
+      expect(message).toBeNull();
+      expect(results.length).toBeGreaterThan(0);
+      
+      // Results should have required properties
+      for (const result of results) {
+        expect(result).toHaveProperty('file');
+        expect(result).toHaveProperty('content');
+        expect(result).toHaveProperty('score');
+        expect(result).toHaveProperty('startLine');
+        expect(result).toHaveProperty('endLine');
+        expect(result).toHaveProperty('vector');
+      }
+    });
+    
+    it('should return results sorted by score (highest first)', async () => {
+      const { results } = await fixtures.hybridSearch.search('function', 10);
+      
+      expect(results.length).toBeGreaterThan(1);
+      
+      // Verify descending order
+      for (let i = 1; i < results.length; i++) {
+        expect(results[i - 1].score).toBeGreaterThanOrEqual(results[i].score);
+      }
+    });
+    
+    it('should respect maxResults parameter', async () => {
+      const maxResults = 3;
+      const { results } = await fixtures.hybridSearch.search('const', maxResults);
+      
+      expect(results.length).toBeLessThanOrEqual(maxResults);
+    });
+    
+    it('should boost exact matches', async () => {
+      // Search for an exact term that exists
+      const { results: exactResults } = await fixtures.hybridSearch.search('embedder', 5);
+      
+      // At least one result should contain the exact term
+      const hasExactMatch = exactResults.some(r => 
+        r.content.toLowerCase().includes('embedder')
+      );
+      
+      expect(hasExactMatch).toBe(true);
+    });
+    
+    it('should handle natural language queries', async () => {
+      const { results } = await fixtures.hybridSearch.search('where is the configuration loaded', 5);
+      
+      expect(results.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Empty Index Handling', () => {
+    it('should return helpful message when index is empty', async () => {
+      // Create a search instance with empty cache
+      const emptyCache = {
+        getVectorStore: () => [],
+        setVectorStore: () => {},
+        getFileHash: () => null,
+        setFileHash: () => {}
+      };
+      
+      const emptySearch = new HybridSearch(fixtures.embedder, emptyCache, fixtures.config);
+      const { results, message } = await emptySearch.search('test', 5);
+      
+      expect(results.length).toBe(0);
+      expect(message).toContain('No code has been indexed');
+    });
+  });
+
+  describe('Result Formatting', () => {
+    it('should format results as markdown', async () => {
+      const { results } = await fixtures.hybridSearch.search('function', 3);
+      const formatted = fixtures.hybridSearch.formatResults(results);
+      
+      // Should contain markdown elements
+      expect(formatted).toContain('## Result');
+      expect(formatted).toContain('**File:**');
+      expect(formatted).toContain('**Lines:**');
+      expect(formatted).toContain('```');
+      expect(formatted).toContain('Relevance:');
+    });
+    
+    it('should return no matches message for empty results', () => {
+      const formatted = fixtures.hybridSearch.formatResults([]);
+      
+      expect(formatted).toContain('No matching code found');
+    });
+    
+    it('should include relative file paths', async () => {
+      const { results } = await fixtures.hybridSearch.search('export', 1);
+      const formatted = fixtures.hybridSearch.formatResults(results);
+      
+      // Should not contain absolute paths in the output
+      expect(formatted).not.toContain(fixtures.config.searchDirectory);
+    });
+  });
+
+  describe('Score Calculation', () => {
+    it('should give higher scores to more relevant results', async () => {
+      // Search for a specific term
+      const { results } = await fixtures.hybridSearch.search('CodebaseIndexer', 5);
+      
+      if (results.length > 0) {
+        // Top result should have high relevance
+        expect(results[0].score).toBeGreaterThan(0.3);
+      }
+    });
+    
+    it('should apply semantic weight from config', async () => {
+      const { results } = await fixtures.hybridSearch.search('async function', 5);
+      
+      // All results should have positive scores
+      for (const result of results) {
+        expect(result.score).toBeGreaterThan(0);
+      }
+    });
+  });
+});
+
+describe('Hybrid Search Tool Handler', () => {
+  let fixtures;
+  
+  beforeAll(async () => {
+    fixtures = await createTestFixtures({ workerThreads: 2 });
+    
+    // Ensure indexed content
+    await fixtures.indexer.indexAll(false);
+  });
+  
+  afterAll(async () => {
+    await cleanupFixtures(fixtures);
+  });
+
+  describe('Tool Definition', () => {
+    it('should have correct tool definition', () => {
+      const toolDef = HybridSearchFeature.getToolDefinition(fixtures.config);
+      
+      expect(toolDef.name).toBe('a_semantic_search');
+      expect(toolDef.description).toContain('semantic');
+      expect(toolDef.description).toContain('hybrid');
+      expect(toolDef.inputSchema.properties.query).toBeDefined();
+      expect(toolDef.inputSchema.properties.maxResults).toBeDefined();
+      expect(toolDef.inputSchema.required).toContain('query');
+    });
+    
+    it('should use config default for maxResults', () => {
+      const toolDef = HybridSearchFeature.getToolDefinition(fixtures.config);
+      
+      expect(toolDef.inputSchema.properties.maxResults.default).toBe(fixtures.config.maxResults);
+    });
+  });
+
+  describe('Tool Handler', () => {
+    it('should return search results for valid query', async () => {
+      const request = createMockRequest('a_semantic_search', { 
+        query: 'function that handles indexing' 
+      });
+      
+      const result = await HybridSearchFeature.handleToolCall(request, fixtures.hybridSearch);
+      
+      expect(result.content[0].type).toBe('text');
+      expect(result.content[0].text).toContain('Result');
+    });
+    
+    it('should use default maxResults when not provided', async () => {
+      const request = createMockRequest('a_semantic_search', { 
+        query: 'import' 
+      });
+      
+      const result = await HybridSearchFeature.handleToolCall(request, fixtures.hybridSearch);
+      
+      // Should return results (up to default max)
+      expect(result.content[0].text.length).toBeGreaterThan(0);
+    });
+    
+    it('should respect custom maxResults', async () => {
+      const request = createMockRequest('a_semantic_search', { 
+        query: 'const',
+        maxResults: 2
+      });
+      
+      const result = await HybridSearchFeature.handleToolCall(request, fixtures.hybridSearch);
+      
+      // Count result headers
+      const resultCount = (result.content[0].text.match(/## Result/g) || []).length;
+      expect(resultCount).toBeLessThanOrEqual(2);
+    });
+    
+    it('should handle queries with no matches gracefully', async () => {
+      const request = createMockRequest('a_semantic_search', { 
+        query: 'xyzzy_nonexistent_symbol_12345' 
+      });
+      
+      const result = await HybridSearchFeature.handleToolCall(request, fixtures.hybridSearch);
+      
+      // Should return something (either no matches message or low-score results)
+      expect(result.content[0].text.length).toBeGreaterThan(0);
+    });
+  });
+});

package/test/index-codebase.test.js

@@ -0,0 +1,246 @@
+/**
+ * Tests for CodebaseIndexer feature
+ * 
+ * Tests the indexing functionality including:
+ * - File discovery and filtering
+ * - Chunk generation and embedding
+ * - Concurrent indexing protection
+ * - Force reindex behavior
+ * - Progress notifications
+ */
+
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import { 
+  createTestFixtures, 
+  cleanupFixtures, 
+  clearTestCache,
+  createMockRequest,
+  measureTime 
+} from './helpers.js';
+import * as IndexCodebaseFeature from '../features/index-codebase.js';
+import { CodebaseIndexer } from '../features/index-codebase.js';
+
+describe('CodebaseIndexer', () => {
+  let fixtures;
+  
+  beforeAll(async () => {
+    fixtures = await createTestFixtures({ workerThreads: 2 });
+  });
+  
+  afterAll(async () => {
+    await cleanupFixtures(fixtures);
+  });
+  
+  beforeEach(async () => {
+    // Reset state
+    fixtures.indexer.isIndexing = false;
+    fixtures.indexer.terminateWorkers();
+  });
+
+  describe('Basic Indexing', () => {
+    it('should index files and create embeddings', async () => {
+      // Clear cache first
+      await clearTestCache(fixtures.config);
+      fixtures.cache.setVectorStore([]);
+      fixtures.cache.fileHashes = new Map();
+      
+      // Run indexing
+      const result = await fixtures.indexer.indexAll(true);
+      
+      // Should have processed files
+      expect(result.skipped).toBe(false);
+      expect(result.filesProcessed).toBeGreaterThan(0);
+      expect(result.chunksCreated).toBeGreaterThan(0);
+      expect(result.totalFiles).toBeGreaterThan(0);
+      expect(result.totalChunks).toBeGreaterThan(0);
+    });
+    
+    it('should skip unchanged files on subsequent indexing', async () => {
+      // First index
+      await fixtures.indexer.indexAll(true);
+      
+      // Second index without force
+      const result = await fixtures.indexer.indexAll(false);
+      
+      // Should skip processing (files unchanged)
+      expect(result.skipped).toBe(false);
+      expect(result.filesProcessed).toBe(0);
+      expect(result.message).toContain('up to date');
+    });
+    
+    it('should reindex all files when force is true', async () => {
+      // First index
+      await fixtures.indexer.indexAll(true);
+      const firstChunks = fixtures.cache.getVectorStore().length;
+      
+      // Force reindex
+      const result = await fixtures.indexer.indexAll(true);
+      
+      // Should have processed all files again
+      expect(result.filesProcessed).toBeGreaterThan(0);
+      expect(result.chunksCreated).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Concurrent Indexing Protection', () => {
+    it('should prevent concurrent indexing', async () => {
+      // Clear for clean state
+      await clearTestCache(fixtures.config);
+      fixtures.cache.setVectorStore([]);
+      fixtures.cache.fileHashes = new Map();
+      
+      // 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
+      const result2 = await fixtures.indexer.indexAll(false);
+      
+      expect(result2.skipped).toBe(true);
+      expect(result2.reason).toContain('already in progress');
+      
+      await promise1;
+    });
+    
+    it('should set and clear isIndexing flag correctly', async () => {
+      // Clear cache to ensure indexing actually runs
+      await clearTestCache(fixtures.config);
+      fixtures.cache.setVectorStore([]);
+      fixtures.cache.fileHashes = new Map();
+      
+      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;
+      
+      // Should be cleared after indexing
+      expect(fixtures.indexer.isIndexing).toBe(false);
+    });
+  });
+
+  describe('File Discovery', () => {
+    it('should discover files matching configured extensions', async () => {
+      const files = await fixtures.indexer.discoverFiles();
+      
+      expect(files.length).toBeGreaterThan(0);
+      
+      // All files should have valid extensions
+      const extensions = fixtures.config.fileExtensions.map(ext => `.${ext}`);
+      for (const file of files) {
+        const ext = file.substring(file.lastIndexOf('.'));
+        expect(extensions).toContain(ext);
+      }
+    });
+    
+    it('should exclude files in excluded directories', async () => {
+      const files = await fixtures.indexer.discoverFiles();
+      
+      // No files from node_modules
+      const nodeModulesFiles = files.filter(f => f.includes('node_modules'));
+      expect(nodeModulesFiles.length).toBe(0);
+      
+      // No files from .smart-coding-cache
+      const cacheFiles = files.filter(f => f.includes('.smart-coding-cache'));
+      expect(cacheFiles.length).toBe(0);
+    });
+  });
+
+  describe('Worker Thread Management', () => {
+    it('should initialize workers when CPU count > 1', async () => {
+      await fixtures.indexer.initializeWorkers();
+      
+      // Should have at least 1 worker on multi-core systems
+      expect(fixtures.indexer.workers.length).toBeGreaterThanOrEqual(0);
+      
+      fixtures.indexer.terminateWorkers();
+      expect(fixtures.indexer.workers.length).toBe(0);
+    });
+  });
+});
+
+describe('Index Codebase Tool Handler', () => {
+  let fixtures;
+  
+  beforeAll(async () => {
+    fixtures = await createTestFixtures({ workerThreads: 2 });
+  });
+  
+  afterAll(async () => {
+    await cleanupFixtures(fixtures);
+  });
+  
+  beforeEach(async () => {
+    fixtures.indexer.isIndexing = false;
+  });
+
+  describe('Tool Definition', () => {
+    it('should have correct tool definition', () => {
+      const toolDef = IndexCodebaseFeature.getToolDefinition();
+      
+      expect(toolDef.name).toBe('b_index_codebase');
+      expect(toolDef.description).toContain('reindex');
+      expect(toolDef.inputSchema.properties.force).toBeDefined();
+      expect(toolDef.inputSchema.properties.force.type).toBe('boolean');
+    });
+  });
+
+  describe('Tool Handler', () => {
+    it('should return success message on completed indexing', async () => {
+      const request = createMockRequest('b_index_codebase', { force: false });
+      const result = await IndexCodebaseFeature.handleToolCall(request, fixtures.indexer);
+      
+      expect(result.content[0].text).toContain('reindexed successfully');
+      expect(result.content[0].text).toContain('Total files in index');
+      expect(result.content[0].text).toContain('Total code chunks');
+    });
+    
+    it('should return skipped message on concurrent calls', async () => {
+      // Start first indexing
+      await clearTestCache(fixtures.config);
+      fixtures.cache.setVectorStore([]);
+      fixtures.cache.fileHashes = new Map();
+      
+      const promise1 = IndexCodebaseFeature.handleToolCall(
+        createMockRequest('b_index_codebase', { force: true }), 
+        fixtures.indexer
+      );
+      
+      await new Promise(resolve => setTimeout(resolve, 100));
+      
+      // Second concurrent call
+      const result2 = await IndexCodebaseFeature.handleToolCall(
+        createMockRequest('b_index_codebase', { force: false }), 
+        fixtures.indexer
+      );
+      
+      expect(result2.content[0].text).toContain('Indexing skipped');
+      expect(result2.content[0].text).toContain('already in progress');
+      
+      await promise1;
+    });
+    
+    it('should handle force parameter correctly', async () => {
+      // First index
+      await IndexCodebaseFeature.handleToolCall(
+        createMockRequest('b_index_codebase', { force: true }), 
+        fixtures.indexer
+      );
+      
+      // Non-force should skip unchanged
+      const result = await IndexCodebaseFeature.handleToolCall(
+        createMockRequest('b_index_codebase', { force: false }), 
+        fixtures.indexer
+      );
+      
+      expect(result.content[0].text).toContain('up to date');
+    });
+  });
+});