raggrep 0.15.0 → 0.17.0

package/dist/index.js

@@ -1,27 +1,16 @@
 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);
@@ -54,49 +43,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",
@@ -166,6 +143,10 @@ var init_config = __esm(() => {
     ".sql",
     ".txt"
   ];
+  DEFAULT_EMBEDDING_MODULE_OPTIONS = {
+    embeddingModel: "bge-small-en-v1.5",
+    embeddingRuntime: "huggingface"
+  };
 });
 
 // src/domain/entities/literal.ts
@@ -195,24 +176,48 @@ var init_entities = __esm(() => {
   init_lexicon();
 });
 
+// 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/config/configLoader.ts
 import * as path from "path";
 import * as fs from "fs/promises";
-import * as os from "os";
 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 = path.resolve(rootDir);
-  const projectHash = hashPath(absoluteRoot);
-  return path.join(RAGGREP_TEMP_BASE, projectHash);
+  return path.join(absoluteRoot, RAGGREP_INDEX_DIR);
 }
 function getIndexLocation(rootDir) {
   const absoluteRoot = path.resolve(rootDir);
   const projectHash = hashPath(absoluteRoot);
   return {
-    indexDir: path.join(RAGGREP_TEMP_BASE, projectHash),
+    indexDir: path.join(absoluteRoot, RAGGREP_INDEX_DIR),
     projectRoot: absoluteRoot,
     projectHash
   };
@@ -253,23 +258,24 @@ function getEmbeddingConfigFromModule(moduleConfig) {
     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_MODELS;
+var DEFAULT_CONFIG, RAGGREP_INDEX_DIR = ".raggrep";
 var init_configLoader = __esm(() => {
   init_entities();
+  init_modelCatalog();
   DEFAULT_CONFIG = createDefaultConfig();
-  RAGGREP_TEMP_BASE = path.join(os.tmpdir(), "raggrep-indexes");
-  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"
-  };
 });
 
 // src/infrastructure/config/index.ts
@@ -2137,22 +2143,47 @@ var init_core = __esm(() => {
   init_symbols();
 });
 
-// src/infrastructure/embeddings/transformersEmbedding.ts
+// src/infrastructure/embeddings/embeddingPaths.ts
+import * as os from "os";
+import * as path6 from "path";
+var RAGGREP_MODEL_CACHE_DIR;
+var init_embeddingPaths = __esm(() => {
+  RAGGREP_MODEL_CACHE_DIR = path6.join(os.homedir(), ".cache", "raggrep", "models");
+});
+
+// src/infrastructure/embeddings/modelCache.ts
+import * as fs3 from "fs/promises";
+import * as path7 from "path";
+async function isEmbeddingModelCached(model) {
+  const modelId = getEmbeddingModelId(model);
+  const onnxPath = path7.join(RAGGREP_MODEL_CACHE_DIR, modelId, "onnx", "model_quantized.onnx");
+  try {
+    await fs3.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 path6 from "path";
-import * as os2 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
     };
@@ -2160,14 +2191,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) {
@@ -2175,14 +2206,14 @@ class TransformersEmbeddingProvider {
     }
     this.isInitializing = true;
     this.initPromise = (async () => {
-      const modelId = EMBEDDING_MODELS2[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;
@@ -2191,7 +2222,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;
@@ -2221,9 +2252,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 {
@@ -2234,11 +2265,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
     });
@@ -2247,15 +2278,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
         });
@@ -2266,41 +2297,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;
   }
 }
-async function isModelCached(model) {
-  const modelId = EMBEDDING_MODELS2[model];
-  const modelPath = path6.join(CACHE_DIR, modelId);
-  try {
-    const fs3 = await import("fs/promises");
-    const onnxPath = path6.join(modelPath, "onnx", "model_quantized.onnx");
-    await fs3.access(onnxPath);
-    return true;
-  } catch {
-    return false;
+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;
   }
 }
+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;
 }
@@ -2312,27 +2512,14 @@ async function getEmbeddings(texts) {
   const provider = await ensureGlobalProvider();
   return provider.getEmbeddings(texts);
 }
