snapeval 1.0.1

package/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "snapeval",
+  "version": "1.0.0",
+  "description": "Semantic snapshot testing for AI skills. Zero assertions. AI-driven. Free inference.",
+  "author": "Matan Tsach",
+  "license": "MIT",
+  "skills": ["skills/snapeval"],
+  "scripts": ["scripts/snapeval-cli.sh"]
+}

package/scripts/snapeval-cli.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+# Ensures npx snapeval is available
+if ! command -v npx &> /dev/null; then
+  echo "Error: npx not found. Install Node.js first."
+  exit 2
+fi
+npx snapeval "$@"

package/skills/snapeval/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: snapeval
+description: Evaluate AI skills through semantic snapshot testing. Generates test cases, captures baselines, and detects regressions.
+---
+
+You are snapeval, a skill evaluation assistant. When the user asks you to evaluate, check, or approve a skill, follow this process:
+
+## Commands
+
+### evaluate / test (first-time capture)
+
+1. Ask the user which skill they want to evaluate (or accept the path they provide)
+2. Read the target skill's SKILL.md file using the Read tool
+3. Analyze its purpose, inputs, expected behaviors, and edge cases
+4. Generate 5-8 test scenarios covering:
+   - Happy path scenarios (normal use cases)
+   - Edge cases (empty input, unusual input)
+   - At least one negative test
+5. Present the scenarios as a numbered list and ask: "Here are N test scenarios. Want to adjust any, or should I run them?"
+6. Wait for user confirmation
+7. On confirmation, run these commands:
+   ```bash
+   npx snapeval init <skill-path>
+   npx snapeval capture <skill-path>
+   ```
+8. Report results: how many scenarios captured, total cost, location of snapshots
+
+### check (regression detection)
+
+1. Run: `npx snapeval check <skill-path> --threshold 0.85`
+2. Parse the terminal output
+3. Report conversationally:
+   - Which scenarios passed and at which tier (schema/embedding/judge)
+   - Which scenarios regressed with details about what changed
+   - Total cost and duration
+4. If regressions found, present options:
+   - Fix the skill and re-check
+   - Run `@snapeval approve` to accept new behavior
+
+### approve
+
+1. Run: `npx snapeval approve --scenario <N>` (or without --scenario for all)
+2. Confirm what was approved
+3. Remind user to commit the updated snapshots
+
+## Important
+
+- Never ask the user to write evals.json or any config files manually
+- Always read the target skill's SKILL.md before generating scenarios
+- Report costs prominently (should be $0.00 for Copilot gpt-5-mini)
+- When reporting regressions, explain what changed in plain language

package/src/adapters/inference/copilot.ts

@@ -0,0 +1,30 @@
+import { execFileSync } from 'node:child_process';
+import type { InferenceAdapter, Message, ChatOptions } from '../../types.js';
+import { AdapterNotAvailableError } from '../../errors.js';
+
+export class CopilotInference implements InferenceAdapter {
+  readonly name = 'copilot';
+
+  constructor(private readonly fallback?: InferenceAdapter) {}
+
+  async chat(messages: Message[], _options?: ChatOptions): Promise<string> {
+    // Concatenate messages into a single prompt string
+    const prompt = messages.map((m) => m.content).join('\n');
+    const result = execFileSync('gh', ['copilot', '-p', prompt], { encoding: 'utf-8' });
+    return result.trim();
+  }
+
+  async embed(text: string): Promise<number[]> {
+    if (this.fallback) {
+      return this.fallback.embed(text);
+    }
+    throw new AdapterNotAvailableError(
+      'copilot-embed',
+      'Copilot CLI does not support embeddings. Provide a fallback InferenceAdapter (e.g. GitHubModelsInference).'
+    );
+  }
+
+  estimateCost(_tokens: number): number {
+    return 0;
+  }
+}

package/src/adapters/inference/github-models.ts

