@kirrosh/zond 0.14.0 → 0.17.0

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,242 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { OpenAPIV3 } from "openapi-types";
-import { readOpenApiSpec } from "../../core/generator/index.ts";
-import { decycleSchema } from "../../core/generator/schema-utils.ts";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-
-function generateTestSnippet(params: {
-  method: string;
-  path: string;
-  operationId?: string;
-  pathParams: string[];
-  queryParams: Array<{ name: string; required?: boolean }>;
-  requestBody?: { required?: boolean; schema?: OpenAPIV3.SchemaObject };
-  hasSecurity: boolean;
-  successStatus: string;
-}): string {
-  const { method, path, operationId, pathParams, queryParams, requestBody, hasSecurity, successStatus } = params;
-
-  // Build URL with path params as {{paramName}}
-  const urlPath = path.replace(/\{([^}]+)\}/g, (_, name) => `{{${name}}}`);
-  const url = `{{base_url}}${urlPath}`;
-
-  const lines: string[] = [];
-  const testName = operationId ?? `${method} ${path}`;
-  lines.push(`- name: "${testName}"`);
-  lines.push(`  ${method}: "${url}"`);
-
-  if (hasSecurity) {
-    lines.push(`  headers:`);
-    lines.push(`    Authorization: "Bearer {{auth_token}}"`);
-  }
-
-  // Required query params
-  const requiredQuery = queryParams.filter(p => p.required);
-  if (requiredQuery.length > 0) {
-    lines.push(`  query:`);
-    for (const p of requiredQuery) {
-      lines.push(`    ${p.name}: "{{${p.name}}}"`);
-    }
-  }
-
-  // Request body for POST/PUT/PATCH
-  if (requestBody && ["POST", "PUT", "PATCH"].includes(method)) {
-    const schema = requestBody.schema as OpenAPIV3.SchemaObject | undefined;
-    const required = Array.isArray(schema?.required) ? schema.required : [];
-    const properties = schema?.properties as Record<string, OpenAPIV3.SchemaObject> | undefined;
-    if (properties && Object.keys(properties).length > 0) {
-      lines.push(`  json:`);
-      for (const [propName, propSchema] of Object.entries(properties)) {
-        if (!required.includes(propName)) continue;
-        const type = (propSchema as OpenAPIV3.SchemaObject).type ?? "string";
-        const placeholder = type === "integer" || type === "number" ? 0 : type === "boolean" ? false : `"{{${propName}}}"`;
-        lines.push(`    ${propName}: ${placeholder}`);
-      }
-    }
-  }
-
-  lines.push(`  expect:`);
-  lines.push(`    status: ${successStatus}`);
-
-  return lines.join("\n");
-}
-
-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 doc = await readOpenApiSpec(specPath) as OpenAPIV3.Document;
-
-      // Normalize inputs
-      const methodLower = method.toLowerCase() as OpenAPIV3.HttpMethods;
-      const normalizedPath = endpointPath.replace(/\/+$/, "") || "/";
-
-      // Find operation — try exact match first, then case-insensitive path match
-      let operation: OpenAPIV3.OperationObject | undefined;
-      let resolvedPath = normalizedPath;
-
-      const paths = doc.paths ?? {};
-
-      if (paths[normalizedPath]?.[methodLower]) {
-        operation = paths[normalizedPath][methodLower] as OpenAPIV3.OperationObject;
-      } else {
-        // Case-insensitive fallback
-        const lowerTarget = normalizedPath.toLowerCase();
-        for (const [p, pathItem] of Object.entries(paths)) {
-          if (p.toLowerCase() === lowerTarget && pathItem?.[methodLower]) {
-            operation = pathItem[methodLower] as OpenAPIV3.OperationObject;
-            resolvedPath = p;
-            break;
-          }
-        }
-      }
-
-      if (!operation) {
-        const available = Object.entries(paths).flatMap(([p, pathItem]) =>
-          Object.keys(pathItem ?? {})
-            .filter(k => ["get","post","put","patch","delete","head","options","trace"].includes(k))
-            .map(k => `${k.toUpperCase()} ${p}`)
-        ).sort();
-        return {
-          content: [{
-            type: "text" as const,
-            text: JSON.stringify({
-              error: `Endpoint ${method.toUpperCase()} ${endpointPath} not found in spec`,
-              availableEndpoints: available,
-            }, null, 2),
-          }],
-          isError: true,
-        };
-      }
-
-      const pathItem = paths[resolvedPath] ?? {};
-
-      // Merge path-level and operation-level parameters (operation overrides by name+in)
-      const pathLevelParams = (pathItem.parameters ?? []) as OpenAPIV3.ParameterObject[];
-      const opLevelParams = (operation.parameters ?? []) as OpenAPIV3.ParameterObject[];
-
-      const paramMap = new Map<string, OpenAPIV3.ParameterObject>();
-      for (const p of pathLevelParams) paramMap.set(`${p.in}:${p.name}`, p);
-      for (const p of opLevelParams) paramMap.set(`${p.in}:${p.name}`, p); // operation overrides
-
-      // Group by "in"
-      const grouped: Record<string, object[]> = { path: [], query: [], header: [], cookie: [] };
-      for (const p of paramMap.values()) {
-        const loc = p.in in grouped ? p.in : "query";
-        const schema = p.schema as OpenAPIV3.SchemaObject | undefined;
-        grouped[loc]!.push({
-          name: p.name,
-          required: p.required ?? false,
-          ...(schema?.type ? { type: schema.type } : {}),
-          ...(schema?.format ? { format: schema.format } : {}),
-          ...(schema?.enum ? { enum: schema.enum } : {}),
-          ...(schema?.default !== undefined ? { default: schema.default } : {}),
-          ...(p.description ? { description: p.description } : {}),
-        });
-      }
-
-      // Request body
-      let requestBody: object | undefined;
-      if (operation.requestBody) {
-        const rb = operation.requestBody as OpenAPIV3.RequestBodyObject;
-        const contentTypes = Object.keys(rb.content ?? {});
-        const preferredCt = contentTypes.find(ct => ct.includes("application/json")) ?? contentTypes[0];
-        const mediaObj = preferredCt ? rb.content[preferredCt] : undefined;
-        requestBody = {
-          required: rb.required ?? false,
-          ...(preferredCt ? { contentType: preferredCt } : {}),
-          ...(mediaObj?.schema ? { schema: mediaObj.schema } : {}),
-          ...(rb.description ? { description: rb.description } : {}),
-        };
-      }
-
-      // Responses
-      const responses: Record<string, object> = {};
-      for (const [statusCode, respObj] of Object.entries(operation.responses ?? {})) {
-        const resp = respObj as OpenAPIV3.ResponseObject;
-        const contentTypes = Object.keys(resp.content ?? {});
-        const preferredCt = contentTypes.find(ct => ct.includes("application/json")) ?? contentTypes[0];
-        const mediaObj = preferredCt ? resp.content?.[preferredCt] : undefined;
-
-        // Response headers
-        const headers: Record<string, object> = {};
-        for (const [hName, hObj] of Object.entries(resp.headers ?? {})) {
-          const h = hObj as OpenAPIV3.HeaderObject;
-          headers[hName] = {
-            ...(h.description ? { description: h.description } : {}),
-            ...(h.schema ? { schema: h.schema } : {}),
-          };
-        }
-
-        responses[statusCode] = {
-          description: resp.description,
-          headers,
-          ...(preferredCt ? { contentType: preferredCt } : {}),
-          ...(mediaObj?.schema ? { schema: mediaObj.schema } : {}),
-        };
-      }
-
-      // Security — merge doc-level and operation-level
-      const docSecurity = (doc.security ?? []) as OpenAPIV3.SecurityRequirementObject[];
-      const opSecurity = (operation.security ?? docSecurity) as OpenAPIV3.SecurityRequirementObject[];
-      const securityNames = [...new Set(opSecurity.flatMap(req => Object.keys(req)))];
-
-      // Derive success status (first 2xx, or first response code)
-      const responseCodes = Object.keys(operation.responses ?? {});
-      const successStatus = responseCodes.find(c => c.startsWith("2")) ?? responseCodes[0] ?? "200";
-
-      // Build testSnippet
-      const pathParamNames = [...paramMap.values()]
-        .filter(p => p.in === "path")
-        .map(p => p.name);
-      const queryParamsList = [...paramMap.values()]
-        .filter(p => p.in === "query")
-        .map(p => ({ name: p.name, required: p.required }));
-      const reqBodyForSnippet = requestBody
-        ? { required: (operation.requestBody as OpenAPIV3.RequestBodyObject)?.required, schema: (requestBody as any).schema }
-        : undefined;
-
-      const testSnippet = generateTestSnippet({
-        method: method.toUpperCase(),
-        path: resolvedPath,
-        operationId: operation.operationId,
-        pathParams: pathParamNames,
-        queryParams: queryParamsList,
-        requestBody: reqBodyForSnippet,
-        hasSecurity: securityNames.length > 0,
-        successStatus,
-      });
-
-      const result = {
-        method: method.toUpperCase(),
-        path: resolvedPath,
-        ...(operation.operationId ? { operationId: operation.operationId } : {}),
-        ...(operation.summary ? { summary: operation.summary } : {}),
-        ...(operation.description ? { description: operation.description } : {}),
-        ...(operation.tags?.length ? { tags: operation.tags } : {}),
-        deprecated: operation.deprecated ?? false,
-        security: securityNames,
-        parameters: grouped,
-        ...(requestBody ? { requestBody } : {}),
-        responses,
-        testSnippet,
-      };
-
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify(decycleSchema(result), null, 2) }],
-      };
-    } catch (err) {
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({ error: (err as Error).message }, null, 2) }],
-        isError: true,
-      };
-    }
-  });
-}

