@kirrosh/zond 0.13.0 → 0.16.0

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,
-      };
-    }
-  });
-}

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

@@ -1,218 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { validateSuite } from "../../core/parser/schema.ts";
-import { join, dirname } from "node:path";
-import { existsSync, mkdirSync } from "node:fs";
-import YAML from "yaml";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-
-export interface SaveResult {
-  saved: boolean;
-  filePath?: string;
-  suite?: { name: unknown; tests: number; base_url: unknown };
-  hint?: string;
-  coverage?: Record<string, unknown>;
-  error?: string;
-  detected?: string[];
-}
-
-export async function validateAndSave(
-  filePath: string,
-  content: string,
-  overwrite: boolean | undefined,
-  dbPath?: string,
-): Promise<{ result: SaveResult; isError: boolean }> {
-  // Parse YAML
-  let parsed: unknown;
-  try {
-    parsed = YAML.parse(content);
-  } catch (err) {
-    return {
-      result: {
-        saved: false,
-        error: `YAML parse error: ${(err as Error).message}`,
-        hint: "Check YAML syntax — indentation, colons, and quoting",
-      },
-      isError: true,
-    };
-  }
-
-  // Validate against test suite schema
-  try {
-    validateSuite(parsed);
-  } catch (err) {
-    const message = (err as Error).message;
-    let hint = "Check the test suite structure matches the expected format";
-    if (message.includes("status")) {
-      hint = "Status codes must be numbers, not strings (e.g. status: 200, not status: \"200\")";
-    } else if (message.includes("exists")) {
-      hint = "exists must be boolean true/false, not string \"true\"/\"false\"";
-    } else if (message.includes("tests")) {
-      hint = "Suite must have a 'tests' array with at least one test step";
-    }
-    return {
-      result: { saved: false, error: `Validation: ${message}`, hint },
-      isError: true,
-    };
-  }
-
-  // Detect hardcoded credentials — long opaque strings in auth headers
-  const credentialPattern = /Authorization\s*:\s*["']?(Basic|Bearer)\s+([A-Za-z0-9+/=_\-]{20,})["']?/g;
-  const credMatches = [...content.matchAll(credentialPattern)];
-  const suspiciousCredentials = credMatches.filter(m => {
-    const value = m[2]!;
-    return !value.startsWith("{{") && !value.endsWith("}}");
-  });
-  if (suspiciousCredentials.length > 0) {
-    return {
-      result: {
-        saved: false,
-        error: "Hardcoded credentials detected in Authorization header(s)",
-        hint: "Never put literal API keys or tokens in YAML files. Store them in the .env.yaml file in the API directory and reference as {{api_key}} in headers.",
-        detected: suspiciousCredentials.map(m => `${m[1]} <redacted>`),
-      },
-      isError: true,
-    };
-  }
-
-  // Resolve path
-  const resolvedPath = filePath.startsWith("/") || /^[a-zA-Z]:/.test(filePath)
-    ? filePath
-    : join(process.cwd(), filePath);
-
-  // Check existing file
-  if (!overwrite && existsSync(resolvedPath)) {
-    return {
-      result: {
-        saved: false,
-        error: `File already exists: ${resolvedPath}`,
-        hint: "Use overwrite: true to replace the existing file",
-      },
-      isError: true,
-    };
-  }
-
-  // Create directories
-  const dir = dirname(resolvedPath);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-
-  // Write original YAML content (preserve formatting/comments)
-  await Bun.write(resolvedPath, content);
-
-  // Extract summary info
-  const suite = parsed as Record<string, unknown>;
-  const tests = (suite.tests as unknown[]) ?? [];
-
-  const result: SaveResult = {
-    saved: true,
-    filePath: resolvedPath,
-    suite: {
-      name: suite.name,
-      tests: tests.length,
-      base_url: suite.base_url ?? null,
-    },
-    hint: "After tests are ready, ask the user if they want to set up CI/CD with ci_init to run tests automatically on push.",
-  };
-
-  // Attempt to compute coverage hint
-  try {
-    const testDir = dirname(resolvedPath);
-    const { findCollectionByTestPath } = await import("../../db/queries.ts");
-    const { getDb } = await import("../../db/schema.ts");
-    getDb(dbPath);
-    const collection = findCollectionByTestPath(testDir);
-    if (collection?.openapi_spec) {
-      const { readOpenApiSpec, extractEndpoints } = await import("../../core/generator/openapi-reader.ts");
-      const { scanCoveredEndpoints, filterUncoveredEndpoints } = await import("../../core/generator/coverage-scanner.ts");
-
-      const doc = await readOpenApiSpec(collection.openapi_spec);
-      const allEndpoints = extractEndpoints(doc);
-      const covered = await scanCoveredEndpoints(testDir);
-      const uncovered = filterUncoveredEndpoints(allEndpoints, covered);
-
-      const total = allEndpoints.length;
-      const coveredCount = total - uncovered.length;
-      const percentage = total > 0 ? Math.round((coveredCount / total) * 100) : 0;
-
-      const coverage: Record<string, unknown> = { percentage, covered: coveredCount, total, uncoveredCount: uncovered.length };
-      if (percentage < 80 && uncovered.length > 0) {
-        coverage.suggestion = `Use generate_and_save with testsDir to cover ${uncovered.length} remaining endpoint${uncovered.length > 1 ? "s" : ""}`;
-      }
-      result.coverage = coverage;
-    }
-  } catch { /* silently skip coverage if unavailable */ }
-
-  return { result, isError: false };
-}
-
-export function registerSaveTestSuiteTool(server: McpServer, dbPath?: string) {
-  server.registerTool("save_test_suite", {
-    description: TOOL_DESCRIPTIONS.save_test_suite,
-    inputSchema: {
-      filePath: z.string().describe("Path for saving the YAML test file (e.g. apis/petstore/tests/pets-crud.yaml)"),
-      content: z.string().describe("YAML content of the test suite"),
-      overwrite: z.optional(z.boolean()).describe("Overwrite existing file (default: false)"),
-    },
-  }, async ({ filePath, content, overwrite }) => {
-    try {
-      const { result, isError } = await validateAndSave(filePath, content, overwrite, dbPath);
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
-        ...(isError ? { isError: true } : {}),
-      };
-    } catch (err) {
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({
-          saved: false,
-          error: (err as Error).message,
-        }, null, 2) }],
-        isError: true,
-      };
-    }
-  });
-}
-
-export function registerSaveTestSuitesTool(server: McpServer, dbPath?: string) {
-  server.registerTool("save_test_suites", {
-    description: TOOL_DESCRIPTIONS.save_test_suites,
-    inputSchema: {
-      files: z.array(z.object({
-        filePath: z.string().describe("Path for saving the YAML test file"),
-        content: z.string().describe("YAML content of the test suite"),
-      })).describe("Array of files to save"),
-      overwrite: z.optional(z.boolean()).describe("Overwrite existing files (default: false)"),
-    },
-  }, async ({ files, overwrite }) => {
-    try {
-      const results: Array<SaveResult & { filePath: string; inputPath: string }> = [];
-      let hasErrors = false;
-
-      for (const file of files) {
-        const { result, isError } = await validateAndSave(file.filePath, file.content, overwrite, dbPath);
-        results.push({ ...result, inputPath: file.filePath, filePath: result.filePath ?? file.filePath });
-        if (isError) hasErrors = true;
-      }
-
-      const summary = {
-        total: files.length,
-        saved: results.filter(r => r.saved).length,
-        failed: results.filter(r => !r.saved).length,
-        files: results,
-      };
-
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify(summary, null, 2) }],
-        ...(hasErrors ? { 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/set-work-dir.ts

@@ -1,35 +0,0 @@
-import { z } from "zod";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { resolve, join } from "node:path";
-import { existsSync } from "node:fs";
-import { resetDb } from "../../db/schema.ts";
-import { TOOL_DESCRIPTIONS } from "../descriptions.js";
-
-export function registerSetWorkDirTool(server: McpServer) {
-  server.registerTool("set_work_dir", {
-    description: TOOL_DESCRIPTIONS.set_work_dir,
-    inputSchema: {
-      workDir: z.string().describe(
-        "Absolute path to project root (e.g. /home/user/myproject or C:/Users/user/myproject)"
-      ),
-    },
-  }, async ({ workDir }) => {
-    const resolved = resolve(workDir);
-    if (!existsSync(resolved)) {
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify({ error: `Directory not found: ${resolved}` }, null, 2) }],
-        isError: true,
-      };
-    }
-    process.chdir(resolved);
-    resetDb();
-    const dbPath = join(resolved, "zond.db");
-    return {
-      content: [{ type: "text" as const, text: JSON.stringify({
-        workDir: resolved,
-        zond_db: dbPath,
-        hint: "Working directory set. All relative paths and zond.db will now resolve from this directory.",
-      }, null, 2) }],
-    };
-  });
-}

package/src/tui/chat-ui.ts

@@ -1,150 +0,0 @@
-import { createInterface } from "readline";
-import { runAgentTurn } from "../core/agent/agent-loop.ts";
-import { trimContext } from "../core/agent/context-manager.ts";
-import type { AgentConfig, ToolEvent } from "../core/agent/types.ts";
-import type { ModelMessage } from "ai";
-
-// ── ANSI helpers ──
-const RESET = "\x1b[0m";
-const BOLD = "\x1b[1m";
-const DIM = "\x1b[2m";
-const CYAN = "\x1b[36m";
-const GREEN = "\x1b[32m";
-const YELLOW = "\x1b[33m";
-const MAGENTA = "\x1b[35m";
-
-// Mouse reporting escape sequences
-const DISABLE_MOUSE = "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l";
-// Regex to strip mouse escape sequences from input
-// Covers SGR extended, X10, urxvt mouse protocols
-const MOUSE_SEQ_RE = /\x1b\[\<[\d;]*[mM]|\x1b\[M[\s\S]{3}|\x1b\[\d+;\d+;\d+M/g;
-
-function printToolEvent(event: ToolEvent) {
-  const args = Object.entries(event.args)
-    .filter(([, v]) => v !== undefined)
-    .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
-    .slice(0, 3)
-    .join(", ");
-
-  const result = event.result as Record<string, unknown> | null;
-  let summary = "done";
-  if (result) {
-    if ("error" in result) summary = `error: ${result.error}`;
-    else if ("status" in result) summary = String(result.status);
-    else if ("valid" in result) summary = result.valid ? "valid" : "invalid";
-    else if ("runId" in result) summary = `run #${result.runId}`;
-  }
-
-  process.stdout.write(`  ${MAGENTA}↳ ${event.toolName}${RESET}${DIM}(${args})${RESET} → ${summary}\n`);
-}
-
-export async function startChatUI(config: AgentConfig): Promise<void> {
-  const { provider } = config.provider;
-  const model = config.provider.model;
-  const safeLabel = config.safeMode ? ` ${YELLOW}[SAFE]${RESET}` : "";
-
-  // Disable mouse reporting that may be left over from other TUI apps
-  process.stdout.write(DISABLE_MOUSE);
-
-  console.log(`\n${BOLD}${CYAN}zond chat${RESET} — ${provider}/${model}${safeLabel}`);
-  console.log(`${DIM}Commands: /clear, /tokens, /quit  |  Ctrl+C to exit${RESET}\n`);
-
-  const messages: ModelMessage[] = [];
-  let totalIn = 0;
-  let totalOut = 0;
-  let busy = false;
-
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: `${BOLD}${CYAN}> ${RESET}`,
-    terminal: true,
-  });
-
-  rl.prompt();
-
-  rl.on("line", async (raw: string) => {
-    // Strip mouse escape sequences that leak into input
-    const text = raw.replace(MOUSE_SEQ_RE, "").trim();
-
-    if (!text || busy) {
-      if (!busy) rl.prompt();
-      return;
-    }
-
-    if (text === "/quit" || text === "/exit") {
-      rl.close();
-      return;
-    }
-
-    if (text === "/clear") {
-      messages.length = 0;
-      totalIn = 0;
-      totalOut = 0;
-      console.log(`${DIM}Conversation cleared.${RESET}\n`);
-      rl.prompt();
-      return;
-    }
-
-    if (text === "/tokens") {
-      console.log(`${DIM}Tokens: ${totalIn} in / ${totalOut} out${RESET}\n`);
-      rl.prompt();
-      return;
-    }
-
-    busy = true;
-    messages.push({ role: "user", content: text });
-
-    // Trim context if conversation is long
-    const trimmed = trimContext(
-      messages.map((m) => ({
-        role: m.role as "user" | "assistant",
-        content: typeof m.content === "string" ? m.content : "",
-      })),
-    );
-
-    process.stdout.write(`\n${DIM}thinking...${RESET}`);
-
-    try {
-      const result = await runAgentTurn(
-        trimmed.map((m) => ({ role: m.role, content: m.content })),
-        config,
-        (event) => {
-          process.stdout.write(`\r\x1b[K`);
-          printToolEvent(event);
-          process.stdout.write(`${DIM}thinking...${RESET}`);
-        },
-      );
-
-      process.stdout.write(`\r\x1b[K`);
-
-      const responseText = result.text || "(no response)";
-      console.log(`\n${GREEN}${BOLD}AI${RESET} ${responseText}\n`);
-
-      totalIn += result.inputTokens;
-      totalOut += result.outputTokens;
-      messages.push({ role: "assistant", content: responseText });
-    } catch (err) {
-      process.stdout.write(`\r\x1b[K`);
-      console.log(`\n${YELLOW}Error: ${(err as Error).message}${RESET}\n`);
-    }
-
-    busy = false;
-    rl.prompt();
-  });
-
-  rl.on("close", () => {
-    // Disable mouse reporting on exit too
-    process.stdout.write(DISABLE_MOUSE);
-    console.log(`\n${DIM}Bye! (${totalIn} in / ${totalOut} out tokens)${RESET}`);
-    process.exit(0);
-  });
-
-  // Also disable mouse on SIGINT
-  process.on("SIGINT", () => {
-    process.stdout.write(DISABLE_MOUSE);
-    rl.close();
-  });
-
-  await new Promise<void>(() => {});
-}