@curl-runner/cli 1.13.0 → 1.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curl-runner/cli",
-  "version": "1.13.0",
+  "version": "1.15.0",
   "description": "A powerful CLI tool for HTTP request management using YAML configuration",
   "type": "module",
   "main": "./dist/cli.js",

package/src/cli.ts

@@ -1,16 +1,22 @@
 #!/usr/bin/env bun
 
 import { Glob } from 'bun';
+import { BaselineManager, DiffFormatter, DiffOrchestrator } from './diff';
+import { ProfileExecutor } from './executor/profile-executor';
 import { RequestExecutor } from './executor/request-executor';
 import { YamlParser } from './parser/yaml';
 import type {
+  DiffConfig,
   ExecutionResult,
   ExecutionSummary,
   GlobalConfig,
+  GlobalDiffConfig,
+  ProfileConfig,
   RequestConfig,
   WatchConfig,
 } from './types/config';
 import { Logger } from './utils/logger';
+import { exportToCSV, exportToJSON } from './utils/stats';
 import { VersionChecker } from './utils/version-checker';
 import { getVersion } from './version';
 import { FileWatcher } from './watcher/file-watcher';
@@ -166,6 +172,49 @@ class CurlRunnerCLI {
       };
     }
 
+    // Profile mode configuration
+    if (process.env.CURL_RUNNER_PROFILE) {
+      const iterations = Number.parseInt(process.env.CURL_RUNNER_PROFILE, 10);
+      if (iterations > 0) {
+        envConfig.profile = {
+          ...envConfig.profile,
+          iterations,
+        };
+      }
+    }
+
+    if (process.env.CURL_RUNNER_PROFILE_WARMUP) {
+      envConfig.profile = {
+        ...envConfig.profile,
+        iterations: envConfig.profile?.iterations ?? 10,
+        warmup: Number.parseInt(process.env.CURL_RUNNER_PROFILE_WARMUP, 10),
+      };
+    }
+
+    if (process.env.CURL_RUNNER_PROFILE_CONCURRENCY) {
+      envConfig.profile = {
+        ...envConfig.profile,
+        iterations: envConfig.profile?.iterations ?? 10,
+        concurrency: Number.parseInt(process.env.CURL_RUNNER_PROFILE_CONCURRENCY, 10),
+      };
+    }
+
+    if (process.env.CURL_RUNNER_PROFILE_HISTOGRAM) {
+      envConfig.profile = {
+        ...envConfig.profile,
+        iterations: envConfig.profile?.iterations ?? 10,
+        histogram: process.env.CURL_RUNNER_PROFILE_HISTOGRAM.toLowerCase() === 'true',
+      };
+    }
+
+    if (process.env.CURL_RUNNER_PROFILE_EXPORT) {
+      envConfig.profile = {
+        ...envConfig.profile,
+        iterations: envConfig.profile?.iterations ?? 10,
+        exportFile: process.env.CURL_RUNNER_PROFILE_EXPORT,
+      };
+    }
+
     // Snapshot configuration
     if (process.env.CURL_RUNNER_SNAPSHOT) {
       envConfig.snapshot = {
@@ -198,6 +247,52 @@ class CurlRunnerCLI {
       };
     }
 
+    // Diff configuration
+    if (process.env.CURL_RUNNER_DIFF) {
+      envConfig.diff = {
+        ...envConfig.diff,
+        enabled: process.env.CURL_RUNNER_DIFF.toLowerCase() === 'true',
+      };
+    }
+
+    if (process.env.CURL_RUNNER_DIFF_SAVE) {
+      envConfig.diff = {
+        ...envConfig.diff,
+        save: process.env.CURL_RUNNER_DIFF_SAVE.toLowerCase() === 'true',
+      };
+    }
+
+    if (process.env.CURL_RUNNER_DIFF_LABEL) {
+      envConfig.diff = {
+        ...envConfig.diff,
+        label: process.env.CURL_RUNNER_DIFF_LABEL,
+      };
+    }
+
+    if (process.env.CURL_RUNNER_DIFF_COMPARE) {
+      envConfig.diff = {
+        ...envConfig.diff,
+        compareWith: process.env.CURL_RUNNER_DIFF_COMPARE,
+      };
+    }
+
+    if (process.env.CURL_RUNNER_DIFF_DIR) {
+      envConfig.diff = {
+        ...envConfig.diff,
+        dir: process.env.CURL_RUNNER_DIFF_DIR,
+      };
+    }
+
+    if (process.env.CURL_RUNNER_DIFF_OUTPUT) {
+      const format = process.env.CURL_RUNNER_DIFF_OUTPUT.toLowerCase();
+      if (['terminal', 'json', 'markdown'].includes(format)) {
+        envConfig.diff = {
+          ...envConfig.diff,
+          outputFormat: format as 'terminal' | 'json' | 'markdown',
+        };
+      }
+    }
+
     return envConfig;
   }
 
