raggrep 0.15.0 → 0.17.0

package/dist/cli/main.js

@@ -1,49 +1,89 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/infrastructure/embeddings/transformersEmbedding.ts
+// src/infrastructure/embeddings/modelCatalog.ts
+function getEmbeddingModelId(model) {
+  return EMBEDDING_MODEL_IDS[model];
+}
+function getEmbeddingDimension(model) {
+  return EMBEDDING_DIMENSIONS[model];
+}
+var EMBEDDING_MODEL_IDS, EMBEDDING_MODELS, EMBEDDING_DIMENSIONS;
+var init_modelCatalog = __esm(() => {
+  EMBEDDING_MODEL_IDS = {
+    "all-MiniLM-L6-v2": "Xenova/all-MiniLM-L6-v2",
+    "all-MiniLM-L12-v2": "Xenova/all-MiniLM-L12-v2",
+    "bge-small-en-v1.5": "Xenova/bge-small-en-v1.5",
+    "paraphrase-MiniLM-L3-v2": "Xenova/paraphrase-MiniLM-L3-v2",
+    "nomic-embed-text-v1.5": "nomic-ai/nomic-embed-text-v1.5"
+  };
+  EMBEDDING_MODELS = EMBEDDING_MODEL_IDS;
+  EMBEDDING_DIMENSIONS = {
+    "all-MiniLM-L6-v2": 384,
+    "all-MiniLM-L12-v2": 384,
+    "bge-small-en-v1.5": 384,
+    "paraphrase-MiniLM-L3-v2": 384,
+    "nomic-embed-text-v1.5": 768
+  };
+});
+
+// src/infrastructure/embeddings/embeddingPaths.ts
+import * as os from "os";
+import * as path from "path";
+var RAGGREP_MODEL_CACHE_DIR;
+var init_embeddingPaths = __esm(() => {
+  RAGGREP_MODEL_CACHE_DIR = path.join(os.homedir(), ".cache", "raggrep", "models");
+});
+
+// src/infrastructure/embeddings/modelCache.ts
+import * as fs from "fs/promises";
+import * as path2 from "path";
+async function isEmbeddingModelCached(model) {
+  const modelId = getEmbeddingModelId(model);
+  const onnxPath = path2.join(RAGGREP_MODEL_CACHE_DIR, modelId, "onnx", "model_quantized.onnx");
+  try {
+    await fs.access(onnxPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_modelCache = __esm(() => {
+  init_embeddingPaths();
+  init_modelCatalog();
+});
+
+// src/infrastructure/embeddings/xenovaEmbeddingProvider.ts
 import {
   pipeline,
   env
 } from "@xenova/transformers";
-import * as path from "path";
-import * as os from "os";
 
-class TransformersEmbeddingProvider {
-  pipeline = null;
+class XenovaTransformersEmbeddingProvider {
+  extractor = null;
   config;
   isInitializing = false;
   initPromise = null;
   constructor(config) {
     this.config = {
       model: config?.model ?? "bge-small-en-v1.5",
+      runtime: config?.runtime ?? "xenova",
       showProgress: config?.showProgress ?? false,
       logger: config?.logger
     };
@@ -51,14 +91,14 @@ class TransformersEmbeddingProvider {
   async initialize(config) {
     if (config) {
       if (config.model !== this.config.model) {
-        this.pipeline = null;
+        this.extractor = null;
       }
       this.config = { ...this.config, ...config };
     }
-    await this.ensurePipeline();
+    await this.ensureExtractor();
   }
-  async ensurePipeline() {
-    if (this.pipeline) {
+  async ensureExtractor() {
+    if (this.extractor) {
       return;
     }
     if (this.isInitializing && this.initPromise) {
@@ -66,14 +106,14 @@ class TransformersEmbeddingProvider {
     }
     this.isInitializing = true;
     this.initPromise = (async () => {
-      const modelId = EMBEDDING_MODELS[this.config.model];
+      const modelId = getEmbeddingModelId(this.config.model);
       const logger = this.config.logger;
       const showProgress = this.config.showProgress || !!logger;
-      const isCached = await isModelCached(this.config.model);
+      const cached = await isEmbeddingModelCached(this.config.model);
       let hasDownloads = false;
       try {
-        this.pipeline = await pipeline("feature-extraction", modelId, {
-          progress_callback: showProgress && !isCached ? (progress) => {
+        this.extractor = await pipeline("feature-extraction", modelId, {
+          progress_callback: showProgress && !cached ? (progress) => {
             if (progress.status === "progress" && progress.file) {
               if (!hasDownloads) {
                 hasDownloads = true;
@@ -82,7 +122,7 @@ class TransformersEmbeddingProvider {
                 } else {
                   console.log(`
   Loading embedding model: ${this.config.model}`);
-                  console.log(`  Cache: ${CACHE_DIR}`);
+                  console.log(`  Cache: ${RAGGREP_MODEL_CACHE_DIR}`);
                 }
               }
               const pct = progress.progress ? Math.round(progress.progress) : 0;
@@ -112,9 +152,9 @@ class TransformersEmbeddingProvider {
           }
         }
       } catch (error) {
-        this.pipeline = null;
-        if (logger) {
-          logger.clearProgress();
+        this.extractor = null;
+        if (this.config.logger) {
+          this.config.logger.clearProgress();
         }
         throw new Error(`Failed to load embedding model: ${error}`);
       } finally {
@@ -125,11 +165,11 @@ class TransformersEmbeddingProvider {
     return this.initPromise;
   }
   async getEmbedding(text) {
-    await this.ensurePipeline();
-    if (!this.pipeline) {
+    await this.ensureExtractor();
+    if (!this.extractor) {
       throw new Error("Embedding pipeline not initialized");
     }
-    const output = await this.pipeline(text, {
+    const output = await this.extractor(text, {
       pooling: "mean",
       normalize: true
     });
@@ -138,15 +178,15 @@ class TransformersEmbeddingProvider {
   async getEmbeddings(texts) {
     if (texts.length === 0)
       return [];
-    await this.ensurePipeline();
-    if (!this.pipeline) {
+    await this.ensureExtractor();
+    if (!this.extractor) {
       throw new Error("Embedding pipeline not initialized");
     }
     const results = [];
     for (let i = 0;i < texts.length; i += BATCH_SIZE) {
       const batch = texts.slice(i, i + BATCH_SIZE);
       const outputs = await Promise.all(batch.map(async (text) => {
-        const output = await this.pipeline(text, {
+        const output = await this.extractor(text, {
           pooling: "mean",
           normalize: true
         });
@@ -157,44 +197,210 @@ class TransformersEmbeddingProvider {
     return results;
   }
   getDimension() {
-    return EMBEDDING_DIMENSIONS[this.config.model];
+    return getEmbeddingDimension(this.config.model);
   }
   getModelName() {
     return this.config.model;
   }
   async dispose() {
-    this.pipeline = null;
+    this.extractor = null;
   }
 }
-function getCacheDir() {
-  return CACHE_DIR;
+var BATCH_SIZE = 32;
+var init_xenovaEmbeddingProvider = __esm(() => {
+  init_embeddingPaths();
+  init_modelCatalog();
+  init_modelCache();
+  env.cacheDir = RAGGREP_MODEL_CACHE_DIR;
+  env.allowLocalModels = true;
+});
+
+// src/infrastructure/embeddings/huggingfaceEmbeddingProvider.ts
+import {
+  pipeline as pipeline2,
+  env as env2
+} from "@huggingface/transformers";
+
+class HuggingFaceTransformersEmbeddingProvider {
+  extractor = null;
+  config;
+  isInitializing = false;
+  initPromise = null;
+  constructor(config) {
+    this.config = {
+      model: config?.model ?? "bge-small-en-v1.5",
+      runtime: config?.runtime ?? "huggingface",
+      showProgress: config?.showProgress ?? false,
+      logger: config?.logger
+    };
+  }
+  async initialize(config) {
+    if (config) {
+      if (config.model !== this.config.model) {
+        this.extractor = null;
+      }
+      this.config = { ...this.config, ...config };
+    }
+    await this.ensureExtractor();
+  }
+  async ensureExtractor() {
+    if (this.extractor) {
+      return;
+    }
+    if (this.isInitializing && this.initPromise) {
+      return this.initPromise;
+    }
+    this.isInitializing = true;
+    this.initPromise = (async () => {
+      const modelId = getEmbeddingModelId(this.config.model);
+      const logger = this.config.logger;
+      const showProgress = this.config.showProgress || !!logger;
+      const cached = await isEmbeddingModelCached(this.config.model);
+      let hasDownloads = false;
+      try {
+        this.extractor = await pipeline2("feature-extraction", modelId, {
+          progress_callback: showProgress && !cached ? (progress) => {
+            if (progress.status === "progress" && progress.file) {
+              if (!hasDownloads) {
+                hasDownloads = true;
+                if (logger) {
+                  logger.info(`Downloading embedding model: ${this.config.model}`);
+                } else {
+                  console.log(`
+  Loading embedding model: ${this.config.model}`);
+                  console.log(`  Cache: ${RAGGREP_MODEL_CACHE_DIR}`);
+                }
+              }
+              const pct = progress.progress ? Math.round(progress.progress) : 0;
+              if (logger) {
+                logger.progress(`  Downloading ${progress.file}: ${pct}%`);
+              } else {
+                process.stdout.write(`\r  Downloading ${progress.file}: ${pct}%   `);
+              }
+            } else if (progress.status === "done" && progress.file) {
+              if (logger) {
+                logger.clearProgress();
+                logger.info(`  Downloaded ${progress.file}`);
+              } else if (hasDownloads) {
+                process.stdout.write(`\r  Downloaded ${progress.file}              
+`);
+              }
+            }
+          } : undefined
+        });
+        if (hasDownloads) {
+          if (logger) {
+            logger.clearProgress();
+            logger.info(`Model ready: ${this.config.model}`);
+          } else {
+            console.log(`  Model ready.
+`);
+          }
+        }
+      } catch (error) {
+        this.extractor = null;
+        if (this.config.logger) {
+          this.config.logger.clearProgress();
+        }
+        throw new Error(`Failed to load embedding model: ${error}`);
+      } finally {
+        this.isInitializing = false;
+        this.initPromise = null;
+      }
+    })();
+    return this.initPromise;
+  }
+  async getEmbedding(text) {
+    await this.ensureExtractor();
+    if (!this.extractor) {
+      throw new Error("Embedding pipeline not initialized");
+    }
+    const output = await this.extractor(text, {
+      pooling: "mean",
+      normalize: true
+    });
+    return Array.from(output.data);
+  }
+  async getEmbeddings(texts) {
+    if (texts.length === 0)
+      return [];
+    await this.ensureExtractor();
+    if (!this.extractor) {
+      throw new Error("Embedding pipeline not initialized");
+    }
+    const results = [];
+    for (let i = 0;i < texts.length; i += BATCH_SIZE2) {
+      const batch = texts.slice(i, i + BATCH_SIZE2);
+      const outputs = await Promise.all(batch.map(async (text) => {
+        const output = await this.extractor(text, {
+          pooling: "mean",
+          normalize: true
+        });
+        return Array.from(output.data);
+      }));
+      results.push(...outputs);
+    }
+    return results;
+  }
+  getDimension() {
+    return getEmbeddingDimension(this.config.model);
+  }
+  getModelName() {
+    return this.config.model;
+  }
+  async dispose() {
+    this.extractor = null;
+  }
 }
-async function isModelCached(model) {
-  const modelId = EMBEDDING_MODELS[model];
-  const modelPath = path.join(CACHE_DIR, modelId);
-  try {
-    const fs = await import("fs/promises");
-    const onnxPath = path.join(modelPath, "onnx", "model_quantized.onnx");
-    await fs.access(onnxPath);
-    return true;
-  } catch {
-    return false;
+var BATCH_SIZE2 = 32;
+var init_huggingfaceEmbeddingProvider = __esm(() => {
+  init_embeddingPaths();
+  init_modelCatalog();
+  init_modelCache();
+  env2.cacheDir = RAGGREP_MODEL_CACHE_DIR;
+  env2.allowLocalModels = true;
+});
+
+// src/infrastructure/embeddings/embeddingProviderFactory.ts
+function resolveRuntime(config) {
+  return config.runtime ?? "huggingface";
+}
+function createEmbeddingProvider(config) {
+  const runtime = resolveRuntime(config);
+  if (runtime === "huggingface") {
+    return new HuggingFaceTransformersEmbeddingProvider(config);
   }
+  return new XenovaTransformersEmbeddingProvider(config);
 }
+var init_embeddingProviderFactory = __esm(() => {
+  init_huggingfaceEmbeddingProvider();
+  init_xenovaEmbeddingProvider();
+});
+
+// src/infrastructure/embeddings/globalEmbeddings.ts
 function configureEmbeddings(config) {
-  const newConfig = { ...globalConfig, ...config };
-  if (newConfig.model !== globalConfig.model || newConfig.logger !== globalConfig.logger) {
+  const merged = {
+    ...globalConfig,
+    ...config
+  };
+  if (merged.runtime === undefined) {
+    merged.runtime = "huggingface";
+  }
+  const needsReset = merged.model !== globalConfig.model || merged.runtime !== globalConfig.runtime || merged.logger !== globalConfig.logger;
+  if (needsReset) {
+    const prev = globalProvider;
     globalProvider = null;
+    prev?.dispose?.();
   }
-  globalConfig = newConfig;
+  globalConfig = merged;
 }
 function getEmbeddingConfig() {
   return { ...globalConfig };
 }
 async function ensureGlobalProvider() {
   if (!globalProvider) {
-    globalProvider = new TransformersEmbeddingProvider(globalConfig);
-    await globalProvider.initialize();
+    globalProvider = createEmbeddingProvider(globalConfig);
+    await globalProvider.initialize?.(globalConfig);
   }
   return globalProvider;
 }
@@ -206,27 +412,17 @@ async function getEmbeddings(texts) {
   const provider = await ensureGlobalProvider();
   return provider.getEmbeddings(texts);
 }
-var CACHE_DIR, EMBEDDING_MODELS, EMBEDDING_DIMENSIONS, BATCH_SIZE = 32, globalProvider = null, globalConfig;
-var init_transformersEmbedding = __esm(() => {
-  CACHE_DIR = path.join(os.homedir(), ".cache", "raggrep", "models");
-  env.cacheDir = CACHE_DIR;
-  env.allowLocalModels = true;
-  EMBEDDING_MODELS = {
-    "all-MiniLM-L6-v2": "Xenova/all-MiniLM-L6-v2",
-    "all-MiniLM-L12-v2": "Xenova/all-MiniLM-L12-v2",
-    "bge-small-en-v1.5": "Xenova/bge-small-en-v1.5",
-    "paraphrase-MiniLM-L3-v2": "Xenova/paraphrase-MiniLM-L3-v2",
-    "nomic-embed-text-v1.5": "nomic-ai/nomic-embed-text-v1.5"
-  };
-  EMBEDDING_DIMENSIONS = {
-    "all-MiniLM-L6-v2": 384,
-    "all-MiniLM-L12-v2": 384,
-    "bge-small-en-v1.5": 384,
-    "paraphrase-MiniLM-L3-v2": 384,
-    "nomic-embed-text-v1.5": 768
-  };
+function getCacheDir() {
+  return RAGGREP_MODEL_CACHE_DIR;
+}
+var globalProvider = null, globalConfig;
+var init_globalEmbeddings = __esm(() => {
+  init_embeddingPaths();
+  init_embeddingProviderFactory();
+  init_modelCache();
   globalConfig = {
     model: "bge-small-en-v1.5",
+    runtime: "huggingface",
     showProgress: false,
     logger: undefined
   };
@@ -234,7 +430,13 @@ var init_transformersEmbedding = __esm(() => {
 
 // src/infrastructure/embeddings/index.ts
 var init_embeddings = __esm(() => {
-  init_transformersEmbedding();
+  init_modelCatalog();
+  init_embeddingPaths();
+  init_xenovaEmbeddingProvider();
+  init_xenovaEmbeddingProvider();
+  init_huggingfaceEmbeddingProvider();
+  init_embeddingProviderFactory();
+  init_globalEmbeddings();
 });
 
 // src/infrastructure/logger/loggers.ts
@@ -457,29 +659,29 @@ var init_logger = () => {};
 import { createRequire as createRequire2 } from "module";
 import { basename, dirname, normalize, relative, resolve, sep } from "path";
 import * as nativeFs from "fs";
-function cleanPath(path2) {
-  let normalized = normalize(path2);
+function cleanPath(path3) {
+  let normalized = normalize(path3);
   if (normalized.length > 1 && normalized[normalized.length - 1] === sep)
     normalized = normalized.substring(0, normalized.length - 1);
   return normalized;
 }
-function convertSlashes(path2, separator) {
-  return path2.replace(SLASHES_REGEX, separator);
+function convertSlashes(path3, separator) {
+  return path3.replace(SLASHES_REGEX, separator);
 }
-function isRootDirectory(path2) {
-  return path2 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path2);
+function isRootDirectory(path3) {
+  return path3 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path3);
 }
-function normalizePath(path2, options) {
+function normalizePath(path3, options) {
   const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
-  const pathNeedsCleaning = process.platform === "win32" && path2.includes("/") || path2.startsWith(".");
+  const pathNeedsCleaning = process.platform === "win32" && path3.includes("/") || path3.startsWith(".");
   if (resolvePaths)
-    path2 = resolve(path2);
+    path3 = resolve(path3);
   if (normalizePath$1 || pathNeedsCleaning)
-    path2 = cleanPath(path2);
-  if (path2 === ".")
+    path3 = cleanPath(path3);
+  if (path3 === ".")
     return "";
-  const needsSeperator = path2[path2.length - 1] !== pathSeparator;
-  return convertSlashes(needsSeperator ? path2 + pathSeparator : path2, pathSeparator);
+  const needsSeperator = path3[path3.length - 1] !== pathSeparator;
+  return convertSlashes(needsSeperator ? path3 + pathSeparator : path3, pathSeparator);
 }
 function joinPathWithBasePath(filename, directoryPath) {
   return directoryPath + filename;
@@ -545,10 +747,10 @@ function build$2(options, isSynchronous) {
     return null;
   return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
 }
-function isRecursive(path2, resolved, state) {
+function isRecursive(path3, resolved, state) {
   if (state.options.useRealPaths)
     return isRecursiveUsingRealPaths(resolved, state);
-  let parent = dirname(path2);
+  let parent = dirname(path3);
   let depth = 1;
   while (parent !== state.root && depth < 2) {
     const resolvedPath = state.symlinks.get(parent);
@@ -558,7 +760,7 @@ function isRecursive(path2, resolved, state) {
     else
       parent = dirname(parent);
   }
-  state.symlinks.set(path2, resolved);
+  state.symlinks.set(path3, resolved);
   return depth > 1;
 }
 function isRecursiveUsingRealPaths(resolved, state) {
@@ -604,9 +806,9 @@ function sync(root, options) {
 var __require2, SLASHES_REGEX, WINDOWS_ROOT_DIR_REGEX, pushDirectory = (directoryPath, paths) => {
   paths.push(directoryPath || ".");
 }, pushDirectoryFilter = (directoryPath, paths, filters) => {
-  const path2 = directoryPath || ".";
-  if (filters.every((filter) => filter(path2, true)))
-    paths.push(path2);
+  const path3 = directoryPath || ".";
+  if (filters.every((filter) => filter(path3, true)))
+    paths.push(path3);
 }, empty$2 = () => {}, pushFileFilterAndCount = (filename, _paths, counts, filters) => {
   if (filters.every((filter) => filter(filename, false)))
     counts.files++;
@@ -627,28 +829,28 @@ var __require2, SLASHES_REGEX, WINDOWS_ROOT_DIR_REGEX, pushDirectory = (director
     files,
     dir: directory
   });
-}, empty = () => {}, resolveSymlinksAsync = function(path2, state, callback$1) {
-  const { queue, fs, options: { suppressErrors } } = state;
+}, empty = () => {}, resolveSymlinksAsync = function(path3, state, callback$1) {
+  const { queue, fs: fs2, options: { suppressErrors } } = state;
   queue.enqueue();
-  fs.realpath(path2, (error, resolvedPath) => {
+  fs2.realpath(path3, (error, resolvedPath) => {
     if (error)
       return queue.dequeue(suppressErrors ? null : error, state);
-    fs.stat(resolvedPath, (error$1, stat) => {
+    fs2.stat(resolvedPath, (error$1, stat) => {
       if (error$1)
         return queue.dequeue(suppressErrors ? null : error$1, state);
-      if (stat.isDirectory() && isRecursive(path2, resolvedPath, state))
+      if (stat.isDirectory() && isRecursive(path3, resolvedPath, state))
         return queue.dequeue(null, state);
       callback$1(stat, resolvedPath);
       queue.dequeue(null, state);
     });
   });
-}, resolveSymlinks = function(path2, state, callback$1) {
-  const { queue, fs, options: { suppressErrors } } = state;
+}, resolveSymlinks = function(path3, state, callback$1) {
+  const { queue, fs: fs2, options: { suppressErrors } } = state;
   queue.enqueue();
   try {
-    const resolvedPath = fs.realpathSync(path2);
-    const stat = fs.statSync(resolvedPath);
-    if (stat.isDirectory() && isRecursive(path2, resolvedPath, state))
+    const resolvedPath = fs2.realpathSync(path3);
+    const stat = fs2.statSync(resolvedPath);
+    if (stat.isDirectory() && isRecursive(path3, resolvedPath, state))
       return;
     callback$1(stat, resolvedPath);
   } catch (e) {
@@ -679,22 +881,22 @@ var __require2, SLASHES_REGEX, WINDOWS_ROOT_DIR_REGEX, pushDirectory = (director
   state.queue.enqueue();
   if (currentDepth < 0)
     return state.queue.dequeue(null, state);
-  const { fs } = state;
+  const { fs: fs2 } = state;
   state.visited.push(crawlPath);
   state.counts.directories++;
-  fs.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
+  fs2.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
     callback$1(entries, directoryPath, currentDepth);
     state.queue.dequeue(state.options.suppressErrors ? null : error, state);
   });
 }, walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
-  const { fs } = state;
+  const { fs: fs2 } = state;
   if (currentDepth < 0)
     return;
   state.visited.push(crawlPath);
   state.counts.directories++;
   let entries = [];
   try {
-    entries = fs.readdirSync(crawlPath || ".", readdirOpts);
+    entries = fs2.readdirSync(crawlPath || ".", readdirOpts);
   } catch (e) {
     if (!state.options.suppressErrors)
       throw e;
@@ -793,21 +995,21 @@ var __require2, SLASHES_REGEX, WINDOWS_ROOT_DIR_REGEX, pushDirectory = (director
         const filename = this.joinPath(entry.name, directoryPath);
         this.pushFile(filename, files, this.state.counts, filters);
       } else if (entry.isDirectory()) {
-        let path2 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-        if (exclude && exclude(entry.name, path2))
+        let path3 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+        if (exclude && exclude(entry.name, path3))
           continue;
-        this.pushDirectory(path2, paths, filters);
-        this.walkDirectory(this.state, path2, path2, depth - 1, this.walk);
+        this.pushDirectory(path3, paths, filters);
+        this.walkDirectory(this.state, path3, path3, depth - 1, this.walk);
       } else if (this.resolveSymlink && entry.isSymbolicLink()) {
-        let path2 = joinPathWithBasePath(entry.name, directoryPath);
-        this.resolveSymlink(path2, this.state, (stat, resolvedPath) => {
+        let path3 = joinPathWithBasePath(entry.name, directoryPath);
+        this.resolveSymlink(path3, this.state, (stat, resolvedPath) => {
           if (stat.isDirectory()) {
             resolvedPath = normalizePath(resolvedPath, this.state.options);
-            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path2 + pathSeparator))
+            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path3 + pathSeparator))
               return;
-            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path2 + pathSeparator, depth - 1, this.walk);
+            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path3 + pathSeparator, depth - 1, this.walk);
           } else {
-            resolvedPath = useRealPaths ? resolvedPath : path2;
+            resolvedPath = useRealPaths ? resolvedPath : path3;
             const filename = basename(resolvedPath);
             const directoryPath$1 = normalizePath(dirname(resolvedPath), this.state.options);
             resolvedPath = this.joinPath(filename, directoryPath$1);
@@ -943,7 +1145,7 @@ var __require2, SLASHES_REGEX, WINDOWS_ROOT_DIR_REGEX, pushDirectory = (director
       isMatch = globFn(patterns, ...options);
       this.globCache[patterns.join("\x00")] = isMatch;
     }
-    this.options.filters.push((path2) => isMatch(path2));
+    this.options.filters.push((path3) => isMatch(path3));
     return this;
   }
 };
@@ -985,49 +1187,37 @@ function createDefaultConfig() {
       {
         id: "language/typescript",
         enabled: true,
-        options: {
-          embeddingModel: "all-MiniLM-L6-v2"
-        }
+        options: { ...DEFAULT_EMBEDDING_MODULE_OPTIONS }
       },
       {
         id: "language/python",
         enabled: true,
-        options: {
-          embeddingModel: "all-MiniLM-L6-v2"
-        }
+        options: { ...DEFAULT_EMBEDDING_MODULE_OPTIONS }
       },
       {
         id: "language/go",
         enabled: true,
-        options: {
-          embeddingModel: "all-MiniLM-L6-v2"
-        }
+        options: { ...DEFAULT_EMBEDDING_MODULE_OPTIONS }
       },
       {
         id: "language/rust",
         enabled: true,
-        options: {
-          embeddingModel: "all-MiniLM-L6-v2"
-        }
+        options: { ...DEFAULT_EMBEDDING_MODULE_OPTIONS }
       },
       {
         id: "data/json",
         enabled: true,
-        options: {
-          embeddingModel: "all-MiniLM-L6-v2"
-        }
+        options: { ...DEFAULT_EMBEDDING_MODULE_OPTIONS }
       },
       {
         id: "docs/markdown",
         enabled: true,
-        options: {
-          embeddingModel: "all-MiniLM-L6-v2"
-        }
+        options: { ...DEFAULT_EMBEDDING_MODULE_OPTIONS }
       }
     ]
   };
 }
-var DEFAULT_IGNORE_PATHS, DEFAULT_EXTENSIONS;
+var DEFAULT_IGNORE_PATHS, DEFAULT_EXTENSIONS, DEFAULT_EMBEDDING_MODULE_OPTIONS;
 var init_config = __esm(() => {
   DEFAULT_IGNORE_PATHS = [
     "node_modules",
@@ -1097,6 +1287,10 @@ var init_config = __esm(() => {
     ".sql",
     ".txt"
   ];
+  DEFAULT_EMBEDDING_MODULE_OPTIONS = {
+    embeddingModel: "bge-small-en-v1.5",
+    embeddingRuntime: "huggingface"
+  };
 });
 
 // src/domain/entities/literal.ts
@@ -1127,47 +1321,45 @@ var init_entities = __esm(() => {
 });
 
 // src/infrastructure/config/configLoader.ts
-import * as path2 from "path";
-import * as fs from "fs/promises";
-import * as os2 from "os";
+import * as path3 from "path";
+import * as fs2 from "fs/promises";
 import * as crypto from "crypto";
 function hashPath(inputPath) {
   return crypto.createHash("sha256").update(inputPath).digest("hex").slice(0, 12);
 }
 function getRaggrepDir(rootDir, _config = DEFAULT_CONFIG) {
-  const absoluteRoot = path2.resolve(rootDir);
-  const projectHash = hashPath(absoluteRoot);
-  return path2.join(RAGGREP_TEMP_BASE, projectHash);
+  const absoluteRoot = path3.resolve(rootDir);
+  return path3.join(absoluteRoot, RAGGREP_INDEX_DIR);
 }
 function getIndexLocation(rootDir) {
-  const absoluteRoot = path2.resolve(rootDir);
+  const absoluteRoot = path3.resolve(rootDir);
   const projectHash = hashPath(absoluteRoot);
   return {
-    indexDir: path2.join(RAGGREP_TEMP_BASE, projectHash),
+    indexDir: path3.join(absoluteRoot, RAGGREP_INDEX_DIR),
     projectRoot: absoluteRoot,
     projectHash
   };
 }
 function getModuleIndexPath(rootDir, moduleId, config = DEFAULT_CONFIG) {
   const indexDir = getRaggrepDir(rootDir, config);
-  return path2.join(indexDir, "index", moduleId);
+  return path3.join(indexDir, "index", moduleId);
 }
 function getModuleManifestPath(rootDir, moduleId, config = DEFAULT_CONFIG) {
   const indexDir = getRaggrepDir(rootDir, config);
-  return path2.join(indexDir, "index", moduleId, "manifest.json");
+  return path3.join(indexDir, "index", moduleId, "manifest.json");
 }
 function getGlobalManifestPath(rootDir, config = DEFAULT_CONFIG) {
   const indexDir = getRaggrepDir(rootDir, config);
-  return path2.join(indexDir, "manifest.json");
+  return path3.join(indexDir, "manifest.json");
 }
 function getConfigPath(rootDir, config = DEFAULT_CONFIG) {
   const indexDir = getRaggrepDir(rootDir, config);
-  return path2.join(indexDir, "config.json");
+  return path3.join(indexDir, "config.json");
 }
 async function loadConfig(rootDir) {
   const configPath = getConfigPath(rootDir, DEFAULT_CONFIG);
   try {
-    const content = await fs.readFile(configPath, "utf-8");
+    const content = await fs2.readFile(configPath, "utf-8");
     const savedConfig = JSON.parse(content);
     return { ...DEFAULT_CONFIG, ...savedConfig };
   } catch {
@@ -1180,27 +1372,28 @@ function getModuleConfig(config, moduleId) {
 function getEmbeddingConfigFromModule(moduleConfig) {
   const options = moduleConfig.options || {};
   const modelName = options.embeddingModel || "bge-small-en-v1.5";
-  if (!(modelName in EMBEDDING_MODELS2)) {
+  if (!(modelName in EMBEDDING_MODELS)) {
     console.warn(`Unknown embedding model: ${modelName}, falling back to bge-small-en-v1.5`);
     return { model: "bge-small-en-v1.5" };
   }
+  const rt = options.embeddingRuntime;
+  let runtime;
+  if (rt === "xenova" || rt === "huggingface") {
+    runtime = rt;
+  } else if (rt !== undefined) {
+    console.warn(`Unknown embeddingRuntime: ${rt}, falling back to default (huggingface)`);
+  }
   return {
     model: modelName,
+    ...runtime ? { runtime } : {},
     showProgress: options.showProgress === true
   };
 }
-var DEFAULT_CONFIG, RAGGREP_TEMP_BASE, EMBEDDING_MODELS2;
+var DEFAULT_CONFIG, RAGGREP_INDEX_DIR = ".raggrep";
 var init_configLoader = __esm(() => {
   init_entities();
+  init_modelCatalog();
   DEFAULT_CONFIG = createDefaultConfig();
-  RAGGREP_TEMP_BASE = path2.join(os2.tmpdir(), "raggrep-indexes");
-  EMBEDDING_MODELS2 = {
-    "all-MiniLM-L6-v2": "Xenova/all-MiniLM-L6-v2",
-    "all-MiniLM-L12-v2": "Xenova/all-MiniLM-L12-v2",
-    "bge-small-en-v1.5": "Xenova/bge-small-en-v1.5",
-    "paraphrase-MiniLM-L3-v2": "Xenova/paraphrase-MiniLM-L3-v2",
-    "nomic-embed-text-v1.5": "nomic-ai/nomic-embed-text-v1.5"
-  };
 });
 
 // src/infrastructure/config/index.ts
@@ -1338,10 +1531,10 @@ function normalizeScore(score, midpoint = 5) {
 var BM25_K1 = 1.5, BM25_B = 0.75;
 
 // src/domain/services/conventions/entryPoints.ts
-import * as path3 from "path";
+import * as path4 from "path";
 function getParentFolder(filepath) {
-  const dir = path3.dirname(filepath);
-  return path3.basename(dir);
+  const dir = path4.dirname(filepath);
+  return path4.basename(dir);
 }
 var entryPointConventions;
 var init_entryPoints = __esm(() => {
@@ -2208,7 +2401,7 @@ var init_frameworks = __esm(() => {
 });
 
 // src/domain/services/conventions/index.ts
-import * as path4 from "path";
+import * as path5 from "path";
 function getConventions() {
   return [
     ...entryPointConventions,
@@ -2220,8 +2413,8 @@ function getConventions() {
 }
 function getConventionKeywords(filepath) {
   const conventions = getConventions();
-  const filename = path4.basename(filepath);
-  const extension = path4.extname(filepath);
+  const filename = path5.basename(filepath);
+  const extension = path5.extname(filepath);
   const keywords = new Set;
   for (const convention of conventions) {
     try {
@@ -2309,13 +2502,13 @@ var init_conventions = __esm(() => {
 });
 
 // src/domain/services/introspection.ts
-import * as path5 from "path";
+import * as path6 from "path";
 function introspectFile(filepath, structure, options) {
   const opts = typeof options === "string" ? { fileContent: options } : options || {};
   const normalizedPath = filepath.replace(/\\/g, "/");
   const segments = normalizedPath.split("/").filter((s) => s.length > 0);
   const filename = segments[segments.length - 1] || "";
-  const ext = path5.extname(filename);
+  const ext = path6.extname(filename);
   const project = findProjectForFile(normalizedPath, structure);
   const language = EXTENSION_TO_LANGUAGE[ext] || "unknown";
   const layer = detectLayer(segments, filename);
@@ -2357,7 +2550,7 @@ function findNearestReadme(filepath, fileExists) {
 }
 function introspectionToKeywords(intro) {
   const keywords = [];
-  const filename = path5.basename(intro.filepath);
+  const filename = path6.basename(intro.filepath);
   const filenameWithoutExt = filename.replace(/\.[^.]+$/, "");
   const filenameParts = filenameWithoutExt.split(/[-_.]/).flatMap((part) => part.split(/(?=[A-Z])/)).map((part) => part.toLowerCase()).filter((part) => part.length > 1);
   keywords.push(...filenameParts);
@@ -2836,8 +3029,8 @@ var exports_core = {};
 __export(exports_core, {
   CoreModule: () => CoreModule
 });
-import * as path6 from "path";
-import * as fs2 from "fs/promises";
+import * as path7 from "path";
+import * as fs3 from "fs/promises";
 
 class CoreModule {
   id = "core";
@@ -2934,8 +3127,8 @@ class CoreModule {
   }
   async finalize(ctx) {
     const config = ctx.config;
-    const coreDir = path6.join(getRaggrepDir(ctx.rootDir, config), "index", "core");
-    await fs2.mkdir(coreDir, { recursive: true });
+    const coreDir = path7.join(getRaggrepDir(ctx.rootDir, config), "index", "core");
+    await fs3.mkdir(coreDir, { recursive: true });
     this.bm25Index = new BM25Index;
     for (const [filepath, entry] of this.symbolIndex) {
       this.bm25Index.addDocument(filepath, entry.tokens);
@@ -2946,7 +3139,7 @@ class CoreModule {
       files: Object.fromEntries(this.symbolIndex),
       bm25Data: this.bm25Index.serialize()
     };
-    await fs2.writeFile(path6.join(coreDir, "symbols.json"), JSON.stringify(symbolIndexData, null, 2));
+    await fs3.writeFile(path7.join(coreDir, "symbols.json"), JSON.stringify(symbolIndexData, null, 2));
   }
   async search(query, ctx, options) {
     const config = ctx.config;
@@ -3042,10 +3235,10 @@ class CoreModule {
     return bestChunk;
   }
   async loadSymbolIndex(rootDir, config) {
-    const coreDir = path6.join(getRaggrepDir(rootDir, config), "index", "core");
-    const symbolsPath = path6.join(coreDir, "symbols.json");
+    const coreDir = path7.join(getRaggrepDir(rootDir, config), "index", "core");
+    const symbolsPath = path7.join(coreDir, "symbols.json");
     try {
-      const content = await fs2.readFile(symbolsPath, "utf-8");
+      const content = await fs3.readFile(symbolsPath, "utf-8");
       const data = JSON.parse(content);
       this.symbolIndex = new Map(Object.entries(data.files));
       if (data.bm25Data) {
@@ -3276,7 +3469,7 @@ function cosineSimilarity(a, b) {
 }
 
 // src/domain/services/queryIntent.ts
-import * as path7 from "path";
+import * as path8 from "path";
 function detectQueryIntent(queryTerms) {
   const hasImplementationTerm = queryTerms.some((term) => IMPLEMENTATION_TERMS.includes(term));
   const hasDocumentationTerm = queryTerms.some((term) => DOCUMENTATION_TERMS.includes(term));
@@ -3292,11 +3485,11 @@ function extractQueryTerms(query) {
   return query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
 }
 function isSourceCodeFile(filepath) {
-  const ext = path7.extname(filepath).toLowerCase();
+  const ext = path8.extname(filepath).toLowerCase();
   return SOURCE_CODE_EXTENSIONS.includes(ext);
 }
 function isDocFile(filepath) {
-  const ext = path7.extname(filepath).toLowerCase();
+  const ext = path8.extname(filepath).toLowerCase();
   return DOC_EXTENSIONS.includes(ext);
 }
 function calculateFileTypeBoost(filepath, queryTerms) {
@@ -4371,8 +4564,8 @@ var init_lexicon2 = __esm(() => {
 // src/domain/services/jsonPathExtractor.ts
 function extractJsonPaths(obj, fileBasename) {
   const paths = extractPathsRecursive(obj, fileBasename);
-  return paths.map((path8) => ({
-    value: path8,
+  return paths.map((path9) => ({
+    value: path9,
     type: "identifier",
     matchType: "definition"
   }));
@@ -4682,6 +4875,62 @@ var init_simpleSearch = __esm(() => {
   };
 });
 
+// src/domain/services/chunkContext.ts
+import * as path9 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 = path9.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();
@@ -4694,6 +4943,7 @@ var init_services = __esm(() => {
   init_configValidator();
   init_phraseMatch();
   init_simpleSearch();
+  init_chunkContext();
 });
 
 // src/modules/language/typescript/parseCode.ts
@@ -4865,11 +5115,12 @@ var init_parseCode = () => {};
 // src/infrastructure/storage/fileIndexStorage.ts
 var init_fileIndexStorage = __esm(() => {
   init_entities();
+  init_config2();
 });
 
 // src/infrastructure/storage/symbolicIndex.ts
-import * as fs3 from "fs/promises";
-import * as path8 from "path";
+import * as fs4 from "fs/promises";
+import * as path10 from "path";
 
 class SymbolicIndex {
   meta = null;
@@ -4878,7 +5129,7 @@ class SymbolicIndex {
   symbolicPath;
   moduleId;
   constructor(indexDir, moduleId) {
-    this.symbolicPath = path8.join(indexDir, "index", moduleId, "symbolic");
+    this.symbolicPath = path10.join(indexDir, "index", moduleId, "symbolic");
     this.moduleId = moduleId;
   }
   async initialize() {
@@ -4964,13 +5215,13 @@ class SymbolicIndex {
     if (this.bm25Index) {
       this.meta.bm25Serialized = this.bm25Index.serialize();
     }
-    await fs3.mkdir(this.symbolicPath, { recursive: true });
-    const metaPath = path8.join(this.symbolicPath, "_meta.json");
-    await fs3.writeFile(metaPath, JSON.stringify(this.meta, null, 2));
+    await fs4.mkdir(this.symbolicPath, { recursive: true });
+    const metaPath = path10.join(this.symbolicPath, "_meta.json");
+    await fs4.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.writeFile(summaryPath, JSON.stringify(summary, null, 2));
+      await fs4.mkdir(path10.dirname(summaryPath), { recursive: true });
+      await fs4.writeFile(summaryPath, JSON.stringify(summary, null, 2));
     }
   }
   async saveIncremental(filepaths) {
@@ -4981,21 +5232,21 @@ class SymbolicIndex {
     if (this.bm25Index) {
       this.meta.bm25Serialized = this.bm25Index.serialize();
     }
-    await fs3.mkdir(this.symbolicPath, { recursive: true });
-    const metaPath = path8.join(this.symbolicPath, "_meta.json");
-    await fs3.writeFile(metaPath, JSON.stringify(this.meta, null, 2));
+    await fs4.mkdir(this.symbolicPath, { recursive: true });
+    const metaPath = path10.join(this.symbolicPath, "_meta.json");
+    await fs4.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.writeFile(summaryPath, JSON.stringify(summary, null, 2));
+        await fs4.mkdir(path10.dirname(summaryPath), { recursive: true });
+        await fs4.writeFile(summaryPath, JSON.stringify(summary, null, 2));
       }
     }
   }
   async load() {
-    const metaPath = path8.join(this.symbolicPath, "_meta.json");
-    const metaContent = await fs3.readFile(metaPath, "utf-8");
+    const metaPath = path10.join(this.symbolicPath, "_meta.json");
+    const metaContent = await fs4.readFile(metaPath, "utf-8");
     this.meta = JSON.parse(metaContent);
     this.fileSummaries.clear();
     await this.loadFileSummariesRecursive(this.symbolicPath);
@@ -5007,14 +5258,14 @@ class SymbolicIndex {
   }
   async loadFileSummariesRecursive(dir) {
     try {
-      const entries = await fs3.readdir(dir, { withFileTypes: true });
+      const entries = await fs4.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path8.join(dir, entry.name);
+        const fullPath = path10.join(dir, entry.name);
         if (entry.isDirectory()) {
           await this.loadFileSummariesRecursive(fullPath);
         } else if (entry.name.endsWith(".json") && entry.name !== "_meta.json") {
           try {
-            const content = await fs3.readFile(fullPath, "utf-8");
+            const content = await fs4.readFile(fullPath, "utf-8");
             const summary = JSON.parse(content);
             if (summary.filepath) {
               this.fileSummaries.set(summary.filepath, summary);
@@ -5026,18 +5277,18 @@ class SymbolicIndex {
   }
   getFileSummaryPath(filepath) {
     const jsonPath = filepath.replace(/\.[^.]+$/, ".json");
-    return path8.join(this.symbolicPath, jsonPath);
+    return path10.join(this.symbolicPath, jsonPath);
   }
   async deleteFileSummary(filepath) {
     try {
-      await fs3.unlink(this.getFileSummaryPath(filepath));
+      await fs4.unlink(this.getFileSummaryPath(filepath));
     } catch {}
     this.fileSummaries.delete(filepath);
   }
   async exists() {
     try {
-      const metaPath = path8.join(this.symbolicPath, "_meta.json");
-      await fs3.access(metaPath);
+      const metaPath = path10.join(this.symbolicPath, "_meta.json");
+      await fs4.access(metaPath);
       return true;
     } catch {
       return false;
@@ -5069,8 +5320,8 @@ __export(exports_literalIndex, {
   getLiteralIndexPath: () => getLiteralIndexPath,
   LiteralIndex: () => LiteralIndex
 });
-import * as fs4 from "fs/promises";
-import * as path9 from "path";
+import * as fs5 from "fs/promises";
+import * as path11 from "path";
 
 class LiteralIndex {
   indexPath;
@@ -5079,7 +5330,7 @@ class LiteralIndex {
   vocabularyIndex = new Map;
   static VERSION = "1.1.0";
   constructor(indexDir, moduleId) {
-    this.indexPath = path9.join(indexDir, "index", moduleId, "literals");
+    this.indexPath = path11.join(indexDir, "index", moduleId, "literals");
     this.moduleId = moduleId;
   }
   async initialize() {
@@ -5240,17 +5491,17 @@ class LiteralIndex {
     }));
   }
   async save() {
-    await fs4.mkdir(this.indexPath, { recursive: true });
+    await fs5.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));
+    const indexFile = path11.join(this.indexPath, "_index.json");
+    await fs5.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 indexFile = path11.join(this.indexPath, "_index.json");
+    const content = await fs5.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}`);
@@ -5259,8 +5510,8 @@ class LiteralIndex {
   }
   async exists() {
     try {
-      const indexFile = path9.join(this.indexPath, "_index.json");
-      await fs4.access(indexFile);
+      const indexFile = path11.join(this.indexPath, "_index.json");
+      await fs5.access(indexFile);
       return true;
     } catch {
       return false;
@@ -5303,7 +5554,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 path11.join(rootDir, indexDir, "index", moduleId, "literals");
 }
 var init_literalIndex = () => {};
 
@@ -5324,9 +5575,9 @@ __export(exports_typescript, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K2,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE2
 });
-import * as path10 from "path";
+import * as path12 from "path";
 function isTypeScriptFile(filepath) {
-  const ext = path10.extname(filepath).toLowerCase();
+  const ext = path12.extname(filepath).toLowerCase();
   return TYPESCRIPT_EXTENSIONS.includes(ext);
 }
 function calculateChunkTypeBoost(chunk) {
@@ -5388,8 +5639,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) {
@@ -5400,13 +5649,17 @@ class TypeScriptModule {
         startLine: 1,
         endLine: lines.length,
         type: "file",
-        name: path10.basename(filepath),
+        name: path12.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) => ({
@@ -5430,25 +5683,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) {
@@ -5727,16 +5976,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 = path12.dirname(filepath);
+        const resolved = path12.normalize(path12.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 = path12.dirname(filepath);
+        const resolved = path12.normalize(path12.join(dir, importPath));
         references.push(resolved);
       }
     }
@@ -5764,7 +6013,7 @@ var init_typescript = __esm(() => {
 });
 
 // src/infrastructure/parsing/typescriptParser.ts
-import * as path11 from "path";
+import * as path13 from "path";
 
 class TypeScriptParser {
   supportedLanguages = ["typescript", "javascript"];
@@ -5780,12 +6029,12 @@ class TypeScriptParser {
           startLine: 1,
           endLine: lines.length,
           type: "file",
-          name: path11.basename(filepath),
+          name: path13.basename(filepath),
           isExported: false
         };
         chunks.unshift(fullFileChunk);
       }
-      const ext = path11.extname(filepath).toLowerCase();
+      const ext = path13.extname(filepath).toLowerCase();
       const language = ext === ".js" || ext === ".jsx" || ext === ".mjs" || ext === ".cjs" ? "javascript" : "typescript";
       return {
         chunks,
@@ -5802,7 +6051,7 @@ class TypeScriptParser {
     }
   }
   canParse(filepath) {
-    const ext = path11.extname(filepath).toLowerCase();
+    const ext = path13.extname(filepath).toLowerCase();
     return TYPESCRIPT_EXTENSIONS2.includes(ext);
   }
   convertChunk(tc) {
@@ -5817,7 +6066,7 @@ class TypeScriptParser {
     };
   }
   detectLanguage(filepath) {
-    const ext = path11.extname(filepath).toLowerCase();
+    const ext = path13.extname(filepath).toLowerCase();
     if ([".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
       return "javascript";
     }
@@ -6022,8 +6271,8 @@ var init_grammarManager = __esm(() => {
 });
 
 // src/infrastructure/parsing/treeSitterParser.ts
-import * as path12 from "path";
-import * as fs5 from "fs";
+import * as path14 from "path";
+import * as fs6 from "fs";
 
 class TreeSitterParser {
   supportedLanguages = [
@@ -6045,7 +6294,7 @@ class TreeSitterParser {
         chunks: [],
         language: "typescript",
         success: false,
-        error: `Unsupported file type: ${path12.extname(filepath)}`
+        error: `Unsupported file type: ${path14.extname(filepath)}`
       };
     }
     try {
@@ -6065,11 +6314,11 @@ class TreeSitterParser {
     }
   }
   canParse(filepath) {
-    const ext = path12.extname(filepath).toLowerCase();
+    const ext = path14.extname(filepath).toLowerCase();
     return ext in EXTENSION_TO_LANGUAGE2;
   }
   detectLanguage(filepath) {
-    const ext = path12.extname(filepath).toLowerCase();
+    const ext = path14.extname(filepath).toLowerCase();
     return EXTENSION_TO_LANGUAGE2[ext] || null;
   }
   async ensureInitialized() {
@@ -6103,20 +6352,20 @@ class TreeSitterParser {
   async resolveWasmPath() {
     try {
       const webTreeSitterPath = __require.resolve("web-tree-sitter");
-      const wasmPath = path12.join(path12.dirname(webTreeSitterPath), "web-tree-sitter.wasm");
-      if (fs5.existsSync(wasmPath)) {
+      const wasmPath = path14.join(path14.dirname(webTreeSitterPath), "web-tree-sitter.wasm");
+      if (fs6.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")
+        path14.join(__dirname, "../../../node_modules/web-tree-sitter/web-tree-sitter.wasm"),
+        path14.join(__dirname, "../../node_modules/web-tree-sitter/web-tree-sitter.wasm"),
+        path14.join(__dirname, "../../../../node_modules/web-tree-sitter/web-tree-sitter.wasm"),
+        path14.join(__dirname, "web-tree-sitter.wasm")
       ];
       for (const wasmPath of possiblePaths) {
-        if (fs5.existsSync(wasmPath)) {
+        if (fs6.existsSync(wasmPath)) {
           return wasmPath;
         }
       }
@@ -6157,7 +6406,7 @@ class TreeSitterParser {
         startLine: 1,
         endLine: lines.length,
         type: "file",
-        name: path12.basename(filepath),
+        name: path14.basename(filepath),
         isExported: false
       });
     }
@@ -6504,7 +6753,7 @@ class TreeSitterParser {
       startLine: 1,
       endLine: lines.length,
       type: "file",
-      name: path12.basename(filepath)
+      name: path14.basename(filepath)
     });
     return {
       chunks,
@@ -6513,7 +6762,7 @@ class TreeSitterParser {
     };
   }
 }
-var __dirname = "/Users/conradkoh/Documents/Repos/raggrep/src/infrastructure/parsing", EXTENSION_TO_LANGUAGE2;
+var __dirname = "/home/runner/work/raggrep/raggrep/src/infrastructure/parsing", EXTENSION_TO_LANGUAGE2;
 var init_treeSitterParser = __esm(() => {
   init_grammarManager();
   EXTENSION_TO_LANGUAGE2 = {
@@ -6534,7 +6783,7 @@ var init_treeSitterParser = __esm(() => {
 });
 
 // src/infrastructure/parsing/parserFactory.ts
-import * as path13 from "path";
+import * as path15 from "path";
 function getTypeScriptParser() {
   if (!typescriptParserInstance) {
     typescriptParserInstance = new TypeScriptParser;
@@ -6548,7 +6797,7 @@ function getTreeSitterParser() {
   return treeSitterParserInstance;
 }
 function createParserForFile(filepath) {
-  const ext = path13.extname(filepath).toLowerCase();
+  const ext = path15.extname(filepath).toLowerCase();
   const parserType = EXTENSION_PARSER_MAP[ext];
   if (!parserType) {
     return null;
@@ -6597,9 +6846,9 @@ __export(exports_python, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K3,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE3
 });
-import * as path14 from "path";
+import * as path16 from "path";
 function isPythonFile(filepath) {
-  const ext = path14.extname(filepath).toLowerCase();
+  const ext = path16.extname(filepath).toLowerCase();
   return PYTHON_EXTENSIONS.includes(ext);
 }
 function generateChunkId3(filepath, startLine, endLine) {
@@ -6683,7 +6932,7 @@ class PythonModule {
       startLine: 1,
       endLine: lines.length,
       type: "file",
-      name: path14.basename(filepath)
+      name: path16.basename(filepath)
     });
     const funcRegex = /^(\s*)(async\s+)?def\s+(\w+)\s*\([^)]*\)\s*:/gm;
     let match;
@@ -6761,12 +7010,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) => ({
@@ -6789,25 +7039,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) {
@@ -7060,9 +7306,9 @@ __export(exports_go, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K4,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE4
 });
-import * as path15 from "path";
+import * as path17 from "path";
 function isGoFile(filepath) {
-  const ext = path15.extname(filepath).toLowerCase();
+  const ext = path17.extname(filepath).toLowerCase();
   return GO_EXTENSIONS.includes(ext);
 }
 function generateChunkId4(filepath, startLine, endLine) {
@@ -7147,7 +7393,7 @@ class GoModule {
       startLine: 1,
       endLine: lines.length,
       type: "file",
-      name: path15.basename(filepath)
+      name: path17.basename(filepath)
     });
     const funcRegex = /^func\s+(?:\(\s*\w+\s+\*?\w+\s*\)\s+)?(\w+)\s*\(/gm;
     let match;
@@ -7296,12 +7542,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) => ({
@@ -7324,25 +7571,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) {
@@ -7544,9 +7787,9 @@ __export(exports_rust, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K5,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE5
 });
-import * as path16 from "path";
+import * as path18 from "path";
 function isRustFile(filepath) {
-  const ext = path16.extname(filepath).toLowerCase();
+  const ext = path18.extname(filepath).toLowerCase();
   return RUST_EXTENSIONS.includes(ext);
 }
 function generateChunkId5(filepath, startLine, endLine) {
@@ -7633,7 +7876,7 @@ class RustModule {
       startLine: 1,
       endLine: lines.length,
       type: "file",
-      name: path16.basename(filepath)
+      name: path18.basename(filepath)
     });
     const funcRegex = /^(pub(?:\s*\([^)]*\))?\s+)?(?:async\s+)?fn\s+(\w+)/gm;
     let match;
@@ -7859,12 +8102,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) => ({
@@ -7887,25 +8131,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) {
@@ -8107,9 +8347,9 @@ __export(exports_json, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K6,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE6
 });
-import * as path17 from "path";
+import * as path19 from "path";
 function isJsonFile(filepath) {
-  const ext = path17.extname(filepath).toLowerCase();
+  const ext = path19.extname(filepath).toLowerCase();
   return JSON_EXTENSIONS.includes(ext);
 }
 
@@ -8143,7 +8383,7 @@ class JsonModule {
     } catch {
       return null;
     }
-    const fileBasename = path17.basename(filepath, path17.extname(filepath));
+    const fileBasename = path19.basename(filepath, path19.extname(filepath));
     const jsonPathLiterals = extractJsonPaths(parsed, fileBasename);
     const lines = content.split(`
 `);
@@ -8350,7 +8590,7 @@ __export(exports_markdown, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K7,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE7
 });
-import * as path18 from "path";
+import * as path20 from "path";
 function calculateHeadingLevelBoost(chunk) {
   const metadata = chunk.metadata;
   const level = metadata?.headingLevel ?? 0;
@@ -8370,7 +8610,7 @@ function calculateHeadingLevelBoost(chunk) {
   }
 }
 function isMarkdownFile(filepath) {
-  const ext = path18.extname(filepath).toLowerCase();
+  const ext = path20.extname(filepath).toLowerCase();
   return MARKDOWN_EXTENSIONS.includes(ext);
 }
 function parseMarkdownHierarchical(content, maxDepth = 4) {
@@ -8502,9 +8742,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) => ({
@@ -8528,14 +8770,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 {
@@ -8707,15 +8952,15 @@ var init_registry = __esm(() => {
 });
 
 // src/infrastructure/introspection/projectDetector.ts
-import * as path19 from "path";
-import * as fs6 from "fs/promises";
+import * as path21 from "path";
+import * as fs7 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 ? path21.join(rootDir, currentDir) : rootDir;
   try {
-    const entries = await fs6.readdir(fullDir, { withFileTypes: true });
+    const entries = await fs7.readdir(fullDir, { withFileTypes: true });
     const hasPackageJson = entries.some((e) => e.isFile() && e.name === "package.json");
     if (hasPackageJson && currentDir) {
       const info = await parsePackageJson(rootDir, currentDir);
@@ -8736,10 +8981,10 @@ async function scanForPackageJsons(rootDir, currentDir = "", depth = 0) {
 }
 async function parsePackageJson(rootDir, relativePath) {
   try {
-    const packageJsonPath = path19.join(rootDir, relativePath, "package.json");
-    const content = await fs6.readFile(packageJsonPath, "utf-8");
+    const packageJsonPath = path21.join(rootDir, relativePath, "package.json");
+    const content = await fs7.readFile(packageJsonPath, "utf-8");
     const pkg = JSON.parse(content);
-    const name = pkg.name || path19.basename(relativePath);
+    const name = pkg.name || path21.basename(relativePath);
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     let type = "unknown";
     if (deps["next"] || deps["react"] || deps["vue"] || deps["svelte"]) {
@@ -8775,7 +9020,7 @@ async function detectProjectStructure(rootDir) {
   const projectMap = new Map;
   let isMonorepo = false;
   try {
-    const entries = await fs6.readdir(rootDir, { withFileTypes: true });
+    const entries = await fs7.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));
@@ -8784,9 +9029,9 @@ async function detectProjectStructure(rootDir) {
       for (const pattern of monorepoPatterns) {
         if (!dirNames.includes(pattern))
           continue;
-        const patternDir = path19.join(rootDir, pattern);
+        const patternDir = path21.join(rootDir, pattern);
         try {
-          const subDirs = await fs6.readdir(patternDir, { withFileTypes: true });
+          const subDirs = await fs7.readdir(patternDir, { withFileTypes: true });
           for (const subDir of subDirs) {
             if (!subDir.isDirectory())
               continue;
@@ -8815,8 +9060,8 @@ async function detectProjectStructure(rootDir) {
     }
     let rootType = "unknown";
     try {
-      const rootPkgPath = path19.join(rootDir, "package.json");
-      const rootPkg = JSON.parse(await fs6.readFile(rootPkgPath, "utf-8"));
+      const rootPkgPath = path21.join(rootDir, "package.json");
+      const rootPkg = JSON.parse(await fs7.readFile(rootPkgPath, "utf-8"));
       if (rootPkg.workspaces)
         isMonorepo = true;
       const deps = { ...rootPkg.dependencies, ...rootPkg.devDependencies };
@@ -8855,8 +9100,8 @@ var init_projectDetector = __esm(() => {
 });
 
 // src/infrastructure/introspection/IntrospectionIndex.ts
-import * as path20 from "path";
-import * as fs7 from "fs/promises";
+import * as path22 from "path";
+import * as fs8 from "fs/promises";
 import * as fsSync from "fs";
 
 class IntrospectionIndex {
@@ -8870,8 +9115,8 @@ class IntrospectionIndex {
   async initialize() {
     this.structure = await detectProjectStructure(this.rootDir);
     try {
-      const configPath = path20.join(this.rootDir, ".raggrep", "config.json");
-      const configContent = await fs7.readFile(configPath, "utf-8");
+      const configPath = path22.join(this.rootDir, ".raggrep", "config.json");
+      const configContent = await fs8.readFile(configPath, "utf-8");
       const config = JSON.parse(configContent);
       this.config = config.introspection || {};
     } catch {}
@@ -8885,7 +9130,7 @@ class IntrospectionIndex {
     }
     const fileExists = enableReadmeContext ? (relativePath) => {
       try {
-        const absolutePath = path20.join(this.rootDir, relativePath);
+        const absolutePath = path22.join(this.rootDir, relativePath);
         return fsSync.existsSync(absolutePath);
       } catch {
         return false;
@@ -8921,28 +9166,28 @@ class IntrospectionIndex {
     }
   }
   async save(config) {
-    const introDir = path20.join(getRaggrepDir(this.rootDir, config), "introspection");
-    await fs7.mkdir(introDir, { recursive: true });
-    const projectPath = path20.join(introDir, "_project.json");
-    await fs7.writeFile(projectPath, JSON.stringify({
+    const introDir = path22.join(getRaggrepDir(this.rootDir, config), "introspection");
+    await fs8.mkdir(introDir, { recursive: true });
+    const projectPath = path22.join(introDir, "_project.json");
+    await fs8.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 });
-      await fs7.writeFile(introFilePath, JSON.stringify(intro, null, 2));
+      const introFilePath = path22.join(introDir, "files", filepath.replace(/\.[^.]+$/, ".json"));
+      await fs8.mkdir(path22.dirname(introFilePath), { recursive: true });
+      await fs8.writeFile(introFilePath, JSON.stringify(intro, null, 2));
     }
   }
   async load(config) {
-    const introDir = path20.join(getRaggrepDir(this.rootDir, config), "introspection");
+    const introDir = path22.join(getRaggrepDir(this.rootDir, config), "introspection");
     try {
-      const projectPath = path20.join(introDir, "_project.json");
-      const projectContent = await fs7.readFile(projectPath, "utf-8");
+      const projectPath = path22.join(introDir, "_project.json");
+      const projectContent = await fs8.readFile(projectPath, "utf-8");
       const projectData = JSON.parse(projectContent);
       this.structure = projectData.structure;
-      await this.loadFilesRecursive(path20.join(introDir, "files"), "");
+      await this.loadFilesRecursive(path22.join(introDir, "files"), "");
     } catch {
       this.structure = null;
       this.files.clear();
@@ -8950,14 +9195,14 @@ class IntrospectionIndex {
   }
   async loadFilesRecursive(basePath, prefix) {
     try {
-      const entries = await fs7.readdir(basePath, { withFileTypes: true });
+      const entries = await fs8.readdir(basePath, { withFileTypes: true });
       for (const entry of entries) {
-        const entryPath = path20.join(basePath, entry.name);
+        const entryPath = path22.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 fs7.readFile(entryPath, "utf-8");
+          const content = await fs8.readFile(entryPath, "utf-8");
           const intro = JSON.parse(content);
           this.files.set(intro.filepath, intro);
         }
@@ -8983,7 +9228,7 @@ var init_introspection2 = __esm(() => {
 
 // src/app/indexer/watcher.ts
 import { watch } from "chokidar";
-import * as path21 from "path";
+import * as path23 from "path";
 async function watchDirectory(rootDir, options = {}) {
   const {
     debounceMs = DEFAULT_DEBOUNCE_MS,
@@ -8994,17 +9239,17 @@ async function watchDirectory(rootDir, options = {}) {
     onFileChange,
     onError
   } = options;
-  rootDir = path21.resolve(rootDir);
+  rootDir = path23.resolve(rootDir);
   const config = await loadConfig(rootDir);
-  const indexLocation = getIndexLocation(rootDir);
   const validExtensions = new Set(config.extensions);
   const ignorePatterns = [
     ...config.ignorePaths.map((p) => `**/${p}/**`),
     "**/node_modules/**",
-    "**/.git/**"
+    "**/.git/**",
+    "**/.raggrep/**"
   ];
   function shouldWatchFile(filepath) {
-    const ext = path21.extname(filepath);
+    const ext = path23.extname(filepath);
     return validExtensions.has(ext);
   }
   let isRunning = true;
@@ -9087,7 +9332,7 @@ async function watchDirectory(rootDir, options = {}) {
   function handleFileEvent(event, filepath) {
     if (!isRunning)
       return;
-    const relativePath = path21.relative(rootDir, filepath);
+    const relativePath = path23.relative(rootDir, filepath);
     if (!shouldWatchFile(filepath)) {
       return;
     }
@@ -9165,9 +9410,9 @@ __export(exports_indexer, {
   clearFreshnessCache: () => clearFreshnessCache,
   cleanupIndex: () => cleanupIndex
 });
-import * as fs8 from "fs/promises";
-import * as path22 from "path";
-import * as os3 from "os";
+import * as fs9 from "fs/promises";
+import * as path24 from "path";
+import * as os2 from "os";
 import * as crypto2 from "crypto";
 function clearFreshnessCache() {
   freshnessCache = null;
@@ -9207,7 +9452,7 @@ function formatDuration(ms) {
   return `${minutes}m ${remainingSeconds.toFixed(1)}s`;
 }
 function getOptimalConcurrency() {
-  const cpuCount = os3.cpus().length;
+  const cpuCount = os2.cpus().length;
   const optimal = Math.max(2, Math.min(16, Math.floor(cpuCount * 0.75)));
   return optimal;
 }
@@ -9218,7 +9463,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 = path24.resolve(rootDir);
   const location = getIndexLocation(rootDir);
   logger.info(`Indexing directory: ${rootDir}`);
   logger.info(`Index location: ${location.indexDir}`);
@@ -9270,12 +9515,12 @@ async function indexDirectory(rootDir, options = {}) {
         rootDir,
         config,
         readFile: async (filepath) => {
-          const fullPath = path22.isAbsolute(filepath) ? filepath : path22.join(rootDir, filepath);
-          return fs8.readFile(fullPath, "utf-8");
+          const fullPath = path24.isAbsolute(filepath) ? filepath : path24.join(rootDir, filepath);
+          return fs9.readFile(fullPath, "utf-8");
         },
         getFileStats: async (filepath) => {
-          const fullPath = path22.isAbsolute(filepath) ? filepath : path22.join(rootDir, filepath);
-          const stats = await fs8.stat(fullPath);
+          const fullPath = path24.isAbsolute(filepath) ? filepath : path24.join(rootDir, filepath);
+          const stats = await fs9.stat(fullPath);
           return { lastModified: stats.mtime.toISOString() };
         }
       };
@@ -9300,7 +9545,7 @@ async function isIndexVersionCompatible(rootDir) {
   const config = await loadConfig(rootDir);
   const globalManifestPath = getGlobalManifestPath(rootDir, config);
   try {
-    const content = await fs8.readFile(globalManifestPath, "utf-8");
+    const content = await fs9.readFile(globalManifestPath, "utf-8");
     const manifest = JSON.parse(content);
     return manifest.version === INDEX_SCHEMA_VERSION;
   } catch {
@@ -9310,11 +9555,11 @@ async function isIndexVersionCompatible(rootDir) {
 async function deleteIndex(rootDir) {
   const indexDir = getRaggrepDir(rootDir);
   try {
-    await fs8.rm(indexDir, { recursive: true, force: true });
+    await fs9.rm(indexDir, { recursive: true, force: true });
   } catch {}
 }
 async function resetIndex(rootDir) {
-  rootDir = path22.resolve(rootDir);
+  rootDir = path24.resolve(rootDir);
   clearFreshnessCache();
   const status = await getIndexStatus(rootDir);
   if (!status.exists) {
@@ -9339,7 +9584,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 = path24.resolve(rootDir);
   const status = await getIndexStatus(rootDir);
   if (!status.exists) {
     clearFreshnessCache();
@@ -9363,7 +9608,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
   const globalManifestPath = getGlobalManifestPath(rootDir, config);
   let currentManifestMtime = 0;
   try {
-    const manifestStats = await fs8.stat(globalManifestPath);
+    const manifestStats = await fs9.stat(globalManifestPath);
     currentManifestMtime = manifestStats.mtimeMs;
   } catch {}
   const now = Date.now();
@@ -9401,7 +9646,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) => path24.relative(rootDir, f)));
   const changedFileSet = new Set(changedFiles);
   let totalIndexed = 0;
   let totalRemoved = 0;
@@ -9435,11 +9680,11 @@ 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 = path24.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+        const symbolicFilePath = path24.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
         await Promise.all([
-          fs8.unlink(indexFilePath).catch(() => {}),
-          fs8.unlink(symbolicFilePath).catch(() => {})
+          fs9.unlink(indexFilePath).catch(() => {}),
+          fs9.unlink(symbolicFilePath).catch(() => {})
         ]);
         delete manifest.files[filepath];
         removedFilepaths.push(filepath);
@@ -9463,19 +9708,19 @@ async function ensureIndexFresh(rootDir, options = {}) {
       rootDir,
       config,
       readFile: async (filepath) => {
-        const fullPath = path22.isAbsolute(filepath) ? filepath : path22.join(rootDir, filepath);
-        return fs8.readFile(fullPath, "utf-8");
+        const fullPath = path24.isAbsolute(filepath) ? filepath : path24.join(rootDir, filepath);
+        return fs9.readFile(fullPath, "utf-8");
       },
       getFileStats: async (filepath) => {
-        const fullPath = path22.isAbsolute(filepath) ? filepath : path22.join(rootDir, filepath);
-        const stats = await fs8.stat(fullPath);
+        const fullPath = path24.isAbsolute(filepath) ? filepath : path24.join(rootDir, filepath);
+        const stats = await fs9.stat(fullPath);
         return { lastModified: stats.mtime.toISOString() };
       },
       getIntrospection: (filepath) => introspection.getFile(filepath)
     };
     const moduleChangedFiles = module.supportsFile ? changedFiles.filter((f) => module.supportsFile(f)) : changedFiles;
     const filesToProcess = moduleChangedFiles.map((filepath) => {
-      const relativePath = path22.relative(rootDir, filepath);
+      const relativePath = path24.relative(rootDir, filepath);
       const existingEntry = manifest.files[relativePath];
       const lastModified = changedFileMtimes.get(filepath) || new Date().toISOString();
       return {
@@ -9505,7 +9750,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
         return { relativePath, status: "unchanged" };
       }
       try {
-        const content = await fs8.readFile(filepath, "utf-8");
+        const content = await fs9.readFile(filepath, "utf-8");
         const contentHash = computeContentHash(content);
         if (!isNew && existingContentHash && existingContentHash === contentHash) {
           completedCount++;
@@ -9632,7 +9877,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
   }
   let finalManifestMtime = currentManifestMtime;
   try {
-    const manifestStats = await fs8.stat(globalManifestPath);
+    const manifestStats = await fs9.stat(globalManifestPath);
     finalManifestMtime = manifestStats.mtimeMs;
   } catch {}
   freshnessCache = {
@@ -9652,7 +9897,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) => path24.relative(rootDir, f)));
   const filesToRemove = [];
   for (const filepath of Object.keys(manifest.files)) {
     if (!currentFileSet.has(filepath)) {
@@ -9663,13 +9908,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 = path22.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+      const indexFilePath = path24.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
       try {
-        await fs8.unlink(indexFilePath);
+        await fs9.unlink(indexFilePath);
       } catch {}
-      const symbolicFilePath = path22.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
+      const symbolicFilePath = path24.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
       try {
-        await fs8.unlink(symbolicFilePath);
+        await fs9.unlink(symbolicFilePath);
       } catch {}
       delete manifest.files[filepath];
     }
@@ -9679,12 +9924,12 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
     rootDir,
     config,
     readFile: async (filepath) => {
-      const fullPath = path22.isAbsolute(filepath) ? filepath : path22.join(rootDir, filepath);
-      return fs8.readFile(fullPath, "utf-8");
+      const fullPath = path24.isAbsolute(filepath) ? filepath : path24.join(rootDir, filepath);
+      return fs9.readFile(fullPath, "utf-8");
     },
     getFileStats: async (filepath) => {
-      const fullPath = path22.isAbsolute(filepath) ? filepath : path22.join(rootDir, filepath);
-      const stats = await fs8.stat(fullPath);
+      const fullPath = path24.isAbsolute(filepath) ? filepath : path24.join(rootDir, filepath);
+      const stats = await fs9.stat(fullPath);
       return { lastModified: stats.mtime.toISOString() };
     },
     getIntrospection: (filepath) => introspection.getFile(filepath)
@@ -9696,9 +9941,9 @@ 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 = path24.relative(rootDir, filepath);
     try {
-      const stats = await fs8.stat(filepath);
+      const stats = await fs9.stat(filepath);
       const lastModified = stats.mtime.toISOString();
       const existingEntry = manifest.files[relativePath];
       if (existingEntry && existingEntry.lastModified === lastModified) {
@@ -9708,7 +9953,7 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
         logger.debug(`  [${completedCount}/${totalFiles}] Skipped ${relativePath} (unchanged)`);
         return { relativePath, status: "skipped" };
       }
-      const content = await fs8.readFile(filepath, "utf-8");
+      const content = await fs9.readFile(filepath, "utf-8");
       const contentHash = computeContentHash(content);
       if (existingEntry?.contentHash && existingEntry.contentHash === contentHash) {
         completedCount++;
@@ -9789,8 +10034,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 = path24.extname(filepath).toLowerCase();
+  const basename15 = path24.basename(filepath).toLowerCase();
   const binaryExtensions = new Set([
     ".png",
     ".jpg",
@@ -9866,7 +10111,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 = path24.extname(filePath);
     return validExtensions.has(ext);
   }).crawl(rootDir);
   const allFiles = await crawler.withPromise();
@@ -9874,7 +10119,7 @@ async function findFilesWithStats(rootDir, config, lastIndexStarted) {
     const changedFileMtimes2 = new Map;
     await parallelMap(allFiles, async (filePath) => {
       try {
-        const stats = await fs8.stat(filePath);
+        const stats = await fs9.stat(filePath);
         changedFileMtimes2.set(filePath, stats.mtime.toISOString());
       } catch {}
     }, STAT_CONCURRENCY);
@@ -9888,7 +10133,7 @@ async function findFilesWithStats(rootDir, config, lastIndexStarted) {
   const changedFileMtimes = new Map;
   await parallelMap(allFiles, async (filePath) => {
     try {
-      const stats = await fs8.stat(filePath);
+      const stats = await fs9.stat(filePath);
       if (stats.mtimeMs > lastIndexMs) {
         changedFiles.push(filePath);
         changedFileMtimes.set(filePath, stats.mtime.toISOString());
@@ -9908,7 +10153,7 @@ async function findFiles(rootDir, config) {
 async function loadModuleManifest(rootDir, moduleId, config) {
   const manifestPath = getModuleManifestPath(rootDir, moduleId, config);
   try {
-    const content = await fs8.readFile(manifestPath, "utf-8");
+    const content = await fs9.readFile(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {
@@ -9921,19 +10166,19 @@ 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.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+  await fs9.mkdir(path24.dirname(manifestPath), { recursive: true });
+  await fs9.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 });
-  await fs8.writeFile(indexFilePath, JSON.stringify(fileIndex, null, 2));
+  const indexFilePath = path24.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+  await fs9.mkdir(path24.dirname(indexFilePath), { recursive: true });
+  await fs9.writeFile(indexFilePath, JSON.stringify(fileIndex, null, 2));
 }
 async function loadGlobalManifest(rootDir, config) {
   const manifestPath = getGlobalManifestPath(rootDir, config);
   try {
-    const content = await fs8.readFile(manifestPath, "utf-8");
+    const content = await fs9.readFile(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -9947,13 +10192,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.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+  await fs9.mkdir(path24.dirname(manifestPath), { recursive: true });
+  await fs9.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 = path24.resolve(rootDir);
   logger.info(`Cleaning up index in: ${rootDir}`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -9983,9 +10228,9 @@ 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 = path24.join(rootDir, filepath);
     try {
-      await fs8.access(fullPath);
+      await fs9.access(fullPath);
       updatedFiles[filepath] = entry;
       result.kept++;
     } catch {
@@ -9995,9 +10240,9 @@ async function cleanupModuleIndex(rootDir, moduleId, config, logger) {
     }
   }
   for (const filepath of filesToRemove) {
-    const indexFilePath = path22.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+    const indexFilePath = path24.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
     try {
-      await fs8.unlink(indexFilePath);
+      await fs9.unlink(indexFilePath);
     } catch {}
   }
   manifest.files = updatedFiles;
@@ -10008,16 +10253,16 @@ async function cleanupModuleIndex(rootDir, moduleId, config, logger) {
 }
 async function cleanupEmptyDirectories(dir) {
   try {
-    const entries = await fs8.readdir(dir, { withFileTypes: true });
+    const entries = await fs9.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const subDir = path22.join(dir, entry.name);
+        const subDir = path24.join(dir, entry.name);
         await cleanupEmptyDirectories(subDir);
       }
     }
-    const remainingEntries = await fs8.readdir(dir);
+    const remainingEntries = await fs9.readdir(dir);
     if (remainingEntries.length === 0) {
-      await fs8.rmdir(dir);
+      await fs9.rmdir(dir);
       return true;
     }
     return false;
@@ -10026,7 +10271,7 @@ async function cleanupEmptyDirectories(dir) {
   }
 }
 async function getIndexStatus(rootDir) {
-  rootDir = path22.resolve(rootDir);
+  rootDir = path24.resolve(rootDir);
   const config = await loadConfig(rootDir);
   const location = getIndexLocation(rootDir);
   const indexDir = location.indexDir;
@@ -10038,13 +10283,13 @@ async function getIndexStatus(rootDir) {
     totalFiles: 0
   };
   try {
-    await fs8.access(indexDir);
+    await fs9.access(indexDir);
   } catch {
     return status;
   }
   try {
     const globalManifestPath = getGlobalManifestPath(rootDir, config);
-    const content = await fs8.readFile(globalManifestPath, "utf-8");
+    const content = await fs9.readFile(globalManifestPath, "utf-8");
     const globalManifest = JSON.parse(content);
     status.exists = true;
     status.lastUpdated = globalManifest.lastUpdated;
@@ -10062,7 +10307,7 @@ async function getIndexStatus(rootDir) {
     }
   } catch {
     try {
-      const entries = await fs8.readdir(path22.join(indexDir, "index"));
+      const entries = await fs9.readdir(path24.join(indexDir, "index"));
       if (entries.length > 0) {
         status.exists = true;
         for (const entry of entries) {
@@ -10082,7 +10327,7 @@ async function getIndexStatus(rootDir) {
   }
   return status;
 }
-var FRESHNESS_CACHE_TTL_MS = 5000, freshnessCache = null, INDEX_SCHEMA_VERSION = "2.0.0", DEFAULT_CONCURRENCY, STAT_CONCURRENCY = 64;
+var FRESHNESS_CACHE_TTL_MS = 5000, freshnessCache = null, INDEX_SCHEMA_VERSION = "2.1.0", DEFAULT_CONCURRENCY, STAT_CONCURRENCY = 64;
 var init_indexer = __esm(() => {
   init_dist();
   init_config2();
@@ -11428,7 +11673,7 @@ var 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, path25, 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;
   }
@@ -11486,11 +11731,11 @@ var init_esm2 = __esm(() => {
   starRE = /^\*+$/;
   qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
   defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-  path23 = {
+  path25 = {
     win32: { sep: "\\" },
     posix: { sep: "/" }
   };
-  sep2 = defaultPlatform === "win32" ? path23.win32.sep : path23.posix.sep;
+  sep2 = defaultPlatform === "win32" ? path25.win32.sep : path25.posix.sep;
   minimatch.sep = sep2;
   GLOBSTAR = Symbol("globstar **");
   minimatch.GLOBSTAR = GLOBSTAR;
@@ -11530,7 +11775,7 @@ function matchesPathFilter(relativePath, filters, matchFn) {
   }
   return false;
 }
-async function executeExactSearch(fs9, options, matchFn) {
+async function executeExactSearch(fs10, options, matchFn) {
   const {
     rootDir,
     literal,
@@ -11542,13 +11787,13 @@ async function executeExactSearch(fs9, options, matchFn) {
   const files = new Map;
   async function walkDir(dir, baseDir) {
     try {
-      const entries = await fs9.readDir(dir);
+      const entries = await fs10.readDir(dir);
       for (const entry of entries) {
-        const fullPath = fs9.join(dir, entry);
-        const relativePath = fs9.relative(baseDir, fullPath);
+        const fullPath = fs10.join(dir, entry);
+        const relativePath = fs10.relative(baseDir, fullPath);
         let isDirectory = false;
         try {
-          const stats = await fs9.getStats(fullPath);
+          const stats = await fs10.getStats(fullPath);
           isDirectory = stats.isDirectory ?? false;
         } catch {
           continue;
@@ -11565,7 +11810,7 @@ async function executeExactSearch(fs9, options, matchFn) {
             }
           }
           try {
-            const content = await fs9.readFile(fullPath);
+            const content = await fs10.readFile(fullPath);
             if (isSearchableContent(content, fullPath)) {
               files.set(relativePath, content);
             }
@@ -11603,21 +11848,21 @@ var init_usecases = __esm(() => {
 });
 
 // src/infrastructure/filesystem/nodeFileSystem.ts
-import * as fs9 from "fs/promises";
-import * as path24 from "path";
+import * as fs10 from "fs/promises";
+import * as path26 from "path";
 import { glob } from "glob";
 
 class NodeFileSystem {
   async readFile(filepath) {
-    return fs9.readFile(filepath, "utf-8");
+    return fs10.readFile(filepath, "utf-8");
   }
   async writeFile(filepath, content) {
-    await fs9.mkdir(path24.dirname(filepath), { recursive: true });
-    await fs9.writeFile(filepath, content, "utf-8");
+    await fs10.mkdir(path26.dirname(filepath), { recursive: true });
+    await fs10.writeFile(filepath, content, "utf-8");
   }
   async deleteFile(filepath) {
     try {
-      await fs9.unlink(filepath);
+      await fs10.unlink(filepath);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
@@ -11625,7 +11870,7 @@ class NodeFileSystem {
     }
   }
   async getStats(filepath) {
-    const stats = await fs9.stat(filepath);
+    const stats = await fs10.stat(filepath);
     return {
       lastModified: stats.mtime.toISOString(),
       size: stats.isDirectory() ? undefined : stats.size,
@@ -11634,17 +11879,17 @@ class NodeFileSystem {
   }
   async exists(filepath) {
     try {
-      await fs9.access(filepath);
+      await fs10.access(filepath);
       return true;
     } catch {
       return false;
     }
   }
   async mkdir(dirpath) {
-    await fs9.mkdir(dirpath, { recursive: true });
+    await fs10.mkdir(dirpath, { recursive: true });
   }
   async readDir(dirpath) {
-    return fs9.readdir(dirpath);
+    return fs10.readdir(dirpath);
   }
   async findFiles(rootDir, patterns, ignore) {
     const ignorePatterns = ignore.map((p) => `**/${p}/**`);
@@ -11660,19 +11905,19 @@ class NodeFileSystem {
     return [...new Set(files)];
   }
   join(...segments) {
-    return path24.join(...segments);
+    return path26.join(...segments);
   }
   relative(from, to) {
-    return path24.relative(from, to);
+    return path26.relative(from, to);
   }
   resolve(...segments) {
-    return path24.resolve(...segments);
+    return path26.resolve(...segments);
   }
   dirname(filepath) {
-    return path24.dirname(filepath);
+    return path26.dirname(filepath);
   }
   extname(filepath) {
-    return path24.extname(filepath);
+    return path26.extname(filepath);
   }
 }
 var nodeFileSystem;
@@ -11693,14 +11938,14 @@ __export(exports_search, {
   formatSearchResults: () => formatSearchResults2,
   formatHybridSearchResults: () => formatHybridSearchResults
 });
-import * as fs10 from "fs/promises";
-import * as path25 from "path";
+import * as fs11 from "fs/promises";
+import * as path27 from "path";
 async function search(rootDir, query, options = {}) {
   const hybridResults = await hybridSearch(rootDir, query, options);
   return hybridResults.results;
 }
 async function hybridSearch(rootDir, query, options = {}) {
-  rootDir = path25.resolve(rootDir);
+  rootDir = path27.resolve(rootDir);
   const ensureFresh = options.ensureFresh ?? DEFAULT_SEARCH_OPTIONS.ensureFresh;
   if (ensureFresh) {
     await ensureIndexFresh(rootDir, { quiet: true });
@@ -11777,15 +12022,15 @@ async function hybridSearch(rootDir, query, options = {}) {
   };
 }
 async function performExactSearch(rootDir, literal, config, options) {
-  const fs11 = new NodeFileSystem;
-  return executeExactSearch(fs11, {
+  const fs12 = new NodeFileSystem;
+  return executeExactSearch(fs12, {
     rootDir,
     literal,
     pathFilter: options.pathFilter,
     maxFiles: 20,
     maxOccurrencesPerFile: 5,
     caseInsensitive: false
-  }, (path26, pattern) => minimatch(path26, pattern, { matchBase: true }));
+  }, (path28, pattern) => minimatch(path28, pattern, { matchBase: true }));
 }
 function createSearchContext(rootDir, moduleId, config) {
   const indexPath = getModuleIndexPath(rootDir, moduleId, config);
@@ -11794,9 +12039,9 @@ function createSearchContext(rootDir, moduleId, config) {
     config,
     loadFileIndex: async (filepath) => {
       const hasExtension = /\.[^./]+$/.test(filepath);
-      const indexFilePath = hasExtension ? path25.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path25.join(indexPath, filepath + ".json");
+      const indexFilePath = hasExtension ? path27.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path27.join(indexPath, filepath + ".json");
       try {
-        const content = await fs10.readFile(indexFilePath, "utf-8");
+        const content = await fs11.readFile(indexFilePath, "utf-8");
         return JSON.parse(content);
       } catch {
         return null;
@@ -11806,7 +12051,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 relative6 = path25.relative(indexPath, f);
+        const relative6 = path27.relative(indexPath, f);
         return relative6.replace(/\.json$/, "");
       });
     }
@@ -11814,9 +12059,9 @@ function createSearchContext(rootDir, moduleId, config) {
 }
 async function traverseDirectory(dir, files, basePath) {
   try {
-    const entries = await fs10.readdir(dir, { withFileTypes: true });
+    const entries = await fs11.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path25.join(dir, entry.name);
+      const fullPath = path27.join(dir, entry.name);
       if (entry.isDirectory()) {
         await traverseDirectory(fullPath, files, basePath);
       } else if (entry.isFile()) {
@@ -11828,7 +12073,7 @@ async function traverseDirectory(dir, files, basePath) {
 async function loadGlobalManifest2(rootDir, config) {
   const manifestPath = getGlobalManifestPath(rootDir, config);
   try {
-    const content = await fs10.readFile(manifestPath, "utf-8");
+    const content = await fs11.readFile(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -11997,18 +12242,18 @@ function getInstallationMethod(openCodeVersion) {
 }
 async function detectOpenCodeVersion() {
   try {
-    const os4 = await import("os");
-    const fs11 = await import("fs/promises");
-    const path26 = await import("path");
-    const homeDir = os4.homedir();
+    const os3 = await import("os");
+    const fs12 = await import("fs/promises");
+    const path28 = await import("path");
+    const homeDir = os3.homedir();
     const possiblePaths = [
-      path26.join(homeDir, ".local", "share", "opencode", "package.json"),
-      path26.join(homeDir, ".config", "opencode", "package.json"),
-      path26.join(homeDir, ".npm", "global", "node_modules", "opencode", "package.json")
+      path28.join(homeDir, ".local", "share", "opencode", "package.json"),
+      path28.join(homeDir, ".config", "opencode", "package.json"),
+      path28.join(homeDir, ".npm", "global", "node_modules", "opencode", "package.json")
     ];
     for (const packagePath of possiblePaths) {
       try {
-        const content = await fs11.readFile(packagePath, "utf-8");
+        const content = await fs12.readFile(packagePath, "utf-8");
         const pkg = JSON.parse(content);
         if (pkg.version) {
           return pkg.version;
@@ -12046,12 +12291,12 @@ async function detectOpenCodeVersion() {
 // src/app/cli/opencode/install-tool.ts
 async function installTool(options = {}) {
   const { logger, checkForOldSkill = true } = options;
-  const os4 = await import("os");
-  const fs11 = await import("fs/promises");
-  const path26 = await import("path");
-  const homeDir = os4.homedir();
-  const toolDir = path26.join(homeDir, ".config", "opencode", "tool");
-  const toolPath = path26.join(toolDir, "raggrep.ts");
+  const os3 = await import("os");
+  const fs12 = await import("fs/promises");
+  const path28 = await import("path");
+  const homeDir = os3.homedir();
+  const toolDir = path28.join(homeDir, ".config", "opencode", "tool");
+  const toolPath = path28.join(toolDir, "raggrep.ts");
   let removedOldSkill = false;
   const toolContent = `import { tool } from "@opencode-ai/plugin";
 
@@ -12134,11 +12379,11 @@ Please install raggrep globally:
 `;
   try {
     if (checkForOldSkill) {
-      const oldSkillDir = path26.join(homeDir, ".config", "opencode", "skill", "raggrep");
-      const oldSkillPath = path26.join(oldSkillDir, "SKILL.md");
+      const oldSkillDir = path28.join(homeDir, ".config", "opencode", "skill", "raggrep");
+      const oldSkillPath = path28.join(oldSkillDir, "SKILL.md");
       let oldSkillExists = false;
       try {
-        await fs11.access(oldSkillPath);
+        await fs12.access(oldSkillPath);
         oldSkillExists = true;
       } catch {}
       if (oldSkillExists) {
@@ -12163,11 +12408,11 @@ Please install raggrep globally:
         const shouldDelete = answer.toLowerCase() !== "n";
         if (shouldDelete) {
           try {
-            await fs11.unlink(oldSkillPath);
-            const skillDirContents = await fs11.readdir(oldSkillDir);
+            await fs12.unlink(oldSkillPath);
+            const skillDirContents = await fs12.readdir(oldSkillDir);
             if (skillDirContents.length === 0) {
               try {
-                await fs11.rmdir(oldSkillDir);
+                await fs12.rmdir(oldSkillDir);
                 console.log("✓ Removed old skill directory.");
               } catch (rmdirError) {
                 console.log("✓ Removed old skill file. (Directory not empty or other error)");
@@ -12204,8 +12449,8 @@ Please install raggrep globally:
         }
       }
     }
-    await fs11.mkdir(toolDir, { recursive: true });
-    await fs11.writeFile(toolPath, toolContent, "utf-8");
+    await fs12.mkdir(toolDir, { recursive: true });
+    await fs12.writeFile(toolPath, toolContent, "utf-8");
     const message = `Installed raggrep tool for OpenCode.
   Location: ${toolPath}
 
@@ -12238,12 +12483,12 @@ The raggrep tool is now available in OpenCode.`;
 // src/app/cli/opencode/install-skill.ts
 async function installSkill(options = {}) {
   const { logger, checkForOldTool = true } = options;
-  const os4 = await import("os");
-  const fs11 = await import("fs/promises");
-  const path26 = await import("path");
-  const homeDir = os4.homedir();
-  const skillDir = path26.join(homeDir, ".config", "opencode", "skill", "raggrep");
-  const skillPath = path26.join(skillDir, "SKILL.md");
+  const os3 = await import("os");
+  const fs12 = await import("fs/promises");
+  const path28 = await import("path");
+  const homeDir = os3.homedir();
+  const skillDir = path28.join(homeDir, ".config", "opencode", "skill", "raggrep");
+  const skillPath = path28.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.
@@ -12283,19 +12528,32 @@ pnpm add -g raggrep
 \`\`\`
 
 ### Step 1: Index your codebase
+
+Index data is written to **\`<project>/.raggrep/\`** inside the directory you target. Add \`.raggrep/\` to \`.gitignore\` if you do not want it in version control.
+
+From the repository root:
 \`\`\`bash
-# Navigate to your project directory and index it
 cd /path/to/your/project
 raggrep index
 \`\`\`
 
+Or pass the project path explicitly (no \`cd\` needed; same flag as \`git -C\`):
+\`\`\`bash
+raggrep index --dir /path/to/your/project
+# short form:
+raggrep index -C ~/projects/my-app
+\`\`\`
+
 ### Step 2: Use semantic search
+
 \`\`\`bash
-# Search for specific functionality
+# Search for specific functionality (from project root, or use --dir / -C)
 raggrep query "user authentication"
+raggrep query -C /path/to/your/project "user authentication"
 
 # Search with filters
 raggrep query "React hooks for data fetching" --filter "src/components"
+raggrep query -C /path/to/your/project "React hooks" --filter "src/components"
 
 # Search with specific file types
 raggrep query "database connection" --type ts
@@ -12304,6 +12562,8 @@ raggrep query "database connection" --type ts
 raggrep query "error handling" --top 15
 \`\`\`
 
+Use **\`-C\` / \`--dir\`** on \`raggrep query\`, \`raggrep index\`, \`raggrep status\`, and \`raggrep reset\` when the shell is not already in the repository root.
+
 ### Step 3: Use in OpenCode agents
 
 Load this skill in your agent conversation:
@@ -12339,6 +12599,7 @@ Instead of using grep/rg or manually reading files:
 
 ✅ **DO this instead:**
 - \`raggrep query "Find the auth middleware"\` (finds ALL auth-related code)
+- \`raggrep query -C /path/to/repo "Find the auth middleware"\` (when not \`cd\`'d into the repo)
 - \`raggrep query "Where are React components?"\`
 - \`raggrep query "Database connection logic?"\`
 - \`raggrep query "Error handling patterns"\`
@@ -12349,17 +12610,18 @@ Instead of using grep/rg or manually reading files:
 2. **Use filters strategically**: \`--filter "src/auth"\`, \`--filter "*.test.ts"\`
 3. **Adjust result count**: Use \`--top 5\` for focused results, \`--top 20\` for comprehensive search
 4. **Replace grep/rg habits**: Instead of \`rg "pattern"\`, try \`raggrep query "what the code does"\`
+5. **Target the right tree**: If your shell is not in the repo root, use \`-C /path/to/repo\` or \`--dir\` on every command so the index under that repo's \`.raggrep/\` stays aligned with searches
 
 **Result**: 10x fewer tool calls, BETTER results, deeper code understanding.
 `;
   let removedOldTool = false;
   try {
     if (checkForOldTool) {
-      const oldToolDir = path26.join(homeDir, ".config", "opencode", "tool");
-      const oldToolPath = path26.join(oldToolDir, "raggrep.ts");
+      const oldToolDir = path28.join(homeDir, ".config", "opencode", "tool");
+      const oldToolPath = path28.join(oldToolDir, "raggrep.ts");
       let oldToolExists = false;
       try {
-        await fs11.access(oldToolPath);
+        await fs12.access(oldToolPath);
         oldToolExists = true;
       } catch {}
       if (oldToolExists) {
@@ -12384,11 +12646,11 @@ Instead of using grep/rg or manually reading files:
         const shouldDelete = answer.toLowerCase() !== "n";
         if (shouldDelete) {
           try {
-            await fs11.unlink(oldToolPath);
-            const toolDirContents = await fs11.readdir(oldToolDir);
+            await fs12.unlink(oldToolPath);
+            const toolDirContents = await fs12.readdir(oldToolDir);
             if (toolDirContents.length === 0) {
               try {
-                await fs11.rmdir(oldToolDir);
+                await fs12.rmdir(oldToolDir);
                 console.log("✓ Removed old tool directory.");
               } catch (rmdirError) {
                 console.log("✓ Removed old tool file. (Directory not empty or other error)");
@@ -12421,8 +12683,8 @@ Instead of using grep/rg or manually reading files:
         }
       }
     }
-    await fs11.mkdir(skillDir, { recursive: true });
-    await fs11.writeFile(skillPath, skillContent, "utf-8");
+    await fs12.mkdir(skillDir, { recursive: true });
+    await fs12.writeFile(skillPath, skillContent, "utf-8");
     const message = `Installed raggrep skill for OpenCode.
   Location: ${skillPath}
 
@@ -12430,7 +12692,7 @@ The raggrep skill is now available to OpenCode agents.
 
 To use this skill:
 1. Install raggrep: npm install -g raggrep
-2. Index your codebase: raggrep index
+2. Index your codebase: \`cd\` to the repo and \`raggrep index\`, or \`raggrep index --dir /path/to/repo\`
 3. In OpenCode, load the skill: skill({ name: "raggrep" })`;
     if (logger) {
       logger.info(message);
@@ -12472,10 +12734,12 @@ var init_opencode = () => {};
 // src/app/cli/main.ts
 init_embeddings();
 init_logger();
+import * as path28 from "path";
+import { stat as stat3 } from "fs/promises";
 // package.json
 var package_default = {
   name: "raggrep",
-  version: "0.15.0",
+  version: "0.17.0",
   description: "Local filesystem-based RAG system for codebases - semantic search using local embeddings",
   type: "module",
   main: "./dist/index.js",
@@ -12497,12 +12761,15 @@ var package_default = {
   scripts: {
     build: "bun run build:clean && bun run build:bundle && bun run build:types && bun run build:shebang",
     "build:clean": "rm -rf dist",
-    "build:bundle": "bun build src/index.ts --outdir dist --target node --sourcemap=external --external '@xenova/transformers' --external 'glob' --external 'typescript' --external 'chokidar' --external 'web-tree-sitter' && bun build src/app/cli/main.ts --outdir dist/cli --target node --sourcemap=external --external '@xenova/transformers' --external 'glob' --external 'typescript' --external 'chokidar' --external 'web-tree-sitter'",
-    "build:types": "tsc --emitDeclarationOnly --outDir dist",
+    "build:bundle": "bun build src/index.ts --outdir dist --target node --sourcemap=external --external '@xenova/transformers' --external '@huggingface/transformers' --external 'glob' --external 'typescript' --external 'chokidar' --external 'web-tree-sitter' && bun build src/app/cli/main.ts --outdir dist/cli --target node --sourcemap=external --external '@xenova/transformers' --external '@huggingface/transformers' --external 'glob' --external 'typescript' --external 'chokidar' --external 'web-tree-sitter'",
+    "build:types": "tsc --project tsconfig.json --noEmit false --declaration true --emitDeclarationOnly true --rootDir ./src --outDir ./dist",
     "build:shebang": "echo '#!/usr/bin/env node' | cat - dist/cli/main.js > temp && mv temp dist/cli/main.js && chmod +x dist/cli/main.js",
     prepublishOnly: "bun run build",
     raggrep: "bun run src/app/cli/main.ts",
     test: "bun test",
+    typecheck: "tsc --noEmit -p tsconfig.json && tsc --noEmit -p scripts/tsconfig.json",
+    "bench:embeddings": "bun run scripts/benchmark-embedding-runtimes.ts",
+    "bench:retrieval": "bun run scripts/benchmark-retrieval-quality.ts",
     dev: "bun run src/app/cli/main.ts"
   },
   keywords: [
@@ -12530,6 +12797,7 @@ var package_default = {
     node: ">=18.0.0"
   },
   dependencies: {
+    "@huggingface/transformers": "^4.0.0",
     "@xenova/transformers": "^2.17.0",
     chokidar: "^5.0.0",
     fdir: "^6.5.0",
@@ -12638,6 +12906,14 @@ function parseFlags(args2) {
         console.error('--filter requires a path or glob pattern (e.g., src/auth, "*.ts")');
         process.exit(1);
       }
+    } else if (arg === "--dir" || arg === "-C") {
+      const dir = args2[++i];
+      if (dir) {
+        flags.projectDir = dir;
+      } else {
+        console.error("--dir / -C requires a path to the project directory to index or search.");
+        process.exit(1);
+      }
     } else if (arg === "--tool") {
       flags.forceTool = true;
     } else if (arg === "--skill") {
@@ -12648,6 +12924,20 @@ function parseFlags(args2) {
   }
   return flags;
 }
+async function resolveProjectRoot(flags) {
+  const root = path28.resolve(flags.projectDir ?? process.cwd());
+  try {
+    const st = await stat3(root);
+    if (!st.isDirectory()) {
+      console.error(`Error: not a directory: ${root}`);
+      process.exit(1);
+    }
+  } catch {
+    console.error(`Error: directory does not exist or is not accessible: ${root}`);
+    process.exit(1);
+  }
+  return root;
+}
 async function main() {
   const flags = parseFlags(args.slice(1));
   switch (command) {
@@ -12655,14 +12945,15 @@ async function main() {
       if (flags.help) {
         const models = Object.keys(EMBEDDING_MODELS).join(", ");
         console.log(`
-raggrep index - Index the current directory for semantic search
+raggrep index - Index a directory for semantic search
 
 Usage:
   raggrep index [options]
 
 Options:
+  -C, --dir <path>         Project directory to index (default: current directory)
   -w, --watch              Watch for file changes and re-index automatically
-  -m, --model <name>       Embedding model to use (default: bge-small-en-v1.5)
+  -m, --model <name>       Override embedding model for the TypeScript module (default: saved config, else bge-small-en-v1.5)
   -c, --concurrency <n>    Number of files to process in parallel (default: auto)
   -v, --verbose            Show detailed progress
   -h, --help               Show this help message
@@ -12674,6 +12965,7 @@ Model Cache: ${getCacheDir()}
 
 Examples:
   raggrep index
+  raggrep index --dir ../other-repo
   raggrep index --watch
   raggrep index --model bge-small-en-v1.5
   raggrep index --concurrency 8
@@ -12683,11 +12975,12 @@ Examples:
       }
       const { indexDirectory: indexDirectory3, watchDirectory: watchDirectory2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
       const logger = createInlineLogger({ verbose: flags.verbose });
+      const projectRoot = await resolveProjectRoot(flags);
       console.log("RAGgrep Indexer");
       console.log(`================
 `);
       try {
-        const results = await indexDirectory3(process.cwd(), {
+        const results = await indexDirectory3(projectRoot, {
           model: flags.model,
           verbose: flags.verbose,
           concurrency: flags.concurrency,
@@ -12710,7 +13003,7 @@ Examples:
         console.log(`└─────────────────────────────────────────┘
 `);
         try {
-          const watcher = await watchDirectory2(process.cwd(), {
+          const watcher = await watchDirectory2(projectRoot, {
             model: flags.model,
             verbose: flags.verbose,
             onFileChange: (event, filepath) => {
@@ -12747,6 +13040,7 @@ Usage:
   raggrep query <search query> [options]
 
 Options:
+  -C, --dir <path>     Project directory to search (default: current directory)
   -k, --top <n>        Number of results to return (default: 10)
   -s, --min-score <n>  Minimum similarity score 0-1 (default: 0.15)
   -t, --type <ext>     Filter by file extension (e.g., ts, tsx, js)
@@ -12774,6 +13068,7 @@ Multiple Filters (OR logic):
 
 Examples:
   raggrep query "user authentication"
+  raggrep query --dir ~/projects/my-app "user authentication"
   raggrep query "handle errors" --top 5
   raggrep query "database" --min-score 0.1
   raggrep query "interface" --type ts
@@ -12799,9 +13094,10 @@ Examples:
         console.error('Run "raggrep query --help" for more information.');
         process.exit(1);
       }
+      const projectRoot = await resolveProjectRoot(flags);
       try {
         const silentLogger = createSilentLogger();
-        const freshStats = await ensureIndexFresh2(process.cwd(), {
+        const freshStats = await ensureIndexFresh2(projectRoot, {
           model: flags.model,
           quiet: true,
           logger: silentLogger,
@@ -12842,7 +13138,7 @@ Examples:
         }
         const filePatterns = flags.fileType ? [`*.${flags.fileType}`] : undefined;
         const { hybridSearch: hybridSearch2, formatHybridSearchResults: formatHybridSearchResults2 } = await Promise.resolve().then(() => (init_search(), exports_search));
-        const hybridResults = await hybridSearch2(process.cwd(), query, {
+        const hybridResults = await hybridSearch2(projectRoot, query, {
           topK: flags.topK ?? 10,
           minScore: flags.minScore,
           filePatterns,
@@ -12859,26 +13155,29 @@ Examples:
     case "reset": {
       if (flags.help) {
         console.log(`
-raggrep reset - Clear the index for the current directory
+raggrep reset - Clear the index for a project directory
 
 Usage:
   raggrep reset [options]
 
 Options:
+  -C, --dir <path>     Project directory whose index to remove (default: current directory)
   -h, --help           Show this help message
 
 Description:
-  Completely removes the index for the current directory.
+  Completely removes the .raggrep index for the project directory.
   The next 'raggrep index' or 'raggrep query' will rebuild from scratch.
 
 Examples:
   raggrep reset
+  raggrep reset --dir ../other-repo
 `);
         process.exit(0);
       }
       const { resetIndex: resetIndex2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
+      const projectRoot = await resolveProjectRoot(flags);
       try {
-        const result = await resetIndex2(process.cwd());
+        const result = await resetIndex2(projectRoot);
         console.log("Index cleared successfully.");
         console.log(`  Removed: ${result.indexDir}`);
       } catch (error) {
@@ -12900,21 +13199,24 @@ Usage:
   raggrep status [options]
 
 Options:
+  -C, --dir <path>     Project directory to report on (default: current directory)
   -h, --help           Show this help message
 
 Description:
-  Displays information about the index in the current directory,
+  Displays information about the index for the project directory,
   including whether it exists, how many files are indexed, and
   when it was last updated.
 
 Examples:
   raggrep status
+  raggrep status --dir ../other-repo
 `);
         process.exit(0);
       }
       const { getIndexStatus: getIndexStatus2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
+      const projectRoot = await resolveProjectRoot(flags);
       try {
-        const status = await getIndexStatus2(process.cwd());
+        const status = await getIndexStatus2(projectRoot);
         if (!status.exists) {
           console.log(`
 ┌─────────────────────────────────────────┐
@@ -13045,19 +13347,23 @@ Usage:
   raggrep <command> [options]
 
 Commands:
-  index      Index the current directory
+  index      Index a project directory
   query      Search the indexed codebase
   status     Show the current state of the index
-  reset      Clear the index for the current directory
+  reset      Clear the index for a project directory
   opencode   Manage opencode integration
 
 Options:
   -h, --help     Show help for a command
   -v, --version  Show version number
 
+Project directory (index, query, status, reset):
+  Use -C or --dir <path> to target a directory other than the current one.
+
 Examples:
   raggrep index
   raggrep query "user login"
+  raggrep query -C ~/projects/app "user login"
   raggrep status
   raggrep reset
   raggrep opencode install
@@ -13072,4 +13378,4 @@ Run 'raggrep <command> --help' for more information.
 }
 main();
 
-//# debugId=2B4BB49E8FD1AEE664756E2164756E21
+//# debugId=6B05E3A822FD1AE664756E2164756E21