codebasesearch 0.1.23 → 0.1.24

package/mcp.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 
-// MUST patch sharp before any other imports
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
@@ -23,178 +22,136 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { cwd } from 'process';
 import { join } from 'path';
-import { existsSync, readFileSync, appendFileSync, writeFileSync } from 'fs';
+import { existsSync, readFileSync, appendFileSync, writeFileSync, readdirSync } from 'fs';
+import { homedir } from 'os';
 import { supervisor } from './src/supervisor.js';
 
-async function ensureIgnoreEntry(rootPath) {
+const WORKSPACE_PATH = join(homedir(), 'workspace');
+
+function getWorkspaceFolders() {
+  try {
+    return readdirSync(WORKSPACE_PATH, { withFileTypes: true })
+      .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+      .map(e => join(WORKSPACE_PATH, e.name));
+  } catch { return []; }
+}
+
+function ensureIgnoreEntry(rootPath) {
   const gitignorePath = join(rootPath, '.gitignore');
   const entry = '.code-search/';
-
   try {
     if (existsSync(gitignorePath)) {
       const content = readFileSync(gitignorePath, 'utf8');
-      if (!content.includes(entry)) {
-        appendFileSync(gitignorePath, `\n${entry}`);
-      }
+      if (!content.includes(entry)) appendFileSync(gitignorePath, `\n${entry}`);
     } else {
       writeFileSync(gitignorePath, `${entry}\n`);
     }
-  } catch (e) {
-    // Ignore write errors
-  }
+  } catch (e) {}
 }
 
-const server = new Server(
-  {
-    name: 'code-search-mcp',
-    version: '0.1.0',
-  },
-  {
-    capabilities: {
-      tools: {},
-    },
-  }
-);
+function formatResults(result, query, scope) {
+  if (result.resultsCount === 0) return `No results found${scope ? ` across ${scope}` : ''} for: "${query}"`;
+  const plural = result.resultsCount !== 1 ? 's' : '';
+  const header = `Found ${result.resultsCount} result${plural}${scope ? ` across ${scope}` : ''} for: "${query}"\n\n`;
+  const body = result.results.map((r) => {
+    const pathPart = r.relativePath || r.absolutePath;
+    const lineCount = r.totalLines ? ` [${r.totalLines}L]` : '';
+    const ctx = r.enclosingContext ? ` (in: ${r.enclosingContext})` : '';
+    const rHeader = `${r.rank}. ${pathPart}${lineCount}:${r.lines}${ctx} (score: ${r.score}%)`;
+    const rBody = r.snippet.split('\n').map((line) => `   ${line}`).join('\n');
+    return `${rHeader}\n${rBody}`;
+  }).join('\n\n');
+  return header + body;
+}
+
+function errResponse(msg) {
+  return { content: [{ type: 'text', text: msg }], isError: true };
+}
+
+function okResponse(text) {
+  return { content: [{ type: 'text', text }] };
+}
 
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: [
-      {
-        name: 'search',
-        description:
-          'Search through a code repository using semantic search with Jina embeddings. Automatically indexes the repository before searching.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            repository_path: {
-              type: 'string',
-              description:
-                'Absolute or relative path to the repository to search in (defaults to current directory)',
-            },
-            query: {
-              type: 'string',
-              description:
-                'Natural language search query (e.g., "authentication middleware", "database connection")',
-            },
-          },
-          required: ['query'],
+const server = new Server({ name: 'code-search-mcp', version: '0.1.0' }, { capabilities: { tools: {} } });
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'search',
+      description: 'Search through a code repository. Automatically indexes before searching.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          repository_path: { type: 'string', description: 'Path to repository (defaults to current directory)' },
+          query: { type: 'string', description: 'Natural language search query' },
         },
+        required: ['query'],
       },
