@kirrosh/zond 0.14.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
@@ -286,6 +312,7 @@ export async function runSuite(suite: TestSuite, env: Environment = {}, dryRun =
     suite_name: suite.name,
     suite_tags: suite.tags,
     suite_description: suite.description,
+    suite_file: suite.filePath,
     started_at: startedAt,
     finished_at: finishedAt,
     total: steps.length,

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/send-request.ts

@@ -0,0 +1,94 @@
+import { executeRequest } from "./http-client.ts";
+import { loadEnvironment, substituteString, substituteDeep } from "../parser/variables.ts";
+import { getDb } from "../../db/schema.ts";
+import { findCollectionByNameOrId } from "../../db/queries.ts";
+
+function extractByPath(obj: unknown, path: string): unknown {
+  const segments = path.replace(/\[(\d+)\]/g, '.$1').split('.').filter(Boolean);
+  let current: unknown = obj;
+  for (const seg of segments) {
+    if (current === null || current === undefined) return undefined;
+    if (Array.isArray(current)) {
+      const idx = parseInt(seg, 10);
+      if (isNaN(idx)) return undefined;
+      current = current[idx];
+    } else if (typeof current === 'object') {
+      current = (current as Record<string, unknown>)[seg];
+    } else {
+      return undefined;
+    }
+  }
+  return current;
+}
+
+export interface SendAdHocRequestOptions {
+  method: string;
+  url: string;
+  headers?: Record<string, string>;
+  body?: string;
+  timeout?: number;
+  envName?: string;
+  collectionName?: string;
+  jsonPath?: string;
+  maxResponseChars?: number;
+  dbPath?: string;
+  searchDir?: string;
+}
+
+export interface SendAdHocRequestResult {
+  status: number;
+  headers: Record<string, string>;
+  body: unknown;
+  duration_ms: number;
+}
+
+export async function sendAdHocRequest(options: SendAdHocRequestOptions): Promise<SendAdHocRequestResult> {
+  let searchDir = options.searchDir ?? process.cwd();
+  if (options.collectionName) {
+    getDb(options.dbPath);
+    const col = findCollectionByNameOrId(options.collectionName);
+    if (col?.base_dir) searchDir = col.base_dir;
+  }
+  const vars = await loadEnvironment(options.envName, searchDir);
+
+  const resolvedUrl = substituteString(options.url, vars) as string;
+  const parsedHeaders = options.headers ?? {};
+  const resolvedHeaders = Object.keys(parsedHeaders).length > 0 ? substituteDeep(parsedHeaders, vars) : {};
+  const resolvedBody = options.body ? substituteString(options.body, vars) as string : undefined;
+
+  // Auto-detect Content-Type for body if not explicitly set
+  const finalHeaders: Record<string, string> = { ...resolvedHeaders };
+  if (resolvedBody && !finalHeaders["Content-Type"] && !finalHeaders["content-type"]) {
+    try {
+      JSON.parse(resolvedBody);
+      finalHeaders["Content-Type"] = "application/json";
+    } catch {
+      // Not JSON — don't set content-type, let server decide
+    }
+  }
+
+  const response = await executeRequest(
+    {
+      method: options.method,
+      url: resolvedUrl,
+      headers: finalHeaders,
+      body: resolvedBody,
+    },
+    options.timeout ? { timeout: options.timeout } : undefined,
+  );
+
+  let responseBody: unknown = response.body_parsed ?? response.body;
+
+  if (options.jsonPath && responseBody !== undefined) {
+    responseBody = extractByPath(responseBody, options.jsonPath);
+  }
+
+  const result: SendAdHocRequestResult = {
+    status: response.status,
+    headers: response.headers,
+    body: responseBody,
+    duration_ms: response.duration_ms,
+  };
+
+  return result;
+}

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 {
@@ -38,6 +39,7 @@ export interface TestRunResult {
   suite_name: string;
   suite_tags?: string[];
   suite_description?: string;
+  suite_file?: string;
   started_at: string;
   finished_at: string;
   total: number;

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/db/queries.ts

@@ -103,6 +103,7 @@ export interface StoredStepResult {
   error_message: string | null;
   assertions: import("../core/runner/types.ts").AssertionResult[];
   captures: Record<string, unknown>;
+  suite_file: string | null;
 }
 
 // ──────────────────────────────────────────────
@@ -244,11 +245,11 @@ export function saveResults(runId: number, suiteResults: TestRunResult[]): void
     INSERT INTO results
       (run_id, suite_name, test_name, status, duration_ms,
        request_method, request_url, request_body,
-       response_status, response_body, response_headers, error_message, assertions, captures)
+       response_status, response_body, response_headers, error_message, assertions, captures, suite_file)
     VALUES
       ($run_id, $suite_name, $test_name, $status, $duration_ms,
        $request_method, $request_url, $request_body,
-       $response_status, $response_body, $response_headers, $error_message, $assertions, $captures)
+       $response_status, $response_body, $response_headers, $error_message, $assertions, $captures, $suite_file)
   `);
 
   db.transaction(() => {
@@ -272,6 +273,7 @@ export function saveResults(runId: number, suiteResults: TestRunResult[]): void
           $error_message: step.error ?? null,
           $assertions: step.assertions.length > 0 ? JSON.stringify(step.assertions) : null,
           $captures: Object.keys(step.captures).length > 0 ? JSON.stringify(step.captures) : null,
+          $suite_file: suite.suite_file ?? null,
         });
       }
     }

package/src/db/schema.ts

@@ -48,7 +48,7 @@ export function resetDb(): void {
 // Schema
 // ──────────────────────────────────────────────
 
-const SCHEMA_VERSION = 1;
+const SCHEMA_VERSION = 2;
 
 const SCHEMA = `
   CREATE TABLE IF NOT EXISTS runs (
@@ -82,7 +82,8 @@ const SCHEMA = `
     error_message    TEXT,
     assertions       TEXT,
     captures         TEXT,
-    response_headers TEXT
+    response_headers TEXT,
+    suite_file       TEXT
   );
 
   CREATE TABLE IF NOT EXISTS collections (
@@ -153,7 +154,14 @@ function runMigrations(db: Database): void {
   if (ver >= SCHEMA_VERSION) return;
 
   db.transaction(() => {
-    db.exec(SCHEMA);
+    if (ver === 0) {
+      // Fresh database — create all tables
+      db.exec(SCHEMA);
+    }
+    if (ver >= 1 && ver < 2) {
+      // Migration v1→v2: add suite_file column to results
+      db.exec("ALTER TABLE results ADD COLUMN suite_file TEXT");
+    }
     db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
   })();
 }

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_and_save</code>.</div>`;
+    return `<div class="tab-empty">No test suites found on disk. Generate tests with <code>zond guide</code> or use the test-generation skill.</div>`;
   }
 
   const rows = state.suites.map((s, i) => renderSuiteRow(s, i)).join("");

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,71 +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 = {
-  set_work_dir:
-    "Set the working directory for this MCP session. " +
-    "Call this FIRST before any other tool when using a shared MCP server (npx). " +
-    "Determines where zond.db and relative test paths resolve to. " +
-    "Pass the absolute path to your project root (same as workspace root in your editor).",
-
-  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.",
-
-  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_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.",
-
-  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.",
-
-  generate_and_save:
-    "Read an OpenAPI spec, auto-chunk by tags if large (>30 endpoints), " +
-    "and return a focused test generation guide. For large APIs returns a chunking plan — " +
-    "call again with tag parameter for each chunk. Use testsDir param to only generate for uncovered endpoints. " +
-    "After generating YAML, use save_test_suites to save files, then run_tests to verify. " +
-    "Includes YAML format cheatsheet by default; pass includeFormat: false for subsequent tag chunks to save tokens. " +
-    "Use mode: 'generate' to auto-generate and save deterministic YAML test files (smoke + CRUD) without LLM. " +
-    "Default mode is 'generate'; use mode: 'guide' for the text-based generation guide.",
-
-  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,45 +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 { registerSaveTestSuiteTool, registerSaveTestSuitesTool } from "./tools/save-test-suite.ts";
-import { registerSetupApiTool } from "./tools/setup-api.ts";
-import { registerManageServerTool } from "./tools/manage-server.ts";
-import { registerCiInitTool } from "./tools/ci-init.ts";
-import { registerSetWorkDirTool } from "./tools/set-work-dir.ts";
-import { registerDescribeEndpointTool } from "./tools/describe-endpoint.ts";
-import { registerGenerateAndSaveTool } from "./tools/generate-and-save.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 all tools
-  registerRunTestsTool(server, dbPath);
-  registerQueryDbTool(server, dbPath);
-  registerSendRequestTool(server, dbPath);
-  registerCoverageAnalysisTool(server, dbPath);
-  registerSaveTestSuiteTool(server, dbPath);
-  registerSaveTestSuitesTool(server, dbPath);
-  registerSetupApiTool(server, dbPath);
-  registerManageServerTool(server, dbPath);
-  registerCiInitTool(server);
-  registerSetWorkDirTool(server);
-  registerDescribeEndpointTool(server);
-  registerGenerateAndSaveTool(server);
-
-  // Connect via stdio transport
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}