@@ -0,0 +1,74 @@
+import type { InferenceAdapter, Message, ChatOptions } from '../../types.js';
+import { RateLimitError } from '../../errors.js';
+
+const API_BASE = 'https://models.github.ai/inference';
+const CHAT_MODEL = 'openai/gpt-4o-mini';
+const EMBEDDING_MODEL = 'openai/text-embedding-3-small';
+
+export class GitHubModelsInference implements InferenceAdapter {
+  readonly name = 'github-models';
+
+  constructor(private readonly token: string = process.env.GITHUB_TOKEN ?? '') {}
+
+  async chat(messages: Message[], options?: ChatOptions): Promise<string> {
+    const body: Record<string, unknown> = {
+      model: CHAT_MODEL,
+      messages,
+    };
+    if (options?.temperature !== undefined) body.temperature = options.temperature;
+    if (options?.maxTokens !== undefined) body.max_tokens = options.maxTokens;
+    if (options?.responseFormat === 'json') {
+      body.response_format = { type: 'json_object' };
+    }
+
+    const response = await fetch(`${API_BASE}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (response.status === 429) {
+      throw new RateLimitError(this.name);
+    }
+
+    if (!response.ok) {
+      throw new Error(`GitHub Models API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as {
+      choices: Array<{ message: { content: string } }>;
+    };
+    return data.choices[0].message.content;
+  }
+
+  async embed(text: string): Promise<number[]> {
+    const response = await fetch(`${API_BASE}/embeddings`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ model: EMBEDDING_MODEL, input: text }),
+    });
+
+    if (response.status === 429) {
+      throw new RateLimitError(this.name);
+    }
+
+    if (!response.ok) {
+      throw new Error(`GitHub Models API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as {
+      data: Array<{ embedding: number[] }>;
+    };
+    return data.data[0].embedding;
+  }
+
+  estimateCost(_tokens: number): number {
+    return 0;
+  }
+}

package/src/adapters/inference/resolve.ts

@@ -0,0 +1,70 @@
+import { execFileSync } from 'node:child_process';
+import type { InferenceAdapter } from '../../types.js';
+import { AdapterNotAvailableError } from '../../errors.js';
+import { GitHubModelsInference } from './github-models.js';
+import { CopilotInference } from './copilot.js';
+
+function isCopilotAvailable(): boolean {
+  try {
+    execFileSync('gh', ['copilot', '--version'], { encoding: 'utf-8', stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isGitHubTokenAvailable(): boolean {
+  return Boolean(process.env.GITHUB_TOKEN);
+}
+
+export function resolveInference(preference: string): InferenceAdapter {
+  if (preference === 'auto') {
+    const copilotAvailable = isCopilotAvailable();
+    const tokenAvailable = isGitHubTokenAvailable();
+
+    if (copilotAvailable && tokenAvailable) {
+      // Copilot for chat, GitHubModels as embedding fallback
+      const githubModels = new GitHubModelsInference();
+      return new CopilotInference(githubModels);
+    }
+
+    if (copilotAvailable) {
+      return new CopilotInference();
+    }
+
+    if (tokenAvailable) {
+      return new GitHubModelsInference();
+    }
+
+    throw new AdapterNotAvailableError(
+      'inference',
+      'No inference adapter available. Install GitHub Copilot CLI (`gh extension install github/gh-copilot`) or set GITHUB_TOKEN.'
+    );
+  }
+
+  if (preference === 'copilot') {
+    if (!isCopilotAvailable()) {
+      throw new AdapterNotAvailableError(
+        'copilot',
+        'GitHub Copilot CLI is not available. Install with: gh extension install github/gh-copilot'
+      );
+    }
+    const fallback = isGitHubTokenAvailable() ? new GitHubModelsInference() : undefined;
+    return new CopilotInference(fallback);
+  }
+
+  if (preference === 'github-models') {
+    if (!isGitHubTokenAvailable()) {
+      throw new AdapterNotAvailableError(
+        'github-models',
+        'GITHUB_TOKEN environment variable is not set.'
+      );
+    }
+    return new GitHubModelsInference();
+  }
+
+  throw new AdapterNotAvailableError(
+    preference,
+    `Unknown inference adapter "${preference}". Valid options: auto, copilot, github-models.`
+  );
+}

package/src/adapters/report/json.ts

@@ -0,0 +1,64 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type {
+  ReportAdapter,
+  EvalResults,
+  GradingFile,
+  AssertionResult,
+  GradingSummary,
+} from '../../types.js';
+
+function buildGradingFile(results: EvalResults): GradingFile {
+  const allAssertions: AssertionResult[] = [];
+
+  for (const scenario of results.scenarios) {
+    if (scenario.grading) {
+      allAssertions.push(...scenario.grading.assertion_results);
+    }
+  }
+
+  const passed = allAssertions.filter((a) => a.passed).length;
+  const failed = allAssertions.filter((a) => !a.passed).length;
+  const total = allAssertions.length;
+  const pass_rate = total > 0 ? passed / total : 0;
+
+  const summary: GradingSummary = { passed, failed, total, pass_rate };
+  return { assertion_results: allAssertions, summary };
+}
+
+export class JSONReporter implements ReportAdapter {
+  readonly name = 'json';
+
+  constructor(private readonly outputDir: string) {}
+
+  async report(results: EvalResults): Promise<void> {
+    fs.mkdirSync(this.outputDir, { recursive: true });
+
+    // grading.json
+    const gradingFile = buildGradingFile(results);
+    fs.writeFileSync(
+      path.join(this.outputDir, 'grading.json'),
+      JSON.stringify(gradingFile, null, 2),
+      'utf-8'
+    );
+
+    // timing.json
+    const timingData = {
+      total_tokens: results.timing.total_tokens,
+      duration_ms: results.timing.duration_ms,
+    };
+    fs.writeFileSync(
+      path.join(this.outputDir, 'timing.json'),
+      JSON.stringify(timingData, null, 2),
+      'utf-8'
+    );
+
+    // benchmark.json
+    const benchmarkData = { run_summary: results.summary };
+    fs.writeFileSync(
+      path.join(this.outputDir, 'benchmark.json'),
+      JSON.stringify(benchmarkData, null, 2),
+      'utf-8'
+    );
+  }
+}

package/src/adapters/report/terminal.ts

@@ -0,0 +1,59 @@
+import chalk from 'chalk';
+import type { ReportAdapter, EvalResults, ScenarioResult, ComparisonVerdict } from '../../types.js';
+
+function verdictIcon(verdict: ComparisonVerdict): string {
+  switch (verdict) {
+    case 'pass':
+      return chalk.green('✓');
+    case 'regressed':
+      return chalk.red('✗');
+    default:
+      return chalk.yellow('?');
+  }
+}
+
+function formatScenario(scenario: ScenarioResult): string {
+  const icon = verdictIcon(scenario.comparison.verdict);
+  const tier = `tier${scenario.comparison.tier}`;
+  const tokens = scenario.timing.total_tokens;
+  const durationS = (scenario.timing.duration_ms / 1000).toFixed(2);
+  const cost = scenario.newOutput.metadata.adapter;
+  return `  ${icon} Scenario ${scenario.scenarioId} [${tier}] — ${tokens} tokens, ${durationS}s (${cost})`;
+}
+
+export class TerminalReporter implements ReportAdapter {
+  readonly name = 'terminal';
+
+  async report(results: EvalResults): Promise<void> {
+    const { skillName, scenarios, summary, timing } = results;
+
+    console.log(chalk.bold(`\nSnapeval — ${skillName}`));
+    console.log(chalk.dim('─'.repeat(50)));
+
+    for (const scenario of scenarios) {
+      console.log(formatScenario(scenario));
+    }
+
+    console.log(chalk.dim('─'.repeat(50)));
+
+    const passedStr = chalk.green(`${summary.passed} passed`);
+    const regressedCount = summary.regressed;
+    const regressedStr = regressedCount > 0
+      ? chalk.red(`${regressedCount} regressed`)
+      : chalk.dim(`${regressedCount} regressed`);
+    const totalStr = `${summary.total_scenarios} total`;
+    const passRate = (summary.pass_rate * 100).toFixed(0);
+
+    console.log(`${passedStr}, ${regressedStr}, ${totalStr} (${passRate}%)`);
+    console.log(
+      chalk.dim(
+        `Tokens: ${timing.total_tokens} | Duration: ${(timing.duration_ms / 1000).toFixed(2)}s | Cost: $${summary.total_cost_usd.toFixed(4)}`
+      )
+    );
+    console.log(
+      chalk.dim(
+        `Tier breakdown — schema: ${summary.tier_breakdown.tier1_schema}, embedding: ${summary.tier_breakdown.tier2_embedding}, llm: ${summary.tier_breakdown.tier3_llm_judge}`
+      )
+    );
+  }
+}

package/src/adapters/skill/copilot-cli.ts

@@ -0,0 +1,60 @@
+import { execFile, execFileSync } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import * as path from 'node:path';
+import type { SkillAdapter, SkillOutput } from '../../types.js';
+
+export class CopilotCLIAdapter implements SkillAdapter {
+  readonly name = 'copilot-cli';
+
+  async invoke(skillPath: string, prompt: string, _files?: string[]): Promise<SkillOutput> {
+    const startMs = Date.now();
+
+    // Try to include SKILL.md content as context if present
+    let skillMd = '';
+    try {
+      const skillFile = path.join(skillPath, 'SKILL.md');
+      skillMd = await readFile(skillFile, { encoding: 'utf-8' });
+    } catch {
+      // ignore missing SKILL.md
+    }
+
+    const finalPrompt = skillMd ? `${skillMd}\n\n${prompt}` : prompt;
+
+    return new Promise<SkillOutput>((resolve, reject) => {
+      // Use gh copilot and pass flags after `--` so gh doesn't consume them.
+      // Use --silent to limit output to the model's response only.
+      execFile(
+        'gh',
+        ['copilot', '--', '-p', finalPrompt, '--silent'],
+        { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 },
+        (error, stdout, _stderr) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          const durationMs = Date.now() - startMs;
+          const raw = stdout.trim();
+          resolve({
+            raw,
+            metadata: {
+              tokens: 0,
+              durationMs,
+              model: 'copilot',
+              adapter: this.name,
+            },
+          });
+        }
+      );
+    });
+  }
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      // Use gh copilot --help as a lightweight availability check
+      execFileSync('gh', ['copilot', '--help'], { encoding: 'utf-8', stdio: 'pipe' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/commands/approve.ts

@@ -0,0 +1,58 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { SkillAdapter, EvalsFile, EvalResults } from '../types.js';
+import { SnapshotManager } from '../engine/snapshot.js';
+import { SnapevalError } from '../errors.js';
+
+export async function approveCommand(
+  skillPath: string,
+  skillAdapter: SkillAdapter,
+  options: { scenarioIds?: number[] } = {}
+): Promise<void> {
+  const evalsPath = path.join(skillPath, 'evals', 'evals.json');
+  if (!fs.existsSync(evalsPath)) {
+    throw new SnapevalError(`No evals.json found at ${evalsPath}. Run \`snapeval init\` first.`);
+  }
+
+  const evalsFile: EvalsFile = JSON.parse(fs.readFileSync(evalsPath, 'utf-8'));
+  const manager = new SnapshotManager(path.join(skillPath, 'evals'));
+
+  // Determine which scenarios to approve
+  const targetCases = options.scenarioIds && options.scenarioIds.length > 0
+    ? evalsFile.evals.filter((e) => options.scenarioIds!.includes(e.id))
+    : evalsFile.evals;
+
+  for (const evalCase of targetCases) {
+    const newOutput = await skillAdapter.invoke(skillPath, evalCase.prompt, evalCase.files);
+    manager.approve(evalCase.id, evalCase.prompt, newOutput);
+  }
+}
+
+export function approveFromResults(
+  skillPath: string,
+  results: EvalResults,
+  scenarioIds?: number[]
+): void {
+  const evalsPath = path.join(skillPath, 'evals', 'evals.json');
+  if (!fs.existsSync(evalsPath)) {
+    throw new SnapevalError(`No evals.json found at ${evalsPath}.`);
+  }
+
+  const evalsFile: EvalsFile = JSON.parse(fs.readFileSync(evalsPath, 'utf-8'));
+  const manager = new SnapshotManager(path.join(skillPath, 'evals'));
+
+  // Find regressed scenarios from results
+  const regressedResults = results.scenarios.filter(
+    (s) => s.comparison.verdict === 'regressed'
+  );
+
+  const toApprove = scenarioIds && scenarioIds.length > 0
+    ? regressedResults.filter((s) => scenarioIds.includes(s.scenarioId))
+    : regressedResults;
+
+  for (const scenario of toApprove) {
+    const evalCase = evalsFile.evals.find((e) => e.id === scenario.scenarioId);
+    if (!evalCase) continue;
+    manager.approve(scenario.scenarioId, evalCase.prompt, scenario.newOutput);
+  }
+}

