vibecodingmachine-cli 2025.12.6-1702 → 2025.12.24-2348

package/src/commands/sync.js

@@ -1,16 +1,17 @@
 const chalk = require('chalk');
 const Table = require('cli-table3');
 const SyncEngine = require('vibecodingmachine-core/src/sync/sync-engine');
+const { t } = require('vibecodingmachine-core');
 
 /**
  * Trigger immediate sync
  */
-async function syncNow(options = {}) {
+async function syncNow() {
   const syncEngine = new SyncEngine();
   
   try {
-    console.log(chalk.cyan('\n🔄 Starting sync...\n'));
-    
+    console.log(chalk.cyan(`\n🔄 ${t('sync.starting')}\n`));
+
     await syncEngine.initialize();
     
     // Listen for sync completion
@@ -31,18 +32,18 @@ async function syncNow(options = {}) {
     const result = await syncPromise;
     
     const status = syncEngine.getStatus();
-    
-    console.log(chalk.green('✓ Sync complete!\n'));
-    console.log(chalk.white('Last Sync:       ') + new Date(status.lastSyncTime).toLocaleString());
-    console.log(chalk.white('Remote Changes:  ') + (result.remoteChanges || 0));
-    console.log(chalk.white('Local Changes:   ') + (result.localChanges || 0));
-    console.log(chalk.white('Conflicts:       ') + (result.conflicts || 0));
-    console.log(chalk.white('Queued Changes:  ') + status.queuedChanges);
+
+    console.log(chalk.green(`✓ ${t('sync.complete')}\n`));
+    console.log(chalk.white(t('sync.last.sync').padEnd(17)) + new Date(status.lastSyncTime).toLocaleString());
+    console.log(chalk.white(t('sync.remote.changes').padEnd(17)) + (result.remoteChanges || 0));
+    console.log(chalk.white(t('sync.local.changes').padEnd(17)) + (result.localChanges || 0));
+    console.log(chalk.white(t('sync.conflicts').padEnd(17)) + (result.conflicts || 0));
+    console.log(chalk.white(t('sync.queued.changes').padEnd(17)) + status.queuedChanges);
     console.log('');
     
   } catch (error) {
-    console.error(chalk.red('\n✗ Sync failed:'), error.message);
-    console.log(chalk.gray('\nTip: Check AWS credentials and DynamoDB table configuration.\n'));
+    console.error(chalk.red(`\n✗ ${t('sync.failed')}`), error.message);
+    console.log(chalk.gray(`\n${t('sync.tip.aws')}\n`));
     // Don't throw - just log the error
   } finally {
     syncEngine.stop();
@@ -52,49 +53,49 @@ async function syncNow(options = {}) {
 /**
  * Show sync status and statistics
  */
-async function syncStatus(options = {}) {
+async function syncStatus() {
   const syncEngine = new SyncEngine();
   
   try {
     await syncEngine.initialize();
     
     const status = syncEngine.getStatus();
-    
-    console.log('\n' + chalk.bold.cyan('Sync Status'));
+
+    console.log('\n' + chalk.bold.cyan(t('sync.status.title')));
     console.log(chalk.gray('─'.repeat(60)));
-    
+
     // Connection status
     const onlineIcon = status.isOnline ? chalk.green('●') : chalk.red('●');
-    const onlineText = status.isOnline ? 'Online' : 'Offline';
-    console.log(chalk.white('Connection:      ') + onlineIcon + ' ' + onlineText);
-    
+    const onlineText = status.isOnline ? t('sync.status.online') : t('sync.status.offline');
+    console.log(chalk.white(t('sync.connection').padEnd(17)) + onlineIcon + ' ' + onlineText);
+
     // Sync status
     const syncingIcon = status.isSyncing ? chalk.yellow('⟳') : chalk.gray('○');
-    const syncingText = status.isSyncing ? 'Syncing...' : 'Idle';
-    console.log(chalk.white('Status:          ') + syncingIcon + ' ' + syncingText);
-    
+    const syncingText = status.isSyncing ? t('sync.status.syncing') : t('sync.status.idle');
+    console.log(chalk.white(t('sync.status').padEnd(17)) + syncingIcon + ' ' + syncingText);
+
     // Last sync
-    const lastSync = status.lastSyncTime 
+    const lastSync = status.lastSyncTime
       ? new Date(status.lastSyncTime).toLocaleString()
-      : 'Never';
-    console.log(chalk.white('Last Sync:       ') + lastSync);
-    
+      : t('sync.never');
+    console.log(chalk.white(t('sync.last.sync').padEnd(17)) + lastSync);
+
     // Queued changes
     const queueColor = status.queuedChanges > 0 ? chalk.yellow : chalk.gray;
-    console.log(chalk.white('Queued Changes:  ') + queueColor(status.queuedChanges));
-    
+    console.log(chalk.white(t('sync.queued.changes').padEnd(17)) + queueColor(status.queuedChanges));
+
     // Conflict strategy
-    console.log(chalk.white('Conflict Mode:   ') + status.conflictStrategy);
-    
+    console.log(chalk.white(t('sync.conflict.mode').padEnd(17)) + status.conflictStrategy);
+
     // Computer ID
-    console.log(chalk.white('Computer ID:     ') + status.computerId);
-    
+    console.log(chalk.white(t('sync.computer.id').padEnd(17)) + status.computerId);
+
     console.log('');
     
     // Show recent sync events
     const history = syncEngine.getHistory(5);
     if (history.length > 0) {
-      console.log(chalk.bold.cyan('Recent Sync Events'));
+      console.log(chalk.bold.cyan(t('sync.recent.events')));
       console.log(chalk.gray('─'.repeat(60)));
       
       for (const event of history.reverse()) {
@@ -107,7 +108,7 @@ async function syncStatus(options = {}) {
     }
     
   } catch (error) {
-    console.error(chalk.red('\n✗ Failed to get sync status:'), error.message);
+    console.error(chalk.red(`\n✗ ${t('sync.status.failed')}`), error.message);
     throw error;
   } finally {
     syncEngine.stop();
@@ -117,28 +118,28 @@ async function syncStatus(options = {}) {
 /**
  * View pending changes in offline queue
  */
-async function viewQueue(options = {}) {
+async function viewQueue() {
   const syncEngine = new SyncEngine();
   
   try {
     await syncEngine.initialize();
     
     const status = syncEngine.getStatus();
-    
+
     if (status.queuedChanges === 0) {
-      console.log(chalk.gray('\nNo pending changes in queue.\n'));
+      console.log(chalk.gray(`\n${t('sync.queue.no.pending')}\n`));
       return;
     }
-    
-    console.log(chalk.cyan(`\n📋 Offline Queue (${status.queuedChanges} changes)\n`));
-    
+
+    console.log(chalk.cyan(`\n📋 ${t('sync.queue.title', { count: status.queuedChanges })}\n`));
+
     // Create table
     const table = new Table({
       head: [
-        chalk.cyan('#'),
-        chalk.cyan('Type'),
-        chalk.cyan('Requirement'),
-        chalk.cyan('Timestamp')
+        chalk.cyan(t('sync.queue.header.number')),
+        chalk.cyan(t('sync.queue.header.type')),
+        chalk.cyan(t('sync.queue.header.requirement')),
+        chalk.cyan(t('sync.queue.header.timestamp'))
       ],
       colWidths: [5, 15, 40, 20]
     });
@@ -154,15 +155,15 @@ async function viewQueue(options = {}) {
     });
     
     console.log(table.toString() + '\n');
-    
-    console.log(chalk.gray('These changes will be synced when connection is restored.\n'));
-    console.log(chalk.white('Commands:'));
-    console.log(chalk.gray('  vcm sync:force  ') + '- Force sync now');
-    console.log(chalk.gray('  vcm sync:now    ') + '- Sync when online');
+
+    console.log(chalk.gray(`${t('sync.queue.will.sync')}\n`));
+    console.log(chalk.white(t('sync.queue.commands')));
+    console.log(chalk.gray('  vcm sync:force  ') + `- ${t('sync.queue.force.now')}`);
+    console.log(chalk.gray('  vcm sync:now    ') + `- ${t('sync.queue.sync.online')}`);
     console.log('');
     
   } catch (error) {
-    console.error(chalk.red('\n✗ Failed to view queue:'), error.message);
+    console.error(chalk.red(`\n✗ ${t('sync.queue.view.failed')}`), error.message);
     throw error;
   } finally {
     syncEngine.stop();
@@ -172,29 +173,29 @@ async function viewQueue(options = {}) {
 /**
  * Force sync even if offline
  */
-async function forceSync(options = {}) {
+async function forceSync() {
   const syncEngine = new SyncEngine();
   
   try {
-    console.log(chalk.yellow('\n⚠ Forcing sync (ignoring offline status)...\n'));
-    
+    console.log(chalk.yellow(`\n⚠ ${t('sync.force.starting')}\n`));
+
     await syncEngine.initialize();
-    
+
     // Temporarily set online
     const wasOnline = syncEngine.isOnline;
     syncEngine.setOnlineMode(true);
-    
+
     try {
       await syncEngine.sync();
-      console.log(chalk.green('✓ Force sync complete!\n'));
+      console.log(chalk.green(`✓ ${t('sync.force.complete')}\n`));
     } finally {
       // Restore original online status
       syncEngine.setOnlineMode(wasOnline);
     }
     
   } catch (error) {
-    console.error(chalk.red('\n✗ Force sync failed:'), error.message);
-    console.log(chalk.gray('\nThis usually means the server is unreachable.\n'));
+    console.error(chalk.red(`\n✗ ${t('sync.force.failed')}`), error.message);
+    console.log(chalk.gray(`\n${t('sync.force.unreachable')}\n`));
     throw error;
   } finally {
     syncEngine.stop();
@@ -212,20 +213,20 @@ async function viewHistory(options = {}) {
     
     const limit = parseInt(options.limit) || 50;
     const history = syncEngine.getHistory(limit);
-    
+
     if (history.length === 0) {
-      console.log(chalk.gray('\nNo sync history available.\n'));
+      console.log(chalk.gray(`\n${t('sync.history.no.events')}\n`));
       return;
     }
-    
-    console.log(chalk.cyan(`\n📜 Sync History (last ${history.length} events)\n`));
-    
+
+    console.log(chalk.cyan(`\n📜 ${t('sync.history.title', { count: history.length })}\n`));
+
     // Create table
     const table = new Table({
       head: [
-        chalk.cyan('Time'),
-        chalk.cyan('Type'),
-        chalk.cyan('Details')
+        chalk.cyan(t('sync.history.header.time')),
+        chalk.cyan(t('sync.history.header.type')),
+        chalk.cyan(t('sync.history.header.details'))
       ],
       colWidths: [20, 20, 50]
     });
@@ -242,7 +243,7 @@ async function viewHistory(options = {}) {
     console.log(table.toString() + '\n');
     
   } catch (error) {
-    console.error(chalk.red('\n✗ Failed to view history:'), error.message);
+    console.error(chalk.red(`\n✗ ${t('sync.history.view.failed')}`), error.message);
     throw error;
   } finally {
     syncEngine.stop();
@@ -259,13 +260,13 @@ function truncate(str, maxLength) {
 function getEventDetails(event) {
   switch (event.type) {
     case 'conflict-resolution':
-      return `Resolved: ${event.resolution?.requirementId || 'unknown'}`;
+      return t('sync.event.resolved', { id: event.resolution?.requirementId || 'unknown' });
     case 'sync-complete':
-      return `Remote: ${event.remoteChanges || 0}, Local: ${event.localChanges || 0}`;
+      return t('sync.event.remote.local', { remote: event.remoteChanges || 0, local: event.localChanges || 0 });
     case 'remote-change-applied':
-      return `Applied: ${event.change?.requirementId || 'unknown'}`;
+      return t('sync.event.applied', { id: event.change?.requirementId || 'unknown' });
     case 'local-change-pushed':
-      return `Pushed: ${event.change?.requirementId || 'unknown'}`;
+      return t('sync.event.pushed', { id: event.change?.requirementId || 'unknown' });
     default:
       return JSON.stringify(event).substring(0, 47);
   }

package/src/utils/agent-selector.js

@@ -0,0 +1,50 @@
+/**
+ * Centralized agent selection logic
+ * Respects provider preferences order and ensures DRY principle
+ */
+
+const { getProviderPreferences } = require('./provider-registry');
+
+/**
+ * Get the effective agent based on provider preferences and options
+ * @param {Object} options - Command line options (may include ide)
+ * @param {Array} providerDefinitions - Array of provider definitions
+ * @param {Map} providerDefinitionMap - Map of provider definitions by ID
+ * @returns {Object} - { effectiveAgent: string, providerDef: Object }
+ */
+async function getEffectiveAgent(options = {}, providerDefinitions, providerDefinitionMap) {
+  const prefs = await getProviderPreferences();
+  
+  // Get all available providers in the order specified in preferences
+  const availableProviders = [];
+  for (const id of prefs.order) {
+    if (prefs.enabled[id] !== false && providerDefinitionMap.has(id)) {
+      availableProviders.push(id);
+    }
+  }
+  
+  // If no providers are available, use the first one from definitions as fallback
+  if (availableProviders.length === 0) {
+    availableProviders.push(providerDefinitions[0]?.id || 'claude-code');
+  }
+  
+  // Use the first available provider by default, unless overridden by options
+  let effectiveAgent = options.ide || availableProviders[0];
+  
+  // If the requested agent isn't available, use the first available one
+  if (!availableProviders.includes(effectiveAgent)) {
+    effectiveAgent = availableProviders[0];
+  }
+  
+  const providerDef = providerDefinitionMap.get(effectiveAgent);
+  
+  return {
+    effectiveAgent,
+    providerDef,
+    availableProviders
+  };
+}
+
+module.exports = {
+  getEffectiveAgent
+};

package/src/utils/antigravity-installer.js

@@ -0,0 +1,212 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+const ora = require('ora');
+const chalk = require('chalk');
+
+async function installAntigravity() {
+  console.log(chalk.cyan('\n🚀 Initiating Google Antigravity IDE Installation...'));
+
+  const spinner = ora('Checking system requirements...').start();
+  await new Promise((r) => setTimeout(r, 800));
+
+  if (os.platform() !== 'darwin') {
+    spinner.fail('Automated Antigravity installation is only supported on macOS');
+    return false;
+  }
+
+  const arch = os.arch();
+  const isArm = arch === 'arm64';
+
+  // URLs from electron-app IDE installer
+  const downloadUrl = isArm
+    ? 'https://edgedl.me.gvt1.com/edgedl/release2/j0qc3/antigravity/stable/1.11.2-6251250307170304/darwin-arm/Antigravity.dmg'
+    : 'https://edgedl.me.gvt1.com/edgedl/release2/j0qc3/antigravity/stable/1.11.2-6251250307170304/darwin-x64/Antigravity.dmg';
+
+  spinner.succeed(`System OK (${isArm ? 'Apple Silicon' : 'Intel'})`);
+
+    try {
+    const cacheDir = path.join(os.homedir(), '.vibecodingmachine', 'cache');
+    await fs.ensureDir(cacheDir);
+    const cachedPath = path.join(cacheDir, 'Antigravity.dmg');
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'antigravity-'));
+    const dmgPath = path.join(tempDir, 'Antigravity.dmg');
+    const { downloadWithProgress } = require('./download-with-progress');
+
+    // Prefer cached DMG if it exists and matches upstream size (or exists at all)
+    let usedCache = false;
+    try {
+      if (await fs.pathExists(cachedPath)) {
+        // Try HEAD to compare sizes
+        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 Antigravity DMG')); 
+          }
+        } catch (e) {
+          // If HEAD fails, still allow reuse of cache to avoid re-download
+          await fs.copy(cachedPath, dmgPath);
+          usedCache = true;
+          console.log(chalk.gray('Using cached Antigravity DMG (no HEAD)'));
+        }
+      }
+    } catch (e) {
+      // ignore cache errors
+      usedCache = false;
+    }
+
+    // Use download helper which displays progress and ETA if we didn't reuse cache
+    if (!usedCache) {
+      await downloadWithProgress(downloadUrl, dmgPath, { label: 'Downloading Antigravity...' });
+      // Save to cache for future runs
+      try { await fs.copy(dmgPath, cachedPath); } catch (e) { /* ignore cache write errors */ }
+    }
+
+    const installSpinner = ora('Installing Antigravity...').start();
+
+    try {
+      installSpinner.text = 'Mounting disk image...';
+      execSync(`hdiutil attach "${dmgPath}" -nobrowse -noverify -mountpoint "${tempDir}/mount"`);
+
+      installSpinner.text = 'Copying to /Applications...';
+      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 in DMG');
+
+      const src = path.join(tempDir, 'mount', appName);
+      const dest = path.join('/Applications', appName);
+
+      if (await fs.pathExists(dest)) {
+        installSpinner.text = 'Replacing existing application...';
+        await fs.remove(dest);
+      }
+
+        // Prefer rsync/ditto; fallback to node-stream copy with progress
+        try {
+          const { copyAppWithProgress } = require('./copy-with-progress');
+          installSpinner.stop();
+          const ok = await copyAppWithProgress(src, dest, { spinner: installSpinner });
+          if (!ok) {
+            installSpinner.text = 'Copying (fs fallback) to /Applications...';
+            await fs.copy(src, dest);
+          }
+        } catch (e) {
+          // final fallback
+          installSpinner.text = 'Copying (fs fallback) to /Applications...';
+          try {
+            execSync(`cp -R "${src}" "/Applications/"`, { stdio: 'inherit' });
+          } catch (err) {
+            await fs.copy(src, dest);
+          }
+        }
+
+      installSpinner.text = 'Cleaning up...';
+      execSync(`hdiutil detach "${tempDir}/mount" -force`);
+      await fs.remove(tempDir);
+
+      installSpinner.succeed('Antigravity installed');
+      console.log(chalk.green(`\n✅ Installed to ${dest}`));
+          // Attempt to automatically configure Antigravity's first-run settings
+          try {
+            await configureAntigravityDefaults(dest);
+          } catch (e) {
+            // Non-fatal: log and continue
+            console.log(chalk.yellow('Warning: could not auto-configure Antigravity:'), e.message || e);
+          }
+
+          return true;
+    } catch (err) {
+      installSpinner.fail('Installation failed');
+      try {
+        if (await fs.pathExists(path.join(tempDir, 'mount'))) {
+          execSync(`hdiutil detach "${tempDir}/mount" -force`);
+        }
+      try { await fs.remove(tempDir); } catch (e) { /* ignore */ }
+      console.log(chalk.red('\nInstallation error:'), err.message);
+      return false;
+    }
+  } catch (error) {
+    console.log(chalk.red('\nFailed to install Antigravity:'), error.message);
+    return false;
+  }
+}
+
+async function configureAntigravityDefaults() {
+  // Attempt to open Antigravity and set the onboarding defaults via AppleScript
+  // Desired selections:
+  // - Agent-driven development (instead of recommended Agent-assisted)
+  // - Terminal execution policy: Turbo
+  // - Review policy: Always Proceed
+  // - Use the default allowlist for the browser (checked)
+  try {
+    const script = `
+      tell application "Antigravity"
+        activate
+      end tell
+      delay 0.8
+      tell application "System Events"
+        tell process "Antigravity"
+          set frontmost to true
+          delay 0.5
+          -- Try to select Agent-driven development radio button
+          try
+            click radio button "Agent-driven development" of radio group 1 of window 1
+            delay 0.2
+          end try
+
+          -- Set Terminal execution policy to Turbo (attempt by label, then by index)
+          try
+            try
+              click pop up button "Terminal execution policy" of window 1
+              delay 0.2
+              click menu item "Turbo" of menu 1 of pop up button "Terminal execution policy" of window 1
+            on error
+              -- fallback: click first pop up button and choose Turbo
+              click pop up button 1 of window 1
+              delay 0.2
+              click menu item "Turbo" of menu 1 of pop up button 1 of window 1
+            end try
+            delay 0.2
+          end try
+
+          -- Set Review policy to Always Proceed
+          try
+            click pop up button "Review policy" of window 1
+            delay 0.2
+            click menu item "Always Proceed" of menu 1 of pop up button "Review policy" of window 1
+            delay 0.2
+          end try
+
+          -- Ensure default allowlist checkbox is checked
+          try
+            set cb to checkbox "Use the default allowlist for the browser" of window 1
+            if (value of cb as boolean) is false then click cb
+            delay 0.2
+          end try
+
+          -- Advance the onboarding if a Next/Done button exists
+          try
+            if exists button "Next" of window 1 then click button "Next" of window 1
+            delay 0.3
+          end try
+        end tell
+      end tell
+    `;
+
+    // Use osascript to run the UI automation. JSON-stringify ensures safe quoting.
+    const { execSync } = require('child_process');
+    execSync(`osascript -e ${JSON.stringify(script)}`, { stdio: 'ignore', timeout: 15000 });
+    console.log(chalk.gray('Auto-configured Antigravity first-run preferences'));
+    return true;
+  } catch (err) {
+    throw new Error(err.message || err);
+  }
+}
+
+module.exports = { installAntigravity };

package/src/utils/antigravity-js-handler.js

@@ -0,0 +1,60 @@
+const chalk = require('chalk');
+const {
+  getProviderPreferences,
+  saveProviderPreferences
+} = require('./provider-registry');
+
+/**
+ * Check if Antigravity agent has hit a rate limit.
+ * @param {string} stderr - Standard error output from the agent.
+ * @returns {{isRateLimited: boolean, message: string|null}} - Rate limit status and message.
+ */
+function checkAntigravityRateLimit(stderr) {
+  const rateLimitPatterns = [
+    /quota limit/i,
+    /rate limit/i,
+    /too many requests/i,
+    /limit exceeded/i
+  ];
+
+  for (const pattern of rateLimitPatterns) {
+    if (pattern.test(stderr)) {
+      return {
+        isRateLimited: true,
+        message: 'Antigravity quota limit reached.'
+      };
+    }
+  }
+
+  return { isRateLimited: false, message: null };
+}
+
+/**
+ * Handle rate limit for Antigravity by disabling it and selecting the next available provider.
+ * @returns {Promise<{success: boolean, nextProvider: string|null, error: string|null}>}
+ */
+async function handleAntigravityRateLimit() {
+  console.log(chalk.yellow('Antigravity rate limit detected. Disabling for this session.'));
+
+  try {
+    const prefs = await getProviderPreferences();
+    prefs.enabled.antigravity = false;
+    await saveProviderPreferences(prefs);
+
+    const nextProvider = prefs.order.find(p => p !== 'antigravity' && prefs.enabled[p]);
+
+    if (nextProvider) {
+      console.log(chalk.cyan(`Switching to next available provider: ${nextProvider}`));
+      return { success: true, nextProvider, error: null };
+    } else {
+      return { success: false, nextProvider: null, error: 'No fallback providers available.' };
+    }
+  } catch (error) {
+    return { success: false, nextProvider: null, error: 'Failed to update provider preferences.' };
+  }
+}
+
+module.exports = {
+  checkAntigravityRateLimit,
+  handleAntigravityRateLimit
+};

package/src/utils/asset-cleanup.js

@@ -1,6 +1,5 @@
 const fs = require('fs-extra');
 const path = require('path');
-const chalk = require('chalk');
 
 /**
  * Scans the assets directory and removes 0-byte PNG files