@kirrosh/zond 0.7.1 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kirrosh/zond",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "API testing platform — define tests in YAML, run from CLI or WebUI, generate from OpenAPI specs",
   "license": "MIT",
   "module": "index.ts",

package/src/core/agent/system-prompt.ts

@@ -1,15 +1,14 @@
-export const AGENT_SYSTEM_PROMPT = `You are an API testing assistant powered by zond. You help users run, create, validate, and diagnose API tests.
+export const AGENT_SYSTEM_PROMPT = `You are an API testing assistant powered by zond. You help users run, create, and diagnose API tests.
 
 You have access to the following tools:
 
 - **run_tests**: Execute API test suites from YAML files or directories. Returns pass/fail summary with run ID.
-- **validate_tests**: Validate YAML test files without executing them. Check syntax and structure.
 - **query_results**: Query historical test run results and collections from the database.
 - **diagnose_failure**: Analyze a failed test run to identify root causes and suggest fixes.
+- **send_request**: Send an ad-hoc HTTP request for quick testing.
 
 Tool usage examples:
 - run_tests: { testPath: "tests/api.yaml" } or { testPath: "tests/", envName: "staging", safe: true }
-- validate_tests: { testPath: "tests/api.yaml" }
 - query_results: action must be "list_runs", "get_run" (requires runId), or "list_collections"
   - List runs: { action: "list_runs", limit: 10 }
   - Get run details: { action: "get_run", runId: 1 }

package/src/core/agent/tools/index.ts

@@ -1,10 +1,8 @@
 import { tool } from "ai";
 import { runTestsTool } from "./run-tests.ts";
-import { validateTestsTool } from "./validate-tests.ts";
 import { queryResultsTool } from "./query-results.ts";
 import { diagnoseFailureTool } from "./diagnose-failure.ts";
 import { sendRequestTool } from "./send-request.ts";
