vibecodingmachine-cli 2026.3.14-1528 → 2026.6.17-1835

package/src/utils/trui-windsurf.js

@@ -1,7 +1,7 @@
 /**
- * Windsurf/Cascade Detection and Integration
+ * Devin Detection and Integration
  *
- * Detects when Windsurf (Cascade) is done typing and automatically
+ * Detects when Devin is done working and automatically
  * sends "continue with your best approach" messages to keep work flowing.
  */
 
@@ -11,7 +11,7 @@ const { execSync } = require('child_process');
 const { debugLogger, perfMonitor } = require('./trui-debug');
 
 /**
- * Windsurf/Cascade state detector
+ * Devin state detector
  */
 class WindsurfDetector {
   constructor() {
@@ -28,7 +28,7 @@ class WindsurfDetector {
   findProjectRoot() {
     let currentDir = process.cwd();
     while (currentDir !== path.dirname(currentDir)) {
-      const markerFile = path.join(currentDir, '.windsurf-workspace');
+      const markerFile = path.join(currentDir, '.devin-workspace');
       if (fs.existsSync(markerFile) ||
           fs.existsSync(path.join(currentDir, '.git')) ||
           fs.existsSync(path.join(currentDir, 'package.json'))) {
@@ -40,7 +40,7 @@ class WindsurfDetector {
   }
 
   /**
-   * Check if Windsurf/Cascade is running
+   * Check if Devin is running
    */
   isWindsurfRunning() {
     try {
@@ -50,28 +50,28 @@ class WindsurfDetector {
 
       if (isWindows) {
         // Windows: use tasklist
-        result = execSync('tasklist /FI "IMAGENAME eq Windsurf.exe" /NH', {
+        result = execSync('tasklist /FI "IMAGENAME eq Devin.exe" /NH', {
           encoding: 'utf8',
           timeout: 5000
         });
-        // Check if Windsurf.exe is in the output
-        return result.toLowerCase().includes('windsurf.exe');
+        // Check if Devin.exe is in the output
+        return result.toLowerCase().includes('devin.exe');
       } else {
         // Unix/macOS: use ps and grep
-        result = execSync('ps aux | grep -i windsurf | grep -v grep', {
+        result = execSync('ps aux | grep -i devin | grep -v grep', {
           encoding: 'utf8',
           timeout: 5000
         });
         return result.trim().length > 0;
       }
     } catch (error) {
-      debugLogger.warn('Windsurf process check failed', { error: error.message });
+      debugLogger.warn('Devin process check failed', { error: error.message });
       return false;
     }
   }
 
   /**
-   * Check if Cascade/Windsurf is actively typing/working
+   * Check if Devin is actively typing/working
    */
   checkWindsurfActivity() {
     try {
@@ -94,8 +94,8 @@ class WindsurfDetector {
         }
       }
 
-      // Also check for specific Windsurf activity files
-      const activityFile = path.join(this.projectRoot, '.windsurf-activity');
+      // Also check for specific Devin activity files
+      const activityFile = path.join(this.projectRoot, '.devin-activity');
       if (fs.existsSync(activityFile)) {
         const activityTime = fs.statSync(activityFile).mtime.getTime();
         if (Date.now() - activityTime < 30000) {
@@ -105,24 +105,24 @@ class WindsurfDetector {
 
       return recentActivity;
     } catch (error) {
-      debugLogger.warn('Windsurf activity check failed', { error: error.message });
+      debugLogger.warn('Devin activity check failed', { error: error.message });
       return false;
     }
   }
 
   /**
-   * Detect when Windsurf completes work (stops typing)
+   * Detect when Devin completes work (stops typing)
    */
   detectWorkCompletion() {
     const wasActive = this.isWindsurfActive;
     const isActive = this.checkWindsurfActivity();
 
-    debugLogger.info('Windsurf activity check', { wasActive, isActive });
+    debugLogger.info('Devin activity check', { wasActive, isActive });
 
     // Transition from active to inactive = work completed
     if (wasActive && !isActive) {
       this.lastActivity = Date.now();
-      debugLogger.info('Windsurf work completed detected');
+      debugLogger.info('Devin work completed detected');
       return true;
     }
 
@@ -135,43 +135,43 @@ class WindsurfDetector {
    */
   async sendContinueMessage() {
     try {
-      debugLogger.info('Sending continue message to Windsurf');
-      
-      // Use AppleScript manager to actually send text to Windsurf
+      debugLogger.info('Sending continue message to Devin');
+
+      // Use AppleScript manager to actually send text to Devin
       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('Using AppleScript manager to send to Devin');
+      const result = await applescriptManager.sendText('continue with your best approach', 'devin');
+
       debugLogger.info('AppleScript result', { success: result.success, error: result.error, method: result.method });
-      
+
       if (result.success) {
-        debugLogger.info('Continue message sent successfully to Windsurf');
-        
+        debugLogger.info('Continue message sent successfully to Devin');
+
         // Set up timeout to prevent indefinite waiting
         const maxWaitTime = 10 * 60 * 1000; // 10 minutes maximum wait
         const checkInterval = 5000; // Check every 5 seconds
         let totalWaited = 0;
-        
+
         const checkForCompletion = async () => {
           try {
             const completed = await this.checkForDoneStatusAndRespond();
             if (completed) {
-              debugLogger.info('✅ Windsurf task completion confirmed');
+              debugLogger.info('✅ Devin task completion confirmed');
               return true;
             }
-            
+
             totalWaited += checkInterval;
             if (totalWaited >= maxWaitTime) {
               debugLogger.warn(`⚠️ Maximum wait time (${maxWaitTime/1000/60} minutes) reached, assuming completion`);
-              
+
               // Force completion after timeout
-              const timeoutMessage = `⚠️ VCM timeout after ${maxWaitTime/1000/60} minutes. Assuming Windsurf task completed. STATUS:DONE`;
-              await applescriptManager.sendText(timeoutMessage, 'windsurf');
+              const timeoutMessage = `⚠️ VCM timeout after ${maxWaitTime/1000/60} minutes. Assuming Devin task completed. STATUS:DONE`;
+              await applescriptManager.sendText(timeoutMessage, 'devin');
               return true;
             }
-            
+
             // Continue checking
             setTimeout(checkForCompletion, checkInterval);
             return false;
@@ -180,7 +180,7 @@ class WindsurfDetector {
             return false;
           }
         };
-        
+
         // Start checking after initial delay
         setTimeout(async () => {
           try {
@@ -189,14 +189,14 @@ class WindsurfDetector {
             debugLogger.error('Failed to start completion checking', { error: error.message });
           }
         }, 5000); // Wait 5 seconds before first check
-        
+
         return true;
       } else {
-        debugLogger.error('Failed to send continue message to Windsurf', { error: result.error, details: result });
+        debugLogger.error('Failed to send continue message to Devin', { error: result.error, details: result });
 
         // Fallback: create file and notification for manual intervention
         try {
-          const continueFile = path.join(this.projectRoot, '.windsurf-continue');
+          const continueFile = path.join(this.projectRoot, '.devin-continue');
           const message = {
             type: 'continue',
             message: 'continue with your best approach',
@@ -221,14 +221,14 @@ class WindsurfDetector {
   }
 
   /**
-   * Start monitoring Windsurf activity
+   * Start monitoring Devin activity
    */
   startMonitoring() {
     if (this.pollInterval) {
       this.stopMonitoring();
     }
 
-    debugLogger.info('Starting Windsurf activity monitoring');
+    debugLogger.info('Starting Devin activity monitoring');
     this.isWindsurfActive = this.checkWindsurfActivity();
 
     this.pollInterval = setInterval(() => {
@@ -243,13 +243,13 @@ class WindsurfDetector {
   }
 
   /**
-   * Stop monitoring Windsurf activity
+   * Stop monitoring Devin activity
    */
   stopMonitoring() {
     if (this.pollInterval) {
       clearInterval(this.pollInterval);
       this.pollInterval = null;
-      debugLogger.info('Windsurf monitoring stopped');
+      debugLogger.info('Devin monitoring stopped');
     }
   }
 
@@ -267,7 +267,7 @@ class WindsurfDetector {
 }
 
 /**
- * Integration manager for VCM + Windsurf workflow
+ * Integration manager for VCM + Devin workflow
  */
 class VCMWindsurfIntegration {
   constructor() {
@@ -280,11 +280,11 @@ class VCMWindsurfIntegration {
    * Initialize the integration
    */
   async initialize() {
-    debugLogger.info('Initializing VCM-Windsurf integration');
+    debugLogger.info('Initializing VCM-Devin integration');
 
-    // Check if Windsurf is running
+    // Check if Devin is running
     if (!this.detector.isWindsurfRunning()) {
-      debugLogger.info('Windsurf not detected, integration disabled');
+      debugLogger.info('Devin not detected, integration disabled');
       return false;
     }
 
@@ -296,7 +296,7 @@ class VCMWindsurfIntegration {
       this.setupAutoContinue();
     }
 
-    debugLogger.info('VCM-Windsurf integration initialized');
+    debugLogger.info('VCM-Devin integration initialized');
     return true;
   }
 
@@ -337,21 +337,21 @@ class VCMWindsurfIntegration {
    */
   async forceCompletionDetection() {
     try {
-      debugLogger.info('🔧 Manually forcing completion detection for stalled VCM-Windsurf communication');
-      
+      debugLogger.info('🔧 Manually forcing completion detection for stalled VCM-Devin communication');
+
       const { AppleScriptManager } = require('vibecodingmachine-core');
       const applescriptManager = new AppleScriptManager();
-      
-      // Try to read current Windsurf chat state
+
+      // Try to read current Devin chat state
       let chatResponse = '';
       try {
-        chatResponse = await applescriptManager.readChatResponse('windsurf');
-        debugLogger.info('Current Windsurf chat state:', chatResponse ? chatResponse.substring(0, 300) + '...' : 'No response readable');
+        chatResponse = await applescriptManager.readChatResponse('devin');
+        debugLogger.info('Current Devin chat state:', chatResponse ? chatResponse.substring(0, 300) + '...' : 'No response readable');
       } catch (error) {
-        debugLogger.warn('Could not read Windsurf chat response:', error.message);
+        debugLogger.warn('Could not read Devin chat response:', error.message);
       }
-      
-      // Check if Windsurf shows completion indicators
+
+      // Check if Devin shows completion indicators
       const hasCompletionIndicators = chatResponse && (
         chatResponse.includes('STATUS:WAITING') ||
         chatResponse.includes('PLEASE RESPOND') ||
@@ -361,39 +361,39 @@ class VCMWindsurfIntegration {
         chatResponse.includes('complete') ||
         chatResponse.includes('finished')
       );
-      
+
       if (hasCompletionIndicators) {
-        debugLogger.info('✅ Completion indicators detected in Windsurf chat');
-        
-        const confirmMessage = `✅ VCM-to-Windsurf communication test PASSED! Message successfully sent to Windsurf chat panel. Completion detected via manual recovery. Cascade panel remained open and functional. STATUS:DONE`;
-        
-        const result = await applescriptManager.sendText(confirmMessage, 'windsurf');
-        
+        debugLogger.info('✅ Completion indicators detected in Devin chat');
+
+        const confirmMessage = `✅ VCM-to-Devin communication test PASSED! Message successfully sent to Devin chat panel. Completion detected via manual recovery. STATUS:DONE`;
+
+        const result = await applescriptManager.sendText(confirmMessage, 'devin');
+
         if (result.success) {
           debugLogger.info('✅ Manual recovery confirmation sent successfully');
-          
+
           // Update requirements file
           const fs = require('fs');
           const path = require('path');
           const requirementsPath = path.join(this.projectRoot, 'REQUIREMENTS.md');
-          
+
           if (fs.existsSync(requirementsPath)) {
             let content = fs.readFileSync(requirementsPath, 'utf8');
             content = content.replace(
-              /\[ \] \*\*VCM-to-Windsurf Communication Test\*\*:.*?When Windsurf agent detects this status change, it should send a confirmation message back and then the requirement should be automatically removed via normal completion process\./g,
-              `[x] **VCM-to-Windsurf Communication Test**: Add test requirement that updates to "DONE" status when VCM successfully sends text to Windsurf chat panel. When Windsurf agent detects this status change, it should send a confirmation message back and then the requirement should be automatically removed via normal completion process.`
+              /\[ \] \*\*VCM-to-Devin Communication Test\*\*:.*?When Devin agent detects this status change, it should send a confirmation message back and then the requirement should be automatically removed via normal completion process\./g,
+              `[x] **VCM-to-Devin Communication Test**: Add test requirement that updates to "DONE" status when VCM successfully sends text to Devin chat panel. When Devin agent detects this status change, it should send a confirmation message back and then the requirement should be automatically removed via normal completion process.`
             );
             fs.writeFileSync(requirementsPath, content, 'utf8');
             debugLogger.info('✅ Updated REQUIREMENTS.md to mark test as DONE');
           }
-          
+
           return { success: true, message: 'Manual recovery completed successfully' };
         } else {
           debugLogger.error('❌ Failed to send manual recovery confirmation');
           return { success: false, error: result.error };
         }
       } else {
-        debugLogger.info('No completion indicators detected, Windsurf may still be working');
+        debugLogger.info('No completion indicators detected, Devin may still be working');
         return { success: false, message: 'No completion indicators detected' };
       }
     } catch (error) {
@@ -403,7 +403,7 @@ class VCMWindsurfIntegration {
   }
 
   /**
-   * Get current Windsurf integration status
+   * Get current Devin integration status
    */
   getStatus() {
     return {
@@ -414,81 +414,81 @@ class VCMWindsurfIntegration {
   }
 
   /**
-   * Check for DONE status in REQUIREMENTS.md and respond to Windsurf
+   * Check for DONE status in REQUIREMENTS.md and respond to Devin
    */
   async checkForDoneStatusAndRespond() {
     try {
       const fs = require('fs');
       const path = require('path');
       const requirementsPath = path.join(this.projectRoot, 'REQUIREMENTS.md');
-      
-      // Check both requirements file AND try to read Windsurf's last response
+
+      // Check both requirements file AND try to read Devin's last response
       let doneDetected = false;
       let detectionSource = '';
-      
+
       // Method 1: Check requirements file for DONE status
       if (fs.existsSync(requirementsPath)) {
         const content = fs.readFileSync(requirementsPath, 'utf8');
-        const donePattern = /\[x\].*VCM-to-Windsurf Communication Test/;
+        const donePattern = /\[x\].*VCM-to-Devin Communication Test/;
         const doneMatch = content.match(donePattern);
-        
+
         if (doneMatch) {
           doneDetected = true;
           detectionSource = 'requirements file';
-          debugLogger.info('✅ Detected DONE status for VCM-to-Windsurf Communication Test in requirements file');
+          debugLogger.info('✅ Detected DONE status for VCM-to-Devin Communication Test in requirements file');
         }
       }
-      
-      // Method 2: Try to read Windsurf's chat response for STATUS:WAITING
+
+      // Method 2: Try to read Devin's chat response for STATUS:WAITING
       if (!doneDetected) {
         try {
           const { AppleScriptManager } = require('vibecodingmachine-core');
           const applescriptManager = new AppleScriptManager();
-          
-          // Try to read the last chat response from Windsurf
-          const chatResponse = await applescriptManager.readChatResponse('windsurf');
-          
-          if (chatResponse && 
+
+          // Try to read the last chat response from Devin
+          const chatResponse = await applescriptManager.readChatResponse('devin');
+
+          if (chatResponse &&
               (chatResponse.includes('STATUS:WAITING') || chatResponse.includes('PLEASE RESPOND')) &&
               (chatResponse.includes('done') || chatResponse.includes('complete') || chatResponse.includes('finished'))) {
             doneDetected = true;
             detectionSource = 'chat response';
-            debugLogger.info('✅ Detected completion status in Windsurf chat response');
+            debugLogger.info('✅ Detected completion status in Devin chat response');
             debugLogger.info('Chat response sample:', chatResponse.substring(0, 200) + '...');
           }
         } catch (error) {
-          debugLogger.info('Could not read Windsurf chat response:', error.message);
+          debugLogger.info('Could not read Devin chat response:', error.message);
         }
       }
-      
+
       // Method 3: Check for activity completion (no recent activity + time elapsed)
       if (!doneDetected && this.detector.lastActivity) {
         const timeSinceActivity = Date.now() - this.detector.lastActivity;
         const fiveMinutes = 5 * 60 * 1000;
-        
+
         if (timeSinceActivity > fiveMinutes) {
           doneDetected = true;
           detectionSource = 'activity timeout';
           debugLogger.info('✅ Detected completion via activity timeout (5 minutes since last activity)');
         }
       }
-      
+
       if (doneDetected) {
         debugLogger.info(`✅ Completion detected via ${detectionSource}`);
-        
-        // Send confirmation message back to Windsurf
+
+        // Send confirmation message back to Devin
         const { AppleScriptManager } = require('vibecodingmachine-core');
         const applescriptManager = new AppleScriptManager();
-        
-        const confirmMessage = `✅ VCM-to-Windsurf communication test PASSED! Message successfully sent to Windsurf chat panel. Completion detected via ${detectionSource}. Cascade panel remained open and functional. STATUS:DONE`;
-        
-        debugLogger.info('Sending confirmation message to Windsurf', { message: confirmMessage });
-        
-        const result = await applescriptManager.sendText(confirmMessage, 'windsurf');
-        
+
+        const confirmMessage = `✅ VCM-to-Devin communication test PASSED! Message successfully sent to Devin chat panel. Completion detected via ${detectionSource}. STATUS:DONE`;
+
+        debugLogger.info('Sending confirmation message to Devin', { message: confirmMessage });
+
+        const result = await applescriptManager.sendText(confirmMessage, 'devin');
+
         if (result.success) {
-          debugLogger.info('✅ Confirmation message sent successfully to Windsurf');
-          
+          debugLogger.info('✅ Confirmation message sent successfully to Devin');
+
           // Update the requirements file to mark the test as DONE
           try {
             if (fs.existsSync(requirementsPath)) {
@@ -503,10 +503,10 @@ class VCMWindsurfIntegration {
           } catch (updateError) {
             debugLogger.warn('Could not update requirements file:', updateError.message);
           }
-          
+
           return true;
         } else {
-          debugLogger.error('❌ Failed to send confirmation message to Windsurf', { error: result.error });
+          debugLogger.error('❌ Failed to send confirmation message to Devin', { error: result.error });
           return false;
         }
       } else {
@@ -558,7 +558,7 @@ async function forceWindsurfCompletionDetection() {
   if (windsurfIntegration) {
     return await windsurfIntegration.forceCompletionDetection();
   }
-  return { success: false, error: 'Windsurf integration not initialized' };
+  return { success: false, error: 'Devin integration not initialized' };
 }
 
 module.exports = {

package/src/utils/user-tracking.js

@@ -1,6 +1,6 @@
 /**
  * User Tracking Integration for CLI
- * 
+ *
  * This module integrates the CLI with the enhanced user tracking system,
  * automatically logging user activities and updating usage statistics.
  */
@@ -12,7 +12,7 @@ class CLIUserTracking {
     this.sessionStartTime = Date.now()
     this.activityBuffer = []
     this.flushInterval = null
-    
+
     // Start periodic flush of activity data
     this.startActivityFlush()
   }
@@ -142,7 +142,7 @@ class CLIUserTracking {
   async endSession() {
     try {
       const sessionDuration = Date.now() - this.sessionStartTime
-      
+
       await auth.trackCLIActivity('session_ended', {
         duration: Math.round(sessionDuration / 1000), // Convert to seconds
         metadata: {
@@ -184,7 +184,7 @@ class CLIUserTracking {
       if (token && token.id_token) {
         await auth._updateUserActivity()
       }
-      
+
       // Clear buffer after successful flush
       this.activityBuffer = []
     } catch (error) {
@@ -201,12 +201,12 @@ class CLIUserTracking {
       if (!token || !token.id_token) return null
 
       const payload = JSON.parse(Buffer.from(token.id_token.split('.')[1], 'base64').toString())
-      
+
       const UserDatabase = require('vibecodingmachine-core/src/database/user-schema')
       const userDb = new UserDatabase()
-      
+
       const userId = userDb.generateUserId(payload.email)
-      
+
       const project = await userDb.registerProject(userId, {
         name: projectInfo.name || 'Unnamed Project',
         description: projectInfo.description || '',
@@ -241,16 +241,16 @@ class CLIUserTracking {
       if (!token || !token.id_token) return { compliant: false }
 
       const payload = JSON.parse(Buffer.from(token.id_token.split('.')[1], 'base64').toString())
-      
+
       const ComplianceManager = require('vibecodingmachine-core/src/compliance/compliance-manager')
       const compliance = new ComplianceManager()
-      
+
       const UserDatabase = require('vibecodingmachine-core/src/database/user-schema')
       const userDb = new UserDatabase()
       const userId = userDb.generateUserId(payload.email)
-      
+
       const status = await compliance.checkComplianceStatus(userId)
-      
+
       return {
         compliant: !status.needsAcknowledgment,
         termsAccepted: status.termsAccepted,
@@ -272,16 +272,16 @@ class CLIUserTracking {
       if (!token || !token.id_token) return false
 
       const payload = JSON.parse(Buffer.from(token.id_token.split('.')[1], 'base64').toString())
-      
+
       const ComplianceManager = require('vibecodingmachine-core/src/compliance/compliance-manager')
       const compliance = new ComplianceManager()
-      
+
       const UserDatabase = require('vibecodingmachine-core/src/database/user-schema')
       const userDb = new UserDatabase()
       const userId = userDb.generateUserId(payload.email)
-      
+
       await compliance.recordAcknowledgment(userId, acknowledgments)
-      
+
       // Track compliance activity
       await this.trackCommand('compliance_acknowledged', [], {
         termsAccepted: acknowledgments.terms,