scripts-orchestrator 2.10.0 → 2.13.0

package/index.js

@@ -39,6 +39,18 @@ const argv = yargs(hideBin(process.argv))
     type: 'boolean',
     description: 'Force execution even if git state is unchanged',
   })
+  .option('metrics', {
+    type: 'string',
+    description: 'Comma-separated metrics to collect and report: time, memory',
+  })
+  .option('json-results', {
+    type: 'string',
+    description: 'Write results JSON to this path; use "-" for stdout only',
+  })
+  .option('html-results', {
+    type: 'string',
+    description: 'Write HTML report to this path; use "-" for stdout only',
+  })
   .help()
   .alias('h', 'help')
   .parse();
@@ -52,6 +64,8 @@ const phases = argv.phases ? argv.phases.split(',').map(p => p.trim()) : null;
 const sequential = argv.sequential || false;
 const force = argv.force || false;
 
+const validMetrics = ['time', 'memory'];
+
 // Validate config file exists
 if (!fs.existsSync(configPath)) {
   log.error(`Error: Config file not found at ${configPath}`);
@@ -74,13 +88,46 @@ if (!logFolder && commandsConfig.log_folder) {
   logFolder = commandsConfig.log_folder;
 }
 
+// Metrics: CLI overrides config
+let metrics = [];
+if (argv.metrics != null && argv.metrics !== '') {
+  metrics = argv.metrics.split(',').map((m) => m.trim()).filter((m) => validMetrics.includes(m));
+} else if (commandsConfig.metrics != null) {
+  const fromConfig = Array.isArray(commandsConfig.metrics)
+    ? commandsConfig.metrics
+    : String(commandsConfig.metrics).split(',').map((m) => m.trim());
+  metrics = fromConfig.filter((m) => validMetrics.includes(m));
+}
+
+// JSON results path: CLI overrides config
+const jsonResultsPath =
+  argv.jsonResults != null
+    ? argv.jsonResults
+    : (commandsConfig.json_results ?? commandsConfig.json_results_path ?? null);
+
+// HTML results path: CLI overrides config (optional)
+const htmlResultsPath =
+  argv.htmlResults != null
+    ? argv.htmlResults
+    : (commandsConfig.html_results ?? commandsConfig.html_results_path ?? null);
+
 // Set the log folder for the main orchestrator logs if specified
 if (logFolder) {
   log.setLogFolder(logFolder);
 }
 
 // Create and run the orchestrator
-const orchestrator = new Orchestrator(commandsConfig, startPhase, logFolder, phases, sequential, force);
+const orchestrator = new Orchestrator(
+  commandsConfig,
+  startPhase,
+  logFolder,
+  phases,
+  sequential,
+  force,
+  metrics,
+  jsonResultsPath,
+  htmlResultsPath,
+);
 
 // 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 };