@tamyla/clodo-framework 3.1.14 → 3.1.15

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [3.1.15](https://github.com/tamylaa/clodo-framework/compare/v3.1.14...v3.1.15) (2025-10-28)
+
+
+### Bug Fixes
+
+* Complete comprehensive clodo-framework refactoring (Tasks 3.1-3.4) ([0949b8b](https://github.com/tamylaa/clodo-framework/commit/0949b8be5f4f6522c0e4e4050e858ce82be5d034))
+
 ## [3.1.14](https://github.com/tamylaa/clodo-framework/compare/v3.1.13...v3.1.14) (2025-10-27)
 
 

package/dist/bin/commands/assess.js

@@ -4,16 +4,43 @@
  */
 
 import chalk from 'chalk';
+import { StandardOptions } from '../shared/utils/cli-options.js';
+import { ConfigLoader } from '../shared/utils/config-loader.js';
 export function registerAssessCommand(program) {
-  program.command('assess [service-path]').description('Run intelligent capability assessment (requires @tamyla/clodo-orchestration)').option('--export <file>', 'Export assessment results to JSON file').option('--domain <domain>', 'Domain name for assessment').option('--service-type <type>', 'Service type for assessment').option('--token <token>', 'Cloudflare API token').action(async (servicePath, options) => {
+  const command = program.command('assess [service-path]').description('Run intelligent capability assessment (requires @tamyla/clodo-orchestration)').option('--export <file>', 'Export assessment results to JSON file').option('--domain <domain>', 'Domain name for assessment').option('--service-type <type>', 'Service type for assessment').option('--token <token>', 'Cloudflare API token');
+
+  // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
+  StandardOptions.define(command).action(async (servicePath, options) => {
     try {
+      const output = new (await import('../shared/utils/output-formatter.js')).OutputFormatter(options);
+      const configLoader = new ConfigLoader({
+        verbose: options.verbose,
+        quiet: options.quiet,
+        json: options.json
+      });
+
+      // Load config from file if specified
+      let configFileData = {};
+      if (options.configFile) {
+        configFileData = configLoader.loadSafe(options.configFile, {});
+        if (options.verbose && !options.quiet) {
+          output.info(`Loaded configuration from: ${options.configFile}`);
+        }
+      }
+
+      // Substitute environment variables
+      configFileData = configLoader.substituteEnvironmentVariables(configFileData);
+
+      // Merge config file defaults with CLI options (CLI takes precedence)
+      const mergedOptions = configLoader.merge(configFileData, options);
+
       // Try to load professional orchestration package
       let orchestrationModule;
       try {
         orchestrationModule = await import('@tamyla/clodo-orchestration');
       } catch (err) {
-        console.error(chalk.red('❌ clodo-orchestration package not found'));
-        console.error(chalk.yellow('💡 Install with: npm install @tamyla/clodo-orchestration'));
+        output.error('❌ clodo-orchestration package not found');
+        output.info('💡 Install with: npm install @tamyla/clodo-orchestration');
         process.exit(1);
       }
       const {
@@ -22,53 +49,41 @@ export function registerAssessCommand(program) {
         runAssessmentWorkflow
       } = orchestrationModule;
       const targetPath = servicePath || process.cwd();
-      console.log(chalk.cyan('\n🧠 Professional Capability Assessment'));
-      console.log(chalk.gray('─'.repeat(60)));
-      console.log(chalk.white(`Service Path: ${targetPath}`));
-      if (options.domain) {
-        console.log(chalk.white(`Domain: ${options.domain}`));
-      }
-      if (options.serviceType) {
-        console.log(chalk.white(`Service Type: ${options.serviceType}`));
-      }
-      console.log(chalk.gray('─'.repeat(60)));
+      output.section('Professional Capability Assessment');
+      output.list([`Service Path: ${targetPath}`, mergedOptions.domain ? `Domain: ${mergedOptions.domain}` : null, mergedOptions.serviceType ? `Service Type: ${mergedOptions.serviceType}` : null].filter(Boolean));
 
       // Use the assessment workflow
       const assessment = await runAssessmentWorkflow({
         servicePath: targetPath,
-        domain: options.domain,
-        serviceType: options.serviceType,
-        token: options.token || process.env.CLOUDFLARE_API_TOKEN
+        domain: mergedOptions.domain,
+        serviceType: mergedOptions.serviceType,
+        token: mergedOptions.token || process.env.CLOUDFLARE_API_TOKEN
       });
 
       // Display results
-      console.log(chalk.cyan('\n✅ Assessment Results'));
-      console.log(chalk.gray('─'.repeat(60)));
-      console.log(chalk.white(`Service Type: ${assessment.mergedInputs?.serviceType || assessment.serviceType || 'Not determined'}`));
-      console.log(chalk.white(`Confidence: ${assessment.confidence}%`));
+      output.section('✅ Assessment Results');
+      output.list([`Service Type: ${assessment.mergedInputs?.serviceType || assessment.serviceType || 'Not determined'}`, `Confidence: ${assessment.confidence}%`]);
       if (assessment.gapAnalysis?.missing) {
-        console.log(chalk.white(`Missing Capabilities: ${assessment.gapAnalysis.missing.length}`));
         if (assessment.gapAnalysis.missing.length > 0) {
-          console.log(chalk.yellow('\n⚠️  Missing:'));
-          assessment.gapAnalysis.missing.forEach(gap => {
-            console.log(chalk.yellow(`   • ${gap.capability}: ${gap.reason || 'Not available'}`));
-          });
+          output.warning('⚠️  Missing Capabilities:');
+          const missingItems = assessment.gapAnalysis.missing.map(gap => `${gap.capability}: ${gap.reason || 'Not available'}`);
+          output.list(missingItems);
         }
       }
-      console.log(chalk.gray('─'.repeat(60)));
 
       // Export results if requested
-      if (options.export) {
+      if (mergedOptions.export) {
         const {
           writeFileSync
         } = await import('fs');
-        writeFileSync(options.export, JSON.stringify(assessment, null, 2));
-        console.log(chalk.green(`\n📄 Results exported to: ${options.export}`));
+        writeFileSync(mergedOptions.export, JSON.stringify(assessment, null, 2));
+        output.success(`📄 Results exported to: ${mergedOptions.export}`);
       }
     } catch (error) {
-      console.error(chalk.red(`Assessment failed: ${error.message}`));
+      const output = new (await import('../shared/utils/output-formatter.js')).OutputFormatter(options || {});
+      output.error(`Assessment failed: ${error.message}`);
       if (process.env.DEBUG) {
-        console.error(chalk.gray(error.stack));
+        output.debug(error.stack);
       }
       process.exit(1);
     }

package/dist/bin/commands/create.js

@@ -7,48 +7,69 @@
 
 import chalk from 'chalk';
 import { ServiceOrchestrator } from "../../service-management/ServiceOrchestrator.js";
+import { StandardOptions } from '../shared/utils/cli-options.js';
+import { ConfigLoader } from '../shared/utils/config-loader.js';
 export function registerCreateCommand(program) {
-  program.command('create').description('Create a new Clodo service with conversational setup').option('-n, --non-interactive', 'Run in non-interactive mode with all required parameters').option('--service-name <name>', 'Service name (required in non-interactive mode)').option('--service-type <type>', 'Service type: data-service, auth-service, content-service, api-gateway, generic', 'generic').option('--domain-name <domain>', 'Domain name (required in non-interactive mode)').option('--cloudflare-token <token>', 'Cloudflare API token (required in non-interactive mode)').option('--cloudflare-account-id <id>', 'Cloudflare account ID (required in non-interactive mode)').option('--cloudflare-zone-id <id>', 'Cloudflare zone ID (required in non-interactive mode)').option('--environment <env>', 'Target environment: development, staging, production', 'development').option('--output-path <path>', 'Output directory for generated service', '.').option('--template-path <path>', 'Path to service templates', './templates').action(async options => {
+  const command = program.command('create').description('Create a new Clodo service with conversational setup').option('-n, --non-interactive', 'Run in non-interactive mode with all required parameters').option('--service-name <name>', 'Service name (required in non-interactive mode)').option('--service-type <type>', 'Service type: data-service, auth-service, content-service, api-gateway, generic', 'generic').option('--domain-name <domain>', 'Domain name (required in non-interactive mode)').option('--cloudflare-token <token>', 'Cloudflare API token (required in non-interactive mode)').option('--cloudflare-account-id <id>', 'Cloudflare account ID (required in non-interactive mode)').option('--cloudflare-zone-id <id>', 'Cloudflare zone ID (required in non-interactive mode)').option('--environment <env>', 'Target environment: development, staging, production', 'development').option('--output-path <path>', 'Output directory for generated service', '.').option('--template-path <path>', 'Path to service templates', './templates').option('--force', 'Skip confirmation prompts').option('--validate', 'Validate service after creation');
+
+  // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
+  StandardOptions.define(command).action(async options => {
     try {
+      const output = new (await import('../shared/utils/output-formatter.js')).OutputFormatter(options);
+      const configLoader = new ConfigLoader({
+        verbose: options.verbose,
+        quiet: options.quiet,
+        json: options.json
+      });
+
+      // Load config from file if specified
+      let configFileData = {};
+      if (options.configFile) {
+        configFileData = configLoader.loadSafe(options.configFile, {});
+        if (options.verbose && !options.quiet) {
+          output.info(`Loaded configuration from: ${options.configFile}`);
+        }
+      }
+
+      // Merge config file defaults with CLI options (CLI takes precedence)
+      const mergedOptions = configLoader.merge(configFileData, options);
       const orchestrator = new ServiceOrchestrator({
-        interactive: !options.nonInteractive,
-        outputPath: options.outputPath,
-        templatePath: options.templatePath
+        interactive: !mergedOptions.nonInteractive,
+        outputPath: mergedOptions.outputPath,
+        templatePath: mergedOptions.templatePath
       });
-      if (options.nonInteractive) {
+      if (mergedOptions.nonInteractive) {
         // Validate required parameters for non-interactive mode
         const required = ['serviceName', 'domainName', 'cloudflareToken', 'cloudflareAccountId', 'cloudflareZoneId'];
-        const missing = required.filter(key => !options[key]);
+        const missing = required.filter(key => !mergedOptions[key]);
         if (missing.length > 0) {
-          console.error(chalk.red(`Missing required parameters: ${missing.join(', ')}`));
-          console.error(chalk.yellow('Use --help for parameter details'));
+          output.error(`Missing required parameters: ${missing.join(', ')}`);
+          output.info('Use --help for parameter details');
           process.exit(1);
         }
 
-        // Convert CLI options to core inputs
+        // Convert merged options to core inputs
         const coreInputs = {
-          serviceName: options.serviceName,
-          serviceType: options.serviceType,
-          domainName: options.domainName,
-          cloudflareToken: options.cloudflareToken,
-          cloudflareAccountId: options.cloudflareAccountId,
-          cloudflareZoneId: options.cloudflareZoneId,
-          environment: options.environment
+          serviceName: mergedOptions.serviceName,
+          serviceType: mergedOptions.serviceType,
+          domainName: mergedOptions.domainName,
+          cloudflareToken: mergedOptions.cloudflareToken,
+          cloudflareAccountId: mergedOptions.cloudflareAccountId,
+          cloudflareZoneId: mergedOptions.cloudflareZoneId,
+          environment: mergedOptions.environment
         };
         await orchestrator.runNonInteractive(coreInputs);
       } else {
         await orchestrator.runInteractive();
       }
-      console.log(chalk.green('\n✓ Service creation completed successfully!'));
-      console.log(chalk.cyan('Next steps:'));
-      console.log(chalk.white('  1. cd into your new service directory'));
-      console.log(chalk.white('  2. Run npm install'));
-      console.log(chalk.white('  3. Configure additional settings in src/config/domains.js'));
-      console.log(chalk.white('  4. Run npm run deploy to deploy to Cloudflare'));
+      output.success('Service creation completed successfully!');
+      output.section('Next steps');
+      output.list(['cd into your new service directory', 'Run npm install', 'Configure additional settings in src/config/domains.js', 'Run npm run deploy to deploy to Cloudflare']);
     } catch (error) {
-      console.error(chalk.red(`\n✗ Service creation failed: ${error.message}`));
+      const output = new (await import('../shared/utils/output-formatter.js')).OutputFormatter(options || {});
+      output.error(`Service creation failed: ${error.message}`);
       if (error.details) {
-        console.error(chalk.yellow(`Details: ${error.details}`));
+        output.warning(`Details: ${error.details}`);
       }
       process.exit(1);
     }

package/dist/bin/commands/deploy.js

@@ -1,12 +1,13 @@
 /**
  * Deploy Command - Smart minimal input deployment with service detection
  * 
- * Input Strategy: SMART MINIMAL
+ * Input Strategy: SMART MINIMAL WITH DOMAIN ROUTING
  * - Detects Clodo services OR legacy services (wrangler.toml)
  * - Supports multiple manifest locations
+ * - Uses DomainRouter for intelligent domain selection
  * - Gathers credentials smartly: env vars → flags → interactive collection with auto-fetch
  * - Validates token and fetches account ID & zone ID from Cloudflare
- * - Integrates with modular-enterprise-deploy.js for clean CLI-based deployment
+ * - REFACTORED (Task 3.2): Integrates with MultiDomainOrchestrator for full deployment orchestration
  */
 
 import chalk from 'chalk';
@@ -14,13 +15,43 @@ import { resolve } from 'path';
 import { ManifestLoader } from '../shared/config/manifest-loader.js';
 import { CloudflareServiceValidator } from '../shared/config/cloudflare-service-validator.js';
 import { DeploymentCredentialCollector } from '../shared/deployment/credential-collector.js';
+import { StandardOptions } from '../shared/utils/cli-options.js';
+import { ConfigLoader } from '../shared/utils/config-loader.js';
+import { DomainRouter } from '../shared/routing/domain-router.js';
+import { MultiDomainOrchestrator } from "../../orchestration/multi-domain-orchestrator.js";
 export function registerDeployCommand(program) {
-  program.command('deploy').description('Deploy a Clodo service with smart credential handling').option('--token <token>', 'Cloudflare API token').option('--account-id <id>', 'Cloudflare account ID').option('--zone-id <id>', 'Cloudflare zone ID').option('--dry-run', 'Simulate deployment without making changes').option('--quiet', 'Quiet mode - minimal output').option('--service-path <path>', 'Path to service directory', '.').action(async options => {
+  const command = program.command('deploy').description('Deploy a Clodo service with smart credential handling and domain selection')
+  // Cloudflare-specific options
+  .option('--token <token>', 'Cloudflare API token').option('--account-id <id>', 'Cloudflare account ID').option('--zone-id <id>', 'Cloudflare zone ID').option('--domain <domain>', 'Specific domain to deploy to (otherwise prompted if multiple exist)').option('--environment <env>', 'Target environment (development, staging, production)', 'production').option('--all-domains', 'Deploy to all configured domains (ignores --domain flag)').option('--dry-run', 'Simulate deployment without making changes').option('--service-path <path>', 'Path to service directory', '.');
+
+  // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
+  StandardOptions.define(command).action(async options => {
     try {
-      console.log(chalk.cyan('\n🚀 Clodo Service Deployment\n'));
+      const output = new (await import('../shared/utils/output-formatter.js')).OutputFormatter(options);
+      const configLoader = new ConfigLoader({
+        verbose: options.verbose,
+        quiet: options.quiet,
+        json: options.json
+      });
+
+      // Load config from file if specified
+      let configFileData = {};
+      if (options.configFile) {
+        configFileData = configLoader.loadSafe(options.configFile, {});
+        if (options.verbose && !options.quiet) {
+          output.info(`Loaded configuration from: ${options.configFile}`);
+        }
+      }
+
+      // Substitute environment variables in config
+      configFileData = configLoader.substituteEnvironmentVariables(configFileData);
+
+      // Merge config file defaults with CLI options (CLI takes precedence)
+      const mergedOptions = configLoader.merge(configFileData, options);
+      output.info('🚀 Clodo Service Deployment');
 
       // Step 1: Load and validate service configuration
-      const servicePath = resolve(options.servicePath);
+      const servicePath = resolve(mergedOptions.servicePath || '.');
       const serviceConfig = await ManifestLoader.loadAndValidateCloudflareService(servicePath);
       if (!serviceConfig.manifest) {
         if (serviceConfig.error === 'NOT_A_CLOUDFLARE_SERVICE') {
@@ -37,7 +68,7 @@ export function registerDeployCommand(program) {
         CloudflareServiceValidator.printValidationReport(serviceConfig.validationResult.validation);
       }
       ManifestLoader.printManifestInfo(serviceConfig.manifest);
-      console.log(chalk.gray(`Configuration loaded from: ${serviceConfig.foundAt}\n`));
+      output.info(`Configuration loaded from: ${serviceConfig.foundAt}`);
 
       // Step 2: Smart credential gathering with interactive collection
       // Uses DeploymentCredentialCollector which:
@@ -47,126 +78,246 @@ export function registerDeployCommand(program) {
       // - Caches credentials for future use
       const credentialCollector = new DeploymentCredentialCollector({
         servicePath: servicePath,
-        quiet: options.quiet
+        quiet: mergedOptions.quiet
       });
       let credentials;
       try {
         credentials = await credentialCollector.collectCredentials({
-          token: options.token,
-          accountId: options.accountId,
-          zoneId: options.zoneId
+          token: mergedOptions.token,
+          accountId: mergedOptions.accountId,
+          zoneId: mergedOptions.zoneId
         });
       } finally {
         credentialCollector.cleanup();
       }
 
-      // Step 3: Extract configuration from manifest
+      // Step 3: Initialize DomainRouter for intelligent domain selection
+      // REFACTORED (Task 3.2): Use DomainRouter for domain detection and selection
+      console.log(chalk.cyan('\n🗺️  Detecting available domains...\n'));
+      const router = new DomainRouter({
+        environment: mergedOptions.environment || 'production',
+        verbose: options.verbose,
+        configPath: options.configPath,
+        disableOrchestrator: false,
+        // We'll use the orchestrator for deployment
+        orchestratorOptions: {
+          dryRun: options.dryRun || false,
+          cloudflareToken: credentials.token,
+          cloudflareAccountId: credentials.accountId
+        }
+      });
+
+      // Detect domains from manifest
+      let detectedDomains = [];
       const manifest = serviceConfig.manifest;
       const config = manifest.deployment || manifest.configuration || {};
+      const domainsConfig = config.domains || [];
+      if (Array.isArray(domainsConfig) && domainsConfig.length > 0) {
+        // Handle both array of strings and array of objects
+        detectedDomains = domainsConfig.map(d => {
+          if (typeof d === 'string') return d;
+          if (typeof d === 'object' && d.name) return d.name;
+          return null;
+        }).filter(d => d !== null);
+      }
+
+      // If no domains in config, try to detect from environment
+      if (detectedDomains.length === 0 && manifest._source === 'cloudflare-service-detected') {
+        // For detected CF services, use default
+        detectedDomains = ['workers.cloudflare.com'];
+      }
+
+      // Domain selection: check CLI flag first, then prompt user
+      let selectedDomain = mergedOptions.domain;
+      if (!selectedDomain && detectedDomains.length > 0) {
+        if (detectedDomains.length === 1) {
+          // Only one domain, use it directly
+          selectedDomain = detectedDomains[0];
+          if (!options.quiet) {
+            console.log(chalk.green(`✓ Selected domain: ${selectedDomain}`));
+          }
+        } else {
+          // Multiple domains available - let user choose
+          console.log(chalk.cyan('📍 Available domains:'));
+          detectedDomains.forEach((d, i) => {
+            console.log(chalk.white(`  ${i + 1}) ${d}`));
+          });
+
+          // If running interactively, prompt user
+          if (process.stdin.isTTY) {
+            const {
+              createPromptModule
+            } = await import('inquirer');
+            const prompt = createPromptModule();
+            const response = await prompt([{
+              type: 'list',
+              name: 'selectedDomain',
+              message: 'Select domain to deploy to:',
+              choices: detectedDomains,
+              default: detectedDomains[0]
+            }]);
+            selectedDomain = response.selectedDomain;
+          } else {
+            // Non-interactive mode: use first domain
+            selectedDomain = detectedDomains[0];
+            console.log(chalk.yellow(`⚠️  Non-interactive mode: using first domain: ${selectedDomain}`));
+          }
+        }
+      }
+      if (!selectedDomain) {
+        if (!options.quiet) {
+          console.error(chalk.yellow('⚠️  No domain configured for deployment'));
+          console.error(chalk.gray('For Clodo services: add deployment.domains in clodo-service-manifest.json'));
+          console.error(chalk.gray('For detected CF services: define routes in wrangler.toml'));
+        }
+        process.exit(1);
+      }
+
+      // Step 4: Validate domain configuration
+      console.log(chalk.cyan('\n🔍 Validating domain configuration...\n'));
+      const validation = router.validateConfiguration({
+        domains: [selectedDomain],
+        environment: mergedOptions.environment || 'production'
+      });
+      if (!validation.valid) {
+        console.error(chalk.red('❌ Configuration validation failed:'));
+        validation.errors.forEach(err => {
+          console.error(chalk.yellow(`  • ${err}`));
+        });
+        process.exit(1);
+      }
+      if (validation.warnings && validation.warnings.length > 0) {
+        console.log(chalk.yellow('⚠️  Configuration warnings:'));
+        validation.warnings.forEach(warn => {
+          console.log(chalk.gray(`  • ${warn}`));
+        });
+      }
 
       // Extract service metadata
       const serviceName = manifest.serviceName || 'unknown-service';
       const serviceType = manifest.serviceType || 'generic';
 
-      // For detected Cloudflare services, domain comes from wrangler.toml or environment
-      // For Clodo services, use first domain if available
-      let domain = null;
-      const domains = config.domains || [];
-      if (domains.length > 0) {
-        // Clodo service with multiple domains
-        domain = domains[0].name || domains[0];
-      } else if (manifest._source === 'cloudflare-service-detected') {
-        // Detected CF service - get domain from route or config
-        // For now, use a placeholder since we don't have explicit domain routing in detected services
-        domain = 'workers.cloudflare.com';
-        console.log(chalk.gray('Note: Using Cloudflare Workers default domain (add routes in wrangler.toml for custom domains)'));
-      }
-      if (!domain && !options.quiet) {
-        console.error(chalk.yellow('⚠️  No domain configured for deployment'));
-        console.error(chalk.gray('For Clodo services: add deployment.domains in clodo-service-manifest.json'));
-        console.error(chalk.gray('For detected CF services: define routes in wrangler.toml'));
-      }
-      console.log(chalk.cyan('📋 Deployment Plan:'));
-      console.log(chalk.gray('─'.repeat(50)));
-      console.log(chalk.white(`Service:  ${serviceName}`));
-      console.log(chalk.white(`Type:     ${serviceType}`));
-      if (domain) {
-        console.log(chalk.white(`Domain:   ${domain}`));
-      }
-      console.log(chalk.white(`Account:  ${credentials.accountId.substring(0, 8)}...`));
-      console.log(chalk.white(`Zone:     ${credentials.zoneId.substring(0, 8)}...`));
-      console.log(chalk.gray('─'.repeat(50)));
+      // Display deployment plan
+      console.log(chalk.cyan('\n📋 Deployment Plan:'));
+      console.log(chalk.gray('─'.repeat(60)));
+      console.log(chalk.white(`Service:         ${serviceName}`));
+      console.log(chalk.white(`Type:            ${serviceType}`));
+      console.log(chalk.white(`Domain:          ${selectedDomain}`));
+      console.log(chalk.white(`Environment:     ${mergedOptions.environment || 'production'}`));
+      console.log(chalk.white(`Account:         ${credentials.accountId.substring(0, 8)}...`));
+      console.log(chalk.white(`Zone:            ${credentials.zoneId.substring(0, 8)}...`));
+      console.log(chalk.white(`Deployment Mode: ${options.dryRun ? 'DRY RUN' : 'LIVE'}`));
+      console.log(chalk.gray('─'.repeat(60)));
       if (options.dryRun) {
         console.log(chalk.yellow('\n🔍 DRY RUN MODE - No changes will be made\n'));
       }
 
-      // Step 4: Load and call modular deployer
-      console.log(chalk.cyan('\n⚙️  Initializing deployment system...\n'));
-      let ModularEnterpriseDeployer;
+      // Step 5: Initialize MultiDomainOrchestrator for deployment
+      // REFACTORED (Task 3.2): Direct orchestrator integration instead of external deployer
+      console.log(chalk.cyan('\n⚙️  Initializing orchestration system...\n'));
+      const orchestrator = new MultiDomainOrchestrator({
+        domains: [selectedDomain],
+        environment: mergedOptions.environment || 'production',
+        dryRun: options.dryRun || false,
+        skipTests: false,
+        parallelDeployments: 1,
+        // Single domain in this flow
+        servicePath: servicePath,
+        cloudflareToken: credentials.token,
+        cloudflareAccountId: credentials.accountId,
+        enablePersistence: !options.dryRun,
+        rollbackEnabled: !options.dryRun,
+        verbose: options.verbose
+      });
       try {
-        const module = await import('../../deployment/modular-enterprise-deploy.js');
-        ModularEnterpriseDeployer = module.ModularEnterpriseDeployer || module.default;
+        await orchestrator.initialize();
       } catch (err) {
-        console.error(chalk.red('❌ Failed to load deployment system'));
+        console.error(chalk.red('❌ Failed to initialize orchestrator'));
         console.error(chalk.yellow(`Error: ${err.message}`));
         if (process.env.DEBUG) {
           console.error(chalk.gray(err.stack));
         }
         process.exit(1);
       }
-      if (!ModularEnterpriseDeployer) {
-        console.error(chalk.red('❌ ModularEnterpriseDeployer not found in deployment module'));
-        process.exit(1);
-      }
 
-      // Create deployer instance with gathered credentials
-      const deployer = new ModularEnterpriseDeployer({
-        apiToken: credentials.token,
-        accountId: credentials.accountId,
-        zoneId: credentials.zoneId,
-        domain: domain,
-        dryRun: options.dryRun,
-        quiet: options.quiet,
-        servicePath: servicePath,
-        serviceName: serviceName,
-        serviceType: serviceType
-      });
+      // Step 6: Execute deployment via orchestrator
+      console.log(chalk.cyan('🚀 Starting deployment via orchestrator...\n'));
+      let result;
+      try {
+        result = await orchestrator.deploySingleDomain(selectedDomain, {
+          manifest: manifest,
+          credentials: credentials,
+          dryRun: options.dryRun,
+          environment: mergedOptions.environment || 'production'
+        });
+      } catch (deployError) {
+        console.error(chalk.red('\n❌ Deployment failed during orchestration\n'));
+        console.error(chalk.yellow(`Error: ${deployError.message}`));
 
-      // Run deployment
-      console.log(chalk.cyan('🚀 Starting deployment...\n'));
-      const result = await deployer.run({
-        manifest: manifest,
-        credentials: credentials,
-        dryRun: options.dryRun
-      });
+        // Provide helpful error context
+        if (deployError.message.includes('credentials') || deployError.message.includes('auth')) {
+          console.error(chalk.yellow('\n💡 Credential Issue:'));
+          console.error(chalk.white('  Check your API token, account ID, and zone ID'));
+          console.error(chalk.white('  Visit: https://dash.cloudflare.com/profile/api-tokens'));
+        }
+        if (deployError.message.includes('domain') || deployError.message.includes('zone')) {
+          console.error(chalk.yellow('\n� Domain Issue:'));
+          console.error(chalk.white('  Verify domain exists in Cloudflare'));
+          console.error(chalk.white('  Check API token has zone:read permissions'));
+        }
+        if (process.env.DEBUG) {
+          console.error(chalk.gray('\nFull Stack Trace:'));
+          console.error(chalk.gray(deployError.stack));
+        }
+        process.exit(1);
+      }
 
-      // Display results
+      // Step 7: Display deployment results
       console.log(chalk.green('\n✅ Deployment Completed Successfully!\n'));
-      console.log(chalk.gray('─'.repeat(50)));
+      console.log(chalk.gray('─'.repeat(60)));
+
+      // Display results from orchestrator
       if (result.url) {
-        console.log(chalk.white(`🌐 Service URL: ${chalk.bold(result.url)}`));
+        console.log(chalk.white(`🌐 Service URL:     ${chalk.bold(result.url)}`));
       }
-      console.log(chalk.white(`📦 Service: ${serviceName}`));
-      console.log(chalk.white(`🔧 Type: ${serviceType}`));
-      console.log(chalk.white(`🌍 Domain: ${domain}`));
+      console.log(chalk.white(`📦 Service:         ${serviceName}`));
+      console.log(chalk.white(`🔧 Type:            ${serviceType}`));
+      console.log(chalk.white(`🌍 Domain:          ${selectedDomain}`));
+      console.log(chalk.white(`🌎 Environment:     ${mergedOptions.environment || 'production'}`));
       if (result.workerId) {
-        console.log(chalk.white(`👤 Worker ID: ${result.workerId}`));
+        console.log(chalk.white(`👤 Worker ID:       ${result.workerId}`));
+      }
+      if (result.deploymentId) {
+        console.log(chalk.white(`📋 Deployment ID:   ${result.deploymentId}`));
       }
       if (result.status) {
         const statusColor = result.status.toLowerCase().includes('success') ? chalk.green : chalk.yellow;
-        console.log(chalk.white(`📊 Status: ${statusColor(result.status)}`));
+        console.log(chalk.white(`📊 Status:          ${statusColor(result.status)}`));
+      }
+
+      // Display audit information if available
+      if (result.auditLog) {
+        console.log(chalk.cyan('\n📋 Deployment Audit:'));
+        console.log(chalk.gray(`  Started:  ${result.auditLog.startTime}`));
+        console.log(chalk.gray(`  Completed: ${result.auditLog.endTime}`));
+        console.log(chalk.gray(`  Duration: ${result.auditLog.duration}ms`));
       }
-      console.log(chalk.gray('─'.repeat(50)));
+      console.log(chalk.gray('─'.repeat(60)));
 
-      // Next steps
+      // Display next steps
       if (!options.dryRun) {
         console.log(chalk.cyan('\n💡 Next Steps:'));
-        console.log(chalk.white('  • Test deployment: curl ' + (result.url || `https://${domain}`)));
-        console.log(chalk.white('  • View logs: wrangler tail ' + serviceName));
-        console.log(chalk.white('  • Monitor: https://dash.cloudflare.com'));
+        console.log(chalk.white(`  • Test deployment: curl ${result.url || `https://${selectedDomain}`}`));
+        console.log(chalk.white(`  • View logs: wrangler tail ${serviceName}`));
+        console.log(chalk.white(`  • Monitor: https://dash.cloudflare.com`));
+        console.log(chalk.white(`  • Check audit logs: See deployment ID above\n`));
+      } else {
+        console.log(chalk.cyan('\n💡 Dry Run Complete'));
+        console.log(chalk.white(`  • Review the plan above`));
+        console.log(chalk.white(`  • Remove --dry-run to execute deployment\n`));
       }
       if (process.env.DEBUG && result.details) {
-        console.log(chalk.gray('\n📋 Full Result:'));
+        console.log(chalk.gray('📋 Full Result:'));
         console.log(chalk.gray(JSON.stringify(result, null, 2)));
       }
     } catch (error) {
@@ -176,11 +327,16 @@ export function registerDeployCommand(program) {
         console.error(chalk.white('  Check your API token, account ID, and zone ID'));
         console.error(chalk.white('  Visit: https://dash.cloudflare.com/profile/api-tokens'));
       }
-      if (error.message.includes('domain')) {
+      if (error.message.includes('domain') || error.message.includes('zone')) {
         console.error(chalk.yellow('\n💡 Domain Issue:'));
         console.error(chalk.white('  Verify domain exists in Cloudflare'));
         console.error(chalk.white('  Check API token has zone:read permissions'));
       }
+      if (error.message.includes('orchestration') || error.message.includes('initialization')) {
+        console.error(chalk.yellow('\n💡 Orchestration Issue:'));
+        console.error(chalk.white('  Check MultiDomainOrchestrator configuration'));
+        console.error(chalk.white('  Verify all modular components loaded correctly'));
+      }
       if (process.env.DEBUG) {
         console.error(chalk.gray('\nFull Stack Trace:'));
         console.error(chalk.gray(error.stack));