vibecodingmachine-cli 2026.3.9-907 → 2026.3.10-1547

package/src/utils/auto-mode-simple-ui.js

@@ -1,141 +1,141 @@
-const chalk = require('chalk');
-const boxen = require('boxen');
-
-/**
- * Simple status-line UI for Auto Mode with persistent workflow card
- * Shows a purple card similar to Electron app that stays visible
- */
-class AutoModeSimpleUI {
-  constructor(options = {}) {
-    this.menuContent = options.menuContent || '';
-    this.requirement = 'Loading...';
-    this.step = 'PREPARE';
-    this.chatCount = 0;
-    this.maxChats = null;
-    this.progress = 0;
-
-    // Print header once
-    console.log('\n' + chalk.bold.cyan('═══════════════════════════════════════════════════════════'));
-    console.log(this.menuContent);
-    console.log(chalk.bold.cyan('═══════════════════════════════════════════════════════════') + '\n');
-
-    // Initial workflow card
-    this.printWorkflowCard();
-  }
-
-  updateStatus(status) {
-    if (status.requirement !== undefined) this.requirement = status.requirement;
-    if (status.step !== undefined) this.step = status.step;
-    if (status.chatCount !== undefined) this.chatCount = status.chatCount;
-    if (status.maxChats !== undefined) this.maxChats = status.maxChats;
-    if (status.progress !== undefined) this.progress = status.progress;
-
-    this.printWorkflowCard();
-  }
-
-  /**
-   * Get icon for each workflow stage based on current step
-   */
-  getStepIcon(stage, currentStage) {
-    const stageOrder = ['PREPARE', 'ACT', 'CLEAN UP', 'VERIFY', 'DONE'];
-    const currentIndex = stageOrder.indexOf(currentStage);
-    const stepIndex = stageOrder.indexOf(stage);
-
-    if (stepIndex < currentIndex) {
-      return '✅'; // Completed steps
-    } else if (stepIndex === currentIndex) {
-      if (currentStage === 'DONE') {
-        return '✅'; // Done is always checked
-      } else {
-        return '🔨'; // Current step
-      }
-    } else {
-      return '⏳'; // Pending steps
-    }
-  }
-
-  /**
-   * Render the persistent workflow card (similar to Electron app's purple card)
-   */
-  printWorkflowCard() {
-    // Step color mapping
-    const stepColors = {
-      'PREPARE': chalk.cyan,
-      'ACT': chalk.yellow,
-      'CLEAN UP': chalk.magenta,
-      'VERIFY': chalk.blue,
-      'DONE': chalk.green,
-      'UNKNOWN': chalk.gray
-    };
-
-    const currentStepColor = stepColors[this.step] || chalk.gray;
-
-    // Build workflow states line: PREPARE ⏳ ACT ⏳ CLEAN UP ⏳ VERIFY ⏳ DONE
-    const stages = [
-      { name: 'PREPARE', color: chalk.cyan },
-      { name: 'ACT', color: chalk.yellow },
-      { name: 'CLEAN UP', color: chalk.magenta },
-      { name: 'VERIFY', color: chalk.blue },
-      { name: 'DONE', color: chalk.green }
-    ];
-
-    const workflowLine = stages.map((stage, _index) => {
-      const icon = this.getStepIcon(stage.name, this.step);
-      const isCurrent = stage.name === this.step;
-      const stageColor = isCurrent ? currentStepColor.bold : stage.color;
-      return `${icon} ${stageColor(stage.name)}`;
-    }).join(` ${chalk.gray('⏳')} `);
-
-    // Truncate requirement if too long
-    const displayReq = this.requirement.length > 70
-      ? this.requirement.substring(0, 67) + '...'
-      : this.requirement;
-
-    // Build card content
-    const cardContent = [
-      workflowLine,
-      '',
-      chalk.bold.white(`🎯 Working on: ${displayReq}`)
-    ].join('\n');
-
-    // Render card with purple/magenta border (matching Electron app)
-    const card = boxen(cardContent, {
-      padding: { left: 1, right: 1, top: 1, bottom: 1 },
-      margin: { top: 0, right: 0, bottom: 1, left: 0 },
-      borderStyle: 'round',
-      borderColor: 'magenta',
-      backgroundColor: 'black'
-    });
-
-    console.log(card);
-  }
-
-  appendOutput(line) {
-    // Just print the line - no automatic card re-printing
-    if (line && line.trim()) {
-      console.log(line);
-    }
-  }
-
-  clearOutput() {
-    // No-op for simple UI
-  }
-
-  destroy() {
-    console.log('\n' + chalk.bold.green('Auto mode exited.') + '\n');
-  }
-}
-
-/**
- * Create and display a simple status UI for Auto Mode
- * @param {object} options - UI configuration
- * @returns {AutoModeSimpleUI} UI instance
- */
-function createAutoModeUI(options = {}) {
-  return new AutoModeSimpleUI(options);
-}
-
-module.exports = {
-  createAutoModeUI,
-  AutoModeSimpleUI
-};
+const chalk = require('chalk');
+const boxen = require('boxen');
+
+/**
+ * Simple status-line UI for Auto Mode with persistent workflow card
+ * Shows a purple card similar to Electron app that stays visible
+ */
+class AutoModeSimpleUI {
+  constructor(options = {}) {
+    this.menuContent = options.menuContent || '';
+    this.requirement = 'Loading...';
+    this.step = 'PREPARE';
+    this.chatCount = 0;
+    this.maxChats = null;
+    this.progress = 0;
+
+    // Print header once
+    console.log('\n' + chalk.bold.cyan('═══════════════════════════════════════════════════════════'));
+    console.log(this.menuContent);
+    console.log(chalk.bold.cyan('═══════════════════════════════════════════════════════════') + '\n');
+
+    // Initial workflow card
+    this.printWorkflowCard();
+  }
+
+  updateStatus(status) {
+    if (status.requirement !== undefined) this.requirement = status.requirement;
+    if (status.step !== undefined) this.step = status.step;
+    if (status.chatCount !== undefined) this.chatCount = status.chatCount;
+    if (status.maxChats !== undefined) this.maxChats = status.maxChats;
+    if (status.progress !== undefined) this.progress = status.progress;
+
+    this.printWorkflowCard();
+  }
+
+  /**
+   * Get icon for each workflow stage based on current step
+   */
+  getStepIcon(stage, currentStage) {
+    const stageOrder = ['PREPARE', 'ACT', 'CLEAN UP', 'VERIFY', 'DONE'];
+    const currentIndex = stageOrder.indexOf(currentStage);
+    const stepIndex = stageOrder.indexOf(stage);
+
+    if (stepIndex < currentIndex) {
+      return '✅'; // Completed steps
+    } else if (stepIndex === currentIndex) {
+      if (currentStage === 'DONE') {
+        return '✅'; // Done is always checked
+      } else {
+        return '🔨'; // Current step
+      }
+    } else {
+      return '⏳'; // Pending steps
+    }
+  }
+
+  /**
+   * Render the persistent workflow card (similar to Electron app's purple card)
+   */
+  printWorkflowCard() {
+    // Step color mapping
+    const stepColors = {
+      'PREPARE': chalk.cyan,
+      'ACT': chalk.yellow,
+      'CLEAN UP': chalk.magenta,
+      'VERIFY': chalk.blue,
+      'DONE': chalk.green,
+      'UNKNOWN': chalk.gray
+    };
+
+    const currentStepColor = stepColors[this.step] || chalk.gray;
+
+    // Build workflow states line: PREPARE ⏳ ACT ⏳ CLEAN UP ⏳ VERIFY ⏳ DONE
+    const stages = [
+      { name: 'PREPARE', color: chalk.cyan },
+      { name: 'ACT', color: chalk.yellow },
+      { name: 'CLEAN UP', color: chalk.magenta },
+      { name: 'VERIFY', color: chalk.blue },
+      { name: 'DONE', color: chalk.green }
+    ];
+
+    const workflowLine = stages.map((stage, _index) => {
+      const icon = this.getStepIcon(stage.name, this.step);
+      const isCurrent = stage.name === this.step;
+      const stageColor = isCurrent ? currentStepColor.bold : stage.color;
+      return `${icon} ${stageColor(stage.name)}`;
+    }).join(` ${chalk.gray('⏳')} `);
+
+    // Truncate requirement if too long
+    const displayReq = this.requirement.length > 70
+      ? this.requirement.substring(0, 67) + '...'
+      : this.requirement;
+
+    // Build card content
+    const cardContent = [
+      workflowLine,
+      '',
+      chalk.bold.white(`🎯 Working on: ${displayReq}`)
+    ].join('\n');
+
+    // Render card with purple/magenta border (matching Electron app)
+    const card = boxen(cardContent, {
+      padding: { left: 1, right: 1, top: 1, bottom: 1 },
+      margin: { top: 0, right: 0, bottom: 1, left: 0 },
+      borderStyle: 'round',
+      borderColor: 'magenta',
+      backgroundColor: 'black'
+    });
+
+    console.log(card);
+  }
+
+  appendOutput(line) {
+    // Just print the line - no automatic card re-printing
+    if (line && line.trim()) {
+      console.log(line);
+    }
+  }
+
+  clearOutput() {
+    // No-op for simple UI
+  }
+
+  destroy() {
+    console.log('\n' + chalk.bold.green('Auto mode exited.') + '\n');
+  }
+}
+
+/**
+ * Create and display a simple status UI for Auto Mode
+ * @param {object} options - UI configuration
+ * @returns {AutoModeSimpleUI} UI instance
+ */
+function createAutoModeUI(options = {}) {
+  return new AutoModeSimpleUI(options);
+}
+
+module.exports = {
+  createAutoModeUI,
+  AutoModeSimpleUI
+};

