opencode-codebase-index 0.2.5 → 0.3.2

package/dist/index.js

@@ -491,7 +491,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path8, checkUnignored, mode) {
+      test(path9, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -500,7 +500,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path8);
+          const matched = rule[mode].test(path9);
           if (!matched) {
             return;
           }
@@ -521,17 +521,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path8, originalPath, doThrow) => {
-      if (!isString(path8)) {
+    var checkPath = (path9, originalPath, doThrow) => {
+      if (!isString(path9)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path8) {
+      if (!path9) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path8)) {
+      if (checkPath.isNotRelative(path9)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -540,7 +540,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path8) => REGEX_TEST_INVALID_PATH.test(path8);
+    var isNotRelative = (path9) => REGEX_TEST_INVALID_PATH.test(path9);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -570,19 +570,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path8 = originalPath && checkPath.convert(originalPath);
+        const path9 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path8,
+          path9,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path8, cache, checkUnignored, slices);
+        return this._t(path9, cache, checkUnignored, slices);
       }
-      checkIgnore(path8) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path8)) {
-          return this.test(path8);
+      checkIgnore(path9) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path9)) {
+          return this.test(path9);
         }
-        const slices = path8.split(SLASH2).filter(Boolean);
+        const slices = path9.split(SLASH2).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -595,18 +595,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path8, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path9, false, MODE_CHECK_IGNORE);
       }
