@vizzly-testing/cli 0.16.4 → 0.18.0

package/README.md

@@ -227,7 +227,7 @@ vizzly run "npm test" --parallel-id "ci-run-123"  # For parallel CI builds
 
 **Processing Options:**
 - `--wait` - Wait for build completion and exit with appropriate code
-- `--threshold <number>` - Comparison threshold (0-1, default: 0.01)
+- `--threshold <number>` - Comparison threshold (CIEDE2000 Delta E, default: 2.0)
 - `--upload-timeout <ms>` - Upload wait timeout in ms
 - `--upload-all` - Upload all screenshots without SHA deduplication
 
@@ -279,7 +279,7 @@ vizzly dev stop
 **Dev Command Options:**
 - `--set-baseline` - Accept current screenshots as new baseline
 - `--baseline-build <id>` - Use specific build as baseline (requires API token)
-- `--threshold <number>` - Comparison threshold (0-1, default: 0.1)
+- `--threshold <number>` - Comparison threshold (CIEDE2000 Delta E, default: 2.0)
 - `--port <port>` - Server port (default: 47392)
 - `--timeout <ms>` - Server timeout (default: 30000)
 - `--open` - Auto-open dashboard in browser (start command only)
@@ -357,9 +357,9 @@ export default {
     timeout: 30000
   },
 
-  // Comparison configuration
+  // Comparison configuration (CIEDE2000 Delta E: 0=exact, 1=JND, 2=recommended)
   comparison: {
-    threshold: 0.1,
+    threshold: 2.0,
     ignoreAntialiasing: true
   },
 

package/claude-plugin/skills/debug-visual-regression/SKILL.md

@@ -118,7 +118,7 @@ Response:
   "name": "homepage",
   "status": "failed",
   "diffPercentage": 2.3,
-  "threshold": 0.1,
+  "threshold": 2.0,
   "mode": "local",
   "baselinePath": "/Users/you/project/.vizzly/baselines/homepage.png",
   "currentPath": "/Users/you/project/.vizzly/screenshots/homepage.png"
@@ -170,7 +170,7 @@ Response:
   "name": "login-page",
   "status": "failed",
   "diffPercentage": 0.8,
-  "threshold": 0.1,
+  "threshold": 2.0,
   "mode": "cloud",
   "baselineUrl": "https://app.vizzly.dev/screenshots/abc123/baseline.png",
   "currentUrl": "https://app.vizzly.dev/screenshots/abc123/current.png",

package/dist/cli.js

@@ -1,29 +1,30 @@
 #!/usr/bin/env node
 import 'dotenv/config';
 import { program } from 'commander';
-import { init } from './commands/init.js';
-import { uploadCommand, validateUploadOptions } from './commands/upload.js';
-import { runCommand, validateRunOptions } from './commands/run.js';
-import { tddCommand, validateTddOptions } from './commands/tdd.js';
-import { tddStartCommand, tddStopCommand, tddStatusCommand, runDaemonChild } from './commands/tdd-daemon.js';
-import { statusCommand, validateStatusOptions } from './commands/status.js';
-import { finalizeCommand, validateFinalizeOptions } from './commands/finalize.js';
 import { doctorCommand, validateDoctorOptions } from './commands/doctor.js';
+import { finalizeCommand, validateFinalizeOptions } from './commands/finalize.js';
+import { init } from './commands/init.js';
 import { loginCommand, validateLoginOptions } from './commands/login.js';
 import { logoutCommand, validateLogoutOptions } from './commands/logout.js';
-import { whoamiCommand, validateWhoamiOptions } from './commands/whoami.js';
-import { projectSelectCommand, projectListCommand, projectTokenCommand, projectRemoveCommand, validateProjectOptions } from './commands/project.js';
-import { getPackageVersion } from './utils/package-info.js';
+import { projectListCommand, projectRemoveCommand, projectSelectCommand, projectTokenCommand, validateProjectOptions } from './commands/project.js';
+import { runCommand, validateRunOptions } from './commands/run.js';
+import { statusCommand, validateStatusOptions } from './commands/status.js';
+import { tddCommand, validateTddOptions } from './commands/tdd.js';
+import { runDaemonChild, tddStartCommand, tddStatusCommand, tddStopCommand } from './commands/tdd-daemon.js';
+import { uploadCommand, validateUploadOptions } from './commands/upload.js';
+import { validateWhoamiOptions, whoamiCommand } from './commands/whoami.js';
 import { loadPlugins } from './plugin-loader.js';
