raggrep 0.3.0 → 0.5.0

package/dist/index.js

@@ -1,4 +1,20 @@
+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, {
@@ -9,6 +25,7 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // src/domain/entities/searchResult.ts
 var DEFAULT_SEARCH_OPTIONS;
 var init_searchResult = __esm(() => {
@@ -39,6 +56,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"
+        }
       }
     ]
   };
@@ -82,16 +113,18 @@ var init_config = __esm(() => {
     ".jsx",
     ".mjs",
     ".cjs",
+    ".mts",
+    ".cts",
+    ".json",
+    ".md",
     ".py",
     ".go",
     ".rs",
     ".java",
-    ".json",
     ".yaml",
     ".yml",
     ".toml",
     ".sql",
-    ".md",
     ".txt"
   ];
 });
@@ -1999,7 +2032,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) {
@@ -2021,29 +2055,55 @@ class TransformersEmbeddingProvider {
     this.isInitializing = true;
     this.initPromise = (async () => {
       const modelId = EMBEDDING_MODELS2[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;
@@ -2094,9 +2154,21 @@ class TransformersEmbeddingProvider {
     this.pipeline = null;
   }
 }
+async function isModelCached(model) {
+  const modelId = EMBEDDING_MODELS2[model];
+  const modelPath = path6.join(CACHE_DIR, modelId);
+  try {
+    const fs3 = await import("fs/promises");
+    const onnxPath = path6.join(modelPath, "onnx", "model_quantized.onnx");
+    await fs3.access(onnxPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
 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;
@@ -2132,7 +2204,8 @@ var init_transformersEmbedding = __esm(() => {
   };
   globalConfig = {
     model: "all-MiniLM-L6-v2",
-    showProgress: false
+    showProgress: false,
+    logger: undefined
   };
 });
 
@@ -2141,221 +2214,6 @@ var init_embeddings = __esm(() => {
   init_transformersEmbedding();
 });
 
-// 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;
@@ -2544,166 +2402,27 @@ var init_keywords = __esm(() => {
   };
 });
 
-// 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;
+// 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}`);
   }
-  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());
-  }
-  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 = 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));
-    }
-  }
-  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 {}
-        }
-      }
-    } catch {}
-  }
-  getFileSummaryPath(filepath) {
-    const jsonPath = filepath.replace(/\.[^.]+$/, ".json");
-    return path7.join(this.symbolicPath, jsonPath);
-  }
-  async deleteFileSummary(filepath) {
-    try {
-      await fs3.unlink(this.getFileSummaryPath(filepath));
-    } catch {}
-    this.fileSummaries.delete(filepath);
-  }
-  async exists() {
-    try {
-      const metaPath = path7.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;
+  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;
 }
-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, {
-  TypeScriptModule: () => TypeScriptModule,
-  DEFAULT_TOP_K: () => DEFAULT_TOP_K2,
-  DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE2
-});
-import * as path8 from "path";
+// 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));
@@ -2715,10 +2434,20 @@ function detectQueryIntent(queryTerms) {
   }
   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 ext = path8.extname(filepath).toLowerCase();
-  const isSourceCode = SOURCE_CODE_EXTENSIONS.includes(ext);
-  const isDoc = DOC_EXTENSIONS.includes(ext);
+  const isSourceCode = isSourceCodeFile(filepath);
+  const isDoc = isDocFile(filepath);
   const intent = detectQueryIntent(queryTerms);
   if (intent === "implementation") {
     if (isSourceCode) {
@@ -2734,103 +2463,1110 @@ function calculateFileTypeBoost(filepath, queryTerms) {
   }
   return 0;
 }
-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;
+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 {
+      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());
+  }
+  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;
+  }
+}
+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, {
+  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;
+  }
+}
+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 calculateExportBoost(chunk) {
-  return chunk.isExported ? 0.03 : 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);
+    }
+  }
+  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) {
@@ -2846,8 +3582,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);
@@ -2859,9 +3595,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);
@@ -2899,36 +3635,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,
@@ -2938,10 +3662,7 @@ class TypeScriptModule {
           context: {
             semanticScore,
             bm25Score,
-            pathBoost,
-            fileTypeBoost,
-            chunkTypeBoost,
-            exportBoost
+            docBoost
           }
         });
       }
