opencode-codebase-index 0.13.1 → 0.14.0

package/dist/index.cjs

@@ -495,7 +495,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(path22, checkUnignored, mode) {
+      test(path23, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -504,7 +504,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path22);
+          const matched = rule[mode].test(path23);
           if (!matched) {
             return;
           }
@@ -525,17 +525,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path22, originalPath, doThrow) => {
-      if (!isString(path22)) {
+    var checkPath = (path23, originalPath, doThrow) => {
+      if (!isString(path23)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path22) {
+      if (!path23) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path22)) {
+      if (checkPath.isNotRelative(path23)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -544,7 +544,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path22) => REGEX_TEST_INVALID_PATH.test(path22);
+    var isNotRelative = (path23) => REGEX_TEST_INVALID_PATH.test(path23);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -574,19 +574,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path22 = originalPath && checkPath.convert(originalPath);
+        const path23 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path22,
+          path23,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path22, cache, checkUnignored, slices);
+        return this._t(path23, cache, checkUnignored, slices);
       }
-      checkIgnore(path22) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path22)) {
-          return this.test(path22);
+      checkIgnore(path23) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path23)) {
+          return this.test(path23);
         }
-        const slices = path22.split(SLASH2).filter(Boolean);
+        const slices = path23.split(SLASH2).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -599,18 +599,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path22, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path23, false, MODE_CHECK_IGNORE);
       }
-      _t(path22, cache, checkUnignored, slices) {
-        if (path22 in cache) {
-          return cache[path22];
+      _t(path23, cache, checkUnignored, slices) {
+        if (path23 in cache) {
+          return cache[path23];
         }
         if (!slices) {
-          slices = path22.split(SLASH2).filter(Boolean);
+          slices = path23.split(SLASH2).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path22] = this._rules.test(path22, checkUnignored, MODE_IGNORE);
+          return cache[path23] = this._rules.test(path23, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH2) + SLASH2,
@@ -618,29 +618,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path22] = parent.ignored ? parent : this._rules.test(path22, checkUnignored, MODE_IGNORE);
+        return cache[path23] = parent.ignored ? parent : this._rules.test(path23, checkUnignored, MODE_IGNORE);
       }
-      ignores(path22) {
-        return this._test(path22, this._ignoreCache, false).ignored;
+      ignores(path23) {
+        return this._test(path23, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path22) => !this.ignores(path22);
+        return (path23) => !this.ignores(path23);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path22) {
-        return this._test(path22, this._testCache, true);
+      test(path23) {
+        return this._test(path23, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path22) => checkPath(path22 && checkPath.convert(path22), path22, RETURN_FALSE);
+    var isPathValid = (path23) => checkPath(path23 && checkPath.convert(path23), path23, 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 = (path22) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path22) || isNotRelative(path22);
+      checkPath.isNotRelative = (path23) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path23) || isNotRelative(path23);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -662,7 +662,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var os5 = __toESM(require("os"), 1);
-var path21 = __toESM(require("path"), 1);
+var path22 = __toESM(require("path"), 1);
 var import_url2 = require("url");
 
 // src/config/constants.ts
@@ -795,7 +795,8 @@ function getDefaultIndexingConfig() {
     requireProjectMarker: true,
     maxDepth: 5,
     maxFilesPerDirectory: 100,
-    fallbackToTextOnMaxChunks: true
+    fallbackToTextOnMaxChunks: true,
+    gitBlame: { enabled: false }
   };
 }
 function getDefaultSearchConfig() {
@@ -919,7 +920,10 @@ function parseConfig(raw) {
     requireProjectMarker: typeof rawIndexing.requireProjectMarker === "boolean" ? rawIndexing.requireProjectMarker : defaultIndexing.requireProjectMarker,
     maxDepth: typeof rawIndexing.maxDepth === "number" ? rawIndexing.maxDepth < -1 ? -1 : rawIndexing.maxDepth : defaultIndexing.maxDepth,
     maxFilesPerDirectory: typeof rawIndexing.maxFilesPerDirectory === "number" ? Math.max(1, rawIndexing.maxFilesPerDirectory) : defaultIndexing.maxFilesPerDirectory,
-    fallbackToTextOnMaxChunks: typeof rawIndexing.fallbackToTextOnMaxChunks === "boolean" ? rawIndexing.fallbackToTextOnMaxChunks : defaultIndexing.fallbackToTextOnMaxChunks
+    fallbackToTextOnMaxChunks: typeof rawIndexing.fallbackToTextOnMaxChunks === "boolean" ? rawIndexing.fallbackToTextOnMaxChunks : defaultIndexing.fallbackToTextOnMaxChunks,
+    gitBlame: {
+      enabled: rawIndexing.gitBlame && typeof rawIndexing.gitBlame === "object" && typeof rawIndexing.gitBlame.enabled === "boolean" ? rawIndexing.gitBlame.enabled : defaultIndexing.gitBlame.enabled
+    }
   };
   const rawSearch = input.search && typeof input.search === "object" ? input.search : {};
   const search = {
@@ -1589,14 +1593,14 @@ function loadMergedConfig(projectRoot, host = "opencode") {
 
 // src/tools/operations.ts
 var import_fs9 = require("fs");
-var path14 = __toESM(require("path"), 1);
+var path15 = __toESM(require("path"), 1);
 
 // src/indexer/index.ts
 var import_fs7 = require("fs");
-var path11 = __toESM(require("path"), 1);
+var path12 = __toESM(require("path"), 1);
 var import_perf_hooks = require("perf_hooks");
-var import_child_process2 = require("child_process");
-var import_util2 = require("util");
+var import_child_process3 = require("child_process");
+var import_util3 = require("util");
 
 // node_modules/eventemitter3/index.mjs
 var import_index = __toESM(require_eventemitter3(), 1);
@@ -4784,8 +4788,8 @@ function normalizeFiles(rawFiles, projectRoot) {
     const trimmed = raw.trim();
     if (!trimmed) continue;
     const absolute = path10.resolve(projectRoot, trimmed);
-    const relative10 = path10.relative(projectRoot, absolute);
-    const cleaned = relative10.startsWith("./") ? relative10.slice(2) : relative10;
+    const relative11 = path10.relative(projectRoot, absolute);
+    const cleaned = relative11.startsWith("./") ? relative11.slice(2) : relative11;
     if (!seen.has(cleaned)) {
       seen.add(cleaned);
       result.push(cleaned);
@@ -4794,8 +4798,61 @@ function normalizeFiles(rawFiles, projectRoot) {
   return result;
 }
 
+// src/indexer/git-blame.ts
+var import_child_process2 = require("child_process");
+var path11 = __toESM(require("path"), 1);
+var import_util2 = require("util");
+var execFileAsync2 = (0, import_util2.promisify)(import_child_process2.execFile);
+function parseGitBlamePorcelain(output) {
+  const commits = /* @__PURE__ */ new Map();
+  let current;
+  for (const line of output.split("\n")) {
+    if (/^[0-9a-f]{40} /.test(line)) {
+      const sha = line.slice(0, 40);
+      current = commits.get(sha) ?? {
+        sha,
+        author: "",
+        authorEmail: "",
+        committedAt: 0,
+        summary: "",
+        lines: 0
+      };
+      commits.set(sha, current);
+      continue;
+    }
+    if (!current) {
+      continue;
+    }
+    if (line.startsWith("author ")) {
+      current.author = line.slice("author ".length);
+    } else if (line.startsWith("author-mail ")) {
+      current.authorEmail = line.slice("author-mail ".length).replace(/^<|>$/g, "");
+    } else if (line.startsWith("author-time ")) {
+      current.committedAt = Number.parseInt(line.slice("author-time ".length), 10);
+    } else if (line.startsWith("summary ")) {
+      current.summary = line.slice("summary ".length);
+    } else if (line.startsWith("	")) {
+      current.lines += 1;
+    }
+  }
+  return Array.from(commits.values()).filter((commit) => commit.lines > 0).sort((a, b) => b.lines - a.lines || b.committedAt - a.committedAt)[0];
+}
+async function getChunkGitBlame(projectRoot, filePath, startLine, endLine) {
+  const relativePath = path11.relative(projectRoot, filePath);
+  try {
+    const { stdout } = await execFileAsync2(
+      "git",
+      ["blame", "--line-porcelain", "-L", `${startLine},${endLine}`, "--", relativePath],
+      { cwd: projectRoot, timeout: 3e4 }
+    );
+    return parseGitBlamePorcelain(stdout);
+  } catch {
+    return void 0;
+  }
+}
+
 // src/indexer/index.ts
-var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "php", "apex", "zig", "gdscript", "matlab"]);
+var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "php", "apex", "zig", "gdscript", "matlab", "bash"]);
 var CASE_INSENSITIVE_LANGUAGES = /* @__PURE__ */ new Set(["apex"]);
 var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "function_declaration",
@@ -4875,6 +4932,45 @@ function isSqliteCorruptionError(error) {
   return message.includes("database disk image is malformed") || message.includes("file is not a database") || message.includes("database schema is corrupt") || message.includes("sqlite_corrupt");
 }
 var STARTUP_WARNING_METADATA_KEY = "index.startupWarning";
+function metadataFromBlame(blame) {
+  if (!blame) {
+    return {};
+  }
+  return {
+    blameSha: blame.sha,
+    blameAuthor: blame.author,
+    blameAuthorEmail: blame.authorEmail,
+    blameCommittedAt: blame.committedAt,
+    blameSummary: blame.summary
+  };
+}
+function blameFromChunkData(chunk) {
+  if (!chunk?.blameSha || !chunk.blameAuthor || !chunk.blameAuthorEmail || chunk.blameCommittedAt === void 0 || !chunk.blameSummary) {
+    return void 0;
+  }
+  return {
+    sha: chunk.blameSha,
+    author: chunk.blameAuthor,
+    authorEmail: chunk.blameAuthorEmail,
+    committedAt: chunk.blameCommittedAt,
+    summary: chunk.blameSummary
+  };
+}
+function blameFromMetadata(metadata) {
+  if (!metadata.blameSha || !metadata.blameAuthor || !metadata.blameAuthorEmail || metadata.blameCommittedAt === void 0 || !metadata.blameSummary) {
+    return void 0;
+  }
+  return {
+    sha: metadata.blameSha,
+    author: metadata.blameAuthor,
+    authorEmail: metadata.blameAuthorEmail,
+    committedAt: metadata.blameCommittedAt,
+    summary: metadata.blameSummary
+  };
+}
+function hasBlameMetadata(metadata) {
+  return blameFromMetadata(metadata) !== void 0;
+}
 var INDEX_METADATA_VERSION = "1";
 var EMBEDDING_STRATEGY_VERSION = "2";
 var RANKING_TOKEN_CACHE_LIMIT = 4096;
@@ -5033,9 +5129,9 @@ function hasAllEmbeddingParts(parts, expectedPartCount) {
   return true;
 }
 function isPathWithinRoot(filePath, rootPath) {
-  const normalizedFilePath = path11.resolve(filePath);
-  const normalizedRoot = path11.resolve(rootPath);
-  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path11.sep}`);
+  const normalizedFilePath = path12.resolve(filePath);
+  const normalizedRoot = path12.resolve(rootPath);
+  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path12.sep}`);
 }
 var rankingQueryTokenCache = /* @__PURE__ */ new Map();
 var rankingNameTokenCache = /* @__PURE__ */ new Map();
@@ -5794,7 +5890,8 @@ function promoteIdentifierMatches(query, combined, semanticCandidates, keywordCa
             chunkType,
             name: chunk.name ?? void 0,
             language: chunk.language,
-            hash: chunk.contentHash
+            hash: chunk.contentHash,
+            ...metadataFromBlame(blameFromChunkData(chunk))
           };
           const baselineScore = existing?.score ?? 0.5;
           candidateUnion.set(chunk.chunkId, {
@@ -5878,7 +5975,8 @@ function buildSymbolDefinitionLane(query, database, branchChunkIds, limit, fallb
           chunkType,
           name: chunk.name ?? void 0,
           language: chunk.language,
-          hash: chunk.contentHash
+          hash: chunk.contentHash,
+          ...metadataFromBlame(blameFromChunkData(chunk))
         }
       });
     }