-import { exploreApiTool } from "./explore-api.ts";
 import type { AgentConfig } from "../types.ts";
 
 export function buildAgentTools(config: AgentConfig) {
@@ -35,12 +33,10 @@ export function buildAgentTools(config: AgentConfig) {
 
   return {
     run_tests,
-    validate_tests: validateTestsTool,
     query_results: queryResultsTool,
     diagnose_failure: diagnoseFailureTool,
     send_request,
-    explore_api: exploreApiTool,
   };
 }
 
-export { runTestsTool, validateTestsTool, queryResultsTool, diagnoseFailureTool, sendRequestTool, exploreApiTool };
+export { runTestsTool, queryResultsTool, diagnoseFailureTool, sendRequestTool };

package/src/{mcp/tools/generate-tests-guide.ts → core/generator/guide-builder.ts}

@@ -1,56 +1,5 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { readOpenApiSpec, extractEndpoints, extractSecuritySchemes } from "../../core/generator/index.ts";
-import type { EndpointInfo, SecuritySchemeInfo } from "../../core/generator/types.ts";
-import { compressSchema, formatParam, isAnySchema } from "../../core/generator/schema-utils.ts";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-
-export function registerGenerateTestsGuideTool(server: McpServer) {
-  server.registerTool("generate_tests_guide", {
-    description: TOOL_DESCRIPTIONS.generate_tests_guide,
-    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/)"),
-      methodFilter: z.optional(z.array(z.string())).describe("Only include endpoints with these HTTP methods (e.g. [\"GET\"] for smoke tests)"),
-      tag: z.optional(z.string()).describe("Filter endpoints by tag"),
-    },
-  }, async ({ specPath, outputDir, methodFilter, tag }) => {
-    try {
-      const doc = await readOpenApiSpec(specPath);
-      let endpoints = extractEndpoints(doc);
-      if (methodFilter && methodFilter.length > 0) {
-        const methods = methodFilter.map(m => m.toUpperCase());
-        endpoints = endpoints.filter(ep => methods.includes(ep.method.toUpperCase()));
-      }
-      if (tag) {
-        const lower = tag.toLowerCase();
-        endpoints = endpoints.filter(ep => ep.tags.some(t => t.toLowerCase() === lower));
-      }
-      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;
-
-      const apiContext = compressEndpointsWithSchemas(endpoints, securitySchemes);
-      const guide = buildGenerationGuide({
-        title: title ?? "API",
-        baseUrl,
-        apiContext,
-        outputDir: outputDir ?? "./tests/",
-        securitySchemes,
-        endpointCount: endpoints.length,
-      });
-
-      return {
-        content: [{ type: "text" as const, text: guide }],
-      };
-    } catch (err) {
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({ error: (err as Error).message }, null, 2) }],
-        isError: true,
-      };
-    }
-  });
-}
+import type { EndpointInfo, SecuritySchemeInfo } from "./types.ts";
+import { compressSchema, formatParam, isAnySchema } from "./schema-utils.ts";
 
 export function compressEndpointsWithSchemas(
   endpoints: EndpointInfo[],
@@ -262,7 +211,7 @@ Never put actual key values directly in YAML test files.
 - Note required fields in request bodies
 
 ### Step 2: Plan Test Suites
-Before generating, check coverage with \`coverage_analysis\` to avoid duplicating existing tests. Use \`generate_missing_tests\` for incremental generation.
+Before generating, check coverage with \`coverage_analysis\` to avoid duplicating existing tests. Use \`generate_and_save(testsDir=...)\` for incremental generation of uncovered endpoints only.
 
 > **Coverage note**: coverage is a static scan of YAML files — an endpoint is "covered" if a test file contains a matching METHOD + path line, regardless of whether tests pass or actually run.
 
@@ -372,13 +321,13 @@ Example: \`zond run --tag smoke --safe\` → reads-only, safe against production
 | Tool | When |
 |------|------|
 | \`setup_api\` | Register a new API (creates dirs, reads spec, sets up env) |
-| \`generate_tests_guide\` | Get this guide for full API spec |
-| \`generate_missing_tests\` | Get guide for only uncovered endpoints |
+| \`generate_and_save\` | Get test generation guide (with auto-chunking for large APIs) |
 | \`save_test_suite\` | Save generated YAML (validates before writing) |
+| \`save_test_suites\` | Save multiple YAML files in one call |
 | \`run_tests\` | Execute saved test suites |
 | \`query_db\` | Query runs, collections, results, diagnose failures |
 | \`coverage_analysis\` | Find untested endpoints for incremental generation |
-| \`explore_api\` | Re-check specific endpoints (use includeSchemas=true) |
+| \`describe_endpoint\` | Get full details for one endpoint when debugging |
 | \`ci_init\` | Generate CI/CD workflow (GitHub Actions / GitLab CI) to run tests on push |
 
 ## Workflow After Tests Pass

package/src/core/generator/index.ts

@@ -8,5 +8,7 @@ export type { AIProviderConfig, AIGenerateOptions, AIGenerateResult } from "./ai
 export { scanCoveredEndpoints, filterUncoveredEndpoints, normalizePath, specPathToRegex } from "./coverage-scanner.ts";
 export type { CoveredEndpoint } from "./coverage-scanner.ts";
 export { analyzeEndpoints } from "./endpoint-warnings.ts";
+export { compressEndpointsWithSchemas, buildGenerationGuide } from "./guide-builder.ts";
+export type { GuideOptions } from "./guide-builder.ts";
 export type { EndpointWarning, WarningCode } from "./endpoint-warnings.ts";
 export type { EndpointInfo, ResponseInfo, GenerateOptions, SecuritySchemeInfo, CrudGroup } from "./types.ts";

package/src/core/generator/schema-utils.ts

@@ -1,5 +1,35 @@
 import type { OpenAPIV3 } from "openapi-types";
 
+/**
+ * Deep-clone an object, replacing circular references with `{ "$ref": "[Circular]" }`.
+ * Uses WeakSet to track visited objects.
+ */
+export function decycleSchema(obj: unknown): unknown {
+  const seen = new WeakSet<object>();
+
+  function walk(value: unknown): unknown {
+    if (value === null || typeof value !== "object") return value;
+
+    if (Array.isArray(value)) {
+      return value.map(item => walk(item));
+    }
+
+    const obj = value as Record<string, unknown>;
+    if (seen.has(obj)) {
+      return { $ref: "[Circular]" };
+    }
+    seen.add(obj);
+
+    const result: Record<string, unknown> = {};
+    for (const key of Object.keys(obj)) {
+      result[key] = walk(obj[key]);
+    }
+    return result;
+  }
+
+  return walk(obj);
+}
+
 /**
  * Returns true if the schema is effectively `any` — no type, no properties, no constraints.
  */

package/src/mcp/descriptions.ts

@@ -14,42 +14,20 @@ export const TOOL_DESCRIPTIONS = {
     "sets up environment variables, and creates a collection in the database. " +
     "Use this before generating tests for a new API.",
 
-  explore_api:
-    "Explore an OpenAPI spec — list endpoints, servers, and security schemes. " +
-    "Use with includeSchemas=true when generating tests to get full request/response body schemas.",
-
   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.",
 
-  generate_tests_guide:
-    "Get a comprehensive guide for generating API test suites. " +
-    "Returns the full API specification (with request/response schemas) and a step-by-step algorithm " +
-    "for creating YAML test files. Use this BEFORE generating tests — it gives you " +
-    "everything you need to write high-quality test suites. " +
-    "After generating, use save_test_suite to save, run_tests to execute, " +
-    "manage_server(action: 'start') to view results in the Web UI, " +
-    "and query_db(action: 'diagnose_failure') to debug failures.",
-
-  generate_missing_tests:
-    "Analyze test coverage and generate a test guide for only the uncovered endpoints. " +
-    "Combines coverage_analysis + generate_tests_guide — returns a focused guide for missing tests. " +
-    "Use this for incremental test generation to avoid duplicating existing tests. " +
-    "After saving and running new tests, use manage_server(action: 'start') to view results in the Web UI.",
-
   save_test_suite:
     "Save a YAML test suite file with validation. Parses and validates the YAML content " +
     "before writing. Returns structured errors if validation fails so you can fix and retry. " +
-    "Use after generating test content with generate_tests_guide.",
+    "Use after generating test content with generate_and_save.",
 
   save_test_suites:
     "Save multiple YAML test suite files in a single call. Each file is validated before writing. " +
     "Returns per-file results. Use when you have generated multiple suites at once.",
 
-  validate_tests:
-    "Validate YAML test files without running them. Returns parsed suite info or validation errors.",
-
   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.",

package/src/mcp/server.ts

@@ -1,15 +1,11 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { registerRunTestsTool } from "./tools/run-tests.ts";
-import { registerValidateTestsTool } from "./tools/validate-tests.ts";
 import { registerQueryDbTool } from "./tools/query-db.ts";
 import { registerSendRequestTool } from "./tools/send-request.ts";
-import { registerExploreApiTool } from "./tools/explore-api.ts";
 import { registerCoverageAnalysisTool } from "./tools/coverage-analysis.ts";
 import { registerSaveTestSuiteTool, registerSaveTestSuitesTool } from "./tools/save-test-suite.ts";
-import { registerGenerateTestsGuideTool } from "./tools/generate-tests-guide.ts";
 import { registerSetupApiTool } from "./tools/setup-api.ts";
-import { registerGenerateMissingTestsTool } from "./tools/generate-missing-tests.ts";
 import { registerManageServerTool } from "./tools/manage-server.ts";
 import { registerCiInitTool } from "./tools/ci-init.ts";
 import { registerSetWorkDirTool } from "./tools/set-work-dir.ts";
@@ -25,21 +21,17 @@ export async function startMcpServer(options: McpServerOptions = {}): Promise<vo
 
   const server = new McpServer({
     name: "zond",
-    version: "0.7.1",
+    version: "0.8.0",
   });
 
   // Register all tools
   registerRunTestsTool(server, dbPath);
-  registerValidateTestsTool(server);
   registerQueryDbTool(server, dbPath);
   registerSendRequestTool(server, dbPath);
-  registerExploreApiTool(server);
   registerCoverageAnalysisTool(server, dbPath);
   registerSaveTestSuiteTool(server, dbPath);
   registerSaveTestSuitesTool(server, dbPath);
-  registerGenerateTestsGuideTool(server);
   registerSetupApiTool(server, dbPath);
-  registerGenerateMissingTestsTool(server);
   registerManageServerTool(server, dbPath);
   registerCiInitTool(server);
   registerSetWorkDirTool(server);

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

@@ -2,6 +2,7 @@ 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: {
@@ -229,7 +230,7 @@ export function registerDescribeEndpointTool(server: McpServer) {
       };
 
       return {
-        content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
+        content: [{ type: "text" as const, text: JSON.stringify(decycleSchema(result), null, 2) }],
       };
     } catch (err) {
       return {

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

@@ -7,7 +7,7 @@ import {
   scanCoveredEndpoints,
   filterUncoveredEndpoints,
 } from "../../core/generator/index.ts";
-import { compressEndpointsWithSchemas, buildGenerationGuide } from "./generate-tests-guide.ts";
+import { compressEndpointsWithSchemas, buildGenerationGuide } from "../../core/generator/guide-builder.ts";
 import { planChunks, filterByTag } from "../../core/generator/chunker.ts";
 import { TOOL_DESCRIPTIONS } from "../descriptions.js";
 

package/src/mcp/tools/save-test-suite.ts

@@ -138,7 +138,7 @@ export async function validateAndSave(
 
       const coverage: Record<string, unknown> = { percentage, covered: coveredCount, total, uncoveredCount: uncovered.length };
       if (percentage < 80 && uncovered.length > 0) {
-        coverage.suggestion = `Use generate_missing_tests to cover ${uncovered.length} remaining endpoint${uncovered.length > 1 ? "s" : ""}`;
+        coverage.suggestion = `Use generate_and_save with testsDir to cover ${uncovered.length} remaining endpoint${uncovered.length > 1 ? "s" : ""}`;
       }
       result.coverage = coverage;
     }

package/src/web/views/suites-tab.ts

@@ -8,7 +8,7 @@ import { basename } from "node:path";
 
 export function renderSuitesTab(state: CollectionState): string {
   if (state.suites.length === 0) {
-    return `<div class="tab-empty">No test suites found on disk. Generate tests with <code>generate_tests_guide</code> or <code>generate_and_save</code>.</div>`;
+    return `<div class="tab-empty">No test suites found on disk. Generate tests with <code>generate_and_save</code>.</div>`;
   }
 
   const rows = state.suites.map((s, i) => renderSuiteRow(s, i)).join("");

package/src/core/agent/tools/explore-api.ts

@@ -1,40 +0,0 @@
-import { tool } from "ai";
-import { z } from "zod";
-import { readOpenApiSpec, extractEndpoints, extractSecuritySchemes } from "../../generator/index.ts";
-
-export const exploreApiTool = tool({
-  description: "Explore an OpenAPI spec — list endpoints with method, path, and summary. Optionally filter by tag.",
-  inputSchema: z.object({
-    specPath: z.string().describe("Path to OpenAPI spec file (JSON or YAML)"),
-    tag: z.string().optional().describe("Filter endpoints by tag"),
-  }),
-  execute: async (args) => {
-    try {
-      const doc = await readOpenApiSpec(args.specPath);
-      const allEndpoints = extractEndpoints(doc);
-      const securitySchemes = extractSecuritySchemes(doc);
-      const servers = ((doc as any).servers ?? []) as Array<{ url: string }>;
-
-      const endpoints = args.tag
-        ? allEndpoints.filter(ep => ep.tags.includes(args.tag!))
-        : allEndpoints;
-
-      // Compact output — method + path + summary only
-      return {
-        title: (doc as any).info?.title,
-        version: (doc as any).info?.version,
-        servers: servers.map(s => s.url),
-        securitySchemes: securitySchemes.map(s => s.name),
-        totalEndpoints: allEndpoints.length,
-        ...(args.tag ? { filteredByTag: args.tag, matchingEndpoints: endpoints.length } : {}),
-        endpoints: endpoints.map(ep => ({
-          method: ep.method,
-          path: ep.path,
-          summary: ep.summary,
-        })),
-      };
-    } catch (err) {
-      return { error: (err as Error).message };
-    }
-  },
-});

package/src/core/agent/tools/validate-tests.ts

@@ -1,23 +0,0 @@
-import { tool } from "ai";
-import { z } from "zod";
-import { parse } from "../../parser/yaml-parser.ts";
-
-export const validateTestsTool = tool({
-  description: "Validate YAML test files without running them. Returns parsed suite info or validation errors.",
-  inputSchema: z.object({
-    testPath: z.string().describe("Path to test YAML file or directory"),
-  }),
-  execute: async (args) => {
-    try {
-      const suites = await parse(args.testPath);
-      return {
-        valid: true,
-        suiteCount: suites.length,
-        totalTests: suites.reduce((s, suite) => s + suite.tests.length, 0),
-        suites: suites.map((s) => ({ name: s.name, testCount: s.tests.length })),
-      };
-    } catch (err) {
-      return { valid: false, error: (err as Error).message };
-    }
-  },
-});

package/src/mcp/tools/explore-api.ts

@@ -1,84 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { readOpenApiSpec, extractEndpoints, extractSecuritySchemes } from "../../core/generator/index.ts";
-import { compressSchema, formatParam } from "../../core/generator/schema-utils.ts";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-
-export function registerExploreApiTool(server: McpServer) {
-  server.registerTool("explore_api", {
-    description: TOOL_DESCRIPTIONS.explore_api,
-    inputSchema: {
-      specPath: z.string().describe("Path to OpenAPI spec file (JSON or YAML)"),
-      tag: z.optional(z.string()).describe("Filter endpoints by tag"),
-      includeSchemas: z.optional(z.boolean()).describe("Include request/response body schemas and parameter types (default: false)"),
-    },
-  }, async ({ specPath, tag, includeSchemas }) => {
-    try {
-      const doc = await readOpenApiSpec(specPath);
-      const allEndpoints = extractEndpoints(doc);
-      const securitySchemes = extractSecuritySchemes(doc);
-      const servers = ((doc as any).servers ?? []) as Array<{ url: string; description?: string }>;
-
-      const endpoints = tag
-        ? allEndpoints.filter(ep => ep.tags.includes(tag))
-        : allEndpoints;
-
-      const result = {
-        title: (doc as any).info?.title,
-        version: (doc as any).info?.version,
-        servers: servers.map(s => ({ url: s.url, description: s.description })),
-        securitySchemes: securitySchemes.map(s => ({
-          name: s.name,
-          type: s.type,
-          ...(s.scheme ? { scheme: s.scheme } : {}),
-          ...(s.in ? { in: s.in, keyName: s.apiKeyName } : {}),
-        })),
-        totalEndpoints: allEndpoints.length,
-        ...(tag ? { filteredByTag: tag, matchingEndpoints: endpoints.length } : {}),
-        endpoints: endpoints.map(ep => {
-          const base: Record<string, unknown> = {
-            method: ep.method,
-            path: ep.path,
-            summary: ep.summary,
-            tags: ep.tags,
-            parameters: ep.parameters.map(p => ({
-              name: p.name,
-              in: p.in,
-              required: p.required ?? false,
-              ...(includeSchemas ? { type: formatParam(p).split(": ")[1] } : {}),
-            })),
-            hasRequestBody: !!ep.requestBodySchema,
-            responses: ep.responses.map(r => ({
-              statusCode: r.statusCode,
-              description: r.description,
-              ...(includeSchemas && r.schema ? { schema: compressSchema(r.schema) } : {}),
-            })),
-          };
-
-          if (includeSchemas) {
-            if (ep.requestBodySchema) {
-              base.requestBodySchema = compressSchema(ep.requestBodySchema);
-            }
-            if (ep.requestBodyContentType) {
-              base.requestBodyContentType = ep.requestBodyContentType;
-            }
-            if (ep.security.length > 0) {
-              base.security = ep.security;
-            }
-          }
-
-          return base;
-        }),
-      };
-
-      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,
-      };
-    }
-  });
-}

package/src/mcp/tools/generate-missing-tests.ts

@@ -1,91 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import {
-  readOpenApiSpec,
-  extractEndpoints,
-  extractSecuritySchemes,
-  scanCoveredEndpoints,
-  filterUncoveredEndpoints,
-} from "../../core/generator/index.ts";
-import { compressEndpointsWithSchemas, buildGenerationGuide } from "./generate-tests-guide.ts";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-
-export function registerGenerateMissingTestsTool(server: McpServer) {
-  server.registerTool("generate_missing_tests", {
-    description: TOOL_DESCRIPTIONS.generate_missing_tests,
-    inputSchema: {
-      specPath: z.string().describe("Path or URL to OpenAPI spec file"),
-      testsDir: z.string().describe("Path to directory with existing test YAML files"),
-      outputDir: z.optional(z.string()).describe("Directory for saving new test files (default: same as testsDir)"),
-      methodFilter: z.optional(z.array(z.string())).describe("Only include endpoints with these HTTP methods (e.g. [\"GET\"] for smoke tests)"),
-      tag: z.optional(z.string()).describe("Filter endpoints by tag"),
-    },
-  }, async ({ specPath, testsDir, outputDir, methodFilter, tag }) => {
-    try {
-      const doc = await readOpenApiSpec(specPath);
-      let allEndpoints = 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;
-
-      // Apply method filter before coverage check
-      if (methodFilter && methodFilter.length > 0) {
-        const methods = methodFilter.map(m => m.toUpperCase());
-        allEndpoints = allEndpoints.filter(ep => methods.includes(ep.method.toUpperCase()));
-      }
-      if (tag) {
-        const lower = tag.toLowerCase();
-        allEndpoints = allEndpoints.filter(ep => ep.tags.some(t => t.toLowerCase() === lower));
-      }
-
-      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);
-
-      if (uncovered.length === 0) {
-        return {
-          content: [{
-            type: "text" as const,
-            text: JSON.stringify({
-              fullyCovered: true,
-              percentage: 100,
-              totalEndpoints: allEndpoints.length,
-              covered: coveredCount,
-            }, null, 2),
-          }],
-        };
-      }
-
-      // Build guide for uncovered endpoints only
-      const apiContext = compressEndpointsWithSchemas(uncovered, securitySchemes);
-      const coverageHeader = `## Coverage: ${coveredCount}/${allEndpoints.length} endpoints covered (${percentage}%). Generating tests for ${uncovered.length} uncovered endpoints:`;
-
-      const guide = buildGenerationGuide({
-        title: title ?? "API",
-        baseUrl,
-        apiContext,
-        outputDir: outputDir ?? testsDir,
-        securitySchemes,
-        endpointCount: uncovered.length,
-        coverageHeader,
-      });
-
-      return {
-        content: [{ type: "text" as const, text: guide }],
-      };
-    } catch (err) {
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({ error: (err as Error).message }, null, 2) }],
-        isError: true,
-      };
-    }
-  });
-}

package/src/mcp/tools/validate-tests.ts

@@ -1,43 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { parse } from "../../core/parser/yaml-parser.ts";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-
-export function registerValidateTestsTool(server: McpServer) {
-  server.registerTool("validate_tests", {
-    description: TOOL_DESCRIPTIONS.validate_tests,
-    inputSchema: {
-      testPath: z.string().describe("Path to test YAML file or directory"),
-    },
-  }, async ({ testPath }) => {
-    try {
-      const suites = await parse(testPath);
-      const totalSteps = suites.reduce((sum, s) => sum + s.tests.length, 0);
-
-      const result = {
-        valid: true,
-        suites: suites.length,
-        tests: totalSteps,
-        details: suites.map(s => ({
-          name: s.name,
-          tests: s.tests.length,
-          tags: s.tags,
-          description: s.description,
-          source: (s as any)._source,
-        })),
-      };
-
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
-      };
-    } catch (err) {
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({
-          valid: false,
-          error: (err as Error).message,
-        }, null, 2) }],
-        isError: true,
-      };
-    }
-  });
-}