@@ -2949,91 +3670,21 @@ 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/app/indexer/index.ts
 init_config2();
 import { glob } from "glob";
 import * as fs6 from "fs/promises";
-import * as path11 from "path";
+import * as path14 from "path";
 
 // src/modules/registry.ts
 class ModuleRegistryImpl {
@@ -3058,16 +3709,20 @@ var registry = new 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);
 }
 
 // src/infrastructure/introspection/IntrospectionIndex.ts
-import * as path10 from "path";
+import * as path13 from "path";
 import * as fs5 from "fs/promises";
 
 // src/infrastructure/introspection/projectDetector.ts
-import * as path9 from "path";
+import * as path12 from "path";
 import * as fs4 from "fs/promises";
 var MAX_SCAN_DEPTH = 4;
 var SKIP_DIRS = new Set([
@@ -3084,7 +3739,7 @@ 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");
@@ -3107,10 +3762,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"]) {
@@ -3155,7 +3810,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) {
@@ -3186,7 +3841,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;
@@ -3227,7 +3882,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 || {};
@@ -3267,28 +3922,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();
@@ -3298,7 +3953,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);
@@ -3315,51 +3970,148 @@ class IntrospectionIndex {
     this.structure = null;
   }
 }
+// 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/app/indexer/watcher.ts
 import { watch } from "chokidar";
 init_config2();
 
 // src/app/indexer/index.ts
+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;
+}
 var INDEX_SCHEMA_VERSION = "1.0.0";
+var DEFAULT_CONCURRENCY = 4;
 async function indexDirectory(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
   const quiet = options.quiet ?? false;
-  rootDir = path11.resolve(rootDir);
+  const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
+  const logger = options.logger ? options.logger : quiet ? createSilentLogger() : createLogger({ verbose });
+  rootDir = path14.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 };
@@ -3369,32 +4121,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 = path11.isAbsolute(filepath) ? filepath : path11.join(rootDir, filepath);
+          const fullPath = path14.isAbsolute(filepath) ? filepath : path14.join(rootDir, filepath);
           return fs6.readFile(fullPath, "utf-8");
         },
         getFileStats: async (filepath) => {
-          const fullPath = path11.isAbsolute(filepath) ? filepath : path11.join(rootDir, filepath);
+          const fullPath = path14.isAbsolute(filepath) ? filepath : path14.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);
@@ -3417,28 +4169,37 @@ async function deleteIndex(rootDir) {
     await fs6.rm(indexDir, { recursive: true, force: true });
   } catch {}
 }
+async function resetIndex(rootDir) {
+  rootDir = path14.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 = path11.resolve(rootDir);
+  const logger = options.logger ? options.logger : quiet ? createSilentLogger() : createLogger({ verbose });
+  rootDir = path14.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 };
   }
@@ -3451,7 +4212,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) => path11.relative(rootDir, f)));
+  const currentFileSet = new Set(currentFiles.map((f) => path14.relative(rootDir, f)));
   let totalIndexed = 0;
   let totalRemoved = 0;
   let totalUnchanged = 0;
