@tamyla/clodo-framework 4.0.13 → 4.0.14

package/scripts/utilities/generate-secrets.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+/**
+ * Secret Generation Utility
+ * Generates cryptographically secure secrets for production deployment
+ * Now with secret persistence for cross-service sharing
+ */
+
+import { randomBytes } from 'crypto';
+import { writeFileSync, readFileSync, mkdirSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = join(__dirname, '..', '..');
+const SECRETS_DIR = join(PROJECT_ROOT, 'secrets');
+
+function generateSecret(length = 32) {
+  return randomBytes(length).toString('hex');
+}
+
+function generateSecrets(options = {}) {
+  const { domainName, reuseSecrets = false, saveToFile = false, environment = 'production' } = options;
+  
+  console.log('🔐 PRODUCTION SECRETS GENERATOR');
+  console.log('================================');
+  console.log('');
+  console.log('⚠️  IMPORTANT: Store these secrets securely and never commit them to git!');
+  console.log('');
+  
+  let secrets = {};
+  let secretsFile = null;
+  
+  // Set up file paths if domain name provided
+  if (domainName) {
+    if (!existsSync(SECRETS_DIR)) {
+      mkdirSync(SECRETS_DIR, { recursive: true });
+    }
+    secretsFile = join(SECRETS_DIR, `${domainName}-secrets.json`);
+  }
+  
+  // Always try to reuse existing secrets for consistency across services
+  if (secretsFile && existsSync(secretsFile)) {
+    try {
+      const existing = JSON.parse(readFileSync(secretsFile, 'utf8'));
+      const { domain: _domain, environment: _env, generated: _gen, note: _note, ...existingSecrets } = existing;
+      secrets = existingSecrets;
+      console.log(`📂 Reusing existing secrets for domain '${domainName}' (consistent across services)`);
+      console.log(`🕒 Originally generated: ${existing.generated}`);
+      console.log('');
+      console.log('🔄 IMPORTANT: Using existing secrets ensures all services can authenticate with each other');
+    } catch (error) {
+      console.log('⚠️  Could not load existing secrets, generating new ones...');
+    }
+  } else if (domainName) {
+    console.log(`🆕 Creating new secrets for domain '${domainName}'`);
+  }
+  
+  // Generate any missing secrets
+  if (!secrets.AUTH_JWT_SECRET) secrets.AUTH_JWT_SECRET = generateSecret(32);
+  if (!secrets.X_SERVICE_KEY) secrets.X_SERVICE_KEY = generateSecret(32);
+  if (!secrets.AUTH_SERVICE_API_KEY) secrets.AUTH_SERVICE_API_KEY = generateSecret(24);
+  if (!secrets.LOGGER_SERVICE_API_KEY) secrets.LOGGER_SERVICE_API_KEY = generateSecret(24);
+  if (!secrets.CONTENT_SKIMMER_API_KEY) secrets.CONTENT_SKIMMER_API_KEY = generateSecret(24);
+  
+  // Save secrets to file if requested
+  if ((saveToFile || domainName) && secretsFile) {
+    try {
+      const secretsData = {
+        ...secrets,
+        domain: domainName,
+        environment,
+        generated: new Date().toISOString(),
+        note: 'Generated by generate-secrets.js - Share with other services for authentication'
+      };
+      writeFileSync(secretsFile, JSON.stringify(secretsData, null, 2));
+      console.log(`💾 Secrets saved to: ${secretsFile}`);
+      console.log('📋 Other services can load these secrets for consistent authentication');
+    } catch (error) {
+      console.log(`⚠️  Could not save secrets to file: ${error.message}`);
+    }
+  }
+  
+  console.log('');
+  console.log('Generated secrets:');
+  console.log('');
+  
+  for (const [key, value] of Object.entries(secrets)) {
+    console.log(`${key}=${value}`);
+  }
+  
+  console.log('');
+  console.log('🚀 To set these in Cloudflare Workers:');
+  console.log('');
+  
+  for (const [key, value] of Object.entries(secrets)) {
+    console.log(`echo "${value}" | wrangler secret put ${key} --env ${environment}`);
+  }
+  
+  console.log('');
+  console.log(`For other environments, replace --env ${environment} with --env staging or --env development`);
+  console.log('');
+  console.log('💡 You can also set these individually when prompted by the deployment script.');
+  
+  return secrets;
+}
+
+// Command line interface
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {};
+  
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case '--domain':
+        options.domainName = args[++i];
+        options.saveToFile = true;
+        break;
+      case '--reuse':
+        options.reuseSecrets = true;
+        break;
+      case '--environment':
+      case '--env':
+        options.environment = args[++i];
+        break;
+      case '--save':
+        options.saveToFile = true;
+        break;
+      case '--help':
+        console.log(`
+Usage: node generate-secrets.js [options]
+
+Options:
+  --domain <name>      Domain name (enables file saving)
+  --reuse             Try to reuse existing secrets
+  --env <environment>  Environment (production, staging, development)
+  --save              Force save to file
+  --help              Show this help
+
+Examples:
+  node generate-secrets.js                                    # Generate one-time secrets
+  node generate-secrets.js --domain newclient --env production # Create domain secrets (reusable)
+  node generate-secrets.js --domain newclient                 # Reuse existing domain secrets
+        `);
+        process.exit(0);
+        break;
+    }
+  }
+  
+  return options;
+}
+
+// Run if called directly
+if (process.argv[1] && import.meta.url.endsWith(process.argv[1].replace(/\\/g, '/'))) {
+  const options = parseArgs();
+  generateSecrets(options);
+}
+
+export { generateSecret, generateSecrets };

