@kirrosh/zond 0.12.7 → 0.14.0

package/src/core/runner/assertions.ts

@@ -90,6 +90,132 @@ function checkRule(path: string, rule: AssertionRule, actual: unknown): Assertio
     });
   }
 
+  if (rule.not_equals !== undefined) {
+    results.push({
+      field, rule: `not_equals ${JSON.stringify(rule.not_equals)}`,
+      passed: !deepEquals(actual, rule.not_equals), actual, expected: rule.not_equals,
+    });
+  }
+
+  if (rule.not_contains !== undefined) {
+    const passed = typeof actual === "string" && !actual.includes(rule.not_contains);
+    results.push({
+      field, rule: `not_contains "${rule.not_contains}"`,
+      passed, actual, expected: rule.not_contains,
+    });
+  }
+
+  if (rule.gte !== undefined) {
+    const passed = typeof actual === "number" && actual >= rule.gte;
+    results.push({
+      field, rule: `gte ${rule.gte}`,
+      passed, actual, expected: rule.gte,
+    });
+  }
+
+  if (rule.lte !== undefined) {
+    const passed = typeof actual === "number" && actual <= rule.lte;
+    results.push({
+      field, rule: `lte ${rule.lte}`,
+      passed, actual, expected: rule.lte,
+    });
+  }
+
+  if (rule.length !== undefined) {
+    const hasLength = (Array.isArray(actual) || typeof actual === "string");
+    const passed = hasLength && (actual as string | unknown[]).length === rule.length;
+    results.push({
+      field, rule: `length ${rule.length}`,
+      passed, actual: hasLength ? (actual as string | unknown[]).length : describeType(actual), expected: rule.length,
+    });
+  }
+
+  if (rule.length_gt !== undefined) {
+    const hasLength = (Array.isArray(actual) || typeof actual === "string");
+    const passed = hasLength && (actual as string | unknown[]).length > rule.length_gt;
+    results.push({
+      field, rule: `length_gt ${rule.length_gt}`,
+      passed, actual: hasLength ? (actual as string | unknown[]).length : describeType(actual), expected: rule.length_gt,
+    });
+  }
+
+  if (rule.length_gte !== undefined) {
+    const hasLength = (Array.isArray(actual) || typeof actual === "string");
+    const passed = hasLength && (actual as string | unknown[]).length >= rule.length_gte;
+    results.push({
+      field, rule: `length_gte ${rule.length_gte}`,
+      passed, actual: hasLength ? (actual as string | unknown[]).length : describeType(actual), expected: rule.length_gte,
+    });
+  }
+
+  if (rule.length_lt !== undefined) {
+    const hasLength = (Array.isArray(actual) || typeof actual === "string");
+    const passed = hasLength && (actual as string | unknown[]).length < rule.length_lt;
+    results.push({
+      field, rule: `length_lt ${rule.length_lt}`,
+      passed, actual: hasLength ? (actual as string | unknown[]).length : describeType(actual), expected: rule.length_lt,
+    });
+  }
+
+  if (rule.length_lte !== undefined) {
+    const hasLength = (Array.isArray(actual) || typeof actual === "string");
+    const passed = hasLength && (actual as string | unknown[]).length <= rule.length_lte;
+    results.push({
+      field, rule: `length_lte ${rule.length_lte}`,
+      passed, actual: hasLength ? (actual as string | unknown[]).length : describeType(actual), expected: rule.length_lte,
+    });
+  }
+
+  if (rule.each !== undefined) {
+    if (!Array.isArray(actual)) {
+      results.push({ field, rule: "each", passed: false, actual: describeType(actual), expected: "array" });
+    } else {
+      for (let i = 0; i < actual.length; i++) {
+        for (const [subPath, subRule] of Object.entries(rule.each)) {
+          const subActual = getByPath(actual[i], subPath);
+          const subResults = checkRule(`${path}[${i}].${subPath}`, subRule, subActual);
+          results.push(...subResults);
+        }
+      }
+    }
+  }
+
+  if (rule.contains_item !== undefined) {
+    if (!Array.isArray(actual)) {
+      results.push({ field, rule: "contains_item", passed: false, actual: describeType(actual), expected: "array" });
+    } else {
+      const found = actual.some((item) => {
+        for (const [subPath, subRule] of Object.entries(rule.contains_item!)) {
+          const subActual = getByPath(item, subPath);
+          const subResults = checkRule("", subRule, subActual);
+          if (subResults.some(r => !r.passed)) return false;
+        }
+        return true;
+      });
+      results.push({
+        field, rule: "contains_item",
+        passed: found, actual: `array(${actual.length})`, expected: "at least one matching item",
+      });
+    }
+  }
+
+  if (rule.set_equals !== undefined) {
+    if (!Array.isArray(actual) || !Array.isArray(rule.set_equals)) {
+      results.push({
+        field, rule: "set_equals",
+        passed: false, actual: describeType(actual), expected: "both must be arrays",
+      });
+    } else {
+      const actualSet = new Set(actual.map(v => JSON.stringify(v)));
+      const expectedSet = new Set((rule.set_equals as unknown[]).map(v => JSON.stringify(v)));
+      const passed = actualSet.size === expectedSet.size && [...actualSet].every(v => expectedSet.has(v));
+      results.push({
+        field, rule: "set_equals",
+        passed, actual, expected: rule.set_equals,
+      });
+    }
+  }
+
   return results;
 }
 

