raggrep 0.3.0 → 0.5.0

package/dist/cli/main.js

@@ -1,5 +1,21 @@
 #!/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 __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -10,6 +26,7 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/infrastructure/embeddings/transformersEmbedding.ts
 import {
@@ -27,7 +44,8 @@ class TransformersEmbeddingProvider {
   constructor(config) {
     this.config = {
       model: config?.model ?? "all-MiniLM-L6-v2",
-      showProgress: config?.showProgress ?? false
+      showProgress: config?.showProgress ?? false,
+      logger: config?.logger
     };
   }
   async initialize(config) {
@@ -49,29 +67,55 @@ class TransformersEmbeddingProvider {
     this.isInitializing = true;
     this.initPromise = (async () => {
       const modelId = EMBEDDING_MODELS[this.config.model];
-      if (this.config.showProgress) {
-        console.log(`
-  Loading embedding model: ${this.config.model}`);
-        console.log(`  Cache: ${CACHE_DIR}`);
-      }
+      const logger = this.config.logger;
+      const showProgress = this.config.showProgress || !!logger;
+      const isCached = await isModelCached(this.config.model);
+      let hasDownloads = false;
       try {
         this.pipeline = await pipeline("feature-extraction", modelId, {
-          progress_callback: this.config.showProgress ? (progress) => {
+          progress_callback: showProgress && !isCached ? (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: ${CACHE_DIR}`);
+                }
+              }
               const pct = progress.progress ? Math.round(progress.progress) : 0;
-              process.stdout.write(`\r  Downloading ${progress.file}: ${pct}%   `);
+              if (logger) {
+                logger.progress(`  Downloading ${progress.file}: ${pct}%`);
+              } else {
+                process.stdout.write(`\r  Downloading ${progress.file}: ${pct}%   `);
+              }
             } else if (progress.status === "done" && progress.file) {
-              process.stdout.write(`\r  Downloaded ${progress.file}              
+              if (logger) {
+                logger.clearProgress();
+                logger.info(`  Downloaded ${progress.file}`);
+              } else if (hasDownloads) {
+                process.stdout.write(`\r  Downloaded ${progress.file}              
 `);
+              }
             }
           } : undefined
         });
-        if (this.config.showProgress) {
-          console.log(`  Model ready.
+        if (hasDownloads) {
+          if (logger) {
+            logger.clearProgress();
+            logger.info(`Model ready: ${this.config.model}`);
+          } else {
+            console.log(`  Model ready.
 `);
+          }
         }
       } catch (error) {
         this.pipeline = null;
+        if (logger) {
+          logger.clearProgress();
+        }
         throw new Error(`Failed to load embedding model: ${error}`);
       } finally {
         this.isInitializing = false;
@@ -125,9 +169,21 @@ class TransformersEmbeddingProvider {
 function getCacheDir() {
   return CACHE_DIR;
 }
+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;
+  }
+}
 function configureEmbeddings(config) {
   const newConfig = { ...globalConfig, ...config };
-  if (newConfig.model !== globalConfig.model) {
+  if (newConfig.model !== globalConfig.model || newConfig.logger !== globalConfig.logger) {
     globalProvider = null;
   }
   globalConfig = newConfig;
@@ -163,7 +219,8 @@ var init_transformersEmbedding = __esm(() => {
   };
   globalConfig = {
     model: "all-MiniLM-L6-v2",
-    showProgress: false
+    showProgress: false,
+    logger: undefined
   };
 });
 
@@ -171,6 +228,96 @@ var init_transformersEmbedding = __esm(() => {
 var init_embeddings = __esm(() => {
   init_transformersEmbedding();
 });
+
+// src/infrastructure/logger/loggers.ts
+class ConsoleLogger {
+  verbose;
+  constructor(options) {
+    this.verbose = options?.verbose ?? false;
+  }
+  info(message) {
+    console.log(message);
+  }
+  warn(message) {
+    console.warn(message);
+  }
+  error(message) {
+    console.error(message);
+  }
+  debug(message) {
+    if (this.verbose) {
+      console.log(message);
+    }
+  }
+  progress(message) {
+    console.log(message);
+  }
+  clearProgress() {}
+}
+
+class InlineProgressLogger {
+  verbose;
+  lastProgressLength = 0;
+  hasProgress = false;
+  constructor(options) {
+    this.verbose = options?.verbose ?? false;
+  }
+  info(message) {
+    this.clearProgress();
+    console.log(message);
+  }
+  warn(message) {
+    this.clearProgress();
+    console.warn(message);
+  }
+  error(message) {
+    this.clearProgress();
+    console.error(message);
+  }
+  debug(message) {
+    if (this.verbose) {
+      this.clearProgress();
+      console.log(message);
+    }
+  }
+  progress(message) {
+    process.stdout.write(`\r${message}`);
+    const padding = Math.max(0, this.lastProgressLength - message.length);
+    if (padding > 0) {
+      process.stdout.write(" ".repeat(padding));
+    }
+    this.lastProgressLength = message.length;
+    this.hasProgress = true;
+  }
+  clearProgress() {
+    if (this.hasProgress && this.lastProgressLength > 0) {
+      process.stdout.write("\r" + " ".repeat(this.lastProgressLength) + "\r");
+      this.lastProgressLength = 0;
+      this.hasProgress = false;
+    }
+  }
+}
+
+class SilentLogger {
+  info() {}
+  warn() {}
+  error() {}
+  debug() {}
+  progress() {}
+  clearProgress() {}
+}
+function createLogger(options) {
+  return new ConsoleLogger(options);
+}
+function createInlineLogger(options) {
+  return new InlineProgressLogger(options);
+}
+function createSilentLogger() {
+  return new SilentLogger;
+}
+
+// src/infrastructure/logger/index.ts
+var init_logger = () => {};
 // src/domain/entities/searchResult.ts
 var DEFAULT_SEARCH_OPTIONS;
 var init_searchResult = __esm(() => {
@@ -201,6 +348,20 @@ function createDefaultConfig() {
         options: {
           embeddingModel: "all-MiniLM-L6-v2"
         }
+      },
+      {
+        id: "data/json",
+        enabled: true,
+        options: {
+          embeddingModel: "all-MiniLM-L6-v2"
+        }
+      },
+      {
+        id: "docs/markdown",
+        enabled: true,
+        options: {
+          embeddingModel: "all-MiniLM-L6-v2"
+        }
       }
     ]
   };
@@ -244,16 +405,18 @@ var init_config = __esm(() => {
     ".jsx",
     ".mjs",
     ".cjs",
+    ".mts",
+    ".cts",
+    ".json",
+    ".md",
     ".py",
     ".go",
     ".rs",
     ".java",
-    ".json",
     ".yaml",
     ".yml",
     ".toml",
     ".sql",
-    ".md",
     ".txt"
   ];
 });
@@ -2145,6 +2308,194 @@ var init_core = __esm(() => {
   init_symbols();
 });
 
+// src/domain/services/keywords.ts
+function extractKeywords(content, name, maxKeywords = 50) {
+  const keywords = new Set;
+  if (name) {
+    keywords.add(name.toLowerCase());
+    const parts = name.split(/(?=[A-Z])/).map((p) => p.toLowerCase());
+    parts.forEach((p) => p.length > 2 && keywords.add(p));
+  }
+  const identifierRegex = /\b([a-zA-Z_][a-zA-Z0-9_]{2,})\b/g;
+  let match;
+  while ((match = identifierRegex.exec(content)) !== null) {
+    const word = match[1].toLowerCase();
+    if (!COMMON_KEYWORDS.has(word) && word.length > 2) {
+      keywords.add(word);
+    }
+  }
+  return Array.from(keywords).slice(0, maxKeywords);
+}
+function splitIdentifier(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").split(/\s+/).map((s) => s.toLowerCase()).filter((s) => s.length > 1);
+}
+function extractPathKeywords(filepath) {
+  const keywords = new Set;
+  const pathWithoutExt = filepath.replace(/\.[^.]+$/, "");
+  const segments = pathWithoutExt.split(/[/\\]/);
+  for (const segment of segments) {
+    if (segment.length < 2)
+      continue;
+    const lower = segment.toLowerCase();
+    if (!COMMON_KEYWORDS.has(lower) && lower.length > 2) {
+      keywords.add(lower);
+    }
+    const parts = splitIdentifier(segment);
+    for (const part of parts) {
+      if (!COMMON_KEYWORDS.has(part) && part.length > 2) {
+        keywords.add(part);
+      }
+    }
+  }
+  return Array.from(keywords);
+}
+function parsePathContext(filepath) {
+  const pathWithoutExt = filepath.replace(/\.[^.]+$/, "");
+  const allSegments = pathWithoutExt.split(/[/\\]/);
+  const filename = allSegments[allSegments.length - 1];
+  const dirSegments = allSegments.slice(0, -1);
+  const keywords = extractPathKeywords(filepath);
+  let layer;
+  const allLower = [...dirSegments, filename].map((s) => s.toLowerCase()).join(" ");
+  const filenameLower = filename.toLowerCase();
+  for (const [layerName, patterns] of Object.entries(LAYER_PATTERNS2)) {
+    for (const pattern of patterns) {
+      if (filenameLower.includes(pattern)) {
+        layer = layerName;
+        break;
+      }
+      if (dirSegments.some((s) => s.toLowerCase() === pattern)) {
+        layer = layerName;
+        break;
+      }
+    }
+    if (layer)
+      break;
+  }
+  let domain;
+  const layerPatternSet = new Set(Object.values(LAYER_PATTERNS2).flat());
+  const reversedSegments = [...dirSegments].reverse();
+  for (const segment of reversedSegments) {
+    const lower = segment.toLowerCase();
+    if (["src", "lib", "app", "packages", "modules"].includes(lower))
+      continue;
+    if (layerPatternSet.has(lower))
+      continue;
+    if (lower.length > 2) {
+      domain = lower;
+      break;
+    }
+  }
+  return {
+    segments: dirSegments,
+    layer,
+    domain,
+    depth: dirSegments.length,
+    keywords
+  };
+}
+function formatPathContextForEmbedding(pathContext) {
+  const parts = [];
+  if (pathContext.domain) {
+    parts.push(pathContext.domain);
+  }
+  if (pathContext.layer) {
+    parts.push(pathContext.layer);
+  }
+  const significantSegments = pathContext.segments.slice(-3).filter((s) => s.length > 2 && !["src", "lib", "app"].includes(s.toLowerCase()));
+  if (significantSegments.length > 0) {
+    parts.push(...significantSegments.map((s) => s.toLowerCase()));
+  }
+  if (parts.length === 0)
+    return "";
+  const unique = [...new Set(parts)];
+  return `[${unique.join(" ")}]`;
+}
+var COMMON_KEYWORDS, LAYER_PATTERNS2;
+var init_keywords = __esm(() => {
+  COMMON_KEYWORDS = new Set([
+    "const",
+    "let",
+    "var",
+    "function",
+    "class",
+    "interface",
+    "type",
+    "enum",
+    "export",
+    "import",
+    "from",
+    "return",
+    "async",
+    "await",
+    "new",
+    "this",
+    "true",
+    "false",
+    "null",
+    "undefined",
+    "if",
+    "else",
+    "for",
+    "while",
+    "switch",
+    "case",
+    "break",
+    "continue",
+    "try",
+    "catch",
+    "finally",
+    "throw",
+    "typeof",
+    "instanceof",
+    "void",
+    "delete",
+    "in",
+    "of",
+    "string",
+    "number",
+    "boolean",
+    "any",
+    "unknown",
+    "never",
+    "object",
+    "public",
+    "private",
+    "protected",
+    "static",
+    "readonly",
+    "abstract",
+    "implements",
+    "extends",
+    "super",
+    "get",
+    "set",
+    "constructor",
+    "the",
+    "and",
+    "for",
+    "not",
+    "with",
+    "are",
+    "was",
+    "has",
+    "have"
+  ]);
+  LAYER_PATTERNS2 = {
+    controller: ["controller", "controllers", "handler", "handlers", "route", "routes", "api"],
+    service: ["service", "services", "usecase", "usecases", "application"],
+    repository: ["repository", "repositories", "repo", "repos", "dao", "store", "storage"],
+    model: ["model", "models", "entity", "entities", "schema", "schemas"],
+    util: ["util", "utils", "utility", "utilities", "helper", "helpers", "common", "shared"],
+    config: ["config", "configs", "configuration", "settings"],
+    middleware: ["middleware", "middlewares", "interceptor", "interceptors"],
+    domain: ["domain", "core", "business"],
+    infrastructure: ["infrastructure", "infra", "external", "adapters"],
+    presentation: ["presentation", "view", "views", "component", "components", "ui"],
+    test: ["test", "tests", "spec", "specs", "__tests__", "__test__"]
+  };
+});
+
 // src/domain/services/similarity.ts
 function cosineSimilarity(a, b) {
   if (a.length !== b.length) {
@@ -2164,17 +2515,151 @@ function cosineSimilarity(a, b) {
   return dotProduct / magnitude;
 }
 
-// src/modules/language/typescript/parseCode.ts
-import * as ts from "typescript";
-function parseCode(content, filepath) {
-  const ext = filepath.split(".").pop()?.toLowerCase();
-  if (["ts", "tsx", "js", "jsx", "mts", "cts", "mjs", "cjs"].includes(ext || "")) {
-    return parseTypeScript(content, filepath);
+// src/domain/services/queryIntent.ts
+import * as path7 from "path";
+function detectQueryIntent(queryTerms) {
+  const hasImplementationTerm = queryTerms.some((term) => IMPLEMENTATION_TERMS.includes(term));
+  const hasDocumentationTerm = queryTerms.some((term) => DOCUMENTATION_TERMS.includes(term));
+  if (hasDocumentationTerm) {
+    return "documentation";
+  }
+  if (hasImplementationTerm) {
+    return "implementation";
   }
-  return parseGenericCode(content);
+  return "neutral";
 }
-function parseTypeScript(content, filepath) {
-  const chunks = [];
+function extractQueryTerms(query) {
+  return query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+}
+function isSourceCodeFile(filepath) {
+  const ext = path7.extname(filepath).toLowerCase();
+  return SOURCE_CODE_EXTENSIONS.includes(ext);
+}
+function isDocFile(filepath) {
+  const ext = path7.extname(filepath).toLowerCase();
+  return DOC_EXTENSIONS.includes(ext);
+}
+function calculateFileTypeBoost(filepath, queryTerms) {
+  const isSourceCode = isSourceCodeFile(filepath);
+  const isDoc = isDocFile(filepath);
+  const intent = detectQueryIntent(queryTerms);
+  if (intent === "implementation") {
+    if (isSourceCode) {
+      return 0.06;
+    }
+    return 0;
+  }
+  if (intent === "documentation") {
+    if (isDoc) {
+      return 0.08;
+    }
+    return 0;
+  }
+  return 0;
+}
+var IMPLEMENTATION_TERMS, DOCUMENTATION_TERMS, SOURCE_CODE_EXTENSIONS, DOC_EXTENSIONS;
+var init_queryIntent = __esm(() => {
+  IMPLEMENTATION_TERMS = [
+    "function",
+    "method",
+    "class",
+    "interface",
+    "implement",
+    "implementation",
+    "endpoint",
+    "route",
+    "handler",
+    "controller",
+    "module",
+    "code"
+  ];
+  DOCUMENTATION_TERMS = [
+    "documentation",
+    "docs",
+    "guide",
+    "tutorial",
+    "readme",
+    "how",
+    "what",
+    "why",
+    "explain",
+    "overview",
+    "getting",
+    "started",
+    "requirements",
+    "setup",
+    "install",
+    "configure",
+    "configuration"
+  ];
+  SOURCE_CODE_EXTENSIONS = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".py",
+    ".go",
+    ".rs",
+    ".java"
+  ];
+  DOC_EXTENSIONS = [".md", ".txt", ".rst"];
+});
+
+// src/domain/services/chunking.ts
+function createLineBasedChunks(content, options = {}) {
+  const {
+    chunkSize = DEFAULT_CHUNK_SIZE,
+    overlap = DEFAULT_OVERLAP,
+    minLinesForMultipleChunks = chunkSize
+  } = options;
+  const lines = content.split(`
+`);
+  const chunks = [];
+  if (lines.length <= minLinesForMultipleChunks) {
+    return [
+      {
+        content,
+        startLine: 1,
+        endLine: lines.length,
+        type: "file"
+      }
+    ];
+  }
+  for (let i = 0;i < lines.length; i += chunkSize - overlap) {
+    const endIdx = Math.min(i + chunkSize, lines.length);
+    chunks.push({
+      content: lines.slice(i, endIdx).join(`
+`),
+      startLine: i + 1,
+      endLine: endIdx,
+      type: "block"
+    });
+    if (endIdx >= lines.length)
+      break;
+  }
+  return chunks;
+}
+function generateChunkId(filepath, startLine, endLine) {
+  const safePath = filepath.replace(/[/\\]/g, "-").replace(/\./g, "_");
+  return `${safePath}-${startLine}-${endLine}`;
+}
+var DEFAULT_CHUNK_SIZE = 30, DEFAULT_OVERLAP = 5;
+
+// src/domain/services/index.ts
+var init_services = __esm(() => {
+  init_keywords();
+  init_queryIntent();
+});
+
+// src/modules/language/typescript/parseCode.ts
+import * as ts from "typescript";
+function parseTypeScriptCode(content, filepath) {
+  return parseTypeScript(content, filepath);
+}
+function parseTypeScript(content, filepath) {
+  const chunks = [];
   const lines = content.split(`
 `);
   const sourceFile = ts.createSourceFile(filepath, content, ts.ScriptTarget.Latest, true, filepath.endsWith(".tsx") || filepath.endsWith(".jsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
@@ -2315,41 +2800,20 @@ function parseTypeScript(content, filepath) {
   }
   ts.forEachChild(sourceFile, visit);
   if (chunks.length === 0) {
-    return parseGenericCode(content);
-  }
-  return chunks;
-}
-function parseGenericCode(content) {
-  const chunks = [];
-  const lines = content.split(`
+    const lines2 = content.split(`
 `);
-  const CHUNK_SIZE = 30;
-  const OVERLAP = 5;
-  if (lines.length <= CHUNK_SIZE) {
     return [
       {
         content,
         startLine: 1,
-        endLine: lines.length,
+        endLine: lines2.length,
         type: "file"
       }
     ];
   }
-  for (let i = 0;i < lines.length; i += CHUNK_SIZE - OVERLAP) {
-    const endIdx = Math.min(i + CHUNK_SIZE, lines.length);
-    chunks.push({
-      content: lines.slice(i, endIdx).join(`
-`),
-      startLine: i + 1,
-      endLine: endIdx,
-      type: "block"
-    });
-    if (endIdx >= lines.length)
-      break;
-  }
   return chunks;
 }
-function generateChunkId(filepath, startLine, endLine) {
+function generateChunkId2(filepath, startLine, endLine) {
   const safePath = filepath.replace(/[/\\]/g, "-").replace(/\./g, "_");
   return `${safePath}-${startLine}-${endLine}`;
 }
@@ -2360,256 +2824,68 @@ var init_fileIndexStorage = __esm(() => {
   init_entities();
 });
 
-// src/domain/services/keywords.ts
-function extractKeywords(content, name, maxKeywords = 50) {
-  const keywords = new Set;
-  if (name) {
-    keywords.add(name.toLowerCase());
-    const parts = name.split(/(?=[A-Z])/).map((p) => p.toLowerCase());
-    parts.forEach((p) => p.length > 2 && keywords.add(p));
+// src/infrastructure/storage/symbolicIndex.ts
+import * as fs3 from "fs/promises";
+import * as path8 from "path";
+
+class SymbolicIndex {
+  meta = null;
+  fileSummaries = new Map;
+  bm25Index = null;
+  symbolicPath;
+  moduleId;
+  constructor(indexDir, moduleId) {
+    this.symbolicPath = path8.join(indexDir, "index", moduleId, "symbolic");
+    this.moduleId = moduleId;
   }
-  const identifierRegex = /\b([a-zA-Z_][a-zA-Z0-9_]{2,})\b/g;
-  let match;
-  while ((match = identifierRegex.exec(content)) !== null) {
-    const word = match[1].toLowerCase();
-    if (!COMMON_KEYWORDS.has(word) && word.length > 2) {
-      keywords.add(word);
+  async initialize() {
+    try {
+      await this.load();
+    } catch {
+      this.meta = {
+        version: "1.0.0",
+        lastUpdated: new Date().toISOString(),
+        moduleId: this.moduleId,
+        fileCount: 0,
+        bm25Data: {
+          avgDocLength: 0,
+          documentFrequencies: {},
+          totalDocs: 0
+        }
+      };
+      this.bm25Index = new BM25Index;
     }
   }
-  return Array.from(keywords).slice(0, maxKeywords);
-}
-function splitIdentifier(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").split(/\s+/).map((s) => s.toLowerCase()).filter((s) => s.length > 1);
-}
-function extractPathKeywords(filepath) {
-  const keywords = new Set;
-  const pathWithoutExt = filepath.replace(/\.[^.]+$/, "");
-  const segments = pathWithoutExt.split(/[/\\]/);
-  for (const segment of segments) {
-    if (segment.length < 2)
-      continue;
-    const lower = segment.toLowerCase();
-    if (!COMMON_KEYWORDS.has(lower) && lower.length > 2) {
-      keywords.add(lower);
+  addFile(summary) {
+    this.fileSummaries.set(summary.filepath, summary);
+  }
+  removeFile(filepath) {
+    return this.fileSummaries.delete(filepath);
+  }
+  buildBM25Index() {
+    this.bm25Index = new BM25Index;
+    for (const [filepath, summary] of this.fileSummaries) {
+      const content = [
+        ...summary.keywords,
+        ...summary.exports,
+        ...extractPathKeywords(filepath)
+      ].join(" ");
+      this.bm25Index.addDocuments([{ id: filepath, content }]);
     }
-    const parts = splitIdentifier(segment);
-    for (const part of parts) {
-      if (!COMMON_KEYWORDS.has(part) && part.length > 2) {
-        keywords.add(part);
-      }
+    if (this.meta) {
+      this.meta.fileCount = this.fileSummaries.size;
+      this.meta.bm25Data.totalDocs = this.fileSummaries.size;
     }
   }
-  return Array.from(keywords);
-}
-function parsePathContext(filepath) {
-  const pathWithoutExt = filepath.replace(/\.[^.]+$/, "");
-  const allSegments = pathWithoutExt.split(/[/\\]/);
-  const filename = allSegments[allSegments.length - 1];
-  const dirSegments = allSegments.slice(0, -1);
-  const keywords = extractPathKeywords(filepath);
-  let layer;
-  const allLower = [...dirSegments, filename].map((s) => s.toLowerCase()).join(" ");
-  const filenameLower = filename.toLowerCase();
-  for (const [layerName, patterns] of Object.entries(LAYER_PATTERNS2)) {
-    for (const pattern of patterns) {
-      if (filenameLower.includes(pattern)) {
-        layer = layerName;
-        break;
-      }
-      if (dirSegments.some((s) => s.toLowerCase() === pattern)) {
-        layer = layerName;
-        break;
-      }
+  findCandidates(query, maxCandidates = 20) {
+    if (!this.bm25Index) {
+      return Array.from(this.fileSummaries.keys());
     }
-    if (layer)
-      break;
+    const results = this.bm25Index.search(query, maxCandidates);
+    return results.map((r) => r.id);
   }
-  let domain;
-  const layerPatternSet = new Set(Object.values(LAYER_PATTERNS2).flat());
-  const reversedSegments = [...dirSegments].reverse();
-  for (const segment of reversedSegments) {
-    const lower = segment.toLowerCase();
-    if (["src", "lib", "app", "packages", "modules"].includes(lower))
-      continue;
-    if (layerPatternSet.has(lower))
-      continue;
-    if (lower.length > 2) {
-      domain = lower;
-      break;
-    }
-  }
-  return {
-    segments: dirSegments,
-    layer,
-    domain,
-    depth: dirSegments.length,
-    keywords
-  };
-}
-function formatPathContextForEmbedding(pathContext) {
-  const parts = [];
-  if (pathContext.domain) {
-    parts.push(pathContext.domain);
-  }
-  if (pathContext.layer) {
-    parts.push(pathContext.layer);
-  }
-  const significantSegments = pathContext.segments.slice(-3).filter((s) => s.length > 2 && !["src", "lib", "app"].includes(s.toLowerCase()));
-  if (significantSegments.length > 0) {
-    parts.push(...significantSegments.map((s) => s.toLowerCase()));
-  }
-  if (parts.length === 0)
-    return "";
-  const unique = [...new Set(parts)];
-  return `[${unique.join(" ")}]`;
-}
-var COMMON_KEYWORDS, LAYER_PATTERNS2;
-var init_keywords = __esm(() => {
-  COMMON_KEYWORDS = new Set([
-    "const",
-    "let",
-    "var",
-    "function",
-    "class",
-    "interface",
-    "type",
-    "enum",
-    "export",
-    "import",
-    "from",
-    "return",
-    "async",
-    "await",
-    "new",
-    "this",
-    "true",
-    "false",
-    "null",
-    "undefined",
-    "if",
-    "else",
-    "for",
-    "while",
-    "switch",
-    "case",
-    "break",
-    "continue",
-    "try",
-    "catch",
-    "finally",
-    "throw",
-    "typeof",
-    "instanceof",
-    "void",
-    "delete",
-    "in",
-    "of",
-    "string",
-    "number",
-    "boolean",
-    "any",
-    "unknown",
-    "never",
-    "object",
-    "public",
-    "private",
-    "protected",
-    "static",
-    "readonly",
-    "abstract",
-    "implements",
-    "extends",
-    "super",
-    "get",
-    "set",
-    "constructor",
-    "the",
-    "and",
-    "for",
-    "not",
-    "with",
-    "are",
-    "was",
-    "has",
-    "have"
-  ]);
-  LAYER_PATTERNS2 = {
-    controller: ["controller", "controllers", "handler", "handlers", "route", "routes", "api"],
-    service: ["service", "services", "usecase", "usecases", "application"],
-    repository: ["repository", "repositories", "repo", "repos", "dao", "store", "storage"],
-    model: ["model", "models", "entity", "entities", "schema", "schemas"],
-    util: ["util", "utils", "utility", "utilities", "helper", "helpers", "common", "shared"],
-    config: ["config", "configs", "configuration", "settings"],
-    middleware: ["middleware", "middlewares", "interceptor", "interceptors"],
-    domain: ["domain", "core", "business"],
-    infrastructure: ["infrastructure", "infra", "external", "adapters"],
-    presentation: ["presentation", "view", "views", "component", "components", "ui"],
-    test: ["test", "tests", "spec", "specs", "__tests__", "__test__"]
-  };
-});
-
-// src/infrastructure/storage/symbolicIndex.ts
-import * as fs3 from "fs/promises";
-import * as path7 from "path";
-
-class SymbolicIndex {
-  meta = null;
-  fileSummaries = new Map;
-  bm25Index = null;
-  symbolicPath;
-  moduleId;
-  constructor(indexDir, moduleId) {
-    this.symbolicPath = path7.join(indexDir, "index", moduleId, "symbolic");
-    this.moduleId = moduleId;
-  }
-  async initialize() {
-    try {
-      await this.load();
-    } catch {
-      this.meta = {
-        version: "1.0.0",
-        lastUpdated: new Date().toISOString(),
-        moduleId: this.moduleId,
-        fileCount: 0,
-        bm25Data: {
-          avgDocLength: 0,
-          documentFrequencies: {},
-          totalDocs: 0
-        }
-      };
-      this.bm25Index = new BM25Index;
-    }
-  }
-  addFile(summary) {
-    this.fileSummaries.set(summary.filepath, summary);
-  }
-  removeFile(filepath) {
-    return this.fileSummaries.delete(filepath);
-  }
-  buildBM25Index() {
-    this.bm25Index = new BM25Index;
-    for (const [filepath, summary] of this.fileSummaries) {
-      const content = [
-        ...summary.keywords,
-        ...summary.exports,
-        ...extractPathKeywords(filepath)
-      ].join(" ");
-      this.bm25Index.addDocuments([{ id: filepath, content }]);
-    }
-    if (this.meta) {
-      this.meta.fileCount = this.fileSummaries.size;
-      this.meta.bm25Data.totalDocs = this.fileSummaries.size;
-    }
-  }
-  findCandidates(query, maxCandidates = 20) {
-    if (!this.bm25Index) {
-      return Array.from(this.fileSummaries.keys());
-    }
-    const results = this.bm25Index.search(query, maxCandidates);
-    return results.map((r) => r.id);
-  }
-  getAllFiles() {
-    return Array.from(this.fileSummaries.keys());
+  getAllFiles() {
+    return Array.from(this.fileSummaries.keys());
   }
   getFileSummary(filepath) {
     return this.fileSummaries.get(filepath);
@@ -2620,16 +2896,16 @@ class SymbolicIndex {
     this.meta.lastUpdated = new Date().toISOString();
     this.meta.fileCount = this.fileSummaries.size;
     await fs3.mkdir(this.symbolicPath, { recursive: true });
-    const metaPath = path7.join(this.symbolicPath, "_meta.json");
+    const metaPath = path8.join(this.symbolicPath, "_meta.json");
     await fs3.writeFile(metaPath, JSON.stringify(this.meta, null, 2));
     for (const [filepath, summary] of this.fileSummaries) {
       const summaryPath = this.getFileSummaryPath(filepath);
-      await fs3.mkdir(path7.dirname(summaryPath), { recursive: true });
+      await fs3.mkdir(path8.dirname(summaryPath), { recursive: true });
       await fs3.writeFile(summaryPath, JSON.stringify(summary, null, 2));
     }
   }
   async load() {
-    const metaPath = path7.join(this.symbolicPath, "_meta.json");
+    const metaPath = path8.join(this.symbolicPath, "_meta.json");
     const metaContent = await fs3.readFile(metaPath, "utf-8");
     this.meta = JSON.parse(metaContent);
     this.fileSummaries.clear();
@@ -2640,7 +2916,7 @@ class SymbolicIndex {
     try {
       const entries = await fs3.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path7.join(dir, entry.name);
+        const fullPath = path8.join(dir, entry.name);
         if (entry.isDirectory()) {
           await this.loadFileSummariesRecursive(fullPath);
         } else if (entry.name.endsWith(".json") && entry.name !== "_meta.json") {
@@ -2657,7 +2933,7 @@ class SymbolicIndex {
   }
   getFileSummaryPath(filepath) {
     const jsonPath = filepath.replace(/\.[^.]+$/, ".json");
-    return path7.join(this.symbolicPath, jsonPath);
+    return path8.join(this.symbolicPath, jsonPath);
   }
   async deleteFileSummary(filepath) {
     try {
@@ -2667,7 +2943,7 @@ class SymbolicIndex {
   }
   async exists() {
     try {
-      const metaPath = path7.join(this.symbolicPath, "_meta.json");
+      const metaPath = path8.join(this.symbolicPath, "_meta.json");
       await fs3.access(metaPath);
       return true;
     } catch {
@@ -2703,40 +2979,16 @@ var init_storage = __esm(() => {
 // src/modules/language/typescript/index.ts
 var exports_typescript = {};
 __export(exports_typescript, {
+  isTypeScriptFile: () => isTypeScriptFile,
   TypeScriptModule: () => TypeScriptModule,
+  TYPESCRIPT_EXTENSIONS: () => TYPESCRIPT_EXTENSIONS,
   DEFAULT_TOP_K: () => DEFAULT_TOP_K2,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE2
 });
-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));
-  if (hasDocumentationTerm) {
-    return "documentation";
-  }
-  if (hasImplementationTerm) {
-    return "implementation";
-  }
-  return "neutral";
-}
-function calculateFileTypeBoost(filepath, queryTerms) {
-  const ext = path8.extname(filepath).toLowerCase();
-  const isSourceCode = SOURCE_CODE_EXTENSIONS.includes(ext);
-  const isDoc = DOC_EXTENSIONS.includes(ext);
-  const intent = detectQueryIntent(queryTerms);
-  if (intent === "implementation") {
-    if (isSourceCode) {
-      return 0.06;
-    }
-    return 0;
-  }
-  if (intent === "documentation") {
-    if (isDoc) {
-      return 0.08;
-    }
-    return 0;
-  }
-  return 0;
+import * as path9 from "path";
+function isTypeScriptFile(filepath) {
+  const ext = path9.extname(filepath).toLowerCase();
+  return TYPESCRIPT_EXTENSIONS.includes(ext);
 }
 function calculateChunkTypeBoost(chunk) {
   switch (chunk.type) {
@@ -2756,85 +3008,659 @@ function calculateChunkTypeBoost(chunk) {
       return 0;
   }
 }
-function calculateExportBoost(chunk) {
-  return chunk.isExported ? 0.03 : 0;
+function calculateExportBoost(chunk) {
+  return chunk.isExported ? 0.03 : 0;
+}
+
+class TypeScriptModule {
+  id = "language/typescript";
+  name = "TypeScript Search";
+  description = "TypeScript-aware code search with AST parsing and semantic embeddings";
+  version = "1.0.0";
+  embeddingConfig = null;
+  symbolicIndex = null;
+  pendingSummaries = new Map;
+  rootDir = "";
+  logger = undefined;
+  async initialize(config) {
+    this.embeddingConfig = getEmbeddingConfigFromModule(config);
+    this.logger = config.options?.logger;
+    if (this.logger) {
+      this.embeddingConfig = {
+        ...this.embeddingConfig,
+        logger: this.logger
+      };
+    }
+    configureEmbeddings(this.embeddingConfig);
+    this.pendingSummaries.clear();
+  }
+  async indexFile(filepath, content, ctx) {
+    if (!isTypeScriptFile(filepath)) {
+      return null;
+    }
+    this.rootDir = ctx.rootDir;
+    const parsedChunks = parseTypeScriptCode(content, filepath);
+    if (parsedChunks.length === 0) {
+      return null;
+    }
+    const pathContext = parsePathContext(filepath);
+    const pathPrefix = formatPathContextForEmbedding(pathContext);
+    const chunkContents = parsedChunks.map((c) => {
+      const namePrefix = c.name ? `${c.name}: ` : "";
+      return `${pathPrefix} ${namePrefix}${c.content}`;
+    });
+    const embeddings = await getEmbeddings(chunkContents);
+    const chunks = parsedChunks.map((pc) => ({
+      id: generateChunkId2(filepath, pc.startLine, pc.endLine),
+      content: pc.content,
+      startLine: pc.startLine,
+      endLine: pc.endLine,
+      type: pc.type,
+      name: pc.name,
+      isExported: pc.isExported,
+      jsDoc: pc.jsDoc
+    }));
+    const references = this.extractReferences(content, filepath);
+    const stats = await ctx.getFileStats(filepath);
+    const currentConfig = getEmbeddingConfig();
+    const moduleData = {
+      embeddings,
+      embeddingModel: currentConfig.model
+    };
+    const chunkTypes = [
+      ...new Set(parsedChunks.map((pc) => pc.type))
+    ];
+    const exports = parsedChunks.filter((pc) => pc.isExported && pc.name).map((pc) => pc.name);
+    const allKeywords = new Set;
+    for (const pc of parsedChunks) {
+      const keywords = extractKeywords(pc.content, pc.name);
+      keywords.forEach((k) => allKeywords.add(k));
+    }
+    pathContext.keywords.forEach((k) => allKeywords.add(k));
+    const fileSummary = {
+      filepath,
+      chunkCount: chunks.length,
+      chunkTypes,
+      keywords: Array.from(allKeywords),
+      exports,
+      lastModified: stats.lastModified,
+      pathContext: {
+        segments: pathContext.segments,
+        layer: pathContext.layer,
+        domain: pathContext.domain,
+        depth: pathContext.depth
+      }
+    };
+    this.pendingSummaries.set(filepath, fileSummary);
+    return {
+      filepath,
+      lastModified: stats.lastModified,
+      chunks,
+      moduleData,
+      references
+    };
+  }
+  async finalize(ctx) {
+    const indexDir = getRaggrepDir(ctx.rootDir, ctx.config);
+    this.symbolicIndex = new SymbolicIndex(indexDir, this.id);
+    await this.symbolicIndex.initialize();
+    for (const [filepath, summary] of this.pendingSummaries) {
+      this.symbolicIndex.addFile(summary);
+    }
+    this.symbolicIndex.buildBM25Index();
+    await this.symbolicIndex.save();
+    this.pendingSummaries.clear();
+  }
+  async search(query, ctx, options = {}) {
+    const {
+      topK = DEFAULT_TOP_K2,
+      minScore = DEFAULT_MIN_SCORE2,
+      filePatterns
+    } = options;
+    const indexDir = getRaggrepDir(ctx.rootDir, ctx.config);
+    const symbolicIndex = new SymbolicIndex(indexDir, this.id);
+    let allFiles;
+    try {
+      await symbolicIndex.initialize();
+      allFiles = symbolicIndex.getAllFiles();
+    } catch {
+      allFiles = await ctx.listIndexedFiles();
+    }
+    let filesToSearch = allFiles;
+    if (filePatterns && filePatterns.length > 0) {
+      filesToSearch = allFiles.filter((filepath) => {
+        return filePatterns.some((pattern) => {
+          if (pattern.startsWith("*.")) {
+            const ext = pattern.slice(1);
+            return filepath.endsWith(ext);
+          }
+          return filepath.includes(pattern);
+        });
+      });
+    }
+    const queryEmbedding = await getEmbedding(query);
+    const bm25Index = new BM25Index;
+    const allChunksData = [];
+    for (const filepath of filesToSearch) {
+      const fileIndex = await ctx.loadFileIndex(filepath);
+      if (!fileIndex)
+        continue;
+      const moduleData = fileIndex.moduleData;
+      if (!moduleData?.embeddings)
+        continue;
+      for (let i = 0;i < fileIndex.chunks.length; i++) {
+        const chunk = fileIndex.chunks[i];
+        const embedding = moduleData.embeddings[i];
+        if (!embedding)
+          continue;
+        allChunksData.push({
+          filepath: fileIndex.filepath,
+          chunk,
+          embedding
+        });
+        bm25Index.addDocuments([{ id: chunk.id, content: chunk.content }]);
+      }
+    }
+    const bm25Results = bm25Index.search(query, topK * 3);
+    const bm25Scores = new Map;
+    for (const result of bm25Results) {
+      bm25Scores.set(result.id, normalizeScore(result.score, 3));
+    }
+    const queryTerms = extractQueryTerms(query);
+    const pathBoosts = new Map;
+    for (const filepath of filesToSearch) {
+      const summary = symbolicIndex.getFileSummary(filepath);
+      if (summary?.pathContext) {
+        let boost = 0;
+        const ctx2 = summary.pathContext;
+        if (ctx2.domain && queryTerms.some((t) => ctx2.domain.includes(t) || t.includes(ctx2.domain))) {
+          boost += 0.1;
+        }
+        if (ctx2.layer && queryTerms.some((t) => ctx2.layer.includes(t) || t.includes(ctx2.layer))) {
+          boost += 0.05;
+        }
+        const segmentMatch = ctx2.segments.some((seg) => queryTerms.some((t) => seg.toLowerCase().includes(t) || t.includes(seg.toLowerCase())));
+        if (segmentMatch) {
+          boost += 0.05;
+        }
+        pathBoosts.set(filepath, boost);
+      }
+    }
+    const results = [];
+    for (const { filepath, chunk, embedding } of allChunksData) {
+      const semanticScore = cosineSimilarity(queryEmbedding, embedding);
+      const bm25Score = bm25Scores.get(chunk.id) || 0;
+      const pathBoost = pathBoosts.get(filepath) || 0;
+      const fileTypeBoost = calculateFileTypeBoost(filepath, queryTerms);
+      const chunkTypeBoost = calculateChunkTypeBoost(chunk);
+      const exportBoost = calculateExportBoost(chunk);
+      const totalBoost = pathBoost + fileTypeBoost + chunkTypeBoost + exportBoost;
+      const hybridScore = SEMANTIC_WEIGHT * semanticScore + BM25_WEIGHT * bm25Score + totalBoost;
+      if (hybridScore >= minScore || bm25Score > 0.3) {
+        results.push({
+          filepath,
+          chunk,
+          score: hybridScore,
+          moduleId: this.id,
+          context: {
+            semanticScore,
+            bm25Score,
+            pathBoost,
+            fileTypeBoost,
+            chunkTypeBoost,
+            exportBoost
+          }
+        });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, topK);
+  }
+  extractReferences(content, filepath) {
+    const references = [];
+    const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
+    const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      const importPath = match[1];
+      if (importPath.startsWith(".")) {
+        const dir = path9.dirname(filepath);
+        const resolved = path9.normalize(path9.join(dir, importPath));
+        references.push(resolved);
+      }
+    }
+    while ((match = requireRegex.exec(content)) !== null) {
+      const importPath = match[1];
+      if (importPath.startsWith(".")) {
+        const dir = path9.dirname(filepath);
+        const resolved = path9.normalize(path9.join(dir, importPath));
+        references.push(resolved);
+      }
+    }
+    return references;
+  }
+}
+var DEFAULT_MIN_SCORE2 = 0.15, DEFAULT_TOP_K2 = 10, SEMANTIC_WEIGHT = 0.7, BM25_WEIGHT = 0.3, TYPESCRIPT_EXTENSIONS;
+var init_typescript = __esm(() => {
+  init_embeddings();
+  init_services();
+  init_config2();
+  init_parseCode();
+  init_storage();
+  TYPESCRIPT_EXTENSIONS = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".mts",
+    ".cts"
+  ];
+});
+
+// src/modules/data/json/index.ts
+var exports_json = {};
+__export(exports_json, {
+  isJsonFile: () => isJsonFile,
+  JsonModule: () => JsonModule,
+  JSON_EXTENSIONS: () => JSON_EXTENSIONS,
+  DEFAULT_TOP_K: () => DEFAULT_TOP_K3,
+  DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE3
+});
+import * as path10 from "path";
+function isJsonFile(filepath) {
+  const ext = path10.extname(filepath).toLowerCase();
+  return JSON_EXTENSIONS.includes(ext);
+}
+function extractJsonKeys(obj, prefix = "") {
+  const keys = [];
+  if (obj === null || obj === undefined) {
+    return keys;
+  }
+  if (Array.isArray(obj)) {
+    obj.forEach((item, index) => {
+      keys.push(...extractJsonKeys(item, `${prefix}[${index}]`));
+    });
+  } else if (typeof obj === "object") {
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      keys.push(key);
+      keys.push(...extractJsonKeys(value, fullKey));
+    }
+  }
+  return keys;
+}
+function extractJsonKeywords(content) {
+  try {
+    const parsed = JSON.parse(content);
+    const keys = extractJsonKeys(parsed);
+    const stringValues = [];
+    const extractStrings = (obj) => {
+      if (typeof obj === "string") {
+        const words = obj.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+        stringValues.push(...words);
+      } else if (Array.isArray(obj)) {
+        obj.forEach(extractStrings);
+      } else if (obj && typeof obj === "object") {
+        Object.values(obj).forEach(extractStrings);
+      }
+    };
+    extractStrings(parsed);
+    return [...new Set([...keys, ...stringValues])];
+  } catch {
+    return [];
+  }
+}
+
+class JsonModule {
+  id = "data/json";
+  name = "JSON Search";
+  description = "JSON file search with structure-aware indexing";
+  version = "1.0.0";
+  embeddingConfig = null;
+  symbolicIndex = null;
+  pendingSummaries = new Map;
+  rootDir = "";
+  logger = undefined;
+  async initialize(config) {
+    this.embeddingConfig = getEmbeddingConfigFromModule(config);
+    this.logger = config.options?.logger;
+    if (this.logger) {
+      this.embeddingConfig = {
+        ...this.embeddingConfig,
+        logger: this.logger
+      };
+    }
+    configureEmbeddings(this.embeddingConfig);
+    this.pendingSummaries.clear();
+  }
+  async indexFile(filepath, content, ctx) {
+    if (!isJsonFile(filepath)) {
+      return null;
+    }
+    this.rootDir = ctx.rootDir;
+    const textChunks = createLineBasedChunks(content, {
+      chunkSize: 50,
+      overlap: 10
+    });
+    if (textChunks.length === 0) {
+      return null;
+    }
+    const chunkContents = textChunks.map((c) => {
+      const filename = path10.basename(filepath);
+      return `${filename}: ${c.content}`;
+    });
+    const embeddings = await getEmbeddings(chunkContents);
+    const chunks = textChunks.map((tc, i) => ({
+      id: generateChunkId(filepath, tc.startLine, tc.endLine),
+      content: tc.content,
+      startLine: tc.startLine,
+      endLine: tc.endLine,
+      type: tc.type
+    }));
+    const jsonKeys = extractJsonKeys((() => {
+      try {
+        return JSON.parse(content);
+      } catch {
+        return {};
+      }
+    })());
+    const stats = await ctx.getFileStats(filepath);
+    const currentConfig = getEmbeddingConfig();
+    const moduleData = {
+      embeddings,
+      embeddingModel: currentConfig.model,
+      jsonKeys
+    };
+    const keywords = extractJsonKeywords(content);
+    const fileSummary = {
+      filepath,
+      chunkCount: chunks.length,
+      chunkTypes: ["file"],
+      keywords,
+      exports: [],
+      lastModified: stats.lastModified
+    };
+    this.pendingSummaries.set(filepath, fileSummary);
+    return {
+      filepath,
+      lastModified: stats.lastModified,
+      chunks,
+      moduleData
+    };
+  }
+  async finalize(ctx) {
+    const indexDir = getRaggrepDir(ctx.rootDir, ctx.config);
+    this.symbolicIndex = new SymbolicIndex(indexDir, this.id);
+    await this.symbolicIndex.initialize();
+    for (const [filepath, summary] of this.pendingSummaries) {
+      this.symbolicIndex.addFile(summary);
+    }
+    this.symbolicIndex.buildBM25Index();
+    await this.symbolicIndex.save();
+    this.pendingSummaries.clear();
+  }
+  async search(query, ctx, options = {}) {
+    const {
+      topK = DEFAULT_TOP_K3,
+      minScore = DEFAULT_MIN_SCORE3,
+      filePatterns
+    } = options;
+    const indexDir = getRaggrepDir(ctx.rootDir, ctx.config);
+    const symbolicIndex = new SymbolicIndex(indexDir, this.id);
+    let allFiles;
+    try {
+      await symbolicIndex.initialize();
+      allFiles = symbolicIndex.getAllFiles();
+    } catch {
+      allFiles = await ctx.listIndexedFiles();
+    }
+    let filesToSearch = allFiles.filter((f) => isJsonFile(f));
+    if (filePatterns && filePatterns.length > 0) {
+      filesToSearch = filesToSearch.filter((filepath) => {
+        return filePatterns.some((pattern) => {
+          if (pattern.startsWith("*.")) {
+            const ext = pattern.slice(1);
+            return filepath.endsWith(ext);
+          }
+          return filepath.includes(pattern);
+        });
+      });
+    }
+    const queryEmbedding = await getEmbedding(query);
+    const bm25Index = new BM25Index;
+    const allChunksData = [];
+    for (const filepath of filesToSearch) {
+      const fileIndex = await ctx.loadFileIndex(filepath);
+      if (!fileIndex)
+        continue;
+      const moduleData = fileIndex.moduleData;
+      if (!moduleData?.embeddings)
+        continue;
+      for (let i = 0;i < fileIndex.chunks.length; i++) {
+        const chunk = fileIndex.chunks[i];
+        const embedding = moduleData.embeddings[i];
+        if (!embedding)
+          continue;
+        allChunksData.push({
+          filepath: fileIndex.filepath,
+          chunk,
+          embedding
+        });
+        bm25Index.addDocuments([{ id: chunk.id, content: chunk.content }]);
+      }
+    }
+    const bm25Results = bm25Index.search(query, topK * 3);
+    const bm25Scores = new Map;
+    for (const result of bm25Results) {
+      bm25Scores.set(result.id, normalizeScore(result.score, 3));
+    }
+    const queryTerms = extractQueryTerms(query);
+    const results = [];
+    for (const { filepath, chunk, embedding } of allChunksData) {
+      const semanticScore = cosineSimilarity(queryEmbedding, embedding);
+      const bm25Score = bm25Scores.get(chunk.id) || 0;
+      const hybridScore = SEMANTIC_WEIGHT2 * semanticScore + BM25_WEIGHT2 * bm25Score;
+      if (hybridScore >= minScore || bm25Score > 0.3) {
+        results.push({
+          filepath,
+          chunk,
+          score: hybridScore,
+          moduleId: this.id,
+          context: {
+            semanticScore,
+            bm25Score
+          }
+        });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, topK);
+  }
+}
+var DEFAULT_MIN_SCORE3 = 0.15, DEFAULT_TOP_K3 = 10, SEMANTIC_WEIGHT2 = 0.7, BM25_WEIGHT2 = 0.3, JSON_EXTENSIONS;
+var init_json = __esm(() => {
+  init_embeddings();
+  init_services();
+  init_config2();
+  init_storage();
+  JSON_EXTENSIONS = [".json"];
+});
+
+// src/modules/docs/markdown/index.ts
+var exports_markdown = {};
+__export(exports_markdown, {
+  isMarkdownFile: () => isMarkdownFile,
+  MarkdownModule: () => MarkdownModule,
+  MARKDOWN_EXTENSIONS: () => MARKDOWN_EXTENSIONS,
+  DEFAULT_TOP_K: () => DEFAULT_TOP_K4,
+  DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE4
+});
+import * as path11 from "path";
+function isMarkdownFile(filepath) {
+  const ext = path11.extname(filepath).toLowerCase();
+  return MARKDOWN_EXTENSIONS.includes(ext);
+}
+function parseMarkdownSections(content) {
+  const lines = content.split(`
+`);
+  const sections = [];
+  let currentSection = null;
+  let currentContent = [];
+  let startLine = 1;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      if (currentSection) {
+        currentSection.content = currentContent.join(`
+`).trim();
+        currentSection.endLine = i;
+        if (currentSection.content || currentSection.heading) {
+          sections.push(currentSection);
+        }
+      } else if (currentContent.length > 0) {
+        sections.push({
+          heading: "",
+          level: 0,
+          content: currentContent.join(`
+`).trim(),
+          startLine: 1,
+          endLine: i
+        });
+      }
+      currentSection = {
+        heading: headingMatch[2],
+        level: headingMatch[1].length,
+        content: "",
+        startLine: i + 1,
+        endLine: lines.length
+      };
+      currentContent = [];
+    } else {
+      currentContent.push(line);
+    }
+  }
+  if (currentSection) {
+    currentSection.content = currentContent.join(`
+`).trim();
+    currentSection.endLine = lines.length;
+    if (currentSection.content || currentSection.heading) {
+      sections.push(currentSection);
+    }
+  } else if (currentContent.length > 0) {
+    sections.push({
+      heading: "",
+      level: 0,
+      content: currentContent.join(`
+`).trim(),
+      startLine: 1,
+      endLine: lines.length
+    });
+  }
+  return sections;
+}
+function extractMarkdownKeywords(content) {
+  const keywords = [];
+  const headingMatches = content.matchAll(/^#{1,6}\s+(.+)$/gm);
+  for (const match of headingMatches) {
+    const heading = match[1].toLowerCase();
+    const words = heading.split(/\s+/).filter((w) => w.length > 2);
+    keywords.push(...words);
+  }
+  const emphasisMatches = content.matchAll(/\*\*(.+?)\*\*|\*(.+?)\*/g);
+  for (const match of emphasisMatches) {
+    const text = (match[1] || match[2] || "").toLowerCase();
+    const words = text.split(/\s+/).filter((w) => w.length > 2);
+    keywords.push(...words);
+  }
+  const codeMatches = content.matchAll(/`([^`]+)`/g);
+  for (const match of codeMatches) {
+    const code = match[1].toLowerCase();
+    if (code.length > 2 && code.length < 50) {
+      keywords.push(code);
+    }
+  }
+  const linkMatches = content.matchAll(/\[([^\]]+)\]/g);
+  for (const match of linkMatches) {
+    const text = match[1].toLowerCase();
+    const words = text.split(/\s+/).filter((w) => w.length > 2);
+    keywords.push(...words);
+  }
+  return [...new Set(keywords)];
 }
 
-class TypeScriptModule {
-  id = "language/typescript";
-  name = "TypeScript Search";
-  description = "TypeScript-aware code search with AST parsing and semantic embeddings";
+class MarkdownModule {
+  id = "docs/markdown";
+  name = "Markdown Search";
+  description = "Markdown documentation search with section-aware indexing";
   version = "1.0.0";
   embeddingConfig = null;
   symbolicIndex = null;
   pendingSummaries = new Map;
   rootDir = "";
+  logger = undefined;
   async initialize(config) {
     this.embeddingConfig = getEmbeddingConfigFromModule(config);
+    this.logger = config.options?.logger;
+    if (this.logger) {
+      this.embeddingConfig = {
+        ...this.embeddingConfig,
+        logger: this.logger
+      };
+    }
     configureEmbeddings(this.embeddingConfig);
     this.pendingSummaries.clear();
   }
   async indexFile(filepath, content, ctx) {
+    if (!isMarkdownFile(filepath)) {
+      return null;
+    }
     this.rootDir = ctx.rootDir;
-    const parsedChunks = parseCode(content, filepath);
-    if (parsedChunks.length === 0) {
+    const sections = parseMarkdownSections(content);
+    if (sections.length === 0) {
       return null;
     }
-    const pathContext = parsePathContext(filepath);
-    const pathPrefix = formatPathContextForEmbedding(pathContext);
-    const chunkContents = parsedChunks.map((c) => {
-      const namePrefix = c.name ? `${c.name}: ` : "";
-      return `${pathPrefix} ${namePrefix}${c.content}`;
+    const chunkContents = sections.map((s) => {
+      const filename = path11.basename(filepath);
+      const headingContext = s.heading ? `${s.heading}: ` : "";
+      return `${filename} ${headingContext}${s.content}`;
     });
     const embeddings = await getEmbeddings(chunkContents);
-    const chunks = parsedChunks.map((pc) => ({
-      id: generateChunkId(filepath, pc.startLine, pc.endLine),
-      content: pc.content,
-      startLine: pc.startLine,
-      endLine: pc.endLine,
-      type: pc.type,
-      name: pc.name,
-      isExported: pc.isExported,
-      jsDoc: pc.jsDoc
+    const chunks = sections.map((section, i) => ({
+      id: generateChunkId(filepath, section.startLine, section.endLine),
+      content: section.heading ? `## ${section.heading}
+
+${section.content}` : section.content,
+      startLine: section.startLine,
+      endLine: section.endLine,
+      type: "block",
+      name: section.heading || undefined
     }));
-    const references = this.extractReferences(content, filepath);
+    const headings = sections.filter((s) => s.heading).map((s) => s.heading);
     const stats = await ctx.getFileStats(filepath);
     const currentConfig = getEmbeddingConfig();
     const moduleData = {
       embeddings,
-      embeddingModel: currentConfig.model
+      embeddingModel: currentConfig.model,
+      headings
     };
-    const chunkTypes = [
-      ...new Set(parsedChunks.map((pc) => pc.type))
-    ];
-    const exports = parsedChunks.filter((pc) => pc.isExported && pc.name).map((pc) => pc.name);
-    const allKeywords = new Set;
-    for (const pc of parsedChunks) {
-      const keywords = extractKeywords(pc.content, pc.name);
-      keywords.forEach((k) => allKeywords.add(k));
-    }
-    pathContext.keywords.forEach((k) => allKeywords.add(k));
+    const keywords = extractMarkdownKeywords(content);
     const fileSummary = {
       filepath,
       chunkCount: chunks.length,
-      chunkTypes,
-      keywords: Array.from(allKeywords),
-      exports,
-      lastModified: stats.lastModified,
-      pathContext: {
-        segments: pathContext.segments,
-        layer: pathContext.layer,
-        domain: pathContext.domain,
-        depth: pathContext.depth
-      }
+      chunkTypes: ["block"],
+      keywords,
+      exports: headings,
+      lastModified: stats.lastModified
     };
     this.pendingSummaries.set(filepath, fileSummary);
     return {
       filepath,
       lastModified: stats.lastModified,
       chunks,
-      moduleData,
-      references
+      moduleData
     };
   }
   async finalize(ctx) {
@@ -2850,8 +3676,8 @@ class TypeScriptModule {
   }
   async search(query, ctx, options = {}) {
     const {
-      topK = DEFAULT_TOP_K2,
-      minScore = DEFAULT_MIN_SCORE2,
+      topK = DEFAULT_TOP_K4,
+      minScore = DEFAULT_MIN_SCORE4,
       filePatterns
     } = options;
     const indexDir = getRaggrepDir(ctx.rootDir, ctx.config);
@@ -2863,9 +3689,9 @@ class TypeScriptModule {
     } catch {
       allFiles = await ctx.listIndexedFiles();
     }
-    let filesToSearch = allFiles;
+    let filesToSearch = allFiles.filter((f) => isMarkdownFile(f));
     if (filePatterns && filePatterns.length > 0) {
-      filesToSearch = allFiles.filter((filepath) => {
+      filesToSearch = filesToSearch.filter((filepath) => {
         return filePatterns.some((pattern) => {
           if (pattern.startsWith("*.")) {
             const ext = pattern.slice(1);
@@ -2903,36 +3729,24 @@ class TypeScriptModule {
     for (const result of bm25Results) {
       bm25Scores.set(result.id, normalizeScore(result.score, 3));
     }
-    const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
-    const pathBoosts = new Map;
-    for (const filepath of filesToSearch) {
-      const summary = symbolicIndex.getFileSummary(filepath);
-      if (summary?.pathContext) {
-        let boost = 0;
-        const ctx2 = summary.pathContext;
-        if (ctx2.domain && queryTerms.some((t) => ctx2.domain.includes(t) || t.includes(ctx2.domain))) {
-          boost += 0.1;
-        }
-        if (ctx2.layer && queryTerms.some((t) => ctx2.layer.includes(t) || t.includes(ctx2.layer))) {
-          boost += 0.05;
-        }
-        const segmentMatch = ctx2.segments.some((seg) => queryTerms.some((t) => seg.toLowerCase().includes(t) || t.includes(seg.toLowerCase())));
-        if (segmentMatch) {
-          boost += 0.05;
-        }
-        pathBoosts.set(filepath, boost);
-      }
-    }
+    const queryTerms = extractQueryTerms(query);
     const results = [];
     for (const { filepath, chunk, embedding } of allChunksData) {
       const semanticScore = cosineSimilarity(queryEmbedding, embedding);
       const bm25Score = bm25Scores.get(chunk.id) || 0;
-      const pathBoost = pathBoosts.get(filepath) || 0;
-      const fileTypeBoost = calculateFileTypeBoost(filepath, queryTerms);
-      const chunkTypeBoost = calculateChunkTypeBoost(chunk);
-      const exportBoost = calculateExportBoost(chunk);
-      const totalBoost = pathBoost + fileTypeBoost + chunkTypeBoost + exportBoost;
-      const hybridScore = SEMANTIC_WEIGHT * semanticScore + BM25_WEIGHT * bm25Score + totalBoost;
+      let docBoost = 0;
+      if (queryTerms.some((t) => [
+        "docs",
+        "documentation",
+        "readme",
+        "guide",
+        "how",
+        "what",
+        "explain"
+      ].includes(t))) {
+        docBoost = 0.05;
+      }
+      const hybridScore = SEMANTIC_WEIGHT3 * semanticScore + BM25_WEIGHT3 * bm25Score + docBoost;
       if (hybridScore >= minScore || bm25Score > 0.3) {
         results.push({
           filepath,
@@ -2942,10 +3756,7 @@ class TypeScriptModule {
           context: {
             semanticScore,
             bm25Score,
-            pathBoost,
-            fileTypeBoost,
-            chunkTypeBoost,
-            exportBoost
+            docBoost
           }
         });
       }
@@ -2953,84 +3764,14 @@ class TypeScriptModule {
     results.sort((a, b) => b.score - a.score);
     return results.slice(0, topK);
   }
-  extractReferences(content, filepath) {
-    const references = [];
-    const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
-    const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-    let match;
-    while ((match = importRegex.exec(content)) !== null) {
-      const importPath = match[1];
-      if (importPath.startsWith(".")) {
-        const dir = path8.dirname(filepath);
-        const resolved = path8.normalize(path8.join(dir, importPath));
-        references.push(resolved);
-      }
-    }
-    while ((match = requireRegex.exec(content)) !== null) {
-      const importPath = match[1];
-      if (importPath.startsWith(".")) {
-        const dir = path8.dirname(filepath);
-        const resolved = path8.normalize(path8.join(dir, importPath));
-        references.push(resolved);
-      }
-    }
-    return references;
-  }
 }
-var DEFAULT_MIN_SCORE2 = 0.15, DEFAULT_TOP_K2 = 10, SEMANTIC_WEIGHT = 0.7, BM25_WEIGHT = 0.3, IMPLEMENTATION_TERMS, DOCUMENTATION_TERMS, SOURCE_CODE_EXTENSIONS, DOC_EXTENSIONS;
-var init_typescript = __esm(() => {
+var DEFAULT_MIN_SCORE4 = 0.15, DEFAULT_TOP_K4 = 10, SEMANTIC_WEIGHT3 = 0.7, BM25_WEIGHT3 = 0.3, MARKDOWN_EXTENSIONS;
+var init_markdown = __esm(() => {
   init_embeddings();
+  init_services();
   init_config2();
-  init_parseCode();
   init_storage();
-  init_keywords();
-  init_keywords();
-  IMPLEMENTATION_TERMS = [
-    "function",
-    "method",
-    "class",
-    "interface",
-    "implement",
-    "implementation",
-    "endpoint",
-    "route",
-    "handler",
-    "controller",
-    "module",
-    "code"
-  ];
-  DOCUMENTATION_TERMS = [
-    "documentation",
-    "docs",
-    "guide",
-    "tutorial",
-    "readme",
-    "how",
-    "what",
-    "why",
-    "explain",
-    "overview",
-    "getting",
-    "started",
-    "requirements",
-    "setup",
-    "install",
-    "configure",
-    "configuration"
-  ];
-  SOURCE_CODE_EXTENSIONS = [
-    ".ts",
-    ".tsx",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".py",
-    ".go",
-    ".rs",
-    ".java"
-  ];
-  DOC_EXTENSIONS = [".md", ".txt", ".rst"];
+  MARKDOWN_EXTENSIONS = [".md", ".txt"];
 });
 
 // src/modules/registry.ts
@@ -3055,8 +3796,12 @@ class ModuleRegistryImpl {
 async function registerBuiltInModules() {
   const { CoreModule: CoreModule2 } = await Promise.resolve().then(() => (init_core(), exports_core));
   const { TypeScriptModule: TypeScriptModule2 } = await Promise.resolve().then(() => (init_typescript(), exports_typescript));
+  const { JsonModule: JsonModule2 } = await Promise.resolve().then(() => (init_json(), exports_json));
+  const { MarkdownModule: MarkdownModule2 } = await Promise.resolve().then(() => (init_markdown(), exports_markdown));
   registry.register(new CoreModule2);
   registry.register(new TypeScriptModule2);
+  registry.register(new JsonModule2);
+  registry.register(new MarkdownModule2);
 }
 var registry;
 var init_registry = __esm(() => {
@@ -3064,13 +3809,13 @@ var init_registry = __esm(() => {
 });
 
 // src/infrastructure/introspection/projectDetector.ts
-import * as path9 from "path";
+import * as path12 from "path";
 import * as fs4 from "fs/promises";
 async function scanForPackageJsons(rootDir, currentDir = "", depth = 0) {
   if (depth > MAX_SCAN_DEPTH)
     return [];
   const results = [];
-  const fullDir = currentDir ? path9.join(rootDir, currentDir) : rootDir;
+  const fullDir = currentDir ? path12.join(rootDir, currentDir) : rootDir;
   try {
     const entries = await fs4.readdir(fullDir, { withFileTypes: true });
     const hasPackageJson = entries.some((e) => e.isFile() && e.name === "package.json");
@@ -3093,10 +3838,10 @@ async function scanForPackageJsons(rootDir, currentDir = "", depth = 0) {
 }
 async function parsePackageJson(rootDir, relativePath) {
   try {
-    const packageJsonPath = path9.join(rootDir, relativePath, "package.json");
+    const packageJsonPath = path12.join(rootDir, relativePath, "package.json");
     const content = await fs4.readFile(packageJsonPath, "utf-8");
     const pkg = JSON.parse(content);
-    const name = pkg.name || path9.basename(relativePath);
+    const name = pkg.name || path12.basename(relativePath);
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     let type = "unknown";
     if (deps["next"] || deps["react"] || deps["vue"] || deps["svelte"]) {
@@ -3141,7 +3886,7 @@ async function detectProjectStructure(rootDir) {
       for (const pattern of monorepoPatterns) {
         if (!dirNames.includes(pattern))
           continue;
-        const patternDir = path9.join(rootDir, pattern);
+        const patternDir = path12.join(rootDir, pattern);
         try {
           const subDirs = await fs4.readdir(patternDir, { withFileTypes: true });
           for (const subDir of subDirs) {
@@ -3172,7 +3917,7 @@ async function detectProjectStructure(rootDir) {
     }
     let rootType = "unknown";
     try {
-      const rootPkgPath = path9.join(rootDir, "package.json");
+      const rootPkgPath = path12.join(rootDir, "package.json");
       const rootPkg = JSON.parse(await fs4.readFile(rootPkgPath, "utf-8"));
       if (rootPkg.workspaces)
         isMonorepo = true;
@@ -3212,7 +3957,7 @@ var init_projectDetector = __esm(() => {
 });
 
 // src/infrastructure/introspection/IntrospectionIndex.ts
-import * as path10 from "path";
+import * as path13 from "path";
 import * as fs5 from "fs/promises";
 
 class IntrospectionIndex {
@@ -3226,7 +3971,7 @@ class IntrospectionIndex {
   async initialize() {
     this.structure = await detectProjectStructure(this.rootDir);
     try {
-      const configPath = path10.join(this.rootDir, ".raggrep", "config.json");
+      const configPath = path13.join(this.rootDir, ".raggrep", "config.json");
       const configContent = await fs5.readFile(configPath, "utf-8");
       const config = JSON.parse(configContent);
       this.config = config.introspection || {};
@@ -3266,28 +4011,28 @@ class IntrospectionIndex {
     }
   }
   async save(config) {
-    const introDir = path10.join(getRaggrepDir(this.rootDir, config), "introspection");
+    const introDir = path13.join(getRaggrepDir(this.rootDir, config), "introspection");
     await fs5.mkdir(introDir, { recursive: true });
-    const projectPath = path10.join(introDir, "_project.json");
+    const projectPath = path13.join(introDir, "_project.json");
     await fs5.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 = path10.join(introDir, "files", filepath.replace(/\.[^.]+$/, ".json"));
-      await fs5.mkdir(path10.dirname(introFilePath), { recursive: true });
+      const introFilePath = path13.join(introDir, "files", filepath.replace(/\.[^.]+$/, ".json"));
+      await fs5.mkdir(path13.dirname(introFilePath), { recursive: true });
       await fs5.writeFile(introFilePath, JSON.stringify(intro, null, 2));
     }
   }
   async load(config) {
-    const introDir = path10.join(getRaggrepDir(this.rootDir, config), "introspection");
+    const introDir = path13.join(getRaggrepDir(this.rootDir, config), "introspection");
     try {
-      const projectPath = path10.join(introDir, "_project.json");
+      const projectPath = path13.join(introDir, "_project.json");
       const projectContent = await fs5.readFile(projectPath, "utf-8");
       const projectData = JSON.parse(projectContent);
       this.structure = projectData.structure;
-      await this.loadFilesRecursive(path10.join(introDir, "files"), "");
+      await this.loadFilesRecursive(path13.join(introDir, "files"), "");
     } catch {
       this.structure = null;
       this.files.clear();
@@ -3297,7 +4042,7 @@ class IntrospectionIndex {
     try {
       const entries = await fs5.readdir(basePath, { withFileTypes: true });
       for (const entry of entries) {
-        const entryPath = path10.join(basePath, entry.name);
+        const entryPath = path13.join(basePath, entry.name);
         const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
         if (entry.isDirectory()) {
           await this.loadFilesRecursive(entryPath, relativePath);
@@ -3328,7 +4073,7 @@ var init_introspection2 = __esm(() => {
 
 // src/app/indexer/watcher.ts
 import { watch } from "chokidar";
-import * as path11 from "path";
+import * as path14 from "path";
 async function watchDirectory(rootDir, options = {}) {
   const {
     debounceMs = DEFAULT_DEBOUNCE_MS,
@@ -3339,7 +4084,7 @@ async function watchDirectory(rootDir, options = {}) {
     onFileChange,
     onError
   } = options;
-  rootDir = path11.resolve(rootDir);
+  rootDir = path14.resolve(rootDir);
   const config = await loadConfig(rootDir);
   const indexLocation = getIndexLocation(rootDir);
   const validExtensions = new Set(config.extensions);
@@ -3349,7 +4094,7 @@ async function watchDirectory(rootDir, options = {}) {
     "**/.git/**"
   ];
   function shouldWatchFile(filepath) {
-    const ext = path11.extname(filepath);
+    const ext = path14.extname(filepath);
     return validExtensions.has(ext);
   }
   let isRunning = true;
@@ -3431,7 +4176,7 @@ async function watchDirectory(rootDir, options = {}) {
   function handleFileEvent(event, filepath) {
     if (!isRunning)
       return;
-    const relativePath = path11.relative(rootDir, filepath);
+    const relativePath = path14.relative(rootDir, filepath);
     if (!shouldWatchFile(filepath)) {
       return;
     }
@@ -3502,6 +4247,7 @@ var init_watcher = __esm(() => {
 var exports_indexer = {};
 __export(exports_indexer, {
   watchDirectory: () => watchDirectory,
+  resetIndex: () => resetIndex,
   indexDirectory: () => indexDirectory,
   getIndexStatus: () => getIndexStatus,
   ensureIndexFresh: () => ensureIndexFresh,
@@ -3509,46 +4255,56 @@ __export(exports_indexer, {
 });
 import { glob } from "glob";
 import * as fs6 from "fs/promises";
-import * as path12 from "path";
+import * as path15 from "path";
+async function parallelMap(items, processor, concurrency) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  async function worker() {
+    while (nextIndex < items.length) {
+      const index = nextIndex++;
+      const item = items[index];
+      try {
+        const value = await processor(item, index);
+        results[index] = { success: true, value };
+      } catch (error) {
+        results[index] = { success: false, error };
+      }
+    }
+  }
+  const workers = Array(Math.min(concurrency, items.length)).fill(null).map(() => worker());
+  await Promise.all(workers);
+  return results;
+}
 async function indexDirectory(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
   const quiet = options.quiet ?? false;
-  rootDir = path12.resolve(rootDir);
+  const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
+  const logger = options.logger ? options.logger : quiet ? createSilentLogger() : createLogger({ verbose });
+  rootDir = path15.resolve(rootDir);
   const location = getIndexLocation(rootDir);
-  if (!quiet) {
-    console.log(`Indexing directory: ${rootDir}`);
-    console.log(`Index location: ${location.indexDir}`);
-  }
+  logger.info(`Indexing directory: ${rootDir}`);
+  logger.info(`Index location: ${location.indexDir}`);
+  logger.debug(`Concurrency: ${concurrency}`);
   const config = await loadConfig(rootDir);
   const introspection = new IntrospectionIndex(rootDir);
   await introspection.initialize();
-  if (verbose) {
-    const structure = introspection.getStructure();
-    if (structure?.isMonorepo) {
-      console.log(`Detected monorepo with ${structure.projects.length} projects`);
-    }
+  const structure = introspection.getStructure();
+  if (structure?.isMonorepo) {
+    logger.debug(`Detected monorepo with ${structure.projects.length} projects`);
   }
   await registerBuiltInModules();
   const enabledModules = registry.getEnabled(config);
   if (enabledModules.length === 0) {
-    if (!quiet) {
-      console.log("No modules enabled. Check your configuration.");
-    }
+    logger.info("No modules enabled. Check your configuration.");
     return [];
   }
-  if (!quiet) {
-    console.log(`Enabled modules: ${enabledModules.map((m) => m.id).join(", ")}`);
-  }
+  logger.info(`Enabled modules: ${enabledModules.map((m) => m.id).join(", ")}`);
   const files = await findFiles(rootDir, config);
-  if (!quiet) {
-    console.log(`Found ${files.length} files to index`);
-  }
+  logger.info(`Found ${files.length} files to index`);
   const results = [];
   for (const module of enabledModules) {
-    if (!quiet) {
-      console.log(`
+    logger.info(`
 [${module.name}] Starting indexing...`);
-    }
     const moduleConfig = getModuleConfig(config, module.id);
     if (module.initialize && moduleConfig) {
       const configWithOverrides = { ...moduleConfig };
@@ -3558,32 +4314,32 @@ async function indexDirectory(rootDir, options = {}) {
           embeddingModel: options.model
         };
       }
+      configWithOverrides.options = {
+        ...configWithOverrides.options,
+        logger
+      };
       await module.initialize(configWithOverrides);
     }
-    const result = await indexWithModule(rootDir, files, module, config, verbose, introspection);
+    const result = await indexWithModule(rootDir, files, module, config, verbose, introspection, logger, concurrency);
     results.push(result);
     if (module.finalize) {
-      if (!quiet) {
-        console.log(`[${module.name}] Building secondary indexes...`);
-      }
+      logger.info(`[${module.name}] Building secondary indexes...`);
       const ctx = {
         rootDir,
         config,
         readFile: async (filepath) => {
-          const fullPath = path12.isAbsolute(filepath) ? filepath : path12.join(rootDir, filepath);
+          const fullPath = path15.isAbsolute(filepath) ? filepath : path15.join(rootDir, filepath);
           return fs6.readFile(fullPath, "utf-8");
         },
         getFileStats: async (filepath) => {
-          const fullPath = path12.isAbsolute(filepath) ? filepath : path12.join(rootDir, filepath);
+          const fullPath = path15.isAbsolute(filepath) ? filepath : path15.join(rootDir, filepath);
           const stats = await fs6.stat(fullPath);
           return { lastModified: stats.mtime.toISOString() };
         }
       };
       await module.finalize(ctx);
     }
-    if (!quiet) {
-      console.log(`[${module.name}] Complete: ${result.indexed} indexed, ${result.skipped} skipped, ${result.errors} errors`);
-    }
+    logger.info(`[${module.name}] Complete: ${result.indexed} indexed, ${result.skipped} skipped, ${result.errors} errors`);
   }
   await introspection.save(config);
   await updateGlobalManifest(rootDir, enabledModules, config);
@@ -3606,28 +4362,37 @@ async function deleteIndex(rootDir) {
     await fs6.rm(indexDir, { recursive: true, force: true });
   } catch {}
 }
+async function resetIndex(rootDir) {
+  rootDir = path15.resolve(rootDir);
+  const status = await getIndexStatus(rootDir);
+  if (!status.exists) {
+    throw new Error(`No index found for ${rootDir}`);
+  }
+  await deleteIndex(rootDir);
+  return {
+    success: true,
+    indexDir: status.indexDir
+  };
+}
 async function ensureIndexFresh(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
   const quiet = options.quiet ?? false;
-  rootDir = path12.resolve(rootDir);
+  const logger = options.logger ? options.logger : quiet ? createSilentLogger() : createLogger({ verbose });
+  rootDir = path15.resolve(rootDir);
   const status = await getIndexStatus(rootDir);
   if (!status.exists) {
-    if (!quiet) {
-      console.log(`No index found. Creating index...
+    logger.info(`No index found. Creating index...
 `);
-    }
-    const results = await indexDirectory(rootDir, { ...options, quiet });
+    const results = await indexDirectory(rootDir, { ...options, logger });
     const totalIndexed2 = results.reduce((sum, r) => sum + r.indexed, 0);
     return { indexed: totalIndexed2, removed: 0, unchanged: 0 };
   }
   const versionCompatible = await isIndexVersionCompatible(rootDir);
   if (!versionCompatible) {
-    if (!quiet) {
-      console.log(`Index version incompatible. Rebuilding...
+    logger.info(`Index version incompatible. Rebuilding...
 `);
-    }
     await deleteIndex(rootDir);
-    const results = await indexDirectory(rootDir, { ...options, quiet });
+    const results = await indexDirectory(rootDir, { ...options, logger });
     const totalIndexed2 = results.reduce((sum, r) => sum + r.indexed, 0);
     return { indexed: totalIndexed2, removed: 0, unchanged: 0 };
   }
@@ -3640,7 +4405,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
   const introspection = new IntrospectionIndex(rootDir);
   await introspection.initialize();
   const currentFiles = await findFiles(rootDir, config);
-  const currentFileSet = new Set(currentFiles.map((f) => path12.relative(rootDir, f)));
+  const currentFileSet = new Set(currentFiles.map((f) => path15.relative(rootDir, f)));
   let totalIndexed = 0;
   let totalRemoved = 0;
   let totalUnchanged = 0;
@@ -3654,6 +4419,10 @@ async function ensureIndexFresh(rootDir, options = {}) {
           embeddingModel: options.model
         };
       }
+      configWithOverrides.options = {
+        ...configWithOverrides.options,
+        logger
+      };
       await module.initialize(configWithOverrides);
     }
     const manifest = await loadModuleManifest(rootDir, module.id, config);
@@ -3665,14 +4434,12 @@ async function ensureIndexFresh(rootDir, options = {}) {
       }
     }
     for (const filepath of filesToRemove) {
-      if (verbose) {
-        console.log(`  Removing stale: ${filepath}`);
-      }
-      const indexFilePath = path12.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+      logger.debug(`  Removing stale: ${filepath}`);
+      const indexFilePath = path15.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
       try {
         await fs6.unlink(indexFilePath);
       } catch {}
-      const symbolicFilePath = path12.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
+      const symbolicFilePath = path15.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
       try {
         await fs6.unlink(symbolicFilePath);
       } catch {}
@@ -3683,18 +4450,21 @@ async function ensureIndexFresh(rootDir, options = {}) {
       rootDir,
       config,
       readFile: async (filepath) => {
-        const fullPath = path12.isAbsolute(filepath) ? filepath : path12.join(rootDir, filepath);
+        const fullPath = path15.isAbsolute(filepath) ? filepath : path15.join(rootDir, filepath);
         return fs6.readFile(fullPath, "utf-8");
       },
       getFileStats: async (filepath) => {
-        const fullPath = path12.isAbsolute(filepath) ? filepath : path12.join(rootDir, filepath);
+        const fullPath = path15.isAbsolute(filepath) ? filepath : path15.join(rootDir, filepath);
         const stats = await fs6.stat(fullPath);
         return { lastModified: stats.mtime.toISOString() };
       },
       getIntrospection: (filepath) => introspection.getFile(filepath)
     };
-    for (const filepath of currentFiles) {
-      const relativePath = path12.relative(rootDir, filepath);
+    const totalFiles = currentFiles.length;
+    for (let i = 0;i < currentFiles.length; i++) {
+      const filepath = currentFiles[i];
+      const relativePath = path15.relative(rootDir, filepath);
+      const progress = `[${i + 1}/${totalFiles}]`;
       try {
         const stats = await fs6.stat(filepath);
         const lastModified = stats.mtime.toISOString();
@@ -3703,9 +4473,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
           totalUnchanged++;
           continue;
         }
-        if (verbose) {
-          console.log(`  Indexing: ${relativePath}`);
-        }
+        logger.progress(`  ${progress} Indexing: ${relativePath}`);
         const content = await fs6.readFile(filepath, "utf-8");
         introspection.addFile(relativePath, content);
         const fileIndex = await module.indexFile(relativePath, content, ctx);
@@ -3718,11 +4486,11 @@ async function ensureIndexFresh(rootDir, options = {}) {
           totalIndexed++;
         }
       } catch (error) {
-        if (verbose) {
-          console.error(`  Error indexing ${relativePath}:`, error);
-        }
+        logger.clearProgress();
+        logger.error(`  ${progress} Error indexing ${relativePath}: ${error}`);
       }
     }
+    logger.clearProgress();
     if (totalIndexed > 0 || totalRemoved > 0) {
       manifest.lastUpdated = new Date().toISOString();
       await writeModuleManifest(rootDir, module.id, manifest, config);
@@ -3746,7 +4514,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
     unchanged: totalUnchanged
   };
 }
-async function indexWithModule(rootDir, files, module, config, verbose, introspection) {
+async function indexWithModule(rootDir, files, module, config, verbose, introspection, logger, concurrency = DEFAULT_CONCURRENCY) {
   const result = {
     moduleId: module.id,
     indexed: 0,
@@ -3754,55 +4522,102 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
     errors: 0
   };
   const manifest = await loadModuleManifest(rootDir, module.id, config);
+  const indexPath = getModuleIndexPath(rootDir, module.id, config);
+  const currentFileSet = new Set(files.map((f) => path15.relative(rootDir, f)));
+  const filesToRemove = [];
+  for (const filepath of Object.keys(manifest.files)) {
+    if (!currentFileSet.has(filepath)) {
+      filesToRemove.push(filepath);
+    }
+  }
+  if (filesToRemove.length > 0) {
+    logger.info(`  Removing ${filesToRemove.length} stale entries...`);
+    for (const filepath of filesToRemove) {
+      logger.debug(`    Removing: ${filepath}`);
+      const indexFilePath = path15.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+      try {
+        await fs6.unlink(indexFilePath);
+      } catch {}
+      const symbolicFilePath = path15.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
+      try {
+        await fs6.unlink(symbolicFilePath);
+      } catch {}
+      delete manifest.files[filepath];
+    }
+    await cleanupEmptyDirectories(indexPath);
+  }
   const ctx = {
     rootDir,
     config,
     readFile: async (filepath) => {
-      const fullPath = path12.isAbsolute(filepath) ? filepath : path12.join(rootDir, filepath);
+      const fullPath = path15.isAbsolute(filepath) ? filepath : path15.join(rootDir, filepath);
       return fs6.readFile(fullPath, "utf-8");
     },
     getFileStats: async (filepath) => {
-      const fullPath = path12.isAbsolute(filepath) ? filepath : path12.join(rootDir, filepath);
+      const fullPath = path15.isAbsolute(filepath) ? filepath : path15.join(rootDir, filepath);
       const stats = await fs6.stat(fullPath);
       return { lastModified: stats.mtime.toISOString() };
     },
     getIntrospection: (filepath) => introspection.getFile(filepath)
   };
-  for (const filepath of files) {
-    const relativePath = path12.relative(rootDir, filepath);
+  const totalFiles = files.length;
+  let completedCount = 0;
+  const processFile = async (filepath, _index) => {
+    const relativePath = path15.relative(rootDir, filepath);
     try {
       const stats = await fs6.stat(filepath);
       const lastModified = stats.mtime.toISOString();
       const existingEntry = manifest.files[relativePath];
       if (existingEntry && existingEntry.lastModified === lastModified) {
-        if (verbose) {
-          console.log(`  Skipped ${relativePath} (unchanged)`);
-        }
-        result.skipped++;
-        continue;
+        completedCount++;
+        logger.debug(`  [${completedCount}/${totalFiles}] Skipped ${relativePath} (unchanged)`);
+        return { relativePath, status: "skipped" };
       }
       const content = await fs6.readFile(filepath, "utf-8");
       introspection.addFile(relativePath, content);
-      if (verbose) {
-        console.log(`  Processing ${relativePath}...`);
-      }
+      completedCount++;
+      logger.progress(`  [${completedCount}/${totalFiles}] Processing: ${relativePath}`);
       const fileIndex = await module.indexFile(relativePath, content, ctx);
       if (!fileIndex) {
-        if (verbose) {
-          console.log(`  Skipped ${relativePath} (no chunks)`);
-        }
-        result.skipped++;
-        continue;
+        logger.debug(`  [${completedCount}/${totalFiles}] Skipped ${relativePath} (no chunks)`);
+        return { relativePath, status: "skipped" };
       }
       await writeFileIndex(rootDir, module.id, relativePath, fileIndex, config);
-      manifest.files[relativePath] = {
+      return {
+        relativePath,
+        status: "indexed",
         lastModified,
         chunkCount: fileIndex.chunks.length
       };
-      result.indexed++;
     } catch (error) {
-      console.error(`  Error indexing ${relativePath}:`, error);
+      completedCount++;
+      return { relativePath, status: "error", error };
+    }
+  };
+  logger.debug(`  Using concurrency: ${concurrency}`);
+  const results = await parallelMap(files, processFile, concurrency);
+  logger.clearProgress();
+  for (const item of results) {
+    if (!item.success) {
       result.errors++;
+      continue;
+    }
+    const fileResult = item.value;
+    switch (fileResult.status) {
+      case "indexed":
+        manifest.files[fileResult.relativePath] = {
+          lastModified: fileResult.lastModified,
+          chunkCount: fileResult.chunkCount
+        };
+        result.indexed++;
+        break;
+      case "skipped":
+        result.skipped++;
+        break;
+      case "error":
+        logger.error(`  Error indexing ${fileResult.relativePath}: ${fileResult.error}`);
+        result.errors++;
+        break;
     }
   }
   manifest.lastUpdated = new Date().toISOString();
@@ -3839,13 +4654,13 @@ async function loadModuleManifest(rootDir, moduleId, config) {
 }
 async function writeModuleManifest(rootDir, moduleId, manifest, config) {
   const manifestPath = getModuleManifestPath(rootDir, moduleId, config);
-  await fs6.mkdir(path12.dirname(manifestPath), { recursive: true });
+  await fs6.mkdir(path15.dirname(manifestPath), { recursive: true });
   await fs6.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 }
 async function writeFileIndex(rootDir, moduleId, filepath, fileIndex, config) {
   const indexPath = getModuleIndexPath(rootDir, moduleId, config);
-  const indexFilePath = path12.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
-  await fs6.mkdir(path12.dirname(indexFilePath), { recursive: true });
+  const indexFilePath = path15.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+  await fs6.mkdir(path15.dirname(indexFilePath), { recursive: true });
   await fs6.writeFile(indexFilePath, JSON.stringify(fileIndex, null, 2));
 }
 async function updateGlobalManifest(rootDir, modules, config) {
@@ -3855,31 +4670,32 @@ async function updateGlobalManifest(rootDir, modules, config) {
     lastUpdated: new Date().toISOString(),
     modules: modules.map((m) => m.id)
   };
-  await fs6.mkdir(path12.dirname(manifestPath), { recursive: true });
+  await fs6.mkdir(path15.dirname(manifestPath), { recursive: true });
   await fs6.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 }
 async function cleanupIndex(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
-  rootDir = path12.resolve(rootDir);
-  console.log(`Cleaning up index in: ${rootDir}`);
+  const logger = options.logger ?? createLogger({ verbose });
+  rootDir = path15.resolve(rootDir);
+  logger.info(`Cleaning up index in: ${rootDir}`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
   const enabledModules = registry.getEnabled(config);
   if (enabledModules.length === 0) {
-    console.log("No modules enabled.");
+    logger.info("No modules enabled.");
     return [];
   }
   const results = [];
   for (const module of enabledModules) {
-    console.log(`
+    logger.info(`
 [${module.name}] Checking for stale entries...`);
-    const result = await cleanupModuleIndex(rootDir, module.id, config, verbose);
+    const result = await cleanupModuleIndex(rootDir, module.id, config, logger);
     results.push(result);
-    console.log(`[${module.name}] Removed ${result.removed} stale entries, kept ${result.kept} valid entries`);
+    logger.info(`[${module.name}] Removed ${result.removed} stale entries, kept ${result.kept} valid entries`);
   }
   return results;
 }
-async function cleanupModuleIndex(rootDir, moduleId, config, verbose) {
+async function cleanupModuleIndex(rootDir, moduleId, config, logger) {
   const result = {
     moduleId,
     removed: 0,
@@ -3890,7 +4706,7 @@ async function cleanupModuleIndex(rootDir, moduleId, config, verbose) {
   const filesToRemove = [];
   const updatedFiles = {};
   for (const [filepath, entry] of Object.entries(manifest.files)) {
-    const fullPath = path12.join(rootDir, filepath);
+    const fullPath = path15.join(rootDir, filepath);
     try {
       await fs6.access(fullPath);
       updatedFiles[filepath] = entry;
@@ -3898,13 +4714,11 @@ async function cleanupModuleIndex(rootDir, moduleId, config, verbose) {
     } catch {
       filesToRemove.push(filepath);
       result.removed++;
-      if (verbose) {
-        console.log(`  Removing stale entry: ${filepath}`);
-      }
+      logger.debug(`  Removing stale entry: ${filepath}`);
     }
   }
   for (const filepath of filesToRemove) {
-    const indexFilePath = path12.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+    const indexFilePath = path15.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
     try {
       await fs6.unlink(indexFilePath);
     } catch {}
@@ -3920,7 +4734,7 @@ async function cleanupEmptyDirectories(dir) {
     const entries = await fs6.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const subDir = path12.join(dir, entry.name);
+        const subDir = path15.join(dir, entry.name);
         await cleanupEmptyDirectories(subDir);
       }
     }
@@ -3935,7 +4749,7 @@ async function cleanupEmptyDirectories(dir) {
   }
 }
 async function getIndexStatus(rootDir) {
-  rootDir = path12.resolve(rootDir);
+  rootDir = path15.resolve(rootDir);
   const config = await loadConfig(rootDir);
   const location = getIndexLocation(rootDir);
   const indexDir = location.indexDir;
@@ -3971,7 +4785,7 @@ async function getIndexStatus(rootDir) {
     }
   } catch {
     try {
-      const entries = await fs6.readdir(path12.join(indexDir, "index"));
+      const entries = await fs6.readdir(path15.join(indexDir, "index"));
       if (entries.length > 0) {
         status.exists = true;
         for (const entry of entries) {
@@ -3991,11 +4805,12 @@ async function getIndexStatus(rootDir) {
   }
   return status;
 }
-var INDEX_SCHEMA_VERSION = "1.0.0";
+var INDEX_SCHEMA_VERSION = "1.0.0", DEFAULT_CONCURRENCY = 4;
 var init_indexer = __esm(() => {
   init_config2();
   init_registry();
   init_introspection2();
+  init_logger();
   init_watcher();
 });
 
@@ -4011,9 +4826,9 @@ __export(exports_search, {
   formatSearchResults: () => formatSearchResults
 });
 import * as fs7 from "fs/promises";
-import * as path13 from "path";
+import * as path16 from "path";
 async function search(rootDir, query, options = {}) {
-  rootDir = path13.resolve(rootDir);
+  rootDir = path16.resolve(rootDir);
   const ensureFresh = options.ensureFresh ?? DEFAULT_SEARCH_OPTIONS.ensureFresh;
   if (ensureFresh) {
     await ensureIndexFresh(rootDir, { quiet: true });
@@ -4058,7 +4873,7 @@ function createSearchContext(rootDir, moduleId, config) {
     config,
     loadFileIndex: async (filepath) => {
       const hasExtension = /\.[^./]+$/.test(filepath);
-      const indexFilePath = hasExtension ? path13.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path13.join(indexPath, filepath + ".json");
+      const indexFilePath = hasExtension ? path16.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path16.join(indexPath, filepath + ".json");
       try {
         const content = await fs7.readFile(indexFilePath, "utf-8");
         return JSON.parse(content);
@@ -4070,7 +4885,7 @@ function createSearchContext(rootDir, moduleId, config) {
       const files = [];
       await traverseDirectory(indexPath, files, indexPath);
       return files.filter((f) => f.endsWith(".json") && !f.endsWith("manifest.json")).map((f) => {
-        const relative4 = path13.relative(indexPath, f);
+        const relative4 = path16.relative(indexPath, f);
         return relative4.replace(/\.json$/, "");
       });
     }
@@ -4080,7 +4895,7 @@ async function traverseDirectory(dir, files, basePath) {
   try {
     const entries = await fs7.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path13.join(dir, entry.name);
+      const fullPath = path16.join(dir, entry.name);
       if (entry.isDirectory()) {
         await traverseDirectory(fullPath, files, basePath);
       } else if (entry.isFile()) {
@@ -4154,10 +4969,11 @@ var init_search = __esm(() => {
 
 // src/app/cli/main.ts
 init_embeddings();
+init_logger();
 // package.json
 var package_default = {
   name: "raggrep",
-  version: "0.3.0",
+  version: "0.5.0",
   description: "Local filesystem-based RAG system for codebases - semantic search using local embeddings",
   type: "module",
   main: "./dist/index.js",
@@ -4293,6 +5109,14 @@ function parseFlags(args2) {
         console.error("--type requires a file extension (e.g., ts, tsx, js)");
         process.exit(1);
       }
+    } else if (arg === "--concurrency" || arg === "-c") {
+      const c = parseInt(args2[++i], 10);
+      if (!isNaN(c) && c > 0) {
+        flags.concurrency = c;
+      } else {
+        console.error(`Invalid concurrency: ${args2[i]}. Must be a positive integer.`);
+        process.exit(1);
+      }
     } else if (!arg.startsWith("-")) {
       flags.remaining.push(arg);
     }
@@ -4312,10 +5136,11 @@ Usage:
   raggrep index [options]
 
 Options:
-  -w, --watch          Watch for file changes and re-index automatically
-  -m, --model <name>   Embedding model to use (default: all-MiniLM-L6-v2)
-  -v, --verbose        Show detailed progress
-  -h, --help           Show this help message
+  -w, --watch              Watch for file changes and re-index automatically
+  -m, --model <name>       Embedding model to use (default: all-MiniLM-L6-v2)
+  -c, --concurrency <n>    Number of files to process in parallel (default: 4)
+  -v, --verbose            Show detailed progress
+  -h, --help               Show this help message
 
 Available Models:
   ${models}
@@ -4326,18 +5151,22 @@ Examples:
   raggrep index
   raggrep index --watch
   raggrep index --model bge-small-en-v1.5
+  raggrep index --concurrency 8
   raggrep index --verbose
 `);
         process.exit(0);
       }
       const { indexDirectory: indexDirectory2, watchDirectory: watchDirectory2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
+      const logger = createInlineLogger({ verbose: flags.verbose });
       console.log("RAGgrep Indexer");
       console.log(`================
 `);
       try {
         const results = await indexDirectory2(process.cwd(), {
           model: flags.model,
-          verbose: flags.verbose
+          verbose: flags.verbose,
+          concurrency: flags.concurrency,
+          logger
         });
         console.log(`
 ================`);
@@ -4422,9 +5251,11 @@ Examples:
         process.exit(1);
       }
       try {
+        const silentLogger = createSilentLogger();
         const freshStats = await ensureIndexFresh2(process.cwd(), {
           model: flags.model,
-          quiet: true
+          quiet: true,
+          logger: silentLogger
         });
         console.log("RAGgrep Search");
         console.log(`==============
@@ -4457,44 +5288,37 @@ Examples:
       }
       break;
     }
-    case "cleanup": {
+    case "reset": {
       if (flags.help) {
         console.log(`
-raggrep cleanup - Remove stale index entries for deleted files
+raggrep reset - Clear the index for the current directory
 
 Usage:
-  raggrep cleanup [options]
+  raggrep reset [options]
 
 Options:
-  -v, --verbose        Show detailed progress
   -h, --help           Show this help message
 
 Description:
-  Scans the index and removes entries for files that no longer exist.
-  Run this command after deleting files to clean up the index.
+  Completely removes the index for the current directory.
+  The next 'raggrep index' or 'raggrep query' will rebuild from scratch.
 
 Examples:
-  raggrep cleanup
-  raggrep cleanup --verbose
+  raggrep reset
 `);
         process.exit(0);
       }
-      const { cleanupIndex: cleanupIndex2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
-      console.log("RAGgrep Cleanup");
-      console.log(`===============
-`);
+      const { resetIndex: resetIndex2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
       try {
-        const results = await cleanupIndex2(process.cwd(), {
-          verbose: flags.verbose
-        });
-        console.log(`
-===============`);
-        console.log("Summary:");
-        for (const result of results) {
-          console.log(`  ${result.moduleId}: ${result.removed} removed, ${result.kept} kept`);
-        }
+        const result = await resetIndex2(process.cwd());
+        console.log("Index cleared successfully.");
+        console.log(`  Removed: ${result.indexDir}`);
       } catch (error) {
-        console.error("Error during cleanup:", error);
+        if (error instanceof Error && error.message.includes("No index found")) {
+          console.error("Error: No index found for this directory.");
+          process.exit(1);
+        }
+        console.error("Error during reset:", error);
         process.exit(1);
       }
       break;
@@ -4573,7 +5397,7 @@ Commands:
   index    Index the current directory
   query    Search the indexed codebase
   status   Show the current state of the index
-  cleanup  Remove stale index entries for deleted files
+  reset    Clear the index for the current directory
 
 Options:
   -h, --help     Show help for a command
@@ -4583,7 +5407,7 @@ Examples:
   raggrep index
   raggrep query "user login"
   raggrep status
-  raggrep cleanup
+  raggrep reset
 
 Run 'raggrep <command> --help' for more information.
 `);
@@ -4595,4 +5419,4 @@ Run 'raggrep <command> --help' for more information.
 }
 main();
 
-//# debugId=F7638DADE034B49B64756E2164756E21
+//# debugId=5CA623D9974ACF4364756E2164756E21