scripts-orchestrator 2.9.0 → 2.12.0

package/lib/orchestrator.js

@@ -2,27 +2,37 @@ import { processManager } from './process-manager.js';
 import { healthCheck } from './health-check.js';
 import { log } from './logger.js';
 import { GitCache } from './git-cache.js';
+import chalk from 'chalk';
 
 export class Orchestrator {
-  constructor(config, startPhase = null, logFolder = null, phases = null, sequential = false) {
+  constructor(
+    config,
+    startPhase = null,
+    logFolder = null,
+    phases = null,
+    sequential = false,
+    force = false,
+  ) {
     this.config = config;
     this.startPhase = startPhase;
     this.logFolder = logFolder;
     this.phases = phases;
     this.sequential = sequential;
+    this.force = force;
     this.processManager = processManager;
     this.healthCheck = healthCheck;
     this.logger = log;
     this.failedCommands = [];
     this.skippedCommands = [];
+    this.skipReasons = new Map(); // Track why commands were skipped
     this.commandTimings = new Map();
     this.gitCache = new GitCache(logFolder);
-    
+
     // Set the log folder in process manager
     if (logFolder) {
       this.processManager.setLogFolder(logFolder);
     }
-    
+
     // Flatten commands for easier tracking
     this.allCommands = this.flattenCommands(config);
   }
@@ -32,11 +42,11 @@ export class Orchestrator {
     if (Array.isArray(config)) {
       return config;
     }
-    
+
     if (config.phases) {
-      return config.phases.flatMap(phase => phase.parallel || []);
+      return config.phases.flatMap((phase) => phase.parallel || []);
     }
-    
+
     return [];
   }
 
@@ -85,6 +95,7 @@ export class Orchestrator {
     if (status === 'disabled') {
       this.logger.warn(`Skipping: npm run ${command} (status: disabled)`);
       this.skippedCommands.push(command);
+      this.skipReasons.set(command, 'disabled');
       this.commandTimings.set(command, Date.now() - startTime);
       visited.delete(command);
       return true;
@@ -92,10 +103,23 @@ export class Orchestrator {
 
     const checkUrl = health_check?.url;
     if (checkUrl) {
-      this.logger.info(`Checking if ${checkUrl} is already available...`);
-      const urlAvailable = await this.healthCheck.waitForUrl({url: checkUrl, maxAttempts: 1, silent:true});
-      if (urlAvailable) {
-        this.logger.verbose(`${checkUrl} is already available. Skipping ${command} start.`);
+      this.logger.startEphemeral(
+        `check_${checkUrl}`,
+        chalk.blue(`[INFO] ⏳ Checking if ${checkUrl} is already available...`),
+      );
+      const urlAvailable = await this.healthCheck.waitForUrl({
+        url: checkUrl,
+        maxAttempts: 1,
+        silent: true,
+      });
+
+      if (!urlAvailable) {
+        this.logger.stopEphemeral(`check_${checkUrl}`);
+      } else {
+        this.logger.stopEphemeral(
+          `check_${checkUrl}`,
+          `✅ ${checkUrl} is already available. Skipping ${command} start.`,
+        );
         this.processManager.addBackgroundProcess({
           command,
           url: checkUrl,
@@ -115,23 +139,21 @@ export class Orchestrator {
       if (!dependencySuccess) {
         this.logger.error(`Skipping ${command} due to failed dependency`);
         this.skippedCommands.push(command);
+        this.skipReasons.set(command, 'failed_dependency');
         this.commandTimings.set(command, Date.now() - startTime);
         visited.delete(command);
         return false;
       }
 
       if (dependency.health_check?.url) {
-        this.logger.info(`Waiting for ${dependency.health_check.url} to be available...`);
         const urlAvailable = await this.healthCheck.waitForUrl({
           url: dependency.health_check.url,
           maxAttempts: dependency.health_check?.max_attempts || 20,
           interval: dependency.health_check?.interval || 2000,
         });
         if (!urlAvailable) {
-          this.logger.error(
-            `URL ${dependency.health_check.url} is not available after maximum attempts`,
-          );
           this.skippedCommands.push(command);
+          this.skipReasons.set(command, 'failed_dependency');
           this.commandTimings.set(command, Date.now() - startTime);
           visited.delete(command);
           return false;
@@ -140,7 +162,9 @@ export class Orchestrator {
           this.logger.verbose(`Waiting ${dependency.wait}ms`);
           await new Promise((resolve) => {
             setTimeout(() => {
-              this.logger.verbose(`Resolving after a wait of ${dependency.wait}ms`);
+              this.logger.verbose(
+                `Resolving after a wait of ${dependency.wait}ms`,
+              );
               resolve(true);
             }, dependency.wait);
           });
@@ -152,10 +176,12 @@ export class Orchestrator {
     let result = false;
     let commandOutput = '';
     let commandFailed = false;
-    
+
     for (let attempt = 1; attempt <= attempts; attempt++) {
       if (attempt > 1) {
-        this.logger.warn(`Retrying ${command} (attempt ${attempt}/${attempts})`);
+        this.logger.warn(
+          `Retrying ${command} (attempt ${attempt}/${attempts})`,
+        );
         await new Promise((resolve) => setTimeout(resolve, 1000));
       }
 
@@ -173,7 +199,9 @@ export class Orchestrator {
 
       if (result) {
         // Remove from failed commands if it was there
-        this.failedCommands = this.failedCommands.filter(cmd => cmd !== command);
+        this.failedCommands = this.failedCommands.filter(
+          (cmd) => cmd !== command,
+        );
         commandFailed = false;
         break;
       } else if (attempt < attempts) {
@@ -184,7 +212,9 @@ export class Orchestrator {
           commandFailed = true;
           break;
         }
-        this.logger.error(`Attempt ${attempt}/${attempts} failed for ${command}`);
+        this.logger.error(
+          `Attempt ${attempt}/${attempts} failed for ${command}`,
+        );
         commandFailed = true;
       } else {
         commandFailed = true;
@@ -193,14 +223,18 @@ export class Orchestrator {
 
     if (commandFailed) {
       this.failedCommands.push(command);
-      
+
       // Cleanup any background processes for this failed command
       if (background) {
-        this.logger.warn(`Command ${command} failed after all attempts. Cleaning up background processes.`);
+        this.logger.warn(
+          `Command ${command} failed after all attempts. Cleaning up background processes.`,
+        );
         try {
           await this.processManager.cleanupCommand(command);
         } catch (cleanupError) {
-          this.logger.error(`Failed to cleanup processes for ${command}: ${cleanupError.message}`);
+          this.logger.error(
+            `Failed to cleanup processes for ${command}: ${cleanupError.message}`,
+          );
         }
       }
     }
@@ -211,40 +245,45 @@ export class Orchestrator {
   }
 
   summarizeResults() {
-    this.logger.info('\nCommand Summary:');
     let hasFailures = false;
-    
+
+    // Check if any command failed or was skipped due to failure
     this.allCommands.forEach(({ command }) => {
-      const duration = this.commandTimings.get(command);
-      const durationStr = duration ? ` (${this.formatDuration(duration)})` : '';
-      
       if (this.failedCommands.includes(command)) {
         hasFailures = true;
-        // Get the actual log path from process manager
-        const logPath = this.processManager.getLogPath(command);
-        this.logger.error(`- ${command}: ❌${durationStr} (See ${logPath})`);
       } else if (this.skippedCommands.includes(command)) {
-        hasFailures = true;
-        this.logger.warn(`- ${command}: ⚠️${durationStr} (Skipped due to failed dependency)`);
-      } else {
-        this.logger.success(`- ${command}: ✅${durationStr}`);
+        const skipReason = this.skipReasons.get(command);
+        if (
+          skipReason === 'failed_dependency' ||
+          skipReason === 'after_phase_failure'
+        ) {
+          hasFailures = true;
+        }
       }
     });
 
     if (hasFailures) {
-      this.logger.error('\n❌ Some commands failed or were skipped. See details above.');
+      this.logger.error('\n❌ Some commands failed or were skipped.');
     } else {
       this.logger.success('\n🎉 All commands executed successfully!');
     }
   }
 
   async run() {
+    this.startTime = Date.now();
     try {
-      // Check if we should skip execution based on git state
-      const shouldSkip = await this.gitCache.shouldSkipExecution();
-      if (shouldSkip) {
-        this.logger.success('🎉 No changes detected, skipping execution!');
-        process.exit(0);
+      // Check if we should skip execution based on git state (unless forced)
+      if (!this.force) {
+        const shouldSkip = await this.gitCache.shouldSkipExecution();
+        if (shouldSkip) {
+          this.logger.success('🎉 No changes detected, skipping execution!');
+          this.logger.info('💡 To force execution, use: --force');
+          process.exit(0);
+        }
+      } else {
+        this.logger.info(
+          '⚡ Force execution enabled, skipping git cache check',
+        );
       }
 
       let hasFailures = false;
@@ -270,14 +309,14 @@ export class Orchestrator {
             this.executeCommand(commandConfig),
           );
           const results = await Promise.all(tasks);
-          hasFailures = results.some(result => !result);
+          hasFailures = results.some((result) => !result);
         }
       } else if (this.config.phases) {
         // New: Run phases sequentially, commands within phases in parallel or sequential based on flag
         if (this.sequential) {
           this.logger.info('🔄 Running in sequential mode');
         }
-        
+
         for (const phase of this.config.phases) {
           // Check if we should start from this phase
           if (this.startPhase && !startPhaseFound) {
@@ -288,6 +327,7 @@ export class Orchestrator {
               // Mark all commands in previous phases as skipped
               phase.parallel.forEach(({ command }) => {
                 this.skippedCommands.push(command);
+                this.skipReasons.set(command, 'before_start_phase');
                 this.commandTimings.set(command, 0);
               });
               continue;
@@ -295,11 +335,18 @@ export class Orchestrator {
           }
 
           // Check if this is an optional phase that should be skipped
-          if (phase.optional === true && this.phases && !this.phases.includes(phase.name)) {
-            this.logger.info(`\n⏭️  Skipping optional phase: ${phase.name} (not explicitly requested)`);
+          if (
+            phase.optional === true &&
+            this.phases &&
+            !this.phases.includes(phase.name)
+          ) {
+            this.logger.info(
+              `\n⏭️  Skipping optional phase: ${phase.name} (not explicitly requested)`,
+            );
             // Mark all commands in this phase as skipped
             phase.parallel.forEach(({ command }) => {
               this.skippedCommands.push(command);
+              this.skipReasons.set(command, 'optional_phase_not_requested');
               this.commandTimings.set(command, 0);
             });
             continue;
@@ -309,13 +356,14 @@ export class Orchestrator {
             // Mark all commands in remaining phases as skipped
             phase.parallel.forEach(({ command }) => {
               this.skippedCommands.push(command);
+              this.skipReasons.set(command, 'after_phase_failure');
               this.commandTimings.set(command, 0);
             });
             continue;
           }
 
-          this.logger.info(`\n🔄 Starting phase: ${phase.name}`);
-          
+          const phaseStartTime = Date.now();
+
           let results;
           if (this.sequential) {
             // Run commands sequentially
@@ -335,58 +383,90 @@ export class Orchestrator {
             );
             results = await Promise.all(tasks);
           }
-          
-          const phaseHasFailures = results.some(result => !result);
-          
+
+          const phaseHasFailures = results.some((result) => !result);
+          const phaseDurationStr = `(${this.formatDuration(
+            Date.now() - phaseStartTime,
+          )})`;
+
           if (phaseHasFailures) {
             hasFailures = true;
             phaseFailed = true;
-            this.logger.error(`❌ Phase "${phase.name}" completed with failures`);
+            this.logger.stopPhase(phase.name, false, phaseDurationStr);
           } else {
-            this.logger.success(`✅ Phase "${phase.name}" completed successfully`);
+            this.logger.stopPhase(phase.name, true, phaseDurationStr);
           }
         }
       }
 
       // Validate start phase if specified
       if (this.startPhase && !startPhaseFound) {
-        const availablePhases = this.config.phases.map(p => p.name).join(', ');
-        this.logger.error(`❌ Start phase "${this.startPhase}" not found. Available phases: ${availablePhases}`);
+        const availablePhases = this.config.phases
+          .map((p) => p.name)
+          .join(', ');
+        this.logger.error(
+          `❌ Start phase "${this.startPhase}" not found. Available phases: ${availablePhases}`,
+        );
         process.exit(1);
       }
 
       // Validate phases if specified
       if (this.phases) {
-        const availablePhases = this.config.phases.map(p => p.name);
-        const invalidPhases = this.phases.filter(phase => !availablePhases.includes(phase));
+        const availablePhases = this.config.phases.map((p) => p.name);
+        const invalidPhases = this.phases.filter(
+          (phase) => !availablePhases.includes(phase),
+        );
         if (invalidPhases.length > 0) {
-          this.logger.error(`❌ Invalid phases specified: ${invalidPhases.join(', ')}. Available phases: ${availablePhases.join(', ')}`);
+          this.logger.error(
+            `❌ Invalid phases specified: ${invalidPhases.join(', ')}. Available phases: ${availablePhases.join(', ')}`,
+          );
           process.exit(1);
         }
       }
 
       // Check final status
-      hasFailures = hasFailures || 
-                   this.failedCommands.length > 0 || 
-                   this.skippedCommands.length > 0;
+      // Only count skipped commands as failures if they're due to dependency issues or phase failures
+      const failureSkippedCommands = Array.from(this.skipReasons.entries())
+        .filter(
+          ([, reason]) =>
+            reason === 'failed_dependency' || reason === 'after_phase_failure',
+        )
+        .map(([command]) => command);
+
+      hasFailures =
+        hasFailures ||
+        this.failedCommands.length > 0 ||
+        failureSkippedCommands.length > 0;
 
       // Add a small delay to ensure all processes have finished
       await new Promise((resolve) => setTimeout(resolve, 1000));
 
       this.summarizeResults();
-      
+
       // Cleanup before exit since finally blocks don't run after process.exit()
       try {
         await this.processManager.cleanup();
       } catch (error) {
         this.logger.error(`Cleanup failed: ${error.message}`);
       }
-      
+
+      // Log overall time after cleanup has finished
+      if (this.startTime) {
+        const overallDuration = Date.now() - this.startTime;
+        this.logger.printMessage(() =>
+          console.log(
+            chalk.cyan(
+              `[INFO] ⏱️  Overall time taken: ${this.formatDuration(overallDuration)}`,
+            ),
+          ),
+        );
+      }
+
       // Update git cache on successful execution
       if (!hasFailures) {
         await this.gitCache.updateCache();
       }
-      
+
       // Force exit with appropriate status
       if (hasFailures) {
         this.logger.info('Exiting with failure status...');
@@ -397,15 +477,15 @@ export class Orchestrator {
       }
     } catch (error) {
       this.logger.error(`Orchestrator failed: ${error.message}`);
-      
+
       // Cleanup on error
       try {
         await this.processManager.cleanup();
       } catch (cleanupError) {
         this.logger.error(`Cleanup failed: ${cleanupError.message}`);
       }
-      
+
       process.exit(1);
     }
   }
-} 
+}