package/src/core/runner/executor.ts

@@ -1,8 +1,10 @@
-import type { TestSuite, Environment } from "../parser/types.ts";
+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";
 import { executeRequest, type FetchOptions } from "./http-client.ts";
 import { checkAssertions, extractCaptures } from "./assertions.ts";
+import { evaluateExpr } from "./expr-eval.ts";
+import { applyTransform } from "./transforms.ts";
 
 function buildUrl(baseUrl: string | undefined, path: string, query?: Record<string, string>): string {
   let url = baseUrl ? `${baseUrl.replace(/\/+$/, "")}${path}` : path;
@@ -38,7 +40,61 @@ export async function runSuite(suite: TestSuite, env: Environment = {}, dryRun =
     follow_redirects: suite.config.follow_redirects,
   };
 
-  for (const step of suite.tests) {
+  // Expand steps lazily (for_each needs current variables)
+  let stepIndex = 0;
+  const rawSteps = [...suite.tests];
+
+  while (stepIndex < rawSteps.length) {
+    const step = rawSteps[stepIndex]!;
+    stepIndex++;
+
+    // Expand for_each: insert expanded steps and skip current
+    if (step.for_each) {
+      const resolvedIn = substituteDeep(step.for_each.in, variables);
+      const items = Array.isArray(resolvedIn) ? resolvedIn : [];
+      const expanded: TestStep[] = [];
+      for (const item of items) {
+        const { for_each: _, ...rest } = step;
+        expanded.push({ ...rest, name: `${step.name} [${step.for_each.var}=${JSON.stringify(item)}]` } as TestStep);
+        // We'll inject the variable right before executing each expanded step
+        // Store the var assignment via a set field
+      }
+      // Insert expanded steps at current position
+      rawSteps.splice(stepIndex, 0, ...expanded);
+      // Set the for_each variable for each expanded step
+      for (let i = 0; i < items.length; i++) {
+        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] };
+      }
+      continue;
+    }
+
+    // Inject for_each variable if present
+    const forEachData = (step 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;
+    }
+
+    // Handle set-only steps (no HTTP request)
+    if (step.set && step.path === "") {
+      for (const [key, rawDirective] of Object.entries(step.set)) {
+        const substituted = substituteDeep(rawDirective, variables);
+        variables[key] = applyTransform(substituted);
+      }
+      steps.push({
+        name: step.name,
+        status: "pass",
+        duration_ms: 0,
+        request: { method: "", url: "", headers: {} },
+        assertions: [],
+        captures: {},
+      });
+      continue;
+    }
+
     // Skip check: if step references a failed capture variable, skip it
     const referencedVars = extractVariableReferences(step);
     const missingCapture = referencedVars.find((v) => failedCaptures.has(v));
@@ -47,6 +103,15 @@ export async function runSuite(suite: TestSuite, env: Environment = {}, dryRun =
       continue;
     }
 
+    // skip_if evaluation
+    if (step.skip_if) {
+      const exprAfterSubst = String(substituteString(step.skip_if, variables));
+      if (evaluateExpr(exprAfterSubst)) {
+        steps.push(makeSkippedResult(step.name, `Skipped: ${step.skip_if}`));
+        continue;
+      }
+    }
+
     // Substitute variables
     const resolved = substituteStep(step, variables);
 
@@ -104,6 +169,59 @@ export async function runSuite(suite: TestSuite, env: Environment = {}, dryRun =
       continue;
     }
 
+    // retry_until wrapper
+    if (step.retry_until) {
+      const rt = step.retry_until;
+      let lastStepResult: StepResult | undefined;
+      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 assertions = checkAssertions(resolved.expect, response);
+          const allPassed = assertions.every((a) => a.passed);
+
+          lastStepResult = {
+            name: step.name,
+            status: allPassed ? "pass" : "fail",
+            duration_ms: response.duration_ms,
+            request,
+            response,
+            assertions,
+            captures,
+          };
+
+          // Evaluate condition with response context
+          const condVars: Record<string, unknown> = { ...variables, ...captures, status: response.status };
+          if (response.body_parsed && typeof response.body_parsed === "object") {
+            for (const [k, v] of Object.entries(response.body_parsed as Record<string, unknown>)) {
+              condVars[k] = v;
+            }
+          }
+          const condStr = String(substituteString(rt.condition, condVars));
+          if (evaluateExpr(condStr)) {
+            Object.assign(variables, captures);
+            break;
+          }
+
+          if (attempt < rt.max_attempts - 1) {
+            await new Promise((resolve) => setTimeout(resolve, rt.delay_ms));
+          }
+        } catch (err) {
+          lastStepResult = {
+            name: step.name,
+            status: "error",
+            duration_ms: 0,
+            request,
+            assertions: [],
+            captures: {},
+            error: err instanceof Error ? err.message : String(err),
+          };
+        }
+      }
+      if (lastStepResult) steps.push(lastStepResult);
+      continue;
+    }
+
     try {
       const response = await executeRequest(request, fetchOptions);
 

package/src/core/runner/expr-eval.ts

@@ -0,0 +1,41 @@
+const OPERATORS = ["!=", "==", ">=", "<=", ">", "<"] as const;
+
+export function evaluateExpr(expr: string): boolean {
+  const trimmed = expr.trim();
+  if (trimmed === "") return false;
+
+  for (const op of OPERATORS) {
+    const idx = trimmed.indexOf(op);
+    if (idx !== -1) {
+      const left = trimmed.slice(0, idx).trim();
+      const right = trimmed.slice(idx + op.length).trim();
+      return compareValues(left, right, op);
+    }
+  }
+
+  // No operator — truthiness
+  return isTruthy(trimmed);
+}
+
+function compareValues(left: string, right: string, op: string): boolean {
+  const lNum = Number(left);
+  const rNum = Number(right);
+  const numeric = !isNaN(lNum) && !isNaN(rNum) && left !== "" && right !== "";
+
+  switch (op) {
+    case "==": return numeric ? lNum === rNum : left === right;
+    case "!=": return numeric ? lNum !== rNum : left !== right;
+    case ">":  return numeric ? lNum > rNum : left > right;
+    case "<":  return numeric ? lNum < rNum : left < right;
+    case ">=": return numeric ? lNum >= rNum : left >= right;
+    case "<=": return numeric ? lNum <= rNum : left <= right;
+    default: return false;
+  }
+}
+
+function isTruthy(value: string): boolean {
+  if (value === "" || value === "0" || value === "false" || value === "null" || value === "undefined") {
+    return false;
+  }
+  return true;
+}

package/src/core/runner/transforms.ts

@@ -0,0 +1,65 @@
+const DIRECTIVES = new Set(["concat", "append", "length", "get", "first", "map_field"]);
+
+export function applyTransform(directive: unknown): unknown {
+  if (typeof directive !== "object" || directive === null || Array.isArray(directive)) {
+    return directive;
+  }
+
+  const obj = directive as Record<string, unknown>;
+  const keys = Object.keys(obj);
+
+  if (keys.length !== 1 || !DIRECTIVES.has(keys[0]!)) {
+    return directive;
+  }
+
+  const op = keys[0]!;
+  const arg = obj[op];
+
+  switch (op) {
+    case "concat": {
+      if (!Array.isArray(arg)) return directive;
+      const result: unknown[] = [];
+      for (const item of arg) {
+        if (Array.isArray(item)) result.push(...item);
+        else result.push(item);
+      }
+      return result;
+    }
+    case "append": {
+      if (!Array.isArray(arg) || arg.length < 2) return directive;
+      const arr = Array.isArray(arg[0]) ? [...arg[0]] : [];
+      return [...arr, ...arg.slice(1)];
+    }
+    case "length": {
+      if (Array.isArray(arg)) return arg.length;
+      if (typeof arg === "string") return arg.length;
+      return 0;
+    }
+    case "get": {
+      if (!Array.isArray(arg) || arg.length < 2) return directive;
+      const [source, index] = arg;
+      if (Array.isArray(source) && typeof index === "number") return source[index];
+      if (typeof source === "object" && source !== null && typeof index === "string") {
+        return (source as Record<string, unknown>)[index];
+      }
+      return undefined;
+    }
+    case "first": {
+      if (Array.isArray(arg)) return arg[0];
+      return undefined;
+    }
+    case "map_field": {
+      if (!Array.isArray(arg) || arg.length < 2) return directive;
+      const [items, field] = arg;
+      if (!Array.isArray(items) || typeof field !== "string") return directive;
+      return items.map((item) => {
+        if (typeof item === "object" && item !== null) {
+          return (item as Record<string, unknown>)[field];
+        }
+        return undefined;
+      });
+    }
+    default:
+      return directive;
+  }
+}

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