@kirrosh/zond 0.13.0 → 0.16.0

package/src/mcp/tools/query-db.ts

@@ -1,63 +1,7 @@
 import { z } from "zod";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { getDb } from "../../db/schema.ts";
-import { listCollections, listRuns, getRunById, getResultsByRunId, getCollectionById } from "../../db/queries.ts";
-import { join } from "node:path";
 import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-import { statusHint, classifyFailure, envHint, envCategory, schemaHint } from "../../core/diagnostics/failure-hints.ts";
-
-function truncateErrorMessage(raw: string | null | undefined, verbose?: boolean): string | undefined {
-  if (!raw) return undefined;
-  if (verbose || raw.length < 500) return raw;
-  const lines = raw.split(/\r?\n/);
-  // First line is the error message itself
-  const msgLines = [lines[0]!];
-  // Grab up to 3 stack-trace lines (indented or starting with "at ")
-  let traceCount = 0;
-  for (let i = 1; i < lines.length && traceCount < 3; i++) {
-    const line = lines[i]!;
-    if (/^\s+/.test(line) || /^\s*at\s/.test(line)) {
-      msgLines.push(line);
-      traceCount++;
-    }
-  }
-  const remaining = lines.length - msgLines.length;
-  if (remaining > 0) {
-    msgLines.push(`...[truncated ${remaining} lines]`);
-  }
-  return msgLines.join("\n");
-}
-
-function parseBodySafe(raw: string | null | undefined): unknown {
-  if (!raw) return undefined;
-  const truncated = raw.length > 2000 ? raw.slice(0, 2000) + "…[truncated]" : raw;
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return truncated;
-  }
-}
-
-const USEFUL_HEADERS = new Set([
-  "content-type", "content-length", "location", "retry-after",
-  "www-authenticate", "allow",
-]);
-const USEFUL_PREFIXES = ["x-", "ratelimit"];
-
-function filterHeaders(raw: string | null | undefined): Record<string, string> | undefined {
-  if (!raw) return undefined;
-  try {
-    const h = JSON.parse(raw) as Record<string, string>;
-    const out: Record<string, string> = {};
-    for (const [k, v] of Object.entries(h)) {
-      const l = k.toLowerCase();
-      if (USEFUL_HEADERS.has(l) || USEFUL_PREFIXES.some(p => l.startsWith(p))) {
-        out[k] = v;
-      }
-    }
-    return Object.keys(out).length > 0 ? out : undefined;
-  } catch { return undefined; }
-}
+import { getCollections, getRuns, getRunDetail, diagnoseRun, compareRuns } from "../../core/diagnostics/db-analysis.ts";
 
 export function registerQueryDbTool(server: McpServer, dbPath?: string) {
   server.registerTool("query_db", {
@@ -76,18 +20,16 @@ export function registerQueryDbTool(server: McpServer, dbPath?: string) {
     },
   }, async ({ action, runId, runIdB, limit, verbose }) => {
     try {
-      getDb(dbPath);
-
       switch (action) {
         case "list_collections": {
-          const collections = listCollections();
+          const collections = getCollections(dbPath);
           return {
             content: [{ type: "text" as const, text: JSON.stringify(collections, null, 2) }],
           };
         }
 
         case "list_runs": {
-          const runs = listRuns(limit ?? 20);
+          const runs = getRuns(limit ?? 20, dbPath);
           return {
             content: [{ type: "text" as const, text: JSON.stringify(runs, null, 2) }],
           };
@@ -100,39 +42,7 @@ export function registerQueryDbTool(server: McpServer, dbPath?: string) {
               isError: true,
             };
           }
-          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);
-          const detail = {
-            run: {
-              id: run.id,
-              started_at: run.started_at,
-              finished_at: run.finished_at,
-              total: run.total,
-              passed: run.passed,
-              failed: run.failed,
-              skipped: run.skipped,
-              trigger: run.trigger,
-              environment: run.environment,
-              duration_ms: run.duration_ms,
-            },
-            results: results.map(r => ({
-              suite_name: r.suite_name,
-              test_name: r.test_name,
-              status: r.status,
-              duration_ms: r.duration_ms,
-              request_method: r.request_method,
-              request_url: r.request_url,
-              response_status: r.response_status,
-              error_message: truncateErrorMessage(r.error_message, verbose),
-              assertions: r.assertions,
-            })),
-          };
+          const detail = getRunDetail(runId, verbose, dbPath);
           return {
             content: [{ type: "text" as const, text: JSON.stringify(detail, null, 2) }],
           };
@@ -145,81 +55,7 @@ export function registerQueryDbTool(server: McpServer, dbPath?: string) {
               isError: true,
             };
           }
-          const diagRun = getRunById(runId);
-          if (!diagRun) {
-            return {
-              content: [{ type: "text" as const, text: JSON.stringify({ error: `Run ${runId} not found` }, null, 2) }],
-              isError: true,
-            };
-          }
-
-          // Resolve env file path from collection for actionable hints
-          let envFilePath: string | undefined;
-          if (diagRun.collection_id) {
-            const collection = getCollectionById(diagRun.collection_id);
-            if (collection?.base_dir) {
-              envFilePath = join(collection.base_dir, ".env.yaml").replace(/\\/g, "/");
-            }
-          }
-
-          const allResults = getResultsByRunId(runId);
-          const failures = allResults
-            .filter(r => r.status === "fail" || r.status === "error")
-            .map(r => {
-              // env issues take priority over generic status hints
-              const hint = envHint(r.request_url, r.error_message, envFilePath) ?? statusHint(r.response_status);
-              const failure_type = classifyFailure(r.status, r.response_status);
-              const sHint = schemaHint(failure_type, r.response_status);
-              return {
-                suite_name: r.suite_name,
-                test_name: r.test_name,
-                status: r.status,
-                failure_type,
-                error_message: truncateErrorMessage(r.error_message, verbose),
-                request_method: r.request_method,
-                request_url: r.request_url,
-                response_status: r.response_status,
-                ...(hint ? { hint } : {}),
-                ...(sHint ? { schema_hint: sHint } : {}),
-                response_body: parseBodySafe(r.response_body),
-                response_headers: filterHeaders(r.response_headers),
-                assertions: r.assertions,
-                duration_ms: r.duration_ms,
-              };
-            });
-
-          // Top-level env_issue when all failures have the same env problem category
-          const categories = new Set(failures.map(f => envCategory(f.hint)).filter(Boolean));
-          const sharedEnvHint = categories.size === 1
-            ? categories.has("base_url_missing")
-              ? `All failures: base_url is not set — add base_url to ${envFilePath ?? ".env.yaml"}`
-              : categories.has("unresolved_variable")
-              ? `All failures: some variables are not substituted — check variable names in ${envFilePath ?? ".env.yaml"}`
-              : [...failures.map(f => f.hint).filter(Boolean)][0]
-            : undefined;
-
-          const apiErrors = failures.filter(f => f.failure_type === "api_error").length;
-          const assertionFailures = failures.filter(f => f.failure_type === "assertion_failed").length;
-          const networkErrors = failures.filter(f => f.failure_type === "network_error").length;
-
-          const result = {
-            run: {
-              id: diagRun.id,
-              started_at: diagRun.started_at,
-              environment: diagRun.environment,
-              duration_ms: diagRun.duration_ms,
-            },
-            summary: {
-              total: diagRun.total,
-              passed: diagRun.passed,
-              failed: diagRun.failed,
-              api_errors: apiErrors,
-              assertion_failures: assertionFailures,
-              network_errors: networkErrors,
-            },
-            ...(sharedEnvHint ? { env_issue: sharedEnvHint } : {}),
-            failures,
-          };
+          const result = diagnoseRun(runId, verbose, dbPath);
           return {
             content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
           };
@@ -232,59 +68,7 @@ export function registerQueryDbTool(server: McpServer, dbPath?: string) {
               isError: true,
             };
           }
-          const runARecord = getRunById(runId);
-          const runBRecord = getRunById(runIdB);
-          if (!runARecord) {
-            return {
-              content: [{ type: "text" as const, text: JSON.stringify({ error: `Run #${runId} not found` }, null, 2) }],
-              isError: true,
-            };
-          }
-          if (!runBRecord) {
-            return {
-              content: [{ type: "text" as const, text: JSON.stringify({ error: `Run #${runIdB} not found` }, null, 2) }],
-              isError: true,
-            };
-          }
-
-          const resultsA = getResultsByRunId(runId);
-          const resultsB = getResultsByRunId(runIdB);
-
-          const mapA = new Map<string, string>();
-          const mapB = new Map<string, string>();
-          for (const r of resultsA) mapA.set(`${r.suite_name}::${r.test_name}`, r.status);
-          for (const r of resultsB) mapB.set(`${r.suite_name}::${r.test_name}`, r.status);
-
-          const regressions: Array<{ suite: string; test: string; before: string; after: string }> = [];
-          const fixes: Array<{ suite: string; test: string; before: string; after: string }> = [];
-          let unchanged = 0;
-          let newTests = 0;
-          let removedTests = 0;
-
-          for (const [key, statusB] of mapB) {
-            const statusA = mapA.get(key);
-            if (statusA === undefined) { newTests++; continue; }
-            const [suite, test] = key.split("::") as [string, string];
-            const wasPass = statusA === "pass";
-            const isPass = statusB === "pass";
-            const wasFail = statusA === "fail" || statusA === "error";
-            const isFail = statusB === "fail" || statusB === "error";
-            if (wasPass && isFail) regressions.push({ suite, test, before: statusA, after: statusB });
-            else if (wasFail && isPass) fixes.push({ suite, test, before: statusA, after: statusB });
-            else unchanged++;
-          }
-          for (const key of mapA.keys()) {
-            if (!mapB.has(key)) removedTests++;
-          }
-
-          const compareResult = {
-            runA: { id: runId, started_at: runARecord.started_at },
-            runB: { id: runIdB, started_at: runBRecord.started_at },
-            summary: { regressions: regressions.length, fixes: fixes.length, unchanged, newTests, removedTests },
-            regressions,
-            fixes,
-            hasRegressions: regressions.length > 0,
-          };
+          const compareResult = compareRuns(runId, runIdB, dbPath);
           return {
             content: [{ type: "text" as const, text: JSON.stringify(compareResult, null, 2) }],
           };

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

@@ -56,6 +56,7 @@ export function registerRunTestsTool(server: McpServer, dbPath?: string) {
       r.steps.filter(s => s.status === "fail" || s.status === "error").map(s => ({
         suite: r.suite_name,
         test: s.name,
+        ...(r.suite_file ? { file: r.suite_file } : {}),
         status: s.status,
         error: s.error,
         assertions: s.assertions.filter(a => !a.passed).map(a => ({

package/src/mcp/tools/send-request.ts

@@ -1,29 +1,8 @@
 import { z } from "zod";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { executeRequest } from "../../core/runner/http-client.ts";
-import { loadEnvironment, substituteString, substituteDeep } from "../../core/parser/variables.ts";
-import { getDb } from "../../db/schema.ts";
-import { findCollectionByNameOrId } from "../../db/queries.ts";
+import { sendAdHocRequest } from "../../core/runner/send-request.ts";
 import { TOOL_DESCRIPTIONS } from "../descriptions.js";
 
-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 function registerSendRequestTool(server: McpServer, dbPath?: string) {
   server.registerTool("send_request", {
     description: TOOL_DESCRIPTIONS.send_request,
@@ -40,48 +19,23 @@ export function registerSendRequestTool(server: McpServer, dbPath?: string) {
     },
   }, async ({ method, url, headers, body, timeout, envName, collectionName, jsonPath, maxResponseChars }) => {
     try {
-      let searchDir = process.cwd();
-      if (collectionName) {
-        getDb(dbPath);
-        const col = findCollectionByNameOrId(collectionName);
-        if (col?.base_dir) searchDir = col.base_dir;
-      }
-      const vars = await loadEnvironment(envName, searchDir);
-
-      const resolvedUrl = substituteString(url, vars) as string;
-      const parsedHeaders = headers ? JSON.parse(headers) as Record<string, string> : {};
-      const resolvedHeaders = Object.keys(parsedHeaders).length > 0 ? substituteDeep(parsedHeaders, vars) : {};
-      const resolvedBody = body ? substituteString(body, vars) as string : undefined;
-
-      const response = await executeRequest(
-        {
-          method,
-          url: resolvedUrl,
-          headers: resolvedHeaders,
-          body: resolvedBody,
-        },
-        timeout ? { timeout } : undefined,
-      );
-
-      let responseBody: unknown = response.body_parsed ?? response.body;
-
-      // Apply jsonPath filter
-      if (jsonPath && responseBody !== undefined) {
-        responseBody = extractByPath(responseBody, jsonPath);
-      }
-
-      const result = {
-        status: response.status,
-        headers: response.headers,
-        body: responseBody,
-        duration_ms: response.duration_ms,
-      };
+      const parsedHeaders = headers ? JSON.parse(headers) as Record<string, string> : undefined;
+
+      const result = await sendAdHocRequest({
+        method,
+        url,
+        headers: parsedHeaders,
+        body: body ?? undefined,
+        timeout,
+        envName,
+        collectionName,
+        jsonPath,
+        dbPath,
+      });
 
       let text = JSON.stringify(result, null, 2);
-
-      // Apply maxResponseChars truncation
       if (maxResponseChars && text.length > maxResponseChars) {
-        text = text.slice(0, maxResponseChars) + '\n…[truncated]';
+        text = text.slice(0, maxResponseChars) + '\n\u2026[truncated]';
       }
 
       return {

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/add-api.ts

@@ -1,53 +0,0 @@
-import { setupApi } from "../../core/setup-api.ts";
-import { printError, printSuccess } from "../output.ts";
-
-export interface AddApiOptions {
-  name: string;
-  spec?: string;
-  dir?: string;
-  envPairs?: string[];
-  dbPath?: string;
-  insecure?: boolean;
-}
-
-export async function addApiCommand(options: AddApiOptions): Promise<number> {
-  const { name, spec, envPairs, dbPath, dir, insecure } = options;
-
-  // Parse --env key=value pairs into a record
-  const envVars: Record<string, string> = {};
-  if (envPairs) {
-    for (const pair of envPairs) {
-      const idx = pair.indexOf("=");
-      if (idx === -1) continue;
-      const key = pair.slice(0, idx).trim();
-      const value = pair.slice(idx + 1).trim();
-      if (key) envVars[key] = value;
-    }
-  }
-
-  try {
-    const result = await setupApi({
-      name,
-      spec,
-      dir,
-      envVars: Object.keys(envVars).length > 0 ? envVars : undefined,
-      dbPath,
-      insecure,
-    });
-
-    printSuccess(`API '${name}' created (id=${result.collectionId})`);
-    console.log(`  Directory: ${result.testPath.replace(/\/tests$/, "")}`);
-    console.log(`  Tests:     ${result.testPath}/`);
-    if (spec) console.log(`  Spec:      ${spec}`);
-    if (result.baseUrl) console.log(`  Base URL:  ${result.baseUrl}`);
-    console.log();
-    console.log("Next steps:");
-    console.log(`  zond ai-generate --api ${name} --prompt "test the user endpoints"`);
-    console.log(`  zond run --api ${name}`);
-
-    return 0;
-  } catch (err) {
-    printError((err as Error).message);
-    return 1;
-  }
-}

package/src/cli/commands/ai-generate.ts

@@ -1,106 +0,0 @@
-import { resolve, dirname } from "path";
-import { generateWithAI } from "../../core/generator/ai/ai-generator.ts";
-import { resolveProviderConfig } from "../../core/generator/ai/types.ts";
-import type { AIProviderConfig } from "../../core/generator/ai/types.ts";
-import { printError, printSuccess } from "../output.ts";
-
-export interface AIGenerateCommandOptions {
-  from: string;
-  prompt: string;
-  provider: string;
-  model?: string;
-  apiKey?: string;
-  baseUrl?: string;
-  output?: string;
-}
-
-export async function aiGenerateCommand(options: AIGenerateCommandOptions): Promise<number> {
-  try {
-    const providerName = options.provider as AIProviderConfig["provider"];
-    if (!["ollama", "openai", "anthropic", "custom"].includes(providerName)) {
-      printError(`Unknown provider: ${options.provider}. Use: ollama, openai, anthropic, custom`);
-      return 2;
-    }
-
-    const provider = resolveProviderConfig({
-      provider: providerName,
-      model: options.model,
-      baseUrl: options.baseUrl,
-      apiKey: options.apiKey ?? process.env.ZOND_AI_KEY,
-    });
-
-    console.log(`Provider: ${provider.provider} (${provider.model})`);
-    console.log(`Spec: ${options.from}`);
-    console.log(`Prompt: ${options.prompt}`);
-    console.log(`Generating...`);
-
-    const startTime = Date.now();
-    const result = await generateWithAI({
-      specPath: options.from,
-      prompt: options.prompt,
-      provider,
-    });
-    const durationMs = Date.now() - startTime;
-
-    console.log(`Done in ${(durationMs / 1000).toFixed(1)}s (model: ${result.model})`);
-    if (result.promptTokens) {
-      console.log(`Tokens: ${result.promptTokens} prompt + ${result.completionTokens} completion`);
-    }
-
-    // Write output
-    const outputDir = options.output ?? "./generated/ai/";
-    const { mkdir } = await import("node:fs/promises");
-    await mkdir(outputDir, { recursive: true });
-
-    const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-    const fileName = `ai-generated-${timestamp}.yaml`;
-    const filePath = resolve(outputDir, fileName);
-
-    await Bun.write(filePath, result.yaml);
-    printSuccess(`Written: ${filePath}`);
-
-    // Auto-create collection if DB is available
-    try {
-      const { getDb } = await import("../../db/schema.ts");
-      getDb();
-      const { findCollectionByTestPath, findCollectionBySpec, createCollection, normalizePath, saveAIGeneration } = await import("../../db/queries.ts");
-      const { resolveSpecPath } = await import("../../core/generator/serializer.ts");
-      const normalizedOutput = normalizePath(outputDir);
-      const resolvedSpec = resolveSpecPath(options.from);
-
-      let collectionId: number | undefined;
-      const existing = findCollectionByTestPath(normalizedOutput) ?? findCollectionBySpec(resolvedSpec);
-      if (existing) {
-        collectionId = existing.id;
-      } else {
-        const specName = `AI Tests (${new Date().toLocaleDateString()})`;
-        collectionId = createCollection({
-          name: specName,
-          test_path: normalizedOutput,
-          openapi_spec: resolvedSpec,
-        });
-        printSuccess(`Created collection "${specName}" (id: ${collectionId})`);
-      }
-
-      saveAIGeneration({
-        collection_id: collectionId,
-        prompt: options.prompt,
-        model: result.model,
-        provider: providerName,
-        generated_yaml: result.yaml,
-        output_path: filePath,
-        status: "success",
-        prompt_tokens: result.promptTokens,
-        completion_tokens: result.completionTokens,
-        duration_ms: durationMs,
-      });
-    } catch {
-      // DB not critical
-    }
-
-    return 0;
-  } catch (err) {
-    printError(err instanceof Error ? err.message : String(err));
-    return 2;
-  }
-}

package/src/cli/commands/chat.ts

@@ -1,43 +0,0 @@
-import { resolveProviderConfig, PROVIDER_DEFAULTS } from "../../core/generator/ai/types.ts";
-import type { AIProviderConfig } from "../../core/generator/ai/types.ts";
-import { printError } from "../output.ts";
-
-export interface ChatCommandOptions {
-  provider?: string;
-  model?: string;
-  apiKey?: string;
-  baseUrl?: string;
-  safe?: boolean;
-  dbPath?: string;
-}
-
-const VALID_PROVIDERS = new Set(["ollama", "openai", "anthropic", "custom"]);
-
-export async function chatCommand(options: ChatCommandOptions): Promise<number> {
-  const providerName = options.provider ?? "ollama";
-
-  if (!VALID_PROVIDERS.has(providerName)) {
-    printError(`Unknown provider: ${providerName}. Available: ollama, openai, anthropic, custom`);
-    return 2;
-  }
-
-  const providerConfig = resolveProviderConfig({
-    provider: providerName as AIProviderConfig["provider"],
-    model: options.model,
-    apiKey: options.apiKey ?? process.env["ZOND_AI_KEY"],
-    baseUrl: options.baseUrl,
-  });
-
-  try {
-    const { startChatUI } = await import("../../tui/chat-ui.ts");
-    await startChatUI({
-      provider: providerConfig,
-      safeMode: options.safe,
-      dbPath: options.dbPath,
-    });
-    return 0;
-  } catch (err) {
-    printError(`Chat error: ${(err as Error).message}`);
-    return 2;
-  }
-}

package/src/cli/commands/collections.ts

@@ -1,41 +0,0 @@
-import { getDb } from "../../db/schema.ts";
-import { listCollections } from "../../db/queries.ts";
-import { formatDuration } from "../../core/reporter/console.ts";
-
-export function collectionsCommand(dbPath?: string): number {
-  getDb(dbPath);
-  const collections = listCollections();
-
-  if (collections.length === 0) {
-    console.log("No collections found.");
-    console.log("Hint: use `zond generate --from <spec>` to create a collection automatically.");
-    return 0;
-  }
-
-  // Print table header
-  const header = [
-    "ID".padEnd(5),
-    "Name".padEnd(30),
-    "Runs".padEnd(6),
-    "Pass Rate".padEnd(11),
-    "Last Run".padEnd(20),
-  ].join(" ");
-
-  console.log(header);
-  console.log("-".repeat(header.length));
-
-  for (const c of collections) {
-    const passRate = c.total_runs > 0 ? `${c.pass_rate}%` : "-";
-    const lastRun = c.last_run_at ?? "-";
-    const row = [
-      String(c.id).padEnd(5),
-      c.name.slice(0, 30).padEnd(30),
-      String(c.total_runs).padEnd(6),
-      passRate.padEnd(11),
-      lastRun.slice(0, 20).padEnd(20),
-    ].join(" ");
-    console.log(row);
-  }
-
-  return 0;
-}