vibecodingmachine-cli 2026.1.29-713 → 2026.2.20-426

package/src/utils/trui-windsurf.js

@@ -0,0 +1,350 @@
+/**
+ * Windsurf/Cascade Detection and Integration
+ *
+ * Detects when Windsurf (Cascade) is done typing and automatically
+ * sends "continue with your best approach" messages to keep work flowing.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { debugLogger, perfMonitor } = require('./trui-debug');
+
+/**
+ * Windsurf/Cascade state detector
+ */
+class WindsurfDetector {
+  constructor() {
+    this.isWindsurfActive = false;
+    this.lastActivity = null;
+    this.pollInterval = null;
+    this.continueThreshold = 30000; // 30 seconds of inactivity
+    this.projectRoot = this.findProjectRoot();
+  }
+
+  /**
+   * Find the project root directory
+   */
+  findProjectRoot() {
+    let currentDir = process.cwd();
+    while (currentDir !== path.dirname(currentDir)) {
+      const markerFile = path.join(currentDir, '.windsurf-workspace');
+      if (fs.existsSync(markerFile) ||
+          fs.existsSync(path.join(currentDir, '.git')) ||
+          fs.existsSync(path.join(currentDir, 'package.json'))) {
+        return currentDir;
+      }
+      currentDir = path.dirname(currentDir);
+    }
+    return process.cwd();
+  }
+
+  /**
+   * Check if Windsurf/Cascade is running
+   */
+  isWindsurfRunning() {
+    try {
+      // Cross-platform process check
+      const isWindows = process.platform === 'win32';
+      let result;
+
+      if (isWindows) {
+        // Windows: use tasklist
+        result = execSync('tasklist /FI "IMAGENAME eq Windsurf.exe" /NH', {
+          encoding: 'utf8',
+          timeout: 5000
+        });
+        // Check if Windsurf.exe is in the output
+        return result.toLowerCase().includes('windsurf.exe');
+      } else {
+        // Unix/macOS: use ps and grep
+        result = execSync('ps aux | grep -i windsurf | grep -v grep', {
+          encoding: 'utf8',
+          timeout: 5000
+        });
+        return result.trim().length > 0;
+      }
+    } catch (error) {
+      debugLogger.warn('Windsurf process check failed', { error: error.message });
+      return false;
+    }
+  }
+
+  /**
+   * Check if Cascade/Windsurf is actively typing/working
+   */
+  checkWindsurfActivity() {
+    try {
+      // Check for recent file modifications in key directories
+      const checkDirs = ['src', 'components', 'pages', 'lib', 'app'];
+      let recentActivity = false;
+
+      for (const dir of checkDirs) {
+        const fullPath = path.join(this.projectRoot, dir);
+        if (fs.existsSync(fullPath)) {
+          const stats = fs.statSync(fullPath);
+          const now = Date.now();
+          const modifiedTime = stats.mtime.getTime();
+
+          // If modified in last 30 seconds, consider active
+          if (now - modifiedTime < 30000) {
+            recentActivity = true;
+            break;
+          }
+        }
+      }
+
+      // Also check for specific Windsurf activity files
+      const activityFile = path.join(this.projectRoot, '.windsurf-activity');
+      if (fs.existsSync(activityFile)) {
+        const activityTime = fs.statSync(activityFile).mtime.getTime();
+        if (Date.now() - activityTime < 30000) {
+          recentActivity = true;
+        }
+      }
+
+      return recentActivity;
+    } catch (error) {
+      debugLogger.warn('Windsurf activity check failed', { error: error.message });
+      return false;
+    }
+  }
+
+  /**
+   * Detect when Windsurf completes work (stops typing)
+   */
+  detectWorkCompletion() {
+    const wasActive = this.isWindsurfActive;
+    const isActive = this.checkWindsurfActivity();
+
+    debugLogger.info('Windsurf activity check', { wasActive, isActive });
+
+    // Transition from active to inactive = work completed
+    if (wasActive && !isActive) {
+      this.lastActivity = Date.now();
+      debugLogger.info('Windsurf work completed detected');
+      return true;
+    }
+
+    this.isWindsurfActive = isActive;
+    return false;
+  }
+
+  /**
+   * Send "continue with best approach" message
+   */
+  async sendContinueMessage() {
+    try {
+      debugLogger.info('Sending continue message to Windsurf');
+
+      // Use AppleScript manager to actually send text to Windsurf
+      const { AppleScriptManager } = require('vibecodingmachine-core');
+      const applescriptManager = new AppleScriptManager();
+
+      debugLogger.info('Using AppleScript manager to send to Windsurf');
+      const result = await applescriptManager.sendText('continue with your best approach', 'windsurf');
+
+      debugLogger.info('AppleScript result', { success: result.success, error: result.error, method: result.method });
+
+      if (result.success) {
+        debugLogger.info('Continue message sent successfully to Windsurf');
+        return true;
+      } else {
+        debugLogger.error('Failed to send continue message to Windsurf', { error: result.error, details: result });
+
+        // Fallback: create file and notification for manual intervention
+        try {
+          const continueFile = path.join(this.projectRoot, '.windsurf-continue');
+          const message = {
+            type: 'continue',
+            message: 'continue with your best approach',
+            timestamp: Date.now(),
+            source: 'vcm-trui',
+            fallback_reason: result.error || 'Unknown error',
+            applescript_result: result
+          };
+
+          fs.writeFileSync(continueFile, JSON.stringify(message, null, 2));
+          debugLogger.info('Fallback: Created continue file for manual intervention');
+        } catch (fallbackError) {
+          debugLogger.error('Fallback also failed', { error: fallbackError.message });
+        }
+
+        return false;
+      }
+    } catch (error) {
+      debugLogger.error('Failed to send continue message', { error: error.message, stack: error.stack });
+      return false;
+    }
+  }
+
+  /**
+   * Start monitoring Windsurf activity
+   */
+  startMonitoring() {
+    if (this.pollInterval) {
+      this.stopMonitoring();
+    }
+
+    debugLogger.info('Starting Windsurf activity monitoring');
+    this.isWindsurfActive = this.checkWindsurfActivity();
+
+    this.pollInterval = setInterval(() => {
+      if (this.detectWorkCompletion()) {
+        this.sendContinueMessage();
+      }
+    }, 5000); // Check every 5 seconds
+
+    // Handle cleanup on exit
+    process.on('SIGINT', () => this.stopMonitoring());
+    process.on('SIGTERM', () => this.stopMonitoring());
+  }
+
+  /**
+   * Stop monitoring Windsurf activity
+   */
+  stopMonitoring() {
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = null;
+      debugLogger.info('Windsurf monitoring stopped');
+    }
+  }
+
+  /**
+   * Get current status
+   */
+  getStatus() {
+    return {
+      isRunning: this.isWindsurfRunning(),
+      isActive: this.isWindsurfActive,
+      lastActivity: this.lastActivity,
+      isMonitoring: this.pollInterval !== null
+    };
+  }
+}
+
+/**
+ * Integration manager for VCM + Windsurf workflow
+ */
+class VCMWindsurfIntegration {
+  constructor() {
+    this.detector = new WindsurfDetector();
+    this.autoContinueEnabled = true;
+    this.continueDelay = 5000; // 5 seconds after completion
+  }
+
+  /**
+   * Initialize the integration
+   */
+  async initialize() {
+    debugLogger.info('Initializing VCM-Windsurf integration');
+
+    // Check if Windsurf is running
+    if (!this.detector.isWindsurfRunning()) {
+      debugLogger.info('Windsurf not detected, integration disabled');
+      return false;
+    }
+
+    // Start monitoring
+    this.detector.startMonitoring();
+
+    // Set up automatic continuation
+    if (this.autoContinueEnabled) {
+      this.setupAutoContinue();
+    }
+
+    debugLogger.info('VCM-Windsurf integration initialized');
+    return true;
+  }
+
+  /**
+   * Set up automatic continuation when work is detected as complete
+   */
+  setupAutoContinue() {
+    // This works in conjunction with the detector's polling
+    debugLogger.info('Auto-continue enabled', { delay: this.continueDelay });
+  }
+
+  /**
+   * Manually trigger continue message
+   */
+  async manualContinue() {
+    debugLogger.info('Manual continue triggered');
+    return await this.detector.sendContinueMessage();
+  }
+
+  /**
+   * Disable auto-continue
+   */
+  disableAutoContinue() {
+    this.autoContinueEnabled = false;
+    debugLogger.info('Auto-continue disabled');
+  }
+
+  /**
+   * Enable auto-continue
+   */
+  enableAutoContinue() {
+    this.autoContinueEnabled = true;
+    debugLogger.info('Auto-continue enabled');
+  }
+
+  /**
+   * Get integration status
+   */
+  getStatus() {
+    return {
+      ...this.detector.getStatus(),
+      autoContinueEnabled: this.autoContinueEnabled,
+      continueDelay: this.continueDelay
+    };
+  }
+
+  /**
+   * Cleanup resources
+   */
+  cleanup() {
+    this.detector.stopMonitoring();
+    debugLogger.info('VCM-Windsurf integration cleaned up');
+  }
+}
+
+// Global integration instance
+let windsurfIntegration = null;
+
+/**
+ * Initialize Windsurf integration (call from main menu)
+ */
+function initializeWindsurfIntegration() {
+  if (!windsurfIntegration) {
+    windsurfIntegration = new VCMWindsurfIntegration();
+    return windsurfIntegration.initialize();
+  }
+  return true;
+}
+
+/**
+ * Get Windsurf integration status
+ */
+function getWindsurfStatus() {
+  return windsurfIntegration ? windsurfIntegration.getStatus() : null;
+}
+
+/**
+ * Send manual continue message
+ */
+async function sendContinueToWindsurf() {
+  if (windsurfIntegration) {
+    return await windsurfIntegration.manualContinue();
+  }
+  return false;
+}
+
+module.exports = {
+  WindsurfDetector,
+  VCMWindsurfIntegration,
+  initializeWindsurfIntegration,
+  getWindsurfStatus,
+  sendContinueToWindsurf
+};

