raggrep 0.2.3 → 0.4.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,8 +25,17 @@ 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 init_searchResult = () => {};
+var DEFAULT_SEARCH_OPTIONS;
+var init_searchResult = __esm(() => {
+  DEFAULT_SEARCH_OPTIONS = {
+    topK: 10,
+    minScore: 0.15,
+    filePatterns: [],
+    ensureFresh: true
+  };
+});
 
 // src/domain/entities/config.ts
 function createDefaultConfig() {
@@ -72,10 +97,17 @@ var init_config = __esm(() => {
     ".tsx",
     ".js",
     ".jsx",
+    ".mjs",
+    ".cjs",
     ".py",
     ".go",
     ".rs",
     ".java",
+    ".json",
+    ".yaml",
+    ".yml",
+    ".toml",
+    ".sql",
     ".md",
     ".txt"
   ];
@@ -1969,7 +2001,10 @@ var init_core = __esm(() => {
 });
 
 // src/infrastructure/embeddings/transformersEmbedding.ts
-import { pipeline, env } from "@xenova/transformers";
+import {
+  pipeline,
+  env
+} from "@xenova/transformers";
 import * as path6 from "path";
 import * as os2 from "os";
 
@@ -1981,7 +2016,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) {
@@ -2003,29 +2039,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;
@@ -2076,9 +2138,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;
@@ -2114,7 +2188,8 @@ var init_transformersEmbedding = __esm(() => {
   };
   globalConfig = {
     model: "all-MiniLM-L6-v2",
-    showProgress: false
+    showProgress: false,
+    logger: undefined
   };
 });
 
@@ -2686,6 +2761,57 @@ __export(exports_typescript, {
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE2
 });
 import * as path8 from "path";
+function detectQueryIntent(queryTerms) {
+  const hasImplementationTerm = queryTerms.some((term) => IMPLEMENTATION_TERMS.includes(term));
+  const hasDocumentationTerm = queryTerms.some((term) => DOCUMENTATION_TERMS.includes(term));
+  if (hasDocumentationTerm) {
+    return "documentation";
+  }
+  if (hasImplementationTerm) {
+    return "implementation";
+  }
+  return "neutral";
+}
+function calculateFileTypeBoost(filepath, queryTerms) {
+  const ext = path8.extname(filepath).toLowerCase();
+  const isSourceCode = SOURCE_CODE_EXTENSIONS.includes(ext);
+  const isDoc = DOC_EXTENSIONS.includes(ext);
+  const intent = detectQueryIntent(queryTerms);
+  if (intent === "implementation") {
+    if (isSourceCode) {
+      return 0.06;
+    }
+    return 0;
+  }
+  if (intent === "documentation") {
+    if (isDoc) {
+      return 0.08;
+    }
+    return 0;
+  }
+  return 0;
+}
+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";
@@ -2696,8 +2822,16 @@ class TypeScriptModule {
   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();
   }
@@ -2855,7 +2989,11 @@ class TypeScriptModule {
       const semanticScore = cosineSimilarity(queryEmbedding, embedding);
       const bm25Score = bm25Scores.get(chunk.id) || 0;
       const pathBoost = pathBoosts.get(filepath) || 0;
-      const hybridScore = SEMANTIC_WEIGHT * semanticScore + BM25_WEIGHT * bm25Score + pathBoost;
+      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,
@@ -2865,7 +3003,10 @@ class TypeScriptModule {
           context: {
             semanticScore,
             bm25Score,
-            pathBoost
+            pathBoost,
+            fileTypeBoost,
+            chunkTypeBoost,
+            exportBoost
           }
         });
       }
@@ -2897,7 +3038,7 @@ class TypeScriptModule {
     return references;
   }
 }
