scripts-orchestrator 2.9.0 → 2.12.0

package/README.md

@@ -263,6 +263,9 @@ The orchestrator doesn't care what the commands do - it just ensures they run (i
 
    # Specify a custom log folder
    npm run scripts-orchestrator -- --logFolder ./custom-logs
+
+   # Force execution even if git state is unchanged
+   npm run scripts-orchestrator -- --force
    ```
 
 ### Starting from a Specific Phase
@@ -422,6 +425,21 @@ This feature is particularly useful in CI/CD pipelines where the same commit mig
 
 **Note**: The cache is only updated on successful execution. Failed runs will not update the cache, ensuring subsequent runs will retry.
 
+### Force Execution
+
+You can bypass the git cache check and force execution even when the git state is unchanged by using the `--force` flag:
+
+```bash
+# Force execution regardless of git state
+npm run scripts-orchestrator -- --force
+```
+
+This is useful when you want to:
+- Re-run commands without making code changes
+- Test configuration changes
+- Debug issues without modifying the codebase
+- Override the cache in CI/CD pipelines
+
 ## Exit Codes
 
 - `0`: All commands executed successfully

package/index.js

@@ -35,6 +35,10 @@ const argv = yargs(hideBin(process.argv))
     type: 'boolean',
     description: 'Run all commands sequentially instead of in parallel (for low CPU machines)',
   })
+  .option('force', {
+    type: 'boolean',
+    description: 'Force execution even if git state is unchanged',
+  })
   .help()
   .alias('h', 'help')
   .parse();
@@ -46,6 +50,7 @@ let startPhase = argv.phase;
 let logFolder = argv.logFolder;
 const phases = argv.phases ? argv.phases.split(',').map(p => p.trim()) : null;
 const sequential = argv.sequential || false;
+const force = argv.force || false;
 
 // Validate config file exists
 if (!fs.existsSync(configPath)) {
@@ -75,7 +80,7 @@ if (logFolder) {
 }
 
 // Create and run the orchestrator
-const orchestrator = new Orchestrator(commandsConfig, startPhase, logFolder, phases, sequential);
+const orchestrator = new Orchestrator(commandsConfig, startPhase, logFolder, phases, sequential, force);
 
 // Enhanced signal handlers
 const handleSignal = async (signal) => {

package/lib/health-check.js

@@ -1,4 +1,5 @@
 import { log } from './logger.js';
+import chalk from 'chalk';
 
 export class HealthCheck {
   constructor() {
@@ -17,17 +18,17 @@ export class HealthCheck {
       const urlObj = new URL(url);
       const isHttps = urlObj.protocol === 'https:';
       const httpModule = isHttps ? await import('https') : await import('http');
-      
+
       return await new Promise((resolve) => {
         const req = httpModule.default.get(url, (res) => {
           resolve({ statusCode: res.statusCode, success: true });
           res.destroy(); // Close the response stream
         });
-        
+
         req.on('error', (error) => {
           resolve({ statusCode: null, success: false, error: error.message });
         });
-        
+
         req.setTimeout(timeout, () => {
           req.destroy();
           resolve({ statusCode: null, success: false, error: 'Timeout' });
@@ -38,30 +39,45 @@ export class HealthCheck {
     }
   }
 
-  async waitForUrl({url, maxAttempts = 20, interval = 2000, silent=false}) {
-    !silent && this.logger.info(`Waiting for ${url} to be available...`);
+  async waitForUrl({ url, maxAttempts = 20, interval = 2000, silent = false }) {
+    if (!silent) {
+      this.logger.startEphemeral(
+        `wait_${url}`,
+        chalk.yellow(`[INFO] ⏳ Waiting for ${url} to be available...`),
+      );
+    }
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
       try {
         const result = await HealthCheck.makeHttpRequest(url, 5000);
 
         if (result.success && result.statusCode === 200) {
-          !silent && this.logger.success(`${url} is available`);
+          if (!silent) {
+            this.logger.stopEphemeral(`wait_${url}`, `✅ ${url} is available`);
+          }
           return true;
         }
       } catch (error) {
-        !silent && this.logger.verbose(`Attempt ${attempt}/${maxAttempts} failed: ${error.message}`);
+        if (!silent) {
+          // You could potentially log attempts via verbose if needed, but not necessary.
+        }
       }
 
       if (attempt < maxAttempts) {
         await new Promise((resolve) => setTimeout(resolve, interval));
       }
     }
-    
-    !silent && this.logger.error(`Failed to connect to ${url} after ${maxAttempts} attempts`);
-    
+
+    if (!silent) {
+      this.logger.stopEphemeral(
+        `wait_${url}`,
+        `❌ Failed to connect to ${url} after ${maxAttempts} attempts`,
+        true,
+      );
+    }
+
     return false;
   }
 }
 
 // For backward compatibility
-export const healthCheck = new HealthCheck(); 
+export const healthCheck = new HealthCheck();

package/lib/logger.js

@@ -30,9 +30,131 @@ class Logger {
     this.logFolder = argv.logFolder || 'scripts-orchestrator-logs';
     this.logFile = null;
     this.logStream = null;
+
+    // For TTY dynamic output
+    this.isTTY = process.stdout.isTTY;
+    this.activeTasks = new Map();
+    this.linesRendered = 0;
+
     this.initializeLogFile();
   }
 
+  // --- Dynamic Output Handling ---
+
+  clearActiveTasks() {
+    if (!this.isTTY || this.linesRendered === 0) return;
+    // Move cursor up and clear lines
+    for (let i = 0; i < this.linesRendered; i++) {
+      process.stdout.write('\x1b[1A\x1b[2K'); // Up one line, clear entire line
+    }
+    this.linesRendered = 0;
+  }
+
+  renderActiveTasks() {
+    if (!this.isTTY) return;
+    if (this.activeTasks.size === 0) return;
+
+    // Render active tasks with a spinner or prefix
+    for (const [, text] of this.activeTasks) {
+      process.stdout.write(`${text}\n`);
+      this.linesRendered++;
+    }
+  }
+
+  startTask(id, text) {
+    if (this.isTTY) {
+      this.clearActiveTasks();
+      this.activeTasks.set(id, chalk.cyan(`[INFO] ⏳ Running: ${text}`));
+      this.renderActiveTasks();
+    } else {
+      this.info(`Running: ${text}`);
+    }
+  }
+
+  updateTask(id, text) {
+    if (this.isTTY && this.activeTasks.has(id)) {
+      this.clearActiveTasks();
+      this.activeTasks.set(id, chalk.cyan(`[INFO] ⏳ Running: ${text}`));
+      this.renderActiveTasks();
+    }
+  }
+
+  stopTask(id) {
+    if (this.isTTY && this.activeTasks.has(id)) {
+      this.clearActiveTasks();
+      this.activeTasks.delete(id);
+      this.renderActiveTasks();
+    }
+  }
+
+  // --- Wrapper for output methods ---
+
+  printMessage(logFn) {
+    if (this.isTTY) {
+      this.clearActiveTasks();
+      logFn();
+      this.renderActiveTasks();
+    } else {
+      logFn();
+    }
+  }
+
+  startEphemeral(id, message) {
+    if (this.isTTY) {
+      this.clearActiveTasks();
+      this.activeTasks.set(id, message);
+      this.renderActiveTasks();
+    } else {
+      this.printMessage(() => console.log(message));
+    }
+  }
+
+  stopEphemeral(id, finalMessage = '', isError = false) {
+    if (this.isTTY && this.activeTasks.has(id)) {
+      this.clearActiveTasks();
+      this.activeTasks.delete(id);
+      this.renderActiveTasks();
+    }
+
+    if (finalMessage) {
+      if (isError) {
+        this.printMessage(() =>
+          console.error(chalk.red(`[ERROR] ${finalMessage}`)),
+        );
+      } else {
+        this.printMessage(() =>
+          console.log(chalk.green(`[SUCCESS] ${finalMessage}`)),
+        );
+      }
+    }
+  }
+
+  stopPhase(phaseName, success, durationStr) {
+    if (success) {
+      this.printMessage(() =>
+        console.log(
+          chalk.green(
+            `[SUCCESS] ✅ Phase "${phaseName}" completed successfully ${durationStr}`,
+          ),
+        ),
+      );
+      // Add a blank line after phase logs for readability
+      this.printMessage(() => console.log(''));
+      this.writeToFile('');
+    } else {
+      this.printMessage(() =>
+        console.error(
+          chalk.red(
+            `[ERROR] ❌ Phase "${phaseName}" completed with failures ${durationStr}`,
+          ),
+        ),
+      );
+      // Add a blank line after phase logs for readability
+      this.printMessage(() => console.log(''));
+      this.writeToFile('');
+    }
+  }
+
   initializeLogFile() {
     try {
       // Create log directory if it doesn't exist
@@ -41,12 +163,18 @@ class Logger {
       }
 
       // Create main log file with timestamp
-      const timestamp = new Date().toISOString().replace(/:/g, '-').replace(/\..+/, '');
-      this.logFile = path.join(this.logFolder, `orchestrator-main-${timestamp}.log`);
-      
+      const timestamp = new Date()
+        .toISOString()
+        .replace(/:/g, '-')
+        .replace(/\..+/, '');
+      this.logFile = path.join(
+        this.logFolder,
+        `orchestrator-main-${timestamp}.log`,
+      );
+
       // Create write stream
       this.logStream = fs.createWriteStream(this.logFile, { flags: 'a' });
-      
+
       // Handle stream errors
       this.logStream.on('error', (err) => {
         console.error(`Error writing to log file: ${err.message}`);
@@ -60,7 +188,9 @@ class Logger {
       });
 
       // Write initial log entry
-      this.writeToFile(`[START] Orchestrator started at ${new Date().toISOString()}\n`);
+      this.writeToFile(
+        `[START] Orchestrator started at ${new Date().toISOString()}\n`,
+      );
     } catch (error) {
       console.error(`Failed to initialize log file: ${error.message}`);
     }
@@ -74,7 +204,7 @@ class Logger {
 
     // Update log folder
     this.logFolder = newLogFolder;
-    
+
     // Reinitialize with new folder
     this.initializeLogFile();
   }
@@ -89,28 +219,28 @@ class Logger {
   }
 
   info(message) {
-    console.log(chalk.blue(`[INFO] ${message}`));
+    this.printMessage(() => console.log(chalk.blue(`[INFO] ${message}`)));
     this.writeToFile(`[INFO] ${message}`);
   }
 
   success(message) {
-    console.log(chalk.green(`[SUCCESS] ${message}`));
+    this.printMessage(() => console.log(chalk.green(`[SUCCESS] ${message}`)));
     this.writeToFile(`[SUCCESS] ${message}`);
   }
 
   error(message) {
-    console.error(chalk.red(`[ERROR] ${message}`));
+    this.printMessage(() => console.error(chalk.red(`[ERROR] ${message}`)));
     this.writeToFile(`[ERROR] ${message}`);
   }
 
   warn(message) {
-    console.warn(chalk.yellow(`[WARN] ${message}`));
+    this.printMessage(() => console.warn(chalk.yellow(`[WARN] ${message}`)));
     this.writeToFile(`[WARN] ${message}`);
   }
 
   verbose(message) {
     if (this.isVerbose) {
-      console.log(chalk.gray(`[VERBOSE] ${message}`));
+      this.printMessage(() => console.log(chalk.gray(`[VERBOSE] ${message}`)));
       this.writeToFile(`[VERBOSE] ${message}`);
     }
   }
@@ -120,4 +250,4 @@ class Logger {
 const logger = new Logger();
 
 // Export both the class and the instance
-export { Logger, logger as log }; 
+export { Logger, logger as log };