@curl-runner/cli 1.14.0 → 1.15.0

package/src/diff/baseline-manager.ts

@@ -0,0 +1,266 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import type {
+  Baseline,
+  BaselineFile,
+  DiffConfig,
+  ExecutionResult,
+  GlobalDiffConfig,
+} from '../types/config';
+
+const BASELINE_VERSION = 1;
+const DEFAULT_BASELINE_DIR = '__baselines__';
+
+/**
+ * Manages baseline files: reading, writing, and listing.
+ */
+export class BaselineManager {
+  private baselineDir: string;
+  private writeLocks: Map<string, Promise<void>> = new Map();
+
+  constructor(globalConfig: GlobalDiffConfig = {}) {
+    this.baselineDir = globalConfig.dir || DEFAULT_BASELINE_DIR;
+  }
+
+  /**
+   * Gets the baseline file path for a label.
+   */
+  getBaselinePath(yamlPath: string, label: string): string {
+    const dir = path.dirname(yamlPath);
+    const basename = path.basename(yamlPath, path.extname(yamlPath));
+    return path.join(dir, this.baselineDir, `${basename}.${label}.baseline.json`);
+  }
+
+  /**
+   * Gets the baseline directory for a YAML file.
+   */
+  getBaselineDir(yamlPath: string): string {
+    return path.join(path.dirname(yamlPath), this.baselineDir);
+  }
+
+  /**
+   * Loads baseline file for a specific label.
+   */
+  async load(yamlPath: string, label: string): Promise<BaselineFile | null> {
+    const baselinePath = this.getBaselinePath(yamlPath, label);
+    try {
+      const file = Bun.file(baselinePath);
+      if (!(await file.exists())) {
+        return null;
+      }
+      const content = await file.text();
+      return JSON.parse(content) as BaselineFile;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Saves baseline file with write queue for parallel safety.
+   */
+  async save(yamlPath: string, label: string, data: BaselineFile): Promise<void> {
+    const baselinePath = this.getBaselinePath(yamlPath, label);
+
+    const existingLock = this.writeLocks.get(baselinePath);
+    const writePromise = (async () => {
+      if (existingLock) {
+        await existingLock;
+      }
+
+      const dir = path.dirname(baselinePath);
+      await fs.mkdir(dir, { recursive: true });
+
+      const content = JSON.stringify(data, null, 2);
+      await Bun.write(baselinePath, content);
+    })();
+
+    this.writeLocks.set(baselinePath, writePromise);
+    await writePromise;
+    this.writeLocks.delete(baselinePath);
+  }
+
+  /**
+   * Gets a single baseline by request name.
+   */
+  async get(yamlPath: string, label: string, requestName: string): Promise<Baseline | null> {
+    const file = await this.load(yamlPath, label);
+    return file?.baselines[requestName] || null;
+  }
+
+  /**
+   * Lists all available baseline labels for a YAML file.
+   */
+  async listLabels(yamlPath: string): Promise<string[]> {
+    const dir = this.getBaselineDir(yamlPath);
+    const basename = path.basename(yamlPath, path.extname(yamlPath));
+
+    try {
+      const files = await fs.readdir(dir);
+      const labels: string[] = [];
+
+      for (const file of files) {
+        const match = file.match(new RegExp(`^${basename}\\.(.+)\\.baseline\\.json$`));
+        if (match) {
+          labels.push(match[1]);
+        }
+      }
+
+      return labels.sort();
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Creates a baseline from execution result.
+   */
+  createBaseline(result: ExecutionResult, config: DiffConfig): Baseline {
+    const baseline: Baseline = {
+      hash: '',
+      capturedAt: new Date().toISOString(),
+    };
+
+    if (result.status !== undefined) {
+      baseline.status = result.status;
+    }
+
+    if (result.headers) {
+      baseline.headers = this.normalizeHeaders(result.headers);
+    }
+
+    if (result.body !== undefined) {
+      baseline.body = result.body;
+    }
+
+    if (config.includeTimings && result.metrics?.duration !== undefined) {
+      baseline.timing = result.metrics.duration;
+    }
+
+    baseline.hash = this.hash(baseline);
+
+    return baseline;
+  }
+
+  /**
+   * Normalizes headers for consistent comparison.
+   */
+  private normalizeHeaders(headers: Record<string, string>): Record<string, string> {
+    const normalized: Record<string, string> = {};
+    const sortedKeys = Object.keys(headers).sort();
+    for (const key of sortedKeys) {
+      normalized[key.toLowerCase()] = headers[key];
+    }
+    return normalized;
+  }
+
+  /**
+   * Generates a hash for baseline content.
+   */
+  hash(content: unknown): string {
+    const str = JSON.stringify(content);
+    const hasher = new Bun.CryptoHasher('md5');
+    hasher.update(str);
+    return hasher.digest('hex').slice(0, 8);
+  }
+
+  /**
+   * Saves execution results as a baseline.
+   */
+  async saveBaseline(
+    yamlPath: string,
+    label: string,
+    results: ExecutionResult[],
+    config: DiffConfig,
+  ): Promise<void> {
+    const baselines: Record<string, Baseline> = {};
+
+    for (const result of results) {
+      if (result.skipped || !result.success) {
+        continue;
+      }
+      const name = result.request.name || result.request.url;
+      baselines[name] = this.createBaseline(result, config);
+    }
+
+    const file: BaselineFile = {
+      version: BASELINE_VERSION,
+      label,
+      capturedAt: new Date().toISOString(),
+      baselines,
+    };
+
+    await this.save(yamlPath, label, file);
+  }
+
+  /**
+   * Deletes baselines older than specified days.
+   */
+  async cleanOldBaselines(yamlPath: string, olderThanDays: number): Promise<number> {
+    const dir = this.getBaselineDir(yamlPath);
+    const cutoff = Date.now() - olderThanDays * 24 * 60 * 60 * 1000;
+    let deleted = 0;
+
+    try {
+      const files = await fs.readdir(dir);
+
+      for (const file of files) {
+        if (!file.endsWith('.baseline.json')) {
+          continue;
+        }
+
+        const filePath = path.join(dir, file);
+        const stat = await fs.stat(filePath);
+
+        if (stat.mtimeMs < cutoff) {
+          await fs.unlink(filePath);
+          deleted++;
+        }
+      }
+    } catch {
+      // Directory doesn't exist or other error
+    }
+
+    return deleted;
+  }
+
+  /**
+   * Merges request-level config with global config.
+   */
+  static mergeConfig(
+    globalConfig: GlobalDiffConfig | undefined,
+    requestConfig: DiffConfig | boolean | undefined,
+  ): DiffConfig | null {
+    if (!requestConfig && !globalConfig?.enabled) {
+      return null;
+    }
+
+    if (requestConfig === true) {
+      return {
+        enabled: true,
+        exclude: globalConfig?.exclude || [],
+        match: globalConfig?.match || {},
+        includeTimings: globalConfig?.includeTimings || false,
+      };
+    }
+
+    if (typeof requestConfig === 'object' && requestConfig.enabled !== false) {
+      return {
+        enabled: true,
+        exclude: [...(globalConfig?.exclude || []), ...(requestConfig.exclude || [])],
+        match: { ...(globalConfig?.match || {}), ...(requestConfig.match || {}) },
+        includeTimings: requestConfig.includeTimings ?? globalConfig?.includeTimings ?? false,
+      };
+    }
+
+    if (globalConfig?.enabled && requestConfig === undefined) {
+      return {
+        enabled: true,
+        exclude: globalConfig.exclude || [],
+        match: globalConfig.match || {},
+        includeTimings: globalConfig.includeTimings || false,
+      };
+    }
+
+    return null;
+  }
+}

package/src/diff/diff-formatter.ts

@@ -0,0 +1,316 @@
+import type { DiffCompareResult, DiffSummary, ResponseDiff } from '../types/config';
+
+const COLORS = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  dim: '\x1b[2m',
+  bright: '\x1b[1m',
+};
+
+/**
+ * Formats diff comparison results for various outputs.
+ */
+export class DiffFormatter {
+  private outputFormat: 'terminal' | 'json' | 'markdown';
+
+  constructor(outputFormat: 'terminal' | 'json' | 'markdown' = 'terminal') {
+    this.outputFormat = outputFormat;
+  }
+
+  private color(text: string, color: keyof typeof COLORS): string {
+    if (this.outputFormat !== 'terminal') {
+      return text;
+    }
+    return `${COLORS[color]}${text}${COLORS.reset}`;
+  }
+
+  /**
+   * Formats the complete diff summary.
+   */
+  formatSummary(summary: DiffSummary, baselineLabel: string, currentLabel: string): string {
+    switch (this.outputFormat) {
+      case 'json':
+        return this.formatSummaryJson(summary);
+      case 'markdown':
+        return this.formatSummaryMarkdown(summary, baselineLabel, currentLabel);
+      default:
+        return this.formatSummaryTerminal(summary, baselineLabel, currentLabel);
+    }
+  }
+
+  /**
+   * Terminal format for summary.
+   */
+  private formatSummaryTerminal(
+    summary: DiffSummary,
+    baselineLabel: string,
+    currentLabel: string,
+  ): string {
+    const lines: string[] = [];
+
+    lines.push('');
+    lines.push(
+      `${this.color('Response Diff:', 'bright')} ${this.color(baselineLabel, 'cyan')} → ${this.color(currentLabel, 'cyan')}`,
+    );
+    lines.push('');
+
+    for (const result of summary.results) {
+      lines.push(this.formatResultTerminal(result));
+      lines.push('');
+    }
+
+    lines.push(this.formatStatsSummary(summary));
+
+    return lines.join('\n');
+  }
+
+  /**
+   * JSON format for summary.
+   */
+  private formatSummaryJson(summary: DiffSummary): string {
+    return JSON.stringify(
+      {
+        summary: {
+          total: summary.totalRequests,
+          unchanged: summary.unchanged,
+          changed: summary.changed,
+          newBaselines: summary.newBaselines,
+        },
+        results: summary.results.map((r) => ({
+          request: r.requestName,
+          status: r.hasDifferences ? 'changed' : r.isNewBaseline ? 'new' : 'unchanged',
+          differences: r.differences,
+          timingDiff: r.timingDiff,
+        })),
+      },
+      null,
+      2,
+    );
+  }
+
+  /**
+   * Markdown format for summary.
+   */
+  private formatSummaryMarkdown(
+    summary: DiffSummary,
+    baselineLabel: string,
+    currentLabel: string,
+  ): string {
+    const lines: string[] = [];
+
+    lines.push(`# Response Diff: ${baselineLabel} → ${currentLabel}`);
+    lines.push('');
+    lines.push(`| Metric | Count |`);
+    lines.push(`|--------|-------|`);
+    lines.push(`| Total Requests | ${summary.totalRequests} |`);
+    lines.push(`| Unchanged | ${summary.unchanged} |`);
+    lines.push(`| Changed | ${summary.changed} |`);
+    lines.push(`| New Baselines | ${summary.newBaselines} |`);
+    lines.push('');
+
+    if (summary.changed > 0) {
+      lines.push('## Changes');
+      lines.push('');
+
+      for (const result of summary.results) {
+        if (result.hasDifferences) {
+          lines.push(this.formatResultMarkdown(result));
+        }
+      }
+    }
+
+    if (summary.newBaselines > 0) {
+      lines.push('## New Requests');
+      lines.push('');
+      for (const result of summary.results) {
+        if (result.isNewBaseline) {
+          lines.push(`- \`${result.requestName}\``);
+        }
+      }
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Formats a single result for terminal.
+   */
+  formatResultTerminal(result: DiffCompareResult): string {
+    const lines: string[] = [];
+
+    if (result.isNewBaseline) {
+      lines.push(`  ${this.color('NEW', 'cyan')} ${this.color(result.requestName, 'bright')}`);
+      return lines.join('\n');
+    }
+
+    if (!result.hasDifferences) {
+      lines.push(
+        `  ${this.color('✓', 'green')} ${this.color(result.requestName, 'bright')} ${this.color('(no changes)', 'dim')}`,
+      );
+      return lines.join('\n');
+    }
+
+    lines.push(`  ${this.color('✗', 'red')} ${this.color(result.requestName, 'bright')}`);
+
+    for (const diff of result.differences) {
+      lines.push(this.formatDifferenceTerminal(diff));
+    }
+
+    if (result.timingDiff) {
+      const { baseline, current, changePercent } = result.timingDiff;
+      const sign = changePercent >= 0 ? '+' : '';
+      const color = changePercent > 20 ? 'red' : changePercent < -20 ? 'green' : 'yellow';
+      lines.push(
+        `    ${this.color('timing:', 'cyan')} ${baseline}ms → ${current}ms ${this.color(`(${sign}${changePercent.toFixed(0)}%)`, color)}`,
+      );
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Formats a single difference for terminal.
+   */
+  private formatDifferenceTerminal(diff: ResponseDiff): string {
+    const lines: string[] = [];
+    const path = diff.path || '(root)';
+
+    switch (diff.type) {
+      case 'added':
+        lines.push(`    ${this.color(path, 'cyan')}:`);
+        lines.push(`      ${this.color(`+ ${this.stringify(diff.current)}`, 'green')}`);
+        break;
+
+      case 'removed':
+        lines.push(`    ${this.color(path, 'cyan')}:`);
+        lines.push(`      ${this.color(`- ${this.stringify(diff.baseline)}`, 'red')}`);
+        break;
+
+      case 'changed':
+        lines.push(`    ${this.color(path, 'cyan')}:`);
+        lines.push(`      ${this.color(`- ${this.stringify(diff.baseline)}`, 'red')}`);
+        lines.push(`      ${this.color(`+ ${this.stringify(diff.current)}`, 'green')}`);
+        break;
+
+      case 'type_mismatch':
+        lines.push(`    ${this.color(path, 'cyan')} (type mismatch):`);
+        lines.push(
+          `      ${this.color(`- ${this.stringify(diff.baseline)} (${typeof diff.baseline})`, 'red')}`,
+        );
+        lines.push(
+          `      ${this.color(`+ ${this.stringify(diff.current)} (${typeof diff.current})`, 'green')}`,
+        );
+        break;
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Formats a single result for markdown.
+   */
+  private formatResultMarkdown(result: DiffCompareResult): string {
+    const lines: string[] = [];
+
+    lines.push(`### \`${result.requestName}\``);
+    lines.push('');
+    lines.push('```diff');
+
+    for (const diff of result.differences) {
+      lines.push(this.formatDifferenceMarkdown(diff));
+    }
+
+    lines.push('```');
+
+    if (result.timingDiff) {
+      const { baseline, current, changePercent } = result.timingDiff;
+      const sign = changePercent >= 0 ? '+' : '';
+      lines.push('');
+      lines.push(`**Timing:** ${baseline}ms → ${current}ms (${sign}${changePercent.toFixed(0)}%)`);
+    }
+
+    lines.push('');
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Formats a single difference for markdown.
+   */
+  private formatDifferenceMarkdown(diff: ResponseDiff): string {
+    const lines: string[] = [];
+    const path = diff.path || '(root)';
+
+    switch (diff.type) {
+      case 'added':
+        lines.push(`# ${path}:`);
+        lines.push(`+ ${this.stringify(diff.current)}`);
+        break;
+
+      case 'removed':
+        lines.push(`# ${path}:`);
+        lines.push(`- ${this.stringify(diff.baseline)}`);
+        break;
+
+      case 'changed':
+        lines.push(`# ${path}:`);
+        lines.push(`- ${this.stringify(diff.baseline)}`);
+        lines.push(`+ ${this.stringify(diff.current)}`);
+        break;
+
+      case 'type_mismatch':
+        lines.push(`# ${path} (type mismatch):`);
+        lines.push(`- ${this.stringify(diff.baseline)} (${typeof diff.baseline})`);
+        lines.push(`+ ${this.stringify(diff.current)} (${typeof diff.current})`);
+        break;
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Formats stats summary for terminal.
+   */
+  private formatStatsSummary(summary: DiffSummary): string {
+    const parts: string[] = [];
+
+    if (summary.unchanged > 0) {
+      parts.push(this.color(`${summary.unchanged} unchanged`, 'green'));
+    }
+    if (summary.changed > 0) {
+      parts.push(this.color(`${summary.changed} changed`, 'red'));
+    }
+    if (summary.newBaselines > 0) {
+      parts.push(this.color(`${summary.newBaselines} new`, 'cyan'));
+    }
+
+    return `Summary: ${parts.join(', ')} (${summary.totalRequests} total)`;
+  }
+
+  /**
+   * Converts value to display string.
+   */
+  private stringify(value: unknown): string {
+    if (value === undefined) {
+      return 'undefined';
+    }
+    if (value === null) {
+      return 'null';
+    }
+    if (typeof value === 'string') {
+      return `"${value}"`;
+    }
+    if (typeof value === 'object') {
+      const str = JSON.stringify(value);
+      if (str.length > 80) {
+        return `${str.slice(0, 77)}...`;
+      }
+      return str;
+    }
+    return String(value);
+  }
+}

package/src/diff/index.ts

@@ -0,0 +1,3 @@
+export { BaselineManager } from './baseline-manager';
+export { DiffFormatter } from './diff-formatter';
+export { DiffOrchestrator, ResponseDiffer } from './response-differ';