package/scripts/utilities/safe-push.ps1

@@ -0,0 +1,51 @@
+# Clodo Framework - Safe Push Workflow
+# This script prevents the "rejected push" issue when working with semantic-release
+
+Write-Host "`nClodo Framework - Safe Push Workflow`n" -ForegroundColor Cyan
+
+# Step 1: Fetch latest changes
+Write-Host "Fetching latest changes from remote..." -ForegroundColor Yellow
+git fetch
+
+if ($LASTEXITCODE -ne 0) {
+    Write-Host "Failed to fetch from remote" -ForegroundColor Red
+    exit 1
+}
+
+# Step 2: Check if we're behind
+$behind = git rev-list HEAD..origin/master --count 2>$null
+if ($behind -gt 0) {
+    Write-Host "Local branch is $behind commit(s) behind remote" -ForegroundColor Yellow
+    Write-Host "Rebasing local changes on top of remote..." -ForegroundColor Yellow
+    
+    git rebase origin/master
+    
+    if ($LASTEXITCODE -ne 0) {
+        Write-Host "Rebase failed - resolve conflicts and run 'git rebase --continue'" -ForegroundColor Red
+        exit 1
+    }
+    
+    Write-Host "Rebase successful" -ForegroundColor Green
+} else {
+    Write-Host "Local branch is up to date" -ForegroundColor Green
+}
+
+# Step 3: Check if we're ahead (have commits to push)
+$ahead = git rev-list origin/master..HEAD --count 2>$null
+if ($ahead -eq 0) {
+    Write-Host "`nNothing to push - already up to date`n" -ForegroundColor Green
+    exit 0
+}
+
+Write-Host "Pushing $ahead commit(s) to remote..." -ForegroundColor Yellow
+
+# Step 4: Push
+git push
+
+if ($LASTEXITCODE -eq 0) {
+    Write-Host "`nPush successful!" -ForegroundColor Green
+    Write-Host "Semantic-release will run shortly and create a new version`n" -ForegroundColor Cyan
+} else {
+    Write-Host "`nPush failed" -ForegroundColor Red
+    exit 1
+}

package/scripts/utilities/setup-helpers.ps1