-var CACHE_DIR, EMBEDDING_MODELS2, EMBEDDING_DIMENSIONS, BATCH_SIZE = 32, globalProvider = null, globalConfig;
-var init_transformersEmbedding = __esm(() => {
-  CACHE_DIR = path6.join(os2.homedir(), ".cache", "raggrep", "models");
-  env.cacheDir = CACHE_DIR;
-  env.allowLocalModels = true;
-  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"
-  };
-  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
-  };
+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
   };
@@ -2340,7 +2527,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/domain/services/keywords.ts
@@ -2551,7 +2744,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));
@@ -2567,11 +2760,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) {
@@ -3646,8 +3839,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"
   }));
@@ -3957,6 +4150,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();
@@ -3969,6 +4218,7 @@ var init_services = __esm(() => {
   init_configValidator();
   init_phraseMatch();
   init_simpleSearch();
+  init_chunkContext();
 });
 
 // src/modules/language/typescript/parseCode.ts
@@ -4140,11 +4390,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;
@@ -4153,7 +4404,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() {
@@ -4239,13 +4490,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) {
@@ -4256,21 +4507,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);
@@ -4282,14 +4533,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);
@@ -4301,18 +4552,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;
@@ -4344,8 +4595,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;
@@ -4354,7 +4605,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() {
@@ -4515,17 +4766,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}`);
@@ -4534,8 +4785,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;
@@ -4578,7 +4829,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 = () => {};
 
@@ -4599,9 +4850,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) {
@@ -4663,8 +4914,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) {
@@ -4675,13 +4924,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) => ({
@@ -4705,25 +4958,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) {
@@ -5002,16 +5251,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);
       }
     }
@@ -5039,7 +5288,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"];
@@ -5055,12 +5304,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,
@@ -5077,7 +5326,7 @@ class TypeScriptParser {
     }
   }
   canParse(filepath) {
-    const ext = path11.extname(filepath).toLowerCase();
+    const ext = path13.extname(filepath).toLowerCase();
     return TYPESCRIPT_EXTENSIONS2.includes(ext);
   }
   convertChunk(tc) {
@@ -5092,7 +5341,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";
     }
@@ -5297,8 +5546,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 = [
@@ -5320,7 +5569,7 @@ class TreeSitterParser {
         chunks: [],
         language: "typescript",
         success: false,
-        error: `Unsupported file type: ${path12.extname(filepath)}`
+        error: `Unsupported file type: ${path14.extname(filepath)}`
       };
     }
     try {
@@ -5340,11 +5589,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() {
@@ -5378,20 +5627,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;
         }
       }
@@ -5432,7 +5681,7 @@ class TreeSitterParser {
         startLine: 1,
         endLine: lines.length,
         type: "file",
-        name: path12.basename(filepath),
+        name: path14.basename(filepath),
         isExported: false
       });
     }
@@ -5779,7 +6028,7 @@ class TreeSitterParser {
       startLine: 1,
       endLine: lines.length,
       type: "file",
-      name: path12.basename(filepath)
+      name: path14.basename(filepath)
     });
     return {
       chunks,
@@ -5788,7 +6037,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 = {
@@ -5809,7 +6058,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;
@@ -5823,7 +6072,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;
@@ -5872,9 +6121,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) {
@@ -5958,7 +6207,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;
@@ -6036,12 +6285,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) => ({
@@ -6064,25 +6314,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) {
@@ -6335,9 +6581,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) {
@@ -6422,7 +6668,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;
@@ -6571,12 +6817,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) => ({
@@ -6599,25 +6846,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) {
@@ -6819,9 +7062,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) {
@@ -6908,7 +7151,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;
@@ -7134,12 +7377,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) => ({
@@ -7162,25 +7406,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) {
@@ -7382,9 +7622,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);
 }
 
@@ -7418,7 +7658,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(`
 `);
@@ -7625,7 +7865,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;
@@ -7645,7 +7885,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) {
@@ -7777,9 +8017,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) => ({
@@ -7803,14 +8045,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 {
@@ -7941,6 +8186,11 @@ var init_markdown = __esm(() => {
   supportsFile6 = isMarkdownFile;
 });
 
+// src/types.ts
+var init_types = __esm(() => {
+  init_entities();
+});
+
 // node_modules/fdir/dist/index.mjs
 import { createRequire as createRequire2 } from "module";
 import { basename, dirname, normalize, relative, resolve, sep } from "path";
@@ -8476,9 +8726,9 @@ var Builder = class {
 
 // src/app/indexer/index.ts
 init_config2();
-import * as fs8 from "fs/promises";
-import * as path21 from "path";
-import * as os3 from "os";
+import * as fs9 from "fs/promises";
+import * as path23 from "path";
+import * as os2 from "os";
 import * as crypto2 from "crypto";
 
 // src/modules/registry.ts
@@ -8519,13 +8769,13 @@ async function registerBuiltInModules() {
 }
 
 // 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";
 
 // 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";
 var MAX_SCAN_DEPTH = 4;
 var SKIP_DIRS = new Set([
   "node_modules",
@@ -8541,9 +8791,9 @@ 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);
@@ -8564,10 +8814,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"]) {
@@ -8603,7 +8853,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));
@@ -8612,9 +8862,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;
@@ -8643,8 +8893,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 };
@@ -8684,8 +8934,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 {}
@@ -8699,7 +8949,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;
@@ -8735,28 +8985,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();
@@ -8764,14 +9014,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);
         }
@@ -9027,7 +9277,7 @@ async function parallelMap(items, processor, concurrency) {
   await Promise.all(workers);
   return results;
 }
-var INDEX_SCHEMA_VERSION = "2.0.0";
+var INDEX_SCHEMA_VERSION = "2.1.0";
 function formatDuration(ms) {
   if (ms < 1000) {
     return `${ms}ms`;
@@ -9041,7 +9291,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;
 }
@@ -9053,7 +9303,7 @@ async function indexDirectory(rootDir, options = {}) {
   const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
   clearFreshnessCache();
   const logger = options.logger ? options.logger : quiet ? createSilentLogger() : createLogger({ verbose });
-  rootDir = path21.resolve(rootDir);
+  rootDir = path23.resolve(rootDir);
   const location = getIndexLocation(rootDir);
   logger.info(`Indexing directory: ${rootDir}`);
   logger.info(`Index location: ${location.indexDir}`);
@@ -9105,12 +9355,12 @@ async function indexDirectory(rootDir, options = {}) {
         rootDir,
         config,
         readFile: async (filepath) => {
-          const fullPath = path21.isAbsolute(filepath) ? filepath : path21.join(rootDir, filepath);
-          return fs8.readFile(fullPath, "utf-8");
+          const fullPath = path23.isAbsolute(filepath) ? filepath : path23.join(rootDir, filepath);
+          return fs9.readFile(fullPath, "utf-8");
         },
         getFileStats: async (filepath) => {
-          const fullPath = path21.isAbsolute(filepath) ? filepath : path21.join(rootDir, filepath);
-          const stats = await fs8.stat(fullPath);
+          const fullPath = path23.isAbsolute(filepath) ? filepath : path23.join(rootDir, filepath);
+          const stats = await fs9.stat(fullPath);
           return { lastModified: stats.mtime.toISOString() };
         }
       };
@@ -9135,7 +9385,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 {
@@ -9145,11 +9395,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 = path21.resolve(rootDir);
+  rootDir = path23.resolve(rootDir);
   clearFreshnessCache();
   const status = await getIndexStatus(rootDir);
   if (!status.exists) {
@@ -9174,7 +9424,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
   let filesChanged = 0;
   let filesReindexed = 0;
   const logger = options.logger ? options.logger : quiet ? createSilentLogger() : createLogger({ verbose });
-  rootDir = path21.resolve(rootDir);
+  rootDir = path23.resolve(rootDir);
   const status = await getIndexStatus(rootDir);
   if (!status.exists) {
     clearFreshnessCache();
@@ -9198,7 +9448,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();
@@ -9236,7 +9486,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) => path21.relative(rootDir, f)));
+  const currentFileSet = new Set(currentFiles.map((f) => path23.relative(rootDir, f)));
   const changedFileSet = new Set(changedFiles);
   let totalIndexed = 0;
   let totalRemoved = 0;
@@ -9270,11 +9520,11 @@ async function ensureIndexFresh(rootDir, options = {}) {
     if (filesToRemove.length > 0) {
       await Promise.all(filesToRemove.map(async (filepath) => {
         logger.debug(`  Removing stale: ${filepath}`);
-        const indexFilePath = path21.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
-        const symbolicFilePath = path21.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
+        const indexFilePath = path23.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+        const symbolicFilePath = path23.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
         await Promise.all([
-          fs8.unlink(indexFilePath).catch(() => {}),
-          fs8.unlink(symbolicFilePath).catch(() => {})
+          fs9.unlink(indexFilePath).catch(() => {}),
+          fs9.unlink(symbolicFilePath).catch(() => {})
         ]);
         delete manifest.files[filepath];
         removedFilepaths.push(filepath);
@@ -9298,19 +9548,19 @@ async function ensureIndexFresh(rootDir, options = {}) {
       rootDir,
       config,
       readFile: async (filepath) => {
-        const fullPath = path21.isAbsolute(filepath) ? filepath : path21.join(rootDir, filepath);
-        return fs8.readFile(fullPath, "utf-8");
+        const fullPath = path23.isAbsolute(filepath) ? filepath : path23.join(rootDir, filepath);
+        return fs9.readFile(fullPath, "utf-8");
       },
       getFileStats: async (filepath) => {
-        const fullPath = path21.isAbsolute(filepath) ? filepath : path21.join(rootDir, filepath);
-        const stats = await fs8.stat(fullPath);
+        const fullPath = path23.isAbsolute(filepath) ? filepath : path23.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 = path21.relative(rootDir, filepath);
+      const relativePath = path23.relative(rootDir, filepath);
       const existingEntry = manifest.files[relativePath];
       const lastModified = changedFileMtimes.get(filepath) || new Date().toISOString();
       return {
@@ -9340,7 +9590,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++;
@@ -9467,7 +9717,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 = {
@@ -9487,7 +9737,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) => path21.relative(rootDir, f)));
+  const currentFileSet = new Set(files.map((f) => path23.relative(rootDir, f)));
   const filesToRemove = [];
   for (const filepath of Object.keys(manifest.files)) {
     if (!currentFileSet.has(filepath)) {
@@ -9498,13 +9748,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 = path21.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+      const indexFilePath = path23.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
       try {
-        await fs8.unlink(indexFilePath);
+        await fs9.unlink(indexFilePath);
       } catch {}
-      const symbolicFilePath = path21.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
+      const symbolicFilePath = path23.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
       try {
-        await fs8.unlink(symbolicFilePath);
+        await fs9.unlink(symbolicFilePath);
       } catch {}
       delete manifest.files[filepath];
     }
@@ -9514,12 +9764,12 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
     rootDir,
     config,
     readFile: async (filepath) => {
-      const fullPath = path21.isAbsolute(filepath) ? filepath : path21.join(rootDir, filepath);
-      return fs8.readFile(fullPath, "utf-8");
+      const fullPath = path23.isAbsolute(filepath) ? filepath : path23.join(rootDir, filepath);
+      return fs9.readFile(fullPath, "utf-8");
     },
     getFileStats: async (filepath) => {
-      const fullPath = path21.isAbsolute(filepath) ? filepath : path21.join(rootDir, filepath);
-      const stats = await fs8.stat(fullPath);
+      const fullPath = path23.isAbsolute(filepath) ? filepath : path23.join(rootDir, filepath);
+      const stats = await fs9.stat(fullPath);
       return { lastModified: stats.mtime.toISOString() };
     },
     getIntrospection: (filepath) => introspection.getFile(filepath)
@@ -9531,9 +9781,9 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
   let indexedCount = 0;
   let skippedCount = 0;
   const processFile = async (filepath, _index) => {
-    const relativePath = path21.relative(rootDir, filepath);
+    const relativePath = path23.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) {
@@ -9543,7 +9793,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++;
@@ -9625,8 +9875,8 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
 }
 var STAT_CONCURRENCY = 64;
 function isLikelyBinary(filepath) {
-  const ext = path21.extname(filepath).toLowerCase();
-  const basename15 = path21.basename(filepath).toLowerCase();
+  const ext = path23.extname(filepath).toLowerCase();
+  const basename15 = path23.basename(filepath).toLowerCase();
   const binaryExtensions = new Set([
     ".png",
     ".jpg",
@@ -9702,7 +9952,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 = path21.extname(filePath);
+    const ext = path23.extname(filePath);
     return validExtensions.has(ext);
   }).crawl(rootDir);
   const allFiles = await crawler.withPromise();
@@ -9710,7 +9960,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);
@@ -9724,7 +9974,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());
@@ -9744,7 +9994,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 {
@@ -9757,19 +10007,19 @@ async function loadModuleManifest(rootDir, moduleId, config) {
 }
 async function writeModuleManifest(rootDir, moduleId, manifest, config) {
   const manifestPath = getModuleManifestPath(rootDir, moduleId, config);
-  await fs8.mkdir(path21.dirname(manifestPath), { recursive: true });
-  await fs8.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+  await fs9.mkdir(path23.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 = path21.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
-  await fs8.mkdir(path21.dirname(indexFilePath), { recursive: true });
-  await fs8.writeFile(indexFilePath, JSON.stringify(fileIndex, null, 2));
+  const indexFilePath = path23.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+  await fs9.mkdir(path23.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;
@@ -9783,13 +10033,13 @@ async function updateGlobalManifest(rootDir, modules, config, indexStartTime) {
     lastIndexStarted: indexStartTime,
     modules: modules.map((m) => m.id)
   };
-  await fs8.mkdir(path21.dirname(manifestPath), { recursive: true });
-  await fs8.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+  await fs9.mkdir(path23.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 = path21.resolve(rootDir);
+  rootDir = path23.resolve(rootDir);
   logger.info(`Cleaning up index in: ${rootDir}`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -9819,9 +10069,9 @@ async function cleanupModuleIndex(rootDir, moduleId, config, logger) {
   const filesToRemove = [];
   const updatedFiles = {};
   for (const [filepath, entry] of Object.entries(manifest.files)) {
-    const fullPath = path21.join(rootDir, filepath);
+    const fullPath = path23.join(rootDir, filepath);
     try {
-      await fs8.access(fullPath);
+      await fs9.access(fullPath);
       updatedFiles[filepath] = entry;
       result.kept++;
     } catch {
@@ -9831,9 +10081,9 @@ async function cleanupModuleIndex(rootDir, moduleId, config, logger) {
     }
   }
   for (const filepath of filesToRemove) {
-    const indexFilePath = path21.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+    const indexFilePath = path23.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
     try {
-      await fs8.unlink(indexFilePath);
+      await fs9.unlink(indexFilePath);
     } catch {}
   }
   manifest.files = updatedFiles;
@@ -9844,16 +10094,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 = path21.join(dir, entry.name);
+        const subDir = path23.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;
@@ -9862,7 +10112,7 @@ async function cleanupEmptyDirectories(dir) {
   }
 }
 async function getIndexStatus(rootDir) {
-  rootDir = path21.resolve(rootDir);
+  rootDir = path23.resolve(rootDir);
   const config = await loadConfig(rootDir);
   const location = getIndexLocation(rootDir);
   const indexDir = location.indexDir;
@@ -9874,13 +10124,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;
@@ -9898,7 +10148,7 @@ async function getIndexStatus(rootDir) {
     }
   } catch {
     try {
-      const entries = await fs8.readdir(path21.join(indexDir, "index"));
+      const entries = await fs9.readdir(path23.join(indexDir, "index"));
       if (entries.length > 0) {
         status.exists = true;
         for (const entry of entries) {
@@ -9920,8 +10170,8 @@ async function getIndexStatus(rootDir) {
 }
 
 // src/app/search/index.ts
-import * as fs10 from "fs/promises";
-import * as path24 from "path";
+import * as fs11 from "fs/promises";
+import * as path26 from "path";
 
 // node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a, b, str) => {
@@ -10724,11 +10974,11 @@ var qmarksTestNoExtDot = ([$0]) => {
   return (f) => f.length === len && f !== "." && f !== "..";
 };
 var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-var path22 = {
+var path24 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep2 = defaultPlatform === "win32" ? path22.win32.sep : path22.posix.sep;
+var sep2 = defaultPlatform === "win32" ? path24.win32.sep : path24.posix.sep;
 minimatch.sep = sep2;
 var GLOBSTAR = Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
@@ -11357,10 +11607,8 @@ minimatch.Minimatch = Minimatch;
 minimatch.escape = escape;
 minimatch.unescape = unescape;
 
-// src/types.ts
-init_entities();
-
 // src/app/search/index.ts
+init_types();
 init_config2();
 init_services();
 // src/domain/usecases/exactSearch.ts
@@ -11394,7 +11642,7 @@ function matchesPathFilter(relativePath, filters, matchFn) {
   }
   return false;
 }
-async function executeExactSearch(fs9, options, matchFn) {
+async function executeExactSearch(fs10, options, matchFn) {
   const {
     rootDir,
     literal,
@@ -11406,13 +11654,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;
@@ -11429,7 +11677,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);
             }
@@ -11446,21 +11694,21 @@ async function executeExactSearch(fs9, options, matchFn) {
   });
 }
 // src/infrastructure/filesystem/nodeFileSystem.ts
-import * as fs9 from "fs/promises";
-import * as path23 from "path";
+import * as fs10 from "fs/promises";
+import * as path25 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(path23.dirname(filepath), { recursive: true });
-    await fs9.writeFile(filepath, content, "utf-8");
+    await fs10.mkdir(path25.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;
@@ -11468,7 +11716,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,
@@ -11477,17 +11725,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}/**`);
@@ -11503,19 +11751,19 @@ class NodeFileSystem {
     return [...new Set(files)];
   }
   join(...segments) {
-    return path23.join(...segments);
+    return path25.join(...segments);
   }
   relative(from, to) {
-    return path23.relative(from, to);
+    return path25.relative(from, to);
   }
   resolve(...segments) {
-    return path23.resolve(...segments);
+    return path25.resolve(...segments);
   }
   dirname(filepath) {
-    return path23.dirname(filepath);
+    return path25.dirname(filepath);
   }
   extname(filepath) {
-    return path23.extname(filepath);
+    return path25.extname(filepath);
   }
 }
 var nodeFileSystem = new NodeFileSystem;
