smart-coding-mcp 1.1.0 → 1.2.1

package/README.md

@@ -30,36 +30,90 @@ This MCP server solves that by indexing your codebase with AI embeddings. Your A
 
 ## Installation
 
-### Prerequisites
+Install globally via npm:
 
-- Node.js 18 or higher
-- npm or yarn
+```bash
+npm install -g smart-coding-mcp
+```
 
-### Setup
+## Configuration
 
-1. Install dependencies:
+Add to your MCP configuration file (e.g., `~/.config/claude/mcp.json` or similar):
 
-```bash
-npm install
+### Option 1: Specific Project (Recommended)
+
+```json
+{
+  "mcpServers": {
+    "smart-coding-mcp": {
+      "command": "smart-coding-mcp",
+      "args": ["--workspace", "/absolute/path/to/your/project"]
+    }
+  }
+}
 ```
 
-2. Add to your MCP configuration file:
+### Option 2: Multi-Project Support
+
+```json
+{
+  "mcpServers": {
+    "smart-coding-mcp-project-a": {
+      "command": "smart-coding-mcp",
+      "args": ["--workspace", "/path/to/project-a"]
+    },
+    "smart-coding-mcp-project-b": {
+      "command": "smart-coding-mcp",
+      "args": ["--workspace", "/path/to/project-b"]
+    }
+  }
+}
+```
+
+### Option 3: Auto-Detect Current Directory
 
 ```json
 {
   "mcpServers": {
     "smart-coding-mcp": {
-      "command": "node",
-      "args": ["/path/to/smart-coding-mcp/index.js"],
-      "cwd": "/path/to/smart-coding-mcp"
+      "command": "smart-coding-mcp"
     }
   }
 }
 ```
 
-3. Restart your AI assistant
+## Environment Variables
+
+Override configuration settings via environment variables in your MCP config:
+
+| Variable                      | Type    | Default   | Description                    |
+| ----------------------------- | ------- | --------- | ------------------------------ |
+| `SMART_CODING_VERBOSE`        | boolean | `false`   | Enable detailed logging        |
+| `SMART_CODING_BATCH_SIZE`     | number  | `100`     | Files to process in parallel   |
+| `SMART_CODING_MAX_FILE_SIZE`  | number  | `1048576` | Max file size in bytes (1MB)   |
+| `SMART_CODING_CHUNK_SIZE`     | number  | `15`      | Lines of code per chunk        |
+| `SMART_CODING_MAX_RESULTS`    | number  | `5`       | Max search results             |
+| `SMART_CODING_SMART_INDEXING` | boolean | `true`    | Enable smart project detection |
+
+**Example with environment variables:**
+
+```json
+{
+  "mcpServers": {
+    "smart-coding-mcp": {
+      "command": "smart-coding-mcp",
+      "args": ["--workspace", "/path/to/project"],
+      "env": {
+        "SMART_CODING_VERBOSE": "true",
+        "SMART_CODING_BATCH_SIZE": "200",
+        "SMART_CODING_MAX_FILE_SIZE": "2097152"
+      }
+    }
+  }
+}
+```
 
-The server will automatically index your codebase on first run.
+**Note**: The server starts instantly and indexes in the background, so your IDE won't be blocked waiting for indexing to complete.
 
 ## Available Tools
 
@@ -119,7 +173,7 @@ This typically reduces indexed file count by 100x. A project with 50,000 files (
 
 ## Configuration
 
-The server works out of the box with sensible defaults. Create a `config.json` file to customize:
+The server works out of the box with sensible defaults. Create a `config.json` file in your workspace to customize:
 
 ```json
 {
@@ -132,6 +186,8 @@ The server works out of the box with sensible defaults. Create a `config.json` f
   "cacheDirectory": "./.smart-coding-cache",
   "watchFiles": true,
   "chunkSize": 15,
+  "batchSize": 100,
+  "maxFileSize": 1048576,
   "maxResults": 5
 }
 ```
@@ -143,6 +199,8 @@ The server works out of the box with sensible defaults. Create a `config.json` f
 - `watchFiles`: Automatically reindex when files change (default: true)
 - `enableCache`: Cache embeddings to disk (default: true)
 - `chunkSize`: Lines of code per chunk - smaller = more precise, larger = more context (default: 15)
+- `batchSize`: Number of files to process in parallel (default: 100)
+- `maxFileSize`: Skip files larger than this size in bytes (default: 1MB)
 
 ## Examples
 

package/index.js

@@ -4,6 +4,11 @@ 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 { createRequire } from "module";
+
+// Import package.json for version
+const require = createRequire(import.meta.url);
+const packageJson = require("./package.json");
 
 import { loadConfig } from "./lib/config.js";
 import { EmbeddingsCache } from "./lib/cache.js";
@@ -110,7 +115,7 @@ async function initialize() {
 const server = new Server(
   { 
     name: "smart-coding-mcp", 
-    version: "1.0.0" 
+    version: packageJson.version 
   },
   { 
     capabilities: { 

package/lib/config.js

@@ -136,6 +136,57 @@ export async function loadConfig(workspaceDir = null) {
     console.error(`[Config] Error: ${error.message}`);
   }
   
+  // Apply environment variable overrides (prefix: SMART_CODING_) with validation
+  if (process.env.SMART_CODING_VERBOSE !== undefined) {
+    const value = process.env.SMART_CODING_VERBOSE;
+    if (value === 'true' || value === 'false') {
+      config.verbose = value === 'true';
+    }
+  }
+  
+  if (process.env.SMART_CODING_BATCH_SIZE !== undefined) {
+    const value = parseInt(process.env.SMART_CODING_BATCH_SIZE, 10);
+    if (!isNaN(value) && value > 0 && value <= 1000) {
+      config.batchSize = value;
+    } else {
+      console.error(`[Config] Invalid SMART_CODING_BATCH_SIZE: ${process.env.SMART_CODING_BATCH_SIZE}, using default`);
+    }
+  }
+  
+  if (process.env.SMART_CODING_MAX_FILE_SIZE !== undefined) {
+    const value = parseInt(process.env.SMART_CODING_MAX_FILE_SIZE, 10);
+    if (!isNaN(value) && value > 0) {
+      config.maxFileSize = value;
+    } else {
+      console.error(`[Config] Invalid SMART_CODING_MAX_FILE_SIZE: ${process.env.SMART_CODING_MAX_FILE_SIZE}, using default`);
+    }
+  }
+  
+  if (process.env.SMART_CODING_CHUNK_SIZE !== undefined) {
+    const value = parseInt(process.env.SMART_CODING_CHUNK_SIZE, 10);
+    if (!isNaN(value) && value > 0 && value <= 100) {
+      config.chunkSize = value;
+    } else {
+      console.error(`[Config] Invalid SMART_CODING_CHUNK_SIZE: ${process.env.SMART_CODING_CHUNK_SIZE}, using default`);
+    }
+  }
+  
+  if (process.env.SMART_CODING_MAX_RESULTS !== undefined) {
+    const value = parseInt(process.env.SMART_CODING_MAX_RESULTS, 10);
+    if (!isNaN(value) && value > 0 && value <= 100) {
+      config.maxResults = value;
+    } else {
+      console.error(`[Config] Invalid SMART_CODING_MAX_RESULTS: ${process.env.SMART_CODING_MAX_RESULTS}, using default`);
+    }
+  }
+  
+  if (process.env.SMART_CODING_SMART_INDEXING !== undefined) {
+    const value = process.env.SMART_CODING_SMART_INDEXING;
+    if (value === 'true' || value === 'false') {
+      config.smartIndexing = value === 'true';
+    }
+  }
+  
   return config;
 }
 

package/lib/utils.js

@@ -31,14 +31,60 @@ export function smartChunk(content, file, config) {
   
   // Language-specific patterns for function/class detection
   const patterns = {
+    // JavaScript/TypeScript
     js: /^(export\s+)?(async\s+)?(function|class|const|let|var)\s+\w+/,
+    jsx: /^(export\s+)?(async\s+)?(function|class|const|let|var)\s+\w+/,
     ts: /^(export\s+)?(async\s+)?(function|class|const|let|var|interface|type)\s+\w+/,
-    py: /^(class|def)\s+\w+/,
-    java: /^(public|private|protected)?\s*(static\s+)?(class|interface|void|int|String|boolean)\s+\w+/,
-    go: /^func\s+\w+/,
-    rs: /^(pub\s+)?(fn|struct|enum|trait|impl)\s+\w+/,
+    tsx: /^(export\s+)?(async\s+)?(function|class|const|let|var|interface|type)\s+\w+/,
+    mjs: /^(export\s+)?(async\s+)?(function|class|const|let|var)\s+\w+/,
+    cjs: /^(export\s+)?(async\s+)?(function|class|const|let|var)\s+\w+/,
+    
+    // Python
+    py: /^(class|def|async\s+def)\s+\w+/,
+    pyw: /^(class|def|async\s+def)\s+\w+/,
+    
+    // Java/Kotlin/Scala
+    java: /^(public|private|protected)?\s*(static\s+)?(class|interface|enum|void|int|String|boolean)\s+\w+/,
+    kt: /^(class|interface|object|fun|val|var)\s+\w+/,
+    kts: /^(class|interface|object|fun|val|var)\s+\w+/,
+    scala: /^(class|object|trait|def|val|var)\s+\w+/,
+    
+    // C/C++
+    c: /^(struct|enum|union|void|int|char|float|double)\s+\w+/,
+    cpp: /^(class|struct|namespace|template|void|int|bool)\s+\w+/,
+    cc: /^(class|struct|namespace|template|void|int|bool)\s+\w+/,
+    cxx: /^(class|struct|namespace|template|void|int|bool)\s+\w+/,
+    h: /^(class|struct|namespace|template|void|int|bool)\s+\w+/,
+    hpp: /^(class|struct|namespace|template|void|int|bool)\s+\w+/,
+    
+    // C#
+    cs: /^(public|private|protected)?\s*(static\s+)?(class|interface|struct|enum|void|int|string|bool)\s+\w+/,
+    
+    // Go
+    go: /^(func|type|const|var)\s+\w+/,
+    
+    // Rust
+    rs: /^(pub\s+)?(fn|struct|enum|trait|impl|const|static)\s+\w+/,
+    
+    // PHP
+    php: /^(class|interface|trait|function|const)\s+\w+/,
+    
+    // Ruby
+    rb: /^(class|module|def)\s+\w+/,
+    rake: /^(class|module|def|task)\s+\w+/,
+    
+    // Swift
+    swift: /^(class|struct|enum|protocol|func|var|let)\s+\w+/,
+    
+    // R
+    r: /^(\w+)\s*<-\s*function/,
+    R: /^(\w+)\s*<-\s*function/,
+    
+    // Lua
+    lua: /^(function|local\s+function)\s+\w+/,
   };
 
+
   const langPattern = patterns[ext.slice(1)] || patterns.js;
   let currentChunk = [];
   let chunkStartLine = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smart-coding-mcp",
-  "version": "1.1.0",
+  "version": "1.2.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",