smart-coding-mcp 2.0.0 → 2.1.1

package/index.js

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
 import fs from "fs/promises";
 import { createRequire } from "module";
 
@@ -10,7 +13,7 @@ const require = createRequire(import.meta.url);
 const packageJson = require("./package.json");
 
 import { loadConfig } from "./lib/config.js";
-import { EmbeddingsCache } from "./lib/cache.js";
+import { SQLiteCache } from "./lib/sqlite-cache.js";
 import { createEmbedder } from "./lib/mrl-embedder.js";
 import { CodebaseIndexer } from "./features/index-codebase.js";
 import { HybridSearch } from "./features/hybrid-search.js";
@@ -24,24 +27,30 @@ import * as GetStatusFeature from "./features/get-status.js";
 
 // Parse workspace from command line arguments
 const args = process.argv.slice(2);
-const workspaceIndex = args.findIndex(arg => arg.startsWith('--workspace'));
+const workspaceIndex = args.findIndex((arg) => arg.startsWith("--workspace"));
 let workspaceDir = process.cwd(); // Default to current directory
 
 if (workspaceIndex !== -1) {
   const arg = args[workspaceIndex];
   let rawWorkspace = null;
 
-  if (arg.includes('=')) {
-    rawWorkspace = arg.split('=')[1];
+  if (arg.includes("=")) {
+    rawWorkspace = arg.split("=")[1];
   } else if (workspaceIndex + 1 < args.length) {
     rawWorkspace = args[workspaceIndex + 1];
   }
 
   // Check if IDE variable wasn't expanded (contains ${})
-  if (rawWorkspace && rawWorkspace.includes('${')) {
-    console.error(`[Server] FATAL: Workspace variable "${rawWorkspace}" was not expanded by your IDE.`);
-    console.error(`[Server] This typically means your MCP client does not support dynamic variables.`);
-    console.error(`[Server] Please use an absolute path instead: --workspace /path/to/your/project`);
+  if (rawWorkspace && rawWorkspace.includes("${")) {
+    console.error(
+      `[Server] FATAL: Workspace variable "${rawWorkspace}" was not expanded by your IDE.`
+    );
+    console.error(
+      `[Server] This typically means your MCP client does not support dynamic variables.`
+    );
+    console.error(
+      `[Server] Please use an absolute path instead: --workspace /path/to/your/project`
+    );
     process.exit(1);
   } else if (rawWorkspace) {
     workspaceDir = rawWorkspace;
@@ -58,110 +67,167 @@ let cache = null;
 let indexer = null;
 let hybridSearch = null;
 let config = null;
+let isInitialized = false;
+let initializationPromise = null;
 
 // Feature registry - ordered by priority (semantic_search first as primary tool)
 const features = [
   {
     module: HybridSearchFeature,
     instance: null,
-    handler: HybridSearchFeature.handleToolCall
+    handler: HybridSearchFeature.handleToolCall,
   },
   {
     module: IndexCodebaseFeature,
     instance: null,
-    handler: IndexCodebaseFeature.handleToolCall
+    handler: IndexCodebaseFeature.handleToolCall,
   },
   {
     module: ClearCacheFeature,
     instance: null,
-    handler: ClearCacheFeature.handleToolCall
+    handler: ClearCacheFeature.handleToolCall,
   },
   {
     module: CheckLastVersionFeature,
     instance: null,
-    handler: CheckLastVersionFeature.handleToolCall
+    handler: CheckLastVersionFeature.handleToolCall,
   },
   {
     module: SetWorkspaceFeature,
     instance: null,
-    handler: SetWorkspaceFeature.handleToolCall
+    handler: SetWorkspaceFeature.handleToolCall,
   },
   {
     module: GetStatusFeature,
     instance: null,
-    handler: GetStatusFeature.handleToolCall
-  }
+    handler: GetStatusFeature.handleToolCall,
+  },
 ];
 
-// Initialize application
+/**
+ * Lazy initialization - only loads heavy resources when first needed
+ * This prevents IDE blocking on startup
+ */
+async function ensureInitialized() {
+  // Already initialized
+  if (isInitialized) {
+    return;
+  }
+
+  // Initialization in progress, wait for it
+  if (initializationPromise) {
+    return initializationPromise;
+  }
+
+  // Start initialization
+  initializationPromise = (async () => {
+    console.error("[Server] Loading AI model and cache (first use)...");
+
+    // Load AI model using MRL embedder factory
+    embedder = await createEmbedder(config);
+    console.error(
+      `[Server] Model: ${embedder.modelName} (${embedder.dimension}d, device: ${embedder.device})`
+    );
+
+    // Initialize cache
+    cache = new SQLiteCache(config);
+    await cache.load();
+
+    // Initialize features
+    indexer = new CodebaseIndexer(embedder, cache, config, server);
+    hybridSearch = new HybridSearch(embedder, cache, config, indexer);
+    const cacheClearer = new ClearCacheFeature.CacheClearer(
+      embedder,
+      cache,
+      config,
+      indexer
+    );
+    const versionChecker = new CheckLastVersionFeature.VersionChecker(config);
+
+    // Store feature instances (matches features array order)
+    features[0].instance = hybridSearch;
+    features[1].instance = indexer;
+    features[2].instance = cacheClearer;
+    features[3].instance = versionChecker;
+
+    // Initialize new tools
+    const workspaceManager = new SetWorkspaceFeature.WorkspaceManager(
+      config,
+      cache,
+      indexer
+    );
+    const statusReporter = new GetStatusFeature.StatusReporter(
+      config,
+      cache,
+      indexer,
+      embedder
+    );
+    features[4].instance = workspaceManager;
+    features[5].instance = statusReporter;
+
+    isInitialized = true;
+    console.error("[Server] Model and cache loaded successfully");
+  })();
+
+  await initializationPromise;
+}
+
+// Initialize application (lightweight, non-blocking)
 async function initialize() {
   // Load configuration with workspace support
   config = await loadConfig(workspaceDir);
-  
+
   // Ensure search directory exists
   try {
     await fs.access(config.searchDirectory);
   } catch {
-    console.error(`[Server] Error: Search directory "${config.searchDirectory}" does not exist`);
+    console.error(
+      `[Server] Error: Search directory "${config.searchDirectory}" does not exist`
+    );
     process.exit(1);
   }
 
-  // Load AI model using MRL embedder factory
-  console.error("[Server] Loading AI embedding model (this may take time on first run)...");
-  embedder = await createEmbedder(config);
-  console.error(`[Server] Model: ${embedder.modelName} (${embedder.dimension}d, device: ${embedder.device})`);
-
-  // Initialize cache
-  cache = new EmbeddingsCache(config);
-  await cache.load();
-
-  // Initialize features
-  indexer = new CodebaseIndexer(embedder, cache, config, server);
-  hybridSearch = new HybridSearch(embedder, cache, config);
-  const cacheClearer = new ClearCacheFeature.CacheClearer(embedder, cache, config, indexer);
-  const versionChecker = new CheckLastVersionFeature.VersionChecker(config);
-
-  // Store feature instances (matches features array order)
-  features[0].instance = hybridSearch;
-  features[1].instance = indexer;
-  features[2].instance = cacheClearer;
-  features[3].instance = versionChecker;
-  
-  // Initialize new tools
-  const workspaceManager = new SetWorkspaceFeature.WorkspaceManager(config, cache, indexer);
-  const statusReporter = new GetStatusFeature.StatusReporter(config, cache, indexer, embedder);
-  features[4].instance = workspaceManager;
-  features[5].instance = statusReporter;
-
-  // Start indexing in background (non-blocking)
-  console.error("[Server] Starting background indexing...");
-  indexer.indexAll().then(() => {
-    // Only start file watcher if explicitly enabled in config
-    if (config.watchFiles) {
-      indexer.setupFileWatcher();
-    }
-  }).catch(err => {
-    console.error("[Server] Background indexing error:", err.message);
-  });
+  console.error(
+    "[Server] Configuration loaded. Model will load on first use (lazy initialization)."
+  );
+
+  // Optional: auto-index after delay
+  if (config.autoIndexDelay && config.autoIndexDelay > 0) {
+    console.error(
+      `[Server] Auto-indexing will start after ${config.autoIndexDelay}ms delay...`
+    );
+    setTimeout(async () => {
+      console.error("[Server] Starting auto-indexing...");
+      try {
+        await ensureInitialized();
+        await indexer.indexAll();
+        if (config.watchFiles) {
+          indexer.setupFileWatcher();
+        }
+      } catch (err) {
+        console.error("[Server] Auto-indexing error:", err.message);
+      }
+    }, config.autoIndexDelay);
+  }
 }
 
 // Setup MCP server
 const server = new Server(
-  { 
-    name: "smart-coding-mcp", 
-    version: packageJson.version 
+  {
+    name: "smart-coding-mcp",
+    version: packageJson.version,
   },
-  { 
-    capabilities: { 
-      tools: {} 
-    } 
+  {
+    capabilities: {
+      tools: {},
+    },
   }
 );
 
 // Register tools from all features
 server.setRequestHandler(ListToolsRequestSchema, async () => {
   const tools = [];
-  
+
   for (const feature of features) {
     const toolDef = feature.module.getToolDefinition(config);
     tools.push(toolDef);
@@ -172,6 +238,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 
 // Handle tool calls
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  // Ensure model and cache are loaded before handling any tool
+  await ensureInitialized();
+  
   for (const feature of features) {
     const toolDef = feature.module.getToolDefinition(config);
     
@@ -191,36 +260,36 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 // Main entry point
 async function main() {
   await initialize();
-  
+
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  
+
   console.error("[Server] Smart Coding MCP server ready!");
 }
 
 // Graceful shutdown
-process.on('SIGINT', async () => {
+process.on("SIGINT", async () => {
   console.error("\n[Server] Shutting down gracefully...");
-  
+
   // Stop file watcher
   if (indexer && indexer.watcher) {
     await indexer.watcher.close();
     console.error("[Server] File watcher stopped");
   }
-  
+
   // Save cache
   if (cache) {
     await cache.save();
     console.error("[Server] Cache saved");
   }
-  
+
   console.error("[Server] Goodbye!");
   process.exit(0);
 });
 
-process.on('SIGTERM', async () => {
+process.on("SIGTERM", async () => {
   console.error("\n[Server] Received SIGTERM, shutting down...");
   process.exit(0);
 });
 
-main().catch(console.error);
+main().catch(console.error);

package/lib/config.js

@@ -63,12 +63,24 @@ const DEFAULT_CONFIG = {
   verbose: false,
   workerThreads: "auto", // "auto" = CPU cores - 1, or set a number
   embeddingModel: "nomic-ai/nomic-embed-text-v1.5",
-  embeddingDimension: 256, // MRL dimension: 64, 128, 256, 512, 768
+  embeddingDimension: 128, // MRL dimension: 64, 128, 256, 512, 768 (changed from 256 to 128 for better performance)
   device: "auto", // "cpu", "webgpu", or "auto"
   chunkingMode: "smart", // "smart", "ast", or "line"
   semanticWeight: 0.7,
   exactMatchBoost: 1.5,
-  smartIndexing: true
+  smartIndexing: true,
+  
+  // Resource throttling (prevents CPU exhaustion)
+  maxCpuPercent: 25,        // Max CPU usage during indexing (default: 25%)
+  batchDelay: 250,          // Delay between batches in ms (default: 250)
+  maxWorkers: 'auto',       // Max worker threads ('auto' = 25% of cores, or specific number)
+  
+  // Startup behavior
+  autoIndexDelay: null,     // Delay before auto-indexing (ms), null = disabled (lazy index on first search)
+  
+  // Progressive indexing
+  incrementalSaveInterval: 5, // Save to cache every N batches
+  allowPartialSearch: true    // Allow searches while indexing is in progress
 };
 
 let config = { ...DEFAULT_CONFIG };
@@ -276,6 +288,44 @@ export async function loadConfig(workspaceDir = null) {
     }
   }
   
+  // Resource throttling - Max CPU percent
+  if (process.env.SMART_CODING_MAX_CPU_PERCENT !== undefined) {
+    const value = parseInt(process.env.SMART_CODING_MAX_CPU_PERCENT, 10);
+    if (!isNaN(value) && value >= 10 && value <= 100) {
+      config.maxCpuPercent = value;
+      console.error(`[Config] Max CPU usage: ${value}%`);
+    } else {
+      console.error(`[Config] Invalid SMART_CODING_MAX_CPU_PERCENT: ${value}, using default (must be 10-100)`);
+    }
+  }
+  
+  // Resource throttling - Batch delay
+  if (process.env.SMART_CODING_BATCH_DELAY !== undefined) {
+    const value = parseInt(process.env.SMART_CODING_BATCH_DELAY, 10);
+    if (!isNaN(value) && value >= 0 && value <= 5000) {
+      config.batchDelay = value;
+      console.error(`[Config] Batch delay: ${value}ms`);
+    } else {
+      console.error(`[Config] Invalid SMART_CODING_BATCH_DELAY: ${value}, using default (must be 0-5000)`);
+    }
+  }
+  
+  // Resource throttling - Max workers
+  if (process.env.SMART_CODING_MAX_WORKERS !== undefined) {
+    const value = process.env.SMART_CODING_MAX_WORKERS.trim().toLowerCase();
+    if (value === 'auto') {
+      config.maxWorkers = 'auto';
+    } else {
+      const numValue = parseInt(value, 10);
+      if (!isNaN(numValue) && numValue >= 1 && numValue <= 32) {
+        config.maxWorkers = numValue;
+        console.error(`[Config] Max workers: ${numValue}`);
+      } else {
+        console.error(`[Config] Invalid SMART_CODING_MAX_WORKERS: ${value}, using default (must be 'auto' or 1-32)`);
+      }
+    }
+  }
+  
   return config;
 }
 

package/lib/resource-throttle.js

@@ -0,0 +1,85 @@
+import os from 'os';
+
+/**
+ * Resource throttling utility to prevent CPU/memory exhaustion during indexing
+ * Ensures the MCP server doesn't freeze the user's laptop
+ */
+export class ResourceThrottle {
+  constructor(config) {
+    // Max CPU usage as percentage (default 50%)
+    this.maxCpuPercent = config.maxCpuPercent || 50;
+    
+    // Delay between batches in milliseconds
+    this.batchDelay = config.batchDelay || 100;
+    
+    // Max worker threads (override auto-detection)
+    const cpuCount = os.cpus().length;
+    if (config.maxWorkers === 'auto' || config.maxWorkers === undefined) {
+      // Use 25% of cores by default for throttling (more conservative)
+      this.maxWorkers = Math.max(1, Math.floor(cpuCount * 0.25));
+    } else {
+      // Validate and parse the value
+      const parsed = typeof config.maxWorkers === 'number' 
+        ? config.maxWorkers 
+        : parseInt(config.maxWorkers, 10);
+      
+      if (isNaN(parsed) || parsed < 1) {
+        console.error(`[Throttle] Invalid maxWorkers: ${config.maxWorkers}, using auto`);
+        this.maxWorkers = Math.max(1, Math.floor(cpuCount * 0.5));
+      } else {
+        this.maxWorkers = Math.max(1, Math.min(parsed, cpuCount));
+      }
+    }
+    
+    console.error(`[Throttle] CPU limit: ${this.maxCpuPercent}%, Batch delay: ${this.batchDelay}ms, Max workers: ${this.maxWorkers}`);
+  }
+
+  /**
+   * Execute work with delay to throttle CPU usage
+   */
+  async throttledBatch(work, signal = null) {
+    // Execute the work
+    if (work) {
+      await work();
+    }
+    
+    // Apply delay if not aborted
+    if (!signal?.aborted && this.batchDelay > 0) {
+      await this.sleep(this.batchDelay);
+    }
+  }
+
+  /**
+   * Sleep utility
+   */
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Calculate optimal worker count based on CPU limit
+   */
+  getWorkerCount(requestedWorkers) {
+    if (requestedWorkers === 'auto') {
+      return this.maxWorkers;
+    }
+    return Math.min(requestedWorkers, this.maxWorkers);
+  }
+
+  /**
+   * Check if we should pause due to high CPU usage
+   * This is a simple implementation - could be enhanced with actual CPU monitoring
+   */
+  async checkCpuUsage() {
+    // Future enhancement: monitor actual CPU usage and pause if needed
+    // For now, we rely on worker limits and batch delays
+    return true;
+  }
+}
+
+/**
+ * Sleep utility function
+ */
+export function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}