@kirrosh/zond 0.16.0 → 0.17.0

package/src/core/runner/assertions.ts

@@ -244,15 +244,24 @@ export function checkAssertions(expect: TestStepExpect, response: HttpResponse):
   }
 
   if (expect.headers) {
-    for (const [key, expectedValue] of Object.entries(expect.headers)) {
+    for (const [key, rule] of Object.entries(expect.headers)) {
       const actual = response.headers[key.toLowerCase()];
-      results.push({
-        field: `headers.${key}`,
-        rule: `equals "${expectedValue}"`,
-        passed: actual === expectedValue,
-        actual,
-        expected: expectedValue,
-      });
+      if (typeof rule === "string") {
+        results.push({
+          field: `headers.${key}`,
+          rule: `equals "${rule}"`,
+          passed: actual === rule,
+          actual,
+          expected: rule,
+        });
+      } else {
+        // AssertionRule in header — supports capture and other checks
+        const ruleResults = checkRule(key, rule, actual).map(r => ({
+          ...r,
+          field: r.field.replace(/^body\./, "headers."),
+        }));
+        results.push(...ruleResults);
+      }
     }
   }
 
@@ -276,24 +285,39 @@ export function checkAssertions(expect: TestStepExpect, response: HttpResponse):
 export function extractCaptures(
   bodyRules: Record<string, AssertionRule> | undefined,
   responseBody: unknown,
+  headerRules?: Record<string, string | AssertionRule>,
+  responseHeaders?: Record<string, string>,
 ): Record<string, unknown> {
   const captures: Record<string, unknown> = {};
-  if (!bodyRules || responseBody === undefined) return captures;
 
-  for (const [path, rule] of Object.entries(bodyRules)) {
-    if (rule.capture) {
-      let value: unknown;
-      if (path === "_body") {
-        value = responseBody;
-      } else if (path.startsWith("_body.")) {
-        value = getByPath(responseBody, path.slice(6));
-      } else {
-        value = getByPath(responseBody, path);
+  if (bodyRules && responseBody !== undefined) {
+    for (const [path, rule] of Object.entries(bodyRules)) {
+      if (rule.capture) {
+        let value: unknown;
+        if (path === "_body") {
+          value = responseBody;
+        } else if (path.startsWith("_body.")) {
+          value = getByPath(responseBody, path.slice(6));
+        } else {
+          value = getByPath(responseBody, path);
+        }
+        if (value !== undefined) {
+          captures[rule.capture] = value;
+        }
       }
-      if (value !== undefined) {
-        captures[rule.capture] = value;
+    }
+  }
+
+  if (headerRules && responseHeaders) {
+    for (const [key, rule] of Object.entries(headerRules)) {
+      if (typeof rule !== "string" && rule.capture) {
+        const value = responseHeaders[key.toLowerCase()];
+        if (value !== undefined) {
+          captures[rule.capture] = value;
+        }
       }
     }
   }
+
   return captures;
 }

package/src/core/runner/execute-run.ts

@@ -8,6 +8,8 @@ import { dirname, resolve } from "path";
 import { stat } from "node:fs/promises";
 import type { TestRunResult } from "./types.ts";
 
+export const AUTH_PATH_RE = /\/(auth|login|signin|token|oauth)\b/i;
+
 export interface ExecuteRunOptions {
   testPath: string;
   envName?: string;
@@ -52,14 +54,14 @@ export async function executeRun(options: ExecuteRunOptions): Promise<ExecuteRun
     }
   }
 
-  // Safe mode: filter to GET-only tests
+  // Safe mode: filter to GET + auth endpoints (same logic as run.ts)
   if (safe) {
     for (const suite of suites) {
-      suite.tests = suite.tests.filter(t => t.method === "GET");
+      suite.tests = suite.tests.filter(t => t.method === "GET" || !t.method || AUTH_PATH_RE.test(t.path));
     }
     suites = suites.filter(s => s.tests.length > 0);
     if (suites.length === 0) {
-      throw new Error("No GET tests found. Nothing to run in safe mode.");
+      throw new Error("No safe tests found. Nothing to run in safe mode.");
     }
   }
 
@@ -83,19 +85,40 @@ export async function executeRun(options: ExecuteRunOptions): Promise<ExecuteRun
     return env;
   }
 
-  let results: Awaited<ReturnType<typeof runSuite>>[];
+  // Phase 1: run setup suites first (sequentially), collect their captures
+  const setupSuites = suites.filter(s => s.setup);
+  const regularSuites = suites.filter(s => !s.setup);
+  const setupResults: Awaited<ReturnType<typeof runSuite>>[] = [];
+  const setupCaptures: Record<string, string> = {};
+
+  for (const suite of setupSuites) {
+    const suiteDir = suite.filePath ? dirname(suite.filePath) : envDir;
+    const env = await loadEnvWithOverrides(suiteDir);
+    const result = await runSuite(suite, env, options.dryRun);
+    setupResults.push(result);
+    for (const step of result.steps) {
+      for (const [k, v] of Object.entries(step.captures)) {
+        setupCaptures[k] = String(v);
+      }
+    }
+  }
+
+  // Phase 2: run regular suites with env enriched by setup captures
+  let regularResults: Awaited<ReturnType<typeof runSuite>>[];
   if (isDirectory) {
-    // Per-suite env: load env from each suite's own directory
-    results = await Promise.all(suites.map(async (s) => {
+    regularResults = await Promise.all(regularSuites.map(async (s) => {
       const suiteDir = s.filePath ? dirname(s.filePath) : envDir;
       const env = await loadEnvWithOverrides(suiteDir);
-      return runSuite(s, env, options.dryRun);
+      return runSuite(s, { ...env, ...setupCaptures }, options.dryRun);
     }));
   } else {
     const env = await loadEnvWithOverrides(envDir);
-    results = await Promise.all(suites.map((s) => runSuite(s, env, options.dryRun)));
+    const enrichedEnv = { ...env, ...setupCaptures };
+    regularResults = await Promise.all(regularSuites.map(s => runSuite(s, enrichedEnv, options.dryRun)));
   }
 
+  const results = [...setupResults, ...regularResults];
+
   const runId = createRun({
     started_at: results[0]?.started_at ?? new Date().toISOString(),
     environment: effectiveEnvName,

package/src/core/runner/executor.ts

@@ -1,3 +1,4 @@
+import { resolve, dirname, basename } from "node:path";
 import type { TestSuite, TestStep, Environment } from "../parser/types.ts";
 import { substituteString, substituteStep, substituteDeep, extractVariableReferences } from "../parser/variables.ts";
 import type { TestRunResult, StepResult, HttpRequest } from "./types.ts";
@@ -66,16 +67,16 @@ export async function runSuite(suite: TestSuite, env: Environment = {}, dryRun =
         const expandedStep = rawSteps[stepIndex + i]!;
         // Temporarily inject into variables when we reach this step
         // We need a way to pass the variable — use a hidden _for_each_vars
-        (expandedStep as Record<string, unknown>).__for_each_var = { key: step.for_each.var, value: items[i] };
+        (expandedStep as unknown as Record<string, unknown>).__for_each_var = { key: step.for_each.var, value: items[i] };
       }
       continue;
     }
 
     // Inject for_each variable if present
-    const forEachData = (step as Record<string, unknown>).__for_each_var as { key: string; value: unknown } | undefined;
+    const forEachData = (step as unknown as Record<string, unknown>).__for_each_var as { key: string; value: unknown } | undefined;
     if (forEachData) {
       variables[forEachData.key] = forEachData.value;
-      delete (step as Record<string, unknown>).__for_each_var;
+      delete (step as unknown as Record<string, unknown>).__for_each_var;
     }
 
     // Handle set-only steps (no HTTP request)
@@ -112,6 +113,14 @@ export async function runSuite(suite: TestSuite, env: Environment = {}, dryRun =
       }
     }
 
+    // Process set: on HTTP steps — evaluate generators once before building request
+    if (step.set) {
+      for (const [key, rawDirective] of Object.entries(step.set)) {
+        const substituted = substituteDeep(rawDirective, variables);
+        variables[key] = applyTransform(substituted);
+      }
+    }
+
     // Substitute variables
     const resolved = substituteStep(step, variables);
 
@@ -121,6 +130,7 @@ export async function runSuite(suite: TestSuite, env: Environment = {}, dryRun =
     const url = buildUrl(resolvedBaseUrl, resolved.path, resolved.query);
     const headers: Record<string, string> = { ...resolvedSuiteHeaders, ...resolved.headers };
     let body: string | undefined;
+    let formData: FormData | undefined;
 
     if (resolved.json !== undefined) {
       body = JSON.stringify(resolved.json);
@@ -132,9 +142,23 @@ export async function runSuite(suite: TestSuite, env: Environment = {}, dryRun =
       if (!headers["Content-Type"] && !headers["content-type"]) {
         headers["Content-Type"] = "application/x-www-form-urlencoded";
       }
+    } else if (resolved.multipart) {
+      const basedir = suite.filePath ? dirname(suite.filePath) : process.cwd();
+      formData = new FormData();
+      for (const [key, field] of Object.entries(resolved.multipart)) {
+        if (typeof field === "string") {
+          formData.append(key, field);
+        } else {
+          const absPath = resolve(basedir, field.file);
+          const buf = await Bun.file(absPath).arrayBuffer();
+          const mime = field.content_type ?? "application/octet-stream";
+          const filename = field.filename ?? basename(absPath);
+          formData.append(key, new Blob([buf], { type: mime }), filename);
+        }
+      }
     }
 
-    const request: HttpRequest = { method: resolved.method, url, headers, body };
+    const request: HttpRequest = { method: resolved.method, url, headers, body, formData };
 
     // Validate absolute URL before attempting fetch
     if (!url.startsWith("http://") && !url.startsWith("https://")) {
@@ -156,7 +180,9 @@ export async function runSuite(suite: TestSuite, env: Environment = {}, dryRun =
     }
 
     if (dryRun) {
-      const bodyPreview = body ? ` ${body.slice(0, 200)}` : "";
+      const bodyPreview = formData
+        ? ` [multipart: ${[...formData.keys()].length} field(s)]`
+        : body ? ` ${body.slice(0, 200)}` : "";
       steps.push({
         name: step.name,
         status: "pass",
@@ -176,7 +202,7 @@ export async function runSuite(suite: TestSuite, env: Environment = {}, dryRun =
       for (let attempt = 0; attempt < rt.max_attempts; attempt++) {
         try {
           const response = await executeRequest(request, fetchOptions);
-          const captures = extractCaptures(resolved.expect.body, response.body_parsed);
+          const captures = extractCaptures(resolved.expect.body, response.body_parsed, resolved.expect.headers, response.headers);
           const assertions = checkAssertions(resolved.expect, response);
           const allPassed = assertions.every((a) => a.passed);
 
@@ -225,8 +251,8 @@ export async function runSuite(suite: TestSuite, env: Environment = {}, dryRun =
     try {
       const response = await executeRequest(request, fetchOptions);
 
-      // Extract captures
-      const captures = extractCaptures(resolved.expect.body, response.body_parsed);
+      // Extract captures (body + header)
+      const captures = extractCaptures(resolved.expect.body, response.body_parsed, resolved.expect.headers, response.headers);
       Object.assign(variables, captures);
 
       // Track expected captures that weren't obtained

package/src/core/runner/http-client.ts

@@ -34,7 +34,7 @@ export async function executeRequest(
       const response = await fetch(request.url, {
         method: request.method,
         headers: request.headers,
-        body: request.body ?? undefined,
+        body: request.formData ?? request.body ?? undefined,
         signal: controller.signal,
         redirect: opts.follow_redirects ? "follow" : "manual",
         tls: { rejectUnauthorized: false },

package/src/core/runner/types.ts

@@ -5,6 +5,7 @@ export interface HttpRequest {
   url: string;
   headers: Record<string, string>;
   body?: string;
+  formData?: FormData;
 }
 
 export interface HttpResponse {

package/src/core/sync/spec-differ.ts

@@ -0,0 +1,38 @@
+import type { EndpointInfo } from "../generator/types.ts";
+import { normalizePath } from "../generator/coverage-scanner.ts";
+
+export interface SpecDiff {
+  /** Endpoints in current spec not present in previous snapshot */
+  newEndpoints: EndpointInfo[];
+  /** Endpoint keys from previous snapshot not present in current spec */
+  removedKeys: string[];
+  /** True if spec content hash changed (could be just description changes) */
+  specChanged: boolean;
+}
+
+/** Produce a normalized key for an endpoint: "GET /users/{*}" */
+export function endpointKey(method: string, path: string): string {
+  return `${method.toUpperCase()} ${normalizePath(path)}`;
+}
+
+/**
+ * Compare current endpoints against previously-known endpoint keys
+ * (stored as strings in .zond-meta.json).
+ */
+export function diffEndpoints(
+  prevKeys: string[],
+  currentEndpoints: EndpointInfo[],
+): Omit<SpecDiff, "specChanged"> {
+  const prevSet = new Set(prevKeys);
+  const currentSet = new Set(
+    currentEndpoints.map((ep) => endpointKey(ep.method, ep.path)),
+  );
+
+  const newEndpoints = currentEndpoints.filter(
+    (ep) => !prevSet.has(endpointKey(ep.method, ep.path)),
+  );
+
+  const removedKeys = [...prevSet].filter((key) => !currentSet.has(key));
+
+  return { newEndpoints, removedKeys };
+}

package/src/cli/commands/mcp.ts

@@ -1,16 +0,0 @@
-import { startMcpServer } from "../../mcp/server.ts";
-import { resolve } from "node:path";
-
-export interface McpCommandOptions {
-  dbPath?: string;
-  dir?: string;
-}
-
-export async function mcpCommand(options: McpCommandOptions): Promise<number> {
-  if (options.dir) {
-    process.chdir(resolve(options.dir));
-  }
-  await startMcpServer({ dbPath: options.dbPath });
-  // Server runs until stdin closes — this promise never resolves during normal operation
-  return 0;
-}

package/src/mcp/descriptions.ts

@@ -1,47 +0,0 @@
-/**
- * Single source of truth for all MCP tool descriptions.
- * Update descriptions here — they are imported by each tool file.
- */
-export const TOOL_DESCRIPTIONS = {
-  setup_api:
-    "Register a new API for testing. Creates directory structure, reads OpenAPI spec, " +
-    "sets up environment variables, and creates a collection in the database. " +
-    "Use this before generating tests for a new API. " +
-    "Warns if spec has relative server URL. Use insecure: true for self-signed HTTPS certs.",
-
-  describe_endpoint:
-    "Full details for one endpoint: params grouped by type, request body schema, " +
-    "all response schemas + response headers, security, deprecated flag. " +
-    "Use when a test fails and you need complete endpoint spec without reading the whole file.",
-
-  run_tests:
-    "Execute API tests from a YAML file or directory and return results summary with failures. " +
-    "Use after saving test suites with save_test_suite. Check query_db(action: 'diagnose_failure') for detailed failure analysis.",
-
-  query_db:
-    "Query the zond database. Actions: list_collections (all APIs with run stats), " +
-    "list_runs (recent test runs), get_run_results (full detail for a run), " +
-    "diagnose_failure (only failed/errored steps for a run — each failure includes failure_type: api_error/assertion_failed/network_error, " +
-    "and summary includes api_errors/assertion_failures/network_errors counts; stack traces are truncated by default, use verbose: true for full traces), " +
-    "compare_runs (regressions and fixes between two runs).",
-
-  coverage_analysis:
-    "Compare an OpenAPI spec against existing test files to find untested endpoints. " +
-    "Use to identify gaps and prioritize which endpoints to generate tests for next. " +
-    "Pass runId to get enriched pass/fail/5xx breakdown per endpoint. " +
-    "Always includes static spec warnings (deprecated, missing response schemas, required params without examples).",
-
-  send_request:
-    "Send an ad-hoc HTTP request. Supports variable interpolation from environments (e.g. {{base_url}}). " +
-    "Use jsonPath to extract a subset of the response (e.g. '[0].code'), maxResponseChars to truncate large responses.",
-
-  manage_server:
-    "Start, stop, restart, or check status of the zond WebUI server. " +
-    "Useful for viewing test results in a browser without leaving the MCP session.",
-
-  ci_init:
-    "Generate a CI/CD workflow file for running API tests automatically on push, PR, and schedule. " +
-    "Supports GitHub Actions and GitLab CI. Auto-detects platform from project structure " +
-    "(.github/ → GitHub, .gitlab-ci.yml → GitLab). " +
-    "Use after tests are generated and passing. After generating the workflow, help the user commit and push to activate CI.",
-} as const;

package/src/mcp/server.ts

@@ -1,38 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { registerRunTestsTool } from "./tools/run-tests.ts";
-import { registerQueryDbTool } from "./tools/query-db.ts";
-import { registerSendRequestTool } from "./tools/send-request.ts";
-import { registerCoverageAnalysisTool } from "./tools/coverage-analysis.ts";
-import { registerSetupApiTool } from "./tools/setup-api.ts";
-import { registerManageServerTool } from "./tools/manage-server.ts";
-import { registerCiInitTool } from "./tools/ci-init.ts";
-import { registerDescribeEndpointTool } from "./tools/describe-endpoint.ts";
-import { version } from "../../package.json";
-
-export interface McpServerOptions {
-  dbPath?: string;
-}
-
-export async function startMcpServer(options: McpServerOptions = {}): Promise<void> {
-  const { dbPath } = options;
-
-  const server = new McpServer({
-    name: "zond",
-    version,
-  });
-
-  // Register tools (slim set — removed set_work_dir, save_test_suite, save_test_suites)
-  registerRunTestsTool(server, dbPath);
-  registerQueryDbTool(server, dbPath);
-  registerSendRequestTool(server, dbPath);
-  registerCoverageAnalysisTool(server, dbPath);
-  registerSetupApiTool(server, dbPath);
-  registerManageServerTool(server, dbPath);
-  registerCiInitTool(server);
-  registerDescribeEndpointTool(server);
-
-  // Connect via stdio transport
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}

package/src/mcp/tools/ci-init.ts

@@ -1,54 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { ciInitCommand } from "../../cli/commands/ci-init.ts";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-
-export function registerCiInitTool(server: McpServer) {
-  server.registerTool("ci_init", {
-    description: TOOL_DESCRIPTIONS.ci_init,
-    inputSchema: {
-      platform: z.optional(z.enum(["github", "gitlab"]))
-        .describe("CI platform. If omitted, auto-detects from project structure (defaults to GitHub)"),
-      force: z.optional(z.boolean())
-        .describe("Overwrite existing CI config (default: false)"),
-      dir: z.optional(z.string())
-        .describe("Project root directory where CI config will be created (default: current working directory)"),
-    },
-  }, async ({ platform, force, dir }) => {
-    // Capture stdout to return as result
-    const logs: string[] = [];
-    const origWrite = process.stdout.write;
-    process.stdout.write = ((chunk: string | Uint8Array) => {
-      logs.push(typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk));
-      return true;
-    }) as typeof process.stdout.write;
-
-    try {
-      const code = await ciInitCommand({
-        platform,
-        force: force ?? false,
-        dir,
-      });
-
-      process.stdout.write = origWrite;
-
-      const output = logs.join("").trim();
-      if (code !== 0) {
-        return {
-          content: [{ type: "text" as const, text: JSON.stringify({ error: output || "ci init failed", exitCode: code }, null, 2) }],
-          isError: true,
-        };
-      }
-
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({ message: output, exitCode: 0 }, null, 2) }],
-      };
-    } catch (err) {
-      process.stdout.write = origWrite;
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({ error: (err as Error).message }, null, 2) }],
-        isError: true,
-      };
-    }
-  });
-}

package/src/mcp/tools/coverage-analysis.ts

@@ -1,141 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { readOpenApiSpec, extractEndpoints, scanCoveredEndpoints, filterUncoveredEndpoints, normalizePath, specPathToRegex, analyzeEndpoints } from "../../core/generator/index.ts";
-import { getDb } from "../../db/schema.ts";
-import { getResultsByRunId, getRunById } from "../../db/queries.ts";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-
-function extractPathFromUrl(url: string): string | null {
-  try {
-    return new URL(url).pathname;
-  } catch {
-    // If not a full URL, treat as path directly
-    return url.startsWith("/") ? url : null;
-  }
-}
-
-export function registerCoverageAnalysisTool(server: McpServer, dbPath?: string) {
-  server.registerTool("coverage_analysis", {
-    description: TOOL_DESCRIPTIONS.coverage_analysis,
-    inputSchema: {
-      specPath: z.string().describe("Path to OpenAPI spec file (JSON or YAML)"),
-      testsDir: z.string().describe("Path to directory with test YAML files"),
-      failThreshold: z.optional(z.number().min(0).max(100)).describe("Return isError when coverage % is below this threshold (0–100)"),
-      runId: z.optional(z.number().int()).describe("Run ID to cross-reference test results for pass/fail/5xx breakdown"),
-    },
-  }, async ({ specPath, testsDir, failThreshold, runId }) => {
-    try {
-      const doc = await readOpenApiSpec(specPath);
-      const allEndpoints = extractEndpoints(doc);
-
-      if (allEndpoints.length === 0) {
-        return {
-          content: [{ type: "text" as const, text: JSON.stringify({ error: "No endpoints found in the spec" }, null, 2) }],
-          isError: true,
-        };
-      }
-
-      const covered = await scanCoveredEndpoints(testsDir);
-      const uncovered = filterUncoveredEndpoints(allEndpoints, covered);
-      const coveredCount = allEndpoints.length - uncovered.length;
-      const percentage = Math.round((coveredCount / allEndpoints.length) * 100);
-
-      // Static warnings
-      const warnings = analyzeEndpoints(allEndpoints);
-
-      const result: Record<string, unknown> = {
-        totalEndpoints: allEndpoints.length,
-        covered: coveredCount,
-        uncovered: uncovered.length,
-        percentage,
-        uncoveredEndpoints: uncovered.map(ep => ({
-          method: ep.method,
-          path: ep.path,
-          summary: ep.summary,
-          tags: ep.tags,
-        })),
-        coveredEndpoints: covered.map(ep => ({
-          method: ep.method,
-          path: ep.path,
-          file: ep.file,
-        })),
-      };
-
-      if (warnings.length > 0) {
-        result.warnings = warnings;
-      }
-
-      // Enriched breakdown when runId is provided
-      if (runId != null) {
-        getDb(dbPath);
-        const run = getRunById(runId);
-        if (!run) {
-          return {
-            content: [{ type: "text" as const, text: JSON.stringify({ error: `Run ${runId} not found` }, null, 2) }],
-            isError: true,
-          };
-        }
-
-        const results = getResultsByRunId(runId);
-
-        // Build a map: spec endpoint → status classification
-        const endpointStatus = new Map<string, "passing" | "api_error" | "test_failed">();
-
-        for (const r of results) {
-          if (!r.request_url || !r.request_method) continue;
-          const urlPath = extractPathFromUrl(r.request_url);
-          if (!urlPath) continue;
-          const normalizedUrl = normalizePath(urlPath);
-
-          // Find matching spec endpoint
-          for (const ep of allEndpoints) {
-            const regex = specPathToRegex(ep.path);
-            if (r.request_method === ep.method && regex.test(normalizedUrl)) {
-              const key = `${ep.method} ${ep.path}`;
-              const existing = endpointStatus.get(key);
-
-              // Worst status wins: api_error > test_failed > passing
-              if (r.response_status !== null && r.response_status >= 500) {
-                endpointStatus.set(key, "api_error");
-              } else if (r.status === "fail" || r.status === "error") {
-                if (existing !== "api_error") {
-                  endpointStatus.set(key, "test_failed");
-                }
-              } else if (!existing) {
-                endpointStatus.set(key, "passing");
-              }
-              break;
-            }
-          }
-        }
-
-        let passing = 0;
-        let apiError = 0;
-        let testFailed = 0;
-        for (const status of endpointStatus.values()) {
-          if (status === "passing") passing++;
-          else if (status === "api_error") apiError++;
-          else if (status === "test_failed") testFailed++;
-        }
-
-        result.enriched = {
-          passing,
-          api_error: apiError,
-          test_failed: testFailed,
-          not_covered: uncovered.length,
-        };
-      }
-
-      const belowThreshold = failThreshold !== undefined && percentage < failThreshold;
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
-        ...(belowThreshold ? { isError: true } : {}),
-      };
-    } catch (err) {
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({ error: (err as Error).message }, null, 2) }],
-        isError: true,
-      };
-    }
-  });
-}

package/src/mcp/tools/describe-endpoint.ts

@@ -1,27 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { describeEndpoint } from "../../core/generator/describe.ts";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-
-export function registerDescribeEndpointTool(server: McpServer) {
-  server.registerTool("describe_endpoint", {
-    description: TOOL_DESCRIPTIONS.describe_endpoint,
-    inputSchema: {
-      specPath: z.string().describe("Path to OpenAPI spec file (JSON or YAML) or HTTP URL"),
-      method: z.string().describe('HTTP method, e.g. "GET", "POST", "PUT"'),
-      path: z.string().describe('Endpoint path, e.g. "/pets/{petId}"'),
-    },
-  }, async ({ specPath, method, path: endpointPath }) => {
-    try {
-      const result = await describeEndpoint(specPath, method, endpointPath);
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
-      };
-    } catch (err) {
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({ error: (err as Error).message }, null, 2) }],
-        isError: true,
-      };
-    }
-  });
-}