vibecodingmachine-cli 2025.12.1-534 → 2025.12.22-2230

package/src/utils/kiro-installer.js

@@ -0,0 +1,178 @@
+const fs = require('fs-extra');
+const os = require('os');
+const ora = require('ora');
+const chalk = require('chalk');
+
+// Placeholder check - this should ideally check for the actual application path
+// On macOS, typically /Applications/AWS Kiro.app or similar
+// For now, we'll check a simulated path or just return false to test the flow
+function isKiroInstalled() {
+    const platform = os.platform();
+    if (platform === 'darwin') {
+        return fs.existsSync('/Applications/AWS Kiro.app') || fs.existsSync('/Applications/Kiro.app');
+    }
+    // Add Windows/Linux checks if needed
+    return false;
+}
+
+async function installKiro() {
+    console.log(chalk.cyan('\n🚀 Initiating AWS Kiro AI IDE Installation...'));
+
+    const spinner = ora('Checking system requirements...').start();
+    await new Promise(resolve => setTimeout(resolve, 1000));
+
+    // Detect architecture
+    const arch = process.arch;
+    const isArm = arch === 'arm64';
+
+    // Verified working URL for ARM64 (v202507161958)
+    // For x64, we don't have the exact timestamp/hash, so recent failures suggest we might need to fallback to manual
+    const downloadUrl = isArm
+        ? 'https://prod.download.desktop.kiro.dev/releases/202507161958-Kiro-dmg-darwin-arm64.dmg'
+        : 'https://kiro.dev/downloads/'; // Fallback to downloads page for x64 until we find the direct link
+
+    spinner.succeed(`System requirements met (${isArm ? 'Apple Silicon' : 'Intel'}).`);
+
+    // for x64, we can't automate yet
+    if (!isArm) {
+        console.log(chalk.yellow('\n⚠️  Automated installation is currently only available for Apple Silicon (M1/M2/M3).'));
+        console.log(chalk.cyan('Opening download page...'));
+        // open v11+ is ESM only
+        const open = (await import('open')).default;
+        await open(downloadUrl);
+        return false;
+    }
+
+    try {
+        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 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 { downloadWithProgress } = require('./download-with-progress');
+
+        // 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;
+        }
+
+        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();
+
+        try {
+            // Mount DMG
+            installSpinner.text = 'Mounting disk image...';
+            // -nobrowse to prevent opening Finder window, -noverify to speed up
+            execSync(`hdiutil attach "${dmgPath}" -nobrowse -noverify -mountpoint "${tempDir}/mount"`);
+
+            // Copy App
+            installSpinner.text = 'Copying to Applications...';
+
+            // Look for .app file
+            const files = await fs.readdir(path.join(tempDir, 'mount'));
+            const appName = files.find(f => f.endsWith('.app'));
+
+            if (!appName) {
+                throw new Error('Could not find .app file in the downloaded DMG.');
+            }
+
+            const fullSourcePath = path.join(tempDir, 'mount', appName);
+            const destinationPath = path.join('/Applications', appName);
+
+            // Remove existing if any
+            if (await fs.pathExists(destinationPath)) {
+                installSpinner.text = 'Replacing existing installation...';
+                await fs.remove(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...';
+            execSync(`hdiutil detach "${tempDir}/mount" -force`);
+            await fs.remove(tempDir);
+
+            installSpinner.succeed('AWS Kiro successfully installed!');
+            console.log(chalk.green(`\n✅ Installed to ${destinationPath}`));
+
+            return true;
+        } catch (installError) {
+            installSpinner.fail('Installation failed during file operations');
+            // Try to cleanup even if install failed
+            try {
+                if (fs.existsSync(path.join(tempDir, 'mount'))) {
+                    execSync(`hdiutil detach "${tempDir}/mount" -force`);
+                }
+                await fs.remove(tempDir);
+            } catch (cleanupError) {
+                // Ignore cleanup errors
+            }
+            throw installError;
+        }
+
+    } catch (error) {
+        // If error was thrown, spinners should have been handled, but just in case
+        // The main catch block for installKiro should not call ora().fail()
+        // as specific spinners (downloadSpinner, installSpinner) would have already failed.
+        // We log the manual download link
+        console.log(chalk.red('\nYou may need to download manually from: https://kiro.dev'));
+        return false;
+    }
+}
+
+module.exports = {
+    isKiroInstalled,
+    installKiro
+};

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
   },
@@ -62,6 +63,14 @@ const PROVIDER_DEFINITIONS = [
     ide: 'antigravity',
     estimatedSpeed: 90000
   },
+  {
+    id: 'kiro',
+    name: 'AWS Kiro AI IDE',
+    type: 'ide',
+    category: 'ide',
+    ide: 'kiro',
+    estimatedSpeed: 90000
+  },
   {
     id: 'ollama',
     name: 'Ollama (Local)',

package/src/utils/status-card.js

@@ -64,7 +64,8 @@ function renderStatusCard(status) {
     borderStyle: 'round',
     borderColor: 'magenta',
     title: 'Auto Mode Status',
-    titleAlignment: 'center'
+    titleAlignment: 'center',
+    width: 80
   });
 }
 

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([]);
+  });
+});