opencode-codebase-index 0.17.1 → 0.18.1

package/dist/index.cjs

@@ -680,7 +680,8 @@ var DEFAULT_INCLUDE = [
   "**/*.{sh,bash,zsh}",
   "**/*.{txt,html,htm}",
   "**/*.zig",
-  "**/*.gd"
+  "**/*.gd",
+  "**/*.metal"
 ];
 var DEFAULT_EXCLUDE = [
   "**/node_modules/**",
@@ -871,6 +872,9 @@ function isValidProvider(value) {
   return typeof value === "string" && Object.keys(EMBEDDING_MODELS).includes(value);
 }
 function isValidModel(value, provider) {
+  if (typeof value === "string" && provider === "ollama" && value.trim().length > 0) {
+    return true;
+  }
   return typeof value === "string" && Object.keys(EMBEDDING_MODELS[provider]).includes(value);
 }
 function isValidScope(value) {
@@ -1235,16 +1239,6 @@ function resolveWorktreeFallbackPath(projectRoot, relativePath) {
   const fallbackPath = path3.join(mainRepoRoot, relativePath);
   return (0, import_fs3.existsSync)(fallbackPath) ? fallbackPath : null;
 }
-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 getHostProjectConfigRelativePath(host) {
   return getProjectConfigRelativePath(host);
 }
@@ -1349,6 +1343,9 @@ function resolveProjectIndexPath(projectRoot, scope, host = "opencode") {
   if (hasHostProjectConfig(projectRoot, host)) {
     return localIndexPath;
   }
+  if (resolveWorktreeMainRepoRoot(projectRoot)) {
+    return localIndexPath;
+  }
   const hostFallback = resolveWorktreeFallbackPath(projectRoot, getProjectIndexRelativePath(host));
   if (hostFallback) {
     return hostFallback;
@@ -1521,12 +1518,6 @@ function loadJsonFile(filePath) {
 function loadConfigFile(filePath) {
   return loadJsonFile(filePath);
 }
-function materializeLocalProjectConfig(projectRoot, config, host = "opencode") {
-  const localConfigPath = resolveWritableProjectConfigPath(projectRoot, host);
-  (0, import_fs4.mkdirSync)(path6.dirname(localConfigPath), { recursive: true });
-  (0, import_fs4.writeFileSync)(localConfigPath, JSON.stringify(config, null, 2), "utf-8");
-  return localConfigPath;
-}
 function loadProjectConfigLayer(projectRoot, host = "opencode") {
   const projectConfigPath = resolveProjectConfigPath(projectRoot, host);
   const projectConfig = loadJsonFile(projectConfigPath);
@@ -1955,40 +1946,6 @@ function releaseIndexLock(lease) {
   }
   return true;
 }
-async function withIndexLock(indexPath, operation, callback, options = {}) {
-  const lease = acquireIndexLock(indexPath, operation);
-  let result;
-  let callbackError;
-  let callbackFailed = false;
-  try {
-    result = await callback(lease);
-  } catch (error) {
-    callbackFailed = true;
-    callbackError = error;
-  }
-  if (!callbackFailed && options.completeRecoveries !== false) {
-    try {
-      completeLeaseRecovery(lease);
-    } catch (error) {
-      callbackFailed = true;
-      callbackError = error;
-    }
-  }
-  let releaseError;
-  try {
-    if (!releaseIndexLock(lease)) {
-      releaseError = new Error(`Lost ownership of index mutation lease ${lease.owner.token}`);
-    }
-  } catch (error) {
-    releaseError = error;
-  }
-  if (releaseError !== void 0) {
-    if (callbackFailed) throw new AggregateError([callbackError, releaseError], "Index mutation and lease release both failed");
-    throw releaseError;
-  }
-  if (callbackFailed) throw callbackError;
-  return result;
-}
 function createLeaseTemporaryPath(targetPath, owner, kind = "tmp") {
   if (kind === "bak") return `${targetPath}.bak.${owner.pid}.${owner.token}`;
   temporaryCounter += 1;
@@ -3095,6 +3052,9 @@ function loadOpenCodeAuth() {
   return {};
 }
 async function detectEmbeddingProvider(preferredProvider, model) {
+  if (preferredProvider === "ollama") {
+    return detectOllamaProvider(model);
+  }
   const credentials = await getProviderCredentials(preferredProvider);
   if (credentials) {
     if (!model) {
@@ -3110,10 +3070,16 @@ async function detectEmbeddingProvider(preferredProvider, model) {
       );
     }
     const providerModels = EMBEDDING_MODELS[preferredProvider];
+    const modelInfo = Object.values(providerModels).find((candidate) => candidate.model === model);
+    if (!modelInfo) {
+      throw new Error(
+        `Model '${model}' is not supported by provider '${preferredProvider}'`
+      );
+    }
     return {
       provider: preferredProvider,
       credentials,
-      modelInfo: providerModels[model]
+      modelInfo
     };
   }
   throw new Error(
@@ -3122,6 +3088,13 @@ async function detectEmbeddingProvider(preferredProvider, model) {
 }
 async function tryDetectProvider() {
   for (const provider of autoDetectProviders) {
+    if (provider === "ollama") {
+      const ollamaProvider = await tryDetectOllamaProvider();
+      if (ollamaProvider) {
+        return ollamaProvider;
+      }
+      continue;
+    }
     const credentials = await getProviderCredentials(provider);
     if (credentials) {
       return {
@@ -3189,32 +3162,105 @@ function getGoogleCredentials() {
   }
   return null;
 }
-async function getOllamaCredentials() {
-  const baseUrl = process.env.OLLAMA_HOST || "http://localhost:11434";
+async function fetchOllama(url, init) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 2e3);
   try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 2e3);
-    const response = await fetch(`${baseUrl}/api/tags`, {
-      signal: controller.signal
-    });
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
     clearTimeout(timeoutId);
+  }
+}
+async function getOllamaCredentials() {
+  const baseUrl = (process.env.OLLAMA_HOST || "http://localhost:11434").replace(/\/+$/, "");
+  try {
+    const response = await fetchOllama(`${baseUrl}/api/tags`);
     if (response.ok) {
-      const data = await response.json();
-      const hasEmbeddingModel = data.models?.some(
-        (m) => m.name.includes("nomic-embed") || m.name.includes("mxbai-embed") || m.name.includes("all-minilm")
-      );
-      if (hasEmbeddingModel) {
-        return {
-          provider: "ollama",
-          baseUrl
-        };
-      }
+      return {
+        provider: "ollama",
+        baseUrl
+      };
     }
   } catch {
     return null;
   }
   return null;
 }
+function findCatalogOllamaModel(model) {
+  const stableName = model.endsWith(":latest") ? model.slice(0, -":latest".length) : model;
+  return Object.values(EMBEDDING_MODELS.ollama).find((candidate) => candidate.model === stableName) ?? null;
+}
+function getPositiveIntegerMetadata(modelInfo, suffix) {
+  const values = Object.entries(modelInfo).filter(([key]) => key.endsWith(suffix)).map(([, value]) => value).filter((value) => typeof value === "number" && Number.isInteger(value) && value > 0);
+  return values.length === 1 ? values[0] : null;
+}
+async function fetchOllamaModelInfo(credentials, model) {
+  const response = await fetchOllama(`${credentials.baseUrl}/api/show`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ model })
+  });
+  if (!response.ok) {
+    return null;
+  }
+  const data = await response.json();
+  if (!data.capabilities?.includes("embedding") || !data.model_info) {
+    return null;
+  }
+  const dimensions = getPositiveIntegerMetadata(data.model_info, ".embedding_length");
+  const maxTokens = getPositiveIntegerMetadata(data.model_info, ".context_length");
+  if (!dimensions || !maxTokens) {
+    return null;
+  }
+  return {
+    provider: "ollama",
+    model,
+    dimensions,
+    maxTokens,
+    costPer1MTokens: 0
+  };
+}
+async function listOllamaModels(credentials) {
+  const response = await fetchOllama(`${credentials.baseUrl}/api/tags`);
+  if (!response.ok) {
+    return [];
+  }
+  const data = await response.json();
+  return [...new Set((data.models ?? []).map((entry) => entry.name ?? entry.model).filter((name) => typeof name === "string" && name.trim().length > 0))];
+}
+async function detectOllamaProvider(model) {
+  const credentials = await getOllamaCredentials();
+  if (!credentials) {
+    throw new Error("Preferred provider 'ollama' is not configured or authenticated");
+  }
+  const requestedModel = model?.trim();
+  if (requestedModel) {
+    const catalogModel = findCatalogOllamaModel(requestedModel);
+    if (catalogModel) {
+      return { provider: "ollama", credentials, modelInfo: catalogModel };
+    }
+  }
+  const candidates = requestedModel ? [requestedModel] : await listOllamaModels(credentials);
+  for (const candidate of candidates) {
+    const modelInfo = await fetchOllamaModelInfo(credentials, candidate);
+    if (modelInfo) {
+      return {
+        provider: "ollama",
+        credentials,
+        modelInfo: findCatalogOllamaModel(candidate) ?? modelInfo
+      };
+    }
+  }
+  const detail = model ? `Model '${model}' is not installed or is not embedding-capable` : "No installed embedding-capable Ollama model was found";
+  throw new Error(detail);
+}
+async function tryDetectOllamaProvider() {
+  try {
+    return await detectOllamaProvider();
+  } catch {
+    return null;
+  }
+}
 function getProviderDisplayName(provider) {
   switch (provider) {
     case "github-copilot":
@@ -3554,6 +3600,7 @@ var GoogleEmbeddingProvider = class _GoogleEmbeddingProvider extends BaseEmbeddi
 // src/embeddings/providers/ollama.ts
 var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddingProvider {
   static MIN_TRUNCATION_CHARS = 512;
+  static REQUEST_TIMEOUT_MS = 12e4;
   constructor(credentials, modelInfo) {
     super(credentials, modelInfo);
   }
@@ -3628,22 +3675,45 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddi
     }
   }
   async embedSingle(text) {
-    const response = await fetch(`${this.credentials.baseUrl}/api/embeddings`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        model: this.modelInfo.model,
-        prompt: text,
-        truncate: false
-      })
-    });
+    const controller = new AbortController();
+    const timeout = setTimeout(
+      () => controller.abort(),
+      _OllamaEmbeddingProvider.REQUEST_TIMEOUT_MS
+    );
+    let response;
+    try {
+      response = await fetch(`${this.credentials.baseUrl}/api/embeddings`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model: this.modelInfo.model,
+          prompt: text,
+          truncate: false
+        }),
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(
+          `Ollama embedding request timed out after ${_OllamaEmbeddingProvider.REQUEST_TIMEOUT_MS}ms`
+        );
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
     if (!response.ok) {
       const error = (await response.text()).slice(0, 500);
       throw new Error(`Ollama embedding API error: ${response.status} - ${error}`);
     }
     const data = await response.json();
+    if (!Array.isArray(data.embedding) || data.embedding.length !== this.modelInfo.dimensions || data.embedding.some((value) => typeof value !== "number" || !Number.isFinite(value))) {
+      throw new Error(
+        `Ollama returned an invalid embedding; expected ${this.modelInfo.dimensions} finite dimensions`
+      );
+    }
     return {
       embedding: data.embedding,
       tokensUsed: this.estimateTokens(text)
@@ -4507,7 +4577,9 @@ function mapChunk(c) {
   return {
     content: c.content,
     startLine: c.startLine ?? c.start_line,
+    startCol: c.startCol ?? c.start_col,
     endLine: c.endLine ?? c.end_line,
+    endCol: c.endCol ?? c.end_col,
     chunkType: c.chunkType ?? c.chunk_type,
     name: c.name ?? void 0,
     language: c.language
@@ -4628,6 +4700,7 @@ function getEmbeddingHeaderParts(chunk, filePath) {
     javascript: "JavaScript",
     python: "Python",
     rust: "Rust",
+    swift: "Swift",
     go: "Go",
     java: "Java"
   };
@@ -4636,7 +4709,16 @@ function getEmbeddingHeaderParts(chunk, filePath) {
     function: "function",
     arrow_function: "arrow function",
     method_definition: "method",
+    method_declaration: "method",
+    protocol_function_declaration: "protocol requirement",
+    init_declaration: "initializer",
+    deinit_declaration: "deinitializer",
+    subscript_declaration: "subscript",
     class_declaration: "class",
+    actor_declaration: "actor",
+    extension_declaration: "extension",
+    protocol_declaration: "protocol",
+    struct_declaration: "struct",
     interface_declaration: "interface",
     type_alias_declaration: "type alias",
     enum_declaration: "enum",
@@ -5307,8 +5389,18 @@ async function getChunkGitBlame(projectRoot, filePath, startLine, endLine) {
 }
 
 // src/indexer/index.ts
-var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "php", "apex", "zig", "gdscript", "matlab", "bash"]);
-var CASE_INSENSITIVE_LANGUAGES = /* @__PURE__ */ new Set(["apex"]);
+var CALL_GRAPH_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx", "python", "go", "rust", "swift", "php", "apex", "zig", "gdscript", "matlab", "bash", "c", "cpp", "metal"]);
+var CASE_INSENSITIVE_LANGUAGES = /* @__PURE__ */ new Set(["apex", "php"]);
+var CALL_GRAPH_RESOLUTION_VERSION = "4";
+var PHP_FUNCTION_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "function",
+  "function_definition"
+]);
+var PHP_CLASS_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
+  "class_declaration",
+  "class_definition"
+]);
 var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "function_declaration",
   "function",
@@ -5321,6 +5413,9 @@ var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "enum_declaration",
   "function_definition",
   "class_definition",
+  "class_specifier",
+  "struct_specifier",
+  "namespace_definition",
   "decorated_definition",
   "method_declaration",
   "type_declaration",
@@ -5336,6 +5431,14 @@ var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "test_declaration",
   "struct_declaration",
   "union_declaration",
+  // Synthetic Swift declarations or declarations specific to tree-sitter-swift.
+  "actor_declaration",
+  "extension_declaration",
+  "protocol_declaration",
+  "protocol_function_declaration",
+  "init_declaration",
+  "deinit_declaration",
+  "subscript_declaration",
   // GDScript declarations whose names participate in the call graph.
   // `function_definition` and `class_definition` are already in the set
   // above (shared with Python/C/Bash and Python, respectively).
@@ -5345,6 +5448,53 @@ var CALL_GRAPH_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
   "const_statement",
   "class_name_statement"
 ]);