-var DEFAULT_MIN_SCORE2 = 0.15, DEFAULT_TOP_K2 = 10, SEMANTIC_WEIGHT = 0.7, BM25_WEIGHT = 0.3;
+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(() => {
   init_embeddings();
   init_config2();
@@ -2905,6 +3046,52 @@ var init_typescript = __esm(() => {
   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"];
 });
 
 // src/app/indexer/index.ts
@@ -3193,6 +3380,92 @@ 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();
@@ -3202,42 +3475,31 @@ var INDEX_SCHEMA_VERSION = "1.0.0";
 async function indexDirectory(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
   const quiet = options.quiet ?? false;
+  const logger = options.logger ? options.logger : quiet ? createSilentLogger() : createLogger({ verbose });
   rootDir = path11.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}`);
   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 };
@@ -3247,14 +3509,16 @@ 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);
     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,
@@ -3270,15 +3534,182 @@ async function indexDirectory(rootDir, options = {}) {
       };
       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);
   return results;
 }
-async function indexWithModule(rootDir, files, module, config, verbose, introspection) {
+async function isIndexVersionCompatible(rootDir) {
+  const config = await loadConfig(rootDir);
+  const globalManifestPath = getGlobalManifestPath(rootDir, config);
+  try {
+    const content = await fs6.readFile(globalManifestPath, "utf-8");
+    const manifest = JSON.parse(content);
+    return manifest.version === INDEX_SCHEMA_VERSION;
+  } catch {
+    return false;
+  }
+}
+async function deleteIndex(rootDir) {
+  const indexDir = getRaggrepDir(rootDir);
+  try {
+    await fs6.rm(indexDir, { recursive: true, force: true });
+  } catch {}
+}
+async function resetIndex(rootDir) {
+  rootDir = path11.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;
+  const logger = options.logger ? options.logger : quiet ? createSilentLogger() : createLogger({ verbose });
+  rootDir = path11.resolve(rootDir);
+  const status = await getIndexStatus(rootDir);
+  if (!status.exists) {
+    logger.info(`No index found. Creating index...
+`);
+    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) {
+    logger.info(`Index version incompatible. Rebuilding...
+`);
+    await deleteIndex(rootDir);
+    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 config = await loadConfig(rootDir);
+  await registerBuiltInModules();
+  const enabledModules = registry.getEnabled(config);
+  if (enabledModules.length === 0) {
+    return { indexed: 0, removed: 0, unchanged: 0 };
+  }
+  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)));
+  let totalIndexed = 0;
+  let totalRemoved = 0;
+  let totalUnchanged = 0;
+  for (const module of enabledModules) {
+    const moduleConfig = getModuleConfig(config, module.id);
+    if (module.initialize && moduleConfig) {
+      const configWithOverrides = { ...moduleConfig };
+      if (options.model && module.id === "language/typescript") {
+        configWithOverrides.options = {
+          ...configWithOverrides.options,
+          embeddingModel: options.model
+        };
+      }
+      configWithOverrides.options = {
+        ...configWithOverrides.options,
+        logger
+      };
+      await module.initialize(configWithOverrides);
+    }
+    const manifest = await loadModuleManifest(rootDir, module.id, config);
+    const indexPath = getModuleIndexPath(rootDir, module.id, config);
+    const filesToRemove = [];
+    for (const filepath of Object.keys(manifest.files)) {
+      if (!currentFileSet.has(filepath)) {
+        filesToRemove.push(filepath);
+      }
+    }
+    for (const filepath of filesToRemove) {
+      logger.debug(`  Removing stale: ${filepath}`);
+      const indexFilePath = path11.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+      try {
+        await fs6.unlink(indexFilePath);
+      } catch {}
+      const symbolicFilePath = path11.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
+      try {
+        await fs6.unlink(symbolicFilePath);
+      } catch {}
+      delete manifest.files[filepath];
+      totalRemoved++;
+    }
+    const ctx = {
+      rootDir,
+      config,
+      readFile: async (filepath) => {
+        const fullPath = path11.isAbsolute(filepath) ? filepath : path11.join(rootDir, filepath);
+        return fs6.readFile(fullPath, "utf-8");
+      },
+      getFileStats: async (filepath) => {
+        const fullPath = path11.isAbsolute(filepath) ? filepath : path11.join(rootDir, filepath);
+        const stats = await fs6.stat(fullPath);
+        return { lastModified: stats.mtime.toISOString() };
+      },
+      getIntrospection: (filepath) => introspection.getFile(filepath)
+    };
+    const totalFiles = currentFiles.length;
+    for (let i = 0;i < currentFiles.length; i++) {
+      const filepath = currentFiles[i];
+      const relativePath = path11.relative(rootDir, filepath);
+      const progress = `[${i + 1}/${totalFiles}]`;
+      try {
+        const stats = await fs6.stat(filepath);
+        const lastModified = stats.mtime.toISOString();
+        const existingEntry = manifest.files[relativePath];
+        if (existingEntry && existingEntry.lastModified === lastModified) {
+          totalUnchanged++;
+          continue;
+        }
+        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);
+        if (fileIndex) {
+          await writeFileIndex(rootDir, module.id, relativePath, fileIndex, config);
+          manifest.files[relativePath] = {
+            lastModified,
+            chunkCount: fileIndex.chunks.length
+          };
+          totalIndexed++;
+        }
+      } catch (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);
+      if (module.finalize) {
+        await module.finalize(ctx);
+      }
+    }
+    if (totalRemoved > 0) {
+      await cleanupEmptyDirectories(indexPath);
+    }
+  }
+  if (totalIndexed > 0) {
+    await introspection.save(config);
+  }
+  if (totalIndexed > 0 || totalRemoved > 0) {
+    await updateGlobalManifest(rootDir, enabledModules, config);
+  }
+  return {
+    indexed: totalIndexed,
+    removed: totalRemoved,
+    unchanged: totalUnchanged
+  };
+}
+async function indexWithModule(rootDir, files, module, config, verbose, introspection, logger) {
   const result = {
     moduleId: module.id,
     indexed: 0,
@@ -3286,6 +3717,30 @@ 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) => path11.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 = path11.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+      try {
+        await fs6.unlink(indexFilePath);
+      } catch {}
+      const symbolicFilePath = path11.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
+      try {
+        await fs6.unlink(symbolicFilePath);
+      } catch {}
+      delete manifest.files[filepath];
+    }
+    await cleanupEmptyDirectories(indexPath);
+  }
   const ctx = {
     rootDir,
     config,
@@ -3300,29 +3755,26 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
     },
     getIntrospection: (filepath) => introspection.getFile(filepath)
   };
-  for (const filepath of files) {
+  const totalFiles = files.length;
+  for (let i = 0;i < files.length; i++) {
+    const filepath = files[i];
     const relativePath = path11.relative(rootDir, filepath);
+    const progress = `[${i + 1}/${totalFiles}]`;
     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)`);
-        }
+        logger.debug(`  ${progress} Skipped ${relativePath} (unchanged)`);
         result.skipped++;
         continue;
       }
       const content = await fs6.readFile(filepath, "utf-8");
       introspection.addFile(relativePath, content);
