raggrep 0.4.0 → 0.5.1

package/dist/cli/main.js

@@ -325,6 +325,7 @@ var init_searchResult = __esm(() => {
     topK: 10,
     minScore: 0.15,
     filePatterns: [],
+    pathFilter: [],
     ensureFresh: true
   };
 });
@@ -348,6 +349,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"
+        }
       }
     ]
   };
@@ -391,16 +406,18 @@ var init_config = __esm(() => {
     ".jsx",
     ".mjs",
     ".cjs",
+    ".mts",
+    ".cts",
+    ".json",
+    ".md",
     ".py",
     ".go",
     ".rs",
     ".java",
-    ".json",
     ".yaml",
     ".yml",
     ".toml",
     ".sql",
-    ".md",
     ".txt"
   ];
 });
@@ -2071,6 +2088,9 @@ class CoreModule {
   name = "Core Search";
   description = "Language-agnostic text search with symbol extraction";
   version = "1.0.0";
+  supportsFile(_filepath) {
+    return true;
+  }
   symbolIndex = new Map;
   bm25Index = null;
   rootDir = "";
@@ -2292,221 +2312,6 @@ var init_core = __esm(() => {
   init_symbols();
 });
 
-// src/domain/services/similarity.ts
-function cosineSimilarity(a, b) {
-  if (a.length !== b.length) {
-    throw new Error(`Vector length mismatch: ${a.length} vs ${b.length}`);
-  }
-  let dotProduct = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0;i < a.length; i++) {
-    dotProduct += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
-  if (magnitude === 0)
-    return 0;
-  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);
-  }
-  return parseGenericCode(content);
-}
-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);
-  function getLineNumbers(node) {
-    const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-    return {
-      startLine: start.line + 1,
-      endLine: end.line + 1
-    };
-  }
-  function getNodeText(node) {
-    return node.getText(sourceFile);
-  }
-  function isExported(node) {
-    if (!ts.canHaveModifiers(node))
-      return false;
-    const modifiers = ts.getModifiers(node);
-    return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
-  }
-  function getJSDoc(node) {
-    const jsDocNodes = ts.getJSDocCommentsAndTags(node);
-    if (jsDocNodes.length === 0)
-      return;
-    return jsDocNodes.map((doc) => doc.getText(sourceFile)).join(`
-`);
-  }
-  function getFunctionName(node) {
-    if (ts.isFunctionDeclaration(node) && node.name) {
-      return node.name.text;
-    }
-    if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name)) {
-      return node.name.text;
-    }
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
-      return node.name.text;
-    }
-    return;
-  }
-  function visit(node) {
-    const { startLine, endLine } = getLineNumbers(node);
-    if (ts.isFunctionDeclaration(node) && node.name) {
-      chunks.push({
-        content: getNodeText(node),
-        startLine,
-        endLine,
-        type: "function",
-        name: node.name.text,
-        isExported: isExported(node),
-        jsDoc: getJSDoc(node)
-      });
-      return;
-    }
-    if (ts.isVariableStatement(node)) {
-      for (const decl of node.declarationList.declarations) {
-        if (decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
-          const name = ts.isIdentifier(decl.name) ? decl.name.text : undefined;
-          chunks.push({
-            content: getNodeText(node),
-            startLine,
-            endLine,
-            type: "function",
-            name,
-            isExported: isExported(node),
-            jsDoc: getJSDoc(node)
-          });
-          return;
-        }
-      }
-    }
-    if (ts.isClassDeclaration(node) && node.name) {
-      chunks.push({
-        content: getNodeText(node),
-        startLine,
-        endLine,
-        type: "class",
-        name: node.name.text,
-        isExported: isExported(node),
-        jsDoc: getJSDoc(node)
-      });
-      return;
-    }
-    if (ts.isInterfaceDeclaration(node)) {
-      chunks.push({
-        content: getNodeText(node),
-        startLine,
-        endLine,
-        type: "interface",
-        name: node.name.text,
-        isExported: isExported(node),
-        jsDoc: getJSDoc(node)
-      });
-      return;
-    }
-    if (ts.isTypeAliasDeclaration(node)) {
-      chunks.push({
-        content: getNodeText(node),
-        startLine,
-        endLine,
-        type: "type",
-        name: node.name.text,
-        isExported: isExported(node),
-        jsDoc: getJSDoc(node)
-      });
-      return;
-    }
-    if (ts.isEnumDeclaration(node)) {
-      chunks.push({
-        content: getNodeText(node),
-        startLine,
-        endLine,
-        type: "enum",
-        name: node.name.text,
-        isExported: isExported(node),
-        jsDoc: getJSDoc(node)
-      });
-      return;
-    }
-    if (ts.isVariableStatement(node) && isExported(node)) {
-      for (const decl of node.declarationList.declarations) {
-        if (decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
-          continue;
-        }
-        const name = ts.isIdentifier(decl.name) ? decl.name.text : undefined;
-        chunks.push({
-          content: getNodeText(node),
-          startLine,
-          endLine,
-          type: "variable",
-          name,
-          isExported: true,
-          jsDoc: getJSDoc(node)
-        });
-      }
-      return;
-    }
-    ts.forEachChild(node, visit);
-  }
-  ts.forEachChild(sourceFile, visit);
-  if (chunks.length === 0) {
-    return parseGenericCode(content);
-  }
-  return chunks;
-}
-function parseGenericCode(content) {
-  const chunks = [];
-  const lines = content.split(`
-`);
-  const CHUNK_SIZE = 30;
-  const OVERLAP = 5;
-  if (lines.length <= CHUNK_SIZE) {
-    return [
-      {
-        content,
-        startLine: 1,
-        endLine: lines.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) {
-  const safePath = filepath.replace(/[/\\]/g, "-").replace(/\./g, "_");
-  return `${safePath}-${startLine}-${endLine}`;
-}
-var init_parseCode = () => {};
-
-// src/infrastructure/storage/fileIndexStorage.ts
-var init_fileIndexStorage = __esm(() => {
-  init_entities();
-});
-
 // src/domain/services/keywords.ts
 function extractKeywords(content, name, maxKeywords = 50) {
   const keywords = new Set;
@@ -2695,19 +2500,347 @@ var init_keywords = __esm(() => {
   };
 });
 
-// src/infrastructure/storage/symbolicIndex.ts
-import * as fs3 from "fs/promises";
-import * as path7 from "path";
+// src/domain/services/similarity.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector length mismatch: ${a.length} vs ${b.length}`);
+  }
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0;i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+  if (magnitude === 0)
+    return 0;
+  return dotProduct / magnitude;
+}
 
-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;
+// 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 "neutral";
+}
+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);
+  function getLineNumbers(node) {
+    const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+    return {
+      startLine: start.line + 1,
+      endLine: end.line + 1
+    };
+  }
+  function getNodeText(node) {
+    return node.getText(sourceFile);
+  }
+  function isExported(node) {
+    if (!ts.canHaveModifiers(node))
+      return false;
+    const modifiers = ts.getModifiers(node);
+    return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+  }
+  function getJSDoc(node) {
+    const jsDocNodes = ts.getJSDocCommentsAndTags(node);
+    if (jsDocNodes.length === 0)
+      return;
+    return jsDocNodes.map((doc) => doc.getText(sourceFile)).join(`
+`);
+  }
+  function getFunctionName(node) {
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      return node.name.text;
+    }
+    if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name)) {
+      return node.name.text;
+    }
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+      return node.name.text;
+    }
+    return;
+  }
+  function visit(node) {
+    const { startLine, endLine } = getLineNumbers(node);
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      chunks.push({
+        content: getNodeText(node),
+        startLine,
+        endLine,
+        type: "function",
+        name: node.name.text,
+        isExported: isExported(node),
+        jsDoc: getJSDoc(node)
+      });
+      return;
+    }
+    if (ts.isVariableStatement(node)) {
+      for (const decl of node.declarationList.declarations) {
+        if (decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
+          const name = ts.isIdentifier(decl.name) ? decl.name.text : undefined;
+          chunks.push({
+            content: getNodeText(node),
+            startLine,
+            endLine,
+            type: "function",
+            name,
+            isExported: isExported(node),
+            jsDoc: getJSDoc(node)
+          });
+          return;
+        }
+      }
+    }
+    if (ts.isClassDeclaration(node) && node.name) {
+      chunks.push({
+        content: getNodeText(node),
+        startLine,
+        endLine,
+        type: "class",
+        name: node.name.text,
+        isExported: isExported(node),
+        jsDoc: getJSDoc(node)
+      });
+      return;
+    }
+    if (ts.isInterfaceDeclaration(node)) {
+      chunks.push({
+        content: getNodeText(node),
+        startLine,
+        endLine,
+        type: "interface",
+        name: node.name.text,
+        isExported: isExported(node),
+        jsDoc: getJSDoc(node)
+      });
+      return;
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+      chunks.push({
+        content: getNodeText(node),
+        startLine,
+        endLine,
+        type: "type",
+        name: node.name.text,
+        isExported: isExported(node),
+        jsDoc: getJSDoc(node)
+      });
+      return;
+    }
+    if (ts.isEnumDeclaration(node)) {
+      chunks.push({
+        content: getNodeText(node),
+        startLine,
+        endLine,
+        type: "enum",
+        name: node.name.text,
+        isExported: isExported(node),
+        jsDoc: getJSDoc(node)
+      });
+      return;
+    }
+    if (ts.isVariableStatement(node) && isExported(node)) {
+      for (const decl of node.declarationList.declarations) {
+        if (decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
+          continue;
+        }
+        const name = ts.isIdentifier(decl.name) ? decl.name.text : undefined;
+        chunks.push({
+          content: getNodeText(node),
+          startLine,
+          endLine,
+          type: "variable",
+          name,
+          isExported: true,
+          jsDoc: getJSDoc(node)
+        });
+      }
+      return;
+    }
+    ts.forEachChild(node, visit);
+  }
+  ts.forEachChild(sourceFile, visit);
+  if (chunks.length === 0) {
+    const lines2 = content.split(`
+`);
+    return [
+      {
+        content,
+        startLine: 1,
+        endLine: lines2.length,
+        type: "file"
+      }
+    ];
+  }
+  return chunks;
+}
+function generateChunkId2(filepath, startLine, endLine) {
+  const safePath = filepath.replace(/[/\\]/g, "-").replace(/\./g, "_");
+  return `${safePath}-${startLine}-${endLine}`;
+}
+var init_parseCode = () => {};
+
+// src/infrastructure/storage/fileIndexStorage.ts
+var init_fileIndexStorage = __esm(() => {
+  init_entities();
+});
+
+// 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;
   }
   async initialize() {
     try {
@@ -2724,194 +2857,763 @@ class SymbolicIndex {
           totalDocs: 0
         }
       };
-      this.bm25Index = new BM25Index;
+      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());
+  }
+  getFileSummary(filepath) {
+    return this.fileSummaries.get(filepath);
+  }
+  async save() {
+    if (!this.meta)
+      throw new Error("Index not initialized");
+    this.meta.lastUpdated = new Date().toISOString();
+    this.meta.fileCount = this.fileSummaries.size;
+    await fs3.mkdir(this.symbolicPath, { recursive: true });
+    const metaPath = path8.join(this.symbolicPath, "_meta.json");
+    await fs3.writeFile(metaPath, JSON.stringify(this.meta, null, 2));
+    for (const [filepath, summary] of this.fileSummaries) {
+      const summaryPath = this.getFileSummaryPath(filepath);
+      await fs3.mkdir(path8.dirname(summaryPath), { recursive: true });
+      await fs3.writeFile(summaryPath, JSON.stringify(summary, null, 2));
+    }
+  }
+  async load() {
+    const metaPath = path8.join(this.symbolicPath, "_meta.json");
+    const metaContent = await fs3.readFile(metaPath, "utf-8");
+    this.meta = JSON.parse(metaContent);
+    this.fileSummaries.clear();
+    await this.loadFileSummariesRecursive(this.symbolicPath);
+    this.buildBM25Index();
+  }
+  async loadFileSummariesRecursive(dir) {
+    try {
+      const entries = await fs3.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path8.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await this.loadFileSummariesRecursive(fullPath);
+        } else if (entry.name.endsWith(".json") && entry.name !== "_meta.json") {
+          try {
+            const content = await fs3.readFile(fullPath, "utf-8");
+            const summary = JSON.parse(content);
+            if (summary.filepath) {
+              this.fileSummaries.set(summary.filepath, summary);
+            }
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+  getFileSummaryPath(filepath) {
+    const jsonPath = filepath.replace(/\.[^.]+$/, ".json");
+    return path8.join(this.symbolicPath, jsonPath);
+  }
+  async deleteFileSummary(filepath) {
+    try {
+      await fs3.unlink(this.getFileSummaryPath(filepath));
+    } catch {}
+    this.fileSummaries.delete(filepath);
+  }
+  async exists() {
+    try {
+      const metaPath = path8.join(this.symbolicPath, "_meta.json");
+      await fs3.access(metaPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  get size() {
+    return this.fileSummaries.size;
+  }
+  clear() {
+    this.fileSummaries.clear();
+    if (this.meta) {
+      this.meta.fileCount = 0;
+      this.meta.bm25Data = {
+        avgDocLength: 0,
+        documentFrequencies: {},
+        totalDocs: 0
+      };
     }
+    this.bm25Index = new BM25Index;
   }
-  addFile(summary) {
-    this.fileSummaries.set(summary.filepath, summary);
+}
+var init_symbolicIndex = __esm(() => {
+  init_keywords();
+});
+
+// src/infrastructure/storage/index.ts
+var init_storage = __esm(() => {
+  init_fileIndexStorage();
+  init_symbolicIndex();
+});
+
+// src/modules/language/typescript/index.ts
+var exports_typescript = {};
+__export(exports_typescript, {
+  supportsFile: () => supportsFile,
+  isTypeScriptFile: () => isTypeScriptFile,
+  TypeScriptModule: () => TypeScriptModule,
+  TYPESCRIPT_EXTENSIONS: () => TYPESCRIPT_EXTENSIONS,
+  DEFAULT_TOP_K: () => DEFAULT_TOP_K2,
+  DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE2
+});
+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) {
+    case "function":
+      return 0.05;
+    case "class":
+    case "interface":
+      return 0.04;
+    case "type":
+    case "enum":
+      return 0.03;
+    case "variable":
+      return 0.02;
+    case "file":
+    case "block":
+    default:
+      return 0;
   }
-  removeFile(filepath) {
-    return this.fileSummaries.delete(filepath);
+}
+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";
+  supportsFile(filepath) {
+    return isTypeScriptFile(filepath);
+  }
+  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);
   }
-  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 }]);
+  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);
+      }
     }
