@covibes/zeroshot 1.4.0 → 2.0.0

package/cli/lib/first-run.js

@@ -0,0 +1,174 @@
+/**
+ * First-Run Setup Wizard
+ *
+ * Interactive setup on first use:
+ * - Welcome banner
+ * - Default model selection (sonnet/opus/haiku)
+ * - Auto-update preference
+ * - Marks setup as complete
+ */
+
+const readline = require('readline');
+const { loadSettings, saveSettings } = require('../../lib/settings');
+
+/**
+ * Print welcome banner
+ */
+function printWelcome() {
+  console.log(`
+╔═══════════════════════════════════════════════════════════════╗
+║                                                               ║
+║   Welcome to Zeroshot!                                        ║
+║   Multi-agent orchestration for Claude                        ║
+║                                                               ║
+║   Let's configure a few settings to get started.              ║
+║                                                               ║
+╚═══════════════════════════════════════════════════════════════╝
+`);
+}
+
+/**
+ * Create readline interface
+ * @returns {readline.Interface}
+ */
+function createReadline() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+/**
+ * Prompt for model selection
+ * @param {readline.Interface} rl
+ * @returns {Promise<string>}
+ */
+function promptModel(rl) {
+  return new Promise((resolve) => {
+    console.log('Which Claude model should agents use by default?\n');
+    console.log('  1) sonnet  - Fast & capable (recommended)');
+    console.log('  2) opus    - Most capable, slower');
+    console.log('  3) haiku   - Fastest, for simple tasks\n');
+
+    rl.question('Enter 1, 2, or 3 [1]: ', (answer) => {
+      const choice = answer.trim() || '1';
+      switch (choice) {
+        case '2':
+          resolve('opus');
+          break;
+        case '3':
+          resolve('haiku');
+          break;
+        default:
+          resolve('sonnet');
+      }
+    });
+  });
+}
+
+/**
+ * Prompt for auto-update preference
+ * @param {readline.Interface} rl
+ * @returns {Promise<boolean>}
+ */
+function promptAutoUpdate(rl) {
+  return new Promise((resolve) => {
+    console.log('\nWould you like zeroshot to check for updates automatically?');
+    console.log('(Checks npm registry every 24 hours)\n');
+
+    rl.question('Enable auto-update checks? [Y/n]: ', (answer) => {
+      const normalized = answer.trim().toLowerCase();
+      // Default to yes if empty or starts with 'y'
+      resolve(normalized === '' || normalized === 'y' || normalized === 'yes');
+    });
+  });
+}
+
+/**
+ * Print completion message
+ * @param {object} settings - Saved settings
+ */
+function printComplete(settings) {
+  console.log(`
+╔═══════════════════════════════════════════════════════════════╗
+║  Setup complete!                                              ║
+╚═══════════════════════════════════════════════════════════════╝
+
+Your settings:
+  • Default model: ${settings.defaultModel}
+  • Auto-updates:  ${settings.autoCheckUpdates ? 'enabled' : 'disabled'}
+
+Change anytime with: zeroshot settings set <key> <value>
+
+Get started:
+  zeroshot run "Fix the bug in auth.js"
+  zeroshot run 123  (GitHub issue number)
+  zeroshot --help
+
+`);
+}
+
+/**
+ * Check if first-run setup is needed
+ * @param {object} settings - Current settings
+ * @returns {boolean}
+ */
+function detectFirstRun(settings) {
+  return !settings.firstRunComplete;
+}
+
+/**
+ * Main entry point - run first-time setup if needed
+ * @param {object} options
+ * @param {boolean} options.quiet - Skip interactive prompts
+ * @returns {Promise<boolean>} True if setup was run
+ */
+async function checkFirstRun(options = {}) {
+  const settings = loadSettings();
+
+  // Already completed setup
+  if (!detectFirstRun(settings)) {
+    return false;
+  }
+
+  // Quiet mode - use defaults, mark complete
+  if (options.quiet) {
+    settings.firstRunComplete = true;
+    saveSettings(settings);
+    return true;
+  }
+
+  // Interactive setup
+  printWelcome();
+
+  const rl = createReadline();
+
+  try {
+    // Model selection
+    const model = await promptModel(rl);
+    settings.defaultModel = model;
+
+    // Auto-update preference
+    const autoUpdate = await promptAutoUpdate(rl);
+    settings.autoCheckUpdates = autoUpdate;
+
+    // Mark complete
+    settings.firstRunComplete = true;
+    saveSettings(settings);
+
+    // Print completion
+    printComplete(settings);
+
+    return true;
+  } finally {
+    rl.close();
+  }
+}
+
+module.exports = {
+  checkFirstRun,
+  // Exported for testing
+  detectFirstRun,
+  printWelcome,
+  printComplete,
+};

