codebasesearch 0.1.8 → 0.1.10

package/mcp.js

@@ -22,7 +22,8 @@ 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 { cwd } from 'process';
-import { join, existsSync, readFileSync, appendFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { existsSync, readFileSync, appendFileSync, writeFileSync } from 'fs';
 import { supervisor } from './src/supervisor.js';
 
 async function ensureIgnoreEntry(rootPath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebasesearch",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Ultra-simple code search tool with Jina embeddings, LanceDB, and MCP protocol support",
   "type": "module",
   "bin": {
@@ -20,8 +20,7 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "start": "node ./bin/code-search.js",
-    "postinstall": "node scripts/patch-transformers.js"
+    "start": "node ./bin/code-search.js"
   },
   "dependencies": {
     "@huggingface/transformers": "^3.8.1",

package/src/search-worker.js

@@ -3,52 +3,57 @@ import { resolve } from 'path';
 import { existsSync } from 'fs';
 import { loadIgnorePatterns } from './ignore-parser.js';
 import { scanRepository } from './scanner.js';
-import { generateEmbeddings } from './embeddings.js';
-import { initStore, upsertChunks, closeStore } from './store.js';
-import { executeSearch } from './search.js';
+import { buildTextIndex, searchText } from './text-search.js';
 
-async function performSearch(repositoryPath, query) {
+let indexCache = new Map();
+
+async function initializeIndex(repositoryPath) {
   const absolutePath = resolve(repositoryPath);
+  const cacheKey = absolutePath;
 
-  if (!existsSync(absolutePath)) {
-    return { error: 'Repository path not found', results: [] };
+  if (indexCache.has(cacheKey)) {
+    return indexCache.get(cacheKey);
   }
 
   try {
     const ignorePatterns = loadIgnorePatterns(absolutePath);
-    const dbPath = resolve(absolutePath, '.code-search');
-
-    await initStore(dbPath);
-
     const chunks = scanRepository(absolutePath, ignorePatterns);
+
     if (chunks.length === 0) {
-      await closeStore();
-      return { query, results: [], message: 'No code chunks found' };
+      return { error: 'No code chunks found', chunks: [], index: null };
     }
 
-    const batchSize = 32;
-    const allEmbeddings = [];
+    const index = buildTextIndex(chunks);
+    const indexData = { chunks, index };
+    indexCache.set(cacheKey, indexData);
 
-    for (let i = 0; i < chunks.length; i += batchSize) {
-      const batchTexts = chunks.slice(i, i + batchSize).map(c => c.content);
-      const batchEmbeddings = await generateEmbeddings(batchTexts);
-      allEmbeddings.push(...batchEmbeddings);
-    }
+    return indexData;
+  } catch (error) {
+    return { error: error.message, chunks: [], index: null };
+  }
+}
 
-    const chunksWithEmbeddings = chunks.map((chunk, idx) => ({
-      ...chunk,
-      vector: allEmbeddings[idx],
-    }));
+async function performSearch(repositoryPath, query) {
+  const absolutePath = resolve(repositoryPath);
+
+  if (!existsSync(absolutePath)) {
+    return { error: 'Repository path not found', results: [] };
+  }
+
+  try {
+    const indexData = await initializeIndex(absolutePath);
+
+    if (indexData.error) {
+      return { error: indexData.error, results: [] };
+    }
 
-    await upsertChunks(chunksWithEmbeddings);
-    const results = await executeSearch(query);
-    await closeStore();
+    const results = searchText(query, indexData.chunks, indexData.index);
 
     return {
       query,
       repository: absolutePath,
       resultsCount: results.length,
-      results: results.map((result, idx) => ({
+      results: results.slice(0, 10).map((result, idx) => ({
         rank: idx + 1,
         file: result.file_path,
         lines: `${result.line_start}-${result.line_end}`,
@@ -57,7 +62,6 @@ async function performSearch(repositoryPath, query) {
       })),
     };
   } catch (error) {
-    await closeStore().catch(() => {});
     return { error: error.message, results: [] };
   }
 }

package/src/text-search.js

@@ -0,0 +1,48 @@
+export function buildTextIndex(chunks) {
+  const index = new Map();
+
+  chunks.forEach((chunk, idx) => {
+    const tokens = tokenize(chunk.content);
+    tokens.forEach(token => {
+      if (!index.has(token)) {
+        index.set(token, []);
+      }
+      index.get(token).push(idx);
+    });
+  });
+
+  return index;
+}
+
+export function searchText(query, chunks, index) {
+  const queryTokens = tokenize(query);
+  const chunkScores = new Map();
+
+  queryTokens.forEach(token => {
+    if (index.has(token)) {
+      index.get(token).forEach(chunkIdx => {
+        if (!chunkScores.has(chunkIdx)) {
+          chunkScores.set(chunkIdx, 0);
+        }
+        chunkScores.set(chunkIdx, chunkScores.get(chunkIdx) + 1);
+      });
+    }
+  });
+
+  const results = Array.from(chunkScores.entries())
+    .map(([idx, score]) => ({
+      ...chunks[idx],
+      score: score / queryTokens.length,
+      matchCount: score,
+    }))
+    .filter(r => r.score > 0)
+    .sort((a, b) => b.score - a.score);
+
+  return results;
+}
+
+function tokenize(text) {
+  return text
+    .toLowerCase()
+    .match(/\b\w+\b/g) || [];
+}