package/src/utils/copy-with-progress.js

@@ -1,167 +1,167 @@
-const { spawn, execSync } = require('child_process');
-const fs = require('fs-extra');
-const path = require('path');
-
-function progressBar(percent, width) {
-  const fill = Math.round((percent / 100) * width);
-  return '█'.repeat(fill) + '-'.repeat(Math.max(0, width - fill));
-}
-
-function formatEta(sec) {
-  if (!isFinite(sec) || sec === null) return '--:--';
-  const s = Math.max(0, Math.round(sec));
-  const m = Math.floor(s / 60);
-  const ss = s % 60;
-  return `${m}:${ss.toString().padStart(2, '0')}`;
-}
-
-async function tryRsync(src, dest, spinner, timeoutMs = 5 * 60 * 1000) {
-  try {
-    execSync('which rsync', { stdio: 'ignore' });
-  } catch (e) {
-    return false;
-  }
-  // choose progress option based on rsync version
-  let rsyncArgs = ['-a'];
-  try {
-    const verOut = execSync('rsync --version', { encoding: 'utf8', timeout: 2000 });
-    const m = verOut.match(/version\s+(\d+)\.(\d+)/i);
-    if (m) {
-      const major = Number(m[1]);
-      const minor = Number(m[2] || 0);
-      if (major > 3 || (major === 3 && minor >= 1)) {
-        rsyncArgs.push('--info=progress2');
-      } else {
-        rsyncArgs.push('--progress');
-      }
-    } else {
-      rsyncArgs.push('--progress');
-    }
-  } catch (e) {
-    rsyncArgs.push('--progress');
-  }
-
-  return await new Promise((resolve) => {
-    const rsync = spawn('rsync', rsyncArgs.concat([src + '/', dest]), { stdio: 'inherit' });
-    let finished = false;
-    const to = setTimeout(() => {
-      if (!finished) {
-        try { rsync.kill('SIGINT'); } catch (e) { /* ignore */ }
-        resolve(false);
-      }
-    }, timeoutMs);
-    rsync.on('close', (code) => { finished = true; clearTimeout(to); resolve(code === 0); });
-    rsync.on('error', () => { finished = true; clearTimeout(to); resolve(false); });
-  });
-}
-
-async function tryDitto(src, dest, spinner, timeoutMs = 5 * 60 * 1000) {
-  try {
-    await fs.ensureDir(path.dirname(dest));
-    return await new Promise((resolve) => {
-      const ditto = spawn('ditto', ['-v', src, dest], { stdio: 'inherit' });
-      let finished = false;
-      const to = setTimeout(() => {
-        if (!finished) {
-          try { ditto.kill('SIGINT'); } catch (e) { /* ignore */ }
-          resolve(false);
-        }
-      }, timeoutMs);
-      ditto.on('close', (code) => { finished = true; clearTimeout(to); resolve(code === 0); });
-      ditto.on('error', () => { finished = true; clearTimeout(to); resolve(false); });
-    });
-  } catch (e) {
-    return false;
-  }
-}
-
-async function nodeStreamCopy(src, dest, _spinner) {
-  // Determine total size (attempt du -sk fallback to recursive stat)
-  let total = 0;
-  try {
-    const out = execSync(`du -sk "${src}" | cut -f1`, { encoding: 'utf8' }).trim();
-    total = Number(out) * 1024;
-  } catch (e) {
-    // fallback: sum file sizes via traversal
-    await (async function walk(p) {
-      const entries = await fs.readdir(p);
-      for (const e of entries) {
-        const full = path.join(p, e);
-        const stat = await fs.stat(full);
-        if (stat.isDirectory()) await walk(full);
-        else total += stat.size;
-      }
-    })(src);
-  }
-
-  let copied = 0;
-  const start = Date.now();
-  const width = 30;
-
-  async function copyEntry(srcPath, dstPath) {
-    const stat = await fs.stat(srcPath);
-    if (stat.isDirectory()) {
-      await fs.ensureDir(dstPath);
-      const entries = await fs.readdir(srcPath);
-      for (const e of entries) {
-        await copyEntry(path.join(srcPath, e), path.join(dstPath, e));
-      }
-    } else {
-      await fs.ensureDir(path.dirname(dstPath));
-      await new Promise((resolve, reject) => {
-        const rs = fs.createReadStream(srcPath);
-        const ws = fs.createWriteStream(dstPath);
-        rs.on('data', (chunk) => {
-          copied += chunk.length;
-          if (total) {
-            const percent = Math.round((copied / total) * 100);
-            const mbCopied = (copied / (1024 * 1024)).toFixed(1);
-            const mbTotal = (total / (1024 * 1024)).toFixed(1);
-            const elapsed = Math.max(0.001, (Date.now() - start) / 1000);
-            const speed = copied / elapsed;
-            const eta = formatEta((total - copied) / (speed || 1));
-            const bar = progressBar(percent, width);
-            process.stdout.write(`\r\x1b[2K[${bar}] ${percent}% ${mbCopied}MB / ${mbTotal}MB ETA: ${eta}`);
-          } else {
-            process.stdout.write(`\r\x1b[2KCopying ${ (copied/(1024*1024)).toFixed(1) } MB`);
-          }
-        });
-        rs.on('error', reject);
-        ws.on('error', reject);
-        ws.on('close', resolve);
-        rs.pipe(ws);
-      });
-    }
-  }
-
-  await copyEntry(src, dest);
-  process.stdout.write('\n');
-  return true;
-}
-
-async function copyAppWithProgress(src, dest, opts = {}) {
-  const spinner = (opts && opts.spinner) || { start: () => {}, stop: () => {}, fail: () => {}, succeed: () => {} };
-
-  // Try rsync first
-  spinner.stop && spinner.stop();
-  console.log(`Copying ${path.basename(src)} -> ${dest} (attempting rsync...)`);
-  const okRsync = await tryRsync(src, dest, spinner);
-  if (okRsync) return true;
-
-  // Try ditto (macOS)
-  console.log('rsync failed or not available — trying ditto...');
-  const okDitto = await tryDitto(src, dest, spinner);
-  if (okDitto) return true;
-
-  // Fallback to Node streaming copy with progress
-  console.log('Falling back to node-stream copy with progress...');
-  try {
-    await nodeStreamCopy(src, dest, spinner);
-    return true;
-  } catch (e) {
-    console.error('node-stream copy failed:', e.message || e);
-    return false;
-  }
-}
-
-module.exports = { copyAppWithProgress };
+const { spawn, execSync } = require('child_process');
+const fs = require('fs-extra');
+const path = require('path');
+
+function progressBar(percent, width) {
+  const fill = Math.round((percent / 100) * width);
+  return '█'.repeat(fill) + '-'.repeat(Math.max(0, width - fill));
+}
+
+function formatEta(sec) {
+  if (!isFinite(sec) || sec === null) return '--:--';
+  const s = Math.max(0, Math.round(sec));
+  const m = Math.floor(s / 60);
+  const ss = s % 60;
+  return `${m}:${ss.toString().padStart(2, '0')}`;
+}
+
+async function tryRsync(src, dest, spinner, timeoutMs = 5 * 60 * 1000) {
+  try {
+    execSync('which rsync', { stdio: 'ignore' });
+  } catch (e) {
+    return false;
+  }
+  // choose progress option based on rsync version
+  let rsyncArgs = ['-a'];
+  try {
+    const verOut = execSync('rsync --version', { encoding: 'utf8', timeout: 2000 });
+    const m = verOut.match(/version\s+(\d+)\.(\d+)/i);
+    if (m) {
+      const major = Number(m[1]);
+      const minor = Number(m[2] || 0);
+      if (major > 3 || (major === 3 && minor >= 1)) {
+        rsyncArgs.push('--info=progress2');
+      } else {
+        rsyncArgs.push('--progress');
+      }
+    } else {
+      rsyncArgs.push('--progress');
+    }
+  } catch (e) {
+    rsyncArgs.push('--progress');
+  }
+
+  return await new Promise((resolve) => {
+    const rsync = spawn('rsync', rsyncArgs.concat([src + '/', dest]), { stdio: 'inherit' });
+    let finished = false;
+    const to = setTimeout(() => {
+      if (!finished) {
+        try { rsync.kill('SIGINT'); } catch (e) { /* ignore */ }
+        resolve(false);
+      }
+    }, timeoutMs);
+    rsync.on('close', (code) => { finished = true; clearTimeout(to); resolve(code === 0); });
+    rsync.on('error', () => { finished = true; clearTimeout(to); resolve(false); });
+  });
+}
+
+async function tryDitto(src, dest, spinner, timeoutMs = 5 * 60 * 1000) {
+  try {
+    await fs.ensureDir(path.dirname(dest));
+    return await new Promise((resolve) => {
+      const ditto = spawn('ditto', ['-v', src, dest], { stdio: 'inherit' });
+      let finished = false;
+      const to = setTimeout(() => {
+        if (!finished) {
+          try { ditto.kill('SIGINT'); } catch (e) { /* ignore */ }
+          resolve(false);
+        }
+      }, timeoutMs);
+      ditto.on('close', (code) => { finished = true; clearTimeout(to); resolve(code === 0); });
+      ditto.on('error', () => { finished = true; clearTimeout(to); resolve(false); });
+    });
+  } catch (e) {
+    return false;
+  }
+}
+
+async function nodeStreamCopy(src, dest, _spinner) {
+  // Determine total size (attempt du -sk fallback to recursive stat)
+  let total = 0;
+  try {
+    const out = execSync(`du -sk "${src}" | cut -f1`, { encoding: 'utf8' }).trim();
+    total = Number(out) * 1024;
+  } catch (e) {
+    // fallback: sum file sizes via traversal
+    await (async function walk(p) {
+      const entries = await fs.readdir(p);
+      for (const e of entries) {
+        const full = path.join(p, e);
+        const stat = await fs.stat(full);
+        if (stat.isDirectory()) await walk(full);
+        else total += stat.size;
+      }
+    })(src);
+  }
+
+  let copied = 0;
+  const start = Date.now();
+  const width = 30;
+
+  async function copyEntry(srcPath, dstPath) {
+    const stat = await fs.stat(srcPath);
+    if (stat.isDirectory()) {
+      await fs.ensureDir(dstPath);
+      const entries = await fs.readdir(srcPath);
+      for (const e of entries) {
+        await copyEntry(path.join(srcPath, e), path.join(dstPath, e));
+      }
+    } else {
+      await fs.ensureDir(path.dirname(dstPath));
+      await new Promise((resolve, reject) => {
+        const rs = fs.createReadStream(srcPath);
+        const ws = fs.createWriteStream(dstPath);
+        rs.on('data', (chunk) => {
+          copied += chunk.length;
+          if (total) {
+            const percent = Math.round((copied / total) * 100);
+            const mbCopied = (copied / (1024 * 1024)).toFixed(1);
+            const mbTotal = (total / (1024 * 1024)).toFixed(1);
+            const elapsed = Math.max(0.001, (Date.now() - start) / 1000);
+            const speed = copied / elapsed;
+            const eta = formatEta((total - copied) / (speed || 1));
+            const bar = progressBar(percent, width);
+            process.stdout.write(`\r\x1b[2K[${bar}] ${percent}% ${mbCopied}MB / ${mbTotal}MB ETA: ${eta}`);
+          } else {
+            process.stdout.write(`\r\x1b[2KCopying ${ (copied/(1024*1024)).toFixed(1) } MB`);
+          }
+        });
+        rs.on('error', reject);
+        ws.on('error', reject);
+        ws.on('close', resolve);
+        rs.pipe(ws);
+      });
+    }
+  }
+
+  await copyEntry(src, dest);
+  process.stdout.write('\n');
+  return true;
+}
+
+async function copyAppWithProgress(src, dest, opts = {}) {
+  const spinner = (opts && opts.spinner) || { start: () => {}, stop: () => {}, fail: () => {}, succeed: () => {} };
+
+  // Try rsync first
+  spinner.stop && spinner.stop();
+  console.log(`Copying ${path.basename(src)} -> ${dest} (attempting rsync...)`);
+  const okRsync = await tryRsync(src, dest, spinner);
+  if (okRsync) return true;
+
+  // Try ditto (macOS)
+  console.log('rsync failed or not available — trying ditto...');
+  const okDitto = await tryDitto(src, dest, spinner);
+  if (okDitto) return true;
+
+  // Fallback to Node streaming copy with progress
+  console.log('Falling back to node-stream copy with progress...');
+  try {
+    await nodeStreamCopy(src, dest, spinner);
+    return true;
+  } catch (e) {
+    console.error('node-stream copy failed:', e.message || e);
+    return false;
+  }
+}
+
+module.exports = { copyAppWithProgress };