package/src/utils/welcome-screen-extracted.js

@@ -0,0 +1,135 @@
+const chalk = require('chalk');
+const boxen = require('boxen');
+const { getHostname, requirementsExists, isGitRepo, getCurrentBranch, hasUncommittedChanges, t } = require('vibecodingmachine-core');
+const { checkAutoModeStatus } = require('./auto-mode');
+const { formatIDEName, getAgentDisplayName, formatPath } = require('./display-formatters-extracted');
+const { countRequirements, getSyncStatus, getCurrentProgress } = require('./status-helpers-extracted');
+const pkg = require('../../package.json');
+
+async function showWelcomeScreen() {
+
+
+  const repoPath = process.cwd(); // Always use current working directory
+  const autoStatus = await checkAutoModeStatus();
+  const hostname = getHostname();
+
+  // Get current IDE from config
+  const { getAutoConfig } = require('./config');
+  const autoConfig = await getAutoConfig();
+
+  // Check for requirements file
+  const hasRequirements = await requirementsExists();
+
+  // Count requirements if file exists
+  const counts = hasRequirements ? await countRequirements() : null;
+
+  // Clear the screen using console.clear() for better cross-platform compatibility
+  // This ensures proper screen refresh and prevents text overlap
+  console.clear();
+
+  // Get version from package.json
+  const version = `v${pkg.version}`;
+
+  // Display welcome banner with version
+  console.log('\n' + boxen(
+    chalk.bold.cyan('Vibe Coding Machine!') + '\n' +
+    chalk.gray(version) + '\n' +
+    chalk.gray(t('banner.tagline')),
+    {
+      padding: 1,
+      margin: 0,
+      borderStyle: 'round',
+      borderColor: 'cyan'
+    }
+  ));
+
+  // Display feedback hint at the top of every screen
+  console.log(chalk.gray('💡 Press F for feedback - Share your thoughts anytime'));
+
+  // Display repository and system info
+  console.log();
+  console.log(chalk.gray(t('system.repo').padEnd(25)), formatPath(repoPath));
+
+  // Display git branch if in a git repo
+  try {
+    const { isGitRepo, getCurrentBranch, hasUncommittedChanges } = require('vibecodingmachine-core');
+    if (isGitRepo(repoPath)) {
+      const branch = getCurrentBranch(repoPath);
+      if (branch) {
+        const isDirty = hasUncommittedChanges(repoPath);
+        const branchDisplay = isDirty ? `${chalk.cyan(branch)} ${chalk.yellow(t('system.git.status.dirty'))}` : chalk.cyan(branch);
+        console.log(chalk.gray(t('system.git.branch').padEnd(25)), branchDisplay);
+      }
+    }
+  } catch (error) {
+    // Ignore git display errors
+  }
+
+  console.log(chalk.gray(t('system.computer.name').padEnd(25)), chalk.cyan(hostname));
+
+  // Display auto mode progress if running
+  if (autoStatus.running) {
+    console.log(chalk.gray('Chats:                   '), chalk.cyan(autoStatus.chatCount || 0));
+
+    // Get current status and requirement from REQUIREMENTS file
+    const progress = await getCurrentProgress();
+    if (progress) {
+      console.log();
+      // Display progress in a purple/magenta box similar to UI
+      const stageIcons = {
+        'PREPARE': '🔍',
+        'ACT': '⚡',
+        'CLEAN UP': '🧹',
+        'VERIFY': '✅',
+        'DONE': '🎉'
+      };
+      const icon = stageIcons[progress.status] || '⏳';
+      const statusColor = progress.status === 'DONE' ? chalk.green : chalk.magenta;
+
+      // Truncate requirement text first, THEN apply color to fix box alignment
+      const requirementText = progress.requirement ? progress.requirement.substring(0, 60) + (progress.requirement.length > 60 ? '...' : '') : 'No requirement';
+
+      console.log(boxen(
+        statusColor.bold(`${icon} ${progress.status}`) + '\n' +
+        chalk.gray(requirementText),
+        {
+          padding: { left: 1, right: 1, top: 0, bottom: 0 },
+          margin: 0,
+          borderStyle: 'round',
+          borderColor: 'magenta',
+          width: 70
+        }
+      ));
+    }
+
+    // Display recent audit log entries
+    const { readAuditLog, getDateStr } = require('vibecodingmachine-core');
+    const todayStr = getDateStr();
+    const entries = readAuditLog(todayStr);
+    if (entries && entries.length > 0) {
+      console.log();
+      console.log(chalk.gray.bold('Recent Activity:'));
+      // Show last 5 entries
+      const recentEntries = entries.slice(-5);
+      recentEntries.forEach(entry => {
+        const time = new Date(entry.timestamp).toLocaleTimeString('en-US', {
+          hour: 'numeric',
+          minute: '2-digit',
+          second: '2-digit',
+          hour12: true
+        });
+        const icon = entry.type === 'auto-mode-start' ? '▶️' :
+          entry.type === 'auto-mode-stop' ? '⏹️' :
+            entry.type === 'ide-message' ? '💬' : '•';
+        console.log(chalk.gray(`  ${time} ${icon}`), entry.message || '');
+      });
+    }
+  }
+
+  console.log();
+}
+
+module.exports = {
+  showWelcomeScreen
+};
+

