smart-coding-mcp 1.2.4 → 1.3.1

package/test/clear-cache.test.js

@@ -0,0 +1,288 @@
+/**
+ * Tests for CacheClearer feature
+ * 
+ * Tests the cache clearing functionality including:
+ * - Basic cache clearing
+ * - Protection during indexing
+ * - Protection during save operations
+ * - Concurrent clear prevention
+ * - Tool handler responses
+ */
+
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import { 
+  createTestFixtures, 
+  cleanupFixtures, 
+  clearTestCache,
+  createMockRequest 
+} from './helpers.js';
+import * as ClearCacheFeature from '../features/clear-cache.js';
+import { CacheClearer } from '../features/clear-cache.js';
+import fs from 'fs/promises';
+import path from 'path';
+
+describe('CacheClearer', () => {
+  let fixtures;
+  
+  beforeAll(async () => {
+    fixtures = await createTestFixtures({ workerThreads: 2 });
+  });
+  
+  afterAll(async () => {
+    await cleanupFixtures(fixtures);
+  });
+  
+  beforeEach(async () => {
+    // Reset state
+    fixtures.indexer.isIndexing = false;
+    fixtures.cache.isSaving = false;
+    fixtures.cacheClearer.isClearing = false;
+  });
+
+  describe('Basic Cache Clearing', () => {
+    it('should clear cache successfully', async () => {
+      // First ensure we have a cache
+      await fixtures.indexer.indexAll(true);
+      
+      // Verify cache exists
+      expect(fixtures.cache.getVectorStore().length).toBeGreaterThan(0);
+      
+      // Clear cache
+      const result = await fixtures.cacheClearer.execute();
+      
+      expect(result.success).toBe(true);
+      expect(result.message).toContain('Cache cleared successfully');
+      expect(result.cacheDirectory).toBe(fixtures.config.cacheDirectory);
+    });
+    
+    it('should empty vectorStore and fileHashes', async () => {
+      // Create some cache
+      await fixtures.indexer.indexAll(true);
+      
+      // Clear
+      await fixtures.cacheClearer.execute();
+      
+      // Both should be empty
+      expect(fixtures.cache.getVectorStore().length).toBe(0);
+      expect(fixtures.cache.fileHashes.size).toBe(0);
+    });
+    
+    it('should delete cache directory', async () => {
+      // Create cache
+      await fixtures.indexer.indexAll(true);
+      
+      // Verify cache directory exists
+      await expect(fs.access(fixtures.config.cacheDirectory)).resolves.not.toThrow();
+      
+      // Clear
+      await fixtures.cacheClearer.execute();
+      
+      // Directory should not exist
+      await expect(fs.access(fixtures.config.cacheDirectory)).rejects.toThrow();
+    });
+  });
+
+  describe('Protection During Indexing', () => {
+    it('should prevent clear while indexing is in progress', async () => {
+      // Simulate indexing in progress
+      await clearTestCache(fixtures.config);
+      fixtures.cache.setVectorStore([]);
+      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
+      await expect(fixtures.cacheClearer.execute()).rejects.toThrow(
+        'Cannot clear cache while indexing is in progress'
+      );
+      
+      await indexPromise;
+    });
+    
+    it('should allow clear after indexing completes', async () => {
+      // Complete indexing
+      await fixtures.indexer.indexAll(true);
+      expect(fixtures.indexer.isIndexing).toBe(false);
+      
+      // Clear should work
+      const result = await fixtures.cacheClearer.execute();
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('Protection During Save', () => {
+    it('should prevent clear while cache is being saved', async () => {
+      // Simulate save in progress
+      fixtures.cache.isSaving = true;
+      
+      // Try to clear - should fail
+      await expect(fixtures.cacheClearer.execute()).rejects.toThrow(
+        'Cannot clear cache while cache is being saved'
+      );
+      
+      // Reset
+      fixtures.cache.isSaving = false;
+    });
+    
+    it('should allow clear after save completes', async () => {
+      // Index first
+      await fixtures.indexer.indexAll(true);
+      
+      // isSaving should be false after indexing
+      expect(fixtures.cache.isSaving).toBe(false);
+      
+      // Clear should work
+      const result = await fixtures.cacheClearer.execute();
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('Concurrent Clear Prevention', () => {
+    it('should prevent multiple concurrent clears', async () => {
+      // Index first
+      await fixtures.indexer.indexAll(true);
+      
+      // Reset the isClearing flag
+      fixtures.cacheClearer.isClearing = false;
+      
+      // Start multiple concurrent clears
+      const promises = [
+        fixtures.cacheClearer.execute(),
+        fixtures.cacheClearer.execute(),
+        fixtures.cacheClearer.execute()
+      ];
+      
+      const results = await Promise.allSettled(promises);
+      
+      // Exactly one should succeed
+      const successes = results.filter(r => r.status === 'fulfilled');
+      const failures = results.filter(r => r.status === 'rejected');
+      
+      expect(successes.length).toBe(1);
+      expect(failures.length).toBe(2);
+      
+      // Failures should have correct error message
+      for (const failure of failures) {
+        expect(failure.reason.message).toContain('already in progress');
+      }
+    });
+    
+    it('should reset isClearing flag after completion', async () => {
+      // Index first
+      await fixtures.indexer.indexAll(true);
+      
+      expect(fixtures.cacheClearer.isClearing).toBe(false);
+      
+      // Clear
+      await fixtures.cacheClearer.execute();
+      
+      // Flag should be reset
+      expect(fixtures.cacheClearer.isClearing).toBe(false);
+    });
+    
+    it('should reset isClearing flag even on error', async () => {
+      // Set up for failure
+      fixtures.cache.isSaving = true;
+      
+      try {
+        await fixtures.cacheClearer.execute();
+      } catch {
+        // Expected to fail
+      }
+      
+      // isClearing should not have been set (failed before setting)
+      expect(fixtures.cacheClearer.isClearing).toBe(false);
+      
+      // Reset
+      fixtures.cache.isSaving = false;
+    });
+  });
+});
+
+describe('Clear Cache Tool Handler', () => {
+  let fixtures;
+  
+  beforeAll(async () => {
+    fixtures = await createTestFixtures({ workerThreads: 2 });
+  });
+  
+  afterAll(async () => {
+    await cleanupFixtures(fixtures);
+  });
+  
+  beforeEach(async () => {
+    fixtures.indexer.isIndexing = false;
+    fixtures.cache.isSaving = false;
+    fixtures.cacheClearer.isClearing = false;
+  });
+
+  describe('Tool Definition', () => {
+    it('should have correct tool definition', () => {
+      const toolDef = ClearCacheFeature.getToolDefinition();
+      
+      expect(toolDef.name).toBe('c_clear_cache');
+      expect(toolDef.description).toContain('cache');
+      expect(toolDef.annotations.destructiveHint).toBe(true);
+      expect(toolDef.inputSchema.properties).toEqual({});
+    });
+  });
+
+  describe('Tool Handler', () => {
+    it('should return success message on cleared cache', async () => {
+      // Index first
+      await fixtures.indexer.indexAll(true);
+      
+      const request = createMockRequest('c_clear_cache', {});
+      const result = await ClearCacheFeature.handleToolCall(request, fixtures.cacheClearer);
+      
+      expect(result.content[0].text).toContain('Cache cleared successfully');
+      expect(result.content[0].text).toContain('Cache directory:');
+    });
+    
+    it('should return error message when indexing is in progress', async () => {
+      // Simulate indexing
+      await clearTestCache(fixtures.config);
+      fixtures.cache.setVectorStore([]);
+      fixtures.cache.fileHashes = new Map();
+      
+      const indexPromise = fixtures.indexer.indexAll(true);
+      await new Promise(resolve => setTimeout(resolve, 100));
+      
+      const request = createMockRequest('c_clear_cache', {});
+      const result = await ClearCacheFeature.handleToolCall(request, fixtures.cacheClearer);
+      
+      expect(result.content[0].text).toContain('Failed to clear cache');
+      expect(result.content[0].text).toContain('indexing is in progress');
+      
+      await indexPromise;
+    });
+    
+    it('should return error message when save is in progress', async () => {
+      fixtures.cache.isSaving = true;
+      
+      const request = createMockRequest('c_clear_cache', {});
+      const result = await ClearCacheFeature.handleToolCall(request, fixtures.cacheClearer);
+      
+      expect(result.content[0].text).toContain('Failed to clear cache');
+      expect(result.content[0].text).toContain('being saved');
+      
+      fixtures.cache.isSaving = false;
+    });
+    
+    it('should return error message when clear is already in progress', async () => {
+      fixtures.cacheClearer.isClearing = true;
+      
+      const request = createMockRequest('c_clear_cache', {});
+      const result = await ClearCacheFeature.handleToolCall(request, fixtures.cacheClearer);
+      
+      expect(result.content[0].text).toContain('Failed to clear cache');
+      expect(result.content[0].text).toContain('already in progress');
+      
+      fixtures.cacheClearer.isClearing = false;
+    });
+  });
+});

package/test/embedding-model.test.js

@@ -0,0 +1,230 @@
+/**
+ * Tests for Local LLM (Embedding Model)
+ * 
+ * Tests the embedding model functionality including:
+ * - Model loading
+ * - Embedding generation
+ * - Vector properties
+ * - Similarity calculations
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { pipeline } from '@xenova/transformers';
+import { cosineSimilarity } from '../lib/utils.js';
+import { loadConfig } from '../lib/config.js';
+
+describe('Local Embedding Model', () => {
+  let embedder;
+  let config;
+  
+  beforeAll(async () => {
+    config = await loadConfig();
+    console.log(`[Test] Loading embedding model: ${config.embeddingModel}`);
+    embedder = await pipeline('feature-extraction', config.embeddingModel);
+    console.log('[Test] Embedding model loaded successfully');
+  });
+
+  describe('Model Loading', () => {
+    it('should load the embedding model', () => {
+      expect(embedder).toBeDefined();
+      expect(typeof embedder).toBe('function');
+    });
+    
+    it('should use the configured model', () => {
+      expect(config.embeddingModel).toBe('Xenova/all-MiniLM-L6-v2');
+    });
+  });
+
+  describe('Embedding Generation', () => {
+    it('should generate embeddings for text', async () => {
+      const text = 'Hello, world!';
+      const output = await embedder(text, { pooling: 'mean', normalize: true });
+      
+      expect(output).toBeDefined();
+      expect(output.data).toBeDefined();
+    });
+    
+    it('should return vectors of correct dimensions', async () => {
+      const text = 'Test input for embedding';
+      const output = await embedder(text, { pooling: 'mean', normalize: true });
+      const vector = Array.from(output.data);
+      
+      // MiniLM-L6 produces 384-dimensional vectors
+      expect(vector.length).toBe(384);
+    });
+    
+    it('should return normalized vectors', async () => {
+      const text = 'Normalized vector test';
+      const output = await embedder(text, { pooling: 'mean', normalize: true });
+      const vector = Array.from(output.data);
+      
+      // Calculate magnitude (should be ~1 for normalized vectors)
+      const magnitude = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+      expect(magnitude).toBeCloseTo(1, 4);
+    });
+    
+    it('should generate different embeddings for different text', async () => {
+      const output1 = await embedder('apple fruit', { pooling: 'mean', normalize: true });
+      const output2 = await embedder('programming code', { pooling: 'mean', normalize: true });
+      
+      const vector1 = Array.from(output1.data);
+      const vector2 = Array.from(output2.data);
+      
+      // Vectors should be different
+      const areSame = vector1.every((v, i) => Math.abs(v - vector2[i]) < 0.0001);
+      expect(areSame).toBe(false);
+    });
+    
+    it('should handle code snippets', async () => {
+      const code = `
+        function add(a, b) {
+          return a + b;
+        }
+      `;
+      
+      const output = await embedder(code, { pooling: 'mean', normalize: true });
+      const vector = Array.from(output.data);
+      
+      expect(vector.length).toBe(384);
+    });
+    
+    it('should handle multiline text', async () => {
+      const multiline = 'Line one\nLine two\nLine three';
+      const output = await embedder(multiline, { pooling: 'mean', normalize: true });
+      const vector = Array.from(output.data);
+      
+      expect(vector.length).toBe(384);
+    });
+    
+    it('should handle special characters', async () => {
+      const special = '{}[]()<>!@#$%^&*';
+      const output = await embedder(special, { pooling: 'mean', normalize: true });
+      const vector = Array.from(output.data);
+      
+      expect(vector.length).toBe(384);
+    });
+  });
+
+  describe('Semantic Similarity', () => {
+    it('should give high similarity for semantically similar text', async () => {
+      const output1 = await embedder('user authentication login', { pooling: 'mean', normalize: true });
+      const output2 = await embedder('user login authentication', { pooling: 'mean', normalize: true });
+      
+      const vector1 = Array.from(output1.data);
+      const vector2 = Array.from(output2.data);
+      
+      const similarity = cosineSimilarity(vector1, vector2);
+      
+      // Same words, different order - should be very similar
+      expect(similarity).toBeGreaterThan(0.9);
+    });
+    
+    it('should give lower similarity for different topics', async () => {
+      const output1 = await embedder('database query SQL', { pooling: 'mean', normalize: true });
+      const output2 = await embedder('pizza delivery food', { pooling: 'mean', normalize: true });
+      
+      const vector1 = Array.from(output1.data);
+      const vector2 = Array.from(output2.data);
+      
+      const similarity = cosineSimilarity(vector1, vector2);
+      
+      // Different topics - should have low similarity
+      expect(similarity).toBeLessThan(0.5);
+    });
+    
+    it('should capture code semantic similarity', async () => {
+      const output1 = await embedder('function that handles user login', { pooling: 'mean', normalize: true });
+      const output2 = await embedder('async authenticate(user, password)', { pooling: 'mean', normalize: true });
+      const output3 = await embedder('function to sort array elements', { pooling: 'mean', normalize: true });
+      
+      const v1 = Array.from(output1.data);
+      const v2 = Array.from(output2.data);
+      const v3 = Array.from(output3.data);
+      
+      const sim12 = cosineSimilarity(v1, v2); // login-related
+      const sim13 = cosineSimilarity(v1, v3); // login vs sorting
+      
+      // Login concepts should be more similar to each other than to sorting
+      expect(sim12).toBeGreaterThan(sim13);
+    });
+    
+    it('should recognize programming language constructs', async () => {
+      const output1 = await embedder('import React from "react"', { pooling: 'mean', normalize: true });
+      const output2 = await embedder('import Vue from "vue"', { pooling: 'mean', normalize: true });
+      const output3 = await embedder('The weather is sunny today', { pooling: 'mean', normalize: true });
+      
+      const v1 = Array.from(output1.data);
+      const v2 = Array.from(output2.data);
+      const v3 = Array.from(output3.data);
+      
+      const sim12 = cosineSimilarity(v1, v2); // Both imports
+      const sim13 = cosineSimilarity(v1, v3); // Import vs weather
+      
+      // Import statements should be more similar to each other
+      expect(sim12).toBeGreaterThan(sim13);
+    });
+  });
+
+  describe('Cosine Similarity Function', () => {
+    it('should return 1 for identical vectors', () => {
+      const vector = [0.1, 0.2, 0.3, 0.4, 0.5];
+      expect(cosineSimilarity(vector, vector)).toBeCloseTo(1, 5);
+    });
+    
+    it('should return -1 for opposite vectors', () => {
+      const vector1 = [1, 0, 0];
+      const vector2 = [-1, 0, 0];
+      expect(cosineSimilarity(vector1, vector2)).toBeCloseTo(-1, 5);
+    });
+    
+    it('should return 0 for orthogonal vectors', () => {
+      const vector1 = [1, 0, 0];
+      const vector2 = [0, 1, 0];
+      expect(cosineSimilarity(vector1, vector2)).toBeCloseTo(0, 5);
+    });
+    
+    it('should handle high-dimensional vectors', () => {
+      const dim = 384;
+      const vector1 = Array(dim).fill(0).map(() => Math.random());
+      const vector2 = Array(dim).fill(0).map(() => Math.random());
+      
+      const similarity = cosineSimilarity(vector1, vector2);
+      
+      expect(similarity).toBeGreaterThanOrEqual(-1);
+      expect(similarity).toBeLessThanOrEqual(1);
+    });
+  });
+
+  describe('Performance', () => {
+    it('should generate embeddings in reasonable time', async () => {
+      const text = 'This is a test sentence for measuring embedding generation speed.';
+      
+      const start = Date.now();
+      await embedder(text, { pooling: 'mean', normalize: true });
+      const duration = Date.now() - start;
+      
+      // Should be fast (under 500ms for single embedding)
+      expect(duration).toBeLessThan(500);
+    });
+    
+    it('should handle multiple sequential embeddings', async () => {
+      const texts = [
+        'First test input',
+        'Second test input',
+        'Third test input',
+        'Fourth test input',
+        'Fifth test input'
+      ];
+      
+      const start = Date.now();
+      for (const text of texts) {
+        await embedder(text, { pooling: 'mean', normalize: true });
+      }
+      const duration = Date.now() - start;
+      
+      // 5 embeddings should complete in reasonable time
+      expect(duration).toBeLessThan(2500);
+      console.log(`[Test] 5 embeddings generated in ${duration}ms (${(duration/5).toFixed(0)}ms avg)`);
+    });
+  });
+});

package/test/helpers.js

@@ -0,0 +1,128 @@
+/**
+ * Test helper utilities for Smart Coding MCP tests
+ * Provides shared setup, teardown, and mock utilities
+ */
+
+import { loadConfig } from '../lib/config.js';
+import { EmbeddingsCache } from '../lib/cache.js';
+import { CodebaseIndexer } from '../features/index-codebase.js';
+import { CacheClearer } from '../features/clear-cache.js';
+import { HybridSearch } from '../features/hybrid-search.js';
+import { pipeline } from '@xenova/transformers';
+import fs from 'fs/promises';
+import path from 'path';
+
+// Cached embedder instance (shared across tests for speed)
+let sharedEmbedder = null;
+
+/**
+ * Get or initialize the shared embedder instance
+ * Loading the model once and reusing saves significant time
+ */
+export async function getEmbedder(config) {
+  if (!sharedEmbedder) {
+    console.log('[TestHelper] Loading embedding model (first time)...');
+    sharedEmbedder = await pipeline('feature-extraction', config.embeddingModel);
+    console.log('[TestHelper] Embedding model loaded');
+  }
+  return sharedEmbedder;
+}
+
+/**
+ * Create test fixtures with initialized components
+ * @param {Object} options - Options for fixture creation
+ * @returns {Object} Initialized components for testing
+ */
+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);
+  
+  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,
+    cache,
+    indexer,
+    cacheClearer,
+    hybridSearch
+  };
+}
+
+/**
+ * Clean up test resources
+ * @param {Object} fixtures - Test fixtures to clean up
+ */
+export async function cleanupFixtures(fixtures) {
+  if (fixtures.indexer) {
+    fixtures.indexer.terminateWorkers();
+    if (fixtures.indexer.watcher) {
+      await fixtures.indexer.watcher.close();
+    }
+  }
+}
+
+/**
+ * Clear the cache directory for a clean test state
+ * @param {Object} config - Configuration object
+ */
+export async function clearTestCache(config) {
+  try {
+    await fs.rm(config.cacheDirectory, { recursive: true, force: true });
+  } catch (err) {
+    // Ignore if doesn't exist
+  }
+}
+
+/**
+ * Create a mock MCP request object
+ * @param {string} toolName - Tool name
+ * @param {Object} args - Tool arguments
+ * @returns {Object} Mock request object
+ */
+export function createMockRequest(toolName, args = {}) {
+  return {
+    params: {
+      name: toolName,
+      arguments: args
+    }
+  };
+}
+
+/**
+ * Wait for a condition with timeout
+ * @param {Function} condition - Async function returning boolean
+ * @param {number} timeout - Max wait time in ms
+ * @param {number} interval - Check interval in ms
+ * @returns {boolean} Whether condition was met
+ */
+export async function waitFor(condition, timeout = 5000, interval = 100) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    if (await condition()) return true;
+    await new Promise(resolve => setTimeout(resolve, interval));
+  }
+  return false;
+}
+
+/**
+ * Measure execution time of an async function
+ * @param {Function} fn - Async function to measure
+ * @returns {Object} Result and duration
+ */
+export async function measureTime(fn) {
+  const start = Date.now();
+  const result = await fn();
+  const duration = Date.now() - start;
+  return { result, duration };
+}