@ashx-j/lunr 0.2.17 → 0.2.18

package/dist/node-runtime/chunk-VSELYKWU.js

@@ -0,0 +1,772 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  getAgentPath
+} from "./chunk-4HXHDDCF.js";
+import {
+  formatToolName,
+  isToolExcluded,
+  resourceNameToToolName
+} from "./chunk-ARC4KOTI.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/config.js
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+var GENERIC_GLOBAL_CONFIG_PATH = join(homedir(), ".config", "mcp", "mcp.json"), PROJECT_CONFIG_NAME = ".mcp.json", PROJECT_LUNR_CONFIG_NAME = ".lunr/mcp.json", LEGACY_PROJECT_PI_CONFIG_NAME = ".pi/mcp.json", REPOPROMPT_BINARY_CANDIDATES = [
+  join(homedir(), "RepoPrompt", "repoprompt_cli"),
+  "/Applications/Repo Prompt.app/Contents/MacOS/repoprompt-mcp"
+], IMPORT_PATHS = {
+  cursor: [join(homedir(), ".cursor", "mcp.json")],
+  "claude-code": [
+    join(homedir(), ".claude", "mcp.json"),
+    join(homedir(), ".claude.json"),
+    join(homedir(), ".claude", "claude_desktop_config.json")
+  ],
+  "claude-desktop": [join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json")],
+  codex: [join(homedir(), ".codex", "config.json")],
+  windsurf: [join(homedir(), ".windsurf", "mcp.json")],
+  vscode: [".vscode/mcp.json"]
+};
+function getPiGlobalConfigPath(overridePath) {
+  return overridePath ? resolve(overridePath) : getAgentPath("mcp.json");
+}
+function getProjectConfigPath(cwd = process.cwd()) {
+  return resolve(cwd, PROJECT_CONFIG_NAME);
+}
+function getProjectPiConfigPath(cwd = process.cwd()) {
+  return resolve(cwd, PROJECT_LUNR_CONFIG_NAME);
+}
+function getProjectPiConfigReadPath(cwd = process.cwd()) {
+  let lunrPath = getProjectPiConfigPath(cwd);
+  if (existsSync(lunrPath))
+    return lunrPath;
+  let legacyPath = resolve(cwd, LEGACY_PROJECT_PI_CONFIG_NAME);
+  return existsSync(legacyPath) ? legacyPath : lunrPath;
+}
+function getMcpDiscoverySummary(overridePath, cwd = process.cwd()) {
+  let sources = getConfigSources(overridePath, cwd).map((source) => {
+    let loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
+    return {
+      id: source.id,
+      label: source.label,
+      path: source.readPath,
+      exists: existsSync(source.readPath),
+      scope: source.scope,
+      kind: source.shared ? "shared" : "pi",
+      serverCount: loaded ? Object.keys(loaded.mcpServers).length : 0
+    };
+  }), imports = Object.keys(IMPORT_PATHS).map((kind) => {
+    let path = resolveImportPath(kind, cwd);
+    return path ? {
+      kind,
+      path,
+      serverCount: getImportServerCount(kind, path)
+    } : null;
+  }).filter((value) => value !== null), totalServerCount = sources.reduce((sum, source) => sum + source.serverCount, 0), hasSharedServers = sources.some((source) => source.kind === "shared" && source.serverCount > 0), hasPiOwnedServers = sources.some((source) => source.kind === "pi" && source.serverCount > 0), hasAnyDetectedPaths = sources.some((source) => source.exists) || imports.length > 0, hasAnyConfig = totalServerCount > 0 || imports.some((entry) => entry.serverCount > 0) || hasAnyDetectedPaths, summaryWithoutRepoPrompt = {
+    sources,
+    imports,
+    hasAnyConfig,
+    hasAnyDetectedPaths,
+    hasSharedServers,
+    hasPiOwnedServers,
+    totalServerCount
+  }, fingerprint = JSON.stringify({
+    sources: sources.map((source) => [source.id, source.exists, source.serverCount]),
+    imports: imports.map((entry) => [entry.kind, entry.path, entry.serverCount])
+  });
+  return {
+    ...summaryWithoutRepoPrompt,
+    fingerprint,
+    repoPrompt: detectRepoPrompt(summaryWithoutRepoPrompt, cwd)
+  };
+}
+function loadMcpConfig(overridePath, cwd = process.cwd()) {
+  let config = { mcpServers: {} };
+  for (let source of getConfigSources(overridePath, cwd)) {
+    let loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
+    loaded && (config = mergeConfigs(config, expandImports(loaded, cwd)));
+  }
+  return config;
+}
+function getConfigSources(overridePath, cwd = process.cwd()) {
+  let userPath = getPiGlobalConfigPath(overridePath), projectPath = getProjectConfigPath(cwd), projectPiPath = getProjectPiConfigPath(cwd), projectPiReadPath = getProjectPiConfigReadPath(cwd), sources = [];
+  return GENERIC_GLOBAL_CONFIG_PATH !== userPath && sources.push({
+    id: "shared-global",
+    label: "user-global standard MCP",
+    readPath: GENERIC_GLOBAL_CONFIG_PATH,
+    writePath: userPath,
+    kind: "import",
+    importKind: "global MCP config",
+    shared: !0,
+    scope: "global"
+  }), sources.push({
+    id: "pi-global",
+    label: "Pi global override",
+    readPath: userPath,
+    writePath: userPath,
+    kind: "user",
+    shared: !1,
+    scope: "global"
+  }), projectPath !== userPath && sources.push({
+    id: "shared-project",
+    label: "project standard MCP",
+    readPath: projectPath,
+    writePath: projectPath,
+    kind: "project",
+    shared: !0,
+    scope: "project"
+  }), projectPiPath !== userPath && projectPiPath !== projectPath && sources.push({
+    id: "pi-project",
+    label: "project Pi override",
+    readPath: projectPiReadPath,
+    writePath: projectPiPath,
+    kind: "project",
+    shared: !1,
+    scope: "project"
+  }), sources;
+}
+function mergeConfigs(base, next) {
+  return {
+    mcpServers: mergeServerMaps(base.mcpServers, next.mcpServers),
+    imports: mergeImports(base.imports, next.imports),
+    settings: next.settings ? { ...base.settings, ...next.settings } : base.settings
+  };
+}
+function mergeServerMaps(base, next) {
+  let merged = { ...base };
+  for (let [name, definition] of Object.entries(next))
+    merged[name] = { ...merged[name] ?? {}, ...definition };
+  return merged;
+}
+function mergeImports(left, right) {
+  let merged = [...left ?? [], ...right ?? []];
+  if (merged.length !== 0)
+    return [...new Set(merged)];
+}
+function expandImports(config, cwd = process.cwd()) {
+  if (!config.imports?.length)
+    return config;
+  let importedServers = {};
+  for (let importKind of config.imports) {
+    let importPath = resolveImportPath(importKind, cwd);
+    if (importPath)
+      try {
+        let imported = JSON.parse(readFileSync(importPath, "utf-8")), servers = extractServers(imported, importKind);
+        for (let [name, definition] of Object.entries(servers))
+          importedServers[name] || (importedServers[name] = definition);
+      } catch (error) {
+        console.warn(`Failed to import MCP config from ${importKind}:`, error);
+      }
+  }
+  return {
+    imports: config.imports,
+    settings: config.settings,
+    mcpServers: mergeServerMaps(importedServers, config.mcpServers)
+  };
+}
+function resolveImportPath(importKind, cwd = process.cwd()) {
+  let candidates = IMPORT_PATHS[importKind] ?? [];
+  for (let candidate of candidates) {
+    let fullPath = candidate.startsWith(".") ? resolve(cwd, candidate) : candidate;
+    if (existsSync(fullPath))
+      return fullPath;
+  }
+  return null;
+}
+function getImportServerCount(importKind, path) {
+  try {
+    let raw = JSON.parse(readFileSync(path, "utf-8"));
+    return Object.keys(extractServers(raw, importKind)).length;
+  } catch {
+    return 0;
+  }
+}
+function readValidatedConfig(path, label) {
+  if (!existsSync(path))
+    return null;
+  try {
+    return validateConfig(JSON.parse(readFileSync(path, "utf-8")));
+  } catch (error) {
+    return console.warn(`Failed to load ${label}:`, error), null;
+  }
+}
+function validateConfig(raw) {
+  if (!raw || typeof raw != "object")
+    return { mcpServers: {} };
+  let obj = raw, servers = obj.mcpServers ?? obj["mcp-servers"] ?? {};
+  return typeof servers != "object" || servers === null || Array.isArray(servers) ? { mcpServers: {} } : {
+    mcpServers: servers,
+    imports: Array.isArray(obj.imports) ? obj.imports : void 0,
+    settings: obj.settings
+  };
+}
+function extractServers(config, kind) {
+  if (!config || typeof config != "object")
+    return {};
+  let obj = config, servers;
+  switch (kind) {
+    case "claude-desktop":
+    case "claude-code":
+    case "codex":
+      servers = obj.mcpServers;
+      break;
+    case "cursor":
+    case "windsurf":
+    case "vscode":
+      servers = obj.mcpServers ?? obj["mcp-servers"];
+      break;
+    default:
+      return {};
+  }
+  return !servers || typeof servers != "object" || Array.isArray(servers) ? {} : servers;
+}
+function serializeRawConfig(raw) {
+  return `${JSON.stringify(raw, null, 2)}
+`;
+}
+function buildUnifiedDiff(beforeText, afterText) {
+  if (beforeText === afterText)
+    return "(no changes)";
+  let before = beforeText.split(`
+`), after = afterText.split(`
+`), rows = before.length, cols = after.length, lcs = Array.from({ length: rows + 1 }, () => Array(cols + 1).fill(0));
+  for (let i2 = rows - 1; i2 >= 0; i2--)
+    for (let j2 = cols - 1; j2 >= 0; j2--)
+      lcs[i2][j2] = before[i2] === after[j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
+  let lines = ["--- before", "+++ after"], i = 0, j = 0;
+  for (; i < rows || j < cols; ) {
+    if (i < rows && j < cols && before[i] === after[j]) {
+      lines.push(`  ${before[i]}`), i++, j++;
+      continue;
+    }
+    if (j < cols && (i === rows || lcs[i][j + 1] >= lcs[i + 1][j])) {
+      lines.push(`+ ${after[j]}`), j++;
+      continue;
+    }
+    i < rows && (lines.push(`- ${before[i]}`), i++);
+  }
+  return lines.join(`
+`);
+}
+function buildConfigWritePreview(filePath, nextRaw) {
+  let existed = existsSync(filePath), beforeRaw = readRawConfigObject(filePath), beforeText = existed ? serializeRawConfig(beforeRaw) : "", afterText = serializeRawConfig(nextRaw);
+  return {
+    path: filePath,
+    existed,
+    changed: beforeText !== afterText,
+    beforeText,
+    afterText,
+    diffText: buildUnifiedDiff(beforeText, afterText)
+  };
+}
+function readRawConfigObject(filePath) {
+  if (!existsSync(filePath))
+    return {};
+  try {
+    let raw = JSON.parse(readFileSync(filePath, "utf-8"));
+    return raw && typeof raw == "object" && !Array.isArray(raw) ? raw : {};
+  } catch {
+    return {};
+  }
+}
+function writeRawConfigObject(filePath, raw) {
+  mkdirSync(dirname(filePath), { recursive: !0 });
+  let tmpPath = `${filePath}.${process.pid}.tmp`;
+  writeFileSync(tmpPath, `${JSON.stringify(raw, null, 2)}
+`, "utf-8"), renameSync(tmpPath, filePath);
+}
+function getServersObject(raw) {
+  let existing = raw.mcpServers ?? raw["mcp-servers"] ?? {};
+  return !existing || typeof existing != "object" || Array.isArray(existing) ? {} : existing;
+}
+function setServersObject(raw, servers) {
+  delete raw["mcp-servers"], raw.mcpServers = servers;
+}
+function isRepoPromptServer(name, entry) {
+  let normalizedName = name.toLowerCase();
+  if (normalizedName.includes("repoprompt") || normalizedName === "rp")
+    return !0;
+  let command = entry.command?.toLowerCase() ?? "";
+  return command.includes("repoprompt") || command.includes("rp-mcp") || command.endsWith("repoprompt_cli") ? !0 : (entry.args ?? []).some((arg) => typeof arg == "string" && arg.toLowerCase().includes("repoprompt"));
+}
+function findProjectRoot(cwd = process.cwd()) {
+  let current = resolve(cwd);
+  for (; ; ) {
+    if (existsSync(join(current, ".git")) || existsSync(join(current, "package.json")) || existsSync(join(current, PROJECT_CONFIG_NAME)) || existsSync(join(current, ".pi")) || existsSync(join(current, ".lunr")))
+      return current;
+    let parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function buildRepoPromptEntry(executablePath) {
+  return {
+    command: executablePath,
+    args: [],
+    lifecycle: "lazy"
+  };
+}
+function detectRepoPrompt(summary, cwd = process.cwd()) {
+  for (let source of summary.sources) {
+    if (source.kind !== "shared" || source.serverCount === 0)
+      continue;
+    let config = readValidatedConfig(source.path, `MCP config from ${source.path}`);
+    if (config) {
+      for (let [name, entry] of Object.entries(config.mcpServers))
+        if (isRepoPromptServer(name, entry))
+          return { configured: !0, configuredPath: source.path };
+    }
+  }
+  let executablePath = REPOPROMPT_BINARY_CANDIDATES.find((candidate) => existsSync(candidate));
+  if (!executablePath)
+    return { configured: !1 };
+  let projectRoot = findProjectRoot(cwd), targetPath = projectRoot ? join(projectRoot, PROJECT_CONFIG_NAME) : GENERIC_GLOBAL_CONFIG_PATH;
+  return {
+    configured: !1,
+    executablePath,
+    targetPath,
+    serverName: "repoprompt",
+    entry: buildRepoPromptEntry(executablePath)
+  };
+}
+function previewCompatibilityImports(importKinds, overridePath) {
+  let targetPath = getPiGlobalConfigPath(overridePath), raw = readRawConfigObject(targetPath), currentImports = Array.isArray(raw.imports) ? raw.imports.filter((value) => typeof value == "string") : [], merged = [.../* @__PURE__ */ new Set([...currentImports, ...importKinds])], nextRaw = { ...raw, imports: merged };
+  return setServersObject(nextRaw, getServersObject(nextRaw)), buildConfigWritePreview(targetPath, nextRaw);
+}
+function ensureCompatibilityImports(importKinds, overridePath) {
+  let targetPath = getPiGlobalConfigPath(overridePath), raw = readRawConfigObject(targetPath), currentImports = Array.isArray(raw.imports) ? raw.imports.filter((value) => typeof value == "string") : [], merged = [.../* @__PURE__ */ new Set([...currentImports, ...importKinds])], added = merged.filter((kind) => !currentImports.includes(kind));
+  if (added.length === 0)
+    return { path: targetPath, added: [] };
+  raw.imports = merged;
+  let servers = getServersObject(raw);
+  return setServersObject(raw, servers), writeRawConfigObject(targetPath, raw), { path: targetPath, added };
+}
+function buildStarterProjectConfig() {
+  return {
+    mcpServers: {}
+  };
+}
+function previewStarterProjectConfig(cwd = process.cwd()) {
+  let targetPath = getProjectConfigPath(cwd), nextRaw = { mcpServers: buildStarterProjectConfig().mcpServers };
+  return buildConfigWritePreview(targetPath, nextRaw);
+}
+function writeStarterProjectConfig(cwd = process.cwd()) {
+  let targetPath = getProjectConfigPath(cwd), raw = { mcpServers: buildStarterProjectConfig().mcpServers };
+  return writeRawConfigObject(targetPath, raw), targetPath;
+}
+function previewSharedServerEntry(filePath, serverName, entry) {
+  let nextRaw = { ...readRawConfigObject(filePath) }, servers = getServersObject(nextRaw);
+  return servers[serverName] = entry, setServersObject(nextRaw, servers), buildConfigWritePreview(filePath, nextRaw);
+}
+function writeSharedServerEntry(filePath, serverName, entry) {
+  let raw = readRawConfigObject(filePath), servers = getServersObject(raw);
+  return servers[serverName] = entry, setServersObject(raw, servers), writeRawConfigObject(filePath, raw), filePath;
+}
+function getServerProvenance(overridePath, cwd = process.cwd()) {
+  let provenance = /* @__PURE__ */ new Map(), userPath = getPiGlobalConfigPath(overridePath);
+  for (let source of getConfigSources(overridePath, cwd)) {
+    let loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
+    if (loaded) {
+      if (loaded.imports?.length)
+        for (let importKind of loaded.imports) {
+          let importPath = resolveImportPath(importKind, cwd);
+          if (importPath)
+            try {
+              let imported = JSON.parse(readFileSync(importPath, "utf-8")), servers = extractServers(imported, importKind);
+              for (let name of Object.keys(servers))
+                provenance.has(name) || provenance.set(name, { path: userPath, kind: "import", importKind });
+            } catch {
+            }
+        }
+      for (let name of Object.keys(loaded.mcpServers))
+        provenance.set(name, {
+          path: source.writePath,
+          kind: source.kind,
+          importKind: source.importKind
+        });
+    }
+  }
+  return provenance;
+}
+function writeDirectToolsConfig(changes, provenance, fullConfig) {
+  let byPath = /* @__PURE__ */ new Map();
+  for (let [serverName, value] of changes) {
+    let prov = provenance.get(serverName);
+    if (!prov)
+      continue;
+    let targetPath = prov.path;
+    byPath.has(targetPath) || byPath.set(targetPath, []), byPath.get(targetPath).push({ name: serverName, value, prov });
+  }
+  for (let [filePath, entries] of byPath) {
+    let raw = readRawConfigObject(filePath), servers = getServersObject(raw);
+    for (let { name, value, prov } of entries)
+      if (prov.kind === "import") {
+        let fullDef = fullConfig.mcpServers[name];
+        fullDef && (servers[name] = { ...fullDef, directTools: value });
+      } else servers[name] && (servers[name] = { ...servers[name], directTools: value });
+    setServersObject(raw, servers), writeRawConfigObject(filePath, raw);
+  }
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/utils.js
+import { homedir as homedir2, platform } from "node:os";
+import { join as join2 } from "node:path";
+async function execOpen(pi, target, browser) {
+  let os = platform();
+  return os === "darwin" ? browser ? pi.exec("open", ["-a", browser, target]) : pi.exec("open", [target]) : os === "win32" ? browser ? pi.exec("cmd", ["/c", "start", "", browser, target]) : pi.exec("cmd", ["/c", "start", "", target]) : browser ? pi.exec(browser, [target]) : pi.exec("xdg-open", [target]);
+}
+async function openUrl(pi, url, browser) {
+  let result = await execOpen(pi, url, browser);
+  if (result.code !== 0)
+    throw new Error(result.stderr || `Failed to open browser (exit code ${result.code})`);
+}
+async function openPath(pi, targetPath) {
+  let result = await execOpen(pi, targetPath);
+  if (result.code !== 0)
+    throw new Error(result.stderr || `Failed to open path (exit code ${result.code})`);
+}
+async function parallelLimit(items, limit, fn) {
+  let results = [], index = 0;
+  async function worker() {
+    for (; index < items.length; ) {
+      let i = index++;
+      results[i] = await fn(items[i]);
+    }
+  }
+  let workers = Array(Math.min(limit, items.length)).fill(null).map(() => worker());
+  return await Promise.all(workers), results;
+}
+function getConfigPathFromArgv() {
+  let idx = process.argv.indexOf("--mcp-config");
+  if (idx >= 0 && idx + 1 < process.argv.length)
+    return process.argv[idx + 1];
+}
+function interpolateEnvVars(value) {
+  return value.replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] ?? "").replace(/\$env:(\w+)/g, (_, name) => process.env[name] ?? "");
+}
+function interpolateEnvRecord(values) {
+  if (!values)
+    return;
+  let resolved = {};
+  for (let [key, value] of Object.entries(values))
+    resolved[key] = interpolateEnvVars(value);
+  return resolved;
+}
+function resolveConfigPath(value) {
+  if (value === void 0)
+    return;
+  let resolved = interpolateEnvVars(value);
+  return resolved === "~" ? homedir2() : resolved.startsWith("~/") || resolved.startsWith("~\\") ? join2(homedir2(), resolved.slice(2)) : resolved;
+}
+function resolveBearerToken(definition) {
+  return definition.bearerToken !== void 0 ? interpolateEnvVars(definition.bearerToken) : definition.bearerTokenEnv ? process.env[definition.bearerTokenEnv] : void 0;
+}
+function truncateAtWord(text, target) {
+  if (!text || text.length <= target)
+    return text;
+  let truncated = text.slice(0, target), lastSpace = truncated.lastIndexOf(" ");
+  return lastSpace > target * 0.6 ? truncated.slice(0, lastSpace) + "..." : truncated + "...";
+}
+function normalizeDirectToolInputSchema(schema) {
+  let inputSchema = schema && typeof schema == "object" && !Array.isArray(schema) ? schema : { type: "object", properties: {} }, { $schema, additionalProperties, ...normalized } = inputSchema;
+  return normalized;
+}
+function formatAuthRequiredMessage(config, serverName, defaultMessage) {
+  let template = config.settings?.authRequiredMessage;
+  return template ? template.replaceAll("${server}", serverName) : defaultMessage;
+}
+function extractToolUiStreamMode(toolMeta) {
+  let uiMeta = toolMeta?.ui;
+  if (!uiMeta || typeof uiMeta != "object")
+    return;
+  let streamMode = uiMeta["pi-mcp-adapter.streamMode"];
+  if (streamMode === "eager" || streamMode === "stream-first")
+    return streamMode;
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/metadata-cache.js
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync as renameSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
+var CACHE_VERSION = 1, CACHE_MAX_AGE_MS = 10080 * 60 * 1e3;
+function getMetadataCachePath() {
+  return getAgentPath("mcp-cache.json");
+}
+function loadMetadataCache() {
+  let cachePath = getMetadataCachePath();
+  if (!existsSync2(cachePath))
+    return null;
+  try {
+    let raw = JSON.parse(readFileSync2(cachePath, "utf-8"));
+    return !raw || typeof raw != "object" || raw.version !== CACHE_VERSION || !raw.servers || typeof raw.servers != "object" ? null : raw;
+  } catch {
+    return null;
+  }
+}
+function saveMetadataCache(cache) {
+  let cachePath = getMetadataCachePath(), dir = dirname2(cachePath);
+  mkdirSync2(dir, { recursive: !0 });
+  let merged = { version: CACHE_VERSION, servers: {} };
+  try {
+    if (existsSync2(cachePath)) {
+      let existing = JSON.parse(readFileSync2(cachePath, "utf-8"));
+      existing && existing.version === CACHE_VERSION && existing.servers && (merged.servers = { ...existing.servers });
+    }
+  } catch {
+  }
+  merged.version = CACHE_VERSION, merged.servers = { ...merged.servers, ...cache.servers };
+  let tmpPath = `${cachePath}.${process.pid}.tmp`;
+  writeFileSync2(tmpPath, JSON.stringify(merged, null, 2), "utf-8"), renameSync2(tmpPath, cachePath);
+}
+function computeServerHash(definition) {
+  let identity = {
+    command: definition.command,
+    args: definition.args,
+    env: interpolateEnvRecord(definition.env),
+    cwd: resolveConfigPath(definition.cwd),
+    url: definition.url,
+    headers: interpolateEnvRecord(definition.headers),
+    auth: definition.auth,
+    bearerToken: resolveBearerToken(definition),
+    bearerTokenEnv: definition.bearerTokenEnv,
+    exposeResources: definition.exposeResources,
+    excludeTools: definition.excludeTools
+  }, normalized = stableStringify(identity);
+  return createHash("sha256").update(normalized).digest("hex");
+}
+function isServerCacheValid(entry, definition, maxAgeMs = CACHE_MAX_AGE_MS) {
+  return !(!entry || entry.configHash !== computeServerHash(definition) || !entry.cachedAt || typeof entry.cachedAt != "number" || maxAgeMs > 0 && Date.now() - entry.cachedAt > maxAgeMs);
+}
+function reconstructToolMetadata(serverName, entry, prefix, definition) {
+  let metadata = [];
+  for (let tool of entry.tools ?? [])
+    tool?.name && (isToolExcluded(tool.name, serverName, prefix, definition.excludeTools) || metadata.push({
+      name: formatToolName(tool.name, serverName, prefix),
+      originalName: tool.name,
+      description: tool.description ?? "",
+      inputSchema: tool.inputSchema,
+      uiResourceUri: tool.uiResourceUri,
+      uiStreamMode: tool.uiStreamMode
+    }));
+  if (definition.exposeResources !== !1)
+    for (let resource of entry.resources ?? []) {
+      if (!resource?.name || !resource?.uri)
+        continue;
+      let baseName = `get_${resourceNameToToolName(resource.name)}`;
+      isToolExcluded(baseName, serverName, prefix, definition.excludeTools) || metadata.push({
+        name: formatToolName(baseName, serverName, prefix),
+        originalName: baseName,
+        description: resource.description ?? `Read resource: ${resource.uri}`,
+        resourceUri: resource.uri
+      });
+    }
+  return metadata;
+}
+function serializeTools(tools) {
+  return tools.filter((t) => t?.name).map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: t.inputSchema,
+    uiResourceUri: tryGetToolUiResourceUri(t),
+    uiStreamMode: extractToolUiStreamMode(t._meta)
+  }));
+}
+function serializeResources(resources) {
+  return resources.filter((r) => r?.name && r?.uri).map((r) => ({
+    uri: r.uri,
+    name: r.name,
+    description: r.description
+  }));
+}
+function stableStringify(value) {
+  if (value == null || typeof value != "object") {
+    let serialized = JSON.stringify(value);
+    return serialized === void 0 ? "undefined" : serialized;
+  }
+  if (Array.isArray(value))
+    return `[${value.map((v) => stableStringify(v)).join(",")}]`;
+  let obj = value;
+  return `{${Object.keys(obj).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
+}
+var requireExtApps = createRequire(new URL("../builtin-extensions/pi-mcp-adapter/metadata-cache.js", import.meta.url).href), getToolUiResourceUri;
+function tryGetToolUiResourceUri(tool) {
+  try {
+    return getToolUiResourceUri || (getToolUiResourceUri = requireExtApps("@modelcontextprotocol/ext-apps/app-bridge").getToolUiResourceUri), getToolUiResourceUri({ _meta: tool._meta });
+  } catch {
+    return;
+  }
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/direct-tools.js
+var BUILTIN_NAMES = /* @__PURE__ */ new Set(["read", "bash", "edit", "write", "grep", "find", "ls", "mcp"]);
+function resolveDirectTools(config, cache, prefix, envOverride) {
+  let specs = [];
+  if (!cache)
+    return specs;
+  let seenNames = /* @__PURE__ */ new Set(), envServers = /* @__PURE__ */ new Set(), envTools = /* @__PURE__ */ new Map();
+  if (envOverride)
+    for (let item of envOverride)
+      if (item = item.replace(/\/+$/, ""), item.includes("/")) {
+        let [server, tool] = item.split("/", 2);
+        server && tool ? (envTools.has(server) || envTools.set(server, /* @__PURE__ */ new Set()), envTools.get(server).add(tool)) : server && envServers.add(server);
+      } else item && envServers.add(item);
+  let globalDirect = config.settings?.directTools;
+  for (let [serverName, definition] of Object.entries(config.mcpServers)) {
+    let serverCache = cache.servers[serverName];
+    if (!serverCache || !isServerCacheValid(serverCache, definition))
+      continue;
+    let toolFilter = !1;
+    if (envOverride ? envServers.has(serverName) ? toolFilter = !0 : envTools.has(serverName) && (toolFilter = [...envTools.get(serverName)]) : definition.directTools !== void 0 ? toolFilter = definition.directTools : globalDirect && (toolFilter = globalDirect), !!toolFilter) {
+      for (let tool of serverCache.tools ?? []) {
+        if (toolFilter !== !0 && !toolFilter.includes(tool.name) || isToolExcluded(tool.name, serverName, prefix, definition.excludeTools))
+          continue;
+        let prefixedName = formatToolName(tool.name, serverName, prefix);
+        if (BUILTIN_NAMES.has(prefixedName)) {
+          console.warn(`MCP: skipping direct tool "${prefixedName}" (collides with builtin)`);
+          continue;
+        }
+        if (seenNames.has(prefixedName)) {
+          console.warn(`MCP: skipping duplicate direct tool "${prefixedName}" from "${serverName}"`);
+          continue;
+        }
+        seenNames.add(prefixedName), specs.push({
+          serverName,
+          originalName: tool.name,
+          prefixedName,
+          description: tool.description ?? "",
+          inputSchema: tool.inputSchema,
+          uiResourceUri: tool.uiResourceUri,
+          uiStreamMode: tool.uiStreamMode
+        });
+      }
+      if (definition.exposeResources !== !1)
+        for (let resource of serverCache.resources ?? []) {
+          let baseName = `get_${resourceNameToToolName(resource.name)}`;
+          if (toolFilter !== !0 && !toolFilter.includes(baseName) || isToolExcluded(baseName, serverName, prefix, definition.excludeTools))
+            continue;
+          let prefixedName = formatToolName(baseName, serverName, prefix);
+          if (BUILTIN_NAMES.has(prefixedName)) {
+            console.warn(`MCP: skipping direct resource tool "${prefixedName}" (collides with builtin)`);
+            continue;
+          }
+          if (seenNames.has(prefixedName)) {
+            console.warn(`MCP: skipping duplicate direct resource tool "${prefixedName}" from "${serverName}"`);
+            continue;
+          }
+          seenNames.add(prefixedName), specs.push({
+            serverName,
+            originalName: baseName,
+            prefixedName,
+            description: resource.description ?? `Read resource: ${resource.uri}`,
+            resourceUri: resource.uri
+          });
+        }
+    }
+  }
+  return specs;
+}
+function getMissingConfiguredDirectToolServers(config, cache) {
+  let missing = [], globalDirect = config.settings?.directTools;
+  for (let [serverName, definition] of Object.entries(config.mcpServers)) {
+    if (!(definition.directTools !== void 0 ? !!definition.directTools : !!globalDirect))
+      continue;
+    let serverCache = cache?.servers?.[serverName];
+    (!serverCache || !isServerCacheValid(serverCache, definition)) && missing.push(serverName);
+  }
+  return missing;
+}
+function buildProxyDescription(config, cache, directSpecs) {
+  let prefix = config.settings?.toolPrefix ?? "server", desc = `MCP gateway - connect to MCP servers and call their tools. Non-MCP Pi tools should be called directly, not through mcp.
+`, directByServer = /* @__PURE__ */ new Map();
+  for (let spec of directSpecs)
+    directByServer.set(spec.serverName, (directByServer.get(spec.serverName) ?? 0) + 1);
+  if (directByServer.size > 0) {
+    let parts = [...directByServer.entries()].map(([server, count]) => `${server} (${count})`);
+    desc += `
+Direct tools available (call as normal tools): ${parts.join(", ")}
+`;
+  }
+  let serverSummaries = [];
+  for (let serverName of Object.keys(config.mcpServers)) {
+    let entry = cache?.servers?.[serverName], definition = config.mcpServers[serverName], toolCount = (entry?.tools ?? []).filter((tool) => !isToolExcluded(tool.name, serverName, prefix, definition.excludeTools)).length, resourceCount = definition?.exposeResources !== !1 ? (entry?.resources ?? []).filter((resource) => {
+      let baseName = `get_${resourceNameToToolName(resource.name)}`;
+      return !isToolExcluded(baseName, serverName, prefix, definition.excludeTools);
+    }).length : 0, totalItems = toolCount + resourceCount;
+    if (totalItems === 0)
+      continue;
+    let directCount = directByServer.get(serverName) ?? 0, proxyCount = totalItems - directCount;
+    proxyCount > 0 && serverSummaries.push(`${serverName} (${proxyCount} tools)`);
+  }
+  return serverSummaries.length > 0 && (desc += `
+Servers: ${serverSummaries.join(", ")}
+`), desc += `
+Usage:
+`, desc += `  mcp({ })                              \u2192 Show server status
+`, desc += `  mcp({ server: "name" })               \u2192 List tools from server
+`, desc += `  mcp({ search: "query" })              \u2192 Search MCP tools by name/description
+`, desc += `  mcp({ describe: "tool_name" })        \u2192 Show tool details and parameters
+`, desc += `  mcp({ connect: "server-name" })       \u2192 Connect to a server and refresh metadata
+`, desc += `  mcp({ tool: "name", args: '{"key": "value"}' })    \u2192 Call a tool (args is JSON string)
+`, desc += `  mcp({ action: "ui-messages" })        \u2192 Retrieve accumulated messages from completed UI sessions
+`, desc += `  mcp({ action: "auth-start", server: "name" })      \u2192 Start manual OAuth and get a browser URL
+`, desc += `  mcp({ action: "auth-complete", server: "name", args: '{"redirectUrl":"..."}' }) \u2192 Complete manual OAuth
+`, desc += `
+Mode: action > tool (call) > connect > describe > search > server (list) > nothing (status)`, desc;
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/abort.js
+function throwIfAborted(signal) {
+  if (signal?.aborted)
+    throw signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason ?? "MCP request aborted"));
+}
+async function abortable(promise, signal) {
+  return signal ? (throwIfAborted(signal), await new Promise((resolve2, reject) => {
+    let settled = !1, cleanup = () => signal.removeEventListener("abort", onAbort), onAbort = () => {
+      settled || (settled = !0, cleanup(), reject(signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason ?? "MCP request aborted"))));
+    };
+    signal.addEventListener("abort", onAbort, { once: !0 }), promise.then((value) => {
+      settled || (settled = !0, cleanup(), resolve2(value));
+    }, (error) => {
+      settled || (settled = !0, cleanup(), reject(error));
+    });
+  })) : promise;
+}
+
+export {
+  getMcpDiscoverySummary,
+  loadMcpConfig,
+  previewCompatibilityImports,
+  ensureCompatibilityImports,
+  previewStarterProjectConfig,
+  writeStarterProjectConfig,
+  previewSharedServerEntry,
+  writeSharedServerEntry,
+  getServerProvenance,
+  writeDirectToolsConfig,
+  openUrl,
+  openPath,
+  parallelLimit,
+  getConfigPathFromArgv,
+  interpolateEnvRecord,
+  resolveConfigPath,
+  resolveBearerToken,
+  truncateAtWord,
+  normalizeDirectToolInputSchema,
+  formatAuthRequiredMessage,
+  extractToolUiStreamMode,
+  getMetadataCachePath,
+  loadMetadataCache,
+  saveMetadataCache,
+  computeServerHash,
+  isServerCacheValid,
+  reconstructToolMetadata,
+  serializeTools,
+  serializeResources,
+  resolveDirectTools,
+  getMissingConfiguredDirectToolServers,
+  buildProxyDescription,
+  throwIfAborted,
+  abortable
+};