-    ],
-  };
-});
+    },
+    {
+      name: 'search_workspace',
+      description: 'Search across ALL repositories in ~/workspace simultaneously. Returns ranked results with repo name prefix.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'Natural language search query' },
+          limit: { type: 'number', description: 'Max results to return (default: 10)' },
+        },
+        required: ['query'],
+      },
+    },
+  ],
+}));
 
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
-
-  if (name !== 'search') {
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Unknown tool: ${name}`,
-        },
-      ],
-      isError: true,
-    };
-  }
-
   const query = args?.query;
-  const repositoryPath = args?.repository_path || cwd();
-
-  if (!query || typeof query !== 'string') {
-    return {
-      content: [
-        {
-          type: 'text',
-          text: 'Error: query is required and must be a string',
-        },
-      ],
-      isError: true,
-    };
-  }
+
+  if (!['search', 'search_workspace'].includes(name)) return errResponse(`Unknown tool: ${name}`);
+  if (!query || typeof query !== 'string') return errResponse('Error: query is required and must be a string');
 
   try {
-    await ensureIgnoreEntry(repositoryPath);
-    const result = await supervisor.sendRequest({
-      type: 'search',
-      query,
-      repositoryPath,
-    });
-
-    if (result.error) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `Error: ${result.error}`,
-          },
-        ],
-        isError: true,
-      };
+    if (name === 'search_workspace') {
+      const result = await supervisor.sendRequest({
+        type: 'search-all',
+        query,
+        workspacePaths: getWorkspaceFolders(),
+        limit: args?.limit || 10,
+      });
+      if (result.error) return errResponse(`Error: ${result.error}`);
+      return okResponse(formatResults(result, query, 'workspace'));
     }
 
-    const repoPath = typeof repositoryPath === 'string' ? repositoryPath : null;
-    const text =
-      result.resultsCount === 0
-        ? `No results found for query: "${query}"`
-        : `Found ${result.resultsCount} result${result.resultsCount !== 1 ? 's' : ''} for query: "${query}"\n\n${result.results
-            .map((r) => {
-              const pathPart = r.relativePath || r.absolutePath;
-              const lineCount = r.totalLines ? ` [${r.totalLines}L]` : '';
-              const ctx = r.enclosingContext ? ` (in: ${r.enclosingContext})` : '';
-              const header = `${r.rank}. ${pathPart}${lineCount}:${r.lines}${ctx} (score: ${r.score}%)`;
-              const body = r.snippet.split('\n').map((line) => `   ${line}`).join('\n');
-              return `${header}\n${body}`;
-            })
-            .join('\n\n')}`;
-
-    return {
-      content: [
-        {
-          type: 'text',
-          text,
-        },
-      ],
-    };
+    const repositoryPath = args?.repository_path || cwd();
+    ensureIgnoreEntry(repositoryPath);
+    const result = await supervisor.sendRequest({ type: 'search', query, repositoryPath });
+    if (result.error) return errResponse(`Error: ${result.error}`);
+    return okResponse(formatResults(result, query, null));
   } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Error: ${error.message}`,
-        },
-      ],
-      isError: true,
-    };
+    return errResponse(`Error: ${error.message}`);
   }
 });
 
 export async function startMcpServer() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
+
+  const workspacePaths = getWorkspaceFolders();
+  if (workspacePaths.length > 0) {
+    supervisor.sendRequest({ type: 'index-all', workspacePaths })
+      .then(r => console.error(`[MCP] Pre-indexed workspace: ${r.message || JSON.stringify(r)}`))
+      .catch(e => console.error(`[MCP] Pre-index warning: ${e.message}`));
+  }
 }
 
 const isMain = process.argv[1] && (
-  process.argv[1] === fileURLToPath(import.meta.url) || 
-  process.argv[1].endsWith('mcp.js') || 
+  process.argv[1] === fileURLToPath(import.meta.url) ||
+  process.argv[1].endsWith('mcp.js') ||
   process.argv[1].endsWith('code-search-mcp')
 );
 
-if (isMain) {
-  main().catch((error) => {
-    console.error('Server error:', error);
-  });
-}
+process.on('uncaughtException', (error) => console.error('Uncaught exception:', error));
+process.on('unhandledRejection', (reason) => console.error('Unhandled rejection:', reason));
 
