raggrep 0.12.2 → 0.12.3

package/dist/index.js

@@ -127,7 +127,24 @@ var init_config = __esm(() => {
     ".pytest_cache",
     "*.egg-info",
     ".idea",
-    ".raggrep"
+    ".raggrep",
+    ".DS_Store",
+    "Thumbs.db",
+    ".env",
+    ".env.local",
+    ".env.development.local",
+    ".env.test.local",
+    ".env.production.local",
+    "*.lock",
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "Cargo.lock",
+    "poetry.lock",
+    "Gemfile.lock",
+    "go.sum",
+    "*.min.js",
+    "*.min.css"
   ];
   DEFAULT_EXTENSIONS = [
     ".ts",
@@ -11888,11 +11905,13 @@ class InlineProgressLogger {
     }
   }
   progress(message) {
-    process.stdout.write(`\r${message}`);
-    const padding = Math.max(0, this.lastProgressLength - message.length);
+    const maxCols = 120;
+    process.stdout.write("\r" + message);
+    const padding = Math.max(0, maxCols - message.length);
     if (padding > 0) {
       process.stdout.write(" ".repeat(padding));
     }
+    process.stdout.write("\r");
     this.lastProgressLength = message.length;
     this.hasProgress = true;
   }
@@ -11922,6 +11941,116 @@ function createInlineLogger(options) {
 function createSilentLogger() {
   return new SilentLogger;
 }
+// src/infrastructure/logger/progressManager.ts
+var PROGRESS_UPDATE_INTERVAL_MS = 50;
+
+class ProgressManager {
+  logger;
+  state = {
+    completed: 0,
+    total: 0,
+    message: "",
+    timestamp: 0
+  };
+  intervalId = null;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  start() {
+    if (this.intervalId) {
+      return;
+    }
+    this.intervalId = setInterval(() => {
+      this.writeProgress();
+    }, PROGRESS_UPDATE_INTERVAL_MS);
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.logger.clearProgress();
+  }
+  reportProgress(completed, total, message) {
+    this.state = {
+      completed,
+      total,
+      message,
+      timestamp: Date.now()
+    };
+  }
+  writeProgress() {
+    const progressMessage = `  [${this.state.completed}/${this.state.total}] ${this.state.message}`;
+    this.logger.progress(progressMessage);
+  }
+}
+// src/infrastructure/logger/multiModuleProgressManager.ts
+var PROGRESS_UPDATE_INTERVAL_MS2 = 50;
+
+class MultiModuleProgressManager {
+  logger;
+  modules = new Map;
+  intervalId = null;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  start() {
+    if (this.intervalId) {
+      return;
+    }
+    this.intervalId = setInterval(() => {
+      this.writeProgress();
+    }, PROGRESS_UPDATE_INTERVAL_MS2);
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.logger.clearProgress();
+  }
+  registerModule(moduleId, moduleName, totalFiles) {
+    this.modules.set(moduleId, {
+      moduleName,
+      completed: 0,
+      total: totalFiles,
+      currentFile: "",
+      active: true
+    });
+  }
+  unregisterModule(moduleId) {
+    const module2 = this.modules.get(moduleId);
+    if (module2) {
+      module2.active = false;
+    }
+  }
+  reportProgress(moduleId, completed, currentFile) {
+    const module2 = this.modules.get(moduleId);
+    if (!module2) {
+      return;
+    }
+    module2.completed = completed;
+    module2.currentFile = currentFile;
+  }
+  writeProgress() {
+    const activeModules = Array.from(this.modules.values()).filter((m) => m.active);
+    if (activeModules.length === 0) {
+      return;
+    }
+    if (activeModules.length === 1) {
+      const m = activeModules[0];
+      const progressMessage = `[${m.moduleName}] ${m.completed}/${m.total}: ${m.currentFile}`;
+      this.logger.progress(progressMessage);
+    } else {
+      const parts2 = activeModules.map((m) => {
+        const percent = m.total > 0 ? Math.round(m.completed / m.total * 100) : 100;
+        return `[${m.moduleName} ${m.completed}/${m.total} ${percent}%]`;
+      });
+      const progressMessage = parts2.join(" ");
+      this.logger.progress(progressMessage);
+    }
+  }
+}
 // src/app/indexer/watcher.ts
 import { watch } from "chokidar";
 init_config2();
@@ -12256,8 +12385,15 @@ async function ensureIndexFresh(rootDir, options = {}) {
     }
     let completedCount = 0;
     const totalToProcess = filesToProcess.length;
+    const progressManager = new ProgressManager(logger);
+    progressManager.start();
     const processChangedFile = async (fileToProcess) => {
       const { filepath, relativePath, lastModified, isNew, existingContentHash } = fileToProcess;
+      if (isLikelyBinary(filepath)) {
+        completedCount++;
+        logger.debug(`  Skipping ${relativePath} (binary file)`);
+        return { relativePath, status: "unchanged" };
+      }
       try {
         const content = await fs8.readFile(filepath, "utf-8");
         const contentHash = computeContentHash(content);
@@ -12271,7 +12407,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
           };
         }
         completedCount++;
-        logger.progress(`  [${completedCount}/${totalToProcess}] Indexing: ${relativePath}`);
+        progressManager.reportProgress(completedCount, totalToProcess, `Indexing: ${relativePath}`);
         introspection.addFile(relativePath, content);
         const fileIndex = await module2.indexFile(relativePath, content, ctx);
         if (!fileIndex) {
@@ -12294,6 +12430,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
     const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
     const results = await parallelMap(filesToProcess, processChangedFile, concurrency);
     indexingMs += Date.now() - indexingStart;
+    progressManager.stop();
     totalUnchanged += unchangedCount;
     logger.clearProgress();
     let mtimeUpdates = 0;
@@ -12428,9 +12565,16 @@ async function indexWithModule(rootDir, files, module2, config, verbose, introsp
     getIntrospection: (filepath) => introspection.getFile(filepath)
   };
   const totalFiles = files.length;
+  const progressManager = new ProgressManager(logger);
+  progressManager.start();
   let completedCount = 0;
   const processFile = async (filepath, _index) => {
     const relativePath = path21.relative(rootDir, filepath);
+    if (isLikelyBinary(filepath)) {
+      completedCount++;
+      logger.debug(`  [${completedCount}/${totalFiles}] Skipped ${relativePath} (binary file)`);
+      return { relativePath, status: "skipped" };
+    }
     try {
       const stats = await fs8.stat(filepath);
       const lastModified = stats.mtime.toISOString();
@@ -12454,7 +12598,7 @@ async function indexWithModule(rootDir, files, module2, config, verbose, introsp
       }
       introspection.addFile(relativePath, content);
       completedCount++;
-      logger.progress(`  [${completedCount}/${totalFiles}] Processing: ${relativePath}`);
+      progressManager.reportProgress(completedCount, totalFiles, `Processing: ${relativePath}`);
       const fileIndex = await module2.indexFile(relativePath, content, ctx);
       if (!fileIndex) {
         logger.debug(`  [${completedCount}/${totalFiles}] Skipped ${relativePath} (no chunks)`);
@@ -12475,6 +12619,7 @@ async function indexWithModule(rootDir, files, module2, config, verbose, introsp
   };
   logger.debug(`  Using concurrency: ${concurrency}`);
   const results = await parallelMap(files, processFile, concurrency);
+  progressManager.stop();
   logger.clearProgress();
   for (const item of results) {
     if (!item.success) {
@@ -12515,6 +12660,79 @@ async function indexWithModule(rootDir, files, module2, config, verbose, introsp
   return result;
 }
 var STAT_CONCURRENCY = 64;
+function isLikelyBinary(filepath) {
+  const ext = path21.extname(filepath).toLowerCase();
+  const basename15 = path21.basename(filepath).toLowerCase();
+  const binaryExtensions = new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".ico",
+    ".svg",
+    ".webp",
+    ".bmp",
+    ".tiff",
+    ".pdf",
+    ".doc",
+    ".docx",
+    ".xls",
+    ".xlsx",
+    ".ppt",
+    ".pptx",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".7z",
+    ".rar",
+    ".bz2",
+    ".exe",
+    ".dll",
+    ".so",
+    ".dylib",
+    ".bin",
+    ".dat",
+    ".obj",
+    ".o",
+    ".mp3",
+    ".mp4",
+    ".wav",
+    ".avi",
+    ".mov",
+    ".flac",
+    ".ogg",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot",
+    ".otf"
+  ]);
+  if (binaryExtensions.has(ext)) {
+    return true;
+  }
+  const minifiedPatterns = [
+    ".min.js",
+    ".min.css",
+    ".bundle.js",
+    ".bundle.css",
+    ".prod.js",
+    ".prod.css",
+    ".chunk.js",
+    ".chunk.css"
+  ];
+  if (minifiedPatterns.some((pattern) => filepath.includes(pattern))) {
+    return true;
+  }
+  const systemFiles = [
+    ".ds_store",
+    "thumbs.db",
+    "desktop.ini"
+  ];
+  if (systemFiles.includes(basename15)) {
+    return true;
+  }
+  return false;
+}
 async function findFilesWithStats(rootDir, config, lastIndexStarted) {
   const validExtensions = new Set(config.extensions);
   const ignoreDirs = new Set(config.ignorePaths);
@@ -14145,4 +14363,4 @@ export {
   ConsoleLogger
 };
 
-//# debugId=EA3CF8830C1070D164756E2164756E21
+//# debugId=DF4029DAF7548B8C64756E2164756E21