vibecodingmachine-cli 2025.12.1-534 → 2025.12.22-2230

package/src/commands/requirements.js

@@ -2,16 +2,98 @@ const path = require('path');
 const fs = require('fs-extra');
 const chalk = require('chalk');
 const chokidar = require('chokidar');
-const { getRepoPath } = require('../utils/config');
+const { getRepoPath, setRepoPath } = require('../utils/config');
 const { getRequirementsPath } = require('vibecodingmachine-core');
 
 async function getReqPathOrExit() {
-  const repoPath = await getRepoPath();
+  let repoPath = await getRepoPath();
+
+  // Auto-detect and initialize if we're in a git repository
+  if (!repoPath) {
+    const cwd = process.cwd();
+    const cwdResolved = path.resolve(cwd);
+
+    // Find the git root by walking up the directory tree
+    let currentDir = cwdResolved;
+    let foundGitRoot = false;
+    const maxDepth = 50; // Prevent infinite loops
+    let depth = 0;
+
+    // Walk up the directory tree looking for .git directory
+    while (depth < maxDepth && currentDir !== path.dirname(currentDir)) {
+      const gitPath = path.join(currentDir, '.git');
+      try {
+        if (await fs.pathExists(gitPath)) {
+          repoPath = currentDir;
+          foundGitRoot = true;
+          break;
+        }
+      } catch (err) {
+        // If we can't check, continue to parent
+      }
+      const parentDir = path.dirname(currentDir);
+      if (parentDir === currentDir) {
+        // Reached filesystem root
+        break;
+      }
+      currentDir = parentDir;
+      depth++;
+    }
+
+    // Fallback: if no .git found but .vibecodingmachine exists, use current dir
+    if (!foundGitRoot) {
+      try {
+        const vibecodingmachineDir = path.join(cwdResolved, '.vibecodingmachine');
+        if (await fs.pathExists(vibecodingmachineDir)) {
+          repoPath = cwdResolved;
+          foundGitRoot = true;
+        }
+      } catch (err) {
+        // Ignore errors
+      }
+    }
+
+    // Final fallback: use current directory if we have package.json
+    if (!foundGitRoot) {
+      try {
+        const packageJsonPath = path.join(cwdResolved, 'package.json');
+        if (await fs.pathExists(packageJsonPath)) {
+          repoPath = cwdResolved;
+          foundGitRoot = true;
+        }
+      } catch (err) {
+        // Ignore errors
+      }
+    }
+
+    // If we found a repo path, save it
+    if (repoPath) {
+      try {
+        await setRepoPath(repoPath);
+      } catch (err) {
+        // If setting fails, we still have repoPath set, so continue
+      }
+    }
+  }
+
+  // Final validation - ensure we have a valid path
+  // If we still don't have a repoPath, use current directory as absolute last resort
+  if (!repoPath) {
+    repoPath = path.resolve(process.cwd());
+    try {
+      await setRepoPath(repoPath);
+    } catch (err) {
+      // Even if we can't save it, we'll use it for this session
+    }
+  }
+
+  // At this point, repoPath MUST be set (we've tried everything including current directory)
   if (!repoPath) {
     console.log(chalk.yellow('No repository path configured'));
     console.log(chalk.gray('Use'), chalk.cyan('vcm repo:init'), chalk.gray('or'), chalk.cyan('vcm repo:set <path>'));
     process.exit(1);
   }
+
   // Use getRequirementsPath which handles hostname-specific files
   const reqPath = await getRequirementsPath(repoPath);
   return { repoPath, reqPath };
@@ -40,7 +122,7 @@ async function list(options) {
   }
 }
 
