opencode-codebase-index 0.17.1 → 0.18.1

package/dist/pi-extension.js

@@ -668,7 +668,8 @@ var DEFAULT_INCLUDE = [
   "**/*.{sh,bash,zsh}",
   "**/*.{txt,html,htm}",
   "**/*.zig",
-  "**/*.gd"
+  "**/*.gd",
+  "**/*.metal"
 ];
 var DEFAULT_EXCLUDE = [
   "**/node_modules/**",
@@ -859,6 +860,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) {
@@ -1058,6 +1062,9 @@ function loadOpenCodeAuth() {
   return {};
 }
 async function detectEmbeddingProvider(preferredProvider, model) {
+  if (preferredProvider === "ollama") {
+    return detectOllamaProvider(model);
+  }
   const credentials = await getProviderCredentials(preferredProvider);
   if (credentials) {
     if (!model) {
@@ -1073,10 +1080,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(
@@ -1085,6 +1098,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 {
@@ -1152,32 +1172,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":
@@ -1330,10 +1423,6 @@ function formatPrImpact(result) {
 import { existsSync as existsSync10, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
 import * as path16 from "path";
 
-// src/config/merger.ts
-import { existsSync as existsSync5, mkdirSync, readFileSync as readFileSync4, writeFileSync } from "fs";
-import * as path7 from "path";
-
 // src/config/paths.ts
 import { existsSync as existsSync4 } from "fs";
 import * as os2 from "os";
@@ -1506,16 +1595,6 @@ function resolveWorktreeFallbackPath(projectRoot3, relativePath) {
   const fallbackPath = path4.join(mainRepoRoot, relativePath);
   return existsSync4(fallbackPath) ? fallbackPath : null;
 }
-function resolveWorktreeFallbackProjectIndexPath(projectRoot3, host) {
-  const inheritedHostPath = resolveWorktreeFallbackPath(projectRoot3, getProjectIndexRelativePath(host));
-  if (inheritedHostPath) {
-    return inheritedHostPath;
-  }
-  if (host !== "opencode") {
-    return resolveWorktreeFallbackPath(projectRoot3, OPENCODE_PROJECT_INDEX_RELATIVE_PATH);
-  }
-  return null;
-}
 function getHostProjectConfigRelativePath(host) {
   return getProjectConfigRelativePath(host);
 }
@@ -1620,6 +1699,9 @@ function resolveProjectIndexPath(projectRoot3, scope, host = "opencode") {
   if (hasHostProjectConfig(projectRoot3, host)) {
     return localIndexPath;
   }
+  if (resolveWorktreeMainRepoRoot(projectRoot3)) {
+    return localIndexPath;
+  }
   const hostFallback = resolveWorktreeFallbackPath(projectRoot3, getProjectIndexRelativePath(host));
   if (hostFallback) {
     return hostFallback;
@@ -1633,210 +1715,9 @@ function resolveProjectIndexPath(projectRoot3, scope, host = "opencode") {
   return localIndexPath;
 }
 
-// src/config/rebase.ts
-import * as path6 from "path";
-
-// src/utils/paths.ts
-import * as path5 from "path";
-function normalizePathSeparators(value) {
-  return value.replace(/\\/g, "/");
-}
-function isHiddenPathSegment(part) {
-  return part.startsWith(".") && part !== "." && part !== "..";
-}
-function isBuildPathSegment(part) {
-  return part.toLowerCase().includes("build");
-}
-
-// src/config/rebase.ts
-function isWithinRoot(rootDir, targetPath) {
-  const relativePath = path6.relative(rootDir, targetPath);
-  return relativePath === "" || !relativePath.startsWith("..") && !path6.isAbsolute(relativePath);
-}
-function resolveInheritedKnowledgeBaseEntries(values, sourceRoot, targetRoot) {
-  if (!Array.isArray(values)) {
-    return [];
-  }
-  return values.filter((value) => typeof value === "string").map((value) => {
-    const trimmed = value.trim();
-    if (!trimmed) {
-      return trimmed;
-    }
-    if (path6.isAbsolute(trimmed)) {
-      if (isWithinRoot(sourceRoot, trimmed)) {
-        return normalizePathSeparators(path6.normalize(path6.relative(sourceRoot, trimmed) || "."));
-      }
-      return path6.normalize(trimmed);
-    }
-    const resolvedFromSource = path6.resolve(sourceRoot, trimmed);
-    if (isWithinRoot(sourceRoot, resolvedFromSource)) {
-      return normalizePathSeparators(path6.normalize(trimmed));
-    }
-    return normalizePathSeparators(path6.normalize(path6.relative(targetRoot, resolvedFromSource)));
-  }).filter(Boolean);
-}
-
-// src/config/merger.ts
-var PROJECT_OVERRIDE_KEYS = [
-  "embeddingProvider",
-  "customProvider",
-  "embeddingModel",
-  "reranker",
-  "include",
-  "exclude",
-  "indexing",
-  "search",
-  "debug",
-  "scope"
-];
-var MERGE_ARRAY_KEYS = ["knowledgeBases", "additionalInclude"];
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isStringArray2(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 = path7.normalize(String(value).trim());
-  const root = path7.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 (!isRecord(rawConfig)) {
-    throw new Error(`Config file ${filePath} must contain a JSON object at the root.`);
-  }
-  if (rawConfig.knowledgeBases !== void 0 && !isStringArray2(rawConfig.knowledgeBases)) {
-    throw new Error(`Config file ${filePath} field 'knowledgeBases' must be an array of strings.`);
-  }
-  if (rawConfig.additionalInclude !== void 0 && !isStringArray2(rawConfig.additionalInclude)) {
-    throw new Error(`Config file ${filePath} field 'additionalInclude' must be an array of strings.`);
-  }
-  if (rawConfig.include !== void 0 && !isStringArray2(rawConfig.include)) {
-    throw new Error(`Config file ${filePath} field 'include' must be an array of strings.`);
-  }
-  if (rawConfig.exclude !== void 0 && !isStringArray2(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 && !isRecord(value)) {
-      throw new Error(`Config file ${filePath} field '${section}' must be an object.`);
-    }
-  }
-  return rawConfig;
-}
-function loadJsonFile(filePath) {
-  if (!existsSync5(filePath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync4(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 materializeLocalProjectConfig(projectRoot3, config, host = "opencode") {
-  const localConfigPath = resolveWritableProjectConfigPath(projectRoot3, host);
-  mkdirSync(path7.dirname(localConfigPath), { recursive: true });
-  writeFileSync(localConfigPath, JSON.stringify(config, null, 2), "utf-8");
-  return localConfigPath;
-}
-function loadProjectConfigLayer(projectRoot3, host = "opencode") {
-  const projectConfigPath = resolveProjectConfigPath(projectRoot3, host);
-  const projectConfig = loadJsonFile(projectConfigPath);
-  if (!projectConfig) {
-    return {};
-  }
-  const normalizedConfig = { ...projectConfig };
-  const projectConfigBaseDir = path7.dirname(path7.dirname(projectConfigPath));
-  if (Array.isArray(normalizedConfig.knowledgeBases)) {
-    normalizedConfig.knowledgeBases = resolveInheritedKnowledgeBaseEntries(
-      normalizedConfig.knowledgeBases,
-      projectConfigBaseDir,
-      projectRoot3
-    );
-  }
-  return normalizedConfig;
-}
-function loadMergedConfig(projectRoot3, host = "opencode") {
-  const globalConfigPath = resolveGlobalConfigPath(host);
-  const projectConfigPath = resolveProjectConfigPath(projectRoot3, 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(projectRoot3, 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/indexer/index.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7, statSync as statSync3, writeFileSync as writeFileSync3, renameSync as renameSync2, unlinkSync, mkdirSync as mkdirSync3, promises as fsPromises2 } from "fs";
-import * as path13 from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6, statSync as statSync3, writeFileSync as writeFileSync2, renameSync as renameSync2, unlinkSync, mkdirSync as mkdirSync2, promises as fsPromises2 } from "fs";
+import * as path11 from "path";
 import { performance as performance2 } from "perf_hooks";
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify3 } from "util";
@@ -3187,6 +3068,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);
   }
@@ -3261,22 +3143,45 @@ var OllamaEmbeddingProvider = class _OllamaEmbeddingProvider extends BaseEmbeddi
     }
   }
   async embedSingle(text3) {
-    const response = await fetch(`${this.credentials.baseUrl}/api/embeddings`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        model: this.modelInfo.model,
-        prompt: text3,
-        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: text3,
+          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(text3)
@@ -3423,9 +3328,23 @@ var SiliconFlowReranker = class {
 };
 
 // src/utils/files.ts
-var import_ignore = __toESM(require_ignore(), 1);
-import { existsSync as existsSync6, readFileSync as readFileSync5, promises as fsPromises } from "fs";
-import * as path8 from "path";
+var import_ignore = __toESM(require_ignore(), 1);
+import { existsSync as existsSync5, readFileSync as readFileSync4, promises as fsPromises } from "fs";
+import * as path6 from "path";
+
+// src/utils/paths.ts
+import * as path5 from "path";
+function normalizePathSeparators(value) {
+  return value.replace(/\\/g, "/");
+}
+function isHiddenPathSegment(part) {
+  return part.startsWith(".") && part !== "." && part !== "..";
+}
+function isBuildPathSegment(part) {
+  return part.toLowerCase().includes("build");
+}
+
+// src/utils/files.ts
 function createIgnoreFilter(projectRoot3) {
   const ig = (0, import_ignore.default)();
   const defaultIgnores = [
@@ -3447,9 +3366,9 @@ function createIgnoreFilter(projectRoot3) {
     "**/*build*/**"
   ];
   ig.add(defaultIgnores);
-  const gitignorePath = path8.join(projectRoot3, ".gitignore");
-  if (existsSync6(gitignorePath)) {
-    const gitignoreContent = readFileSync5(gitignorePath, "utf-8");
+  const gitignorePath = path6.join(projectRoot3, ".gitignore");
+  if (existsSync5(gitignorePath)) {
+    const gitignoreContent = readFileSync4(gitignorePath, "utf-8");
     ig.add(gitignoreContent);
   }
   return ig;
@@ -3474,8 +3393,8 @@ async function* walkDirectory(dir, projectRoot3, includePatterns, excludePattern
   const filesInDir = [];
   const subdirs = [];
   for (const entry of entries) {
-    const fullPath = path8.join(dir, entry.name);
-    const relativePath = path8.relative(projectRoot3, fullPath);
+    const fullPath = path6.join(dir, entry.name);
+    const relativePath = path6.relative(projectRoot3, fullPath);
     if (isHiddenPathSegment(entry.name)) {
       if (entry.isDirectory()) {
         skipped.push({ path: relativePath, reason: "excluded" });
@@ -3524,7 +3443,7 @@ async function* walkDirectory(dir, projectRoot3, includePatterns, excludePattern
     yield f;
   }
   for (let i = options.maxFilesPerDirectory; i < filesInDir.length; i++) {
-    skipped.push({ path: path8.relative(projectRoot3, filesInDir[i].path), reason: "excluded" });
+    skipped.push({ path: path6.relative(projectRoot3, filesInDir[i].path), reason: "excluded" });
   }
   const canRecurse = options.maxDepth === -1 || currentDepth < options.maxDepth;
   if (canRecurse) {
@@ -3564,8 +3483,8 @@ async function collectFiles(projectRoot3, includePatterns, excludePatterns, maxF
   if (additionalRoots && additionalRoots.length > 0) {
     const normalizedRoots = /* @__PURE__ */ new Set();
     for (const kbRoot of additionalRoots) {
-      const resolved = path8.normalize(
-        path8.isAbsolute(kbRoot) ? kbRoot : path8.resolve(projectRoot3, kbRoot)
+      const resolved = path6.normalize(
+        path6.isAbsolute(kbRoot) ? kbRoot : path6.resolve(projectRoot3, kbRoot)
       );
       normalizedRoots.add(resolved);
     }
@@ -3912,7 +3831,7 @@ function initializeLogger(config) {
 }
 
 // src/native/index.ts
-import * as path9 from "path";
+import * as path7 from "path";
 import * as os3 from "os";
 import * as module from "module";
 import { fileURLToPath } from "url";
@@ -3936,19 +3855,19 @@ function getNativeBinding() {
   let currentDir;
   let requireTarget;
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    currentDir = path9.dirname(fileURLToPath(import.meta.url));
+    currentDir = path7.dirname(fileURLToPath(import.meta.url));
     requireTarget = import.meta.url;
   } else if (typeof __dirname !== "undefined") {
     currentDir = __dirname;
     requireTarget = __filename;
   } else {
     currentDir = process.cwd();
-    requireTarget = path9.join(currentDir, "index.js");
+    requireTarget = path7.join(currentDir, "index.js");
   }
   const normalizedDir = currentDir.replace(/\\/g, "/");
-  const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path9.join("src", "native"));
-  const packageRoot = isDevMode ? path9.resolve(currentDir, "../..") : path9.resolve(currentDir, "..");
-  const nativePath = path9.join(packageRoot, "native", bindingName);
+  const isDevMode = normalizedDir.includes("/src/native") || currentDir.includes(path7.join("src", "native"));
+  const packageRoot = isDevMode ? path7.resolve(currentDir, "../..") : path7.resolve(currentDir, "..");
+  const nativePath = path7.join(packageRoot, "native", bindingName);
   const require2 = module.createRequire(requireTarget);
   return require2(nativePath);
 }
@@ -4034,7 +3953,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
@@ -4155,6 +4076,7 @@ function getEmbeddingHeaderParts(chunk, filePath) {
     javascript: "JavaScript",
     python: "Python",
     rust: "Rust",
+    swift: "Swift",
     go: "Go",
     java: "Java"
   };
@@ -4163,7 +4085,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",
@@ -4681,7 +4612,7 @@ var Database = class _Database {
 };
 
 // src/tools/changed-files.ts
-import * as path10 from "path";
+import * as path8 from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
@@ -4769,8 +4700,8 @@ function normalizeFiles(rawFiles, projectRoot3) {
   for (const raw of rawFiles) {
     const trimmed = raw.trim();
     if (!trimmed) continue;
-    const absolute = path10.resolve(projectRoot3, trimmed);
-    const relative7 = path10.relative(projectRoot3, absolute);
+    const absolute = path8.resolve(projectRoot3, trimmed);
+    const relative7 = path8.relative(projectRoot3, absolute);
     const cleaned = relative7.startsWith("./") ? relative7.slice(2) : relative7;
     if (!seen.has(cleaned)) {
       seen.add(cleaned);
@@ -4782,7 +4713,7 @@ function normalizeFiles(rawFiles, projectRoot3) {
 
 // src/indexer/git-blame.ts
 import { execFile as execFile2 } from "child_process";
-import * as path11 from "path";
+import * as path9 from "path";
 import { promisify as promisify2 } from "util";
 var execFileAsync2 = promisify2(execFile2);
 function parseGitBlamePorcelain(output) {
@@ -4820,7 +4751,7 @@ function parseGitBlamePorcelain(output) {
   return Array.from(commits.values()).filter((commit) => commit.lines > 0).sort((a, b) => b.lines - a.lines || b.committedAt - a.committedAt)[0];
 }
 async function getChunkGitBlame(projectRoot3, filePath, startLine, endLine) {
-  const relativePath = path11.relative(projectRoot3, filePath);
+  const relativePath = path9.relative(projectRoot3, filePath);
   try {
     const { stdout } = await execFileAsync2(
       "git",
@@ -4836,18 +4767,18 @@ async function getChunkGitBlame(projectRoot3, filePath, startLine, endLine) {
 // src/indexer/index-lock.ts
 import { randomUUID } from "crypto";
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync6,
   lstatSync,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync6,
+  mkdirSync,
+  readFileSync as readFileSync5,
   readdirSync as readdirSync2,
   realpathSync,
   renameSync,
   rmSync,
-  writeFileSync as writeFileSync2
+  writeFileSync
 } from "fs";
 import * as os4 from "os";
-import * as path12 from "path";
+import * as path10 from "path";
 var OWNER_FILE_NAME = "owner.json";
 var RECLAIM_DIRECTORY_NAME = "reclaiming";
 var RECOVERY_MARKER_PREFIX = "indexing.lock.recovery.";
@@ -4904,7 +4835,7 @@ function parseReclaimOwner(value) {
 }
 function readJsonDirectory(directoryPath, parser) {
   try {
-    return parser(JSON.parse(readFileSync6(path12.join(directoryPath, OWNER_FILE_NAME), "utf-8")));
+    return parser(JSON.parse(readFileSync5(path10.join(directoryPath, OWNER_FILE_NAME), "utf-8")));
   } catch {
     return null;
   }
@@ -4920,7 +4851,7 @@ function readRecoveryOwner(markerPath) {
 }
 function readLegacyOwner(lockPath) {
   try {
-    const parsed = JSON.parse(readFileSync6(lockPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync5(lockPath, "utf-8"));
     if (!Number.isInteger(parsed.pid) || Number(parsed.pid) <= 0) return null;
     if (typeof parsed.startedAt !== "string" || Number.isNaN(Date.parse(parsed.startedAt))) return null;
     return {
@@ -4955,23 +4886,23 @@ function sameReclaimOwner(left, right) {
 function publishJsonDirectory(finalPath, value) {
   const candidatePath = `${finalPath}.candidate.${process.pid}.${randomUUID()}`;
   try {
-    mkdirSync2(candidatePath, { mode: 448 });
+    mkdirSync(candidatePath, { mode: 448 });
   } catch (error) {
     if (getErrorCode(error) === "ENOENT") return false;
     throw error;
   }
   try {
-    writeFileSync2(path12.join(candidatePath, OWNER_FILE_NAME), JSON.stringify(value), {
+    writeFileSync(path10.join(candidatePath, OWNER_FILE_NAME), JSON.stringify(value), {
       encoding: "utf-8",
       flag: "wx",
       mode: 384
     });
-    if (existsSync7(finalPath)) return false;
+    if (existsSync6(finalPath)) return false;
     try {
       renameSync(candidatePath, finalPath);
       return true;
     } catch (error) {
-      if (existsSync7(finalPath)) return false;
+      if (existsSync6(finalPath)) return false;
       if (getErrorCode(error) === "ENOENT") return false;
       throw error;
     }
@@ -4979,7 +4910,7 @@ function publishJsonDirectory(finalPath, value) {
     if (getErrorCode(error) === "ENOENT") return false;
     throw error;
   } finally {
-    if (existsSync7(candidatePath)) rmSync(candidatePath, { recursive: true, force: true });
+    if (existsSync6(candidatePath)) rmSync(candidatePath, { recursive: true, force: true });
   }
 }
 function createOwner(operation) {
@@ -4992,7 +4923,7 @@ function createOwner(operation) {
   };
 }
 function recoveryMarkerPath(indexPath, owner) {
-  return path12.join(indexPath, `${RECOVERY_MARKER_PREFIX}${owner.token}`);
+  return path10.join(indexPath, `${RECOVERY_MARKER_PREFIX}${owner.token}`);
 }
 function publishRecoveryMarker(indexPath, owner) {
   const markerPath = recoveryMarkerPath(indexPath, owner);
@@ -5011,7 +4942,7 @@ function getPendingRecoveries(indexPath) {
     return UUID_PATTERN.test(name.slice(RECOVERY_MARKER_PREFIX.length));
   }).sort();
   for (const markerName of markerNames) {
-    const markerPath = path12.join(indexPath, markerName);
+    const markerPath = path10.join(indexPath, markerName);
     const markerToken = markerName.slice(RECOVERY_MARKER_PREFIX.length);
     let markerStats;
     try {
@@ -5043,11 +4974,11 @@ function cleanupDeadPublicationCandidates(indexPath) {
     const pid = Number(match[1]);
     if (!Number.isInteger(pid) || pid <= 0) continue;
     if (getOwnerLiveness({ pid, hostname: os4.hostname() }) !== "dead") continue;
-    rmSync(path12.join(indexPath, entry), { recursive: true, force: true });
+    rmSync(path10.join(indexPath, entry), { recursive: true, force: true });
   }
 }
 function removeDeadReclaimMarker(lockPath, expectedOwner) {
-  const markerPath = path12.join(lockPath, RECLAIM_DIRECTORY_NAME);
+  const markerPath = path10.join(lockPath, RECLAIM_DIRECTORY_NAME);
   const marker = readReclaimOwner(markerPath);
   if (!marker || marker.expectedOwnerToken !== expectedOwner.token || getOwnerLiveness(marker) !== "dead") {
     return false;
@@ -5066,7 +4997,7 @@ function removeDeadReclaimMarker(lockPath, expectedOwner) {
   const claimedMarker = readReclaimOwner(claimedMarkerPath);
   const ownerAfterClaim = readDirectoryOwner(lockPath);
   if (!claimedMarker || !sameReclaimOwner(claimedMarker, marker) || !ownerAfterClaim || !sameOwner(ownerAfterClaim, expectedOwner) || getOwnerLiveness(ownerAfterClaim) !== "dead") {
-    if (!existsSync7(markerPath) && existsSync7(claimedMarkerPath)) {
+    if (!existsSync6(markerPath) && existsSync6(claimedMarkerPath)) {
       renameSync(claimedMarkerPath, markerPath);
     }
     return false;
@@ -5075,7 +5006,7 @@ function removeDeadReclaimMarker(lockPath, expectedOwner) {
   return true;
 }
 function reclaimDeadOwner(indexPath, lockPath, expectedOwner) {
-  const reclaimPath = path12.join(lockPath, RECLAIM_DIRECTORY_NAME);
+  const reclaimPath = path10.join(lockPath, RECLAIM_DIRECTORY_NAME);
   const reclaimOwner = {
     pid: process.pid,
     hostname: os4.hostname(),
@@ -5127,9 +5058,9 @@ function isIndexLockContentionError(error) {
   return error instanceof IndexLockContentionError || typeof error === "object" && error !== null && "code" in error && error.code === "INDEX_BUSY";
 }
 function acquireIndexLock(indexPath, operation) {
-  mkdirSync2(indexPath, { recursive: true });
+  mkdirSync(indexPath, { recursive: true });
   const canonicalIndexPath = realpathSync.native(indexPath);
-  const lockPath = path12.join(canonicalIndexPath, "indexing.lock");
+  const lockPath = path10.join(canonicalIndexPath, "indexing.lock");
   cleanupDeadPublicationCandidates(canonicalIndexPath);
   for (let attempt = 0; attempt < 6; attempt += 1) {
     const owner = createOwner(operation);
@@ -5185,7 +5116,7 @@ function releaseIndexLock(lease) {
   }
   const claimedOwner = readDirectoryOwner(releasePath);
   if (!claimedOwner || !sameOwner(claimedOwner, lease.owner)) {
-    if (!existsSync7(lease.lockPath) && existsSync7(releasePath)) {
+    if (!existsSync6(lease.lockPath) && existsSync6(releasePath)) {
       renameSync(releasePath, lease.lockPath);
     }
     return false;
@@ -5197,59 +5128,25 @@ 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;
   return `${targetPath}.tmp.${owner.pid}.${owner.token}.${temporaryCounter}`;
 }
 function removeLeaseTemporaryPath(temporaryPath) {
-  if (existsSync7(temporaryPath)) rmSync(temporaryPath, { recursive: true, force: true });
+  if (existsSync6(temporaryPath)) rmSync(temporaryPath, { recursive: true, force: true });
 }
 function recoverLeaseArtifacts(indexPath, owner, backupTargets) {
   for (const targetPath of backupTargets) {
     const backupPath = createLeaseTemporaryPath(targetPath, owner, "bak");
-    if (!existsSync7(backupPath)) continue;
-    if (existsSync7(targetPath)) rmSync(targetPath, { recursive: true, force: true });
+    if (!existsSync6(backupPath)) continue;
+    if (existsSync6(targetPath)) rmSync(targetPath, { recursive: true, force: true });
     renameSync(backupPath, targetPath);
   }
   const temporaryOwnerMarker = `.tmp.${owner.pid}.${owner.token}.`;
   for (const entry of readdirSync2(indexPath)) {
     if (!entry.includes(temporaryOwnerMarker)) continue;
-    rmSync(path12.join(indexPath, entry), { recursive: true, force: true });
+    rmSync(path10.join(indexPath, entry), { recursive: true, force: true });
   }
 }
 function completeLeaseRecovery(lease) {
@@ -5265,8 +5162,18 @@ function completeLeaseRecovery(lease) {
 }
 
 // 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",
@@ -5279,6 +5186,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",
@@ -5294,6 +5204,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).
@@ -5303,6 +5221,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);
@@ -5387,6 +5352,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) {
@@ -5543,9 +5510,9 @@ function hasAllEmbeddingParts(parts, expectedPartCount) {
   return true;
 }
 function isPathWithinRoot(filePath, rootPath) {
-  const normalizedFilePath = path13.resolve(filePath);
-  const normalizedRoot = path13.resolve(rootPath);
-  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path13.sep}`);
+  const normalizedFilePath = path11.resolve(filePath);
+  const normalizedRoot = path11.resolve(rootPath);
+  return normalizedFilePath === normalizedRoot || normalizedFilePath.startsWith(`${normalizedRoot}${path11.sep}`);
 }
 var rankingQueryTokenCache = /* @__PURE__ */ new Map();
 var rankingNameTokenCache = /* @__PURE__ */ new Map();
@@ -5709,15 +5676,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:
@@ -5824,11 +5801,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);
 }
@@ -6645,21 +6632,21 @@ var Indexer = class {
     this.config = config;
     this.host = host;
     this.indexPath = this.getIndexPath();
-    this.fileHashCachePath = path13.join(this.indexPath, "file-hashes.json");
-    this.failedBatchesPath = path13.join(this.indexPath, "failed-batches.json");
+    this.fileHashCachePath = path11.join(this.indexPath, "file-hashes.json");
+    this.failedBatchesPath = path11.join(this.indexPath, "failed-batches.json");
     this.logger = initializeLogger(config.debug);
   }
   getIndexPath() {
     return resolveProjectIndexPath(this.projectRoot, this.config.scope, this.host);
   }
   isLocalProjectIndexPath() {
-    const localProjectIndexPaths = [path13.join(this.projectRoot, getHostProjectIndexRelativePath(this.host))];
+    const localProjectIndexPaths = [path11.join(this.projectRoot, getHostProjectIndexRelativePath(this.host))];
     if (this.host !== "opencode") {
-      localProjectIndexPaths.push(path13.join(this.projectRoot, getHostProjectIndexRelativePath("opencode")));
+      localProjectIndexPaths.push(path11.join(this.projectRoot, getHostProjectIndexRelativePath("opencode")));
     }
     return localProjectIndexPaths.some((localPath) => {
-      if (!existsSync8(localPath) || !existsSync8(this.indexPath)) {
-        return path13.resolve(this.indexPath) === path13.resolve(localPath);
+      if (!existsSync7(localPath) || !existsSync7(this.indexPath)) {
+        return path11.resolve(this.indexPath) === path11.resolve(localPath);
       }
       const indexStats = statSync3(this.indexPath);
       const localStats = statSync3(localPath);
@@ -6701,8 +6688,8 @@ var Indexer = class {
   async withIndexMutationLease(operation, callback) {
     const lease = acquireIndexLock(this.indexPath, operation);
     this.indexPath = lease.canonicalIndexPath;
-    this.fileHashCachePath = path13.join(this.indexPath, "file-hashes.json");
-    this.failedBatchesPath = path13.join(this.indexPath, "failed-batches.json");
+    this.fileHashCachePath = path11.join(this.indexPath, "file-hashes.json");
+    this.failedBatchesPath = path11.join(this.indexPath, "failed-batches.json");
     this.activeIndexLease = lease;
     let result;
     let callbackError;
@@ -6736,7 +6723,7 @@ var Indexer = class {
     } catch (error) {
       releaseError = error;
       this.writerArtifactFingerprint = null;
-      if (!existsSync8(lease.lockPath) && this.activeIndexLease?.owner.token === lease.owner.token) {
+      if (!existsSync7(lease.lockPath) && this.activeIndexLease?.owner.token === lease.owner.token) {
         this.activeIndexLease = null;
       }
     }
@@ -6754,11 +6741,11 @@ var Indexer = class {
     return this.activeIndexLease;
   }
   loadFileHashCache() {
-    if (!existsSync8(this.fileHashCachePath)) {
+    if (!existsSync7(this.fileHashCachePath)) {
       return;
     }
     try {
-      const data = readFileSync7(this.fileHashCachePath, "utf-8");
+      const data = readFileSync6(this.fileHashCachePath, "utf-8");
       const parsed = JSON.parse(data);
       this.fileHashCache = new Map(Object.entries(parsed));
     } catch (error) {
@@ -6780,9 +6767,9 @@ var Indexer = class {
   atomicWriteSync(targetPath, data) {
     const lease = this.requireActiveLease();
     const tempPath = createLeaseTemporaryPath(targetPath, lease.owner, "tmp");
-    mkdirSync3(path13.dirname(targetPath), { recursive: true });
+    mkdirSync2(path11.dirname(targetPath), { recursive: true });
     try {
-      writeFileSync3(tempPath, data);
+      writeFileSync2(tempPath, data);
       renameSync2(tempPath, targetPath);
     } finally {
       removeLeaseTemporaryPath(tempPath);
@@ -6790,14 +6777,14 @@ var Indexer = class {
   }
   saveInvertedIndex(invertedIndex) {
     this.atomicWriteSync(
-      path13.join(this.indexPath, "inverted-index.json"),
+      path11.join(this.indexPath, "inverted-index.json"),
       invertedIndex.serialize()
     );
   }
   getScopedRoots() {
-    const roots = /* @__PURE__ */ new Set([path13.resolve(this.projectRoot)]);
+    const roots = /* @__PURE__ */ new Set([path11.resolve(this.projectRoot)]);
     for (const kbRoot of this.config.knowledgeBases) {
-      roots.add(path13.resolve(this.projectRoot, kbRoot));
+      roots.add(path11.resolve(this.projectRoot, kbRoot));
     }
     return Array.from(roots);
   }
@@ -6806,31 +6793,54 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return branchName;
     }
-    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
     return `${projectHash}:${branchName}`;
   }
   getBranchCatalogKeyFor(branchName) {
     if (this.config.scope !== "global") {
       return branchName;
     }
-    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
     return `${projectHash}:${branchName}`;
   }
   getLegacyBranchCatalogKey() {
     return this.currentBranch || "default";
   }
   getLegacyMigrationMetadataKey() {
-    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
     return `index.globalBranchMigration.${projectHash}`;
   }
   getProjectEmbeddingStrategyMetadataKey() {
-    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
     return `index.embeddingStrategyVersion.${projectHash}`;
   }
   getProjectForceReembedMetadataKey() {
-    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
     return `index.forceReembed.${projectHash}`;
   }
+  getCallGraphResolutionMetadataKey() {
+    if (this.config.scope !== "global") {
+      return "index.callGraphResolutionVersion";
+    }
+    const projectHash = hashContent(path11.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(path11.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(path11.resolve(this.projectRoot)).slice(0, 16);
+    return `${key}.${projectHash}`;
+  }
   hasProjectForceReembedPending() {
     return this.config.scope === "global" && this.database?.getMetadata(this.getProjectForceReembedMetadataKey()) === "true";
   }
@@ -6922,7 +6932,7 @@ var Indexer = class {
     if (!this.database) {
       return { chunkIds, symbolIds };
     }
-    const projectRootPath = path13.resolve(this.projectRoot);
+    const projectRootPath = path11.resolve(this.projectRoot);
     const projectLocalFilePaths = /* @__PURE__ */ new Set([
       ...Array.from(this.fileHashCache.keys()).filter(
         (filePath) => this.isFileInCurrentScope(filePath, roots) && isPathWithinRoot(filePath, projectRootPath)
@@ -6945,7 +6955,7 @@ var Indexer = class {
     if (this.config.scope !== "global") {
       return this.getBranchCatalogCleanupKeys();
     }
-    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
     const keys = /* @__PURE__ */ new Set();
     const projectChunkIdSet = new Set(projectChunkIds);
     const projectSymbolIdSet = new Set(projectSymbolIds);
@@ -7029,7 +7039,7 @@ var Indexer = class {
     if (!this.database || this.config.scope !== "global") {
       return false;
     }
-    const projectHash = hashContent(path13.resolve(this.projectRoot)).slice(0, 16);
+    const projectHash = hashContent(path11.resolve(this.projectRoot)).slice(0, 16);
     const roots = this.getScopedRoots();
     const { chunkIds: projectLocalChunkIds, symbolIds: projectLocalSymbolIds } = this.getProjectLocalScopedOwnershipIds(roots);
     return this.database.getAllBranches().some(
@@ -7063,7 +7073,7 @@ var Indexer = class {
       ...Array.from(this.fileHashCache.keys()).filter((filePath) => this.isFileInCurrentScope(filePath, roots)),
       ...scopedEntries.map(({ metadata }) => metadata.filePath)
     ]);
-    const projectRootPath = path13.resolve(this.projectRoot);
+    const projectRootPath = path11.resolve(this.projectRoot);
     const projectLocalFilePaths = new Set(
       Array.from(filePaths).filter((filePath) => isPathWithinRoot(filePath, projectRootPath))
     );
@@ -7141,7 +7151,7 @@ var Indexer = class {
       });
     }
     if (this.config.scope === "global") {
-      if (existsSync8(this.fileHashCachePath)) {
+      if (existsSync7(this.fileHashCachePath)) {
         unlinkSync(this.fileHashCachePath);
       }
       await this.healthCheckUnlocked();
@@ -7161,10 +7171,10 @@ var Indexer = class {
     }
   }
   loadSerializedFailedBatches() {
-    if (!existsSync8(this.failedBatchesPath)) {
+    if (!existsSync7(this.failedBatchesPath)) {
       return [];
     }
-    const data = readFileSync7(this.failedBatchesPath, "utf-8");
+    const data = readFileSync6(this.failedBatchesPath, "utf-8");
     const parsed = JSON.parse(data);
     return parsed.map((batch) => {
       const chunks = Array.isArray(batch.chunks) ? batch.chunks : [];
@@ -7181,7 +7191,7 @@ var Indexer = class {
   }
   saveFailedBatches(batches) {
     if (batches.length === 0) {
-      if (existsSync8(this.failedBatchesPath)) {
+      if (existsSync7(this.failedBatchesPath)) {
         try {
           unlinkSync(this.failedBatchesPath);
         } catch {
@@ -7473,12 +7483,12 @@ var Indexer = class {
     }
   }
   captureReaderArtifactFingerprint() {
-    const storePath = path13.join(this.indexPath, "vectors");
+    const storePath = path11.join(this.indexPath, "vectors");
     return {
       vectors: `${this.getReaderFileFingerprint(storePath)}|${this.getReaderFileFingerprint(`${storePath}.meta.json`)}`,
-      keyword: this.getReaderFileFingerprint(path13.join(this.indexPath, "inverted-index.json")),
-      database: this.getReaderFileFingerprint(path13.join(this.indexPath, "codebase.db")),
-      databaseIdentity: this.getReaderFileFingerprint(path13.join(this.indexPath, "codebase.db"), true)
+      keyword: this.getReaderFileFingerprint(path11.join(this.indexPath, "inverted-index.json")),
+      database: this.getReaderFileFingerprint(path11.join(this.indexPath, "codebase.db")),
+      databaseIdentity: this.getReaderFileFingerprint(path11.join(this.indexPath, "codebase.db"), true)
     };
   }
   refreshReaderArtifacts() {
@@ -7503,13 +7513,13 @@ var Indexer = class {
       issues.set(component, this.createReadIssue(component, message));
       this.readerArtifactRetryAfter.set(component, Date.now() + READER_ARTIFACT_RETRY_INTERVAL_MS);
     };
-    const storePath = path13.join(this.indexPath, "vectors");
+    const storePath = path11.join(this.indexPath, "vectors");
     const vectorMetadataPath = `${storePath}.meta.json`;
-    const invertedIndexPath = path13.join(this.indexPath, "inverted-index.json");
-    const dbPath = path13.join(this.indexPath, "codebase.db");
+    const invertedIndexPath = path11.join(this.indexPath, "inverted-index.json");
+    const dbPath = path11.join(this.indexPath, "codebase.db");
     if (vectorsChanged || retryDue("vectors")) {
-      const vectorStoreExists = existsSync8(storePath);
-      const vectorMetadataExists = existsSync8(vectorMetadataPath);
+      const vectorStoreExists = existsSync7(storePath);
+      const vectorMetadataExists = existsSync7(vectorMetadataPath);
       if (vectorStoreExists && vectorMetadataExists) {
         try {
           const store = new VectorStore(storePath, this.configuredProviderInfo.modelInfo.dimensions);
@@ -7524,8 +7534,8 @@ var Indexer = class {
         setIssue("vectors", this.getVectorReadIssueMessage());
       }
     }
-    if (keywordChanged || retryDue("keyword") || !existsSync8(invertedIndexPath) && (this.store?.count() ?? 0) > 0) {
-      if (existsSync8(invertedIndexPath)) {
+    if (keywordChanged || retryDue("keyword") || !existsSync7(invertedIndexPath) && (this.store?.count() ?? 0) > 0) {
+      if (existsSync7(invertedIndexPath)) {
         try {
           const invertedIndex = new InvertedIndex(invertedIndexPath);
           invertedIndex.load();
@@ -7540,7 +7550,7 @@ var Indexer = class {
       }
     }
     if (databaseReplaced || databaseChanged && issues.has("database") || retryDue("database")) {
-      if (existsSync8(dbPath)) {
+      if (existsSync7(dbPath)) {
         try {
           const database = Database.openReadOnly(dbPath);
           if (this.database) {
@@ -7631,11 +7641,11 @@ var Indexer = class {
       }
     }
     const dimensions = this.configuredProviderInfo.modelInfo.dimensions;
-    const storePath = path13.join(this.indexPath, "vectors");
+    const storePath = path11.join(this.indexPath, "vectors");
     const vectorMetadataPath = `${storePath}.meta.json`;
-    const invertedIndexPath = path13.join(this.indexPath, "inverted-index.json");
-    const dbPath = path13.join(this.indexPath, "codebase.db");
-    let dbIsNew = !existsSync8(dbPath);
+    const invertedIndexPath = path11.join(this.indexPath, "inverted-index.json");
+    const dbPath = path11.join(this.indexPath, "codebase.db");
+    let dbIsNew = !existsSync7(dbPath);
     const readerArtifactFingerprint = mode === "reader" ? this.captureReaderArtifactFingerprint() : null;
     if (mode === "writer") {
       await fsPromises2.mkdir(this.indexPath, { recursive: true });
@@ -7654,14 +7664,14 @@ var Indexer = class {
         await this.resetLocalIndexArtifacts();
       }
       this.store = new VectorStore(storePath, dimensions);
-      if (existsSync8(storePath) || existsSync8(vectorMetadataPath)) {
+      if (existsSync7(storePath) || existsSync7(vectorMetadataPath)) {
         this.store.load();
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
       try {
         this.invertedIndex.load();
       } catch {
-        if (existsSync8(invertedIndexPath)) {
+        if (existsSync7(invertedIndexPath)) {
           await fsPromises2.unlink(invertedIndexPath);
         }
         this.invertedIndex = new InvertedIndex(invertedIndexPath);
@@ -7679,8 +7689,8 @@ var Indexer = class {
       }
     } else {
       this.store = new VectorStore(storePath, dimensions);
-      const vectorStoreExists = existsSync8(storePath);
-      const vectorMetadataExists = existsSync8(vectorMetadataPath);
+      const vectorStoreExists = existsSync7(storePath);
+      const vectorMetadataExists = existsSync7(vectorMetadataPath);
       const vectorReadFailureMessage = this.getVectorReadIssueMessage();
       if (vectorStoreExists !== vectorMetadataExists) {
         this.recordReadIssue("vectors", vectorReadFailureMessage);
@@ -7693,7 +7703,7 @@ var Indexer = class {
         }
       }
       this.invertedIndex = new InvertedIndex(invertedIndexPath);
-      if (existsSync8(invertedIndexPath)) {
+      if (existsSync7(invertedIndexPath)) {
         try {
           this.invertedIndex.load();
         } catch (error) {
@@ -7707,7 +7717,7 @@ var Indexer = class {
       } else if (this.store.count() > 0) {
         this.recordReadIssue("keyword", this.getKeywordReadIssueMessage());
       }
-      if (existsSync8(dbPath)) {
+      if (existsSync7(dbPath)) {
         try {
           this.database = Database.openReadOnly(dbPath);
         } catch (error) {
@@ -7798,7 +7808,7 @@ var Indexer = class {
         if (await this.tryResetCorruptedIndex("running automatic orphan garbage collection", error)) {
           return {
             resetCorruptedIndex: true,
-            warning: this.getCorruptedIndexWarning(path13.join(this.indexPath, "codebase.db"))
+            warning: this.getCorruptedIndexWarning(path11.join(this.indexPath, "codebase.db"))
           };
         }
         throw error;
@@ -7813,7 +7823,7 @@ var Indexer = class {
       return;
     }
     const retainedEntries = store.getAllMetadata().filter(({ key }) => !excludedSet.has(key));
-    const storeBasePath = path13.join(this.indexPath, "vectors");
+    const storeBasePath = path11.join(this.indexPath, "vectors");
     const storeIndexPath = storeBasePath;
     const storeMetadataPath = `${storeBasePath}.meta.json`;
     const lease = this.requireActiveLease();
@@ -7823,18 +7833,18 @@ var Indexer = class {
     let backedUpMetadata = false;
     let rebuiltCount = 0;
     let skippedCount = 0;
-    if (existsSync8(backupIndexPath)) {
+    if (existsSync7(backupIndexPath)) {
       unlinkSync(backupIndexPath);
     }
-    if (existsSync8(backupMetadataPath)) {
+    if (existsSync7(backupMetadataPath)) {
       unlinkSync(backupMetadataPath);
     }
     try {
-      if (existsSync8(storeIndexPath)) {
+      if (existsSync7(storeIndexPath)) {
         renameSync2(storeIndexPath, backupIndexPath);
         backedUpIndex = true;
       }
-      if (existsSync8(storeMetadataPath)) {
+      if (existsSync7(storeMetadataPath)) {
         renameSync2(storeMetadataPath, backupMetadataPath);
         backedUpMetadata = true;
       }
@@ -7855,10 +7865,10 @@ var Indexer = class {
         rebuiltCount += 1;
       }
       store.save();
-      if (backedUpIndex && existsSync8(backupIndexPath)) {
+      if (backedUpIndex && existsSync7(backupIndexPath)) {
         unlinkSync(backupIndexPath);
       }
-      if (backedUpMetadata && existsSync8(backupMetadataPath)) {
+      if (backedUpMetadata && existsSync7(backupMetadataPath)) {
         unlinkSync(backupMetadataPath);
       }
       this.logger.gc("info", "Rebuilt vector store to avoid native remove", {
@@ -7871,16 +7881,16 @@ var Indexer = class {
         store.clear();
       } catch {
       }
-      if (existsSync8(storeIndexPath)) {
+      if (existsSync7(storeIndexPath)) {
         unlinkSync(storeIndexPath);
       }
-      if (existsSync8(storeMetadataPath)) {
+      if (existsSync7(storeMetadataPath)) {
         unlinkSync(storeMetadataPath);
       }
-      if (backedUpIndex && existsSync8(backupIndexPath)) {
+      if (backedUpIndex && existsSync7(backupIndexPath)) {
         renameSync2(backupIndexPath, storeIndexPath);
       }
-      if (backedUpMetadata && existsSync8(backupMetadataPath)) {
+      if (backedUpMetadata && existsSync7(backupMetadataPath)) {
         renameSync2(backupMetadataPath, storeMetadataPath);
       }
       if (backedUpIndex || backedUpMetadata) {
@@ -7908,15 +7918,15 @@ var Indexer = class {
     this.readerArtifactRetryAfter.clear();
     this.fileHashCache.clear();
     const resetPaths = [
-      path13.join(this.indexPath, "codebase.db"),
-      path13.join(this.indexPath, "codebase.db-shm"),
-      path13.join(this.indexPath, "codebase.db-wal"),
-      path13.join(this.indexPath, "vectors"),
-      path13.join(this.indexPath, "vectors.usearch"),
-      path13.join(this.indexPath, "vectors.meta.json"),
-      path13.join(this.indexPath, "inverted-index.json"),
-      path13.join(this.indexPath, "file-hashes.json"),
-      path13.join(this.indexPath, "failed-batches.json")
+      path11.join(this.indexPath, "codebase.db"),
+      path11.join(this.indexPath, "codebase.db-shm"),
+      path11.join(this.indexPath, "codebase.db-wal"),
+      path11.join(this.indexPath, "vectors"),
+      path11.join(this.indexPath, "vectors.usearch"),
+      path11.join(this.indexPath, "vectors.meta.json"),
+      path11.join(this.indexPath, "inverted-index.json"),
+      path11.join(this.indexPath, "file-hashes.json"),
+      path11.join(this.indexPath, "failed-batches.json")
     ];
     await Promise.all(resetPaths.map((targetPath) => fsPromises2.rm(targetPath, { recursive: true, force: true })));
     await fsPromises2.mkdir(this.indexPath, { recursive: true });
@@ -7925,7 +7935,7 @@ var Indexer = class {
     if (!isSqliteCorruptionError(error)) {
       return false;
     }
-    const dbPath = path13.join(this.indexPath, "codebase.db");
+    const dbPath = path11.join(this.indexPath, "codebase.db");
     const warning = this.getCorruptedIndexWarning(dbPath);
     const errorMessage = getErrorMessage2(error);
     if (this.config.scope === "global") {
@@ -7991,6 +8001,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);
@@ -8178,6 +8189,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) => path11.extname(filePath).toLowerCase() === ".swift"
+    )) {
+      this.logger.info("Reindexing cached Swift files for parser support");
+    }
+    if (reparseCachedMetalFiles && Array.from(this.fileHashCache.keys()).some(
+      (filePath) => path11.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,
@@ -8197,10 +8222,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 && path11.extname(f.path).toLowerCase() === ".swift";
+      const requiresMetalParserUpgrade = reparseCachedMetalFiles && path11.extname(f.path).toLowerCase() === ".metal";
+      if (cachedHashMatches && !needsCallGraphRefresh && !requiresSwiftParserUpgrade && !requiresMetalParserUpgrade) {
         unchangedFilePaths.add(f.path);
         this.logger.recordCacheHit();
       } else {
@@ -8302,7 +8334,7 @@ var Indexer = class {
     for (const parsed of parsedFiles) {
       currentFilePaths.add(parsed.path);
       if (parsed.chunks.length === 0) {
-        const relativePath = path13.relative(this.projectRoot, parsed.path);
+        const relativePath = path11.relative(this.projectRoot, parsed.path);
         stats.parseFailures.push(relativePath);
       }
       let chunksToProcess = parsed.chunks;
@@ -8402,16 +8434,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);
@@ -8436,8 +8480,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)}`;
@@ -8456,7 +8502,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);
           }
@@ -8498,8 +8558,8 @@ var Indexer = class {
       database.addChunksToBranchBatch(branchCatalogKey, Array.from(currentChunkIds));
       database.clearBranchSymbols(branchCatalogKey);
       database.addSymbolsToBranchBatch(branchCatalogKey, Array.from(allSymbolIds));
-      const vectorPath = path13.join(this.indexPath, "vectors");
-      const shouldFingerprintLegacyPair = !store.hasFingerprint() && existsSync8(vectorPath) && existsSync8(`${vectorPath}.meta.json`);
+      const vectorPath = path11.join(this.indexPath, "vectors");
+      const shouldFingerprintLegacyPair = !store.hasFingerprint() && existsSync7(vectorPath) && existsSync7(`${vectorPath}.meta.json`);
       if (backfilledBlameMetadata || shouldFingerprintLegacyPair) {
         store.save();
       }
@@ -8511,6 +8571,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;
@@ -8538,6 +8600,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;
@@ -8808,6 +8872,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();
@@ -9241,7 +9307,7 @@ var Indexer = class {
     const removedChunkKeys = [];
     const chunkKeysByRemovedFile = /* @__PURE__ */ new Map();
     for (const [filePath, chunkKeys] of filePathsToChunkKeys) {
-      if (!existsSync8(filePath)) {
+      if (!existsSync7(filePath)) {
         chunkKeysByRemovedFile.set(filePath, chunkKeys);
         for (const key of chunkKeys) {
           removedChunkKeys.push(key);
@@ -9290,7 +9356,7 @@ var Indexer = class {
         gcOrphanSymbols: 0,
         gcOrphanCallEdges: 0,
         resetCorruptedIndex: true,
-        warning: this.getCorruptedIndexWarning(path13.join(this.indexPath, "codebase.db"))
+        warning: this.getCorruptedIndexWarning(path11.join(this.indexPath, "codebase.db"))
       };
     }
     this.logger.recordGc(removedCount, gcOrphanChunks, gcOrphanEmbeddings);
@@ -9720,7 +9786,7 @@ var Indexer = class {
         "Run index_codebase first to build the call graph and symbol index for this branch."
       );
     }
-    const absoluteChangedFiles = changedFiles.map((f) => path13.resolve(this.projectRoot, f));
+    const absoluteChangedFiles = changedFiles.map((f) => path11.resolve(this.projectRoot, f));
     const directSymbols = database.getSymbolsForFiles(absoluteChangedFiles, branchKey);
     const directIds = directSymbols.map((s) => s.id);
     const direction = opts.direction ?? "both";
@@ -9803,7 +9869,7 @@ var Indexer = class {
               projectRoot: this.projectRoot,
               baseBranch: this.baseBranch
             });
-            const otherAbsolute = otherChanged.files.map((f) => path13.resolve(this.projectRoot, f));
+            const otherAbsolute = otherChanged.files.map((f) => path11.resolve(this.projectRoot, f));
             const otherBranchKey = this.getBranchCatalogKeyFor(openPr.headRefName);
             const otherSymbols = database.getSymbolsForFiles(otherAbsolute, otherBranchKey);
             const otherLabels = /* @__PURE__ */ new Set();
@@ -9867,12 +9933,12 @@ var Indexer = class {
         if (meta.filePath) filePaths.add(meta.filePath);
       }
       const directory = options?.directory?.replace(/\/$/, "");
-      const absoluteDirectoryFilter = directory ? path13.resolve(this.projectRoot, directory) : void 0;
+      const absoluteDirectoryFilter = directory ? path11.resolve(this.projectRoot, directory) : void 0;
       for (const filePath of filePaths) {
         if (directory) {
-          const absoluteFilePath = path13.resolve(filePath);
+          const absoluteFilePath = path11.resolve(filePath);
           const matchesRelative = filePath === directory || filePath.startsWith(directory + "/");
-          const matchesProjectRelative = absoluteDirectoryFilter !== void 0 && (absoluteFilePath === absoluteDirectoryFilter || absoluteFilePath.startsWith(absoluteDirectoryFilter + path13.sep));
+          const matchesProjectRelative = absoluteDirectoryFilter !== void 0 && (absoluteFilePath === absoluteDirectoryFilter || absoluteFilePath.startsWith(absoluteDirectoryFilter + path11.sep));
           if (!matchesRelative && !matchesProjectRelative) {
             continue;
           }
@@ -9915,43 +9981,43 @@ var Indexer = class {
 };
 
 // src/tools/knowledge-base-paths.ts
-import * as path14 from "path";
+import * as path12 from "path";
 function resolveConfigPathValue(value, baseDir) {
   const trimmed = value.trim();
   if (!trimmed) {
     return trimmed;
   }
-  const absolutePath = path14.isAbsolute(trimmed) ? trimmed : path14.resolve(baseDir, trimmed);
-  return path14.normalize(absolutePath);
+  const absolutePath = path12.isAbsolute(trimmed) ? trimmed : path12.resolve(baseDir, trimmed);
+  return path12.normalize(absolutePath);
 }
 function serializeConfigPathValue(value, baseDir) {
   const trimmed = value.trim();
   if (!trimmed) {
     return trimmed;
   }
-  if (!path14.isAbsolute(trimmed)) {
-    return normalizePathSeparators(path14.normalize(trimmed));
+  if (!path12.isAbsolute(trimmed)) {
+    return normalizePathSeparators(path12.normalize(trimmed));
   }
-  const relativePath = path14.relative(baseDir, trimmed);
-  if (!relativePath || !relativePath.startsWith("..") && !path14.isAbsolute(relativePath)) {
-    return normalizePathSeparators(path14.normalize(relativePath || "."));
+  const relativePath = path12.relative(baseDir, trimmed);
+  if (!relativePath || !relativePath.startsWith("..") && !path12.isAbsolute(relativePath)) {
+    return normalizePathSeparators(path12.normalize(relativePath || "."));
   }
-  return path14.normalize(trimmed);
+  return path12.normalize(trimmed);
 }
 function resolveKnowledgeBasePath(value, projectRoot3) {
-  return path14.isAbsolute(value) ? value : path14.resolve(projectRoot3, value);
+  return path12.isAbsolute(value) ? value : path12.resolve(projectRoot3, value);
 }
-function normalizeKnowledgeBasePath2(value, projectRoot3) {
-  return path14.normalize(resolveKnowledgeBasePath(value, projectRoot3));
+function normalizeKnowledgeBasePath(value, projectRoot3) {
+  return path12.normalize(resolveKnowledgeBasePath(value, projectRoot3));
 }
 function hasMatchingKnowledgeBasePath(knowledgeBases, inputPath, projectRoot3) {
-  const normalizedInput = path14.normalize(inputPath);
-  return knowledgeBases.some((kb) => normalizeKnowledgeBasePath2(kb, projectRoot3) === normalizedInput);
+  const normalizedInput = path12.normalize(inputPath);
+  return knowledgeBases.some((kb) => normalizeKnowledgeBasePath(kb, projectRoot3) === normalizedInput);
 }
 function findKnowledgeBasePathIndex(knowledgeBases, inputPath, projectRoot3) {
-  const normalizedInput = path14.normalize(inputPath);
+  const normalizedInput = path12.normalize(inputPath);
   return knowledgeBases.findIndex(
-    (kb) => path14.normalize(kb) === normalizedInput || normalizeKnowledgeBasePath2(kb, projectRoot3) === normalizedInput
+    (kb) => path12.normalize(kb) === normalizedInput || normalizeKnowledgeBasePath(kb, projectRoot3) === normalizedInput
   );
 }
 
@@ -10351,8 +10417,195 @@ ${truncateContent(r.content)}
 }
 
 // src/tools/config-state.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
 import * as path15 from "path";
+
+// src/config/merger.ts
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import * as path14 from "path";
+
+// src/config/rebase.ts
+import * as path13 from "path";
+function isWithinRoot(rootDir, targetPath) {
+  const relativePath = path13.relative(rootDir, targetPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !path13.isAbsolute(relativePath);
+}
+function resolveInheritedKnowledgeBaseEntries(values, sourceRoot, targetRoot) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  return values.filter((value) => typeof value === "string").map((value) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return trimmed;
+    }
+    if (path13.isAbsolute(trimmed)) {
+      if (isWithinRoot(sourceRoot, trimmed)) {
+        return normalizePathSeparators(path13.normalize(path13.relative(sourceRoot, trimmed) || "."));
+      }
+      return path13.normalize(trimmed);
+    }
+    const resolvedFromSource = path13.resolve(sourceRoot, trimmed);
+    if (isWithinRoot(sourceRoot, resolvedFromSource)) {
+      return normalizePathSeparators(path13.normalize(trimmed));
+    }
+    return normalizePathSeparators(path13.normalize(path13.relative(targetRoot, resolvedFromSource)));
+  }).filter(Boolean);
+}
+
+// src/config/merger.ts
+var PROJECT_OVERRIDE_KEYS = [
+  "embeddingProvider",
+  "customProvider",
+  "embeddingModel",
+  "reranker",
+  "include",
+  "exclude",
+  "indexing",
+  "search",
+  "debug",
+  "scope"
+];
+var MERGE_ARRAY_KEYS = ["knowledgeBases", "additionalInclude"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray2(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 normalizeKnowledgeBasePath2(value) {
+  let normalized = path14.normalize(String(value).trim());
+  const root = path14.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) => normalizeKnowledgeBasePath2(value)).filter((value) => value.length > 0))];
+}
+function validateConfigLayerShape(rawConfig, filePath) {
+  if (!isRecord(rawConfig)) {
+    throw new Error(`Config file ${filePath} must contain a JSON object at the root.`);
+  }
+  if (rawConfig.knowledgeBases !== void 0 && !isStringArray2(rawConfig.knowledgeBases)) {
+    throw new Error(`Config file ${filePath} field 'knowledgeBases' must be an array of strings.`);
+  }
+  if (rawConfig.additionalInclude !== void 0 && !isStringArray2(rawConfig.additionalInclude)) {
+    throw new Error(`Config file ${filePath} field 'additionalInclude' must be an array of strings.`);
+  }
+  if (rawConfig.include !== void 0 && !isStringArray2(rawConfig.include)) {
+    throw new Error(`Config file ${filePath} field 'include' must be an array of strings.`);
+  }
+  if (rawConfig.exclude !== void 0 && !isStringArray2(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 && !isRecord(value)) {
+      throw new Error(`Config file ${filePath} field '${section}' must be an object.`);
+    }
+  }
+  return rawConfig;
+}
+function loadJsonFile(filePath) {
+  if (!existsSync8(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync7(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 loadProjectConfigLayer(projectRoot3, host = "opencode") {
+  const projectConfigPath = resolveProjectConfigPath(projectRoot3, host);
+  const projectConfig = loadJsonFile(projectConfigPath);
+  if (!projectConfig) {
+    return {};
+  }
+  const normalizedConfig = { ...projectConfig };
+  const projectConfigBaseDir = path14.dirname(path14.dirname(projectConfigPath));
+  if (Array.isArray(normalizedConfig.knowledgeBases)) {
+    normalizedConfig.knowledgeBases = resolveInheritedKnowledgeBaseEntries(
+      normalizedConfig.knowledgeBases,
+      projectConfigBaseDir,
+      projectRoot3
+    );
+  }
+  return normalizedConfig;
+}
+function loadMergedConfig(projectRoot3, host = "opencode") {
+  const globalConfigPath = resolveGlobalConfigPath(host);
+  const projectConfigPath = resolveProjectConfigPath(projectRoot3, 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(projectRoot3, 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/config-state.ts
 function normalizeKnowledgeBasePaths(config, projectRoot3) {
   const normalized = { ...config };
   if (Array.isArray(normalized.knowledgeBases)) {
@@ -10382,7 +10635,7 @@ function saveConfig(projectRoot3, config, host = "opencode") {
   const configDir = path15.dirname(configPath);
   const configBaseDir = path15.dirname(configDir);
   if (!existsSync9(configDir)) {
-    mkdirSync4(configDir, { recursive: true });
+    mkdirSync3(configDir, { recursive: true });
   }
   const serializableConfig = { ...config };
   if (Array.isArray(serializableConfig.knowledgeBases)) {
@@ -10390,7 +10643,7 @@ function saveConfig(projectRoot3, config, host = "opencode") {
       (kb) => serializeConfigPathValue(kb, configBaseDir)
     );
   }
-  writeFileSync4(configPath, JSON.stringify(serializableConfig, null, 2) + "\n", "utf-8");
+  writeFileSync3(configPath, JSON.stringify(serializableConfig, null, 2) + "\n", "utf-8");
 }
 
 // src/tools/operations.ts
@@ -10450,15 +10703,6 @@ function refreshIndexerForDirectory(projectRoot3, host = "opencode", config = pa
   indexerCache.set(key, indexer);
   configCache.set(key, config);
 }
-function shouldForceLocalizeProjectIndex(projectRoot3, host = "opencode") {
-  const root = getProjectRoot(projectRoot3, host);
-  const localIndexPath = path16.join(root, getHostProjectIndexRelativePath(host));
-  if (existsSync10(localIndexPath)) {
-    return false;
-  }
-  const inheritedIndexPath = resolveWorktreeFallbackProjectIndexPath(root, host);
-  return inheritedIndexPath !== null;
-}
 async function searchCodebase(projectRoot3, host, query, options = {}) {
   const indexer = getIndexerForProject(projectRoot3, host);
   return indexer.search(query, options.limit, {
@@ -10508,9 +10752,7 @@ async function getCallGraphPath(projectRoot3, host, from, to, maxDepth) {
 }
 async function runIndexCodebase(projectRoot3, host, args, onProgress) {
   const root = getProjectRoot(projectRoot3, 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() };
@@ -10531,19 +10773,7 @@ async function runIndexCodebase(projectRoot3, 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;