smart-coding-mcp 1.0.0

package/index.js

@@ -0,0 +1,174 @@
+#!/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 { pipeline } from "@xenova/transformers";
+import fs from "fs/promises";
+
+import { loadConfig } from "./lib/config.js";
+import { EmbeddingsCache } from "./lib/cache.js";
+import { CodebaseIndexer } from "./features/index-codebase.js";
+import { HybridSearch } from "./features/hybrid-search.js";
+
+import * as IndexCodebaseFeature from "./features/index-codebase.js";
+import * as HybridSearchFeature from "./features/hybrid-search.js";
+import * as ClearCacheFeature from "./features/clear-cache.js";
+
+// Parse workspace from command line arguments
+const args = process.argv.slice(2);
+const workspaceIndex = args.findIndex(arg => arg.startsWith('--workspace'));
+let workspaceDir = null;
+
+if (workspaceIndex !== -1) {
+  const arg = args[workspaceIndex];
+  if (arg.includes('=')) {
+    workspaceDir = arg.split('=')[1];
+  } else if (workspaceIndex + 1 < args.length) {
+    workspaceDir = args[workspaceIndex + 1];
+  }
+  
+  if (workspaceDir) {
+    console.error(`[Server] Workspace mode: ${workspaceDir}`);
+  }
+}
+
+// Global state
+let embedder = null;
+let cache = null;
+let indexer = null;
+let hybridSearch = null;
+let config = null;
+
+// Feature registry
+const features = [
+  {
+    module: IndexCodebaseFeature,
+    instance: null,
+    handler: IndexCodebaseFeature.handleToolCall
+  },
+  {
+    module: HybridSearchFeature,
+    instance: null,
+    handler: HybridSearchFeature.handleToolCall
+  },
+  {
+    module: ClearCacheFeature,
+    instance: null,
+    handler: ClearCacheFeature.handleToolCall
+  }
+];
+
+// Initialize application
+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`);
+    process.exit(1);
+  }
+
+  // Load AI model
+  console.error("[Server] Loading AI embedding model (this may take time on first run)...");
+  embedder = await pipeline("feature-extraction", config.embeddingModel);
+
+  // Initialize cache
+  cache = new EmbeddingsCache(config);
+  await cache.load();
+
+  // Initialize features
+  indexer = new CodebaseIndexer(embedder, cache, config);
+  hybridSearch = new HybridSearch(embedder, cache, config);
+  const cacheClearer = new ClearCacheFeature.CacheClearer(embedder, cache, config);
+
+  // Store feature instances
+  features[0].instance = indexer;
+  features[1].instance = hybridSearch;
+  features[2].instance = cacheClearer;
+
+  // Index codebase
+  await indexer.initialize();
+}
+
+// Setup MCP server
+const server = new Server(
+  { 
+    name: "smart-coding-mcp", 
+    version: "1.0.0" 
+  },
+  { 
+    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);
+  }
+
+  return { tools };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  for (const feature of features) {
+    const toolDef = feature.module.getToolDefinition(config);
+    
+    if (request.params.name === toolDef.name) {
+      return await feature.handler(request, feature.instance);
+    }
+  }
+
+  return {
+    content: [{
+      type: "text",
+      text: `Unknown tool: ${request.params.name}`
+    }]
+  };
+});
+
+// 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 () => {
+  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 () => {
+  console.error("\n[Server] Received SIGTERM, shutting down...");
+  process.exit(0);
+});
+
+main().catch(console.error);

package/lib/cache.js

@@ -0,0 +1,114 @@
+import fs from "fs/promises";
+import path from "path";
+
+export class EmbeddingsCache {
+  constructor(config) {
+    this.config = config;
+    this.vectorStore = [];
+    this.fileHashes = new Map();
+  }
+
+  async load() {
+    if (!this.config.enableCache) return;
+    
+    try {
+      await fs.mkdir(this.config.cacheDirectory, { recursive: true });
+      const cacheFile = path.join(this.config.cacheDirectory, "embeddings.json");
+      const hashFile = path.join(this.config.cacheDirectory, "file-hashes.json");
+      
+      const [cacheData, hashData] = await Promise.all([
+        fs.readFile(cacheFile, "utf-8").catch(() => null),
+        fs.readFile(hashFile, "utf-8").catch(() => null)
+      ]);
+
+      if (cacheData && hashData) {
+        const rawVectorStore = JSON.parse(cacheData);
+        const rawHashes = new Map(Object.entries(JSON.parse(hashData)));
+        
+        // Filter cache to only include files matching current extensions
+        const allowedExtensions = this.config.fileExtensions.map(ext => `.${ext}`);
+        
+        this.vectorStore = rawVectorStore.filter(chunk => {
+          const ext = path.extname(chunk.file);
+          return allowedExtensions.includes(ext);
+        });
+        
+        // Only keep hashes for files matching current extensions
+        for (const [file, hash] of rawHashes) {
+          const ext = path.extname(file);
+          if (allowedExtensions.includes(ext)) {
+            this.fileHashes.set(file, hash);
+          }
+        }
+        
+        const filtered = rawVectorStore.length - this.vectorStore.length;
+        if (filtered > 0) {
+          console.error(`[Cache] Filtered ${filtered} outdated cache entries`);
+        }
+        console.error(`[Cache] Loaded ${this.vectorStore.length} cached embeddings`);
+      }
+    } catch (error) {
+      console.error("[Cache] Failed to load cache:", error.message);
+    }
+  }
+
+  async save() {
+    if (!this.config.enableCache) return;
+    
+    try {
+      await fs.mkdir(this.config.cacheDirectory, { recursive: true });
+      const cacheFile = path.join(this.config.cacheDirectory, "embeddings.json");
+      const hashFile = path.join(this.config.cacheDirectory, "file-hashes.json");
+      
+      await Promise.all([
+        fs.writeFile(cacheFile, JSON.stringify(this.vectorStore, null, 2)),
+        fs.writeFile(hashFile, JSON.stringify(Object.fromEntries(this.fileHashes), null, 2))
+      ]);
+    } catch (error) {
+      console.error("[Cache] Failed to save cache:", error.message);
+    }
+  }
+
+  getVectorStore() {
+    return this.vectorStore;
+  }
+
+  setVectorStore(store) {
+    this.vectorStore = store;
+  }
+
+  getFileHash(file) {
+    return this.fileHashes.get(file);
+  }
+
+  setFileHash(file, hash) {
+    this.fileHashes.set(file, hash);
+  }
+
+  deleteFileHash(file) {
+    this.fileHashes.delete(file);
+  }
+
+  removeFileFromStore(file) {
+    this.vectorStore = this.vectorStore.filter(chunk => chunk.file !== file);
+  }
+
+
+  addToStore(chunk) {
+    this.vectorStore.push(chunk);
+  }
+
+  async clear() {
+    if (!this.config.enableCache) return;
+    
+    try {
+      await fs.rm(this.config.cacheDirectory, { recursive: true, force: true });
+      this.vectorStore = [];
+      this.fileHashes = new Map();
+      console.error(`[Cache] Cache cleared successfully: ${this.config.cacheDirectory}`);
+    } catch (error) {
+      console.error("[Cache] Failed to clear cache:", error.message);
+      throw error;
+    }
+  }
+}

package/lib/config.js

@@ -0,0 +1,146 @@
+import fs from "fs/promises";
+import path from "path";
+import { ProjectDetector } from "./project-detector.js";
+
+const DEFAULT_CONFIG = {
+  searchDirectory: ".",
+  fileExtensions: [
+    // JavaScript/TypeScript
+    "js", "ts", "jsx", "tsx", "mjs", "cjs",
+    // Styles
+    "css", "scss", "sass", "less", "styl",
+    // Markup
+    "html", "htm", "xml", "svg",
+    // Python
+    "py", "pyw", "pyx",
+    // Java/Kotlin/Scala
+    "java", "kt", "kts", "scala",
+    // C/C++
+    "c", "cpp", "cc", "cxx", "h", "hpp", "hxx",
+    // C#
+    "cs", "csx",
+    // Go
+    "go",
+    // Rust
+    "rs",
+    // Ruby
+    "rb", "rake",
+    // PHP
+    "php", "phtml",
+    // Swift
+    "swift",
+    // Shell scripts
+    "sh", "bash", "zsh", "fish",
+    // Config & Data
+    "json", "yaml", "yml", "toml", "ini", "env",
+    // Documentation
+    "md", "mdx", "txt", "rst",
+    // Database
+    "sql",
+    // Other
+    "r", "R", "lua", "vim", "pl", "pm"
+  ],
+  excludePatterns: [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.git/**",
+    "**/coverage/**",
+    "**/.next/**",
+    "**/target/**",
+    "**/vendor/**"
+  ],
+  chunkSize: 15,
+  chunkOverlap: 3,
+  batchSize: 100,
+  maxFileSize: 1048576, // 1MB - skip files larger than this
+  maxResults: 5,
+  enableCache: true,
+  cacheDirectory: "./.smart-coding-cache",
+  watchFiles: true,
+  verbose: false,
+  embeddingModel: "Xenova/all-MiniLM-L6-v2",
+  semanticWeight: 0.7,
+  exactMatchBoost: 1.5,
+  smartIndexing: true
+};
+
+let config = { ...DEFAULT_CONFIG };
+
+export async function loadConfig(workspaceDir = null) {
+  try {
+    // Determine the base directory for configuration
+    let baseDir;
+    let configPath;
+    
+    if (workspaceDir) {
+      // Workspace mode: load config from workspace root
+      baseDir = path.resolve(workspaceDir);
+      configPath = path.join(baseDir, "config.json");
+      console.error(`[Config] Workspace mode: ${baseDir}`);
+    } else {
+      // Server mode: load config from server directory
+      const scriptDir = path.dirname(new URL(import.meta.url).pathname);
+      baseDir = path.resolve(scriptDir, '..');
+      configPath = path.join(baseDir, "config.json");
+    }
+    
+    let userConfig = {};
+    try {
+      const configData = await fs.readFile(configPath, "utf-8");
+      userConfig = JSON.parse(configData);
+    } catch (configError) {
+      if (workspaceDir) {
+        console.error(`[Config] No config.json in workspace, using defaults`);
+      } else {
+        console.error(`[Config] No config.json found: ${configError.message}`);
+      }
+    }
+    
+    config = { ...DEFAULT_CONFIG, ...userConfig };
+    
+    // Set workspace-specific directories
+    if (workspaceDir) {
+      config.searchDirectory = baseDir;
+      config.cacheDirectory = path.join(baseDir, ".smart-coding-cache");
+    } else {
+      config.searchDirectory = path.resolve(baseDir, config.searchDirectory);
+      config.cacheDirectory = path.resolve(baseDir, config.cacheDirectory);
+    }
+    
+    // Smart project detection
+    if (config.smartIndexing !== false) {
+      const detector = new ProjectDetector(config.searchDirectory);
+      const detectedTypes = await detector.detectProjectTypes();
+      
+      if (detectedTypes.length > 0) {
+        const smartPatterns = detector.getSmartIgnorePatterns();
+        
+        // Merge smart patterns with user patterns (user patterns take precedence)
+        const userPatterns = userConfig.excludePatterns || [];
+        config.excludePatterns = [
+          ...smartPatterns,
+          ...userPatterns
+        ];
+        
+        console.error(`[Config] Smart indexing: ${detectedTypes.join(', ')}`);
+        console.error(`[Config] Applied ${smartPatterns.length} smart ignore patterns`);
+      } else {
+        console.error("[Config] No project markers detected, using default patterns");
+      }
+    }
+    
+    console.error("[Config] Loaded configuration from config.json");
+  } catch (error) {
+    console.error("[Config] Using default configuration (config.json not found or invalid)");
+    console.error(`[Config] Error: ${error.message}`);
+  }
+  
+  return config;
+}
+
+export function getConfig() {
+  return config;
+}
+
+export { DEFAULT_CONFIG };