tare-mcp 0.2.0

package/dist/index.js

@@ -0,0 +1,2199 @@
+#!/usr/bin/env node
+
+// src/version.ts
+var VERSION = "0.2.0";
+
+// src/discovery/discoverConfigs.ts
+import os2 from "os";
+import path2 from "path";
+import fg from "fast-glob";
+
+// src/utils/fs.ts
+import { access, readFile } from "fs/promises";
+import os from "os";
+import path from "path";
+function expandHome(input, home = os.homedir()) {
+  if (input === "~") {
+    return home;
+  }
+  if (input.startsWith("~/")) {
+    return path.join(home, input.slice(2));
+  }
+  return input;
+}
+async function pathExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readUtf8(filePath) {
+  return readFile(filePath, "utf8");
+}
+
+// src/discovery/discoverConfigs.ts
+var LOCAL_CONFIG_PATTERNS = [".mcp.json", "mcp.json", ".cursor/mcp.json", ".vscode/mcp.json"];
+var HOME_CONFIG_PATTERNS = [
+  "~/.claude/mcp.json",
+  "~/Library/Application Support/Claude/claude_desktop_config.json",
+  "~/.config/Claude/claude_desktop_config.json",
+  "~/.config/claude/claude_desktop_config.json",
+  "~/.config/tare/mcp.json"
+];
+function getDefaultConfigCandidates(cwd = process.cwd(), home = os2.homedir()) {
+  return [
+    ...LOCAL_CONFIG_PATTERNS.map((candidate) => path2.resolve(cwd, candidate)),
+    ...HOME_CONFIG_PATTERNS.map((candidate) => expandHome(candidate, home))
+  ];
+}
+async function discoverConfigs(cwd = process.cwd(), home = os2.homedir()) {
+  const warnings = [];
+  const localMatches = await fg(LOCAL_CONFIG_PATTERNS, {
+    cwd,
+    absolute: true,
+    onlyFiles: true,
+    dot: true,
+    unique: true
+  });
+  const homeCandidates = HOME_CONFIG_PATTERNS.map((candidate) => expandHome(candidate, home));
+  const homeMatches = [];
+  for (const candidate of homeCandidates) {
+    if (await pathExists(candidate)) {
+      homeMatches.push(candidate);
+    }
+  }
+  const paths = [.../* @__PURE__ */ new Set([...localMatches, ...homeMatches])].sort();
+  return { paths, warnings };
+}
+
+// src/discovery/parseConfig.ts
+import { z as z2 } from "zod";
+
+// src/discovery/normalizeServer.ts
+import { z } from "zod";
+var ServerConfigSchema = z.record(z.string(), z.unknown());
+function readStringArray(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const strings = value.filter((entry) => typeof entry === "string");
+  return strings.length === value.length ? strings : void 0;
+}
+function readStringRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const entries = Object.entries(value);
+  const strings = entries.filter(
+    (entry) => typeof entry[1] === "string"
+  );
+  return strings.length === entries.length ? Object.fromEntries(strings) : void 0;
+}
+function inferTransport(config) {
+  const explicit = String(config.transport ?? config.type ?? "").toLowerCase();
+  if (explicit.includes("sse")) {
+    return "sse";
+  }
+  if (typeof config.command === "string") {
+    return "stdio";
+  }
+  if (typeof config.url === "string") {
+    return "streamable-http";
+  }
+  return "unknown";
+}
+function normalizeServer(name, rawConfig, sourceConfigPath) {
+  const parsed = ServerConfigSchema.safeParse(rawConfig);
+  if (!parsed.success) {
+    return {
+      warnings: [`${sourceConfigPath}: server "${name}" is malformed and was skipped.`]
+    };
+  }
+  const config = parsed.data;
+  const warnings = [];
+  const command = typeof config.command === "string" ? config.command : void 0;
+  const url = typeof config.url === "string" ? config.url : void 0;
+  const args = readStringArray(config.args);
+  const env = readStringRecord(config.env);
+  const headers = readStringRecord(config.headers);
+  if (config.args !== void 0 && !args) {
+    warnings.push(
+      `${sourceConfigPath}: server "${name}" has non-string args and they were ignored.`
+    );
+  }
+  if (config.env !== void 0 && !env) {
+    warnings.push(
+      `${sourceConfigPath}: server "${name}" has non-string env values and env was ignored.`
+    );
+  }
+  if (config.headers !== void 0 && !headers) {
+    warnings.push(
+      `${sourceConfigPath}: server "${name}" has non-string headers and headers were ignored.`
+    );
+  }
+  if (!command && !url) {
+    warnings.push(
+      `${sourceConfigPath}: server "${name}" has no command or url; transport is unknown.`
+    );
+  }
+  return {
+    server: {
+      name,
+      command,
+      args,
+      env,
+      url,
+      headers,
+      disabled: config.disabled === true,
+      sourceConfigPath,
+      transport: inferTransport(config)
+    },
+    warnings
+  };
+}
+
+// src/discovery/parseConfig.ts
+var ObjectSchema = z2.record(z2.string(), z2.unknown());
+function readServerMap(raw, keyPath) {
+  const segments = keyPath.split(".");
+  let current = raw;
+  for (const segment of segments) {
+    if (!current || typeof current !== "object" || Array.isArray(current)) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  if (!current || typeof current !== "object" || Array.isArray(current)) {
+    return void 0;
+  }
+  return current;
+}
+function parseConfigText(text, sourceConfigPath) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (error) {
+    return {
+      path: sourceConfigPath,
+      servers: [],
+      warnings: [`${sourceConfigPath}: malformed JSON (${error.message}).`]
+    };
+  }
+  const parsed = ObjectSchema.safeParse(raw);
+  if (!parsed.success) {
+    return {
+      path: sourceConfigPath,
+      servers: [],
+      warnings: [`${sourceConfigPath}: config root must be a JSON object.`]
+    };
+  }
+  const config = parsed.data;
+  const maps = [
+    readServerMap(config, "mcpServers"),
+    readServerMap(config, "servers"),
+    readServerMap(config, "mcp.servers")
+  ].filter((entry) => Boolean(entry));
+  const servers = [];
+  const warnings = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const map of maps) {
+    for (const [name, serverConfig] of Object.entries(map)) {
+      if (seen.has(name)) {
+        warnings.push(`${sourceConfigPath}: duplicate server "${name}" was ignored.`);
+        continue;
+      }
+      const normalized = normalizeServer(name, serverConfig, sourceConfigPath);
+      warnings.push(...normalized.warnings);
+      if (normalized.server) {
+        seen.add(name);
+        servers.push(normalized.server);
+      }
+    }
+  }
+  if (maps.length === 0) {
+    warnings.push(`${sourceConfigPath}: no MCP server map found.`);
+  }
+  return { path: sourceConfigPath, servers, warnings };
+}
+async function parseConfigFile(filePath) {
+  return parseConfigText(await readUtf8(filePath), filePath);
+}
+
+// src/inspectors/types.ts
+function toReportTransport(transport) {
+  if (transport === "stdio" || transport === "streamable-http" || transport === "sse") {
+    return transport;
+  }
+  if (transport === "http") {
+    return "streamable-http";
+  }
+  return "unknown";
+}
+
+// src/inspectors/staticInspector.ts
+function urlHost(url) {
+  if (!url) {
+    return void 0;
+  }
+  try {
+    return new URL(url).host;
+  } catch {
+    return void 0;
+  }
+}
+function createStaticInspection(server, mode = "static-insufficient", warnings) {
+  const defaultWarnings = mode === "static-insufficient" ? [
+    "Static inspection only sees MCP config, not exposed tool definitions.",
+    "Run without --no-exec to inspect actual tool schemas."
+  ] : [
+    "Live inspection failed. Server may require credentials, authorization, or failed during startup.",
+    "Static fallback cannot see actual tool definitions.",
+    "Run again after configuring credentials or headers."
+  ];
+  return {
+    name: server.name,
+    sourceConfigPath: server.sourceConfigPath,
+    transport: toReportTransport(server.transport),
+    command: server.command,
+    args: server.args,
+    urlHost: urlHost(server.url),
+    toolDefinitions: [],
+    inspectionMode: mode,
+    confidence: "low",
+    warnings: warnings ?? defaultWarnings
+  };
+}
+
+// src/inspectors/stdioMcpInspector.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+// src/utils/redact.ts
+var SECRET_KEY_PATTERN = /(authorization|api[_-]?key|token|secret|password|credential|bearer)/i;
+function collectSecretValues(...records) {
+  const values = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    for (const value of Object.values(record ?? {})) {
+      if (value && value.length > 2) {
+        values.add(value);
+      }
+    }
+  }
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value && value.length > 2 && SECRET_KEY_PATTERN.test(key)) {
+      values.add(value);
+    }
+  }
+  return [...values].sort((a, b) => b.length - a.length);
+}
+function redactText(input, secrets = []) {
+  let text = input instanceof Error ? input.message : String(input ?? "");
+  for (const secret of secrets) {
+    text = text.split(secret).join("[REDACTED]");
+  }
+  text = text.replace(/(Authorization\s*:\s*)([^\r\n]+)/gi, "$1[REDACTED]");
+  text = text.replace(/(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1[REDACTED]");
+  text = text.replace(
+    /((?:api[_-]?key|token|secret|password)\s*[=:]\s*)[^\s,;]+/gi,
+    "$1[REDACTED]"
+  );
+  return text;
+}
+function isLikelyCredentialError(text) {
+  return /(auth|credential|unauthori[sz]ed|forbidden|api key|token|permission|access denied)/i.test(
+    text
+  );
+}
+
+// src/utils/timeout.ts
+var TimeoutError = class extends Error {
+  constructor(message, timeoutMs) {
+    super(message);
+    this.timeoutMs = timeoutMs;
+    this.name = "TimeoutError";
+  }
+  timeoutMs;
+};
+async function withTimeout(work, timeoutMs, onTimeout) {
+  let timeout;
+  let didTimeout = false;
+  let cleanup;
+  const timeoutPromise = new Promise((_resolve, reject) => {
+    timeout = setTimeout(() => {
+      didTimeout = true;
+      cleanup = Promise.resolve(onTimeout?.()).then(() => void 0);
+      reject(new TimeoutError(`Timed out after ${timeoutMs}ms`, timeoutMs));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([work, timeoutPromise]);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    if (didTimeout) {
+      await cleanup?.catch(() => void 0);
+    }
+  }
+}
+function formatTimeout(timeoutMs) {
+  if (timeoutMs % 1e3 === 0) {
+    return `${timeoutMs / 1e3}s`;
+  }
+  return `${timeoutMs}ms`;
+}
+
+// src/inspectors/stdioMcpInspector.ts
+var EXCLUDED_TARE_ENV = /* @__PURE__ */ new Set([
+  "ANTHROPIC_API_KEY",
+  "TARE_CLAUDE_TOKENIZER",
+  "TARE_ANTHROPIC_MODEL",
+  "TARE_DISABLE_ANTHROPIC_TOKEN_API"
+]);
+function buildServerEnv(server) {
+  const base = Object.fromEntries(
+    Object.entries(process.env).filter(([key]) => !EXCLUDED_TARE_ENV.has(key)).filter((entry) => entry[1] !== void 0)
+  );
+  return { ...base, ...server.env ?? {} };
+}
+function normalizeTool(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    annotations: tool.annotations,
+    outputSchema: tool.outputSchema,
+    metadata: tool.metadata ?? tool._meta
+  };
+}
+async function listAllTools(client) {
+  const tools = [];
+  let cursor;
+  do {
+    const result = await client.listTools(cursor ? { cursor } : void 0);
+    tools.push(...result.tools.map(normalizeTool));
+    cursor = result.nextCursor;
+  } while (cursor);
+  return tools;
+}
+function failureWarnings(server, error, timeoutMs, stderr, secrets) {
+  const safeError = redactText(error, secrets);
+  const safeStderr = redactText(stderr, secrets).trim();
+  const combined = `${safeError}
+${safeStderr}`;
+  if (error instanceof TimeoutError) {
+    return [
+      `live inspection failed after ${formatTimeout(timeoutMs)}.`,
+      "Static config only sees command/args, not actual tool schemas.",
+      "Token estimate for this server is insufficient."
+    ];
+  }
+  if (isLikelyCredentialError(combined)) {
+    const warnings = [
+      "live inspection failed.",
+      "The server may require credentials or failed during startup.",
+      "Static config only sees command/args, not actual tool schemas.",
+      "Token estimate for this server is insufficient."
+    ];
+    const detail2 = safeStderr || safeError;
+    if (detail2) {
+      warnings.push(`Sanitized error: ${detail2}`);
+    }
+    return warnings;
+  }
+  const detail = safeStderr || safeError;
+  return [
+    "live inspection failed.",
+    "The server may require credentials or failed during startup.",
+    "Static config only sees command/args, not actual tool schemas.",
+    "Token estimate for this server is insufficient.",
+    detail ? `Sanitized error: ${detail}` : `${server.name}: no error detail was available.`
+  ];
+}
+async function inspectStdioServer(server, options) {
+  if (!server.command) {
+    return createStaticInspection(server, "fallback-static-insufficient", [
+      "live inspection failed.",
+      "Stdio server config has no command.",
+      "Static config only sees command/args, not actual tool schemas.",
+      "Token estimate for this server is insufficient."
+    ]);
+  }
+  const secrets = collectSecretValues(server.env);
+  const transport = new StdioClientTransport({
+    command: server.command,
+    args: server.args ?? [],
+    env: buildServerEnv(server),
+    stderr: "pipe"
+  });
+  const client = new Client({ name: "tare-mcp", version: VERSION }, { capabilities: {} });
+  let stderr = "";
+  transport.stderr?.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  const close = async () => {
+    await client.close().catch(() => void 0);
+    await transport.close().catch(() => void 0);
+  };
+  try {
+    const tools = await withTimeout(
+      (async () => {
+        await client.connect(transport);
+        return listAllTools(client);
+      })(),
+      options.timeoutMs,
+      close
+    );
+    await close();
+    return {
+      name: server.name,
+      sourceConfigPath: server.sourceConfigPath,
+      transport: "stdio",
+      command: server.command,
+      args: server.args,
+      toolDefinitions: tools,
+      inspectionMode: "live",
+      confidence: "high",
+      warnings: []
+    };
+  } catch (error) {
+    await close();
+    return createStaticInspection(
+      server,
+      "fallback-static-insufficient",
+      failureWarnings(server, error, options.timeoutMs, stderr, secrets)
+    );
+  }
+}
+
+// src/inspectors/streamableHttpMcpInspector.ts
+import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  StreamableHTTPClientTransport,
+  StreamableHTTPError
+} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+// src/utils/envInterpolation.ts
+var ENV_PATTERN = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+function resolveHeaderEnv(headers, env = process.env) {
+  const resolved = {};
+  const missing = /* @__PURE__ */ new Set();
+  for (const [key, value] of Object.entries(headers ?? {})) {
+    resolved[key] = value.replace(ENV_PATTERN, (_match, name) => {
+      const replacement = env[name];
+      if (!replacement) {
+        missing.add(name);
+        return "";
+      }
+      return replacement;
+    });
+  }
+  if (missing.size > 0) {
+    return { ok: false, headers: resolved, missing: [...missing] };
+  }
+  return { ok: true, headers: resolved, missing: [] };
+}
+
+// src/inspectors/streamableHttpMcpInspector.ts
+function normalizeTool2(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    annotations: tool.annotations,
+    outputSchema: tool.outputSchema,
+    metadata: tool.metadata ?? tool._meta
+  };
+}
+async function listAllTools2(client) {
+  const tools = [];
+  let cursor;
+  do {
+    const result = await client.listTools(cursor ? { cursor } : void 0);
+    tools.push(...result.tools.map(normalizeTool2));
+    cursor = result.nextCursor;
+  } while (cursor);
+  return tools;
+}
+function errorStatus(error) {
+  if (error instanceof StreamableHTTPError) {
+    return error.code;
+  }
+  if (error && typeof error === "object" && "status" in error) {
+    const status = Number(error.status);
+    return Number.isFinite(status) ? status : void 0;
+  }
+  const text = error instanceof Error ? error.message : String(error ?? "");
+  const match = text.match(/\b(401|403|404|405|415|500|502|503|504)\b/);
+  return match ? Number(match[1]) : void 0;
+}
+function failureWarnings2(error, timeoutMs, secrets) {
+  const status = errorStatus(error);
+  const safeError = redactText(error, secrets);
+  if (error instanceof TimeoutError) {
+    return [
+      `Streamable HTTP inspection failed after ${formatTimeout(timeoutMs)}.`,
+      "The server may require credentials, an Authorization header, or a valid MCP session.",
+      "Static config only sees URL/headers metadata, not actual tool schemas.",
+      "Token estimate for this server is insufficient."
+    ];
+  }
+  if (status === 401 || status === 403) {
+    const label = status === 401 ? "401 Unauthorized" : "403 Forbidden";
+    return [
+      `Streamable HTTP inspection failed with ${label}.`,
+      "The server requires valid credentials or Authorization headers.",
+      "Static fallback cannot see actual tool schemas."
+    ];
+  }
+  if (status === 404 || status === 405 || status === 415) {
+    return [
+      `Streamable HTTP inspection failed with ${status}.`,
+      "The URL may not be the MCP endpoint or may use a different transport.",
+      "Static fallback cannot see actual tool schemas."
+    ];
+  }
+  return [
+    "Streamable HTTP inspection failed.",
+    "The server may require credentials, an Authorization header, or a valid MCP session.",
+    "Static config only sees URL/headers metadata, not actual tool schemas.",
+    "Token estimate for this server is insufficient.",
+    safeError ? `Sanitized error: ${safeError}` : "No error detail was available."
+  ];
+}
+async function inspectStreamableHttpServer(server, options) {
+  if (!server.url) {
+    return createStaticInspection(server, "fallback-static-insufficient", [
+      "Streamable HTTP inspection failed.",
+      "HTTP server config has no url.",
+      "Static config only sees URL/headers metadata, not actual tool schemas.",
+      "Token estimate for this server is insufficient."
+    ]);
+  }
+  let url;
+  try {
+    url = new URL(server.url);
+  } catch {
+    return createStaticInspection(server, "fallback-static-insufficient", [
+      "Streamable HTTP inspection failed.",
+      "HTTP server config has an invalid url.",
+      "Static config only sees URL/headers metadata, not actual tool schemas.",
+      "Token estimate for this server is insufficient."
+    ]);
+  }
+  const headerResolution = resolveHeaderEnv(server.headers);
+  if (!headerResolution.ok) {
+    const firstMissing = headerResolution.missing[0] ?? "unknown";
+    const headerName = Object.keys(server.headers ?? {}).find(
+      (key) => (server.headers?.[key] ?? "").includes(firstMissing)
+    ) ?? "configured";
+    return createStaticInspection(server, "fallback-static-insufficient", [
+      `missing environment variable ${firstMissing} for ${headerName} header.`,
+      "Static config only sees URL/headers metadata, not actual tool schemas.",
+      "Token estimate for this server is insufficient."
+    ]);
+  }
+  const secrets = collectSecretValues(server.headers, headerResolution.headers);
+  const transport = new StreamableHTTPClientTransport(url, {
+    requestInit: {
+      headers: headerResolution.headers
+    },
+    fetch: options.fetch
+  });
+  const client = new Client2({ name: "tare-mcp", version: VERSION }, { capabilities: {} });
+  const close = async () => {
+    await client.close().catch(() => void 0);
+    await transport.close().catch(() => void 0);
+  };
+  try {
+    const tools = await withTimeout(
+      (async () => {
+        await client.connect(transport);
+        return listAllTools2(client);
+      })(),
+      options.timeoutMs,
+      close
+    );
+    await close();
+    return {
+      name: server.name,
+      sourceConfigPath: server.sourceConfigPath,
+      transport: "streamable-http",
+      urlHost: url.host,
+      toolDefinitions: tools,
+      inspectionMode: "live",
+      confidence: "high",
+      warnings: []
+    };
+  } catch (error) {
+    await close();
+    return createStaticInspection(
+      server,
+      "fallback-static-insufficient",
+      failureWarnings2(error, options.timeoutMs, secrets)
+    );
+  }
+}
+
+// src/utils/stableJson.ts
+function stableValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => stableValue(entry));
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    return Object.fromEntries(
+      Object.keys(record).sort().map((key) => [key, stableValue(record[key])])
+    );
+  }
+  return value;
+}
+function stableStringify(value) {
+  return JSON.stringify(stableValue(value), null, 2);
+}
+
+// src/analysis/recommendations.ts
+function buildRecommendations(report) {
+  const recommendations = [];
+  if (report.servers.some((server) => server.toolCount > 50)) {
+    recommendations.push({
+      type: "profile",
+      message: "Split large MCP servers into task-specific profiles."
+    });
+  }
+  if (report.overlapClusters.length > 0) {
+    recommendations.push({
+      type: "overlap",
+      message: "Avoid exposing multiple tools for the same intent unless needed."
+    });
+  }
+  if (report.servers.some(
+    (server) => server.tools.some((tool) => /create|update|delete|write|patch/i.test(tool.name))
+  )) {
+    recommendations.push({
+      type: "safety",
+      message: "Prefer read-only profiles for common workflows."
+    });
+  }
+  recommendations.push(
+    {
+      type: "hygiene",
+      message: "Disable rarely used write/admin tools."
+    },
+    {
+      type: "budget",
+      message: "Use `tare-mcp --budget 40000` to enforce a context budget."
+    },
+    {
+      type: "ci",
+      message: "Use `tare-mcp --json` to track this in CI."
+    }
+  );
+  return recommendations;
+}
+
+// src/analysis/overlapDetector.ts
+import TfIdf from "natural/lib/natural/tfidf/tfidf.js";
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "in",
+  "into",
+  "is",
+  "it",
+  "of",
+  "on",
+  "or",
+  "the",
+  "to",
+  "with"
+]);
+var INTENT_BUCKETS = {
+  search: ["search", "find", "query", "grep", "lookup", "list"],
+  read: ["get", "read", "fetch", "retrieve", "show"],
+  write: ["write", "create", "update", "edit", "patch", "delete", "remove"],
+  file: ["file", "path", "directory", "filesystem", "fs"],
+  issue: ["issue", "ticket", "task", "bug"],
+  repo: ["repo", "repository", "code", "commit", "pull", "pr", "branch"],
+  incident: ["incident", "alert", "page", "pager", "oncall"],
+  database: ["sql", "query", "table", "database", "db"]
+};
+var VERB_BUCKETS = ["search", "read", "write"];
+var NOUN_BUCKETS = ["file", "issue", "repo", "incident", "database"];
+function splitWords(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_./:-]+/g, " ").replace(/[^A-Za-z0-9]+/g, " ").toLowerCase().split(/\s+/).map((word) => word.trim()).filter((word) => word.length > 1 && !STOPWORDS.has(word));
+}
+function toolDocument(tool) {
+  return [
+    `${tool.server}.${tool.name}`,
+    tool.description ?? "",
+    JSON.stringify(tool.inputSchema ?? {})
+  ].join("\n");
+}
+function tokensForTool(tool) {
+  return splitWords(toolDocument(tool));
+}
+function buckets(tokens) {
+  const tokenSet = new Set(tokens);
+  const verbs = /* @__PURE__ */ new Set();
+  const nouns = /* @__PURE__ */ new Set();
+  for (const verb of VERB_BUCKETS) {
+    if (INTENT_BUCKETS[verb].some((word) => tokenSet.has(word))) {
+      verbs.add(verb);
+    }
+  }
+  for (const noun of NOUN_BUCKETS) {
+    if (INTENT_BUCKETS[noun].some((word) => tokenSet.has(word))) {
+      nouns.add(noun);
+    }
+  }
+  return { verbs, nouns };
+}
+function vectorFromTerms(terms) {
+  return new Map(terms.map((term) => [term.term, term.tfidf]));
+}
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  let aNorm = 0;
+  let bNorm = 0;
+  for (const value of a.values()) {
+    aNorm += value * value;
+  }
+  for (const value of b.values()) {
+    bNorm += value * value;
+  }
+  for (const [term, value] of a) {
+    dot += value * (b.get(term) ?? 0);
+  }
+  if (aNorm === 0 || bNorm === 0) {
+    return 0;
+  }
+  return dot / (Math.sqrt(aNorm) * Math.sqrt(bNorm));
+}
+function intersection(a, b) {
+  return [...a].filter((value) => b.has(value));
+}
+function labelFor(verb, noun) {
+  if (verb === "search") {
+    return "search intent";
+  }
+  if (verb === "write" && noun === "issue") {
+    return "issue creation";
+  }
+  if (verb === "write" && noun === "file") {
+    return "file write";
+  }
+  if (verb && noun) {
+    return `${noun} ${verb}`;
+  }
+  return "similar tools";
+}
+function recommendationFor(label, verb) {
+  if (label === "search intent") {
+    return "Prefer one search surface per workflow.";
+  }
+  if (verb === "write") {
+    return "Disable duplicate write paths unless explicitly needed.";
+  }
+  return "Create task-specific profiles.";
+}
+function intentEdge(left, right, leftBuckets, rightBuckets) {
+  const sharedVerbs = intersection(leftBuckets.verbs, rightBuckets.verbs);
+  const sharedNouns = intersection(leftBuckets.nouns, rightBuckets.nouns);
+  if (sharedVerbs.includes("search")) {
+    return {
+      score: 0.75,
+      signals: /* @__PURE__ */ new Set(["intent-heuristic"]),
+      reason: "tools share a search intent",
+      label: "search intent"
+    };
+  }
+  const strongVerb = sharedVerbs.find((verb) => verb === "write") ?? sharedVerbs[0];
+  const noun = sharedNouns[0];
+  if (strongVerb && noun) {
+    return {
+      score: 0.7,
+      signals: /* @__PURE__ */ new Set(["intent-heuristic"]),
+      reason: `tools share ${strongVerb} and ${noun} intent buckets`,
+      label: labelFor(strongVerb, noun)
+    };
+  }
+  return void 0;
+}
+function mergeLabels(edges) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    counts.set(edge.label, (counts.get(edge.label) ?? 0) + 1);
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? "similar tools";
+}
+function components(size, edges) {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (!adjacency.has(edge.from)) {
+      adjacency.set(edge.from, /* @__PURE__ */ new Set());
+    }
+    if (!adjacency.has(edge.to)) {
+      adjacency.set(edge.to, /* @__PURE__ */ new Set());
+    }
+    adjacency.get(edge.from)?.add(edge.to);
+    adjacency.get(edge.to)?.add(edge.from);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const found = [];
+  for (let index = 0; index < size; index += 1) {
+    if (visited.has(index) || !adjacency.has(index)) {
+      continue;
+    }
+    const stack = [index];
+    const component = [];
+    visited.add(index);
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (current === void 0) {
+        continue;
+      }
+      component.push(current);
+      for (const next of adjacency.get(current) ?? []) {
+        if (!visited.has(next)) {
+          visited.add(next);
+          stack.push(next);
+        }
+      }
+    }
+    if (component.length > 1) {
+      found.push(component);
+    }
+  }
+  return found;
+}
+var OverlapDetector = class {
+  constructor(threshold = 0.42) {
+    this.threshold = threshold;
+  }
+  threshold;
+  detect(tools) {
+    if (tools.length < 2) {
+      return [];
+    }
+    const tokenized = tools.map(tokensForTool);
+    const bucketed = tokenized.map(buckets);
+    const tfidf = new TfIdf();
+    for (const [index, tokens] of tokenized.entries()) {
+      tfidf.addDocument(tokens, index);
+    }
+    const vectors = tools.map((_tool, index) => vectorFromTerms(tfidf.listTerms(index)));
+    const edges = [];
+    for (let left = 0; left < tools.length; left += 1) {
+      for (let right = left + 1; right < tools.length; right += 1) {
+        if (tools[left]?.server === tools[right]?.server) {
+          continue;
+        }
+        const similarity = cosineSimilarity(
+          vectors[left] ?? /* @__PURE__ */ new Map(),
+          vectors[right] ?? /* @__PURE__ */ new Map()
+        );
+        const heuristic = intentEdge(
+          tools[left],
+          tools[right],
+          bucketed[left],
+          bucketed[right]
+        );
+        if (similarity >= this.threshold || heuristic) {
+          const signals = new Set(heuristic?.signals);
+          if (similarity >= this.threshold) {
+            signals.add("tfidf");
+          }
+          edges.push({
+            from: left,
+            to: right,
+            score: Math.max(similarity, heuristic?.score ?? 0),
+            signals,
+            reason: heuristic?.reason ?? `tool definitions have TF-IDF cosine similarity ${similarity.toFixed(2)}`,
+            label: heuristic?.label ?? "similar tools"
+          });
+        }
+      }
+    }
+    return components(tools.length, edges).map((component) => {
+      const componentEdges = edges.filter(
+        (edge) => component.includes(edge.from) && component.includes(edge.to)
+      );
+      const signals = /* @__PURE__ */ new Set();
+      for (const edge of componentEdges) {
+        for (const signal of edge.signals) {
+          signals.add(signal);
+        }
+      }
+      const label = mergeLabels(componentEdges);
+      const maxScore = Math.max(...componentEdges.map((edge) => edge.score));
+      const reason = componentEdges[0]?.reason ?? "tools appear similar";
+      const verb = componentEdges.some((edge) => edge.label.includes("write")) ? "write" : void 0;
+      return {
+        label,
+        score: Number(maxScore.toFixed(2)),
+        reason,
+        signals: [...signals],
+        tools: component.map((index) => tools[index]).sort((a, b) => `${a.server}.${a.name}`.localeCompare(`${b.server}.${b.name}`)).map((tool) => ({
+          server: tool.server,
+          name: tool.name,
+          description: tool.description,
+          estimatedTokens: {
+            claude: tool.estimatedTokens.claude,
+            openaiCl100k: tool.estimatedTokens.openaiCl100k
+          }
+        })),
+        recommendation: recommendationFor(label, verb)
+      };
+    }).filter((cluster) => new Set(cluster.tools.map((tool) => tool.server)).size > 1).sort((a, b) => b.score - a.score || b.tools.length - a.tools.length).slice(0, 10);
+  }
+};
+
+// src/analysis/analyze.ts
+function windowUsage(tokens, window) {
+  return Math.round(tokens / window * 100);
+}
+function serverMetadata(server) {
+  return stableStringify({
+    server: server.name,
+    transport: server.transport,
+    command: server.command,
+    args: server.args,
+    urlHost: server.urlHost
+  });
+}
+function toolPayload(server, tool) {
+  const payload = {
+    server: server.name,
+    transport: server.transport,
+    tool: {
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+      annotations: tool.annotations,
+      outputSchema: tool.outputSchema,
+      metadata: tool.metadata
+    }
+  };
+  return stableStringify(payload);
+}
+async function analyzeServers(inspectedServers, tokenEstimator, options) {
+  const warnings = [...options.warnings ?? []];
+  const analyzedServers = [];
+  const liveToolsForOverlap = [];
+  for (const server of inspectedServers) {
+    const metadataEstimate = await tokenEstimator.count(serverMetadata(server));
+    let serverClaude = metadataEstimate.claude.tokens;
+    let serverOpenAi = metadataEstimate.openaiCl100k.tokens;
+    const tools = [];
+    for (const tool of server.toolDefinitions) {
+      const estimates = await tokenEstimator.count(toolPayload(server, tool));
+      serverClaude += estimates.claude.tokens;
+      serverOpenAi += estimates.openaiCl100k.tokens;
+      const analyzedTool = {
+        server: server.name,
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        estimatedTokens: {
+          claude: estimates.claude.tokens,
+          openaiCl100k: estimates.openaiCl100k.tokens
+        },
+        hasInputSchema: tool.inputSchema !== void 0
+      };
+      tools.push({
+        name: analyzedTool.name,
+        description: analyzedTool.description,
+        estimatedTokens: analyzedTool.estimatedTokens,
+        hasInputSchema: analyzedTool.hasInputSchema
+      });
+      if (server.inspectionMode === "live") {
+        liveToolsForOverlap.push(analyzedTool);
+      }
+    }
+    analyzedServers.push({
+      name: server.name,
+      sourceConfigPath: server.sourceConfigPath,
+      transport: server.transport,
+      command: server.command,
+      args: server.args,
+      urlHost: server.urlHost,
+      toolCount: tools.length,
+      estimatedTokens: {
+        claude: serverClaude,
+        openaiCl100k: serverOpenAi
+      },
+      inspectionMode: server.inspectionMode,
+      confidence: server.confidence,
+      warnings: server.warnings,
+      tools: tools.sort((a, b) => b.estimatedTokens.claude - a.estimatedTokens.claude)
+    });
+  }
+  analyzedServers.sort((a, b) => b.estimatedTokens.claude - a.estimatedTokens.claude);
+  const totalClaude = analyzedServers.reduce(
+    (sum, server) => sum + server.estimatedTokens.claude,
+    0
+  );
+  const totalOpenAi = analyzedServers.reduce(
+    (sum, server) => sum + server.estimatedTokens.openaiCl100k,
+    0
+  );
+  const overlapClusters = new OverlapDetector().detect(liveToolsForOverlap);
+  const report = {
+    version: VERSION,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    summary: {
+      configFiles: options.configFiles,
+      servers: analyzedServers.length,
+      tools: analyzedServers.reduce((sum, server) => sum + server.toolCount, 0),
+      estimatedTokens: {
+        claude: totalClaude,
+        openaiCl100k: totalOpenAi
+      },
+      contextWindows: {
+        "64000": {
+          claude: windowUsage(totalClaude, 64e3),
+          openaiCl100k: windowUsage(totalOpenAi, 64e3)
+        },
+        "128000": {
+          claude: windowUsage(totalClaude, 128e3),
+          openaiCl100k: windowUsage(totalOpenAi, 128e3)
+        },
+        "200000": {
+          claude: windowUsage(totalClaude, 2e5),
+          openaiCl100k: windowUsage(totalOpenAi, 2e5)
+        }
+      },
+      insufficientServers: analyzedServers.filter((server) => server.inspectionMode !== "live").length
+    },
+    servers: analyzedServers,
+    overlapClusters,
+    recommendations: [],
+    warnings,
+    metadata: {
+      staticOnly: options.staticOnly,
+      inspectionMode: options.staticOnly ? "static-only" : "live default"
+    }
+  };
+  report.recommendations = buildRecommendations(report);
+  return report;
+}
+
+// src/tokens/claudeEstimator.ts
+var LocalClaudeEstimator = class {
+  constructor(openAiCount) {
+    this.openAiCount = openAiCount;
+  }
+  openAiCount;
+  async count(text) {
+    const openAiEstimate = await this.openAiCount?.();
+    if (openAiEstimate?.confidence !== "low") {
+      return {
+        tokenizer: "claude-estimate",
+        tokens: Math.ceil((openAiEstimate?.tokens ?? Math.ceil(text.length / 4)) * 1.1),
+        confidence: "medium",
+        warning: "Using local Claude approximation. Use --claude-tokenizer api for API-backed token counting."
+      };
+    }
+    return {
+      tokenizer: "claude-estimate",
+      tokens: Math.ceil(text.length / 4),
+      confidence: "low",
+      warning: "Using low-confidence local Claude approximation because OpenAI cl100k estimate was unavailable."
+    };
+  }
+};
+
+// src/tokens/openaiCl100kCounter.ts
+import { encode } from "gpt-tokenizer";
+var OpenAICl100kCounter = class {
+  async count(text) {
+    try {
+      return {
+        tokenizer: "openai-cl100k",
+        tokens: encode(text).length,
+        confidence: "high"
+      };
+    } catch {
+      return {
+        tokenizer: "fallback-char-ratio",
+        tokens: Math.ceil(text.length / 4),
+        confidence: "low",
+        warning: "OpenAI cl100k tokenizer failed; using character-ratio fallback."
+      };
+    }
+  }
+};
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+function hashText(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+
+// src/tokens/tokenCache.ts
+var TokenCache = class {
+  cache = /* @__PURE__ */ new Map();
+  getOrSet(keyPrefix, text, count) {
+    const key = `${keyPrefix}:${hashText(text)}`;
+    const existing = this.cache.get(key);
+    if (existing) {
+      return existing;
+    }
+    const estimate = count();
+    this.cache.set(key, estimate);
+    return estimate;
+  }
+};
+
+// src/tokens/countTokens.ts
+var PromiseQueue = class {
+  constructor(concurrency) {
+    this.concurrency = concurrency;
+  }
+  concurrency;
+  active = 0;
+  tasks = [];
+  push(run) {
+    return new Promise((resolve, reject) => {
+      this.tasks.push({ run, resolve, reject });
+      this.drain();
+    });
+  }
+  drain() {
+    while (this.active < this.concurrency && this.tasks.length > 0) {
+      const task = this.tasks.shift();
+      if (!task) {
+        return;
+      }
+      this.active += 1;
+      void task.run().then(task.resolve).catch(task.reject).finally(() => {
+        this.active -= 1;
+        this.drain();
+      });
+    }
+  }
+};
+var TokenEstimator = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  cache = new TokenCache();
+  openAiCounter = new OpenAICl100kCounter();
+  anthropicQueue = new PromiseQueue(3);
+  anthropicApiUnavailable = false;
+  emittedMissingKeyWarning = false;
+  emittedDisabledWarning = false;
+  emittedApiFailureWarning = false;
+  async count(text) {
+    const openaiCl100k = await this.cache.getOrSet(
+      "openai-cl100k",
+      text,
+      () => this.openAiCounter.count(text)
+    );
+    const claude = await this.cache.getOrSet(
+      `claude:${this.options.claudeTokenizerMode}`,
+      text,
+      () => this.countClaude(text, openaiCl100k)
+    );
+    return { claude, openaiCl100k };
+  }
+  async countClaude(text, openAiEstimate) {
+    if (this.options.claudeTokenizerMode !== "api") {
+      return new LocalClaudeEstimator(async () => openAiEstimate).count(text);
+    }
+    if (this.options.anthropicDisabled) {
+      if (!this.emittedDisabledWarning) {
+        this.options.onWarning?.(
+          "Claude API token counting requested but TARE_DISABLE_ANTHROPIC_TOKEN_API=1 is set. Falling back to local Claude approximation."
+        );
+        this.emittedDisabledWarning = true;
+      }
+      return new LocalClaudeEstimator(async () => openAiEstimate).count(text);
+    }
+    if (!this.options.anthropicApiKey) {
+      if (!this.emittedMissingKeyWarning) {
+        this.options.onWarning?.(
+          "Claude API token counting requested but ANTHROPIC_API_KEY is not set. Falling back to local Claude approximation."
+        );
+        this.emittedMissingKeyWarning = true;
+      }
+      return new LocalClaudeEstimator(async () => openAiEstimate).count(text);
+    }
+    if (this.anthropicApiUnavailable) {
+      return new LocalClaudeEstimator(async () => openAiEstimate).count(text);
+    }
+    try {
+      return await this.anthropicQueue.push(() => this.countClaudeWithApi(text));
+    } catch {
+      this.anthropicApiUnavailable = true;
+      if (!this.emittedApiFailureWarning) {
+        this.options.onWarning?.(
+          "Claude API token counting failed. Falling back to local Claude approximation."
+        );
+        this.emittedApiFailureWarning = true;
+      }
+      return new LocalClaudeEstimator(async () => openAiEstimate).count(text);
+    }
+  }
+  async countClaudeWithApi(text) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.options.timeoutMs ?? 5e3);
+    try {
+      const response = await fetch("https://api.anthropic.com/v1/messages/count_tokens", {
+        method: "POST",
+        signal: controller.signal,
+        headers: {
+          "x-api-key": this.options.anthropicApiKey ?? "",
+          "anthropic-version": "2023-06-01",
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          model: this.options.anthropicModel ?? "claude-sonnet-4-6",
+          messages: [
+            {
+              role: "user",
+              content: text
+            }
+          ]
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Anthropic count_tokens failed with ${response.status}`);
+      }
+      const body = await response.json();
+      const tokens = body.input_tokens ?? body.inputTokens;
+      if (typeof tokens !== "number" || !Number.isFinite(tokens)) {
+        throw new Error("Anthropic count_tokens response did not include input_tokens.");
+      }
+      return {
+        tokenizer: "claude-api",
+        tokens: Math.ceil(tokens),
+        confidence: "high"
+      };
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
+// src/reporters/humanReporter.ts
+import pc from "picocolors";
+function formatNumber(value) {
+  return Math.round(value).toLocaleString("en-US");
+}
+function approx(value) {
+  return `~${formatNumber(value)}`;
+}
+function padRight(text, length) {
+  return text.padEnd(length, " ");
+}
+function allTools(report) {
+  return report.servers.flatMap(
+    (server) => server.tools.map((tool) => ({
+      server: server.name,
+      name: tool.name,
+      estimatedTokens: tool.estimatedTokens
+    }))
+  );
+}
+function renderHumanReport(report) {
+  const lines = [];
+  lines.push(pc.bold("tare-mcp \u2014 MCP context weight"));
+  lines.push("");
+  lines.push("MCP made tools easy to connect. It did not make them cheap to carry.");
+  lines.push("");
+  if (report.metadata.staticOnly) {
+    lines.push(pc.yellow("Static-only mode: insufficient for packaged or hosted MCP servers."));
+    lines.push("Run without --no-exec for actual tool/schema weight.");
+    lines.push("");
+  }
+  for (const warning of report.warnings) {
+    lines.push(pc.yellow(`\u26A0 ${warning}`));
+  }
+  if (report.warnings.length > 0) {
+    lines.push("");
+  }
+  lines.push(`Config files found: ${report.summary.configFiles}`);
+  lines.push(`Servers analyzed: ${report.summary.servers}`);
+  lines.push(`Inspection mode: ${report.metadata.inspectionMode}`);
+  lines.push(`Tools exposed: ${report.summary.tools}`);
+  lines.push("");
+  lines.push("Estimated context weight:");
+  lines.push(`- Claude estimate:        ${approx(report.summary.estimatedTokens.claude)} tokens`);
+  lines.push(
+    `- OpenAI cl100k estimate: ${approx(report.summary.estimatedTokens.openaiCl100k)} tokens`
+  );
+  lines.push("");
+  lines.push("Context window usage:");
+  lines.push(`- 200k window: ${report.summary.contextWindows["200000"].claude}%`);
+  lines.push(`- 128k window: ${report.summary.contextWindows["128000"].claude}%`);
+  lines.push(`- 64k window: ${report.summary.contextWindows["64000"].claude}%`);
+  if (report.servers.length > 0) {
+    lines.push("");
+    lines.push("Worst servers:");
+    for (const [index, server] of report.servers.slice(0, 5).entries()) {
+      lines.push(
+        `${index + 1}. ${padRight(server.name, 12)} ${padRight(
+          `${approx(server.estimatedTokens.claude)} Claude tokens`,
+          24
+        )} ${server.toolCount.toString().padStart(4)} tools`
+      );
+    }
+  }
+  const tools = allTools(report).sort(
+    (a, b) => b.estimatedTokens.claude - a.estimatedTokens.claude
+  );
+  if (tools.length > 0) {
+    lines.push("");
+    lines.push("Worst tools:");
+    for (const [index, tool] of tools.slice(0, 5).entries()) {
+      lines.push(
+        `${index + 1}. ${padRight(`${tool.server}.${tool.name}`, 34)} ${approx(
+          tool.estimatedTokens.claude
+        )} Claude tokens`
+      );
+    }
+  }
+  if (report.overlapClusters.length > 0) {
+    lines.push("");
+    lines.push(`Overlap warnings: ${report.overlapClusters.length} clusters`);
+    lines.push("");
+    for (const [index, cluster] of report.overlapClusters.slice(0, 5).entries()) {
+      lines.push(`${index + 1}. ${cluster.label}`);
+      for (const tool of cluster.tools) {
+        lines.push(`   ${tool.server}.${tool.name}`);
+      }
+      lines.push(`   \u2192 ${cluster.recommendation}`);
+      if (index < Math.min(report.overlapClusters.length, 5) - 1) {
+        lines.push("");
+      }
+    }
+  }
+  const insufficientServers = report.servers.filter((server) => server.inspectionMode !== "live");
+  if (insufficientServers.length > 0) {
+    lines.push("");
+    lines.push("Insufficient data:");
+    for (const server of insufficientServers) {
+      lines.push(
+        `- ${server.name}: ${server.warnings[0] ?? "static fallback cannot see actual tool schemas."}`
+      );
+    }
+  }
+  lines.push("");
+  lines.push("Recommendations:");
+  for (const recommendation of report.recommendations) {
+    lines.push(`- ${recommendation.message}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function budgetActual(report, tokenizer) {
+  return tokenizer === "openai" ? report.summary.estimatedTokens.openaiCl100k : report.summary.estimatedTokens.claude;
+}
+function renderBudgetFailure(report, budget, tokenizer) {
+  const actual = budgetActual(report, tokenizer);
+  const label = tokenizer === "openai" ? "OpenAI cl100k-estimated tokens" : "Claude-estimated tokens";
+  const lines = [];
+  lines.push("");
+  lines.push(pc.red(pc.bold("FAILED: MCP context budget exceeded.")));
+  lines.push("");
+  lines.push(`Budget: ${formatNumber(budget)} ${label}`);
+  lines.push(`Actual: ${approx(actual)} ${label}`);
+  lines.push(`Over by: ${approx(actual - budget)} tokens`);
+  if (report.servers.length > 0) {
+    lines.push("");
+    lines.push("Top offenders:");
+    for (const [index, server] of report.servers.slice(0, 3).entries()) {
+      const tokens = tokenizer === "openai" ? server.estimatedTokens.openaiCl100k : server.estimatedTokens.claude;
+      lines.push(`${index + 1}. ${padRight(server.name, 12)} ${approx(tokens)} tokens`);
+    }
+  }
+  const largestCluster = report.overlapClusters[0];
+  if (largestCluster) {
+    lines.push("");
+    lines.push("Largest overlap cluster:");
+    lines.push(largestCluster.label);
+    for (const tool of largestCluster.tools) {
+      lines.push(`- ${tool.server}.${tool.name}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/reporters/jsonReporter.ts
+function renderJsonReport(report) {
+  return `${JSON.stringify(report, null, 2)}
+`;
+}
+
+// src/diff/loadReport.ts
+import { z as z3 } from "zod";
+var TokenTotalsSchema = z3.object({
+  claude: z3.number(),
+  openaiCl100k: z3.number()
+}).passthrough();
+var OptionalTokenTotalsSchema = z3.object({
+  claude: z3.number().optional(),
+  openaiCl100k: z3.number().optional()
+}).passthrough();
+var OverlapClusterSchema = z3.object({
+  label: z3.string(),
+  score: z3.number(),
+  reason: z3.string(),
+  signals: z3.array(z3.enum(["tfidf", "intent-heuristic"])),
+  tools: z3.array(
+    z3.object({
+      server: z3.string(),
+      name: z3.string(),
+      description: z3.string().optional(),
+      estimatedTokens: OptionalTokenTotalsSchema.optional()
+    }).passthrough()
+  ),
+  recommendation: z3.string()
+}).passthrough();
+var TareReportSchema = z3.object({
+  version: z3.string(),
+  generatedAt: z3.string(),
+  summary: z3.object({
+    configFiles: z3.number(),
+    servers: z3.number(),
+    tools: z3.number(),
+    estimatedTokens: TokenTotalsSchema,
+    contextWindows: z3.object({
+      "64000": TokenTotalsSchema,
+      "128000": TokenTotalsSchema,
+      "200000": TokenTotalsSchema
+    }).passthrough(),
+    insufficientServers: z3.number()
+  }).passthrough(),
+  servers: z3.array(
+    z3.object({
+      name: z3.string(),
+      sourceConfigPath: z3.string(),
+      transport: z3.enum(["stdio", "streamable-http", "sse", "unknown"]),
+      command: z3.string().optional(),
+      args: z3.array(z3.string()).optional(),
+      urlHost: z3.string().optional(),
+      toolCount: z3.number(),
+      estimatedTokens: TokenTotalsSchema,
+      inspectionMode: z3.enum(["live", "static-insufficient", "fallback-static-insufficient"]),
+      confidence: z3.enum(["high", "medium", "low"]),
+      warnings: z3.array(z3.string()),
+      tools: z3.array(
+        z3.object({
+          name: z3.string(),
+          description: z3.string().optional(),
+          estimatedTokens: TokenTotalsSchema,
+          hasInputSchema: z3.boolean()
+        }).passthrough()
+      )
+    }).passthrough()
+  ),
+  overlapClusters: z3.array(OverlapClusterSchema),
+  recommendations: z3.array(
+    z3.object({
+      type: z3.string(),
+      message: z3.string()
+    }).passthrough()
+  ),
+  warnings: z3.array(z3.string()),
+  metadata: z3.object({
+    staticOnly: z3.boolean(),
+    inspectionMode: z3.enum(["live default", "static-only"])
+  }).passthrough()
+}).passthrough();
+var ReportLoadError = class extends Error {
+  path;
+  constructor(filePath, message) {
+    super(message);
+    this.name = "ReportLoadError";
+    this.path = filePath;
+  }
+};
+async function loadReport(filePath) {
+  const text = await readReportText(filePath);
+  const parsed = parseJson(filePath, text);
+  const result = TareReportSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ReportLoadError(filePath, formatReportIssue(filePath, result.error.issues[0]));
+  }
+  return {
+    path: filePath,
+    report: result.data
+  };
+}
+async function readReportText(filePath) {
+  try {
+    return await readUtf8(filePath);
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      throw new ReportLoadError(filePath, `${filePath} was not found.`);
+    }
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new ReportLoadError(filePath, `Could not read ${filePath}: ${reason}`);
+  }
+}
+function parseJson(filePath, text) {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new ReportLoadError(filePath, `${filePath} is not valid JSON: ${reason}`);
+  }
+}
+function formatReportIssue(filePath, issue) {
+  if (!issue) {
+    return `${filePath} is not a valid tare-mcp report.`;
+  }
+  const field = issue.path.length > 0 ? issue.path.join(".") : "report";
+  return `${filePath} has invalid ${field}: ${issue.message}`;
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/diff/diffReports.ts
+function diffReports(baseReport, headReport, options) {
+  const baseServers = new Map(baseReport.servers.map((server) => [server.name, server]));
+  const headServers = new Map(headReport.servers.map((server) => [server.name, server]));
+  const baseTools = buildToolMap(baseReport);
+  const headTools = buildToolMap(headReport);
+  const baseClusters = buildClusterMap(baseReport);
+  const headClusters = buildClusterMap(headReport);
+  const report = {
+    version: VERSION,
+    generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    base: {
+      path: options.basePath,
+      reportVersion: baseReport.version,
+      generatedAt: baseReport.generatedAt
+    },
+    head: {
+      path: options.headPath,
+      reportVersion: headReport.version,
+      generatedAt: headReport.generatedAt
+    },
+    summary: {
+      servers: numericDelta(baseReport.summary.servers, headReport.summary.servers),
+      tools: numericDelta(baseReport.summary.tools, headReport.summary.tools),
+      estimatedTokens: tokenDelta(
+        baseReport.summary.estimatedTokens,
+        headReport.summary.estimatedTokens
+      ),
+      overlapClusters: numericDelta(
+        baseReport.overlapClusters.length,
+        headReport.overlapClusters.length
+      )
+    },
+    servers: diffServers(baseServers, headServers),
+    tools: diffTools(baseTools, headTools),
+    overlapClusters: diffOverlapClusters(baseClusters, headClusters),
+    thresholds: [],
+    recommendations: [],
+    warnings: buildWarnings(baseReport, headReport)
+  };
+  report.recommendations = buildDiffRecommendations(report);
+  return report;
+}
+function overlapClusterIdentity(cluster) {
+  return JSON.stringify(cluster.tools.map((tool) => `${tool.server}.${tool.name}`).sort());
+}
+function diffServers(baseServers, headServers) {
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const [name, headServer] of headServers) {
+    const baseServer = baseServers.get(name);
+    if (!baseServer) {
+      added.push(toDiffServer(headServer));
+      continue;
+    }
+    const serverChange = diffExistingServer(baseServer, headServer);
+    if (isServerChanged(serverChange)) {
+      changed.push(serverChange);
+    }
+  }
+  for (const [name, baseServer] of baseServers) {
+    if (!headServers.has(name)) {
+      removed.push(toDiffServer(baseServer));
+    }
+  }
+  return {
+    added: added.sort(compareServersByTokens),
+    removed: removed.sort(compareServersByTokens),
+    changed: changed.sort(compareServerChanges)
+  };
+}
+function diffTools(baseTools, headTools) {
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const [id, headTool] of headTools) {
+    const baseTool = baseTools.get(id);
+    if (!baseTool) {
+      added.push(headTool);
+      continue;
+    }
+    const toolChange = diffExistingTool(baseTool, headTool);
+    if (isToolChanged(toolChange)) {
+      changed.push(toolChange);
+    }
+  }
+  for (const [id, baseTool] of baseTools) {
+    if (!headTools.has(id)) {
+      removed.push(baseTool);
+    }
+  }
+  return {
+    added: added.sort(compareToolsByTokens),
+    removed: removed.sort(compareToolsByTokens),
+    changed: changed.sort(compareToolChanges)
+  };
+}
+function diffOverlapClusters(baseClusters, headClusters) {
+  const added = [];
+  const removed = [];
+  for (const [id, headCluster] of headClusters) {
+    if (!baseClusters.has(id)) {
+      added.push(headCluster);
+    }
+  }
+  for (const [id, baseCluster] of baseClusters) {
+    if (!headClusters.has(id)) {
+      removed.push(baseCluster);
+    }
+  }
+  return {
+    added: added.sort(compareClusters),
+    removed: removed.sort(compareClusters)
+  };
+}
+function diffExistingServer(base, head) {
+  return {
+    name: head.name,
+    toolCount: numericDelta(base.toolCount, head.toolCount),
+    estimatedTokens: tokenDelta(base.estimatedTokens, head.estimatedTokens),
+    transport: valueDelta(base.transport, head.transport),
+    sourceConfigPath: valueDelta(base.sourceConfigPath, head.sourceConfigPath),
+    command: valueDelta(base.command ?? null, head.command ?? null),
+    args: valueDelta(base.args ?? null, head.args ?? null),
+    urlHost: valueDelta(base.urlHost ?? null, head.urlHost ?? null),
+    inspectionMode: valueDelta(base.inspectionMode, head.inspectionMode),
+    confidence: valueDelta(base.confidence, head.confidence)
+  };
+}
+function diffExistingTool(base, head) {
+  return {
+    server: head.server,
+    name: head.name,
+    estimatedTokens: tokenDelta(base.estimatedTokens, head.estimatedTokens),
+    descriptionChanged: (base.description ?? null) !== (head.description ?? null),
+    inputSchemaPresenceChanged: base.hasInputSchema !== head.hasInputSchema
+  };
+}
+function isServerChanged(change) {
+  return change.toolCount.delta !== 0 || change.estimatedTokens.delta.claude !== 0 || change.estimatedTokens.delta.openaiCl100k !== 0 || change.transport.changed || change.sourceConfigPath.changed || change.command.changed || change.args.changed || change.urlHost.changed || change.inspectionMode.changed || change.confidence.changed;
+}
+function isToolChanged(change) {
+  return change.estimatedTokens.delta.claude !== 0 || change.estimatedTokens.delta.openaiCl100k !== 0 || change.descriptionChanged || change.inputSchemaPresenceChanged;
+}
+function toDiffServer(server) {
+  return {
+    name: server.name,
+    sourceConfigPath: server.sourceConfigPath,
+    transport: server.transport,
+    command: server.command,
+    args: server.args,
+    urlHost: server.urlHost,
+    toolCount: server.toolCount,
+    estimatedTokens: server.estimatedTokens,
+    inspectionMode: server.inspectionMode,
+    confidence: server.confidence
+  };
+}
+function toDiffTool(server, tool) {
+  return {
+    server: server.name,
+    name: tool.name,
+    description: tool.description,
+    estimatedTokens: tool.estimatedTokens,
+    hasInputSchema: tool.hasInputSchema
+  };
+}
+function toDiffOverlapCluster(cluster) {
+  return {
+    id: overlapClusterIdentity(cluster),
+    label: cluster.label,
+    score: cluster.score,
+    tools: cluster.tools.map((tool) => ({ server: tool.server, name: tool.name })),
+    recommendation: cluster.recommendation
+  };
+}
+function buildToolMap(report) {
+  const tools = /* @__PURE__ */ new Map();
+  for (const server of report.servers) {
+    for (const tool of server.tools) {
+      tools.set(toolKey(server.name, tool.name), toDiffTool(server, tool));
+    }
+  }
+  return tools;
+}
+function buildClusterMap(report) {
+  const clusters = /* @__PURE__ */ new Map();
+  for (const cluster of report.overlapClusters) {
+    clusters.set(overlapClusterIdentity(cluster), toDiffOverlapCluster(cluster));
+  }
+  return clusters;
+}
+function buildWarnings(baseReport, headReport) {
+  const warnings = [];
+  if (baseReport.version !== headReport.version) {
+    warnings.push(
+      `Base report version ${baseReport.version} differs from head report version ${headReport.version}.`
+    );
+  }
+  if (baseReport.metadata.staticOnly || headReport.metadata.staticOnly) {
+    warnings.push(
+      "One or both reports were generated with --no-exec; live tool/schema regressions may be hidden."
+    );
+  }
+  return warnings;
+}
+function buildDiffRecommendations(report) {
+  const recommendations = [];
+  if (positiveIncrease(report.summary.estimatedTokens.delta.claude) > 0) {
+    recommendations.push({
+      type: "budget",
+      message: "Review the largest token increases before merging this MCP config change."
+    });
+  }
+  if (report.servers.added.length > 0 || report.tools.added.length > 0) {
+    recommendations.push({
+      type: "profile",
+      message: "Keep new MCP surfaces scoped to the workflows that actually need them."
+    });
+  }
+  if (report.overlapClusters.added.length > 0) {
+    recommendations.push({
+      type: "overlap",
+      message: "Resolve new overlapping tool clusters or document why both tools should stay exposed."
+    });
+  }
+  if (recommendations.length === 0) {
+    recommendations.push({
+      type: "status",
+      message: "No MCP context regression was detected in this diff."
+    });
+  }
+  return recommendations;
+}
+function tokenDelta(base, head) {
+  return {
+    base,
+    head,
+    delta: {
+      claude: head.claude - base.claude,
+      openaiCl100k: head.openaiCl100k - base.openaiCl100k
+    }
+  };
+}
+function numericDelta(base, head) {
+  return {
+    base,
+    head,
+    delta: head - base
+  };
+}
+function valueDelta(base, head) {
+  return {
+    base,
+    head,
+    changed: JSON.stringify(base) !== JSON.stringify(head)
+  };
+}
+function toolKey(server, tool) {
+  return `${server}\0${tool}`;
+}
+function positiveIncrease(value) {
+  return Math.max(0, value);
+}
+function compareServersByTokens(a, b) {
+  return b.estimatedTokens.claude - a.estimatedTokens.claude || a.name.localeCompare(b.name);
+}
+function compareServerChanges(a, b) {
+  return Math.abs(b.estimatedTokens.delta.claude) - Math.abs(a.estimatedTokens.delta.claude) || a.name.localeCompare(b.name);
+}
+function compareToolsByTokens(a, b) {
+  return b.estimatedTokens.claude - a.estimatedTokens.claude || `${a.server}.${a.name}`.localeCompare(`${b.server}.${b.name}`);
+}
+function compareToolChanges(a, b) {
+  return Math.abs(b.estimatedTokens.delta.claude) - Math.abs(a.estimatedTokens.delta.claude) || `${a.server}.${a.name}`.localeCompare(`${b.server}.${b.name}`);
+}
+function compareClusters(a, b) {
+  return b.score - a.score || a.id.localeCompare(b.id);
+}
+
+// src/diff/thresholds.ts
+function evaluateDiffThresholds(report, options) {
+  const results = [];
+  addThreshold(results, {
+    flag: "--max-token-increase",
+    tokenizer: options.tokenizer,
+    allowed: options.maxTokenIncrease,
+    actual: options.tokenizer === "openai" ? report.summary.estimatedTokens.delta.openaiCl100k : report.summary.estimatedTokens.delta.claude
+  });
+  addThreshold(results, {
+    flag: "--max-tool-increase",
+    allowed: options.maxToolIncrease,
+    actual: report.summary.tools.delta
+  });
+  addThreshold(results, {
+    flag: "--max-server-increase",
+    allowed: options.maxServerIncrease,
+    actual: report.summary.servers.delta
+  });
+  addThreshold(results, {
+    flag: "--max-overlap-increase",
+    allowed: options.maxOverlapIncrease,
+    actual: report.overlapClusters.added.length
+  });
+  return results;
+}
+function hasThresholdFailure(report) {
+  return report.thresholds.some((threshold) => threshold.exceeded);
+}
+function addThreshold(results, input) {
+  if (input.allowed === void 0) {
+    return;
+  }
+  const actualIncrease = Math.max(0, input.actual);
+  const result = {
+    flag: input.flag,
+    allowed: input.allowed,
+    actual: actualIncrease,
+    exceeded: actualIncrease > input.allowed
+  };
+  if (input.tokenizer !== void 0) {
+    result.tokenizer = input.tokenizer;
+  }
+  results.push(result);
+}
+
+// src/reporters/diffHumanReporter.ts
+import pc2 from "picocolors";
+function renderDiffHumanReport(report, options) {
+  const lines = [];
+  lines.push(pc2.bold("tare-mcp diff - MCP context regression"));
+  lines.push("");
+  lines.push(`Base: ${report.base.path} (${report.base.reportVersion})`);
+  lines.push(`Head: ${report.head.path} (${report.head.reportVersion})`);
+  lines.push("");
+  for (const warning of report.warnings) {
+    lines.push(pc2.yellow(`Warning: ${warning}`));
+  }
+  if (report.warnings.length > 0) {
+    lines.push("");
+  }
+  lines.push("Summary:");
+  lines.push(`- Servers: ${formatDeltaLine(report.summary.servers)}`);
+  lines.push(`- Tools: ${formatDeltaLine(report.summary.tools)}`);
+  lines.push(`- Claude tokens: ${formatTokenDeltaLine(report.summary.estimatedTokens, "claude")}`);
+  lines.push(
+    `- OpenAI cl100k tokens: ${formatTokenDeltaLine(report.summary.estimatedTokens, "openai")}`
+  );
+  lines.push(`- Overlap clusters: ${formatDeltaLine(report.summary.overlapClusters)}`);
+  pushServerSection(lines, "New servers", report.servers.added, options.tokenizer);
+  pushServerSection(lines, "Removed servers", report.servers.removed, options.tokenizer);
+  pushServerChangeSection(lines, report.servers.changed, options.tokenizer);
+  pushToolSection(lines, "New tools", report.tools.added, options.tokenizer);
+  pushToolSection(lines, "Removed tools", report.tools.removed, options.tokenizer);
+  pushToolChangeSection(lines, report.tools.changed, options.tokenizer);
+  pushOverlapSection(lines, report);
+  pushThresholdSection(lines, report, options.tokenizer);
+  pushRecommendations(lines, report);
+  return `${lines.join("\n")}
+`;
+}
+function renderDiffThresholdFailure(report, options) {
+  const failures = report.thresholds.filter((threshold) => threshold.exceeded);
+  if (failures.length === 0) {
+    return "";
+  }
+  const lines = [];
+  lines.push("");
+  lines.push(pc2.red(pc2.bold("FAILED: MCP context regression threshold exceeded.")));
+  lines.push("");
+  for (const failure of failures) {
+    const label = thresholdLabel(failure.flag, failure.tokenizer ?? options.tokenizer);
+    const isToken = failure.flag === "--max-token-increase";
+    const fmt = isToken ? approx2 : formatNumber2;
+    lines.push(
+      `${failure.flag}: allowed ${fmt(failure.allowed)}, actual ${fmt(failure.actual)} ${label}`
+    );
+  }
+  const serverOffenders = tokenServerOffenders(report, options.tokenizer);
+  if (serverOffenders.length > 0) {
+    lines.push("");
+    lines.push("Top server increases:");
+    for (const [index, offender] of serverOffenders.slice(0, 5).entries()) {
+      lines.push(
+        `${index + 1}. ${padRight2(offender.label, 20)} ${approxSigned(offender.tokens)} tokens (${offender.details})`
+      );
+    }
+  }
+  const toolOffenders = tokenToolOffenders(report, options.tokenizer);
+  if (toolOffenders.length > 0) {
+    lines.push("");
+    lines.push("Top tool increases:");
+    for (const [index, offender] of toolOffenders.slice(0, 5).entries()) {
+      lines.push(
+        `${index + 1}. ${padRight2(offender.label, 34)} ${approxSigned(offender.tokens)} tokens (${offender.details})`
+      );
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function pushServerSection(lines, title, servers, tokenizer) {
+  if (servers.length === 0) {
+    return;
+  }
+  lines.push("");
+  lines.push(`${title}:`);
+  const tokenizerLabel = tokenizer === "openai" ? "OpenAI cl100k" : "Claude";
+  for (const server of servers.slice(0, 10)) {
+    lines.push(
+      `- ${server.name}: ${server.toolCount} tools, ${approx2(tokenValue(server.estimatedTokens, tokenizer))} ${tokenizerLabel} tokens`
+    );
+  }
+}
+function pushServerChangeSection(lines, servers, tokenizer) {
+  const materialChanges = servers.filter(
+    (server) => server.toolCount.delta !== 0 || tokenValue(server.estimatedTokens.delta, tokenizer) !== 0
+  );
+  if (materialChanges.length === 0) {
+    return;
+  }
+  const tokenizerLabel = tokenizer === "openai" ? "OpenAI cl100k" : "Claude";
+  lines.push("");
+  lines.push("Largest changes to existing servers:");
+  for (const server of materialChanges.slice(0, 10)) {
+    lines.push(
+      `- ${server.name}: ${formatDeltaLine(server.toolCount)} tools, ${approxSigned(
+        tokenValue(server.estimatedTokens.delta, tokenizer)
+      )} ${tokenizerLabel} tokens`
+    );
+  }
+}
+function pushToolSection(lines, title, tools, tokenizer) {
+  if (tools.length === 0) {
+    return;
+  }
+  lines.push("");
+  lines.push(`${title}:`);
+  const tokenizerLabel = tokenizer === "openai" ? "OpenAI cl100k" : "Claude";
+  for (const tool of tools.slice(0, 10)) {
+    lines.push(
+      `- ${tool.server}.${tool.name}: ${approx2(tokenValue(tool.estimatedTokens, tokenizer))} ${tokenizerLabel} tokens`
+    );
+  }
+}
+function pushToolChangeSection(lines, tools, tokenizer) {
+  const materialChanges = tools.filter(
+    (tool) => tokenValue(tool.estimatedTokens.delta, tokenizer) !== 0 || tool.descriptionChanged
+  );
+  if (materialChanges.length === 0) {
+    return;
+  }
+  const tokenizerLabel = tokenizer === "openai" ? "OpenAI cl100k" : "Claude";
+  lines.push("");
+  lines.push("Largest changes to existing tools:");
+  for (const tool of materialChanges.slice(0, 10)) {
+    const notes = [
+      tool.descriptionChanged ? "description changed" : void 0,
+      tool.inputSchemaPresenceChanged ? "schema presence changed" : void 0
+    ].filter(Boolean);
+    const suffix = notes.length > 0 ? ` (${notes.join(", ")})` : "";
+    lines.push(
+      `- ${tool.server}.${tool.name}: ${approxSigned(
+        tokenValue(tool.estimatedTokens.delta, tokenizer)
+      )} ${tokenizerLabel} tokens${suffix}`
+    );
+  }
+}
+function pushOverlapSection(lines, report) {
+  if (report.overlapClusters.added.length === 0 && report.overlapClusters.removed.length === 0) {
+    return;
+  }
+  if (report.overlapClusters.added.length > 0) {
+    lines.push("");
+    lines.push("New overlap clusters:");
+    for (const cluster of report.overlapClusters.added.slice(0, 5)) {
+      lines.push(`- ${cluster.label}`);
+      for (const tool of cluster.tools) {
+        lines.push(`  ${tool.server}.${tool.name}`);
+      }
+    }
+  }
+  if (report.overlapClusters.removed.length > 0) {
+    lines.push("");
+    lines.push("Resolved overlap clusters:");
+    for (const cluster of report.overlapClusters.removed.slice(0, 5)) {
+      lines.push(`- ${cluster.label}`);
+    }
+  }
+}
+function pushThresholdSection(lines, report, tokenizer) {
+  if (report.thresholds.length === 0) {
+    return;
+  }
+  lines.push("");
+  lines.push("Thresholds:");
+  for (const threshold of report.thresholds) {
+    const status = threshold.exceeded ? pc2.red("fail") : pc2.green("pass");
+    const label = thresholdLabel(threshold.flag, threshold.tokenizer ?? tokenizer);
+    const isToken = threshold.flag === "--max-token-increase";
+    const fmt = isToken ? approx2 : formatNumber2;
+    lines.push(
+      `- ${threshold.flag}: ${status} (${fmt(threshold.actual)} / ${fmt(threshold.allowed)} ${label})`
+    );
+  }
+}
+function pushRecommendations(lines, report) {
+  if (report.recommendations.length === 0) {
+    return;
+  }
+  lines.push("");
+  lines.push("Recommendations:");
+  for (const recommendation of report.recommendations) {
+    lines.push(`- ${recommendation.message}`);
+  }
+}
+function tokenServerOffenders(report, tokenizer) {
+  const added = report.servers.added.map((server) => ({
+    label: server.name,
+    tokens: tokenValue(server.estimatedTokens, tokenizer),
+    details: `new server, ${server.toolCount} tools`
+  }));
+  const changed = report.servers.changed.map((server) => ({
+    label: server.name,
+    tokens: tokenValue(server.estimatedTokens.delta, tokenizer),
+    details: `${formatSignedNumber(server.toolCount.delta)} tools`
+  })).filter((offender) => offender.tokens > 0);
+  return [...added, ...changed].sort(compareOffenders);
+}
+function tokenToolOffenders(report, tokenizer) {
+  const added = report.tools.added.map((tool) => ({
+    label: `${tool.server}.${tool.name}`,
+    tokens: tokenValue(tool.estimatedTokens, tokenizer),
+    details: "new tool"
+  }));
+  const changed = report.tools.changed.map((tool) => ({
+    label: `${tool.server}.${tool.name}`,
+    tokens: tokenValue(tool.estimatedTokens.delta, tokenizer),
+    details: tool.descriptionChanged ? "description changed" : "existing tool"
+  })).filter((offender) => offender.tokens > 0);
+  return [...added, ...changed].sort(compareOffenders);
+}
+function compareOffenders(a, b) {
+  return b.tokens - a.tokens || a.label.localeCompare(b.label);
+}
+function formatDeltaLine(delta) {
+  return `${formatNumber2(delta.base)} -> ${formatNumber2(delta.head)} (${formatSignedNumber(
+    delta.delta
+  )})`;
+}
+function formatTokenDeltaLine(delta, tokenizer) {
+  return `${approx2(tokenValue(delta.base, tokenizer))} -> ${approx2(
+    tokenValue(delta.head, tokenizer)
+  )} (${approxSigned(tokenValue(delta.delta, tokenizer))})`;
+}
+function tokenValue(tokens, tokenizer) {
+  return tokenizer === "openai" ? tokens.openaiCl100k : tokens.claude;
+}
+function thresholdLabel(flag, tokenizer) {
+  if (flag === "--max-token-increase") {
+    return tokenizer === "openai" ? "OpenAI cl100k tokens" : "Claude tokens";
+  }
+  if (flag === "--max-server-increase") {
+    return "servers";
+  }
+  if (flag === "--max-overlap-increase") {
+    return "new overlap clusters";
+  }
+  return "tools";
+}
+function formatNumber2(value) {
+  return Math.round(value).toLocaleString("en-US");
+}
+function formatSignedNumber(value) {
+  if (value > 0) {
+    return `+${formatNumber2(value)}`;
+  }
+  return formatNumber2(value);
+}
+function approx2(value) {
+  return `~${formatNumber2(value)}`;
+}
+function approxSigned(value) {
+  if (value > 0) {
+    return `~+${formatNumber2(value)}`;
+  }
+  if (value < 0) {
+    return `~-${formatNumber2(Math.abs(value))}`;
+  }
+  return "~0";
+}
+function padRight2(text, length) {
+  return text.padEnd(length, " ");
+}
+
+// src/reporters/diffJsonReporter.ts
+function renderDiffJsonReport(report) {
+  return `${JSON.stringify(report, null, 2)}
+`;
+}
+export {
+  LocalClaudeEstimator,
+  OpenAICl100kCounter,
+  OverlapDetector,
+  ReportLoadError,
+  TareReportSchema,
+  TokenEstimator,
+  VERSION,
+  analyzeServers,
+  buildRecommendations,
+  buildServerEnv,
+  createStaticInspection,
+  diffReports,
+  discoverConfigs,
+  evaluateDiffThresholds,
+  getDefaultConfigCandidates,
+  hasThresholdFailure,
+  inspectStdioServer,
+  inspectStreamableHttpServer,
+  loadReport,
+  normalizeServer,
+  overlapClusterIdentity,
+  parseConfigFile,
+  parseConfigText,
+  renderBudgetFailure,
+  renderDiffHumanReport,
+  renderDiffJsonReport,
+  renderDiffThresholdFailure,
+  renderHumanReport,
+  renderJsonReport
+};