-    if (this.meta) {
-      this.meta.fileCount = this.fileSummaries.size;
-      this.meta.bm25Data.totalDocs = this.fileSummaries.size;
+    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;
   }
-  findCandidates(query, maxCandidates = 20) {
-    if (!this.bm25Index) {
-      return Array.from(this.fileSummaries.keys());
+}
+var DEFAULT_MIN_SCORE2 = 0.15, DEFAULT_TOP_K2 = 10, SEMANTIC_WEIGHT = 0.7, BM25_WEIGHT = 0.3, TYPESCRIPT_EXTENSIONS, supportsFile;
+var init_typescript = __esm(() => {
+  init_embeddings();
+  init_services();
+  init_config2();
+  init_parseCode();
+  init_storage();
+  TYPESCRIPT_EXTENSIONS = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".mts",
+    ".cts"
+  ];
+  supportsFile = isTypeScriptFile;
+});
+
+// src/modules/data/json/index.ts
+var exports_json = {};
+__export(exports_json, {
+  supportsFile: () => supportsFile2,
+  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));
     }
-    const results = this.bm25Index.search(query, maxCandidates);
-    return results.map((r) => r.id);
   }
-  getAllFiles() {
-    return Array.from(this.fileSummaries.keys());
+  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 [];
   }
-  getFileSummary(filepath) {
-    return this.fileSummaries.get(filepath);
+}
+
+class JsonModule {
+  id = "data/json";
+  name = "JSON Search";
+  description = "JSON file search with structure-aware indexing";
+  version = "1.0.0";
+  supportsFile(filepath) {
+    return isJsonFile(filepath);
   }
-  async save() {
-    if (!this.meta)
-      throw new Error("Index not initialized");
-    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");
-    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.writeFile(summaryPath, JSON.stringify(summary, null, 2));
+  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 load() {
-    const metaPath = path7.join(this.symbolicPath, "_meta.json");
-    const metaContent = await fs3.readFile(metaPath, "utf-8");
-    this.meta = JSON.parse(metaContent);
-    this.fileSummaries.clear();
-    await this.loadFileSummariesRecursive(this.symbolicPath);
-    this.buildBM25Index();
-  }
-  async loadFileSummariesRecursive(dir) {
-    try {
-      const entries = await fs3.readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path7.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          await this.loadFileSummariesRecursive(fullPath);
-        } else if (entry.name.endsWith(".json") && entry.name !== "_meta.json") {
-          try {
-            const content = await fs3.readFile(fullPath, "utf-8");
-            const summary = JSON.parse(content);
-            if (summary.filepath) {
-              this.fileSummaries.set(summary.filepath, summary);
-            }
-          } catch {}
-        }
+  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 {};
       }
-    } catch {}
-  }
-  getFileSummaryPath(filepath) {
-    const jsonPath = filepath.replace(/\.[^.]+$/, ".json");
-    return path7.join(this.symbolicPath, jsonPath);
+    })());
+    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 deleteFileSummary(filepath) {
-    try {
-      await fs3.unlink(this.getFileSummaryPath(filepath));
-    } catch {}
-    this.fileSummaries.delete(filepath);
+  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 exists() {
+  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 {
-      const metaPath = path7.join(this.symbolicPath, "_meta.json");
-      await fs3.access(metaPath);
-      return true;
+      await symbolicIndex.initialize();
+      allFiles = symbolicIndex.getAllFiles();
     } catch {
-      return false;
+      allFiles = await ctx.listIndexedFiles();
     }
-  }
-  get size() {
-    return this.fileSummaries.size;
-  }
-  clear() {
-    this.fileSummaries.clear();
-    if (this.meta) {
-      this.meta.fileCount = 0;
-      this.meta.bm25Data = {
-        avgDocLength: 0,
-        documentFrequencies: {},
-        totalDocs: 0
-      };
+    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);
+        });
+      });
     }
