raggrep 0.6.1 → 0.7.0

package/dist/cli/main.js

@@ -430,10 +430,14 @@ var init_config = __esm(() => {
   ];
 });
 
+// src/domain/entities/literal.ts
+var init_literal = () => {};
+
 // src/domain/entities/index.ts
 var init_entities = __esm(() => {
   init_searchResult();
   init_config();
+  init_literal();
 });
 
 // src/infrastructure/config/configLoader.ts
@@ -2660,10 +2664,299 @@ function generateChunkId(filepath, startLine, endLine) {
 }
 var DEFAULT_CHUNK_SIZE = 30, DEFAULT_OVERLAP = 5;
 
+// src/domain/services/queryLiteralParser.ts
+function parseQueryLiterals(query) {
+  if (!query || query.trim() === "") {
+    return { literals: [], remainingQuery: "" };
+  }
+  const literals = [];
+  let remainingQuery = query;
+  const matchedPositions = new Set;
+  const backtickResult = extractExplicitLiterals(remainingQuery, /`([^`]+)`/g, "explicit-backtick", matchedPositions);
+  literals.push(...backtickResult.literals);
+  remainingQuery = backtickResult.remainingQuery;
+  const quoteResult = extractExplicitLiterals(remainingQuery, /"([^"]+)"/g, "explicit-quote", matchedPositions);
+  literals.push(...quoteResult.literals);
+  remainingQuery = quoteResult.remainingQuery;
+  const implicitLiterals = extractImplicitLiterals(query, matchedPositions);
+  literals.push(...implicitLiterals);
+  return {
+    literals,
+    remainingQuery: remainingQuery.trim()
+  };
+}
+function extractExplicitLiterals(query, pattern, method, matchedPositions) {
+  const literals = [];
+  let remainingQuery = query;
+  pattern.lastIndex = 0;
+  let match;
+  const replacements = [];
+  while ((match = pattern.exec(query)) !== null) {
+    const value = match[1];
+    const rawValue = match[0];
+    if (!value || value.trim() === "") {
+      continue;
+    }
+    const posKey = `${match.index}:${match.index + rawValue.length}`;
+    matchedPositions.add(posKey);
+    matchedPositions.add(`value:${value.toLowerCase()}`);
+    literals.push({
+      value,
+      rawValue,
+      confidence: "high",
+      detectionMethod: method,
+      inferredType: inferTypeFromValue(value)
+    });
+    replacements.push({
+      start: match.index,
+      end: match.index + rawValue.length,
+      text: ""
+    });
+  }
+  replacements.sort((a, b) => b.start - a.start).forEach((r) => {
+    remainingQuery = remainingQuery.slice(0, r.start) + r.text + remainingQuery.slice(r.end);
+  });
+  return { literals, remainingQuery };
+}
+function extractImplicitLiterals(query, matchedPositions) {
+  const literals = [];
+  const seenValues = new Set;
+  for (const patternDef of IMPLICIT_PATTERNS) {
+    patternDef.pattern.lastIndex = 0;
+    let match;
+    while ((match = patternDef.pattern.exec(query)) !== null) {
+      const value = match[1];
+      if (patternDef.minLength && value.length < patternDef.minLength) {
+        continue;
+      }
+      const posKey = `${match.index}:${match.index + value.length}`;
+      if (matchedPositions.has(posKey)) {
+        continue;
+      }
+      if (matchedPositions.has(`value:${value.toLowerCase()}`)) {
+        continue;
+      }
+      const lowerValue = value.toLowerCase();
+      if (seenValues.has(lowerValue)) {
+        continue;
+      }
+      seenValues.add(lowerValue);
+      if (isCommonWord(value)) {
+        continue;
+      }
+      literals.push({
+        value,
+        rawValue: value,
+        confidence: patternDef.confidence,
+        detectionMethod: "implicit-casing",
+        inferredType: patternDef.inferredType
+      });
+    }
+  }
+  return literals;
+}
+function inferTypeFromValue(value) {
+  if (/^[A-Z][a-z]+(?:[A-Z][a-z0-9]*)+$/.test(value)) {
+    return "className";
+  }
+  if (/^[a-z][a-z0-9]*(?:[A-Z][a-zA-Z0-9]*)+$/.test(value)) {
+    return "functionName";
+  }
+  if (/^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+$/.test(value)) {
+    return "variableName";
+  }
+  if (/^[a-z][a-z0-9]*(?:_[a-z0-9]+)+$/.test(value)) {
+    return "identifier";
+  }
+  if (/^[a-z][a-z0-9]*(?:-[a-z0-9]+)+$/.test(value)) {
+    return "packageName";
+  }
+  return;
+}
+function isCommonWord(word) {
+  const commonWords = new Set([
+    "find",
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "what",
+    "where",
+    "when",
+    "how",
+    "why",
+    "which",
+    "who",
+    "this",
+    "that",
+    "these",
+    "those",
+    "and",
+    "or",
+    "but",
+    "for",
+    "with",
+    "from",
+    "to",
+    "in",
+    "on",
+    "at",
+    "by",
+    "of",
+    "all",
+    "any",
+    "some",
+    "get",
+    "set",
+    "new",
+    "class",
+    "function",
+    "const",
+    "let",
+    "var",
+    "type",
+    "interface",
+    "import",
+    "export",
+    "default",
+    "return",
+    "async",
+    "await",
+    "null",
+    "undefined",
+    "true",
+    "false"
+  ]);
+  return commonWords.has(word.toLowerCase());
+}
+var IMPLICIT_PATTERNS;
+var init_queryLiteralParser = __esm(() => {
+  IMPLICIT_PATTERNS = [
+    {
+      pattern: /\b([A-Z][a-z]+(?:[A-Z][a-z0-9]*)+)\b/g,
+      confidence: "medium",
+      inferredType: "className",
+      minLength: 3
+    },
+    {
+      pattern: /\b([a-z][a-z0-9]*(?:[A-Z][a-zA-Z0-9]*)+)\b/g,
+      confidence: "medium",
+      inferredType: "functionName",
+      minLength: 3
+    },
+    {
+      pattern: /\b([A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+)\b/g,
+      confidence: "medium",
+      inferredType: "variableName",
+      minLength: 3
+    },
+    {
+      pattern: /\b([a-z][a-z0-9]*(?:_[a-z0-9]+)+)\b/g,
+      confidence: "low",
+      inferredType: "identifier",
+      minLength: 3
+    },
+    {
+      pattern: /(?<![/:.])\b([a-z][a-z0-9]*(?:-[a-z0-9]+)+)\b(?![/:])/g,
+      confidence: "low",
+      inferredType: "packageName",
+      minLength: 3
+    }
+  ];
+});
+
+// src/domain/services/literalExtractor.ts
+function extractLiterals(chunk) {
+  const literals = [];
+  if (chunk.name) {
+    const literalType = CHUNK_TYPE_TO_LITERAL_TYPE[chunk.type] || "identifier";
+    literals.push({
+      value: chunk.name,
+      type: literalType,
+      matchType: "definition"
+    });
+  }
+  return literals;
+}
+var CHUNK_TYPE_TO_LITERAL_TYPE;
+var init_literalExtractor = __esm(() => {
+  CHUNK_TYPE_TO_LITERAL_TYPE = {
+    class: "className",
+    function: "functionName",
+    interface: "interfaceName",
+    type: "typeName",
+    enum: "enumName",
+    variable: "variableName"
+  };
+});
+
+// src/domain/services/literalScorer.ts
+function calculateLiteralMultiplier(matchType, confidence) {
+  return LITERAL_SCORING_CONSTANTS.MULTIPLIERS[matchType][confidence];
+}
+function calculateMaxMultiplier(matches) {
+  if (!matches || matches.length === 0) {
+    return 1;
+  }
+  return Math.max(...matches.map((m) => calculateLiteralMultiplier(m.indexedLiteral.matchType, m.queryLiteral.confidence)));
+}
+function calculateLiteralContribution(matches, hasSemanticOrBm25) {
+  if (!matches || matches.length === 0) {
+    return {
+      multiplier: 1,
+      literalOnly: false,
+      matchCount: 0
+    };
+  }
+  let bestMatch = null;
+  let bestMultiplier = 0;
+  for (const match of matches) {
+    const mult = calculateLiteralMultiplier(match.indexedLiteral.matchType, match.queryLiteral.confidence);
+    if (mult > bestMultiplier) {
+      bestMultiplier = mult;
+      bestMatch = match;
+    }
+  }
+  return {
+    multiplier: bestMultiplier,
+    literalOnly: !hasSemanticOrBm25,
+    bestMatchType: bestMatch?.indexedLiteral.matchType,
+    bestConfidence: bestMatch?.queryLiteral.confidence,
+    matchCount: matches.length
+  };
+}
+function applyLiteralBoost(baseScore, matches, hasSemanticOrBm25) {
+  if (!matches || matches.length === 0) {
+    return baseScore;
+  }
+  const multiplier = calculateMaxMultiplier(matches);
+  if (!hasSemanticOrBm25) {
+    return LITERAL_SCORING_CONSTANTS.BASE_SCORE * multiplier;
+  }
+  return baseScore * multiplier;
+}
+var LITERAL_SCORING_CONSTANTS;
+var init_literalScorer = __esm(() => {
+  LITERAL_SCORING_CONSTANTS = {
+    BASE_SCORE: 0.5,
+    MULTIPLIERS: {
+      definition: { high: 2.5, medium: 2, low: 1.5 },
+      reference: { high: 2, medium: 1.5, low: 1.3 },
+      import: { high: 1.5, medium: 1.3, low: 1.1 }
+    }
+  };
+});
+
 // src/domain/services/index.ts
 var init_services = __esm(() => {
   init_keywords();
   init_queryIntent();
+  init_queryLiteralParser();
+  init_literalExtractor();
+  init_literalScorer();
 });
 
 // src/modules/language/typescript/parseCode.ts
@@ -2983,10 +3276,158 @@ var init_symbolicIndex = __esm(() => {
   init_keywords();
 });
 
+// src/infrastructure/storage/literalIndex.ts
+import * as fs4 from "fs/promises";
+import * as path9 from "path";
+
+class LiteralIndex {
+  indexPath;
+  moduleId;
+  entries = new Map;
+  static VERSION = "1.0.0";
+  constructor(indexDir, moduleId) {
+    this.indexPath = path9.join(indexDir, "index", moduleId, "literals");
+    this.moduleId = moduleId;
+  }
+  async initialize() {
+    try {
+      await this.load();
+    } catch {
+      this.entries = new Map;
+    }
+  }
+  addLiterals(chunkId, filepath, literals) {
+    for (const literal of literals) {
+      const key = literal.value.toLowerCase();
+      const existingEntries = this.entries.get(key) || [];
+      const existingIndex = existingEntries.findIndex((e) => e.chunkId === chunkId);
+      const newEntry = {
+        chunkId,
+        filepath,
+        originalCasing: literal.value,
+        type: literal.type,
+        matchType: literal.matchType
+      };
+      if (existingIndex >= 0) {
+        const existing = existingEntries[existingIndex];
+        if (shouldReplaceMatchType(existing.matchType, literal.matchType)) {
+          existingEntries[existingIndex] = newEntry;
+        }
+      } else {
+        existingEntries.push(newEntry);
+      }
+      this.entries.set(key, existingEntries);
+    }
+  }
+  removeChunk(chunkId) {
+    for (const [key, entries] of this.entries) {
+      const filtered = entries.filter((e) => e.chunkId !== chunkId);
+      if (filtered.length === 0) {
+        this.entries.delete(key);
+      } else if (filtered.length !== entries.length) {
+        this.entries.set(key, filtered);
+      }
+    }
+  }
+  findMatches(queryLiterals) {
+    const matches = [];
+    for (const queryLiteral of queryLiterals) {
+      const key = queryLiteral.value.toLowerCase();
+      const entries = this.entries.get(key);
+      if (!entries) {
+        continue;
+      }
+      for (const entry of entries) {
+        const exactMatch = entry.originalCasing === queryLiteral.value;
+        matches.push({
+          queryLiteral,
+          indexedLiteral: {
+            value: entry.originalCasing,
+            type: entry.type,
+            matchType: entry.matchType
+          },
+          chunkId: entry.chunkId,
+          filepath: entry.filepath,
+          exactMatch
+        });
+      }
+    }
+    return matches;
+  }
+  getChunksForLiteral(literal) {
+    const key = literal.toLowerCase();
+    const entries = this.entries.get(key);
+    return entries ? entries.map((e) => e.chunkId) : [];
+  }
+  async save() {
+    await fs4.mkdir(this.indexPath, { recursive: true });
+    const data = {
+      version: LiteralIndex.VERSION,
+      entries: Object.fromEntries(this.entries)
+    };
+    const indexFile = path9.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 content = await fs4.readFile(indexFile, "utf-8");
+    const data = JSON.parse(content);
+    if (data.version !== LiteralIndex.VERSION) {
+      console.warn(`Literal index version mismatch: expected ${LiteralIndex.VERSION}, got ${data.version}`);
+    }
+    this.entries = new Map(Object.entries(data.entries));
+  }
+  async exists() {
+    try {
+      const indexFile = path9.join(this.indexPath, "_index.json");
+      await fs4.access(indexFile);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  clear() {
+    this.entries.clear();
+  }
+  get size() {
+    return this.entries.size;
+  }
+  get totalMappings() {
+    let count = 0;
+    for (const entries of this.entries.values()) {
+      count += entries.length;
+    }
+    return count;
+  }
+  getAllLiterals() {
+    return Array.from(this.entries.keys());
+  }
+  buildMatchMap(queryLiterals) {
+    const matches = this.findMatches(queryLiterals);
+    const matchMap = new Map;
+    for (const match of matches) {
+      const existing = matchMap.get(match.chunkId) || [];
+      existing.push(match);
+      matchMap.set(match.chunkId, existing);
+    }
+    return matchMap;
+  }
+}
+function shouldReplaceMatchType(existing, incoming) {
+  const priority = {
+    definition: 3,
+    reference: 2,
+    import: 1
+  };
+  return priority[incoming] > priority[existing];
+}
+var init_literalIndex = () => {};
+
 // src/infrastructure/storage/index.ts
 var init_storage = __esm(() => {
   init_fileIndexStorage();
   init_symbolicIndex();
+  init_literalIndex();
 });
 
 // src/modules/language/typescript/index.ts
@@ -2999,9 +3440,9 @@ __export(exports_typescript, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K2,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE2
 });
-import * as path9 from "path";
+import * as path10 from "path";
 function isTypeScriptFile(filepath) {
-  const ext = path9.extname(filepath).toLowerCase();
+  const ext = path10.extname(filepath).toLowerCase();
   return TYPESCRIPT_EXTENSIONS.includes(ext);
 }
 function calculateChunkTypeBoost(chunk) {
@@ -3036,7 +3477,9 @@ class TypeScriptModule {
   }
   embeddingConfig = null;
   symbolicIndex = null;
+  literalIndex = null;
   pendingSummaries = new Map;
+  pendingLiterals = new Map;
   rootDir = "";
   logger = undefined;
   async initialize(config) {
@@ -3050,6 +3493,7 @@ class TypeScriptModule {
     }
     configureEmbeddings(this.embeddingConfig);
     this.pendingSummaries.clear();
+    this.pendingLiterals.clear();
   }
   async indexFile(filepath, content, ctx) {
     if (!isTypeScriptFile(filepath)) {
@@ -3109,6 +3553,17 @@ class TypeScriptModule {
       }
     };
     this.pendingSummaries.set(filepath, fileSummary);
+    for (const chunk of chunks) {
+      const literals = extractLiterals(chunk);
+      if (literals.length > 0) {
+        const existing = this.pendingLiterals.get(chunk.id);
+        if (existing) {
+          existing.literals.push(...literals);
+        } else {
+          this.pendingLiterals.set(chunk.id, { filepath, literals });
+        }
+      }
+    }
     return {
       filepath,
       lastModified: stats.lastModified,
@@ -3126,7 +3581,14 @@ class TypeScriptModule {
     }
     this.symbolicIndex.buildBM25Index();
     await this.symbolicIndex.save();
+    this.literalIndex = new LiteralIndex(indexDir, this.id);
+    await this.literalIndex.initialize();
+    for (const [chunkId, { filepath, literals }] of this.pendingLiterals) {
+      this.literalIndex.addLiterals(chunkId, filepath, literals);
+    }
+    await this.literalIndex.save();
     this.pendingSummaries.clear();
+    this.pendingLiterals.clear();
   }
   async search(query, ctx, options = {}) {
     const {
@@ -3134,8 +3596,15 @@ class TypeScriptModule {
       minScore = DEFAULT_MIN_SCORE2,
       filePatterns
     } = options;
+    const { literals: queryLiterals, remainingQuery } = parseQueryLiterals(query);
     const indexDir = getRaggrepDir(ctx.rootDir, ctx.config);
     const symbolicIndex = new SymbolicIndex(indexDir, this.id);
+    const literalIndex = new LiteralIndex(indexDir, this.id);
+    let literalMatchMap = new Map;
+    try {
+      await literalIndex.initialize();
+      literalMatchMap = literalIndex.buildMatchMap(queryLiterals);
+    } catch {}
     let allFiles;
     try {
       await symbolicIndex.initialize();
@@ -3155,7 +3624,8 @@ class TypeScriptModule {
         });
       });
     }
-    const queryEmbedding = await getEmbedding(query);
+    const semanticQuery = remainingQuery.trim() || query;
+    const queryEmbedding = await getEmbedding(semanticQuery);
     const bm25Index = new BM25Index;
     const allChunksData = [];
     for (const filepath of filesToSearch) {
@@ -3189,14 +3659,14 @@ class TypeScriptModule {
       const summary = symbolicIndex.getFileSummary(filepath);
       if (summary?.pathContext) {
         let boost = 0;
-        const ctx2 = summary.pathContext;
-        if (ctx2.domain && queryTerms.some((t) => ctx2.domain.includes(t) || t.includes(ctx2.domain))) {
+        const pathCtx = summary.pathContext;
+        if (pathCtx.domain && queryTerms.some((t) => pathCtx.domain.includes(t) || t.includes(pathCtx.domain))) {
           boost += 0.1;
         }
-        if (ctx2.layer && queryTerms.some((t) => ctx2.layer.includes(t) || t.includes(ctx2.layer))) {
+        if (pathCtx.layer && queryTerms.some((t) => pathCtx.layer.includes(t) || t.includes(pathCtx.layer))) {
           boost += 0.05;
         }
-        const segmentMatch = ctx2.segments.some((seg) => queryTerms.some((t) => seg.toLowerCase().includes(t) || t.includes(seg.toLowerCase())));
+        const segmentMatch = pathCtx.segments.some((seg) => queryTerms.some((t) => seg.toLowerCase().includes(t) || t.includes(seg.toLowerCase())));
         if (segmentMatch) {
           boost += 0.05;
         }
@@ -3204,6 +3674,7 @@ class TypeScriptModule {
       }
     }
     const results = [];
+    const processedChunkIds = new Set;
     for (const { filepath, chunk, embedding } of allChunksData) {
       const semanticScore = cosineSimilarity(queryEmbedding, embedding);
       const bm25Score = bm25Scores.get(chunk.id) || 0;
@@ -3211,13 +3682,18 @@ class TypeScriptModule {
       const fileTypeBoost = calculateFileTypeBoost(filepath, queryTerms);
       const chunkTypeBoost = calculateChunkTypeBoost(chunk);
       const exportBoost = calculateExportBoost(chunk);
-      const totalBoost = pathBoost + fileTypeBoost + chunkTypeBoost + exportBoost;
-      const hybridScore = SEMANTIC_WEIGHT * semanticScore + BM25_WEIGHT * bm25Score + totalBoost;
-      if (hybridScore >= minScore || bm25Score > 0.3) {
+      const additiveBoost = pathBoost + fileTypeBoost + chunkTypeBoost + exportBoost;
+      const baseScore = SEMANTIC_WEIGHT * semanticScore + BM25_WEIGHT * bm25Score;
+      const literalMatches = literalMatchMap.get(chunk.id) || [];
+      const literalContribution = calculateLiteralContribution(literalMatches, true);
+      const boostedScore = applyLiteralBoost(baseScore, literalMatches, true);
+      const finalScore = boostedScore + additiveBoost;
+      processedChunkIds.add(chunk.id);
+      if (finalScore >= minScore || bm25Score > 0.3 || literalMatches.length > 0) {
         results.push({
           filepath,
           chunk,
-          score: hybridScore,
+          score: finalScore,
           moduleId: this.id,
           context: {
             semanticScore,
@@ -3225,7 +3701,78 @@ class TypeScriptModule {
             pathBoost,
             fileTypeBoost,
             chunkTypeBoost,
-            exportBoost
+            exportBoost,
+            literalMultiplier: literalContribution.multiplier,
+            literalMatchType: literalContribution.bestMatchType,
+            literalConfidence: literalContribution.bestConfidence,
+            literalMatchCount: literalContribution.matchCount
+          }
+        });
+      }
+    }
+    const literalOnlyFiles = new Map;
+    for (const [chunkId, matches] of literalMatchMap) {
+      if (processedChunkIds.has(chunkId)) {
+        continue;
+      }
+      const filepath = matches[0]?.filepath;
+      if (!filepath)
+        continue;
+      const existing = literalOnlyFiles.get(filepath) || [];
+      existing.push(...matches);
+      literalOnlyFiles.set(filepath, existing);
+    }
+    for (const [filepath, matches] of literalOnlyFiles) {
+      const fileIndex = await ctx.loadFileIndex(filepath);
+      if (!fileIndex)
+        continue;
+      const moduleData = fileIndex.moduleData;
+      const chunkMatches = new Map;
+      for (const match of matches) {
+        const existing = chunkMatches.get(match.chunkId) || [];
+        existing.push(match);
+        chunkMatches.set(match.chunkId, existing);
+      }
+      for (const [chunkId, chunkLiteralMatches] of chunkMatches) {
+        if (processedChunkIds.has(chunkId))
+          continue;
+        const chunkIndex = fileIndex.chunks.findIndex((c) => c.id === chunkId);
+        if (chunkIndex === -1)
+          continue;
+        const chunk = fileIndex.chunks[chunkIndex];
+        const embedding = moduleData?.embeddings?.[chunkIndex];
+        let semanticScore = 0;
+        if (embedding) {
+          semanticScore = cosineSimilarity(queryEmbedding, embedding);
+        }
+        const bm25Score = bm25Scores.get(chunkId) || 0;
+        const pathBoost = pathBoosts.get(filepath) || 0;
+        const fileTypeBoost = calculateFileTypeBoost(filepath, queryTerms);
+        const chunkTypeBoost = calculateChunkTypeBoost(chunk);
+        const exportBoost = calculateExportBoost(chunk);
+        const additiveBoost = pathBoost + fileTypeBoost + chunkTypeBoost + exportBoost;
+        const literalContribution = calculateLiteralContribution(chunkLiteralMatches, false);
+        const baseScore = semanticScore > 0 ? SEMANTIC_WEIGHT * semanticScore + BM25_WEIGHT * bm25Score : LITERAL_SCORING_CONSTANTS.BASE_SCORE;
+        const boostedScore = applyLiteralBoost(baseScore, chunkLiteralMatches, semanticScore > 0);
+        const finalScore = boostedScore + additiveBoost;
+        processedChunkIds.add(chunkId);
+        results.push({
+          filepath,
+          chunk,
+          score: finalScore,
+          moduleId: this.id,
+          context: {
+            semanticScore,
+            bm25Score,
+            pathBoost,
+            fileTypeBoost,
+            chunkTypeBoost,
+            exportBoost,
+            literalMultiplier: literalContribution.multiplier,
+            literalMatchType: literalContribution.bestMatchType,
+            literalConfidence: literalContribution.bestConfidence,
+            literalMatchCount: literalContribution.matchCount,
+            literalOnly: true
           }
         });
       }
@@ -3241,16 +3788,16 @@ class TypeScriptModule {
     while ((match = importRegex.exec(content)) !== null) {
       const importPath = match[1];
       if (importPath.startsWith(".")) {
-        const dir = path9.dirname(filepath);
-        const resolved = path9.normalize(path9.join(dir, importPath));
+        const dir = path10.dirname(filepath);
+        const resolved = path10.normalize(path10.join(dir, importPath));
         references.push(resolved);
       }
     }
     while ((match = requireRegex.exec(content)) !== null) {
       const importPath = match[1];
       if (importPath.startsWith(".")) {
-        const dir = path9.dirname(filepath);
-        const resolved = path9.normalize(path9.join(dir, importPath));
+        const dir = path10.dirname(filepath);
+        const resolved = path10.normalize(path10.join(dir, importPath));
         references.push(resolved);
       }
     }
@@ -3287,9 +3834,9 @@ __export(exports_json, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K3,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE3
 });
-import * as path10 from "path";
+import * as path11 from "path";
 function isJsonFile(filepath) {
-  const ext = path10.extname(filepath).toLowerCase();
+  const ext = path11.extname(filepath).toLowerCase();
   return JSON_EXTENSIONS.includes(ext);
 }
 function extractJsonKeys(obj, prefix = "") {
@@ -3370,7 +3917,7 @@ class JsonModule {
       return null;
     }
     const chunkContents = textChunks.map((c) => {
-      const filename = path10.basename(filepath);
+      const filename = path11.basename(filepath);
       return `${filename}: ${c.content}`;
     });
     const embeddings = await getEmbeddings(chunkContents);
@@ -3521,9 +4068,9 @@ __export(exports_markdown, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K4,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE4
 });
-import * as path11 from "path";
+import * as path12 from "path";
 function isMarkdownFile(filepath) {
-  const ext = path11.extname(filepath).toLowerCase();
+  const ext = path12.extname(filepath).toLowerCase();
   return MARKDOWN_EXTENSIONS.includes(ext);
 }
 function parseMarkdownSections(content) {
@@ -3650,7 +4197,7 @@ class MarkdownModule {
       return null;
     }
     const chunkContents = sections.map((s) => {
-      const filename = path11.basename(filepath);
+      const filename = path12.basename(filepath);
       const headingContext = s.heading ? `${s.heading}: ` : "";
       return `${filename} ${headingContext}${s.content}`;
     });
@@ -3837,15 +4384,15 @@ var init_registry = __esm(() => {
 });
 
 // src/infrastructure/introspection/projectDetector.ts
-import * as path12 from "path";
-import * as fs4 from "fs/promises";
+import * as path13 from "path";
+import * as fs5 from "fs/promises";
 async function scanForPackageJsons(rootDir, currentDir = "", depth = 0) {
   if (depth > MAX_SCAN_DEPTH)
     return [];
   const results = [];
-  const fullDir = currentDir ? path12.join(rootDir, currentDir) : rootDir;
+  const fullDir = currentDir ? path13.join(rootDir, currentDir) : rootDir;
   try {
-    const entries = await fs4.readdir(fullDir, { withFileTypes: true });
+    const entries = await fs5.readdir(fullDir, { withFileTypes: true });
     const hasPackageJson = entries.some((e) => e.isFile() && e.name === "package.json");
     if (hasPackageJson && currentDir) {
       const info = await parsePackageJson(rootDir, currentDir);
@@ -3866,10 +4413,10 @@ async function scanForPackageJsons(rootDir, currentDir = "", depth = 0) {
 }
 async function parsePackageJson(rootDir, relativePath) {
   try {
-    const packageJsonPath = path12.join(rootDir, relativePath, "package.json");
-    const content = await fs4.readFile(packageJsonPath, "utf-8");
+    const packageJsonPath = path13.join(rootDir, relativePath, "package.json");
+    const content = await fs5.readFile(packageJsonPath, "utf-8");
     const pkg = JSON.parse(content);
-    const name = pkg.name || path12.basename(relativePath);
+    const name = pkg.name || path13.basename(relativePath);
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     let type = "unknown";
     if (deps["next"] || deps["react"] || deps["vue"] || deps["svelte"]) {
@@ -3905,7 +4452,7 @@ async function detectProjectStructure(rootDir) {
   const projectMap = new Map;
   let isMonorepo = false;
   try {
-    const entries = await fs4.readdir(rootDir, { withFileTypes: true });
+    const entries = await fs5.readdir(rootDir, { withFileTypes: true });
     const dirNames = entries.filter((e) => e.isDirectory()).map((e) => e.name);
     const monorepoPatterns = ["apps", "packages", "libs", "services"];
     const hasMonorepoStructure = monorepoPatterns.some((p) => dirNames.includes(p));
@@ -3914,9 +4461,9 @@ async function detectProjectStructure(rootDir) {
       for (const pattern of monorepoPatterns) {
         if (!dirNames.includes(pattern))
           continue;
-        const patternDir = path12.join(rootDir, pattern);
+        const patternDir = path13.join(rootDir, pattern);
         try {
-          const subDirs = await fs4.readdir(patternDir, { withFileTypes: true });
+          const subDirs = await fs5.readdir(patternDir, { withFileTypes: true });
           for (const subDir of subDirs) {
             if (!subDir.isDirectory())
               continue;
@@ -3945,8 +4492,8 @@ async function detectProjectStructure(rootDir) {
     }
     let rootType = "unknown";
     try {
-      const rootPkgPath = path12.join(rootDir, "package.json");
-      const rootPkg = JSON.parse(await fs4.readFile(rootPkgPath, "utf-8"));
+      const rootPkgPath = path13.join(rootDir, "package.json");
+      const rootPkg = JSON.parse(await fs5.readFile(rootPkgPath, "utf-8"));
       if (rootPkg.workspaces)
         isMonorepo = true;
       const deps = { ...rootPkg.dependencies, ...rootPkg.devDependencies };
@@ -3985,8 +4532,8 @@ var init_projectDetector = __esm(() => {
 });
 
 // src/infrastructure/introspection/IntrospectionIndex.ts
-import * as path13 from "path";
-import * as fs5 from "fs/promises";
+import * as path14 from "path";
+import * as fs6 from "fs/promises";
 
 class IntrospectionIndex {
   rootDir;
@@ -3999,8 +4546,8 @@ class IntrospectionIndex {
   async initialize() {
     this.structure = await detectProjectStructure(this.rootDir);
     try {
-      const configPath = path13.join(this.rootDir, ".raggrep", "config.json");
-      const configContent = await fs5.readFile(configPath, "utf-8");
+      const configPath = path14.join(this.rootDir, ".raggrep", "config.json");
+      const configContent = await fs6.readFile(configPath, "utf-8");
       const config = JSON.parse(configContent);
       this.config = config.introspection || {};
     } catch {}
@@ -4039,28 +4586,28 @@ class IntrospectionIndex {
     }
   }
   async save(config) {
-    const introDir = path13.join(getRaggrepDir(this.rootDir, config), "introspection");
-    await fs5.mkdir(introDir, { recursive: true });
-    const projectPath = path13.join(introDir, "_project.json");
-    await fs5.writeFile(projectPath, JSON.stringify({
+    const introDir = path14.join(getRaggrepDir(this.rootDir, config), "introspection");
+    await fs6.mkdir(introDir, { recursive: true });
+    const projectPath = path14.join(introDir, "_project.json");
+    await fs6.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 = path13.join(introDir, "files", filepath.replace(/\.[^.]+$/, ".json"));
-      await fs5.mkdir(path13.dirname(introFilePath), { recursive: true });
-      await fs5.writeFile(introFilePath, JSON.stringify(intro, null, 2));
+      const introFilePath = path14.join(introDir, "files", filepath.replace(/\.[^.]+$/, ".json"));
+      await fs6.mkdir(path14.dirname(introFilePath), { recursive: true });
+      await fs6.writeFile(introFilePath, JSON.stringify(intro, null, 2));
     }
   }
   async load(config) {
-    const introDir = path13.join(getRaggrepDir(this.rootDir, config), "introspection");
+    const introDir = path14.join(getRaggrepDir(this.rootDir, config), "introspection");
     try {
-      const projectPath = path13.join(introDir, "_project.json");
-      const projectContent = await fs5.readFile(projectPath, "utf-8");
+      const projectPath = path14.join(introDir, "_project.json");
+      const projectContent = await fs6.readFile(projectPath, "utf-8");
       const projectData = JSON.parse(projectContent);
       this.structure = projectData.structure;
-      await this.loadFilesRecursive(path13.join(introDir, "files"), "");
+      await this.loadFilesRecursive(path14.join(introDir, "files"), "");
     } catch {
       this.structure = null;
       this.files.clear();
@@ -4068,14 +4615,14 @@ class IntrospectionIndex {
   }
   async loadFilesRecursive(basePath, prefix) {
     try {
-      const entries = await fs5.readdir(basePath, { withFileTypes: true });
+      const entries = await fs6.readdir(basePath, { withFileTypes: true });
       for (const entry of entries) {
-        const entryPath = path13.join(basePath, entry.name);
+        const entryPath = path14.join(basePath, entry.name);
         const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
         if (entry.isDirectory()) {
           await this.loadFilesRecursive(entryPath, relativePath);
         } else if (entry.name.endsWith(".json")) {
-          const content = await fs5.readFile(entryPath, "utf-8");
+          const content = await fs6.readFile(entryPath, "utf-8");
           const intro = JSON.parse(content);
           this.files.set(intro.filepath, intro);
         }
@@ -4101,7 +4648,7 @@ var init_introspection2 = __esm(() => {
 
 // src/app/indexer/watcher.ts
 import { watch } from "chokidar";
-import * as path14 from "path";
+import * as path15 from "path";
 async function watchDirectory(rootDir, options = {}) {
   const {
     debounceMs = DEFAULT_DEBOUNCE_MS,
@@ -4112,7 +4659,7 @@ async function watchDirectory(rootDir, options = {}) {
     onFileChange,
     onError
   } = options;
-  rootDir = path14.resolve(rootDir);
+  rootDir = path15.resolve(rootDir);
   const config = await loadConfig(rootDir);
   const indexLocation = getIndexLocation(rootDir);
   const validExtensions = new Set(config.extensions);
@@ -4122,7 +4669,7 @@ async function watchDirectory(rootDir, options = {}) {
     "**/.git/**"
   ];
   function shouldWatchFile(filepath) {
-    const ext = path14.extname(filepath);
+    const ext = path15.extname(filepath);
     return validExtensions.has(ext);
   }
   let isRunning = true;
@@ -4204,7 +4751,7 @@ async function watchDirectory(rootDir, options = {}) {
   function handleFileEvent(event, filepath) {
     if (!isRunning)
       return;
-    const relativePath = path14.relative(rootDir, filepath);
+    const relativePath = path15.relative(rootDir, filepath);
     if (!shouldWatchFile(filepath)) {
       return;
     }
@@ -4282,8 +4829,8 @@ __export(exports_indexer, {
   cleanupIndex: () => cleanupIndex
 });
 import { glob } from "glob";
-import * as fs6 from "fs/promises";
-import * as path15 from "path";
+import * as fs7 from "fs/promises";
+import * as path16 from "path";
 import * as os3 from "os";
 async function parallelMap(items, processor, concurrency) {
   const results = new Array(items.length);
@@ -4326,7 +4873,7 @@ async function indexDirectory(rootDir, options = {}) {
   const quiet = options.quiet ?? false;
   const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
   const logger = options.logger ? options.logger : quiet ? createSilentLogger() : createLogger({ verbose });
-  rootDir = path15.resolve(rootDir);
+  rootDir = path16.resolve(rootDir);
   const location = getIndexLocation(rootDir);
   logger.info(`Indexing directory: ${rootDir}`);
   logger.info(`Index location: ${location.indexDir}`);
@@ -4378,12 +4925,12 @@ async function indexDirectory(rootDir, options = {}) {
         rootDir,
         config,
         readFile: async (filepath) => {
-          const fullPath = path15.isAbsolute(filepath) ? filepath : path15.join(rootDir, filepath);
-          return fs6.readFile(fullPath, "utf-8");
+          const fullPath = path16.isAbsolute(filepath) ? filepath : path16.join(rootDir, filepath);
+          return fs7.readFile(fullPath, "utf-8");
         },
         getFileStats: async (filepath) => {
-          const fullPath = path15.isAbsolute(filepath) ? filepath : path15.join(rootDir, filepath);
-          const stats = await fs6.stat(fullPath);
+          const fullPath = path16.isAbsolute(filepath) ? filepath : path16.join(rootDir, filepath);
+          const stats = await fs7.stat(fullPath);
           return { lastModified: stats.mtime.toISOString() };
         }
       };
@@ -4408,7 +4955,7 @@ async function isIndexVersionCompatible(rootDir) {
   const config = await loadConfig(rootDir);
   const globalManifestPath = getGlobalManifestPath(rootDir, config);
   try {
-    const content = await fs6.readFile(globalManifestPath, "utf-8");
+    const content = await fs7.readFile(globalManifestPath, "utf-8");
     const manifest = JSON.parse(content);
     return manifest.version === INDEX_SCHEMA_VERSION;
   } catch {
@@ -4418,11 +4965,11 @@ async function isIndexVersionCompatible(rootDir) {
 async function deleteIndex(rootDir) {
   const indexDir = getRaggrepDir(rootDir);
   try {
-    await fs6.rm(indexDir, { recursive: true, force: true });
+    await fs7.rm(indexDir, { recursive: true, force: true });
   } catch {}
 }
 async function resetIndex(rootDir) {
-  rootDir = path15.resolve(rootDir);
+  rootDir = path16.resolve(rootDir);
   const status = await getIndexStatus(rootDir);
   if (!status.exists) {
     throw new Error(`No index found for ${rootDir}`);
@@ -4437,7 +4984,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
   const quiet = options.quiet ?? false;
   const logger = options.logger ? options.logger : quiet ? createSilentLogger() : createLogger({ verbose });
-  rootDir = path15.resolve(rootDir);
+  rootDir = path16.resolve(rootDir);
   const status = await getIndexStatus(rootDir);
   if (!status.exists) {
     logger.info(`No index found. Creating index...
