raggrep 0.10.2 → 0.10.5

package/dist/cli/main.js

@@ -327,6 +327,511 @@ function createSilentLogger() {
 
 // src/infrastructure/logger/index.ts
 var init_logger = () => {};
+
+// node_modules/fdir/dist/index.mjs
+import { createRequire as createRequire2 } from "module";
+import { basename, dirname, normalize, relative, resolve, sep } from "path";
+import * as nativeFs from "fs";
+function cleanPath(path2) {
+  let normalized = normalize(path2);
+  if (normalized.length > 1 && normalized[normalized.length - 1] === sep)
+    normalized = normalized.substring(0, normalized.length - 1);
+  return normalized;
+}
+function convertSlashes(path2, separator) {
+  return path2.replace(SLASHES_REGEX, separator);
+}
+function isRootDirectory(path2) {
+  return path2 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path2);
+}
+function normalizePath(path2, options) {
+  const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
+  const pathNeedsCleaning = process.platform === "win32" && path2.includes("/") || path2.startsWith(".");
+  if (resolvePaths)
+    path2 = resolve(path2);
+  if (normalizePath$1 || pathNeedsCleaning)
+    path2 = cleanPath(path2);
+  if (path2 === ".")
+    return "";
+  const needsSeperator = path2[path2.length - 1] !== pathSeparator;
+  return convertSlashes(needsSeperator ? path2 + pathSeparator : path2, pathSeparator);
+}
+function joinPathWithBasePath(filename, directoryPath) {
+  return directoryPath + filename;
+}
+function joinPathWithRelativePath(root, options) {
+  return function(filename, directoryPath) {
+    const sameRoot = directoryPath.startsWith(root);
+    if (sameRoot)
+      return directoryPath.slice(root.length) + filename;
+    else
+      return convertSlashes(relative(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
+  };
+}
+function joinPath(filename) {
+  return filename;
+}
+function joinDirectoryPath(filename, directoryPath, separator) {
+  return directoryPath + filename + separator;
+}
+function build$7(root, options) {
+  const { relativePaths, includeBasePath } = options;
+  return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
+}
+function pushDirectoryWithRelativePath(root) {
+  return function(directoryPath, paths) {
+    paths.push(directoryPath.substring(root.length) || ".");
+  };
+}
+function pushDirectoryFilterWithRelativePath(root) {
+  return function(directoryPath, paths, filters) {
+    const relativePath = directoryPath.substring(root.length) || ".";
+    if (filters.every((filter) => filter(relativePath, true)))
+      paths.push(relativePath);
+  };
+}
+function build$6(root, options) {
+  const { includeDirs, filters, relativePaths } = options;
+  if (!includeDirs)
+    return empty$2;
+  if (relativePaths)
+    return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
+  return filters && filters.length ? pushDirectoryFilter : pushDirectory;
+}
+function build$5(options) {
+  const { excludeFiles, filters, onlyCounts } = options;
+  if (excludeFiles)
+    return empty$1;
+  if (filters && filters.length)
+    return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
+  else if (onlyCounts)
+    return pushFileCount;
+  else
+    return pushFile;
+}
+function build$4(options) {
+  return options.group ? getArrayGroup : getArray;
+}
+function build$3(options) {
+  return options.group ? groupFiles : empty;
+}
+function build$2(options, isSynchronous) {
+  if (!options.resolveSymlinks || options.excludeSymlinks)
+    return null;
+  return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+}
+function isRecursive(path2, resolved, state) {
+  if (state.options.useRealPaths)
+    return isRecursiveUsingRealPaths(resolved, state);
+  let parent = dirname(path2);
+  let depth = 1;
+  while (parent !== state.root && depth < 2) {
+    const resolvedPath = state.symlinks.get(parent);
+    const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
+    if (isSameRoot)
+      depth++;
+    else
+      parent = dirname(parent);
+  }
+  state.symlinks.set(path2, resolved);
+  return depth > 1;
+}
+function isRecursiveUsingRealPaths(resolved, state) {
+  return state.visited.includes(resolved + state.options.pathSeparator);
+}
+function report(error, callback$1, output, suppressErrors) {
+  if (error && !suppressErrors)
+    callback$1(error, output);
+  else
+    callback$1(null, output);
+}
+function build$1(options, isSynchronous) {
+  const { onlyCounts, group, maxFiles } = options;
+  if (onlyCounts)
+    return isSynchronous ? onlyCountsSync : onlyCountsAsync;
+  else if (group)
+    return isSynchronous ? groupsSync : groupsAsync;
+  else if (maxFiles)
+    return isSynchronous ? limitFilesSync : limitFilesAsync;
+  else
+    return isSynchronous ? defaultSync : defaultAsync;
+}
+function build(isSynchronous) {
+  return isSynchronous ? walkSync : walkAsync;
+}
+function promise(root, options) {
+  return new Promise((resolve$1, reject) => {
+    callback(root, options, (err2, output) => {
+      if (err2)
+        return reject(err2);
+      resolve$1(output);
+    });
+  });
+}
+function callback(root, options, callback$1) {
+  let walker = new Walker(root, options, callback$1);
+  walker.start();
+}
+function sync(root, options) {
+  const walker = new Walker(root, options);
+  return walker.start();
+}
+var __require2, SLASHES_REGEX, WINDOWS_ROOT_DIR_REGEX, pushDirectory = (directoryPath, paths) => {
+  paths.push(directoryPath || ".");
+}, pushDirectoryFilter = (directoryPath, paths, filters) => {
+  const path2 = directoryPath || ".";
+  if (filters.every((filter) => filter(path2, true)))
+    paths.push(path2);
+}, empty$2 = () => {}, pushFileFilterAndCount = (filename, _paths, counts, filters) => {
+  if (filters.every((filter) => filter(filename, false)))
+    counts.files++;
+}, pushFileFilter = (filename, paths, _counts, filters) => {
+  if (filters.every((filter) => filter(filename, false)))
+    paths.push(filename);
+}, pushFileCount = (_filename, _paths, counts, _filters) => {
+  counts.files++;
+}, pushFile = (filename, paths) => {
+  paths.push(filename);
+}, empty$1 = () => {}, getArray = (paths) => {
+  return paths;
+}, getArrayGroup = () => {
+  return [""].slice(0, 0);
+}, groupFiles = (groups, directory, files) => {
+  groups.push({
+    directory,
+    files,
+    dir: directory
+  });
+}, empty = () => {}, resolveSymlinksAsync = function(path2, state, callback$1) {
+  const { queue, fs: fs2, options: { suppressErrors } } = state;
+  queue.enqueue();
+  fs2.realpath(path2, (error, resolvedPath) => {
+    if (error)
+      return queue.dequeue(suppressErrors ? null : error, state);
+    fs2.stat(resolvedPath, (error$1, stat) => {
+      if (error$1)
+        return queue.dequeue(suppressErrors ? null : error$1, state);
+      if (stat.isDirectory() && isRecursive(path2, resolvedPath, state))
+        return queue.dequeue(null, state);
+      callback$1(stat, resolvedPath);
+      queue.dequeue(null, state);
+    });
+  });
+}, resolveSymlinks = function(path2, state, callback$1) {
+  const { queue, fs: fs2, options: { suppressErrors } } = state;
+  queue.enqueue();
+  try {
+    const resolvedPath = fs2.realpathSync(path2);
+    const stat = fs2.statSync(resolvedPath);
+    if (stat.isDirectory() && isRecursive(path2, resolvedPath, state))
+      return;
+    callback$1(stat, resolvedPath);
+  } catch (e) {
+    if (!suppressErrors)
+      throw e;
+  }
+}, onlyCountsSync = (state) => {
+  return state.counts;
+}, groupsSync = (state) => {
+  return state.groups;
+}, defaultSync = (state) => {
+  return state.paths;
+}, limitFilesSync = (state) => {
+  return state.paths.slice(0, state.options.maxFiles);
+}, onlyCountsAsync = (state, error, callback$1) => {
+  report(error, callback$1, state.counts, state.options.suppressErrors);
+  return null;
+}, defaultAsync = (state, error, callback$1) => {
+  report(error, callback$1, state.paths, state.options.suppressErrors);
+  return null;
+}, limitFilesAsync = (state, error, callback$1) => {
+  report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
+  return null;
+}, groupsAsync = (state, error, callback$1) => {
+  report(error, callback$1, state.groups, state.options.suppressErrors);
+  return null;
+}, readdirOpts, walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+  state.queue.enqueue();
+  if (currentDepth < 0)
+    return state.queue.dequeue(null, state);
+  const { fs: fs2 } = state;
+  state.visited.push(crawlPath);
+  state.counts.directories++;
+  fs2.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
+    callback$1(entries, directoryPath, currentDepth);
+    state.queue.dequeue(state.options.suppressErrors ? null : error, state);
+  });
+}, walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+  const { fs: fs2 } = state;
+  if (currentDepth < 0)
+    return;
+  state.visited.push(crawlPath);
+  state.counts.directories++;
+  let entries = [];
+  try {
+    entries = fs2.readdirSync(crawlPath || ".", readdirOpts);
+  } catch (e) {
+    if (!state.options.suppressErrors)
+      throw e;
+  }
+  callback$1(entries, directoryPath, currentDepth);
+}, Queue = class {
+  count = 0;
+  constructor(onQueueEmpty) {
+    this.onQueueEmpty = onQueueEmpty;
+  }
+  enqueue() {
+    this.count++;
+    return this.count;
+  }
+  dequeue(error, output) {
+    if (this.onQueueEmpty && (--this.count <= 0 || error)) {
+      this.onQueueEmpty(error, output);
+      if (error) {
+        output.controller.abort();
+        this.onQueueEmpty = undefined;
+      }
+    }
+  }
+}, Counter = class {
+  _files = 0;
+  _directories = 0;
+  set files(num) {
+    this._files = num;
+  }
+  get files() {
+    return this._files;
+  }
+  set directories(num) {
+    this._directories = num;
+  }
+  get directories() {
+    return this._directories;
+  }
+  get dirs() {
+    return this._directories;
+  }
+}, Aborter = class {
+  aborted = false;
+  abort() {
+    this.aborted = true;
+  }
+}, Walker = class {
+  root;
+  isSynchronous;
+  state;
+  joinPath;
+  pushDirectory;
+  pushFile;
+  getArray;
+  groupFiles;
+  resolveSymlink;
+  walkDirectory;
+  callbackInvoker;
+  constructor(root, options, callback$1) {
+    this.isSynchronous = !callback$1;
+    this.callbackInvoker = build$1(options, this.isSynchronous);
+    this.root = normalizePath(root, options);
+    this.state = {
+      root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1),
+      paths: [""].slice(0, 0),
+      groups: [],
+      counts: new Counter,
+      options,
+      queue: new Queue((error, state) => this.callbackInvoker(state, error, callback$1)),
+      symlinks: /* @__PURE__ */ new Map,
+      visited: [""].slice(0, 0),
+      controller: new Aborter,
+      fs: options.fs || nativeFs
+    };
+    this.joinPath = build$7(this.root, options);
+    this.pushDirectory = build$6(this.root, options);
+    this.pushFile = build$5(options);
+    this.getArray = build$4(options);
+    this.groupFiles = build$3(options);
+    this.resolveSymlink = build$2(options, this.isSynchronous);
+    this.walkDirectory = build(this.isSynchronous);
+  }
+  start() {
+    this.pushDirectory(this.root, this.state.paths, this.state.options.filters);
+    this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
+    return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
+  }
+  walk = (entries, directoryPath, depth) => {
+    const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;
+    if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles)
+      return;
+    const files = this.getArray(this.state.paths);
+    for (let i2 = 0;i2 < entries.length; ++i2) {
+      const entry = entries[i2];
+      if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {
+        const filename = this.joinPath(entry.name, directoryPath);
+        this.pushFile(filename, files, this.state.counts, filters);
+      } else if (entry.isDirectory()) {
+        let path2 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+        if (exclude && exclude(entry.name, path2))
+          continue;
+        this.pushDirectory(path2, paths, filters);
+        this.walkDirectory(this.state, path2, path2, depth - 1, this.walk);
+      } else if (this.resolveSymlink && entry.isSymbolicLink()) {
+        let path2 = joinPathWithBasePath(entry.name, directoryPath);
+        this.resolveSymlink(path2, this.state, (stat, resolvedPath) => {
+          if (stat.isDirectory()) {
+            resolvedPath = normalizePath(resolvedPath, this.state.options);
+            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path2 + pathSeparator))
+              return;
+            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path2 + pathSeparator, depth - 1, this.walk);
+          } else {
+            resolvedPath = useRealPaths ? resolvedPath : path2;
+            const filename = basename(resolvedPath);
+            const directoryPath$1 = normalizePath(dirname(resolvedPath), this.state.options);
+            resolvedPath = this.joinPath(filename, directoryPath$1);
+            this.pushFile(resolvedPath, files, this.state.counts, filters);
+          }
+        });
+      }
+    }
+    this.groupFiles(this.state.groups, directoryPath, files);
+  };
+}, APIBuilder = class {
+  constructor(root, options) {
+    this.root = root;
+    this.options = options;
+  }
+  withPromise() {
+    return promise(this.root, this.options);
+  }
+  withCallback(cb) {
+    callback(this.root, this.options, cb);
+  }
+  sync() {
+    return sync(this.root, this.options);
+  }
+}, pm = null, Builder = class {
+  globCache = {};
+  options = {
+    maxDepth: Infinity,
+    suppressErrors: true,
+    pathSeparator: sep,
+    filters: []
+  };
+  globFunction;
+  constructor(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+    this.globFunction = this.options.globFunction;
+  }
+  group() {
+    this.options.group = true;
+    return this;
+  }
+  withPathSeparator(separator) {
+    this.options.pathSeparator = separator;
+    return this;
+  }
+  withBasePath() {
+    this.options.includeBasePath = true;
+    return this;
+  }
+  withRelativePaths() {
+    this.options.relativePaths = true;
+    return this;
+  }
+  withDirs() {
+    this.options.includeDirs = true;
+    return this;
+  }
+  withMaxDepth(depth) {
+    this.options.maxDepth = depth;
+    return this;
+  }
+  withMaxFiles(limit) {
+    this.options.maxFiles = limit;
+    return this;
+  }
+  withFullPaths() {
+    this.options.resolvePaths = true;
+    this.options.includeBasePath = true;
+    return this;
+  }
+  withErrors() {
+    this.options.suppressErrors = false;
+    return this;
+  }
+  withSymlinks({ resolvePaths = true } = {}) {
+    this.options.resolveSymlinks = true;
+    this.options.useRealPaths = resolvePaths;
+    return this.withFullPaths();
+  }
+  withAbortSignal(signal) {
+    this.options.signal = signal;
+    return this;
+  }
+  normalize() {
+    this.options.normalizePath = true;
+    return this;
+  }
+  filter(predicate) {
+    this.options.filters.push(predicate);
+    return this;
+  }
+  onlyDirs() {
+    this.options.excludeFiles = true;
+    this.options.includeDirs = true;
+    return this;
+  }
+  exclude(predicate) {
+    this.options.exclude = predicate;
+    return this;
+  }
+  onlyCounts() {
+    this.options.onlyCounts = true;
+    return this;
+  }
+  crawl(root) {
+    return new APIBuilder(root || ".", this.options);
+  }
+  withGlobFunction(fn) {
+    this.globFunction = fn;
+    return this;
+  }
+  crawlWithOptions(root, options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+    return new APIBuilder(root || ".", this.options);
+  }
+  glob(...patterns) {
+    if (this.globFunction)
+      return this.globWithOptions(patterns);
+    return this.globWithOptions(patterns, ...[{ dot: true }]);
+  }
+  globWithOptions(patterns, ...options) {
+    const globFn = this.globFunction || pm;
+    if (!globFn)
+      throw new Error("Please specify a glob function to use glob matching.");
+    var isMatch = this.globCache[patterns.join("\x00")];
+    if (!isMatch) {
+      isMatch = globFn(patterns, ...options);
+      this.globCache[patterns.join("\x00")] = isMatch;
+    }
+    this.options.filters.push((path2) => isMatch(path2));
+    return this;
+  }
+};
+var init_dist = __esm(() => {
+  __require2 = /* @__PURE__ */ createRequire2(import.meta.url);
+  SLASHES_REGEX = /[\\/]/g;
+  WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
+  readdirOpts = { withFileTypes: true };
+  try {
+    __require2.resolve("picomatch");
+    pm = __require2("picomatch");
+  } catch {}
+});
 // src/domain/entities/searchResult.ts
 var DEFAULT_SEARCH_OPTIONS;
 var init_searchResult = __esm(() => {
@@ -5200,8 +5705,8 @@ async function Module2(moduleArg = {}) {
   var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != "undefined";
   var ENVIRONMENT_IS_NODE = typeof process == "object" && process.versions?.node && process.type != "renderer";
   if (ENVIRONMENT_IS_NODE) {
-    const { createRequire: createRequire2 } = await import("module");
-    var require = createRequire2(import.meta.url);
+    const { createRequire: createRequire3 } = await import("module");
+    var require = createRequire3(import.meta.url);
   }
   Module.currentQueryProgressCallback = null;
   Module.currentProgressCallback = null;
@@ -5261,13 +5766,13 @@ async function Module2(moduleArg = {}) {
       }
       readAsync = /* @__PURE__ */ __name(async (url) => {
         if (isFileURI(url)) {
-          return new Promise((resolve2, reject) => {
+          return new Promise((resolve3, reject) => {
             var xhr = new XMLHttpRequest;
             xhr.open("GET", url, true);
             xhr.responseType = "arraybuffer";
             xhr.onload = () => {
               if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                resolve2(xhr.response);
+                resolve3(xhr.response);
                 return;
               }
               reject(xhr.status);
@@ -5457,9 +5962,9 @@ async function Module2(moduleArg = {}) {
     __name(receiveInstantiationResult, "receiveInstantiationResult");
     var info2 = getWasmImports();
     if (Module["instantiateWasm"]) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve3, reject) => {
         Module["instantiateWasm"](info2, (mod, inst) => {
-          resolve2(receiveInstance(mod, inst));
+          resolve3(receiveInstance(mod, inst));
         });
       });
     }
@@ -6172,9 +6677,9 @@ async function Module2(moduleArg = {}) {
     Module["monitorRunDependencies"]?.(runDependencies);
     if (runDependencies == 0) {
       if (dependenciesFulfilled) {
-        var callback = dependenciesFulfilled;
+        var callback2 = dependenciesFulfilled;
         dependenciesFulfilled = null;
-        callback();
+        callback2();
       }
     }
   }, "removeRunDependency");
@@ -6746,8 +7251,8 @@ async function Module2(moduleArg = {}) {
   if (runtimeInitialized) {
     moduleRtn = Module;
   } else {
-    moduleRtn = new Promise((resolve2, reject) => {
-      readyPromiseResolve = resolve2;
+    moduleRtn = new Promise((resolve3, reject) => {
+      readyPromiseResolve = resolve3;
       readyPromiseReject = reject;
     });
   }
@@ -7863,11 +8368,11 @@ ${JSON.stringify(symbolNames, null, 2)}`);
       C._ts_parser_set_language(this[0], address);
       return this;
     }
-    parse(callback, oldTree, options) {
-      if (typeof callback === "string") {
-        C.currentParseCallback = (index) => callback.slice(index);
-      } else if (typeof callback === "function") {
-        C.currentParseCallback = callback;
+    parse(callback2, oldTree, options) {
+      if (typeof callback2 === "string") {
+        C.currentParseCallback = (index) => callback2.slice(index);
+      } else if (typeof callback2 === "function") {
+        C.currentParseCallback = callback2;
       } else {
         throw new Error("Argument must be a string or a function");
       }
@@ -7928,13 +8433,13 @@ ${JSON.stringify(symbolNames, null, 2)}`);
       }
       return result;
     }
-    setLogger(callback) {
-      if (!callback) {
+    setLogger(callback2) {
+      if (!callback2) {
         this.logCallback = null;
-      } else if (typeof callback !== "function") {
+      } else if (typeof callback2 !== "function") {
         throw new Error("Logger callback must be a function");
       } else {
-        this.logCallback = callback;
+        this.logCallback = callback2;
       }
       return this;
     }
@@ -11344,9 +11849,9 @@ async function watchDirectory(rootDir, options = {}) {
       onError(err2);
     }
   });
-  await new Promise((resolve3) => {
+  await new Promise((resolve4) => {
     watcher.on("ready", () => {
-      resolve3();
+      resolve4();
     });
   });
   return {
@@ -11381,7 +11886,6 @@ __export(exports_indexer, {
   clearFreshnessCache: () => clearFreshnessCache,
   cleanupIndex: () => cleanupIndex
 });
-import { glob } from "glob";
 import * as fs8 from "fs/promises";
 import * as path22 from "path";
 import * as os3 from "os";
@@ -11545,6 +12049,15 @@ async function resetIndex(rootDir) {
 async function ensureIndexFresh(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
   const quiet = options.quiet ?? false;
+  const showTiming = options.timing ?? false;
+  const startTime = Date.now();
+  let fileDiscoveryMs = 0;
+  let statCheckMs = 0;
+  let indexingMs = 0;
+  let cleanupMs = 0;
+  let filesDiscovered = 0;
+  let filesStatChecked = 0;
+  let filesIndexed = 0;
   const logger = options.logger ? options.logger : quiet ? createSilentLogger() : createLogger({ verbose });
   rootDir = path22.resolve(rootDir);
   const status = await getIndexStatus(rootDir);
@@ -11576,16 +12089,35 @@ async function ensureIndexFresh(rootDir, options = {}) {
   const now = Date.now();
   if (freshnessCache && freshnessCache.rootDir === rootDir && now - freshnessCache.timestamp < FRESHNESS_CACHE_TTL_MS && freshnessCache.manifestMtime === currentManifestMtime) {
     logger.debug("Using cached freshness check result");
-    return freshnessCache.result;
+    const cachedResult = { ...freshnessCache.result };
+    if (showTiming) {
+      cachedResult.timing = {
+        totalMs: Date.now() - startTime,
+        fileDiscoveryMs: 0,
+        statCheckMs: 0,
+        indexingMs: 0,
+        cleanupMs: 0,
+        filesDiscovered: 0,
+        filesStatChecked: 0,
+        filesIndexed: 0,
+        fromCache: true
+      };
+    }
+    return cachedResult;
   }
   await registerBuiltInModules();
   const enabledModules = registry.getEnabled(config);
   if (enabledModules.length === 0) {
     return { indexed: 0, removed: 0, unchanged: 0 };
   }
+  const fileDiscoveryStart = Date.now();
   const introspection = new IntrospectionIndex(rootDir);
-  await introspection.initialize();
-  const currentFiles = await findFiles(rootDir, config);
+  const [, currentFiles] = await Promise.all([
+    introspection.initialize(),
+    findFiles(rootDir, config)
+  ]);
+  fileDiscoveryMs = Date.now() - fileDiscoveryStart;
+  filesDiscovered = currentFiles.length;
   const currentFileSet = new Set(currentFiles.map((f) => path22.relative(rootDir, f)));
   let totalIndexed = 0;
   let totalRemoved = 0;
@@ -11614,20 +12146,21 @@ async function ensureIndexFresh(rootDir, options = {}) {
         filesToRemove.push(filepath);
       }
     }
+    const cleanupStart = Date.now();
     const removedFilepaths = [];
-    for (const filepath of filesToRemove) {
-      logger.debug(`  Removing stale: ${filepath}`);
-      const indexFilePath = path22.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
-      try {
-        await fs8.unlink(indexFilePath);
-      } catch {}
-      const symbolicFilePath = path22.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
-      try {
-        await fs8.unlink(symbolicFilePath);
-      } catch {}
-      delete manifest.files[filepath];
-      removedFilepaths.push(filepath);
-      totalRemoved++;
+    if (filesToRemove.length > 0) {
+      await Promise.all(filesToRemove.map(async (filepath) => {
+        logger.debug(`  Removing stale: ${filepath}`);
+        const indexFilePath = path22.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+        const symbolicFilePath = path22.join(indexPath, "symbolic", filepath.replace(/\.[^.]+$/, ".json"));
+        await Promise.all([
+          fs8.unlink(indexFilePath).catch(() => {}),
+          fs8.unlink(symbolicFilePath).catch(() => {})
+        ]);
+        delete manifest.files[filepath];
+        removedFilepaths.push(filepath);
+      }));
+      totalRemoved += removedFilepaths.length;
     }
     if (removedFilepaths.length > 0) {
       try {
@@ -11641,6 +12174,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
         await literalIndex.save();
       } catch {}
     }
+    cleanupMs += Date.now() - cleanupStart;
     const ctx = {
       rootDir,
       config,
@@ -11655,21 +12189,51 @@ async function ensureIndexFresh(rootDir, options = {}) {
       },
       getIntrospection: (filepath) => introspection.getFile(filepath)
     };
-    const totalFiles = currentFiles.length;
-    let completedCount = 0;
-    const processIncrementalFile = async (filepath) => {
+    const statCheck = async (filepath) => {
       const relativePath = path22.relative(rootDir, filepath);
       try {
         const stats = await fs8.stat(filepath);
         const lastModified = stats.mtime.toISOString();
         const existingEntry = manifest.files[relativePath];
-        if (existingEntry && existingEntry.lastModified === lastModified) {
-          completedCount++;
-          return { relativePath, status: "unchanged" };
+        if (!existingEntry) {
+          return { filepath, relativePath, lastModified, needsCheck: true, isNew: true };
         }
+        if (existingEntry.lastModified === lastModified) {
+          return { filepath, relativePath, lastModified, needsCheck: false, isNew: false };
+        }
+        return { filepath, relativePath, lastModified, needsCheck: true, isNew: false };
+      } catch {
+        return null;
+      }
+    };
+    const statCheckStart = Date.now();
+    const statResults = await parallelMap(currentFiles, statCheck, STAT_CONCURRENCY);
+    statCheckMs += Date.now() - statCheckStart;
+    filesStatChecked += currentFiles.length;
+    const filesToProcess = [];
+    let unchangedCount = 0;
+    for (const result2 of statResults) {
+      if (!result2.success || !result2.value)
+        continue;
+      if (result2.value.needsCheck) {
+        filesToProcess.push(result2.value);
+      } else {
+        unchangedCount++;
+      }
+    }
+    if (filesToProcess.length === 0) {
+      totalUnchanged += unchangedCount;
+      continue;
+    }
+    let completedCount = 0;
+    const totalToProcess = filesToProcess.length;
+    const processChangedFile = async (statResult) => {
+      const { filepath, relativePath, lastModified, isNew } = statResult;
+      try {
         const content = await fs8.readFile(filepath, "utf-8");
         const contentHash = computeContentHash(content);
-        if (existingEntry?.contentHash && existingEntry.contentHash === contentHash) {
+        const existingEntry = manifest.files[relativePath];
+        if (!isNew && existingEntry?.contentHash && existingEntry.contentHash === contentHash) {
           completedCount++;
           return {
             relativePath,
@@ -11679,7 +12243,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
           };
         }
         completedCount++;
-        logger.progress(`  [${completedCount}/${totalFiles}] Indexing: ${relativePath}`);
+        logger.progress(`  [${completedCount}/${totalToProcess}] Indexing: ${relativePath}`);
         introspection.addFile(relativePath, content);
         const fileIndex = await module2.indexFile(relativePath, content, ctx);
         if (!fileIndex) {
@@ -11698,8 +12262,12 @@ async function ensureIndexFresh(rootDir, options = {}) {
         return { relativePath, status: "error", error };
       }
     };
+    const indexingStart = Date.now();
     const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
-    const results = await parallelMap(currentFiles, processIncrementalFile, concurrency);
+    const results = await parallelMap(filesToProcess, processChangedFile, concurrency);
+    indexingMs += Date.now() - indexingStart;
+    filesIndexed += filesToProcess.length;
+    totalUnchanged += unchangedCount;
     logger.clearProgress();
     let mtimeUpdates = 0;
     for (const item of results) {
@@ -11760,6 +12328,19 @@ async function ensureIndexFresh(rootDir, options = {}) {
     removed: totalRemoved,
     unchanged: totalUnchanged
   };
+  if (showTiming) {
+    result.timing = {
+      totalMs: Date.now() - startTime,
+      fileDiscoveryMs,
+      statCheckMs,
+      indexingMs,
+      cleanupMs,
+      filesDiscovered,
+      filesStatChecked,
+      filesIndexed,
+      fromCache: false
+    };
+  }
   let finalManifestMtime = currentManifestMtime;
   try {
     const manifestStats = await fs8.stat(globalManifestPath);
@@ -11767,7 +12348,7 @@ async function ensureIndexFresh(rootDir, options = {}) {
   } catch {}
   freshnessCache = {
     rootDir,
-    result,
+    result: { indexed: totalIndexed, removed: totalRemoved, unchanged: totalUnchanged },
     timestamp: Date.now(),
     manifestMtime: finalManifestMtime
   };
@@ -11907,18 +12488,14 @@ async function indexWithModule(rootDir, files, module2, config, verbose, introsp
   return result;
 }
 async function findFiles(rootDir, config) {
-  const patterns = config.extensions.map((ext) => `**/*${ext}`);
-  const ignorePatterns = config.ignorePaths.map((p) => `**/${p}/**`);
-  const files = [];
-  for (const pattern of patterns) {
-    const matches = await glob(pattern, {
-      cwd: rootDir,
-      absolute: true,
-      ignore: ignorePatterns
-    });
-    files.push(...matches);
-  }
-  return [...new Set(files)];
+  const validExtensions = new Set(config.extensions);
+  const ignoreDirs = new Set(config.ignorePaths);
+  const crawler = new Builder().withFullPaths().exclude((dirName) => ignoreDirs.has(dirName)).filter((filePath) => {
+    const ext = path22.extname(filePath);
+    return validExtensions.has(ext);
+  }).crawl(rootDir);
+  const files = await crawler.withPromise();
+  return files;
 }
 async function loadModuleManifest(rootDir, moduleId, config) {
   const manifestPath = getModuleManifestPath(rootDir, moduleId, config);
@@ -12087,14 +12664,16 @@ async function getIndexStatus(rootDir) {
   }
   return status;
 }
-var FRESHNESS_CACHE_TTL_MS = 5000, freshnessCache = null, INDEX_SCHEMA_VERSION = "2.0.0", DEFAULT_CONCURRENCY;
+var FRESHNESS_CACHE_TTL_MS = 5000, freshnessCache = null, INDEX_SCHEMA_VERSION = "2.0.0", DEFAULT_CONCURRENCY, STAT_CONCURRENCY;
 var init_indexer = __esm(() => {
+  init_dist();
   init_config2();
   init_registry();
   init_introspection2();
   init_logger();
   init_watcher();
   DEFAULT_CONCURRENCY = getOptimalConcurrency();
+  STAT_CONCURRENCY = Math.max(32, getOptimalConcurrency() * 4);
 });
 
 // node_modules/balanced-match/index.js
@@ -12317,9 +12896,9 @@ var init_assert_valid_pattern = __esm(() => {
 });
 
 // node_modules/minimatch/dist/esm/brace-expressions.js
-var posixClasses, braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&"), regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), rangesToString = (ranges) => ranges.join(""), parseClass = (glob2, position) => {
+var posixClasses, braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&"), regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), rangesToString = (ranges) => ranges.join(""), parseClass = (glob, position) => {
   const pos = position;
-  if (glob2.charAt(pos) !== "[") {
+  if (glob.charAt(pos) !== "[") {
     throw new Error("not in a brace expression");
   }
   const ranges = [];
@@ -12332,8 +12911,8 @@ var posixClasses, braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&"), regexpEsc
   let endPos = pos;
   let rangeStart = "";
   WHILE:
-    while (i2 < glob2.length) {
-      const c = glob2.charAt(i2);
+    while (i2 < glob.length) {
+      const c = glob.charAt(i2);
       if ((c === "!" || c === "^") && i2 === pos + 1) {
         negate = true;
         i2++;
@@ -12353,9 +12932,9 @@ var posixClasses, braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&"), regexpEsc
       }
       if (c === "[" && !escaping) {
         for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
-          if (glob2.startsWith(cls, i2)) {
+          if (glob.startsWith(cls, i2)) {
             if (rangeStart) {
-              return ["$.", false, glob2.length - pos, true];
+              return ["$.", false, glob.length - pos, true];
             }
             i2 += cls.length;
             if (neg)
@@ -12378,12 +12957,12 @@ var posixClasses, braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&"), regexpEsc
         i2++;
         continue;
       }
-      if (glob2.startsWith("-]", i2 + 1)) {
+      if (glob.startsWith("-]", i2 + 1)) {
         ranges.push(braceEscape(c + "-"));
         i2 += 2;
         continue;
       }
-      if (glob2.startsWith("-", i2 + 1)) {
+      if (glob.startsWith("-", i2 + 1)) {
         rangeStart = c;
         i2 += 2;
         continue;
@@ -12395,7 +12974,7 @@ var posixClasses, braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&"), regexpEsc
     return ["", false, 0, false];
   }
   if (!ranges.length && !negs.length) {
-    return ["$.", false, glob2.length - pos, true];
+    return ["$.", false, glob.length - pos, true];
   }
   if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) {
     const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
@@ -12676,16 +13255,16 @@ class AST {
   toMMPattern() {
     if (this !== this.#root)
       return this.#root.toMMPattern();
-    const glob2 = this.toString();
+    const glob = this.toString();
     const [re, body2, hasMagic, uflag] = this.toRegExpSource();
-    const anyMagic = hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob2.toUpperCase() !== glob2.toLowerCase();
+    const anyMagic = hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob.toUpperCase() !== glob.toLowerCase();
     if (!anyMagic) {
       return body2;
     }
     const flags2 = (this.#options.nocase ? "i" : "") + (uflag ? "u" : "");
     return Object.assign(new RegExp(`^${re}$`, flags2), {
       _src: re,
-      _glob: glob2
+      _glob: glob
     });
   }
   get options() {
@@ -12768,19 +13347,19 @@ class AST {
       return re;
     }).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
   }
-  static #parseGlob(glob2, hasMagic, noEmpty = false) {
+  static #parseGlob(glob, hasMagic, noEmpty = false) {
     let escaping = false;
     let re = "";
     let uflag = false;
-    for (let i2 = 0;i2 < glob2.length; i2++) {
-      const c = glob2.charAt(i2);
+    for (let i2 = 0;i2 < glob.length; i2++) {
+      const c = glob.charAt(i2);
       if (escaping) {
         escaping = false;
         re += (reSpecials.has(c) ? "\\" : "") + c;
         continue;
       }
       if (c === "\\") {
-        if (i2 === glob2.length - 1) {
+        if (i2 === glob.length - 1) {
           re += "\\\\";
         } else {
           escaping = true;
@@ -12788,7 +13367,7 @@ class AST {
         continue;
       }
       if (c === "[") {
-        const [src, needUflag, consumed, magic] = parseClass(glob2, i2);
+        const [src, needUflag, consumed, magic] = parseClass(glob, i2);
         if (consumed) {
           re += src;
           uflag = uflag || needUflag;
@@ -12798,7 +13377,7 @@ class AST {
         }
       }
       if (c === "*") {
-        if (noEmpty && glob2 === "*")
+        if (noEmpty && glob === "*")
           re += starNoEmpty;
         else
           re += star;
@@ -12812,7 +13391,7 @@ class AST {
       }
       re += regExpEscape(c);
     }
-    return [re, unescape(glob2), !!hasMagic, uflag];
+    return [re, unescape(glob), !!hasMagic, uflag];
   }
 }
 var types, isExtglobType = (c) => types.has(c), startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))", startNoDot = "(?!\\.)", addPatternStart, justDots, reSpecials, regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), qmark = "[^/]", star, starNoEmpty;
@@ -13413,7 +13992,7 @@ var import_brace_expansion, minimatch = (p, pattern, options = {}) => {
 }, qmarksTestNoExtDot = ([$0]) => {
   const len = $0.length;
   return (f) => f.length === len && f !== "." && f !== "..";
-}, defaultPlatform, path23, sep, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a, b = {}) => Object.assign({}, a, b), defaults = (def) => {
+}, defaultPlatform, path23, sep2, GLOBSTAR, qmark2 = "[^/]", star2, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a, b = {}) => Object.assign({}, a, b), defaults = (def) => {
   if (!def || typeof def !== "object" || !Object.keys(def).length) {
     return minimatch;
   }
@@ -13475,8 +14054,8 @@ var init_esm = __esm(() => {
     win32: { sep: "\\" },
     posix: { sep: "/" }
   };
-  sep = defaultPlatform === "win32" ? path23.win32.sep : path23.posix.sep;
-  minimatch.sep = sep;
+  sep2 = defaultPlatform === "win32" ? path23.win32.sep : path23.posix.sep;
+  minimatch.sep = sep2;
   GLOBSTAR = Symbol("globstar **");
   minimatch.GLOBSTAR = GLOBSTAR;
   star2 = qmark2 + "*?";
@@ -13579,8 +14158,8 @@ function createSearchContext(rootDir, moduleId, config) {
       const files = [];
       await traverseDirectory(indexPath, files, indexPath);
       return files.filter((f) => f.endsWith(".json") && !f.endsWith("manifest.json")).map((f) => {
-        const relative4 = path24.relative(indexPath, f);
-        return relative4.replace(/\.json$/, "");
+        const relative5 = path24.relative(indexPath, f);
+        return relative5.replace(/\.json$/, "");
       });
     }
   };
@@ -13668,7 +14247,7 @@ init_logger();
 // package.json
 var package_default = {
   name: "raggrep",
-  version: "0.10.2",
+  version: "0.10.5",
   description: "Local filesystem-based RAG system for codebases - semantic search using local embeddings",
   type: "module",
   main: "./dist/index.js",
@@ -13725,6 +14304,7 @@ var package_default = {
   dependencies: {
     "@xenova/transformers": "^2.17.0",
     chokidar: "^5.0.0",
+    fdir: "^6.5.0",
     glob: "^10.0.0",
     typescript: "^5.0.0",
     "web-tree-sitter": "^0.26.3"
@@ -13765,6 +14345,7 @@ function parseFlags(args3) {
     help: false,
     verbose: false,
     watch: false,
+    timing: false,
     remaining: []
   };
   for (let i2 = 0;i2 < args3.length; i2++) {
@@ -13775,6 +14356,8 @@ function parseFlags(args3) {
       flags2.verbose = true;
     } else if (arg === "--watch" || arg === "-w") {
       flags2.watch = true;
+    } else if (arg === "--timing" || arg === "-T") {
+      flags2.timing = true;
     } else if (arg === "--model" || arg === "-m") {
       const modelName = args3[++i2];
       if (modelName && modelName in EMBEDDING_MODELS) {
@@ -13933,6 +14516,7 @@ Options:
   -s, --min-score <n>  Minimum similarity score 0-1 (default: 0.15)
   -t, --type <ext>     Filter by file extension (e.g., ts, tsx, js)
   -f, --filter <path>  Filter by path or glob pattern (can be used multiple times)
+  -T, --timing         Show timing breakdown for performance profiling
   -h, --help           Show this help message
 
 Note:
@@ -13986,7 +14570,8 @@ Examples:
         const freshStats = await ensureIndexFresh2(process.cwd(), {
           model: flags2.model,
           quiet: true,
-          logger: silentLogger
+          logger: silentLogger,
+          timing: flags2.timing
         });
         console.log("RAGgrep Search");
         console.log(`==============
@@ -14003,6 +14588,23 @@ Examples:
 `);
         } else {
           console.log(`Using cached index (no changes detected).
+`);
+        }
+        if (flags2.timing && freshStats.timing) {
+          const t = freshStats.timing;
+          console.log("┌─ Timing ─────────────────────────────────────┐");
+          if (t.fromCache) {
+            console.log(`│  Cache hit (TTL-based)                       │`);
+            console.log(`│  Total: ${t.totalMs.toFixed(0).padStart(6)}ms                              │`);
+          } else {
+            console.log(`│  File discovery: ${t.fileDiscoveryMs.toFixed(0).padStart(6)}ms (${t.filesDiscovered} files)`.padEnd(47) + "│");
+            console.log(`│  Stat checks:    ${t.statCheckMs.toFixed(0).padStart(6)}ms (${t.filesStatChecked} files)`.padEnd(47) + "│");
+            console.log(`│  Indexing:       ${t.indexingMs.toFixed(0).padStart(6)}ms (${t.filesIndexed} files)`.padEnd(47) + "│");
+            console.log(`│  Cleanup:        ${t.cleanupMs.toFixed(0).padStart(6)}ms`.padEnd(47) + "│");
+            console.log(`│  ─────────────────────────────────────────── │`);
+            console.log(`│  Total:          ${t.totalMs.toFixed(0).padStart(6)}ms`.padEnd(47) + "│");
+          }
+          console.log(`└──────────────────────────────────────────────┘
 `);
         }
         const filePatterns = flags2.fileType ? [`*.${flags2.fileType}`] : undefined;
@@ -14262,4 +14864,4 @@ Run 'raggrep <command> --help' for more information.
 }
 main();
 
-//# debugId=04D75A20D6C87C2264756E2164756E21
+//# debugId=D79BF0530F7DE02664756E2164756E21