package/cli/lib/update-checker.js

@@ -0,0 +1,234 @@
+/**
+ * Update Checker - Checks npm registry for newer versions
+ *
+ * Features:
+ * - 24-hour check interval (avoids registry spam)
+ * - 5-second timeout (non-blocking if offline)
+ * - Interactive prompt for manual update
+ * - Respects quiet mode (no prompts in CI/scripts)
+ */
+
+const https = require('https');
+const { spawn } = require('child_process');
+const readline = require('readline');
+const { loadSettings, saveSettings } = require('../../lib/settings');
+
+// 24 hours in milliseconds
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+
+// Timeout for npm registry fetch (5 seconds)
+const FETCH_TIMEOUT_MS = 5000;
+
+// npm registry URL
+const REGISTRY_URL = 'https://registry.npmjs.org/@covibes/zeroshot/latest';
+
+/**
+ * Get current package version
+ * @returns {string}
+ */
+function getCurrentVersion() {
+  const pkg = require('../../package.json');
+  return pkg.version;
+}
+
+/**
+ * Compare semver versions
+ * @param {string} current - Current version (e.g., "1.5.0")
+ * @param {string} latest - Latest version (e.g., "1.6.0")
+ * @returns {boolean} True if latest > current
+ */
+function isNewerVersion(current, latest) {
+  const currentParts = current.split('.').map(Number);
+  const latestParts = latest.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    const c = currentParts[i] || 0;
+    const l = latestParts[i] || 0;
+    if (l > c) return true;
+    if (l < c) return false;
+  }
+  return false;
+}
+
+/**
+ * Fetch latest version from npm registry
+ * @returns {Promise<string|null>} Latest version or null on failure
+ */
+function fetchLatestVersion() {
+  return new Promise((resolve) => {
+    const req = https.get(REGISTRY_URL, { timeout: FETCH_TIMEOUT_MS }, (res) => {
+      if (res.statusCode !== 200) {
+        resolve(null);
+        return;
+      }
+
+      let data = '';
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          resolve(json.version || null);
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+
+    req.on('error', () => {
+      resolve(null);
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(null);
+    });
+
+    // Additional safety timeout
+    setTimeout(() => {
+      req.destroy();
+      resolve(null);
+    }, FETCH_TIMEOUT_MS + 1000);
+  });
+}
+
+/**
+ * Prompt user for update confirmation
+ * @param {string} currentVersion
+ * @param {string} latestVersion
+ * @returns {Promise<boolean>} True if user wants to update
+ */
+function promptForUpdate(currentVersion, latestVersion) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    console.log(`\n📦 Update available: ${currentVersion} → ${latestVersion}`);
+    rl.question('   Install now? [y/N] ', (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+/**
+ * Run npm install to update the package
+ * @returns {Promise<boolean>} True if update succeeded
+ */
+function runUpdate() {
+  return new Promise((resolve) => {
+    console.log('\n📥 Installing update...');
+
+    const proc = spawn('npm', ['install', '-g', '@covibes/zeroshot@latest'], {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        console.log('✅ Update installed successfully!');
+        console.log('   Restart zeroshot to use the new version.\n');
+        resolve(true);
+      } else {
+        console.log('❌ Update failed. Try manually:');
+        console.log('   npm install -g @covibes/zeroshot@latest\n');
+        resolve(false);
+      }
+    });
+
+    proc.on('error', () => {
+      console.log('❌ Update failed. Try manually:');
+      console.log('   npm install -g @covibes/zeroshot@latest\n');
+      resolve(false);
+    });
+  });
+}
+
+/**
+ * Check if update check should run
+ * @param {object} settings - Current settings
+ * @returns {boolean}
+ */
+function shouldCheckForUpdates(settings) {
+  // Disabled by user
+  if (!settings.autoCheckUpdates) {
+    return false;
+  }
+
+  // Never checked before
+  if (!settings.lastUpdateCheckAt) {
+    return true;
+  }
+
+  // Check if 24 hours have passed
+  const elapsed = Date.now() - settings.lastUpdateCheckAt;
+  return elapsed >= CHECK_INTERVAL_MS;
+}
+
+/**
+ * Main entry point - check for updates
+ * @param {object} options
+ * @param {boolean} options.quiet - Skip interactive prompts
+ * @returns {Promise<void>}
+ */
+async function checkForUpdates(options = {}) {
+  const settings = loadSettings();
+
+  // Skip check if not due
+  if (!shouldCheckForUpdates(settings)) {
+    return;
+  }
+
+  const currentVersion = getCurrentVersion();
+  const latestVersion = await fetchLatestVersion();
+
+  // Update last check timestamp regardless of result
+  settings.lastUpdateCheckAt = Date.now();
+  saveSettings(settings);
+
+  // Network failure - silently skip
+  if (!latestVersion) {
+    return;
+  }
+
+  // No update available
+  if (!isNewerVersion(currentVersion, latestVersion)) {
+    return;
+  }
+
+  // Already notified about this version
+  if (settings.lastSeenVersion === latestVersion) {
+    return;
+  }
+
+  // Update lastSeenVersion so we don't nag about the same version
+  settings.lastSeenVersion = latestVersion;
+  saveSettings(settings);
+
+  // Quiet mode - just inform, no prompt
+  if (options.quiet) {
+    console.log(`📦 Update available: ${currentVersion} → ${latestVersion}`);
+    console.log('   Run: npm install -g @covibes/zeroshot@latest\n');
+    return;
+  }
+
+  // Interactive mode - prompt for update
+  const wantsUpdate = await promptForUpdate(currentVersion, latestVersion);
+  if (wantsUpdate) {
+    await runUpdate();
+  }
+}
+
+module.exports = {
+  checkForUpdates,
+  // Exported for testing
+  getCurrentVersion,
+  isNewerVersion,
+  fetchLatestVersion,
+  shouldCheckForUpdates,
+  CHECK_INTERVAL_MS,
+};

package/cli/message-formatters-normal.js

@@ -1,6 +1,9 @@
 /**
  * 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');
@@ -9,9 +12,10 @@ 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) {
+function formatAgentLifecycle(msg, prefix, print = console.log) {
   const data = msg.content?.data;
   const event = data?.event;
 
@@ -35,7 +39,7 @@ function formatAgentLifecycle(msg, prefix) {
       eventText = event || 'unknown event';
   }
 
-  console.log(`${prefix} ${icon} ${eventText}`);
+  print(`${prefix} ${icon} ${eventText}`);
   return true;
 }
 
@@ -44,27 +48,28 @@ function formatAgentLifecycle(msg, prefix) {
  * @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) {
-  console.log(''); // Blank line before error
-  console.log(chalk.bold.red(`${'─'.repeat(60)}`));
-  console.log(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.red('🔴 AGENT ERROR')}`);
+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) {
-    console.log(`${prefix} ${chalk.red(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()) {
-        console.log(`${prefix} ${chalk.dim(line)}`);
+        print(`${prefix} ${chalk.dim(line)}`);
       }
     }
   }
 
-  console.log(chalk.bold.red(`${'─'.repeat(60)}`));
+  print(chalk.bold.red(`${'─'.repeat(60)}`));
   return true;
 }
 
@@ -74,29 +79,30 @@ function formatAgentError(msg, prefix, timestamp) {
  * @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) {
+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);
 
-  console.log(''); // Blank line before new task
-  console.log(chalk.bold.blue(`${'─'.repeat(60)}`));
-  console.log(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.blue('📋 NEW TASK')}`);
+  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') {
-        console.log(`${prefix} ${chalk.white(line)}`);
+        print(`${prefix} ${chalk.white(line)}`);
       }
     }
   }
 
-  console.log(chalk.bold.blue(`${'─'.repeat(60)}`));
+  print(chalk.bold.blue(`${'─'.repeat(60)}`));
   return true;
 }
 
@@ -105,15 +111,16 @@ function formatIssueOpened(msg, prefix, timestamp, shownNewTaskForCluster) {
  * @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) {
-  console.log(
+function formatImplementationReady(msg, prefix, timestamp, print = console.log) {
+  print(
     `${prefix} ${chalk.gray(timestamp)} ${chalk.bold.yellow('✅ IMPLEMENTATION READY')}`
   );
 
   if (msg.content?.data?.commit) {
-    console.log(
+    print(
       `${prefix} ${chalk.gray('Commit:')} ${chalk.cyan(msg.content.data.commit.substring(0, 8))}`
     );
   }
@@ -126,22 +133,23 @@ function formatImplementationReady(msg, prefix, timestamp) {
  * @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) {
+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');
 
-  console.log(`${prefix} ${chalk.gray(timestamp)} ${status}`);
+  print(`${prefix} ${chalk.gray(timestamp)} ${status}`);
 
   // Show summary if present and not a template variable
   if (msg.content?.text && !msg.content.text.includes('{{')) {
-    console.log(`${prefix} ${msg.content.text.substring(0, 100)}`);
+    print(`${prefix} ${msg.content.text.substring(0, 100)}`);
   }
 
   // Show full JSON data structure
-  console.log(
+  print(
     `${prefix} ${chalk.dim(JSON.stringify(data, null, 2).split('\n').join(`\n${prefix} `))}`
   );
 
@@ -153,16 +161,17 @@ function formatValidationResult(msg, prefix, timestamp) {
  * @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) {
-  console.log(''); // Blank line
-  console.log(chalk.bold.green(`${'═'.repeat(60)}`));
-  console.log(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.green('🎉 CLUSTER COMPLETE')}`);
+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) {
-    console.log(`${prefix} ${chalk.green(msg.content.data.reason)}`);
+    print(`${prefix} ${chalk.green(msg.content.data.reason)}`);
   }
-  console.log(chalk.bold.green(`${'═'.repeat(60)}`));
+  print(chalk.bold.green(`${'═'.repeat(60)}`));
   return true;
 }
 
@@ -171,19 +180,47 @@ function formatClusterComplete(msg, prefix, timestamp) {
  * @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) {
-  console.log(''); // Blank line
-  console.log(chalk.bold.red(`${'═'.repeat(60)}`));
-  console.log(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold.red('❌ CLUSTER FAILED')}`);
+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) {
-    console.log(`${prefix} ${chalk.red(msg.content.text)}`);
+    print(`${prefix} ${chalk.red(msg.content.text)}`);
   }
   if (msg.content?.data?.reason) {
-    console.log(`${prefix} ${chalk.red(msg.content.data.reason)}`);
+    print(`${prefix} ${chalk.red(msg.content.data.reason)}`);
   }
-  console.log(chalk.bold.red(`${'═'.repeat(60)}`));
+  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;
 }
 
@@ -192,12 +229,13 @@ function formatClusterFailed(msg, prefix, timestamp) {
  * @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) {
-  console.log(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold(msg.topic)}`);
+function formatGenericMessage(msg, prefix, timestamp, print = console.log) {
+  print(`${prefix} ${chalk.gray(timestamp)} ${chalk.bold(msg.topic)}`);
   if (msg.content?.text) {
-    console.log(`${prefix} ${msg.content.text}`);
+    print(`${prefix} ${msg.content.text}`);
   }
   return true;
 }
@@ -208,6 +246,7 @@ module.exports = {
   formatIssueOpened,
   formatImplementationReady,
   formatValidationResult,
+  formatPrCreated,
   formatClusterComplete,
   formatClusterFailed,
   formatGenericMessage,