codebasesearch 0.1.22 → 0.1.24

package/.prd

@@ -0,0 +1,78 @@
+{
+  "project": "code-search",
+  "created": "2026-03-12",
+  "objective": "Profile and improve code-search speed and result quality",
+  "items": [
+    {
+      "id": "fix-dedup-buildtextindex",
+      "subject": "Remove duplicate buildTextIndex from search.js",
+      "status": "pending",
+      "description": "search.js has a private copy of buildTextIndex and tokenize/extractSymbols/isCodeFile that duplicates text-search.js. Import the exported buildTextIndex from text-search.js instead.",
+      "category": "refactor",
+      "effort": "small",
+      "blocking": ["fix-score-normalization", "fix-hybrid-weights"],
+      "blockedBy": []
+    },
+    {
+      "id": "fix-chunk-size",
+      "subject": "Reduce chunk size from 300 to 60 lines for better semantic granularity",
+      "status": "pending",
+      "description": "scanner.js uses 300-line chunks. Embeddings work best on 50-100 line chunks. Reduce to 60-line chunks with 15-line overlap for better vector search quality.",
+      "category": "feature",
+      "effort": "small",
+      "blocking": [],
+      "blockedBy": []
+    },
+    {
+      "id": "fix-score-normalization",
+      "subject": "Fix text search score normalization so top result is always 1.0",
+      "status": "pending",
+      "description": "Text scores divide raw by 100 but scores can exceed 100. Use dynamic max-score scaling. Lower hasGoodTextResults threshold from 0.5 to 0.3.",
+      "category": "bug",
+      "effort": "small",
+      "blocking": [],
+      "blockedBy": ["fix-dedup-buildtextindex"]
+    },
+    {
+      "id": "fix-hybrid-weights",
+      "subject": "Boost text-only exact-match results in hybrid merge",
+      "status": "pending",
+      "description": "Text-only results are capped at 20% weight. Give high-scoring text-only results a floor finalScore of 0.4.",
+      "category": "feature",
+      "effort": "small",
+      "blocking": [],
+      "blockedBy": ["fix-dedup-buildtextindex"]
+    },
+    {
+      "id": "fix-vector-cache-key",
+      "subject": "Strengthen vector search cache key to 20 dimensions",
+      "status": "pending",
+      "description": "Cache key uses only first 5 embedding dims. Use 20 dims for near-zero collision rate.",
+      "category": "bug",
+      "effort": "small",
+      "blocking": [],
+      "blockedBy": []
+    },
+    {
+      "id": "remove-dead-meanpooling",
+      "subject": "Remove dead meanPooling function from embeddings.js",
+      "status": "pending",
+      "description": "meanPooling is defined but never called. Remove dead code.",
+      "category": "refactor",
+      "effort": "small",
+      "blocking": [],
+      "blockedBy": []
+    },
+    {
+      "id": "verify-and-commit",
+      "subject": "Verify improvements and commit all changes",
+      "status": "pending",
+      "description": "Run end-to-end search logic test inline. Commit and push all changes.",
+      "category": "infra",
+      "effort": "small",
+      "blocking": [],
+      "blockedBy": ["fix-dedup-buildtextindex", "fix-chunk-size", "fix-score-normalization", "fix-hybrid-weights", "fix-vector-cache-key", "remove-dead-meanpooling"]
+    }
+  ],
+  "completed": []
+}

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.22",
+  "version": "0.1.24",
   "description": "Ultra-simple code search tool with Jina embeddings, LanceDB, and MCP protocol support",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -75,29 +75,39 @@ export async function run(args) {
     console.log('Generating embeddings and indexing...');
 
     // Generate embeddings in batches and upsert immediately to free memory
-    const batchSize = 32;
-    let processedCount = 0;
-
-    for (let i = 0; i < chunks.length; i += batchSize) {
-      const batchChunks = chunks.slice(i, i + batchSize);
-      const batchTexts = batchChunks.map(c => c.content);
-      const batchEmbeddings = await generateEmbeddings(batchTexts);
-
-      // Create batch with embeddings
-      const batchWithEmbeddings = batchChunks.map((chunk, idx) => ({
-        ...chunk,
-        vector: batchEmbeddings[idx]
-      }));
+    // Optimize batch size based on chunk count (larger batches are more efficient)
+    let batchSize = 32;
+    if (chunks.length > 500) batchSize = 64;
+    if (chunks.length > 1000) batchSize = 96;
 
-      // Upsert immediately to free memory
-      await upsertChunks(batchWithEmbeddings);
-      processedCount += batchWithEmbeddings.length;
+    let processedCount = 0;
+    let embeddingsAvailable = true;
+
+    try {
+      for (let i = 0; i < chunks.length; i += batchSize) {
+        const batchChunks = chunks.slice(i, i + batchSize);
+        const batchTexts = batchChunks.map(c => c.content);
+        const batchEmbeddings = await generateEmbeddings(batchTexts);
+
+        // Create batch with embeddings
+        const batchWithEmbeddings = batchChunks.map((chunk, idx) => ({
+          ...chunk,
+          vector: batchEmbeddings[idx]
+        }));
+
+        // Upsert immediately to free memory
+        await upsertChunks(batchWithEmbeddings);
+        processedCount += batchWithEmbeddings.length;
+      }
+    } catch (embeddingError) {
+      console.warn(`Warning: Embedding generation failed (${embeddingError.message}). Using text-only search.\n`);
+      embeddingsAvailable = false;
     }
 
     console.log('Index created\n');
 
-    // Execute search
-    const results = await executeSearch(query);
+    // Execute search with chunks for hybrid search (text-only if embeddings failed)
+    const results = await executeSearch(query, 10, chunks);
 
     // Format and display results
     const output = formatResults(results);

package/src/embeddings.js

@@ -13,6 +13,7 @@ try {
 
 let modelCache = null;
 let cacheCleared = false;
+let modelLoadTime = 0;
 
 function clearModelCache() {
   const cacheDirs = [
@@ -37,6 +38,7 @@ async function getModel(retryOnError = true) {
     return modelCache;
   }
 
+  const modelStart = performance.now();
   console.error('Loading embeddings model (this may take a moment on first run)...');
 
   const modelLoadPromise = pipeline(
@@ -50,6 +52,7 @@ async function getModel(retryOnError = true) {
 
   try {
     modelCache = await Promise.race([modelLoadPromise, timeoutPromise]);
+    modelLoadTime = performance.now() - modelStart;
   } catch (e) {
     if (retryOnError && !cacheCleared && (e.message.includes('Protobuf') || e.message.includes('parsing'))) {
       console.error('Detected corrupted cache, clearing and retrying...');
@@ -65,37 +68,8 @@ async function getModel(retryOnError = true) {
   return modelCache;
 }
 
-async function meanPooling(modelOutput, attentionMask) {
-  // Get token embeddings from model output
-  const tokenEmbeddings = modelOutput.data;
-  const embeddingDim = modelOutput.dims[modelOutput.dims.length - 1];
-  const batchSize = modelOutput.dims[0];
-  const seqLength = modelOutput.dims[1];
-
-  const pooled = [];
-
-  for (let b = 0; b < batchSize; b++) {
-    let sum = new Array(embeddingDim).fill(0);
-    let count = 0;
-
-    for (let s = 0; s < seqLength; s++) {
-      const tokenIdx = b * seqLength + s;
-      const maskValue = attentionMask[tokenIdx] || 1;
-
-      if (maskValue > 0) {
-        const tokenStart = tokenIdx * embeddingDim;
-        for (let d = 0; d < embeddingDim; d++) {
-          sum[d] += tokenEmbeddings[tokenStart + d] * maskValue;
-        }
-        count += maskValue;
-      }
-    }
-
-    const normalized = sum.map(v => v / Math.max(count, 1e-9));
-    pooled.push(normalized);
-  }
-
-  return pooled;
+export function getModelLoadTime() {
+  return modelLoadTime;
 }
 
 export async function generateEmbeddings(texts) {
@@ -105,11 +79,16 @@ export async function generateEmbeddings(texts) {
     texts = [texts];
   }
 
-  // Generate embeddings for all texts
-  const embeddings = await model(texts, {
-    pooling: 'mean',
-    normalize: true
-  });
+  // Generate embeddings for all texts with timeout per batch
+  const embeddings = await Promise.race([
+    model(texts, {
+      pooling: 'mean',
+      normalize: true
+    }),
+    new Promise((_, reject) =>
+      setTimeout(() => reject(new Error('Embedding generation timeout')), 60000)
+    )
+  ]);
 
   // Convert to regular arrays
   const result = [];

package/src/scanner.js

@@ -65,7 +65,7 @@ function walkDirectory(dirPath, ignorePatterns, relativePath = '') {
   return files;
 }
 
-function chunkContent(content, chunkSize = 1000, overlapSize = 100) {
+function chunkContent(content, chunkSize = 60, overlapSize = 15) {
   const lines = content.split('\n');
   const chunks = [];
 
@@ -81,7 +81,6 @@ function chunkContent(content, chunkSize = 1000, overlapSize = 100) {
       });
     }
 
-    // Stop if we've reached the end
     if (endIdx === lines.length) {
       break;
     }
@@ -100,7 +99,7 @@ export function scanRepository(rootPath, ignorePatterns) {
       const mtime = file.mtime;
 
       // For small files, treat as single chunk
-      if (content.split('\n').length <= 1000) {
+      if (content.split('\n').length <= 60) {
         chunks.push({
           file_path: file.relativePath,
           chunk_index: 0,

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 });

package/src/search.js

@@ -1,20 +1,84 @@
 import { generateSingleEmbedding } from './embeddings.js';
 import { searchSimilar } from './store.js';
+import { buildTextIndex, searchText } from './text-search.js';
 
-export async function executeSearch(query, limit = 10) {
+export async function executeSearch(query, limit = 10, allChunks = null, skipVector = false) {
   if (!query || query.trim().length === 0) {
     throw new Error('Query cannot be empty');
   }
 
   console.error(`Searching for: "${query}"`);
 
-  // Generate embedding for query
-  const queryEmbedding = await generateSingleEmbedding(query);
+  try {
+    let vectorResults = [];
+    let textResults = [];
 
-  // Search vector store
-  const results = await searchSimilar(queryEmbedding, limit);
+    if (allChunks && allChunks.length > 0) {
+      const textIndexData = buildTextIndex(allChunks);
+      textResults = searchText(query, allChunks, textIndexData);
+    }
+
+    const hasGoodTextResults = textResults.length > 0 && textResults[0].score > 0.3;
+    if (!skipVector && !hasGoodTextResults) {
+      try {
+        const queryEmbedding = await generateSingleEmbedding(query);
+        vectorResults = await searchSimilar(queryEmbedding, limit * 2);
+      } catch (e) {
+        console.warn(`Vector search unavailable: ${e.message}`);
+      }
+    }
+
+    if (vectorResults.length > 0 && textResults.length > 0) {
+      return mergeSearchResults(vectorResults, textResults.slice(0, limit * 2), limit);
+    }
+
+    const allResults = vectorResults.length > 0 ? vectorResults : textResults;
+    return allResults.slice(0, limit);
+  } catch (error) {
+    console.error('Search error:', error.message);
+    if (allChunks && allChunks.length > 0) {
+      const textIndexData = buildTextIndex(allChunks);
+      const textResults = searchText(query, allChunks, textIndexData);
+      return textResults.slice(0, limit);
+    }
+    throw error;
+  }
+}
+
+function mergeSearchResults(vectorResults, textResults, limit) {
+  const merged = new Map();
+
+  vectorResults.forEach((result) => {
+    const key = `${result.file_path}:${result.chunk_index}`;
+    merged.set(key, {
+      ...result,
+      vectorScore: result.score || 0,
+      textScore: 0,
+      finalScore: (result.score || 0) * 0.8
+    });
+  });
+
+  textResults.forEach((result) => {
+    const key = `${result.file_path}:${result.chunk_index || 0}`;
+    if (merged.has(key)) {
+      const existing = merged.get(key);
+      existing.textScore = result.score || 0;
+      existing.finalScore = (existing.vectorScore * 0.8) + (result.score * 0.2);
+    } else {
+      const textScore = result.score || 0;
+      const finalScore = Math.max(textScore * 0.2, textScore > 0.7 ? 0.4 : 0);
+      merged.set(key, {
+        ...result,
+        vectorScore: 0,
+        textScore,
+        finalScore
+      });
+    }
+  });
 
-  return results;
+  return Array.from(merged.values())
+    .sort((a, b) => b.finalScore - a.finalScore)
+    .slice(0, limit);
 }
 
 export function formatResults(results) {
@@ -27,15 +91,14 @@ export function formatResults(results) {
 
   for (let i = 0; i < results.length; i++) {
     const result = results[i];
-    const match = i + 1;
+    const scoreValue = result.finalScore !== undefined ? result.finalScore : (result.score || 0);
+    const scorePercent = (scoreValue * 100).toFixed(1);
 
-    lines.push(`${match}. ${result.file_path}:${result.line_start}-${result.line_end} (score: ${(result.score * 100).toFixed(1)}%)`);
+    lines.push(`${i + 1}. ${result.file_path}:${result.line_start}-${result.line_end} (score: ${scorePercent}%)`);
 
-    // Show code snippet (first 3 lines)
     const codeLines = result.content.split('\n').slice(0, 3);
     for (const line of codeLines) {
-      const trimmed = line.slice(0, 80); // Limit line length
-      lines.push(`   > ${trimmed}`);
+      lines.push(`   > ${line.slice(0, 80)}`);
     }
 
     lines.push('');

package/src/store.js

@@ -5,6 +5,7 @@ import { mkdirSync, existsSync } from 'fs';
 let dbConnection = null;
 let tableRef = null;
 let isFirstBatch = true;
+let vectorSearchCache = new Map();
 
 export async function initStore(dbPath) {
   // Ensure directory exists
@@ -121,12 +122,19 @@ export async function searchSimilar(queryEmbedding, limit = 10) {
     // Ensure vector is a proper array/tensor
     const query = Array.isArray(queryEmbedding) ? queryEmbedding : Array.from(queryEmbedding);
 
+    // Check cache using 20-dimension hash for near-zero collision rate
+    const cacheKey = query.slice(0, 20).join(',');
+    const cached = vectorSearchCache.get(cacheKey);
+    if (cached) {
+      return cached.slice(0, limit);
+    }
+
     const results = await tableRef
       .search(query)
       .limit(limit)
       .execute();
 
-    return results.map(result => {
+    const formattedResults = results.map(result => {
       const distance = result._distance !== undefined ? result._distance : (result.distance || 0);
       const score = distance !== null && distance !== undefined ? 1 / (1 + distance) : 0;
       return {
@@ -139,6 +147,15 @@ export async function searchSimilar(queryEmbedding, limit = 10) {
         score: score
       };
     });
+
+    // Cache results (keep max 100 cached searches)
+    if (vectorSearchCache.size > 100) {
+      const firstKey = vectorSearchCache.keys().next().value;
+      vectorSearchCache.delete(firstKey);
+    }
+    vectorSearchCache.set(cacheKey, formattedResults);
+
+    return formattedResults;
   } catch (e) {
     console.error('Search failed:', e.message);
     return [];

package/src/text-search.js

@@ -52,12 +52,14 @@ export function searchText(query, chunks, indexData) {
     const meta = chunkMetadata[idx];
     let score = 0;
 
-    queryTokens.forEach(token => {
-      if (index.has(token) && index.get(token).has(idx)) {
-        const freq = meta.frequency.get(token) || 1;
-        const lengthBoost = token.length > 4 ? 1.5 : 1;
-        score += lengthBoost * Math.min(freq, 5);
-      }
+    // Exact phrase match - highest priority (saves embedding cost)
+    if (chunk.content.toLowerCase().includes(query.toLowerCase())) {
+      score += 30;
+    }
+
+    // Symbol match in content - function/class named after query terms
+    querySymbols.forEach(symbol => {
+      if (meta.symbols.includes(symbol)) score += 10;
     });
 
     // Filename token match - strong signal that this file is about the query topic
@@ -66,32 +68,32 @@ export function searchText(query, chunks, indexData) {
       if (meta.fileNameTokens.includes(token)) fileNameMatches++;
     });
     if (fileNameMatches > 0) {
-      score += fileNameMatches * 8;
+      score += fileNameMatches * 10;
     }
 
-    // Symbol match in content - function/class named after query terms
-    querySymbols.forEach(symbol => {
-      if (meta.symbols.includes(symbol)) score += 5;
+    // Token frequency scoring
+    queryTokens.forEach(token => {
+      if (index.has(token) && index.get(token).has(idx)) {
+        const freq = meta.frequency.get(token) || 1;
+        const lengthBoost = token.length > 4 ? 1.5 : 1;
+        score += lengthBoost * Math.min(freq, 5);
+      }
     });
 
-    // Exact phrase match
-    if (chunk.content.toLowerCase().includes(query.toLowerCase())) {
-      score += 15;
-    }
-
     // Code file boost
     if (meta.isCode) score *= 1.2;
 
     if (score > 0) chunkScores.set(idx, score);
   }
 
-  const results = Array.from(chunkScores.entries())
-    .map(([idx, score]) => ({
-      ...chunks[idx],
-      score: Math.min(score / 100, 1),
-      _rawScore: score,
-    }))
-    .sort((a, b) => b._rawScore - a._rawScore);
+  const entries = Array.from(chunkScores.entries()).sort((a, b) => b[1] - a[1]);
+  const maxScore = entries.length > 0 ? entries[0][1] : 1;
+
+  const results = entries.map(([idx, score]) => ({
+    ...chunks[idx],
+    score: score / maxScore,
+    _rawScore: score,
+  }));
 
   return results;
 }