@@ -6047,6 +6145,21 @@ function matchesSearchFilters(candidate, options, minScore) {
   if (options?.chunkType && candidate.metadata.chunkType !== options.chunkType) {
     return false;
   }
+  if (options?.blameAuthor) {
+    const author = options.blameAuthor.toLowerCase();
+    const candidateAuthor = candidate.metadata.blameAuthor?.toLowerCase();
+    const candidateEmail = candidate.metadata.blameAuthorEmail?.toLowerCase();
+    if (candidateAuthor !== author && candidateEmail !== author) return false;
+  }
+  if (options?.blameSha && !candidate.metadata.blameSha?.toLowerCase().startsWith(options.blameSha.toLowerCase())) {
+    return false;
+  }
+  if (options?.blameSince) {
+    const sinceMs = Date.parse(options.blameSince);
+    if (Number.isNaN(sinceMs)) return false;
+    const committedAt = candidate.metadata.blameCommittedAt;
+    if (committedAt === void 0 || committedAt < Math.floor(sinceMs / 1e3)) return false;
+  }
   return true;
 }
 function unionCandidates(semanticCandidates, keywordCandidates) {
@@ -6090,9 +6203,9 @@ var Indexer = class {
     this.config = config;
     this.host = host;
     this.indexPath = this.getIndexPath();
-    this.fileHashCachePath = path11.join(this.indexPath, "file-hashes.json");
-    this.failedBatchesPath = path11.join(this.indexPath, "failed-batches.json");
-    this.indexingLockPath = path11.join(this.indexPath, "indexing.lock");
+    this.fileHashCachePath = path12.join(this.indexPath, "file-hashes.json");
+    this.failedBatchesPath = path12.join(this.indexPath, "failed-batches.json");
+    this.indexingLockPath = path12.join(this.indexPath, "indexing.lock");
     this.logger = initializeLogger(config.debug);
   }
   getIndexPath() {
@@ -6124,14 +6237,14 @@ var Indexer = class {
   }
   atomicWriteSync(targetPath, data) {
     const tempPath = `${targetPath}.tmp`;
-    (0, import_fs7.mkdirSync)(path11.dirname(targetPath), { recursive: true });
+    (0, import_fs7.mkdirSync)(path12.dirname(targetPath), { recursive: true });
     (0, import_fs7.writeFileSync)(tempPath, data);
     (0, import_fs7.renameSync)(tempPath, targetPath);
   }
   getScopedRoots() {
-    const roots = /* @__PURE__ */ new Set([path11.resolve(this.projectRoot)]);
+    const roots = /* @__PURE__ */ new Set([path12.resolve(this.projectRoot)]);
     for (const kbRoot of this.config.knowledgeBases) {
-      roots.add(path11.resolve(this.projectRoot, kbRoot));
+      roots.add(path12.resolve(this.projectRoot, kbRoot));
     }
     return Array.from(roots);
   }
@@ -6140,29 +6253,29 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return branchName;
     }
-    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
     return `${projectHash}:${branchName}`;
   }
   getBranchCatalogKeyFor(branchName) {
     if (this.config.scope !== "global") {
       return branchName;
     }
-    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
     return `${projectHash}:${branchName}`;
   }
   getLegacyBranchCatalogKey() {
     return this.currentBranch || "default";
   }
   getLegacyMigrationMetadataKey() {
-    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
     return `index.globalBranchMigration.${projectHash}`;
   }
   getProjectEmbeddingStrategyMetadataKey() {
-    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
     return `index.embeddingStrategyVersion.${projectHash}`;
   }
   getProjectForceReembedMetadataKey() {
-    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
     return `index.forceReembed.${projectHash}`;
   }
   hasProjectForceReembedPending() {
@@ -6256,7 +6369,7 @@ var Indexer = class {
     if (!this.database) {
       return { chunkIds, symbolIds };
     }
-    const projectRootPath = path11.resolve(this.projectRoot);
+    const projectRootPath = path12.resolve(this.projectRoot);
     const projectLocalFilePaths = /* @__PURE__ */ new Set([
       ...Array.from(this.fileHashCache.keys()).filter(
         (filePath) => this.isFileInCurrentScope(filePath, roots) && isPathWithinRoot(filePath, projectRootPath)
@@ -6279,7 +6392,7 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return this.getBranchCatalogCleanupKeys();
     }
-    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
     const keys = /* @__PURE__ */ new Set();
     const projectChunkIdSet = new Set(projectChunkIds);
     const projectSymbolIdSet = new Set(projectSymbolIds);
@@ -6363,7 +6476,7 @@ var Indexer = class {
     if (!this.database || this.config.scope !== "global") {
       return false;
     }
-    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path12.resolve(this.projectRoot)).slice(0, 16);
     const roots = this.getScopedRoots();
     const { chunkIds: projectLocalChunkIds, symbolIds: projectLocalSymbolIds } = this.getProjectLocalScopedOwnershipIds(roots);
     return this.database.getAllBranches().some(
@@ -6397,7 +6510,7 @@ var Indexer = class {
       ...Array.from(this.fileHashCache.keys()).filter((filePath) => this.isFileInCurrentScope(filePath, roots)),
       ...scopedEntries.map(({ metadata }) => metadata.filePath)
     ]);
-    const projectRootPath = path11.resolve(this.projectRoot);
+    const projectRootPath = path12.resolve(this.projectRoot);
     const projectLocalFilePaths = new Set(
       Array.from(filePaths).filter((filePath) => isPathWithinRoot(filePath, projectRootPath))
     );
@@ -6757,13 +6870,13 @@ var Indexer = class {
     }
     await import_fs7.promises.mkdir(this.indexPath, { recursive: true });
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path11.join(this.indexPath, "vectors");
+    const storePath = path12.join(this.indexPath, "vectors");
     this.store = new VectorStore(storePath, dimensions);
-    const indexFilePath = path11.join(this.indexPath, "vectors.usearch");
+    const indexFilePath = path12.join(this.indexPath, "vectors.usearch");
     if ((0, import_fs7.existsSync)(indexFilePath)) {
       this.store.load();
     }
-    const invertedIndexPath = path11.join(this.indexPath, "inverted-index.json");
+    const invertedIndexPath = path12.join(this.indexPath, "inverted-index.json");
     this.invertedIndex = new InvertedIndex(invertedIndexPath);
     try {
       this.invertedIndex.load();
@@ -6773,7 +6886,7 @@ var Indexer = class {
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
     }
-    const dbPath = path11.join(this.indexPath, "codebase.db");
+    const dbPath = path12.join(this.indexPath, "codebase.db");
     let dbIsNew = !(0, import_fs7.existsSync)(dbPath);
     try {
       this.database = new Database(dbPath);
@@ -6854,7 +6967,7 @@ var Indexer = class {
         if (await this.tryResetCorruptedIndex("running automatic orphan garbage collection", error)) {
           return {
             resetCorruptedIndex: true,
-            warning: this.getCorruptedIndexWarning(path11.join(this.indexPath, "codebase.db"))
+            warning: this.getCorruptedIndexWarning(path12.join(this.indexPath, "codebase.db"))
           };
         }
         throw error;
@@ -6869,7 +6982,7 @@ var Indexer = class {
       return;
     }
     const retainedEntries = store.getAllMetadata().filter(({ key }) => !excludedSet.has(key));
-    const storeBasePath = path11.join(this.indexPath, "vectors");
+    const storeBasePath = path12.join(this.indexPath, "vectors");
     const storeIndexPath = `${storeBasePath}.usearch`;
     const storeMetadataPath = `${storeBasePath}.meta.json`;
     const backupIndexPath = `${storeIndexPath}.bak`;
@@ -6954,7 +7067,7 @@ var Indexer = class {
     if (!isSqliteCorruptionError(error)) {
       return false;
     }
-    const dbPath = path11.join(this.indexPath, "codebase.db");
+    const dbPath = path12.join(this.indexPath, "codebase.db");
     const warning = this.getCorruptedIndexWarning(dbPath);
     const errorMessage = getErrorMessage2(error);
     if (this.config.scope === "global") {
@@ -6977,15 +7090,15 @@ var Indexer = class {
     this.indexCompatibility = null;
     this.fileHashCache.clear();
     const resetPaths = [
-      path11.join(this.indexPath, "codebase.db"),
-      path11.join(this.indexPath, "codebase.db-shm"),
-      path11.join(this.indexPath, "codebase.db-wal"),
-      path11.join(this.indexPath, "vectors.usearch"),
-      path11.join(this.indexPath, "inverted-index.json"),
-      path11.join(this.indexPath, "file-hashes.json"),
-      path11.join(this.indexPath, "failed-batches.json"),
-      path11.join(this.indexPath, "indexing.lock"),
-      path11.join(this.indexPath, "vectors")
+      path12.join(this.indexPath, "codebase.db"),
+      path12.join(this.indexPath, "codebase.db-shm"),
+      path12.join(this.indexPath, "codebase.db-wal"),
+      path12.join(this.indexPath, "vectors.usearch"),
+      path12.join(this.indexPath, "inverted-index.json"),
+      path12.join(this.indexPath, "file-hashes.json"),
+      path12.join(this.indexPath, "failed-batches.json"),
+      path12.join(this.indexPath, "indexing.lock"),
+      path12.join(this.indexPath, "vectors")
     ];
     await Promise.all(resetPaths.map(async (targetPath) => {
       try {
@@ -7222,6 +7335,7 @@ var Indexer = class {
     this.logger.debug("Parsed changed files", { parsedCount: parsedFiles.length, parseMs: parseMs.toFixed(2) });
     const existingChunks = /* @__PURE__ */ new Map();
     const existingChunksByFile = /* @__PURE__ */ new Map();
+    const existingMetadataById = /* @__PURE__ */ new Map();
     for (const { key, metadata } of store.getAllMetadata()) {
       if (scopedRoots && !this.isFileInCurrentScope(metadata.filePath, scopedRoots)) {
         continue;
@@ -7230,6 +7344,7 @@ var Indexer = class {
         continue;
       }
       existingChunks.set(key, metadata.hash);
+      existingMetadataById.set(key, metadata);
       const fileChunks = existingChunksByFile.get(metadata.filePath) || /* @__PURE__ */ new Set();
       fileChunks.add(key);
       existingChunksByFile.set(metadata.filePath, fileChunks);
@@ -7237,6 +7352,8 @@ var Indexer = class {
     const currentChunkIds = /* @__PURE__ */ new Set();
     const currentFilePaths = /* @__PURE__ */ new Set();
     const pendingChunks = [];
+    const gitBlameEnabled = this.config.indexing.gitBlame.enabled && isGitRepo(this.projectRoot);
+    let backfilledBlameMetadata = false;
     for (const filePath of unchangedFilePaths) {
       currentFilePaths.add(filePath);
       const fileChunks = existingChunksByFile.get(filePath);
@@ -7247,10 +7364,52 @@ var Indexer = class {
       }
     }
     const chunkDataBatch = [];
+    if (gitBlameEnabled) {
+      const backfillItems = [];
+      for (const chunkId of currentChunkIds) {
+        const metadata = existingMetadataById.get(chunkId);
+        if (!metadata || hasBlameMetadata(metadata)) {
+          continue;
+        }
+        const chunk = database.getChunk(chunkId);
+        if (!chunk) {
+          continue;
+        }
+        const blame = await getChunkGitBlame(this.projectRoot, chunk.filePath, chunk.startLine, chunk.endLine);
+        const blameMetadata = metadataFromBlame(blame);
+        if (!blameMetadata.blameSha) {
+          continue;
+        }
+        chunkDataBatch.push({
+          ...chunk,
+          blameSha: blameMetadata.blameSha,
+          blameAuthor: blameMetadata.blameAuthor,
+          blameAuthorEmail: blameMetadata.blameAuthorEmail,
+          blameCommittedAt: blameMetadata.blameCommittedAt,
+          blameSummary: blameMetadata.blameSummary
+        });
+        const embeddingBuffer = database.getEmbedding(chunk.contentHash);
+        if (!embeddingBuffer) {
+          continue;
+        }
+        backfillItems.push({
+          id: chunkId,
+          vector: Array.from(bufferToFloat32Array(embeddingBuffer)),
+          metadata: {
+            ...metadata,
+            ...blameMetadata
+          }
+        });
+      }
+      if (backfillItems.length > 0) {
+        store.addBatch(backfillItems);
+        backfilledBlameMetadata = true;
+      }
+    }
     for (const parsed of parsedFiles) {
       currentFilePaths.add(parsed.path);
       if (parsed.chunks.length === 0) {
-        const relativePath = path11.relative(this.projectRoot, parsed.path);
+        const relativePath = path12.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
       let fileChunkCount = 0;
@@ -7271,6 +7430,10 @@ var Indexer = class {
         }
         const id = generateChunkId(parsed.path, chunk);
         const contentHash = generateChunkHash(chunk);
+        const existingContentHash = existingChunks.get(id);
+        const existingChunk = gitBlameEnabled ? database.getChunk(id) : null;
+        const blame = gitBlameEnabled && existingContentHash !== contentHash ? await getChunkGitBlame(this.projectRoot, parsed.path, chunk.startLine, chunk.endLine) : blameFromChunkData(existingChunk);
+        const blameMetadata = metadataFromBlame(blame);
         currentChunkIds.add(id);
         chunkDataBatch.push({
           chunkId: id,
@@ -7280,9 +7443,14 @@ var Indexer = class {
           endLine: chunk.endLine,
           nodeType: chunk.chunkType,
           name: chunk.name,
-          language: chunk.language
+          language: chunk.language,
+          blameSha: blameMetadata.blameSha,
+          blameAuthor: blameMetadata.blameAuthor,
+          blameAuthorEmail: blameMetadata.blameAuthorEmail,
+          blameCommittedAt: blameMetadata.blameCommittedAt,
+          blameSummary: blameMetadata.blameSummary
         });
-        if (existingChunks.get(id) === contentHash) {
+        if (existingContentHash === contentHash) {
           fileChunkCount++;
           continue;
         }
@@ -7297,7 +7465,8 @@ var Indexer = class {
           chunkType: chunk.chunkType,
           name: chunk.name,
           language: chunk.language,
-          hash: contentHash
+          hash: contentHash,
+          ...blameMetadata
         };
         pendingChunks.push({
           id,
@@ -7440,6 +7609,9 @@ var Indexer = class {
       database.addChunksToBranchBatch(branchCatalogKey, Array.from(currentChunkIds));
       database.clearBranchSymbols(branchCatalogKey);
       database.addSymbolsToBranchBatch(branchCatalogKey, Array.from(allSymbolIds));
+      if (backfilledBlameMetadata) {
+        store.save();
+      }
       if (scopedRoots) {
         this.replaceScopedFileHashCache(currentFileHashes, scopedRoots);
         this.clearScopedFailedBatches(scopedRoots);
@@ -8003,7 +8175,8 @@ var Indexer = class {
           content,
           score: r.score,
           chunkType: r.metadata.chunkType,
-          name: r.metadata.name
+          name: r.metadata.name,
+          blame: blameFromMetadata(r.metadata)
         };
       })
     );
@@ -8095,12 +8268,12 @@ var Indexer = class {
       this.indexCompatibility = compatibility;
       return;
     }
-    const localProjectIndexPaths = [path11.join(this.projectRoot, getHostProjectIndexRelativePath(this.host))];
+    const localProjectIndexPaths = [path12.join(this.projectRoot, getHostProjectIndexRelativePath(this.host))];
     if (this.host !== "opencode") {
-      localProjectIndexPaths.push(path11.join(this.projectRoot, getHostProjectIndexRelativePath("opencode")));
+      localProjectIndexPaths.push(path12.join(this.projectRoot, getHostProjectIndexRelativePath("opencode")));
     }
     const isLocalProjectIndex = localProjectIndexPaths.some(
-      (localPath) => path11.resolve(this.indexPath) === path11.resolve(localPath)
+      (localPath) => path12.resolve(this.indexPath) === path12.resolve(localPath)
     );
     if (!isLocalProjectIndex) {
       throw new Error(
@@ -8190,7 +8363,7 @@ var Indexer = class {
         gcOrphanSymbols: 0,
         gcOrphanCallEdges: 0,
         resetCorruptedIndex: true,
-        warning: this.getCorruptedIndexWarning(path11.join(this.indexPath, "codebase.db"))
+        warning: this.getCorruptedIndexWarning(path12.join(this.indexPath, "codebase.db"))
       };
     }
     this.logger.recordGc(removedCount, gcOrphanChunks, gcOrphanEmbeddings);
@@ -8510,7 +8683,8 @@ var Indexer = class {
           content,
           score: r.score,
           chunkType: r.metadata.chunkType,
-          name: r.metadata.name
+          name: r.metadata.name,
+          blame: blameFromMetadata(r.metadata)
         };
       })
     );
@@ -8547,9 +8721,9 @@ var Indexer = class {
     const { database } = await this.ensureInitialized();
     let shortest = [];
     for (const branchKey of this.getBranchCatalogKeys()) {
-      const path22 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
-      if (path22.length > 0 && (shortest.length === 0 || path22.length < shortest.length)) {
-        shortest = path22;
+      const path23 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
+      if (path23.length > 0 && (shortest.length === 0 || path23.length < shortest.length)) {
+        shortest = path23;
       }
     }
     return shortest;
@@ -8581,7 +8755,7 @@ var Indexer = class {
   }
   async getPrImpact(opts) {
     const { database } = await this.ensureInitialized();
-    const execFileAsync2 = (0, import_util2.promisify)(import_child_process2.execFile);
+    const execFileAsync3 = (0, import_util3.promisify)(import_child_process3.execFile);
     const changedFilesResult = await getChangedFiles({
       pr: opts.pr,
       branch: opts.branch,
@@ -8603,7 +8777,7 @@ var Indexer = class {
         "Run index_codebase first to build the call graph and symbol index for this branch."
       );
     }
-    const absoluteChangedFiles = changedFiles.map((f) => path11.resolve(this.projectRoot, f));
+    const absoluteChangedFiles = changedFiles.map((f) => path12.resolve(this.projectRoot, f));
     const directSymbols = database.getSymbolsForFiles(absoluteChangedFiles, branchKey);
     const directIds = directSymbols.map((s) => s.id);
     const direction = opts.direction ?? "both";
@@ -8665,7 +8839,7 @@ var Indexer = class {
     if (opts.checkConflicts) {
       conflictingPRs = [];
       try {
-        const { stdout } = await execFileAsync2(
+        const { stdout } = await execFileAsync3(
           "gh",
           ["pr", "list", "--state", "open", "--json", "number,headRefName", "--limit", "10000"],
           { cwd: this.projectRoot, timeout: 3e4 }
@@ -8686,7 +8860,7 @@ var Indexer = class {
               projectRoot: this.projectRoot,
               baseBranch: this.baseBranch
             });
-            const otherAbsolute = otherChanged.files.map((f) => path11.resolve(this.projectRoot, f));
+            const otherAbsolute = otherChanged.files.map((f) => path12.resolve(this.projectRoot, f));
             const otherBranchKey = this.getBranchCatalogKeyFor(openPr.headRefName);
             const otherSymbols = database.getSymbolsForFiles(otherAbsolute, otherBranchKey);
             const otherLabels = /* @__PURE__ */ new Set();
@@ -8749,12 +8923,12 @@ var Indexer = class {
         if (meta.filePath) filePaths.add(meta.filePath);
       }
       const directory = options?.directory?.replace(/\/$/, "");
-      const absoluteDirectoryFilter = directory ? path11.resolve(this.projectRoot, directory) : void 0;
+      const absoluteDirectoryFilter = directory ? path12.resolve(this.projectRoot, directory) : void 0;
       for (const filePath of filePaths) {
         if (directory) {
-          const absoluteFilePath = path11.resolve(filePath);
+          const absoluteFilePath = path12.resolve(filePath);
           const matchesRelative = filePath === directory || filePath.startsWith(directory + "/");
-          const matchesProjectRelative = absoluteDirectoryFilter !== void 0 && (absoluteFilePath === absoluteDirectoryFilter || absoluteFilePath.startsWith(absoluteDirectoryFilter + path11.sep));
+          const matchesProjectRelative = absoluteDirectoryFilter !== void 0 && (absoluteFilePath === absoluteDirectoryFilter || absoluteFilePath.startsWith(absoluteDirectoryFilter + path12.sep));
           if (!matchesRelative && !matchesProjectRelative) {
             continue;
           }
@@ -8786,43 +8960,43 @@ var Indexer = class {
 };
 
 // src/tools/knowledge-base-paths.ts
-var path12 = __toESM(require("path"), 1);
+var path13 = __toESM(require("path"), 1);
 function resolveConfigPathValue(value, baseDir) {
   const trimmed = value.trim();
   if (!trimmed) {
     return trimmed;
   }
-  const absolutePath = path12.isAbsolute(trimmed) ? trimmed : path12.resolve(baseDir, trimmed);
-  return path12.normalize(absolutePath);
+  const absolutePath = path13.isAbsolute(trimmed) ? trimmed : path13.resolve(baseDir, trimmed);
+  return path13.normalize(absolutePath);
 }
 function serializeConfigPathValue(value, baseDir) {
   const trimmed = value.trim();
   if (!trimmed) {
     return trimmed;
   }
-  if (!path12.isAbsolute(trimmed)) {
-    return normalizePathSeparators(path12.normalize(trimmed));
+  if (!path13.isAbsolute(trimmed)) {
+    return normalizePathSeparators(path13.normalize(trimmed));
   }
-  const relativePath = path12.relative(baseDir, trimmed);
-  if (!relativePath || !relativePath.startsWith("..") && !path12.isAbsolute(relativePath)) {
-    return normalizePathSeparators(path12.normalize(relativePath || "."));
+  const relativePath = path13.relative(baseDir, trimmed);
+  if (!relativePath || !relativePath.startsWith("..") && !path13.isAbsolute(relativePath)) {
+    return normalizePathSeparators(path13.normalize(relativePath || "."));
   }
-  return path12.normalize(trimmed);
+  return path13.normalize(trimmed);
 }
 function resolveKnowledgeBasePath(value, projectRoot) {
-  return path12.isAbsolute(value) ? value : path12.resolve(projectRoot, value);
+  return path13.isAbsolute(value) ? value : path13.resolve(projectRoot, value);
 }
 function normalizeKnowledgeBasePath2(value, projectRoot) {
-  return path12.normalize(resolveKnowledgeBasePath(value, projectRoot));
+  return path13.normalize(resolveKnowledgeBasePath(value, projectRoot));
 }
 function hasMatchingKnowledgeBasePath(knowledgeBases, inputPath, projectRoot) {
-  const normalizedInput = path12.normalize(inputPath);
+  const normalizedInput = path13.normalize(inputPath);
   return knowledgeBases.some((kb) => normalizeKnowledgeBasePath2(kb, projectRoot) === normalizedInput);
 }
 function findKnowledgeBasePathIndex(knowledgeBases, inputPath, projectRoot) {
-  const normalizedInput = path12.normalize(inputPath);
+  const normalizedInput = path13.normalize(inputPath);
   return knowledgeBases.findIndex(
-    (kb) => path12.normalize(kb) === normalizedInput || normalizeKnowledgeBasePath2(kb, projectRoot) === normalizedInput
+    (kb) => path13.normalize(kb) === normalizedInput || normalizeKnowledgeBasePath2(kb, projectRoot) === normalizedInput
   );
 }
 
@@ -8974,7 +9148,7 @@ function formatCodebasePeek(results) {
   const formatted = results.map((r, idx) => {
     const location = `${r.filePath}:${r.startLine}-${r.endLine}`;
     const name = r.name ? `"${r.name}"` : "(anonymous)";
-    return `[${idx + 1}] ${r.chunkType} ${name} at ${location} (score: ${r.score.toFixed(2)})`;
+    return `[${idx + 1}] ${r.chunkType} ${name} at ${location} (score: ${r.score.toFixed(2)})${formatBlame(r)}`;
   });
   return formatted.join("\n");
 }
@@ -9006,16 +9180,57 @@ function formatHealthCheck(result) {
   }
   return lines.join("\n");
 }
+function formatCallGraphCallers(name, callers, relationshipType) {
+  if (callers.length === 0) {
+    return `No callers found for "${name}"${relationshipType ? ` with type ${relationshipType}` : ""}. It may not be called by any tracked function, or the index needs updating.`;
+  }
+  const formatted = callers.map((edge, index) => {
+    const confidence = edge.confidence !== "Direct" ? ` [${edge.confidence.toLowerCase()}]` : "";
+    return `[${index + 1}] \u2190 from ${edge.fromSymbolName ?? "<unknown>"} in ${edge.fromSymbolFilePath ?? "<unknown file>"} [${edge.fromSymbolId}] (${edge.callType})${confidence} at line ${edge.line}${edge.isResolved ? " [resolved]" : " [unresolved]"}`;
+  });
+  return `"${name}" is called by ${callers.length} function(s):
+
+${formatted.join("\n")}`;
+}
+function formatCallGraphCallees(symbolId, callees, relationshipType) {
+  if (callees.length === 0) {
+    return `No callees found for symbol ${symbolId}${relationshipType ? ` with type ${relationshipType}` : ""}. The function may not call any other tracked functions.`;
+  }
+  return callees.map((edge, index) => {
+    const confidence = edge.confidence !== "Direct" ? ` [${edge.confidence.toLowerCase()}]` : "";
+    return `[${index + 1}] \u2192 ${edge.targetName} (${edge.callType})${confidence} at line ${edge.line}${edge.isResolved ? ` [resolved: ${edge.toSymbolId}]` : " [unresolved]"}`;
+  }).join("\n");
+}
+function formatCallGraphPath(from, to, path23) {
+  if (path23.length === 0) {
+    return `No path found between "${from}" and "${to}". They may be in disconnected components, or the call graph index needs updating.`;
+  }
+  const formatted = path23.map((hop, index) => {
+    const prefix = index === 0 ? "[start]" : `--${hop.callType}-->`;
+    const location = hop.filePath ? ` (${hop.filePath}:${hop.line})` : "";
+    return `${prefix} ${hop.symbolName}${location}`;
+  });
+  return `Path (${path23.length} hops):
+${formatted.join("\n")}`;
+}
 function formatResultHeader(result, index) {
   return result.name ? `[${index + 1}] ${result.chunkType} "${result.name}" in ${result.filePath}:${result.startLine}-${result.endLine}` : `[${index + 1}] ${result.chunkType} in ${result.filePath}:${result.startLine}-${result.endLine}`;
 }
+function formatBlame(result) {
+  if (!result.blame) {
+    return "";
+  }
+  const date = new Date(result.blame.committedAt * 1e3).toISOString().slice(0, 10);
+  return `
+    ${result.blame.sha.slice(0, 7)} | ${result.blame.author} | ${date} | ${result.blame.summary}`;
+}
 function formatDefinitionLookup(results, query) {
   if (results.length === 0) {
     return `No definition found for "${query}". Try codebase_search for broader discovery, or verify the symbol name.`;
   }
   const formatted = results.map((r, idx) => {
     const header = formatResultHeader(r, idx);
-    return `${header} (score: ${r.score.toFixed(2)})
+    return `${header} (score: ${r.score.toFixed(2)})${formatBlame(r)}
 \`\`\`
 ${truncateContent(r.content)}
 \`\`\``;
@@ -9026,7 +9241,7 @@ function formatSearchResults(results, scoreFormat = "similarity") {
   const formatted = results.map((r, idx) => {
     const header = formatResultHeader(r, idx);
     const scoreLabel = scoreFormat === "similarity" ? `(similarity: ${(r.score * 100).toFixed(1)}%)` : `(score: ${r.score.toFixed(2)})`;
-    return `${header} ${scoreLabel}
+    return `${header} ${scoreLabel}${formatBlame(r)}
 \`\`\`
 ${truncateContent(r.content)}
 \`\`\``;
@@ -9036,7 +9251,7 @@ ${truncateContent(r.content)}
 
 // src/tools/config-state.ts
 var import_fs8 = require("fs");
-var path13 = __toESM(require("path"), 1);
+var path14 = __toESM(require("path"), 1);
 function normalizeKnowledgeBasePaths(config, projectRoot) {
   const normalized = { ...config };
   if (Array.isArray(normalized.knowledgeBases)) {
@@ -9063,8 +9278,8 @@ function loadEditableConfig(projectRoot, host = "opencode") {
 }
 function saveConfig(projectRoot, config, host = "opencode") {
   const configPath = getConfigPath(projectRoot, host);
-  const configDir = path13.dirname(configPath);
-  const configBaseDir = path13.dirname(configDir);
+  const configDir = path14.dirname(configPath);
+  const configBaseDir = path14.dirname(configDir);
   if (!(0, import_fs8.existsSync)(configDir)) {
     (0, import_fs8.mkdirSync)(configDir, { recursive: true });
   }
@@ -9125,7 +9340,7 @@ function refreshIndexerForDirectory(projectRoot, host = "opencode", config = par
 }
 function shouldForceLocalizeProjectIndex(projectRoot, host = "opencode") {
   const root = getProjectRoot(projectRoot, host);
-  const localIndexPath = path14.join(root, getHostProjectIndexRelativePath(host));
+  const localIndexPath = path15.join(root, getHostProjectIndexRelativePath(host));
   if ((0, import_fs9.existsSync)(localIndexPath)) {
     return false;
   }
@@ -9140,7 +9355,10 @@ async function searchCodebase(projectRoot, host, query, options = {}) {
     chunkType: options.chunkType,
     contextLines: options.contextLines,
     metadataOnly: options.metadataOnly,
-    definitionIntent: options.definitionIntent
+    definitionIntent: options.definitionIntent,
+    blameAuthor: options.blameAuthor,
+    blameSha: options.blameSha,
+    blameSince: options.blameSince
   });
 }
 async function findSimilarCode(projectRoot, host, code, options = {}) {
@@ -9272,8 +9490,8 @@ async function getIndexLogs(projectRoot, host, args) {
 function addKnowledgeBase(projectRoot, host, knowledgeBasePath) {
   const root = getProjectRoot(projectRoot, host);
   const inputPath = knowledgeBasePath.trim();
-  const normalizedPath = path14.resolve(
-    path14.isAbsolute(inputPath) ? inputPath : resolveKnowledgeBasePath(inputPath, root)
+  const normalizedPath = path15.resolve(
+    path15.isAbsolute(inputPath) ? inputPath : resolveKnowledgeBasePath(inputPath, root)
   );
   if (!(0, import_fs9.existsSync)(normalizedPath)) {
     return `Error: Directory does not exist: ${normalizedPath}`;
@@ -9309,7 +9527,7 @@ function addKnowledgeBase(projectRoot, host, knowledgeBasePath) {
     }
   }
   for (const dotDir of sensitiveDotDirs) {
-    const sensitiveDir = path14.join(homeDir, dotDir);
+    const sensitiveDir = path15.join(homeDir, dotDir);
     if (sensitiveDir && (realPath === sensitiveDir || realPath.startsWith(`${sensitiveDir}/`))) {
       return `Error: Adding sensitive directory as knowledge base is not allowed: ${normalizedPath}`;
     }
@@ -9372,7 +9590,7 @@ function listKnowledgeBases(projectRoot, host) {
     }
     result += "\n";
   }
-  const hasHostConfig = (0, import_fs9.existsSync)(path14.join(root, getHostProjectConfigRelativePath(host)));
+  const hasHostConfig = (0, import_fs9.existsSync)(path15.join(root, getHostProjectConfigRelativePath(host)));
   if (hasHostConfig) {
     result += `
 Config sources: 1 file(s).`;
@@ -9495,7 +9713,7 @@ var ReaddirpStream = class extends import_node_stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
     if (wantBigintFsStats) {
-      this._stat = (path22) => statMethod(path22, { bigint: true });
+      this._stat = (path23) => statMethod(path23, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -9520,8 +9738,8 @@ var ReaddirpStream = class extends import_node_stream.Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path22, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path22));
+          const { path: path23, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path23));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -9561,20 +9779,20 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path22, depth) {
+  async _exploreDir(path23, depth) {
     let files;
     try {
-      files = await (0, import_promises.readdir)(path22, this._rdOptions);
+      files = await (0, import_promises.readdir)(path23, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path22 };
+    return { files, depth, path: path23 };
   }
-  async _formatEntry(dirent, path22) {
+  async _formatEntry(dirent, path23) {
     let entry;
     const basename5 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path22, basename5));
+      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path23, basename5));
       entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename5 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -9974,16 +10192,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path22, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path23, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path22);
-    emitRaw(rawEvent, evPath, { watchedPath: path22 });
-    if (evPath && path22 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path22, evPath), KEY_LISTENERS, sp.join(path22, evPath));
+    listener(path23);
+    emitRaw(rawEvent, evPath, { watchedPath: path23 });
+    if (evPath && path23 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path23, evPath), KEY_LISTENERS, sp.join(path23, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path22, {
+    return (0, import_node_fs.watch)(path23, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -9999,12 +10217,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path22, fullPath, options, handlers) => {
+var setFsWatchListener = (path23, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path22, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path23, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -10015,7 +10233,7 @@ var setFsWatchListener = (path22, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path22,
+      path23,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -10030,7 +10248,7 @@ var setFsWatchListener = (path22, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await (0, import_promises2.open)(path22, "r");
+          const fd = await (0, import_promises2.open)(path23, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -10061,7 +10279,7 @@ var setFsWatchListener = (path22, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path22, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path23, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -10083,7 +10301,7 @@ var setFsWatchFileListener = (path22, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path22, curr));
+          foreach(cont.listeners, (listener2) => listener2(path23, curr));
         }
       })
     };
@@ -10113,13 +10331,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path22, listener) {
+  _watchWithNodeFs(path23, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path22);
-    const basename5 = sp.basename(path22);
+    const directory = sp.dirname(path23);
+    const basename5 = sp.basename(path23);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename5);
-    const absolutePath = sp.resolve(path22);
+    const absolutePath = sp.resolve(path23);
     const options = {
       persistent: opts.persistent
     };
@@ -10129,12 +10347,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path22, absolutePath, options, {
+      closer = setFsWatchFileListener(path23, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path22, absolutePath, options, {
+      closer = setFsWatchListener(path23, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -10156,7 +10374,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename5))
       return;
-    const listener = async (path22, newStats) => {
+    const listener = async (path23, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -10170,11 +10388,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path22);
+            this.fsw._closeFile(path23);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path22, closer2);
+              this.fsw._addPathCloser(path23, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -10206,7 +10424,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, path22, item) {
+  async _handleSymlink(entry, directory, path23, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -10216,7 +10434,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises2.realpath)(path22);
+        linkPath = await (0, import_promises2.realpath)(path23);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -10226,12 +10444,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, path22, entry.stats);
+          this.fsw._emit(EV.CHANGE, path23, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path22, entry.stats);
+        this.fsw._emit(EV.ADD, path23, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -10261,9 +10479,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path22 = sp.join(directory, item);
+      let path23 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path22, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path23, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -10272,8 +10490,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path22 = sp.join(dir, sp.relative(dir, path22));
-        this._addToNodeFs(path22, initialAdd, wh, depth + 1);
+        path23 = sp.join(dir, sp.relative(dir, path23));
+        this._addToNodeFs(path23, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve13, reject) => {
@@ -10342,13 +10560,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path22, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path23, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path22) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path23) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path22);
+    const wh = this.fsw._getWatchHelpers(path23);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -10364,8 +10582,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path22);
-        const targetPath = follow ? await (0, import_promises2.realpath)(path22) : path22;
+        const absPath = sp.resolve(path23);
+        const targetPath = follow ? await (0, import_promises2.realpath)(path23) : path23;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -10375,29 +10593,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises2.realpath)(path22) : path22;
+        const targetPath = follow ? await (0, import_promises2.realpath)(path23) : path23;
         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, path22, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path23, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path22), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path23), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path22, closer);
+        this.fsw._addPathCloser(path23, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path22;
+        return path23;
       }
     }
   }
@@ -10429,35 +10647,35 @@ function createPattern(matcher) {
       if (matcher.path === string)
         return true;
       if (matcher.recursive) {
-        const relative10 = sp2.relative(matcher.path, string);
-        if (!relative10) {
+        const relative11 = sp2.relative(matcher.path, string);
+        if (!relative11) {
           return false;
         }
-        return !relative10.startsWith("..") && !sp2.isAbsolute(relative10);
+        return !relative11.startsWith("..") && !sp2.isAbsolute(relative11);
       }
       return false;
     };
   }
   return () => false;
 }
-function normalizePath(path22) {
-  if (typeof path22 !== "string")
+function normalizePath(path23) {
+  if (typeof path23 !== "string")
     throw new Error("string expected");
-  path22 = sp2.normalize(path22);
-  path22 = path22.replace(/\\/g, "/");
+  path23 = sp2.normalize(path23);
+  path23 = path23.replace(/\\/g, "/");
   let prepend = false;
-  if (path22.startsWith("//"))
+  if (path23.startsWith("//"))
     prepend = true;
-  path22 = path22.replace(DOUBLE_SLASH_RE, "/");
+  path23 = path23.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path22 = "/" + path22;
-  return path22;
+    path23 = "/" + path23;
+  return path23;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path22 = normalizePath(testString);
+  const path23 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path22, stats)) {
+    if (pattern(path23, stats)) {
       return true;
     }
   }
@@ -10495,19 +10713,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path22) => toUnix(sp2.normalize(toUnix(path22)));
-var normalizeIgnored = (cwd = "") => (path22) => {
-  if (typeof path22 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path22) ? path22 : sp2.join(cwd, path22));
+var normalizePathToUnix = (path23) => toUnix(sp2.normalize(toUnix(path23)));
+var normalizeIgnored = (cwd = "") => (path23) => {
+  if (typeof path23 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path23) ? path23 : sp2.join(cwd, path23));
   } else {
-    return path22;
+    return path23;
   }
 };
-var getAbsolutePath = (path22, cwd) => {
-  if (sp2.isAbsolute(path22)) {
-    return path22;
+var getAbsolutePath = (path23, cwd) => {
+  if (sp2.isAbsolute(path23)) {
+    return path23;
   }
-  return sp2.join(cwd, path22);
+  return sp2.join(cwd, path23);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -10572,10 +10790,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path22, follow, fsw) {
+  constructor(path23, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path22;
-    this.path = path22 = path22.replace(REPLACER_RE, "");
+    const watchPath = path23;
+    this.path = path23 = path23.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -10715,20 +10933,20 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path22) => {
-        const absPath = getAbsolutePath(path22, cwd);
+      paths = paths.map((path23) => {
+        const absPath = getAbsolutePath(path23, cwd);
         return absPath;
       });
     }
-    paths.forEach((path22) => {
-      this._removeIgnoredPath(path22);
+    paths.forEach((path23) => {
+      this._removeIgnoredPath(path23);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path22) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path22, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path23) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path23, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -10750,17 +10968,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path22) => {
-      if (!sp2.isAbsolute(path22) && !this._closers.has(path22)) {
+    paths.forEach((path23) => {
+      if (!sp2.isAbsolute(path23) && !this._closers.has(path23)) {
         if (cwd)
-          path22 = sp2.join(cwd, path22);
-        path22 = sp2.resolve(path22);
+          path23 = sp2.join(cwd, path23);
+        path23 = sp2.resolve(path23);
       }
-      this._closePath(path22);
-      this._addIgnoredPath(path22);
-      if (this._watched.has(path22)) {
+      this._closePath(path23);
+      this._addIgnoredPath(path23);
+      if (this._watched.has(path23)) {
         this._addIgnoredPath({
-          path: path22,
+          path: path23,
           recursive: true
         });
       }
@@ -10824,38 +11042,38 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @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, path22, stats) {
+  async _emit(event, path23, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path22 = sp2.normalize(path22);
+      path23 = sp2.normalize(path23);
     if (opts.cwd)
-      path22 = sp2.relative(opts.cwd, path22);
-    const args = [path22];
+      path23 = sp2.relative(opts.cwd, path23);
+    const args = [path23];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path22))) {
+    if (awf && (pw = this._pendingWrites.get(path23))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path22, [event, ...args]);
+        this._pendingUnlinks.set(path23, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path23) => {
+          this._pendingUnlinks.forEach((entry, path24) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path23);
+            this._pendingUnlinks.delete(path24);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path22)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path23)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path22);
+        this._pendingUnlinks.delete(path23);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -10873,16 +11091,16 @@ var FSWatcher = class extends import_node_events.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path22, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path23, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path22, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path23, 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, path22) : path22;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path23) : path23;
       let stats2;
       try {
         stats2 = await (0, import_promises3.stat)(fullPath);
@@ -10913,23 +11131,23 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path22, timeout) {
+  _throttle(actionType, path23, 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(path22);
+    const actionPath = action.get(path23);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path22);
+      const item = action.get(path23);
       const count = item ? item.count : 0;
-      action.delete(path22);
+      action.delete(path23);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -10937,7 +11155,7 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path22, thr);
+    action.set(path23, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -10951,44 +11169,44 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path22, threshold, event, awfEmit) {
+  _awaitWriteFinish(path23, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path22;
-    if (this.options.cwd && !sp2.isAbsolute(path22)) {
-      fullPath = sp2.join(this.options.cwd, path22);
+    let fullPath = path23;
+    if (this.options.cwd && !sp2.isAbsolute(path23)) {
+      fullPath = sp2.join(this.options.cwd, path23);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-        if (err || !writes.has(path22)) {
+        if (err || !writes.has(path23)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path22).lastChange = now2;
+          writes.get(path23).lastChange = now2;
         }
-        const pw = writes.get(path22);
+        const pw = writes.get(path23);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path22);
+          writes.delete(path23);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path22)) {
-      writes.set(path22, {
+    if (!writes.has(path23)) {
+      writes.set(path23, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path22);
+          writes.delete(path23);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -10999,8 +11217,8 @@ var FSWatcher = class extends import_node_events.EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path22, stats) {
-    if (this.options.atomic && DOT_RE.test(path22))
+  _isIgnored(path23, stats) {
+    if (this.options.atomic && DOT_RE.test(path23))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -11010,17 +11228,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path22, stats);
+    return this._userIgnored(path23, stats);
   }
-  _isntIgnored(path22, stat4) {
-    return !this._isIgnored(path22, stat4);
+  _isntIgnored(path23, stat4) {
+    return !this._isIgnored(path23, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path22) {
-    return new WatchHelper(path22, this.options.followSymlinks, this);
+  _getWatchHelpers(path23) {
+    return new WatchHelper(path23, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -11052,63 +11270,63 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path22 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path22);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path22) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path22, 100))
+    const path23 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path23);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path23) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path23, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path22);
+    const wp = this._getWatchedDir(path23);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path22, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path23, 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 = path22;
+    let relPath = path23;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path22);
+      relPath = sp2.relative(this.options.cwd, path23);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path22);
+    this._watched.delete(path23);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path22))
-      this._emit(eventName, path22);
-    this._closePath(path22);
+    if (wasTracked && !this._isIgnored(path23))
+      this._emit(eventName, path23);
+    this._closePath(path23);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path22) {
-    this._closeFile(path22);
-    const dir = sp2.dirname(path22);
-    this._getWatchedDir(dir).remove(sp2.basename(path22));
+  _closePath(path23) {
+    this._closeFile(path23);
+    const dir = sp2.dirname(path23);
+    this._getWatchedDir(dir).remove(sp2.basename(path23));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path22) {
-    const closers = this._closers.get(path22);
+  _closeFile(path23) {
+    const closers = this._closers.get(path23);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path22);
+    this._closers.delete(path23);
   }
-  _addPathCloser(path22, closer) {
+  _addPathCloser(path23, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path22);
+    let list = this._closers.get(path23);
     if (!list) {
       list = [];
-      this._closers.set(path22, list);
+      this._closers.set(path23, list);
     }
     list.push(closer);
   }
@@ -11138,7 +11356,7 @@ function watch(paths, options = {}) {
 var chokidar_default = { watch, FSWatcher };
 
 // src/watcher/file-watcher.ts
-var path15 = __toESM(require("path"), 1);
+var path16 = __toESM(require("path"), 1);
 var FileWatcher = class {
   watcher = null;
   projectRoot;
@@ -11164,15 +11382,15 @@ var FileWatcher = class {
     const watchTargets = this.configPath ? [this.projectRoot, this.configPath] : this.projectRoot;
     this.watcher = chokidar_default.watch(watchTargets, {
       ignored: (filePath) => {
-        const relativePath = path15.relative(this.projectRoot, filePath);
+        const relativePath = path16.relative(this.projectRoot, filePath);
         if (!relativePath) return false;
         if (this.isProjectConfigPathOrAncestor(relativePath)) {
           return false;
         }
-        if (hasFilteredPathSegment(relativePath, path15.sep)) {
+        if (hasFilteredPathSegment(relativePath, path16.sep)) {
           return true;
         }
-        if (isRestrictedDirectory(relativePath, path15.sep)) {
+        if (isRestrictedDirectory(relativePath, path16.sep)) {
           return true;
         }
         if (ignoreFilter.ignores(relativePath)) {
@@ -11218,24 +11436,24 @@ var FileWatcher = class {
     this.scheduleFlush();
   }
   isProjectConfigPath(filePath) {
-    const relativePath = path15.relative(this.projectRoot, filePath);
-    const normalizedRelativePath = path15.normalize(relativePath);
+    const relativePath = path16.relative(this.projectRoot, filePath);
+    const normalizedRelativePath = path16.normalize(relativePath);
     return this.getProjectConfigRelativePaths().some((configPath) => configPath === normalizedRelativePath);
   }
   isProjectConfigPathOrAncestor(relativePath) {
-    const normalizedRelativePath = path15.normalize(relativePath);
+    const normalizedRelativePath = path16.normalize(relativePath);
     return this.getProjectConfigRelativePaths().some(
-      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path15.sep}`)
+      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path16.sep}`)
     );
   }
   getProjectConfigRelativePaths() {
     if (this.configPath) {
-      return [path15.normalize(path15.relative(this.projectRoot, this.configPath))];
+      return [path16.normalize(path16.relative(this.projectRoot, this.configPath))];
     }
     return [
       resolveProjectConfigPath(this.projectRoot, this.host),
       resolveWritableProjectConfigPath(this.projectRoot, this.host)
-    ].map((configPath) => path15.normalize(path15.relative(this.projectRoot, configPath)));
+    ].map((configPath) => path16.normalize(path16.relative(this.projectRoot, configPath)));
   }
   scheduleFlush() {
     if (this.debounceTimer) {
@@ -11250,7 +11468,7 @@ var FileWatcher = class {
       return;
     }
     const changes = Array.from(this.pendingChanges.entries()).map(
-      ([path22, type]) => ({ path: path22, type })
+      ([path23, type]) => ({ path: path23, type })
     );
     this.pendingChanges.clear();
     try {
@@ -11277,7 +11495,7 @@ var FileWatcher = class {
 };
 
 // src/watcher/git-head-watcher.ts
-var path16 = __toESM(require("path"), 1);
+var path17 = __toESM(require("path"), 1);
 var GitHeadWatcher = class {
   watcher = null;
   projectRoot;
@@ -11299,7 +11517,7 @@ var GitHeadWatcher = class {
     this.onBranchChange = handler;
     this.currentBranch = getCurrentBranch(this.projectRoot);
     const headPath = getHeadPath(this.projectRoot);
-    const refsPath = path16.join(this.projectRoot, ".git", "refs", "heads");
+    const refsPath = path17.join(this.projectRoot, ".git", "refs", "heads");
     this.watcher = chokidar_default.watch([headPath, refsPath], {
       persistent: true,
       ignoreInitial: true,
@@ -11532,11 +11750,11 @@ var pr_impact = (0, import_plugin.tool)({
 // src/tools/index.ts
 var import_fs10 = require("fs");
 var os4 = __toESM(require("os"), 1);
-var path19 = __toESM(require("path"), 1);
+var path20 = __toESM(require("path"), 1);
 
 // src/tools/visualize/activity.ts
-var import_child_process3 = require("child_process");
-var path17 = __toESM(require("path"), 1);
+var import_child_process4 = require("child_process");
+var path18 = __toESM(require("path"), 1);
 function attachRecentActivity(data, projectRoot) {
   const activity = readGitActivity(projectRoot);
   const changes = activity.size > 0 ? buildGitChanges(data, activity, projectRoot) : buildGraphChanges(data);
@@ -11547,7 +11765,7 @@ function attachRecentActivity(data, projectRoot) {
 }
 function readGitActivity(projectRoot) {
   try {
-    const output = (0, import_child_process3.execFileSync)(
+    const output = (0, import_child_process4.execFileSync)(
       "git",
       ["-C", projectRoot, "log", "--since=90.days", "--numstat", "--date=short", "--pretty=format:__COMMIT__%x09%h%x09%ad%x09%s"],
       { encoding: "utf8", maxBuffer: 8 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] }
@@ -11698,7 +11916,7 @@ function normalizePath2(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function toGitRelativePath(projectRoot, filePath) {
-  const relativePath = path17.isAbsolute(filePath) ? path17.relative(projectRoot, filePath) : filePath;
+  const relativePath = path18.isAbsolute(filePath) ? path18.relative(projectRoot, filePath) : filePath;
   return normalizePath2(relativePath);
 }
 
@@ -11956,7 +12174,7 @@ render();
 }
 
 // src/tools/visualize/transform.ts
-var path18 = __toESM(require("path"), 1);
+var path19 = __toESM(require("path"), 1);
 
 // src/tools/visualize/modules.ts
 var MAX_MODULES = 18;
@@ -12089,8 +12307,8 @@ function compactModules(prefixToNodes) {
 function deriveModules(nodes) {
   const initial = /* @__PURE__ */ new Map();
   for (const node of nodes) {
-    const relative10 = stripToProjectRelative(node.filePath);
-    const prefix = modulePrefixFromRelativePath(relative10);
+    const relative11 = stripToProjectRelative(node.filePath);
+    const prefix = modulePrefixFromRelativePath(relative11);
     if (!initial.has(prefix)) initial.set(prefix, []);
     initial.get(prefix)?.push(node);
   }
@@ -12216,7 +12434,7 @@ function transformForVisualization(symbols, edges, options = {}) {
     filePath: s.filePath,
     kind: s.kind,
     line: s.startLine,
-    directory: path18.dirname(s.filePath),
+    directory: path19.dirname(s.filePath),
     moduleId: "",
     moduleLabel: ""
   }));
@@ -12267,7 +12485,10 @@ var codebase_peek = (0, import_plugin2.tool)({
     limit: z2.number().optional().default(10).describe("Maximum number of results to return"),
     fileType: z2.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
     directory: z2.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
-    chunkType: z2.enum(CHUNK_TYPE_VALUES).optional().describe("Filter by code chunk type")
+    chunkType: z2.enum(CHUNK_TYPE_VALUES).optional().describe("Filter by code chunk type"),
+    blameAuthor: z2.string().optional().describe("Filter by git blame author name or email"),
+    blameSha: z2.string().optional().describe("Filter by git blame commit SHA or prefix"),
+    blameSince: z2.string().optional().describe("Filter to chunks last changed on or after this date (e.g., 2025-01-01)")
   },
   async execute(args, context) {
     const results = await searchCodebase(context?.worktree, DEFAULT_HOST, args.query, {
@@ -12275,7 +12496,10 @@ var codebase_peek = (0, import_plugin2.tool)({
       fileType: args.fileType,
       directory: args.directory,
       chunkType: args.chunkType,
-      metadataOnly: true
+      metadataOnly: true,
+      blameAuthor: args.blameAuthor,
+      blameSha: args.blameSha,
+      blameSince: args.blameSince
     });
     return formatCodebasePeek(results);
   }
@@ -12358,7 +12582,10 @@ var codebase_search = (0, import_plugin2.tool)({
     fileType: z2.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
     directory: z2.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
     chunkType: z2.enum(CHUNK_TYPE_VALUES).optional().describe("Filter by code chunk type"),
-    contextLines: z2.number().optional().describe("Number of extra lines to include before/after each match (default: 0)")
+    contextLines: z2.number().optional().describe("Number of extra lines to include before/after each match (default: 0)"),
+    blameAuthor: z2.string().optional().describe("Filter by git blame author name or email"),
+    blameSha: z2.string().optional().describe("Filter by git blame commit SHA or prefix"),
+    blameSince: z2.string().optional().describe("Filter to chunks last changed on or after this date (e.g., 2025-01-01)")
   },
   async execute(args, context) {
     const results = await searchCodebase(context?.worktree, DEFAULT_HOST, args.query, {
@@ -12366,7 +12593,10 @@ var codebase_search = (0, import_plugin2.tool)({
       fileType: args.fileType,
       directory: args.directory,
       chunkType: args.chunkType,
-      contextLines: args.contextLines
+      contextLines: args.contextLines,
+      blameAuthor: args.blameAuthor,
+      blameSha: args.blameSha,
+      blameSince: args.blameSince
     });
     if (results.length === 0) {
       return "No matching code found. Try a different query or run index_codebase first.";
@@ -12405,22 +12635,10 @@ var call_graph = (0, import_plugin2.tool)({
         return "Error: 'symbolId' is required when direction is 'callees'. First use direction='callers' to find the symbol ID.";
       }
       const { callees } = await getCallGraphData(context?.worktree, DEFAULT_HOST, args);
-      if (callees.length === 0) {
-        return `No callees found for symbol ${args.symbolId}${args.relationshipType ? ` with type ${args.relationshipType}` : ""}. The function may not call any other tracked functions.`;
-      }
-      return callees.map((edge, index) => {
-        const confidence = edge.confidence !== "Direct" ? ` [${edge.confidence.toLowerCase()}]` : "";
-        return `[${index + 1}] \u2192 ${edge.targetName} (${edge.callType})${confidence} at line ${edge.line}${edge.isResolved ? ` [resolved: ${edge.toSymbolId}]` : " [unresolved]"}`;
-      }).join("\n");
+      return formatCallGraphCallees(args.symbolId, callees, args.relationshipType);
     }
     const { callers } = await getCallGraphData(context?.worktree, DEFAULT_HOST, args);
-    if (callers.length === 0) {
-      return `No callers found for "${args.name}"${args.relationshipType ? ` with type ${args.relationshipType}` : ""}. It may not be called by any tracked function, or the index needs updating.`;
-    }
-    return callers.map((edge, index) => {
-      const confidence = edge.confidence !== "Direct" ? ` [${edge.confidence.toLowerCase()}]` : "";
-      return `[${index + 1}] \u2190 from ${edge.fromSymbolName ?? "<unknown>"} in ${edge.fromSymbolFilePath ?? "<unknown file>"} [${edge.fromSymbolId}] (${edge.callType})${confidence} at line ${edge.line}${edge.isResolved ? " [resolved]" : " [unresolved]"}`;
-    }).join("\n");
+    return formatCallGraphCallers(args.name, callers, args.relationshipType);
   }
 });
 var call_graph_path = (0, import_plugin2.tool)({
@@ -12431,17 +12649,8 @@ var call_graph_path = (0, import_plugin2.tool)({
     maxDepth: z2.number().optional().default(10).describe("Maximum traversal depth (default: 10)")
   },
   async execute(args, context) {
-    const path22 = await getCallGraphPath(context?.worktree, DEFAULT_HOST, args.from, args.to, args.maxDepth);
-    if (path22.length === 0) {
-      return `No path found between "${args.from}" and "${args.to}". They may be in disconnected components, or the call graph index needs updating.`;
-    }
-    const formatted = path22.map((hop, index) => {
-      const prefix = index === 0 ? "[start]" : `--${hop.callType}-->`;
-      const location = hop.filePath ? ` (${hop.filePath}:${hop.line})` : "";
-      return `${prefix} ${hop.symbolName}${location}`;
-    });
-    return `Path (${path22.length} hops):
-${formatted.join("\n")}`;
+    const path23 = await getCallGraphPath(context?.worktree, DEFAULT_HOST, args.from, args.to, args.maxDepth);
+    return formatCallGraphPath(args.from, args.to, path23);
   }
 });
 var add_knowledge_base = (0, import_plugin2.tool)({
@@ -12494,7 +12703,7 @@ var index_visualize = (0, import_plugin2.tool)({
       return "No connected symbols found for visualization. Try including orphans with includeOrphans=true, or check that the call graph has resolved edges.";
     }
     const html = generateVisualizationHtml(vizData);
-    const outputPath = path19.join(os4.tmpdir(), `call-graph-${Date.now()}.html`);
+    const outputPath = path20.join(os4.tmpdir(), `call-graph-${Date.now()}.html`);
     (0, import_fs10.writeFileSync)(outputPath, html, "utf-8");
     let result = `Temporal call graph visualization generated: ${outputPath}
 
@@ -12517,7 +12726,7 @@ var index_visualize = (0, import_plugin2.tool)({
 
 // src/commands/loader.ts
 var import_fs11 = require("fs");
-var path20 = __toESM(require("path"), 1);
+var path21 = __toESM(require("path"), 1);
 function parseFrontmatter(content) {
   const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
   const match = content.match(frontmatterRegex);
@@ -12543,7 +12752,7 @@ function loadCommandsFromDirectory(commandsDir) {
   }
   const files = (0, import_fs11.readdirSync)(commandsDir).filter((f) => f.endsWith(".md"));
   for (const file of files) {
-    const filePath = path20.join(commandsDir, file);
+    const filePath = path21.join(commandsDir, file);
     let content;
     try {
       content = (0, import_fs11.readFileSync)(filePath, "utf-8");
@@ -12552,7 +12761,7 @@ function loadCommandsFromDirectory(commandsDir) {
       throw new Error(`Failed to load command file ${filePath}: ${message}`);
     }
     const { frontmatter, body } = parseFrontmatter(content);
-    const name = path20.basename(file, ".md");
+    const name = path21.basename(file, ".md");
     const description = frontmatter.description || `Run the ${name} command`;
     commands.set(name, {
       description,
@@ -12885,9 +13094,9 @@ function replaceActiveWatcher(projectRoot, nextWatcher) {
 function getCommandsDir() {
   let currentDir = process.cwd();
   if (typeof import_meta2 !== "undefined" && import_meta2.url) {
-    currentDir = path21.dirname((0, import_url2.fileURLToPath)(import_meta2.url));
+    currentDir = path22.dirname((0, import_url2.fileURLToPath)(import_meta2.url));
   }
-  return path21.join(currentDir, "..", "commands");
+  return path22.join(currentDir, "..", "commands");
 }
 function appendRoutingHints(output, hints, preferredRole) {
   const preferredBucket = preferredRole === "developer" ? output.developer : output.system;
@@ -12907,7 +13116,7 @@ var plugin = async ({ directory, worktree }) => {
     initializeTools2(projectRoot, config);
     const getProjectIndexer = () => getIndexerForProject2(projectRoot);
     const routingHints = config.search.routingHints ? new RoutingHintController(() => getProjectIndexer().getStatus(), 200, config.search.routingGraphHandoffHints) : null;
-    const isHomeDir = path21.resolve(projectRoot) === path21.resolve(os5.homedir());
+    const isHomeDir = path22.resolve(projectRoot) === path22.resolve(os5.homedir());
     const isValidProject = !isHomeDir && (!config.indexing.requireProjectMarker || hasProjectMarker(projectRoot));
     if (isHomeDir) {
       console.warn(