package/src/commands/capture.ts

@@ -0,0 +1,25 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { SkillAdapter, EvalsFile } from '../types.js';
+import { SnapshotManager } from '../engine/snapshot.js';
+import { SnapevalError } from '../errors.js';
+
+export async function captureCommand(
+  skillPath: string,
+  skillAdapter: SkillAdapter,
+  options: { runs?: number } = {}
+): Promise<void> {
+  const evalsPath = path.join(skillPath, 'evals', 'evals.json');
+  if (!fs.existsSync(evalsPath)) {
+    throw new SnapevalError(`No evals.json found at ${evalsPath}. Run \`snapeval init\` first.`);
+  }
+
+  const evalsFile: EvalsFile = JSON.parse(fs.readFileSync(evalsPath, 'utf-8'));
+  const manager = new SnapshotManager(path.join(skillPath, 'evals'));
+  const runs = options.runs ?? 1;
+
+  for (const evalCase of evalsFile.evals) {
+    const output = await skillAdapter.invoke(skillPath, evalCase.prompt, evalCase.files);
+    manager.saveSnapshot(evalCase.id, evalCase.prompt, output, runs);
+  }
+}

package/src/commands/check.ts

@@ -0,0 +1,86 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type {
+  SkillAdapter,
+  InferenceAdapter,
+  EvalsFile,
+  EvalResults,
+  ScenarioResult,
+  BenchmarkSummary,
+} from '../types.js';
+import { SnapshotManager } from '../engine/snapshot.js';
+import { comparePipeline } from '../engine/comparison/pipeline.js';
+import { NoBaselineError, SnapevalError } from '../errors.js';
+import { BudgetEngine } from '../engine/budget.js';
+
+export async function checkCommand(
+  skillPath: string,
+  skillAdapter: SkillAdapter,
+  inference: InferenceAdapter,
+  options: { threshold: number; budget: string; skipEmbedding?: boolean }
+): Promise<EvalResults> {
+  const evalsPath = path.join(skillPath, 'evals', 'evals.json');
+  if (!fs.existsSync(evalsPath)) {
+    throw new SnapevalError(`No evals.json found at ${evalsPath}`);
+  }
+  const evalsFile: EvalsFile = JSON.parse(fs.readFileSync(evalsPath, 'utf-8'));
+  const manager = new SnapshotManager(path.join(skillPath, 'evals'));
+  const budget = new BudgetEngine(options.budget);
+  const startTime = Date.now();
+
+  if (manager.listSnapshotIds().length === 0) {
+    throw new NoBaselineError(skillPath);
+  }
+
+  const scenarios: ScenarioResult[] = [];
+  const tierBreakdown = { tier1_schema: 0, tier2_embedding: 0, tier3_llm_judge: 0 };
+
+  for (const evalCase of evalsFile.evals) {
+    const baseline = manager.loadSnapshot(evalCase.id);
+    if (!baseline) continue;
+    const newOutput = await skillAdapter.invoke(skillPath, evalCase.prompt, evalCase.files);
+    const comparison = await comparePipeline(
+      baseline.output.raw,
+      newOutput.raw,
+      inference,
+      { threshold: options.threshold, skipEmbedding: options.skipEmbedding }
+    );
+    comparison.scenarioId = evalCase.id;
+    if (comparison.tier === 1) tierBreakdown.tier1_schema++;
+    else if (comparison.tier === 2) tierBreakdown.tier2_embedding++;
+    else tierBreakdown.tier3_llm_judge++;
+    budget.addCost(inference.estimateCost(newOutput.metadata.tokens));
+    scenarios.push({
+      scenarioId: evalCase.id,
+      prompt: evalCase.prompt,
+      comparison,
+      timing: {
+        total_tokens: newOutput.metadata.tokens,
+        duration_ms: newOutput.metadata.durationMs,
+      },
+      newOutput,
+    });
+  }
+
+  const passed = scenarios.filter((s) => s.comparison.verdict === 'pass').length;
+  const regressed = scenarios.filter((s) => s.comparison.verdict === 'regressed').length;
+  const summary: BenchmarkSummary = {
+    total_scenarios: scenarios.length,
+    passed,
+    regressed,
+    pass_rate: scenarios.length > 0 ? passed / scenarios.length : 1.0,
+    total_tokens: scenarios.reduce((sum, s) => sum + s.timing.total_tokens, 0),
+    total_cost_usd: budget.totalCost,
+    total_duration_ms: Date.now() - startTime,
+    tier_breakdown: tierBreakdown,
+  };
+  return {
+    skillName: evalsFile.skill_name,
+    scenarios,
+    summary,
+    timing: {
+      total_tokens: summary.total_tokens,
+      duration_ms: summary.total_duration_ms,
+    },
+  };
+}