package/src/utils/welcome-screen.js

@@ -0,0 +1,134 @@
+const chalk = require('chalk');
+const boxen = require('boxen');
+const { t, getHostname, requirementsExists, isGitRepo, getCurrentBranch, hasUncommittedChanges, readAuditLog, getDateStr } = require('vibecodingmachine-core');
+const { checkAutoModeStatus } = require('./auto-mode');
+const { getAutoConfig } = require('./config');
+const { formatPath } = require('./display-formatters');
+const { countRequirements, getCurrentProgress } = require('./status-helpers');
+
+const pkg = require('../../package.json');
+
+/**
+ * Display the welcome screen with system information and current status
+ */
+async function showWelcomeScreen() {
+  const repoPath = process.cwd(); // Always use current working directory
+  const autoStatus = await checkAutoModeStatus();
+  const hostname = getHostname();
+
+  // Get current IDE from config
+  const autoConfig = await getAutoConfig();
+
+  // Check for requirements file
+  const hasRequirements = await requirementsExists();
+
+  // Count requirements if file exists
+  const counts = hasRequirements ? await countRequirements() : null;
+
+  // Clear the screen using console.clear() for better cross-platform compatibility
+  // This ensures proper screen refresh and prevents text overlap
+  console.clear();
+
+  // Get version from package.json
+  const version = `v${pkg.version}`;
+
+  // Display welcome banner with version
+  console.log('\n' + boxen(
+    chalk.bold.cyan('Vibe Coding Machine!') + '\n' +
+    chalk.gray(version) + '\n' +
+    chalk.gray(t('banner.tagline')),
+    {
+      padding: 1,
+      margin: 0,
+      borderStyle: 'round',
+      borderColor: 'cyan'
+    }
+  ));
+
+  // Display feedback hint at the top of every screen
+  console.log(chalk.gray('💡 Press F for feedback - Share your thoughts anytime'));
+
+  // Display repository and system info
+  console.log();
+  console.log(chalk.gray(t('system.repo').padEnd(25)), formatPath(repoPath));
+
+  // Display git branch if in a git repo
+  try {
+    if (isGitRepo(repoPath)) {
+      const branch = getCurrentBranch(repoPath);
+      if (branch) {
+        const isDirty = hasUncommittedChanges(repoPath);
+        const branchDisplay = isDirty ? `${chalk.cyan(branch)} ${chalk.yellow(t('system.git.status.dirty'))}` : chalk.cyan(branch);
+        console.log(chalk.gray(t('system.git.branch').padEnd(25)), branchDisplay);
+      }
+    }
+  } catch (error) {
+    // Ignore git display errors
+  }
+
+  console.log(chalk.gray(t('system.computer.name').padEnd(25)), chalk.cyan(hostname));
+
+  // Display auto mode progress if running
+  if (autoStatus.running) {
+    console.log(chalk.gray('Chats:                   '), chalk.cyan(autoStatus.chatCount || 0));
+
+    // Get current status and requirement from REQUIREMENTS file
+    const progress = await getCurrentProgress();
+    if (progress) {
+      console.log();
+      // Display progress in a purple/magenta box similar to UI
+      const stageIcons = {
+        'PREPARE': '🔍',
+        'ACT': '⚡',
+        'CLEAN UP': '🧹',
+        'VERIFY': '✅',
+        'DONE': '🎉'
+      };
+      const icon = stageIcons[progress.status] || '⏳';
+      const statusColor = progress.status === 'DONE' ? chalk.green : chalk.magenta;
+
+      // Truncate requirement text first, THEN apply color to fix box alignment
+      const requirementText = progress.requirement ? progress.requirement.substring(0, 60) + (progress.requirement.length > 60 ? '...' : '') : 'No requirement';
+
+      console.log(boxen(
+        statusColor.bold(`${icon} ${progress.status}`) + '\n' +
+        chalk.gray(requirementText),
+        {
+          padding: { left: 1, right: 1, top: 0, bottom: 0 },
+          margin: 0,
+          borderStyle: 'round',
+          borderColor: 'magenta',
+          width: 70
+        }
+      ));
+    }
+
+    // Display recent audit log entries
+    const todayStr = getDateStr();
+    const entries = readAuditLog(todayStr);
+    if (entries && entries.length > 0) {
+      console.log();
+      console.log(chalk.gray.bold('Recent Activity:'));
+      // Show last 5 entries
+      const recentEntries = entries.slice(-5);
+      recentEntries.forEach(entry => {
+        const time = new Date(entry.timestamp).toLocaleTimeString('en-US', {
+          hour: 'numeric',
+          minute: '2-digit',
+          second: '2-digit',
+          hour12: true
+        });
+        const icon = entry.type === 'auto-mode-start' ? '▶️' :
+          entry.type === 'auto-mode-stop' ? '⏹️' :
+            entry.type === 'ide-message' ? '💬' : '•';
+        console.log(chalk.gray(`  ${time} ${icon}`), entry.message || '');
+      });
+    }
+  }
+
+  console.log();
+}
+
+module.exports = {
+  showWelcomeScreen
+};