-    this.bm25Index = new BM25Index;
+    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 init_symbolicIndex = __esm(() => {
-  init_keywords();
-});
-
-// src/infrastructure/storage/index.ts
-var init_storage = __esm(() => {
-  init_fileIndexStorage();
-  init_symbolicIndex();
+var DEFAULT_MIN_SCORE3 = 0.15, DEFAULT_TOP_K3 = 10, SEMANTIC_WEIGHT2 = 0.7, BM25_WEIGHT2 = 0.3, JSON_EXTENSIONS, supportsFile2;
+var init_json = __esm(() => {
+  init_embeddings();
+  init_services();
+  init_config2();
+  init_storage();
+  JSON_EXTENSIONS = [".json"];
+  supportsFile2 = isJsonFile;
 });
 
-// src/modules/language/typescript/index.ts
-var exports_typescript = {};
-__export(exports_typescript, {
-  TypeScriptModule: () => TypeScriptModule,
-  DEFAULT_TOP_K: () => DEFAULT_TOP_K2,
-  DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE2
+// src/modules/docs/markdown/index.ts
+var exports_markdown = {};
+__export(exports_markdown, {
+  supportsFile: () => supportsFile3,
+  isMarkdownFile: () => isMarkdownFile,
+  MarkdownModule: () => MarkdownModule,
+  MARKDOWN_EXTENSIONS: () => MARKDOWN_EXTENSIONS,
+  DEFAULT_TOP_K: () => DEFAULT_TOP_K4,
+  DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE4
 });
-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";
+import * as path11 from "path";
+function isMarkdownFile(filepath) {
+  const ext = path11.extname(filepath).toLowerCase();
+  return MARKDOWN_EXTENSIONS.includes(ext);
 }
-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;
+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);
     }
-    return 0;
   }
-  if (intent === "documentation") {
-    if (isDoc) {
-      return 0.08;
+  if (currentSection) {
+    currentSection.content = currentContent.join(`
+`).trim();
+    currentSection.endLine = lines.length;
+    if (currentSection.content || currentSection.heading) {
+      sections.push(currentSection);
     }
-    return 0;
+  } else if (currentContent.length > 0) {
+    sections.push({
+      heading: "",
+      level: 0,
+      content: currentContent.join(`
+`).trim(),
+      startLine: 1,
+      endLine: lines.length
+    });
   }
-  return 0;
+  return sections;
 }
-function calculateChunkTypeBoost(chunk) {
-  switch (chunk.type) {
-    case "function":
-      return 0.05;
-    case "class":
-    case "interface":
-      return 0.04;
-    case "type":
-    case "enum":
-      return 0.03;
-    case "variable":
-      return 0.02;
-    case "file":
-    case "block":
-    default:
-      return 0;
+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);
+    }
   }
-}
-function calculateExportBoost(chunk) {
-  return chunk.isExported ? 0.03 : 0;
+  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";
+  supportsFile(filepath) {
+    return isMarkdownFile(filepath);
+  }
   embeddingConfig = null;
   symbolicIndex = null;
   pendingSummaries = new Map;
@@ -2930,66 +3632,53 @@ class TypeScriptModule {
     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) {
@@ -3005,8 +3694,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);
@@ -3018,9 +3707,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);
@@ -3058,36 +3747,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,
@@ -3097,10 +3774,7 @@ class TypeScriptModule {
           context: {
             semanticScore,
             bm25Score,
-            pathBoost,
-            fileTypeBoost,
-            chunkTypeBoost,
-            exportBoost
+            docBoost
           }
         });
       }