-process.on('uncaughtException', (error) => {
-  console.error('Uncaught exception:', error);
-});
-
-process.on('unhandledRejection', (reason) => {
-  console.error('Unhandled rejection:', reason);
-});
-
-async function main() {
-  await startMcpServer();
-}
+async function main() { await startMcpServer(); }
+if (isMain) main().catch((error) => console.error('Server error:', error));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebasesearch",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "description": "Ultra-simple code search tool with Jina embeddings, LanceDB, and MCP protocol support",
   "type": "module",
   "bin": {

package/src/search-worker.js

@@ -1,6 +1,6 @@
 import { parentPort } from 'worker_threads';
 import { resolve, relative } from 'path';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { loadIgnorePatterns } from './ignore-parser.js';
 import { scanRepository } from './scanner.js';
 import { buildTextIndex, searchText } from './text-search.js';
@@ -31,12 +31,28 @@ function getFileTotalLines(absoluteFilePath) {
 
 let indexCache = new Map();
 
+function getWorkspaceFolders(workspacePath) {
+  try {
+    const entries = readdirSync(workspacePath, { withFileTypes: true });
+    return entries
+      .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+      .map(e => resolve(workspacePath, e.name));
+  } catch {
+    return [];
+  }
+}
+
 async function initializeIndex(repositoryPath) {
   const absolutePath = resolve(repositoryPath);
-  const cacheKey = absolutePath;
 
-  if (indexCache.has(cacheKey)) {
-    return indexCache.get(cacheKey);
+  const cached = indexCache.get(absolutePath);
+  if (cached) {
+    try {
+      const dirStat = statSync(absolutePath);
+      if (dirStat.mtimeMs <= cached.indexedAt) return cached;
+    } catch {
+      return cached;
+    }
   }
 
   try {
@@ -48,8 +64,8 @@ async function initializeIndex(repositoryPath) {
     }
 
     const indexData = buildTextIndex(chunks);
-    const result = { chunks, indexData };
-    indexCache.set(cacheKey, result);
+    const result = { chunks, indexData, indexedAt: Date.now() };
+    indexCache.set(absolutePath, result);
 
     return result;
   } catch (error) {
@@ -99,6 +115,53 @@ async function performSearch(repositoryPath, query) {
   }
 }
 
+async function performSearchAll(workspacePaths, query, limit = 10) {
+  const allResults = [];
+
+  for (const repoPath of workspacePaths) {
+    const absolutePath = resolve(repoPath);
+    if (!existsSync(absolutePath)) continue;
+
+    const indexData = await initializeIndex(absolutePath);
+    if (indexData.error || !indexData.chunks) continue;
+
+    const results = searchText(query, indexData.chunks, indexData.indexData);
+    const repoName = absolutePath.split('/').pop();
+
+    const seenFiles = new Set();
+    for (const r of results) {
+      if (!seenFiles.has(r.file_path)) {
+        seenFiles.add(r.file_path);
+        allResults.push({ ...r, repoName, repoPath: absolutePath });
+      }
+      if (seenFiles.size >= limit) break;
+    }
+  }
+
+  allResults.sort((a, b) => b.score - a.score);
+  const top = allResults.slice(0, limit);
+
+  return {
+    query,
+    resultsCount: top.length,
+    results: top.map((r, idx) => {
+      const absoluteFilePath = resolve(r.repoPath, r.file_path);
+      const totalLines = getFileTotalLines(absoluteFilePath);
+      const enclosingContext = findEnclosingContext(r.content, r.line_start);
+      return {
+        rank: idx + 1,
+        absolutePath: absoluteFilePath,
+        relativePath: `${r.repoName}/${r.file_path}`,
+        lines: `${r.line_start}-${r.line_end}`,
+        totalLines,
+        enclosingContext,
+        score: (r.score * 100).toFixed(1),
+        snippet: r.content.split('\n').slice(0, 30).join('\n'),
+      };
+    }),
+  };
+}
+
 if (parentPort) {
   parentPort.on('message', async (msg) => {
     try {
@@ -107,6 +170,26 @@ if (parentPort) {
         return;
       }
 
+      if (msg.type === 'index-all') {
+        const folders = msg.workspacePaths || getWorkspaceFolders(msg.workspacePath || '');
+        let indexed = 0;
+        for (const folder of folders) {
+          if (existsSync(folder)) {
+            await initializeIndex(folder);
+            indexed++;
+          }
+        }
+        parentPort.postMessage({ id: msg.id, result: { indexed, message: `Indexed ${indexed} repositories` } });
+        return;
+      }
+
+      if (msg.type === 'search-all') {
+        const folders = msg.workspacePaths || getWorkspaceFolders(msg.workspacePath || '');
+        const result = await performSearchAll(folders, msg.query, msg.limit || 10);
+        parentPort.postMessage({ id: msg.id, result });
+        return;
+      }
+
       if (msg.type === 'search') {
         const result = await performSearch(msg.repositoryPath || process.cwd(), msg.query);
         parentPort.postMessage({ id: msg.id, result });