@introspection-ai/recipes 0.13.0 → 0.14.0

package/dist/mcp-chunks/chunk-7FHEBT5G.js

@@ -0,0 +1,149 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  legacyMcporterDir
+} from "./chunk-ECIVB7P4.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/runtime/record-transport.js
+import fs from "node:fs/promises";
+import path from "node:path";
+var initializedRecordingPaths = /* @__PURE__ */ new Map();
+var PRIVATE_RECORDING_DIR_MODE = 448;
+var PRIVATE_RECORDING_FILE_MODE = 384;
+var RecordTransport = class {
+  opts;
+  onclose;
+  onerror;
+  onmessage;
+  sessionId;
+  finishAuth;
+  writes = Promise.resolve();
+  closeRecorded = false;
+  constructor(opts) {
+    this.opts = opts;
+    this.sessionId = opts.inner.sessionId;
+    const finishAuth = opts.inner.finishAuth;
+    if (finishAuth) {
+      this.finishAuth = (authorizationCode) => finishAuth.call(opts.inner, authorizationCode);
+    }
+  }
+  get pid() {
+    const pid = this.opts.inner.pid;
+    return typeof pid === "number" && pid > 0 ? pid : null;
+  }
+  get _process() {
+    return this.opts.inner._process ?? null;
+  }
+  async start() {
+    await initializeRecordingFile(this.opts.recordPath);
+    this.opts.inner.onclose = () => {
+      void this.appendCloseOnce();
+      this.onclose?.();
+    };
+    this.opts.inner.onerror = (error) => {
+      this.onerror?.(error);
+    };
+    this.opts.inner.onmessage = (message) => {
+      void this.appendLine(this.withMeta(message, "recv"));
+      this.onmessage?.(message);
+    };
+    await this.appendLifecycle("start");
+    await this.opts.inner.start();
+    this.sessionId = this.opts.inner.sessionId;
+  }
+  async send(message, options) {
+    await this.appendLine(this.withMeta(message, "send"));
+    await this.opts.inner.send(message, options);
+  }
+  async close() {
+    await this.appendCloseOnce();
+    await this.opts.inner.close();
+    await this.writes;
+  }
+  setProtocolVersion(version) {
+    this.opts.inner.setProtocolVersion?.(version);
+  }
+  async appendLifecycle(event) {
+    await this.appendLine(this.withMeta({
+      jsonrpc: "2.0",
+      method: `$transport/${event}`
+    }, "lifecycle"));
+  }
+  async appendCloseOnce() {
+    if (this.closeRecorded) {
+      return;
+    }
+    this.closeRecorded = true;
+    await this.appendLifecycle("close");
+  }
+  withMeta(message, dir) {
+    return {
+      ...message,
+      _meta: {
+        dir,
+        server: this.opts.server,
+        ts: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+  async appendLine(message) {
+    const line = `${JSON.stringify(message)}
+`;
+    this.writes = this.writes.then(async () => {
+      await ensurePrivateRecordingDir(this.opts.recordPath);
+      await fs.appendFile(this.opts.recordPath, line, {
+        encoding: "utf8",
+        mode: PRIVATE_RECORDING_FILE_MODE
+      });
+    });
+    await this.writes;
+  }
+};
+function initializeRecordingFile(recordPath) {
+  const existing = initializedRecordingPaths.get(recordPath);
+  if (existing) {
+    return existing;
+  }
+  const initialization = ensurePrivateRecordingDir(recordPath).then(() => fs.writeFile(recordPath, "", {
+    encoding: "utf8",
+    mode: PRIVATE_RECORDING_FILE_MODE
+  })).then(() => fs.chmod(recordPath, PRIVATE_RECORDING_FILE_MODE)).catch((error) => {
+    initializedRecordingPaths.delete(recordPath);
+    throw error;
+  });
+  initializedRecordingPaths.set(recordPath, initialization);
+  return initialization;
+}
+async function ensurePrivateRecordingDir(recordPath) {
+  const recordingDir = path.dirname(recordPath);
+  await fs.mkdir(recordingDir, {
+    recursive: true,
+    mode: PRIVATE_RECORDING_DIR_MODE
+  });
+  await fs.chmod(recordingDir, PRIVATE_RECORDING_DIR_MODE);
+}
+function resolveRecordingPath(sessionName) {
+  const normalized = normalizeRecordingSessionName(sessionName);
+  return path.join(legacyMcporterDir(), "recordings", `${normalized}.ndjson`);
+}
+function resolveRecordingConfigPath(sessionName) {
+  const normalized = normalizeRecordingSessionName(sessionName);
+  return path.join(legacyMcporterDir(), "recordings", `${normalized}.config.json`);
+}
+function normalizeRecordingSessionName(sessionName) {
+  const normalized = sessionName.trim();
+  if (!normalized) {
+    throw new Error("Recording session name is required.");
+  }
+  if (normalized.includes("/") || normalized.includes("\\") || normalized === "." || normalized === "..") {
+    throw new Error(`Invalid recording session name '${sessionName}'. Use a simple file name without path separators.`);
+  }
+  return normalized;
+}
+
+export {
+  PRIVATE_RECORDING_FILE_MODE,
+  RecordTransport,
+  ensurePrivateRecordingDir,
+  resolveRecordingPath,
+  resolveRecordingConfigPath
+};

package/dist/mcp-chunks/chunk-7KA2VJVZ.js

@@ -0,0 +1,114 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  dimText,
+  extraDimText,
+  redText,
+  yellowText
+} from "./chunk-N46NEFAF.js";
+import {
+  analyzeConnectionError
+} from "./chunk-UKYNQGNE.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/path-utils.js
+import os from "node:os";
+import path from "node:path";
+function formatPathForDisplay(filePath) {
+  const cwd = process.cwd();
+  const relative = path.relative(cwd, filePath);
+  const displayPath = relative && !relative.startsWith("..") && !path.isAbsolute(relative) ? relative : filePath.replace(os.homedir(), "~");
+  return displayPath;
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/list-format.js
+function renderServerListRow(result, timeoutMs, options = {}) {
+  const description = result.server.description ? dimText(` \u2014 ${result.server.description}`) : "";
+  const durationLabel = dimText(`${(result.durationMs / 1e3).toFixed(1)}s`);
+  const sourceSuffix = formatSourceSuffix(result.server.sources ?? result.server.source, false, {
+    verbose: options.verbose
+  });
+  const prefix = `- ${result.server.name}${description}`;
+  if (result.status === "ok") {
+    const toolSuffix = result.tools.length === 0 ? "no tools reported" : `${result.tools.length === 1 ? "1 tool" : `${result.tools.length} tools`}`;
+    return {
+      line: `${prefix} (${toolSuffix}, ${durationLabel})${sourceSuffix}`,
+      summary: toolSuffix,
+      category: "ok"
+    };
+  }
+  const timeoutSeconds = Math.round(timeoutMs / 1e3);
+  const advice = classifyListError(result.error, result.server.name, timeoutSeconds);
+  return {
+    line: `${prefix} (${advice.colored}, ${durationLabel})${sourceSuffix}`,
+    summary: advice.summary,
+    category: advice.category,
+    authCommand: advice.authCommand,
+    issue: advice.issue
+  };
+}
+function formatSourceSuffix(sourceOrSources, inline = false, options = {}) {
+  const sources = Array.isArray(sourceOrSources) ? [...sourceOrSources] : sourceOrSources ? [sourceOrSources] : [];
+  if (sources.length === 0) {
+    return "";
+  }
+  const verbose = options.verbose ?? false;
+  if (!verbose) {
+    const primary2 = sources[0];
+    if (primary2.kind !== "import") {
+      return "";
+    }
+    const formatted = formatPathForDisplay(primary2.path);
+    const tinted2 = extraDimText(inline ? formatted : `[source: ${formatted}]`);
+    return inline ? tinted2 : ` ${tinted2}`;
+  }
+  const [primary, ...alternates] = sources;
+  const primaryLabel = buildSourceLabel(primary, { primary: true });
+  const altLabels = alternates.map((entry) => {
+    const shadowedByLocal = primary.kind === "local" && entry.kind !== "local";
+    return buildSourceLabel(entry, { shadowReason: shadowedByLocal ? "shadowed by local" : "shadowed" });
+  });
+  const label = altLabels.length === 0 ? `source: ${primaryLabel}` : `sources: ${[primaryLabel, ...altLabels].join(" \xB7 ")}`;
+  const tinted = extraDimText(inline ? label : `[${label}]`);
+  return inline ? tinted : ` ${tinted}`;
+}
+function buildSourceLabel(source, options) {
+  const base = formatPathForDisplay(source.path);
+  const tags = [];
+  if (options.primary) {
+    tags.push("primary");
+  }
+  if (options.shadowReason) {
+    tags.push(options.shadowReason);
+  }
+  if (source.importKind) {
+    tags.push(source.importKind);
+  }
+  return tags.length === 0 ? base : `${base} (${tags.join(", ")})`;
+}
+function classifyListError(error, serverName, _timeoutSeconds, options) {
+  const issue = analyzeConnectionError(error);
+  if (issue.kind === "auth") {
+    const authCommand = options?.authCommand ?? `mcporter auth ${serverName}`;
+    const note2 = yellowText(`auth required \u2014 run '${authCommand}'`);
+    return { colored: note2, summary: "auth required", category: "auth", authCommand, issue };
+  }
+  if (issue.kind === "offline") {
+    const note2 = redText("offline \u2014 unable to reach server");
+    return { colored: note2, summary: "offline", category: "offline", issue };
+  }
+  if (issue.kind === "http") {
+    const statusText = issue.statusCode ? `HTTP ${issue.statusCode}` : "HTTP error";
+    const detail = issue.rawMessage && issue.rawMessage !== String(issue.statusCode) ? ` \u2014 ${issue.rawMessage}` : "";
+    const note2 = redText(`${statusText}${detail}`);
+    return { colored: note2, summary: statusText.toLowerCase(), category: "http", issue };
+  }
+  const rawMessage = issue.rawMessage || "unknown error";
+  const note = redText(rawMessage);
+  return { colored: note, summary: rawMessage, category: "error", issue };
+}
+
+export {
+  formatPathForDisplay,
+  renderServerListRow,
+  formatSourceSuffix,
+  classifyListError
+};

package/dist/mcp-chunks/chunk-7UDVSOOF.js

@@ -0,0 +1,138 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  buildRecordCommandEnv
+} from "./chunk-J6LYIZXN.js";
+import {
+  PRIVATE_RECORDING_FILE_MODE,
+  ensurePrivateRecordingDir,
+  resolveRecordingConfigPath,
+  resolveRecordingPath
+} from "./chunk-7FHEBT5G.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/record-command.js
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+async function handleRecordCli(args) {
+  const parsed = parseRecordArgs(args);
+  const recordPath = resolveRecordingPath(parsed.sessionName);
+  if (parsed.command.length > 0) {
+    await runWithRecordingEnv(parsed, buildRecordCommandEnv(parsed.sessionName, parsed.server));
+    return;
+  }
+  await writeModeConfig(parsed, {
+    mode: "record",
+    recordPath,
+    env: {
+      MCPORTER_RECORD: parsed.sessionName,
+      ...parsed.server ? { MCPORTER_RECORD_SERVER: parsed.server } : {},
+      MCPORTER_DISABLE_KEEPALIVE: "*"
+    }
+  });
+  console.log(`Recording configuration written to ${resolveRecordingConfigPath(parsed.sessionName)}`);
+  const envInstructions = [
+    `MCPORTER_RECORD=${parsed.sessionName}`,
+    ...parsed.server ? [`MCPORTER_RECORD_SERVER=${parsed.server}`] : [],
+    "MCPORTER_DISABLE_KEEPALIVE=*"
+  ];
+  console.log(`Set ${envInstructions.join(" and ")} before the next mcporter call to record ${recordPath}.`);
+}
+function printRecordHelp() {
+  console.log(`Usage: mcporter record <session-name> [--server <name>] [-- <command-to-run>]
+
+Capture MCP JSON-RPC traffic to ~/.mcporter/recordings/<session-name>.ndjson.
+
+Flags:
+  --server <name>  Restrict recording to one configured server.`);
+}
+function parseRecordArgs(args) {
+  return parseSessionCommandArgs(args, "record");
+}
+function parseReplayArgs(args) {
+  return parseSessionCommandArgs(args, "replay");
+}
+async function writeModeConfig(parsed, extra) {
+  const configPath = resolveRecordingConfigPath(parsed.sessionName);
+  await ensurePrivateRecordingDir(configPath);
+  await fs.writeFile(configPath, `${JSON.stringify({
+    session: parsed.sessionName,
+    server: parsed.server,
+    ...extra
+  }, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: PRIVATE_RECORDING_FILE_MODE
+  });
+  await fs.chmod(configPath, PRIVATE_RECORDING_FILE_MODE);
+}
+async function runWithRecordingEnv(parsed, env) {
+  const [command, ...commandArgs] = parsed.command;
+  if (!command) {
+    return;
+  }
+  await new Promise((resolve, reject) => {
+    const child = spawn(command, commandArgs, {
+      stdio: "inherit",
+      env
+    });
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (signal) {
+        reject(new Error(`Command '${command}' exited from signal ${signal}.`));
+        return;
+      }
+      process.exitCode = code ?? 0;
+      resolve();
+    });
+  });
+}
+function parseSessionCommandArgs(args, commandName) {
+  let server;
+  const tokens = [...args];
+  const commandSeparator = tokens.indexOf("--");
+  const command = commandSeparator === -1 ? [] : tokens.splice(commandSeparator);
+  if (command[0] === "--") {
+    command.shift();
+  }
+  const remaining = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token) {
+      continue;
+    }
+    if (token === "--server") {
+      const value = tokens[index + 1];
+      if (!value) {
+        throw new Error("Flag '--server' requires a server name.");
+      }
+      server = value;
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("--server=")) {
+      server = token.slice("--server=".length);
+      if (!server) {
+        throw new Error("Flag '--server' requires a server name.");
+      }
+      continue;
+    }
+    if (token.startsWith("-")) {
+      throw new Error(`Unknown ${commandName} flag '${token}'.`);
+    }
+    remaining.push(token);
+  }
+  const sessionName = remaining[0];
+  if (!sessionName) {
+    throw new Error(`Usage: mcporter ${commandName} <session-name> [--server <name>] [-- <command-to-run>]`);
+  }
+  if (remaining.length > 1) {
+    throw new Error(`Unexpected ${commandName} argument '${remaining[1]}'. Put commands after '--'.`);
+  }
+  return { sessionName, server, command };
+}
+
+export {
+  handleRecordCli,
+  printRecordHelp,
+  parseRecordArgs,
+  parseReplayArgs
+};

package/dist/mcp-chunks/chunk-BNV3TPE4.js

@@ -0,0 +1,66 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/timeouts.js
+var DEFAULT_LIST_TIMEOUT_MS = 3e4;
+var DEFAULT_CALL_TIMEOUT_MS = 6e4;
+var POSITIVE_INTEGER_PATTERN = /^[1-9]\d*$/;
+function parsePositiveInteger(raw) {
+  if (!raw || !POSITIVE_INTEGER_PATTERN.test(raw)) {
+    return void 0;
+  }
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function parseTimeout(raw, fallback) {
+  if (!raw) {
+    return fallback;
+  }
+  return parsePositiveInteger(raw) ?? fallback;
+}
+var LIST_TIMEOUT_MS = parseTimeout(process.env.MCPORTER_LIST_TIMEOUT, DEFAULT_LIST_TIMEOUT_MS);
+function resolveCallTimeout(override) {
+  if (typeof override === "number" && Number.isFinite(override) && override > 0) {
+    return override;
+  }
+  return parseTimeout(process.env.MCPORTER_CALL_TIMEOUT, DEFAULT_CALL_TIMEOUT_MS);
+}
+function withTimeout(promise, timeoutMs) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return promise;
+  }
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error("Timeout"));
+    }, timeoutMs);
+    promise.then((value) => {
+      clearTimeout(timer);
+      resolve(value);
+    }, (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+function consumeTimeoutFlag(args, index, options) {
+  const flagName = options?.flagName ?? "--timeout";
+  const missingValueMessage = options?.missingValueMessage ?? `Flag '${flagName}' requires a value.`;
+  const value = args[index + 1];
+  if (!value) {
+    throw new Error(missingValueMessage);
+  }
+  const parsed = parsePositiveInteger(value);
+  if (parsed === void 0) {
+    throw new Error(`${flagName} must be a positive integer (milliseconds).`);
+  }
+  args.splice(index, 2);
+  return parsed;
+}
+
+export {
+  parsePositiveInteger,
+  parseTimeout,
+  LIST_TIMEOUT_MS,
+  resolveCallTimeout,
+  withTimeout,
+  consumeTimeoutFlag
+};

package/dist/mcp-chunks/chunk-BTLAWHTA.js

@@ -0,0 +1,129 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  logInfo,
+  logWarn
+} from "./chunk-UNKB4SBV.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/runtime-debug.js
+var DEBUG_HANG = process.env.MCPORTER_DEBUG_HANG === "1";
+function describeHandle(handle) {
+  if (!handle || typeof handle !== "object" && typeof handle !== "function") {
+    return String(handle);
+  }
+  const ctor = handle.constructor?.name ?? typeof handle;
+  if (ctor === "Socket") {
+    try {
+      const socket = handle;
+      const parts = ["Socket"];
+      if (socket.localAddress) {
+        parts.push(`local=${socket.localAddress}:${socket.localPort ?? "?"}`);
+      }
+      if (socket.remoteAddress) {
+        parts.push(`remote=${socket.remoteAddress}:${socket.remotePort ?? "?"}`);
+      }
+      if (typeof socket.address === "function") {
+        const addr = socket.address?.();
+        if (addr) {
+          parts.push(`addr=${addr.address}:${addr.port}`);
+        }
+      }
+      const host = handle._host;
+      if (host) {
+        parts.push(`host=${host}`);
+      }
+      const pipeName = handle.path;
+      if (pipeName) {
+        parts.push(`path=${pipeName}`);
+      }
+      const extraKeys = Reflect.ownKeys(handle).filter((key) => typeof key === "string" && key.startsWith("_") && !["_events", "_eventsCount"].includes(key)).slice(0, 4);
+      if (extraKeys.length > 0) {
+        parts.push(`keys=${extraKeys.join(",")}`);
+      }
+      return parts.join(" ");
+    } catch {
+      return ctor;
+    }
+  }
+  if (typeof handle === "object") {
+    const pid = handle.pid;
+    if (typeof pid === "number") {
+      return `${ctor} (pid=${pid})`;
+    }
+    const fd = handle.fd;
+    if (typeof fd === "number") {
+      return `${ctor} (fd=${fd})`;
+    }
+  }
+  return ctor;
+}
+function dumpActiveHandles(label) {
+  if (!DEBUG_HANG) {
+    return;
+  }
+  const proc = process;
+  const activeHandles = proc._getActiveHandles?.() ?? [];
+  const activeRequests = proc._getActiveRequests?.() ?? [];
+  logInfo(`[debug] ${label}: ${activeHandles.length} active handle(s), ${activeRequests.length} request(s)`);
+  for (const handle of activeHandles) {
+    logInfo(`[debug] handle => ${describeHandle(handle)}`);
+  }
+  for (const request of activeRequests) {
+    logInfo(`[debug] request => ${describeHandle(request)}`);
+  }
+}
+function terminateChildProcesses(label) {
+  const proc = process;
+  const handles = proc._getActiveHandles?.() ?? [];
+  for (const handle of handles) {
+    if (!handle || typeof handle !== "object") {
+      continue;
+    }
+    const candidate = handle;
+    const ctor = handle.constructor?.name ?? "";
+    if (ctor === "Socket" && typeof handle.destroy === "function") {
+      try {
+        handle.destroy?.();
+        if (typeof handle.unref === "function") {
+          handle.unref?.();
+        }
+      } catch {
+      }
+    }
+    if (typeof candidate.stdout?.destroy === "function") {
+      try {
+        candidate.stdout.destroy?.();
+      } catch {
+      }
+    }
+    if (typeof candidate.stderr?.destroy === "function") {
+      try {
+        candidate.stderr.destroy?.();
+      } catch {
+      }
+    }
+    if (typeof candidate.stdin?.end === "function") {
+      try {
+        candidate.stdin.end?.();
+      } catch {
+      }
+    }
+    if (DEBUG_HANG) {
+      const killed = candidate.kill?.("SIGKILL") ?? false;
+      if (candidate.pid) {
+        const outcome = killed ? "killed" : "kill-failed";
+        logWarn(`[debug] forcibly ${outcome} child pid=${candidate.pid} (${label})`);
+      }
+    } else if (typeof candidate.kill === "function" && typeof candidate.pid === "number" && !candidate.killed) {
+      try {
+        candidate.kill("SIGKILL");
+      } catch {
+      }
+    }
+  }
+}
+
+export {
+  DEBUG_HANG,
+  dumpActiveHandles,
+  terminateChildProcesses
+};

package/dist/mcp-chunks/chunk-BV56DXPW.js

@@ -0,0 +1,13 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/errors.js
+var CliUsageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CliUsageError";
+  }
+};
+
+export {
+  CliUsageError
+};

package/dist/mcp-chunks/chunk-BWHIA4PC.js

@@ -0,0 +1,90 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/identifier-helpers.js
+var AUTO_THRESHOLD_RATIO = 0.3;
+var AUTO_THRESHOLD_MIN = 2;
+function chooseClosestIdentifier(input, candidates) {
+  if (candidates.length === 0) {
+    return void 0;
+  }
+  const normalizedInput = normalizeIdentifier(input);
+  let bestName;
+  let bestScore = Number.POSITIVE_INFINITY;
+  for (const candidate of candidates) {
+    if (candidate === input) {
+      return { kind: "auto", value: candidate };
+    }
+    const normalizedCandidate = normalizeIdentifier(candidate);
+    if (normalizedCandidate === normalizedInput) {
+      return { kind: "auto", value: candidate };
+    }
+    if (candidate.toLowerCase() === input.toLowerCase()) {
+      return { kind: "auto", value: candidate };
+    }
+    const score = levenshtein(normalizedInput, normalizedCandidate);
+    if (score < bestScore) {
+      bestScore = score;
+      bestName = candidate;
+    }
+  }
+  if (!bestName) {
+    return void 0;
+  }
+  const normalizedBest = normalizeIdentifier(bestName);
+  const lengthBaseline = Math.max(normalizedInput.length, normalizedBest.length, 1);
+  const threshold = Math.max(AUTO_THRESHOLD_MIN, Math.floor(lengthBaseline * AUTO_THRESHOLD_RATIO));
+  if (bestScore <= threshold) {
+    return { kind: "auto", value: bestName };
+  }
+  return { kind: "suggest", value: bestName };
+}
+function normalizeIdentifier(value) {
+  return value.replace(/[^a-z0-9]/gi, "").toLowerCase();
+}
+function renderIdentifierResolutionMessages(context) {
+  const resolvedDisplay = context.entity === "tool" && context.scope ? `${context.scope}.${context.resolution.value}` : context.resolution.value;
+  const attemptedDisplay = context.entity === "tool" && context.scope ? `${context.scope}.${context.attempted}` : context.attempted;
+  if (context.resolution.kind === "auto") {
+    const noun = context.entity === "tool" ? "tool call" : "server name";
+    return {
+      auto: `[mcporter] Auto-corrected ${noun} to ${resolvedDisplay} (input: ${attemptedDisplay}).`
+    };
+  }
+  return {
+    suggest: `[mcporter] Did you mean ${resolvedDisplay}?`
+  };
+}
+function levenshtein(a, b) {
+  if (a === b) {
+    return 0;
+  }
+  if (a.length === 0) {
+    return b.length;
+  }
+  if (b.length === 0) {
+    return a.length;
+  }
+  const previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+  const current = Array.from({ length: b.length + 1 }, () => 0);
+  for (let i = 1; i <= a.length; i += 1) {
+    current[0] = i;
+    const charA = a[i - 1];
+    for (let j = 1; j <= b.length; j += 1) {
+      const charB = b[j - 1];
+      const insertCost = (current[j - 1] ?? Number.POSITIVE_INFINITY) + 1;
+      const deleteCost = (previous[j] ?? Number.POSITIVE_INFINITY) + 1;
+      const replaceCost = (previous[j - 1] ?? Number.POSITIVE_INFINITY) + (charA === charB ? 0 : 1);
+      current[j] = Math.min(insertCost, deleteCost, replaceCost);
+    }
+    for (let j = 0; j <= b.length; j += 1) {
+      previous[j] = current[j] ?? Number.POSITIVE_INFINITY;
+    }
+  }
+  return previous[b.length] ?? Number.POSITIVE_INFINITY;
+}
+
+export {
+  chooseClosestIdentifier,
+  normalizeIdentifier,
+  renderIdentifierResolutionMessages
+};