package/src/commands/init.ts

@@ -0,0 +1,38 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { InferenceAdapter } from '../types.js';
+import { generateEvals } from '../engine/generator.js';
+import { SnapevalError } from '../errors.js';
+
+export async function initCommand(
+  skillPath: string,
+  inference: InferenceAdapter
+): Promise<void> {
+  // Locate the skill definition file (SKILL.md or skill.md)
+  const candidates = ['SKILL.md', 'skill.md'];
+  let skillFilePath: string | null = null;
+  for (const name of candidates) {
+    const candidate = path.join(skillPath, name);
+    if (fs.existsSync(candidate)) {
+      skillFilePath = candidate;
+      break;
+    }
+  }
+
+  if (!skillFilePath) {
+    throw new SnapevalError(
+      `No SKILL.md found at ${skillPath}. Create a SKILL.md file to describe your skill.`
+    );
+  }
+
+  const skillContent = fs.readFileSync(skillFilePath, 'utf-8');
+  const skillName = path.basename(skillPath);
+
+  const evalsFile = await generateEvals(skillContent, skillName, inference);
+
+  const evalsDir = path.join(skillPath, 'evals');
+  fs.mkdirSync(evalsDir, { recursive: true });
+
+  const evalsPath = path.join(evalsDir, 'evals.json');
+  fs.writeFileSync(evalsPath, JSON.stringify(evalsFile, null, 2), 'utf-8');
+}