@@ -3108,84 +3782,15 @@ 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, supportsFile3;
+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"];
+  supportsFile3 = isMarkdownFile;
 });
 
 // src/modules/registry.ts
@@ -3210,8 +3815,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(() => {
@@ -3219,13 +3828,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");
@@ -3248,10 +3857,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"]) {
@@ -3296,7 +3905,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) {
@@ -3327,7 +3936,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;
@@ -3367,7 +3976,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 {
@@ -3381,7 +3990,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 || {};
@@ -3421,28 +4030,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();
@@ -3452,7 +4061,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);
@@ -3483,7 +4092,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,
@@ -3494,7 +4103,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);
@@ -3504,7 +4113,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;
@@ -3586,7 +4195,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;
     }
@@ -3665,15 +4274,48 @@ __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;
+}
+function formatDuration(ms) {
+  if (ms < 1000) {
+    return `${ms}ms`;
+  }
+  const seconds = ms / 1000;
+  if (seconds < 60) {
+    return `${seconds.toFixed(1)}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes}m ${remainingSeconds.toFixed(1)}s`;
+}
 async function indexDirectory(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
   const quiet = options.quiet ?? false;
+  const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
   const logger = options.logger ? options.logger : quiet ? createSilentLogger() : createLogger({ verbose });
-  rootDir = path12.resolve(rootDir);
+  rootDir = path15.resolve(rootDir);
   const location = getIndexLocation(rootDir);
   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();
@@ -3690,8 +4332,10 @@ async function indexDirectory(rootDir, options = {}) {
   logger.info(`Enabled modules: ${enabledModules.map((m) => m.id).join(", ")}`);
   const files = await findFiles(rootDir, config);
   logger.info(`Found ${files.length} files to index`);
+  const overallStart = Date.now();
   const results = [];
   for (const module of enabledModules) {
+    const moduleStart = Date.now();
     logger.info(`
 [${module.name}] Starting indexing...`);
     const moduleConfig = getModuleConfig(config, module.id);
@@ -3709,7 +4353,9 @@ async function indexDirectory(rootDir, options = {}) {
       };
       await module.initialize(configWithOverrides);
     }
-    const result = await indexWithModule(rootDir, files, module, config, verbose, introspection, logger);
+    const moduleFiles = module.supportsFile ? files.filter((f) => module.supportsFile(f)) : files;
+    logger.info(`  Processing ${moduleFiles.length} files...`);
+    const result = await indexWithModule(rootDir, moduleFiles, module, config, verbose, introspection, logger, concurrency);
     results.push(result);
     if (module.finalize) {
       logger.info(`[${module.name}] Building secondary indexes...`);
@@ -3717,20 +4363,29 @@ async function indexDirectory(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() };
         }
       };
       await module.finalize(ctx);
     }
-    logger.info(`[${module.name}] Complete: ${result.indexed} indexed, ${result.skipped} skipped, ${result.errors} errors`);
+    const moduleDuration = Date.now() - moduleStart;
+    result.durationMs = moduleDuration;
+    logger.info(`[${module.name}] Complete: ${result.indexed} indexed, ${result.skipped} skipped, ${result.errors} errors (${formatDuration(moduleDuration)})`);
   }
   await introspection.save(config);