package/src/mcp/tools/generate-and-save.ts

@@ -1,202 +0,0 @@
-import { z } from "zod";
-import { join } from "node:path";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import {
-  readOpenApiSpec,
-  extractEndpoints,
-  extractSecuritySchemes,
-  scanCoveredEndpoints,
-  filterUncoveredEndpoints,
-  serializeSuite,
-  generateSuites,
-  findUnresolvedVars,
-} from "../../core/generator/index.ts";
-import { loadEnvironment } from "../../core/parser/variables.ts";
-import { compressEndpointsWithSchemas, buildGenerationGuide } from "../../core/generator/guide-builder.ts";
-import { findCollectionBySpec } from "../../db/queries.ts";
-import { planChunks, filterByTag } from "../../core/generator/chunker.ts";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-import { validateAndSave } from "./save-test-suite.ts";
-
-export function registerGenerateAndSaveTool(server: McpServer) {
-  server.registerTool("generate_and_save", {
-    description: TOOL_DESCRIPTIONS.generate_and_save,
-    inputSchema: {
-      specPath: z.string().describe("Path or URL to OpenAPI spec file"),
-      outputDir: z.optional(z.string()).describe("Directory for saving test files (default: ./tests/)"),
-      tag: z.optional(z.string()).describe("Generate tests only for this tag's endpoints"),
-      methodFilter: z.optional(z.array(z.string())).describe("Only include endpoints with these HTTP methods (e.g. [\"GET\"] for smoke tests)"),
-      testsDir: z.optional(z.string()).describe("Path to existing tests directory — filters to uncovered endpoints only"),
-      overwrite: z.optional(z.boolean()).describe("Hint for save_test_suites overwrite behavior (default: false)"),
-      includeFormat: z.optional(z.boolean()).describe("Include YAML format reference (default: true, set false for subsequent tag chunks)"),
-      mode: z.optional(z.enum(["generate", "guide"])).describe(
-        "'generate' creates and saves YAML test files deterministically (default), 'guide' returns text for LLM-crafted tests"
-      ),
-    },
-  }, async ({ specPath, outputDir, tag, methodFilter, testsDir, overwrite, includeFormat, mode }) => {
-    try {
-      const doc = await readOpenApiSpec(specPath);
-      let endpoints = extractEndpoints(doc);
-      const securitySchemes = extractSecuritySchemes(doc);
-      const baseUrl = ((doc as any).servers?.[0]?.url) as string | undefined;
-      const title = (doc as any).info?.title as string | undefined;
-      let effectiveOutputDir = outputDir;
-      if (!effectiveOutputDir) {
-        const collection = findCollectionBySpec(specPath);
-        effectiveOutputDir = collection?.test_path ?? "./tests/";
-      }
-      const effectiveMode = mode ?? "generate";
-
-      // Apply method filter
-      if (methodFilter && methodFilter.length > 0) {
-        const methods = methodFilter.map(m => m.toUpperCase());
-        endpoints = endpoints.filter(ep => methods.includes(ep.method.toUpperCase()));
-      }
-
-      // Coverage filtering
-      let coverageInfo: { covered: number; total: number; percentage: number } | undefined;
-      if (testsDir) {
-        const totalBefore = endpoints.length;
-        const covered = await scanCoveredEndpoints(testsDir);
-        const uncovered = filterUncoveredEndpoints(endpoints, covered);
-        const coveredCount = totalBefore - uncovered.length;
-        const percentage = totalBefore > 0 ? Math.round((coveredCount / totalBefore) * 100) : 100;
-        coverageInfo = { covered: coveredCount, total: totalBefore, percentage };
-        endpoints = uncovered;
-      }
-
-      if (endpoints.length === 0) {
-        const msg = testsDir
-          ? { fullyCovered: true, ...coverageInfo }
-          : { error: "No endpoints found in the spec" };
-        return {
-          content: [{ type: "text" as const, text: JSON.stringify(msg, null, 2) }],
-          isError: !testsDir,
-        };
-      }
-
-      // Tag filtering
-      if (tag) {
-        endpoints = filterByTag(endpoints, tag);
-        if (endpoints.length === 0) {
-          return {
-            content: [{ type: "text" as const, text: JSON.stringify({ error: `No endpoints found for tag "${tag}"` }, null, 2) }],
-            isError: true,
-          };
-        }
-      }
-
-      const plan = planChunks(endpoints);
-
-      // Plan mode: large API without specific tag
-      if (plan.needsChunking && !tag) {
-        const result: Record<string, unknown> = {
-          mode: "plan",
-          title: title ?? "API",
-          totalEndpoints: plan.totalEndpoints,
-          chunks: plan.chunks,
-          instruction:
-            `This API has ${plan.totalEndpoints} endpoints across ${plan.chunks.length} tags. ` +
-            `Call generate_and_save with tag parameter for each chunk sequentially. ` +
-            (effectiveMode === "guide"
-              ? `Pass includeFormat: false for subsequent chunks to save tokens. `
-              : "") +
-            `Example: generate_and_save(specPath: '${specPath}', tag: '${plan.chunks[0]!.tag}'` +
-            (effectiveMode === "guide" ? `, mode: 'guide'` : "") + `)`,
-        };
-        if (coverageInfo) {
-          result.coverage = coverageInfo;
-        }
-        return {
-          content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
-        };
-      }
-
-      // ── Generate mode: deterministic YAML generation ──
-      if (effectiveMode === "generate") {
-        const suites = generateSuites({ endpoints, securitySchemes });
-
-        const files: Array<{
-          saved: boolean;
-          filePath: string;
-          tests: number;
-          error?: string;
-        }> = [];
-
-        for (const suite of suites) {
-          const yaml = serializeSuite(suite);
-          const fileName = (suite.fileStem ?? suite.name) + ".yaml";
-          const filePath = join(effectiveOutputDir, fileName);
-
-          const { result: saveResult } = await validateAndSave(filePath, yaml, overwrite ?? false);
-          files.push({
-            saved: saveResult.saved,
-            filePath: saveResult.filePath ?? filePath,
-            tests: suite.tests.length,
-            ...(saveResult.error ? { error: saveResult.error } : {}),
-          });
-        }
-
-        const warnings: string[] = [];
-        const env = await loadEnvironment(undefined, effectiveOutputDir);
-        const envKeys = new Set(Object.keys(env));
-        for (const suite of suites) {
-          const unresolved = findUnresolvedVars(suite, envKeys);
-          if (unresolved.length > 0)
-            warnings.push(`${suite.fileStem ?? suite.name}.yaml: unresolved [${unresolved.join(", ")}]`);
-        }
-
-        const response: Record<string, unknown> = {
-          mode: "generate",
-          suitesGenerated: suites.length,
-          files,
-          ...(warnings.length > 0 ? { warnings } : {}),
-          hint: files.some(f => !f.saved)
-            ? "Some files were not saved (already exist?). Use overwrite: true to replace."
-            : "Files saved. Run run_tests to verify. Use mode: 'guide' for LLM-crafted tests with more detail.",
-        };
-        if (coverageInfo) {
-          response.coverage = coverageInfo;
-        }
-
-        return {
-          content: [{ type: "text" as const, text: JSON.stringify(response, null, 2) }],
-        };
-      }
-
-      // ── Guide mode: text-based generation guide ──
-      const coverageHeader = coverageInfo
-        ? `## Coverage: ${coverageInfo.covered}/${coverageInfo.total} endpoints covered (${coverageInfo.percentage}%). Generating tests for ${endpoints.length} uncovered endpoints:`
-        : undefined;
-
-      const apiContext = compressEndpointsWithSchemas(endpoints, securitySchemes);
-      const guide = buildGenerationGuide({
-        title: tag ? `${title ?? "API"} — tag: ${tag}` : (title ?? "API"),
-        baseUrl,
-        apiContext,
-        outputDir: effectiveOutputDir,
-        securitySchemes,
-        endpointCount: endpoints.length,
-        coverageHeader,
-        includeFormat: includeFormat ?? true,
-      });
-
-      const saveInstructions = `
----
-## Save Instructions
-- Output directory: ${effectiveOutputDir}
-- Use \`save_test_suites\` to save all generated files in one call
-- Overwrite: ${overwrite ? "true" : "false (set overwrite: true in save_test_suites to replace existing files)"}
-- After saving, run \`run_tests\` to verify`;
-
-      return {
-        content: [{ type: "text" as const, text: guide + saveInstructions }],
-      };
-    } catch (err) {
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({ error: (err as Error).message }, null, 2) }],
-        isError: true,
-      };
-    }
-  });
-}