package/src/commands/report.ts

@@ -0,0 +1,36 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { EvalResults } from '../types.js';
+import { JSONReporter } from '../adapters/report/json.js';
+import { TerminalReporter } from '../adapters/report/terminal.js';
+
+export async function reportCommand(
+  skillPath: string,
+  results: EvalResults,
+  options: { verbose?: boolean } = {}
+): Promise<void> {
+  // Determine next iteration number
+  const resultsBaseDir = path.join(skillPath, 'evals', 'results');
+  fs.mkdirSync(resultsBaseDir, { recursive: true });
+
+  const existingIterations = fs.readdirSync(resultsBaseDir)
+    .filter((d) => /^iteration-\d+$/.test(d))
+    .map((d) => parseInt(d.replace('iteration-', ''), 10))
+    .sort((a, b) => a - b);
+
+  const nextIteration = existingIterations.length > 0
+    ? existingIterations[existingIterations.length - 1] + 1
+    : 1;
+
+  const iterationDir = path.join(resultsBaseDir, `iteration-${nextIteration}`);
+
+  // Write JSON report
+  const jsonReporter = new JSONReporter(iterationDir);
+  await jsonReporter.report(results);
+
+  // Print terminal report
+  if (options.verbose !== false) {
+    const terminalReporter = new TerminalReporter();
+    await terminalReporter.report(results);
+  }
+}