-async function add(name) {
+async function add(name, pkg, description) {
   try {
     const { reqPath } = await getReqPathOrExit();
     await fs.ensureFile(reqPath);
@@ -48,7 +130,7 @@ async function add(name) {
 
     // Find the TODO section
     const todoSectionHeader = '## ⏳ Requirements not yet completed';
-    if (!content.includes(todoSectionHeader)) {
+    if (!content.includes('Requirements not yet completed')) {
       content += '\n\n' + todoSectionHeader + '\n';
     }
 
@@ -60,10 +142,38 @@ async function add(name) {
     for (let i = 0; i < lines.length; i++) {
       newLines.push(lines[i]);
 
-      // Insert right after the TODO section header (new header format)
-      if (!inserted && lines[i].includes(todoSectionHeader)) {
+      // Insert right after the TODO section header
+      if (!inserted && lines[i].startsWith('##') && lines[i].includes('Requirements not yet completed')) {
         // Add requirement header
         newLines.push(`### ${name}`);
+
+        // Add package if provided (and not 'all')
+        if (pkg && Array.isArray(pkg) && pkg.length > 0) {
+          const packageValue = pkg.length === 1 ? pkg[0] : pkg.join(', ');
+          if (packageValue !== 'all') {
+            newLines.push(`PACKAGE: ${packageValue}`);
+          }
+        } else if (pkg && typeof pkg === 'string' && pkg !== 'all') {
+          newLines.push(`PACKAGE: ${pkg}`);
+        }
+
+        // Add description if provided
+        if (description && typeof description === 'string' && description.trim()) {
+          const descLines = description.split('\n');
+          descLines.forEach(line => {
+            if (line.trim()) {
+              newLines.push(line);
+            }
+          });
+        } else if (description && Array.isArray(description)) {
+          // Handle array of description lines
+          description.forEach(line => {
+            if (line && typeof line === 'string' && line.trim()) {
+              newLines.push(line);
+            }
+          });
+        }
+
         // Add blank line after requirement
         newLines.push('');
         inserted = true;
@@ -120,15 +230,10 @@ async function next() {
 async function edit() {
   try {
     const { reqPath } = await getReqPathOrExit();
-    const opener = process.env.EDITOR ? null : 'open';
-    if (process.env.EDITOR) {
-      const { spawn } = require('child_process');
-      const child = spawn(process.env.EDITOR, [reqPath], { stdio: 'inherit' });
-      child.on('exit', (code) => process.exit(code || 0));
-    } else {
-      const { execSync } = require('child_process');
-      execSync(`${opener} ${JSON.stringify(reqPath)}`);
-    }
+    // Always use system default opener to avoid taking over the terminal
+    const { execSync } = require('child_process');
+    // Use 'open' for macOS (user's OS), could be expanded for others if needed
+    execSync(`open ${JSON.stringify(reqPath)}`);
   } catch (error) {
     console.error(chalk.red('Error opening file:'), error.message);
     process.exit(1);
@@ -148,13 +253,125 @@ async function watch() {
   }
 }
 
+async function rename(oldTitle, newTitle, description) {
+  try {
+    const { reqPath } = await getReqPathOrExit();
+    if (!await fs.pathExists(reqPath)) {
+      console.log(chalk.yellow('No REQUIREMENTS.md found.'));
+      return;
+    }
+
+    // Read the requirements file
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+
+    // Find the requirement block
+    let requirementStartIndex = -1;
+    let requirementEndIndex = -1;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith('###')) {
+        const title = line.replace(/^###\s*/, '').trim();
+        if (title === oldTitle) {
+          requirementStartIndex = i;
+          // Find the end of this requirement (next ### or ## header)
+          for (let j = i + 1; j < lines.length; j++) {
+            const nextLine = lines[j].trim();
+            if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+              requirementEndIndex = j;
+              break;
+            }
+          }
+          if (requirementEndIndex === -1) {
+            requirementEndIndex = lines.length;
+          }
+          break;
+        }
+      }
+    }
+
+    if (requirementStartIndex === -1) {
+      console.log(chalk.yellow(`⚠️  Could not find requirement: "${oldTitle}"`));
+      return;
+    }
+
+    // Build new requirement block
+    const newBlock = [`### ${newTitle}`];
+
+    // If description provided, use it
+    if (description) {
+      if (Array.isArray(description)) {
+        description.forEach(line => {
+          if (line && line.trim()) {
+            newBlock.push(line);
+          }
+        });
+      } else if (typeof description === 'string') {
+        description.split('\n').forEach(line => {
+          if (line.trim()) {
+            newBlock.push(line);
+          }
+        });
+      }
+    } else {
+      // Keep existing details (skip the ### header line)
+      for (let i = requirementStartIndex + 1; i < requirementEndIndex; i++) {
+        const line = lines[i];
+        if (line.trim()) {
+          newBlock.push(line);
+        }
+      }
+    }
+
+    newBlock.push(''); // Blank line after requirement
+
+    // Replace the old block with the new one
+    lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex, ...newBlock);
+
+    // Save
+    await fs.writeFile(reqPath, lines.join('\n'));
+    console.log(chalk.green('✓ Requirement renamed/updated'));
+  } catch (error) {
+    console.error(chalk.red('Error renaming requirement:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function working() {
+  try {
+    const { reqPath } = await getReqPathOrExit();
+    if (!await fs.pathExists(reqPath)) {
+      console.log(chalk.yellow('No REQUIREMENTS.md found.'));
+      return;
+    }
+    const { getCurrentRequirement } = require('vibecodingmachine-core');
+    // Note: Core's getCurrentRequirement returns "Working on: X" or default text.
+    // It assumes process.cwd() or similar. 
+    // But wait, Core's getCurrentRequirement takes 'repoPath'.
+    // And imported from core index.cjs might need repoPath.
+
+    // Let's manually implement it to be safe and use getReqPathOrExit's resolved path
+    // OR use the core helper but pass the correct repo path.
+    const { repoPath } = await getReqPathOrExit();
+    const coreResult = await getCurrentRequirement(repoPath);
+    console.log(chalk.cyan(coreResult));
+
+  } catch (error) {
+    console.error(chalk.red('Error getting working requirement:'), error.message);
+    process.exit(1);
+  }
+}
+
 module.exports = {
   list,
   add,
   current,
+  working,
   next,
   edit,
-  watch
+  watch,
+  rename
 };
 
 

package/src/commands/status.js

@@ -64,7 +64,6 @@ async function progress() {
 
 async function logs(cmd) {
   const lines = parseInt((cmd && cmd.lines) || '50', 10);
-  const repoPath = await getRepoPath();
   const defaultLog = path.join(process.cwd(), 'logs', 'security', 'security-2025-10-29.log');
   const logPath = await fs.pathExists(defaultLog) ? defaultLog : null;
   console.log(chalk.bold('\nRecent Logs'));

package/src/commands/sync.js

@@ -0,0 +1,280 @@
+const chalk = require('chalk');
+const Table = require('cli-table3');
+const SyncEngine = require('vibecodingmachine-core/src/sync/sync-engine');
+
+/**
+ * Trigger immediate sync
+ */
+async function syncNow() {
+  const syncEngine = new SyncEngine();
+  
+  try {
+    console.log(chalk.cyan('\n🔄 Starting sync...\n'));
+    
+    await syncEngine.initialize();
+    
+    // Listen for sync completion
+    const syncPromise = new Promise((resolve, reject) => {
+      syncEngine.once('sync-complete', (result) => {
+        if (result.status === 'error') {
+          reject(new Error(result.error || 'Sync failed'));
+        } else {
+          resolve(result);
+        }
+      });
+    });
+    
+    // Start sync
+    await syncEngine.sync();
+    
+    // Wait for completion
+    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('');
+    
+  } catch (error) {
+    console.error(chalk.red('\n✗ Sync failed:'), error.message);
+    console.log(chalk.gray('\nTip: Check AWS credentials and DynamoDB table configuration.\n'));
+    // Don't throw - just log the error
+  } finally {
+    syncEngine.stop();
+  }
+}
+
+/**
+ * Show sync status and statistics
+ */
+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(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);
+    
+    // Sync status
+    const syncingIcon = status.isSyncing ? chalk.yellow('⟳') : chalk.gray('○');
+    const syncingText = status.isSyncing ? 'Syncing...' : 'Idle';
+    console.log(chalk.white('Status:          ') + syncingIcon + ' ' + syncingText);
+    
+    // Last sync
+    const lastSync = status.lastSyncTime 
+      ? new Date(status.lastSyncTime).toLocaleString()
+      : 'Never';
+    console.log(chalk.white('Last Sync:       ') + lastSync);
+    
+    // Queued changes
+    const queueColor = status.queuedChanges > 0 ? chalk.yellow : chalk.gray;
+    console.log(chalk.white('Queued Changes:  ') + queueColor(status.queuedChanges));
+    
+    // Conflict strategy
+    console.log(chalk.white('Conflict Mode:   ') + status.conflictStrategy);
+    
+    // Computer ID
+    console.log(chalk.white('Computer ID:     ') + 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.gray('─'.repeat(60)));
+      
+      for (const event of history.reverse()) {
+        const time = new Date(event.timestamp).toLocaleTimeString();
+        const icon = event.type === 'conflict-resolution' ? chalk.yellow('⚠') : chalk.gray('•');
+        console.log(`${icon} ${chalk.gray(time)} ${event.type}`);
+      }
+      
+      console.log('');
+    }
+    
+  } catch (error) {
+    console.error(chalk.red('\n✗ Failed to get sync status:'), error.message);
+    throw error;
+  } finally {
+    syncEngine.stop();
+  }
+}
+
+/**
+ * View pending changes in offline queue
+ */
+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'));
+      return;
+    }
+    
+    console.log(chalk.cyan(`\n📋 Offline Queue (${status.queuedChanges} changes)\n`));
+    
+    // Create table
+    const table = new Table({
+      head: [
+        chalk.cyan('#'),
+        chalk.cyan('Type'),
+        chalk.cyan('Requirement'),
+        chalk.cyan('Timestamp')
+      ],
+      colWidths: [5, 15, 40, 20]
+    });
+    
+    // Add rows (accessing internal queue - in production, add a public getter)
+    syncEngine.offlineQueue.forEach((change, index) => {
+      table.push([
+        index + 1,
+        change.type || 'update',
+        truncate(change.requirementName || change.requirementId || '-', 38),
+        new Date(change.timestamp).toLocaleString()
+      ]);
+    });
+    
+    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('');
+    
+  } catch (error) {
+    console.error(chalk.red('\n✗ Failed to view queue:'), error.message);
+    throw error;
+  } finally {
+    syncEngine.stop();
+  }
+}
+
+/**
+ * Force sync even if offline
+ */
+async function forceSync() {
+  const syncEngine = new SyncEngine();
+  
+  try {
+    console.log(chalk.yellow('\n⚠ Forcing sync (ignoring offline status)...\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'));
+    } 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'));
+    throw error;
+  } finally {
+    syncEngine.stop();
+  }
+}
+
+/**
+ * View sync history
+ */
+async function viewHistory(options = {}) {
+  const syncEngine = new SyncEngine();
+  
+  try {
+    await syncEngine.initialize();
+    
+    const limit = parseInt(options.limit) || 50;
+    const history = syncEngine.getHistory(limit);
+    
+    if (history.length === 0) {
+      console.log(chalk.gray('\nNo sync history available.\n'));
+      return;
+    }
+    
+    console.log(chalk.cyan(`\n📜 Sync History (last ${history.length} events)\n`));
+    
+    // Create table
+    const table = new Table({
+      head: [
+        chalk.cyan('Time'),
+        chalk.cyan('Type'),
+        chalk.cyan('Details')
+      ],
+      colWidths: [20, 20, 50]
+    });
+    
+    // Add rows
+    for (const event of history.reverse()) {
+      const time = new Date(event.timestamp).toLocaleString();
+      const type = event.type;
+      const details = getEventDetails(event);
+      
+      table.push([time, type, details]);
+    }
+    
+    console.log(table.toString() + '\n');
+    
+  } catch (error) {
+    console.error(chalk.red('\n✗ Failed to view history:'), error.message);
+    throw error;
+  } finally {
+    syncEngine.stop();
+  }
+}
+
+// Helper functions
+
+function truncate(str, maxLength) {
+  if (str.length <= maxLength) return str;
+  return str.substring(0, maxLength - 3) + '...';
+}
+
+function getEventDetails(event) {
+  switch (event.type) {
+    case 'conflict-resolution':
+      return `Resolved: ${event.resolution?.requirementId || 'unknown'}`;
+    case 'sync-complete':
+      return `Remote: ${event.remoteChanges || 0}, Local: ${event.localChanges || 0}`;
+    case 'remote-change-applied':
+      return `Applied: ${event.change?.requirementId || 'unknown'}`;
+    case 'local-change-pushed':
+      return `Pushed: ${event.change?.requirementId || 'unknown'}`;
+    default:
+      return JSON.stringify(event).substring(0, 47);
+  }
+}
+
+module.exports = {
+  syncNow,
+  syncStatus,
+  viewQueue,
+  forceSync,
+  viewHistory
+};

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
+};