-      _t(path8, cache, checkUnignored, slices) {
-        if (path8 in cache) {
-          return cache[path8];
+      _t(path9, cache, checkUnignored, slices) {
+        if (path9 in cache) {
+          return cache[path9];
         }
         if (!slices) {
-          slices = path8.split(SLASH2).filter(Boolean);
+          slices = path9.split(SLASH2).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path8] = this._rules.test(path8, checkUnignored, MODE_IGNORE);
+          return cache[path9] = this._rules.test(path9, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH2) + SLASH2,
@@ -614,29 +614,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path8] = parent.ignored ? parent : this._rules.test(path8, checkUnignored, MODE_IGNORE);
+        return cache[path9] = parent.ignored ? parent : this._rules.test(path9, checkUnignored, MODE_IGNORE);
       }
-      ignores(path8) {
-        return this._test(path8, this._ignoreCache, false).ignored;
+      ignores(path9) {
+        return this._test(path9, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path8) => !this.ignores(path8);
+        return (path9) => !this.ignores(path9);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path8) {
-        return this._test(path8, this._testCache, true);
+      test(path9) {
+        return this._test(path9, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path8) => checkPath(path8 && checkPath.convert(path8), path8, RETURN_FALSE);
+    var isPathValid = (path9) => checkPath(path9 && checkPath.convert(path9), path9, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path8) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path8) || isNotRelative(path8);
+      checkPath.isNotRelative = (path9) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path9) || isNotRelative(path9);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -652,9 +652,10 @@ var require_ignore = __commonJS({
 });
 
 // src/index.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
-import * as path7 from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
+import * as path8 from "path";
 import * as os3 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/config/schema.ts
 var DEFAULT_INCLUDE = [
@@ -692,7 +693,10 @@ function getDefaultIndexingConfig() {
     maxChunksPerFile: 100,
     semanticOnly: false,
     retries: 3,
-    retryDelayMs: 1e3
+    retryDelayMs: 1e3,
+    autoGc: true,
+    gcIntervalDays: 7,
+    gcOrphanThreshold: 100
   };
 }
 function getDefaultSearchConfig() {
@@ -704,8 +708,21 @@ function getDefaultSearchConfig() {
     contextLines: 0
   };
 }
+function getDefaultDebugConfig() {
+  return {
+    enabled: false,
+    logLevel: "info",
+    logSearch: true,
+    logEmbedding: true,
+    logCache: true,
+    logGc: true,
+    logBranch: true,
+    metrics: true
+  };
+}
 var VALID_PROVIDERS = ["auto", "github-copilot", "openai", "google", "ollama"];
 var VALID_SCOPES = ["project", "global"];
+var VALID_LOG_LEVELS = ["error", "warn", "info", "debug"];
 function isValidProvider(value) {
   return typeof value === "string" && VALID_PROVIDERS.includes(value);
 }
@@ -715,10 +732,14 @@ function isValidScope(value) {
 function isStringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
+function isValidLogLevel(value) {
+  return typeof value === "string" && VALID_LOG_LEVELS.includes(value);
+}
 function parseConfig(raw) {
   const input = raw && typeof raw === "object" ? raw : {};
   const defaultIndexing = getDefaultIndexingConfig();
   const defaultSearch = getDefaultSearchConfig();
+  const defaultDebug = getDefaultDebugConfig();
   const rawIndexing = input.indexing && typeof input.indexing === "object" ? input.indexing : {};
   const indexing = {
     autoIndex: typeof rawIndexing.autoIndex === "boolean" ? rawIndexing.autoIndex : defaultIndexing.autoIndex,
@@ -727,7 +748,10 @@ function parseConfig(raw) {
     maxChunksPerFile: typeof rawIndexing.maxChunksPerFile === "number" ? Math.max(1, rawIndexing.maxChunksPerFile) : defaultIndexing.maxChunksPerFile,
     semanticOnly: typeof rawIndexing.semanticOnly === "boolean" ? rawIndexing.semanticOnly : defaultIndexing.semanticOnly,
     retries: typeof rawIndexing.retries === "number" ? rawIndexing.retries : defaultIndexing.retries,
-    retryDelayMs: typeof rawIndexing.retryDelayMs === "number" ? rawIndexing.retryDelayMs : defaultIndexing.retryDelayMs
+    retryDelayMs: typeof rawIndexing.retryDelayMs === "number" ? rawIndexing.retryDelayMs : defaultIndexing.retryDelayMs,
+    autoGc: typeof rawIndexing.autoGc === "boolean" ? rawIndexing.autoGc : defaultIndexing.autoGc,
+    gcIntervalDays: typeof rawIndexing.gcIntervalDays === "number" ? Math.max(1, rawIndexing.gcIntervalDays) : defaultIndexing.gcIntervalDays,
+    gcOrphanThreshold: typeof rawIndexing.gcOrphanThreshold === "number" ? Math.max(0, rawIndexing.gcOrphanThreshold) : defaultIndexing.gcOrphanThreshold
   };
   const rawSearch = input.search && typeof input.search === "object" ? input.search : {};
   const search = {
@@ -737,6 +761,17 @@ function parseConfig(raw) {
     hybridWeight: typeof rawSearch.hybridWeight === "number" ? Math.min(1, Math.max(0, rawSearch.hybridWeight)) : defaultSearch.hybridWeight,
     contextLines: typeof rawSearch.contextLines === "number" ? Math.min(50, Math.max(0, rawSearch.contextLines)) : defaultSearch.contextLines
   };
+  const rawDebug = input.debug && typeof input.debug === "object" ? input.debug : {};
+  const debug = {
+    enabled: typeof rawDebug.enabled === "boolean" ? rawDebug.enabled : defaultDebug.enabled,
+    logLevel: isValidLogLevel(rawDebug.logLevel) ? rawDebug.logLevel : defaultDebug.logLevel,
+    logSearch: typeof rawDebug.logSearch === "boolean" ? rawDebug.logSearch : defaultDebug.logSearch,
+    logEmbedding: typeof rawDebug.logEmbedding === "boolean" ? rawDebug.logEmbedding : defaultDebug.logEmbedding,
+    logCache: typeof rawDebug.logCache === "boolean" ? rawDebug.logCache : defaultDebug.logCache,
+    logGc: typeof rawDebug.logGc === "boolean" ? rawDebug.logGc : defaultDebug.logGc,
+    logBranch: typeof rawDebug.logBranch === "boolean" ? rawDebug.logBranch : defaultDebug.logBranch,
+    metrics: typeof rawDebug.metrics === "boolean" ? rawDebug.metrics : defaultDebug.metrics
+  };
   return {
     embeddingProvider: isValidProvider(input.embeddingProvider) ? input.embeddingProvider : "auto",
     embeddingModel: typeof input.embeddingModel === "string" ? input.embeddingModel : "auto",
@@ -744,7 +779,8 @@ function parseConfig(raw) {
     include: isStringArray(input.include) ? input.include : DEFAULT_INCLUDE,
     exclude: isStringArray(input.exclude) ? input.exclude : DEFAULT_EXCLUDE,
     indexing,
-    search
+    search,
+    debug
   };
 }
 var EMBEDDING_MODELS = {
@@ -809,6 +845,7 @@ function getDefaultModelForProvider(provider) {
 // src/indexer/index.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync, promises as fsPromises2 } from "fs";
 import * as path5 from "path";
+import { performance as performance2 } from "perf_hooks";
 
 // node_modules/eventemitter3/index.mjs
 var import_index = __toESM(require_eventemitter3(), 1);
@@ -2066,34 +2103,36 @@ var GoogleEmbeddingProvider = class {
     };
   }
   async embedBatch(texts) {
-    const embeddings = [];
-    let totalTokens = 0;
-    for (const text of texts) {
-      const response = await fetch(
-        `${this.credentials.baseUrl}/models/${this.modelInfo.model}:embedContent?key=${this.credentials.apiKey}`,
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            content: {
-              parts: [{ text }]
-            }
-          })
+    const results = await Promise.all(
+      texts.map(async (text) => {
+        const response = await fetch(
+          `${this.credentials.baseUrl}/models/${this.modelInfo.model}:embedContent?key=${this.credentials.apiKey}`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              content: {
+                parts: [{ text }]
+              }
+            })
+          }
+        );
+        if (!response.ok) {
+          const error = await response.text();
+          throw new Error(`Google embedding API error: ${response.status} - ${error}`);
         }
-      );
-      if (!response.ok) {
-        const error = await response.text();
-        throw new Error(`Google embedding API error: ${response.status} - ${error}`);
-      }
-      const data = await response.json();
-      embeddings.push(data.embedding.values);
-      totalTokens += Math.ceil(text.length / 4);
-    }
+        const data = await response.json();
+        return {
+          embedding: data.embedding.values,
+          tokensUsed: Math.ceil(text.length / 4)
+        };
+      })
+    );
     return {
-      embeddings,
-      totalTokensUsed: totalTokens
+      embeddings: results.map((r) => r.embedding),
+      totalTokensUsed: results.reduce((sum, r) => sum + r.tokensUsed, 0)
     };
   }
   getModelInfo() {
@@ -2127,16 +2166,10 @@ var OllamaEmbeddingProvider = class {
     };
   }
   async embedBatch(texts) {
-    const embeddings = [];
-    let totalTokens = 0;
-    for (const text of texts) {
-      const result = await this.embed(text);
-      embeddings.push(result.embedding);
-      totalTokens += result.tokensUsed;
-    }
+    const results = await Promise.all(texts.map((text) => this.embed(text)));
     return {
-      embeddings,
-      totalTokensUsed: totalTokens
+      embeddings: results.map((r) => r.embedding),
+      totalTokensUsed: results.reduce((sum, r) => sum + r.tokensUsed, 0)
     };
   }
   getModelInfo() {
@@ -2322,6 +2355,298 @@ function padRight(str, length) {
   return str.padEnd(length);
 }
 
+// src/utils/logger.ts
+var LOG_LEVEL_PRIORITY = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3
+};
+function createEmptyMetrics() {
+  return {
+    filesScanned: 0,
+    filesParsed: 0,
+    parseMs: 0,
+    chunksProcessed: 0,
+    chunksEmbedded: 0,
+    chunksFromCache: 0,
+    chunksRemoved: 0,
+    embeddingApiCalls: 0,
+    embeddingTokensUsed: 0,
+    embeddingErrors: 0,
+    searchCount: 0,
+    searchTotalMs: 0,
+    searchAvgMs: 0,
+    searchLastMs: 0,
+    embeddingCallMs: 0,
+    vectorSearchMs: 0,
+    keywordSearchMs: 0,
+    fusionMs: 0,
+    cacheHits: 0,
+    cacheMisses: 0,
+    queryCacheHits: 0,
+    queryCacheSimilarHits: 0,
+    queryCacheMisses: 0,
+    gcRuns: 0,
+    gcOrphansRemoved: 0,
+    gcChunksRemoved: 0,
+    gcEmbeddingsRemoved: 0
+  };
+}
+var Logger = class {
+  config;
+  metrics;
+  logs = [];
+  maxLogs = 1e3;
+  constructor(config) {
+    this.config = config;
+    this.metrics = createEmptyMetrics();
+  }
+  shouldLog(level) {
+    if (!this.config.enabled) return false;
+    return LOG_LEVEL_PRIORITY[level] <= LOG_LEVEL_PRIORITY[this.config.logLevel];
+  }
+  log(level, category, message, data) {
+    if (!this.shouldLog(level)) return;
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      category,
+      message,
+      data
+    };
+    this.logs.push(entry);
+    if (this.logs.length > this.maxLogs) {
+      this.logs.shift();
+    }
+  }
+  search(level, message, data) {
+    if (this.config.logSearch) {
+      this.log(level, "search", message, data);
+    }
+  }
+  embedding(level, message, data) {
+    if (this.config.logEmbedding) {
+      this.log(level, "embedding", message, data);
+    }
+  }
+  cache(level, message, data) {
+    if (this.config.logCache) {
+      this.log(level, "cache", message, data);
+    }
+  }
+  gc(level, message, data) {
+    if (this.config.logGc) {
+      this.log(level, "gc", message, data);
+    }
+  }
+  branch(level, message, data) {
+    if (this.config.logBranch) {
+      this.log(level, "branch", message, data);
+    }
+  }
+  info(message, data) {
+    this.log("info", "general", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", "general", message, data);
+  }
+  error(message, data) {
+    this.log("error", "general", message, data);
+  }
+  debug(message, data) {
+    this.log("debug", "general", message, data);
+  }
+  recordIndexingStart() {
+    if (!this.config.metrics) return;
+    this.metrics.indexingStartTime = Date.now();
+  }
+  recordIndexingEnd() {
+    if (!this.config.metrics) return;
+    this.metrics.indexingEndTime = Date.now();
+  }
+  recordFilesScanned(count) {
+    if (!this.config.metrics) return;
+    this.metrics.filesScanned = count;
+  }
+  recordFilesParsed(count) {
+    if (!this.config.metrics) return;
+    this.metrics.filesParsed = count;
+  }
+  recordParseDuration(durationMs) {
+    if (!this.config.metrics) return;
+    this.metrics.parseMs = durationMs;
+  }
+  recordChunksProcessed(count) {
+    if (!this.config.metrics) return;
+    this.metrics.chunksProcessed += count;
+  }
+  recordChunksEmbedded(count) {
+    if (!this.config.metrics) return;
+    this.metrics.chunksEmbedded += count;
+  }
+  recordChunksFromCache(count) {
+    if (!this.config.metrics) return;
+    this.metrics.chunksFromCache += count;
+  }
+  recordChunksRemoved(count) {
+    if (!this.config.metrics) return;
+    this.metrics.chunksRemoved += count;
+  }
+  recordEmbeddingApiCall(tokens) {
+    if (!this.config.metrics) return;
+    this.metrics.embeddingApiCalls++;
+    this.metrics.embeddingTokensUsed += tokens;
+  }
+  recordEmbeddingError() {
+    if (!this.config.metrics) return;
+    this.metrics.embeddingErrors++;
+  }
+  recordSearch(durationMs, breakdown) {
+    if (!this.config.metrics) return;
+    this.metrics.searchCount++;
+    this.metrics.searchTotalMs += durationMs;
+    this.metrics.searchLastMs = durationMs;
+    this.metrics.searchAvgMs = this.metrics.searchTotalMs / this.metrics.searchCount;
+    if (breakdown) {
+      this.metrics.embeddingCallMs = breakdown.embeddingMs;
+      this.metrics.vectorSearchMs = breakdown.vectorMs;
+      this.metrics.keywordSearchMs = breakdown.keywordMs;
+      this.metrics.fusionMs = breakdown.fusionMs;
+    }
+  }
+  recordCacheHit() {
+    if (!this.config.metrics) return;
+    this.metrics.cacheHits++;
+  }
+  recordCacheMiss() {
+    if (!this.config.metrics) return;
+    this.metrics.cacheMisses++;
+  }
+  recordQueryCacheHit() {
+    if (!this.config.metrics) return;
+    this.metrics.queryCacheHits++;
+  }
+  recordQueryCacheSimilarHit() {
+    if (!this.config.metrics) return;
+    this.metrics.queryCacheSimilarHits++;
+  }
+  recordQueryCacheMiss() {
+    if (!this.config.metrics) return;
+    this.metrics.queryCacheMisses++;
+  }
+  recordGc(orphans, chunks, embeddings) {
+    if (!this.config.metrics) return;
+    this.metrics.gcRuns++;
+    this.metrics.gcOrphansRemoved += orphans;
+    this.metrics.gcChunksRemoved += chunks;
+    this.metrics.gcEmbeddingsRemoved += embeddings;
+  }
+  getMetrics() {
+    return { ...this.metrics };
+  }
+  getLogs(limit) {
+    const logs = [...this.logs];
+    if (limit) {
+      return logs.slice(-limit);
+    }
+    return logs;
+  }
+  getLogsByCategory(category, limit) {
+    const filtered = this.logs.filter((l) => l.category === category);
+    if (limit) {
+      return filtered.slice(-limit);
+    }
+    return filtered;
+  }
+  getLogsByLevel(level, limit) {
+    const filtered = this.logs.filter((l) => l.level === level);
+    if (limit) {
+      return filtered.slice(-limit);
+    }
+    return filtered;
+  }
+  resetMetrics() {
+    this.metrics = createEmptyMetrics();
+  }
+  clearLogs() {
+    this.logs = [];
+  }
+  formatMetrics() {
+    const m = this.metrics;
+    const lines = [];
+    lines.push("=== Metrics ===");
+    if (m.indexingStartTime && m.indexingEndTime) {
+      const duration = m.indexingEndTime - m.indexingStartTime;
+      lines.push(`Indexing duration: ${(duration / 1e3).toFixed(2)}s`);
+    }
+    lines.push("");
+    lines.push("Indexing:");
+    lines.push(`  Files scanned: ${m.filesScanned}`);
+    lines.push(`  Files parsed: ${m.filesParsed}`);
+    lines.push(`  Chunks processed: ${m.chunksProcessed}`);
+    lines.push(`  Chunks embedded: ${m.chunksEmbedded}`);
+    lines.push(`  Chunks from cache: ${m.chunksFromCache}`);
+    lines.push(`  Chunks removed: ${m.chunksRemoved}`);
+    lines.push("");
+    lines.push("Embedding API:");
+    lines.push(`  API calls: ${m.embeddingApiCalls}`);
+    lines.push(`  Tokens used: ${m.embeddingTokensUsed.toLocaleString()}`);
+    lines.push(`  Errors: ${m.embeddingErrors}`);
+    if (m.searchCount > 0) {
+      lines.push("");
+      lines.push("Search:");
+      lines.push(`  Total searches: ${m.searchCount}`);
+      lines.push(`  Average time: ${m.searchAvgMs.toFixed(2)}ms`);
+      lines.push(`  Last search: ${m.searchLastMs.toFixed(2)}ms`);
+      if (m.embeddingCallMs > 0) {
+        lines.push(`    - Embedding: ${m.embeddingCallMs.toFixed(2)}ms`);
+        lines.push(`    - Vector search: ${m.vectorSearchMs.toFixed(2)}ms`);
+        lines.push(`    - Keyword search: ${m.keywordSearchMs.toFixed(2)}ms`);
+        lines.push(`    - Fusion: ${m.fusionMs.toFixed(2)}ms`);
+      }
+    }
+    const totalCacheOps = m.cacheHits + m.cacheMisses;
+    if (totalCacheOps > 0) {
+      lines.push("");
+      lines.push("Cache:");
+      lines.push(`  Hits: ${m.cacheHits}`);
+      lines.push(`  Misses: ${m.cacheMisses}`);
+      lines.push(`  Hit rate: ${(m.cacheHits / totalCacheOps * 100).toFixed(1)}%`);
+    }
+    if (m.gcRuns > 0) {
+      lines.push("");
+      lines.push("Garbage Collection:");
+      lines.push(`  GC runs: ${m.gcRuns}`);
+      lines.push(`  Orphans removed: ${m.gcOrphansRemoved}`);
+      lines.push(`  Chunks removed: ${m.gcChunksRemoved}`);
+      lines.push(`  Embeddings removed: ${m.gcEmbeddingsRemoved}`);
+    }
+    return lines.join("\n");
+  }
+  formatRecentLogs(limit = 20) {
+    const logs = this.getLogs(limit);
+    if (logs.length === 0) {
+      return "No logs recorded.";
+    }
+    return logs.map((l) => {
+      const dataStr = l.data ? ` ${JSON.stringify(l.data)}` : "";
+      return `[${l.timestamp}] [${l.level.toUpperCase()}] [${l.category}] ${l.message}${dataStr}`;
+    }).join("\n");
+  }
+  isEnabled() {
+    return this.config.enabled;
+  }
+  isMetricsEnabled() {
+    return this.config.enabled && this.config.metrics;
+  }
+};
+var globalLogger = null;
+function initializeLogger(config) {
+  globalLogger = new Logger(config);
+  return globalLogger;
+}
+
 // src/native/index.ts
 import * as path3 from "path";
 import * as os2 from "os";
@@ -2450,6 +2775,21 @@ var VectorStore = class {
       metadata: JSON.parse(r.metadata)
     }));
   }
