smart-coding-mcp 1.3.0 → 1.3.1

package/README.md

@@ -1,6 +1,11 @@
 # Smart Coding MCP
 
-An extensible Model Context Protocol (MCP) server that provides intelligent semantic code search for AI assistants. Built with local AI models, inspired by Cursor's semantic search research.
+[![npm version](https://img.shields.io/npm/v/smart-coding-mcp.svg)](https://www.npmjs.com/package/smart-coding-mcp)
+[![npm downloads](https://img.shields.io/npm/dm/smart-coding-mcp.svg)](https://www.npmjs.com/package/smart-coding-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Node.js](https://img.shields.io/badge/Node.js-%3E%3D18-green.svg)](https://nodejs.org/)
+
+An extensible Model Context Protocol (MCP) server that provides intelligent semantic code search for AI assistants. Built with local AI models (RAG), inspired by Cursor's semantic search research.
 
 ## What This Does
 

package/features/clear-cache.js

@@ -1,16 +1,39 @@
 export class CacheClearer {
-  constructor(embedder, cache, config) {
+  constructor(embedder, cache, config, indexer) {
     this.cache = cache;
     this.config = config;
+    this.indexer = indexer;
+    this.isClearing = false;
   }
 
   async execute() {
-    await this.cache.clear();
-    return {
-      success: true,
-      message: `Cache cleared successfully. Next indexing will be a full rebuild.`,
-      cacheDirectory: this.config.cacheDirectory
-    };
+    // Check if indexing is in progress
+    if (this.indexer && this.indexer.isIndexing) {
+      throw new Error("Cannot clear cache while indexing is in progress. Please wait for indexing to complete.");
+    }
+
+    // Check if cache is currently being saved (race condition prevention)
+    if (this.cache.isSaving) {
+      throw new Error("Cannot clear cache while cache is being saved. Please try again in a moment.");
+    }
+
+    // Check if a clear operation is already in progress (prevent concurrent clears)
+    if (this.isClearing) {
+      throw new Error("Cache clear operation already in progress. Please wait for it to complete.");
+    }
+
+    this.isClearing = true;
+
+    try {
+      await this.cache.clear();
+      return {
+        success: true,
+        message: `Cache cleared successfully. Next indexing will be a full rebuild.`,
+        cacheDirectory: this.config.cacheDirectory
+      };
+    } finally {
+      this.isClearing = false;
+    }
   }
 }
 

package/features/index-codebase.js

@@ -18,6 +18,7 @@ export class CodebaseIndexer {
     this.watcher = null;
     this.workers = [];
     this.workerReady = [];
+    this.isIndexing = false;
   }
 
   /**
@@ -409,8 +410,22 @@ export class CodebaseIndexer {
     return filesToProcess;
   }
 
-  async indexAll() {
-    const totalStartTime = Date.now();
+  async indexAll(force = false) {
+    if (this.isIndexing) {
+      console.error("[Indexer] Indexing already in progress, skipping concurrent request");
+      return { skipped: true, reason: "Indexing already in progress" };
+    }
+
+    this.isIndexing = true;
+
+    try {
+      if (force) {
+        console.error("[Indexer] Force reindex requested: clearing cache");
+        this.cache.setVectorStore([]);
+        this.cache.fileHashes = new Map();
+      }
+
+      const totalStartTime = Date.now();
     console.error(`[Indexer] Starting optimized indexing in ${this.config.searchDirectory}...`);
     
     // Step 1: Fast file discovery with fdir
@@ -419,7 +434,7 @@ export class CodebaseIndexer {
     if (files.length === 0) {
       console.error("[Indexer] No files found to index");
       this.sendProgress(100, 100, "No files found to index");
-      return;
+      return { skipped: false, filesProcessed: 0, chunksCreated: 0, message: "No files found to index" };
     }
 
     // Send progress: discovery complete
@@ -432,7 +447,15 @@ export class CodebaseIndexer {
       console.error("[Indexer] All files unchanged, nothing to index");
       this.sendProgress(100, 100, "All files up to date");
       await this.cache.save();
-      return;
+      const vectorStore = this.cache.getVectorStore();
+      return { 
+        skipped: false, 
+        filesProcessed: 0, 
+        chunksCreated: 0, 
+        totalFiles: new Set(vectorStore.map(v => v.file)).size,
+        totalChunks: vectorStore.length,
+        message: "All files up to date" 
+      };
     }
 
     // Send progress: filtering complete
@@ -541,6 +564,20 @@ export class CodebaseIndexer {
     this.sendProgress(100, 100, `Complete: ${totalChunks} chunks from ${filesToProcess.length} files in ${totalTime}s`);
     
     await this.cache.save();
+    
+    const vectorStore = this.cache.getVectorStore();
+    return {
+      skipped: false,
+      filesProcessed: filesToProcess.length,
+      chunksCreated: totalChunks,
+      totalFiles: new Set(vectorStore.map(v => v.file)).size,
+      totalChunks: vectorStore.length,
+      duration: totalTime,
+      message: `Indexed ${filesToProcess.length} files (${totalChunks} chunks) in ${totalTime}s`
+    };
+    } finally {
+      this.isIndexing = false;
+    }
   }
 
   setupFileWatcher() {
@@ -608,25 +645,41 @@ export function getToolDefinition() {
 // Tool handler
 export async function handleToolCall(request, indexer) {
   const force = request.params.arguments?.force || false;
+  const result = await indexer.indexAll(force);
   
-  if (force) {
-    // Clear cache to force full reindex
-    indexer.cache.setVectorStore([]);
-    indexer.cache.fileHashes = new Map();
+  // Handle case when indexing was skipped due to concurrent request
+  if (result?.skipped) {
+    return {
+      content: [{
+        type: "text",
+        text: `Indexing skipped: ${result.reason}\n\nPlease wait for the current indexing operation to complete before requesting another reindex.`
+      }]
+    };
   }
   
-  await indexer.indexAll();
-  
+  // Get current stats from cache
   const vectorStore = indexer.cache.getVectorStore();
   const stats = {
-    totalChunks: vectorStore.length,
-    totalFiles: new Set(vectorStore.map(v => v.file)).size
+    totalChunks: result?.totalChunks ?? vectorStore.length,
+    totalFiles: result?.totalFiles ?? new Set(vectorStore.map(v => v.file)).size,
+    filesProcessed: result?.filesProcessed ?? 0,
+    chunksCreated: result?.chunksCreated ?? 0
   };
   
+  let message = result?.message 
+    ? `Codebase reindexed successfully.\n\n${result.message}`
+    : `Codebase reindexed successfully.`;
+  
+  message += `\n\nStatistics:\n- Total files in index: ${stats.totalFiles}\n- Total code chunks: ${stats.totalChunks}`;
+  
+  if (stats.filesProcessed > 0) {
+    message += `\n- Files processed this run: ${stats.filesProcessed}\n- Chunks created this run: ${stats.chunksCreated}`;
+  }
+  
   return {
     content: [{
       type: "text",
-      text: `Codebase reindexed successfully.\n\nStatistics:\n- Files indexed: ${stats.totalFiles}\n- Code chunks: ${stats.totalChunks}`
+      text: message
     }]
   };
 }

package/index.js

@@ -97,7 +97,7 @@ async function initialize() {
   // Initialize features
   indexer = new CodebaseIndexer(embedder, cache, config, server);
   hybridSearch = new HybridSearch(embedder, cache, config);
-  const cacheClearer = new ClearCacheFeature.CacheClearer(embedder, cache, config);
+  const cacheClearer = new ClearCacheFeature.CacheClearer(embedder, cache, config, indexer);
 
   // Store feature instances (matches features array order)
   features[0].instance = hybridSearch;

package/lib/cache.js

@@ -6,6 +6,7 @@ export class EmbeddingsCache {
     this.config = config;
     this.vectorStore = [];
     this.fileHashes = new Map();
+    this.isSaving = false;
   }
 
   async load() {
@@ -55,6 +56,8 @@ export class EmbeddingsCache {
   async save() {
     if (!this.config.enableCache) return;
     
+    this.isSaving = true;
+    
     try {
       await fs.mkdir(this.config.cacheDirectory, { recursive: true });
       const cacheFile = path.join(this.config.cacheDirectory, "embeddings.json");
@@ -66,6 +69,8 @@ export class EmbeddingsCache {
       ]);
     } catch (error) {
       console.error("[Cache] Failed to save cache:", error.message);
+    } finally {
+      this.isSaving = false;
     }
   }
 

package/lib/config.js

@@ -49,7 +49,8 @@ const DEFAULT_CONFIG = {
     "**/coverage/**",
     "**/.next/**",
     "**/target/**",
-    "**/vendor/**"
+    "**/vendor/**",
+    "**/.smart-coding-cache/**"
   ],
   chunkSize: 25, // Lines per chunk (larger = fewer embeddings = faster indexing)
   chunkOverlap: 5, // Overlap between chunks for context continuity

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smart-coding-mcp",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "An extensible MCP server that enhances coding productivity with AI-powered features including semantic code search, intelligent indexing, and more, using local LLMs",
   "type": "module",
   "main": "index.js",
@@ -10,6 +10,8 @@
   "scripts": {
     "start": "node index.js",
     "dev": "node --watch index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "clear-cache": "node scripts/clear-cache.js"
   },
   "keywords": [
@@ -51,5 +53,8 @@
   },
   "engines": {
     "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "vitest": "^4.0.16"
   }
 }

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;
+    });
+  });
+});