-      if (verbose) {
-        console.log(`  Processing ${relativePath}...`);
-      }
+      logger.progress(`  ${progress} Processing: ${relativePath}`);
       const fileIndex = await module.indexFile(relativePath, content, ctx);
       if (!fileIndex) {
-        if (verbose) {
-          console.log(`  Skipped ${relativePath} (no chunks)`);
-        }
+        logger.debug(`  ${progress} Skipped ${relativePath} (no chunks)`);
         result.skipped++;
         continue;
       }
@@ -3333,10 +3785,12 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
       };
       result.indexed++;
     } catch (error) {
-      console.error(`  Error indexing ${relativePath}:`, error);
+      logger.clearProgress();
+      logger.error(`  ${progress} Error indexing ${relativePath}: ${error}`);
       result.errors++;
     }
   }
+  logger.clearProgress();
   manifest.lastUpdated = new Date().toISOString();
   await writeModuleManifest(rootDir, module.id, manifest, config);
   return result;
@@ -3392,26 +3846,27 @@ async function updateGlobalManifest(rootDir, modules, config) {
 }
 async function cleanupIndex(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
+  const logger = options.logger ?? createLogger({ verbose });
   rootDir = path11.resolve(rootDir);
-  console.log(`Cleaning up index in: ${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,
@@ -3430,9 +3885,7 @@ 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) {
@@ -3466,19 +3919,85 @@ async function cleanupEmptyDirectories(dir) {
     return false;
   }
 }
+async function getIndexStatus(rootDir) {
+  rootDir = path11.resolve(rootDir);
+  const config = await loadConfig(rootDir);
+  const location = getIndexLocation(rootDir);
+  const indexDir = location.indexDir;
+  const status = {
+    exists: false,
+    rootDir,
+    indexDir,
+    modules: [],
+    totalFiles: 0
+  };
+  try {
+    await fs6.access(indexDir);
+  } catch {
+    return status;
+  }
+  try {
+    const globalManifestPath = getGlobalManifestPath(rootDir, config);
+    const content = await fs6.readFile(globalManifestPath, "utf-8");
+    const globalManifest = JSON.parse(content);
+    status.exists = true;
+    status.lastUpdated = globalManifest.lastUpdated;
+    for (const moduleId of globalManifest.modules) {
+      try {
+        const manifest = await loadModuleManifest(rootDir, moduleId, config);
+        const fileCount = Object.keys(manifest.files).length;
+        status.modules.push({
+          id: moduleId,
+          fileCount,
+          lastUpdated: manifest.lastUpdated
+        });
+        status.totalFiles += fileCount;
+      } catch {}
+    }
+  } catch {
+    try {
+      const entries = await fs6.readdir(path11.join(indexDir, "index"));
+      if (entries.length > 0) {
+        status.exists = true;
+        for (const entry of entries) {
+          try {
+            const manifest = await loadModuleManifest(rootDir, entry, config);
+            const fileCount = Object.keys(manifest.files).length;
+            status.modules.push({
+              id: entry,
+              fileCount,
+              lastUpdated: manifest.lastUpdated
+            });
+            status.totalFiles += fileCount;
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+  return status;
+}
 
 // src/app/search/index.ts
-init_config2();
 import * as fs7 from "fs/promises";
 import * as path12 from "path";
+
+// src/types.ts
+init_entities();
+
+// src/app/search/index.ts
+init_config2();
 async function search(rootDir, query, options = {}) {
   rootDir = path12.resolve(rootDir);
+  const ensureFresh = options.ensureFresh ?? DEFAULT_SEARCH_OPTIONS.ensureFresh;
+  if (ensureFresh) {
+    await ensureIndexFresh(rootDir, { quiet: true });
+  }
   console.log(`Searching for: "${query}"`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
   const globalManifest = await loadGlobalManifest(rootDir, config);
   if (!globalManifest || globalManifest.modules.length === 0) {
-    console.log('No index found. Run "bun run index" first.');
+    console.log('No index found. Run "raggrep index" first.');
     return [];
   }
   const modulesToSearch = [];
@@ -3611,19 +4130,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=22D9AEEC336F77A764756E2164756E21
+//# debugId=3E17C296D218EF4F64756E2164756E21