+var C_FAMILY_TYPE_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set(["class_specifier", "struct_specifier"]);
+function isCompatibleCFamilyCallTarget(language, callType, symbolKind) {
+  if (language !== "c" && language !== "cpp") return true;
+  if (symbolKind === "namespace_definition") return callType === "Import";
+  const isTypeSymbol = C_FAMILY_TYPE_SYMBOL_CHUNK_TYPES.has(symbolKind);
+  if (callType === "Constructor" || callType === "Inherits" || callType === "Implements") {
+    return isTypeSymbol;
+  }
+  return !isTypeSymbol;
+}
+var EXECUTABLE_SYMBOL_CHUNK_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "function",
+  "arrow_function",
+  "method_definition",
+  "function_definition",
+  "method_declaration",
+  "function_item",
+  "protocol_function_declaration",
+  "init_declaration",
+  "deinit_declaration",
+  "subscript_declaration",
+  "constructor_definition",
+  "trigger_declaration",
+  "test_declaration"
+]);
+function findEnclosingSymbol(symbols, line, column) {
+  let best;
+  for (const symbol of symbols) {
+    if (line < symbol.startLine || line > symbol.endLine) continue;
+    if (column !== void 0 && (line === symbol.startLine && column < symbol.startCol || line === symbol.endLine && column >= symbol.endCol)) {
+      continue;
+    }
+    if (!best) {
+      best = symbol;
+      continue;
+    }
+    const span = symbol.endLine - symbol.startLine;
+    const bestSpan = best.endLine - best.startLine;
+    const isNarrowerPositionRange = column !== void 0 && span === bestSpan && symbol.startLine === best.startLine && symbol.endLine === best.endLine && symbol.startCol >= best.startCol && symbol.endCol <= best.endCol && (symbol.startCol > best.startCol || symbol.endCol < best.endCol);
+    const isMoreSpecificTie = span === bestSpan && symbol.startLine === best.startLine && EXECUTABLE_SYMBOL_CHUNK_TYPES.has(symbol.kind) && !EXECUTABLE_SYMBOL_CHUNK_TYPES.has(best.kind);
+    if (span < bestSpan || span === bestSpan && symbol.startLine > best.startLine || isNarrowerPositionRange || isMoreSpecificTie) {
+      best = symbol;
+    }
+  }
+  return best;
+}
 function float32ArrayToBuffer(arr) {
   const float32 = new Float32Array(arr);
   return Buffer.from(float32.buffer);
@@ -5429,6 +5579,8 @@ function hasBlameMetadata(metadata) {
 }
 var INDEX_METADATA_VERSION = "1";
 var EMBEDDING_STRATEGY_VERSION = "2";
+var SWIFT_PARSER_VERSION = "1";
+var METAL_PARSER_VERSION = "1";
 var RANKING_TOKEN_CACHE_LIMIT = 4096;
 var RANK_HYBRID_CACHE_LIMIT = 256;
 function createPendingChunkStorageText(texts) {
@@ -5751,15 +5903,25 @@ function chunkTypeBoost(chunkType) {
     case "function_declaration":
     case "method":
     case "method_definition":
+    case "method_declaration":
+    case "protocol_function_declaration":
+    case "init_declaration":
+    case "deinit_declaration":
+    case "subscript_declaration":
     case "class":
     case "class_declaration":
+    case "actor_declaration":
+    case "extension_declaration":
       return 0.2;
     case "interface":
     case "type":
     case "enum":
+    case "enum_declaration":
     case "struct":
+    case "struct_declaration":
     case "impl":
     case "trait":
+    case "protocol_declaration":
     case "module":
       return 0.1;
     default:
@@ -5866,11 +6028,21 @@ function isImplementationChunkType(chunkType) {
     "function_declaration",
     "method",
     "method_definition",
+    "method_declaration",
+    "protocol_function_declaration",
+    "init_declaration",
+    "deinit_declaration",
+    "subscript_declaration",
     "class",
     "class_declaration",
+    "actor_declaration",
+    "extension_declaration",
     "interface",
+    "protocol_declaration",
     "type",
     "enum",
+    "enum_declaration",
+    "struct_declaration",
     "module"
   ].includes(chunkType);
 }
@@ -6873,6 +7045,29 @@ var Indexer = class {
     const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
     return `index.forceReembed.${projectHash}`;
   }
+  getCallGraphResolutionMetadataKey() {
+    if (this.config.scope !== "global") {
+      return "index.callGraphResolutionVersion";
+    }
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    return `index.callGraphResolutionVersion.${projectHash}`;
+  }
+  getSwiftParserVersionMetadataKey() {
+    const key = "index.parser.swiftVersion";
+    if (this.config.scope !== "global") {
+      return key;
+    }
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    return `${key}.${projectHash}`;
+  }
+  getMetalParserVersionMetadataKey() {
+    const key = "index.parser.metalVersion";
+    if (this.config.scope !== "global") {
+      return key;
+    }
+    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    return `${key}.${projectHash}`;
+  }
   hasProjectForceReembedPending() {
     return this.config.scope === "global" && this.database?.getMetadata(this.getProjectForceReembedMetadataKey()) === "true";
   }
@@ -8033,6 +8228,7 @@ var Indexer = class {
     this.database.setMetadata("index.embeddingProvider", provider.provider);
     this.database.setMetadata("index.embeddingModel", provider.modelInfo.model);
     this.database.setMetadata("index.embeddingDimensions", provider.modelInfo.dimensions.toString());
+    this.database.setMetadata(this.getCallGraphResolutionMetadataKey(), CALL_GRAPH_RESOLUTION_VERSION);
     if (this.config.scope === "global") {
       if (completeProjectEmbeddingStrategyReset) {
         this.database.setMetadata(this.getProjectEmbeddingStrategyMetadataKey(), EMBEDDING_STRATEGY_VERSION);
@@ -8220,6 +8416,20 @@ var Indexer = class {
       totalChunks: 0
     });
     this.loadFileHashCache();
+    const swiftParserMetadataKey = this.getSwiftParserVersionMetadataKey();
+    const reparseCachedSwiftFiles = database.getMetadata(swiftParserMetadataKey) !== SWIFT_PARSER_VERSION;
+    const metalParserMetadataKey = this.getMetalParserVersionMetadataKey();
+    const reparseCachedMetalFiles = database.getMetadata(metalParserMetadataKey) !== METAL_PARSER_VERSION;
+    if (reparseCachedSwiftFiles && Array.from(this.fileHashCache.keys()).some(
+      (filePath) => path13.extname(filePath).toLowerCase() === ".swift"
+    )) {
+      this.logger.info("Reindexing cached Swift files for parser support");
+    }
+    if (reparseCachedMetalFiles && Array.from(this.fileHashCache.keys()).some(
+      (filePath) => path13.extname(filePath).toLowerCase() === ".metal"
+    )) {
+      this.logger.info("Reindexing cached Metal files for parser support");
+    }
     const includePatterns = [...this.config.include, ...this.config.additionalInclude];
     const { files, skipped } = await collectFiles(
       this.projectRoot,
@@ -8239,10 +8449,17 @@ var Indexer = class {
     const changedFiles = [];
     const unchangedFilePaths = /* @__PURE__ */ new Set();
     const currentFileHashes = /* @__PURE__ */ new Map();
+    const needsCallGraphResolutionMigration = database.getMetadata(this.getCallGraphResolutionMetadataKey()) !== CALL_GRAPH_RESOLUTION_VERSION;
     for (const f of files) {
       const currentHash = hashFile(f.path);
       currentFileHashes.set(f.path, currentHash);
-      if (this.fileHashCache.get(f.path) === currentHash) {
+      const cachedHashMatches = this.fileHashCache.get(f.path) === currentHash;
+      const needsCallGraphRefresh = cachedHashMatches && needsCallGraphResolutionMigration && database.getChunksByFile(f.path).some(
+        (chunk) => chunk.language === "php" || chunk.language === "c" || chunk.language === "cpp"
+      );
+      const requiresSwiftParserUpgrade = reparseCachedSwiftFiles && path13.extname(f.path).toLowerCase() === ".swift";
+      const requiresMetalParserUpgrade = reparseCachedMetalFiles && path13.extname(f.path).toLowerCase() === ".metal";
+      if (cachedHashMatches && !needsCallGraphRefresh && !requiresSwiftParserUpgrade && !requiresMetalParserUpgrade) {
         unchangedFilePaths.add(f.path);
         this.logger.recordCacheHit();
       } else {
@@ -8444,16 +8661,28 @@ var Indexer = class {
       const fileSymbols = [];
       for (const chunk of parsed.chunks) {
         if (!chunk.name || !CALL_GRAPH_SYMBOL_CHUNK_TYPES.has(chunk.chunkType)) continue;
-        const symbolId = `sym_${hashContent(parsed.path + ":" + chunk.name + ":" + chunk.chunkType + ":" + chunk.startLine).slice(0, 16)}`;
+        const existingMetalSymbol = chunk.language === "metal" ? fileSymbols.find(
+          (symbol2) => symbol2.name === chunk.name && symbol2.kind === chunk.chunkType && symbol2.startLine <= chunk.endLine && chunk.startLine <= symbol2.endLine
+        ) : void 0;
+        if (existingMetalSymbol) {
+          existingMetalSymbol.startLine = Math.min(existingMetalSymbol.startLine, chunk.startLine);
+          existingMetalSymbol.endLine = Math.max(existingMetalSymbol.endLine, chunk.endLine);
+          existingMetalSymbol.startCol = Math.min(existingMetalSymbol.startCol, chunk.startCol ?? 0);
+          existingMetalSymbol.endCol = Math.max(existingMetalSymbol.endCol, chunk.endCol ?? 0);
+          continue;
+        }
+        const symbolId = `sym_${hashContent(
+          parsed.path + ":" + chunk.name + ":" + chunk.chunkType + ":" + chunk.startLine + ":" + (chunk.startCol ?? 0)
+        ).slice(0, 16)}`;
         const symbol = {
           id: symbolId,
           filePath: parsed.path,
           name: chunk.name,
           kind: chunk.chunkType,
           startLine: chunk.startLine,
-          startCol: 0,
+          startCol: chunk.startCol ?? 0,
           endLine: chunk.endLine,
-          endCol: 0,
+          endCol: chunk.endCol ?? 0,
           language: chunk.language
         };
         fileSymbols.push(symbol);
@@ -8478,8 +8707,10 @@ var Indexer = class {
       if (callSites.length === 0) continue;
       const edges = [];
       for (const site of callSites) {
-        const enclosingSymbol = fileSymbols.find(
-          (sym) => site.line >= sym.startLine && site.line <= sym.endLine
+        const enclosingSymbol = findEnclosingSymbol(
+          fileSymbols,
+          site.line,
+          site.column
         );
         if (!enclosingSymbol) continue;
         const edgeId = `edge_${hashContent(enclosingSymbol.id + ":" + site.calleeName + ":" + site.line + ":" + site.column).slice(0, 16)}`;
@@ -8498,7 +8729,21 @@ var Indexer = class {
       if (edges.length > 0) {
         database.upsertCallEdgesBatch(edges);
         for (const edge of edges) {
-          const candidates = symbolsByName.get(normalizeSymbolKey(edge.targetName));
+          let candidates = symbolsByName.get(normalizeSymbolKey(edge.targetName));
+          if (fileLanguage === "php" && candidates) {
+            if (edge.callType === "Constructor") {
+              candidates = candidates.filter(
+                (candidate) => PHP_CLASS_SYMBOL_CHUNK_TYPES.has(candidate.kind)
+              );
+            } else if (edge.callType === "Call") {
+              candidates = candidates.filter(
+                (candidate) => PHP_FUNCTION_SYMBOL_CHUNK_TYPES.has(candidate.kind)
+              );
+            }
+          }
+          candidates = candidates?.filter(
+            (symbol) => isCompatibleCFamilyCallTarget(fileLanguage, edge.callType, symbol.kind)
+          );
           if (candidates && candidates.length === 1) {
             database.resolveCallEdge(edge.id, candidates[0].id);
           }
@@ -8553,6 +8798,8 @@ var Indexer = class {
         this.saveFileHashCache();
         this.saveFailedBatches([]);
       }
+      database.setMetadata(swiftParserMetadataKey, SWIFT_PARSER_VERSION);
+      database.setMetadata(metalParserMetadataKey, METAL_PARSER_VERSION);
       this.saveIndexMetadata(configuredProviderInfo);
       this.indexCompatibility = { compatible: true };
       stats.durationMs = Date.now() - startTime;
@@ -8580,6 +8827,8 @@ var Indexer = class {
         this.saveFileHashCache();
         this.saveFailedBatches([]);
       }
+      database.setMetadata(swiftParserMetadataKey, SWIFT_PARSER_VERSION);
+      database.setMetadata(metalParserMetadataKey, METAL_PARSER_VERSION);
       this.saveIndexMetadata(configuredProviderInfo);
       this.indexCompatibility = { compatible: true };
       stats.durationMs = Date.now() - startTime;
@@ -8850,6 +9099,8 @@ var Indexer = class {
     if (forceScopedReembed && failedForcedChunkIds.size === 0) {
       database.deleteMetadata(this.getProjectForceReembedMetadataKey());
     }
+    database.setMetadata(swiftParserMetadataKey, SWIFT_PARSER_VERSION);
+    database.setMetadata(metalParserMetadataKey, METAL_PARSER_VERSION);
     this.saveIndexMetadata(configuredProviderInfo);
     this.indexCompatibility = { compatible: true };
     this.logger.recordIndexingEnd();
@@ -10510,15 +10761,6 @@ function refreshIndexerForDirectory(projectRoot, host = "opencode", config = par
   indexerCache.set(key, indexer);
   configCache.set(key, config);
 }
-function shouldForceLocalizeProjectIndex(projectRoot, host = "opencode") {
-  const root = getProjectRoot(projectRoot, host);
-  const localIndexPath = path16.join(root, getHostProjectIndexRelativePath(host));
-  if ((0, import_fs10.existsSync)(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, {
@@ -10568,9 +10810,7 @@ async function getCallGraphPath(projectRoot, host, from, to, maxDepth) {
 }
 async function runIndexCodebase(projectRoot, host, args, onProgress) {
   const root = getProjectRoot(projectRoot, host);
-  const key = getIndexerCacheKey(root, host);
-  let indexer = getIndexerForProject(root, host);
-  const runtimeConfig = configCache.get(key);
+  const indexer = getIndexerForProject(root, host);
   try {
     if (args.estimateOnly) {
       return { kind: "estimate", estimate: await indexer.estimateCost() };
@@ -10591,19 +10831,7 @@ async function runIndexCodebase(projectRoot, host, args, onProgress) {
         return Promise.resolve();
       });
     };
-    let stats;
-    if (args.force && shouldForceLocalizeProjectIndex(root, host)) {
-      const inheritedIndexPath = resolveProjectIndexPath(root, runtimeConfig.scope, host);
-      stats = await withIndexLock(inheritedIndexPath, "force-index", async () => {
-        materializeLocalProjectConfig(root, loadProjectConfigLayer(root, host), host);
-        refreshIndexerForDirectory(root, host, runtimeConfig);
-        indexer = getIndexerForProject(root, host);
-        return runIndex(indexer);
-      }, { completeRecoveries: false });
-    } else {
-      stats = await runIndex(indexer);
-    }
-    return { kind: "stats", stats };
+    return { kind: "stats", stats: await runIndex(indexer) };
   } catch (error) {
     const busyResult = getIndexBusyResult(error);
     if (!busyResult) throw error;
@@ -12892,11 +13120,12 @@ function getConfigPaths(projectRoot, host, options) {
   ].map((configPath) => pathNormalize(configPath));
 }
 
-// src/tools/index.ts
-var import_plugin2 = require("@opencode-ai/plugin");
-
-// src/tools/pr-impact.ts
-var import_plugin = require("@opencode-ai/plugin");
+// node_modules/@opencode-ai/plugin/dist/tool.js
+var import_zod = require("zod");
+function tool(input) {
+  return input;
+}
+tool.schema = import_zod.z;
 
 // src/tools/format-pr-impact.ts
 function formatPrImpact(result) {
@@ -12950,16 +13179,16 @@ function formatPrImpact(result) {
 }
 
 // src/tools/pr-impact.ts
-var z = import_plugin.tool.schema;
-var pr_impact = (0, import_plugin.tool)({
+var z2 = tool.schema;
+var pr_impact = tool({
   description: "Analyze the impact of a pull request or branch by examining changed files, affected symbols, transitive callers, communities touched, hub nodes, and risk level. Use to understand blast radius before merging.",
   args: {
-    pr: z.number().optional().describe("Pull request number to analyze"),
-    branch: z.string().optional().describe("Branch name to analyze (defaults to current branch)"),
-    maxDepth: z.number().optional().default(5).describe("Maximum traversal depth for transitive callers (default: 5)"),
-    hubThreshold: z.number().optional().default(10).describe("Minimum caller count to flag a symbol as a hub node (default: 10)"),
-    checkConflicts: z.boolean().optional().default(false).describe("Check for conflicting open PRs touching the same communities (default: false)"),
-    direction: z.enum(["callers", "callees", "both"]).optional().default("both").describe("Call-graph traversal direction: 'callers' for upstream, 'callees' for downstream, 'both' for union (default: both)")
+    pr: z2.number().optional().describe("Pull request number to analyze"),
+    branch: z2.string().optional().describe("Branch name to analyze (defaults to current branch)"),
+    maxDepth: z2.number().optional().default(5).describe("Maximum traversal depth for transitive callers (default: 5)"),
+    hubThreshold: z2.number().optional().default(10).describe("Minimum caller count to flag a symbol as a hub node (default: 10)"),
+    checkConflicts: z2.boolean().optional().default(false).describe("Check for conflicting open PRs touching the same communities (default: false)"),
+    direction: z2.enum(["callers", "callees", "both"]).optional().default("both").describe("Call-graph traversal direction: 'callers' for upstream, 'callees' for downstream, 'both' for union (default: both)")
   },
   async execute(args, context) {
     const indexer = getIndexerForProject2(context?.worktree);
@@ -13936,7 +14165,7 @@ function transformForVisualization(symbols, edges, options = {}) {
 }
 
 // src/tools/index.ts
-var z2 = import_plugin2.tool.schema;
+var z3 = tool.schema;
 var DEFAULT_HOST = "opencode";
 var CHUNK_TYPE_VALUES = [
   "function",
@@ -13958,34 +14187,34 @@ function initializeTools2(projectRoot, config) {
 function getIndexerForProject2(directory) {
   return getIndexerForProject(directory, DEFAULT_HOST);
 }
-var codebase_context = (0, import_plugin2.tool)({
+var codebase_context = tool({
   description: "PREFERRED FIRST TOOL for repository questions. Returns a deduplicated, file-diverse evidence pack within tokenBudget. Provide from and to for dependency paths, symbol for definitions, or only query for conceptual discovery.",
   args: {
-    query: z2.string().describe("The repository question or behavior to locate"),
-    from: z2.string().nullable().optional().describe("Source symbol for a dependency path"),
-    to: z2.string().nullable().optional().describe("Target symbol for a dependency path"),
-    symbol: z2.string().nullable().optional().describe("Exact symbol for authoritative definition lookup"),
-    limit: z2.number().int().min(MIN_CONTEXT_RESULT_LIMIT).max(MAX_CONTEXT_RESULT_LIMIT).nullable().optional().default(10).describe(`Maximum number of results (${MIN_CONTEXT_RESULT_LIMIT}-${MAX_CONTEXT_RESULT_LIMIT})`),
-    maxDepth: z2.number().int().min(MIN_CONTEXT_PATH_DEPTH).max(MAX_CONTEXT_PATH_DEPTH).nullable().optional().default(10).describe(`Maximum call-path traversal depth (${MIN_CONTEXT_PATH_DEPTH}-${MAX_CONTEXT_PATH_DEPTH})`),
-    fileType: z2.string().nullable().optional().describe("Filter by file extension"),
-    directory: z2.string().nullable().optional().describe("Filter by directory path"),
-    tokenBudget: z2.number().int().min(MIN_CONTEXT_PACK_TOKEN_BUDGET).max(MAX_CONTEXT_PACK_TOKEN_BUDGET).nullable().optional().default(DEFAULT_CONTEXT_PACK_TOKEN_BUDGET).describe(`Maximum response tokens (${MIN_CONTEXT_PACK_TOKEN_BUDGET}-${MAX_CONTEXT_PACK_TOKEN_BUDGET})`)
+    query: z3.string().describe("The repository question or behavior to locate"),
+    from: z3.string().nullable().optional().describe("Source symbol for a dependency path"),
+    to: z3.string().nullable().optional().describe("Target symbol for a dependency path"),
+    symbol: z3.string().nullable().optional().describe("Exact symbol for authoritative definition lookup"),
+    limit: z3.number().int().min(MIN_CONTEXT_RESULT_LIMIT).max(MAX_CONTEXT_RESULT_LIMIT).nullable().optional().default(10).describe(`Maximum number of results (${MIN_CONTEXT_RESULT_LIMIT}-${MAX_CONTEXT_RESULT_LIMIT})`),
+    maxDepth: z3.number().int().min(MIN_CONTEXT_PATH_DEPTH).max(MAX_CONTEXT_PATH_DEPTH).nullable().optional().default(10).describe(`Maximum call-path traversal depth (${MIN_CONTEXT_PATH_DEPTH}-${MAX_CONTEXT_PATH_DEPTH})`),
+    fileType: z3.string().nullable().optional().describe("Filter by file extension"),
+    directory: z3.string().nullable().optional().describe("Filter by directory path"),
+    tokenBudget: z3.number().int().min(MIN_CONTEXT_PACK_TOKEN_BUDGET).max(MAX_CONTEXT_PACK_TOKEN_BUDGET).nullable().optional().default(DEFAULT_CONTEXT_PACK_TOKEN_BUDGET).describe(`Maximum response tokens (${MIN_CONTEXT_PACK_TOKEN_BUDGET}-${MAX_CONTEXT_PACK_TOKEN_BUDGET})`)
   },
   async execute(args, context) {
     return (await resolveCodebaseContext(context?.worktree, DEFAULT_HOST, args)).text;
   }
 });
-var codebase_peek = (0, import_plugin2.tool)({
+var codebase_peek = tool({
   description: "Quick lookup of code locations by meaning. Returns only metadata (file, line, name, type) WITHOUT code content. Use this first to find WHERE code is, then use Read tool to examine specific files. Saves tokens by not returning full code blocks. Best for: discovery, navigation, finding multiple related locations.",
   args: {
-    query: z2.string().describe("Natural language description of what code you're looking for."),
-    limit: z2.number().optional().default(10).describe("Maximum number of results to return"),
-    fileType: z2.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
-    directory: z2.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
-    chunkType: z2.enum(CHUNK_TYPE_VALUES).optional().describe("Filter by code chunk type"),
-    blameAuthor: z2.string().optional().describe("Filter by git blame author name or email"),
-    blameSha: z2.string().optional().describe("Filter by git blame commit SHA or prefix"),
-    blameSince: z2.string().optional().describe("Filter to chunks last changed on or after this date (e.g., 2025-01-01)")
+    query: z3.string().describe("Natural language description of what code you're looking for."),
+    limit: z3.number().optional().default(10).describe("Maximum number of results to return"),
+    fileType: z3.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
+    directory: z3.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
+    chunkType: z3.enum(CHUNK_TYPE_VALUES).optional().describe("Filter by code chunk type"),
+    blameAuthor: z3.string().optional().describe("Filter by git blame author name or email"),
+    blameSha: z3.string().optional().describe("Filter by git blame commit SHA or prefix"),
+    blameSince: z3.string().optional().describe("Filter to chunks last changed on or after this date (e.g., 2025-01-01)")
   },
   async execute(args, context) {
     const results = await searchCodebase(context?.worktree, DEFAULT_HOST, args.query, {
@@ -14001,12 +14230,12 @@ var codebase_peek = (0, import_plugin2.tool)({
     return formatCodebasePeek(results);
   }
 });
-var index_codebase = (0, import_plugin2.tool)({
+var index_codebase = tool({
   description: "Index the codebase for semantic search. Creates vector embeddings of code chunks. Incremental - only re-indexes changed files (~50ms when nothing changed). Run before first codebase_search.",
   args: {
-    force: z2.boolean().optional().default(false).describe("Force reindex even if already indexed"),
-    estimateOnly: z2.boolean().optional().default(false).describe("Only show cost estimate without indexing"),
-    verbose: z2.boolean().optional().default(false).describe("Show detailed info about skipped files and parsing failures")
+    force: z3.boolean().optional().default(false).describe("Force reindex even if already indexed"),
+    estimateOnly: z3.boolean().optional().default(false).describe("Only show cost estimate without indexing"),
+    verbose: z3.boolean().optional().default(false).describe("Show detailed info about skipped files and parsing failures")
   },
   async execute(args, context) {
     const result = await runIndexCodebase(context?.worktree, DEFAULT_HOST, args, (title, metadata) => {
@@ -14017,14 +14246,14 @@ var index_codebase = (0, import_plugin2.tool)({
     return formatIndexStats(result.stats, args.verbose ?? false);
   }
 });
-var index_status = (0, import_plugin2.tool)({
+var index_status = tool({
   description: "Check the status of the codebase index. Shows whether the codebase is indexed, how many chunks are stored, and the embedding provider being used.",
   args: {},
   async execute(_args, context) {
     return formatStatus(await getIndexStatus(context?.worktree, DEFAULT_HOST));
   }
 });
-var index_health_check = (0, import_plugin2.tool)({
+var index_health_check = tool({
   description: "Check index health and remove stale entries from deleted files. Run this to clean up the index after files have been deleted.",
   args: {},
   async execute(_args, context) {
@@ -14033,33 +14262,33 @@ var index_health_check = (0, import_plugin2.tool)({
     return formatHealthCheck(result.health);
   }
 });
-var index_metrics = (0, import_plugin2.tool)({
+var index_metrics = tool({
   description: "Get metrics and performance statistics for the codebase index. Shows indexing stats, search timings, cache hit rates, and API usage. Requires debug.enabled=true and debug.metrics=true in config.",
   args: {},
   async execute(_args, context) {
     return (await getIndexMetrics(context?.worktree, DEFAULT_HOST)).text;
   }
 });
-var index_logs = (0, import_plugin2.tool)({
+var index_logs = tool({
   description: "Get recent debug logs from the codebase indexer. Shows timestamped log entries with level and category. Requires debug.enabled=true in config.",
   args: {
-    limit: z2.number().optional().default(20).describe("Maximum number of log entries to return"),
-    category: z2.enum(["search", "embedding", "cache", "gc", "branch", "general"]).optional().describe("Filter by log category"),
-    level: z2.enum(["error", "warn", "info", "debug"]).optional().describe("Filter by minimum log level")
+    limit: z3.number().optional().default(20).describe("Maximum number of log entries to return"),
+    category: z3.enum(["search", "embedding", "cache", "gc", "branch", "general"]).optional().describe("Filter by log category"),
+    level: z3.enum(["error", "warn", "info", "debug"]).optional().describe("Filter by minimum log level")
   },
   async execute(args, context) {
     return (await getIndexLogs(context?.worktree, DEFAULT_HOST, args)).text;
   }
 });
-var find_similar = (0, import_plugin2.tool)({
+var find_similar = tool({
   description: "Find code similar to a given snippet. Use for duplicate detection, pattern discovery, or refactoring prep. Paste code and find semantically similar implementations elsewhere in the codebase.",
   args: {
-    code: z2.string().describe("The code snippet to find similar code for"),
-    limit: z2.number().optional().default(10).describe("Maximum number of results to return"),
-    fileType: z2.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
-    directory: z2.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
-    chunkType: z2.enum(CHUNK_TYPE_VALUES).optional().describe("Filter by code chunk type"),
-    excludeFile: z2.string().optional().describe("Exclude results from this file path (useful when searching for duplicates of code from a specific file)")
+    code: z3.string().describe("The code snippet to find similar code for"),
+    limit: z3.number().optional().default(10).describe("Maximum number of results to return"),
+    fileType: z3.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
+    directory: z3.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
+    chunkType: z3.enum(CHUNK_TYPE_VALUES).optional().describe("Filter by code chunk type"),
+    excludeFile: z3.string().optional().describe("Exclude results from this file path (useful when searching for duplicates of code from a specific file)")
   },
   async execute(args, context) {
     const results = await findSimilarCode(context?.worktree, DEFAULT_HOST, args.code, {
@@ -14075,18 +14304,18 @@ var find_similar = (0, import_plugin2.tool)({
     return formatSearchResults(results);
   }
 });
-var codebase_search = (0, import_plugin2.tool)({
+var codebase_search = tool({
   description: "Search codebase by MEANING, not keywords. Returns full code content. Use when you need to see actual implementation. For just finding WHERE code is (saves ~90% tokens), use codebase_peek instead. For known identifiers like 'validateToken', use grep - it's faster.",
   args: {
-    query: z2.string().describe("Natural language description of what code you're looking for. Describe behavior, not syntax."),
-    limit: z2.number().optional().default(5).describe("Maximum number of results to return"),
-    fileType: z2.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
-    directory: z2.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
-    chunkType: z2.enum(CHUNK_TYPE_VALUES).optional().describe("Filter by code chunk type"),
-    contextLines: z2.number().optional().describe("Number of extra lines to include before/after each match (default: 0)"),
-    blameAuthor: z2.string().optional().describe("Filter by git blame author name or email"),
-    blameSha: z2.string().optional().describe("Filter by git blame commit SHA or prefix"),
-    blameSince: z2.string().optional().describe("Filter to chunks last changed on or after this date (e.g., 2025-01-01)")
+    query: z3.string().describe("Natural language description of what code you're looking for. Describe behavior, not syntax."),
+    limit: z3.number().optional().default(5).describe("Maximum number of results to return"),
+    fileType: z3.string().optional().describe("Filter by file extension (e.g., 'ts', 'py', 'rs')"),
+    directory: z3.string().optional().describe("Filter by directory path (e.g., 'src/utils', 'lib')"),
+    chunkType: z3.enum(CHUNK_TYPE_VALUES).optional().describe("Filter by code chunk type"),
+    contextLines: z3.number().optional().describe("Number of extra lines to include before/after each match (default: 0)"),
+    blameAuthor: z3.string().optional().describe("Filter by git blame author name or email"),
+    blameSha: z3.string().optional().describe("Filter by git blame commit SHA or prefix"),
+    blameSince: z3.string().optional().describe("Filter to chunks last changed on or after this date (e.g., 2025-01-01)")
   },
   async execute(args, context) {
     const results = await searchCodebase(context?.worktree, DEFAULT_HOST, args.query, {
@@ -14105,13 +14334,13 @@ var codebase_search = (0, import_plugin2.tool)({
     return formatSearchResults(results, "score");
   }
 });
-var implementation_lookup = (0, import_plugin2.tool)({
+var implementation_lookup = tool({
   description: "Jump to symbol definition. Find WHERE something is defined. Returns the authoritative source location(s) for a function, class, method, type, or variable. Prefers real implementation files over tests, docs, examples, and fixtures. Use when you need the definition site, not all usages.",
   args: {
-    query: z2.string().describe("Symbol name or natural language description (e.g., 'validateToken', 'where is the payment handler defined')"),
-    limit: z2.number().optional().default(5).describe("Maximum number of results"),
-    fileType: z2.string().optional().describe("Filter by file extension (e.g., 'ts', 'py')"),
-    directory: z2.string().optional().describe("Filter by directory path (e.g., 'src/utils')")
+    query: z3.string().describe("Symbol name or natural language description (e.g., 'validateToken', 'where is the payment handler defined')"),
+    limit: z3.number().optional().default(5).describe("Maximum number of results"),
+    fileType: z3.string().optional().describe("Filter by file extension (e.g., 'ts', 'py')"),
+    directory: z3.string().optional().describe("Filter by directory path (e.g., 'src/utils')")
   },
   async execute(args, context) {
     const results = await implementationLookup(context?.worktree, DEFAULT_HOST, args.query, {
@@ -14122,13 +14351,13 @@ var implementation_lookup = (0, import_plugin2.tool)({
     return formatDefinitionLookup(results, args.query);
   }
 });
-var call_graph = (0, import_plugin2.tool)({
+var call_graph = tool({
   description: "Query the call graph to find callers or callees of a function/method. Use to understand code flow and dependencies between functions. Supports relationship types: Call, MethodCall, Constructor, Import, Inherits, Implements.",
   args: {
-    name: z2.string().describe("Function or method name to query"),
-    direction: z2.enum(["callers", "callees"]).default("callers").describe("Direction: 'callers' finds who calls this function, 'callees' finds what this function calls"),
-    symbolId: z2.string().optional().describe("Symbol ID (required for 'callees' direction, returned by previous call_graph queries)"),
-    relationshipType: z2.enum(RELATIONSHIP_TYPE_VALUES).optional().describe("Filter by relationship type. Omit to show all.")
+    name: z3.string().describe("Function or method name to query"),
+    direction: z3.enum(["callers", "callees"]).default("callers").describe("Direction: 'callers' finds who calls this function, 'callees' finds what this function calls"),
+    symbolId: z3.string().optional().describe("Symbol ID (required for 'callees' direction, returned by previous call_graph queries)"),
+    relationshipType: z3.enum(RELATIONSHIP_TYPE_VALUES).optional().describe("Filter by relationship type. Omit to show all.")
   },
   async execute(args, context) {
     if (args.direction === "callees") {
@@ -14142,49 +14371,49 @@ var call_graph = (0, import_plugin2.tool)({
     return formatCallGraphCallers(args.name, callers, args.relationshipType);
   }
 });
-var call_graph_path = (0, import_plugin2.tool)({
+var call_graph_path = tool({
   description: "Find the shortest connection path between two symbols in the call graph. Given a source and target function/method name, returns the chain of calls connecting them.",
   args: {
-    from: z2.string().describe("Source function/method name (starting point)"),
-    to: z2.string().describe("Target function/method name (destination)"),
-    maxDepth: z2.number().optional().default(10).describe("Maximum traversal depth (default: 10)")
+    from: z3.string().describe("Source function/method name (starting point)"),
+    to: z3.string().describe("Target function/method name (destination)"),
+    maxDepth: z3.number().optional().default(10).describe("Maximum traversal depth (default: 10)")
   },
   async execute(args, context) {
     const path24 = await getCallGraphPath(context?.worktree, DEFAULT_HOST, args.from, args.to, args.maxDepth);
     return formatCallGraphPath(args.from, args.to, path24);
   }
 });
-var add_knowledge_base = (0, import_plugin2.tool)({
+var add_knowledge_base = tool({
   description: "Add a folder as a knowledge base to the semantic search index. The folder will be indexed alongside the main project code. Supports absolute paths or relative paths (relative to the project root).",
   args: {
-    path: z2.string().describe("Path to the folder to add as a knowledge base (absolute or relative to the project root)")
+    path: z3.string().describe("Path to the folder to add as a knowledge base (absolute or relative to the project root)")
   },
   async execute(args, context) {
     return addKnowledgeBase(context?.worktree, DEFAULT_HOST, args.path);
   }
 });
-var list_knowledge_bases = (0, import_plugin2.tool)({
+var list_knowledge_bases = tool({
   description: "List all configured knowledge base folders that are indexed alongside the main project.",
   args: {},
   async execute(_args, context) {
     return listKnowledgeBases(context?.worktree, DEFAULT_HOST);
   }
 });
-var remove_knowledge_base = (0, import_plugin2.tool)({
+var remove_knowledge_base = tool({
   description: "Remove a knowledge base folder from the semantic search index.",
   args: {
-    path: z2.string().describe("Path of the knowledge base to remove (must match the configured path exactly)")
+    path: z3.string().describe("Path of the knowledge base to remove (must match the configured path exactly)")
   },
   async execute(args, context) {
     return removeKnowledgeBase(context?.worktree, DEFAULT_HOST, args.path.trim());
   }
 });
-var index_visualize = (0, import_plugin2.tool)({
+var index_visualize = tool({
   description: "Generate an interactive HTML visualization of recent code movement and the call graph. Starts with temporal onboarding context from Git history, then supports module, symbol, hotspot, and cycle drill-down.",
   args: {
-    directory: z2.string().optional().describe("Filter to symbols in this directory (e.g., 'src/services')"),
-    maxNodes: z2.number().optional().default(5e3).describe("Maximum nodes to include (default 5000)"),
-    includeOrphans: z2.boolean().optional().default(false).describe("Include symbols with no call relationships")
+    directory: z3.string().optional().describe("Filter to symbols in this directory (e.g., 'src/services')"),
+    maxNodes: z3.number().optional().default(5e3).describe("Maximum nodes to include (default 5000)"),
+    includeOrphans: z3.boolean().optional().default(false).describe("Include symbols with no call relationships")
   },
   async execute(args, context) {
     const projectRoot = context?.worktree ?? process.cwd();