opencode-codebase-index 0.12.0 → 0.13.0

package/dist/cli.js

@@ -62,11 +62,11 @@ var require_eventemitter3 = __commonJS({
       if (--emitter._eventsCount === 0) emitter._events = new Events();
       else delete emitter._events[evt];
     }
-    function EventEmitter2() {
+    function EventEmitter3() {
       this._events = new Events();
       this._eventsCount = 0;
     }
-    EventEmitter2.prototype.eventNames = function eventNames() {
+    EventEmitter3.prototype.eventNames = function eventNames() {
       var names = [], events, name;
       if (this._eventsCount === 0) return names;
       for (name in events = this._events) {
@@ -77,7 +77,7 @@ var require_eventemitter3 = __commonJS({
       }
       return names;
     };
-    EventEmitter2.prototype.listeners = function listeners(event) {
+    EventEmitter3.prototype.listeners = function listeners(event) {
       var evt = prefix ? prefix + event : event, handlers = this._events[evt];
       if (!handlers) return [];
       if (handlers.fn) return [handlers.fn];
@@ -86,13 +86,13 @@ var require_eventemitter3 = __commonJS({
       }
       return ee;
     };
-    EventEmitter2.prototype.listenerCount = function listenerCount(event) {
+    EventEmitter3.prototype.listenerCount = function listenerCount(event) {
       var evt = prefix ? prefix + event : event, listeners = this._events[evt];
       if (!listeners) return 0;
       if (listeners.fn) return 1;
       return listeners.length;
     };
-    EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+    EventEmitter3.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
       var evt = prefix ? prefix + event : event;
       if (!this._events[evt]) return false;
       var listeners = this._events[evt], len = arguments.length, args, i;
@@ -143,13 +143,13 @@ var require_eventemitter3 = __commonJS({
       }
       return true;
     };
-    EventEmitter2.prototype.on = function on(event, fn, context) {
+    EventEmitter3.prototype.on = function on(event, fn, context) {
       return addListener(this, event, fn, context, false);
     };
-    EventEmitter2.prototype.once = function once(event, fn, context) {
+    EventEmitter3.prototype.once = function once(event, fn, context) {
       return addListener(this, event, fn, context, true);
     };
-    EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
+    EventEmitter3.prototype.removeListener = function removeListener(event, fn, context, once) {
       var evt = prefix ? prefix + event : event;
       if (!this._events[evt]) return this;
       if (!fn) {
@@ -172,7 +172,7 @@ var require_eventemitter3 = __commonJS({
       }
       return this;
     };
-    EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
+    EventEmitter3.prototype.removeAllListeners = function removeAllListeners(event) {
       var evt;
       if (event) {
         evt = prefix ? prefix + event : event;
@@ -183,12 +183,12 @@ var require_eventemitter3 = __commonJS({
       }
       return this;
     };
-    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
-    EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
-    EventEmitter2.prefixed = prefix;
-    EventEmitter2.EventEmitter = EventEmitter2;
+    EventEmitter3.prototype.off = EventEmitter3.prototype.removeListener;
+    EventEmitter3.prototype.addListener = EventEmitter3.prototype.on;
+    EventEmitter3.prefixed = prefix;
+    EventEmitter3.EventEmitter = EventEmitter3;
     if ("undefined" !== typeof module2) {
-      module2.exports = EventEmitter2;
+      module2.exports = EventEmitter3;
     }
   }
 });
@@ -211,7 +211,7 @@ var require_ignore = __commonJS({
     var REGEX_SPLITALL_CRLF = /\r?\n/g;
     var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
     var REGEX_TEST_TRAILING_SLASH = /\/$/;
-    var SLASH = "/";
+    var SLASH2 = "/";
     var TMP_KEY_IGNORE = "node-ignore";
     if (typeof Symbol !== "undefined") {
       TMP_KEY_IGNORE = /* @__PURE__ */ Symbol.for("node-ignore");
@@ -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(path19, checkUnignored, mode) {
+      test(path25, 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(path19);
+          const matched = rule[mode].test(path25);
           if (!matched) {
             return;
           }
@@ -521,17 +521,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path19, originalPath, doThrow) => {
-      if (!isString(path19)) {
+    var checkPath = (path25, originalPath, doThrow) => {
+      if (!isString(path25)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path19) {
+      if (!path25) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path19)) {
+      if (checkPath.isNotRelative(path25)) {
         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 = (path19) => REGEX_TEST_INVALID_PATH.test(path19);
+    var isNotRelative = (path25) => REGEX_TEST_INVALID_PATH.test(path25);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore2 = class {
@@ -570,23 +570,23 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path19 = originalPath && checkPath.convert(originalPath);
+        const path25 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path19,
+          path25,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path19, cache, checkUnignored, slices);
+        return this._t(path25, cache, checkUnignored, slices);
       }
-      checkIgnore(path19) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path19)) {
-          return this.test(path19);
+      checkIgnore(path25) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path25)) {
+          return this.test(path25);
         }
-        const slices = path19.split(SLASH).filter(Boolean);
+        const slices = path25.split(SLASH2).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
-            slices.join(SLASH) + SLASH,
+            slices.join(SLASH2) + SLASH2,
             this._testCache,
             true,
             slices
@@ -595,48 +595,48 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path19, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path25, false, MODE_CHECK_IGNORE);
       }
-      _t(path19, cache, checkUnignored, slices) {
-        if (path19 in cache) {
-          return cache[path19];
+      _t(path25, cache, checkUnignored, slices) {
+        if (path25 in cache) {
+          return cache[path25];
         }
         if (!slices) {
-          slices = path19.split(SLASH).filter(Boolean);
+          slices = path25.split(SLASH2).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path19] = this._rules.test(path19, checkUnignored, MODE_IGNORE);
+          return cache[path25] = this._rules.test(path25, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
-          slices.join(SLASH) + SLASH,
+          slices.join(SLASH2) + SLASH2,
           cache,
           checkUnignored,
           slices
         );
-        return cache[path19] = parent.ignored ? parent : this._rules.test(path19, checkUnignored, MODE_IGNORE);
+        return cache[path25] = parent.ignored ? parent : this._rules.test(path25, checkUnignored, MODE_IGNORE);
       }
-      ignores(path19) {
-        return this._test(path19, this._ignoreCache, false).ignored;
+      ignores(path25) {
+        return this._test(path25, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path19) => !this.ignores(path19);
+        return (path25) => !this.ignores(path25);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path19) {
-        return this._test(path19, this._testCache, true);
+      test(path25) {
+        return this._test(path25, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore2(options);
-    var isPathValid = (path19) => checkPath(path19 && checkPath.convert(path19), path19, RETURN_FALSE);
+    var isPathValid = (path25) => checkPath(path25 && checkPath.convert(path25), path25, 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 = (path19) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path19) || isNotRelative(path19);
+      checkPath.isNotRelative = (path25) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path25) || isNotRelative(path25);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -653,7 +653,10 @@ var require_ignore = __commonJS({
 
 // src/cli.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import * as path18 from "path";
+import { writeFileSync as writeFileSync6 } from "fs";
+import * as os5 from "os";
+import * as path24 from "path";
+import { pathToFileURL } from "url";
 
 // src/config/constants.ts
 var DEFAULT_INCLUDE = [
@@ -1038,6 +1041,19 @@ var autoDetectProviders = AUTO_DETECT_PROVIDER_ORDER.filter(
   (provider) => provider in EMBEDDING_MODELS
 );
 
+// src/config/host.ts
+var HOST_MODES = ["opencode", "codex", "claude", "pi"];
+function isSupportedHostMode(value) {
+  return HOST_MODES.includes(value);
+}
+function parseHostMode(value) {
+  const normalized = (value ?? "").toLowerCase();
+  if (isSupportedHostMode(normalized)) {
+    return normalized;
+  }
+  throw new Error(`Invalid host mode: ${value ?? "(none)"}. Allowed values: ${HOST_MODES.join(", ")}.`);
+}
+
 // src/eval/compare.ts
 function metricDelta(current, baseline) {
   const absolute = current - baseline;
@@ -1081,9 +1097,9 @@ import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import * as path from "path";
 
 // src/eval/report-formatters.ts
-function assertFiniteNumber(value, path19) {
+function assertFiniteNumber(value, path25) {
   if (typeof value !== "number" || Number.isNaN(value) || !Number.isFinite(value)) {
-    throw new Error(`${path19} must be a finite number`);
+    throw new Error(`${path25} must be a finite number`);
   }
   return value;
 }
@@ -1304,7 +1320,7 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve11, reject) => {
+  const wrappedPromise = new Promise((resolve15, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
@@ -1318,7 +1334,7 @@ function pTimeout(promise, options) {
       };
       signal.addEventListener("abort", abortHandler, { once: true });
     }
-    promise.then(resolve11, reject);
+    promise.then(resolve15, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
       return;
     }
@@ -1326,7 +1342,7 @@ function pTimeout(promise, options) {
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve11(fallback());
+          resolve15(fallback());
         } catch (error) {
           reject(error);
         }
@@ -1336,7 +1352,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message === false) {
-        resolve11();
+        resolve15();
       } else if (message instanceof Error) {
         reject(message);
       } else {
@@ -1738,7 +1754,7 @@ var PQueue = class extends import_index.default {
       // Assign unique ID if not provided
       id: options.id ?? (this.#idAssigner++).toString()
     };
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve15, reject) => {
       const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
       let cleanupQueueAbortHandler = () => void 0;
       const run = async () => {
@@ -1778,7 +1794,7 @@ var PQueue = class extends import_index.default {
             })]);
           }
           const result = await operation;
-          resolve11(result);
+          resolve15(result);
           this.emit("completed", result);
         } catch (error) {
           reject(error);
@@ -1966,13 +1982,13 @@ var PQueue = class extends import_index.default {
     });
   }
   async #onEvent(event, filter) {
-    return new Promise((resolve11) => {
+    return new Promise((resolve15) => {
       const listener = () => {
         if (filter && !filter()) {
           return;
         }
         this.off(event, listener);
-        resolve11();
+        resolve15();
       };
       this.on(event, listener);
     });
@@ -2258,7 +2274,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
   const finalDelay = Math.min(delayTime, remainingTime);
   options.signal?.throwIfAborted();
   if (finalDelay > 0) {
-    await new Promise((resolve11, reject) => {
+    await new Promise((resolve15, reject) => {
       const onAbort = () => {
         clearTimeout(timeoutToken);
         options.signal?.removeEventListener("abort", onAbort);
@@ -2266,7 +2282,7 @@ async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTi
       };
       const timeoutToken = setTimeout(() => {
         options.signal?.removeEventListener("abort", onAbort);
-        resolve11();
+        resolve15();
       }, finalDelay);
       if (options.unref) {
         timeoutToken.unref?.();
@@ -3054,8 +3070,64 @@ function isHiddenPathSegment(part) {
 function isBuildPathSegment(part) {
   return part.toLowerCase().includes("build");
 }
+function hasFilteredPathSegment(relativePath, separator = path3.sep) {
+  return relativePath.split(separator).some(
+    (part) => isHiddenPathSegment(part) || isBuildPathSegment(part)
+  );
+}
+var RESTRICTED_DIRECTORIES = /* @__PURE__ */ new Set([
+  // macOS
+  "library",
+  "applications",
+  "system",
+  "volumes",
+  "private",
+  "cores",
+  // Linux
+  "proc",
+  "sys",
+  "dev",
+  "run",
+  "snap",
+  // Windows
+  "windows",
+  "programdata",
+  "program files",
+  "program files (x86)",
+  "$recycle.bin"
+]);
+function isRestrictedDirectory(relativePath, separator = path3.sep) {
+  const firstSegment = relativePath.split(separator)[0];
+  if (!firstSegment) return false;
+  return RESTRICTED_DIRECTORIES.has(firstSegment.toLowerCase());
+}
 
 // src/utils/files.ts
+var PROJECT_MARKERS = [
+  ".git",
+  "package.json",
+  "Cargo.toml",
+  "go.mod",
+  "pyproject.toml",
+  "setup.py",
+  "requirements.txt",
+  "Gemfile",
+  "composer.json",
+  "pom.xml",
+  "build.gradle",
+  "CMakeLists.txt",
+  "Makefile",
+  ".opencode",
+  ".codebase-index"
+];
+function hasProjectMarker(projectRoot) {
+  for (const marker of PROJECT_MARKERS) {
+    if (existsSync2(path4.join(projectRoot, marker))) {
+      return true;
+    }
+  }
+  return false;
+}
 function createIgnoreFilter(projectRoot) {
   const ig = (0, import_ignore.default)();
   const defaultIgnores = [
@@ -3070,6 +3142,7 @@ function createIgnoreFilter(projectRoot) {
     "target",
     "vendor",
     ".opencode",
+    ".codebase-index",
     ".*",
     "**/.*",
     "**/.*/**",
@@ -3083,6 +3156,26 @@ function createIgnoreFilter(projectRoot) {
   }
   return ig;
 }
+function shouldIncludeFile(filePath, projectRoot, includePatterns, excludePatterns, ignoreFilter) {
+  const relativePath = path4.relative(projectRoot, filePath);
+  if (hasFilteredPathSegment(relativePath, path4.sep)) {
+    return false;
+  }
+  if (ignoreFilter.ignores(relativePath)) {
+    return false;
+  }
+  for (const pattern of excludePatterns) {
+    if (matchGlob(relativePath, pattern)) {
+      return false;
+    }
+  }
+  for (const pattern of includePatterns) {
+    if (matchGlob(relativePath, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
 function matchGlob(filePath, pattern) {
   if (pattern.startsWith("**/")) {
     const withoutPrefix = pattern.slice(3);
@@ -3124,8 +3217,8 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
     if (entry.isDirectory()) {
       subdirs.push({ fullPath, relativePath });
     } else if (entry.isFile()) {
-      const stat = await fsPromises.stat(fullPath);
-      if (stat.size > maxFileSize) {
+      const stat4 = await fsPromises.stat(fullPath);
+      if (stat4.size > maxFileSize) {
         skipped.push({ path: relativePath, reason: "too_large" });
         continue;
       }
@@ -3143,7 +3236,7 @@ async function* walkDirectory(dir, projectRoot, includePatterns, excludePatterns
         }
       }
       if (matched) {
-        filesInDir.push({ path: fullPath, size: stat.size });
+        filesInDir.push({ path: fullPath, size: stat4.size });
       }
     }
   }
@@ -3200,8 +3293,8 @@ async function collectFiles(projectRoot, includePatterns, excludePatterns, maxFi
     }
     for (const resolvedKbRoot of normalizedRoots) {
       try {
-        const stat = await fsPromises.stat(resolvedKbRoot);
-        if (!stat.isDirectory()) {
+        const stat4 = await fsPromises.stat(resolvedKbRoot);
+        if (!stat4.isDirectory()) {
           skipped.push({ path: resolvedKbRoot, reason: "excluded" });
           continue;
         }
@@ -4408,11 +4501,11 @@ function resolveGitDir(repoRoot) {
     return null;
   }
   try {
-    const stat = statSync2(gitPath);
-    if (stat.isDirectory()) {
+    const stat4 = statSync2(gitPath);
+    if (stat4.isDirectory()) {
       return gitPath;
     }
-    if (stat.isFile()) {
+    if (stat4.isFile()) {
       const content = readFileSync5(gitPath, "utf-8").trim();
       const match = content.match(/^gitdir:\s*(.+)$/);
       if (match) {
@@ -4477,13 +4570,46 @@ function getBranchOrDefault(repoRoot) {
   }
   return getCurrentBranch(repoRoot) ?? "default";
 }
+function getHeadPath(repoRoot) {
+  const gitDir = resolveGitDir(repoRoot);
+  if (gitDir) {
+    return path7.join(gitDir, "HEAD");
+  }
+  return path7.join(repoRoot, ".git", "HEAD");
+}
 
 // src/config/paths.ts
 import { existsSync as existsSync5 } from "fs";
 import * as os3 from "os";
 import * as path8 from "path";
-var PROJECT_CONFIG_RELATIVE_PATH = path8.join(".opencode", "codebase-index.json");
-var PROJECT_INDEX_RELATIVE_PATH = path8.join(".opencode", "index");
+var OPENCODE_PROJECT_CONFIG_RELATIVE_PATH = path8.join(".opencode", "codebase-index.json");
+var OPENCODE_PROJECT_INDEX_RELATIVE_PATH = path8.join(".opencode", "index");
+var CODEBASE_INDEX_DIR = ".codebase-index";
+var CODEBASE_PROJECT_CONFIG_RELATIVE_PATH = path8.join(CODEBASE_INDEX_DIR, "config.json");
+var CODEBASE_PROJECT_INDEX_RELATIVE_PATH = path8.join(CODEBASE_INDEX_DIR, "index");
+var CLAUDE_DIR = ".claude";
+var CLAUDE_PROJECT_CONFIG_RELATIVE_PATH = path8.join(CLAUDE_DIR, "codebase-index.json");
+var CLAUDE_PROJECT_INDEX_RELATIVE_PATH = path8.join(CLAUDE_DIR, "index");
+function getProjectConfigRelativePath(host) {
+  switch (host) {
+    case "opencode":
+      return OPENCODE_PROJECT_CONFIG_RELATIVE_PATH;
+    case "claude":
+      return CLAUDE_PROJECT_CONFIG_RELATIVE_PATH;
+    default:
+      return CODEBASE_PROJECT_CONFIG_RELATIVE_PATH;
+  }
+}
+function getProjectIndexRelativePath(host) {
+  switch (host) {
+    case "opencode":
+      return OPENCODE_PROJECT_INDEX_RELATIVE_PATH;
+    case "claude":
+      return CLAUDE_PROJECT_INDEX_RELATIVE_PATH;
+    default:
+      return CODEBASE_PROJECT_INDEX_RELATIVE_PATH;
+  }
+}
 function resolveWorktreeFallbackPath(projectRoot, relativePath) {
   const mainRepoRoot = resolveWorktreeMainRepoRoot(projectRoot);
   if (!mainRepoRoot) {
@@ -4492,31 +4618,122 @@ function resolveWorktreeFallbackPath(projectRoot, relativePath) {
   const fallbackPath = path8.join(mainRepoRoot, relativePath);
   return existsSync5(fallbackPath) ? fallbackPath : null;
 }
-function hasProjectConfig(projectRoot) {
-  return existsSync5(path8.join(projectRoot, PROJECT_CONFIG_RELATIVE_PATH));
+function resolveWorktreeFallbackProjectIndexPath(projectRoot, host) {
+  const inheritedHostPath = resolveWorktreeFallbackPath(projectRoot, getProjectIndexRelativePath(host));
+  if (inheritedHostPath) {
+    return inheritedHostPath;
+  }
+  if (host !== "opencode") {
+    return resolveWorktreeFallbackPath(projectRoot, OPENCODE_PROJECT_INDEX_RELATIVE_PATH);
+  }
+  return null;
 }
-function getGlobalIndexPath() {
-  return path8.join(os3.homedir(), ".opencode", "global-index");
+function getHostProjectIndexRelativePath(host) {
+  return getProjectIndexRelativePath(host);
 }
-function resolveProjectConfigPath(projectRoot) {
-  const localConfigPath = path8.join(projectRoot, PROJECT_CONFIG_RELATIVE_PATH);
-  if (existsSync5(localConfigPath)) {
-    return localConfigPath;
+function hasHostProjectConfig(projectRoot, host) {
+  return existsSync5(path8.join(projectRoot, getProjectConfigRelativePath(host)));
+}
+function getGlobalIndexPath(host = "opencode") {
+  switch (host) {
+    case "opencode":
+      return path8.join(os3.homedir(), ".opencode", "global-index");
+    case "claude":
+      return path8.join(os3.homedir(), ".claude", "global-index");
+    default:
+      return path8.join(os3.homedir(), ".codebase-index", "global-index");
+  }
+}
+function getGlobalConfigPath(host = "opencode") {
+  switch (host) {
+    case "opencode":
+      return path8.join(os3.homedir(), ".config", "opencode", "codebase-index.json");
+    case "claude":
+      return path8.join(os3.homedir(), ".claude", "codebase-index.json");
+    default:
+      return path8.join(os3.homedir(), ".config", "codebase-index", "config.json");
+  }
+}
+function resolveGlobalConfigPath(host = "opencode") {
+  const hostConfigPath = getGlobalConfigPath(host);
+  if (existsSync5(hostConfigPath)) {
+    return hostConfigPath;
+  }
+  if (host !== "opencode") {
+    const legacyConfigPath = getGlobalConfigPath("opencode");
+    if (existsSync5(legacyConfigPath)) {
+      return legacyConfigPath;
+    }
+  }
+  return hostConfigPath;
+}
+function resolveGlobalIndexPath(host = "opencode") {
+  const hostIndexPath = getGlobalIndexPath(host);
+  if (existsSync5(hostIndexPath)) {
+    return hostIndexPath;
+  }
+  if (host !== "opencode") {
+    const legacyIndexPath = getGlobalIndexPath("opencode");
+    if (existsSync5(legacyIndexPath)) {
+      return legacyIndexPath;
+    }
+  }
+  return hostIndexPath;
+}
+function resolveProjectConfigPath(projectRoot, host = "opencode") {
+  const hostConfigPath = path8.join(projectRoot, getProjectConfigRelativePath(host));
+  if (existsSync5(hostConfigPath)) {
+    return hostConfigPath;
+  }
+  if (host !== "opencode") {
+    const legacyConfigPath = path8.join(projectRoot, OPENCODE_PROJECT_CONFIG_RELATIVE_PATH);
+    if (existsSync5(legacyConfigPath)) {
+      return legacyConfigPath;
+    }
+  }
+  const hostFallback = resolveWorktreeFallbackPath(projectRoot, getProjectConfigRelativePath(host));
+  if (hostFallback) {
+    return hostFallback;
+  }
+  if (host !== "opencode") {
+    const legacyFallback = resolveWorktreeFallbackPath(projectRoot, OPENCODE_PROJECT_CONFIG_RELATIVE_PATH);
+    if (legacyFallback) {
+      return legacyFallback;
+    }
   }
-  return resolveWorktreeFallbackPath(projectRoot, PROJECT_CONFIG_RELATIVE_PATH) ?? localConfigPath;
+  return hostConfigPath;
 }
-function resolveProjectIndexPath(projectRoot, scope) {
+function resolveWritableProjectConfigPath(projectRoot, host = "opencode") {
+  return path8.join(projectRoot, getProjectConfigRelativePath(host));
+}
+function resolveProjectIndexPath(projectRoot, scope, host = "opencode") {
   if (scope === "global") {
-    return getGlobalIndexPath();
+    return resolveGlobalIndexPath(host);
   }
-  const localIndexPath = path8.join(projectRoot, PROJECT_INDEX_RELATIVE_PATH);
+  const localIndexPath = path8.join(projectRoot, getProjectIndexRelativePath(host));
   if (existsSync5(localIndexPath)) {
     return localIndexPath;
   }
-  if (hasProjectConfig(projectRoot)) {
+  if (host !== "opencode") {
+    const legacyIndexPath = path8.join(projectRoot, OPENCODE_PROJECT_INDEX_RELATIVE_PATH);
+    if (existsSync5(legacyIndexPath) && !hasHostProjectConfig(projectRoot, host)) {
+      return legacyIndexPath;
+    }
+  }
+  if (hasHostProjectConfig(projectRoot, host)) {
     return localIndexPath;
   }
-  return resolveWorktreeFallbackPath(projectRoot, PROJECT_INDEX_RELATIVE_PATH) ?? localIndexPath;
+  const hostFallback = resolveWorktreeFallbackPath(projectRoot, getProjectIndexRelativePath(host));
+  if (hostFallback) {
+    return hostFallback;
+  }
+  if (host !== "opencode") {
+    const legacyFallback = resolveWorktreeFallbackPath(projectRoot, OPENCODE_PROJECT_INDEX_RELATIVE_PATH);
+    if (legacyFallback) {
+      return legacyFallback;
+    }
+  }
+  return localIndexPath;
 }
 
 // src/tools/changed-files.ts
@@ -4609,8 +4826,8 @@ function normalizeFiles(rawFiles, projectRoot) {
     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;
+    const relative10 = path9.relative(projectRoot, absolute);
+    const cleaned = relative10.startsWith("./") ? relative10.slice(2) : relative10;
     if (!seen.has(cleaned)) {
       seen.add(cleaned);
       result.push(cleaned);
@@ -5888,6 +6105,7 @@ function unionCandidates(semanticCandidates, keywordCandidates) {
   return Array.from(byId.values());
 }
 var Indexer = class {
+  host;
   config;
   projectRoot;
   indexPath;
@@ -5909,9 +6127,10 @@ var Indexer = class {
   querySimilarityThreshold = 0.85;
   indexCompatibility = null;
   indexingLockPath = "";
-  constructor(projectRoot, config) {
+  constructor(projectRoot, config, host = "opencode") {
     this.projectRoot = projectRoot;
     this.config = config;
+    this.host = host;
     this.indexPath = this.getIndexPath();
     this.fileHashCachePath = path10.join(this.indexPath, "file-hashes.json");
     this.failedBatchesPath = path10.join(this.indexPath, "failed-batches.json");
@@ -5919,7 +6138,7 @@ var Indexer = class {
     this.logger = initializeLogger(config.debug);
   }
   getIndexPath() {
-    return resolveProjectIndexPath(this.projectRoot, this.config.scope);
+    return resolveProjectIndexPath(this.projectRoot, this.config.scope, this.host);
   }
   loadFileHashCache() {
     if (!existsSync6(this.fileHashCachePath)) {
@@ -7357,7 +7576,7 @@ var Indexer = class {
     for (const requestBatch of requestBatches) {
       queue.add(async () => {
         if (rateLimitBackoffMs > 0) {
-          await new Promise((resolve11) => setTimeout(resolve11, rateLimitBackoffMs));
+          await new Promise((resolve15) => setTimeout(resolve15, rateLimitBackoffMs));
         }
         try {
           const result = await pRetry(
@@ -7918,8 +8137,14 @@ var Indexer = class {
       this.indexCompatibility = compatibility;
       return;
     }
-    const localProjectIndexPath = path10.join(this.projectRoot, ".opencode", "index");
-    if (path10.resolve(this.indexPath) !== path10.resolve(localProjectIndexPath)) {
+    const localProjectIndexPaths = [path10.join(this.projectRoot, getHostProjectIndexRelativePath(this.host))];
+    if (this.host !== "opencode") {
+      localProjectIndexPaths.push(path10.join(this.projectRoot, getHostProjectIndexRelativePath("opencode")));
+    }
+    const isLocalProjectIndex = localProjectIndexPaths.some(
+      (localPath) => path10.resolve(this.indexPath) === path10.resolve(localPath)
+    );
+    if (!isLocalProjectIndex) {
       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."
       );
@@ -8364,9 +8589,9 @@ var Indexer = class {
     const { database } = await this.ensureInitialized();
     let shortest = [];
     for (const branchKey of this.getBranchCatalogKeys()) {
-      const path19 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
-      if (path19.length > 0 && (shortest.length === 0 || path19.length < shortest.length)) {
-        shortest = path19;
+      const path25 = database.findShortestPath(fromName, toName, branchKey, maxDepth);
+      if (path25.length > 0 && (shortest.length === 0 || path25.length < shortest.length)) {
+        shortest = path25;
       }
     }
     return shortest;
@@ -8552,6 +8777,46 @@ var Indexer = class {
       conflictingPRs
     };
   }
+  async getVisualizationData(options) {
+    const { database, store } = await this.ensureInitialized();
+    const seenSymbols = /* @__PURE__ */ new Map();
+    const seenEdges = /* @__PURE__ */ new Map();
+    for (const branchKey of this.getBranchCatalogKeys()) {
+      const symbolIds = database.getBranchSymbolIds(branchKey);
+      const symbolIdSet = new Set(symbolIds);
+      const chunkIds = database.getBranchChunkIds(branchKey);
+      const metadataMap = chunkIds.length > 0 ? store.getMetadataBatch(chunkIds) : /* @__PURE__ */ new Map();
+      const filePaths = /* @__PURE__ */ new Set();
+      for (const [, meta] of metadataMap) {
+        if (meta.filePath) filePaths.add(meta.filePath);
+      }
+      const directory = options?.directory?.replace(/\/$/, "");
+      const absoluteDirectoryFilter = directory ? path10.resolve(this.projectRoot, directory) : void 0;
+      for (const filePath of filePaths) {
+        if (directory) {
+          const absoluteFilePath = path10.resolve(filePath);
+          const matchesRelative = filePath === directory || filePath.startsWith(directory + "/");
+          const matchesProjectRelative = absoluteDirectoryFilter !== void 0 && (absoluteFilePath === absoluteDirectoryFilter || absoluteFilePath.startsWith(absoluteDirectoryFilter + path10.sep));
+          if (!matchesRelative && !matchesProjectRelative) {
+            continue;
+          }
+        }
+        for (const sym of database.getSymbolsByFile(filePath)) {
+          if (symbolIdSet.has(sym.id) && !seenSymbols.has(sym.id)) {
+            seenSymbols.set(sym.id, sym);
+          }
+        }
+      }
+      for (const symbolId of seenSymbols.keys()) {
+        for (const edge of database.getCallees(symbolId, branchKey)) {
+          if (!seenEdges.has(edge.id)) {
+            seenEdges.set(edge.id, edge);
+          }
+        }
+      }
+    }
+    return { symbols: [...seenSymbols.values()], edges: [...seenEdges.values()] };
+  }
   async close() {
     await this.database?.close();
     this.database = null;
@@ -9024,23 +9289,23 @@ function isRecord2(value) {
 function isStringArray3(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
-function asPositiveNumber(value, path19) {
+function asPositiveNumber(value, path25) {
   if (typeof value !== "number" || Number.isNaN(value) || value < 0) {
-    throw new Error(`${path19} must be a non-negative number`);
+    throw new Error(`${path25} must be a non-negative number`);
   }
   return value;
 }
-function parseQueryType(value, path19) {
+function parseQueryType(value, path25) {
   if (value === "definition" || value === "implementation-intent" || value === "similarity" || value === "keyword-heavy") {
     return value;
   }
   throw new Error(
-    `${path19} must be one of: definition, implementation-intent, similarity, keyword-heavy`
+    `${path25} must be one of: definition, implementation-intent, similarity, keyword-heavy`
   );
 }
-function parseExpected(input, path19) {
+function parseExpected(input, path25) {
   if (!isRecord2(input)) {
-    throw new Error(`${path19} must be an object`);
+    throw new Error(`${path25} must be an object`);
   }
   const filePathRaw = input.filePath;
   const acceptableFilesRaw = input.acceptableFiles;
@@ -9049,16 +9314,16 @@ function parseExpected(input, path19) {
   const filePath = typeof filePathRaw === "string" ? filePathRaw : void 0;
   const acceptableFiles = isStringArray3(acceptableFilesRaw) ? acceptableFilesRaw : void 0;
   if (!filePath && (!acceptableFiles || acceptableFiles.length === 0)) {
-    throw new Error(`${path19} must include either expected.filePath or expected.acceptableFiles`);
+    throw new Error(`${path25} must include either expected.filePath or expected.acceptableFiles`);
   }
   if (acceptableFilesRaw !== void 0 && !isStringArray3(acceptableFilesRaw)) {
-    throw new Error(`${path19}.acceptableFiles must be an array of strings`);
+    throw new Error(`${path25}.acceptableFiles must be an array of strings`);
   }
   if (symbolRaw !== void 0 && typeof symbolRaw !== "string") {
-    throw new Error(`${path19}.symbol must be a string when provided`);
+    throw new Error(`${path25}.symbol must be a string when provided`);
   }
   if (branchRaw !== void 0 && typeof branchRaw !== "string") {
-    throw new Error(`${path19}.branch must be a string when provided`);
+    throw new Error(`${path25}.branch must be a string when provided`);
   }
   return {
     filePath,
@@ -9068,25 +9333,25 @@ function parseExpected(input, path19) {
   };
 }
 function parseQuery(input, index) {
-  const path19 = `queries[${index}]`;
+  const path25 = `queries[${index}]`;
   if (!isRecord2(input)) {
-    throw new Error(`${path19} must be an object`);
+    throw new Error(`${path25} 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(`${path19}.id must be a non-empty string`);
+    throw new Error(`${path25}.id must be a non-empty string`);
   }
   if (typeof query !== "string" || query.trim().length === 0) {
-    throw new Error(`${path19}.query must be a non-empty string`);
+    throw new Error(`${path25}.query must be a non-empty string`);
   }
   return {
     id,
     query,
-    queryType: parseQueryType(queryType, `${path19}.queryType`),
-    expected: parseExpected(expected, `${path19}.expected`)
+    queryType: parseQueryType(queryType, `${path25}.queryType`),
+    expected: parseExpected(expected, `${path25}.expected`)
   };
 }
 function parseGoldenDataset(raw, sourceLabel) {
@@ -9669,8 +9934,7 @@ async function handleEvalCommand(args, cwd) {
 
 // src/mcp-server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import * as path17 from "path";
-import { existsSync as existsSync10 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 
 // src/mcp-server/register-prompts.ts
 import { z } from "zod";
@@ -9765,168 +10029,6 @@ Use the implementation_lookup tool to find where this symbol is defined. This pr
 // src/mcp-server/register-tools.ts
 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 path16 from "path";
-var PROJECT_OVERRIDE_KEYS = [
-  "embeddingProvider",
-  "customProvider",
-  "embeddingModel",
-  "reranker",
-  "include",
-  "exclude",
-  "indexing",
-  "search",
-  "debug",
-  "scope"
-];
-var MERGE_ARRAY_KEYS = ["knowledgeBases", "additionalInclude"];
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isStringArray4(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string");
-}
-function applyProjectOverride(merged, normalizedProjectConfig, globalConfig, key) {
-  if (key in normalizedProjectConfig) {
-    merged[key] = normalizedProjectConfig[key];
-    return;
-  }
-  if (key in globalConfig) {
-    merged[key] = globalConfig[key];
-  }
-}
-function mergeUniqueStringArray(values) {
-  return [...new Set(values.map((value) => String(value).trim()))];
-}
-function normalizeKnowledgeBasePath(value) {
-  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);
-  }
-  return normalized;
-}
-function mergeKnowledgeBasePaths(values) {
-  return [...new Set(values.map((value) => normalizeKnowledgeBasePath(value)).filter((value) => value.length > 0))];
-}
-function validateConfigLayerShape(rawConfig, filePath) {
-  if (!isRecord3(rawConfig)) {
-    throw new Error(`Config file ${filePath} must contain a JSON object at the root.`);
-  }
-  if (rawConfig.knowledgeBases !== void 0 && !isStringArray4(rawConfig.knowledgeBases)) {
-    throw new Error(`Config file ${filePath} field 'knowledgeBases' must be an array of strings.`);
-  }
-  if (rawConfig.additionalInclude !== void 0 && !isStringArray4(rawConfig.additionalInclude)) {
-    throw new Error(`Config file ${filePath} field 'additionalInclude' must be an array of strings.`);
-  }
-  if (rawConfig.include !== void 0 && !isStringArray4(rawConfig.include)) {
-    throw new Error(`Config file ${filePath} field 'include' must be an array of strings.`);
-  }
-  if (rawConfig.exclude !== void 0 && !isStringArray4(rawConfig.exclude)) {
-    throw new Error(`Config file ${filePath} field 'exclude' must be an array of strings.`);
-  }
-  for (const section of ["customProvider", "indexing", "search", "debug", "reranker"]) {
-    const value = rawConfig[section];
-    if (value !== void 0 && !isRecord3(value)) {
-      throw new Error(`Config file ${filePath} field '${section}' must be an object.`);
-    }
-  }
-  return rawConfig;
-}
-function loadJsonFile(filePath) {
-  if (!existsSync9(filePath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync9(filePath, "utf-8");
-    return validateConfigLayerShape(JSON.parse(content), filePath);
-  } catch (error) {
-    if (error instanceof Error && error.message.startsWith("Config file ")) {
-      throw error;
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to load config file ${filePath}: ${message}`);
-  }
-  return null;
-}
-function materializeLocalProjectConfig(projectRoot, config) {
-  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;
-}
-function loadProjectConfigLayer(projectRoot) {
-  const projectConfigPath = resolveProjectConfigPath(projectRoot);
-  const projectConfig = loadJsonFile(projectConfigPath);
-  if (!projectConfig) {
-    return {};
-  }
-  const normalizedConfig = { ...projectConfig };
-  const projectConfigBaseDir = path16.dirname(path16.dirname(projectConfigPath));
-  if (Array.isArray(normalizedConfig.knowledgeBases)) {
-    normalizedConfig.knowledgeBases = resolveInheritedKnowledgeBaseEntries(
-      normalizedConfig.knowledgeBases,
-      projectConfigBaseDir,
-      projectRoot
-    );
-  }
-  return normalizedConfig;
-}
-function loadMergedConfig(projectRoot) {
-  const globalConfigPath = os5.homedir() + "/.config/opencode/codebase-index.json";
-  const projectConfigPath = resolveProjectConfigPath(projectRoot);
-  let globalConfig = null;
-  let globalConfigError = null;
-  try {
-    globalConfig = loadJsonFile(globalConfigPath);
-  } catch (error) {
-    globalConfigError = error instanceof Error ? error : new Error(String(error));
-  }
-  const projectConfig = loadJsonFile(projectConfigPath);
-  const normalizedProjectConfig = loadProjectConfigLayer(projectRoot);
-  if (globalConfigError) {
-    if (!projectConfig) {
-      throw globalConfigError;
-    }
-    globalConfig = null;
-  }
-  if (!globalConfig && !projectConfig) {
-    return {};
-  }
-  if (!projectConfig && globalConfig) {
-    return globalConfig;
-  }
-  if (!globalConfig && projectConfig) {
-    return normalizedProjectConfig;
-  }
-  if (!globalConfig || !projectConfig) {
-    return globalConfig ?? normalizedProjectConfig;
-  }
-  const merged = { ...globalConfig };
-  for (const key of PROJECT_OVERRIDE_KEYS) {
-    applyProjectOverride(merged, normalizedProjectConfig, globalConfig, key);
-  }
-  if (projectConfig) {
-    for (const key of Object.keys(projectConfig)) {
-      if (PROJECT_OVERRIDE_KEYS.includes(key) || MERGE_ARRAY_KEYS.includes(key)) {
-        continue;
-      }
-      merged[key] = normalizedProjectConfig[key];
-    }
-  }
-  const globalKbs = globalConfig && Array.isArray(globalConfig.knowledgeBases) ? globalConfig.knowledgeBases : [];
-  const projectKbs = projectConfig ? Array.isArray(normalizedProjectConfig.knowledgeBases) ? normalizedProjectConfig.knowledgeBases : [] : [];
-  const allKbs = [...globalKbs, ...projectKbs];
-  merged.knowledgeBases = mergeKnowledgeBasePaths(allKbs);
-  const globalAdditional = globalConfig && Array.isArray(globalConfig.additionalInclude) ? globalConfig.additionalInclude : [];
-  const projectAdditional = projectConfig && Array.isArray(projectConfig.additionalInclude) ? projectConfig.additionalInclude : [];
-  const allAdditional = [...globalAdditional, ...projectAdditional];
-  merged.additionalInclude = mergeUniqueStringArray(allAdditional);
-  return merged;
-}
-
 // src/tools/utils.ts
 var MAX_CONTENT_LINES = 30;
 function truncateContent(content) {
@@ -10038,6 +10140,36 @@ function formatStatus(status) {
   }
   return lines.join("\n");
 }
+function formatProgressTitle(progress) {
+  switch (progress.phase) {
+    case "scanning":
+      return "Scanning files...";
+    case "parsing":
+      return `Parsing: ${progress.filesProcessed}/${progress.totalFiles} files`;
+    case "embedding":
+      return `Embedding: ${progress.chunksProcessed}/${progress.totalChunks} chunks`;
+    case "storing":
+      return "Storing index...";
+    case "complete":
+      return "Indexing complete";
+    default:
+      return "Indexing...";
+  }
+}
+function calculatePercentage(progress) {
+  if (progress.phase === "scanning") return 0;
+  if (progress.phase === "complete") return 100;
+  if (progress.phase === "parsing") {
+    if (progress.totalFiles === 0) return 5;
+    return Math.round(5 + progress.filesProcessed / progress.totalFiles * 15);
+  }
+  if (progress.phase === "embedding") {
+    if (progress.totalChunks === 0) return 20;
+    return Math.round(20 + progress.chunksProcessed / progress.totalChunks * 70);
+  }
+  if (progress.phase === "storing") return 95;
+  return 0;
+}
 function formatHealthCheck(result) {
   if (result.resetCorruptedIndex) {
     return result.warning ?? "Detected a corrupted local index and reset it. Run index_codebase to rebuild search data.";
@@ -10134,20 +10266,424 @@ function formatPrImpact(result) {
   return lines.join("\n");
 }
 
-// src/mcp-server/shared.ts
-var MAX_CONTENT_LINES2 = 30;
-function truncateContent2(content) {
-  const lines = content.split("\n");
-  if (lines.length <= MAX_CONTENT_LINES2) return content;
-  return lines.slice(0, MAX_CONTENT_LINES2).join("\n") + `
-// ... (${lines.length - MAX_CONTENT_LINES2} more lines)`;
-}
-var CHUNK_TYPE_ENUM = [
-  "function",
-  "class",
-  "method",
-  "interface",
-  "type",
+// src/tools/operations.ts
+import { existsSync as existsSync11, realpathSync, statSync as statSync3 } from "fs";
+import * as path19 from "path";
+
+// src/config/merger.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
+import * as path16 from "path";
+var PROJECT_OVERRIDE_KEYS = [
+  "embeddingProvider",
+  "customProvider",
+  "embeddingModel",
+  "reranker",
+  "include",
+  "exclude",
+  "indexing",
+  "search",
+  "debug",
+  "scope"
+];
+var MERGE_ARRAY_KEYS = ["knowledgeBases", "additionalInclude"];
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray4(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function applyProjectOverride(merged, normalizedProjectConfig, globalConfig, key) {
+  if (key in normalizedProjectConfig) {
+    merged[key] = normalizedProjectConfig[key];
+    return;
+  }
+  if (key in globalConfig) {
+    merged[key] = globalConfig[key];
+  }
+}
+function mergeUniqueStringArray(values) {
+  return [...new Set(values.map((value) => String(value).trim()))];
+}
+function normalizeKnowledgeBasePath(value) {
+  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);
+  }
+  return normalized;
+}
+function mergeKnowledgeBasePaths(values) {
+  return [...new Set(values.map((value) => normalizeKnowledgeBasePath(value)).filter((value) => value.length > 0))];
+}
+function validateConfigLayerShape(rawConfig, filePath) {
+  if (!isRecord3(rawConfig)) {
+    throw new Error(`Config file ${filePath} must contain a JSON object at the root.`);
+  }
+  if (rawConfig.knowledgeBases !== void 0 && !isStringArray4(rawConfig.knowledgeBases)) {
+    throw new Error(`Config file ${filePath} field 'knowledgeBases' must be an array of strings.`);
+  }
+  if (rawConfig.additionalInclude !== void 0 && !isStringArray4(rawConfig.additionalInclude)) {
+    throw new Error(`Config file ${filePath} field 'additionalInclude' must be an array of strings.`);
+  }
+  if (rawConfig.include !== void 0 && !isStringArray4(rawConfig.include)) {
+    throw new Error(`Config file ${filePath} field 'include' must be an array of strings.`);
+  }
+  if (rawConfig.exclude !== void 0 && !isStringArray4(rawConfig.exclude)) {
+    throw new Error(`Config file ${filePath} field 'exclude' must be an array of strings.`);
+  }
+  for (const section of ["customProvider", "indexing", "search", "debug", "reranker"]) {
+    const value = rawConfig[section];
+    if (value !== void 0 && !isRecord3(value)) {
+      throw new Error(`Config file ${filePath} field '${section}' must be an object.`);
+    }
+  }
+  return rawConfig;
+}
+function loadJsonFile(filePath) {
+  if (!existsSync9(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync9(filePath, "utf-8");
+    return validateConfigLayerShape(JSON.parse(content), filePath);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Config file ")) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load config file ${filePath}: ${message}`);
+  }
+}
+function loadConfigFile(filePath) {
+  return loadJsonFile(filePath);
+}
+function materializeLocalProjectConfig(projectRoot, config, host = "opencode") {
+  const localConfigPath = resolveWritableProjectConfigPath(projectRoot, host);
+  mkdirSync4(path16.dirname(localConfigPath), { recursive: true });
+  writeFileSync4(localConfigPath, JSON.stringify(config, null, 2), "utf-8");
+  return localConfigPath;
+}
+function loadProjectConfigLayer(projectRoot, host = "opencode") {
+  const projectConfigPath = resolveProjectConfigPath(projectRoot, host);
+  const projectConfig = loadJsonFile(projectConfigPath);
+  if (!projectConfig) {
+    return {};
+  }
+  const normalizedConfig = { ...projectConfig };
+  const projectConfigBaseDir = path16.dirname(path16.dirname(projectConfigPath));
+  if (Array.isArray(normalizedConfig.knowledgeBases)) {
+    normalizedConfig.knowledgeBases = resolveInheritedKnowledgeBaseEntries(
+      normalizedConfig.knowledgeBases,
+      projectConfigBaseDir,
+      projectRoot
+    );
+  }
+  return normalizedConfig;
+}
+function loadMergedConfig(projectRoot, host = "opencode") {
+  const globalConfigPath = resolveGlobalConfigPath(host);
+  const projectConfigPath = resolveProjectConfigPath(projectRoot, host);
+  let globalConfig = null;
+  let globalConfigError = null;
+  try {
+    globalConfig = loadJsonFile(globalConfigPath);
+  } catch (error) {
+    globalConfigError = error instanceof Error ? error : new Error(String(error));
+  }
+  const projectConfig = loadJsonFile(projectConfigPath);
+  const normalizedProjectConfig = loadProjectConfigLayer(projectRoot, host);
+  if (globalConfigError) {
+    if (!projectConfig) {
+      throw globalConfigError;
+    }
+    globalConfig = null;
+  }
+  if (!globalConfig && !projectConfig) {
+    return {};
+  }
+  if (!projectConfig && globalConfig) {
+    return globalConfig;
+  }
+  if (!globalConfig && projectConfig) {
+    return normalizedProjectConfig;
+  }
+  if (!globalConfig || !projectConfig) {
+    return globalConfig ?? normalizedProjectConfig;
+  }
+  const merged = { ...globalConfig };
+  for (const key of PROJECT_OVERRIDE_KEYS) {
+    applyProjectOverride(merged, normalizedProjectConfig, globalConfig, key);
+  }
+  if (projectConfig) {
+    for (const key of Object.keys(projectConfig)) {
+      if (PROJECT_OVERRIDE_KEYS.includes(key) || MERGE_ARRAY_KEYS.includes(key)) {
+        continue;
+      }
+      merged[key] = normalizedProjectConfig[key];
+    }
+  }
+  const globalKbs = globalConfig && Array.isArray(globalConfig.knowledgeBases) ? globalConfig.knowledgeBases : [];
+  const projectKbs = projectConfig ? Array.isArray(normalizedProjectConfig.knowledgeBases) ? normalizedProjectConfig.knowledgeBases : [] : [];
+  const allKbs = [...globalKbs, ...projectKbs];
+  merged.knowledgeBases = mergeKnowledgeBasePaths(allKbs);
+  const globalAdditional = globalConfig && Array.isArray(globalConfig.additionalInclude) ? globalConfig.additionalInclude : [];
+  const projectAdditional = projectConfig && Array.isArray(projectConfig.additionalInclude) ? projectConfig.additionalInclude : [];
+  const allAdditional = [...globalAdditional, ...projectAdditional];
+  merged.additionalInclude = mergeUniqueStringArray(allAdditional);
+  return merged;
+}
+
+// src/tools/knowledge-base-paths.ts
+import * as path17 from "path";
+function resolveConfigPathValue(value, baseDir) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  const absolutePath = path17.isAbsolute(trimmed) ? trimmed : path17.resolve(baseDir, trimmed);
+  return path17.normalize(absolutePath);
+}
+
+// src/tools/config-state.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import * as path18 from "path";
+function normalizeKnowledgeBasePaths(config, projectRoot) {
+  const normalized = { ...config };
+  if (Array.isArray(normalized.knowledgeBases)) {
+    normalized.knowledgeBases = normalized.knowledgeBases.map(
+      (kb) => resolveConfigPathValue(kb, projectRoot)
+    );
+  }
+  return normalized;
+}
+function toConfigRecord(rawConfig) {
+  if (!rawConfig || typeof rawConfig !== "object") {
+    return {};
+  }
+  return { ...rawConfig };
+}
+function loadRuntimeConfig(projectRoot, host = "opencode") {
+  return normalizeKnowledgeBasePaths(toConfigRecord(loadMergedConfig(projectRoot, host)), projectRoot);
+}
+
+// src/tools/operations.ts
+var indexerCache = /* @__PURE__ */ new Map();
+var configCache = /* @__PURE__ */ new Map();
+var defaultProjectRoots = /* @__PURE__ */ new Map();
+function getProjectRoot(projectRoot, host) {
+  if (projectRoot) {
+    return projectRoot;
+  }
+  const root = defaultProjectRoots.get(host);
+  if (!root) {
+    throw new Error("Codebase index tools not initialized. Plugin may not be loaded correctly.");
+  }
+  return root;
+}
+function getIndexerCacheKey(projectRoot, host) {
+  return `${host}::${projectRoot}`;
+}
+function getOrCreateIndexer(projectRoot, host) {
+  const key = getIndexerCacheKey(projectRoot, host);
+  const cached = indexerCache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const config = parseConfig(loadRuntimeConfig(projectRoot, host));
+  const indexer = new Indexer(projectRoot, config, host);
+  indexerCache.set(key, indexer);
+  configCache.set(key, config);
+  return indexer;
+}
+function initializeTools(projectRoot, config, host = "opencode") {
+  defaultProjectRoots.set(host, projectRoot);
+  const key = getIndexerCacheKey(projectRoot, host);
+  const indexer = new Indexer(projectRoot, config, host);
+  indexerCache.set(key, indexer);
+  configCache.set(key, config);
+}
+function getIndexerForProject(projectRoot, host = "opencode") {
+  const root = getProjectRoot(projectRoot, host);
+  return getOrCreateIndexer(root, host);
+}
+function refreshIndexerForDirectory(projectRoot, host = "opencode", config = parseConfig(loadRuntimeConfig(projectRoot, host))) {
+  const key = getIndexerCacheKey(projectRoot, host);
+  const indexer = new Indexer(projectRoot, config, host);
+  indexerCache.set(key, indexer);
+  configCache.set(key, config);
+}
+function shouldForceLocalizeProjectIndex(projectRoot, host = "opencode") {
+  const root = getProjectRoot(projectRoot, host);
+  const localIndexPath = path19.join(root, getHostProjectIndexRelativePath(host));
+  if (existsSync11(localIndexPath)) {
+    return false;
+  }
+  const inheritedIndexPath = resolveWorktreeFallbackProjectIndexPath(root, host);
+  return inheritedIndexPath !== null;
+}
+async function searchCodebase(projectRoot, host, query, options = {}) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  return indexer.search(query, options.limit, {
+    fileType: options.fileType,
+    directory: options.directory,
+    chunkType: options.chunkType,
+    contextLines: options.contextLines,
+    metadataOnly: options.metadataOnly,
+    definitionIntent: options.definitionIntent
+  });
+}
+async function findSimilarCode(projectRoot, host, code, options = {}) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  return indexer.findSimilar(code, options.limit, {
+    fileType: options.fileType,
+    directory: options.directory,
+    chunkType: options.chunkType,
+    excludeFile: options.excludeFile
+  });
+}
+async function implementationLookup(projectRoot, host, query, options = {}) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  return indexer.search(query, options.limit, {
+    fileType: options.fileType,
+    directory: options.directory,
+    definitionIntent: true
+  });
+}
+async function getCallGraphData(projectRoot, host, params) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  if (params.direction === "callees") {
+    if (!params.symbolId) {
+      return { direction: "callees", callees: [], callers: [] };
+    }
+    const callees = await indexer.getCallees(params.symbolId, params.relationshipType);
+    return { direction: "callees", callees, callers: [] };
+  }
+  const callers = await indexer.getCallers(params.name, params.relationshipType);
+  return { direction: "callers", callers, callees: [] };
+}
+async function getCallGraphPath(projectRoot, host, from, to, maxDepth) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  return indexer.findCallPath(from, to, maxDepth);
+}
+async function runIndexCodebase(projectRoot, host, args, onProgress) {
+  const root = getProjectRoot(projectRoot, host);
+  const key = getIndexerCacheKey(root, host);
+  const cachedConfig = configCache.get(key);
+  let indexer = getIndexerForProject(root, host);
+  if (args.estimateOnly) {
+    return { kind: "estimate", estimate: await indexer.estimateCost() };
+  }
+  if (args.force) {
+    if (shouldForceLocalizeProjectIndex(root, host)) {
+      materializeLocalProjectConfig(root, loadProjectConfigLayer(root, host), host);
+      refreshIndexerForDirectory(root, host, cachedConfig);
+      indexer = getIndexerForProject(root, host);
+    }
+    await indexer.clearIndex();
+    refreshIndexerForDirectory(root, host, cachedConfig);
+    indexer = getIndexerForProject(root, host);
+  }
+  const stats = await indexer.index((progress) => {
+    if (onProgress) {
+      return onProgress(formatProgressTitle(progress), {
+        phase: progress.phase,
+        filesProcessed: progress.filesProcessed,
+        totalFiles: progress.totalFiles,
+        chunksProcessed: progress.chunksProcessed,
+        totalChunks: progress.totalChunks,
+        percentage: calculatePercentage(progress)
+      });
+    }
+    return Promise.resolve();
+  });
+  return { kind: "stats", stats };
+}
+async function getIndexStatus(projectRoot, host) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  return indexer.getStatus();
+}
+async function getIndexHealthCheck(projectRoot, host) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  return indexer.healthCheck();
+}
+async function getPrImpact(projectRoot, host, params) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  return indexer.getPrImpact({
+    pr: params.pr,
+    branch: params.branch,
+    maxDepth: params.maxDepth,
+    hubThreshold: params.hubThreshold,
+    checkConflicts: params.checkConflicts,
+    direction: params.direction
+  });
+}
+async function getIndexMetrics(projectRoot, host) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  const logger = indexer.getLogger();
+  if (!logger.isEnabled()) {
+    return {
+      enabled: false,
+      metricsEnabled: false,
+      text: 'Debug mode is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true,\n    "metrics": true\n  }\n}\n```'
+    };
+  }
+  if (!logger.isMetricsEnabled()) {
+    return {
+      enabled: true,
+      metricsEnabled: false,
+      text: 'Metrics collection is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true,\n    "metrics": true\n  }\n}\n```'
+    };
+  }
+  return {
+    enabled: true,
+    metricsEnabled: true,
+    text: logger.formatMetrics()
+  };
+}
+async function getIndexLogs(projectRoot, host, args) {
+  const indexer = getIndexerForProject(projectRoot, host);
+  const logger = indexer.getLogger();
+  if (!logger.isEnabled()) {
+    return {
+      kind: "disabled",
+      text: 'Debug mode is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true\n  }\n}\n```'
+    };
+  }
+  let logs;
+  if (args.category) {
+    logs = logger.getLogsByCategory(args.category, args.limit);
+  } else if (args.level) {
+    logs = logger.getLogsByLevel(args.level, args.limit);
+  } else {
+    logs = logger.getLogs(args.limit);
+  }
+  if (logs.length === 0) {
+    return {
+      kind: "entries",
+      text: "No logs recorded yet. Logs are captured during indexing and search operations."
+    };
+  }
+  const text = logs.map((entry) => {
+    const dataStr = entry.data ? ` ${JSON.stringify(entry.data)}` : "";
+    return `[${entry.timestamp}] [${entry.level.toUpperCase()}] [${entry.category}] ${entry.message}${dataStr}`;
+  }).join("\n");
+  return { kind: "entries", text };
+}
+
+// src/mcp-server/shared.ts
+var MAX_CONTENT_LINES2 = 30;
+function truncateContent2(content) {
+  const lines = content.split("\n");
+  if (lines.length <= MAX_CONTENT_LINES2) return content;
+  return lines.slice(0, MAX_CONTENT_LINES2).join("\n") + `
+// ... (${lines.length - MAX_CONTENT_LINES2} more lines)`;
+}
+var CHUNK_TYPE_ENUM = [
+  "function",
+  "class",
+  "method",
+  "interface",
+  "type",
   "enum",
   "struct",
   "impl",
@@ -10170,8 +10706,8 @@ function registerMcpTools(server, runtime) {
       contextLines: z2.number().optional().describe("Number of extra lines to include before/after each match (default: 0)")
     },
     async (args) => {
-      await runtime.ensureInitialized();
-      const results = await runtime.getIndexer().search(args.query, args.limit ?? 5, {
+      const results = await searchCodebase(runtime.projectRoot, runtime.host, args.query, {
+        limit: args.limit ?? 5,
         fileType: args.fileType,
         directory: args.directory,
         chunkType: args.chunkType,
@@ -10203,8 +10739,8 @@ ${formatted.join("\n\n")}` }] };
       chunkType: z2.enum(CHUNK_TYPE_ENUM).optional().describe("Filter by code chunk type")
     },
     async (args) => {
-      await runtime.ensureInitialized();
-      const results = await runtime.getIndexer().search(args.query, args.limit ?? 10, {
+      const results = await searchCodebase(runtime.projectRoot, runtime.host, args.query, {
+        limit: args.limit ?? 10,
         fileType: args.fileType,
         directory: args.directory,
         chunkType: args.chunkType,
@@ -10234,25 +10770,9 @@ Use Read tool to examine specific files.` }] };
       verbose: z2.boolean().optional().default(false).describe("Show detailed info about skipped files and parsing failures")
     },
     async (args) => {
-      if (args.estimateOnly) {
-        await runtime.ensureInitialized();
-        const estimate = await runtime.getIndexer().estimateCost();
-        return { content: [{ type: "text", text: formatCostEstimate(estimate) }] };
-      }
-      if (args.force) {
-        if (runtime.shouldForceLocalizeProjectIndex()) {
-          materializeLocalProjectConfig(runtime.projectRoot, loadProjectConfigLayer(runtime.projectRoot));
-          runtime.refreshIndexerFromConfig();
-        }
-        await runtime.ensureInitialized();
-        await runtime.getIndexer().clearIndex();
-        runtime.refreshIndexerFromConfig();
-        await runtime.ensureInitialized();
-      } else {
-        await runtime.ensureInitialized();
-      }
-      const stats = await runtime.getIndexer().index();
-      return { content: [{ type: "text", text: formatIndexStats(stats, args.verbose ?? false) }] };
+      const result = await runIndexCodebase(runtime.projectRoot, runtime.host, args);
+      const text = result.kind === "estimate" ? formatCostEstimate(result.estimate) : formatIndexStats(result.stats, args.verbose ?? false);
+      return { content: [{ type: "text", text }] };
     }
   );
   server.tool(
@@ -10260,8 +10780,7 @@ Use Read tool to examine specific files.` }] };
     "Check the status of the codebase index. Shows whether the codebase is indexed, how many chunks are stored, and the embedding provider being used.",
     {},
     async () => {
-      await runtime.ensureInitialized();
-      const status = await runtime.getIndexer().getStatus();
+      const status = await getIndexStatus(runtime.projectRoot, runtime.host);
       return { content: [{ type: "text", text: formatStatus(status) }] };
     }
   );
@@ -10270,8 +10789,7 @@ Use Read tool to examine specific files.` }] };
     "Check index health and remove stale entries from deleted files. Run this to clean up the index after files have been deleted.",
     {},
     async () => {
-      await runtime.ensureInitialized();
-      const result = await runtime.getIndexer().healthCheck();
+      const result = await getIndexHealthCheck(runtime.projectRoot, runtime.host);
       return { content: [{ type: "text", text: formatHealthCheck(result) }] };
     }
   );
@@ -10280,15 +10798,8 @@ Use Read tool to examine specific files.` }] };
     "Get metrics and performance statistics for the codebase index. Requires debug.enabled=true and debug.metrics=true in config.",
     {},
     async () => {
-      await runtime.ensureInitialized();
-      const logger = runtime.getIndexer().getLogger();
-      if (!logger.isEnabled()) {
-        return { content: [{ type: "text", text: 'Debug mode is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true,\n    "metrics": true\n  }\n}\n```' }] };
-      }
-      if (!logger.isMetricsEnabled()) {
-        return { content: [{ type: "text", text: 'Metrics collection is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true,\n    "metrics": true\n  }\n}\n```' }] };
-      }
-      return { content: [{ type: "text", text: logger.formatMetrics() }] };
+      const result = await getIndexMetrics(runtime.projectRoot, runtime.host);
+      return { content: [{ type: "text", text: result.text }] };
     }
   );
   server.tool(
@@ -10300,27 +10811,8 @@ Use Read tool to examine specific files.` }] };
       level: z2.enum(["error", "warn", "info", "debug"]).optional().describe("Filter by minimum log level")
     },
     async (args) => {
-      await runtime.ensureInitialized();
-      const logger = runtime.getIndexer().getLogger();
-      if (!logger.isEnabled()) {
-        return { content: [{ type: "text", text: 'Debug mode is disabled. Enable it in your config:\n\n```json\n{\n  "debug": {\n    "enabled": true\n  }\n}\n```' }] };
-      }
-      let logs;
-      if (args.category) {
-        logs = logger.getLogsByCategory(args.category, args.limit);
-      } else if (args.level) {
-        logs = logger.getLogsByLevel(args.level, args.limit);
-      } else {
-        logs = logger.getLogs(args.limit);
-      }
-      if (logs.length === 0) {
-        return { content: [{ type: "text", text: "No logs recorded yet. Logs are captured during indexing and search operations." }] };
-      }
-      const text = logs.map((l) => {
-        const dataStr = l.data ? ` ${JSON.stringify(l.data)}` : "";
-        return `[${l.timestamp}] [${l.level.toUpperCase()}] [${l.category}] ${l.message}${dataStr}`;
-      }).join("\n");
-      return { content: [{ type: "text", text }] };
+      const result = await getIndexLogs(runtime.projectRoot, runtime.host, args);
+      return { content: [{ type: "text", text: result.text }] };
     }
   );
   server.tool(
@@ -10335,8 +10827,8 @@ Use Read tool to examine specific files.` }] };
       excludeFile: z2.string().optional().describe("Exclude results from this file path")
     },
     async (args) => {
-      await runtime.ensureInitialized();
-      const results = await runtime.getIndexer().findSimilar(args.code, args.limit ?? 10, {
+      const results = await findSimilarCode(runtime.projectRoot, runtime.host, args.code, {
+        limit: args.limit ?? 10,
         fileType: args.fileType,
         directory: args.directory,
         chunkType: args.chunkType,
@@ -10367,11 +10859,10 @@ ${formatted.join("\n\n")}` }] };
       directory: z2.string().optional().describe("Filter by directory path (e.g., 'src/utils')")
     },
     async (args) => {
-      await runtime.ensureInitialized();
-      const results = await runtime.getIndexer().search(args.query, args.limit ?? 5, {
+      const results = await implementationLookup(runtime.projectRoot, runtime.host, args.query, {
+        limit: args.limit ?? 5,
         fileType: args.fileType,
-        directory: args.directory,
-        definitionIntent: true
+        directory: args.directory
       });
       return { content: [{ type: "text", text: formatDefinitionLookup(results, args.query) }] };
     }
@@ -10386,13 +10877,11 @@ ${formatted.join("\n\n")}` }] };
       relationshipType: z2.enum(["Call", "MethodCall", "Constructor", "Import", "Inherits", "Implements"]).optional().describe("Filter by relationship type. Omit to show all.")
     },
     async (args) => {
-      await runtime.ensureInitialized();
-      const indexer = runtime.getIndexer();
       if (args.direction === "callees") {
         if (!args.symbolId) {
           return { content: [{ type: "text", text: "Error: 'symbolId' is required when direction is 'callees'." }] };
         }
-        const callees = await indexer.getCallees(args.symbolId, args.relationshipType);
+        const { callees } = await getCallGraphData(runtime.projectRoot, runtime.host, args);
         if (callees.length === 0) {
           return { content: [{ type: "text", text: `No callees found for symbol ${args.symbolId}${args.relationshipType ? ` with type ${args.relationshipType}` : ""}.` }] };
         }
@@ -10404,7 +10893,7 @@ ${formatted.join("\n\n")}` }] };
 
 ${formatted2.join("\n")}` }] };
       }
-      const callers = await indexer.getCallers(args.name, args.relationshipType);
+      const { callers } = await getCallGraphData(runtime.projectRoot, runtime.host, args);
       if (callers.length === 0) {
         return { content: [{ type: "text", text: `No callers found for "${args.name}"${args.relationshipType ? ` with type ${args.relationshipType}` : ""}.` }] };
       }
@@ -10426,18 +10915,16 @@ ${formatted.join("\n")}` }] };
       maxDepth: z2.number().optional().default(10).describe("Maximum traversal depth (default: 10)")
     },
     async (args) => {
-      await runtime.ensureInitialized();
-      const indexer = runtime.getIndexer();
-      const path19 = await indexer.findCallPath(args.from, args.to, args.maxDepth);
-      if (path19.length === 0) {
+      const path25 = await getCallGraphPath(runtime.projectRoot, runtime.host, args.from, args.to, args.maxDepth);
+      if (path25.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 = path19.map((hop, i) => {
+      const formatted = path25.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 (${path19.length} hops):
+      return { content: [{ type: "text", text: `Path (${path25.length} hops):
 ${formatted.join("\n")}` }] };
     }
   );
@@ -10453,10 +10940,8 @@ ${formatted.join("\n")}` }] };
       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({
+        const result = await getPrImpact(runtime.projectRoot, runtime.host, {
           pr: args.pr,
           branch: args.branch,
           maxDepth: args.maxDepth,
@@ -10474,80 +10959,2922 @@ ${formatted.join("\n")}` }] };
 }
 
 // src/mcp-server.ts
-function createMcpServer(projectRoot, config) {
+function getPackageVersion() {
+  const raw = JSON.parse(readFileSync10(new URL("../package.json", import.meta.url), "utf-8"));
+  if (raw && typeof raw === "object" && "version" in raw && typeof raw.version === "string") {
+    return raw.version;
+  }
+  return "0.0.0";
+}
+function createMcpServer(projectRoot, config, host = "opencode") {
   const server = new McpServer({
     name: "opencode-codebase-index",
-    version: "0.5.1"
+    version: getPackageVersion()
   });
-  let indexer = new Indexer(projectRoot, config);
-  let initialized = false;
-  function refreshIndexerFromConfig() {
-    indexer = new Indexer(projectRoot, config);
-    initialized = false;
-  }
-  function shouldForceLocalizeProjectIndex() {
-    if (config.scope !== "project") {
-      return false;
-    }
-    const localIndexPath = path17.join(projectRoot, ".opencode", "index");
-    const mainRepoRoot = resolveWorktreeMainRepoRoot(projectRoot);
-    if (!mainRepoRoot) {
-      return false;
-    }
-    const inheritedIndexPath = path17.join(mainRepoRoot, ".opencode", "index");
-    return !existsSync10(localIndexPath) && existsSync10(inheritedIndexPath);
-  }
-  async function ensureInitialized() {
-    if (!initialized) {
-      await indexer.initialize();
-      initialized = true;
-    }
-  }
+  initializeTools(projectRoot, config, host);
   registerMcpTools(server, {
     projectRoot,
-    ensureInitialized,
-    getIndexer: () => indexer,
-    refreshIndexerFromConfig,
-    shouldForceLocalizeProjectIndex
+    host
   });
   registerMcpPrompts(server);
   return server;
 }
 
-// src/cli.ts
-function parseArgs(argv) {
-  let project = process.cwd();
-  let config;
-  for (let i = 2; i < argv.length; i++) {
-    if (argv[i] === "--project" && argv[i + 1]) {
-      project = path18.resolve(argv[++i]);
-    } else if (argv[i] === "--config" && argv[i + 1]) {
-      config = path18.resolve(argv[++i]);
-    }
-  }
-  return { project, config };
-}
-async function main() {
-  if (process.argv[2] === "eval") {
-    const exitCode = await handleEvalCommand(process.argv.slice(3), process.cwd());
-    process.exit(exitCode);
-  }
-  const args = parseArgs(process.argv);
-  const rawConfig = loadMergedConfig(args.project);
-  const config = parseConfig(rawConfig);
-  const server = createMcpServer(args.project, config);
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  const shutdown = () => {
-    server.close().catch(() => {
+// src/utils/auto-index.ts
+function getErrorMessage3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function startAutoIndex(indexer, projectRoot) {
+  indexer.initialize().then(() => {
+    indexer.index().catch((error) => {
+      console.error(`[codebase-index] Auto-index failed for "${projectRoot}": ${getErrorMessage3(error)}`);
+    });
+  }).catch((error) => {
+    console.error(`[codebase-index] Auto-index initialization failed for "${projectRoot}": ${getErrorMessage3(error)}`);
+  });
+}
+
+// node_modules/chokidar/index.js
+import { EventEmitter as EventEmitter2 } from "events";
+import { stat as statcb, Stats } from "fs";
+import { readdir as readdir2, stat as stat3 } from "fs/promises";
+import * as sp2 from "path";
+
+// node_modules/readdirp/index.js
+import { lstat, readdir, realpath, stat } from "fs/promises";
+import { join as pjoin, relative as prelative, resolve as presolve, sep as psep } from "path";
+import { Readable } from "stream";
+var EntryTypes = {
+  FILE_TYPE: "files",
+  DIR_TYPE: "directories",
+  FILE_DIR_TYPE: "files_directories",
+  EVERYTHING_TYPE: "all"
+};
+var defaultOptions = {
+  root: ".",
+  fileFilter: (_entryInfo) => true,
+  directoryFilter: (_entryInfo) => true,
+  type: EntryTypes.FILE_TYPE,
+  lstat: false,
+  depth: 2147483648,
+  alwaysStat: false,
+  highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+var NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+var ALL_TYPES = [
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+];
+var DIR_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE
+]);
+var FILE_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+]);
+var isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+var wantBigintFsStats = process.platform === "win32";
+var emptyFn = (_entryInfo) => true;
+var normalizeFilter = (filter) => {
+  if (filter === void 0)
+    return emptyFn;
+  if (typeof filter === "function")
+    return filter;
+  if (typeof filter === "string") {
+    const fl = filter.trim();
+    return (entry) => entry.basename === fl;
+  }
+  if (Array.isArray(filter)) {
+    const trItems = filter.map((item) => item.trim());
+    return (entry) => trItems.some((f) => entry.basename === f);
+  }
+  return emptyFn;
+};
+var ReaddirpStream = class extends Readable {
+  parents;
+  reading;
+  parent;
+  _stat;
+  _maxDepth;
+  _wantsDir;
+  _wantsFile;
+  _wantsEverything;
+  _root;
+  _isDirent;
+  _statsProp;
+  _rdOptions;
+  _fileFilter;
+  _directoryFilter;
+  constructor(options = {}) {
+    super({
+      objectMode: true,
+      autoDestroy: true,
+      highWaterMark: options.highWaterMark
+    });
+    const opts = { ...defaultOptions, ...options };
+    const { root, type } = opts;
+    this._fileFilter = normalizeFilter(opts.fileFilter);
+    this._directoryFilter = normalizeFilter(opts.directoryFilter);
+    const statMethod = opts.lstat ? lstat : stat;
+    if (wantBigintFsStats) {
+      this._stat = (path25) => statMethod(path25, { bigint: true });
+    } else {
+      this._stat = statMethod;
+    }
+    this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+    this._wantsDir = type ? DIR_TYPES.has(type) : false;
+    this._wantsFile = type ? FILE_TYPES.has(type) : false;
+    this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+    this._root = presolve(root);
+    this._isDirent = !opts.alwaysStat;
+    this._statsProp = this._isDirent ? "dirent" : "stats";
+    this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+    this.parents = [this._exploreDir(root, 1)];
+    this.reading = false;
+    this.parent = void 0;
+  }
+  async _read(batch) {
+    if (this.reading)
+      return;
+    this.reading = true;
+    try {
+      while (!this.destroyed && batch > 0) {
+        const par = this.parent;
+        const fil = par && par.files;
+        if (fil && fil.length > 0) {
+          const { path: path25, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path25));
+          const awaited = await Promise.all(slice);
+          for (const entry of awaited) {
+            if (!entry)
+              continue;
+            if (this.destroyed)
+              return;
+            const entryType = await this._getEntryType(entry);
+            if (entryType === "directory" && this._directoryFilter(entry)) {
+              if (depth <= this._maxDepth) {
+                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+              }
+              if (this._wantsDir) {
+                this.push(entry);
+                batch--;
+              }
+            } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+              if (this._wantsFile) {
+                this.push(entry);
+                batch--;
+              }
+            }
+          }
+        } else {
+          const parent = this.parents.pop();
+          if (!parent) {
+            this.push(null);
+            break;
+          }
+          this.parent = await parent;
+          if (this.destroyed)
+            return;
+        }
+      }
+    } catch (error) {
+      this.destroy(error);
+    } finally {
+      this.reading = false;
+    }
+  }
+  async _exploreDir(path25, depth) {
+    let files;
+    try {
+      files = await readdir(path25, this._rdOptions);
+    } catch (error) {
+      this._onError(error);
+    }
+    return { files, depth, path: path25 };
+  }
+  async _formatEntry(dirent, path25) {
+    let entry;
+    const basename5 = this._isDirent ? dirent.name : dirent;
+    try {
+      const fullPath = presolve(pjoin(path25, basename5));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename5 };
+      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+    } catch (err) {
+      this._onError(err);
+      return;
+    }
+    return entry;
+  }
+  _onError(err) {
+    if (isNormalFlowError(err) && !this.destroyed) {
+      this.emit("warn", err);
+    } else {
+      this.destroy(err);
+    }
+  }
+  async _getEntryType(entry) {
+    if (!entry && this._statsProp in entry) {
+      return "";
+    }
+    const stats = entry[this._statsProp];
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "directory";
+    if (stats && stats.isSymbolicLink()) {
+      const full = entry.fullPath;
+      try {
+        const entryRealPath = await realpath(full);
+        const entryRealPathStats = await lstat(entryRealPath);
+        if (entryRealPathStats.isFile()) {
+          return "file";
+        }
+        if (entryRealPathStats.isDirectory()) {
+          const len = entryRealPath.length;
+          if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
+            const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+            recursiveError.code = RECURSIVE_ERROR_CODE;
+            return this._onError(recursiveError);
+          }
+          return "directory";
+        }
+      } catch (error) {
+        this._onError(error);
+        return "";
+      }
+    }
+  }
+  _includeAsFile(entry) {
+    const stats = entry && entry[this._statsProp];
+    return stats && this._wantsEverything && !stats.isDirectory();
+  }
+};
+function readdirp(root, options = {}) {
+  let type = options.entryType || options.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options.type = type;
+  if (!root) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+  }
+  options.root = root;
+  return new ReaddirpStream(options);
+}
+
+// node_modules/chokidar/handler.js
+import { watch as fs_watch, unwatchFile, watchFile } from "fs";
+import { realpath as fsrealpath, lstat as lstat2, open, stat as stat2 } from "fs/promises";
+import { type as osType } from "os";
+import * as sp from "path";
+var STR_DATA = "data";
+var STR_END = "end";
+var STR_CLOSE = "close";
+var EMPTY_FN = () => {
+};
+var pl = process.platform;
+var isWindows = pl === "win32";
+var isMacos = pl === "darwin";
+var isLinux = pl === "linux";
+var isFreeBSD = pl === "freebsd";
+var isIBMi = osType() === "OS400";
+var EVENTS = {
+  ALL: "all",
+  READY: "ready",
+  ADD: "add",
+  CHANGE: "change",
+  ADD_DIR: "addDir",
+  UNLINK: "unlink",
+  UNLINK_DIR: "unlinkDir",
+  RAW: "raw",
+  ERROR: "error"
+};
+var EV = EVENTS;
+var THROTTLE_MODE_WATCH = "watch";
+var statMethods = { lstat: lstat2, stat: stat2 };
+var KEY_LISTENERS = "listeners";
+var KEY_ERR = "errHandlers";
+var KEY_RAW = "rawEmitters";
+var HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+var binaryExtensions = /* @__PURE__ */ new Set([
+  "3dm",
+  "3ds",
+  "3g2",
+  "3gp",
+  "7z",
+  "a",
+  "aac",
+  "adp",
+  "afdesign",
+  "afphoto",
+  "afpub",
+  "ai",
+  "aif",
+  "aiff",
+  "alz",
+  "ape",
+  "apk",
+  "appimage",
+  "ar",
+  "arj",
+  "asf",
+  "au",
+  "avi",
+  "bak",
+  "baml",
+  "bh",
+  "bin",
+  "bk",
+  "bmp",
+  "btif",
+  "bz2",
+  "bzip2",
+  "cab",
+  "caf",
+  "cgm",
+  "class",
+  "cmx",
+  "cpio",
+  "cr2",
+  "cur",
+  "dat",
+  "dcm",
+  "deb",
+  "dex",
+  "djvu",
+  "dll",
+  "dmg",
+  "dng",
+  "doc",
+  "docm",
+  "docx",
+  "dot",
+  "dotm",
+  "dra",
+  "DS_Store",
+  "dsk",
+  "dts",
+  "dtshd",
+  "dvb",
+  "dwg",
+  "dxf",
+  "ecelp4800",
+  "ecelp7470",
+  "ecelp9600",
+  "egg",
+  "eol",
+  "eot",
+  "epub",
+  "exe",
+  "f4v",
+  "fbs",
+  "fh",
+  "fla",
+  "flac",
+  "flatpak",
+  "fli",
+  "flv",
+  "fpx",
+  "fst",
+  "fvt",
+  "g3",
+  "gh",
+  "gif",
+  "graffle",
+  "gz",
+  "gzip",
+  "h261",
+  "h263",
+  "h264",
+  "icns",
+  "ico",
+  "ief",
+  "img",
+  "ipa",
+  "iso",
+  "jar",
+  "jpeg",
+  "jpg",
+  "jpgv",
+  "jpm",
+  "jxr",
+  "key",
+  "ktx",
+  "lha",
+  "lib",
+  "lvp",
+  "lz",
+  "lzh",
+  "lzma",
+  "lzo",
+  "m3u",
+  "m4a",
+  "m4v",
+  "mar",
+  "mdi",
+  "mht",
+  "mid",
+  "midi",
+  "mj2",
+  "mka",
+  "mkv",
+  "mmr",
+  "mng",
+  "mobi",
+  "mov",
+  "movie",
+  "mp3",
+  "mp4",
+  "mp4a",
+  "mpeg",
+  "mpg",
+  "mpga",
+  "mxu",
+  "nef",
+  "npx",
+  "numbers",
+  "nupkg",
+  "o",
+  "odp",
+  "ods",
+  "odt",
+  "oga",
+  "ogg",
+  "ogv",
+  "otf",
+  "ott",
+  "pages",
+  "pbm",
+  "pcx",
+  "pdb",
+  "pdf",
+  "pea",
+  "pgm",
+  "pic",
+  "png",
+  "pnm",
+  "pot",
+  "potm",
+  "potx",
+  "ppa",
+  "ppam",
+  "ppm",
+  "pps",
+  "ppsm",
+  "ppsx",
+  "ppt",
+  "pptm",
+  "pptx",
+  "psd",
+  "pya",
+  "pyc",
+  "pyo",
+  "pyv",
+  "qt",
+  "rar",
+  "ras",
+  "raw",
+  "resources",
+  "rgb",
+  "rip",
+  "rlc",
+  "rmf",
+  "rmvb",
+  "rpm",
+  "rtf",
+  "rz",
+  "s3m",
+  "s7z",
+  "scpt",
+  "sgi",
+  "shar",
+  "snap",
+  "sil",
+  "sketch",
+  "slk",
+  "smv",
+  "snk",
+  "so",
+  "stl",
+  "suo",
+  "sub",
+  "swf",
+  "tar",
+  "tbz",
+  "tbz2",
+  "tga",
+  "tgz",
+  "thmx",
+  "tif",
+  "tiff",
+  "tlz",
+  "ttc",
+  "ttf",
+  "txz",
+  "udf",
+  "uvh",
+  "uvi",
+  "uvm",
+  "uvp",
+  "uvs",
+  "uvu",
+  "viv",
+  "vob",
+  "war",
+  "wav",
+  "wax",
+  "wbmp",
+  "wdp",
+  "weba",
+  "webm",
+  "webp",
+  "whl",
+  "wim",
+  "wm",
+  "wma",
+  "wmv",
+  "wmx",
+  "woff",
+  "woff2",
+  "wrm",
+  "wvx",
+  "xbm",
+  "xif",
+  "xla",
+  "xlam",
+  "xls",
+  "xlsb",
+  "xlsm",
+  "xlsx",
+  "xlt",
+  "xltm",
+  "xltx",
+  "xm",
+  "xmind",
+  "xpi",
+  "xpm",
+  "xwd",
+  "xz",
+  "z",
+  "zip",
+  "zipx"
+]);
+var isBinaryPath = (filePath) => binaryExtensions.has(sp.extname(filePath).slice(1).toLowerCase());
+var foreach = (val, fn) => {
+  if (val instanceof Set) {
+    val.forEach(fn);
+  } else {
+    fn(val);
+  }
+};
+var addAndConvert = (main2, prop, item) => {
+  let container = main2[prop];
+  if (!(container instanceof Set)) {
+    main2[prop] = container = /* @__PURE__ */ new Set([container]);
+  }
+  container.add(item);
+};
+var clearItem = (cont) => (key) => {
+  const set = cont[key];
+  if (set instanceof Set) {
+    set.clear();
+  } else {
+    delete cont[key];
+  }
+};
+var delFromSet = (main2, prop, item) => {
+  const container = main2[prop];
+  if (container instanceof Set) {
+    container.delete(item);
+  } else if (container === item) {
+    delete main2[prop];
+  }
+};
+var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+var FsWatchInstances = /* @__PURE__ */ new Map();
+function createFsWatchInstance(path25, options, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path25);
+    emitRaw(rawEvent, evPath, { watchedPath: path25 });
+    if (evPath && path25 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path25, evPath), KEY_LISTENERS, sp.join(path25, evPath));
+    }
+  };
+  try {
+    return fs_watch(path25, {
+      persistent: options.persistent
+    }, handleEvent);
+  } catch (error) {
+    errHandler(error);
+    return void 0;
+  }
+}
+var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+  const cont = FsWatchInstances.get(fullPath);
+  if (!cont)
+    return;
+  foreach(cont[listenerType], (listener) => {
+    listener(val1, val2, val3);
+  });
+};
+var setFsWatchListener = (path25, fullPath, options, handlers) => {
+  const { listener, errHandler, rawEmitter } = handlers;
+  let cont = FsWatchInstances.get(fullPath);
+  let watcher;
+  if (!options.persistent) {
+    watcher = createFsWatchInstance(path25, options, listener, errHandler, rawEmitter);
+    if (!watcher)
+      return;
+    return watcher.close.bind(watcher);
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_ERR, errHandler);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    watcher = createFsWatchInstance(
+      path25,
+      options,
+      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+      errHandler,
+      // no need to use broadcast here
+      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
+    );
+    if (!watcher)
+      return;
+    watcher.on(EV.ERROR, async (error) => {
+      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+      if (cont)
+        cont.watcherUnusable = true;
+      if (isWindows && error.code === "EPERM") {
+        try {
+          const fd = await open(path25, "r");
+          await fd.close();
+          broadcastErr(error);
+        } catch (err) {
+        }
+      } else {
+        broadcastErr(error);
+      }
+    });
+    cont = {
+      listeners: listener,
+      errHandlers: errHandler,
+      rawEmitters: rawEmitter,
+      watcher
+    };
+    FsWatchInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_ERR, errHandler);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      cont.watcher.close();
+      FsWatchInstances.delete(fullPath);
+      HANDLER_KEYS.forEach(clearItem(cont));
+      cont.watcher = void 0;
+      Object.freeze(cont);
+    }
+  };
+};
+var FsWatchFileInstances = /* @__PURE__ */ new Map();
+var setFsWatchFileListener = (path25, fullPath, options, handlers) => {
+  const { listener, rawEmitter } = handlers;
+  let cont = FsWatchFileInstances.get(fullPath);
+  const copts = cont && cont.options;
+  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+    unwatchFile(fullPath);
+    cont = void 0;
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    cont = {
+      listeners: listener,
+      rawEmitters: rawEmitter,
+      options,
+      watcher: watchFile(fullPath, options, (curr, prev) => {
+        foreach(cont.rawEmitters, (rawEmitter2) => {
+          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
+        });
+        const currmtime = curr.mtimeMs;
+        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+          foreach(cont.listeners, (listener2) => listener2(path25, curr));
+        }
+      })
+    };
+    FsWatchFileInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      FsWatchFileInstances.delete(fullPath);
+      unwatchFile(fullPath);
+      cont.options = cont.watcher = void 0;
+      Object.freeze(cont);
+    }
+  };
+};
+var NodeFsHandler = class {
+  fsw;
+  _boundHandleError;
+  constructor(fsW) {
+    this.fsw = fsW;
+    this._boundHandleError = (error) => fsW._handleError(error);
+  }
+  /**
+   * Watch file for changes with fs_watchFile or fs_watch.
+   * @param path to file or dir
+   * @param listener on fs change
+   * @returns closer for the watcher instance
+   */
+  _watchWithNodeFs(path25, listener) {
+    const opts = this.fsw.options;
+    const directory = sp.dirname(path25);
+    const basename5 = sp.basename(path25);
+    const parent = this.fsw._getWatchedDir(directory);
+    parent.add(basename5);
+    const absolutePath = sp.resolve(path25);
+    const options = {
+      persistent: opts.persistent
+    };
+    if (!listener)
+      listener = EMPTY_FN;
+    let closer;
+    if (opts.usePolling) {
+      const enableBin = opts.interval !== opts.binaryInterval;
+      options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path25, absolutePath, options, {
+        listener,
+        rawEmitter: this.fsw._emitRaw
+      });
+    } else {
+      closer = setFsWatchListener(path25, absolutePath, options, {
+        listener,
+        errHandler: this._boundHandleError,
+        rawEmitter: this.fsw._emitRaw
+      });
+    }
+    return closer;
+  }
+  /**
+   * Watch a file and emit add event if warranted.
+   * @returns closer for the watcher instance
+   */
+  _handleFile(file, stats, initialAdd) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const dirname10 = sp.dirname(file);
+    const basename5 = sp.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname10);
+    let prevStats = stats;
+    if (parent.has(basename5))
+      return;
+    const listener = async (path25, newStats) => {
+      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+        return;
+      if (!newStats || newStats.mtimeMs === 0) {
+        try {
+          const newStats2 = await stat2(file);
+          if (this.fsw.closed)
+            return;
+          const at = newStats2.atimeMs;
+          const mt = newStats2.mtimeMs;
+          if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+            this.fsw._emit(EV.CHANGE, file, newStats2);
+          }
+          if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
+            this.fsw._closeFile(path25);
+            prevStats = newStats2;
+            const closer2 = this._watchWithNodeFs(file, listener);
+            if (closer2)
+              this.fsw._addPathCloser(path25, closer2);
+          } else {
+            prevStats = newStats2;
+          }
+        } catch (error) {
+          this.fsw._remove(dirname10, basename5);
+        }
+      } else if (parent.has(basename5)) {
+        const at = newStats.atimeMs;
+        const mt = newStats.mtimeMs;
+        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+          this.fsw._emit(EV.CHANGE, file, newStats);
+        }
+        prevStats = newStats;
+      }
+    };
+    const closer = this._watchWithNodeFs(file, listener);
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+      if (!this.fsw._throttle(EV.ADD, file, 0))
+        return;
+      this.fsw._emit(EV.ADD, file, stats);
+    }
+    return closer;
+  }
+  /**
+   * Handle symlinks encountered while reading a dir.
+   * @param entry returned by readdirp
+   * @param directory path of dir being read
+   * @param path of this item
+   * @param item basename of this item
+   * @returns true if no more processing is needed for this entry.
+   */
+  async _handleSymlink(entry, directory, path25, item) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const full = entry.fullPath;
+    const dir = this.fsw._getWatchedDir(directory);
+    if (!this.fsw.options.followSymlinks) {
+      this.fsw._incrReadyCount();
+      let linkPath;
+      try {
+        linkPath = await fsrealpath(path25);
+      } catch (e) {
+        this.fsw._emitReady();
+        return true;
+      }
+      if (this.fsw.closed)
+        return;
+      if (dir.has(item)) {
+        if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+          this.fsw._symlinkPaths.set(full, linkPath);
+          this.fsw._emit(EV.CHANGE, path25, entry.stats);
+        }
+      } else {
+        dir.add(item);
+        this.fsw._symlinkPaths.set(full, linkPath);
+        this.fsw._emit(EV.ADD, path25, entry.stats);
+      }
+      this.fsw._emitReady();
+      return true;
+    }
+    if (this.fsw._symlinkPaths.has(full)) {
+      return true;
+    }
+    this.fsw._symlinkPaths.set(full, true);
+  }
+  _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+    directory = sp.join(directory, "");
+    const throttleKey = target ? `${directory}:${target}` : directory;
+    throttler = this.fsw._throttle("readdir", throttleKey, 1e3);
+    if (!throttler)
+      return;
+    const previous = this.fsw._getWatchedDir(wh.path);
+    const current = /* @__PURE__ */ new Set();
+    let stream = this.fsw._readdirp(directory, {
+      fileFilter: (entry) => wh.filterPath(entry),
+      directoryFilter: (entry) => wh.filterDir(entry)
+    });
+    if (!stream)
+      return;
+    stream.on(STR_DATA, async (entry) => {
+      if (this.fsw.closed) {
+        stream = void 0;
+        return;
+      }
+      const item = entry.path;
+      let path25 = sp.join(directory, item);
+      current.add(item);
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path25, item)) {
+        return;
+      }
+      if (this.fsw.closed) {
+        stream = void 0;
+        return;
+      }
+      if (item === target || !target && !previous.has(item)) {
+        this.fsw._incrReadyCount();
+        path25 = sp.join(dir, sp.relative(dir, path25));
+        this._addToNodeFs(path25, initialAdd, wh, depth + 1);
+      }
+    }).on(EV.ERROR, this._boundHandleError);
+    return new Promise((resolve15, reject) => {
+      if (!stream)
+        return reject();
+      stream.once(STR_END, () => {
+        if (this.fsw.closed) {
+          stream = void 0;
+          return;
+        }
+        const wasThrottled = throttler ? throttler.clear() : false;
+        resolve15(void 0);
+        previous.getChildren().filter((item) => {
+          return item !== directory && !current.has(item);
+        }).forEach((item) => {
+          this.fsw._remove(directory, item);
+        });
+        stream = void 0;
+        if (wasThrottled)
+          this._handleRead(directory, false, wh, target, dir, depth, throttler);
+      });
+    });
+  }
+  /**
+   * Read directory to add / remove files from `@watched` list and re-read it on change.
+   * @param dir fs path
+   * @param stats
+   * @param initialAdd
+   * @param depth relative to user-supplied path
+   * @param target child path targeted for watch
+   * @param wh Common watch helpers for this path
+   * @param realpath
+   * @returns closer for the watcher instance.
+   */
+  async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
+    const parentDir = this.fsw._getWatchedDir(sp.dirname(dir));
+    const tracked = parentDir.has(sp.basename(dir));
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+      this.fsw._emit(EV.ADD_DIR, dir, stats);
+    }
+    parentDir.add(sp.basename(dir));
+    this.fsw._getWatchedDir(dir);
+    let throttler;
+    let closer;
+    const oDepth = this.fsw.options.depth;
+    if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
+      if (!target) {
+        await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+        if (this.fsw.closed)
+          return;
+      }
+      closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
+        if (stats2 && stats2.mtimeMs === 0)
+          return;
+        this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+      });
+    }
+    return closer;
+  }
+  /**
+   * Handle added file, directory, or glob pattern.
+   * Delegates call to _handleFile / _handleDir after checks.
+   * @param path to file or ir
+   * @param initialAdd was the file added at watch instantiation?
+   * @param priorWh depth relative to user-supplied path
+   * @param depth Child path actually targeted for watch
+   * @param target Child path actually targeted for watch
+   */
+  async _addToNodeFs(path25, initialAdd, priorWh, depth, target) {
+    const ready = this.fsw._emitReady;
+    if (this.fsw._isIgnored(path25) || this.fsw.closed) {
+      ready();
+      return false;
+    }
+    const wh = this.fsw._getWatchHelpers(path25);
+    if (priorWh) {
+      wh.filterPath = (entry) => priorWh.filterPath(entry);
+      wh.filterDir = (entry) => priorWh.filterDir(entry);
+    }
+    try {
+      const stats = await statMethods[wh.statMethod](wh.watchPath);
+      if (this.fsw.closed)
+        return;
+      if (this.fsw._isIgnored(wh.watchPath, stats)) {
+        ready();
+        return false;
+      }
+      const follow = this.fsw.options.followSymlinks;
+      let closer;
+      if (stats.isDirectory()) {
+        const absPath = sp.resolve(path25);
+        const targetPath = follow ? await fsrealpath(path25) : path25;
+        if (this.fsw.closed)
+          return;
+        closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (absPath !== targetPath && targetPath !== void 0) {
+          this.fsw._symlinkPaths.set(absPath, targetPath);
+        }
+      } else if (stats.isSymbolicLink()) {
+        const targetPath = follow ? await fsrealpath(path25) : path25;
+        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, path25, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (targetPath !== void 0) {
+          this.fsw._symlinkPaths.set(sp.resolve(path25), targetPath);
+        }
+      } else {
+        closer = this._handleFile(wh.watchPath, stats, initialAdd);
+      }
+      ready();
+      if (closer)
+        this.fsw._addPathCloser(path25, closer);
+      return false;
+    } catch (error) {
+      if (this.fsw._handleError(error)) {
+        ready();
+        return path25;
+      }
+    }
+  }
+};
+
+// node_modules/chokidar/index.js
+var SLASH = "/";
+var SLASH_SLASH = "//";
+var ONE_DOT = ".";
+var TWO_DOTS = "..";
+var STRING_TYPE = "string";
+var BACK_SLASH_RE = /\\/g;
+var DOUBLE_SLASH_RE = /\/\//g;
+var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+var REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+  return Array.isArray(item) ? item : [item];
+}
+var isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+  if (typeof matcher === "function")
+    return matcher;
+  if (typeof matcher === "string")
+    return (string) => matcher === string;
+  if (matcher instanceof RegExp)
+    return (string) => matcher.test(string);
+  if (typeof matcher === "object" && matcher !== null) {
+    return (string) => {
+      if (matcher.path === string)
+        return true;
+      if (matcher.recursive) {
+        const relative10 = sp2.relative(matcher.path, string);
+        if (!relative10) {
+          return false;
+        }
+        return !relative10.startsWith("..") && !sp2.isAbsolute(relative10);
+      }
+      return false;
+    };
+  }
+  return () => false;
+}
+function normalizePath2(path25) {
+  if (typeof path25 !== "string")
+    throw new Error("string expected");
+  path25 = sp2.normalize(path25);
+  path25 = path25.replace(/\\/g, "/");
+  let prepend = false;
+  if (path25.startsWith("//"))
+    prepend = true;
+  path25 = path25.replace(DOUBLE_SLASH_RE, "/");
+  if (prepend)
+    path25 = "/" + path25;
+  return path25;
+}
+function matchPatterns(patterns, testString, stats) {
+  const path25 = normalizePath2(testString);
+  for (let index = 0; index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (pattern(path25, stats)) {
+      return true;
+    }
+  }
+  return false;
+}
+function anymatch(matchers, testString) {
+  if (matchers == null) {
+    throw new TypeError("anymatch: specify first argument");
+  }
+  const matchersArray = arrify(matchers);
+  const patterns = matchersArray.map((matcher) => createPattern(matcher));
+  if (testString == null) {
+    return (testString2, stats) => {
+      return matchPatterns(patterns, testString2, stats);
+    };
+  }
+  return matchPatterns(patterns, testString);
+}
+var unifyPaths = (paths_) => {
+  const paths = arrify(paths_).flat();
+  if (!paths.every((p) => typeof p === STRING_TYPE)) {
+    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+  }
+  return paths.map(normalizePathToUnix);
+};
+var toUnix = (string) => {
+  let str = string.replace(BACK_SLASH_RE, SLASH);
+  let prepend = false;
+  if (str.startsWith(SLASH_SLASH)) {
+    prepend = true;
+  }
+  str = str.replace(DOUBLE_SLASH_RE, SLASH);
+  if (prepend) {
+    str = SLASH + str;
+  }
+  return str;
+};
+var normalizePathToUnix = (path25) => toUnix(sp2.normalize(toUnix(path25)));
+var normalizeIgnored = (cwd = "") => (path25) => {
+  if (typeof path25 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path25) ? path25 : sp2.join(cwd, path25));
+  } else {
+    return path25;
+  }
+};
+var getAbsolutePath = (path25, cwd) => {
+  if (sp2.isAbsolute(path25)) {
+    return path25;
+  }
+  return sp2.join(cwd, path25);
+};
+var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+var DirEntry = class {
+  path;
+  _removeWatcher;
+  items;
+  constructor(dir, removeWatcher) {
+    this.path = dir;
+    this._removeWatcher = removeWatcher;
+    this.items = /* @__PURE__ */ new Set();
+  }
+  add(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    if (item !== ONE_DOT && item !== TWO_DOTS)
+      items.add(item);
+  }
+  async remove(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    items.delete(item);
+    if (items.size > 0)
+      return;
+    const dir = this.path;
+    try {
+      await readdir2(dir);
+    } catch (err) {
+      if (this._removeWatcher) {
+        this._removeWatcher(sp2.dirname(dir), sp2.basename(dir));
+      }
+    }
+  }
+  has(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    return items.has(item);
+  }
+  getChildren() {
+    const { items } = this;
+    if (!items)
+      return [];
+    return [...items.values()];
+  }
+  dispose() {
+    this.items.clear();
+    this.path = "";
+    this._removeWatcher = EMPTY_FN;
+    this.items = EMPTY_SET;
+    Object.freeze(this);
+  }
+};
+var STAT_METHOD_F = "stat";
+var STAT_METHOD_L = "lstat";
+var WatchHelper = class {
+  fsw;
+  path;
+  watchPath;
+  fullWatchPath;
+  dirParts;
+  followSymlinks;
+  statMethod;
+  constructor(path25, follow, fsw) {
+    this.fsw = fsw;
+    const watchPath = path25;
+    this.path = path25 = path25.replace(REPLACER_RE, "");
+    this.watchPath = watchPath;
+    this.fullWatchPath = sp2.resolve(watchPath);
+    this.dirParts = [];
+    this.dirParts.forEach((parts) => {
+      if (parts.length > 1)
+        parts.pop();
+    });
+    this.followSymlinks = follow;
+    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+  }
+  entryPath(entry) {
+    return sp2.join(this.watchPath, sp2.relative(this.watchPath, entry.fullPath));
+  }
+  filterPath(entry) {
+    const { stats } = entry;
+    if (stats && stats.isSymbolicLink())
+      return this.filterDir(entry);
+    const resolvedPath = this.entryPath(entry);
+    return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+  }
+  filterDir(entry) {
+    return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+  }
+};
+var FSWatcher = class extends EventEmitter2 {
+  closed;
+  options;
+  _closers;
+  _ignoredPaths;
+  _throttled;
+  _streams;
+  _symlinkPaths;
+  _watched;
+  _pendingWrites;
+  _pendingUnlinks;
+  _readyCount;
+  _emitReady;
+  _closePromise;
+  _userIgnored;
+  _readyEmitted;
+  _emitRaw;
+  _boundRemove;
+  _nodeFsHandler;
+  // Not indenting methods for history sake; for now.
+  constructor(_opts = {}) {
+    super();
+    this.closed = false;
+    this._closers = /* @__PURE__ */ new Map();
+    this._ignoredPaths = /* @__PURE__ */ new Set();
+    this._throttled = /* @__PURE__ */ new Map();
+    this._streams = /* @__PURE__ */ new Set();
+    this._symlinkPaths = /* @__PURE__ */ new Map();
+    this._watched = /* @__PURE__ */ new Map();
+    this._pendingWrites = /* @__PURE__ */ new Map();
+    this._pendingUnlinks = /* @__PURE__ */ new Map();
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    const awf = _opts.awaitWriteFinish;
+    const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
+    const opts = {
+      // Defaults
+      persistent: true,
+      ignoreInitial: false,
+      ignorePermissionErrors: false,
+      interval: 100,
+      binaryInterval: 300,
+      followSymlinks: true,
+      usePolling: false,
+      // useAsync: false,
+      atomic: true,
+      // NOTE: overwritten later (depends on usePolling)
+      ..._opts,
+      // Change format
+      ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+      awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
+    };
+    if (isIBMi)
+      opts.usePolling = true;
+    if (opts.atomic === void 0)
+      opts.atomic = !opts.usePolling;
+    const envPoll = process.env.CHOKIDAR_USEPOLLING;
+    if (envPoll !== void 0) {
+      const envLower = envPoll.toLowerCase();
+      if (envLower === "false" || envLower === "0")
+        opts.usePolling = false;
+      else if (envLower === "true" || envLower === "1")
+        opts.usePolling = true;
+      else
+        opts.usePolling = !!envLower;
+    }
+    const envInterval = process.env.CHOKIDAR_INTERVAL;
+    if (envInterval)
+      opts.interval = Number.parseInt(envInterval, 10);
+    let readyCalls = 0;
+    this._emitReady = () => {
+      readyCalls++;
+      if (readyCalls >= this._readyCount) {
+        this._emitReady = EMPTY_FN;
+        this._readyEmitted = true;
+        process.nextTick(() => this.emit(EVENTS.READY));
+      }
+    };
+    this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+    this._boundRemove = this._remove.bind(this);
+    this.options = opts;
+    this._nodeFsHandler = new NodeFsHandler(this);
+    Object.freeze(opts);
+  }
+  _addIgnoredPath(matcher) {
+    if (isMatcherObject(matcher)) {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
+          return;
+        }
+      }
+    }
+    this._ignoredPaths.add(matcher);
+  }
+  _removeIgnoredPath(matcher) {
+    this._ignoredPaths.delete(matcher);
+    if (typeof matcher === "string") {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher) {
+          this._ignoredPaths.delete(ignored);
+        }
+      }
+    }
+  }
+  // Public methods
+  /**
+   * Adds paths to be watched on an existing FSWatcher instance.
+   * @param paths_ file or file list. Other arguments are unused
+   */
+  add(paths_, _origAdd, _internal) {
+    const { cwd } = this.options;
+    this.closed = false;
+    this._closePromise = void 0;
+    let paths = unifyPaths(paths_);
+    if (cwd) {
+      paths = paths.map((path25) => {
+        const absPath = getAbsolutePath(path25, cwd);
+        return absPath;
+      });
+    }
+    paths.forEach((path25) => {
+      this._removeIgnoredPath(path25);
+    });
+    this._userIgnored = void 0;
+    if (!this._readyCount)
+      this._readyCount = 0;
+    this._readyCount += paths.length;
+    Promise.all(paths.map(async (path25) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path25, !_internal, void 0, 0, _origAdd);
+      if (res)
+        this._emitReady();
+      return res;
+    })).then((results) => {
+      if (this.closed)
+        return;
+      results.forEach((item) => {
+        if (item)
+          this.add(sp2.dirname(item), sp2.basename(_origAdd || item));
+      });
+    });
+    return this;
+  }
+  /**
+   * Close watchers or start ignoring events from specified paths.
+   */
+  unwatch(paths_) {
+    if (this.closed)
+      return this;
+    const paths = unifyPaths(paths_);
+    const { cwd } = this.options;
+    paths.forEach((path25) => {
+      if (!sp2.isAbsolute(path25) && !this._closers.has(path25)) {
+        if (cwd)
+          path25 = sp2.join(cwd, path25);
+        path25 = sp2.resolve(path25);
+      }
+      this._closePath(path25);
+      this._addIgnoredPath(path25);
+      if (this._watched.has(path25)) {
+        this._addIgnoredPath({
+          path: path25,
+          recursive: true
+        });
+      }
+      this._userIgnored = void 0;
+    });
+    return this;
+  }
+  /**
+   * Close watchers and remove all listeners from watched paths.
+   */
+  close() {
+    if (this._closePromise) {
+      return this._closePromise;
+    }
+    this.closed = true;
+    this.removeAllListeners();
+    const closers = [];
+    this._closers.forEach((closerList) => closerList.forEach((closer) => {
+      const promise = closer();
+      if (promise instanceof Promise)
+        closers.push(promise);
+    }));
+    this._streams.forEach((stream) => stream.destroy());
+    this._userIgnored = void 0;
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    this._watched.forEach((dirent) => dirent.dispose());
+    this._closers.clear();
+    this._watched.clear();
+    this._streams.clear();
+    this._symlinkPaths.clear();
+    this._throttled.clear();
+    this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+    return this._closePromise;
+  }
+  /**
+   * Expose list of watched paths
+   * @returns for chaining
+   */
+  getWatched() {
+    const watchList = {};
+    this._watched.forEach((entry, dir) => {
+      const key = this.options.cwd ? sp2.relative(this.options.cwd, dir) : dir;
+      const index = key || ONE_DOT;
+      watchList[index] = entry.getChildren().sort();
+    });
+    return watchList;
+  }
+  emitWithAll(event, args) {
+    this.emit(event, ...args);
+    if (event !== EVENTS.ERROR)
+      this.emit(EVENTS.ALL, event, ...args);
+  }
+  // Common helpers
+  // --------------
+  /**
+   * Normalize and emit events.
+   * Calling _emit DOES NOT MEAN emit() would be called!
+   * @param event Type of event
+   * @param path File or directory path
+   * @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, path25, stats) {
+    if (this.closed)
+      return;
+    const opts = this.options;
+    if (isWindows)
+      path25 = sp2.normalize(path25);
+    if (opts.cwd)
+      path25 = sp2.relative(opts.cwd, path25);
+    const args = [path25];
+    if (stats != null)
+      args.push(stats);
+    const awf = opts.awaitWriteFinish;
+    let pw;
+    if (awf && (pw = this._pendingWrites.get(path25))) {
+      pw.lastChange = /* @__PURE__ */ new Date();
+      return this;
+    }
+    if (opts.atomic) {
+      if (event === EVENTS.UNLINK) {
+        this._pendingUnlinks.set(path25, [event, ...args]);
+        setTimeout(() => {
+          this._pendingUnlinks.forEach((entry, path26) => {
+            this.emit(...entry);
+            this.emit(EVENTS.ALL, ...entry);
+            this._pendingUnlinks.delete(path26);
+          });
+        }, typeof opts.atomic === "number" ? opts.atomic : 100);
+        return this;
+      }
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path25)) {
+        event = EVENTS.CHANGE;
+        this._pendingUnlinks.delete(path25);
+      }
+    }
+    if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+      const awfEmit = (err, stats2) => {
+        if (err) {
+          event = EVENTS.ERROR;
+          args[0] = err;
+          this.emitWithAll(event, args);
+        } else if (stats2) {
+          if (args.length > 1) {
+            args[1] = stats2;
+          } else {
+            args.push(stats2);
+          }
+          this.emitWithAll(event, args);
+        }
+      };
+      this._awaitWriteFinish(path25, awf.stabilityThreshold, event, awfEmit);
+      return this;
+    }
+    if (event === EVENTS.CHANGE) {
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path25, 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, path25) : path25;
+      let stats2;
+      try {
+        stats2 = await stat3(fullPath);
+      } catch (err) {
+      }
+      if (!stats2 || this.closed)
+        return;
+      args.push(stats2);
+    }
+    this.emitWithAll(event, args);
+    return this;
+  }
+  /**
+   * Common handler for errors
+   * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+   */
+  _handleError(error) {
+    const code = error && error.code;
+    if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
+      this.emit(EVENTS.ERROR, error);
+    }
+    return error || this.closed;
+  }
+  /**
+   * Helper utility for throttling
+   * @param actionType type being throttled
+   * @param path being acted upon
+   * @param timeout duration of time to suppress duplicate actions
+   * @returns tracking object or false if action should be suppressed
+   */
+  _throttle(actionType, path25, 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(path25);
+    if (actionPath) {
+      actionPath.count++;
+      return false;
+    }
+    let timeoutObject;
+    const clear = () => {
+      const item = action.get(path25);
+      const count = item ? item.count : 0;
+      action.delete(path25);
+      clearTimeout(timeoutObject);
+      if (item)
+        clearTimeout(item.timeoutObject);
+      return count;
+    };
+    timeoutObject = setTimeout(clear, timeout);
+    const thr = { timeoutObject, clear, count: 0 };
+    action.set(path25, thr);
+    return thr;
+  }
+  _incrReadyCount() {
+    return this._readyCount++;
+  }
+  /**
+   * Awaits write operation to finish.
+   * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+   * @param path being acted upon
+   * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+   * @param event
+   * @param awfEmit Callback to be called when ready for event to be emitted.
+   */
+  _awaitWriteFinish(path25, threshold, event, awfEmit) {
+    const awf = this.options.awaitWriteFinish;
+    if (typeof awf !== "object")
+      return;
+    const pollInterval = awf.pollInterval;
+    let timeoutHandler;
+    let fullPath = path25;
+    if (this.options.cwd && !sp2.isAbsolute(path25)) {
+      fullPath = sp2.join(this.options.cwd, path25);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const writes = this._pendingWrites;
+    function awaitWriteFinishFn(prevStat) {
+      statcb(fullPath, (err, curStat) => {
+        if (err || !writes.has(path25)) {
+          if (err && err.code !== "ENOENT")
+            awfEmit(err);
+          return;
+        }
+        const now2 = Number(/* @__PURE__ */ new Date());
+        if (prevStat && curStat.size !== prevStat.size) {
+          writes.get(path25).lastChange = now2;
+        }
+        const pw = writes.get(path25);
+        const df = now2 - pw.lastChange;
+        if (df >= threshold) {
+          writes.delete(path25);
+          awfEmit(void 0, curStat);
+        } else {
+          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+        }
+      });
+    }
+    if (!writes.has(path25)) {
+      writes.set(path25, {
+        lastChange: now,
+        cancelWait: () => {
+          writes.delete(path25);
+          clearTimeout(timeoutHandler);
+          return event;
+        }
+      });
+      timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+    }
+  }
+  /**
+   * Determines whether user has asked to ignore this path.
+   */
+  _isIgnored(path25, stats) {
+    if (this.options.atomic && DOT_RE.test(path25))
+      return true;
+    if (!this._userIgnored) {
+      const { cwd } = this.options;
+      const ign = this.options.ignored;
+      const ignored = (ign || []).map(normalizeIgnored(cwd));
+      const ignoredPaths = [...this._ignoredPaths];
+      const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+      this._userIgnored = anymatch(list, void 0);
+    }
+    return this._userIgnored(path25, stats);
+  }
+  _isntIgnored(path25, stat4) {
+    return !this._isIgnored(path25, stat4);
+  }
+  /**
+   * Provides a set of common helpers and properties relating to symlink handling.
+   * @param path file or directory pattern being watched
+   */
+  _getWatchHelpers(path25) {
+    return new WatchHelper(path25, this.options.followSymlinks, this);
+  }
+  // Directory helpers
+  // -----------------
+  /**
+   * Provides directory tracking objects
+   * @param directory path of the directory
+   */
+  _getWatchedDir(directory) {
+    const dir = sp2.resolve(directory);
+    if (!this._watched.has(dir))
+      this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+    return this._watched.get(dir);
+  }
+  // File helpers
+  // ------------
+  /**
+   * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+   */
+  _hasReadPermissions(stats) {
+    if (this.options.ignorePermissionErrors)
+      return true;
+    return Boolean(Number(stats.mode) & 256);
+  }
+  /**
+   * Handles emitting unlink events for
+   * files and directories, and via recursion, for
+   * files and directories within directories that are unlinked
+   * @param directory within which the following item is located
+   * @param item      base path of item/directory
+   */
+  _remove(directory, item, isDirectory) {
+    const path25 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path25);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path25) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path25, 100))
+      return;
+    if (!isDirectory && this._watched.size === 1) {
+      this.add(directory, item, true);
+    }
+    const wp = this._getWatchedDir(path25);
+    const nestedDirectoryChildren = wp.getChildren();
+    nestedDirectoryChildren.forEach((nested) => this._remove(path25, 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 = path25;
+    if (this.options.cwd)
+      relPath = sp2.relative(this.options.cwd, path25);
+    if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+      const event = this._pendingWrites.get(relPath).cancelWait();
+      if (event === EVENTS.ADD)
+        return;
+    }
+    this._watched.delete(path25);
+    this._watched.delete(fullPath);
+    const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+    if (wasTracked && !this._isIgnored(path25))
+      this._emit(eventName, path25);
+    this._closePath(path25);
+  }
+  /**
+   * Closes all watchers for a path
+   */
+  _closePath(path25) {
+    this._closeFile(path25);
+    const dir = sp2.dirname(path25);
+    this._getWatchedDir(dir).remove(sp2.basename(path25));
+  }
+  /**
+   * Closes only file-specific watchers
+   */
+  _closeFile(path25) {
+    const closers = this._closers.get(path25);
+    if (!closers)
+      return;
+    closers.forEach((closer) => closer());
+    this._closers.delete(path25);
+  }
+  _addPathCloser(path25, closer) {
+    if (!closer)
+      return;
+    let list = this._closers.get(path25);
+    if (!list) {
+      list = [];
+      this._closers.set(path25, list);
+    }
+    list.push(closer);
+  }
+  _readdirp(root, opts) {
+    if (this.closed)
+      return;
+    const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+    let stream = readdirp(root, options);
+    this._streams.add(stream);
+    stream.once(STR_CLOSE, () => {
+      stream = void 0;
+    });
+    stream.once(STR_END, () => {
+      if (stream) {
+        this._streams.delete(stream);
+        stream = void 0;
+      }
+    });
+    return stream;
+  }
+};
+function watch(paths, options = {}) {
+  const watcher = new FSWatcher(options);
+  watcher.add(paths);
+  return watcher;
+}
+var chokidar_default = { watch, FSWatcher };
+
+// src/watcher/file-watcher.ts
+import * as path20 from "path";
+var FileWatcher = class {
+  watcher = null;
+  projectRoot;
+  config;
+  host;
+  configPath;
+  pendingChanges = /* @__PURE__ */ new Map();
+  debounceTimer = null;
+  debounceMs = 1e3;
+  onChanges = null;
+  constructor(projectRoot, config, host = "opencode", options = {}) {
+    this.projectRoot = projectRoot;
+    this.config = config;
+    this.host = host;
+    this.configPath = options.configPath;
+  }
+  start(handler) {
+    if (this.watcher) {
+      return;
+    }
+    this.onChanges = handler;
+    const ignoreFilter = createIgnoreFilter(this.projectRoot);
+    const watchTargets = this.configPath ? [this.projectRoot, this.configPath] : this.projectRoot;
+    this.watcher = chokidar_default.watch(watchTargets, {
+      ignored: (filePath) => {
+        const relativePath = path20.relative(this.projectRoot, filePath);
+        if (!relativePath) return false;
+        if (this.isProjectConfigPathOrAncestor(relativePath)) {
+          return false;
+        }
+        if (hasFilteredPathSegment(relativePath, path20.sep)) {
+          return true;
+        }
+        if (isRestrictedDirectory(relativePath, path20.sep)) {
+          return true;
+        }
+        if (ignoreFilter.ignores(relativePath)) {
+          return true;
+        }
+        return false;
+      },
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 300,
+        pollInterval: 100
+      }
+    });
+    this.watcher.on("error", (error) => {
+      const err = error instanceof Error ? error : null;
+      if (err?.code === "EPERM" || err?.code === "EACCES") {
+        return;
+      }
+      console.error("[codebase-index] Watcher error:", err?.message ?? error);
+    });
+    this.watcher.on("add", (filePath) => this.handleChange("add", filePath));
+    this.watcher.on("change", (filePath) => this.handleChange("change", filePath));
+    this.watcher.on("unlink", (filePath) => this.handleChange("unlink", filePath));
+  }
+  handleChange(type, filePath) {
+    if (this.isProjectConfigPath(filePath)) {
+      this.pendingChanges.set(filePath, type);
+      this.scheduleFlush();
+      return;
+    }
+    const includePatterns = [...this.config.include, ...this.config.additionalInclude ?? []];
+    if (!shouldIncludeFile(
+      filePath,
+      this.projectRoot,
+      includePatterns,
+      this.config.exclude,
+      createIgnoreFilter(this.projectRoot)
+    )) {
+      return;
+    }
+    this.pendingChanges.set(filePath, type);
+    this.scheduleFlush();
+  }
+  isProjectConfigPath(filePath) {
+    const relativePath = path20.relative(this.projectRoot, filePath);
+    const normalizedRelativePath = path20.normalize(relativePath);
+    return this.getProjectConfigRelativePaths().some((configPath) => configPath === normalizedRelativePath);
+  }
+  isProjectConfigPathOrAncestor(relativePath) {
+    const normalizedRelativePath = path20.normalize(relativePath);
+    return this.getProjectConfigRelativePaths().some(
+      (configPath) => configPath === normalizedRelativePath || configPath.startsWith(`${normalizedRelativePath}${path20.sep}`)
+    );
+  }
+  getProjectConfigRelativePaths() {
+    if (this.configPath) {
+      return [path20.normalize(path20.relative(this.projectRoot, this.configPath))];
+    }
+    return [
+      resolveProjectConfigPath(this.projectRoot, this.host),
+      resolveWritableProjectConfigPath(this.projectRoot, this.host)
+    ].map((configPath) => path20.normalize(path20.relative(this.projectRoot, configPath)));
+  }
+  scheduleFlush() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.flush();
+    }, this.debounceMs);
+  }
+  async flush() {
+    if (this.pendingChanges.size === 0 || !this.onChanges) {
+      return;
+    }
+    const changes = Array.from(this.pendingChanges.entries()).map(
+      ([path25, type]) => ({ path: path25, type })
+    );
+    this.pendingChanges.clear();
+    try {
+      await this.onChanges(changes);
+    } catch (error) {
+      console.error("Error handling file changes:", error);
+    }
+  }
+  stop() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    this.pendingChanges.clear();
+    this.onChanges = null;
+  }
+  isRunning() {
+    return this.watcher !== null;
+  }
+};
+
+// src/watcher/git-head-watcher.ts
+import * as path21 from "path";
+var GitHeadWatcher = class {
+  watcher = null;
+  projectRoot;
+  currentBranch = null;
+  onBranchChange = null;
+  debounceTimer = null;
+  debounceMs = 100;
+  // Short debounce for git operations
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  start(handler) {
+    if (this.watcher) {
+      return;
+    }
+    if (!isGitRepo(this.projectRoot)) {
+      return;
+    }
+    this.onBranchChange = handler;
+    this.currentBranch = getCurrentBranch(this.projectRoot);
+    const headPath = getHeadPath(this.projectRoot);
+    const refsPath = path21.join(this.projectRoot, ".git", "refs", "heads");
+    this.watcher = chokidar_default.watch([headPath, refsPath], {
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 50,
+        pollInterval: 10
+      }
+    });
+    this.watcher.on("change", () => this.handleHeadChange());
+    this.watcher.on("add", () => this.handleHeadChange());
+  }
+  handleHeadChange() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.checkBranchChange();
+    }, this.debounceMs);
+  }
+  async checkBranchChange() {
+    const newBranch = getCurrentBranch(this.projectRoot);
+    if (newBranch && newBranch !== this.currentBranch && this.onBranchChange) {
+      const oldBranch = this.currentBranch;
+      this.currentBranch = newBranch;
+      try {
+        await this.onBranchChange(oldBranch, newBranch);
+      } catch (error) {
+        console.error("Error handling branch change:", error);
+      }
+    } else if (newBranch) {
+      this.currentBranch = newBranch;
+    }
+  }
+  getCurrentBranch() {
+    return this.currentBranch;
+  }
+  stop() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    this.onBranchChange = null;
+  }
+  isRunning() {
+    return this.watcher !== null;
+  }
+};
+
+// src/watcher/index.ts
+var BackgroundReindexer = class {
+  constructor(runIndex) {
+    this.runIndex = runIndex;
+  }
+  runIndex;
+  running = false;
+  pending = false;
+  stopped = false;
+  request() {
+    if (this.stopped) {
+      return;
+    }
+    this.pending = true;
+    this.drain();
+  }
+  stop() {
+    this.stopped = true;
+    this.pending = false;
+  }
+  drain() {
+    if (this.stopped || this.running || !this.pending) {
+      return;
+    }
+    this.pending = false;
+    this.running = true;
+    void this.run();
+  }
+  async run() {
+    try {
+      await this.runIndex();
+    } catch (error) {
+      console.error("[codebase-index] Background reindex failed:", error);
+    } finally {
+      this.running = false;
+      this.drain();
+    }
+  }
+};
+function createWatcherWithIndexer(getIndexer, projectRoot, config, host = "opencode", options = {}) {
+  const fileWatcher = new FileWatcher(projectRoot, config, host, options);
+  const backgroundReindexer = new BackgroundReindexer(async () => {
+    await getIndexer().index();
+  });
+  fileWatcher.start(async (changes) => {
+    const hasAddOrChange = changes.some(
+      (c) => c.type === "add" || c.type === "change"
+    );
+    const hasDelete = changes.some((c) => c.type === "unlink");
+    if (hasAddOrChange || hasDelete) {
+      const configPaths = getConfigPaths(projectRoot, host, options);
+      if (changes.some((change) => configPaths.includes(pathNormalize(change.path)))) {
+        const parsedConfig = options.configPath ? parseConfig(loadConfigFile(options.configPath)) : void 0;
+        refreshIndexerForDirectory(projectRoot, host, parsedConfig);
+      }
+      backgroundReindexer.request();
+    }
+  });
+  let gitWatcher = null;
+  if (isGitRepo(projectRoot)) {
+    gitWatcher = new GitHeadWatcher(projectRoot);
+    gitWatcher.start(async (oldBranch, newBranch) => {
+      console.log(`Branch changed: ${oldBranch ?? "(none)"} -> ${newBranch}`);
+      backgroundReindexer.request();
+    });
+  }
+  return {
+    fileWatcher,
+    gitWatcher,
+    stop() {
+      backgroundReindexer.stop();
+      fileWatcher.stop();
+      gitWatcher?.stop();
+    }
+  };
+}
+function pathNormalize(value) {
+  return value.split("\\").join("/");
+}
+function getConfigPaths(projectRoot, host, options) {
+  if (options.configPath) {
+    return [pathNormalize(options.configPath)];
+  }
+  return [
+    resolveProjectConfigPath(projectRoot, host),
+    resolveWritableProjectConfigPath(projectRoot, host)
+  ].map((configPath) => pathNormalize(configPath));
+}
+
+// src/tools/visualize/activity.ts
+import { execFileSync } from "child_process";
+import * as path22 from "path";
+function attachRecentActivity(data, projectRoot) {
+  const activity = readGitActivity(projectRoot);
+  const changes = activity.size > 0 ? buildGitChanges(data, activity, projectRoot) : buildGraphChanges(data);
+  return {
+    ...data,
+    changes
+  };
+}
+function readGitActivity(projectRoot) {
+  try {
+    const output = 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"] }
+    );
+    return parseGitActivity(output);
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function parseGitActivity(output) {
+  const activity = /* @__PURE__ */ new Map();
+  let latestHash = "";
+  let latestDate = "";
+  let latestSubject = "";
+  for (const line of output.split(/\r?\n/)) {
+    if (!line) continue;
+    if (line.startsWith("__COMMIT__	")) {
+      const [, hash = "", date = "", subject = ""] = line.split("	");
+      latestHash = hash;
+      latestDate = date;
+      latestSubject = subject;
+      continue;
+    }
+    const [addedRaw, deletedRaw, filePath] = line.split("	");
+    if (!filePath || addedRaw === "-" || deletedRaw === "-") continue;
+    const churn = Number(addedRaw) + Number(deletedRaw);
+    if (!Number.isFinite(churn) || churn <= 0) continue;
+    const normalizedPath = normalizePath3(filePath);
+    const previous = activity.get(normalizedPath);
+    activity.set(normalizedPath, {
+      churn: (previous?.churn ?? 0) + churn,
+      commits: (previous?.commits ?? 0) + 1,
+      latestDate: previous?.latestDate ?? latestDate,
+      latestHash: previous?.latestHash ?? latestHash,
+      latestSubject: previous?.latestSubject ?? latestSubject
+    });
+  }
+  return activity;
+}
+function buildGitChanges(data, activity, projectRoot) {
+  const byModule = /* @__PURE__ */ new Map();
+  for (const node of data.nodes) {
+    const fileActivity = activity.get(toGitRelativePath(projectRoot, node.filePath));
+    if (!fileActivity) continue;
+    const current = byModule.get(node.moduleId) ?? {
+      moduleId: node.moduleId,
+      filePaths: /* @__PURE__ */ new Set(),
+      churn: 0,
+      commits: 0,
+      latestDate: fileActivity.latestDate,
+      latestHash: fileActivity.latestHash,
+      latestSubject: fileActivity.latestSubject
+    };
+    if (!current.filePaths.has(node.filePath)) {
+      current.filePaths.add(node.filePath);
+      current.churn += fileActivity.churn;
+      current.commits += fileActivity.commits;
+    }
+    if (fileActivity.latestDate > current.latestDate) {
+      current.latestDate = fileActivity.latestDate;
+      current.latestHash = fileActivity.latestHash;
+      current.latestSubject = fileActivity.latestSubject;
+    }
+    byModule.set(node.moduleId, current);
+  }
+  return [...byModule.values()].sort((a, b) => scoreModule(data, b.moduleId, b.churn) - scoreModule(data, a.moduleId, a.churn)).slice(0, 12).map((item, index) => toGitChange(data, item, index));
+}
+function buildGraphChanges(data) {
+  return data.modules.map((module2) => {
+    const calls = moduleCallCount(data, module2.id);
+    const focusNode = strongestNode(data, module2.id);
+    const risk = riskFor(calls, module2.symbolCount);
+    return {
+      id: `graph-${module2.id}`,
+      title: `${module2.label} is structurally important`,
+      kind: risk === "high" ? "risk" : "hot",
+      when: "graph-derived",
+      source: "call graph",
+      intent: "load-bearing path",
+      summary: `${module2.symbolCount} symbols with ${calls} cross-module calls in this slice.`,
+      why: "No recent Git history was available, so this highlights modules whose call relationships make them expensive to misunderstand during onboarding.",
+      calls,
+      churn: 0,
+      risk,
+      moduleId: module2.id,
+      focusNodeId: focusNode?.id,
+      filePaths: [...new Set(data.nodes.filter((node) => node.moduleId === module2.id).map((node) => node.filePath))].slice(0, 6)
+    };
+  }).sort((a, b) => b.calls - a.calls).slice(0, 8);
+}
+function toGitChange(data, item, index) {
+  const module2 = data.modules.find((candidate) => candidate.id === item.moduleId);
+  const label = module2?.label ?? item.moduleId;
+  const calls = moduleCallCount(data, item.moduleId);
+  const focusNode = strongestNode(data, item.moduleId);
+  const risk = riskFor(calls, item.churn);
+  const intent = inferIntent(item.latestSubject);
+  return {
+    id: `git-${item.moduleId}-${index}`,
+    title: `${label} moved recently`,
+    kind: risk === "high" ? "risk" : "hot",
+    when: item.latestDate || "recently",
+    source: item.latestHash ? `commit ${item.latestHash}` : "git history",
+    intent,
+    summary: `${item.churn} changed lines across ${item.filePaths.size} indexed files. Latest: ${item.latestSubject || "no commit subject"}.`,
+    why: `${label} is both changing and connected to ${calls} call edges. Start here to understand whether the current graph is new work, load-bearing behavior, or legacy surface area.`,
+    calls,
+    churn: item.churn,
+    risk,
+    moduleId: item.moduleId,
+    focusNodeId: focusNode?.id,
+    filePaths: [...item.filePaths].slice(0, 8)
+  };
+}
+function scoreModule(data, moduleId, churn) {
+  return churn + moduleCallCount(data, moduleId) * 4;
+}
+function moduleCallCount(data, moduleId) {
+  const moduleEdgeCount = data.moduleEdges.filter((edge) => edge.source === moduleId || edge.target === moduleId).reduce((total, edge) => total + edge.weight, 0);
+  if (moduleEdgeCount > 0) return moduleEdgeCount;
+  const nodeModules = new Map(data.nodes.map((node) => [node.id, node.moduleId]));
+  return data.edges.filter((edge) => nodeModules.get(edge.source) === moduleId || nodeModules.get(edge.target) === moduleId).length;
+}
+function strongestNode(data, moduleId) {
+  const degree = /* @__PURE__ */ new Map();
+  for (const edge of data.edges) {
+    degree.set(edge.source, (degree.get(edge.source) ?? 0) + 1);
+    degree.set(edge.target, (degree.get(edge.target) ?? 0) + 1);
+  }
+  return data.nodes.filter((node) => node.moduleId === moduleId).sort((a, b) => (degree.get(b.id) ?? 0) - (degree.get(a.id) ?? 0))[0];
+}
+function riskFor(calls, churnOrSymbols) {
+  if (calls >= 20 || churnOrSymbols >= 250) return "high";
+  if (calls >= 8 || churnOrSymbols >= 80) return "medium";
+  return "low";
+}
+function inferIntent(subject) {
+  const normalized = subject.toLowerCase();
+  if (normalized.includes("fix")) return "stability";
+  if (normalized.includes("test")) return "verification";
+  if (normalized.includes("refactor")) return "refactor";
+  if (normalized.includes("visual")) return "visualization";
+  if (normalized.includes("call") || normalized.includes("graph")) return "call graph";
+  if (normalized.includes("config")) return "configuration";
+  return "recent work";
+}
+function normalizePath3(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function toGitRelativePath(projectRoot, filePath) {
+  const relativePath = path22.isAbsolute(filePath) ? path22.relative(projectRoot, filePath) : filePath;
+  return normalizePath3(relativePath);
+}
+
+// src/tools/visualize/template.ts
+function generateVisualizationHtml(data) {
+  const jsonData = JSON.stringify(data).replace(/</g, "\\u003c").replace(/>/g, "\\u003e");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<meta http-equiv="Content-Security-Policy" content="default-src 'self' 'unsafe-inline'; script-src 'unsafe-inline'">
+<title>Call Graph Visualization</title>
+<style>
+*{box-sizing:border-box}body{margin:0;background:#0d1118;color:#c4cfe6;font-family:Inter,-apple-system,BlinkMacSystemFont,"Segoe UI",system-ui,sans-serif;overflow:hidden}
+#app{height:100vh;display:grid;grid-template-columns:300px minmax(0,1fr) 320px;grid-template-rows:auto 1fr;gap:12px;padding:14px}
+.top{grid-column:1/-1;display:flex;align-items:center;gap:10px;min-width:0}.search{width:300px;max-width:40vw;padding:8px 11px;border:1px solid #203149;border-radius:6px;background:#141e2e;color:#c4cfe6;outline:none}.search:focus{border-color:#5577d8}
+.tabs{display:flex;gap:6px;min-width:0;overflow:auto}.tab{border:1px solid #203149;background:#141e2e;color:#6f83a4;border-radius:6px;padding:7px 10px;cursor:pointer;white-space:nowrap}.tab.active{border-color:#5577d8;color:#fff;background:#111c30}
+.stats{margin-left:auto;color:#334966;font-size:12px;white-space:nowrap;border:1px solid #203149;background:#141e2e;border-radius:6px;padding:7px 11px}.stats b{color:#7f94b8}
+.panel{background:rgba(13,17,24,.86);border:1px solid #203149;border-radius:8px;min-height:0}.left,.right{padding:14px;overflow:auto;overflow-x:hidden}.title{font-size:10px;text-transform:uppercase;letter-spacing:.1em;color:#334966;margin:0 0 10px}
+.results,.list{display:grid;gap:7px;min-width:0}.result,.row,.node,.change{min-width:0;border:1px solid #203149;background:#101722;border-radius:7px;padding:9px 10px;cursor:pointer;overflow:hidden}.result:hover,.row:hover,.node:hover,.change:hover{border-color:#375171;background:#121c2a}.result.active,.node.active,.change.active{border-color:#8b6cf6;background:#15172a}
+.name{font-family:"SF Mono","Cascadia Code",Consolas,monospace;font-size:12px;color:#e0e6f7;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.meta{min-width:0;max-width:100%;font-size:11px;color:#6f83a4;margin-top:4px;display:flex;gap:8px;align-items:center;overflow:hidden}.meta span{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.badge{font-family:"SF Mono",Consolas,monospace;font-size:10px;border-radius:4px;padding:2px 5px;background:#1b2940;color:#7890ac;flex:0 0 auto}.badge.function,.badge.fn{background:#18264a;color:#7896ff}.badge.class{background:#271f4b;color:#a48cff}.badge.type,.badge.interface{background:#172d36;color:#5fc4d4}.badge.enum{background:#382812;color:#e3a348}
+.main{position:relative;overflow:hidden;padding:14px}.flow{position:relative;height:100%;display:grid;grid-template-columns:minmax(220px,1fr) minmax(300px,1.15fr) minmax(220px,1fr);gap:24px;align-items:center}.lane{height:min(640px,calc(100vh - 150px));min-height:360px;border:1px solid #203149;border-radius:8px;padding:14px;display:flex;flex-direction:column;gap:10px;overflow:auto;background:rgba(16,23,34,.5)}.lane .node,.lane .row{flex:0 0 auto}.lane h3,.module-symbols h3{margin:0 0 4px;font-size:10px;text-transform:uppercase;letter-spacing:.1em;color:#334966;text-align:center}.center{align-self:center;min-width:0}.center .node{cursor:default;border-color:#8b6cf6;background:#15172a;box-shadow:0 0 0 1px rgba(139,108,246,.2)}.module-board{height:100%;display:grid;grid-template-rows:auto 260px minmax(260px,1fr);gap:12px;overflow:hidden}.module-summary .node{cursor:default;border-color:#8b6cf6;background:#15172a}.module-lanes{min-height:0;display:grid;grid-template-columns:1fr 1fr;gap:12px}.module-board .lane{height:auto;min-height:0}.module-symbols{min-height:0;border:1px solid #203149;border-radius:8px;padding:14px;background:rgba(16,23,34,.5);display:flex;flex-direction:column;gap:10px;overflow:hidden}.module-symbols .list{display:block;overflow:auto;min-height:0}.module-symbols .row{display:grid;grid-template-columns:minmax(0,1fr) auto;align-items:center;margin:0 0 6px;padding:8px 10px}.module-symbols .row .meta{margin-top:0;justify-content:flex-end}.weight{margin-left:auto;color:#334966;font-variant-numeric:tabular-nums}.edges{position:absolute;inset:0;pointer-events:none;z-index:1}.node{position:relative;z-index:2}
+.details{display:grid;gap:8px}.kv{display:flex;justify-content:space-between;gap:12px;border-bottom:1px solid #17243a;padding-bottom:7px;color:#6f83a4;font-size:12px}.kv span:first-child{color:#334966;text-transform:uppercase;font-size:10px;letter-spacing:.08em}.mini{display:flex;align-items:center;gap:8px;color:#6f83a4;font-size:12px}.dot{width:8px;height:8px;border-radius:50%;flex:0 0 auto}.empty{height:100%;display:grid;place-items:center;color:#334966;font-size:12px;text-align:center;line-height:1.5}.guide{border:1px solid #203149;border-radius:7px;background:#101722;padding:10px;color:#6f83a4;font-size:12px;line-height:1.45}.guide b{display:block;color:#e0e6f7;margin-bottom:4px}.guide span{display:block}
+.grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(250px,1fr));gap:10px;align-content:start}.rank{font-size:20px;color:#8b6cf6;font-variant-numeric:tabular-nums}.change-grid{display:grid;grid-template-columns:minmax(280px,.95fr) minmax(320px,1.2fr);gap:12px;height:100%;min-height:0}.change-list,.why{display:flex;flex-direction:column;gap:9px;min-height:0;overflow:auto;overflow-x:hidden}.change-top{display:flex;align-items:center;gap:8px;margin-bottom:7px;min-width:0}.pill{font-size:10px;text-transform:uppercase;letter-spacing:.08em;border:1px solid #203149;border-radius:999px;padding:3px 7px;color:#6f83a4;flex:0 0 auto}.pill.hot{color:#d5c9ff;border-color:#634bc2}.pill.risk{color:#ffbab7;border-color:#8d3d3a}.pill.legacy{color:#c5d1df;border-color:#41536c}.why-card{min-width:0;border:1px solid #203149;background:rgba(16,23,34,.65);border-radius:8px;padding:14px;overflow:hidden}.why-card h3{margin:0 0 8px;font-size:13px}.why-card p{margin:0;color:#6f83a4;font-size:13px;line-height:1.55}.impact{display:grid;grid-template-columns:repeat(3,1fr);gap:8px;margin-top:10px}.impact div{border:1px solid #17243a;border-radius:7px;padding:8px}.impact b{display:block;font-size:16px;color:#e0e6f7}.impact span{font-size:10px;color:#334966;text-transform:uppercase;letter-spacing:.08em}
+.hint{position:absolute;left:50%;bottom:12px;transform:translateX(-50%);font-size:11px;color:#334966;border:1px solid #203149;background:rgba(13,17,24,.9);border-radius:6px;padding:6px 12px;white-space:nowrap}
+@media(max-width:1500px){body{overflow:auto}#app{height:auto;min-height:100vh;grid-template-columns:1fr;grid-template-rows:auto auto auto auto}.top{flex-wrap:wrap}.tabs{flex-wrap:wrap;overflow:visible}.search{width:100%;max-width:none}.stats{margin-left:0;width:100%}.main{order:1;min-height:820px}.right{order:2}.left{order:3}.flow{grid-template-columns:minmax(220px,1fr) minmax(300px,1.15fr) minmax(220px,1fr);gap:16px;align-items:center}.change-grid{grid-template-columns:1fr;gap:12px;align-items:stretch}.why{order:1}.change-list{order:2}.lane{height:min(560px,calc(100vh - 180px));min-height:260px}.impact{grid-template-columns:1fr}.edges{display:none}.hint{position:static;transform:none;margin-top:10px;text-align:center}}
+@media(max-width:900px){.flow,.module-lanes{grid-template-columns:1fr;gap:12px;align-items:stretch}.lane{height:auto;max-height:360px;min-height:160px}.module-board{grid-template-rows:auto auto minmax(260px,1fr);overflow:visible}.module-symbols{max-height:420px}.module-symbols .row{grid-template-columns:1fr}.module-symbols .row .meta{justify-content:flex-start;margin-top:4px}}
+</style>
+</head>
+<body>
+<div id="app">
+  <div class="top">
+    <input id="search" class="search" placeholder="Search changes, symbols, modules, files..." autocomplete="off">
+    <div class="tabs" id="tabs"></div>
+    <div class="stats"><b id="modeName">Changes</b> | <b id="nodeCount">0</b> nodes | <b id="edgeCount">0</b> edges | <b id="changeCount">0</b> change lenses</div>
+  </div>
+  <aside class="panel left"><h2 class="title">Search / jump</h2><div id="results" class="results"></div></aside>
+  <main class="panel main"><svg id="edges" class="edges"></svg><div id="stage" class="flow"></div><div class="hint" id="hint">Scroll to pan vertically inside focus mode</div></main>
+  <aside class="panel right"><h2 class="title">Details</h2><div id="details" class="details"></div></aside>
+</div>
+<script>
+const graphData = ${jsonData};
+const nodes = graphData.nodes || [];
+const edges = graphData.edges || [];
+const modules = graphData.modules || [];
+const moduleEdges = graphData.moduleEdges || [];
+const changes = graphData.changes || [];
+const modes = ["Changes", "Module Overview", "Explore Symbols", "Hotspots", "Cycles"];
+let mode = changes.length > 0 ? "Changes" : "Module Overview";
+let selected = nodes[0] ? { type: "symbol", id: nodes[0].id } : { type: "module", id: modules[0] && modules[0].id };
+let selectedChange = changes[0] && changes[0].id;
+let query = "";
+
+function esc(value){return String(value == null ? "" : value).replace(/[&<>"']/g,function(c){return {"&":"&amp;","<":"&lt;",">":"&gt;","\\"":"&quot;","'":"&#39;"}[c];});}
+function nodeById(id){return nodes.find(function(node){return node.id === id;});}
+function moduleById(id){return modules.find(function(item){return item.id === id;});}
+function colorFor(id){const moduleId = nodeById(id) ? nodeById(id).moduleId : id; const index = Math.max(0, modules.findIndex(function(item){return item.id === moduleId;})); return ["#8b6cf6","#5577d8","#4aa46c","#ce6764","#d0933a","#41a6bd","#c667a4","#7890ac"][index % 8];}
+function shortPath(filePath){const parts = String(filePath || "").split(/[\\\\/]/).filter(Boolean); if(parts.length <= 3)return String(filePath || ""); return ".../" + parts.slice(-3).join("/");}
+function badge(kind){return '<span class="badge ' + esc(kind) + '">' + esc(kind) + '</span>';}
+function edgeWeight(edge){return edge.weight || 1;}
+function incomingSymbol(id){return edges.filter(function(edge){return edge.target === id;}).sort(function(a,b){return edgeWeight(b)-edgeWeight(a);});}
+function outgoingSymbol(id){return edges.filter(function(edge){return edge.source === id;}).sort(function(a,b){return edgeWeight(b)-edgeWeight(a);});}
+function incomingModule(id){return moduleEdges.filter(function(edge){return edge.target === id;}).sort(function(a,b){return b.weight-a.weight;});}
+function outgoingModule(id){return moduleEdges.filter(function(edge){return edge.source === id;}).sort(function(a,b){return b.weight-a.weight;});}
+function labelOf(id){const node = nodeById(id); if(node)return node.name; const mod = moduleById(id); return mod ? mod.label : id;}
+function nodeCard(title, meta, id, type, color, active){return '<div class="node ' + (active ? 'active' : '') + '" data-id="' + esc(id || '') + '" data-type="' + esc(type || 'symbol') + '" style="border-color:' + esc(color || "#203149") + '"><div class="name">' + esc(title) + '</div><div class="meta">' + meta + '</div></div>';}
+function symbolCard(id, weight){const node = nodeById(id); if(!node)return ""; return nodeCard(node.name, badge(node.kind) + '<span>' + esc(shortPath(node.filePath)) + '</span><span class="weight">' + weight + '</span>', node.id, "symbol", colorFor(node.id), false);}
+function moduleCard(id, weight){const item = moduleById(id); if(!item)return ""; return nodeCard(item.label, '<span>' + item.symbolCount + ' symbols</span><span class="weight">' + weight + '</span>', item.id, "module", colorFor(item.id), false);}
+function empty(a,b){return '<div class="empty"><div>' + esc(a) + '<br>' + esc(b) + '</div></div>';}
+function emptyCycleState(){return '<div class="empty"><div><b>No cycles found</b><br>This graph slice has no resolved module loops or symbol recursion.<br><br>A cycle means A calls B, B calls C, and C calls A.</div></div>';}
+function guideForMode(){
+  if(mode === "Module Overview")return '<div class="guide"><b>How to read</b><span>Module = code area. Symbol = named code item. Counts on caller/callee cards are call edges. Grouped symbol rows collapse repeated indexed ranges.</span></div>';
+  if(mode === "Explore Symbols")return '<div class="guide"><b>How to read</b><span>Focused symbol is in the middle. Left calls it. Right is what it calls.</span></div>';
+  if(mode === "Hotspots")return '<div class="guide"><b>How to read</b><span>Higher score means more incoming plus outgoing call edges, often more load-bearing.</span></div>';
+  if(mode === "Cycles")return '<div class="guide"><b>How to read</b><span>Cycles include module dependency loops and direct or short symbol recursion.</span></div>';
+  return '<div class="guide"><b>How to read</b><span>Recent Git movement is shown first; open a change to see affected module, churn, and call context.</span></div>';
+}
+function groupedSymbolCards(edgeList, pickId, limit){
+  const groups = new Map();
+  edgeList.forEach(function(edge){const id = pickId(edge); const node = nodeById(id); if(!node)return; const key = node.name + "|" + node.kind + "|" + node.filePath; const group = groups.get(key) || { id:id, count:0 }; group.count += edgeWeight(edge); groups.set(key, group);});
+  return [...groups.values()].sort(function(a,b){return b.count-a.count;}).slice(0, limit || groups.size).map(function(group){return symbolCard(group.id, group.count);}).join("");
+}
+function groupedModuleSymbolRows(symbols){
+  const groups = new Map();
+  symbols.forEach(function(node){
+    const key = node.name + "|" + node.kind + "|" + node.filePath;
+    const group = groups.get(key) || { id:node.id, node:node, count:0, minLine:node.line, maxLine:node.line };
+    group.count += 1;
+    group.minLine = Math.min(group.minLine, node.line);
+    group.maxLine = Math.max(group.maxLine, node.line);
+    groups.set(key, group);
+  });
+  return [...groups.values()].map(function(group){
+    const lineText = group.minLine === group.maxLine ? "line " + group.minLine : "lines " + group.minLine + "-" + group.maxLine;
+    const countText = group.count > 1 ? '<span>x' + group.count + '</span>' : "";
+    return '<div class="row" data-id="' + esc(group.id) + '" data-type="symbol"><div class="name">' + esc(group.node.name) + '</div><div class="meta">' + badge(group.node.kind) + '<span>' + esc(shortPath(group.node.filePath)) + '</span><span>' + esc(lineText) + '</span>' + countText + '</div></div>';
+  }).join("");
+}
+function findSymbolCycles(limit){
+  const outgoing = new Map();
+  edges.forEach(function(edge){if(edge.source === edge.target)return; const list = outgoing.get(edge.source) || []; list.push(edge.target); outgoing.set(edge.source, list);});
+  const cycles = [];
+  const seen = new Set();
+  edges.filter(function(edge){return edge.source === edge.target;}).forEach(function(edge){
+    if(!nodeById(edge.source))return;
+    seen.add(edge.source + ">" + edge.source);
+    cycles.push({ ids:[edge.source], kind:"direct recursion" });
+  });
+  nodes.some(function(start){
+    const stack = [{ id:start.id, path:[start.id] }];
+    while(stack.length > 0 && cycles.length < limit){
+      const current = stack.pop();
+      (outgoing.get(current.id) || []).forEach(function(next){
+        if(cycles.length >= limit)return;
+        if(next === start.id && current.path.length > 1){
+          const key = current.path.slice().sort().join(">");
+          if(!seen.has(key)){seen.add(key); cycles.push({ ids:current.path.slice(), kind:"symbol loop" });}
+        } else if(current.path.length < 5 && current.path.indexOf(next) === -1) {
+          stack.push({ id:next, path:current.path.concat(next) });
+        }
+      });
+    }
+    return cycles.length >= limit;
+  });
+  return cycles.slice(0, limit);
+}
+
+function renderTabs(){
+  document.getElementById("tabs").innerHTML = modes.map(function(item){return '<button class="tab ' + (item === mode ? 'active' : '') + '" data-mode="' + esc(item) + '">' + esc(item) + '</button>';}).join("");
+  document.querySelectorAll("[data-mode]").forEach(function(button){button.onclick = function(){mode = button.dataset.mode || "Changes"; render();};});
+  document.getElementById("modeName").textContent = mode;
+  document.getElementById("nodeCount").textContent = String(nodes.length);
+  document.getElementById("edgeCount").textContent = String(edges.length);
+  document.getElementById("changeCount").textContent = String(changes.length);
+}
+function renderResults(){
+  const q = query.toLowerCase();
+  const items = changes.map(function(change){return {type:"change",id:change.id,title:change.title,meta:change.source + " | " + change.when + " | " + change.intent,color:change.kind === "risk" ? "#ce6764" : "#8b6cf6"};})
+    .concat(modules.map(function(item){return {type:"module",id:item.id,title:item.label,meta:item.symbolCount + " symbols | " + item.category,color:colorFor(item.id)};}))
+    .concat(nodes.map(function(node){return {type:"symbol",id:node.id,title:node.name,meta:node.kind + " | " + shortPath(node.filePath),color:colorFor(node.id)};}))
+    .filter(function(item){return !q || (item.title + " " + item.meta + " " + item.id).toLowerCase().includes(q);})
+    .slice(0, 24);
+  document.getElementById("results").innerHTML = items.map(function(item){return '<div class="result" data-id="' + esc(item.id) + '" data-type="' + esc(item.type) + '" style="border-color:' + esc(item.color) + '"><div class="name">' + esc(item.title) + '</div><div class="meta">' + esc(item.meta) + '</div></div>';}).join("") || empty("No matching changes, symbols, or modules", "Try a file, symbol, intent, or risk term");
+}
+function renderChanges(){
+  const active = changes.find(function(change){return change.id === selectedChange;}) || changes[0];
+  if(!active){renderHotspots(); return;}
+  selectedChange = active.id;
+  const focus = active.focusNodeId ? nodeById(active.focusNodeId) : undefined;
+  document.getElementById("stage").className = "change-grid";
+  document.getElementById("stage").innerHTML = '<section class="change-list"><h2 class="title">Moving lately</h2>' + changes.map(function(change){
+    return '<div class="change ' + (change.id === active.id ? 'active' : '') + '" data-change="' + esc(change.id) + '"><div class="change-top"><span class="pill ' + esc(change.kind) + '">' + esc(change.kind) + '</span><span class="meta">' + esc(change.source) + ' | ' + esc(change.when) + '</span></div><div class="name">' + esc(change.title) + '</div><div class="meta">' + esc(change.summary) + '</div></div>';
+  }).join("") + '</section><section class="why"><div class="why-card"><div class="change-top"><span class="pill ' + esc(active.kind) + '">' + esc(active.intent) + '</span><span class="meta">' + esc(active.source) + ' | ' + esc(active.when) + '</span></div><h3>' + esc(active.title) + '</h3><p>' + esc(active.why) + '</p><div class="impact"><div><b>' + active.calls + '</b><span>call edges</span></div><div><b>' + active.churn + '</b><span>churn</span></div><div><b>' + esc(active.risk) + '</b><span>risk</span></div></div></div><div class="why-card"><h3>Current touchpoint</h3>' + (focus ? nodeCard(focus.name, badge(focus.kind) + '<span>' + esc(shortPath(focus.filePath)) + '</span>', focus.id, "symbol", colorFor(focus.id), false) : moduleCard(active.moduleId, active.calls)) + '</div><div class="why-card"><h3>Nearest call context</h3><div class="list">' + (focus ? (groupedSymbolCards(incomingSymbol(focus.id), function(edge){return edge.source;}, 3) + groupedSymbolCards(outgoingSymbol(focus.id), function(edge){return edge.target;}, 3)) : empty("No focused symbol", "Open Module Overview")) + '</div></div></section>';
+  document.getElementById("hint").textContent = "Temporal default: what changed, why, and which call path it affects.";
+  document.getElementById("edges").innerHTML = "";
+  document.querySelectorAll("[data-change]").forEach(function(el){el.onclick = function(){selectedChange = el.dataset.change; render();};});
+}
+function renderSymbol(){
+  const symbol = selected.type === "symbol" ? nodeById(selected.id) : nodes.find(function(node){return node.moduleId === selected.id;}) || nodes[0];
+  if(!symbol){document.getElementById("stage").innerHTML = empty("No symbols", "Run index_codebase first"); return;}
+  selected = {type:"symbol", id:symbol.id};
+  const callers = incomingSymbol(symbol.id);
+  const callees = outgoingSymbol(symbol.id);
+  document.getElementById("stage").className = "flow";
+  document.getElementById("stage").innerHTML = '<section class="lane" id="callers"><h3>Callers</h3>' + (groupedSymbolCards(callers, function(edge){return edge.source;}) || empty("No callers", "Entry-level symbol")) + '</section><section class="center">' + nodeCard(symbol.name, badge(symbol.kind) + '<span>' + esc(shortPath(symbol.filePath)) + '</span>', symbol.id, "symbol", colorFor(symbol.id), true) + '</section><section class="lane" id="callees"><h3>Callees</h3>' + (groupedSymbolCards(callees, function(edge){return edge.target;}) || empty("No callees", "Leaf-level symbol")) + '</section>';
+  document.getElementById("hint").textContent = "Explore mode: clustered symbol relationships. Focused module view uses the same one-hop navigation.";
+  requestAnimationFrame(drawEdges);
+}
+function renderModule(){
+  const item = selected.type === "module" ? moduleById(selected.id) : moduleById((nodeById(selected.id) || {}).moduleId) || modules[0];
+  if(!item){document.getElementById("stage").innerHTML = empty("No modules", "Run index_codebase first"); return;}
+  selected = {type:"module", id:item.id};
+  const callers = incomingModule(item.id);
+  const callees = outgoingModule(item.id);
+  const internalEdges = edges.filter(function(edge){return nodeById(edge.source)?.moduleId === item.id && nodeById(edge.target)?.moduleId === item.id;});
+  const moduleSymbols = nodes.filter(function(node){return node.moduleId === item.id;});
+  const leftTitle = callers.length > 0 ? "Incoming modules" : "Internal callers";
+  const rightTitle = callees.length > 0 ? "Outgoing modules" : "Internal callees";
+  const groupedModuleSymbols = groupedModuleSymbolRows(moduleSymbols);
+  const uniqueModuleSymbolCount = (groupedModuleSymbols.match(/class="row"/g) || []).length;
+  const leftCards = callers.length > 0 ? callers.map(function(edge){return moduleCard(edge.source, edge.weight);}).join("") : groupedSymbolCards(internalEdges, function(edge){return edge.source;}, 12);
+  const rightCards = callees.length > 0 ? callees.map(function(edge){return moduleCard(edge.target, edge.weight);}).join("") : groupedSymbolCards(internalEdges, function(edge){return edge.target;}, 12);
+  document.getElementById("stage").className = "module-board";
+  document.getElementById("stage").innerHTML = '<section class="module-summary">' + nodeCard(item.label, '<span>' + item.symbolCount + ' indexed symbols</span><span>' + uniqueModuleSymbolCount + ' unique rows</span><span>' + esc(item.category) + '</span>', item.id, "module", colorFor(item.id), true) + '</section><section class="module-lanes"><div class="lane" id="callers"><h3>' + leftTitle + '</h3>' + (leftCards || empty("This slice only has intra-module calls.", "Selected from module list")) + '</div><div class="lane" id="callees"><h3>' + rightTitle + '</h3>' + (rightCards || empty("No calls in this module.", "Selected from module list")) + '</div></section><section class="module-symbols"><h3>Symbols in module (' + uniqueModuleSymbolCount + ' unique, ' + moduleSymbols.length + ' indexed)</h3><div class="list">' + groupedModuleSymbols + '</div></section>';
+  document.getElementById("hint").textContent = callers.length + callees.length > 0 ? "Module Overview. Focused module view shows strongest incoming and outgoing module edges." : "Module Overview. This repo slice has no resolved cross-module edges, so this view shows intra-module hotspots.";
+  requestAnimationFrame(drawEdges);
+}
+function renderHotspots(){
+  const ranked = nodes.map(function(node){return {node:node, score:incomingSymbol(node.id).length + outgoingSymbol(node.id).length};}).sort(function(a,b){return b.score-a.score;}).slice(0, 20);
+  document.getElementById("stage").className = "grid";
+  document.getElementById("stage").innerHTML = ranked.map(function(item,index){return '<div class="row" data-id="' + esc(item.node.id) + '" data-type="symbol"><div class="meta"><span class="rank">' + (index + 1) + '</span><span class="weight">' + item.score + ' call edges</span></div><div class="name">' + esc(item.node.name) + '</div><div class="meta">' + badge(item.node.kind) + '<span>' + esc(shortPath(item.node.filePath)) + '</span></div></div>';}).join("") || empty("No hotspots", "No call edges in this slice");
+  document.getElementById("hint").textContent = "Hotspots rank symbols by incoming plus outgoing call edges.";
+  document.getElementById("edges").innerHTML = "";
+}
+function renderCycles(){
+  const cycles = moduleEdges.filter(function(edge){return moduleEdges.some(function(other){return other.source === edge.target && other.target === edge.source;});});
+  const symbolCycles = findSymbolCycles(20);
+  document.getElementById("stage").className = "grid";
+  const moduleHtml = cycles.map(function(edge){return '<div class="row" data-id="' + esc(edge.source) + '" data-type="module"><div class="name">' + esc(labelOf(edge.source)) + ' -> ' + esc(labelOf(edge.target)) + '</div><div class="meta"><span>module dependency loop candidate</span><span class="weight">' + edge.weight + ' calls</span></div></div>';}).join("");
+  const symbolHtml = symbolCycles.map(function(cycle){const start = cycle.ids[0]; const node = nodeById(start); const path = cycle.ids.map(function(id){return labelOf(id);}).join(" -> ") + " -> " + labelOf(start); const countLabel = cycle.ids.length === 1 ? "1 symbol" : cycle.ids.length + " symbols"; return '<div class="row" data-id="' + esc(start) + '" data-type="symbol"><div class="name">' + esc(path) + '</div><div class="meta"><span>' + esc(cycle.kind) + '</span>' + (node ? '<span>' + esc(shortPath(node.filePath)) + '</span>' : '') + '<span class="weight">' + countLabel + '</span></div></div>';}).join("");
+  document.getElementById("stage").innerHTML = moduleHtml + symbolHtml || emptyCycleState();
+  document.getElementById("hint").textContent = "Cycle mode surfaces module loops plus direct or short symbol recursion.";
+  document.getElementById("edges").innerHTML = "";
+}
+function renderDetails(){
+  if(mode === "Changes"){
+    const active = changes.find(function(change){return change.id === selectedChange;});
+    if(active){document.getElementById("details").innerHTML = guideForMode() + '<div class="name">' + esc(active.title) + '</div><div class="kv"><span>Source</span><b>' + esc(active.source) + '</b></div><div class="kv"><span>Changed</span><b>' + esc(active.when) + '</b></div><div class="kv"><span>Intent</span><b>' + esc(active.intent) + '</b></div><div class="kv"><span>Risk</span><b>' + esc(active.risk) + '</b></div><h2 class="title">Onboarding read</h2><p style="margin:0;color:#6f83a4;font-size:13px;line-height:1.6">' + esc(active.summary) + '</p>'; return;}
+  }
+  const isSymbol = selected.type === "symbol";
+  const item = isSymbol ? nodeById(selected.id) : moduleById(selected.id);
+  if(!item){document.getElementById("details").innerHTML = guideForMode(); return;}
+  const incoming = isSymbol ? incomingSymbol(selected.id) : incomingModule(selected.id);
+  const outgoing = isSymbol ? outgoingSymbol(selected.id) : outgoingModule(selected.id);
+  if(!isSymbol){
+    const internal = edges.filter(function(edge){const source = nodeById(edge.source); const target = nodeById(edge.target); return source && target && source.moduleId === selected.id && target.moduleId === selected.id;});
+    const hasCrossModuleEdges = incoming.length + outgoing.length > 0;
+    const edgeCards = hasCrossModuleEdges ? incoming.concat(outgoing).map(function(edge){return moduleCard(edge.source === selected.id ? edge.target : edge.source, edge.weight);}).join("") : groupedSymbolCards(internal, function(edge){return edge.source;}, 4) + groupedSymbolCards(internal, function(edge){return edge.target;}, 4);
+    document.getElementById("details").innerHTML = guideForMode() + '<div class="name">' + esc(item.label) + '</div><div class="kv"><span>Kind</span><b>' + esc(item.category) + '</b></div><div class="kv"><span>File/module</span><b>' + esc(item.label) + '</b></div><div class="kv"><span>Symbols</span><b>' + item.symbolCount + '</b></div><div class="kv"><span>' + (hasCrossModuleEdges ? 'Cross-module edges' : 'Internal call edges') + '</span><b>' + (incoming.length + outgoing.length || internal.length) + '</b></div><h2 class="title">Strongest edges</h2><div class="list">' + (edgeCards || empty("No calls in this module.", "Selected from module list")) + '</div>';
+    return;
+  }
+  document.getElementById("details").innerHTML = guideForMode() + '<div class="name">' + esc(item.name) + '</div><div class="kv"><span>Kind</span><b>' + esc(item.kind) + '</b></div><div class="kv"><span>File/module</span><b>' + esc(shortPath(item.filePath)) + '</b></div><div class="kv"><span>Callers</span><b>' + incoming.length + '</b></div><div class="kv"><span>Callees</span><b>' + outgoing.length + '</b></div><h2 class="title">Strongest edges</h2><div class="list">' + groupedSymbolCards(incoming.concat(outgoing), function(edge){return edge.source === selected.id ? edge.target : edge.source;}, 8) + '</div>';
+}
+function drawEdges(){
+  const svg = document.getElementById("edges");
+  const stage = document.getElementById("stage");
+  const left = document.getElementById("callers");
+  const right = document.getElementById("callees");
+  const center = document.querySelector(".center .node");
+  svg.innerHTML = "";
+  if(!left || !right || !center || innerWidth < 901)return;
+  const box = stage.getBoundingClientRect();
+  svg.setAttribute("viewBox", "0 0 " + box.width + " " + box.height);
+  function line(from,to){const a=from.getBoundingClientRect();const b=to.getBoundingClientRect();const x1=a.right-box.left;const y1=a.top+a.height/2-box.top;const x2=b.left-box.left;const y2=b.top+b.height/2-box.top;const mid=(x1+x2)/2;const path=document.createElementNS("http://www.w3.org/2000/svg","path");path.setAttribute("d","M"+x1+","+y1+" C"+mid+","+y1+" "+mid+","+y2+" "+x2+","+y2);path.setAttribute("fill","none");path.setAttribute("stroke","#334966");path.setAttribute("stroke-width","1.5");path.setAttribute("opacity",".65");svg.appendChild(path);}
+  left.querySelectorAll(".node").forEach(function(node){line(node, center);});
+  right.querySelectorAll(".node").forEach(function(node){line(center, node);});
+}
+function wireClicks(){
+  document.querySelectorAll("[data-id]").forEach(function(el){el.onclick = function(){selected = {type:el.dataset.type, id:el.dataset.id}; if(selected.type === "change"){selectedChange = selected.id; mode = "Changes";} else {mode = selected.type === "module" ? "Module Overview" : "Explore Symbols";} render();};});
+}
+function render(){
+  renderTabs();
+  renderResults();
+  if(mode === "Changes")renderChanges(); else if(mode === "Module Overview")renderModule(); else if(mode === "Hotspots")renderHotspots(); else if(mode === "Cycles")renderCycles(); else renderSymbol();
+  renderDetails();
+  wireClicks();
+}
+document.getElementById("search").addEventListener("input", function(event){query = event.target.value; renderResults(); wireClicks();});
+addEventListener("resize", function(){requestAnimationFrame(drawEdges);});
+render();
+</script>
+</body>
+</html>`;
+}
+
+// src/tools/visualize/transform.ts
+import * as path23 from "path";
+
+// src/tools/visualize/modules.ts
+var MAX_MODULES = 18;
+var KNOWN_ROOTS = ["src", "native", "tests", "commands", "scripts", "docs", "benchmarks"];
+function normalizeSlashes(input) {
+  return input.replace(/\\/g, "/");
+}
+function stripToProjectRelative(filePath) {
+  const normalized = normalizeSlashes(filePath);
+  let bestIndex = Number.POSITIVE_INFINITY;
+  let bestRoot = null;
+  for (const root of KNOWN_ROOTS) {
+    if (normalized === root || normalized.startsWith(`${root}/`)) {
+      return normalized;
+    }
+    const marker = `/${root}/`;
+    const rootIndex = normalized.indexOf(marker);
+    if (rootIndex !== -1 && rootIndex < bestIndex) {
+      bestIndex = rootIndex;
+      bestRoot = root;
+    }
+    if (normalized.endsWith(`/${root}`)) {
+      return root;
+    }
+  }
+  if (bestRoot !== null && Number.isFinite(bestIndex)) {
+    return normalized.slice(bestIndex + 1);
+  }
+  const parts = normalized.split("/").filter(Boolean);
+  return parts.slice(-3).join("/") || normalized;
+}
+function modulePrefixFromRelativePath(relativeFilePath) {
+  const parts = relativeFilePath.split("/").filter(Boolean);
+  if (parts.length === 0) return ".";
+  const [root, second, third] = parts;
+  if (root === "src") {
+    if (!second) return "src";
+    const broadBuckets = /* @__PURE__ */ new Set([
+      "config",
+      "embeddings",
+      "eval",
+      "git",
+      "indexer",
+      "native",
+      "rerank",
+      "tools",
+      "utils",
+      "watcher"
+    ]);
+    if (broadBuckets.has(second)) return `src/${second}`;
+    return second ? `src/${second}` : "src";
+  }
+  if (root === "tests") {
+    if (second === "fixtures" && third) return `tests/fixtures/${third}`;
+    return second ? `tests/${second}` : "tests";
+  }
+  if (root === "native") {
+    if (second === "src") return "native";
+    return second ? `native/${second}` : "native";
+  }
+  if (root === "commands") return "commands";
+  if (root === "scripts") return "scripts";
+  if (root === "docs") return second ? `docs/${second}` : "docs";
+  if (root === "benchmarks") return second ? `benchmarks/${second}` : "benchmarks";
+  return root;
+}
+function parentModulePrefix(prefix) {
+  const parts = prefix.split("/");
+  if (parts.length <= 1) return null;
+  return parts.slice(0, -1).join("/");
+}
+function shortLabel(prefix, allPrefixes) {
+  const parts = prefix.split("/");
+  for (let i = 1; i <= parts.length; i++) {
+    const suffix = parts.slice(parts.length - i).join("/");
+    const ambiguous = [...allPrefixes].some((candidate) => {
+      if (candidate === prefix) return false;
+      return candidate.endsWith(`/${suffix}`) || candidate === suffix;
+    });
+    if (!ambiguous) return suffix;
+  }
+  return prefix;
+}
+function classifyModulePrefix(prefix) {
+  if (prefix.startsWith("tests/fixtures")) return "fixture";
+  if (prefix.startsWith("tests")) return "test";
+  if (prefix === "native" || prefix.startsWith("native/")) return "native";
+  if (prefix === "commands" || prefix.startsWith("commands/")) return "command";
+  if (prefix === "scripts" || prefix.startsWith("scripts/")) return "script";
+  if (prefix === "docs" || prefix.startsWith("docs/")) return "doc";
+  if (prefix === "benchmarks" || prefix.startsWith("benchmarks/")) return "benchmark";
+  if (prefix === "src" || prefix.startsWith("src/")) return "source";
+  return "other";
+}
+function displayLabelForPrefix(prefix, allPrefixes) {
+  const short = shortLabel(prefix, allPrefixes);
+  if (prefix.startsWith("tests/fixtures/")) {
+    const fixtureName = prefix.slice("tests/fixtures/".length);
+    return `fixture: ${fixtureName}`;
+  }
+  if (prefix === "tests/fixtures") {
+    return "fixtures";
+  }
+  if (prefix.startsWith("tests/")) {
+    const testArea = prefix.slice("tests/".length);
+    return `tests: ${testArea}`;
+  }
+  if (prefix === "tests") {
+    return "tests";
+  }
+  if (prefix === "native") {
+    return "native";
+  }
+  return short;
+}
+function compactModules(prefixToNodes) {
+  const grouped = new Map(prefixToNodes);
+  while (grouped.size > MAX_MODULES) {
+    const smallest = [...grouped.entries()].sort((a, b) => a[1].length - b[1].length)[0];
+    if (!smallest) break;
+    const [prefix, members] = smallest;
+    const parent = parentModulePrefix(prefix);
+    if (!parent) break;
+    grouped.delete(prefix);
+    if (!grouped.has(parent)) grouped.set(parent, []);
+    grouped.get(parent)?.push(...members);
+  }
+  return grouped;
+}
+function deriveModules(nodes) {
+  const initial = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const relative10 = stripToProjectRelative(node.filePath);
+    const prefix = modulePrefixFromRelativePath(relative10);
+    if (!initial.has(prefix)) initial.set(prefix, []);
+    initial.get(prefix)?.push(node);
+  }
+  const nonFixturePrefixes = [...initial.keys()].filter((prefix) => !prefix.startsWith("tests/fixtures/"));
+  if (nonFixturePrefixes.length > 0) {
+    const fixtureEntries = [...initial.entries()].filter(([prefix]) => prefix.startsWith("tests/fixtures/"));
+    if (fixtureEntries.length > 1) {
+      const mergedFixtureNodes = fixtureEntries.flatMap(([, members]) => members);
+      for (const [prefix] of fixtureEntries) {
+        initial.delete(prefix);
+      }
+      initial.set("tests/fixtures", mergedFixtureNodes);
+    }
+  }
+  const grouped = compactModules(initial);
+  const allPrefixes = new Set(grouped.keys());
+  const modules = [...grouped.entries()].map(([prefix, members]) => {
+    const kinds = {};
+    for (const node of members) {
+      kinds[node.kind] = (kinds[node.kind] ?? 0) + 1;
+    }
+    const label = displayLabelForPrefix(prefix, allPrefixes);
+    const category = classifyModulePrefix(prefix);
+    const id = `module-${prefix.replace(/[^a-zA-Z0-9]+/g, "-")}`;
+    for (const node of members) {
+      node.moduleId = id;
+      node.moduleLabel = label;
+    }
+    return {
+      id,
+      label,
+      pathPrefix: prefix,
+      category,
+      symbolCount: members.length,
+      symbols: members.map((node) => node.id),
+      kinds
+    };
+  }).sort((a, b) => b.symbolCount - a.symbolCount || a.label.localeCompare(b.label));
+  return modules;
+}
+function deriveModuleEdges(nodes, edges) {
+  const nodeMap = new Map(nodes.map((node) => [node.id, node]));
+  const aggregate = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const source = nodeMap.get(edge.source);
+    if (!source || !source.moduleId) continue;
+    const target = nodeMap.get(edge.target);
+    const targetModuleId = target?.moduleId;
+    if (!targetModuleId) continue;
+    if (source.moduleId === targetModuleId) continue;
+    const key = `${source.moduleId}__${targetModuleId}`;
+    if (!aggregate.has(key)) {
+      aggregate.set(key, {
+        source: source.moduleId,
+        target: targetModuleId,
+        weight: 0,
+        callTypes: {}
+      });
+    }
+    const moduleEdge = aggregate.get(key);
+    moduleEdge.weight += 1;
+    moduleEdge.callTypes[edge.callType] = (moduleEdge.callTypes[edge.callType] ?? 0) + 1;
+  }
+  return [...aggregate.values()].sort((a, b) => b.weight - a.weight);
+}
+
+// src/tools/visualize/transform.ts
+function transformForVisualization(symbols, edges, options = {}) {
+  const { includeOrphans = false, directory, maxNodes = 5e3 } = options;
+  let filteredSymbols = symbols;
+  if (directory) {
+    const normalizedDir = directory.replace(/\/$/, "");
+    const normalizedDirWithSlash = `${normalizedDir}/`;
+    const normalizedAbsoluteSuffix = `/${normalizedDirWithSlash}`;
+    filteredSymbols = symbols.filter(
+      (s) => {
+        const normalizedPath = s.filePath.replace(/\\/g, "/");
+        return normalizedPath === normalizedDir || normalizedPath.startsWith(normalizedDirWithSlash) || normalizedPath.endsWith(`/${normalizedDir}`) || normalizedPath.includes(normalizedAbsoluteSuffix);
+      }
+    );
+  }
+  const symbolIdSet = new Set(filteredSymbols.map((s) => s.id));
+  const filteredEdges = [];
+  for (const edge of edges) {
+    if (!edge.isResolved || !edge.toSymbolId) continue;
+    if (!symbolIdSet.has(edge.fromSymbolId)) continue;
+    if (!symbolIdSet.has(edge.toSymbolId)) continue;
+    filteredEdges.push({
+      source: edge.fromSymbolId,
+      target: edge.toSymbolId,
+      callType: edge.callType,
+      confidence: edge.confidence,
+      line: edge.line
+    });
+  }
+  let finalSymbols = filteredSymbols;
+  if (!includeOrphans) {
+    const connectedIds = /* @__PURE__ */ new Set();
+    for (const edge of filteredEdges) {
+      connectedIds.add(edge.source);
+      connectedIds.add(edge.target);
+    }
+    finalSymbols = filteredSymbols.filter((s) => connectedIds.has(s.id));
+  }
+  const truncated = finalSymbols.length > maxNodes;
+  if (truncated) {
+    const connectionCount = /* @__PURE__ */ new Map();
+    for (const edge of filteredEdges) {
+      connectionCount.set(edge.source, (connectionCount.get(edge.source) ?? 0) + 1);
+      connectionCount.set(edge.target, (connectionCount.get(edge.target) ?? 0) + 1);
+    }
+    finalSymbols = finalSymbols.sort((a, b) => (connectionCount.get(b.id) ?? 0) - (connectionCount.get(a.id) ?? 0)).slice(0, maxNodes);
+    const remainingIds = new Set(finalSymbols.map((s) => s.id));
+    filteredEdges.splice(
+      0,
+      filteredEdges.length,
+      ...filteredEdges.filter((e) => remainingIds.has(e.source) && remainingIds.has(e.target))
+    );
+  }
+  const nodes = finalSymbols.map((s) => ({
+    id: s.id,
+    name: s.name,
+    filePath: s.filePath,
+    kind: s.kind,
+    line: s.startLine,
+    directory: path23.dirname(s.filePath),
+    moduleId: "",
+    moduleLabel: ""
+  }));
+  const modules = deriveModules(nodes);
+  const moduleEdges = deriveModuleEdges(nodes, filteredEdges);
+  return {
+    nodes,
+    edges: filteredEdges,
+    modules,
+    moduleEdges,
+    metadata: {
+      totalSymbols: symbols.length,
+      totalEdges: edges.length,
+      truncated,
+      directory,
+      moduleCount: modules.length
+    }
+  };
+}
+
+// src/cli.ts
+function parseArgs(argv) {
+  let project = process.cwd();
+  let config;
+  let host = "opencode";
+  for (let i = 2; i < argv.length; i++) {
+    if (argv[i] === "--project" && argv[i + 1]) {
+      project = path24.resolve(argv[++i]);
+    } else if (argv[i] === "--config" && argv[i + 1]) {
+      config = path24.resolve(argv[++i]);
+    } else if (argv[i] === "--host" && argv[i + 1]) {
+      host = parseHostMode(argv[++i]);
+    } else if (argv[i] === "--host") {
+      host = parseHostMode(void 0);
+    }
+  }
+  return { project, config, host };
+}
+function loadCliRawConfig(args) {
+  return args.config ? loadConfigFile(args.config) : loadMergedConfig(args.project, args.host);
+}
+function parseVisualizeArgs(argv, cwd) {
+  let project = cwd;
+  let directory;
+  let includeOrphans = false;
+  let maxNodes = 5e3;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--project" && argv[i + 1]) {
+      project = path24.resolve(argv[++i]);
+    } else if (arg === "--max" && argv[i + 1]) {
+      maxNodes = Number(argv[++i]);
+    } else if (arg.startsWith("--max=") || arg.startsWith("max=")) {
+      maxNodes = Number(arg.split("=")[1]);
+    } else if (arg === "--orphans" || arg === "orphans" || arg === "--include-orphans" || arg === "include-orphans") {
+      includeOrphans = true;
+    } else if (!arg.startsWith("-") && directory === void 0) {
+      directory = arg;
+    }
+  }
+  if (!Number.isFinite(maxNodes) || maxNodes < 1) {
+    throw new Error("max must be a positive number");
+  }
+  return { directory, includeOrphans, maxNodes, project };
+}
+async function handleVisualizeCommand(argv, cwd) {
+  try {
+    const args = parseVisualizeArgs(argv, cwd);
+    const config = parseConfig(loadMergedConfig(args.project));
+    const indexer = new Indexer(args.project, config);
+    const rawData = await indexer.getVisualizationData({
+      directory: args.directory
+    });
+    if (rawData.symbols.length === 0) {
+      console.error("No call graph data found. Run /index in OpenCode first, then retry npm run visualize.");
+      return 1;
+    }
+    const vizData = attachRecentActivity(transformForVisualization(rawData.symbols, rawData.edges, {
+      includeOrphans: args.includeOrphans,
+      directory: args.directory,
+      maxNodes: args.maxNodes
+    }), args.project);
+    if (vizData.nodes.length === 0) {
+      console.error("No connected symbols found. Retry with: npm run visualize -- orphans");
+      return 1;
+    }
+    const outputPath = path24.join(os5.tmpdir(), `call-graph-${Date.now()}.html`);
+    writeFileSync6(outputPath, generateVisualizationHtml(vizData), "utf-8");
+    console.log(`Temporal call graph visualization generated: ${outputPath}`);
+    console.log(`Nodes: ${vizData.nodes.length} | Edges: ${vizData.edges.length}`);
+    console.log(`Recent change lenses: ${vizData.changes?.length ?? 0}`);
+    if (vizData.metadata.truncated) {
+      console.log(`Graph truncated to ${args.maxNodes} most-connected nodes.`);
+    }
+    return 0;
+  } catch {
+    console.error("Failed to generate visualization. Check the project, config, and arguments, then retry.");
+    return 1;
+  }
+}
+async function main() {
+  if (process.argv[2] === "eval") {
+    const exitCode = await handleEvalCommand(process.argv.slice(3), process.cwd());
+    process.exit(exitCode);
+  }
+  if (process.argv[2] === "visualize") {
+    const exitCode = await handleVisualizeCommand(process.argv.slice(3), process.cwd());
+    process.exit(exitCode);
+  }
+  const args = parseArgs(process.argv);
+  const rawConfig = loadCliRawConfig(args);
+  const config = parseConfig(rawConfig);
+  const server = createMcpServer(args.project, config, args.host);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  let watcher = null;
+  const isHomeDir = path24.resolve(args.project) === path24.resolve(os5.homedir());
+  const isValidProject = !isHomeDir && (!config.indexing.requireProjectMarker || hasProjectMarker(args.project));
+  if (config.indexing.autoIndex && isValidProject) {
+    const indexer = getIndexerForProject(args.project, args.host);
+    startAutoIndex(indexer, args.project);
+  }
+  if (config.indexing.watchFiles && isValidProject) {
+    watcher = createWatcherWithIndexer(
+      () => getIndexerForProject(args.project, args.host),
+      args.project,
+      config,
+      args.host,
+      args.config ? { configPath: args.config } : {}
+    );
+  }
+  const shutdown = () => {
+    watcher?.stop();
+    server.close().catch(() => {
     });
     process.exit(0);
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
 }
-main().catch((_error) => {
-  console.error("Fatal: failed to start MCP server (check config and network)");
+function handleMainError(error) {
+  if (error instanceof Error && error.message.startsWith("Invalid host mode")) {
+    console.error(`Invalid host mode. Allowed values: ${HOST_MODES.join(", ")}.`);
+    process.exit(1);
+  }
+  if (error instanceof Error) {
+    console.error("Failed to start MCP server. Check config and network.");
+    process.exit(1);
+  }
+  console.error("Fatal: failed to start MCP server");
   process.exit(1);
-});
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(path24.resolve(process.argv[1])).href) {
+  main().catch(handleMainError);
+}
+export {
+  loadCliRawConfig,
+  parseArgs
+};
+/*! Bundled license information:
+
+chokidar/index.js:
+  (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
+*/
 //# sourceMappingURL=cli.js.map