@@ -0,0 +1,206 @@
+# PowerShell Setup Helper Functions
+# Interactive setup utilities for Clodo Framework services
+
+function Get-UserInput {
+    param(
+        [Parameter(Mandatory=$true)]
+        [string]$Prompt,
+        
+        [Parameter(Mandatory=$false)]
+        [string]$DefaultValue = "",
+        
+        [Parameter(Mandatory=$false)]
+        [switch]$Required
+    )
+    
+    do {
+        if ($DefaultValue) {
+            $userInput = Read-Host "$Prompt [$DefaultValue]"
+            if ([string]::IsNullOrEmpty($userInput)) {
+                $userInput = $DefaultValue
+            }
+        } else {
+            $userInput = Read-Host $Prompt
+        }
+        
+        if ($Required -and [string]::IsNullOrEmpty($userInput)) {
+            Write-Host "This field is required. Please provide a value." -ForegroundColor Red
+        }
+    } while ($Required -and [string]::IsNullOrEmpty($userInput))
+    
+    return $userInput
+}
+
+function Get-UserChoice {
+    param(
+        [Parameter(Mandatory=$true)]
+        [string]$Prompt,
+        
+        [Parameter(Mandatory=$true)]
+        [string[]]$Options,
+        
+        [Parameter(Mandatory=$false)]
+        [int]$DefaultIndex = 0
+    )
+    
+    Write-Host $Prompt -ForegroundColor Yellow
+    
+    for ($i = 0; $i -lt $Options.Length; $i++) {
+        $marker = if ($i -eq $DefaultIndex) { " (default)" } else { "" }
+        Write-Host "  $($i + 1). $($Options[$i])$marker" -ForegroundColor White
+    }
+    
+    do {
+        $choice = Read-Host "Enter choice (1-$($Options.Length))"
+        
+        if ([string]::IsNullOrEmpty($choice)) {
+            return $Options[$DefaultIndex]
+        }
+        
+        if ([int]::TryParse($choice, [ref]$null)) {
+            $index = [int]$choice - 1
+            if ($index -ge 0 -and $index -lt $Options.Length) {
+                return $Options[$index]
+            }
+        }
+        
+        Write-Host "Invalid choice. Please select 1-$($Options.Length)." -ForegroundColor Red
+    } while ($true)
+}
+
+function Test-ServiceName {
+    param(
+        [Parameter(Mandatory=$true)]
+        [string]$ServiceName
+    )
+    
+    if ($ServiceName -notmatch '^[a-z0-9-]+$') {
+        return @{
+            Valid = $false
+            Error = "Service name must contain only lowercase letters, numbers, and hyphens"
+        }
+    }
+    
+    if ($ServiceName.Length -lt 3 -or $ServiceName.Length -gt 50) {
+        return @{
+            Valid = $false
+            Error = "Service name must be between 3 and 50 characters"
+        }
+    }
+    
+    return @{
+        Valid = $true
+        Error = $null
+    }
+}
+
+function Test-DomainName {
+    param(
+        [Parameter(Mandatory=$true)]
+        [string]$DomainName
+    )
+    
+    if ($DomainName -notmatch '^[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]*\.[a-zA-Z]{2,}$') {
+        return @{
+            Valid = $false
+            Error = "Domain name format is invalid"
+        }
+    }
+    
+    return @{
+        Valid = $true
+        Error = $null
+    }
+}
+
+function Show-SetupSummary {
+    param(
+        [Parameter(Mandatory=$true)]
+        [hashtable]$Configuration
+    )
+    
+    Write-Host "`n🔍 Configuration Summary:" -ForegroundColor Cyan
+    Write-Host "=========================" -ForegroundColor Cyan
+    
+    foreach ($key in $Configuration.Keys) {
+        $value = $Configuration[$key]
+        if ($key -like "*token*" -or $key -like "*secret*" -or $key -like "*key*") {
+            $value = "*" * 8 + $value.Substring([Math]::Max(0, $value.Length - 4))
+        }
+        Write-Host "  $key`: $value" -ForegroundColor White
+    }
+    
+    Write-Host "`nProceed with this configuration? (y/N)" -ForegroundColor Yellow -NoNewline
+    $confirm = Read-Host
+    
+    return $confirm -eq 'y' -or $confirm -eq 'Y' -or $confirm -eq 'yes'
+}
+
+function New-ServiceDirectory {
+    param(
+        [Parameter(Mandatory=$true)]
+        [string]$ServiceName,
+        
+        [Parameter(Mandatory=$true)]
+        [string]$OutputPath
+    )
+    
+    $servicePath = Join-Path $OutputPath $ServiceName
+    
+    if (Test-Path $servicePath) {
+        Write-Host "Directory already exists: $servicePath" -ForegroundColor Yellow
+        Write-Host "Overwrite existing directory? (y/N)" -ForegroundColor Yellow -NoNewline
+        $overwrite = Read-Host
+        
+        if ($overwrite -eq 'y' -or $overwrite -eq 'Y' -or $overwrite -eq 'yes') {
+            Remove-Item $servicePath -Recurse -Force
+        } else {
+            throw "Service directory already exists and user chose not to overwrite"
+        }
+    }
+    
+    New-Item -ItemType Directory -Path $servicePath -Force | Out-Null
+    Write-Host "✅ Created service directory: $servicePath" -ForegroundColor Green
+    
+    return $servicePath
+}
+
+function Get-ServiceTypeFeatures {
+    param(
+        [Parameter(Mandatory=$true)]
+        [string]$ServiceType
+    )
+    
+    $features = @{
+        "data-service" = @("Authentication", "Authorization", "File Storage", "Search", "Filtering", "Pagination")
+        "auth-service" = @("Authentication", "Authorization", "User Profiles", "Email Notifications", "Magic Link Auth")
+        "content-service" = @("File Storage", "Search", "Filtering", "Pagination", "Caching")
+        "api-gateway" = @("Authentication", "Authorization", "Rate Limiting", "Caching", "Monitoring")
+        "generic" = @("Logging", "Monitoring", "Error Reporting")
+    }
+    
+    return $features[$ServiceType] -or @()
+}
+
+function Show-WelcomeMessage {
+    Write-Host @"
+🚀 Clodo Framework Interactive Setup Wizard
+==========================================
+
+This wizard will guide you through creating a new Clodo service.
+You'll be prompted for the following information:
+
+• Service Name (required)
+• Service Type (required) 
+• Domain Name (required)
+• Cloudflare Configuration (required)
+• Additional Options (optional)
+
+Press Enter to continue or Ctrl+C to exit...
+"@ -ForegroundColor Cyan
+    
+    Read-Host
+}
+
+# Export functions for use by other scripts
+Export-ModuleMember -Function *

