opencode-codebase-index 0.11.0 → 0.12.0

package/dist/cli.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(path18, checkUnignored, mode) {
+      test(path19, 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(path18);
+          const matched = rule[mode].test(path19);
           if (!matched) {
             return;
           }
@@ -521,17 +521,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path18, originalPath, doThrow) => {
-      if (!isString(path18)) {
+    var checkPath = (path19, originalPath, doThrow) => {
+      if (!isString(path19)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path18) {
+      if (!path19) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path18)) {
+      if (checkPath.isNotRelative(path19)) {
         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 = (path18) => REGEX_TEST_INVALID_PATH.test(path18);
+    var isNotRelative = (path19) => REGEX_TEST_INVALID_PATH.test(path19);
     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 path18 = originalPath && checkPath.convert(originalPath);
+        const path19 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path18,
+          path19,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path18, cache, checkUnignored, slices);
+        return this._t(path19, cache, checkUnignored, slices);
       }
-      checkIgnore(path18) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path18)) {
-          return this.test(path18);
+      checkIgnore(path19) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path19)) {
+          return this.test(path19);
         }
-        const slices = path18.split(SLASH).filter(Boolean);
+        const slices = path19.split(SLASH).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(path18, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path19, false, MODE_CHECK_IGNORE);
       }
-      _t(path18, cache, checkUnignored, slices) {
-        if (path18 in cache) {
-          return cache[path18];
+      _t(path19, cache, checkUnignored, slices) {
+        if (path19 in cache) {
+          return cache[path19];
         }
         if (!slices) {
-          slices = path18.split(SLASH).filter(Boolean);
+          slices = path19.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path18] = this._rules.test(path18, checkUnignored, MODE_IGNORE);
+          return cache[path19] = this._rules.test(path19, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -614,29 +614,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path18] = parent.ignored ? parent : this._rules.test(path18, checkUnignored, MODE_IGNORE);
+        return cache[path19] = parent.ignored ? parent : this._rules.test(path19, checkUnignored, MODE_IGNORE);
       }
-      ignores(path18) {
-        return this._test(path18, this._ignoreCache, false).ignored;
+      ignores(path19) {
+        return this._test(path19, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path18) => !this.ignores(path18);
+        return (path19) => !this.ignores(path19);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path18) {
-        return this._test(path18, this._testCache, true);
+      test(path19) {
+        return this._test(path19, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path18) => checkPath(path18 && checkPath.convert(path18), path18, RETURN_FALSE);
+    var isPathValid = (path19) => checkPath(path19 && checkPath.convert(path19), path19, 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 = (path18) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path18) || isNotRelative(path18);
+      checkPath.isNotRelative = (path19) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path19) || isNotRelative(path19);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -653,7 +653,7 @@ var require_ignore = __commonJS({
 
 // src/cli.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import * as path17 from "path";
+import * as path18 from "path";
 
 // src/config/constants.ts
 var DEFAULT_INCLUDE = [
@@ -799,6 +799,7 @@ function getDefaultSearchConfig() {
     rerankTopN: 20,
     contextLines: 0,
     routingHints: true,
+    routingGraphHandoffHints: false,
     routingHintRole: "system"
   };
 }
@@ -921,6 +922,7 @@ function parseConfig(raw) {
     rerankTopN: typeof rawSearch.rerankTopN === "number" ? Math.min(200, Math.max(0, Math.floor(rawSearch.rerankTopN))) : defaultSearch.rerankTopN,
     contextLines: typeof rawSearch.contextLines === "number" ? Math.min(50, Math.max(0, rawSearch.contextLines)) : defaultSearch.contextLines,
     routingHints: typeof rawSearch.routingHints === "boolean" ? rawSearch.routingHints : defaultSearch.routingHints,
+    routingGraphHandoffHints: typeof rawSearch.routingGraphHandoffHints === "boolean" ? rawSearch.routingGraphHandoffHints : defaultSearch.routingGraphHandoffHints,
     routingHintRole: rawSearch.routingHintRole === "developer" || rawSearch.routingHintRole === "system" ? rawSearch.routingHintRole : defaultSearch.routingHintRole
   };
   const rawDebug = input.debug && typeof input.debug === "object" ? input.debug : {};
@@ -1079,9 +1081,9 @@ import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import * as path from "path";
 
 // src/eval/report-formatters.ts
-function assertFiniteNumber(value, path18) {
+function assertFiniteNumber(value, path19) {
   if (typeof value !== "number" || Number.isNaN(value) || !Number.isFinite(value)) {
-    throw new Error(`${path18} must be a finite number`);
+    throw new Error(`${path19} must be a finite number`);
   }
   return value;
 }
@@ -1270,13 +1272,15 @@ function buildPerQueryArtifact(perQuery) {
 
 // src/eval/runner.ts
 import { existsSync as existsSync8 } from "fs";
-import * as path12 from "path";
+import * as path13 from "path";
 import { performance as performance3 } from "perf_hooks";
 
 // src/indexer/index.ts
 import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync2, renameSync, unlinkSync, mkdirSync as mkdirSync2, promises as fsPromises2 } from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 import { performance as performance2 } from "perf_hooks";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
 
 // node_modules/eventemitter3/index.mjs
 var import_index = __toESM(require_eventemitter3(), 1);
@@ -1300,7 +1304,7 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve10, reject) => {
+  const wrappedPromise = new Promise((resolve11, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
@@ -1314,7 +1318,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve10, reject);
+    promise.then(resolve11, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -1322,7 +1326,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve10(fallback());
+          resolve11(fallback());
         } catch (error) {
           reject(error);
         }
@@ -1332,7 +1336,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve10();
+        resolve11();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -1734,7 +1738,7 @@ var PQueue = class extends import_index.default {
       // Assign unique ID if not provided
       id: options.id ?? (this.#idAssigner++).toString()
     };
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve11, reject) => {
       const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
       let cleanupQueueAbortHandler = () => void 0;
       const run = async () => {
@@ -1774,7 +1778,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve10(result);
+          resolve11(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -1962,13 +1966,13 @@ var PQueue = class extends import_index.default {
     });
   }
   async #onEvent(event, filter) {
-    return new Promise((resolve10) => {
+    return new Promise((resolve11) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve10();
+        resolve11();
       };
       this.on(event, listener);
     });
@@ -2254,7 +2258,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
   const finalDelay = Math.min(delayTime, remainingTime);
   options.signal?.throwIfAborted();
   if (finalDelay > 0) {
-    await new Promise((resolve10, reject) => {
+    await new Promise((resolve11, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
         options.signal?.removeEventListener("abort", onAbort);
@@ -2262,7 +2266,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve10();
+        resolve11();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -3681,6 +3685,15 @@ function createMockNativeBinding() {
       close() {
         throw error;
       }
+      getTransitiveReachability() {
+        throw error;
+      }
+      detectCommunities() {
+        throw error;
+      }
+      computeCentrality() {
+        throw error;
+      }
     }
   };
 }
@@ -4231,6 +4244,14 @@ var Database = class {
     this.throwIfClosed();
     return this.inner.getSymbolsByNameCi(name);
   }
+  getSymbolsForBranch(branch) {
+    this.throwIfClosed();
+    return this.inner.getSymbolsForBranch(branch);
+  }
+  getSymbolsForFiles(filePaths, branch) {
+    this.throwIfClosed();
+    return this.inner.getSymbolsForFiles(filePaths, branch);
+  }
   deleteSymbolsByFile(filePath) {
     this.throwIfClosed();
     return this.inner.deleteSymbolsByFile(filePath);
@@ -4308,6 +4329,23 @@ var Database = class {
     this.throwIfClosed();
     return this.inner.gcOrphanCallEdges();
   }
+  getTransitiveReachability(rootSymbolIds, branch, direction, maxDepth) {
+    this.throwIfClosed();
+    return this.inner.getTransitiveReachability(
+      rootSymbolIds,
+      branch,
+      direction,
+      maxDepth ?? null
+    );
+  }
+  detectCommunities(branch, symbolIds) {
+    this.throwIfClosed();
+    return this.inner.detectCommunities(branch, symbolIds ?? null);
+  }
+  computeCentrality(branch) {
+    this.throwIfClosed();
+    return this.inner.computeCentrality(branch);
+  }
 };
 
 // src/git/index.ts
@@ -4481,6 +4519,106 @@ function resolveProjectIndexPath(projectRoot, scope) {
   return resolveWorktreeFallbackPath(projectRoot, PROJECT_INDEX_RELATIVE_PATH) ?? localIndexPath;
 }
 
+// src/tools/changed-files.ts
+import * as path9 from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function getErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+async function getChangedFiles(opts) {
+  const { pr, branch, projectRoot, baseBranch = "main" } = opts;
+  if (pr !== void 0) {
+    return getChangedFilesForPr(pr, projectRoot, baseBranch);
+  }
+  return getChangedFilesForBranch(branch, projectRoot, baseBranch);
+}
+async function getChangedFilesForPr(pr, projectRoot, baseBranch) {
+  let headRefName;
+  let actualBaseBranch = baseBranch;
+  try {
+    const { stdout } = await execFileAsync(
+      "gh",
+      ["pr", "view", String(pr), "--json", "headRefName,baseRefName,files"],
+      { cwd: projectRoot, timeout: 3e4 }
+    );
+    const data = JSON.parse(stdout);
+    headRefName = data.headRefName;
+    actualBaseBranch = data.baseRefName || baseBranch;
+    if (data.files && data.files.length > 0) {
+      return {
+        files: normalizeFiles(
+          data.files.map((f) => f.path),
+          projectRoot
+        ),
+        baseBranch: actualBaseBranch,
+        source: "gh",
+        headRefName
+      };
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to retrieve PR #${pr} via gh CLI: ${getErrorMessage(error)}`
+    );
+  }
+  if (headRefName === void 0) {
+    throw new Error(
+      `PR #${pr} returned no usable branch or file information.`
+    );
+  }
+  const result = await getChangedFilesForBranch(headRefName, projectRoot, actualBaseBranch);
+  return { ...result, headRefName };
+}
+async function getChangedFilesForBranch(branch, projectRoot, baseBranch) {
+  const targetBranch = branch || await getCurrentBranch2(projectRoot);
+  const mergeBase = await getMergeBase(projectRoot, baseBranch, targetBranch);
+  const { stdout } = await execFileAsync(
+    "git",
+    ["diff", "--name-only", `${mergeBase}...${targetBranch}`],
+    { cwd: projectRoot, timeout: 3e4 }
+  );
+  return {
+    files: normalizeFiles(stdout.split("\n"), projectRoot),
+    baseBranch,
+    source: "git",
+    headRefName: targetBranch
+  };
+}
+async function getCurrentBranch2(projectRoot) {
+  const { stdout } = await execFileAsync(
+    "git",
+    ["branch", "--show-current"],
+    { cwd: projectRoot, timeout: 3e4 }
+  );
+  return stdout.trim() || "HEAD";
+}
+async function getMergeBase(projectRoot, baseBranch, branch) {
+  const { stdout } = await execFileAsync(
+    "git",
+    ["merge-base", baseBranch, branch],
+    { cwd: projectRoot, timeout: 3e4 }
+  );
+  return stdout.trim();
+}
+function normalizeFiles(rawFiles, projectRoot) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const raw of rawFiles) {
+    const trimmed = raw.trim();
+    if (!trimmed) continue;
+    const absolute = path9.resolve(projectRoot, trimmed);
+    const relative5 = path9.relative(projectRoot, absolute);
+    const cleaned = relative5.startsWith("./") ? relative5.slice(2) : relative5;
+    if (!seen.has(cleaned)) {
+      seen.add(cleaned);
+      result.push(cleaned);
+    }
+  }
+  return result;
+}
+
 // src/indexer/index.ts
 var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "php", "apex", "zig", "gdscript", "matlab"]);
 var CASE_INSENSITIVE_LANGUAGES = /* @__PURE__ */ new Set(["apex"]);
@@ -4488,6 +4626,7 @@ var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "function_declaration",
   "function",
   "arrow_function",
+  "export_statement",
   "method_definition",
   "class_declaration",
   "interface_declaration",
@@ -4526,7 +4665,7 @@ function float32ArrayToBuffer(arr) {
 function bufferToFloat32Array(buf) {
   return new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
 }
-function getErrorMessage(error) {
+function getErrorMessage2(error) {
   if (error instanceof Error) {
     return error.message;
   }
@@ -4539,7 +4678,7 @@ function getErrorMessage(error) {
   return String(error);
 }
 function isRateLimitError(error) {
-  const message = getErrorMessage(error);
+  const message = getErrorMessage2(error);
   return message.includes("429") || message.toLowerCase().includes("rate limit") || message.toLowerCase().includes("too many requests");
 }
 function getSafeEmbeddingChunkTokenLimit(provider) {
@@ -4557,7 +4696,7 @@ function getDynamicBatchOptions(provider) {
   return {};
 }
 function isSqliteCorruptionError(error) {
-  const message = getErrorMessage(error).toLowerCase();
+  const message = getErrorMessage2(error).toLowerCase();
   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";
@@ -4719,9 +4858,9 @@ function hasAllEmbeddingParts(parts, expectedPartCount) {
   return true;
 }
 function isPathWithinRoot(filePath, rootPath) {
-  const normalizedFilePath = path9.resolve(filePath);
-  const normalizedRoot = path9.resolve(rootPath);
-  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path9.sep}`);
+  const normalizedFilePath = path10.resolve(filePath);
+  const normalizedRoot = path10.resolve(rootPath);
+  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path10.sep}`);
 }
 var rankingQueryTokenCache = /* @__PURE__ */ new Map();
 var rankingNameTokenCache = /* @__PURE__ */ new Map();
@@ -5774,9 +5913,9 @@ var Indexer = class {
     this.projectRoot = projectRoot;
     this.config = config;
     this.indexPath = this.getIndexPath();
-    this.fileHashCachePath = path9.join(this.indexPath, "file-hashes.json");
-    this.failedBatchesPath = path9.join(this.indexPath, "failed-batches.json");
-    this.indexingLockPath = path9.join(this.indexPath, "indexing.lock");
+    this.fileHashCachePath = path10.join(this.indexPath, "file-hashes.json");
+    this.failedBatchesPath = path10.join(this.indexPath, "failed-batches.json");
+    this.indexingLockPath = path10.join(this.indexPath, "indexing.lock");
     this.logger = initializeLogger(config.debug);
   }
   getIndexPath() {
@@ -5808,14 +5947,14 @@ var Indexer = class {
   }
   atomicWriteSync(targetPath, data) {
     const tempPath = `${targetPath}.tmp`;
-    mkdirSync2(path9.dirname(targetPath), { recursive: true });
+    mkdirSync2(path10.dirname(targetPath), { recursive: true });
     writeFileSync2(tempPath, data);
     renameSync(tempPath, targetPath);
   }
   getScopedRoots() {
-    const roots = /* @__PURE__ */ new Set([path9.resolve(this.projectRoot)]);
+    const roots = /* @__PURE__ */ new Set([path10.resolve(this.projectRoot)]);
     for (const kbRoot of this.config.knowledgeBases) {
-      roots.add(path9.resolve(this.projectRoot, kbRoot));
+      roots.add(path10.resolve(this.projectRoot, kbRoot));
     }
     return Array.from(roots);
   }
@@ -5824,22 +5963,29 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return branchName;
     }
-    const projectHash = hashContent(path9.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path10.resolve(this.projectRoot)).slice(0, 16);
+    return `${projectHash}:${branchName}`;
+  }
+  getBranchCatalogKeyFor(branchName) {
+    if (this.config.scope !== "global") {
+      return branchName;
+    }
+    const projectHash = hashContent(path10.resolve(this.projectRoot)).slice(0, 16);
     return `${projectHash}:${branchName}`;
   }
   getLegacyBranchCatalogKey() {
     return this.currentBranch || "default";
   }
   getLegacyMigrationMetadataKey() {
-    const projectHash = hashContent(path9.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path10.resolve(this.projectRoot)).slice(0, 16);
     return `index.globalBranchMigration.${projectHash}`;
   }
   getProjectEmbeddingStrategyMetadataKey() {
-    const projectHash = hashContent(path9.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path10.resolve(this.projectRoot)).slice(0, 16);
     return `index.embeddingStrategyVersion.${projectHash}`;
   }
   getProjectForceReembedMetadataKey() {
-    const projectHash = hashContent(path9.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path10.resolve(this.projectRoot)).slice(0, 16);
     return `index.forceReembed.${projectHash}`;
   }
   hasProjectForceReembedPending() {
@@ -5933,7 +6079,7 @@ var Indexer = class {
     if (!this.database) {
       return { chunkIds, symbolIds };
     }
-    const projectRootPath = path9.resolve(this.projectRoot);
+    const projectRootPath = path10.resolve(this.projectRoot);
     const projectLocalFilePaths = /* @__PURE__ */ new Set([
       ...Array.from(this.fileHashCache.keys()).filter(
         (filePath) => this.isFileInCurrentScope(filePath, roots) && isPathWithinRoot(filePath, projectRootPath)
@@ -5956,7 +6102,7 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return this.getBranchCatalogCleanupKeys();
     }
-    const projectHash = hashContent(path9.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path10.resolve(this.projectRoot)).slice(0, 16);
     const keys = /* @__PURE__ */ new Set();
     const projectChunkIdSet = new Set(projectChunkIds);
     const projectSymbolIdSet = new Set(projectSymbolIds);
@@ -6040,7 +6186,7 @@ var Indexer = class {
     if (!this.database || this.config.scope !== "global") {
       return false;
     }
-    const projectHash = hashContent(path9.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path10.resolve(this.projectRoot)).slice(0, 16);
     const roots = this.getScopedRoots();
     const { chunkIds: projectLocalChunkIds, symbolIds: projectLocalSymbolIds } = this.getProjectLocalScopedOwnershipIds(roots);
     return this.database.getAllBranches().some(
@@ -6074,7 +6220,7 @@ var Indexer = class {
       ...Array.from(this.fileHashCache.keys()).filter((filePath) => this.isFileInCurrentScope(filePath, roots)),
       ...scopedEntries.map(({ metadata }) => metadata.filePath)
     ]);
-    const projectRootPath = path9.resolve(this.projectRoot);
+    const projectRootPath = path10.resolve(this.projectRoot);
     const projectLocalFilePaths = new Set(
       Array.from(filePaths).filter((filePath) => isPathWithinRoot(filePath, projectRootPath))
     );
@@ -6327,7 +6473,7 @@ var Indexer = class {
       this.logger.search("warn", "External reranker failed; using deterministic order", {
         provider: reranker.provider,
         model: reranker.model,
-        error: getErrorMessage(error)
+        error: getErrorMessage2(error)
       });
       return candidates;
     }
@@ -6434,13 +6580,13 @@ var Indexer = class {
     }
     await fsPromises2.mkdir(this.indexPath, { recursive: true });
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path9.join(this.indexPath, "vectors");
+    const storePath = path10.join(this.indexPath, "vectors");
     this.store = new VectorStore(storePath, dimensions);
-    const indexFilePath = path9.join(this.indexPath, "vectors.usearch");
+    const indexFilePath = path10.join(this.indexPath, "vectors.usearch");
     if (existsSync6(indexFilePath)) {
       this.store.load();
     }
-    const invertedIndexPath = path9.join(this.indexPath, "inverted-index.json");
+    const invertedIndexPath = path10.join(this.indexPath, "inverted-index.json");
     this.invertedIndex = new InvertedIndex(invertedIndexPath);
     try {
       this.invertedIndex.load();
@@ -6450,7 +6596,7 @@ var Indexer = class {
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
     }
-    const dbPath = path9.join(this.indexPath, "codebase.db");
+    const dbPath = path10.join(this.indexPath, "codebase.db");
     let dbIsNew = !existsSync6(dbPath);
     try {
       this.database = new Database(dbPath);
@@ -6531,7 +6677,7 @@ var Indexer = class {
         if (await this.tryResetCorruptedIndex("running automatic orphan garbage collection", error)) {
           return {
             resetCorruptedIndex: true,
-            warning: this.getCorruptedIndexWarning(path9.join(this.indexPath, "codebase.db"))
+            warning: this.getCorruptedIndexWarning(path10.join(this.indexPath, "codebase.db"))
           };
         }
         throw error;
@@ -6546,7 +6692,7 @@ var Indexer = class {
       return;
     }
     const retainedEntries = store.getAllMetadata().filter(({ key }) => !excludedSet.has(key));
-    const storeBasePath = path9.join(this.indexPath, "vectors");
+    const storeBasePath = path10.join(this.indexPath, "vectors");
     const storeIndexPath = `${storeBasePath}.usearch`;
     const storeMetadataPath = `${storeBasePath}.meta.json`;
     const backupIndexPath = `${storeIndexPath}.bak`;
@@ -6631,9 +6777,9 @@ var Indexer = class {
     if (!isSqliteCorruptionError(error)) {
       return false;
     }
-    const dbPath = path9.join(this.indexPath, "codebase.db");
+    const dbPath = path10.join(this.indexPath, "codebase.db");
     const warning = this.getCorruptedIndexWarning(dbPath);
-    const errorMessage = getErrorMessage(error);
+    const errorMessage = getErrorMessage2(error);
     if (this.config.scope === "global") {
       this.logger.error("Detected corrupted shared global index database", {
         stage,
@@ -6654,15 +6800,15 @@ var Indexer = class {
     this.indexCompatibility = null;
     this.fileHashCache.clear();
     const resetPaths = [
-      path9.join(this.indexPath, "codebase.db"),
-      path9.join(this.indexPath, "codebase.db-shm"),
-      path9.join(this.indexPath, "codebase.db-wal"),
-      path9.join(this.indexPath, "vectors.usearch"),
-      path9.join(this.indexPath, "inverted-index.json"),
-      path9.join(this.indexPath, "file-hashes.json"),
-      path9.join(this.indexPath, "failed-batches.json"),
-      path9.join(this.indexPath, "indexing.lock"),
-      path9.join(this.indexPath, "vectors")
+      path10.join(this.indexPath, "codebase.db"),
+      path10.join(this.indexPath, "codebase.db-shm"),
+      path10.join(this.indexPath, "codebase.db-wal"),
+      path10.join(this.indexPath, "vectors.usearch"),
+      path10.join(this.indexPath, "inverted-index.json"),
+      path10.join(this.indexPath, "file-hashes.json"),
+      path10.join(this.indexPath, "failed-batches.json"),
+      path10.join(this.indexPath, "indexing.lock"),
+      path10.join(this.indexPath, "vectors")
     ];
     await Promise.all(resetPaths.map(async (targetPath) => {
       try {
@@ -6927,7 +7073,7 @@ var Indexer = class {
     for (const parsed of parsedFiles) {
       currentFilePaths.add(parsed.path);
       if (parsed.chunks.length === 0) {
-        const relativePath = path9.relative(this.projectRoot, parsed.path);
+        const relativePath = path10.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
       let fileChunkCount = 0;
@@ -7211,7 +7357,7 @@ var Indexer = class {
     for (const requestBatch of requestBatches) {
       queue.add(async () => {
         if (rateLimitBackoffMs > 0) {
-          await new Promise((resolve10) => setTimeout(resolve10, rateLimitBackoffMs));
+          await new Promise((resolve11) => setTimeout(resolve11, rateLimitBackoffMs));
         }
         try {
           const result = await pRetry(
@@ -7226,7 +7372,7 @@ var Indexer = class {
               factor: 2,
               shouldRetry: (error) => !(error.error instanceof CustomProviderNonRetryableError),
               onFailedAttempt: (error) => {
-                const message = getErrorMessage(error);
+                const message = getErrorMessage2(error);
                 if (isRateLimitError(error)) {
                   rateLimitBackoffMs = Math.min(providerRateLimits.maxRetryMs, (rateLimitBackoffMs || providerRateLimits.minRetryMs) * 2);
                   this.logger.embedding("warn", `Rate limited, backing off`, {
@@ -7333,7 +7479,7 @@ var Indexer = class {
           });
         } catch (error) {
           const failedChunks = getUniquePendingChunksFromRequests(requestBatch).filter((chunk) => !completedChunkIds.has(chunk.id));
-          const failureMessage = getErrorMessage(error);
+          const failureMessage = getErrorMessage2(error);
           const failureTimestamp = (/* @__PURE__ */ new Date()).toISOString();
           for (const chunk of failedChunks) {
             if (!failedChunkIds.has(chunk.id)) {
@@ -7772,8 +7918,8 @@ var Indexer = class {
       this.indexCompatibility = compatibility;
       return;
     }
-    const localProjectIndexPath = path9.join(this.projectRoot, ".opencode", "index");
-    if (path9.resolve(this.indexPath) !== path9.resolve(localProjectIndexPath)) {
+    const localProjectIndexPath = path10.join(this.projectRoot, ".opencode", "index");
+    if (path10.resolve(this.indexPath) !== path10.resolve(localProjectIndexPath)) {
       throw new Error(
         "Project-scoped force rebuild is unsafe while using an inherited worktree index. Create a local project config boundary before clearing the index."
       );
@@ -7861,7 +8007,7 @@ var Indexer = class {
         gcOrphanSymbols: 0,
         gcOrphanCallEdges: 0,
         resetCorruptedIndex: true,
-        warning: this.getCorruptedIndexWarning(path9.join(this.indexPath, "codebase.db"))
+        warning: this.getCorruptedIndexWarning(path10.join(this.indexPath, "codebase.db"))
       };
     }
     this.logger.recordGc(removedCount, gcOrphanChunks, gcOrphanEmbeddings);
@@ -8012,7 +8158,7 @@ var Indexer = class {
         succeeded += successfulResults.length;
         stillFailing.push(...failedChunksForBatch.values());
       } catch (error) {
-        const failureMessage = getErrorMessage(error);
+        const failureMessage = getErrorMessage2(error);
         const failureTimestamp = (/* @__PURE__ */ new Date()).toISOString();
         const unaccountedChunks = batch.chunks.filter(
           (chunk) => !failedChunksForBatch.has(chunk.id) && !completedChunkIds.has(chunk.id)
@@ -8218,13 +8364,194 @@ var Indexer = class {
     const { database } = await this.ensureInitialized();
     let shortest = [];
     for (const branchKey of this.getBranchCatalogKeys()) {
-      const path18 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
-      if (path18.length > 0 && (shortest.length === 0 || path18.length < shortest.length)) {
-        shortest = path18;
+      const path19 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
+      if (path19.length > 0 && (shortest.length === 0 || path19.length < shortest.length)) {
+        shortest = path19;
       }
     }
     return shortest;
   }
+  async getSymbolsForBranch(branch) {
+    const { database } = await this.ensureInitialized();
+    const resolvedBranch = branch ?? this.getBranchCatalogKey();
+    return database.getSymbolsForBranch(resolvedBranch);
+  }
+  async getSymbolsForFiles(filePaths, branch) {
+    const { database } = await this.ensureInitialized();
+    const resolvedBranch = branch ?? this.getBranchCatalogKey();
+    return database.getSymbolsForFiles(filePaths, resolvedBranch);
+  }
+  async getTransitiveReachability(rootSymbolIds, direction, maxDepth) {
+    const { database } = await this.ensureInitialized();
+    const branch = this.getBranchCatalogKey();
+    return database.getTransitiveReachability(rootSymbolIds, branch, direction, maxDepth);
+  }
+  async detectCommunities(branch, symbolIds) {
+    const { database } = await this.ensureInitialized();
+    const resolvedBranch = branch ?? this.getBranchCatalogKey();
+    return database.detectCommunities(resolvedBranch, symbolIds);
+  }
+  async computeCentrality(branch) {
+    const { database } = await this.ensureInitialized();
+    const resolvedBranch = branch ?? this.getBranchCatalogKey();
+    return database.computeCentrality(resolvedBranch);
+  }
+  async getPrImpact(opts) {
+    const { database } = await this.ensureInitialized();
+    const execFileAsync2 = promisify2(execFile2);
+    const changedFilesResult = await getChangedFiles({
+      pr: opts.pr,
+      branch: opts.branch,
+      projectRoot: this.projectRoot,
+      baseBranch: this.baseBranch
+    });
+    const changedFiles = changedFilesResult.files;
+    const headRefName = changedFilesResult.headRefName;
+    if (opts.pr !== void 0 && headRefName === void 0) {
+      throw new Error(
+        `Could not resolve head branch for PR #${opts.pr}. Run index_codebase on the PR branch first.`
+      );
+    }
+    const resolvedBranch = opts.pr !== void 0 ? headRefName : opts.branch || this.currentBranch;
+    const branchKey = this.getBranchCatalogKeyFor(resolvedBranch || "default");
+    const branchSymbols = database.getSymbolsForBranch(branchKey);
+    if (branchSymbols.length === 0) {
+      throw new Error(
+        "Run index_codebase first to build the call graph and symbol index for this branch."
+      );
+    }
+    const absoluteChangedFiles = changedFiles.map((f) => path10.resolve(this.projectRoot, f));
+    const directSymbols = database.getSymbolsForFiles(absoluteChangedFiles, branchKey);
+    const directIds = directSymbols.map((s) => s.id);
+    const direction = opts.direction ?? "both";
+    const maxDepth = opts.maxDepth ?? 5;
+    const transitiveCallers = database.getTransitiveReachability(
+      directIds,
+      branchKey,
+      direction,
+      maxDepth
+    );
+    const affectedIdsSet = new Set(directIds);
+    for (const caller of transitiveCallers) {
+      affectedIdsSet.add(caller.symbolId);
+    }
+    const allAffectedIds = Array.from(affectedIdsSet);
+    const communitiesData = database.detectCommunities(branchKey, allAffectedIds);
+    const communityMap = /* @__PURE__ */ new Map();
+    for (const c of communitiesData) {
+      if (!communityMap.has(c.communityLabel)) {
+        communityMap.set(c.communityLabel, {
+          label: c.communityLabel,
+          symbolCount: 0,
+          directSymbols: /* @__PURE__ */ new Set()
+        });
+      }
+      const entry = communityMap.get(c.communityLabel);
+      entry.symbolCount++;
+      if (directIds.includes(c.symbolId)) {
+        entry.directSymbols.add(c.symbolId);
+      }
+    }
+    const communities = Array.from(communityMap.values()).map((c) => ({
+      label: c.label,
+      symbolCount: c.symbolCount,
+      directSymbols: Array.from(c.directSymbols)
+    }));
+    const centralityData = database.computeCentrality(branchKey);
+    const hubThreshold = opts.hubThreshold ?? 10;
+    const hubNodes = centralityData.filter((c) => directIds.includes(c.symbolId) && c.callerCount >= hubThreshold).map((c) => ({
+      id: c.symbolId,
+      name: c.symbolName,
+      callerCount: c.callerCount,
+      filePath: c.filePath
+    }));
+    const totalAffected = allAffectedIds.length;
+    let riskLevel;
+    let riskReason;
+    if (totalAffected < 5 && hubNodes.length === 0) {
+      riskLevel = "LOW";
+      riskReason = `Small impact: ${totalAffected} affected symbols, no hub nodes touched.`;
+    } else if (totalAffected > 20 || hubNodes.length > 1) {
+      riskLevel = "HIGH";
+      riskReason = `Large impact: ${totalAffected} affected symbols${hubNodes.length > 0 ? `, ${hubNodes.length} hub nodes touched` : ""}.`;
+    } else {
+      riskLevel = "MEDIUM";
+      riskReason = `Moderate impact: ${totalAffected} affected symbols${hubNodes.length === 1 ? ", 1 hub node touched" : ""}.`;
+    }
+    let conflictingPRs;
+    if (opts.checkConflicts) {
+      conflictingPRs = [];
+      try {
+        const { stdout } = await execFileAsync2(
+          "gh",
+          ["pr", "list", "--state", "open", "--json", "number,headRefName", "--limit", "10000"],
+          { cwd: this.projectRoot, timeout: 3e4 }
+        );
+        const openPRs = JSON.parse(stdout);
+        const currentCommunityLabels = new Set(communities.map((c) => c.label));
+        const allCommunitiesData = database.detectCommunities(branchKey);
+        const symbolToCommunity = /* @__PURE__ */ new Map();
+        const structuralKey = (filePath, name) => `${filePath.toLowerCase()}:${name.toLowerCase()}`;
+        for (const c of allCommunitiesData) {
+          symbolToCommunity.set(structuralKey(c.filePath, c.symbolName), c.communityLabel);
+        }
+        for (const openPr of openPRs) {
+          if (openPr.number === opts.pr) continue;
+          try {
+            const otherChanged = await getChangedFiles({
+              pr: openPr.number,
+              projectRoot: this.projectRoot,
+              baseBranch: this.baseBranch
+            });
+            const otherAbsolute = otherChanged.files.map((f) => path10.resolve(this.projectRoot, f));
+            const otherBranchKey = this.getBranchCatalogKeyFor(openPr.headRefName);
+            const otherSymbols = database.getSymbolsForFiles(otherAbsolute, otherBranchKey);
+            const otherLabels = /* @__PURE__ */ new Set();
+            for (const sym of otherSymbols) {
+              const label = symbolToCommunity.get(structuralKey(sym.filePath, sym.name));
+              if (label) {
+                otherLabels.add(label);
+              }
+            }
+            const overlapping = Array.from(otherLabels).filter(
+              (l) => currentCommunityLabels.has(l)
+            );
+            if (overlapping.length > 0) {
+              conflictingPRs.push({
+                pr: openPr.number,
+                branch: openPr.headRefName,
+                overlappingCommunities: overlapping
+              });
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    return {
+      changedFiles,
+      directSymbols: directSymbols.map((s) => ({
+        id: s.id,
+        name: s.name,
+        kind: s.kind,
+        filePath: s.filePath
+      })),
+      transitiveCallers: transitiveCallers.map((c) => ({
+        id: c.symbolId,
+        name: c.symbolName,
+        filePath: c.filePath,
+        depth: c.depth
+      })),
+      totalAffected,
+      communities,
+      hubNodes,
+      riskLevel,
+      riskReason,
+      direction,
+      conflictingPRs
+    };
+  }
   async close() {
     await this.database?.close();
     this.database = null;
@@ -8484,13 +8811,13 @@ function computeEvalMetrics(queries, perQuery, embeddingCallCount, embeddingToke
 // src/eval/runner-config.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync7, rmSync, writeFileSync as writeFileSync3 } from "fs";
 import * as os4 from "os";
-import * as path11 from "path";
+import * as path12 from "path";
 
 // src/config/rebase.ts
-import * as path10 from "path";
+import * as path11 from "path";
 function isWithinRoot(rootDir, targetPath) {
-  const relativePath = path10.relative(rootDir, targetPath);
-  return relativePath === "" || !relativePath.startsWith("..") && !path10.isAbsolute(relativePath);
+  const relativePath = path11.relative(rootDir, targetPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !path11.isAbsolute(relativePath);
 }
 function rebasePathEntries(values, fromDir, toDir) {
   if (!Array.isArray(values)) {
@@ -8498,10 +8825,10 @@ function rebasePathEntries(values, fromDir, toDir) {
   }
   return values.filter((value) => typeof value === "string").map((value) => {
     const trimmed = value.trim();
-    if (!trimmed || path10.isAbsolute(trimmed)) {
+    if (!trimmed || path11.isAbsolute(trimmed)) {
       return trimmed;
     }
-    return normalizePathSeparators(path10.normalize(path10.relative(toDir, path10.resolve(fromDir, trimmed))));
+    return normalizePathSeparators(path11.normalize(path11.relative(toDir, path11.resolve(fromDir, trimmed))));
   }).filter(Boolean);
 }
 function resolveInheritedKnowledgeBaseEntries(values, sourceRoot, targetRoot) {
@@ -8513,17 +8840,17 @@ function resolveInheritedKnowledgeBaseEntries(values, sourceRoot, targetRoot) {
     if (!trimmed) {
       return trimmed;
     }
-    if (path10.isAbsolute(trimmed)) {
+    if (path11.isAbsolute(trimmed)) {
       if (isWithinRoot(sourceRoot, trimmed)) {
-        return normalizePathSeparators(path10.normalize(path10.relative(sourceRoot, trimmed) || "."));
+        return normalizePathSeparators(path11.normalize(path11.relative(sourceRoot, trimmed) || "."));
       }
-      return path10.normalize(trimmed);
+      return path11.normalize(trimmed);
     }
-    const resolvedFromSource = path10.resolve(sourceRoot, trimmed);
+    const resolvedFromSource = path11.resolve(sourceRoot, trimmed);
     if (isWithinRoot(sourceRoot, resolvedFromSource)) {
-      return normalizePathSeparators(path10.normalize(trimmed));
+      return normalizePathSeparators(path11.normalize(trimmed));
     }
-    return normalizePathSeparators(path10.normalize(path10.relative(targetRoot, resolvedFromSource)));
+    return normalizePathSeparators(path11.normalize(path11.relative(targetRoot, resolvedFromSource)));
   }).filter(Boolean);
 }
 
@@ -8571,20 +8898,20 @@ function parseJsonConfigFile(filePath) {
   }
 }
 function toAbsolute(projectRoot, maybeRelative) {
-  return path11.isAbsolute(maybeRelative) ? maybeRelative : path11.join(projectRoot, maybeRelative);
+  return path12.isAbsolute(maybeRelative) ? maybeRelative : path12.join(projectRoot, maybeRelative);
 }
 function isProjectScopedConfigPath(configPath) {
-  return path11.basename(configPath) === "codebase-index.json" && path11.basename(path11.dirname(configPath)) === ".opencode";
+  return path12.basename(configPath) === "codebase-index.json" && path12.basename(path12.dirname(configPath)) === ".opencode";
 }
 function normalizeEvalConfigKnowledgeBases(rawConfig, projectRoot, resolvedConfigPath) {
   const config = rawConfig && typeof rawConfig === "object" ? { ...rawConfig } : {};
   const rebaseEntries = (values) => isProjectScopedConfigPath(resolvedConfigPath) ? resolveInheritedKnowledgeBaseEntries(
     values,
-    path11.dirname(path11.dirname(resolvedConfigPath)),
+    path12.dirname(path12.dirname(resolvedConfigPath)),
     projectRoot
   ) : rebasePathEntries(
     values,
-    path11.dirname(resolvedConfigPath),
+    path12.dirname(resolvedConfigPath),
     projectRoot
   );
   if (Array.isArray(config.knowledgeBases)) {
@@ -8612,7 +8939,7 @@ function loadRawConfig(projectRoot, configPath) {
       projectConfig
     );
   }
-  const globalConfig = path11.join(os4.homedir(), ".config", "opencode", "codebase-index.json");
+  const globalConfig = path12.join(os4.homedir(), ".config", "opencode", "codebase-index.json");
   if (existsSync7(globalConfig)) {
     return parseJsonConfigFile(globalConfig);
   }
@@ -8622,10 +8949,10 @@ function getIndexRootPath(projectRoot, scope) {
   return scope === "global" ? getGlobalIndexPath() : resolveProjectIndexPath(projectRoot, scope);
 }
 function getLocalProjectIndexRoot(projectRoot) {
-  return path11.join(projectRoot, ".opencode", "index");
+  return path12.join(projectRoot, ".opencode", "index");
 }
 function getLocalProjectConfigPath(projectRoot) {
-  return path11.join(projectRoot, ".opencode", "codebase-index.json");
+  return path12.join(projectRoot, ".opencode", "codebase-index.json");
 }
 function clearIndexRoot(projectRoot, scope) {
   const indexRoot = scope === "global" ? getIndexRootPath(projectRoot, scope) : getLocalProjectIndexRoot(projectRoot);
@@ -8647,7 +8974,7 @@ function ensureLocalEvalProjectConfig(projectRoot, configPath) {
     projectRoot,
     resolvedConfigPath
   );
-  mkdirSync3(path11.dirname(localConfigPath), { recursive: true });
+  mkdirSync3(path12.dirname(localConfigPath), { recursive: true });
   writeFileSync3(localConfigPath, JSON.stringify(sourceConfig, null, 2), "utf-8");
   return localConfigPath;
 }
@@ -8697,23 +9024,23 @@ function isRecord2(value) {
 function isStringArray3(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
-function asPositiveNumber(value, path18) {
+function asPositiveNumber(value, path19) {
   if (typeof value !== "number" || Number.isNaN(value) || value < 0) {
-    throw new Error(`${path18} must be a non-negative number`);
+    throw new Error(`${path19} must be a non-negative number`);
   }
   return value;
 }
-function parseQueryType(value, path18) {
+function parseQueryType(value, path19) {
   if (value === "definition" || value === "implementation-intent" || value === "similarity" || value === "keyword-heavy") {
     return value;
   }
   throw new Error(
-    `${path18} must be one of: definition, implementation-intent, similarity, keyword-heavy`
+    `${path19} must be one of: definition, implementation-intent, similarity, keyword-heavy`
   );
 }
-function parseExpected(input, path18) {
+function parseExpected(input, path19) {
   if (!isRecord2(input)) {
-    throw new Error(`${path18} must be an object`);
+    throw new Error(`${path19} must be an object`);
   }
   const filePathRaw = input.filePath;
   const acceptableFilesRaw = input.acceptableFiles;
@@ -8722,16 +9049,16 @@ function parseExpected(input, path18) {
   const filePath = typeof filePathRaw === "string" ? filePathRaw : void 0;
   const acceptableFiles = isStringArray3(acceptableFilesRaw) ? acceptableFilesRaw : void 0;
   if (!filePath && (!acceptableFiles || acceptableFiles.length === 0)) {
-    throw new Error(`${path18} must include either expected.filePath or expected.acceptableFiles`);
+    throw new Error(`${path19} must include either expected.filePath or expected.acceptableFiles`);
   }
   if (acceptableFilesRaw !== void 0 && !isStringArray3(acceptableFilesRaw)) {
-    throw new Error(`${path18}.acceptableFiles must be an array of strings`);
+    throw new Error(`${path19}.acceptableFiles must be an array of strings`);
   }
   if (symbolRaw !== void 0 && typeof symbolRaw !== "string") {
-    throw new Error(`${path18}.symbol must be a string when provided`);
+    throw new Error(`${path19}.symbol must be a string when provided`);
   }
   if (branchRaw !== void 0 && typeof branchRaw !== "string") {
-    throw new Error(`${path18}.branch must be a string when provided`);
+    throw new Error(`${path19}.branch must be a string when provided`);
   }
   return {
     filePath,
@@ -8741,25 +9068,25 @@ function parseExpected(input, path18) {
   };
 }
 function parseQuery(input, index) {
-  const path18 = `queries[${index}]`;
+  const path19 = `queries[${index}]`;
   if (!isRecord2(input)) {
-    throw new Error(`${path18} must be an object`);
+    throw new Error(`${path19} must be an object`);
   }
   const id = input.id;
   const query = input.query;
   const queryType = input.queryType;
   const expected = input.expected;
   if (typeof id !== "string" || id.trim().length === 0) {
-    throw new Error(`${path18}.id must be a non-empty string`);
+    throw new Error(`${path19}.id must be a non-empty string`);
   }
   if (typeof query !== "string" || query.trim().length === 0) {
-    throw new Error(`${path18}.query must be a non-empty string`);
+    throw new Error(`${path19}.query must be a non-empty string`);
   }
   return {
     id,
     query,
-    queryType: parseQueryType(queryType, `${path18}.queryType`),
-    expected: parseExpected(expected, `${path18}.expected`)
+    queryType: parseQueryType(queryType, `${path19}.queryType`),
+    expected: parseExpected(expected, `${path19}.expected`)
   };
 }
 function parseGoldenDataset(raw, sourceLabel) {
@@ -8942,13 +9269,13 @@ async function runEvaluation(options) {
     };
     const outputDir = createRunDirectory(toAbsolute(options.projectRoot, options.outputRoot));
     const perQueryArtifact = buildPerQueryArtifact(perQuery);
-    writeJson(path12.join(outputDir, "summary.json"), summary);
-    writeJson(path12.join(outputDir, "per-query.json"), perQueryArtifact);
+    writeJson(path13.join(outputDir, "summary.json"), summary);
+    writeJson(path13.join(outputDir, "per-query.json"), perQueryArtifact);
     let comparison;
     if (againstPath) {
       const baseline = loadSummary(againstPath);
       comparison = compareSummaries(summary, baseline, againstPath);
-      writeJson(path12.join(outputDir, "compare.json"), comparison);
+      writeJson(path13.join(outputDir, "compare.json"), comparison);
     }
     let gate;
     if (options.ciMode) {
@@ -8961,7 +9288,7 @@ async function runEvaluation(options) {
         if (existsSync8(resolvedBaseline)) {
           const baselineSummary = loadSummary(resolvedBaseline);
           comparison = compareSummaries(summary, baselineSummary, resolvedBaseline);
-          writeJson(path12.join(outputDir, "compare.json"), comparison);
+          writeJson(path13.join(outputDir, "compare.json"), comparison);
         } else if (budget.failOnMissingBaseline) {
           throw new Error(
             `Budget baseline is missing: ${resolvedBaseline}. Set failOnMissingBaseline=false to allow CI run without baseline.`
@@ -8971,7 +9298,7 @@ async function runEvaluation(options) {
       gate = evaluateBudgetGate(budget, summary, comparison);
     }
     const markdown = createSummaryMarkdown(summary, comparison, gate);
-    writeText(path12.join(outputDir, "summary.md"), markdown);
+    writeText(path13.join(outputDir, "summary.md"), markdown);
     return { outputDir, summary, perQuery, comparison, gate };
   } finally {
     await indexer.close();
@@ -9029,23 +9356,23 @@ async function runSweep(options, sweep) {
     bestByMrrAt10,
     bestByP95Latency
   };
-  writeJson(path12.join(outputDir, "compare.json"), aggregate);
+  writeJson(path13.join(outputDir, "compare.json"), aggregate);
   const md = createSummaryMarkdown(
     bestByHitAt5?.summary ?? runs[0].summary,
     bestByHitAt5?.comparison,
     void 0,
     aggregate
   );
-  writeText(path12.join(outputDir, "summary.md"), md);
-  writeJson(path12.join(outputDir, "summary.json"), bestByHitAt5?.summary ?? runs[0].summary);
+  writeText(path13.join(outputDir, "summary.md"), md);
+  writeJson(path13.join(outputDir, "summary.json"), bestByHitAt5?.summary ?? runs[0].summary);
   return { outputDir, aggregate };
 }
 
 // src/eval/cli.ts
-import * as path14 from "path";
+import * as path15 from "path";
 
 // src/eval/cli-parser.ts
-import * as path13 from "path";
+import * as path14 from "path";
 function printUsage() {
   console.log(`
 Usage:
@@ -9117,12 +9444,12 @@ function parseEvalArgs(argv, cwd) {
     const arg = argv[i];
     const next = argv[i + 1];
     if (arg === "--project" && next) {
-      parsed.projectRoot = path13.resolve(cwd, next);
+      parsed.projectRoot = path14.resolve(cwd, next);
       i += 1;
       continue;
     }
     if (arg === "--config" && next) {
-      parsed.configPath = path13.resolve(cwd, next);
+      parsed.configPath = path14.resolve(cwd, next);
       i += 1;
       continue;
     }
@@ -9318,22 +9645,22 @@ async function handleEvalCommand(args, cwd) {
     if (!parsed.againstPath.endsWith(".json")) {
       throw new Error("eval diff --against must point to a summary JSON file");
     }
-    const currentSummary = loadSummary(path14.resolve(parsed.projectRoot, currentPath), {
+    const currentSummary = loadSummary(path15.resolve(parsed.projectRoot, currentPath), {
       allowLegacyDiversityMetrics: true
     });
-    const baselineSummary = loadSummary(path14.resolve(parsed.projectRoot, parsed.againstPath), {
+    const baselineSummary = loadSummary(path15.resolve(parsed.projectRoot, parsed.againstPath), {
       allowLegacyDiversityMetrics: true
     });
     const comparison = compareSummaries(
       currentSummary,
       baselineSummary,
-      path14.resolve(parsed.projectRoot, parsed.againstPath)
+      path15.resolve(parsed.projectRoot, parsed.againstPath)
     );
-    const outputDir = createRunDirectory(path14.resolve(parsed.projectRoot, parsed.outputRoot));
+    const outputDir = createRunDirectory(path15.resolve(parsed.projectRoot, parsed.outputRoot));
     const summaryMd = createSummaryMarkdown(currentSummary, comparison);
-    writeJson(path14.join(outputDir, "compare.json"), comparison);
-    writeText(path14.join(outputDir, "summary.md"), summaryMd);
-    writeJson(path14.join(outputDir, "summary.json"), currentSummary);
+    writeJson(path15.join(outputDir, "compare.json"), comparison);
+    writeText(path15.join(outputDir, "summary.md"), summaryMd);
+    writeJson(path15.join(outputDir, "summary.json"), currentSummary);
     console.log(`Eval diff complete. Artifacts: ${outputDir}`);
     return 0;
   }
@@ -9342,7 +9669,7 @@ async function handleEvalCommand(args, cwd) {
 
 // src/mcp-server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import * as path16 from "path";
+import * as path17 from "path";
 import { existsSync as existsSync10 } from "fs";
 
 // src/mcp-server/register-prompts.ts
@@ -9441,7 +9768,7 @@ import { z as z2 } from "zod";
 // src/config/merger.ts
 import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
 import * as os5 from "os";
-import * as path15 from "path";
+import * as path16 from "path";
 var PROJECT_OVERRIDE_KEYS = [
   "embeddingProvider",
   "customProvider",
@@ -9474,8 +9801,8 @@ function mergeUniqueStringArray(values) {
   return [...new Set(values.map((value) => String(value).trim()))];
 }
 function normalizeKnowledgeBasePath(value) {
-  let normalized = path15.normalize(String(value).trim());
-  const root = path15.parse(normalized).root;
+  let normalized = path16.normalize(String(value).trim());
+  const root = path16.parse(normalized).root;
   while (normalized.length > root.length && /[\\/]$/.test(normalized)) {
     normalized = normalized.slice(0, -1);
   }
@@ -9525,8 +9852,8 @@ function loadJsonFile(filePath) {
   return null;
 }
 function materializeLocalProjectConfig(projectRoot, config) {
-  const localConfigPath = path15.join(projectRoot, ".opencode", "codebase-index.json");
-  mkdirSync4(path15.dirname(localConfigPath), { recursive: true });
+  const localConfigPath = path16.join(projectRoot, ".opencode", "codebase-index.json");
+  mkdirSync4(path16.dirname(localConfigPath), { recursive: true });
   writeFileSync4(localConfigPath, JSON.stringify(config, null, 2), "utf-8");
   return localConfigPath;
 }
@@ -9537,7 +9864,7 @@ function loadProjectConfigLayer(projectRoot) {
     return {};
   }
   const normalizedConfig = { ...projectConfig };
-  const projectConfigBaseDir = path15.dirname(path15.dirname(projectConfigPath));
+  const projectConfigBaseDir = path16.dirname(path16.dirname(projectConfigPath));
   if (Array.isArray(normalizedConfig.knowledgeBases)) {
     normalizedConfig.knowledgeBases = resolveInheritedKnowledgeBaseEntries(
       normalizedConfig.knowledgeBases,
@@ -9756,6 +10083,57 @@ ${truncateContent(r.content)}
   return formatted.join("\n\n");
 }
 
+// src/tools/format-pr-impact.ts
+function formatPrImpact(result) {
+  const lines = [];
+  lines.push(`\u2192 Files changed: ${result.changedFiles.length}`);
+  for (const file of result.changedFiles) {
+    lines.push(`  - ${file}`);
+  }
+  const directCount = result.directSymbols.length;
+  const transitiveCount = result.transitiveCallers.length;
+  const directionLabel = result.direction === "callees" ? "callees" : result.direction === "both" ? "reachable (callers + callees)" : "callers";
+  lines.push(
+    `\u2192 Symbols affected: ${result.totalAffected} (${directCount} direct, ${transitiveCount} transitive ${directionLabel})`
+  );
+  if (directCount > 0) {
+    lines.push(
+      `  Direct: ${result.directSymbols.map((s) => `${s.name} (${s.kind})`).join(", ")}`
+    );
+  }
+  if (transitiveCount > 0) {
+    lines.push(
+      `  Transitive ${directionLabel}: ${result.transitiveCallers.map((s) => s.name).join(", ")}`
+    );
+  }
+  if (result.communities.length > 0) {
+    lines.push(
+      `\u2192 Communities touched: ${result.communities.map((c) => c.label).join(", ")}`
+    );
+    for (const community of result.communities) {
+      lines.push(
+        `  - ${community.label}: ${community.symbolCount} symbols`
+      );
+    }
+  } else {
+    lines.push("\u2192 Communities touched: none");
+  }
+  lines.push(`\u2192 Risk: ${result.riskLevel} \u2014 ${result.riskReason}`);
+  if (result.hubNodes.length > 0) {
+    lines.push("  Hub nodes in change scope:");
+    for (const hub of result.hubNodes) {
+      lines.push(`    - ${hub.name} (${hub.callerCount} callers) at ${hub.filePath}`);
+    }
+  }
+  if (result.conflictingPRs && result.conflictingPRs.length > 0) {
+    const conflictList = result.conflictingPRs.map(
+      (c) => `PR #${c.pr} (also touches ${c.overlappingCommunities.join(", ")} community)`
+    );
+    lines.push(`\u2192 Potential conflicts with: ${conflictList.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+
 // src/mcp-server/shared.ts
 var MAX_CONTENT_LINES2 = 30;
 function truncateContent2(content) {
@@ -10050,19 +10428,49 @@ ${formatted.join("\n")}` }] };
     async (args) => {
       await runtime.ensureInitialized();
       const indexer = runtime.getIndexer();
-      const path18 = await indexer.findCallPath(args.from, args.to, args.maxDepth);
-      if (path18.length === 0) {
+      const path19 = await indexer.findCallPath(args.from, args.to, args.maxDepth);
+      if (path19.length === 0) {
         return { content: [{ type: "text", text: `No path found between "${args.from}" and "${args.to}". They may be in disconnected components, or the call graph index needs updating.` }] };
       }
-      const formatted = path18.map((hop, i) => {
+      const formatted = path19.map((hop, i) => {
         const prefix = i === 0 ? "[start]" : `--${hop.callType}-->`;
         const location = hop.filePath ? ` (${hop.filePath}:${hop.line})` : "";
         return `${prefix} ${hop.symbolName}${location}`;
       });
-      return { content: [{ type: "text", text: `Path (${path18.length} hops):
+      return { content: [{ type: "text", text: `Path (${path19.length} hops):
 ${formatted.join("\n")}` }] };
     }
   );
+  server.tool(
+    "pr_impact",
+    "Analyze the impact of a pull request or branch by examining changed files, affected symbols, transitive callers, communities touched, hub nodes, and risk level. Use to understand blast radius before merging.",
+    {
+      pr: z2.number().optional().describe("Pull request number to analyze"),
+      branch: z2.string().optional().describe("Branch name to analyze (defaults to current branch)"),
+      maxDepth: z2.number().optional().default(5).describe("Maximum traversal depth for transitive callers (default: 5)"),
+      hubThreshold: z2.number().optional().default(10).describe("Minimum caller count to flag a symbol as a hub node (default: 10)"),
+      checkConflicts: z2.boolean().optional().default(false).describe("Check for conflicting open PRs touching the same communities (default: false)"),
+      direction: z2.enum(["callers", "callees", "both"]).optional().default("both").describe("Call-graph traversal direction: 'callers' for upstream, 'callees' for downstream, 'both' for union (default: both)")
+    },
+    async (args) => {
+      await runtime.ensureInitialized();
+      const indexer = runtime.getIndexer();
+      try {
+        const result = await indexer.getPrImpact({
+          pr: args.pr,
+          branch: args.branch,
+          maxDepth: args.maxDepth,
+          hubThreshold: args.hubThreshold,
+          checkConflicts: args.checkConflicts,
+          direction: args.direction
+        });
+        return { content: [{ type: "text", text: formatPrImpact(result) }] };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `Error analyzing PR impact: ${message}` }] };
+      }
+    }
+  );
 }
 
 // src/mcp-server.ts
@@ -10081,12 +10489,12 @@ function createMcpServer(projectRoot, config) {
     if (config.scope !== "project") {
       return false;
     }
-    const localIndexPath = path16.join(projectRoot, ".opencode", "index");
+    const localIndexPath = path17.join(projectRoot, ".opencode", "index");
     const mainRepoRoot = resolveWorktreeMainRepoRoot(projectRoot);
     if (!mainRepoRoot) {
       return false;
     }
-    const inheritedIndexPath = path16.join(mainRepoRoot, ".opencode", "index");
+    const inheritedIndexPath = path17.join(mainRepoRoot, ".opencode", "index");
     return !existsSync10(localIndexPath) && existsSync10(inheritedIndexPath);
   }
   async function ensureInitialized() {
@@ -10112,9 +10520,9 @@ function parseArgs(argv) {
   let config;
   for (let i = 2; i < argv.length; i++) {
     if (argv[i] === "--project" && argv[i + 1]) {
-      project = path17.resolve(argv[++i]);
+      project = path18.resolve(argv[++i]);
     } else if (argv[i] === "--config" && argv[i + 1]) {
-      config = path17.resolve(argv[++i]);
+      config = path18.resolve(argv[++i]);
     }
   }
   return { project, config };