+  getMetadata(id) {
+    const result = this.inner.getMetadata(id);
+    if (result === null || result === void 0) {
+      return void 0;
+    }
+    return JSON.parse(result);
+  }
+  getMetadataBatch(ids) {
+    const results = this.inner.getMetadataBatch(ids);
+    const map = /* @__PURE__ */ new Map();
+    for (const { key, metadata } of results) {
+      map.set(key, JSON.parse(metadata));
+    }
+    return map;
+  }
 };
 var CHARS_PER_TOKEN = 4;
 var MAX_BATCH_TOKENS = 7500;
@@ -2677,12 +3017,20 @@ var Database = class {
   upsertEmbedding(contentHash, embedding, chunkText, model) {
     this.inner.upsertEmbedding(contentHash, embedding, chunkText, model);
   }
+  upsertEmbeddingsBatch(items) {
+    if (items.length === 0) return;
+    this.inner.upsertEmbeddingsBatch(items);
+  }
   getMissingEmbeddings(contentHashes) {
     return this.inner.getMissingEmbeddings(contentHashes);
   }
   upsertChunk(chunk) {
     this.inner.upsertChunk(chunk);
   }
+  upsertChunksBatch(chunks) {
+    if (chunks.length === 0) return;
+    this.inner.upsertChunksBatch(chunks);
+  }
   getChunk(chunkId) {
     return this.inner.getChunk(chunkId) ?? null;
   }
@@ -2695,6 +3043,10 @@ var Database = class {
   addChunksToBranch(branch, chunkIds) {
     this.inner.addChunksToBranch(branch, chunkIds);
   }
+  addChunksToBranchBatch(branch, chunkIds) {
+    if (chunkIds.length === 0) return;
+    this.inner.addChunksToBranchBatch(branch, chunkIds);
+  }
   clearBranch(branch) {
     return this.inner.clearBranch(branch);
   }
@@ -2836,12 +3188,18 @@ var Indexer = class {
   failedBatchesPath = "";
   currentBranch = "default";
   baseBranch = "main";
+  logger;
+  queryEmbeddingCache = /* @__PURE__ */ new Map();
+  maxQueryCacheSize = 100;
+  queryCacheTtlMs = 5 * 60 * 1e3;
+  querySimilarityThreshold = 0.85;
   constructor(projectRoot, config) {
     this.projectRoot = projectRoot;
     this.config = config;
     this.indexPath = this.getIndexPath();
     this.fileHashCachePath = path5.join(this.indexPath, "file-hashes.json");
     this.failedBatchesPath = path5.join(this.indexPath, "failed-batches.json");
+    this.logger = initializeLogger(config.debug);
   }
   getIndexPath() {
     if (this.config.scope === "global") {
@@ -2920,6 +3278,11 @@ var Indexer = class {
         "No embedding provider available. Configure GitHub, OpenAI, Google, or Ollama."
       );
     }
+    this.logger.info("Initializing indexer", {
+      provider: this.detectedProvider.provider,
+      model: this.detectedProvider.modelInfo.model,
+      scope: this.config.scope
+    });
     this.provider = createEmbeddingProvider(
       this.detectedProvider.credentials,
       this.detectedProvider.modelInfo
@@ -2951,15 +3314,54 @@ var Indexer = class {
     if (isGitRepo(this.projectRoot)) {
       this.currentBranch = getBranchOrDefault(this.projectRoot);
       this.baseBranch = getBaseBranch(this.projectRoot);
+      this.logger.branch("info", "Detected git repository", {
+        currentBranch: this.currentBranch,
+        baseBranch: this.baseBranch
+      });
     } else {
       this.currentBranch = "default";
       this.baseBranch = "default";
+      this.logger.branch("debug", "Not a git repository, using default branch");
+    }
+    if (this.config.indexing.autoGc) {
+      await this.maybeRunAutoGc();
+    }
+  }
+  async maybeRunAutoGc() {
+    if (!this.database) return;
+    const lastGcTimestamp = this.database.getMetadata("lastGcTimestamp");
+    const now = Date.now();
+    const intervalMs = this.config.indexing.gcIntervalDays * 24 * 60 * 60 * 1e3;
+    let shouldRunGc = false;
+    if (!lastGcTimestamp) {
+      shouldRunGc = true;
+    } else {
+      const lastGcTime = parseInt(lastGcTimestamp, 10);
+      if (!isNaN(lastGcTime) && now - lastGcTime > intervalMs) {
+        shouldRunGc = true;
+      }
+    }
+    if (shouldRunGc) {
+      await this.healthCheck();
+      this.database.setMetadata("lastGcTimestamp", now.toString());
+    }
+  }
+  async maybeRunOrphanGc() {
+    if (!this.database) return;
+    const stats = this.database.getStats();
+    if (!stats) return;
+    const orphanCount = stats.embeddingCount - stats.chunkCount;
+    if (orphanCount > this.config.indexing.gcOrphanThreshold) {
+      this.database.gcOrphanEmbeddings();
+      this.database.gcOrphanChunks();
+      this.database.setMetadata("lastGcTimestamp", Date.now().toString());
     }
   }
   migrateFromLegacyIndex() {
     if (!this.store || !this.database) return;
     const allMetadata = this.store.getAllMetadata();
     const chunkIds = [];
+    const chunkDataBatch = [];
     for (const { key, metadata } of allMetadata) {
       const chunkData = {
         chunkId: key,
@@ -2971,10 +3373,13 @@ var Indexer = class {
         name: metadata.name,
         language: metadata.language
       };
-      this.database.upsertChunk(chunkData);
+      chunkDataBatch.push(chunkData);
       chunkIds.push(key);
     }
-    this.database.addChunksToBranch(this.currentBranch || "default", chunkIds);
+    if (chunkDataBatch.length > 0) {
+      this.database.upsertChunksBatch(chunkDataBatch);
+    }
+    this.database.addChunksToBranchBatch(this.currentBranch || "default", chunkIds);
   }
   async ensureInitialized() {
     if (!this.store || !this.provider || !this.invertedIndex || !this.detectedProvider || !this.database) {
@@ -3000,6 +3405,8 @@ var Indexer = class {
   }
   async index(onProgress) {
     const { store, provider, invertedIndex, database, detectedProvider } = await this.ensureInitialized();
+    this.logger.recordIndexingStart();
+    this.logger.info("Starting indexing", { projectRoot: this.projectRoot });
     const startTime = Date.now();
     const stats = {
       totalFiles: 0,
@@ -3029,6 +3436,11 @@ var Indexer = class {
     );
     stats.totalFiles = files.length;
     stats.skippedFiles = skipped;
+    this.logger.recordFilesScanned(files.length);
+    this.logger.cache("debug", "Scanning files for changes", {
+      totalFiles: files.length,
+      skippedFiles: skipped.length
+    });
     const changedFiles = [];
     const unchangedFilePaths = /* @__PURE__ */ new Set();
     const currentFileHashes = /* @__PURE__ */ new Map();
@@ -3037,11 +3449,17 @@ var Indexer = class {
       currentFileHashes.set(f.path, currentHash);
       if (this.fileHashCache.get(f.path) === currentHash) {
         unchangedFilePaths.add(f.path);
+        this.logger.recordCacheHit();
       } else {
         const content = await fsPromises2.readFile(f.path, "utf-8");
         changedFiles.push({ path: f.path, content, hash: currentHash });
+        this.logger.recordCacheMiss();
       }
     }
+    this.logger.cache("info", "File hash cache results", {
+      unchanged: unchangedFilePaths.size,
+      changed: changedFiles.length
+    });
     onProgress?.({
       phase: "parsing",
       filesProcessed: 0,
@@ -3049,7 +3467,12 @@ var Indexer = class {
       chunksProcessed: 0,
       totalChunks: 0
     });
+    const parseStartTime = performance2.now();
     const parsedFiles = parseFiles(changedFiles);
+    const parseMs = performance2.now() - parseStartTime;
+    this.logger.recordFilesParsed(parsedFiles.length);
+    this.logger.recordParseDuration(parseMs);
+    this.logger.debug("Parsed changed files", { parsedCount: parsedFiles.length, parseMs: parseMs.toFixed(2) });
     const existingChunks = /* @__PURE__ */ new Map();
     const existingChunksByFile = /* @__PURE__ */ new Map();
     for (const { key, metadata } of store.getAllMetadata()) {
@@ -3070,6 +3493,7 @@ var Indexer = class {
         }
       }
     }
+    const chunkDataBatch = [];
     for (const parsed of parsedFiles) {
       currentFilePaths.add(parsed.path);
       if (parsed.chunks.length === 0) {
@@ -3097,7 +3521,7 @@ var Indexer = class {
           name: chunk.name,
           language: chunk.language
         };
-        database.upsertChunk(chunkData);
+        chunkDataBatch.push(chunkData);
         if (existingChunks.get(id) === contentHash) {
           fileChunkCount++;
           continue;
@@ -3116,6 +3540,9 @@ var Indexer = class {
         fileChunkCount++;
       }
     }
+    if (chunkDataBatch.length > 0) {
+      database.upsertChunksBatch(chunkDataBatch);
+    }
     let removedCount = 0;
     for (const [chunkId] of existingChunks) {
       if (!currentChunkIds.has(chunkId)) {
@@ -3127,9 +3554,16 @@ var Indexer = class {
     stats.totalChunks = pendingChunks.length;
     stats.existingChunks = currentChunkIds.size - pendingChunks.length;
     stats.removedChunks = removedCount;
+    this.logger.recordChunksProcessed(currentChunkIds.size);
+    this.logger.recordChunksRemoved(removedCount);
+    this.logger.info("Chunk analysis complete", {
+      pending: pendingChunks.length,
+      existing: stats.existingChunks,
+      removed: removedCount
+    });
     if (pendingChunks.length === 0 && removedCount === 0) {
       database.clearBranch(this.currentBranch);
-      database.addChunksToBranch(this.currentBranch, Array.from(currentChunkIds));
+      database.addChunksToBranchBatch(this.currentBranch, Array.from(currentChunkIds));
       this.fileHashCache = currentFileHashes;
       this.saveFileHashCache();
       stats.durationMs = Date.now() - startTime;
@@ -3144,7 +3578,7 @@ var Indexer = class {
     }
     if (pendingChunks.length === 0) {
       database.clearBranch(this.currentBranch);
-      database.addChunksToBranch(this.currentBranch, Array.from(currentChunkIds));
+      database.addChunksToBranchBatch(this.currentBranch, Array.from(currentChunkIds));
       store.save();
       invertedIndex.save();
       this.fileHashCache = currentFileHashes;
@@ -3170,6 +3604,11 @@ var Indexer = class {
     const missingHashes = new Set(database.getMissingEmbeddings(allContentHashes));
     const chunksNeedingEmbedding = pendingChunks.filter((c) => missingHashes.has(c.contentHash));
     const chunksWithExistingEmbedding = pendingChunks.filter((c) => !missingHashes.has(c.contentHash));
+    this.logger.cache("info", "Embedding cache lookup", {
+      needsEmbedding: chunksNeedingEmbedding.length,
+      fromCache: chunksWithExistingEmbedding.length
+    });
+    this.logger.recordChunksFromCache(chunksWithExistingEmbedding.length);
     for (const chunk of chunksWithExistingEmbedding) {
       const embeddingBuffer = database.getEmbedding(chunk.contentHash);
       if (embeddingBuffer) {
@@ -3208,13 +3647,16 @@ var Indexer = class {
                 const message = getErrorMessage(error);
                 if (isRateLimitError(error)) {
                   rateLimitBackoffMs = Math.min(providerRateLimits.maxRetryMs, (rateLimitBackoffMs || providerRateLimits.minRetryMs) * 2);
-                  console.error(
-                    `Rate limited (attempt ${error.attemptNumber}/${error.retriesLeft + error.attemptNumber}): waiting ${rateLimitBackoffMs / 1e3}s before retry...`
-                  );
+                  this.logger.embedding("warn", `Rate limited, backing off`, {
+                    attempt: error.attemptNumber,
+                    retriesLeft: error.retriesLeft,
+                    backoffMs: rateLimitBackoffMs
+                  });
                 } else {
-                  console.error(
-                    `Embedding batch failed (attempt ${error.attemptNumber}): ${message}`
-                  );
+                  this.logger.embedding("error", `Embedding batch failed`, {
+                    attempt: error.attemptNumber,
+                    error: message
+                  });
                 }
               }
             }
@@ -3228,20 +3670,25 @@ var Indexer = class {
             metadata: chunk.metadata
           }));
           store.addBatch(items);
-          for (let i = 0; i < batch.length; i++) {
-            const chunk = batch[i];
-            const embedding = result.embeddings[i];
-            database.upsertEmbedding(
-              chunk.contentHash,
-              float32ArrayToBuffer(embedding),
-              chunk.text,
-              detectedProvider.modelInfo.model
-            );
+          const embeddingBatchItems = batch.map((chunk, i) => ({
+            contentHash: chunk.contentHash,
+            embedding: float32ArrayToBuffer(result.embeddings[i]),
+            chunkText: chunk.text,
+            model: detectedProvider.modelInfo.model
+          }));
+          database.upsertEmbeddingsBatch(embeddingBatchItems);
+          for (const chunk of batch) {
             invertedIndex.removeChunk(chunk.id);
             invertedIndex.addChunk(chunk.id, chunk.content);
           }
           stats.indexedChunks += batch.length;
           stats.tokensUsed += result.totalTokensUsed;
+          this.logger.recordChunksEmbedded(batch.length);
+          this.logger.recordEmbeddingApiCall(result.totalTokensUsed);
+          this.logger.embedding("debug", `Embedded batch`, {
+            batchSize: batch.length,
+            tokens: result.totalTokensUsed
+          });
           onProgress?.({
             phase: "embedding",
             filesProcessed: files.length,
@@ -3252,7 +3699,11 @@ var Indexer = class {
         } catch (error) {
           stats.failedChunks += batch.length;
           this.addFailedBatch(batch, getErrorMessage(error));
-          console.error(`Failed to embed batch after retries: ${getErrorMessage(error)}`);
+          this.logger.recordEmbeddingError();
+          this.logger.embedding("error", `Failed to embed batch after retries`, {
+            batchSize: batch.length,
+            error: getErrorMessage(error)
+          });
         }
       });
     }
@@ -3265,12 +3716,25 @@ var Indexer = class {
       totalChunks: pendingChunks.length
     });
     database.clearBranch(this.currentBranch);
-    database.addChunksToBranch(this.currentBranch, Array.from(currentChunkIds));
+    database.addChunksToBranchBatch(this.currentBranch, Array.from(currentChunkIds));
     store.save();
     invertedIndex.save();
     this.fileHashCache = currentFileHashes;
     this.saveFileHashCache();
+    if (this.config.indexing.autoGc && stats.removedChunks > 0) {
+      await this.maybeRunOrphanGc();
+    }
     stats.durationMs = Date.now() - startTime;
+    this.logger.recordIndexingEnd();
+    this.logger.info("Indexing complete", {
+      files: stats.totalFiles,
+      indexed: stats.indexedChunks,
+      existing: stats.existingChunks,
+      removed: stats.removedChunks,
+      failed: stats.failedChunks,
+      tokens: stats.tokensUsed,
+      durationMs: stats.durationMs
+    });
     if (stats.failedChunks > 0) {
       stats.failedBatchesPath = this.failedBatchesPath;
     }
@@ -3283,18 +3747,96 @@ var Indexer = class {
     });
     return stats;
   }
+  async getQueryEmbedding(query, provider) {
+    const now = Date.now();
+    const cached = this.queryEmbeddingCache.get(query);
+    if (cached && now - cached.timestamp < this.queryCacheTtlMs) {
+      this.logger.cache("debug", "Query embedding cache hit (exact)", { query: query.slice(0, 50) });
+      this.logger.recordQueryCacheHit();
+      return cached.embedding;
+    }
+    const similarMatch = this.findSimilarCachedQuery(query, now);
+    if (similarMatch) {
+      this.logger.cache("debug", "Query embedding cache hit (similar)", {
+        query: query.slice(0, 50),
+        similarTo: similarMatch.key.slice(0, 50),
+        similarity: similarMatch.similarity.toFixed(3)
+      });
+      this.logger.recordQueryCacheSimilarHit();
+      return similarMatch.embedding;
+    }
+    this.logger.cache("debug", "Query embedding cache miss", { query: query.slice(0, 50) });
+    this.logger.recordQueryCacheMiss();
+    const { embedding, tokensUsed } = await provider.embed(query);
+    this.logger.recordEmbeddingApiCall(tokensUsed);
+    if (this.queryEmbeddingCache.size >= this.maxQueryCacheSize) {
+      const oldestKey = this.queryEmbeddingCache.keys().next().value;
+      if (oldestKey) {
+        this.queryEmbeddingCache.delete(oldestKey);
+      }
+    }
+    this.queryEmbeddingCache.set(query, { embedding, timestamp: now });
+    return embedding;
+  }
+  findSimilarCachedQuery(query, now) {
+    const queryTokens = this.tokenize(query);
+    if (queryTokens.size === 0) return null;
+    let bestMatch = null;
+    for (const [cachedQuery, { embedding, timestamp }] of this.queryEmbeddingCache) {
+      if (now - timestamp >= this.queryCacheTtlMs) continue;
+      const cachedTokens = this.tokenize(cachedQuery);
+      const similarity = this.jaccardSimilarity(queryTokens, cachedTokens);
+      if (similarity >= this.querySimilarityThreshold) {
+        if (!bestMatch || similarity > bestMatch.similarity) {
+          bestMatch = { key: cachedQuery, embedding, similarity };
+        }
+      }
+    }
+    return bestMatch;
+  }
+  tokenize(text) {
+    return new Set(
+      text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((t) => t.length > 1)
+    );
+  }
+  jaccardSimilarity(a, b) {
+    if (a.size === 0 && b.size === 0) return 1;
+    if (a.size === 0 || b.size === 0) return 0;
+    let intersection = 0;
+    for (const token of a) {
+      if (b.has(token)) intersection++;
+    }
+    const union = a.size + b.size - intersection;
+    return intersection / union;
+  }
   async search(query, limit, options) {
+    const searchStartTime = performance2.now();
     const { store, provider, database } = await this.ensureInitialized();
     if (store.count() === 0) {
+      this.logger.search("debug", "Search on empty index", { query });
       return [];
     }
     const maxResults = limit ?? this.config.search.maxResults;
     const hybridWeight = options?.hybridWeight ?? this.config.search.hybridWeight;
     const filterByBranch = options?.filterByBranch ?? true;
-    const { embedding } = await provider.embed(query);
+    this.logger.search("debug", "Starting search", {
+      query,
+      maxResults,
+      hybridWeight,
+      filterByBranch
+    });
+    const embeddingStartTime = performance2.now();
+    const embedding = await this.getQueryEmbedding(query, provider);
+    const embeddingMs = performance2.now() - embeddingStartTime;
+    const vectorStartTime = performance2.now();
     const semanticResults = store.search(embedding, maxResults * 4);
+    const vectorMs = performance2.now() - vectorStartTime;
+    const keywordStartTime = performance2.now();
     const keywordResults = await this.keywordSearch(query, maxResults * 4);
+    const keywordMs = performance2.now() - keywordStartTime;
+    const fusionStartTime = performance2.now();
     const combined = this.fuseResults(semanticResults, keywordResults, hybridWeight, maxResults * 4);
+    const fusionMs = performance2.now() - fusionStartTime;
     let branchChunkIds = null;
     if (filterByBranch && this.currentBranch !== "default") {
       branchChunkIds = new Set(database.getBranchChunkIds(this.currentBranch));
@@ -3315,6 +3857,22 @@ var Indexer = class {
       }
       return true;
     }).slice(0, maxResults);
+    const totalSearchMs = performance2.now() - searchStartTime;
+    this.logger.recordSearch(totalSearchMs, {
+      embeddingMs,
+      vectorMs,
+      keywordMs,
+      fusionMs
+    });
+    this.logger.search("info", "Search complete", {
+      query,
+      results: filtered.length,
+      totalMs: Math.round(totalSearchMs * 100) / 100,
+      embeddingMs: Math.round(embeddingMs * 100) / 100,
+      vectorMs: Math.round(vectorMs * 100) / 100,
+      keywordMs: Math.round(keywordMs * 100) / 100,
+      fusionMs: Math.round(fusionMs * 100) / 100
+    });
     return Promise.all(
       filtered.map(async (r) => {
         let content = "";
@@ -3353,11 +3911,8 @@ var Indexer = class {
     if (scores.size === 0) {
       return [];
     }
-    const allMetadata = store.getAllMetadata();
-    const metadataMap = /* @__PURE__ */ new Map();
-    for (const { key, metadata } of allMetadata) {
-      metadataMap.set(key, metadata);
-    }
+    const chunkIds = Array.from(scores.keys());
+    const metadataMap = store.getMetadataBatch(chunkIds);
     const results = [];
     for (const [chunkId, score] of scores) {
       const metadata = metadataMap.get(chunkId);
@@ -3409,14 +3964,18 @@ var Indexer = class {
     };
   }
   async clearIndex() {
-    const { store, invertedIndex } = await this.ensureInitialized();
+    const { store, invertedIndex, database } = await this.ensureInitialized();
     store.clear();
     store.save();
     invertedIndex.clear();
     invertedIndex.save();
+    this.fileHashCache.clear();
+    this.saveFileHashCache();
+    database.clearBranch(this.currentBranch);
   }
   async healthCheck() {
     const { store, invertedIndex, database } = await this.ensureInitialized();
+    this.logger.gc("info", "Starting health check");
     const allMetadata = store.getAllMetadata();
     const filePathsToChunkKeys = /* @__PURE__ */ new Map();
     for (const { key, metadata } of allMetadata) {
@@ -3443,6 +4002,13 @@ var Indexer = class {
     }
     const gcOrphanEmbeddings = database.gcOrphanEmbeddings();
     const gcOrphanChunks = database.gcOrphanChunks();
+    this.logger.recordGc(removedCount, gcOrphanChunks, gcOrphanEmbeddings);
+    this.logger.gc("info", "Health check complete", {
+      removedStale: removedCount,
+      orphanEmbeddings: gcOrphanEmbeddings,
+      orphanChunks: gcOrphanChunks,
+      removedFiles: removedFilePaths.length
+    });
     return { removed: removedCount, filePaths: removedFilePaths, gcOrphanEmbeddings, gcOrphanChunks };
   }
   async retryFailedBatches() {
@@ -3476,9 +4042,12 @@ var Indexer = class {
           invertedIndex.removeChunk(chunk.id);
           invertedIndex.addChunk(chunk.id, chunk.content);
         }
+        this.logger.recordChunksEmbedded(batch.chunks.length);
+        this.logger.recordEmbeddingApiCall(result.totalTokensUsed);
         succeeded += batch.chunks.length;
       } catch (error) {
         failed += batch.chunks.length;
+        this.logger.recordEmbeddingError();
         stillFailing.push({
           ...batch,
           attemptCount: batch.attemptCount + 1,
@@ -3513,6 +4082,9 @@ var Indexer = class {
     const { database } = await this.ensureInitialized();
     return database.getStats();
   }
+  getLogger() {
+    return this.logger;
+  }
 };
 
 // node_modules/chokidar/index.js
@@ -3605,7 +4177,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path8) => statMethod(path8, { bigint: true });
+      this._stat = (path9) => statMethod(path9, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -3630,8 +4202,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path8, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path8));
+          const { path: path9, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path9));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -3671,21 +4243,21 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path8, depth) {
+  async _exploreDir(path9, depth) {
     let files;
     try {
-      files = await readdir(path8, this._rdOptions);
+      files = await readdir(path9, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path8 };
+    return { files, depth, path: path9 };
   }
-  async _formatEntry(dirent, path8) {
+  async _formatEntry(dirent, path9) {
     let entry;
-    const basename3 = this._isDirent ? dirent.name : dirent;
+    const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path8, basename3));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
+      const fullPath = presolve(pjoin(path9, basename4));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -4084,16 +4656,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path8, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path9, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path8);
-    emitRaw(rawEvent, evPath, { watchedPath: path8 });
-    if (evPath && path8 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path8, evPath), KEY_LISTENERS, sp.join(path8, evPath));
+    listener(path9);
+    emitRaw(rawEvent, evPath, { watchedPath: path9 });
+    if (evPath && path9 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path9, evPath), KEY_LISTENERS, sp.join(path9, evPath));
     }
   };
   try {
-    return fs_watch(path8, {
+    return fs_watch(path9, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -4109,12 +4681,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path8, fullPath, options, handlers) => {
+var setFsWatchListener = (path9, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path8, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path9, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -4125,7 +4697,7 @@ var setFsWatchListener = (path8, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path8,
+      path9,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -4140,7 +4712,7 @@ var setFsWatchListener = (path8, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path8, "r");
+          const fd = await open(path9, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -4171,7 +4743,7 @@ var setFsWatchListener = (path8, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path8, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path9, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -4193,7 +4765,7 @@ var setFsWatchFileListener = (path8, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path8, curr));
+          foreach(cont.listeners, (listener2) => listener2(path9, curr));
         }
       })
     };
@@ -4223,13 +4795,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path8, listener) {
+  _watchWithNodeFs(path9, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path8);
-    const basename3 = sp.basename(path8);
+    const directory = sp.dirname(path9);
+    const basename4 = sp.basename(path9);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename3);
-    const absolutePath = sp.resolve(path8);
+    parent.add(basename4);
+    const absolutePath = sp.resolve(path9);
     const options = {
       persistent: opts.persistent
     };
@@ -4238,13 +4810,13 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path8, absolutePath, options, {
+      options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path9, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path8, absolutePath, options, {
+      closer = setFsWatchListener(path9, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -4260,13 +4832,13 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname4 = sp.dirname(file);
-    const basename3 = sp.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname4);
+    const dirname5 = sp.dirname(file);
+    const basename4 = sp.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname5);
     let prevStats = stats;
-    if (parent.has(basename3))
+    if (parent.has(basename4))
       return;
-    const listener = async (path8, newStats) => {
+    const listener = async (path9, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -4280,18 +4852,18 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path8);
+            this.fsw._closeFile(path9);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path8, closer2);
+              this.fsw._addPathCloser(path9, closer2);
           } else {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname4, basename3);
+          this.fsw._remove(dirname5, basename4);
         }
-      } else if (parent.has(basename3)) {
+      } else if (parent.has(basename4)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -4316,7 +4888,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path8, item) {
+  async _handleSymlink(entry, directory, path9, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -4326,7 +4898,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path8);
+        linkPath = await fsrealpath(path9);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -4336,12 +4908,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path8, entry.stats);
+          this.fsw._emit(EV.CHANGE, path9, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path8, entry.stats);
+        this.fsw._emit(EV.ADD, path9, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -4371,9 +4943,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path8 = sp.join(directory, item);
+      let path9 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path8, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path9, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -4382,8 +4954,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path8 = sp.join(dir, sp.relative(dir, path8));
-        this._addToNodeFs(path8, initialAdd, wh, depth + 1);
+        path9 = sp.join(dir, sp.relative(dir, path9));
+        this._addToNodeFs(path9, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve4, reject) => {
@@ -4452,13 +5024,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path8, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path9, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path8) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path9) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path8);
+    const wh = this.fsw._getWatchHelpers(path9);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -4474,8 +5046,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path8);
-        const targetPath = follow ? await fsrealpath(path8) : path8;
+        const absPath = sp.resolve(path9);
+        const targetPath = follow ? await fsrealpath(path9) : path9;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -4485,29 +5057,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path8) : path8;
+        const targetPath = follow ? await fsrealpath(path9) : path9;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path8, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path9, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path8), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path9), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path8, closer);
+        this.fsw._addPathCloser(path9, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path8;
+        return path9;
       }
     }
   }
@@ -4550,24 +5122,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path8) {
-  if (typeof path8 !== "string")
+function normalizePath(path9) {
+  if (typeof path9 !== "string")
     throw new Error("string expected");
-  path8 = sp2.normalize(path8);
-  path8 = path8.replace(/\\/g, "/");
+  path9 = sp2.normalize(path9);
+  path9 = path9.replace(/\\/g, "/");
   let prepend = false;
-  if (path8.startsWith("//"))
+  if (path9.startsWith("//"))
     prepend = true;
-  path8 = path8.replace(DOUBLE_SLASH_RE, "/");
+  path9 = path9.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path8 = "/" + path8;
-  return path8;
+    path9 = "/" + path9;
+  return path9;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path8 = normalizePath(testString);
+  const path9 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path8, stats)) {
+    if (pattern(path9, stats)) {
       return true;
     }
   }
@@ -4605,19 +5177,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path8) => toUnix(sp2.normalize(toUnix(path8)));
-var normalizeIgnored = (cwd = "") => (path8) => {
-  if (typeof path8 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path8) ? path8 : sp2.join(cwd, path8));
+var normalizePathToUnix = (path9) => toUnix(sp2.normalize(toUnix(path9)));
+var normalizeIgnored = (cwd = "") => (path9) => {
+  if (typeof path9 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path9) ? path9 : sp2.join(cwd, path9));
   } else {
-    return path8;
+    return path9;
   }
 };
-var getAbsolutePath = (path8, cwd) => {
-  if (sp2.isAbsolute(path8)) {
-    return path8;
+var getAbsolutePath = (path9, cwd) => {
+  if (sp2.isAbsolute(path9)) {
+    return path9;
   }
-  return sp2.join(cwd, path8);
+  return sp2.join(cwd, path9);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -4682,10 +5254,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path8, follow, fsw) {
+  constructor(path9, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path8;
-    this.path = path8 = path8.replace(REPLACER_RE, "");
+    const watchPath = path9;
+    this.path = path9 = path9.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -4825,20 +5397,20 @@ var FSWatcher = class extends EventEmitter2 {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path8) => {
-        const absPath = getAbsolutePath(path8, cwd);
+      paths = paths.map((path9) => {
+        const absPath = getAbsolutePath(path9, cwd);
         return absPath;
       });
     }
-    paths.forEach((path8) => {
-      this._removeIgnoredPath(path8);
+    paths.forEach((path9) => {
+      this._removeIgnoredPath(path9);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path8) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path8, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path9) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path9, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -4860,17 +5432,17 @@ var FSWatcher = class extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path8) => {
-      if (!sp2.isAbsolute(path8) && !this._closers.has(path8)) {
+    paths.forEach((path9) => {
+      if (!sp2.isAbsolute(path9) && !this._closers.has(path9)) {
         if (cwd)
-          path8 = sp2.join(cwd, path8);
-        path8 = sp2.resolve(path8);
+          path9 = sp2.join(cwd, path9);
+        path9 = sp2.resolve(path9);
       }
-      this._closePath(path8);
-      this._addIgnoredPath(path8);
-      if (this._watched.has(path8)) {
+      this._closePath(path9);
+      this._addIgnoredPath(path9);
+      if (this._watched.has(path9)) {
         this._addIgnoredPath({
-          path: path8,
+          path: path9,
           recursive: true
         });
       }
@@ -4934,38 +5506,38 @@ var FSWatcher = class extends EventEmitter2 {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path8, stats) {
+  async _emit(event, path9, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path8 = sp2.normalize(path8);
+      path9 = sp2.normalize(path9);
     if (opts.cwd)
-      path8 = sp2.relative(opts.cwd, path8);
-    const args = [path8];
+      path9 = sp2.relative(opts.cwd, path9);
+    const args = [path9];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path8))) {
+    if (awf && (pw = this._pendingWrites.get(path9))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path8, [event, ...args]);
+        this._pendingUnlinks.set(path9, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path9) => {
+          this._pendingUnlinks.forEach((entry, path10) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path9);
+            this._pendingUnlinks.delete(path10);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path8)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path9)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path8);
+        this._pendingUnlinks.delete(path9);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -4983,16 +5555,16 @@ var FSWatcher = class extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path8, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path9, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path8, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path9, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path8) : path8;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path9) : path9;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -5023,23 +5595,23 @@ var FSWatcher = class extends EventEmitter2 {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path8, timeout) {
+  _throttle(actionType, path9, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path8);
+    const actionPath = action.get(path9);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path8);
+      const item = action.get(path9);
       const count = item ? item.count : 0;
-      action.delete(path8);
+      action.delete(path9);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -5047,7 +5619,7 @@ var FSWatcher = class extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path8, thr);
+    action.set(path9, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -5061,44 +5633,44 @@ var FSWatcher = class extends EventEmitter2 {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path8, threshold, event, awfEmit) {
+  _awaitWriteFinish(path9, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path8;
-    if (this.options.cwd && !sp2.isAbsolute(path8)) {
-      fullPath = sp2.join(this.options.cwd, path8);
+    let fullPath = path9;
+    if (this.options.cwd && !sp2.isAbsolute(path9)) {
+      fullPath = sp2.join(this.options.cwd, path9);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path8)) {
+        if (err || !writes.has(path9)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path8).lastChange = now2;
+          writes.get(path9).lastChange = now2;
         }
-        const pw = writes.get(path8);
+        const pw = writes.get(path9);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path8);
+          writes.delete(path9);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path8)) {
-      writes.set(path8, {
+    if (!writes.has(path9)) {
+      writes.set(path9, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path8);
+          writes.delete(path9);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -5109,8 +5681,8 @@ var FSWatcher = class extends EventEmitter2 {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path8, stats) {
-    if (this.options.atomic && DOT_RE.test(path8))
+  _isIgnored(path9, stats) {
+    if (this.options.atomic && DOT_RE.test(path9))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -5120,17 +5692,17 @@ var FSWatcher = class extends EventEmitter2 {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path8, stats);
+    return this._userIgnored(path9, stats);
   }
-  _isntIgnored(path8, stat4) {
-    return !this._isIgnored(path8, stat4);
+  _isntIgnored(path9, stat4) {
+    return !this._isIgnored(path9, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path8) {
-    return new WatchHelper(path8, this.options.followSymlinks, this);
+  _getWatchHelpers(path9) {
+    return new WatchHelper(path9, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -5162,63 +5734,63 @@ var FSWatcher = class extends EventEmitter2 {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path8 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path8);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path8) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path8, 100))
+    const path9 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path9);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path9) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path9, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path8);
+    const wp = this._getWatchedDir(path9);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path8, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path9, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path8;
+    let relPath = path9;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path8);
+      relPath = sp2.relative(this.options.cwd, path9);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path8);
+    this._watched.delete(path9);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path8))
-      this._emit(eventName, path8);
-    this._closePath(path8);
+    if (wasTracked && !this._isIgnored(path9))
+      this._emit(eventName, path9);
+    this._closePath(path9);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path8) {
-    this._closeFile(path8);
-    const dir = sp2.dirname(path8);
-    this._getWatchedDir(dir).remove(sp2.basename(path8));
+  _closePath(path9) {
+    this._closeFile(path9);
+    const dir = sp2.dirname(path9);
+    this._getWatchedDir(dir).remove(sp2.basename(path9));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path8) {
-    const closers = this._closers.get(path8);
+  _closeFile(path9) {
+    const closers = this._closers.get(path9);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path8);
+    this._closers.delete(path9);
   }
-  _addPathCloser(path8, closer) {
+  _addPathCloser(path9, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path8);
+    let list = this._closers.get(path9);
     if (!list) {
       list = [];
-      this._closers.set(path8, list);
+      this._closers.set(path9, list);
     }
     list.push(closer);
   }
@@ -5313,7 +5885,7 @@ var FileWatcher = class {
       return;
     }
     const changes = Array.from(this.pendingChanges.entries()).map(
-      ([path8, type]) => ({ path: path8, type })
+      ([path9, type]) => ({ path: path9, type })
     );
     this.pendingChanges.clear();
     try {
@@ -5493,7 +6065,7 @@ var index_codebase = tool({
     estimateOnly: z.boolean().optional().default(false).describe("Only show cost estimate without indexing"),
     verbose: z.boolean().optional().default(false).describe("Show detailed info about skipped files and parsing failures")
   },
-  async execute(args) {
+  async execute(args, context) {
     const indexer = getIndexer();
     if (args.estimateOnly) {
       const estimate = await indexer.estimateCost();
@@ -5502,7 +6074,19 @@ var index_codebase = tool({
     if (args.force) {
       await indexer.clearIndex();
     }
-    const stats = await indexer.index();
+    const stats = await indexer.index((progress) => {
+      context.metadata({
+        title: formatProgressTitle(progress),
+        metadata: {
+          phase: progress.phase,
+          filesProcessed: progress.filesProcessed,
+          totalFiles: progress.totalFiles,
+          chunksProcessed: progress.chunksProcessed,
+          totalChunks: progress.totalChunks,
+          percentage: calculatePercentage(progress)
+        }
+      });
+    });
     return formatIndexStats(stats, args.verbose ?? false);
   }
 });
@@ -5540,6 +6124,51 @@ var index_health_check = tool({
     return lines.join("\n");
   }
 });
+var index_metrics = tool({
+  description: "Get metrics and performance statistics for the codebase index. Shows indexing stats, search timings, cache hit rates, and API usage. Requires debug.enabled=true and debug.metrics=true in config.",
+  args: {},
+  async execute() {
+    const indexer = getIndexer();
+    const logger = indexer.getLogger();
+    if (!logger.isEnabled()) {
+      return 'Debug mode is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true,\n    "metrics": true\n  }\n}\n```';
+    }
+    if (!logger.isMetricsEnabled()) {
+      return 'Metrics collection is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true,\n    "metrics": true\n  }\n}\n```';
+    }
+    return logger.formatMetrics();
+  }
+});
+var index_logs = tool({
+  description: "Get recent debug logs from the codebase indexer. Shows timestamped log entries with level and category. Requires debug.enabled=true in config.",
+  args: {
+    limit: z.number().optional().default(20).describe("Maximum number of log entries to return"),
+    category: z.enum(["search", "embedding", "cache", "gc", "branch", "general"]).optional().describe("Filter by log category"),
+    level: z.enum(["error", "warn", "info", "debug"]).optional().describe("Filter by minimum log level")
+  },
+  async execute(args) {
+    const indexer = getIndexer();
+    const logger = indexer.getLogger();
+    if (!logger.isEnabled()) {
+      return 'Debug mode is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true\n  }\n}\n```';
+    }
+    let logs;
+    if (args.category) {
+      logs = logger.getLogsByCategory(args.category, args.limit);
+    } else if (args.level) {
+      logs = logger.getLogsByLevel(args.level, args.limit);
+    } else {
+      logs = logger.getLogs(args.limit);
+    }
+    if (logs.length === 0) {
+      return "No logs recorded yet. Logs are captured during indexing and search operations.";
+    }
+    return logs.map((l) => {
+      const dataStr = l.data ? ` ${JSON.stringify(l.data)}` : "";
+      return `[${l.timestamp}] [${l.level.toUpperCase()}] [${l.category}] ${l.message}${dataStr}`;
+    }).join("\n");
+  }
+});
 function formatIndexStats(stats, verbose = false) {
   const lines = [];
   if (stats.indexedChunks === 0 && stats.removedChunks === 0) {
@@ -5601,12 +6230,90 @@ function formatStatus(status) {
   }
   return lines.join("\n");
 }
+function formatProgressTitle(progress) {
+  switch (progress.phase) {
+    case "scanning":
+      return "Scanning files...";
+    case "parsing":
+      return `Parsing: ${progress.filesProcessed}/${progress.totalFiles} files`;
+    case "embedding":
+      return `Embedding: ${progress.chunksProcessed}/${progress.totalChunks} chunks`;
+    case "storing":
+      return "Storing index...";
+    case "complete":
+      return "Indexing complete";
+    default:
+      return "Indexing...";
+  }
+}
+function calculatePercentage(progress) {
+  if (progress.phase === "scanning") return 0;
+  if (progress.phase === "complete") return 100;
+  if (progress.phase === "parsing") {
+    if (progress.totalFiles === 0) return 5;
+    return Math.round(5 + progress.filesProcessed / progress.totalFiles * 15);
+  }
+  if (progress.phase === "embedding") {
+    if (progress.totalChunks === 0) return 20;
+    return Math.round(20 + progress.chunksProcessed / progress.totalChunks * 70);
+  }
+  if (progress.phase === "storing") return 95;
+  return 0;
+}
+
+// src/commands/loader.ts
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
+import * as path7 from "path";
+function parseFrontmatter(content) {
+  const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return { frontmatter: {}, body: content.trim() };
+  }
+  const frontmatterLines = match[1].split("\n");
+  const frontmatter = {};
+  for (const line of frontmatterLines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      const value = line.slice(colonIndex + 1).trim();
+      frontmatter[key] = value;
+    }
+  }
+  return { frontmatter, body: match[2].trim() };
+}
+function loadCommandsFromDirectory(commandsDir) {
+  const commands = /* @__PURE__ */ new Map();
+  if (!existsSync5(commandsDir)) {
+    return commands;
+  }
+  const files = readdirSync2(commandsDir).filter((f) => f.endsWith(".md"));
+  for (const file of files) {
+    const filePath = path7.join(commandsDir, file);
+    const content = readFileSync5(filePath, "utf-8");
+    const { frontmatter, body } = parseFrontmatter(content);
+    const name = path7.basename(file, ".md");
+    const description = frontmatter.description || `Run the ${name} command`;
+    commands.set(name, {
+      description,
+      template: body
+    });
+  }
+  return commands;
+}
 
 // src/index.ts
+function getCommandsDir() {
+  let currentDir = process.cwd();
+  if (typeof import.meta !== "undefined" && import.meta.url) {
+    currentDir = path8.dirname(fileURLToPath2(import.meta.url));
+  }
+  return path8.join(currentDir, "..", "commands");
+}
 function loadJsonFile(filePath) {
   try {
-    if (existsSync5(filePath)) {
-      const content = readFileSync5(filePath, "utf-8");
+    if (existsSync6(filePath)) {
+      const content = readFileSync6(filePath, "utf-8");
       return JSON.parse(content);
     }
   } catch {
@@ -5614,11 +6321,11 @@ function loadJsonFile(filePath) {
   return null;
 }
 function loadPluginConfig(projectRoot) {
-  const projectConfig = loadJsonFile(path7.join(projectRoot, ".opencode", "codebase-index.json"));
+  const projectConfig = loadJsonFile(path8.join(projectRoot, ".opencode", "codebase-index.json"));
   if (projectConfig) {
     return projectConfig;
   }
-  const globalConfigPath = path7.join(os3.homedir(), ".config", "opencode", "codebase-index.json");
+  const globalConfigPath = path8.join(os3.homedir(), ".config", "opencode", "codebase-index.json");
   const globalConfig = loadJsonFile(globalConfigPath);
   if (globalConfig) {
     return globalConfig;
@@ -5646,40 +6353,17 @@ var plugin = async ({ directory }) => {
       codebase_search,
       index_codebase,
       index_status,
-      index_health_check
+      index_health_check,
+      index_metrics,
+      index_logs
     },
     async config(cfg) {
       cfg.command = cfg.command ?? {};
-      cfg.command["search"] = {
-        description: "Search codebase by meaning using semantic search",
-        template: `Use the \`codebase_search\` tool to find code related to: $ARGUMENTS
-
-If the index doesn't exist yet, run \`index_codebase\` first.
-
-Return the most relevant results with file paths and line numbers.`
-      };
-      cfg.command["find"] = {
-        description: "Find code using hybrid approach (semantic + grep)",
-        template: `Find code related to: $ARGUMENTS
-
-Strategy:
-1. First use \`codebase_search\` to find semantically related code
-2. From the results, identify specific function/class names
-3. Use grep to find all occurrences of those identifiers
-4. Combine findings into a comprehensive answer
-
-If the semantic index doesn't exist, run \`index_codebase\` first.`
-      };
-      cfg.command["index"] = {
-        description: "Index the codebase for semantic search",
-        template: `Run the \`index_codebase\` tool to create or update the semantic search index.
-
-Show progress and final statistics including:
-- Number of files processed
-- Number of chunks indexed
-- Tokens used
-- Duration`
-      };
+      const commandsDir = getCommandsDir();
+      const commands = loadCommandsFromDirectory(commandsDir);
+      for (const [name, definition] of commands) {
+        cfg.command[name] = definition;
+      }
     }
   };
 };