+  const overallDuration = Date.now() - overallStart;
+  logger.info(`
+Indexing complete in ${formatDuration(overallDuration)}`);
+  const totalIndexed = results.reduce((sum, r) => sum + r.indexed, 0);
+  const totalSkipped = results.reduce((sum, r) => sum + r.skipped, 0);
+  const totalErrors = results.reduce((sum, r) => sum + r.errors, 0);
+  logger.info(`Total: ${totalIndexed} indexed, ${totalSkipped} skipped, ${totalErrors} errors`);
   await updateGlobalManifest(rootDir, enabledModules, config);
   return results;
 }
@@ -3752,7 +4407,7 @@ async function deleteIndex(rootDir) {
   } catch {}
 }
 async function resetIndex(rootDir) {
-  rootDir = path12.resolve(rootDir);
+  rootDir = path15.resolve(rootDir);
   const status = await getIndexStatus(rootDir);
   if (!status.exists) {
     throw new Error(`No index found for ${rootDir}`);
@@ -3767,7 +4422,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
   const quiet = options.quiet ?? false;
   const logger = options.logger ? options.logger : quiet ? createSilentLogger() : createLogger({ verbose });
-  rootDir = path12.resolve(rootDir);
+  rootDir = path15.resolve(rootDir);
   const status = await getIndexStatus(rootDir);
   if (!status.exists) {
     logger.info(`No index found. Creating index...
@@ -3794,7 +4449,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;
@@ -3824,11 +4479,11 @@ async function ensureIndexFresh(rootDir, options = {}) {
     }
     for (const filepath of filesToRemove) {
       logger.debug(`  Removing stale: ${filepath}`);
-      const indexFilePath = path12.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+      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 {}
@@ -3839,11 +4494,11 @@ 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() };
       },
@@ -3852,7 +4507,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
     const totalFiles = currentFiles.length;
     for (let i = 0;i < currentFiles.length; i++) {
       const filepath = currentFiles[i];
-      const relativePath = path12.relative(rootDir, filepath);
+      const relativePath = path15.relative(rootDir, filepath);
       const progress = `[${i + 1}/${totalFiles}]`;
       try {
         const stats = await fs6.stat(filepath);
@@ -3903,7 +4558,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
     unchanged: totalUnchanged
   };
 }
-async function indexWithModule(rootDir, files, module, config, verbose, introspection, logger) {
+async function indexWithModule(rootDir, files, module, config, verbose, introspection, logger, concurrency = DEFAULT_CONCURRENCY) {
   const result = {
     moduleId: module.id,
     indexed: 0,
@@ -3912,7 +4567,7 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
   };
   const manifest = await loadModuleManifest(rootDir, module.id, config);
   const indexPath = getModuleIndexPath(rootDir, module.id, config);
-  const currentFileSet = new Set(files.map((f) => path12.relative(rootDir, f)));
+  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)) {
@@ -3923,11 +4578,11 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
     logger.info(`  Removing ${filesToRemove.length} stale entries...`);
     for (const filepath of filesToRemove) {
       logger.debug(`    Removing: ${filepath}`);
-      const indexFilePath = path12.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+      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 {}
@@ -3939,52 +4594,76 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
     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)
   };
   const totalFiles = files.length;
-  for (let i = 0;i < files.length; i++) {
-    const filepath = files[i];
-    const relativePath = path12.relative(rootDir, filepath);
-    const progress = `[${i + 1}/${totalFiles}]`;
+  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) {
-        logger.debug(`  ${progress} 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);
-      logger.progress(`  ${progress} Processing: ${relativePath}`);
+      completedCount++;
+      logger.progress(`  [${completedCount}/${totalFiles}] Processing: ${relativePath}`);
       const fileIndex = await module.indexFile(relativePath, content, ctx);
       if (!fileIndex) {
-        logger.debug(`  ${progress} 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) {
-      logger.clearProgress();
-      logger.error(`  ${progress} 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;
     }
   }
-  logger.clearProgress();
   manifest.lastUpdated = new Date().toISOString();
   await writeModuleManifest(rootDir, module.id, manifest, config);
   return result;
@@ -4019,13 +4698,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) {
@@ -4035,13 +4714,13 @@ 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;
   const logger = options.logger ?? createLogger({ verbose });
-  rootDir = path12.resolve(rootDir);
+  rootDir = path15.resolve(rootDir);
   logger.info(`Cleaning up index in: ${rootDir}`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -4071,7 +4750,7 @@ async function cleanupModuleIndex(rootDir, moduleId, config, logger) {
   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;
@@ -4083,7 +4762,7 @@ async function cleanupModuleIndex(rootDir, moduleId, config, logger) {
     }
   }
   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 {}
@@ -4099,7 +4778,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);
       }
     }
@@ -4114,7 +4793,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;
@@ -4150,7 +4829,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) {
@@ -4170,7 +4849,7 @@ 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();
@@ -4191,9 +4870,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 });
@@ -4227,9 +4906,17 @@ async function search(rootDir, query, options = {}) {
     const moduleResults = await module.search(query, ctx, options);
     allResults.push(...moduleResults);
   }
