@vizzly-testing/cli 0.13.4 → 0.15.0

package/dist/services/tdd-service.js

@@ -3,14 +3,13 @@ import { join } from 'path';
 import { compare } from '@vizzly-testing/honeydiff';
 import crypto from 'crypto';
 import { ApiService } from '../services/api-service.js';
-import { createServiceLogger } from '../utils/logger-factory.js';
+import * as output from '../utils/output.js';
 import { colors } from '../utils/colors.js';
 import { getDefaultBranch } from '../utils/git.js';
 import { fetchWithTimeout } from '../utils/fetch-utils.js';
 import { NetworkError } from '../errors/vizzly-error.js';
 import { HtmlReportGenerator } from './html-report-generator.js';
 import { sanitizeScreenshotName, validatePathSecurity, safePath, validateScreenshotProperties } from '../utils/security.js';
-const logger = createServiceLogger('TDD');
 
 /**
  * Generate a screenshot signature for baseline matching
@@ -64,12 +63,13 @@ function generateComparisonId(signature) {
  * Create a new TDD service instance
  */
 export function createTDDService(config, options = {}) {
-  return new TddService(config, options.workingDir, options.setBaseline);
+  return new TddService(config, options.workingDir, options.setBaseline, options.authService);
 }
 export class TddService {
-  constructor(config, workingDir = process.cwd(), setBaseline = false) {
+  constructor(config, workingDir = process.cwd(), setBaseline = false, authService = null) {
     this.config = config;
     this.setBaseline = setBaseline;
+    this.authService = authService;
     this.api = new ApiService({
       baseUrl: config.apiUrl,
       token: config.apiKey,
@@ -81,7 +81,7 @@ export class TddService {
     try {
       this.workingDir = validatePathSecurity(workingDir, workingDir);
     } catch (error) {
-      logger.error(`Invalid working directory: ${error.message}`);
+      output.error(`Invalid working directory: ${error.message}`);
       throw new Error(`Working directory validation failed: ${error.message}`);
     }
 
@@ -95,7 +95,7 @@ export class TddService {
 
     // Check if we're in baseline update mode
     if (this.setBaseline) {
-      logger.info('🐻 Baseline update mode - will overwrite existing baselines with new ones');
+      output.info('🐻 Baseline update mode - will overwrite existing baselines with new ones');
     }
 
     // Ensure directories exist
@@ -106,7 +106,7 @@ export class TddService {
             recursive: true
           });
         } catch (error) {
-          logger.error(`Failed to create directory ${dir}: ${error.message}`);
+          output.error(`Failed to create directory ${dir}: ${error.message}`);
           throw new Error(`Directory creation failed: ${error.message}`);
         }
       }
@@ -119,9 +119,9 @@ export class TddService {
       if (!branch) {
         // If we can't detect a default branch, use 'main' as fallback
         branch = 'main';
-        logger.warn(`⚠️  Could not detect default branch, using 'main' as fallback`);
+        output.warn(`⚠️  Could not detect default branch, using 'main' as fallback`);
       } else {
-        logger.debug(`Using detected default branch: ${branch}`);
+        output.debug('tdd', `detected default branch: ${branch}`);
       }
     }
     try {
@@ -130,9 +130,9 @@ export class TddService {
         // Use specific build ID - get it with screenshots in one call
         const apiResponse = await this.api.getBuild(buildId, 'screenshots');
 
-        // Debug the full API response (only in debug mode)
-        logger.debug(`📊 Raw API response:`, {
-          apiResponse
+        // API response available in verbose mode
+        output.debug('tdd', 'fetched baseline build', {
+          id: apiResponse?.build?.id || apiResponse?.id
         });
         if (!apiResponse) {
           throw new Error(`Build ${buildId} not found or API returned null`);
@@ -141,22 +141,22 @@ export class TddService {
         // Handle wrapped response format
         baselineBuild = apiResponse.build || apiResponse;
         if (!baselineBuild.id) {
-          logger.warn(`⚠️  Build response structure: ${JSON.stringify(Object.keys(apiResponse))}`);
-          logger.warn(`⚠️  Extracted build keys: ${JSON.stringify(Object.keys(baselineBuild))}`);
+          output.warn(`⚠️  Build response structure: ${JSON.stringify(Object.keys(apiResponse))}`);
+          output.warn(`⚠️  Extracted build keys: ${JSON.stringify(Object.keys(baselineBuild))}`);
         }
 
         // Check build status and warn if it's not successful
         if (baselineBuild.status === 'failed') {
-          logger.warn(`⚠️  Build ${buildId} is marked as FAILED - falling back to local baselines`);
-          logger.info(`💡 To use remote baselines, specify a successful build ID instead`);
+          output.warn(`⚠️  Build ${buildId} is marked as FAILED - falling back to local baselines`);
+          output.info(`💡 To use remote baselines, specify a successful build ID instead`);
           // Fall back to local baseline logic
           return await this.handleLocalBaselines();
         } else if (baselineBuild.status !== 'completed') {
-          logger.warn(`⚠️  Build ${buildId} has status: ${baselineBuild.status} (expected: completed)`);
+          output.warn(`⚠️  Build ${buildId} has status: ${baselineBuild.status} (expected: completed)`);
         }
       } else if (comparisonId) {
         // Use specific comparison ID - download only this comparison's baseline screenshot
-        logger.info(`Using comparison: ${comparisonId}`);
+        output.info(`Using comparison: ${comparisonId}`);
         const comparison = await this.api.getComparison(comparisonId);
 
         // A comparison doesn't have baselineBuild directly - we need to get it
@@ -201,7 +201,7 @@ export class TddService {
             screenshotProperties.browser = comparison.baseline_browser;
           }
         }
-        logger.info(`📊 Extracted properties for signature: ${JSON.stringify(screenshotProperties)}`);
+        output.info(`📊 Extracted properties for signature: ${JSON.stringify(screenshotProperties)}`);
 
         // For a specific comparison, we only download that one baseline screenshot
         // Create a mock build structure with just this one screenshot
@@ -225,8 +225,8 @@ export class TddService {
           limit: 1
         });
         if (!builds.data || builds.data.length === 0) {
-          logger.warn(`⚠️  No baseline builds found for ${environment}/${branch}`);
-          logger.info('💡 Run a build in normal mode first to create baselines');
+          output.warn(`⚠️  No baseline builds found for ${environment}/${branch}`);
+          output.info('💡 Run a build in normal mode first to create baselines');
           return null;
         }
         baselineBuild = builds.data[0];
@@ -242,11 +242,11 @@ export class TddService {
         buildDetails = await this.api.getBuild(actualBuildId, 'screenshots');
       }
       if (!buildDetails.screenshots || buildDetails.screenshots.length === 0) {
-        logger.warn('⚠️  No screenshots found in baseline build');
+        output.warn('⚠️  No screenshots found in baseline build');
         return null;
       }
-      logger.info(`Using baseline from build: ${colors.cyan(baselineBuild.name || 'Unknown')} (${baselineBuild.id || 'Unknown ID'})`);
-      logger.info(`Checking ${colors.cyan(buildDetails.screenshots.length)} baseline screenshots...`);
+      output.info(`Using baseline from build: ${colors.cyan(baselineBuild.name || 'Unknown')} (${baselineBuild.id || 'Unknown ID'})`);
+      output.info(`Checking ${colors.cyan(buildDetails.screenshots.length)} baseline screenshots...`);
 
       // Check existing baseline metadata for efficient SHA comparison
       const existingBaseline = await this.loadBaseline();
@@ -274,7 +274,7 @@ export class TddService {
         try {
           sanitizedName = sanitizeScreenshotName(screenshot.name);
         } catch (error) {
-          logger.warn(`Skipping screenshot with invalid name '${screenshot.name}': ${error.message}`);
+          output.warn(`Skipping screenshot with invalid name '${screenshot.name}': ${error.message}`);
           errorCount++;
           continue;
         }
@@ -289,19 +289,16 @@ export class TddService {
         if (existsSync(imagePath) && screenshot.sha256) {
           const storedSha = existingShaMap.get(signature);
           if (storedSha === screenshot.sha256) {
-            logger.debug(`⚡ Skipping ${sanitizedName} - SHA match from metadata`);
             downloadedCount++; // Count as "downloaded" since we have it
             skippedCount++;
             continue;
-          } else if (storedSha) {
-            logger.debug(`🔄 SHA mismatch for ${sanitizedName} - will re-download (stored: ${storedSha?.slice(0, 8)}..., remote: ${screenshot.sha256?.slice(0, 8)}...)`);
           }
         }
 
         // Use original_url as the download URL
         const downloadUrl = screenshot.original_url || screenshot.url;
         if (!downloadUrl) {
-          logger.warn(`⚠️  Screenshot ${sanitizedName} has no download URL - skipping`);
+          output.warn(`⚠️  Screenshot ${sanitizedName} has no download URL - skipping`);
           errorCount++;
           continue;
         }
@@ -319,12 +316,12 @@ export class TddService {
       // Process downloads in batches
       const actualDownloadsNeeded = screenshotsToProcess.length;
       if (actualDownloadsNeeded > 0) {
-        logger.info(`📥 Downloading ${actualDownloadsNeeded} new/updated screenshots in batches of ${batchSize}...`);
+        output.info(`📥 Downloading ${actualDownloadsNeeded} new/updated screenshots in batches of ${batchSize}...`);
         for (let i = 0; i < screenshotsToProcess.length; i += batchSize) {
           const batch = screenshotsToProcess.slice(i, i + batchSize);
           const batchNum = Math.floor(i / batchSize) + 1;
           const totalBatches = Math.ceil(screenshotsToProcess.length / batchSize);
-          logger.info(`📦 Processing batch ${batchNum}/${totalBatches} (${batch.length} screenshots)`);
+          output.info(`📦 Processing batch ${batchNum}/${totalBatches} (${batch.length} screenshots)`);
 
           // Download batch concurrently
           const downloadPromises = batch.map(async ({
@@ -333,7 +330,6 @@ export class TddService {
             downloadUrl
           }) => {
             try {
-              logger.debug(`📥 Downloading: ${sanitizedName}`);
               const response = await fetchWithTimeout(downloadUrl);
               if (!response.ok) {
                 throw new NetworkError(`Failed to download ${sanitizedName}: ${response.statusText}`);
@@ -341,13 +337,12 @@ export class TddService {
               const arrayBuffer = await response.arrayBuffer();
               const imageBuffer = Buffer.from(arrayBuffer);
               writeFileSync(imagePath, imageBuffer);
-              logger.debug(`✓ Downloaded ${sanitizedName}.png`);
               return {
                 success: true,
                 name: sanitizedName
               };
             } catch (error) {
-              logger.warn(`⚠️  Failed to download ${sanitizedName}: ${error.message}`);
+              output.warn(`⚠️  Failed to download ${sanitizedName}: ${error.message}`);
               return {
                 success: false,
                 name: sanitizedName,
@@ -364,18 +359,18 @@ export class TddService {
           // Show progress
           const totalProcessed = downloadedCount + skippedCount + errorCount;
           const progressPercent = Math.round(totalProcessed / totalScreenshots * 100);
-          logger.info(`📊 Progress: ${totalProcessed}/${totalScreenshots} (${progressPercent}%) - ${batchSuccesses} downloaded, ${batchFailures} failed in this batch`);
+          output.info(`📊 Progress: ${totalProcessed}/${totalScreenshots} (${progressPercent}%) - ${batchSuccesses} downloaded, ${batchFailures} failed in this batch`);
         }
       }
 
       // Check if we actually downloaded any screenshots
       if (downloadedCount === 0 && skippedCount === 0) {
-        logger.error('❌ No screenshots were successfully downloaded from the baseline build');
+        output.error('❌ No screenshots were successfully downloaded from the baseline build');
         if (errorCount > 0) {
-          logger.info(`💡 ${errorCount} screenshots had errors - check download URLs and network connection`);
+          output.info(`💡 ${errorCount} screenshots had errors - check download URLs and network connection`);
         }
-        logger.info('💡 This usually means the build failed or screenshots have no download URLs');
-        logger.info('💡 Try using a successful build ID, or run without --baseline-build to create local baselines');
+        output.info('💡 This usually means the build failed or screenshots have no download URLs');
+        output.info('💡 Try using a successful build ID, or run without --baseline-build to create local baselines');
         return null;
       }
 
@@ -398,7 +393,7 @@ export class TddService {
           try {
             sanitizedName = sanitizeScreenshotName(s.name);
           } catch (error) {
-            logger.warn(`Screenshot name sanitization failed for '${s.name}': ${error.message}`);
+            output.warn(`Screenshot name sanitization failed for '${s.name}': ${error.message}`);
             return null; // Skip invalid screenshots
           }
           let properties = validateScreenshotProperties(s.metadata || s.properties || {});
@@ -445,21 +440,176 @@ export class TddService {
       if (skippedCount > 0) {
         // All skipped (up-to-date)
         if (actualDownloads === 0) {
-          logger.info(`✅ All ${skippedCount} baselines up-to-date (matching local SHA)`);
+          output.info(`✅ All ${skippedCount} baselines up-to-date (matching local SHA)`);
         } else {
           // Mixed: some downloaded, some skipped
-          logger.info(`✅ Downloaded ${actualDownloads} new screenshots, ${skippedCount} already up-to-date`);
+          output.info(`✅ Downloaded ${actualDownloads} new screenshots, ${skippedCount} already up-to-date`);
         }
       } else {
         // Fresh download
-        logger.info(`✅ Downloaded ${downloadedCount}/${buildDetails.screenshots.length} screenshots successfully`);
+        output.info(`✅ Downloaded ${downloadedCount}/${buildDetails.screenshots.length} screenshots successfully`);
       }
       if (errorCount > 0) {
-        logger.warn(`⚠️  ${errorCount} screenshots failed to download`);
+        output.warn(`⚠️  ${errorCount} screenshots failed to download`);
       }
       return this.baselineData;
     } catch (error) {
-      logger.error(`❌ Failed to download baseline: ${error.message}`);
+      output.error(`❌ Failed to download baseline: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Download baselines using OAuth authentication
+   * Used when user is logged in via device flow but no API token is configured
+   * @param {string} buildId - Build ID to download from
+   * @param {string} organizationSlug - Organization slug
+   * @param {string} projectSlug - Project slug
+   * @param {Object} authService - Auth service for OAuth requests
+   * @returns {Promise<Object>} Download result
+   */
+  async downloadBaselinesWithAuth(buildId, organizationSlug, projectSlug, authService) {
+    output.info(`Downloading baselines using OAuth from build ${buildId}...`);
+    try {
+      // Fetch build with screenshots via OAuth endpoint
+      let endpoint = `/api/build/${projectSlug}/${buildId}/tdd-baselines`;
+      let response = await authService.authenticatedRequest(endpoint, {
+        method: 'GET',
+        headers: {
+          'X-Organization': organizationSlug
+        }
+      });
+      let {
+        build,
+        screenshots
+      } = response;
+      if (!screenshots || screenshots.length === 0) {
+        output.warn('⚠️  No screenshots found in build');
+        return {
+          downloadedCount: 0,
+          skippedCount: 0,
+          errorCount: 0
+        };
+      }
+      output.info(`Using baseline from build: ${colors.cyan(build.name || 'Unknown')} (${build.id})`);
+      output.info(`Checking ${colors.cyan(screenshots.length)} baseline screenshots...`);
+
+      // Load existing baseline metadata for SHA comparison
+      let existingBaseline = await this.loadBaseline();
+      let existingShaMap = new Map();
+      if (existingBaseline) {
+        existingBaseline.screenshots.forEach(s => {
+          if (s.sha256 && s.signature) {
+            existingShaMap.set(s.signature, s.sha256);
+          }
+        });
+      }
+
+      // Process and download screenshots
+      let downloadedCount = 0;
+      let skippedCount = 0;
+      let errorCount = 0;
+      let downloadedScreenshots = [];
+      for (let screenshot of screenshots) {
+        let sanitizedName;
+        try {
+          sanitizedName = sanitizeScreenshotName(screenshot.name);
+        } catch (error) {
+          output.warn(`Screenshot name sanitization failed for '${screenshot.name}': ${error.message}`);
+          errorCount++;
+          continue;
+        }
+        let properties = validateScreenshotProperties(screenshot.metadata || {});
+        let signature = generateScreenshotSignature(sanitizedName, properties);
+        let filename = signatureToFilename(signature);
+        let filePath = safePath(this.baselinePath, `${filename}.png`);
+
+        // Check if we can skip via SHA comparison
+        if (screenshot.sha256 && existingShaMap.get(signature) === screenshot.sha256) {
+          skippedCount++;
+          downloadedScreenshots.push({
+            name: sanitizedName,
+            sha256: screenshot.sha256,
+            signature,
+            path: filePath,
+            properties
+          });
+          continue;
+        }
+
+        // Download the screenshot
+        let downloadUrl = screenshot.original_url;
+        if (!downloadUrl) {
+          output.warn(`⚠️  No download URL for screenshot: ${sanitizedName}`);
+          errorCount++;
+          continue;
+        }
+        try {
+          let imageResponse = await fetchWithTimeout(downloadUrl, {}, 30000);
+          if (!imageResponse.ok) {
+            throw new Error(`HTTP ${imageResponse.status}`);
+          }
+          let imageBuffer = Buffer.from(await imageResponse.arrayBuffer());
+
+          // Calculate SHA256 of downloaded content
+          let sha256 = crypto.createHash('sha256').update(imageBuffer).digest('hex');
+          writeFileSync(filePath, imageBuffer);
+          downloadedCount++;
+          downloadedScreenshots.push({
+            name: sanitizedName,
+            sha256,
+            signature,
+            path: filePath,
+            properties,
+            originalUrl: downloadUrl
+          });
+        } catch (error) {
+          output.warn(`⚠️  Failed to download ${sanitizedName}: ${error.message}`);
+          errorCount++;
+        }
+      }
+
+      // Store baseline metadata
+      this.baselineData = {
+        buildId: build.id,
+        buildName: build.name,
+        branch: build.branch,
+        threshold: this.threshold,
+        screenshots: downloadedScreenshots
+      };
+      let metadataPath = join(this.baselinePath, 'metadata.json');
+      writeFileSync(metadataPath, JSON.stringify(this.baselineData, null, 2));
+
+      // Save baseline build metadata
+      let baselineMetadataPath = safePath(this.workingDir, '.vizzly', 'baseline-metadata.json');
+      writeFileSync(baselineMetadataPath, JSON.stringify({
+        buildId: build.id,
+        buildName: build.name,
+        branch: build.branch,
+        commitSha: build.commit_sha,
+        downloadedAt: new Date().toISOString()
+      }, null, 2));
+
+      // Summary
+      if (skippedCount > 0 && downloadedCount === 0) {
+        output.info(`✅ All ${skippedCount} baselines up-to-date (matching local SHA)`);
+      } else if (skippedCount > 0) {
+        output.info(`✅ Downloaded ${downloadedCount} new screenshots, ${skippedCount} already up-to-date`);
+      } else {
+        output.info(`✅ Downloaded ${downloadedCount}/${screenshots.length} screenshots successfully`);
+      }
+      if (errorCount > 0) {
+        output.warn(`⚠️  ${errorCount} screenshots failed to download`);
+      }
+      return {
+        downloadedCount,
+        skippedCount,
+        errorCount,
+        buildId: build.id,
+        buildName: build.name
+      };
+    } catch (error) {
+      output.error(`❌ OAuth download failed: ${error.message} (org=${organizationSlug}, project=${projectSlug}, build=${buildId})`);
       throw error;
     }
   }
@@ -471,7 +621,7 @@ export class TddService {
   async handleLocalBaselines() {
     // Check if we're in baseline update mode - skip loading existing baselines
     if (this.setBaseline) {
-      logger.info('📁 Ready for new baseline creation - all screenshots will be treated as new baselines');
+      output.info('📁 Ready for new baseline creation - all screenshots will be treated as new baselines');
 
       // Reset baseline data since we're creating new ones
       this.baselineData = null;
@@ -480,21 +630,21 @@ export class TddService {
     const baseline = await this.loadBaseline();
     if (!baseline) {
       if (this.config.apiKey) {
-        logger.info('📥 No local baseline found, but API key available for future remote fetching');
-        logger.info('🆕 Current run will create new local baselines');
+        output.info('📥 No local baseline found, but API key available for future remote fetching');
+        output.info('🆕 Current run will create new local baselines');
       } else {
-        logger.info('📝 No local baseline found and no API token - all screenshots will be marked as new');
+        output.info('📝 No local baseline found and no API token - all screenshots will be marked as new');
       }
       return null;
     } else {
-      logger.info(`✅ Using existing baseline: ${colors.cyan(baseline.buildName)}`);
+      output.info(`✅ Using existing baseline: ${colors.cyan(baseline.buildName)}`);
       return baseline;
     }
   }
   async loadBaseline() {
     // In baseline update mode, never load existing baselines
     if (this.setBaseline) {
-      logger.debug('🐻 Baseline update mode - skipping baseline loading');
+      output.debug('tdd', 'baseline update mode - skipping loading');
       return null;
     }
     const metadataPath = join(this.baselinePath, 'metadata.json');
@@ -507,7 +657,7 @@ export class TddService {
       this.threshold = metadata.threshold || this.threshold;
       return metadata;
     } catch (error) {
-      logger.error(`❌ Failed to load baseline metadata: ${error.message}`);
+      output.error(`❌ Failed to load baseline metadata: ${error.message}`);
       return null;
     }
   }
@@ -517,14 +667,14 @@ export class TddService {
     try {
       sanitizedName = sanitizeScreenshotName(name);
     } catch (error) {
-      logger.error(`Invalid screenshot name '${name}': ${error.message}`);
+      output.error(`Invalid screenshot name '${name}': ${error.message}`);
       throw new Error(`Screenshot name validation failed: ${error.message}`);
     }
     let validatedProperties;
     try {
       validatedProperties = validateScreenshotProperties(properties);
     } catch (error) {
-      logger.warn(`Property validation failed for '${sanitizedName}': ${error.message}`);
+      output.warn(`Property validation failed for '${sanitizedName}': ${error.message}`);
       validatedProperties = {};
     }
 
@@ -552,13 +702,8 @@ export class TddService {
     // Check if baseline exists
     const baselineExists = existsSync(baselineImagePath);
     if (!baselineExists) {
-      logger.debug(`No baseline found for ${sanitizedName} - creating baseline`);
-      logger.debug(`Path: ${baselineImagePath}`);
-      logger.debug(`Size: ${imageBuffer.length} bytes`);
-
       // Copy current screenshot to baseline directory for future comparisons
       writeFileSync(baselineImagePath, imageBuffer);
-      logger.debug(`Created baseline: ${imageBuffer.length} bytes`);
 
       // Update or create baseline metadata
       if (!this.baselineData) {
@@ -589,7 +734,9 @@ export class TddService {
       // Save updated metadata
       const metadataPath = join(this.baselinePath, 'metadata.json');
       writeFileSync(metadataPath, JSON.stringify(this.baselineData, null, 2));
-      logger.debug(`✅ Created baseline for ${sanitizedName}`);
+
+      // Baseline creation tracked by event handler
+
       const result = {
         id: generateComparisonId(signature),
         name: sanitizedName,
@@ -606,13 +753,6 @@ export class TddService {
 
     // Baseline exists - compare with it
     try {
-      // Log file sizes for debugging
-      const baselineSize = readFileSync(baselineImagePath).length;
-      const currentSize = readFileSync(currentImagePath).length;
-      logger.debug(`Comparing ${sanitizedName}`);
-      logger.debug(`Baseline: ${baselineImagePath} (${baselineSize} bytes)`);
-      logger.debug(`Current:  ${currentImagePath} (${currentSize} bytes)`);
-
       // Try to compare - honeydiff will throw if dimensions don't match
       const result = await compare(baselineImagePath, currentImagePath, {
         colorThreshold: this.threshold,
@@ -639,7 +779,8 @@ export class TddService {
           aaPixelsIgnored: result.aaPixelsIgnored,
           aaPercentage: result.aaPercentage
         };
-        logger.debug(`PASSED ${sanitizedName}`);
+
+        // Result tracked by event handler
         this.comparisons.push(comparison);
         return comparison;
       } else {
@@ -672,8 +813,8 @@ export class TddService {
           intensityStats: result.intensityStats,
           diffClusters: result.diffClusters
         };
-        logger.warn(`❌ ${colors.red('FAILED')} ${sanitizedName} - differences detected${diffInfo}`);
-        logger.info(`    Diff saved to: ${diffImagePath}`);
+        output.warn(`❌ ${colors.red('FAILED')} ${sanitizedName} - differences detected${diffInfo}`);
+        output.info(`    Diff saved to: ${diffImagePath}`);
         this.comparisons.push(comparison);
         return comparison;
       }
@@ -683,9 +824,11 @@ export class TddService {
       if (isDimensionMismatch) {
         // Different dimensions = different screenshot signature
         // This shouldn't happen if signatures are working correctly, but handle gracefully
-        logger.warn(`⚠️  Dimension mismatch for ${sanitizedName} - baseline file exists but has different dimensions`);
-        logger.warn(`   This indicates a signature collision. Creating new baseline with correct signature.`);
-        logger.debug(`   Error: ${error.message}`);
+        output.warn(`⚠️  Dimension mismatch for ${sanitizedName} - baseline file exists but has different dimensions`);
+        output.warn(`   This indicates a signature collision. Creating new baseline with correct signature.`);
+        output.debug('tdd', 'dimension mismatch', {
+          error: error.message
+        });
 
         // Create a new baseline for this screenshot (overwriting the incorrect one)
         writeFileSync(baselineImagePath, imageBuffer);
@@ -715,7 +858,7 @@ export class TddService {
         }
         const metadataPath = join(this.baselinePath, 'metadata.json');
         writeFileSync(metadataPath, JSON.stringify(this.baselineData, null, 2));
-        logger.info(`✅ Created new baseline for ${sanitizedName} (different dimensions)`);
+        output.info(`✅ Created new baseline for ${sanitizedName} (different dimensions)`);
         const comparison = {
           id: generateComparisonId(signature),
           name: sanitizedName,
@@ -731,7 +874,7 @@ export class TddService {
       }
 
       // Handle other file errors or issues
-      logger.error(`❌ Error comparing ${sanitizedName}: ${error.message}`);
+      output.error(`❌ Error comparing ${sanitizedName}: ${error.message}`);
       const comparison = {
         id: generateComparisonId(signature),
         name: sanitizedName,
@@ -764,34 +907,34 @@ export class TddService {
   }
   async printResults() {
     const results = this.getResults();
-    logger.info('\n📊 TDD Results:');
-    logger.info(`Total: ${colors.cyan(results.total)}`);
-    logger.info(`Passed: ${colors.green(results.passed)}`);
+    output.info('\n📊 TDD Results:');
+    output.info(`Total: ${colors.cyan(results.total)}`);
+    output.info(`Passed: ${colors.green(results.passed)}`);
     if (results.failed > 0) {
-      logger.info(`Failed: ${colors.red(results.failed)}`);
+      output.info(`Failed: ${colors.red(results.failed)}`);
     }
     if (results.new > 0) {
-      logger.info(`New: ${colors.yellow(results.new)}`);
+      output.info(`New: ${colors.yellow(results.new)}`);
     }
     if (results.errors > 0) {
-      logger.info(`Errors: ${colors.red(results.errors)}`);
+      output.info(`Errors: ${colors.red(results.errors)}`);
     }
 
     // Show failed comparisons
     const failedComparisons = results.comparisons.filter(c => c.status === 'failed');
     if (failedComparisons.length > 0) {
-      logger.info('\n❌ Failed comparisons:');
+      output.info('\n❌ Failed comparisons:');
       failedComparisons.forEach(comp => {
-        logger.info(`  • ${comp.name}`);
+        output.info(`  • ${comp.name}`);
       });
     }
 
     // Show new screenshots
     const newComparisons = results.comparisons.filter(c => c.status === 'new');
     if (newComparisons.length > 0) {
-      logger.info('\n📸 New screenshots:');
+      output.info('\n📸 New screenshots:');
       newComparisons.forEach(comp => {
-        logger.info(`  • ${comp.name}`);
+        output.info(`  • ${comp.name}`);
       });
     }
 
@@ -813,7 +956,7 @@ export class TddService {
       });
 
       // Show report path (always clickable)
-      logger.info(`\n🐻 View detailed report: ${colors.cyan('file://' + reportPath)}`);
+      output.info(`\n🐻 View detailed report: ${colors.cyan('file://' + reportPath)}`);
 
       // Auto-open if configured
       if (this.config.tdd?.openReport) {
@@ -821,7 +964,7 @@ export class TddService {
       }
       return reportPath;
     } catch (error) {
-      logger.warn(`Failed to generate HTML report: ${error.message}`);
+      output.warn(`Failed to generate HTML report: ${error.message}`);
     }
   }
 
@@ -854,9 +997,9 @@ export class TddService {
           break;
       }
       await execAsync(command);
-      logger.info('📖 Report opened in browser');
-    } catch (error) {
-      logger.debug(`Failed to open report: ${error.message}`);
+      output.info('📖 Report opened in browser');
+    } catch {
+      // Browser open may fail silently
     }
   }
 
@@ -866,7 +1009,7 @@ export class TddService {
    */
   updateBaselines() {
     if (this.comparisons.length === 0) {
-      logger.warn('No comparisons found - nothing to update');
+      output.warn('No comparisons found - nothing to update');
       return 0;
     }
     let updatedCount = 0;
@@ -888,7 +1031,7 @@ export class TddService {
         current
       } = comparison;
       if (!current || !existsSync(current)) {
-        logger.warn(`Current screenshot not found for ${name}, skipping`);
+        output.warn(`Current screenshot not found for ${name}, skipping`);
         continue;
       }
 
@@ -897,7 +1040,7 @@ export class TddService {
       try {
         sanitizedName = sanitizeScreenshotName(name);
       } catch (error) {
-        logger.warn(`Skipping baseline update for invalid name '${name}': ${error.message}`);
+        output.warn(`Skipping baseline update for invalid name '${name}': ${error.message}`);
         continue;
       }
       let validatedProperties = validateScreenshotProperties(comparison.properties || {});
@@ -923,9 +1066,9 @@ export class TddService {
           this.baselineData.screenshots.push(screenshotEntry);
         }
         updatedCount++;
-        logger.info(`✅ Updated baseline for ${sanitizedName}`);
+        output.info(`✅ Updated baseline for ${sanitizedName}`);
       } catch (error) {
-        logger.error(`❌ Failed to update baseline for ${sanitizedName}: ${error.message}`);
+        output.error(`❌ Failed to update baseline for ${sanitizedName}: ${error.message}`);
       }
     }
 
@@ -934,9 +1077,9 @@ export class TddService {
       try {
         const metadataPath = join(this.baselinePath, 'metadata.json');
         writeFileSync(metadataPath, JSON.stringify(this.baselineData, null, 2));
-        logger.info(`✅ Updated ${updatedCount} baseline(s)`);
+        output.info(`✅ Updated ${updatedCount} baseline(s)`);
       } catch (error) {
-        logger.error(`❌ Failed to save baseline metadata: ${error.message}`);
+        output.error(`❌ Failed to save baseline metadata: ${error.message}`);
       }
     }
     return updatedCount;
@@ -947,7 +1090,7 @@ export class TddService {
    * @private
    */
   createNewBaseline(name, imageBuffer, properties, currentImagePath, baselineImagePath) {
-    logger.info(`🐻 Creating baseline for ${name}`);
+    output.info(`🐻 Creating baseline for ${name}`);
 
     // Copy current screenshot to baseline directory
     writeFileSync(baselineImagePath, imageBuffer);
@@ -995,7 +1138,7 @@ export class TddService {
       signature
     };
     this.comparisons.push(result);
-    logger.info(`✅ Baseline created for ${name}`);
+    output.info(`✅ Baseline created for ${name}`);
     return result;
   }
 
@@ -1004,7 +1147,7 @@ export class TddService {
    * @private
    */
   updateSingleBaseline(name, imageBuffer, properties, currentImagePath, baselineImagePath) {
-    logger.info(`🐻 Setting baseline for ${name}`);
+    output.info(`🐻 Setting baseline for ${name}`);
 
     // Copy current screenshot to baseline directory
     writeFileSync(baselineImagePath, imageBuffer);
@@ -1052,7 +1195,7 @@ export class TddService {
       signature
     };
     this.comparisons.push(result);
-    logger.info(`🐻 Baseline set for ${name}`);
+    output.info(`🐻 Baseline set for ${name}`);
     return result;
   }
 
@@ -1083,7 +1226,7 @@ export class TddService {
     // Find the current screenshot file
     const currentImagePath = safePath(this.currentPath, `${filename}.png`);
     if (!existsSync(currentImagePath)) {
-      logger.error(`Current screenshot not found at: ${currentImagePath}`);
+      output.error(`Current screenshot not found at: ${currentImagePath}`);
       throw new Error(`Current screenshot not found: ${sanitizedName} (looked at ${currentImagePath})`);
     }
 
@@ -1105,7 +1248,7 @@ export class TddService {
 
     // Verify the write
     if (!existsSync(baselineImagePath)) {
-      logger.error(`Baseline file does not exist after write!`);
+      output.error(`Baseline file does not exist after write!`);
     }
 
     // Update baseline metadata