@the-open-engine/zeroshot 5.4.0

package/cli/message-formatters-normal.js

@@ -0,0 +1,275 @@
+/**
+ * Normal mode message formatters
+ * Full-detail message display for non-watch mode
+ *
+ * All functions accept an optional `print` parameter for output routing.
+ * When StatusFooter is active, pass safePrint to avoid terminal garbling.
+ */
+
+const chalk = require('chalk');
+
+/**
+ * Format AGENT_LIFECYCLE events
+ * @param {Object} msg - Message object
+ * @param {string} prefix - Formatted message prefix
+ * @param {Function} [print=console.log] - Print function for output
+ * @returns {boolean} True if message was handled
+ */
+function formatAgentLifecycle(msg, prefix, print = console.log) {
+  const data = msg.content?.data;
+  const event = data?.event;
+
+  let icon, eventText;
+  switch (event) {
+    case 'STARTED':
+      icon = chalk.green('▶');
+      const triggers = data.triggers?.join(', ') || 'none';
+      eventText = `started (listening for: ${chalk.dim(triggers)})`;
+      break;
+    case 'TASK_STARTED':
+      icon = chalk.yellow('⚡');
+      eventText = `${chalk.cyan(data.triggeredBy)} → task #${data.iteration} (${chalk.dim(data.model)})`;
+      break;
+    case 'TASK_COMPLETED':
+      icon = chalk.green('✓');
+      eventText = `task #${data.iteration} completed`;
+      break;
+    default:
+      icon = chalk.dim('•');
+      eventText = event || 'unknown event';
+  }
+
+  print(`${prefix} ${icon} ${eventText}`);
+  return true;
+}
+
+/**
+ * Format AGENT_ERROR events
+ * @param {Object} msg - Message object
+ * @param {string} prefix - Formatted message prefix
+ * @param {string} timestamp - Formatted timestamp
+ * @param {Function} [print=console.log] - Print function for output
+ * @returns {boolean} True if message was handled
+ */
+function formatAgentError(msg, prefix, timestamp, print = console.log) {
+  print(''); // Blank line before error
+  print(chalk.bold.red(`${'─'.repeat(60)}`));
+  print(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.red('🔴 AGENT ERROR')}`);
+
+  if (msg.content?.text) {
+    print(`${prefix} ${chalk.red(msg.content.text)}`);
+  }
+
+  if (msg.content?.data?.stack) {
+    const stackLines = msg.content.data.stack.split('\n').slice(0, 5);
+    for (const line of stackLines) {
+      if (line.trim()) {
+        print(`${prefix} ${chalk.dim(line)}`);
+      }
+    }
+  }
+
+  print(chalk.bold.red(`${'─'.repeat(60)}`));
+  return true;
+}
+
+/**
+ * Format ISSUE_OPENED events
+ * @param {Object} msg - Message object
+ * @param {string} prefix - Formatted message prefix
+ * @param {string} timestamp - Formatted timestamp
+ * @param {Set} shownNewTaskForCluster - Set tracking shown tasks
+ * @param {Function} [print=console.log] - Print function for output
+ * @returns {boolean} True if message was handled
+ */
+function formatIssueOpened(msg, prefix, timestamp, shownNewTaskForCluster, print = console.log) {
+  // Skip duplicate - conductor re-publishes after spawning agents
+  if (shownNewTaskForCluster.has(msg.cluster_id)) {
+    return true;
+  }
+  shownNewTaskForCluster.add(msg.cluster_id);
+
+  print(''); // Blank line before new task
+  print(chalk.bold.blue(`${'─'.repeat(60)}`));
+  print(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.blue('📋 NEW TASK')}`);
+
+  if (msg.content?.text) {
+    const lines = msg.content.text.split('\n').slice(0, 3);
+    for (const line of lines) {
+      if (line.trim() && line.trim() !== '# Manual Input') {
+        print(`${prefix} ${chalk.white(line)}`);
+      }
+    }
+  }
+
+  print(chalk.bold.blue(`${'─'.repeat(60)}`));
+  return true;
+}
+
+/**
+ * Format IMPLEMENTATION_READY events
+ * @param {Object} msg - Message object
+ * @param {string} prefix - Formatted message prefix
+ * @param {string} timestamp - Formatted timestamp
+ * @param {Function} [print=console.log] - Print function for output
+ * @returns {boolean} True if message was handled
+ */
+function formatImplementationReady(msg, prefix, timestamp, print = console.log) {
+  print(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.yellow('✅ IMPLEMENTATION READY')}`);
+
+  if (msg.content?.data?.commit) {
+    print(
+      `${prefix} ${chalk.gray('Commit:')} ${chalk.cyan(msg.content.data.commit.substring(0, 8))}`
+    );
+  }
+
+  return true;
+}
+
+/**
+ * Format VALIDATION_RESULT events
+ * @param {Object} msg - Message object
+ * @param {string} prefix - Formatted message prefix
+ * @param {string} timestamp - Formatted timestamp
+ * @param {Function} [print=console.log] - Print function for output
+ * @returns {boolean} True if message was handled
+ */
+function formatValidationResult(msg, prefix, timestamp, print = console.log) {
+  const data = msg.content?.data || {};
+  const approved = data.approved === true || data.approved === 'true';
+  const status = approved ? chalk.bold.green('✓ APPROVED') : chalk.bold.red('✗ REJECTED');
+
+  print(`${prefix} ${chalk.gray(timestamp)} ${status}`);
+
+  // Show summary if present and not a template variable
+  if (msg.content?.text && !msg.content.text.includes('{{')) {
+    print(`${prefix} ${msg.content.text.substring(0, 100)}`);
+  }
+
+  // Show CANNOT_VALIDATE (permanent) as warnings, CANNOT_VALIDATE_YET (temporary) as errors
+  const criteriaResults = data.criteriaResults;
+  if (Array.isArray(criteriaResults)) {
+    // CANNOT_VALIDATE_YET = temporary, treated as FAIL (work incomplete)
+    const cannotValidateYet = criteriaResults.filter((c) => c.status === 'CANNOT_VALIDATE_YET');
+    if (cannotValidateYet.length > 0) {
+      print(
+        `${prefix} ${chalk.red('❌ Cannot validate yet')} (${cannotValidateYet.length} criteria - work incomplete):`
+      );
+      for (const cv of cannotValidateYet) {
+        print(`${prefix}   ${chalk.red('•')} ${cv.id}: ${cv.reason || 'No reason provided'}`);
+      }
+    }
+
+    // CANNOT_VALIDATE = permanent, treated as PASS (environmental limitation)
+    const cannotValidate = criteriaResults.filter((c) => c.status === 'CANNOT_VALIDATE');
+    if (cannotValidate.length > 0) {
+      print(
+        `${prefix} ${chalk.yellow('⚠️ Could not validate')} (${cannotValidate.length} criteria - permanent):`
+      );
+      for (const cv of cannotValidate) {
+        print(`${prefix}   ${chalk.yellow('•')} ${cv.id}: ${cv.reason || 'No reason provided'}`);
+      }
+    }
+  }
+
+  // Show full JSON data structure
+  print(`${prefix} ${chalk.dim(JSON.stringify(data, null, 2).split('\n').join(`\n${prefix} `))}`);
+
+  return true;
+}
+
+/**
+ * Format CLUSTER_COMPLETE events
+ * @param {Object} msg - Message object
+ * @param {string} prefix - Formatted message prefix
+ * @param {string} timestamp - Formatted timestamp
+ * @param {Function} [print=console.log] - Print function for output
+ * @returns {boolean} True if message was handled
+ */
+function formatClusterComplete(msg, prefix, timestamp, print = console.log) {
+  print(''); // Blank line
+  print(chalk.bold.green(`${'═'.repeat(60)}`));
+  print(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.green('🎉 CLUSTER COMPLETE')}`);
+  if (msg.content?.data?.reason) {
+    print(`${prefix} ${chalk.green(msg.content.data.reason)}`);
+  }
+  print(chalk.bold.green(`${'═'.repeat(60)}`));
+  return true;
+}
+
+/**
+ * Format CLUSTER_FAILED events
+ * @param {Object} msg - Message object
+ * @param {string} prefix - Formatted message prefix
+ * @param {string} timestamp - Formatted timestamp
+ * @param {Function} [print=console.log] - Print function for output
+ * @returns {boolean} True if message was handled
+ */
+function formatClusterFailed(msg, prefix, timestamp, print = console.log) {
+  print(''); // Blank line
+  print(chalk.bold.red(`${'═'.repeat(60)}`));
+  print(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.red('❌ CLUSTER FAILED')}`);
+  if (msg.content?.text) {
+    print(`${prefix} ${chalk.red(msg.content.text)}`);
+  }
+  if (msg.content?.data?.reason) {
+    print(`${prefix} ${chalk.red(msg.content.data.reason)}`);
+  }
+  print(chalk.bold.red(`${'═'.repeat(60)}`));
+  return true;
+}
+
+/**
+ * Format PR_CREATED events
+ * @param {Object} msg - Message object
+ * @param {string} prefix - Formatted message prefix
+ * @param {string} timestamp - Formatted timestamp
+ * @param {Function} [print=console.log] - Print function for output
+ * @returns {boolean} True if message was handled
+ */
+function formatPrCreated(msg, prefix, timestamp, print = console.log) {
+  const prNumber = msg.content?.data?.pr_number || '';
+  const prUrl = msg.content?.data?.pr_url || '';
+
+  print(''); // Blank line before PR notification
+  print(chalk.bold.green(`${'─'.repeat(60)}`));
+  print(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.green('🎉 PULL REQUEST CREATED')}`);
+
+  if (prNumber) {
+    print(`${prefix} ${chalk.gray('PR:')} ${chalk.cyan(`#${prNumber}`)}`);
+  }
+  if (prUrl) {
+    print(`${prefix} ${chalk.gray('URL:')} ${chalk.blue(prUrl)}`);
+  }
+
+  print(chalk.bold.green(`${'─'.repeat(60)}`));
+  return true;
+}
+
+/**
+ * Format generic messages (fallback)
+ * @param {Object} msg - Message object
+ * @param {string} prefix - Formatted message prefix
+ * @param {string} timestamp - Formatted timestamp
+ * @param {Function} [print=console.log] - Print function for output
+ * @returns {boolean} True if message was handled
+ */
+function formatGenericMessage(msg, prefix, timestamp, print = console.log) {
+  print(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold(msg.topic)}`);
+  if (msg.content?.text) {
+    print(`${prefix} ${msg.content.text}`);
+  }
+  return true;
+}
+
+module.exports = {
+  formatAgentLifecycle,
+  formatAgentError,
+  formatIssueOpened,
+  formatImplementationReady,
+  formatValidationResult,
+  formatPrCreated,
+  formatClusterComplete,
+  formatClusterFailed,
+  formatGenericMessage,
+};

package/cli/message-formatters-watch.js

@@ -0,0 +1,185 @@
+/**
+ * Watch mode message formatters
+ * Simplified, high-level event display for zeroshot watch command
+ */
+
+const chalk = require('chalk');
+const {
+  buildClusterPrefix,
+  getColorForSender,
+  parseDataField,
+} = require('./message-formatter-utils');
+
+/**
+ * Format AGENT_ERROR for watch mode
+ * @param {Object} msg - Message object
+ * @param {string} clusterPrefix - Formatted cluster prefix
+ */
+function formatAgentError(msg, clusterPrefix) {
+  const errorMsg = `${msg.sender} ${chalk.bold.red('ERROR')}`;
+  console.log(`${clusterPrefix} ${errorMsg}`);
+  if (msg.content?.text) {
+    console.log(`${clusterPrefix}   ${chalk.red(msg.content.text)}`);
+  }
+}
+
+/**
+ * Format ISSUE_OPENED for watch mode
+ * @param {Object} msg - Message object
+ * @param {string} clusterPrefix - Formatted cluster prefix
+ */
+function formatIssueOpened(msg, clusterPrefix) {
+  const issueNum = msg.content?.data?.issue_number || '';
+  const title = msg.content?.data?.title || '';
+  const prompt = msg.content?.data?.prompt || msg.content?.text || '';
+
+  const taskDesc = title === 'Manual Input' && prompt ? prompt : title;
+  const truncatedDesc =
+    taskDesc && taskDesc.length > 60 ? taskDesc.substring(0, 60) + '...' : taskDesc;
+
+  const eventText = `Started ${issueNum ? `#${issueNum}` : 'task'}${truncatedDesc ? chalk.dim(` - ${truncatedDesc}`) : ''}`;
+  console.log(`${clusterPrefix} ${eventText}`);
+}
+
+/**
+ * Format IMPLEMENTATION_READY for watch mode
+ * @param {Object} msg - Message object
+ * @param {string} clusterPrefix - Formatted cluster prefix
+ */
+function formatImplementationReady(msg, clusterPrefix) {
+  const agentColor = getColorForSender(msg.sender);
+  const agentName = agentColor(msg.sender);
+  const eventText = `${agentName} completed implementation`;
+  console.log(`${clusterPrefix} ${eventText}`);
+}
+
+/**
+ * Format VALIDATION_RESULT for watch mode
+ * @param {Object} msg - Message object
+ * @param {string} clusterPrefix - Formatted cluster prefix
+ */
+function formatValidationResult(msg, clusterPrefix) {
+  const agentColor = getColorForSender(msg.sender);
+  const agentName = agentColor(msg.sender);
+  const data = msg.content?.data;
+  const approved = data?.approved === 'true' || data?.approved === true;
+  const status = approved ? chalk.green('APPROVED') : chalk.red('REJECTED');
+
+  let eventText = `${agentName} ${status}`;
+  if (data?.summary && !approved) {
+    eventText += chalk.dim(` - ${data.summary}`);
+  }
+  console.log(`${clusterPrefix} ${eventText}`);
+
+  if (!approved) {
+    printRejectionDetails(data, clusterPrefix);
+  }
+}
+
+/**
+ * Print rejection details (errors/issues)
+ * @param {Object} data - Validation data
+ * @param {string} clusterPrefix - Formatted cluster prefix
+ */
+function printRejectionDetails(data, clusterPrefix) {
+  const errors = parseDataField(data.errors);
+  const issues = parseDataField(data.issues);
+
+  if (errors.length > 0) {
+    const errorsCharCount = JSON.stringify(errors).length;
+    console.log(
+      `${clusterPrefix}   ${chalk.red('•')} ${errors.length} error${errors.length > 1 ? 's' : ''} (${errorsCharCount} chars)`
+    );
+  }
+
+  if (issues.length > 0) {
+    const issuesCharCount = JSON.stringify(issues).length;
+    console.log(
+      `${clusterPrefix}   ${chalk.yellow('•')} ${issues.length} issue${issues.length > 1 ? 's' : ''} (${issuesCharCount} chars)`
+    );
+  }
+}
+
+/**
+ * Format PR_CREATED for watch mode
+ * @param {Object} msg - Message object
+ * @param {string} clusterPrefix - Formatted cluster prefix
+ */
+function formatPrCreated(msg, clusterPrefix) {
+  const agentColor = getColorForSender(msg.sender);
+  const agentName = agentColor(msg.sender);
+  const prNum = msg.content?.data?.pr_number || '';
+  const eventText = `${agentName} created PR${prNum ? ` #${prNum}` : ''}`;
+  console.log(`${clusterPrefix} ${eventText}`);
+}
+
+/**
+ * Format PR_MERGED for watch mode
+ * @param {Object} msg - Message object
+ * @param {string} clusterPrefix - Formatted cluster prefix
+ */
+function formatPrMerged(msg, clusterPrefix) {
+  const agentColor = getColorForSender(msg.sender);
+  const agentName = agentColor(msg.sender);
+  const eventText = `${agentName} merged PR`;
+  console.log(`${clusterPrefix} ${eventText}`);
+}
+
+/**
+ * Format unknown topic for watch mode (fallback)
+ * @param {Object} msg - Message object
+ * @param {string} clusterPrefix - Formatted cluster prefix
+ */
+function formatUnknownTopic(msg, clusterPrefix) {
+  const agentColor = getColorForSender(msg.sender);
+  const agentName = agentColor(msg.sender);
+  const eventText = `${agentName} ${msg.topic.toLowerCase().replace(/_/g, ' ')}`;
+  console.log(`${clusterPrefix} ${eventText}`);
+}
+
+/**
+ * Main watch mode formatter
+ * @param {Object} msg - Message object
+ * @param {boolean} isActive - Whether cluster is active
+ * @returns {boolean} True if message was handled
+ */
+function formatWatchMode(msg, isActive) {
+  // Skip low-level topics (too noisy for watch mode)
+  if (msg.topic === 'AGENT_OUTPUT' || msg.topic === 'AGENT_LIFECYCLE') {
+    return true;
+  }
+
+  // Clear status line, print message, will be redrawn by status interval
+  process.stdout.write('\r' + ' '.repeat(120) + '\r');
+
+  const clusterPrefix = buildClusterPrefix(msg.cluster_id, isActive);
+
+  switch (msg.topic) {
+    case 'AGENT_ERROR':
+      formatAgentError(msg, clusterPrefix);
+      break;
+    case 'ISSUE_OPENED':
+      formatIssueOpened(msg, clusterPrefix);
+      break;
+    case 'IMPLEMENTATION_READY':
+      formatImplementationReady(msg, clusterPrefix);
+      break;
+    case 'VALIDATION_RESULT':
+      formatValidationResult(msg, clusterPrefix);
+      break;
+    case 'PR_CREATED':
+      formatPrCreated(msg, clusterPrefix);
+      break;
+    case 'PR_MERGED':
+      formatPrMerged(msg, clusterPrefix);
+      break;
+    default:
+      formatUnknownTopic(msg, clusterPrefix);
+  }
+
+  return true;
+}
+
+module.exports = {
+  formatWatchMode,
+};