-  allResults.sort((a, b) => b.score - a.score);
+  let filteredResults = allResults;
+  if (options.pathFilter && options.pathFilter.length > 0) {
+    const normalizedFilters = options.pathFilter.map((p) => p.replace(/\\/g, "/").replace(/^\//, "").replace(/\/$/, ""));
+    filteredResults = allResults.filter((result) => {
+      const normalizedPath = result.filepath.replace(/\\/g, "/");
+      return normalizedFilters.some((filter) => normalizedPath.startsWith(filter + "/") || normalizedPath === filter || normalizedPath.startsWith("./" + filter + "/") || normalizedPath === "./" + filter);
+    });
+  }
+  filteredResults.sort((a, b) => b.score - a.score);
   const topK = options.topK ?? 10;
-  return allResults.slice(0, topK);
+  return filteredResults.slice(0, topK);
 }
 function createSearchContext(rootDir, moduleId, config) {
   const indexPath = getModuleIndexPath(rootDir, moduleId, config);
@@ -4238,7 +4925,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);
@@ -4250,7 +4937,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$/, "");
       });
     }
@@ -4260,7 +4947,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()) {
@@ -4338,7 +5025,7 @@ init_logger();
 // package.json
 var package_default = {
   name: "raggrep",
-  version: "0.4.0",
+  version: "0.5.1",
   description: "Local filesystem-based RAG system for codebases - semantic search using local embeddings",
   type: "module",
   main: "./dist/index.js",
@@ -4474,6 +5161,25 @@ 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 === "--filter" || arg === "-f") {
+      const filterPath = args2[++i];
+      if (filterPath) {
+        if (!flags.pathFilter) {
+          flags.pathFilter = [];
+        }
+        flags.pathFilter.push(filterPath);
+      } else {
+        console.error("--filter requires a path (e.g., src/auth)");
+        process.exit(1);
+      }
     } else if (!arg.startsWith("-")) {
       flags.remaining.push(arg);
     }
@@ -4493,10 +5199,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}
@@ -4507,6 +5214,7 @@ Examples:
   raggrep index
   raggrep index --watch
   raggrep index --model bge-small-en-v1.5