@@ -4464,7 +5011,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
   const introspection = new IntrospectionIndex(rootDir);
   await introspection.initialize();
   const currentFiles = await findFiles(rootDir, config);
-  const currentFileSet = new Set(currentFiles.map((f) => path15.relative(rootDir, f)));
+  const currentFileSet = new Set(currentFiles.map((f) => path16.relative(rootDir, f)));
   let totalIndexed = 0;
   let totalRemoved = 0;
   let totalUnchanged = 0;
@@ -4494,13 +5041,13 @@ async function ensureIndexFresh(rootDir, options = {}) {
     }
     for (const filepath of filesToRemove) {
       logger.debug(`  Removing stale: ${filepath}`);
-      const indexFilePath = path15.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+      const indexFilePath = path16.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
       try {
-        await fs6.unlink(indexFilePath);
+        await fs7.unlink(indexFilePath);
       } catch {}
-      const symbolicFilePath = path15.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
+      const symbolicFilePath = path16.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
       try {
-        await fs6.unlink(symbolicFilePath);
+        await fs7.unlink(symbolicFilePath);
       } catch {}
       delete manifest.files[filepath];
       totalRemoved++;
@@ -4509,12 +5056,12 @@ async function ensureIndexFresh(rootDir, options = {}) {
       rootDir,
       config,
       readFile: async (filepath) => {
-        const fullPath = path15.isAbsolute(filepath) ? filepath : path15.join(rootDir, filepath);
-        return fs6.readFile(fullPath, "utf-8");
+        const fullPath = path16.isAbsolute(filepath) ? filepath : path16.join(rootDir, filepath);
+        return fs7.readFile(fullPath, "utf-8");
       },
       getFileStats: async (filepath) => {
-        const fullPath = path15.isAbsolute(filepath) ? filepath : path15.join(rootDir, filepath);
-        const stats = await fs6.stat(fullPath);
+        const fullPath = path16.isAbsolute(filepath) ? filepath : path16.join(rootDir, filepath);
+        const stats = await fs7.stat(fullPath);
         return { lastModified: stats.mtime.toISOString() };
       },
       getIntrospection: (filepath) => introspection.getFile(filepath)
@@ -4522,10 +5069,10 @@ async function ensureIndexFresh(rootDir, options = {}) {
     const totalFiles = currentFiles.length;
     for (let i = 0;i < currentFiles.length; i++) {
       const filepath = currentFiles[i];
-      const relativePath = path15.relative(rootDir, filepath);
+      const relativePath = path16.relative(rootDir, filepath);
       const progress = `[${i + 1}/${totalFiles}]`;
       try {
-        const stats = await fs6.stat(filepath);
+        const stats = await fs7.stat(filepath);
         const lastModified = stats.mtime.toISOString();
         const existingEntry = manifest.files[relativePath];
         if (existingEntry && existingEntry.lastModified === lastModified) {
@@ -4533,7 +5080,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
           continue;
         }
         logger.progress(`  ${progress} Indexing: ${relativePath}`);
-        const content = await fs6.readFile(filepath, "utf-8");
+        const content = await fs7.readFile(filepath, "utf-8");
         introspection.addFile(relativePath, content);
         const fileIndex = await module.indexFile(relativePath, content, ctx);
         if (fileIndex) {
@@ -4582,7 +5129,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) => path15.relative(rootDir, f)));
+  const currentFileSet = new Set(files.map((f) => path16.relative(rootDir, f)));
   const filesToRemove = [];
   for (const filepath of Object.keys(manifest.files)) {
     if (!currentFileSet.has(filepath)) {
@@ -4593,13 +5140,13 @@ 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 = path15.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+      const indexFilePath = path16.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
       try {
-        await fs6.unlink(indexFilePath);
+        await fs7.unlink(indexFilePath);
       } catch {}
-      const symbolicFilePath = path15.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
+      const symbolicFilePath = path16.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
       try {
-        await fs6.unlink(symbolicFilePath);
+        await fs7.unlink(symbolicFilePath);
       } catch {}
       delete manifest.files[filepath];
     }
@@ -4609,12 +5156,12 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
     rootDir,
     config,
     readFile: async (filepath) => {
-      const fullPath = path15.isAbsolute(filepath) ? filepath : path15.join(rootDir, filepath);
-      return fs6.readFile(fullPath, "utf-8");
+      const fullPath = path16.isAbsolute(filepath) ? filepath : path16.join(rootDir, filepath);
+      return fs7.readFile(fullPath, "utf-8");
     },
     getFileStats: async (filepath) => {
-      const fullPath = path15.isAbsolute(filepath) ? filepath : path15.join(rootDir, filepath);
-      const stats = await fs6.stat(fullPath);
+      const fullPath = path16.isAbsolute(filepath) ? filepath : path16.join(rootDir, filepath);
+      const stats = await fs7.stat(fullPath);
       return { lastModified: stats.mtime.toISOString() };
     },
     getIntrospection: (filepath) => introspection.getFile(filepath)
@@ -4622,9 +5169,9 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
   const totalFiles = files.length;
   let completedCount = 0;
   const processFile = async (filepath, _index) => {
-    const relativePath = path15.relative(rootDir, filepath);
+    const relativePath = path16.relative(rootDir, filepath);
     try {
-      const stats = await fs6.stat(filepath);
+      const stats = await fs7.stat(filepath);
       const lastModified = stats.mtime.toISOString();
       const existingEntry = manifest.files[relativePath];
       if (existingEntry && existingEntry.lastModified === lastModified) {
@@ -4632,7 +5179,7 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
         logger.debug(`  [${completedCount}/${totalFiles}] Skipped ${relativePath} (unchanged)`);
         return { relativePath, status: "skipped" };
       }
-      const content = await fs6.readFile(filepath, "utf-8");
+      const content = await fs7.readFile(filepath, "utf-8");
       introspection.addFile(relativePath, content);
       completedCount++;
       logger.progress(`  [${completedCount}/${totalFiles}] Processing: ${relativePath}`);
@@ -4700,7 +5247,7 @@ async function findFiles(rootDir, config) {
 async function loadModuleManifest(rootDir, moduleId, config) {
   const manifestPath = getModuleManifestPath(rootDir, moduleId, config);
   try {
-    const content = await fs6.readFile(manifestPath, "utf-8");
+    const content = await fs7.readFile(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {
@@ -4713,14 +5260,14 @@ async function loadModuleManifest(rootDir, moduleId, config) {
 }
 async function writeModuleManifest(rootDir, moduleId, manifest, config) {
   const manifestPath = getModuleManifestPath(rootDir, moduleId, config);
-  await fs6.mkdir(path15.dirname(manifestPath), { recursive: true });
-  await fs6.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+  await fs7.mkdir(path16.dirname(manifestPath), { recursive: true });
+  await fs7.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 }
 async function writeFileIndex(rootDir, moduleId, filepath, fileIndex, config) {
   const indexPath = getModuleIndexPath(rootDir, moduleId, config);
-  const indexFilePath = path15.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
-  await fs6.mkdir(path15.dirname(indexFilePath), { recursive: true });
-  await fs6.writeFile(indexFilePath, JSON.stringify(fileIndex, null, 2));
+  const indexFilePath = path16.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+  await fs7.mkdir(path16.dirname(indexFilePath), { recursive: true });
+  await fs7.writeFile(indexFilePath, JSON.stringify(fileIndex, null, 2));
 }
 async function updateGlobalManifest(rootDir, modules, config) {
   const manifestPath = getGlobalManifestPath(rootDir, config);
@@ -4729,13 +5276,13 @@ async function updateGlobalManifest(rootDir, modules, config) {
     lastUpdated: new Date().toISOString(),
     modules: modules.map((m) => m.id)
   };
-  await fs6.mkdir(path15.dirname(manifestPath), { recursive: true });
-  await fs6.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+  await fs7.mkdir(path16.dirname(manifestPath), { recursive: true });
+  await fs7.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 }
 async function cleanupIndex(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
   const logger = options.logger ?? createLogger({ verbose });
-  rootDir = path15.resolve(rootDir);
+  rootDir = path16.resolve(rootDir);
   logger.info(`Cleaning up index in: ${rootDir}`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -4765,9 +5312,9 @@ async function cleanupModuleIndex(rootDir, moduleId, config, logger) {
   const filesToRemove = [];
   const updatedFiles = {};
   for (const [filepath, entry] of Object.entries(manifest.files)) {
-    const fullPath = path15.join(rootDir, filepath);
+    const fullPath = path16.join(rootDir, filepath);
     try {
-      await fs6.access(fullPath);
+      await fs7.access(fullPath);
       updatedFiles[filepath] = entry;
       result.kept++;
     } catch {
@@ -4777,9 +5324,9 @@ async function cleanupModuleIndex(rootDir, moduleId, config, logger) {
     }
   }
   for (const filepath of filesToRemove) {
-    const indexFilePath = path15.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+    const indexFilePath = path16.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
     try {
-      await fs6.unlink(indexFilePath);
+      await fs7.unlink(indexFilePath);
     } catch {}
   }
   manifest.files = updatedFiles;
@@ -4790,16 +5337,16 @@ async function cleanupModuleIndex(rootDir, moduleId, config, logger) {
 }
 async function cleanupEmptyDirectories(dir) {
   try {
-    const entries = await fs6.readdir(dir, { withFileTypes: true });
+    const entries = await fs7.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const subDir = path15.join(dir, entry.name);
+        const subDir = path16.join(dir, entry.name);
         await cleanupEmptyDirectories(subDir);
       }
     }
-    const remainingEntries = await fs6.readdir(dir);
+    const remainingEntries = await fs7.readdir(dir);
     if (remainingEntries.length === 0) {
-      await fs6.rmdir(dir);
+      await fs7.rmdir(dir);
       return true;
     }
     return false;
@@ -4808,7 +5355,7 @@ async function cleanupEmptyDirectories(dir) {
   }
 }
 async function getIndexStatus(rootDir) {
-  rootDir = path15.resolve(rootDir);
+  rootDir = path16.resolve(rootDir);
   const config = await loadConfig(rootDir);
   const location = getIndexLocation(rootDir);
   const indexDir = location.indexDir;
@@ -4820,13 +5367,13 @@ async function getIndexStatus(rootDir) {
     totalFiles: 0
   };
   try {
-    await fs6.access(indexDir);
+    await fs7.access(indexDir);
   } catch {
     return status;
   }
   try {
     const globalManifestPath = getGlobalManifestPath(rootDir, config);
-    const content = await fs6.readFile(globalManifestPath, "utf-8");
+    const content = await fs7.readFile(globalManifestPath, "utf-8");
     const globalManifest = JSON.parse(content);
     status.exists = true;
     status.lastUpdated = globalManifest.lastUpdated;
@@ -4844,7 +5391,7 @@ async function getIndexStatus(rootDir) {
     }
   } catch {
     try {
-      const entries = await fs6.readdir(path15.join(indexDir, "index"));
+      const entries = await fs7.readdir(path16.join(indexDir, "index"));
       if (entries.length > 0) {
         status.exists = true;
         for (const entry of entries) {
@@ -4885,10 +5432,10 @@ __export(exports_search, {
   search: () => search,
   formatSearchResults: () => formatSearchResults
 });
-import * as fs7 from "fs/promises";
-import * as path16 from "path";
+import * as fs8 from "fs/promises";
+import * as path17 from "path";
 async function search(rootDir, query, options = {}) {
-  rootDir = path16.resolve(rootDir);
+  rootDir = path17.resolve(rootDir);
   const ensureFresh = options.ensureFresh ?? DEFAULT_SEARCH_OPTIONS.ensureFresh;
   if (ensureFresh) {
     await ensureIndexFresh(rootDir, { quiet: true });
@@ -4941,9 +5488,9 @@ function createSearchContext(rootDir, moduleId, config) {
     config,
     loadFileIndex: async (filepath) => {
       const hasExtension = /\.[^./]+$/.test(filepath);
-      const indexFilePath = hasExtension ? path16.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path16.join(indexPath, filepath + ".json");
+      const indexFilePath = hasExtension ? path17.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path17.join(indexPath, filepath + ".json");
       try {
-        const content = await fs7.readFile(indexFilePath, "utf-8");
+        const content = await fs8.readFile(indexFilePath, "utf-8");
         return JSON.parse(content);
       } catch {
         return null;
@@ -4953,7 +5500,7 @@ 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 relative4 = path16.relative(indexPath, f);
+        const relative4 = path17.relative(indexPath, f);
         return relative4.replace(/\.json$/, "");
       });
     }
@@ -4961,9 +5508,9 @@ function createSearchContext(rootDir, moduleId, config) {
 }
 async function traverseDirectory(dir, files, basePath) {
   try {
-    const entries = await fs7.readdir(dir, { withFileTypes: true });
+    const entries = await fs8.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path16.join(dir, entry.name);
+      const fullPath = path17.join(dir, entry.name);
       if (entry.isDirectory()) {
         await traverseDirectory(fullPath, files, basePath);
       } else if (entry.isFile()) {
@@ -4975,7 +5522,7 @@ async function traverseDirectory(dir, files, basePath) {
 async function loadGlobalManifest(rootDir, config) {
   const manifestPath = getGlobalManifestPath(rootDir, config);
   try {
-    const content = await fs7.readFile(manifestPath, "utf-8");
+    const content = await fs8.readFile(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -5041,7 +5588,7 @@ init_logger();
 // package.json
 var package_default = {
   name: "raggrep",
-  version: "0.6.1",
+  version: "0.7.0",
   description: "Local filesystem-based RAG system for codebases - semantic search using local embeddings",
   type: "module",
   main: "./dist/index.js",
@@ -5502,4 +6049,4 @@ Run 'raggrep <command> --help' for more information.
 }
 main();
 
-//# debugId=8FCF189E9FBCBFE264756E2164756E21
+//# debugId=4DE86C1D7DC4E21964756E2164756E21