@tamyla/clodo-framework 4.0.12 → 4.0.14

package/scripts/utilities/check-import-paths.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+/**
+ * Check Import Paths Validator
+ * 
+ * Validates that all re-export wrappers AND dynamic imports have correct paths that work
+ * when compiled to dist/. This prevents module resolution errors in published packages.
+ * 
+ * Purpose: Catch path issues BEFORE publication to npm
+ * 
+ * Checks:
+ * 1. Static imports in re-export wrappers (src/utils/)
+ * 2. Dynamic imports in bin/ files (must NOT reference dist/)
+ * 3. Compiled dist/ structure integrity
+ */
+
+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 RULES = {
+  // Re-export wrappers in src/utils/ compile to dist/utils/ and need paths that work in npm packages
+  // When installed via npm, only dist/ exists at package root level
+  // So paths must resolve correctly: dist/utils/X.js -> ../lib/ (one level up to dist, then lib)
+  
+  // Files at src/utils/X.js compile to dist/utils/X.js (2 levels deep) use '../lib/...'
+  'src/utils/file-manager.js': {
+    pattern: /from\s+['"]([^'"]+)['"]/,
+    shouldContain: '../lib/shared/utils/file-manager.js',
+    description: 'file-manager re-export wrapper (compiles with depth adjustment for npm)'
+  },
+  'src/utils/formatters.js': {
+    pattern: /from\s+['"]([^'"]+)['"]/,
+    shouldContain: '../lib/shared/utils/formatters.js',
+    description: 'formatters re-export wrapper (compiles with depth adjustment for npm)'
+  },
+  'src/utils/logger.js': {
+    pattern: /from\s+['"]([^'"]+)['"]/,
+    shouldContain: '../lib/shared/logging/Logger.js',
+    description: 'logger re-export wrapper (compiles with depth adjustment for npm)'
+  },
+  
+  // Files at src/utils/cloudflare/X.js compile to dist/utils/cloudflare/X.js (3 levels deep) use '../../lib/...'
+  'src/utils/cloudflare/ops.js': {
+    pattern: /from\s+['"]([^'"]+)['"]/,
+    shouldContain: '../../lib/shared/cloudflare/ops.js',
+    description: 'cloudflare ops re-export wrapper (3 levels, compiles with depth adjustment)'
+  }
+};
+
+// Check for problematic dynamic imports that reference dist/ from bin/
+const DYNAMIC_IMPORT_CHECKS = {
+  'lib/shared/cloudflare/ops.js': {
+    pattern: /import\(['"]([^'"]*dist[^'"]*)['"]\)/g,
+    shouldNotContain: 'dist/',
+    description: 'Dynamic imports in lib/ must not reference dist/ (causes dist/dist/ bug)'
+  }
+};
+
+let passCount = 0;
+let failCount = 0;
+const failures = [];
+
+console.log('\n🔍 Checking import paths in re-export wrappers...\n');
+
+for (const [filePath, rule] of Object.entries(RULES)) {
+  const fullPath = path.join(projectRoot, filePath);
+  
+  if (!fs.existsSync(fullPath)) {
+    console.log(`❌ MISSING: ${filePath}`);
+    failCount++;
+    failures.push(`File not found: ${filePath}`);
+    continue;
+  }
+
+  const content = fs.readFileSync(fullPath, 'utf8');
+  const match = content.match(rule.pattern);
+  
+  if (!match || match[1] !== rule.shouldContain) {
+    const actual = match ? match[1] : 'NOT FOUND';
+    console.log(`❌ INCORRECT PATH: ${filePath}`);
+    console.log(`   Expected: ${rule.shouldContain}`);
+    console.log(`   Actual:   ${actual}`);
+    console.log(`   (${rule.description})\n`);
+    failCount++;
+    failures.push(`${filePath}: expected "${rule.shouldContain}", got "${actual}"`);
+  } else {
+    console.log(`✅ CORRECT: ${filePath}`);
+    console.log(`   → ${rule.shouldContain}\n`);
+    passCount++;
+  }
+}
+
+// Check for problematic dynamic imports
+console.log('\n🔍 Checking dynamic imports in bin/ files...\n');
+
+for (const [filePath, rule] of Object.entries(DYNAMIC_IMPORT_CHECKS)) {
+  const fullPath = path.join(projectRoot, filePath);
+  
+  if (!fs.existsSync(fullPath)) {
+    console.log(`⚠️  SKIPPED: ${filePath} (file not found)`);
+    continue;
+  }
+
+  const content = fs.readFileSync(fullPath, 'utf8');
+  const matches = [...content.matchAll(rule.pattern)];
+  
+  if (matches.length > 0) {
+    console.log(`❌ PROBLEMATIC IMPORTS: ${filePath}`);
+    matches.forEach(match => {
+      console.log(`   → ${match[1]}`);
+    });
+    console.log(`   Issue: ${rule.description}\n`);
+    failCount += matches.length;
+    failures.push(`${filePath}: contains ${matches.length} dynamic import(s) referencing dist/`);
+  } else {
+    console.log(`✅ NO DIST/ IMPORTS: ${filePath}\n`);
+    passCount++;
+  }
+}
+
+// Check compiled dist paths
+console.log('\n📦 Verifying compiled dist/ structure...\n');
+
+const distFiles = [
+  'dist/utils/file-manager.js',
+  'dist/utils/formatters.js', 
+  'dist/utils/logger.js',
+  'dist/utils/cloudflare/ops.js'
+];
+
+for (const file of distFiles) {
+  const fullPath = path.join(projectRoot, file);
+  
+  if (!fs.existsSync(fullPath)) {
+    console.log(`❌ MISSING: ${file}`);
+    failCount++;
+    failures.push(`Compiled file not found: ${file}`);
+  } else {
+    console.log(`✅ EXISTS: ${file}`);
+    passCount++;
+  }
+}
+
+// Check dist/cli/ and dist/lib/ exist
+console.log('\n📂 Verifying cli/ and lib/ were compiled to dist/...\n');
+
+const cliPath = path.join(projectRoot, 'dist/cli');
+const libPath = path.join(projectRoot, 'dist/lib');
+
+if (!fs.existsSync(cliPath)) {
+  console.log(`❌ MISSING: dist/cli/ directory`);
+  failCount++;
+  failures.push('dist/cli/ directory not found - cli/ not compiled');
+} else {
+  console.log(`✅ EXISTS: dist/cli/ directory`);
+  passCount++;
+}
+
+if (!fs.existsSync(libPath)) {
+  console.log(`❌ MISSING: dist/lib/ directory`);
+  failCount++;
+  failures.push('dist/lib/ directory not found - lib/ not compiled');
+} else {
+  console.log(`✅ EXISTS: dist/lib/ directory\n`);
+  passCount++;
+}
+
+// Summary
+console.log(`\n${'='.repeat(60)}`);
+console.log(`Validation Results: ${passCount} passed, ${failCount} failed`);
+console.log(`${'='.repeat(60)}\n`);
+
+if (failCount > 0) {
+  console.log('❌ PATH VALIDATION FAILED\n');
+  console.log('Issues found:');
+  failures.forEach(f => console.log(`  • ${f}`));
+  console.log('\nRecommendations:');
+  console.log('1. Ensure all src/utils/*.js re-export wrappers use "../../bin/shared/..." paths');
+  console.log('2. These paths must work AFTER Babel compilation to dist/');
+  console.log('3. Run: npm run build && npm run check:imports\n');
+  process.exit(1);
+} else {
+  console.log('✅ ALL PATHS VALID\n');
+  console.log('The re-export wrappers are correctly configured for the npm package.');
+  console.log('Users should not encounter ERR_MODULE_NOT_FOUND errors.\n');
+  process.exit(0);
+}

package/scripts/utilities/cleanup-cli.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+/**
+ * Data Cleanup CLI Tool
+ * Provides command-line access to data cleanup operations
+ */
+
+import { initD1Client } from '../../src/shared/clients/d1/index.js';
+import { readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+// Load environment variables
+const env = {
+  NODE_ENV: process.env.NODE_ENV || 'development',
+  ...process.env
+};
+
+// Initialize D1 client
+let d1Client;
+try {
+  // For local development, we need to handle the database binding
+  if (env.NODE_ENV === 'development') {
+    // Create a mock database binding for development
+    env.DB = {}; // This will trigger in-memory database creation
+  }
+
+  d1Client = await initD1Client(env);
+
+  // Wait for the client to be fully initialized
+  await new Promise((resolve) => {
+    const checkInit = () => {
+      if (d1Client._isInitialized || d1Client.db) {
+        resolve();
+      } else {
+        setTimeout(checkInit, 10);
+      }
+    };
+    checkInit();
+  });
+
+} catch (error) {
+  console.error('Failed to initialize D1 client:', error.message);
+  process.exit(1);
+}
+
+const command = process.argv[2];
+const args = process.argv.slice(3);
+
+async function main() {
+  try {
+    switch (command) {
+      case 'stats': {
+        console.log('📊 Getting database statistics...');
+        const stats = await d1Client.getDatabaseStats();
+        console.log(JSON.stringify(stats, null, 2));
+        break;
+      }
+
+      case 'backup': {
+        console.log('💾 Creating database backup...');
+        const backup = await d1Client.createBackup({ reason: args[0] || 'CLI backup' });
+
+        const filename = `backup_${backup.id}.sql`;
+        writeFileSync(filename, backup.content);
+        console.log(`✅ Backup saved to: ${filename}`);
+        console.log(`📊 Records backed up: ${backup.totalRecords}`);
+        break;
+      }
+
+      case 'clear-old': {
+        const days = parseInt(args[0]);
+        if (!days || days < 1) {
+          console.error('❌ Please specify number of days (e.g., clear-old 90)');
+          process.exit(1);
+        }
+
+        console.log(`🗑️ Clearing data older than ${days} days...`);
+        const oldResult = await d1Client.safeCleanup('CLEAR_OLD', { daysOld: days });
+        console.log('✅ Old data cleared:', JSON.stringify(oldResult, null, 2));
+        break;
+      }
+
+      case 'clear-user': {
+        const userId = args[0];
+        if (!userId) {
+          console.error('❌ Please specify user ID (e.g., clear-user user123)');
+          process.exit(1);
+        }
+
+        console.log(`🗑️ Clearing data for user: ${userId}`);
+        const userResult = await d1Client.safeCleanup('CLEAR_USER', { userId });
+        console.log('✅ User data cleared:', JSON.stringify(userResult, null, 2));
+        break;
+      }
+
+      case 'clear-all': {
+        if (env.NODE_ENV === 'production') {
+          console.error('❌ CLEAR ALL operation blocked in production environment');
+          console.log('💡 Use selective cleanup operations instead');
+          process.exit(1);
+        }
+
+        console.log('🗑️ Clearing ALL data (this will delete everything!)...');
+        const confirm = args.includes('--confirm');
+        if (!confirm) {
+          console.log('⚠️ This operation will delete ALL data permanently');
+          console.log('💡 Add --confirm flag to proceed');
+          process.exit(1);
+        }
+
+        const allResult = await d1Client.safeCleanup('CLEAR_ALL');
+        console.log('✅ All data cleared:', JSON.stringify(allResult, null, 2));
+        break;
+      }
+
+      case 'validate': {
+        const operation = args[0];
+        const params = {};
+
+        if (operation === 'CLEAR_OLD') params.daysOld = parseInt(args[1]);
+        if (operation === 'CLEAR_USER') params.userId = args[1];
+
+        console.log(`🔍 Validating operation: ${operation}`);
+        const validation = await d1Client.validateCleanupOperation(operation, params);
+        console.log(JSON.stringify(validation, null, 2));
+        break;
+      }
+
+      default:
+        console.log('🧹 Data Cleanup CLI Tool');
+        console.log('');
+        console.log('Usage: node scripts/cleanup-cli.js <command> [args...]');
+        console.log('');
+        console.log('Commands:');
+        console.log('  stats                    Show database statistics');
+        console.log('  backup [reason]          Create database backup');
+        console.log('  clear-old <days>         Clear data older than X days');
+        console.log('  clear-user <userId>      Clear all data for a user');
+        console.log('  clear-all --confirm      Clear ALL data (dangerous!)');
+        console.log('  validate <op> [params]   Validate if operation is safe');
+        console.log('');
+        console.log('Examples:');
+        console.log('  node scripts/cleanup-cli.js stats');
+        console.log('  node scripts/cleanup-cli.js backup "Pre-deployment backup"');
+        console.log('  node scripts/cleanup-cli.js clear-old 90');
+        console.log('  node scripts/cleanup-cli.js clear-user user123');
+        console.log('  node scripts/cleanup-cli.js validate CLEAR_OLD 90');
+        break;
+    }
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  }
+}
+
+main().catch(error => {
+  console.error('❌ Unexpected error:', error);
+  process.exit(1);
+});

package/scripts/utilities/deployment-helpers.ps1

@@ -0,0 +1,199 @@
+# PowerShell Deployment Helper Functions
+# Common utilities for Clodo Framework deployment scripts
+
+function Write-DeploymentLog {
+    param(
+        [Parameter(Mandatory=$true)]
+        [string]$Message,
+        
+        [Parameter(Mandatory=$false)]
+        [ValidateSet("Info", "Warning", "Error", "Success")]
+        [string]$Level = "Info"
+    )
+    
+    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
+    $color = switch ($Level) {
+        "Info"    { "White" }
+        "Warning" { "Yellow" }
+        "Error"   { "Red" }
+        "Success" { "Green" }
+        default   { "White" }
+    }
+    
+    Write-Host "[$timestamp] $Level`: $Message" -ForegroundColor $color
+}
+
+function Test-Prerequisites {
+    param(
+        [Parameter(Mandatory=$false)]
+        [string[]]$RequiredCommands = @("node", "npm", "wrangler")
+    )
+    
+    Write-DeploymentLog "Checking prerequisites..." "Info"
+    
+    $allPresent = $true
+    foreach ($cmd in $RequiredCommands) {
+        try {
+            $null = Get-Command $cmd -ErrorAction Stop
+            Write-DeploymentLog "✓ $cmd is available" "Success"
+        }
+        catch {
+            Write-DeploymentLog "✗ $cmd is not available" "Error"
+            $allPresent = $false
+        }
+    }
+    
+    return $allPresent
+}
+
+function Test-EnvironmentVariables {
+    param(
+        [Parameter(Mandatory=$true)]
+        [string[]]$RequiredVars
+    )
+    
+    Write-DeploymentLog "Checking environment variables..." "Info"
+    
+    $allPresent = $true
+    foreach ($var in $RequiredVars) {
+        $value = [System.Environment]::GetEnvironmentVariable($var)
+        if ([string]::IsNullOrEmpty($value)) {
+            Write-DeploymentLog "✗ Environment variable $var is not set" "Error"
+            $allPresent = $false
+        } else {
+            Write-DeploymentLog "✓ $var is set" "Success"
+        }
+    }
+    
+    return $allPresent
+}
+
+function Invoke-SafeCommand {
+    param(
+        [Parameter(Mandatory=$true)]
+        [string]$Command,
+        
+        [Parameter(Mandatory=$false)]
+        [string]$WorkingDirectory = $PWD,
+        
+        [Parameter(Mandatory=$false)]
+        [switch]$DryRun
+    )
+    
+    if ($DryRun) {
+        Write-DeploymentLog "[DRY RUN] Would execute: $Command" "Warning"
+        return @{
+            Success = $true
+            Output = "[DRY RUN] Command not executed"
+        }
+    }
+    
+    try {
+        Write-DeploymentLog "Executing: $Command" "Info"
+        $output = Invoke-Expression $Command -ErrorAction Stop
+        Write-DeploymentLog "Command completed successfully" "Success"
+        
+        return @{
+            Success = $true
+            Output = $output
+        }
+    }
+    catch {
+        Write-DeploymentLog "Command failed: $($_.Exception.Message)" "Error"
+        
+        return @{
+            Success = $false
+            Error = $_.Exception.Message
+        }
+    }
+}
+
+function Test-FileExists {
+    param(
+        [Parameter(Mandatory=$true)]
+        [string]$FilePath,
+        
+        [Parameter(Mandatory=$false)]
+        [string]$Description = "file"
+    )
+    
+    if (Test-Path $FilePath) {
+        Write-DeploymentLog "✓ $Description exists: $FilePath" "Success"
+        return $true
+    } else {
+        Write-DeploymentLog "✗ $Description not found: $FilePath" "Error"
+        return $false
+    }
+}
+
+function Get-ServiceConfiguration {
+    param(
+        [Parameter(Mandatory=$true)]
+        [string]$ConfigPath
+    )
+    
+    Write-DeploymentLog "Loading service configuration from: $ConfigPath" "Info"
+    
+    try {
+        if (Test-Path $ConfigPath) {
+            $content = Get-Content $ConfigPath -Raw
+            Write-DeploymentLog "Configuration loaded successfully" "Success"
+            return $content
+        } else {
+            throw "Configuration file not found: $ConfigPath"
+        }
+    }
+    catch {
+        Write-DeploymentLog "Failed to load configuration: $($_.Exception.Message)" "Error"
+        throw
+    }
+}
+
+function Start-DeploymentProcess {
+    param(
+        [Parameter(Mandatory=$true)]
+        [string]$ServiceName,
+        
+        [Parameter(Mandatory=$true)]
+        [string]$Environment,
+        
+        [Parameter(Mandatory=$false)]
+        [switch]$DryRun
+    )
+    
+    $startTime = Get-Date
+    Write-DeploymentLog "Starting deployment for $ServiceName ($Environment)" "Info"
+    Write-DeploymentLog "Deployment started at: $startTime" "Info"
+    
+    return @{
+        ServiceName = $ServiceName
+        Environment = $Environment
+        StartTime = $startTime
+        DryRun = $DryRun.IsPresent
+    }
+}
+
+function Complete-DeploymentProcess {
+    param(
+        [Parameter(Mandatory=$true)]
+        [hashtable]$DeploymentInfo,
+        
+        [Parameter(Mandatory=$true)]
+        [bool]$Success
+    )
+    
+    $endTime = Get-Date
+    $duration = $endTime - $DeploymentInfo.StartTime
+    
+    if ($Success) {
+        Write-DeploymentLog "✅ Deployment completed successfully" "Success"
+    } else {
+        Write-DeploymentLog "❌ Deployment failed" "Error"
+    }
+    
+    Write-DeploymentLog "Deployment duration: $($duration.ToString('hh\:mm\:ss'))" "Info"
+    Write-DeploymentLog "Deployment ended at: $endTime" "Info"
+}
+
+# Export functions for use by other scripts
+Export-ModuleMember -Function *

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

@@ -0,0 +1,135 @@
+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, '../..');
+
+/**
+ * Minimal import path fix for dist/ after Babel compilation
+ * 
+ * NOTE: This script should do MINIMAL changes. Babel preserves relative imports
+ * from source files, so most imports are already correct.
+ * 
+ * Fix:
+ * 1. CLI commands that reference ../lib/ instead of ../../lib/ (depth mismatch)
+ * 2. CLI commands that reference ../config/ instead of ../../config/
+ * 3. CLI commands that reference ../service-management/ instead of ../../service-management/
+ * 4. Files importing ../../../dist/utils/ should be ../../../utils/
+ * 5. Files in dist/utils/ importing ../../../lib/shared/ should be ../../lib/shared/
+ * 6. Files in dist/lib/shared/ importing ../../../src/utils/ should be ../../utils/
+ * 
+ * DO NOT apply aggressive global replacements - they break things!
+ */
+function fixDistImports(dir) {
+  const fullDir = path.join(projectRoot, dir);
+  if (!fs.existsSync(fullDir)) return;
+  
+  const files = fs.readdirSync(fullDir, { recursive: true });
+  files.forEach(file => {
+    const filePath = path.join(fullDir, file);
+    if (fs.statSync(filePath).isFile() && filePath.endsWith('.js')) {
+      let content = fs.readFileSync(filePath, 'utf8');
+      const original = content;
+      const relPath = path.relative(projectRoot, filePath);
+      
+      // Only fix CLI command imports
+      // Files in dist/cli/commands/ are 2 levels deep and need ../../ to reach dist root
+      if (relPath.startsWith('dist/cli/commands/')) {
+        // Fix imports that incorrectly have ../lib/ instead of ../../lib/
+        content = content.replace(/from\s+['"]\.\.\/lib\//g, "from '../../lib/");
+        // Fix imports that incorrectly have ../config/ instead of ../../config/
+        content = content.replace(/from\s+['"]\.\.\/config\//g, "from '../../config/");
+        // Fix imports that incorrectly have ../service-management/ instead of ../../service-management/
+        content = content.replace(/from\s+['"]\.\.\/service-management\//g, "from '../../service-management/");
+        
+        // Also fix dynamic imports with import()
+        content = content.replace(/import\(['"]\.\.\/lib\//g, "import('../../lib/");
+        content = content.replace(/import\(['"]\.\.\/config\//g, "import('../../config/");
+        content = content.replace(/import\(['"]\.\.\/service-management\//g, "import('../../service-management/");
+      }
+      
+      // Fix imports in all dist/ files
+      if (relPath.startsWith('dist')) {
+        // Fix ../../../src/utils/ to ../../utils/ for files in dist/lib/shared/
+        if (relPath.includes('dist/lib/shared/') || relPath.includes('dist\\lib\\shared\\')) {
+          content = content.replace(/\.\.\/\.\.\/\.\.\/src\/utils\//g, "../../utils/");
+        }
+        
+        const normalizedRelPath = relPath.replace(/\\/g, '/');
+        const pathDepth = normalizedRelPath.split('/').length;
+        
+        // Fix ../../lib/shared/ to ../lib/shared/ for files at depth 2: dist/<dir>/<file>.js
+        // Example: dist/database/database-orchestrator.js importing ../../lib/shared/utils/framework-config.js
+        // Should become: ../lib/shared/utils/framework-config.js
+        if (pathDepth === 3 && normalizedRelPath.match(/^dist\/[^\/]+\/[^\/]+\.js$/)) {
+          // File is at depth 2: dist/<dir>/<file>.js
+          // Fix specific shared lib imports
+          content = content.replace(/from\s+(['"])\.\.\/\.\.\/lib\/shared\//g, "from $1../lib/shared/");
+          content = content.replace(/import\s*\(\s*(['"])\.\.\/\.\.\/lib\/shared\//g, "import($1../lib/shared/");
+          // Fix generic lib imports (e.g. ../../lib/database/.. -> ../lib/database/...)
+          content = content.replace(/from\s+(['"])\.\.\/\.\.\/lib\//g, "from $1../lib/");
+          content = content.replace(/import\s*\(\s*(['"])\.\.\/\.\.\/lib\//g, "import($1../lib/");
+        }
+        
+        // Fix ../../../lib/shared/ to ../../lib/shared/ for files at depth 3: dist/<dir>/<subdir>/<file>.js
+        // Example: dist/deployment/orchestration/BaseDeploymentOrchestrator.js importing ../../../lib/shared/utils/ErrorHandler.js
+        // Should become: ../../lib/shared/utils/ErrorHandler.js
+        if (pathDepth === 4 && normalizedRelPath.match(/^dist\/[^\/]+\/[^\/]+\/[^\/]+\.js$/)) {
+          // File is at depth 3: dist/<dir>/<subdir>/<file>.js
+          content = content.replace(/from\s+(['"])\.\.\/\.\.\/\.\.\/lib\/shared\//g, "from $1../../lib/shared/");
+          content = content.replace(/import\s*\(\s*(['"])\.\.\/\.\.\/\.\.\/lib\/shared\//g, "import($1../../lib/shared/");
+        }
+        
+        // Fix ../../../lib/shared/ to ../../lib/shared/ for files in dist/utils/ subdirectories
+        // Example: dist/utils/deployment/config-cache.js importing ../../../lib/shared/utils/framework-config.js
+        // Should become: ../../lib/shared/utils/framework-config.js
+        if (normalizedRelPath.match(/^dist\/utils\/[^\/]+\/[^\/]+\.js$/)) {
+          // File is at depth 3: dist/utils/<subdir>/<file>.js
+          content = content.replace(/from\s+(['"])\.\.\/\.\.\/\.\.\/lib\/shared\//g, "from $1../../lib/shared/");
+          content = content.replace(/import\s*\(\s*(['"])\.\.\/\.\.\/\.\.\/lib\/shared\//g, "import($1../../lib/shared/");
+        }
+        
+        // Fix ../../../lib/shared/ to ../../lib/shared/ for files in dist/service-management/ subdirectories
+        if (normalizedRelPath.match(/^dist\/service-management\/[^\/]+\/[^\/]+\.js$/)) {
+          content = content.replace(/from\s+(['"])\.\.\/\.\.\/\.\.\/lib\/shared\//g, "from $1../../lib/shared/");
+          content = content.replace(/import\s*\(\s*(['"])\.\.\/\.\.\/\.\.\/lib\/shared\//g, "import($1../../lib/shared/");
+        }
+        // Fix ../../../../lib/ to ../../../lib/ for deeper nested files in dist/service-management (e.g. generators/config/...)
+        if (normalizedRelPath.startsWith('dist/service-management/')) {
+          content = content.replace(/from\s+(['"])\.\.\/\.\.\/\.\.\/lib\/shared\//g, "from $1../../../lib/shared/");
+          content = content.replace(/from\s+(['"])\.\.\/\.\.\/\.\.\/lib\//g, "from $1../../../lib/");
+          content = content.replace(/import\s*\(\s*(['"])\.\.\/\.\.\/\.\.\/lib\/shared\//g, "import($1../../../lib/shared/");
+          content = content.replace(/import\s*\(\s*(['"])\.\.\/\.\.\/\.\.\/lib\//g, "import($1../../../lib/");
+        }
+
+        // Specific fix for generators/config files that had one extra ../ and still resolve outside dist
+        if (normalizedRelPath.match(/^dist\/service-management\/generators\/config\/.+\.js$/)) {
+          content = content.replace(/from\s+(['"])\.\.\/\.\.\/\.\.\/lib\/shared\/utils\//g, "from $1../../../lib/shared/utils/");
+          content = content.replace(/from\s+(['"])\.\.\/\.\.\/\.\.\/lib\/shared\//g, "from $1../../../lib/shared/");
+          content = content.replace(/from\s+(['"])\.\.\/\.\.\/\.\.\/lib\/utils\//g, "from $1../../../lib/utils/");
+          content = content.replace(/from\s+(['"])\.\.\/\.\.\/\.\.\/lib\//g, "from $1../../../lib/");
+        }
+
+        // General fix: convert four-level '../../../../lib/' imports to '../../../lib/' across dist/
+        // This handles deeply nested files that mistakenly reference project root lib/ (outside dist)
+        content = content.replace(/(\.\.\/){4}lib\//g, "../../../lib/");
+        content = content.replace(/import\s*\(\s*(['"])(?:\.\.\/){4}lib\//g, "import($1../../../lib/");
+
+        // Fix ../lib/ to ./lib/ for files directly in dist/ root (like index.js)
+        if (normalizedRelPath.startsWith('dist/') && pathDepth === 2 && normalizedRelPath.endsWith('.js')) {
+          content = content.replace(/\.\.\/lib\//g, "./lib/");
+        }
+      }
+      
+      if (content !== original) {
+        fs.writeFileSync(filePath, content);
+        console.log('✅ Fixed dist import:', relPath);
+      }
+    }
+  });
+}
+
+// Process all dist/ where the fixes are needed
+fixDistImports('dist');
+console.log('✅ Dist import path fixes completed');