@vizzly-testing/cli 0.17.0 → 0.19.0

package/dist/cli.js

@@ -1,29 +1,31 @@
 #!/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 { createPluginServices } from './plugin-api.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 +33,36 @@ 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);
+const pluginServices = createPluginServices(services);
 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,
+        services: pluginServices,
         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 +73,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 +81,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 +112,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 +157,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 +179,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,10 +73,10 @@ 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;
     // CIEDE2000 threshold: 0 = exact, 1 = JND, 2 = recommended, 3+ = permissive
-    let thresholdValid = Number.isFinite(threshold) && threshold >= 0;
+    const thresholdValid = Number.isFinite(threshold) && threshold >= 0;
     diagnostics.configuration.thresholdValid = thresholdValid;
     if (thresholdValid) {
       output.success(`Threshold: ${threshold} (CIEDE2000 Delta E)`);
@@ -86,12 +86,12 @@ export async function doctorCommand(options = {}, globalOptions = {}) {
     }
 
     // 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) {
@@ -102,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');
   }

package/dist/commands/init.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import fs from 'fs/promises';
-import path from 'path';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
 import { VizzlyError } from '../errors/vizzly-error.js';
-import * as output from '../utils/output.js';
 import { loadPlugins } from '../plugin-loader.js';
 import { loadConfig } from '../utils/config-loader.js';
-import { z } from 'zod';
+import * as output from '../utils/output.js';
 
 /**
  * Simple configuration setup for Vizzly CLI
@@ -19,8 +19,8 @@ export class InitCommand {
     output.blank();
     try {
       // Check for existing config
-      let configPath = path.join(process.cwd(), 'vizzly.config.js');
-      let hasConfig = await this.fileExists(configPath);
+      const configPath = path.join(process.cwd(), 'vizzly.config.js');
+      const hasConfig = await this.fileExists(configPath);
       if (hasConfig && !options.force) {
         output.info('❌ A vizzly.config.js file already exists. Use --force to overwrite.');
         return;
@@ -71,16 +71,16 @@ export class InitCommand {
   }`;
 
     // Add plugin configurations
-    let pluginConfigs = this.generatePluginConfigs();
+    const pluginConfigs = this.generatePluginConfigs();
     if (pluginConfigs) {
-      coreConfig += ',\n\n' + pluginConfigs;
+      coreConfig += `,\n\n${pluginConfigs}`;
     }
     coreConfig += '\n};\n';
     await fs.writeFile(configPath, coreConfig, 'utf8');
     output.info(`📄 Created vizzly.config.js`);
 
     // Log discovered plugins
-    let pluginsWithConfig = this.plugins.filter(p => p.configSchema);
+    const pluginsWithConfig = this.plugins.filter(p => p.configSchema);
     if (pluginsWithConfig.length > 0) {
       output.info(`   Added config for ${pluginsWithConfig.length} plugin(s):`);
       pluginsWithConfig.forEach(p => {
@@ -94,10 +94,10 @@ export class InitCommand {
    * @returns {string} Plugin config sections as formatted string
    */
   generatePluginConfigs() {
-    let sections = [];
-    for (let plugin of this.plugins) {
+    const sections = [];
+    for (const plugin of this.plugins) {
       if (plugin.configSchema) {
-        let configStr = this.formatPluginConfig(plugin);
+        const configStr = this.formatPluginConfig(plugin);
         if (configStr) {
           sections.push(configStr);
         }
@@ -114,18 +114,18 @@ export class InitCommand {
   formatPluginConfig(plugin) {
     try {
       // Validate config schema structure with Zod (defensive check)
-      let configValueSchema = z.lazy(() => z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(configValueSchema), z.record(configValueSchema)]));
-      let configSchemaValidator = z.record(configValueSchema);
+      const configValueSchema = z.lazy(() => z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(configValueSchema), z.record(configValueSchema)]));
+      const configSchemaValidator = z.record(configValueSchema);
       configSchemaValidator.parse(plugin.configSchema);
-      let configEntries = [];
-      for (let [key, value] of Object.entries(plugin.configSchema)) {
-        let formattedValue = this.formatValue(value, 1);
+      const configEntries = [];
+      for (const [key, value] of Object.entries(plugin.configSchema)) {
+        const formattedValue = this.formatValue(value, 1);
         configEntries.push(`  // ${plugin.name} plugin configuration\n  ${key}: ${formattedValue}`);
       }
       return configEntries.join(',\n\n');
     } catch (error) {
       if (error instanceof z.ZodError) {
-        let messages = error.errors.map(e => `${e.path.join('.')}: ${e.message}`);
+        const messages = error.errors.map(e => `${e.path.join('.')}: ${e.message}`);
         output.warn(`Invalid config schema for plugin ${plugin.name}: ${messages.join(', ')}`);
       } else {
         output.warn(`Failed to format config for plugin ${plugin.name}: ${error.message}`);
@@ -141,25 +141,25 @@ export class InitCommand {
    * @returns {string} Formatted value
    */
   formatValue(value, depth = 0) {
-    let indent = '  '.repeat(depth);
-    let nextIndent = '  '.repeat(depth + 1);
+    const indent = '  '.repeat(depth);
+    const nextIndent = '  '.repeat(depth + 1);
     if (value === null) return 'null';
     if (value === undefined) return 'undefined';
     if (typeof value === 'string') return `'${value.replace(/'/g, "\\'")}'`;
     if (typeof value === 'number' || typeof value === 'boolean') return String(value);
     if (Array.isArray(value)) {
       if (value.length === 0) return '[]';
-      let items = value.map(item => {
-        let formatted = this.formatValue(item, depth + 1);
+      const items = value.map(item => {
+        const formatted = this.formatValue(item, depth + 1);
         return `${nextIndent}${formatted}`;
       });
       return `[\n${items.join(',\n')}\n${indent}]`;
     }
     if (typeof value === 'object') {
-      let entries = Object.entries(value);
+      const entries = Object.entries(value);
       if (entries.length === 0) return '{}';
-      let props = entries.map(([k, v]) => {
-        let formatted = this.formatValue(v, depth + 1);
+      const props = entries.map(([k, v]) => {
+        const formatted = this.formatValue(v, depth + 1);
         return `${nextIndent}${k}: ${formatted}`;
       });
       return `{\n${props.join(',\n')}\n${indent}}`;
@@ -188,7 +188,7 @@ export class InitCommand {
 
 // Export factory function for CLI
 export function createInitCommand(options) {
-  let command = new InitCommand(options.plugins);
+  const command = new InitCommand(options.plugins);
   return () => command.run(options);
 }
 
@@ -204,7 +204,7 @@ export async function init(options = {}) {
   // Try to load plugins if not provided
   if (!options.plugins) {
     try {
-      let config = await loadConfig(options.config, {});
+      const config = await loadConfig(options.config, {});
       plugins = await loadPlugins(options.config, config, null);
     } catch {
       // Silent fail - plugins are optional for init
@@ -212,6 +212,6 @@ export async function init(options = {}) {
   } else {
     plugins = options.plugins;
   }
-  let command = new InitCommand(plugins);
+  const command = new InitCommand(plugins);
   return await command.run(options);
 }