raggrep 0.14.2 → 0.16.0

package/dist/cli/main.js

@@ -16,7 +16,6 @@ var __toESM = (mod, isNodeMode, target) => {
       });
   return to;
 };
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -4536,6 +4535,209 @@ var init_phraseMatch = __esm(() => {
   ]);
 });
 
+// src/domain/services/simpleSearch.ts
+function isIdentifierQuery(query) {
+  const trimmed = query.trim();
+  if (trimmed.startsWith("`") && trimmed.endsWith("`") || trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return true;
+  }
+  for (const pattern of Object.values(IDENTIFIER_PATTERNS)) {
+    if (pattern.test(trimmed)) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractSearchLiteral(query) {
+  const trimmed = query.trim();
+  if (trimmed.startsWith("`") && trimmed.endsWith("`")) {
+    return trimmed.slice(1, -1);
+  }
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function findOccurrences(content, literal, options = {}) {
+  const { maxOccurrences = 10, caseInsensitive = false } = options;
+  const occurrences = [];
+  const lines = content.split(`
+`);
+  const searchContent = caseInsensitive ? content.toLowerCase() : content;
+  const searchLiteral = caseInsensitive ? literal.toLowerCase() : literal;
+  let currentIndex = 0;
+  for (let lineNum = 0;lineNum < lines.length; lineNum++) {
+    const line = lines[lineNum];
+    const searchLine = caseInsensitive ? line.toLowerCase() : line;
+    let columnStart = 0;
+    while (true) {
+      const column = searchLine.indexOf(searchLiteral, columnStart);
+      if (column === -1)
+        break;
+      occurrences.push({
+        line: lineNum + 1,
+        column,
+        lineContent: line,
+        contextBefore: lineNum > 0 ? lines[lineNum - 1] : undefined,
+        contextAfter: lineNum < lines.length - 1 ? lines[lineNum + 1] : undefined
+      });
+      if (occurrences.length >= maxOccurrences) {
+        return occurrences;
+      }
+      columnStart = column + 1;
+    }
+    currentIndex += line.length + 1;
+  }
+  return occurrences;
+}
+function searchFiles(files, literal, options = {}) {
+  const {
+    maxFiles = 20,
+    maxOccurrencesPerFile = 5,
+    caseInsensitive = false
+  } = options;
+  const matchingFiles = [];
+  let totalMatches = 0;
+  let totalFilesWithMatches = 0;
+  for (const [filepath, content] of files) {
+    const occurrences = findOccurrences(content, literal, {
+      maxOccurrences: maxOccurrencesPerFile,
+      caseInsensitive
+    });
+    if (occurrences.length > 0) {
+      totalFilesWithMatches++;
+      const searchContent = caseInsensitive ? content.toLowerCase() : content;
+      const searchLiteral = caseInsensitive ? literal.toLowerCase() : literal;
+      let matchCount = 0;
+      let index = 0;
+      while ((index = searchContent.indexOf(searchLiteral, index)) !== -1) {
+        matchCount++;
+        index += 1;
+      }
+      totalMatches += matchCount;
+      if (matchingFiles.length < maxFiles) {
+        matchingFiles.push({
+          filepath,
+          occurrences,
+          matchCount
+        });
+      }
+    }
+  }
+  matchingFiles.sort((a, b) => b.matchCount - a.matchCount);
+  return {
+    query: literal,
+    files: matchingFiles,
+    totalMatches,
+    totalFiles: totalFilesWithMatches,
+    truncated: totalFilesWithMatches > maxFiles
+  };
+}
+function isSearchableContent(content, filepath) {
+  if (content.length > 1024 * 1024) {
+    return false;
+  }
+  if (content.includes("\x00")) {
+    return false;
+  }
+  const binaryExtensions = [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".ico",
+    ".webp",
+    ".pdf",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".rar",
+    ".exe",
+    ".dll",
+    ".so",
+    ".dylib",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot",
+    ".mp3",
+    ".mp4",
+    ".wav",
+    ".avi"
+  ];
+  const ext = filepath.toLowerCase().slice(filepath.lastIndexOf("."));
+  if (binaryExtensions.includes(ext)) {
+    return false;
+  }
+  return true;
+}
+var IDENTIFIER_PATTERNS;
+var init_simpleSearch = __esm(() => {
+  IDENTIFIER_PATTERNS = {
+    screamingSnake: /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+$/,
+    camelCase: /^[a-z][a-z0-9]*(?:[A-Z][a-zA-Z0-9]*)+$/,
+    pascalCase: /^[A-Z][a-z]+(?:[A-Z][a-z0-9]*)+$/,
+    snakeCase: /^[a-z][a-z0-9]*(?:_[a-z0-9]+)+$/,
+    kebabCase: /^[a-z][a-z0-9]*(?:-[a-z0-9]+)+$/
+  };
+});
+
+// src/domain/services/chunkContext.ts
+import * as path8 from "path";
+function prepareChunkForEmbedding(options) {
+  const { filepath, content, name, docComment } = options;
+  const pathContext = parsePathContext(filepath);
+  const pathPrefix = formatPathContextForEmbedding(pathContext);
+  const parts = [];
+  if (pathPrefix) {
+    parts.push(pathPrefix);
+  }
+  const filename = path8.basename(filepath);
+  const filenameWithoutExt = filename.replace(/\.[^.]+$/, "");
+  if (filenameWithoutExt && filenameWithoutExt.length > MIN_SEGMENT_LENGTH) {
+    const pathPrefixLower = pathPrefix.toLowerCase();
+    if (!pathPrefixLower.includes(filenameWithoutExt.toLowerCase())) {
+      parts.push(filenameWithoutExt);
+    }
+  }
+  if (name) {
+    parts.push(`${name}:`);
+  }
+  if (docComment) {
+    parts.push(docComment);
+  }
+  parts.push(content);
+  return parts.join(" ");
+}
+function extractPathKeywordsForFileSummary(filepath) {
+  const keywords = extractPathKeywords(filepath);
+  const filtered = keywords.filter((k) => k.length >= MIN_SEGMENT_LENGTH && !GENERIC_SEGMENTS.has(k));
+  return [...new Set(filtered)];
+}
+function getPathContextForFileSummary(filepath) {
+  const pathContext = parsePathContext(filepath);
+  return {
+    segments: pathContext.segments,
+    layer: pathContext.layer,
+    domain: pathContext.domain,
+    depth: pathContext.depth
+  };
+}
+var GENERIC_SEGMENTS, MIN_SEGMENT_LENGTH = 2;
+var init_chunkContext = __esm(() => {
+  init_keywords();
+  GENERIC_SEGMENTS = new Set([
+    "src",
+    "lib",
+    "app",
+    "index",
+    "dist",
+    "build",
+    "out",
+    "node_modules"
+  ]);
+});
+
 // src/domain/services/index.ts
 var init_services = __esm(() => {
   init_keywords();
@@ -4547,6 +4749,8 @@ var init_services = __esm(() => {
   init_introspection();
   init_configValidator();
   init_phraseMatch();
+  init_simpleSearch();
+  init_chunkContext();
 });
 
 // src/modules/language/typescript/parseCode.ts
@@ -4722,7 +4926,7 @@ var init_fileIndexStorage = __esm(() => {
 
 // src/infrastructure/storage/symbolicIndex.ts
 import * as fs3 from "fs/promises";
-import * as path8 from "path";
+import * as path9 from "path";
 
 class SymbolicIndex {
   meta = null;
@@ -4731,7 +4935,7 @@ class SymbolicIndex {
   symbolicPath;
   moduleId;
   constructor(indexDir, moduleId) {
-    this.symbolicPath = path8.join(indexDir, "index", moduleId, "symbolic");
+    this.symbolicPath = path9.join(indexDir, "index", moduleId, "symbolic");
     this.moduleId = moduleId;
   }
   async initialize() {
@@ -4818,11 +5022,11 @@ class SymbolicIndex {
       this.meta.bm25Serialized = this.bm25Index.serialize();
     }
     await fs3.mkdir(this.symbolicPath, { recursive: true });
-    const metaPath = path8.join(this.symbolicPath, "_meta.json");
+    const metaPath = path9.join(this.symbolicPath, "_meta.json");
     await fs3.writeFile(metaPath, JSON.stringify(this.meta, null, 2));
     for (const [filepath, summary] of this.fileSummaries) {
       const summaryPath = this.getFileSummaryPath(filepath);
-      await fs3.mkdir(path8.dirname(summaryPath), { recursive: true });
+      await fs3.mkdir(path9.dirname(summaryPath), { recursive: true });
       await fs3.writeFile(summaryPath, JSON.stringify(summary, null, 2));
     }
   }
@@ -4835,19 +5039,19 @@ class SymbolicIndex {
       this.meta.bm25Serialized = this.bm25Index.serialize();
     }
     await fs3.mkdir(this.symbolicPath, { recursive: true });
-    const metaPath = path8.join(this.symbolicPath, "_meta.json");
+    const metaPath = path9.join(this.symbolicPath, "_meta.json");
     await fs3.writeFile(metaPath, JSON.stringify(this.meta, null, 2));
     for (const filepath of filepaths) {
       const summary = this.fileSummaries.get(filepath);
       if (summary) {
         const summaryPath = this.getFileSummaryPath(filepath);
-        await fs3.mkdir(path8.dirname(summaryPath), { recursive: true });
+        await fs3.mkdir(path9.dirname(summaryPath), { recursive: true });
         await fs3.writeFile(summaryPath, JSON.stringify(summary, null, 2));
       }
     }
   }
   async load() {
-    const metaPath = path8.join(this.symbolicPath, "_meta.json");
+    const metaPath = path9.join(this.symbolicPath, "_meta.json");
     const metaContent = await fs3.readFile(metaPath, "utf-8");
     this.meta = JSON.parse(metaContent);
     this.fileSummaries.clear();
@@ -4862,7 +5066,7 @@ class SymbolicIndex {
     try {
       const entries = await fs3.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path8.join(dir, entry.name);
+        const fullPath = path9.join(dir, entry.name);
         if (entry.isDirectory()) {
           await this.loadFileSummariesRecursive(fullPath);
         } else if (entry.name.endsWith(".json") && entry.name !== "_meta.json") {
@@ -4879,7 +5083,7 @@ class SymbolicIndex {
   }
   getFileSummaryPath(filepath) {
     const jsonPath = filepath.replace(/\.[^.]+$/, ".json");
-    return path8.join(this.symbolicPath, jsonPath);
+    return path9.join(this.symbolicPath, jsonPath);
   }
   async deleteFileSummary(filepath) {
     try {
@@ -4889,7 +5093,7 @@ class SymbolicIndex {
   }
   async exists() {
     try {
-      const metaPath = path8.join(this.symbolicPath, "_meta.json");
+      const metaPath = path9.join(this.symbolicPath, "_meta.json");
       await fs3.access(metaPath);
       return true;
     } catch {
@@ -4923,7 +5127,7 @@ __export(exports_literalIndex, {
   LiteralIndex: () => LiteralIndex
 });
 import * as fs4 from "fs/promises";
-import * as path9 from "path";
+import * as path10 from "path";
 
 class LiteralIndex {
   indexPath;
@@ -4932,7 +5136,7 @@ class LiteralIndex {
   vocabularyIndex = new Map;
   static VERSION = "1.1.0";
   constructor(indexDir, moduleId) {
-    this.indexPath = path9.join(indexDir, "index", moduleId, "literals");
+    this.indexPath = path10.join(indexDir, "index", moduleId, "literals");
     this.moduleId = moduleId;
   }
   async initialize() {
@@ -5098,11 +5302,11 @@ class LiteralIndex {
       version: LiteralIndex.VERSION,
       entries: Object.fromEntries(this.entries)
     };
-    const indexFile = path9.join(this.indexPath, "_index.json");
+    const indexFile = path10.join(this.indexPath, "_index.json");
     await fs4.writeFile(indexFile, JSON.stringify(data, null, 2));
   }
   async load() {
-    const indexFile = path9.join(this.indexPath, "_index.json");
+    const indexFile = path10.join(this.indexPath, "_index.json");
     const content = await fs4.readFile(indexFile, "utf-8");
     const data = JSON.parse(content);
     if (data.version !== LiteralIndex.VERSION) {
@@ -5112,7 +5316,7 @@ class LiteralIndex {
   }
   async exists() {
     try {
-      const indexFile = path9.join(this.indexPath, "_index.json");
+      const indexFile = path10.join(this.indexPath, "_index.json");
       await fs4.access(indexFile);
       return true;
     } catch {
@@ -5156,7 +5360,7 @@ function shouldReplaceMatchType(existing, incoming) {
   return priority[incoming] > priority[existing];
 }
 function getLiteralIndexPath(rootDir, moduleId, indexDir = ".raggrep") {
-  return path9.join(rootDir, indexDir, "index", moduleId, "literals");
+  return path10.join(rootDir, indexDir, "index", moduleId, "literals");
 }
 var init_literalIndex = () => {};
 
@@ -5177,9 +5381,9 @@ __export(exports_typescript, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K2,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE2
 });
-import * as path10 from "path";
+import * as path11 from "path";
 function isTypeScriptFile(filepath) {
-  const ext = path10.extname(filepath).toLowerCase();
+  const ext = path11.extname(filepath).toLowerCase();
   return TYPESCRIPT_EXTENSIONS.includes(ext);
 }
 function calculateChunkTypeBoost(chunk) {
@@ -5241,8 +5445,6 @@ class TypeScriptModule {
     if (parsedChunks.length === 0) {
       return null;
     }
-    const pathContext = parsePathContext(filepath);
-    const pathPrefix = formatPathContextForEmbedding(pathContext);
     const includeFullFileChunk = parsedChunks.length > 1;
     const allParsedChunks = [...parsedChunks];
     if (includeFullFileChunk) {
@@ -5253,13 +5455,17 @@ class TypeScriptModule {
         startLine: 1,
         endLine: lines.length,
         type: "file",
-        name: path10.basename(filepath),
+        name: path11.basename(filepath),
         isExported: false
       });
     }
     const chunkContents = allParsedChunks.map((c) => {
-      const namePrefix = c.name ? `${c.name}: ` : "";
-      return `${pathPrefix} ${namePrefix}${c.content}`;
+      return prepareChunkForEmbedding({
+        filepath,
+        content: c.content,
+        name: c.name,
+        docComment: c.jsDoc
+      });
     });
     const embeddings = await getEmbeddings(chunkContents);
     const chunks = allParsedChunks.map((pc) => ({
@@ -5283,25 +5489,21 @@ class TypeScriptModule {
       ...new Set(parsedChunks.map((pc) => pc.type))
     ];
     const exports = parsedChunks.filter((pc) => pc.isExported && pc.name).map((pc) => pc.name);
-    const allKeywords = new Set;
+    const contentKeywords = new Set;
     for (const pc of parsedChunks) {
       const keywords = extractKeywords(pc.content, pc.name);
-      keywords.forEach((k) => allKeywords.add(k));
+      keywords.forEach((k) => contentKeywords.add(k));
     }
-    pathContext.keywords.forEach((k) => allKeywords.add(k));
+    const pathKeywords = extractPathKeywordsForFileSummary(filepath);
+    const allKeywords = [...contentKeywords, ...pathKeywords];
     const fileSummary = {
       filepath,
       chunkCount: chunks.length,
       chunkTypes,
-      keywords: Array.from(allKeywords),
+      keywords: [...new Set(allKeywords)],
       exports,
       lastModified: stats.lastModified,
-      pathContext: {
-        segments: pathContext.segments,
-        layer: pathContext.layer,
-        domain: pathContext.domain,
-        depth: pathContext.depth
-      }
+      pathContext: getPathContextForFileSummary(filepath)
     };
     this.pendingSummaries.set(filepath, fileSummary);
     for (const chunk of chunks) {
@@ -5580,16 +5782,16 @@ class TypeScriptModule {
     while ((match = importRegex.exec(content)) !== null) {
       const importPath = match[1];
       if (importPath.startsWith(".")) {
-        const dir = path10.dirname(filepath);
-        const resolved = path10.normalize(path10.join(dir, importPath));
+        const dir = path11.dirname(filepath);
+        const resolved = path11.normalize(path11.join(dir, importPath));
         references.push(resolved);
       }
     }
     while ((match = requireRegex.exec(content)) !== null) {
       const importPath = match[1];
       if (importPath.startsWith(".")) {
-        const dir = path10.dirname(filepath);
-        const resolved = path10.normalize(path10.join(dir, importPath));
+        const dir = path11.dirname(filepath);
+        const resolved = path11.normalize(path11.join(dir, importPath));
         references.push(resolved);
       }
     }
@@ -5617,7 +5819,7 @@ var init_typescript = __esm(() => {
 });
 
 // src/infrastructure/parsing/typescriptParser.ts
-import * as path11 from "path";
+import * as path12 from "path";
 
 class TypeScriptParser {
   supportedLanguages = ["typescript", "javascript"];
@@ -5633,12 +5835,12 @@ class TypeScriptParser {
           startLine: 1,
           endLine: lines.length,
           type: "file",
-          name: path11.basename(filepath),
+          name: path12.basename(filepath),
           isExported: false
         };
         chunks.unshift(fullFileChunk);
       }
-      const ext = path11.extname(filepath).toLowerCase();
+      const ext = path12.extname(filepath).toLowerCase();
       const language = ext === ".js" || ext === ".jsx" || ext === ".mjs" || ext === ".cjs" ? "javascript" : "typescript";
       return {
         chunks,
@@ -5655,7 +5857,7 @@ class TypeScriptParser {
     }
   }
   canParse(filepath) {
-    const ext = path11.extname(filepath).toLowerCase();
+    const ext = path12.extname(filepath).toLowerCase();
     return TYPESCRIPT_EXTENSIONS2.includes(ext);
   }
   convertChunk(tc) {
@@ -5670,7 +5872,7 @@ class TypeScriptParser {
     };
   }
   detectLanguage(filepath) {
-    const ext = path11.extname(filepath).toLowerCase();
+    const ext = path12.extname(filepath).toLowerCase();
     if ([".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
       return "javascript";
     }
@@ -5875,7 +6077,7 @@ var init_grammarManager = __esm(() => {
 });
 
 // src/infrastructure/parsing/treeSitterParser.ts
-import * as path12 from "path";
+import * as path13 from "path";
 import * as fs5 from "fs";
 
 class TreeSitterParser {
@@ -5898,7 +6100,7 @@ class TreeSitterParser {
         chunks: [],
         language: "typescript",
         success: false,
-        error: `Unsupported file type: ${path12.extname(filepath)}`
+        error: `Unsupported file type: ${path13.extname(filepath)}`
       };
     }
     try {
@@ -5918,11 +6120,11 @@ class TreeSitterParser {
     }
   }
   canParse(filepath) {
-    const ext = path12.extname(filepath).toLowerCase();
+    const ext = path13.extname(filepath).toLowerCase();
     return ext in EXTENSION_TO_LANGUAGE2;
   }
   detectLanguage(filepath) {
-    const ext = path12.extname(filepath).toLowerCase();
+    const ext = path13.extname(filepath).toLowerCase();
     return EXTENSION_TO_LANGUAGE2[ext] || null;
   }
   async ensureInitialized() {
@@ -5956,17 +6158,17 @@ class TreeSitterParser {
   async resolveWasmPath() {
     try {
       const webTreeSitterPath = __require.resolve("web-tree-sitter");
-      const wasmPath = path12.join(path12.dirname(webTreeSitterPath), "web-tree-sitter.wasm");
+      const wasmPath = path13.join(path13.dirname(webTreeSitterPath), "web-tree-sitter.wasm");
       if (fs5.existsSync(wasmPath)) {
         return wasmPath;
       }
     } catch {}
     try {
       const possiblePaths = [
-        path12.join(__dirname, "../../../node_modules/web-tree-sitter/web-tree-sitter.wasm"),
-        path12.join(__dirname, "../../node_modules/web-tree-sitter/web-tree-sitter.wasm"),
-        path12.join(__dirname, "../../../../node_modules/web-tree-sitter/web-tree-sitter.wasm"),
-        path12.join(__dirname, "web-tree-sitter.wasm")
+        path13.join(__dirname, "../../../node_modules/web-tree-sitter/web-tree-sitter.wasm"),
+        path13.join(__dirname, "../../node_modules/web-tree-sitter/web-tree-sitter.wasm"),
+        path13.join(__dirname, "../../../../node_modules/web-tree-sitter/web-tree-sitter.wasm"),
+        path13.join(__dirname, "web-tree-sitter.wasm")
       ];
       for (const wasmPath of possiblePaths) {
         if (fs5.existsSync(wasmPath)) {
@@ -6010,7 +6212,7 @@ class TreeSitterParser {
         startLine: 1,
         endLine: lines.length,
         type: "file",
-        name: path12.basename(filepath),
+        name: path13.basename(filepath),
         isExported: false
       });
     }
@@ -6357,7 +6559,7 @@ class TreeSitterParser {
       startLine: 1,
       endLine: lines.length,
       type: "file",
-      name: path12.basename(filepath)
+      name: path13.basename(filepath)
     });
     return {
       chunks,
@@ -6387,7 +6589,7 @@ var init_treeSitterParser = __esm(() => {
 });
 
 // src/infrastructure/parsing/parserFactory.ts
-import * as path13 from "path";
+import * as path14 from "path";
 function getTypeScriptParser() {
   if (!typescriptParserInstance) {
     typescriptParserInstance = new TypeScriptParser;
@@ -6401,7 +6603,7 @@ function getTreeSitterParser() {
   return treeSitterParserInstance;
 }
 function createParserForFile(filepath) {
-  const ext = path13.extname(filepath).toLowerCase();
+  const ext = path14.extname(filepath).toLowerCase();
   const parserType = EXTENSION_PARSER_MAP[ext];
   if (!parserType) {
     return null;
@@ -6450,9 +6652,9 @@ __export(exports_python, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K3,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE3
 });
-import * as path14 from "path";
+import * as path15 from "path";
 function isPythonFile(filepath) {
-  const ext = path14.extname(filepath).toLowerCase();
+  const ext = path15.extname(filepath).toLowerCase();
   return PYTHON_EXTENSIONS.includes(ext);
 }
 function generateChunkId3(filepath, startLine, endLine) {
@@ -6536,7 +6738,7 @@ class PythonModule {
       startLine: 1,
       endLine: lines.length,
       type: "file",
-      name: path14.basename(filepath)
+      name: path15.basename(filepath)
     });
     const funcRegex = /^(\s*)(async\s+)?def\s+(\w+)\s*\([^)]*\)\s*:/gm;
     let match;
@@ -6614,12 +6816,13 @@ class PythonModule {
     return chunks;
   }
   async createFileIndex(filepath, content, parsedChunks, ctx) {
-    const pathContext = parsePathContext(filepath);
-    const pathPrefix = formatPathContextForEmbedding(pathContext);
     const chunkContents = parsedChunks.map((c) => {
-      const namePrefix = c.name ? `${c.name}: ` : "";
-      const docPrefix = c.docComment ? `${c.docComment} ` : "";
-      return `${pathPrefix} ${namePrefix}${docPrefix}${c.content}`;
+      return prepareChunkForEmbedding({
+        filepath,
+        content: c.content,
+        name: c.name,
+        docComment: c.docComment
+      });
     });
     const embeddings = await getEmbeddings(chunkContents);
     const chunks = parsedChunks.map((pc) => ({
@@ -6642,25 +6845,21 @@ class PythonModule {
       ...new Set(parsedChunks.map((pc) => pc.type))
     ];
     const exports = parsedChunks.filter((pc) => pc.isExported && pc.name).map((pc) => pc.name);
-    const allKeywords = new Set;
+    const contentKeywords = new Set;
     for (const pc of parsedChunks) {
       const keywords = extractKeywords(pc.content, pc.name);
-      keywords.forEach((k) => allKeywords.add(k));
+      keywords.forEach((k) => contentKeywords.add(k));
     }
-    pathContext.keywords.forEach((k) => allKeywords.add(k));
+    const pathKeywords = extractPathKeywordsForFileSummary(filepath);
+    const allKeywords = [...contentKeywords, ...pathKeywords];
     const fileSummary = {
       filepath,
       chunkCount: chunks.length,
       chunkTypes,
-      keywords: Array.from(allKeywords),
+      keywords: [...new Set(allKeywords)],
       exports,
       lastModified: stats.lastModified,
-      pathContext: {
-        segments: pathContext.segments,
-        layer: pathContext.layer,
-        domain: pathContext.domain,
-        depth: pathContext.depth
-      }
+      pathContext: getPathContextForFileSummary(filepath)
     };
     this.pendingSummaries.set(filepath, fileSummary);
     for (const chunk of chunks) {
@@ -6913,9 +7112,9 @@ __export(exports_go, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K4,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE4
 });
-import * as path15 from "path";
+import * as path16 from "path";
 function isGoFile(filepath) {
-  const ext = path15.extname(filepath).toLowerCase();
+  const ext = path16.extname(filepath).toLowerCase();
   return GO_EXTENSIONS.includes(ext);
 }
 function generateChunkId4(filepath, startLine, endLine) {
@@ -7000,7 +7199,7 @@ class GoModule {
       startLine: 1,
       endLine: lines.length,
       type: "file",
-      name: path15.basename(filepath)
+      name: path16.basename(filepath)
     });
     const funcRegex = /^func\s+(?:\(\s*\w+\s+\*?\w+\s*\)\s+)?(\w+)\s*\(/gm;
     let match;
@@ -7149,12 +7348,13 @@ class GoModule {
     return chunks;
   }
   async createFileIndex(filepath, content, parsedChunks, ctx) {
-    const pathContext = parsePathContext(filepath);
-    const pathPrefix = formatPathContextForEmbedding(pathContext);
     const chunkContents = parsedChunks.map((c) => {
-      const namePrefix = c.name ? `${c.name}: ` : "";
-      const docPrefix = c.docComment ? `${c.docComment} ` : "";
-      return `${pathPrefix} ${namePrefix}${docPrefix}${c.content}`;
+      return prepareChunkForEmbedding({
+        filepath,
+        content: c.content,
+        name: c.name,
+        docComment: c.docComment
+      });
     });
     const embeddings = await getEmbeddings(chunkContents);
     const chunks = parsedChunks.map((pc) => ({
@@ -7177,25 +7377,21 @@ class GoModule {
       ...new Set(parsedChunks.map((pc) => pc.type))
     ];
     const exports = parsedChunks.filter((pc) => pc.isExported && pc.name).map((pc) => pc.name);
-    const allKeywords = new Set;
+    const contentKeywords = new Set;
     for (const pc of parsedChunks) {
       const keywords = extractKeywords(pc.content, pc.name);
-      keywords.forEach((k) => allKeywords.add(k));
+      keywords.forEach((k) => contentKeywords.add(k));
     }
-    pathContext.keywords.forEach((k) => allKeywords.add(k));
+    const pathKeywords = extractPathKeywordsForFileSummary(filepath);
+    const allKeywords = [...contentKeywords, ...pathKeywords];
     const fileSummary = {
       filepath,
       chunkCount: chunks.length,
       chunkTypes,
-      keywords: Array.from(allKeywords),
+      keywords: [...new Set(allKeywords)],
       exports,
       lastModified: stats.lastModified,
-      pathContext: {
-        segments: pathContext.segments,
-        layer: pathContext.layer,
-        domain: pathContext.domain,
-        depth: pathContext.depth
-      }
+      pathContext: getPathContextForFileSummary(filepath)
     };
     this.pendingSummaries.set(filepath, fileSummary);
     for (const chunk of chunks) {
@@ -7397,9 +7593,9 @@ __export(exports_rust, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K5,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE5
 });
-import * as path16 from "path";
+import * as path17 from "path";
 function isRustFile(filepath) {
-  const ext = path16.extname(filepath).toLowerCase();
+  const ext = path17.extname(filepath).toLowerCase();
   return RUST_EXTENSIONS.includes(ext);
 }
 function generateChunkId5(filepath, startLine, endLine) {
@@ -7486,7 +7682,7 @@ class RustModule {
       startLine: 1,
       endLine: lines.length,
       type: "file",
-      name: path16.basename(filepath)
+      name: path17.basename(filepath)
     });
     const funcRegex = /^(pub(?:\s*\([^)]*\))?\s+)?(?:async\s+)?fn\s+(\w+)/gm;
     let match;
@@ -7712,12 +7908,13 @@ class RustModule {
     return chunks;
   }
   async createFileIndex(filepath, content, parsedChunks, ctx) {
-    const pathContext = parsePathContext(filepath);
-    const pathPrefix = formatPathContextForEmbedding(pathContext);
     const chunkContents = parsedChunks.map((c) => {
-      const namePrefix = c.name ? `${c.name}: ` : "";
-      const docPrefix = c.docComment ? `${c.docComment} ` : "";
-      return `${pathPrefix} ${namePrefix}${docPrefix}${c.content}`;
+      return prepareChunkForEmbedding({
+        filepath,
+        content: c.content,
+        name: c.name,
+        docComment: c.docComment
+      });
     });
     const embeddings = await getEmbeddings(chunkContents);
     const chunks = parsedChunks.map((pc) => ({
@@ -7740,25 +7937,21 @@ class RustModule {
       ...new Set(parsedChunks.map((pc) => pc.type))
     ];
     const exports = parsedChunks.filter((pc) => pc.isExported && pc.name).map((pc) => pc.name);
-    const allKeywords = new Set;
+    const contentKeywords = new Set;
     for (const pc of parsedChunks) {
       const keywords = extractKeywords(pc.content, pc.name);
-      keywords.forEach((k) => allKeywords.add(k));
+      keywords.forEach((k) => contentKeywords.add(k));
     }
-    pathContext.keywords.forEach((k) => allKeywords.add(k));
+    const pathKeywords = extractPathKeywordsForFileSummary(filepath);
+    const allKeywords = [...contentKeywords, ...pathKeywords];
     const fileSummary = {
       filepath,
       chunkCount: chunks.length,
       chunkTypes,
-      keywords: Array.from(allKeywords),
+      keywords: [...new Set(allKeywords)],
       exports,
       lastModified: stats.lastModified,
-      pathContext: {
-        segments: pathContext.segments,
-        layer: pathContext.layer,
-        domain: pathContext.domain,
-        depth: pathContext.depth
-      }
+      pathContext: getPathContextForFileSummary(filepath)
     };
     this.pendingSummaries.set(filepath, fileSummary);
     for (const chunk of chunks) {
@@ -7960,9 +8153,9 @@ __export(exports_json, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K6,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE6
 });
-import * as path17 from "path";
+import * as path18 from "path";
 function isJsonFile(filepath) {
-  const ext = path17.extname(filepath).toLowerCase();
+  const ext = path18.extname(filepath).toLowerCase();
   return JSON_EXTENSIONS.includes(ext);
 }
 
@@ -7996,7 +8189,7 @@ class JsonModule {
     } catch {
       return null;
     }
-    const fileBasename = path17.basename(filepath, path17.extname(filepath));
+    const fileBasename = path18.basename(filepath, path18.extname(filepath));
     const jsonPathLiterals = extractJsonPaths(parsed, fileBasename);
     const lines = content.split(`
 `);
@@ -8203,7 +8396,7 @@ __export(exports_markdown, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K7,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE7
 });
-import * as path18 from "path";
+import * as path19 from "path";
 function calculateHeadingLevelBoost(chunk) {
   const metadata = chunk.metadata;
   const level = metadata?.headingLevel ?? 0;
@@ -8223,7 +8416,7 @@ function calculateHeadingLevelBoost(chunk) {
   }
 }
 function isMarkdownFile(filepath) {
-  const ext = path18.extname(filepath).toLowerCase();
+  const ext = path19.extname(filepath).toLowerCase();
   return MARKDOWN_EXTENSIONS.includes(ext);
 }
 function parseMarkdownHierarchical(content, maxDepth = 4) {
@@ -8355,9 +8548,11 @@ class MarkdownModule {
       return null;
     }
     const chunkContents = hierarchicalChunks.map((s) => {
-      const filename = path18.basename(filepath);
-      const headingContext = s.heading ? `${s.heading}: ` : "";
-      return `${filename} ${headingContext}${s.content}`;
+      return prepareChunkForEmbedding({
+        filepath,
+        content: s.content,
+        name: s.heading || undefined
+      });
     });
     const embeddings = await getEmbeddings(chunkContents);
     const chunks = hierarchicalChunks.map((section) => ({
@@ -8381,14 +8576,17 @@ class MarkdownModule {
       embeddingModel: currentConfig.model,
       headings: uniqueHeadings
     };
-    const keywords = extractMarkdownKeywords(content);
+    const contentKeywords = extractMarkdownKeywords(content);
+    const pathKeywords = extractPathKeywordsForFileSummary(filepath);
+    const allKeywords = [...new Set([...contentKeywords, ...pathKeywords])];
     const fileSummary = {
       filepath,
       chunkCount: chunks.length,
       chunkTypes: ["block"],
-      keywords,
+      keywords: allKeywords,
       exports: uniqueHeadings,
-      lastModified: stats.lastModified
+      lastModified: stats.lastModified,
+      pathContext: getPathContextForFileSummary(filepath)
     };
     this.pendingSummaries.set(filepath, fileSummary);
     return {
@@ -8560,13 +8758,13 @@ var init_registry = __esm(() => {
 });
 
 // src/infrastructure/introspection/projectDetector.ts
-import * as path19 from "path";
+import * as path20 from "path";
 import * as fs6 from "fs/promises";
 async function scanForPackageJsons(rootDir, currentDir = "", depth = 0) {
   if (depth > MAX_SCAN_DEPTH)
     return [];
   const results = [];
-  const fullDir = currentDir ? path19.join(rootDir, currentDir) : rootDir;
+  const fullDir = currentDir ? path20.join(rootDir, currentDir) : rootDir;
   try {
     const entries = await fs6.readdir(fullDir, { withFileTypes: true });
     const hasPackageJson = entries.some((e) => e.isFile() && e.name === "package.json");
@@ -8589,10 +8787,10 @@ async function scanForPackageJsons(rootDir, currentDir = "", depth = 0) {
 }
 async function parsePackageJson(rootDir, relativePath) {
   try {
-    const packageJsonPath = path19.join(rootDir, relativePath, "package.json");
+    const packageJsonPath = path20.join(rootDir, relativePath, "package.json");
     const content = await fs6.readFile(packageJsonPath, "utf-8");
     const pkg = JSON.parse(content);
-    const name = pkg.name || path19.basename(relativePath);
+    const name = pkg.name || path20.basename(relativePath);
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     let type = "unknown";
     if (deps["next"] || deps["react"] || deps["vue"] || deps["svelte"]) {
@@ -8637,7 +8835,7 @@ async function detectProjectStructure(rootDir) {
       for (const pattern of monorepoPatterns) {
         if (!dirNames.includes(pattern))
           continue;
-        const patternDir = path19.join(rootDir, pattern);
+        const patternDir = path20.join(rootDir, pattern);
         try {
           const subDirs = await fs6.readdir(patternDir, { withFileTypes: true });
           for (const subDir of subDirs) {
@@ -8668,7 +8866,7 @@ async function detectProjectStructure(rootDir) {
     }
     let rootType = "unknown";
     try {
-      const rootPkgPath = path19.join(rootDir, "package.json");
+      const rootPkgPath = path20.join(rootDir, "package.json");
       const rootPkg = JSON.parse(await fs6.readFile(rootPkgPath, "utf-8"));
       if (rootPkg.workspaces)
         isMonorepo = true;
@@ -8708,7 +8906,7 @@ var init_projectDetector = __esm(() => {
 });
 
 // src/infrastructure/introspection/IntrospectionIndex.ts
-import * as path20 from "path";
+import * as path21 from "path";
 import * as fs7 from "fs/promises";
 import * as fsSync from "fs";
 
@@ -8723,7 +8921,7 @@ class IntrospectionIndex {
   async initialize() {
     this.structure = await detectProjectStructure(this.rootDir);
     try {
-      const configPath = path20.join(this.rootDir, ".raggrep", "config.json");
+      const configPath = path21.join(this.rootDir, ".raggrep", "config.json");
       const configContent = await fs7.readFile(configPath, "utf-8");
       const config = JSON.parse(configContent);
       this.config = config.introspection || {};
@@ -8738,7 +8936,7 @@ class IntrospectionIndex {
     }
     const fileExists = enableReadmeContext ? (relativePath) => {
       try {
-        const absolutePath = path20.join(this.rootDir, relativePath);
+        const absolutePath = path21.join(this.rootDir, relativePath);
         return fsSync.existsSync(absolutePath);
       } catch {
         return false;
@@ -8774,28 +8972,28 @@ class IntrospectionIndex {
     }
   }
   async save(config) {
-    const introDir = path20.join(getRaggrepDir(this.rootDir, config), "introspection");
+    const introDir = path21.join(getRaggrepDir(this.rootDir, config), "introspection");
     await fs7.mkdir(introDir, { recursive: true });
-    const projectPath = path20.join(introDir, "_project.json");
+    const projectPath = path21.join(introDir, "_project.json");
     await fs7.writeFile(projectPath, JSON.stringify({
       version: "1.0.0",
       lastUpdated: new Date().toISOString(),
       structure: this.structure
     }, null, 2));
     for (const [filepath, intro] of this.files) {
-      const introFilePath = path20.join(introDir, "files", filepath.replace(/\.[^.]+$/, ".json"));
-      await fs7.mkdir(path20.dirname(introFilePath), { recursive: true });
+      const introFilePath = path21.join(introDir, "files", filepath.replace(/\.[^.]+$/, ".json"));
+      await fs7.mkdir(path21.dirname(introFilePath), { recursive: true });
       await fs7.writeFile(introFilePath, JSON.stringify(intro, null, 2));
     }
   }
   async load(config) {
-    const introDir = path20.join(getRaggrepDir(this.rootDir, config), "introspection");
+    const introDir = path21.join(getRaggrepDir(this.rootDir, config), "introspection");
     try {
-      const projectPath = path20.join(introDir, "_project.json");
+      const projectPath = path21.join(introDir, "_project.json");
       const projectContent = await fs7.readFile(projectPath, "utf-8");
       const projectData = JSON.parse(projectContent);
       this.structure = projectData.structure;
-      await this.loadFilesRecursive(path20.join(introDir, "files"), "");
+      await this.loadFilesRecursive(path21.join(introDir, "files"), "");
     } catch {
       this.structure = null;
       this.files.clear();
@@ -8805,7 +9003,7 @@ class IntrospectionIndex {
     try {
       const entries = await fs7.readdir(basePath, { withFileTypes: true });
       for (const entry of entries) {
-        const entryPath = path20.join(basePath, entry.name);
+        const entryPath = path21.join(basePath, entry.name);
         const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
         if (entry.isDirectory()) {
           await this.loadFilesRecursive(entryPath, relativePath);
@@ -8836,7 +9034,7 @@ var init_introspection2 = __esm(() => {
 
 // src/app/indexer/watcher.ts
 import { watch } from "chokidar";
-import * as path21 from "path";
+import * as path22 from "path";
 async function watchDirectory(rootDir, options = {}) {
   const {
     debounceMs = DEFAULT_DEBOUNCE_MS,
@@ -8847,7 +9045,7 @@ async function watchDirectory(rootDir, options = {}) {
     onFileChange,
     onError
   } = options;
-  rootDir = path21.resolve(rootDir);
+  rootDir = path22.resolve(rootDir);
   const config = await loadConfig(rootDir);
   const indexLocation = getIndexLocation(rootDir);
   const validExtensions = new Set(config.extensions);
@@ -8857,7 +9055,7 @@ async function watchDirectory(rootDir, options = {}) {
     "**/.git/**"
   ];
   function shouldWatchFile(filepath) {
-    const ext = path21.extname(filepath);
+    const ext = path22.extname(filepath);
     return validExtensions.has(ext);
   }
   let isRunning = true;
@@ -8940,7 +9138,7 @@ async function watchDirectory(rootDir, options = {}) {
   function handleFileEvent(event, filepath) {
     if (!isRunning)
       return;
-    const relativePath = path21.relative(rootDir, filepath);
+    const relativePath = path22.relative(rootDir, filepath);
     if (!shouldWatchFile(filepath)) {
       return;
     }
@@ -9019,7 +9217,7 @@ __export(exports_indexer, {
   cleanupIndex: () => cleanupIndex
 });
 import * as fs8 from "fs/promises";
-import * as path22 from "path";
+import * as path23 from "path";
 import * as os3 from "os";
 import * as crypto2 from "crypto";
 function clearFreshnessCache() {
@@ -9071,7 +9269,7 @@ async function indexDirectory(rootDir, options = {}) {
   const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
   clearFreshnessCache();
   const logger = options.logger ? options.logger : quiet ? createSilentLogger() : createLogger({ verbose });
-  rootDir = path22.resolve(rootDir);
+  rootDir = path23.resolve(rootDir);
   const location = getIndexLocation(rootDir);
   logger.info(`Indexing directory: ${rootDir}`);
   logger.info(`Index location: ${location.indexDir}`);
@@ -9123,11 +9321,11 @@ async function indexDirectory(rootDir, options = {}) {
         rootDir,
         config,
         readFile: async (filepath) => {
-          const fullPath = path22.isAbsolute(filepath) ? filepath : path22.join(rootDir, filepath);
+          const fullPath = path23.isAbsolute(filepath) ? filepath : path23.join(rootDir, filepath);
           return fs8.readFile(fullPath, "utf-8");
         },
         getFileStats: async (filepath) => {
-          const fullPath = path22.isAbsolute(filepath) ? filepath : path22.join(rootDir, filepath);
+          const fullPath = path23.isAbsolute(filepath) ? filepath : path23.join(rootDir, filepath);
           const stats = await fs8.stat(fullPath);
           return { lastModified: stats.mtime.toISOString() };
         }
@@ -9167,7 +9365,7 @@ async function deleteIndex(rootDir) {
   } catch {}
 }
 async function resetIndex(rootDir) {
-  rootDir = path22.resolve(rootDir);
+  rootDir = path23.resolve(rootDir);
   clearFreshnessCache();
   const status = await getIndexStatus(rootDir);
   if (!status.exists) {
@@ -9192,7 +9390,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
   let filesChanged = 0;
   let filesReindexed = 0;
   const logger = options.logger ? options.logger : quiet ? createSilentLogger() : createLogger({ verbose });
-  rootDir = path22.resolve(rootDir);
+  rootDir = path23.resolve(rootDir);
   const status = await getIndexStatus(rootDir);
   if (!status.exists) {
     clearFreshnessCache();
@@ -9254,7 +9452,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
   const { allFiles: currentFiles, changedFiles, changedFileMtimes } = discoveryResult;
   filesDiscovered = currentFiles.length;
   filesChanged = changedFiles.length;
-  const currentFileSet = new Set(currentFiles.map((f) => path22.relative(rootDir, f)));
+  const currentFileSet = new Set(currentFiles.map((f) => path23.relative(rootDir, f)));
   const changedFileSet = new Set(changedFiles);
   let totalIndexed = 0;
   let totalRemoved = 0;
@@ -9288,8 +9486,8 @@ async function ensureIndexFresh(rootDir, options = {}) {
     if (filesToRemove.length > 0) {
       await Promise.all(filesToRemove.map(async (filepath) => {
         logger.debug(`  Removing stale: ${filepath}`);
-        const indexFilePath = path22.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
-        const symbolicFilePath = path22.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
+        const indexFilePath = path23.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+        const symbolicFilePath = path23.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
         await Promise.all([
           fs8.unlink(indexFilePath).catch(() => {}),
           fs8.unlink(symbolicFilePath).catch(() => {})
@@ -9316,11 +9514,11 @@ async function ensureIndexFresh(rootDir, options = {}) {
       rootDir,
       config,
       readFile: async (filepath) => {
-        const fullPath = path22.isAbsolute(filepath) ? filepath : path22.join(rootDir, filepath);
+        const fullPath = path23.isAbsolute(filepath) ? filepath : path23.join(rootDir, filepath);
         return fs8.readFile(fullPath, "utf-8");
       },
       getFileStats: async (filepath) => {
-        const fullPath = path22.isAbsolute(filepath) ? filepath : path22.join(rootDir, filepath);
+        const fullPath = path23.isAbsolute(filepath) ? filepath : path23.join(rootDir, filepath);
         const stats = await fs8.stat(fullPath);
         return { lastModified: stats.mtime.toISOString() };
       },
@@ -9328,7 +9526,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
     };
     const moduleChangedFiles = module.supportsFile ? changedFiles.filter((f) => module.supportsFile(f)) : changedFiles;
     const filesToProcess = moduleChangedFiles.map((filepath) => {
-      const relativePath = path22.relative(rootDir, filepath);
+      const relativePath = path23.relative(rootDir, filepath);
       const existingEntry = manifest.files[relativePath];
       const lastModified = changedFileMtimes.get(filepath) || new Date().toISOString();
       return {
@@ -9505,7 +9703,7 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
   };
   const manifest = await loadModuleManifest(rootDir, module.id, config);
   const indexPath = getModuleIndexPath(rootDir, module.id, config);
-  const currentFileSet = new Set(files.map((f) => path22.relative(rootDir, f)));
+  const currentFileSet = new Set(files.map((f) => path23.relative(rootDir, f)));
   const filesToRemove = [];
   for (const filepath of Object.keys(manifest.files)) {
     if (!currentFileSet.has(filepath)) {
@@ -9516,11 +9714,11 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
     logger.info(`  Removing ${filesToRemove.length} stale entries...`);
     for (const filepath of filesToRemove) {
       logger.debug(`    Removing: ${filepath}`);
-      const indexFilePath = path22.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+      const indexFilePath = path23.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
       try {
         await fs8.unlink(indexFilePath);
       } catch {}
-      const symbolicFilePath = path22.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
+      const symbolicFilePath = path23.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
       try {
         await fs8.unlink(symbolicFilePath);
       } catch {}
@@ -9532,11 +9730,11 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
     rootDir,
     config,
     readFile: async (filepath) => {
-      const fullPath = path22.isAbsolute(filepath) ? filepath : path22.join(rootDir, filepath);
+      const fullPath = path23.isAbsolute(filepath) ? filepath : path23.join(rootDir, filepath);
       return fs8.readFile(fullPath, "utf-8");
     },
     getFileStats: async (filepath) => {
-      const fullPath = path22.isAbsolute(filepath) ? filepath : path22.join(rootDir, filepath);
+      const fullPath = path23.isAbsolute(filepath) ? filepath : path23.join(rootDir, filepath);
       const stats = await fs8.stat(fullPath);
       return { lastModified: stats.mtime.toISOString() };
     },
@@ -9549,7 +9747,7 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
   let indexedCount = 0;
   let skippedCount = 0;
   const processFile = async (filepath, _index) => {
-    const relativePath = path22.relative(rootDir, filepath);
+    const relativePath = path23.relative(rootDir, filepath);
     try {
       const stats = await fs8.stat(filepath);
       const lastModified = stats.mtime.toISOString();
@@ -9642,8 +9840,8 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
   return result;
 }
 function isLikelyBinary(filepath) {
-  const ext = path22.extname(filepath).toLowerCase();
-  const basename15 = path22.basename(filepath).toLowerCase();
+  const ext = path23.extname(filepath).toLowerCase();
+  const basename15 = path23.basename(filepath).toLowerCase();
   const binaryExtensions = new Set([
     ".png",
     ".jpg",
@@ -9719,7 +9917,7 @@ async function findFilesWithStats(rootDir, config, lastIndexStarted) {
   const ignoreDirs = new Set(config.ignorePaths);
   const lastIndexMs = lastIndexStarted?.getTime() ?? 0;
   const crawler = new Builder().withFullPaths().exclude((dirName) => ignoreDirs.has(dirName)).filter((filePath) => {
-    const ext = path22.extname(filePath);
+    const ext = path23.extname(filePath);
     return validExtensions.has(ext);
   }).crawl(rootDir);
   const allFiles = await crawler.withPromise();
@@ -9774,13 +9972,13 @@ async function loadModuleManifest(rootDir, moduleId, config) {
 }
 async function writeModuleManifest(rootDir, moduleId, manifest, config) {
   const manifestPath = getModuleManifestPath(rootDir, moduleId, config);
-  await fs8.mkdir(path22.dirname(manifestPath), { recursive: true });
+  await fs8.mkdir(path23.dirname(manifestPath), { recursive: true });
   await fs8.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 }
 async function writeFileIndex(rootDir, moduleId, filepath, fileIndex, config) {
   const indexPath = getModuleIndexPath(rootDir, moduleId, config);
-  const indexFilePath = path22.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
-  await fs8.mkdir(path22.dirname(indexFilePath), { recursive: true });
+  const indexFilePath = path23.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+  await fs8.mkdir(path23.dirname(indexFilePath), { recursive: true });
   await fs8.writeFile(indexFilePath, JSON.stringify(fileIndex, null, 2));
 }
 async function loadGlobalManifest(rootDir, config) {
@@ -9800,13 +9998,13 @@ async function updateGlobalManifest(rootDir, modules, config, indexStartTime) {
     lastIndexStarted: indexStartTime,
     modules: modules.map((m) => m.id)
   };
-  await fs8.mkdir(path22.dirname(manifestPath), { recursive: true });
+  await fs8.mkdir(path23.dirname(manifestPath), { recursive: true });
   await fs8.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 }
 async function cleanupIndex(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
   const logger = options.logger ?? createLogger({ verbose });
-  rootDir = path22.resolve(rootDir);
+  rootDir = path23.resolve(rootDir);
   logger.info(`Cleaning up index in: ${rootDir}`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -9836,7 +10034,7 @@ async function cleanupModuleIndex(rootDir, moduleId, config, logger) {
   const filesToRemove = [];
   const updatedFiles = {};
   for (const [filepath, entry] of Object.entries(manifest.files)) {
-    const fullPath = path22.join(rootDir, filepath);
+    const fullPath = path23.join(rootDir, filepath);
     try {
       await fs8.access(fullPath);
       updatedFiles[filepath] = entry;
@@ -9848,7 +10046,7 @@ async function cleanupModuleIndex(rootDir, moduleId, config, logger) {
     }
   }
   for (const filepath of filesToRemove) {
-    const indexFilePath = path22.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+    const indexFilePath = path23.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
     try {
       await fs8.unlink(indexFilePath);
     } catch {}
@@ -9864,7 +10062,7 @@ async function cleanupEmptyDirectories(dir) {
     const entries = await fs8.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const subDir = path22.join(dir, entry.name);
+        const subDir = path23.join(dir, entry.name);
         await cleanupEmptyDirectories(subDir);
       }
     }
@@ -9879,7 +10077,7 @@ async function cleanupEmptyDirectories(dir) {
   }
 }
 async function getIndexStatus(rootDir) {
-  rootDir = path22.resolve(rootDir);
+  rootDir = path23.resolve(rootDir);
   const config = await loadConfig(rootDir);
   const location = getIndexLocation(rootDir);
   const indexDir = location.indexDir;
@@ -9915,7 +10113,7 @@ async function getIndexStatus(rootDir) {
     }
   } catch {
     try {
-      const entries = await fs8.readdir(path22.join(indexDir, "index"));
+      const entries = await fs8.readdir(path23.join(indexDir, "index"));
       if (entries.length > 0) {
         status.exists = true;
         for (const entry of entries) {
@@ -9946,210 +10144,215 @@ var init_indexer = __esm(() => {
   DEFAULT_CONCURRENCY = getOptimalConcurrency();
 });
 
-// node_modules/balanced-match/index.js
-var require_balanced_match = __commonJS((exports, module) => {
-  module.exports = balanced;
-  function balanced(a, b, str) {
-    if (a instanceof RegExp)
-      a = maybeMatch(a, str);
-    if (b instanceof RegExp)
-      b = maybeMatch(b, str);
-    var r = range(a, b, str);
-    return r && {
-      start: r[0],
-      end: r[1],
-      pre: str.slice(0, r[0]),
-      body: str.slice(r[0] + a.length, r[1]),
-      post: str.slice(r[1] + b.length)
-    };
-  }
-  function maybeMatch(reg, str) {
-    var m = str.match(reg);
-    return m ? m[0] : null;
-  }
-  balanced.range = range;
-  function range(a, b, str) {
-    var begs, beg, left, right, result;
-    var ai = str.indexOf(a);
-    var bi = str.indexOf(b, ai + 1);
-    var i = ai;
-    if (ai >= 0 && bi > 0) {
-      if (a === b) {
-        return [ai, bi];
-      }
-      begs = [];
-      left = str.length;
-      while (i >= 0 && !result) {
-        if (i == ai) {
-          begs.push(i);
-          ai = str.indexOf(a, i + 1);
-        } else if (begs.length == 1) {
-          result = [begs.pop(), bi];
-        } else {
-          beg = begs.pop();
-          if (beg < left) {
-            left = beg;
-            right = bi;
-          }
-          bi = str.indexOf(b, i + 1);
+// node_modules/@isaacs/balanced-match/dist/esm/index.js
+var balanced = (a, b, str) => {
+  const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+  const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+  const r = ma !== null && mb != null && range(ma, mb, str);
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: str.slice(0, r[0]),
+    body: str.slice(r[0] + ma.length, r[1]),
+    post: str.slice(r[1] + mb.length)
+  };
+}, maybeMatch = (reg, str) => {
+  const m = str.match(reg);
+  return m ? m[0] : null;
+}, range = (a, b, str) => {
+  let begs, beg, left, right = undefined, result;
+  let ai = str.indexOf(a);
+  let bi = str.indexOf(b, ai + 1);
+  let i = ai;
+  if (ai >= 0 && bi > 0) {
+    if (a === b) {
+      return [ai, bi];
+    }
+    begs = [];
+    left = str.length;
+    while (i >= 0 && !result) {
+      if (i === ai) {
+        begs.push(i);
+        ai = str.indexOf(a, i + 1);
+      } else if (begs.length === 1) {
+        const r = begs.pop();
+        if (r !== undefined)
+          result = [r, bi];
+      } else {
+        beg = begs.pop();
+        if (beg !== undefined && beg < left) {
+          left = beg;
+          right = bi;
         }
-        i = ai < bi && ai >= 0 ? ai : bi;
-      }
-      if (begs.length) {
-        result = [left, right];
+        bi = str.indexOf(b, i + 1);
       }
+      i = ai < bi && ai >= 0 ? ai : bi;
     }
-    return result;
-  }
-});
-
-// node_modules/brace-expansion/index.js
-var require_brace_expansion = __commonJS((exports, module) => {
-  var balanced = require_balanced_match();
-  module.exports = expandTop;
-  var escSlash = "\x00SLASH" + Math.random() + "\x00";
-  var escOpen = "\x00OPEN" + Math.random() + "\x00";
-  var escClose = "\x00CLOSE" + Math.random() + "\x00";
-  var escComma = "\x00COMMA" + Math.random() + "\x00";
-  var escPeriod = "\x00PERIOD" + Math.random() + "\x00";
-  function numeric(str) {
-    return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
-  }
-  function escapeBraces(str) {
-    return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
-  }
-  function unescapeBraces(str) {
-    return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
-  }
-  function parseCommaParts(str) {
-    if (!str)
-      return [""];
-    var parts = [];
-    var m = balanced("{", "}", str);
-    if (!m)
-      return str.split(",");
-    var pre = m.pre;
-    var body = m.body;
-    var post = m.post;
-    var p = pre.split(",");
-    p[p.length - 1] += "{" + body + "}";
-    var postParts = parseCommaParts(post);
-    if (post.length) {
-      p[p.length - 1] += postParts.shift();
-      p.push.apply(p, postParts);
-    }
-    parts.push.apply(parts, p);
-    return parts;
-  }
-  function expandTop(str) {
-    if (!str)
-      return [];
-    if (str.substr(0, 2) === "{}") {
-      str = "\\{\\}" + str.substr(2);
+    if (begs.length && right !== undefined) {
+      result = [left, right];
     }
-    return expand(escapeBraces(str), true).map(unescapeBraces);
-  }
-  function embrace(str) {
-    return "{" + str + "}";
   }
-  function isPadded(el) {
-    return /^-?0\d/.test(el);
-  }
-  function lte(i, y) {
-    return i <= y;
+  return result;
+};
+
+// node_modules/@isaacs/brace-expansion/dist/esm/index.js
+function numeric(str) {
+  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+}
+function escapeBraces(str) {
+  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+}
+function unescapeBraces(str) {
+  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+}
+function parseCommaParts(str) {
+  if (!str) {
+    return [""];
   }
-  function gte(i, y) {
-    return i >= y;
+  const parts = [];
+  const m = balanced("{", "}", str);
+  if (!m) {
+    return str.split(",");
+  }
+  const { pre, body, post } = m;
+  const p = pre.split(",");
+  p[p.length - 1] += "{" + body + "}";
+  const postParts = parseCommaParts(post);
+  if (post.length) {
+    p[p.length - 1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+  parts.push.apply(parts, p);
+  return parts;
+}
+function expand(str) {
+  if (!str) {
+    return [];
   }
-  function expand(str, isTop) {
-    var expansions = [];
-    var m = balanced("{", "}", str);
-    if (!m)
-      return [str];
-    var pre = m.pre;
-    var post = m.post.length ? expand(m.post, false) : [""];
-    if (/\$$/.test(m.pre)) {
-      for (var k = 0;k < post.length; k++) {
-        var expansion = pre + "{" + m.body + "}" + post[k];
-        expansions.push(expansion);
+  if (str.slice(0, 2) === "{}") {
+    str = "\\{\\}" + str.slice(2);
+  }
+  return expand_(escapeBraces(str), true).map(unescapeBraces);
+}
+function embrace(str) {
+  return "{" + str + "}";
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+function lte(i, y) {
+  return i <= y;
+}
+function gte(i, y) {
+  return i >= y;
+}
+function expand_(str, isTop) {
+  const expansions = [];
+  const m = balanced("{", "}", str);
+  if (!m)
+    return [str];
+  const pre = m.pre;
+  const post = m.post.length ? expand_(m.post, false) : [""];
+  if (/\$$/.test(m.pre)) {
+    for (let k = 0;k < post.length; k++) {
+      const expansion = pre + "{" + m.body + "}" + post[k];
+      expansions.push(expansion);
+    }
+  } else {
+    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+    const isSequence = isNumericSequence || isAlphaSequence;
+    const isOptions = m.body.indexOf(",") >= 0;
+    if (!isSequence && !isOptions) {
+      if (m.post.match(/,(?!,).*\}/)) {
+        str = m.pre + "{" + m.body + escClose + m.post;
+        return expand_(str);
       }
+      return [str];
+    }
+    let n;
+    if (isSequence) {
+      n = m.body.split(/\.\./);
     } else {
-      var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-      var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-      var isSequence = isNumericSequence || isAlphaSequence;
-      var isOptions = m.body.indexOf(",") >= 0;
-      if (!isSequence && !isOptions) {
-        if (m.post.match(/,(?!,).*\}/)) {
-          str = m.pre + "{" + m.body + escClose + m.post;
-          return expand(str);
-        }
-        return [str];
-      }
-      var n;
-      if (isSequence) {
-        n = m.body.split(/\.\./);
-      } else {
-        n = parseCommaParts(m.body);
+      n = parseCommaParts(m.body);
+      if (n.length === 1 && n[0] !== undefined) {
+        n = expand_(n[0], false).map(embrace);
         if (n.length === 1) {
-          n = expand(n[0], false).map(embrace);
-          if (n.length === 1) {
-            return post.map(function(p) {
-              return m.pre + n[0] + p;
-            });
+          return post.map((p) => m.pre + n[0] + p);
+        }
+      }
+    }
+    let N;
+    if (isSequence && n[0] !== undefined && n[1] !== undefined) {
+      const x = numeric(n[0]);
+      const y = numeric(n[1]);
+      const width = Math.max(n[0].length, n[1].length);
+      let incr = n.length === 3 && n[2] !== undefined ? Math.abs(numeric(n[2])) : 1;
+      let test = lte;
+      const reverse = y < x;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
+      }
+      const pad = n.some(isPadded);
+      N = [];
+      for (let i = x;test(i, y); i += incr) {
+        let c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i);
+          if (c === "\\") {
+            c = "";
           }
-        }
-      }
-      var N;
-      if (isSequence) {
-        var x = numeric(n[0]);
-        var y = numeric(n[1]);
-        var width = Math.max(n[0].length, n[1].length);
-        var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
-        var test = lte;
-        var reverse = y < x;
-        if (reverse) {
-          incr *= -1;
-          test = gte;
-        }
-        var pad = n.some(isPadded);
-        N = [];
-        for (var i = x;test(i, y); i += incr) {
-          var c;
-          if (isAlphaSequence) {
-            c = String.fromCharCode(i);
-            if (c === "\\")
-              c = "";
-          } else {
-            c = String(i);
-            if (pad) {
-              var need = width - c.length;
-              if (need > 0) {
-                var z = new Array(need + 1).join("0");
-                if (i < 0)
-                  c = "-" + z + c.slice(1);
-                else
-                  c = z + c;
+        } else {
+          c = String(i);
+          if (pad) {
+            const need = width - c.length;
+            if (need > 0) {
+              const z = new Array(need + 1).join("0");
+              if (i < 0) {
+                c = "-" + z + c.slice(1);
+              } else {
+                c = z + c;
               }
             }
           }
-          N.push(c);
-        }
-      } else {
-        N = [];
-        for (var j = 0;j < n.length; j++) {
-          N.push.apply(N, expand(n[j], false));
         }
+        N.push(c);
       }
-      for (var j = 0;j < N.length; j++) {
-        for (var k = 0;k < post.length; k++) {
-          var expansion = pre + N[j] + post[k];
-          if (!isTop || isSequence || expansion)
-            expansions.push(expansion);
+    } else {
+      N = [];
+      for (let j = 0;j < n.length; j++) {
+        N.push.apply(N, expand_(n[j], false));
+      }
+    }
+    for (let j = 0;j < N.length; j++) {
+      for (let k = 0;k < post.length; k++) {
+        const expansion = pre + N[j] + post[k];
+        if (!isTop || isSequence || expansion) {
+          expansions.push(expansion);
         }
       }
     }
-    return expansions;
   }
+  return expansions;
+}
+var escSlash, escOpen, escClose, escComma, escPeriod, escSlashPattern, escOpenPattern, escClosePattern, escCommaPattern, escPeriodPattern, slashPattern, openPattern, closePattern, commaPattern, periodPattern;
+var init_esm = __esm(() => {
+  escSlash = "\x00SLASH" + Math.random() + "\x00";
+  escOpen = "\x00OPEN" + Math.random() + "\x00";
+  escClose = "\x00CLOSE" + Math.random() + "\x00";
+  escComma = "\x00COMMA" + Math.random() + "\x00";
+  escPeriod = "\x00PERIOD" + Math.random() + "\x00";
+  escSlashPattern = new RegExp(escSlash, "g");
+  escOpenPattern = new RegExp(escOpen, "g");
+  escClosePattern = new RegExp(escClose, "g");
+  escCommaPattern = new RegExp(escComma, "g");
+  escPeriodPattern = new RegExp(escPeriod, "g");
+  slashPattern = /\\\\/g;
+  openPattern = /\\{/g;
+  closePattern = /\\}/g;
+  commaPattern = /\\,/g;
+  periodPattern = /\\./g;
 });
 
 // node_modules/minimatch/dist/esm/assert-valid-pattern.js
@@ -10275,8 +10478,11 @@ var init_brace_expressions = __esm(() => {
 });
 
 // node_modules/minimatch/dist/esm/unescape.js
-var unescape = (s, { windowsPathsNoEscape = false } = {}) => {
-  return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+var unescape = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {}) => {
+  if (magicalBraces) {
+    return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+  }
+  return windowsPathsNoEscape ? s.replace(/\[([^\/\\{}])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
 };
 
 // node_modules/minimatch/dist/esm/ast.js
@@ -10545,7 +10751,7 @@ class AST {
     if (this.#root === this)
       this.#fillNegs();
     if (!this.type) {
-      const noEmpty = this.isStart() && this.isEnd();
+      const noEmpty = this.isStart() && this.isEnd() && !this.#parts.some((s) => typeof s !== "string");
       const src = this.#parts.map((p) => {
         const [re, _, hasMagic, uflag] = typeof p === "string" ? AST.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
         this.#hasMagic = this.#hasMagic || hasMagic;
@@ -10647,10 +10853,7 @@ class AST {
         }
       }
       if (c === "*") {
-        if (noEmpty && glob === "*")
-          re += starNoEmpty;
-        else
-          re += star;
+        re += noEmpty && glob === "*" ? starNoEmpty : star;
         hasMagic = true;
         continue;
       }
@@ -10676,7 +10879,10 @@ var init_ast = __esm(() => {
 });
 
 // node_modules/minimatch/dist/esm/escape.js
-var escape = (s, { windowsPathsNoEscape = false } = {}) => {
+var escape = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
+  if (magicalBraces) {
+    return windowsPathsNoEscape ? s.replace(/[?*()[\]{}]/g, "[$&]") : s.replace(/[?*()[\]\\{}]/g, "\\$&");
+  }
   return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
 };
 
@@ -11150,16 +11356,27 @@ globstar while`, file, fr, pattern, pr, swallowee);
             pp[i] = twoStar;
           }
         } else if (next === undefined) {
-          pp[i - 1] = prev + "(?:\\/|" + twoStar + ")?";
+          pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + ")?";
         } else if (next !== GLOBSTAR) {
           pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
           pp[i + 1] = GLOBSTAR;
         }
       });
-      return pp.filter((p) => p !== GLOBSTAR).join("/");
+      const filtered = pp.filter((p) => p !== GLOBSTAR);
+      if (this.partial && filtered.length >= 1) {
+        const prefixes = [];
+        for (let i = 1;i <= filtered.length; i++) {
+          prefixes.push(filtered.slice(0, i).join("/"));
+        }
+        return "(?:" + prefixes.join("|") + ")";
+      }
+      return filtered.join("/");
     }).join("|");
     const [open, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
     re = "^" + open + re + close + "$";
+    if (this.partial) {
+      re = "^(?:\\/|" + open + re.slice(1, -1) + close + ")$";
+    }
     if (this.negate)
       re = "^(?!" + re + ").+$";
     try {
@@ -11226,7 +11443,7 @@ globstar while`, file, fr, pattern, pr, swallowee);
     return minimatch.defaults(def).Minimatch;
   }
 }
-var import_brace_expansion, minimatch = (p, pattern, options = {}) => {
+var minimatch = (p, pattern, options = {}) => {
   assertValidPattern(pattern);
   if (!options.nocomment && pattern.charAt(0) === "#") {
     return false;
@@ -11262,7 +11479,7 @@ var import_brace_expansion, minimatch = (p, pattern, options = {}) => {
 }, qmarksTestNoExtDot = ([$0]) => {
   const len = $0.length;
   return (f) => f.length === len && f !== "." && f !== "..";
-}, defaultPlatform, path23, sep2, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a, b = {}) => Object.assign({}, a, b), defaults = (def) => {
+}, defaultPlatform, path24, sep2, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a, b = {}) => Object.assign({}, a, b), defaults = (def) => {
   if (!def || typeof def !== "object" || !Object.keys(def).length) {
     return minimatch;
   }
@@ -11300,7 +11517,7 @@ var import_brace_expansion, minimatch = (p, pattern, options = {}) => {
   if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
     return [pattern];
   }
-  return import_brace_expansion.default(pattern);
+  return expand(pattern);
 }, makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe(), match = (list, pattern, options = {}) => {
   const mm = new Minimatch(pattern, options);
   list = list.filter((f) => mm.match(f));
@@ -11309,22 +11526,22 @@ var import_brace_expansion, minimatch = (p, pattern, options = {}) => {
   }
   return list;
 }, globMagic, regExpEscape2 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-var init_esm = __esm(() => {
+var init_esm2 = __esm(() => {
+  init_esm();
   init_assert_valid_pattern();
   init_ast();
   init_ast();
-  import_brace_expansion = __toESM(require_brace_expansion(), 1);
   starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
   starDotStarRE = /^\*+\.\*+$/;
   dotStarRE = /^\.\*+$/;
   starRE = /^\*+$/;
   qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
   defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-  path23 = {
+  path24 = {
     win32: { sep: "\\" },
     posix: { sep: "/" }
   };
-  sep2 = defaultPlatform === "win32" ? path23.win32.sep : path23.posix.sep;
+  sep2 = defaultPlatform === "win32" ? path24.win32.sep : path24.posix.sep;
   minimatch.sep = sep2;
   GLOBSTAR = Symbol("globstar **");
   minimatch.GLOBSTAR = GLOBSTAR;
@@ -11345,17 +11562,196 @@ var init_esm = __esm(() => {
 var init_types = __esm(() => {
   init_entities();
 });
+// src/domain/usecases/exactSearch.ts
+function matchesPathFilter(relativePath, filters, matchFn) {
+  const normalizedPath = relativePath.replace(/\\/g, "/");
+  for (const filter2 of filters) {
+    const normalizedFilter = filter2.replace(/\\/g, "/").replace(/^\//, "").replace(/\/$/, "");
+    const isGlobPattern = /[*?[\]{}!]/.test(normalizedFilter);
+    if (isGlobPattern) {
+      const pattern = normalizedFilter.startsWith("**/") ? normalizedFilter : `**/${normalizedFilter}`;
+      if (matchFn(normalizedPath, pattern)) {
+        return true;
+      }
+    } else {
+      if (normalizedPath.startsWith(normalizedFilter + "/") || normalizedPath === normalizedFilter || normalizedPath.includes("/" + normalizedFilter + "/")) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+async function executeExactSearch(fs9, options, matchFn) {
+  const {
+    rootDir,
+    literal,
+    pathFilter = [],
+    maxFiles = 20,
+    maxOccurrencesPerFile = 5,
+    caseInsensitive = false
+  } = options;
+  const files = new Map;
+  async function walkDir(dir, baseDir) {
+    try {
+      const entries = await fs9.readDir(dir);
+      for (const entry of entries) {
+        const fullPath = fs9.join(dir, entry);
+        const relativePath = fs9.relative(baseDir, fullPath);
+        let isDirectory = false;
+        try {
+          const stats = await fs9.getStats(fullPath);
+          isDirectory = stats.isDirectory ?? false;
+        } catch {
+          continue;
+        }
+        if (isDirectory) {
+          if (DEFAULT_IGNORED_DIRS.includes(entry)) {
+            continue;
+          }
+          await walkDir(fullPath, baseDir);
+        } else {
+          if (pathFilter.length > 0) {
+            if (!matchesPathFilter(relativePath, pathFilter, matchFn)) {
+              continue;
+            }
+          }
+          try {
+            const content = await fs9.readFile(fullPath);
+            if (isSearchableContent(content, fullPath)) {
+              files.set(relativePath, content);
+            }
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+  await walkDir(rootDir, rootDir);
+  return searchFiles(files, literal, {
+    maxFiles,
+    maxOccurrencesPerFile,
+    caseInsensitive
+  });
+}
+var DEFAULT_IGNORED_DIRS;
+var init_exactSearch = __esm(() => {
+  init_simpleSearch();
+  DEFAULT_IGNORED_DIRS = [
+    "node_modules",
+    ".git",
+    ".raggrep",
+    "dist",
+    "build",
+    ".next",
+    "__pycache__",
+    ".venv",
+    "venv"
+  ];
+});
+
+// src/domain/usecases/index.ts
+var init_usecases = __esm(() => {
+  init_exactSearch();
+});
+
+// src/infrastructure/filesystem/nodeFileSystem.ts
+import * as fs9 from "fs/promises";
+import * as path25 from "path";
+import { glob } from "glob";
+
+class NodeFileSystem {
+  async readFile(filepath) {
+    return fs9.readFile(filepath, "utf-8");
+  }
+  async writeFile(filepath, content) {
+    await fs9.mkdir(path25.dirname(filepath), { recursive: true });
+    await fs9.writeFile(filepath, content, "utf-8");
+  }
+  async deleteFile(filepath) {
+    try {
+      await fs9.unlink(filepath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  async getStats(filepath) {
+    const stats = await fs9.stat(filepath);
+    return {
+      lastModified: stats.mtime.toISOString(),
+      size: stats.isDirectory() ? undefined : stats.size,
+      isDirectory: stats.isDirectory()
+    };
+  }
+  async exists(filepath) {
+    try {
+      await fs9.access(filepath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async mkdir(dirpath) {
+    await fs9.mkdir(dirpath, { recursive: true });
+  }
+  async readDir(dirpath) {
+    return fs9.readdir(dirpath);
+  }
+  async findFiles(rootDir, patterns, ignore) {
+    const ignorePatterns = ignore.map((p) => `**/${p}/**`);
+    const files = [];
+    for (const pattern of patterns) {
+      const matches = await glob(pattern, {
+        cwd: rootDir,
+        absolute: true,
+        ignore: ignorePatterns
+      });
+      files.push(...matches);
+    }
+    return [...new Set(files)];
+  }
+  join(...segments) {
+    return path25.join(...segments);
+  }
+  relative(from, to) {
+    return path25.relative(from, to);
+  }
+  resolve(...segments) {
+    return path25.resolve(...segments);
+  }
+  dirname(filepath) {
+    return path25.dirname(filepath);
+  }
+  extname(filepath) {
+    return path25.extname(filepath);
+  }
+}
+var nodeFileSystem;
+var init_nodeFileSystem = __esm(() => {
+  nodeFileSystem = new NodeFileSystem;
+});
+
+// src/infrastructure/filesystem/index.ts
+var init_filesystem = __esm(() => {
+  init_nodeFileSystem();
+});
 
 // src/app/search/index.ts
 var exports_search = {};
 __export(exports_search, {
   search: () => search,
-  formatSearchResults: () => formatSearchResults
+  hybridSearch: () => hybridSearch,
+  formatSearchResults: () => formatSearchResults2,
+  formatHybridSearchResults: () => formatHybridSearchResults
 });
-import * as fs9 from "fs/promises";
-import * as path24 from "path";
+import * as fs10 from "fs/promises";
+import * as path26 from "path";
 async function search(rootDir, query, options = {}) {
-  rootDir = path24.resolve(rootDir);
+  const hybridResults = await hybridSearch(rootDir, query, options);
+  return hybridResults.results;
+}
+async function hybridSearch(rootDir, query, options = {}) {
+  rootDir = path26.resolve(rootDir);
   const ensureFresh = options.ensureFresh ?? DEFAULT_SEARCH_OPTIONS.ensureFresh;
   if (ensureFresh) {
     await ensureIndexFresh(rootDir, { quiet: true });
@@ -11366,7 +11762,7 @@ async function search(rootDir, query, options = {}) {
   const globalManifest = await loadGlobalManifest2(rootDir, config);
   if (!globalManifest || globalManifest.modules.length === 0) {
     console.log('No index found. Run "raggrep index" first.');
-    return [];
+    return { results: [], fusionApplied: false };
   }
   const modulesToSearch = [];
   for (const moduleId of globalManifest.modules) {
@@ -11381,7 +11777,7 @@ async function search(rootDir, query, options = {}) {
   }
   if (modulesToSearch.length === 0) {
     console.log("No enabled modules with indexes found.");
-    return [];
+    return { results: [], fusionApplied: false };
   }
   const allResults = [];
   for (const module of modulesToSearch) {
@@ -11405,9 +11801,42 @@ async function search(rootDir, query, options = {}) {
       });
     });
   }
+  let exactMatches;
+  let fusionApplied = false;
+  if (isIdentifierQuery(query)) {
+    const literal = extractSearchLiteral(query);
+    exactMatches = await performExactSearch(rootDir, literal, config, options);
+    if (exactMatches && exactMatches.totalMatches > 0) {
+      const exactMatchFilepaths = new Set(exactMatches.files.map((f) => f.filepath));
+      for (const result of filteredResults) {
+        if (exactMatchFilepaths.has(result.filepath)) {
+          result.score *= 1.5;
+          if (!result.context)
+            result.context = {};
+          result.context.exactMatchFusion = true;
+          fusionApplied = true;
+        }
+      }
+    }
+  }
   filteredResults.sort((a, b) => b.score - a.score);
   const topK = options.topK ?? 10;
-  return filteredResults.slice(0, topK);
+  return {
+    results: filteredResults.slice(0, topK),
+    exactMatches,
+    fusionApplied
+  };
+}
+async function performExactSearch(rootDir, literal, config, options) {
+  const fs11 = new NodeFileSystem;
+  return executeExactSearch(fs11, {
+    rootDir,
+    literal,
+    pathFilter: options.pathFilter,
+    maxFiles: 20,
+    maxOccurrencesPerFile: 5,
+    caseInsensitive: false
+  }, (path27, pattern) => minimatch(path27, pattern, { matchBase: true }));
 }
 function createSearchContext(rootDir, moduleId, config) {
   const indexPath = getModuleIndexPath(rootDir, moduleId, config);
@@ -11416,9 +11845,9 @@ function createSearchContext(rootDir, moduleId, config) {
     config,
     loadFileIndex: async (filepath) => {
       const hasExtension = /\.[^./]+$/.test(filepath);
-      const indexFilePath = hasExtension ? path24.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path24.join(indexPath, filepath + ".json");
+      const indexFilePath = hasExtension ? path26.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path26.join(indexPath, filepath + ".json");
       try {
-        const content = await fs9.readFile(indexFilePath, "utf-8");
+        const content = await fs10.readFile(indexFilePath, "utf-8");
         return JSON.parse(content);
       } catch {
         return null;
@@ -11428,17 +11857,17 @@ function createSearchContext(rootDir, moduleId, config) {
       const files = [];
       await traverseDirectory(indexPath, files, indexPath);
       return files.filter((f) => f.endsWith(".json") && !f.endsWith("manifest.json")).map((f) => {
-        const relative5 = path24.relative(indexPath, f);
-        return relative5.replace(/\.json$/, "");
+        const relative6 = path26.relative(indexPath, f);
+        return relative6.replace(/\.json$/, "");
       });
     }
   };
 }
 async function traverseDirectory(dir, files, basePath) {
   try {
-    const entries = await fs9.readdir(dir, { withFileTypes: true });
+    const entries = await fs10.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path24.join(dir, entry.name);
+      const fullPath = path26.join(dir, entry.name);
       if (entry.isDirectory()) {
         await traverseDirectory(fullPath, files, basePath);
       } else if (entry.isFile()) {
@@ -11450,7 +11879,7 @@ async function traverseDirectory(dir, files, basePath) {
 async function loadGlobalManifest2(rootDir, config) {
   const manifestPath = getGlobalManifestPath(rootDir, config);
   try {
-    const content = await fs9.readFile(manifestPath, "utf-8");
+    const content = await fs10.readFile(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -11470,7 +11899,7 @@ function formatModuleName(moduleId) {
       return moduleId;
   }
 }
-function formatSearchResults(results) {
+function formatSearchResults2(results) {
   if (results.length === 0) {
     return "No results found.";
   }
@@ -11489,6 +11918,9 @@ function formatSearchResults(results) {
     if (chunk.isExported) {
       output += " | exported";
     }
+    if (result.context?.exactMatchFusion) {
+      output += " | exact match";
+    }
     output += `
 `;
     const lines = chunk.content.split(`
@@ -11503,12 +11935,84 @@ function formatSearchResults(results) {
   }
   return output;
 }
+function formatHybridSearchResults(hybridResults) {
+  let output = "";
+  if (hybridResults.exactMatches && hybridResults.exactMatches.totalMatches > 0) {
+    const em = hybridResults.exactMatches;
+    const showingCount = Math.min(em.files.length, 10);
+    output += `┌─ Exact Matches `;
+    if (em.truncated || em.files.length < em.totalFiles) {
+      output += `(showing ${showingCount} of ${em.totalFiles} files, ${em.totalMatches} total matches)`;
+    } else {
+      output += `(${em.totalFiles} files, ${em.totalMatches} matches)`;
+    }
+    output += ` ─┐
+`;
+    output += `│  Query: "${em.query}"
+`;
+    output += `└─────────────────────────────────────────────────────────────────────┘
+
+`;
+    for (let i = 0;i < Math.min(em.files.length, 10); i++) {
+      const file = em.files[i];
+      output += `  ${i + 1}. ${file.filepath}`;
+      if (file.matchCount > 1) {
+        output += ` (${file.matchCount} matches)`;
+      }
+      output += `
+`;
+      const firstOcc = file.occurrences[0];
+      if (firstOcc) {
+        if (firstOcc.contextBefore) {
+          const beforeLine = firstOcc.contextBefore.substring(0, 76);
+          output += `     ${(firstOcc.line - 1).toString().padStart(4)} │ ${beforeLine}${firstOcc.contextBefore.length > 76 ? "..." : ""}
+`;
+        }
+        const matchLine = firstOcc.lineContent.substring(0, 76);
+        output += `   ► ${firstOcc.line.toString().padStart(4)} │ ${matchLine}${firstOcc.lineContent.length > 76 ? "..." : ""}
+`;
+        if (firstOcc.contextAfter) {
+          const afterLine = firstOcc.contextAfter.substring(0, 76);
+          output += `     ${(firstOcc.line + 1).toString().padStart(4)} │ ${afterLine}${firstOcc.contextAfter.length > 76 ? "..." : ""}
+`;
+        }
+      }
+      output += `
+`;
+    }
+    if (hybridResults.results.length > 0) {
+      output += `
+`;
+    }
+  }
+  if (hybridResults.results.length > 0) {
+    if (hybridResults.exactMatches?.totalMatches) {
+      output += `┌─ Semantic Results `;
+      if (hybridResults.fusionApplied) {
+        output += `(boosted by exact matches) `;
+      }
+      output += `─┐
+`;
+      output += `└─────────────────────────────────────────────────────────────────────┘
+
+`;
+    }
+    output += formatSearchResults2(hybridResults.results);
+  } else if (!hybridResults.exactMatches?.totalMatches) {
+    output += `No results found.
+`;
+  }
+  return output;
+}
 var init_search = __esm(() => {
-  init_esm();
+  init_esm2();
   init_types();
   init_config2();
   init_registry();
   init_indexer();
+  init_services();
+  init_usecases();
+  init_filesystem();
 });
 
 // src/app/cli/opencode/version-check.ts
@@ -11545,17 +12049,17 @@ function getInstallationMethod(openCodeVersion) {
 async function detectOpenCodeVersion() {
   try {
     const os4 = await import("os");
-    const fs10 = await import("fs/promises");
-    const path25 = await import("path");
+    const fs11 = await import("fs/promises");
+    const path27 = await import("path");
     const homeDir = os4.homedir();
     const possiblePaths = [
-      path25.join(homeDir, ".local", "share", "opencode", "package.json"),
-      path25.join(homeDir, ".config", "opencode", "package.json"),
-      path25.join(homeDir, ".npm", "global", "node_modules", "opencode", "package.json")
+      path27.join(homeDir, ".local", "share", "opencode", "package.json"),
+      path27.join(homeDir, ".config", "opencode", "package.json"),
+      path27.join(homeDir, ".npm", "global", "node_modules", "opencode", "package.json")
     ];
     for (const packagePath of possiblePaths) {
       try {
-        const content = await fs10.readFile(packagePath, "utf-8");
+        const content = await fs11.readFile(packagePath, "utf-8");
         const pkg = JSON.parse(content);
         if (pkg.version) {
           return pkg.version;
@@ -11564,7 +12068,7 @@ async function detectOpenCodeVersion() {
     }
     try {
       const { spawn } = await import("child_process");
-      return new Promise((resolve6) => {
+      return new Promise((resolve7) => {
         const proc = spawn("opencode", ["--version"], { stdio: "pipe" });
         let version = "";
         proc.stdout.on("data", (data) => {
@@ -11573,14 +12077,14 @@ async function detectOpenCodeVersion() {
         proc.on("close", (code) => {
           if (code === 0) {
             const match2 = version.match(/v?(\d+\.\d+\.\d+)/);
-            resolve6(match2 ? match2[1] : null);
+            resolve7(match2 ? match2[1] : null);
           } else {
-            resolve6(null);
+            resolve7(null);
           }
         });
         setTimeout(() => {
           proc.kill();
-          resolve6(null);
+          resolve7(null);
         }, 3000);
       });
     } catch {}
@@ -11594,11 +12098,11 @@ async function detectOpenCodeVersion() {
 async function installTool(options = {}) {
   const { logger, checkForOldSkill = true } = options;
   const os4 = await import("os");
-  const fs10 = await import("fs/promises");
-  const path25 = await import("path");
+  const fs11 = await import("fs/promises");
+  const path27 = await import("path");
   const homeDir = os4.homedir();
-  const toolDir = path25.join(homeDir, ".config", "opencode", "tool");
-  const toolPath = path25.join(toolDir, "raggrep.ts");
+  const toolDir = path27.join(homeDir, ".config", "opencode", "tool");
+  const toolPath = path27.join(toolDir, "raggrep.ts");
   let removedOldSkill = false;
   const toolContent = `import { tool } from "@opencode-ai/plugin";
 
@@ -11681,11 +12185,11 @@ Please install raggrep globally:
 `;
   try {
     if (checkForOldSkill) {
-      const oldSkillDir = path25.join(homeDir, ".config", "opencode", "skill", "raggrep");
-      const oldSkillPath = path25.join(oldSkillDir, "SKILL.md");
+      const oldSkillDir = path27.join(homeDir, ".config", "opencode", "skill", "raggrep");
+      const oldSkillPath = path27.join(oldSkillDir, "SKILL.md");
       let oldSkillExists = false;
       try {
-        await fs10.access(oldSkillPath);
+        await fs11.access(oldSkillPath);
         oldSkillExists = true;
       } catch {}
       if (oldSkillExists) {
@@ -11703,18 +12207,18 @@ Please install raggrep globally:
           input: process.stdin,
           output: process.stdout
         });
-        const answer = await new Promise((resolve6) => {
-          rl.question("Remove the existing skill and install tool? (Y/n): ", resolve6);
+        const answer = await new Promise((resolve7) => {
+          rl.question("Remove the existing skill and install tool? (Y/n): ", resolve7);
         });
         rl.close();
         const shouldDelete = answer.toLowerCase() !== "n";
         if (shouldDelete) {
           try {
-            await fs10.unlink(oldSkillPath);
-            const skillDirContents = await fs10.readdir(oldSkillDir);
+            await fs11.unlink(oldSkillPath);
+            const skillDirContents = await fs11.readdir(oldSkillDir);
             if (skillDirContents.length === 0) {
               try {
-                await fs10.rmdir(oldSkillDir);
+                await fs11.rmdir(oldSkillDir);
                 console.log("✓ Removed old skill directory.");
               } catch (rmdirError) {
                 console.log("✓ Removed old skill file. (Directory not empty or other error)");
@@ -11751,8 +12255,8 @@ Please install raggrep globally:
         }
       }
     }
-    await fs10.mkdir(toolDir, { recursive: true });
-    await fs10.writeFile(toolPath, toolContent, "utf-8");
+    await fs11.mkdir(toolDir, { recursive: true });
+    await fs11.writeFile(toolPath, toolContent, "utf-8");
     const message = `Installed raggrep tool for OpenCode.
   Location: ${toolPath}
 
@@ -11786,11 +12290,11 @@ The raggrep tool is now available in OpenCode.`;
 async function installSkill(options = {}) {
   const { logger, checkForOldTool = true } = options;
   const os4 = await import("os");
-  const fs10 = await import("fs/promises");
-  const path25 = await import("path");
+  const fs11 = await import("fs/promises");
+  const path27 = await import("path");
   const homeDir = os4.homedir();
-  const skillDir = path25.join(homeDir, ".config", "opencode", "skill", "raggrep");
-  const skillPath = path25.join(skillDir, "SKILL.md");
+  const skillDir = path27.join(homeDir, ".config", "opencode", "skill", "raggrep");
+  const skillPath = path27.join(skillDir, "SKILL.md");
   const skillContent = `---
 name: raggrep
 description: AST-powered semantic code search that understands intent, not just text. Superior to grep/rg - finds functions, classes, and logic even when keywords differ. Saves 10x tool calls by searching the actual code structure.
@@ -11902,11 +12406,11 @@ Instead of using grep/rg or manually reading files:
   let removedOldTool = false;
   try {
     if (checkForOldTool) {
-      const oldToolDir = path25.join(homeDir, ".config", "opencode", "tool");
-      const oldToolPath = path25.join(oldToolDir, "raggrep.ts");
+      const oldToolDir = path27.join(homeDir, ".config", "opencode", "tool");
+      const oldToolPath = path27.join(oldToolDir, "raggrep.ts");
       let oldToolExists = false;
       try {
-        await fs10.access(oldToolPath);
+        await fs11.access(oldToolPath);
         oldToolExists = true;
       } catch {}
       if (oldToolExists) {
@@ -11924,18 +12428,18 @@ Instead of using grep/rg or manually reading files:
           input: process.stdin,
           output: process.stdout
         });
-        const answer = await new Promise((resolve6) => {
-          rl.question("Do you want to remove the old tool file? (Y/n): ", resolve6);
+        const answer = await new Promise((resolve7) => {
+          rl.question("Do you want to remove the old tool file? (Y/n): ", resolve7);
         });
         rl.close();
         const shouldDelete = answer.toLowerCase() !== "n";
         if (shouldDelete) {
           try {
-            await fs10.unlink(oldToolPath);
-            const toolDirContents = await fs10.readdir(oldToolDir);
+            await fs11.unlink(oldToolPath);
+            const toolDirContents = await fs11.readdir(oldToolDir);
             if (toolDirContents.length === 0) {
               try {
-                await fs10.rmdir(oldToolDir);
+                await fs11.rmdir(oldToolDir);
                 console.log("✓ Removed old tool directory.");
               } catch (rmdirError) {
                 console.log("✓ Removed old tool file. (Directory not empty or other error)");
@@ -11968,8 +12472,8 @@ Instead of using grep/rg or manually reading files:
         }
       }
     }
-    await fs10.mkdir(skillDir, { recursive: true });
-    await fs10.writeFile(skillPath, skillContent, "utf-8");
+    await fs11.mkdir(skillDir, { recursive: true });
+    await fs11.writeFile(skillPath, skillContent, "utf-8");
     const message = `Installed raggrep skill for OpenCode.
   Location: ${skillPath}
 
@@ -12022,7 +12526,7 @@ init_logger();
 // package.json
 var package_default = {
   name: "raggrep",
-  version: "0.14.2",
+  version: "0.16.0",
   description: "Local filesystem-based RAG system for codebases - semantic search using local embeddings",
   type: "module",
   main: "./dist/index.js",
@@ -12081,6 +12585,7 @@ var package_default = {
     chokidar: "^5.0.0",
     fdir: "^6.5.0",
     glob: "^10.0.0",
+    minimatch: "^10.1.1",
     typescript: "^5.0.0",
     "web-tree-sitter": "^0.26.3"
   },
@@ -12227,13 +12732,13 @@ Examples:
 `);
         process.exit(0);
       }
-      const { indexDirectory: indexDirectory2, watchDirectory: watchDirectory2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
+      const { indexDirectory: indexDirectory3, watchDirectory: watchDirectory2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
       const logger = createInlineLogger({ verbose: flags.verbose });
       console.log("RAGgrep Indexer");
       console.log(`================
 `);
       try {
-        const results = await indexDirectory2(process.cwd(), {
+        const results = await indexDirectory3(process.cwd(), {
           model: flags.model,
           verbose: flags.verbose,
           concurrency: flags.concurrency,
@@ -12338,7 +12843,6 @@ Examples:
 `);
         process.exit(0);
       }
-      const { search: search2, formatSearchResults: formatSearchResults2 } = await Promise.resolve().then(() => (init_search(), exports_search));
       const { ensureIndexFresh: ensureIndexFresh2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
       const query = flags.remaining[0];
       if (!query) {
@@ -12388,14 +12892,15 @@ Examples:
 `);
         }
         const filePatterns = flags.fileType ? [`*.${flags.fileType}`] : undefined;
-        const results = await search2(process.cwd(), query, {
+        const { hybridSearch: hybridSearch2, formatHybridSearchResults: formatHybridSearchResults2 } = await Promise.resolve().then(() => (init_search(), exports_search));
+        const hybridResults = await hybridSearch2(process.cwd(), query, {
           topK: flags.topK ?? 10,
           minScore: flags.minScore,
           filePatterns,
           pathFilter: flags.pathFilter,
           ensureFresh: false
         });
-        console.log(formatSearchResults2(results));
+        console.log(formatHybridSearchResults2(hybridResults));
       } catch (error) {
         console.error("Error during search:", error);
         process.exit(1);
@@ -12618,4 +13123,4 @@ Run 'raggrep <command> --help' for more information.
 }
 main();
 
-//# debugId=71C6E22A4D7E91CE64756E2164756E21
+//# debugId=8BF97097099E1F1364756E2164756E21