+  raggrep index --concurrency 8
   raggrep index --verbose
 `);
         process.exit(0);
@@ -4520,6 +5228,7 @@ Examples:
         const results = await indexDirectory2(process.cwd(), {
           model: flags.model,
           verbose: flags.verbose,
+          concurrency: flags.concurrency,
           logger
         });
         console.log(`
@@ -4579,6 +5288,7 @@ Options:
   -k, --top <n>        Number of results to return (default: 10)
   -s, --min-score <n>  Minimum similarity score 0-1 (default: 0.15)
   -t, --type <ext>     Filter by file extension (e.g., ts, tsx, js)
+  -f, --filter <path>  Filter by path prefix (can be used multiple times)
   -h, --help           Show this help message
 
 Note:
@@ -4593,6 +5303,8 @@ Examples:
   raggrep query "handle errors" --top 5
   raggrep query "database" --min-score 0.1
   raggrep query "interface" --type ts
+  raggrep query "login" --filter src/auth
+  raggrep query "api" --filter src/api --filter src/routes
 `);
         process.exit(0);
       }
@@ -4633,6 +5345,7 @@ Examples:
           topK: flags.topK ?? 10,
           minScore: flags.minScore,
           filePatterns,
+          pathFilter: flags.pathFilter,
           ensureFresh: false
         });
         console.log(formatSearchResults2(results));
@@ -4773,4 +5486,4 @@ Run 'raggrep <command> --help' for more information.
 }
 main();
 
-//# debugId=B729BEE1B814E8D564756E2164756E21
+//# debugId=E73618F0DDE8326264756E2164756E21