@@ -3465,6 +4226,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);
@@ -3476,14 +4241,12 @@ async function ensureIndexFresh(rootDir, options = {}) {
       }
     }
     for (const filepath of filesToRemove) {
-      if (verbose) {
-        console.log(`  Removing stale: ${filepath}`);
-      }
-      const indexFilePath = path11.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+      logger.debug(`  Removing stale: ${filepath}`);
+      const indexFilePath = path14.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
       try {
         await fs6.unlink(indexFilePath);
       } catch {}
-      const symbolicFilePath = path11.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
+      const symbolicFilePath = path14.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
       try {
         await fs6.unlink(symbolicFilePath);
       } catch {}
@@ -3494,18 +4257,21 @@ async function ensureIndexFresh(rootDir, options = {}) {
       rootDir,
       config,
       readFile: async (filepath) => {
-        const fullPath = path11.isAbsolute(filepath) ? filepath : path11.join(rootDir, filepath);
+        const fullPath = path14.isAbsolute(filepath) ? filepath : path14.join(rootDir, filepath);
         return fs6.readFile(fullPath, "utf-8");
       },
       getFileStats: async (filepath) => {
-        const fullPath = path11.isAbsolute(filepath) ? filepath : path11.join(rootDir, filepath);
+        const fullPath = path14.isAbsolute(filepath) ? filepath : path14.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 = path11.relative(rootDir, filepath);
+    const totalFiles = currentFiles.length;
+    for (let i = 0;i < currentFiles.length; i++) {
+      const filepath = currentFiles[i];
+      const relativePath = path14.relative(rootDir, filepath);
+      const progress = `[${i + 1}/${totalFiles}]`;
       try {
         const stats = await fs6.stat(filepath);
         const lastModified = stats.mtime.toISOString();
@@ -3514,9 +4280,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);
@@ -3529,11 +4293,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);
@@ -3557,7 +4321,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,
@@ -3565,55 +4329,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) => path14.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 = path14.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+      try {
+        await fs6.unlink(indexFilePath);
+      } catch {}
+      const symbolicFilePath = path14.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 = path11.isAbsolute(filepath) ? filepath : path11.join(rootDir, filepath);
+      const fullPath = path14.isAbsolute(filepath) ? filepath : path14.join(rootDir, filepath);
       return fs6.readFile(fullPath, "utf-8");
     },
     getFileStats: async (filepath) => {
-      const fullPath = path11.isAbsolute(filepath) ? filepath : path11.join(rootDir, filepath);
+      const fullPath = path14.isAbsolute(filepath) ? filepath : path14.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 = path11.relative(rootDir, filepath);
+  const totalFiles = files.length;
+  let completedCount = 0;
+  const processFile = async (filepath, _index) => {
+    const relativePath = path14.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();
@@ -3650,13 +4461,13 @@ async function loadModuleManifest(rootDir, moduleId, config) {
 }
 async function writeModuleManifest(rootDir, moduleId, manifest, config) {
   const manifestPath = getModuleManifestPath(rootDir, moduleId, config);
-  await fs6.mkdir(path11.dirname(manifestPath), { recursive: true });
+  await fs6.mkdir(path14.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 = path11.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
-  await fs6.mkdir(path11.dirname(indexFilePath), { recursive: true });
+  const indexFilePath = path14.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+  await fs6.mkdir(path14.dirname(indexFilePath), { recursive: true });
   await fs6.writeFile(indexFilePath, JSON.stringify(fileIndex, null, 2));
 }
 async function updateGlobalManifest(rootDir, modules, config) {
@@ -3666,31 +4477,32 @@ async function updateGlobalManifest(rootDir, modules, config) {
     lastUpdated: new Date().toISOString(),
     modules: modules.map((m) => m.id)
   };
-  await fs6.mkdir(path11.dirname(manifestPath), { recursive: true });
+  await fs6.mkdir(path14.dirname(manifestPath), { recursive: true });
   await fs6.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 }
 async function cleanupIndex(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
-  rootDir = path11.resolve(rootDir);
-  console.log(`Cleaning up index in: ${rootDir}`);
+  const logger = options.logger ?? createLogger({ verbose });
+  rootDir = path14.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,
@@ -3701,7 +4513,7 @@ async function cleanupModuleIndex(rootDir, moduleId, config, verbose) {
   const filesToRemove = [];
   const updatedFiles = {};
   for (const [filepath, entry] of Object.entries(manifest.files)) {
-    const fullPath = path11.join(rootDir, filepath);
+    const fullPath = path14.join(rootDir, filepath);
     try {
       await fs6.access(fullPath);
       updatedFiles[filepath] = entry;
@@ -3709,13 +4521,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 = path11.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+    const indexFilePath = path14.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
     try {
       await fs6.unlink(indexFilePath);
     } catch {}
@@ -3731,7 +4541,7 @@ async function cleanupEmptyDirectories(dir) {
     const entries = await fs6.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const subDir = path11.join(dir, entry.name);
+        const subDir = path14.join(dir, entry.name);
         await cleanupEmptyDirectories(subDir);
       }
     }
@@ -3746,7 +4556,7 @@ async function cleanupEmptyDirectories(dir) {
   }
 }
 async function getIndexStatus(rootDir) {
-  rootDir = path11.resolve(rootDir);
+  rootDir = path14.resolve(rootDir);
   const config = await loadConfig(rootDir);
   const location = getIndexLocation(rootDir);
   const indexDir = location.indexDir;
@@ -3782,7 +4592,7 @@ async function getIndexStatus(rootDir) {
     }
   } catch {
     try {
-      const entries = await fs6.readdir(path11.join(indexDir, "index"));
+      const entries = await fs6.readdir(path14.join(indexDir, "index"));
       if (entries.length > 0) {
         status.exists = true;
         for (const entry of entries) {
@@ -3805,7 +4615,7 @@ async function getIndexStatus(rootDir) {
 
 // src/app/search/index.ts
 import * as fs7 from "fs/promises";
-import * as path12 from "path";
+import * as path15 from "path";
 
 // src/types.ts
 init_entities();
@@ -3813,7 +4623,7 @@ init_entities();
 // src/app/search/index.ts
 init_config2();
 async function search(rootDir, query, options = {}) {
-  rootDir = path12.resolve(rootDir);
+  rootDir = path15.resolve(rootDir);
   const ensureFresh = options.ensureFresh ?? DEFAULT_SEARCH_OPTIONS.ensureFresh;
   if (ensureFresh) {
     await ensureIndexFresh(rootDir, { quiet: true });
@@ -3858,7 +4668,7 @@ function createSearchContext(rootDir, moduleId, config) {
     config,
     loadFileIndex: async (filepath) => {
       const hasExtension = /\.[^./]+$/.test(filepath);
-      const indexFilePath = hasExtension ? path12.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path12.join(indexPath, filepath + ".json");
+      const indexFilePath = hasExtension ? path15.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path15.join(indexPath, filepath + ".json");
       try {
         const content = await fs7.readFile(indexFilePath, "utf-8");
         return JSON.parse(content);
@@ -3870,7 +4680,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 relative3 = path12.relative(indexPath, f);
+        const relative3 = path15.relative(indexPath, f);
         return relative3.replace(/\.json$/, "");
       });
     }
@@ -3880,7 +4690,7 @@ async function traverseDirectory(dir, files, basePath) {
   try {
     const entries = await fs7.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path12.join(dir, entry.name);
+      const fullPath = path15.join(dir, entry.name);
       if (entry.isDirectory()) {
         await traverseDirectory(fullPath, files, basePath);
       } else if (entry.isFile()) {
@@ -3956,19 +4766,30 @@ async function search2(directory, query, options = {}) {
 async function cleanup(directory, options = {}) {
   return cleanupIndex(directory, options);
 }
+async function reset(directory) {
+  return resetIndex(directory);
+}
 var raggrep = {
   index,
   search: search2,
   cleanup,
+  reset,
   formatSearchResults
 };
 var src_default = raggrep;
 export {
   search2 as search,
+  reset,
   index,
   formatSearchResults,
   src_default as default,
-  cleanup
+  createSilentLogger,
+  createLogger,
+  createInlineLogger,
+  cleanup,
+  SilentLogger,
+  InlineProgressLogger,
+  ConsoleLogger
 };
 
-//# debugId=25853E0D892AD2D964756E2164756E21
+//# debugId=984F0AA3FD08D5A664756E2164756E21