-import { loadConfig } from './utils/config-loader.js';
 import { createServices } from './services/index.js';
+import { loadConfig } from './utils/config-loader.js';
 import * as output from './utils/output.js';
-program.name('vizzly').description('Vizzly CLI for visual regression testing').version(getPackageVersion()).option('-c, --config <path>', 'Config file path').option('--token <token>', 'Vizzly API token').option('-v, --verbose', 'Verbose output').option('--json', 'Machine-readable output').option('--no-color', 'Disable colored output');
+import { getPackageVersion } from './utils/package-info.js';
+program.name('vizzly').description('Vizzly CLI for visual regression testing').version(getPackageVersion()).option('-c, --config <path>', 'Config file path').option('--token <token>', 'Vizzly API token').option('-v, --verbose', 'Verbose output (shorthand for --log-level debug)').option('--log-level <level>', 'Log level: debug, info, warn, error (default: info, or VIZZLY_LOG_LEVEL env var)').option('--json', 'Machine-readable output').option('--no-color', 'Disable colored output');
 
 // Load plugins before defining commands
 // We need to manually parse to get the config option early
 let configPath = null;
 let verboseMode = false;
+let logLevelArg = null;
 for (let i = 0; i < process.argv.length; i++) {
   if ((process.argv[i] === '-c' || process.argv[i] === '--config') && process.argv[i + 1]) {
     configPath = process.argv[i + 1];
@@ -31,30 +32,35 @@ for (let i = 0; i < process.argv.length; i++) {
   if (process.argv[i] === '-v' || process.argv[i] === '--verbose') {
     verboseMode = true;
   }
+  if (process.argv[i] === '--log-level' && process.argv[i + 1]) {
+    logLevelArg = process.argv[i + 1];
+  }
 }
 
 // Configure output early
+// Priority: --log-level > --verbose > VIZZLY_LOG_LEVEL env var > default ('info')
 output.configure({
+  logLevel: logLevelArg,
   verbose: verboseMode,
   color: !process.argv.includes('--no-color'),
   json: process.argv.includes('--json')
 });
-let config = await loadConfig(configPath, {});
-let services = createServices(config);
+const config = await loadConfig(configPath, {});
+const services = createServices(config);
 let plugins = [];
 try {
   plugins = await loadPlugins(configPath, config);
-  for (let plugin of plugins) {
+  for (const plugin of plugins) {
     try {
       // Add timeout protection for plugin registration (5 seconds)
-      let registerPromise = plugin.register(program, {
+      const registerPromise = plugin.register(program, {
         config,
         services,
         output,
         // Backwards compatibility alias for plugins using old API
         logger: output
       });
-      let timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Plugin registration timeout (5s)')), 5000));
+      const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Plugin registration timeout (5s)')), 5000));
       await Promise.race([registerPromise, timeoutPromise]);
       output.debug(`Registered plugin: ${plugin.name}`);
     } catch (error) {
@@ -65,7 +71,7 @@ try {
   output.debug(`Plugin loading failed: ${error.message}`);
 }
 program.command('init').description('Initialize Vizzly in your project').option('--force', 'Overwrite existing configuration').action(async options => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
   await init({
     ...globalOptions,
     ...options,
@@ -73,24 +79,26 @@ program.command('init').description('Initialize Vizzly in your project').option(
   });
 });
 program.command('upload').description('Upload screenshots to Vizzly').argument('<path>', 'Path to screenshots directory or file').option('-b, --build-name <name>', 'Build name for grouping').option('-m, --metadata <json>', 'Additional metadata as JSON').option('--batch-size <n>', 'Upload batch size', v => parseInt(v, 10)).option('--upload-timeout <ms>', 'Upload timeout in milliseconds', v => parseInt(v, 10)).option('--branch <branch>', 'Git branch').option('--commit <sha>', 'Git commit SHA').option('--message <msg>', 'Commit message').option('--environment <env>', 'Environment name', 'test').option('--threshold <number>', 'Comparison threshold', parseFloat).option('--token <token>', 'API token override').option('--wait', 'Wait for build completion').option('--upload-all', 'Upload all screenshots without SHA deduplication').option('--parallel-id <id>', 'Unique identifier for parallel test execution').action(async (path, options) => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
 
   // Validate options
-  let validationErrors = validateUploadOptions(path, options);
+  const validationErrors = validateUploadOptions(path, options);
   if (validationErrors.length > 0) {
     output.error('Validation errors:');
-    validationErrors.forEach(error => output.printErr(`  - ${error}`));
+    for (let error of validationErrors) {
+      output.printErr(`  - ${error}`);
+    }
     process.exit(1);
   }
   await uploadCommand(path, options, globalOptions);
 });
 
 // TDD command with subcommands - Local visual testing with interactive dashboard
-let tddCmd = program.command('tdd').description('Run tests in TDD mode with local visual comparisons');
+const tddCmd = program.command('tdd').description('Run tests in TDD mode with local visual comparisons');
 
 // TDD Start - Background server
 tddCmd.command('start').description('Start background TDD server with dashboard').option('--port <port>', 'Port for TDD server', '47392').option('--open', 'Open dashboard in browser').option('--baseline-build <id>', 'Use specific build as baseline').option('--baseline-comparison <id>', 'Use specific comparison as baseline').option('--environment <env>', 'Environment name', 'test').option('--threshold <number>', 'Comparison threshold', parseFloat).option('--timeout <ms>', 'Server timeout in milliseconds', '30000').option('--token <token>', 'API token override').option('--daemon-child', 'Internal: run as daemon child process').action(async options => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
 
   // If this is a daemon child process, run the server directly
   if (options.daemonChild) {
@@ -102,34 +110,36 @@ tddCmd.command('start').description('Start background TDD server with dashboard'
 
 // TDD Stop - Kill background server
 tddCmd.command('stop').description('Stop background TDD server').action(async options => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
   await tddStopCommand(options, globalOptions);
 });
 
 // TDD Status - Check server status
 tddCmd.command('status').description('Check TDD server status').action(async options => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
   await tddStatusCommand(options, globalOptions);
 });
 
 // TDD Run - One-off test run with ephemeral server (generates static report)
 tddCmd.command('run <command>').description('Run tests once in TDD mode with local visual comparisons').option('--port <port>', 'Port for TDD server', '47392').option('--branch <branch>', 'Git branch override').option('--environment <env>', 'Environment name', 'test').option('--threshold <number>', 'Comparison threshold', parseFloat).option('--token <token>', 'API token override').option('--timeout <ms>', 'Server timeout in milliseconds', '30000').option('--baseline-build <id>', 'Use specific build as baseline').option('--baseline-comparison <id>', 'Use specific comparison as baseline').option('--set-baseline', 'Accept current screenshots as new baseline (overwrites existing)').action(async (command, options) => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
 
   // Validate options
-  let validationErrors = validateTddOptions(command, options);
+  const validationErrors = validateTddOptions(command, options);
   if (validationErrors.length > 0) {
     output.error('Validation errors:');
-    validationErrors.forEach(error => output.printErr(`  - ${error}`));
+    for (let error of validationErrors) {
+      output.printErr(`  - ${error}`);
+    }
     process.exit(1);
   }
-  let {
+  const {
     result,
     cleanup
   } = await tddCommand(command, options, globalOptions);
 
   // Set up cleanup on process signals
-  let handleCleanup = async () => {
+  const handleCleanup = async () => {
     await cleanup();
   };
   process.once('SIGINT', () => {
@@ -145,17 +155,19 @@ tddCmd.command('run <command>').description('Run tests once in TDD mode with loc
   await cleanup();
 });
 program.command('run').description('Run tests with Vizzly integration').argument('<command>', 'Test command to run').option('--port <port>', 'Port for screenshot server', '47392').option('-b, --build-name <name>', 'Custom build name').option('--branch <branch>', 'Git branch override').option('--commit <sha>', 'Git commit SHA').option('--message <msg>', 'Commit message').option('--environment <env>', 'Environment name', 'test').option('--token <token>', 'API token override').option('--wait', 'Wait for build completion').option('--timeout <ms>', 'Server timeout in milliseconds', '30000').option('--allow-no-token', 'Allow running without API token').option('--upload-all', 'Upload all screenshots without SHA deduplication').option('--parallel-id <id>', 'Unique identifier for parallel test execution').action(async (command, options) => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
 
   // Validate options
-  let validationErrors = validateRunOptions(command, options);
+  const validationErrors = validateRunOptions(command, options);
   if (validationErrors.length > 0) {
     output.error('Validation errors:');
-    validationErrors.forEach(error => output.printErr(`  - ${error}`));
+    for (let error of validationErrors) {
+      output.printErr(`  - ${error}`);
+    }
     process.exit(1);
   }
   try {
-    let result = await runCommand(command, options, globalOptions);
+    const result = await runCommand(command, options, globalOptions);
     if (result && !result.success && result.exitCode > 0) {
       process.exit(result.exitCode);
     }
@@ -165,99 +177,113 @@ program.command('run').description('Run tests with Vizzly integration').argument
   }
 });
 program.command('status').description('Check the status of a build').argument('<build-id>', 'Build ID to check status for').action(async (buildId, options) => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
 
   // Validate options
-  let validationErrors = validateStatusOptions(buildId, options);
+  const validationErrors = validateStatusOptions(buildId, options);
   if (validationErrors.length > 0) {
     output.error('Validation errors:');
-    validationErrors.forEach(error => output.printErr(`  - ${error}`));
+    for (let error of validationErrors) {
+      output.printErr(`  - ${error}`);
+    }
     process.exit(1);
   }
   await statusCommand(buildId, options, globalOptions);
 });
 program.command('finalize').description('Finalize a parallel build after all shards complete').argument('<parallel-id>', 'Parallel ID to finalize').action(async (parallelId, options) => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
 
   // Validate options
-  let validationErrors = validateFinalizeOptions(parallelId, options);
+  const validationErrors = validateFinalizeOptions(parallelId, options);
   if (validationErrors.length > 0) {
     output.error('Validation errors:');
-    validationErrors.forEach(error => output.printErr(`  - ${error}`));
+    for (let error of validationErrors) {
+      output.printErr(`  - ${error}`);
+    }
     process.exit(1);
   }
   await finalizeCommand(parallelId, options, globalOptions);
 });
 program.command('doctor').description('Run diagnostics to check your environment and configuration').option('--api', 'Include API connectivity checks').action(async options => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
 
   // Validate options
-  let validationErrors = validateDoctorOptions(options);
+  const validationErrors = validateDoctorOptions(options);
   if (validationErrors.length > 0) {
     output.error('Validation errors:');
-    validationErrors.forEach(error => output.printErr(`  - ${error}`));
+    for (let error of validationErrors) {
+      output.printErr(`  - ${error}`);
+    }
     process.exit(1);
   }
   await doctorCommand(options, globalOptions);
 });
 program.command('login').description('Authenticate with your Vizzly account').option('--api-url <url>', 'API URL override').action(async options => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
 
   // Validate options
-  let validationErrors = validateLoginOptions(options);
+  const validationErrors = validateLoginOptions(options);
   if (validationErrors.length > 0) {
     output.error('Validation errors:');
-    validationErrors.forEach(error => output.printErr(`  - ${error}`));
+    for (let error of validationErrors) {
+      output.printErr(`  - ${error}`);
+    }
     process.exit(1);
   }
   await loginCommand(options, globalOptions);
 });
 program.command('logout').description('Clear stored authentication tokens').option('--api-url <url>', 'API URL override').action(async options => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
 
   // Validate options
-  let validationErrors = validateLogoutOptions(options);
+  const validationErrors = validateLogoutOptions(options);
   if (validationErrors.length > 0) {
     output.error('Validation errors:');
-    validationErrors.forEach(error => output.printErr(`  - ${error}`));
+    for (let error of validationErrors) {
+      output.printErr(`  - ${error}`);
+    }
     process.exit(1);
   }
   await logoutCommand(options, globalOptions);
 });
 program.command('whoami').description('Show current authentication status and user information').option('--api-url <url>', 'API URL override').action(async options => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
 
   // Validate options
-  let validationErrors = validateWhoamiOptions(options);
+  const validationErrors = validateWhoamiOptions(options);
   if (validationErrors.length > 0) {
     output.error('Validation errors:');
-    validationErrors.forEach(error => output.printErr(`  - ${error}`));
+    for (let error of validationErrors) {
+      output.printErr(`  - ${error}`);
+    }
     process.exit(1);
   }
   await whoamiCommand(options, globalOptions);
 });
 program.command('project:select').description('Configure project for current directory').option('--api-url <url>', 'API URL override').action(async options => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
 
   // Validate options
-  let validationErrors = validateProjectOptions(options);
+  const validationErrors = validateProjectOptions(options);
   if (validationErrors.length > 0) {
     output.error('Validation errors:');
-    validationErrors.forEach(error => output.printErr(`  - ${error}`));
+    for (let error of validationErrors) {
+      output.printErr(`  - ${error}`);
+    }
     process.exit(1);
   }
   await projectSelectCommand(options, globalOptions);
 });
 program.command('project:list').description('Show all configured projects').action(async options => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
   await projectListCommand(options, globalOptions);
 });
 program.command('project:token').description('Show project token for current directory').action(async options => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
   await projectTokenCommand(options, globalOptions);
 });
 program.command('project:remove').description('Remove project configuration for current directory').action(async options => {
-  let globalOptions = program.opts();
+  const globalOptions = program.opts();
   await projectRemoveCommand(options, globalOptions);
 });
 program.parse();

package/dist/client/index.js

@@ -3,9 +3,9 @@
  * @description Thin client for test runners - minimal API for taking screenshots
  */
 
-import { getServerUrl, getBuildId, isTddMode, setVizzlyEnabled } from '../utils/environment-config.js';
-import { existsSync, readFileSync } from 'fs';
-import { join, parse, dirname } from 'path';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, parse } from 'node:path';
+import { getBuildId, getServerUrl, isTddMode, setVizzlyEnabled } from '../utils/environment-config.js';
 
 // Internal client state
 let currentClient = null;
@@ -104,12 +104,12 @@ function getClient() {
 function createSimpleClient(serverUrl) {
   return {
     async screenshot(name, imageBuffer, options = {}) {
-      let controller = new AbortController();
-      let timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
       try {
         // If it's a string, assume it's a file path and send directly
         // Otherwise it's a Buffer, so convert to base64
-        let image = typeof imageBuffer === 'string' ? imageBuffer : imageBuffer.toString('base64');
+        const image = typeof imageBuffer === 'string' ? imageBuffer : imageBuffer.toString('base64');
         const response = await fetch(`${serverUrl}/screenshot`, {
           method: 'POST',
           headers: {

package/dist/commands/doctor.js

@@ -1,9 +1,9 @@
-import { URL } from 'url';
-import { loadConfig } from '../utils/config-loader.js';
-import * as output from '../utils/output.js';
-import { ApiService } from '../services/api-service.js';
+import { URL } from 'node:url';
 import { ConfigError } from '../errors/vizzly-error.js';
+import { ApiService } from '../services/api-service.js';
+import { loadConfig } from '../utils/config-loader.js';
 import { getApiToken } from '../utils/environment-config.js';
+import * as output from '../utils/output.js';
 
 /**
  * Doctor command implementation - Run diagnostics to check environment
@@ -16,7 +16,7 @@ export async function doctorCommand(options = {}, globalOptions = {}) {
     verbose: globalOptions.verbose,
     color: !globalOptions.noColor
   });
-  let diagnostics = {
+  const diagnostics = {
     environment: {
       nodeVersion: null,
       nodeVersionValid: null
@@ -37,14 +37,14 @@ export async function doctorCommand(options = {}, globalOptions = {}) {
   let hasErrors = false;
   try {
     // Determine if we'll attempt remote checks (API connectivity)
-    let willCheckConnectivity = Boolean(options.api || getApiToken());
+    const willCheckConnectivity = Boolean(options.api || getApiToken());
 
     // Announce preflight, indicating local-only when no token/connectivity is planned
     output.info(`Running Vizzly preflight${willCheckConnectivity ? '' : ' (local checks only)'}...`);
 
     // Node.js version check (require >= 20)
-    let nodeVersion = process.version;
-    let nodeMajor = parseInt(nodeVersion.slice(1).split('.')[0], 10);
+    const nodeVersion = process.version;
+    const nodeMajor = parseInt(nodeVersion.slice(1).split('.')[0], 10);
     diagnostics.environment.nodeVersion = nodeVersion;
     diagnostics.environment.nodeVersionValid = nodeMajor >= 20;
     if (nodeMajor >= 20) {
@@ -55,12 +55,12 @@ export async function doctorCommand(options = {}, globalOptions = {}) {
     }
 
     // Load configuration (apply global CLI overrides like --config only)
-    let config = await loadConfig(globalOptions.config);
+    const config = await loadConfig(globalOptions.config);
 
     // Validate apiUrl
     diagnostics.configuration.apiUrl = config.apiUrl;
     try {
-      let url = new URL(config.apiUrl);
+      const url = new URL(config.apiUrl);
       if (!['http:', 'https:'].includes(url.protocol)) {
         throw new ConfigError('URL must use http or https');
       }
@@ -73,24 +73,25 @@ export async function doctorCommand(options = {}, globalOptions = {}) {
     }
 
     // Validate threshold (0..1 inclusive)
-    let threshold = Number(config?.comparison?.threshold);
+    const threshold = Number(config?.comparison?.threshold);
     diagnostics.configuration.threshold = threshold;
-    let thresholdValid = Number.isFinite(threshold) && threshold >= 0 && threshold <= 1;
+    // CIEDE2000 threshold: 0 = exact, 1 = JND, 2 = recommended, 3+ = permissive
+    const thresholdValid = Number.isFinite(threshold) && threshold >= 0;
     diagnostics.configuration.thresholdValid = thresholdValid;
     if (thresholdValid) {
-      output.success(`Threshold: ${threshold}`);
+      output.success(`Threshold: ${threshold} (CIEDE2000 Delta E)`);
     } else {
       hasErrors = true;
-      output.error('Invalid threshold (expected number between 0 and 1)');
+      output.error('Invalid threshold (expected non-negative number)');
     }
 
     // Report effective port without binding
-    let port = config?.server?.port ?? 47392;
+    const port = config?.server?.port ?? 47392;
     diagnostics.configuration.port = port;
     output.info(`Effective port: ${port}`);
 
     // Optional: API connectivity check when --api is provided or VIZZLY_TOKEN is present
-    let autoApi = Boolean(getApiToken());
+    const autoApi = Boolean(getApiToken());
     if (options.api || autoApi) {
       diagnostics.connectivity.checked = true;
       if (!config.apiKey) {
@@ -101,7 +102,7 @@ export async function doctorCommand(options = {}, globalOptions = {}) {
       } else {
         output.progress('Checking API connectivity...');
         try {
-          let api = new ApiService({
+          const api = new ApiService({
             baseUrl: config.apiUrl,
             token: config.apiKey,
             command: 'doctor'

package/dist/commands/finalize.js

@@ -1,6 +1,6 @@
+import { createServices } from '../services/index.js';
 import { loadConfig } from '../utils/config-loader.js';
 import * as output from '../utils/output.js';
-import { createServices } from '../services/index.js';
 
 /**
  * Finalize command implementation
@@ -16,11 +16,11 @@ export async function finalizeCommand(parallelId, options = {}, globalOptions =
   });
   try {
     // Load configuration with CLI overrides
-    let allOptions = {
+    const allOptions = {
       ...globalOptions,
       ...options
     };
-    let config = await loadConfig(globalOptions.config, allOptions);
+    const config = await loadConfig(globalOptions.config, allOptions);
 
     // Validate API token
     if (!config.apiKey) {
@@ -37,12 +37,12 @@ export async function finalizeCommand(parallelId, options = {}, globalOptions =
 
     // Create services and get API service
     output.startSpinner('Finalizing parallel build...');
-    let services = createServices(config, 'finalize');
-    let apiService = services.apiService;
+    const services = createServices(config, 'finalize');
+    const apiService = services.apiService;
     output.stopSpinner();
 
     // Call finalize endpoint
-    let result = await apiService.finalizeParallelBuild(parallelId);
+    const result = await apiService.finalizeParallelBuild(parallelId);
     if (globalOptions.json) {
       output.data(result);
     } else {
@@ -65,7 +65,7 @@ export async function finalizeCommand(parallelId, options = {}, globalOptions =
  * @param {Object} options - Command options
  */
 export function validateFinalizeOptions(parallelId, _options) {
-  let errors = [];
+  const errors = [];
   if (!parallelId || parallelId.trim() === '') {
     errors.push('Parallel ID is required');
   }