package/scripts/utilities/test-packaged-artifact.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+/**
+ * Test Packaged Artifact
+ *
+ * Steps:
+ * 1. Run npm pack and get tarball name
+ * 2. Create temp directory, initialize npm project
+ * 3. Install the tarball into temp project
+ * 4. Require the package and a couple of internal modules/cli entry points
+ *
+ * Exit non-zero on any failure.
+ */
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import os from 'os';
+
+const cwd = process.cwd();
+
+try {
+  console.log('Packing package...');
+  const tarball = execSync('npm pack', { cwd, stdio: 'pipe' }).toString().trim().split('\n').pop();
+  const tarPath = path.join(cwd, tarball);
+  console.log('Tarball:', tarPath);
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'clodo-pack-'));
+  console.log('Using temp dir:', tmpDir);
+  fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify({ name: 'clodo-test-temp', version: '0.0.0' }));
+
+  console.log('Installing tarball into temp project...');
+  execSync(`npm install "${tarPath}" --no-audit --no-fund --no-package-lock`, { cwd: tmpDir, stdio: 'inherit' });
+
+  console.log('Running smoke checks...');
+  // Run a node script that requires the package and exercises the CLI via installed bin
+  const nodeScript = `try {
+  const path = require('path');
+  const { execSync } = require('child_process');
+  const pkg = require('@tamyla/clodo-framework');
+  console.log('package loaded, exports count:', Object.keys(pkg).length);
+  // require a named export that is part of the public exports map
+  const services = require('@tamyla/clodo-framework/services');
+  console.log('named export services loaded');
+  // Verify middleware export and included migration script/docs
+  let middleware;
+  try {
+    middleware = require('@tamyla/clodo-framework/middleware');
+    console.log('middleware export loaded, keys:', Object.keys(middleware));
+  } catch (e) {
+    console.error('middleware export missing:', e && e.stack || e);
+    throw e;
+  }
+
+  if (!middleware || !middleware.MiddlewareComposer) {
+    throw new Error('MiddlewareComposer not exported from @tamyla/clodo-framework/middleware');
+  }
+
+  const migrationScript = path.join(process.cwd(), 'node_modules', '@tamyla', 'clodo-framework', 'scripts', 'migration', 'migrate-middleware-legacy-to-contract.js');
+  if (!require('fs').existsSync(migrationScript)) {
+    throw new Error('Migration script missing in packaged artifact: ' + migrationScript);
+  }
+  const migrationDoc = path.join(process.cwd(), 'node_modules', '@tamyla', 'clodo-framework', 'docs', 'MIDDLEWARE_MIGRATION_SUMMARY.md');
+  if (!require('fs').existsSync(migrationDoc)) {
+    throw new Error('Migration doc missing in packaged artifact: ' + migrationDoc);
+  }
+  // Execute CLI via the installed dist path to avoid shell wrapper issues on Windows
+  const pkgRoot = path.join(process.cwd(), 'node_modules', '@tamyla', 'clodo-framework');
+  const cliPath = path.join(pkgRoot, 'dist', 'cli', 'clodo-service.js');
+  // Run --version and --help to ensure CLI executes successfully
+  execSync('node ' + JSON.stringify(cliPath) + ' --version', { stdio: 'inherit' });
+  execSync('node ' + JSON.stringify(cliPath) + ' --help', { stdio: 'ignore' });
+  console.log('cli executed successfully');
+  process.exit(0);
+} catch (err) {
+  console.error('Smoke check failed:', err && err.stack || err);
+  process.exit(2);
+}
+`;
+
+  // Write the smoke script to a file in the temp project and run it directly to avoid shell quoting issues
+  const smokeScriptPath = path.join(tmpDir, 'smoke-test.js');
+  fs.writeFileSync(smokeScriptPath, nodeScript.replace(/\r\n/g, '\n'));
+  execSync(`node "${smokeScriptPath}"`, { cwd: tmpDir, stdio: 'inherit' });
+
+  console.log('\nAll packaged-artifact smoke checks passed.');
+  // Clean up tarball to avoid leaving artifacts
+  try { fs.unlinkSync(tarPath); } catch (e) {}
+  process.exit(0);
+} catch (err) {
+  console.error('\nPackaged artifact test failed:', err && err.stack || err);
+  process.exit(1);
+}

