vibecodingmachine-cli 2025.12.6-1702 → 2025.12.22-2230

package/src/utils/kiro-installer.js

@@ -1,7 +1,5 @@
 const fs = require('fs-extra');
-const path = require('path');
 const os = require('os');
-const { spawn } = require('child_process');
 const ora = require('ora');
 const chalk = require('chalk');
 
@@ -46,36 +44,47 @@ async function installKiro() {
     }
 
     try {
-        const fetch = require('node-fetch');
         const fs = require('fs-extra');
         const path = require('path');
         const os = require('os');
         const { execSync } = require('child_process');
 
         console.log(chalk.cyan(`\n⬇️  Downloading AWS Kiro for macOS (${arch})...`));
-        const downloadSpinner = ora('Downloading... (this may take a moment)').start();
-
-        const response = await fetch(downloadUrl);
-        if (!response.ok) {
-            downloadSpinner.fail(`Failed to download: ${response.statusText}`);
-            console.log(chalk.red(`\nURL: ${downloadUrl}`));
-            throw new Error(`Download failed with status ${response.status}`);
-        }
-
+        const cacheDir = path.join(os.homedir(), '.vibecodingmachine', 'cache');
+        await fs.ensureDir(cacheDir);
+        const cachedPath = path.join(cacheDir, 'Kiro.dmg');
         const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'kiro-install-'));
         const dmgPath = path.join(tempDir, 'Kiro.dmg');
-        const fileStream = fs.createWriteStream(dmgPath);
+        const { downloadWithProgress } = require('./download-with-progress');
 
-        await new Promise((resolve, reject) => {
-            response.body.pipe(fileStream);
-            response.body.on('error', (err) => {
-                downloadSpinner.fail('Download error');
-                reject(err);
-            });
-            fileStream.on('finish', resolve);
-        });
+        // Try to reuse cached DMG to avoid re-downloading
+        let usedCache = false;
+        try {
+            if (await fs.pathExists(cachedPath)) {
+                try {
+                    const fetch = require('node-fetch');
+                    const head = await fetch(downloadUrl, { method: 'HEAD' });
+                    const total = Number(head.headers.get('content-length')) || 0;
+                    const stat = await fs.stat(cachedPath);
+                    if (total && stat.size === total) {
+                        await fs.copy(cachedPath, dmgPath);
+                        usedCache = true;
+                        console.log(chalk.gray('Using cached Kiro DMG'));
+                    }
+                } catch (e) {
+                    await fs.copy(cachedPath, dmgPath);
+                    usedCache = true;
+                    console.log(chalk.gray('Using cached Kiro DMG (no HEAD)'));
+                }
+            }
+        } catch (e) {
+            usedCache = false;
+        }
 
-        downloadSpinner.succeed('Download complete.');
+        if (!usedCache) {
+            await downloadWithProgress(downloadUrl, dmgPath, { label: 'Downloading AWS Kiro...' });
+            try { await fs.copy(dmgPath, cachedPath); } catch (e) { /* ignore */ }
+        }
 
         const installSpinner = ora('Installing AWS Kiro...').start();
 
@@ -104,8 +113,31 @@ async function installKiro() {
                 installSpinner.text = 'Replacing existing installation...';
                 await fs.remove(destinationPath);
             }
-
-            await fs.copy(fullSourcePath, destinationPath);
+            // Use robust copy with progress (rsync -> ditto -> node stream)
+            try {
+                const { copyAppWithProgress } = require('./copy-with-progress');
+                installSpinner.stop();
+                const ok = await copyAppWithProgress(fullSourcePath, destinationPath, { spinner: installSpinner });
+                if (!ok) {
+                    console.log('Falling back to cp -R for installation...');
+                    installSpinner.start();
+                    try {
+                        execSync(`cp -R "${fullSourcePath}" "/Applications/"`, { stdio: 'inherit' });
+                    } catch (e) {
+                        installSpinner.text = 'Copying (fs fallback) to /Applications...';
+                        await fs.copy(fullSourcePath, destinationPath);
+                    }
+                } else {
+                    installSpinner.start();
+                }
+            } catch (e) {
+                installSpinner.text = 'Copying (cp/fs fallback) to /Applications...';
+                try {
+                    execSync(`cp -R "${fullSourcePath}" "/Applications/"`, { stdio: 'inherit' });
+                } catch (err) {
+                    await fs.copy(fullSourcePath, destinationPath);
+                }
+            }
 
             // Unmount
             installSpinner.text = 'Cleaning up...';

package/src/utils/persistent-header.js