@@ -11525,7 +11773,7 @@ async function search(rootDir, query, options = {}) {
   return hybridResults.results;
 }
 async function hybridSearch(rootDir, query, options = {}) {
-  rootDir = path24.resolve(rootDir);
+  rootDir = path26.resolve(rootDir);
   const ensureFresh = options.ensureFresh ?? DEFAULT_SEARCH_OPTIONS.ensureFresh;
   if (ensureFresh) {
     await ensureIndexFresh(rootDir, { quiet: true });
@@ -11602,15 +11850,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
-  }, (path25, pattern) => minimatch(path25, pattern, { matchBase: true }));
+  }, (path27, pattern) => minimatch(path27, pattern, { matchBase: true }));
 }
 function createSearchContext(rootDir, moduleId, config) {
   const indexPath = getModuleIndexPath(rootDir, moduleId, config);
@@ -11619,9 +11867,9 @@ function createSearchContext(rootDir, moduleId, config) {
     config,
     loadFileIndex: async (filepath) => {
       const hasExtension = /\.[^./]+$/.test(filepath);
-      const indexFilePath = hasExtension ? path24.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path24.join(indexPath, filepath + ".json");
+      const indexFilePath = hasExtension ? path26.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path26.join(indexPath, filepath + ".json");
       try {
-        const content = await fs10.readFile(indexFilePath, "utf-8");
+        const content = await fs11.readFile(indexFilePath, "utf-8");
         return JSON.parse(content);
       } catch {
         return null;
@@ -11631,7 +11879,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 relative5 = path24.relative(indexPath, f);
+        const relative5 = path26.relative(indexPath, f);
         return relative5.replace(/\.json$/, "");
       });
     }
@@ -11639,9 +11887,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 = path24.join(dir, entry.name);
+      const fullPath = path26.join(dir, entry.name);
       if (entry.isDirectory()) {
         await traverseDirectory(fullPath, files, basePath);
       } else if (entry.isFile()) {
@@ -11653,7 +11901,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;
@@ -11822,4 +12070,4 @@ export {
   ConsoleLogger
 };
 
-//# debugId=095586B82981352264756E2164756E21
+//# debugId=5C9139B3A95BD0AB64756E2164756E21