package/scripts/utilities/validate-dist-imports.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+
+/**
+ * CRITICAL: Pre-Publish Distribution Import Validator
+ * 
+ * This script ACTUALLY TESTS that all exports can be imported from dist/
+ * It catches import path issues that static validators miss.
+ * 
+ * Must run AFTER babel compilation (in postbuild)
+ * Prevents publishing packages with broken imports
+ * 
+ * Exit codes:
+ * - 0: All exports load successfully
+ * - 1: One or more imports failed
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.join(__dirname, '../../');
+const distPath = path.join(projectRoot, 'dist');
+
+// Color codes
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+};
+
+function log(color, text) {
+  console.log(`${color}${text}${colors.reset}`);
+}
+
+async function validateDistImports() {
+  log(colors.cyan, '\n╔═══════════════════════════════════════════════════════════════╗');
+  log(colors.cyan, '║  PRE-PUBLISH DISTRIBUTION IMPORT VALIDATOR                     ║');
+  log(colors.cyan, '║  Testing all exports with actual import attempts               ║');
+  log(colors.cyan, '╚═══════════════════════════════════════════════════════════════╝\n');
+
+  if (!fs.existsSync(distPath)) {
+    log(colors.red, '❌ ERROR: dist/ directory not found. Run "npm run build" first.');
+    process.exit(1);
+  }
+
+  const packageJson = JSON.parse(
+    fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8')
+  );
+
+  const exports = packageJson.exports;
+  const bins = packageJson.bin;
+
+  if (!exports) {
+    log(colors.red, '❌ ERROR: No exports defined in package.json');
+    process.exit(1);
+  }
+
+  let successCount = 0;
+  let failCount = 0;
+  const failures = [];
+
+  // Test main entry point with actual import
+  log(colors.blue, '📦 Testing Main Entry Point');
+  log(colors.blue, '─'.repeat(60));
+
+  try {
+    const mainPath = path.join(projectRoot, exports['.']);
+    if (!fs.existsSync(mainPath)) {
+      throw new Error(`Main entry not found: ${exports['.']}`);
+    }
+    
+    // Try to import main entry (using dynamic import)
+    try {
+      const fileUrl = `file://${mainPath}`;
+      await import(fileUrl);
+      log(colors.green, `✅ "${exports['.']}" exists and imports successfully`);
+    } catch (importErr) {
+      // File exists but import fails - this is a critical error
+      throw new Error(`Import failed: ${importErr.message}`);
+    }
+    successCount++;
+  } catch (e) {
+    log(colors.red, `❌ Main entry failed: ${e.message}`);
+    failures.push(`Main: ${e.message}`);
+    failCount++;
+  }
+
+  // Test all named exports (file existence only - imports on main tested)
+  log(colors.blue, '\n📚 Testing Named Exports (23+ files)');
+  log(colors.blue, '─'.repeat(60));
+
+  const exportEntries = Object.entries(exports).slice(1); // Skip main
+  const maxNameLength = Math.max(...exportEntries.map(([name]) => name.length));
+
+  for (const [name, exportPath] of exportEntries) {
+    try {
+      const fullPath = path.join(projectRoot, exportPath);
+
+      // Check file exists
+      if (!fs.existsSync(fullPath)) {
+        throw new Error(`File not found: ${exportPath}`);
+      }
+
+      // Check it's not a dist/internal/ export (these should be blocked)
+      if (exportPath.includes('dist/internal/')) {
+        throw new Error(`Internal export leaked to public API: ${exportPath}`);
+      }
+
+      // Check it's actually a .js file that can be imported
+      if (!exportPath.endsWith('.js')) {
+        throw new Error(`Invalid export path (must be .js): ${exportPath}`);
+      }
+
+      // Format output with consistent padding
+      const paddedName = name.padEnd(maxNameLength);
+      log(colors.green, `✅ ${paddedName} → ${exportPath}`);
+      successCount++;
+    } catch (e) {
+      const paddedName = name.padEnd(maxNameLength);
+      log(colors.red, `❌ ${paddedName} → ERROR: ${e.message}`);
+      failures.push(`${name}: ${e.message}`);
+      failCount++;
+    }
+  }
+
+  // Test CLI binaries
+  log(colors.blue, '\n🛠️  Testing CLI Binaries');
+  log(colors.blue, '─'.repeat(60));
+
+  for (const [binName, binPath] of Object.entries(bins || {})) {
+    try {
+      const fullPath = path.join(projectRoot, binPath);
+
+      if (!fs.existsSync(fullPath)) {
+        throw new Error(`Binary file not found: ${binPath}`);
+      }
+
+      // Check shebang for CLI files
+      const content = fs.readFileSync(fullPath, 'utf8');
+      if (!content.startsWith('#!/usr/bin/env node')) {
+        throw new Error(`Missing shebang in CLI binary`);
+      }
+
+      log(colors.green, `✅ ${binName.padEnd(20)} → ${binPath}`);
+      successCount++;
+    } catch (e) {
+      log(colors.red, `❌ ${binName.padEnd(20)} → ERROR: ${e.message}`);
+      failures.push(`CLI ${binName}: ${e.message}`);
+      failCount++;
+    }
+  }
+
+  // Summary
+  log(colors.blue, '\n' + '═'.repeat(60));
+  log(colors.blue, '📊 VALIDATION SUMMARY');
+  log(colors.blue, '═'.repeat(60));
+
+  log(colors.green, `✅ Successful: ${successCount}`);
+  if (failCount > 0) {
+    log(colors.red, `❌ Failed: ${failCount}`);
+    log(colors.yellow, '\n⚠️  FAILURES:');
+    failures.forEach((f, i) => {
+      log(colors.yellow, `   ${i + 1}. ${f}`);
+    });
+  }
+
+  const total = successCount + failCount;
+  const percentage = ((successCount / total) * 100).toFixed(1);
+
+  log(colors.blue, '\n' + '═'.repeat(60));
+  if (failCount === 0) {
+    log(colors.green, `✅ ALL ${successCount} EXPORTS VALIDATED SUCCESSFULLY`);
+    log(colors.green, `\n🎉 Package is ready for npm publication!\n`);
+    process.exit(0);
+  } else {
+    log(colors.red, `❌ VALIDATION FAILED: ${failCount}/${total} exports have issues`);
+    log(colors.red, `${percentage}% pass rate\n`);
+    process.exit(1);
+  }
+}
+
+validateDistImports().catch(err => {
+  log(colors.red, `\n❌ FATAL ERROR: ${err.message}\n`);
+  process.exit(1);
+});