@@ -76,9 +76,7 @@ function formatAutoModeHeader(status) {
     step = 'PREPARE',
     chatCount = 0,
     maxChats = null,
-    progress = 0,
-    repoPath = '',
-    hostname = ''
+    progress = 0
   } = status;
 
   const stepColors = {

package/src/utils/provider-registry.js

@@ -1,5 +1,3 @@
-const path = require('path');
-const os = require('os');
 const { getAutoConfig, setAutoConfig } = require('./config');
 
 const PROVIDER_DEFINITIONS = [
@@ -9,6 +7,7 @@ const PROVIDER_DEFINITIONS = [
     type: 'direct',
     category: 'llm',
     defaultModel: 'llama-3.3-70b-versatile',
+    fallbackModels: ['llama-3.1-70b-versatile', 'llama-3.1-8b-instant', 'mixtral-8x7b-32768'],
     configKeys: { apiKey: 'groqApiKey', model: 'groqModel' },
     estimatedSpeed: 15000
   },
@@ -17,7 +16,8 @@ const PROVIDER_DEFINITIONS = [
     name: 'Anthropic (Claude Sonnet 4)',
     type: 'direct',
     category: 'llm',
-    defaultModel: 'claude-sonnet-4-20250514',
+    defaultModel: 'claude-3-5-sonnet-20241022',
+    fallbackModels: ['claude-3-5-haiku-20241022', 'claude-3-opus-20240229'],
     configKeys: { apiKey: 'anthropicApiKey', model: 'anthropicModel' },
     estimatedSpeed: 25000
   },
@@ -26,7 +26,8 @@ const PROVIDER_DEFINITIONS = [
     name: 'AWS Bedrock (Claude)',
     type: 'direct',
     category: 'llm',
-    defaultModel: 'anthropic.claude-sonnet-4-v1',
+    defaultModel: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
+    fallbackModels: ['anthropic.claude-3-5-haiku-20241022-v1:0', 'anthropic.claude-3-sonnet-20240229-v1:0'],
     configKeys: { region: 'awsRegion', accessKeyId: 'awsAccessKeyId', secretAccessKey: 'awsSecretAccessKey' },
     estimatedSpeed: 40000
   },

package/src/utils/user-tracking.js

@@ -0,0 +1,300 @@
+/**
+ * User Tracking Integration for CLI
+ * 
+ * This module integrates the CLI with the enhanced user tracking system,
+ * automatically logging user activities and updating usage statistics.
+ */
+
+const auth = require('./auth')
+
+class CLIUserTracking {
+  constructor() {
+    this.sessionStartTime = Date.now()
+    this.activityBuffer = []
+    this.flushInterval = null
+    
+    // Start periodic flush of activity data
+    this.startActivityFlush()
+  }
+
+  /**
+   * Track CLI command execution
+   */
+  async trackCommand(command, args = [], metadata = {}) {
+    try {
+      await auth.trackCLIActivity('command_executed', {
+        command,
+        args: args.filter(arg => !arg.includes('password') && !arg.includes('token')), // Filter sensitive data
+        duration: 0,
+        ...metadata
+      })
+    } catch (error) {
+      // Silently fail - don't disrupt user experience
+      console.debug('Failed to track command:', error.message)
+    }
+  }
+
+  /**
+   * Track requirement operations
+   */
+  async trackRequirementActivity(action, requirementData = {}) {
+    try {
+      await auth.trackCLIActivity('requirement_activity', {
+        action, // 'created', 'updated', 'completed', 'verified', etc.
+        requirementId: requirementData.id,
+        package: requirementData.package,
+        duration: 0,
+        metadata: {
+          hasDescription: !!requirementData.description,
+          descriptionLength: requirementData.description?.length || 0,
+          timestamp: Date.now()
+        }
+      })
+    } catch (error) {
+      console.debug('Failed to track requirement activity:', error.message)
+    }
+  }
+
+  /**
+   * Track auto mode sessions
+   */
+  async trackAutoModeSession(action, sessionData = {}) {
+    try {
+      await auth.trackCLIActivity('auto_mode', {
+        action, // 'started', 'stopped', 'iteration_completed'
+        duration: sessionData.duration || 0,
+        metadata: {
+          maxIterations: sessionData.maxIterations,
+          completedIterations: sessionData.completedIterations,
+          ide: sessionData.ide,
+          timestamp: Date.now()
+        }
+      })
+    } catch (error) {
+      console.debug('Failed to track auto mode session:', error.message)
+    }
+  }
+
+  /**
+   * Track IDE interactions
+   */
+  async trackIDEInteraction(ide, action, metadata = {}) {
+    try {
+      await auth.trackCLIActivity('ide_interaction', {
+        action, // 'opened', 'sent_message', 'received_response'
+        ide,
+        duration: metadata.duration || 0,
+        metadata: {
+          messageLength: metadata.messageLength,
+          responseLength: metadata.responseLength,
+          success: metadata.success !== false,
+          timestamp: Date.now()
+        }
+      })
+    } catch (error) {
+      console.debug('Failed to track IDE interaction:', error.message)
+    }
+  }
+
+  /**
+   * Track project operations
+   */
+  async trackProjectActivity(action, projectData = {}) {
+    try {
+      await auth.trackCLIActivity('project_activity', {
+        action, // 'created', 'opened', 'switched'
+        duration: 0,
+        metadata: {
+          projectPath: projectData.path,
+          hasDescription: !!projectData.description,
+          techStack: projectData.techStack || [],
+          timestamp: Date.now()
+        }
+      })
+    } catch (error) {
+      console.debug('Failed to track project activity:', error.message)
+    }
+  }
+
+  /**
+   * Track sync operations
+   */
+  async trackSyncActivity(action, syncData = {}) {
+    try {
+      await auth.trackCLIActivity('sync_activity', {
+        action, // 'started', 'completed', 'failed'
+        duration: syncData.duration || 0,
+        metadata: {
+          itemsSync: syncData.itemsSync || 0,
+          conflicts: syncData.conflicts || 0,
+          success: syncData.success !== false,
+          timestamp: Date.now()
+        }
+      })
+    } catch (error) {
+      console.debug('Failed to track sync activity:', error.message)
+    }
+  }
+
+  /**
+   * Track session duration and end session
+   */
+  async endSession() {
+    try {
+      const sessionDuration = Date.now() - this.sessionStartTime
+      
+      await auth.trackCLIActivity('session_ended', {
+        duration: Math.round(sessionDuration / 1000), // Convert to seconds
+        metadata: {
+          sessionStartTime: this.sessionStartTime,
+          sessionEndTime: Date.now(),
+          totalCommands: this.activityBuffer.length,
+          timestamp: Date.now()
+        }
+      })
+
+      // Stop activity flushing
+      if (this.flushInterval) {
+        clearInterval(this.flushInterval)
+      }
+    } catch (error) {
+      console.debug('Failed to track session end:', error.message)
+    }
+  }
+
+  /**
+   * Start periodic flushing of activity data
+   */
+  startActivityFlush() {
+    // Flush activity buffer every 5 minutes
+    this.flushInterval = setInterval(() => {
+      this.flushActivityBuffer()
+    }, 5 * 60 * 1000)
+  }
+
+  /**
+   * Flush buffered activity data
+   */
+  async flushActivityBuffer() {
+    if (this.activityBuffer.length === 0) return
+
+    try {
+      // Update user activity timestamp
+      const token = await auth.getToken()
+      if (token && token.id_token) {
+        await auth._updateUserActivity()
+      }
+      
+      // Clear buffer after successful flush
+      this.activityBuffer = []
+    } catch (error) {
+      console.debug('Failed to flush activity buffer:', error.message)
+    }
+  }
+
+  /**
+   * Register project with enhanced tracking
+   */
+  async registerProject(projectInfo) {
+    try {
+      const token = await auth.getToken()
+      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 || '',
+        path: projectInfo.path || process.cwd(),
+        techStack: projectInfo.techStack || [],
+        framework: projectInfo.framework || '',
+        language: projectInfo.language || '',
+        goals: projectInfo.goals || '',
+        category: projectInfo.category || 'general'
+      })
+
+      // Track project creation
+      await this.trackProjectActivity('created', {
+        path: project.path,
+        description: project.description,
+        techStack: project.techStack
+      })
+
+      return project
+    } catch (error) {
+      console.debug('Failed to register project:', error.message)
+      return null
+    }
+  }
+
+  /**
+   * Check and prompt for compliance if needed
+   */
+  async checkCompliance() {
+    try {
+      const token = await auth.getToken()
+      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,
+        privacyAccepted: status.privacyAccepted,
+        requiredActions: status.requiredActions
+      }
+    } catch (error) {
+      console.debug('Failed to check compliance:', error.message)
+      return { compliant: true } // Default to compliant to not block users
+    }
+  }
+
+  /**
+   * Record compliance acknowledgment
+   */
+  async recordCompliance(acknowledgments) {
+    try {
+      const token = await auth.getToken()
+      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,
+        privacyAccepted: acknowledgments.privacy
+      })
+
+      return true
+    } catch (error) {
+      console.debug('Failed to record compliance:', error.message)
+      return false
+    }
+  }
+}
+
+// Export singleton instance
+module.exports = new CLIUserTracking()

package/tests/requirements-navigator-buildtree-await.test.js

@@ -0,0 +1,28 @@
+const fs = require('fs');
+const path = require('path');
+
+describe('Requirements Navigator regression: buildTree must be awaited', () => {
+  test('interactive.js does not call buildTree() without await', () => {
+    const interactivePath = path.join(__dirname, '../src/utils/interactive.js');
+    const content = fs.readFileSync(interactivePath, 'utf8');
+    const lines = content.split('\n');
+
+    const offending = [];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line.includes('buildTree();')) continue;
+
+      const trimmed = line.trim();
+
+      // Ignore the function definition line(s)
+      if (trimmed.startsWith('const buildTree') || trimmed.startsWith('function buildTree')) continue;
+
+      if (trimmed !== 'await buildTree();') {
+        offending.push({ lineNumber: i + 1, line: trimmed });
+      }
+    }
+
+    expect(offending).toEqual([]);
+  });
+});