@@ -223,6 +318,12 @@ class CurlRunnerCLI {
         return;
       }
 
+      // Handle diff subcommand: curl-runner diff <label1> <label2> [file]
+      if (args[0] === 'diff' && args.length >= 3) {
+        await this.executeDiffSubcommand(args.slice(1), options);
+        return;
+      }
+
       // Load configuration from environment variables, config file, then CLI options
       const envConfig = this.loadEnvironmentVariables();
       const configFile = await this.loadConfigFile();
@@ -370,6 +471,46 @@ class CurlRunnerCLI {
         };
       }
 
+      // Apply diff options
+      if (options.diff !== undefined) {
+        globalConfig.diff = {
+          ...globalConfig.diff,
+          enabled: options.diff as boolean,
+        };
+      }
+      if (options.diffSave !== undefined) {
+        globalConfig.diff = {
+          ...globalConfig.diff,
+          enabled: true,
+          save: options.diffSave as boolean,
+        };
+      }
+      if (options.diffLabel !== undefined) {
+        globalConfig.diff = {
+          ...globalConfig.diff,
+          label: options.diffLabel as string,
+        };
+      }
+      if (options.diffCompare !== undefined) {
+        globalConfig.diff = {
+          ...globalConfig.diff,
+          enabled: true,
+          compareWith: options.diffCompare as string,
+        };
+      }
+      if (options.diffDir !== undefined) {
+        globalConfig.diff = {
+          ...globalConfig.diff,
+          dir: options.diffDir as string,
+        };
+      }
+      if (options.diffOutput !== undefined) {
+        globalConfig.diff = {
+          ...globalConfig.diff,
+          outputFormat: options.diffOutput as 'terminal' | 'json' | 'markdown',
+        };
+      }
+
       if (allRequests.length === 0) {
         this.logger.logError('No requests found in YAML files');
         process.exit(1);
@@ -378,7 +519,36 @@ class CurlRunnerCLI {
       // Check if watch mode is enabled
       const watchEnabled = options.watch || globalConfig.watch?.enabled;
 
-      if (watchEnabled) {
+      // Check if profile mode is enabled (mutually exclusive with watch mode)
+      const profileIterations =
+        (options.profile as number | undefined) ?? globalConfig.profile?.iterations;
+      const profileEnabled = profileIterations && profileIterations > 0;
+
+      if (watchEnabled && profileEnabled) {
+        this.logger.logError('Profile mode and watch mode cannot be used together');
+        process.exit(1);
+      }
+
+      if (profileEnabled) {
+        // Profile mode - run requests multiple times for latency stats
+        const profileConfig: ProfileConfig = {
+          iterations: profileIterations,
+          warmup:
+            (options.profileWarmup as number | undefined) ?? globalConfig.profile?.warmup ?? 1,
+          concurrency:
+            (options.profileConcurrency as number | undefined) ??
+            globalConfig.profile?.concurrency ??
+            1,
+          histogram:
+            (options.profileHistogram as boolean | undefined) ??
+            globalConfig.profile?.histogram ??
+            false,
+          exportFile:
+            (options.profileExport as string | undefined) ?? globalConfig.profile?.exportFile,
+        };
+
+        await this.executeProfileMode(allRequests, globalConfig, profileConfig);
+      } else if (watchEnabled) {
         // Build watch config from options and global config
         const watchConfig: WatchConfig = {
           enabled: true,
@@ -409,6 +579,49 @@ class CurlRunnerCLI {
     }
   }
 
+  private async executeProfileMode(
+    requests: RequestConfig[],
+    globalConfig: GlobalConfig,
+    profileConfig: ProfileConfig,
+  ): Promise<void> {
+    const profileExecutor = new ProfileExecutor(globalConfig, profileConfig);
+    const results = await profileExecutor.profileRequests(requests);
+
+    this.logger.logProfileSummary(results);
+
+    // Export results if requested
+    if (profileConfig.exportFile) {
+      const exportData: string[] = [];
+      const isCSV = profileConfig.exportFile.endsWith('.csv');
+
+      for (const result of results) {
+        const name = result.request.name || result.request.url;
+        if (isCSV) {
+          exportData.push(exportToCSV(result.stats, name));
+        } else {
+          exportData.push(exportToJSON(result.stats, name));
+        }
+      }
+
+      const content = isCSV ? exportData.join('\n\n') : `[${exportData.join(',\n')}]`;
+      await Bun.write(profileConfig.exportFile, content);
+      this.logger.logInfo(`Profile results exported to ${profileConfig.exportFile}`);
+    }
+
+    // Exit with code 1 if failure rate is high
+    const totalFailures = results.reduce((sum, r) => sum + r.stats.failures, 0);
+    const totalIterations = results.reduce(
+      (sum, r) => sum + r.stats.iterations + r.stats.warmup,
+      0,
+    );
+
+    if (totalFailures > 0 && totalFailures / totalIterations > 0.5) {
+      process.exit(1);
+    }
+
+    process.exit(0);
+  }
+
   private async executeRequests(
     yamlFiles: string[],
     globalConfig: GlobalConfig,
@@ -475,9 +688,138 @@ class CurlRunnerCLI {
       summary = await executor.execute(allRequests);
     }
 
+    // Handle diff mode
+    if (globalConfig.diff?.enabled || globalConfig.diff?.save || globalConfig.diff?.compareWith) {
+      await this.handleDiffMode(yamlFiles[0], summary.results, globalConfig.diff);
+    }
+
     return summary;
   }
 
+  private async handleDiffMode(
+    yamlPath: string,
+    results: ExecutionResult[],
+    diffConfig: GlobalDiffConfig,
+  ): Promise<void> {
+    const orchestrator = new DiffOrchestrator(diffConfig);
+    const formatter = new DiffFormatter(diffConfig.outputFormat || 'terminal');
+    const config: DiffConfig = BaselineManager.mergeConfig(diffConfig, true) || {};
+
+    const currentLabel = diffConfig.label || 'current';
+    const compareLabel = diffConfig.compareWith;
+
+    // Save baseline if requested
+    if (diffConfig.save) {
+      await orchestrator.saveBaseline(yamlPath, currentLabel, results, config);
+      this.logger.logInfo(`Baseline saved as '${currentLabel}'`);
+    }
+
+    // Compare with baseline if requested
+    if (compareLabel) {
+      const diffSummary = await orchestrator.compareWithBaseline(
+        yamlPath,
+        results,
+        currentLabel,
+        compareLabel,
+        config,
+      );
+
+      // Check if baseline exists
+      if (diffSummary.newBaselines === diffSummary.totalRequests) {
+        this.logger.logWarning(
+          `No baseline '${compareLabel}' found. Saving current run as baseline.`,
+        );
+        await orchestrator.saveBaseline(yamlPath, compareLabel, results, config);
+        return;
+      }
+
+      const output = formatter.formatSummary(diffSummary, compareLabel, currentLabel);
+      console.log(output);
+
+      // Save current as baseline if configured
+      if (diffConfig.save) {
+        await orchestrator.saveBaseline(yamlPath, currentLabel, results, config);
+      }
+    } else if (diffConfig.enabled && !diffConfig.save) {
+      // Auto-detect: list available baselines or save first baseline
+      const labels = await orchestrator.listLabels(yamlPath);
+
+      if (labels.length === 0) {
+        // No baselines exist - save current as default baseline
+        await orchestrator.saveBaseline(yamlPath, 'baseline', results, config);
+        this.logger.logInfo(`No baselines found. Saved current run as 'baseline'.`);
+      } else if (labels.length === 1) {
+        // One baseline exists - compare against it
+        const diffSummary = await orchestrator.compareWithBaseline(
+          yamlPath,
+          results,
+          currentLabel,
+          labels[0],
+          config,
+        );
+        const output = formatter.formatSummary(diffSummary, labels[0], currentLabel);
+        console.log(output);
+      } else {
+        // Multiple baselines - list them
+        this.logger.logInfo(`Available baselines: ${labels.join(', ')}`);
+        this.logger.logInfo(`Use --diff-compare <label> to compare against a specific baseline.`);
+      }
+    }
+  }
+
+  /**
+   * Executes the diff subcommand to compare two stored baselines.
+   * Usage: curl-runner diff <label1> <label2> [file.yaml]
+   */
+  private async executeDiffSubcommand(
+    args: string[],
+    options: Record<string, unknown>,
+  ): Promise<void> {
+    const label1 = args[0];
+    const label2 = args[1];
+    let yamlFile = args[2];
+
+    // Find YAML file if not specified
+    if (!yamlFile) {
+      const yamlFiles = await this.findYamlFiles([], options);
+      if (yamlFiles.length === 0) {
+        this.logger.logError(
+          'No YAML files found. Specify a file: curl-runner diff <label1> <label2> <file.yaml>',
+        );
+        process.exit(1);
+      }
+      if (yamlFiles.length > 1) {
+        this.logger.logError('Multiple YAML files found. Specify which file to use.');
+        process.exit(1);
+      }
+      yamlFile = yamlFiles[0];
+    }
+
+    const diffConfig: GlobalDiffConfig = {
+      dir: (options.diffDir as string) || '__baselines__',
+      outputFormat: (options.diffOutput as 'terminal' | 'json' | 'markdown') || 'terminal',
+    };
+
+    const orchestrator = new DiffOrchestrator(diffConfig);
+    const formatter = new DiffFormatter(diffConfig.outputFormat || 'terminal');
+    const config: DiffConfig = { exclude: [], match: {} };
+
+    try {
+      const diffSummary = await orchestrator.compareTwoBaselines(yamlFile, label1, label2, config);
+      const output = formatter.formatSummary(diffSummary, label1, label2);
+      console.log(output);
+
+      // Exit with code 1 if differences found
+      if (diffSummary.changed > 0) {
+        process.exit(1);
+      }
+      process.exit(0);
+    } catch (error) {
+      this.logger.logError(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  }
+
   private parseArguments(args: string[]): { files: string[]; options: Record<string, unknown> } {
     const options: Record<string, unknown> = {};
     const files: string[] = [];
@@ -509,6 +851,8 @@ class CurlRunnerCLI {
           options.watchClear = true;
         } else if (key === 'no-watch-clear') {
           options.watchClear = false;
+        } else if (key === 'profile-histogram') {
+          options.profileHistogram = true;
         } else if (key === 'snapshot') {
           options.snapshot = true;
         } else if (key === 'update-snapshots') {
@@ -517,6 +861,10 @@ class CurlRunnerCLI {
           options.snapshotUpdate = 'failing';
         } else if (key === 'ci-snapshot') {
           options.snapshotCi = true;
+        } else if (key === 'diff') {
+          options.diff = true;
+        } else if (key === 'diff-save') {
+          options.diffSave = true;
         } else if (nextArg && !nextArg.startsWith('--')) {
           if (key === 'continue-on-error') {
             options.continueOnError = nextArg === 'true';
@@ -550,8 +898,26 @@ class CurlRunnerCLI {
             }
           } else if (key === 'watch-debounce') {
             options.watchDebounce = Number.parseInt(nextArg, 10);
+          } else if (key === 'profile') {
+            options.profile = Number.parseInt(nextArg, 10);
+          } else if (key === 'profile-warmup') {
+            options.profileWarmup = Number.parseInt(nextArg, 10);
+          } else if (key === 'profile-concurrency') {
+            options.profileConcurrency = Number.parseInt(nextArg, 10);
+          } else if (key === 'profile-export') {
+            options.profileExport = nextArg;
           } else if (key === 'snapshot-dir') {
             options.snapshotDir = nextArg;
+          } else if (key === 'diff-label') {
+            options.diffLabel = nextArg;
+          } else if (key === 'diff-compare') {
+            options.diffCompare = nextArg;
+          } else if (key === 'diff-dir') {
+            options.diffDir = nextArg;
+          } else if (key === 'diff-output') {
+            if (['terminal', 'json', 'markdown'].includes(nextArg)) {
+              options.diffOutput = nextArg;
+            }
           } else {
             options[key] = nextArg;
           }
@@ -587,6 +953,9 @@ class CurlRunnerCLI {
             case 'u':
               options.snapshotUpdate = 'all';
               break;
+            case 'd':
+              options.diff = true;
+              break;
             case 'o': {
               // Handle -o flag for output file
               const outputArg = args[i + 1];
@@ -596,6 +965,15 @@ class CurlRunnerCLI {
               }
               break;
             }
+            case 'P': {
+              // Handle -P flag for profile mode
+              const profileArg = args[i + 1];
+              if (profileArg && !profileArg.startsWith('-')) {
+                options.profile = Number.parseInt(profileArg, 10);
+                i++;
+              }
+              break;
+            }
           }
         }
       } else {
@@ -717,6 +1095,7 @@ class CurlRunnerCLI {
       ci: { ...base.ci, ...override.ci },
       watch: { ...base.watch, ...override.watch },
       snapshot: { ...base.snapshot, ...override.snapshot },
+      diff: { ...base.diff, ...override.diff },
     };
   }
 
@@ -804,6 +1183,13 @@ ${this.logger.color('WATCH MODE:', 'yellow')}
   --watch-debounce <ms>         Debounce delay for watch mode (default: 300)
   --no-watch-clear              Don't clear screen between watch runs
 
+${this.logger.color('PROFILE MODE:', 'yellow')}
+  -P, --profile <n>             Run each request N times for latency stats
+  --profile-warmup <n>          Warmup iterations to exclude from stats (default: 1)
+  --profile-concurrency <n>     Concurrent iterations (default: 1 = sequential)
+  --profile-histogram           Show ASCII histogram of latency distribution
+  --profile-export <file>       Export raw timings to file (.json or .csv)
+
 ${this.logger.color('CI/CD OPTIONS:', 'yellow')}
   --strict-exit                 Exit with code 1 if any validation fails (for CI/CD)
   --fail-on <count>             Exit with code 1 if failures exceed this count
@@ -816,6 +1202,18 @@ ${this.logger.color('SNAPSHOT OPTIONS:', 'yellow')}
   --snapshot-dir <dir>          Custom snapshot directory (default: __snapshots__)
   --ci-snapshot                 Fail if snapshot is missing (CI mode)
 
+${this.logger.color('DIFF OPTIONS:', 'yellow')}
+  -d, --diff                    Enable response diffing (compare with baseline)
+  --diff-save                   Save current run as baseline
+  --diff-label <name>           Label for current run (e.g., 'staging', 'v1.0')
+  --diff-compare <label>        Compare against this baseline label
+  --diff-dir <dir>              Baseline storage directory (default: __baselines__)
+  --diff-output <format>        Output format (terminal|json|markdown)
+
+${this.logger.color('DIFF SUBCOMMAND:', 'yellow')}
+  curl-runner diff <label1> <label2> [file.yaml]
+                                Compare two stored baselines without making requests
+
 ${this.logger.color('EXAMPLES:', 'yellow')}
   # Run all YAML files in current directory
   curl-runner
@@ -865,6 +1263,15 @@ ${this.logger.color('EXAMPLES:', 'yellow')}
   # Watch with custom debounce
   curl-runner tests/ -w --watch-debounce 500
 
+  # Profile mode - run request 100 times for latency stats
+  curl-runner api.yaml -P 100
+
+  # Profile with 5 warmup iterations and histogram
+  curl-runner api.yaml --profile 50 --profile-warmup 5 --profile-histogram
+
+  # Profile with concurrent iterations and export
+  curl-runner api.yaml -P 100 --profile-concurrency 10 --profile-export results.json
+
   # Snapshot testing - save and compare responses
   curl-runner api.yaml --snapshot
 
@@ -874,6 +1281,21 @@ ${this.logger.color('EXAMPLES:', 'yellow')}
   # CI mode - fail if snapshot missing
   curl-runner api.yaml --snapshot --ci-snapshot
 
+  # Response diffing - save baseline for staging
+  curl-runner api.yaml --diff-save --diff-label staging
+
+  # Compare current run against staging baseline
+  curl-runner api.yaml --diff --diff-compare staging
+
+  # Compare staging vs production baselines (offline)
+  curl-runner diff staging production api.yaml
+
+  # Auto-diff: creates baseline on first run, compares on subsequent runs
+  curl-runner api.yaml --diff
+
+  # Diff with JSON output for CI
+  curl-runner api.yaml --diff --diff-compare staging --diff-output json
+
 ${this.logger.color('YAML STRUCTURE:', 'yellow')}
   Single request:
     request: