scripts-orchestrator 1.2.1 → 1.2.3

package/README.md

@@ -56,6 +56,144 @@ Create a configuration file (default: `scripts-orchestrator.config.js`) that def
 }
 ```
 
+## Example Configurations
+
+Here are some practical examples of how to configure the orchestrator for different scenarios:
+
+### Basic Build and Test Pipeline
+```javascript
+export default [
+  {
+    command: 'build',
+    description: 'Build the project',
+    status: 'enabled',
+    attempts: 1
+  },
+  {
+    command: 'test',
+    description: 'Run unit tests',
+    status: 'enabled',
+    attempts: 2,
+    should_retry: (output) => {
+      // Only retry if there are actual test failures
+      const testSummaryMatch = output.match(/Test Suites:.*?(\d+) failed/);
+      return testSummaryMatch && parseInt(testSummaryMatch[1]) > 0;
+    }
+  },
+  {
+    command: 'lint',
+    description: 'Run lint checks',
+    status: 'enabled'
+  }
+];
+```
+
+### Storybook Testing with Background Process
+```javascript
+export default [
+  {
+    command: 'test-storybook',
+    description: 'Run Storybook tests',
+    status: 'enabled',
+    attempts: 2,
+    dependencies: [
+      {
+        command: 'storybook_silent',
+        background: true,
+        wait: 5000,
+        health_check: {
+          url: 'http://localhost:6006',
+          max_attempts: 20,
+          interval: 2000
+        }
+      }
+    ]
+  }
+];
+```
+
+### Playwright Testing with Development Server
+```javascript
+export default [
+  {
+    command: 'playwright_ci',
+    description: 'Run Playwright tests',
+    status: 'enabled',
+    attempts: 1,
+    dependencies: [
+      {
+        command: 'dev',
+        background: true,
+        health_check: {
+          url: 'http://localhost:5173',
+          max_attempts: 20,
+          interval: 2000
+        }
+      }
+    ]
+  }
+];
+```
+
+### Full CI Pipeline with Multiple Checks
+```javascript
+export default [
+  {
+    command: 'build',
+    description: 'Build the project',
+    status: 'enabled',
+    attempts: 1
+  },
+  {
+    command: 'test-ci',
+    description: 'Run unit tests',
+    status: 'enabled',
+    attempts: 2,
+    should_retry: (output) => {
+      const testSummaryMatch = output.match(/Test Suites:.*?(\d+) failed/);
+      const hasTestFailures = testSummaryMatch && parseInt(testSummaryMatch[1]) > 0;
+      const hasCoverageFailures = output.match(/Jest: "global" coverage threshold/);
+      
+      // Only retry for actual test failures, not coverage issues
+      return hasTestFailures;
+    }
+  },
+  {
+    command: 'test-storybook',
+    description: 'Run Storybook tests',
+    status: 'enabled',
+    attempts: 2,
+    dependencies: [
+      {
+        command: 'storybook_silent',
+        background: true,
+        wait: 5000,
+        health_check: {
+          url: 'http://localhost:6006',
+          max_attempts: 20,
+          interval: 2000
+        }
+      }
+    ]
+  },
+  {
+    command: 'stylelint',
+    description: 'Run stylelint checks',
+    status: 'enabled'
+  },
+  {
+    command: 'lint',
+    description: 'Run lint checks',
+    status: 'enabled'
+  },
+  {
+    command: 'jscpd',
+    description: 'Run code duplication checks',
+    status: 'enabled'
+  }
+];
+```
+
 ## Command Types
 
 The orchestrator is completely agnostic to what commands it runs. It can execute any npm scripts. Common use cases include:

package/lib/orchestrator.js

@@ -10,6 +10,18 @@ export class Orchestrator {
     this.logger = log;
     this.failedCommands = [];
     this.skippedCommands = [];
+    this.commandTimings = new Map();
+  }
+
+  formatDuration(ms) {
+    if (ms < 1000) return `${ms}ms`;
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes > 0) {
+      return `${minutes}m ${remainingSeconds}s`;
+    }
+    return `${seconds}s`;
   }
 
   async executeCommand(commandConfig, visited = new Set()) {
@@ -26,12 +38,15 @@ export class Orchestrator {
       health_check,
     } = commandConfig;
 
+    const startTime = Date.now();
+
     // Check for circular dependencies
     if (visited.has(command)) {
       this.logger.error(
         `Circular dependency detected: ${Array.from(visited).join(' -> ')} -> ${command}`,
       );
       this.failedCommands.push(command);
+      this.commandTimings.set(command, Date.now() - startTime);
       return false;
     }
     visited.add(command);
@@ -40,6 +55,7 @@ export class Orchestrator {
     if (status === 'disabled') {
       this.logger.warn(`Skipping: npm run ${command} (status: disabled)`);
       this.skippedCommands.push(command);
+      this.commandTimings.set(command, Date.now() - startTime);
       visited.delete(command);
       return true;
     }
@@ -56,6 +72,7 @@ export class Orchestrator {
           startedByScript: false,
           process_tracking,
         });
+        this.commandTimings.set(command, Date.now() - startTime);
         visited.delete(command);
         return true;
       }
@@ -67,6 +84,7 @@ export class Orchestrator {
       if (!dependencySuccess) {
         this.logger.error(`Skipping ${command} due to failed dependency`);
         this.skippedCommands.push(command);
+        this.commandTimings.set(command, Date.now() - startTime);
         visited.delete(command);
         return false;
       }
@@ -83,6 +101,7 @@ export class Orchestrator {
             `URL ${dependency.health_check.url} is not available after maximum attempts`,
           );
           this.skippedCommands.push(command);
+          this.commandTimings.set(command, Date.now() - startTime);
           visited.delete(command);
           return false;
         }
@@ -101,6 +120,8 @@ export class Orchestrator {
     // Execute the main command with retries
     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})`);
@@ -117,36 +138,54 @@ export class Orchestrator {
       result = success;
 
       if (result) {
+        // Remove from failed commands if it was there
         this.failedCommands = this.failedCommands.filter(cmd => cmd !== command);
+        commandFailed = false;
         break;
       } else if (attempt < attempts) {
         if (should_retry && !should_retry(commandOutput)) {
           this.logger.warn(
             `${command} failed but doesn't meet retry criteria. Skipping retry.`,
           );
+          commandFailed = true;
           break;
         }
         this.logger.error(`Attempt ${attempt}/${attempts} failed for ${command}`);
+        commandFailed = true;
+      } else {
+        commandFailed = true;
       }
     }
 
+    if (commandFailed) {
+      this.failedCommands.push(command);
+    }
+
+    this.commandTimings.set(command, Date.now() - startTime);
     visited.delete(command);
     return result;
   }
 
   summarizeResults() {
     this.logger.info('\nCommand Summary:');
+    let hasFailures = false;
+    
     this.config.forEach(({ command }) => {
+      const duration = this.commandTimings.get(command);
+      const durationStr = duration ? ` (${this.formatDuration(duration)})` : '';
+      
       if (this.failedCommands.includes(command)) {
-        this.logger.error(`- ${command}: ❌ (See logs/scripts-orchestrator_${command}.log)`);
+        hasFailures = true;
+        this.logger.error(`- ${command}: ❌${durationStr} (See logs/scripts-orchestrator_${command}.log)`);
       } else if (this.skippedCommands.includes(command)) {
-        this.logger.warn(`- ${command}: ⚠️ (Skipped due to failed dependency)`);
+        hasFailures = true;
+        this.logger.warn(`- ${command}: ⚠️${durationStr} (Skipped due to failed dependency)`);
       } else {
-        this.logger.success(`- ${command}: ✅`);
+        this.logger.success(`- ${command}: ✅${durationStr}`);
       }
     });
 
-    if (this.failedCommands.length > 0 || this.skippedCommands.length > 0) {
+    if (hasFailures) {
       this.logger.error('\n❌ Some commands failed or were skipped. See details above.');
     } else {
       this.logger.success('\n🎉 All commands executed successfully!');
@@ -161,21 +200,28 @@ export class Orchestrator {
       );
 
       // Wait for all top-level commands to complete
-      await Promise.all(tasks);
+      const results = await Promise.all(tasks);
+      
+      // Check if any command failed
+      const hasFailures = results.some(result => !result) || 
+                         this.failedCommands.length > 0 || 
+                         this.skippedCommands.length > 0;
 
       // Add a small delay to ensure all processes have finished
       await new Promise((resolve) => setTimeout(resolve, 1000));
 
       this.summarizeResults();
+      
+      // Exit with appropriate status
+      if (hasFailures) {
+        process.exit(1);
+      }
     } finally {
       try {
         await this.processManager.cleanup();
       } catch (error) {
         this.logger.error(`Cleanup failed: ${error.message}`);
       }
-      if (this.failedCommands.length > 0 || this.skippedCommands.length > 0) {
-        process.exit(1);
-      }
     }
   }
 } 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scripts-orchestrator",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "A powerful script orchestrator for running parallel commands with dependency management, background processes, and health checks",
   "main": "lib/index.js",
   "type": "module",