vibecodingmachine-cli 2025.12.1-534 → 2025.12.6-1702

package/src/commands/computers.js

@@ -0,0 +1,306 @@
+const chalk = require('chalk');
+const Table = require('cli-table3');
+const SyncEngine = require('vibecodingmachine-core/src/sync/sync-engine');
+
+/**
+ * Display all registered computers with their status
+ */
+async function listComputers(options = {}) {
+  const syncEngine = new SyncEngine();
+  
+  try {
+    await syncEngine.initialize();
+    
+    // Fetch all computers from DynamoDB
+    const computers = await fetchAllComputers(syncEngine);
+    
+    if (computers.length === 0) {
+      console.log(chalk.yellow('\nNo computers registered yet.\n'));
+      console.log(chalk.gray('Computers will appear here once they sync for the first time.\n'));
+      return;
+    }
+    
+    // Filter by focus area if specified
+    let filteredComputers = computers;
+    if (options.focus) {
+      filteredComputers = computers.filter(c => 
+        c.focusArea && c.focusArea.toLowerCase().includes(options.focus.toLowerCase())
+      );
+    }
+    
+    // Filter by status if specified
+    if (options.status) {
+      filteredComputers = filteredComputers.filter(c => 
+        c.status && c.status.toLowerCase() === options.status.toLowerCase()
+      );
+    }
+    
+    // Create table
+    const table = new Table({
+      head: [
+        chalk.cyan('Computer'),
+        chalk.cyan('Focus Area'),
+        chalk.cyan('Status'),
+        chalk.cyan('Current Requirement'),
+        chalk.cyan('Progress'),
+        chalk.cyan('Last Sync')
+      ],
+      colWidths: [25, 30, 12, 35, 10, 15]
+    });
+    
+    // Add rows
+    for (const computer of filteredComputers) {
+      const statusIcon = getStatusIcon(computer.status);
+      const statusText = `${statusIcon} ${computer.status || 'unknown'}`;
+      const progress = computer.progress ? `${computer.progress}%` : '-';
+      const lastSync = computer.lastSyncTime 
+        ? formatTimeSince(computer.lastSyncTime)
+        : 'never';
+      
+      table.push([
+        computer.hostname || computer.computerId,
+        computer.focusArea || '-',
+        statusText,
+        truncate(computer.currentRequirement || '-', 33),
+        progress,
+        lastSync
+      ]);
+    }
+    
+    console.log('\n' + table.toString() + '\n');
+    
+    // Show summary
+    const activeCount = computers.filter(c => c.status === 'active').length;
+    const idleCount = computers.filter(c => c.status === 'idle').length;
+    const errorCount = computers.filter(c => c.status === 'error').length;
+    
+    console.log(chalk.gray(`Total: ${computers.length} computers`));
+    console.log(chalk.green(`  Active: ${activeCount}`));
+    console.log(chalk.yellow(`  Idle: ${idleCount}`));
+    if (errorCount > 0) {
+      console.log(chalk.red(`  Error: ${errorCount}`));
+    }
+    console.log('');
+    
+  } catch (error) {
+    console.error(chalk.red('\n✗ Failed to fetch computers:'), error.message);
+    throw error;
+  } finally {
+    syncEngine.stop();
+  }
+}
+
+/**
+ * Show detailed status of a specific computer
+ */
+async function showComputerStatus(computerId, options = {}) {
+  const syncEngine = new SyncEngine();
+  
+  try {
+    await syncEngine.initialize();
+    
+    const computer = await fetchComputer(syncEngine, computerId);
+    
+    if (!computer) {
+      console.log(chalk.red(`\n✗ Computer '${computerId}' not found.\n`));
+      return;
+    }
+    
+    // Display computer details
+    console.log('\n' + chalk.bold.cyan('Computer Details'));
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.white('Hostname:        ') + (computer.hostname || computer.computerId));
+    console.log(chalk.white('Computer ID:     ') + computer.computerId);
+    console.log(chalk.white('Focus Area:      ') + (computer.focusArea || '-'));
+    console.log(chalk.white('OS:              ') + (computer.os || '-'));
+    console.log(chalk.white('Status:          ') + getStatusIcon(computer.status) + ' ' + (computer.status || 'unknown'));
+    console.log(chalk.white('Last Sync:       ') + (computer.lastSyncTime ? formatTimeSince(computer.lastSyncTime) : 'never'));
+    console.log('');
+    
+    // Current work
+    console.log(chalk.bold.cyan('Current Work'));
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.white('Requirement:     ') + (computer.currentRequirement || 'None'));
+    console.log(chalk.white('Progress:        ') + (computer.progress ? `${computer.progress}%` : '-'));
+    console.log(chalk.white('Time Active:     ') + (computer.timeActive || '-'));
+    console.log(chalk.white('IDE:             ') + (computer.ide || '-'));
+    console.log('');
+    
+    // Statistics
+    if (computer.stats) {
+      console.log(chalk.bold.cyan('Statistics'));
+      console.log(chalk.gray('─'.repeat(60)));
+      console.log(chalk.white('Total Requirements:  ') + (computer.stats.total || 0));
+      console.log(chalk.white('Completed:           ') + chalk.green(computer.stats.completed || 0));
+      console.log(chalk.white('In Progress:         ') + chalk.yellow(computer.stats.inProgress || 0));
+      console.log(chalk.white('To Verify:           ') + chalk.blue(computer.stats.toVerify || 0));
+      console.log(chalk.white('Completion Rate:     ') + (computer.stats.completionRate || '0%'));
+      console.log('');
+    }
+    
+  } catch (error) {
+    console.error(chalk.red('\n✗ Failed to fetch computer status:'), error.message);
+    throw error;
+  } finally {
+    syncEngine.stop();
+  }
+}
+
+/**
+ * Register current computer with focus area
+ */
+async function registerComputer(focusArea, options = {}) {
+  const syncEngine = new SyncEngine();
+  
+  try {
+    await syncEngine.initialize();
+    
+    const os = require('os');
+    const computerData = {
+      computerId: syncEngine.computerId,
+      hostname: os.hostname(),
+      focusArea: focusArea,
+      os: `${os.platform()} ${os.release()}`,
+      registeredAt: Date.now(),
+      lastSyncTime: Date.now(),
+      status: 'idle'
+    };
+    
+    await saveComputer(syncEngine, computerData);
+    
+    console.log(chalk.green('\n✓ Computer registered successfully!\n'));
+    console.log(chalk.white('Computer ID:  ') + computerData.computerId);
+    console.log(chalk.white('Hostname:     ') + computerData.hostname);
+    console.log(chalk.white('Focus Area:   ') + computerData.focusArea);
+    console.log('');
+    
+  } catch (error) {
+    console.error(chalk.red('\n✗ Failed to register computer:'), error.message);
+    throw error;
+  } finally {
+    syncEngine.stop();
+  }
+}
+
+/**
+ * Update focus area for current computer
+ */
+async function updateFocus(newFocusArea, options = {}) {
+  const syncEngine = new SyncEngine();
+  
+  try {
+    await syncEngine.initialize();
+    
+    const computer = await fetchComputer(syncEngine, syncEngine.computerId);
+    
+    if (!computer) {
+      console.log(chalk.yellow('\n⚠ Computer not registered. Registering now...\n'));
+      await registerComputer(newFocusArea, options);
+      return;
+    }
+    
+    computer.focusArea = newFocusArea;
+    computer.lastSyncTime = Date.now();
+    
+    await saveComputer(syncEngine, computer);
+    
+    console.log(chalk.green('\n✓ Focus area updated!\n'));
+    console.log(chalk.white('Computer:     ') + computer.hostname);
+    console.log(chalk.white('New Focus:    ') + newFocusArea);
+    console.log('');
+    
+  } catch (error) {
+    console.error(chalk.red('\n✗ Failed to update focus area:'), error.message);
+    throw error;
+  } finally {
+    syncEngine.stop();
+  }
+}
+
+// Helper functions
+
+function getStatusIcon(status) {
+  switch (status) {
+    case 'active': return chalk.green('●');
+    case 'idle': return chalk.yellow('●');
+    case 'error': return chalk.red('●');
+    case 'offline': return chalk.gray('●');
+    default: return chalk.gray('○');
+  }
+}
+
+function formatTimeSince(timestamp) {
+  const now = Date.now();
+  const diff = now - timestamp;
+  
+  const seconds = Math.floor(diff / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (minutes > 0) return `${minutes}m ago`;
+  return `${seconds}s ago`;
+}
+
+function truncate(str, maxLength) {
+  if (str.length <= maxLength) return str;
+  return str.substring(0, maxLength - 3) + '...';
+}
+
+async function fetchAllComputers(syncEngine) {
+  const { ScanCommand } = require('@aws-sdk/lib-dynamodb');
+  
+  const tableName = 'vibecodingmachine-computers';
+  
+  try {
+    const command = new ScanCommand({
+      TableName: tableName
+    });
+    
+    const response = await syncEngine.dynamoClient.send(command);
+    return response.Items || [];
+  } catch (error) {
+    // Table might not exist yet
+    return [];
+  }
+}
+
+async function fetchComputer(syncEngine, computerId) {
+  const { GetCommand } = require('@aws-sdk/lib-dynamodb');
+  
+  const tableName = 'vibecodingmachine-computers';
+  
+  try {
+    const command = new GetCommand({
+      TableName: tableName,
+      Key: { computerId }
+    });
+    
+    const response = await syncEngine.dynamoClient.send(command);
+    return response.Item;
+  } catch (error) {
+    return null;
+  }
+}
+
+async function saveComputer(syncEngine, computerData) {
+  const { PutCommand } = require('@aws-sdk/lib-dynamodb');
+  
+  const tableName = 'vibecodingmachine-computers';
+  
+  const command = new PutCommand({
+    TableName: tableName,
+    Item: computerData
+  });
+  
+  await syncEngine.dynamoClient.send(command);
+}
+
+module.exports = {
+  listComputers,
+  showComputerStatus,
+  registerComputer,
+  updateFocus
+};

package/src/commands/requirements-remote.js

@@ -0,0 +1,304 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const inquirer = require('inquirer');
+
+/**
+ * List requirements for a specific computer
+ */
+async function listRemoteRequirements(computerId, options = {}) {
+  try {
+    const repoPath = process.cwd();
+    const reqFilename = `REQUIREMENTS-${computerId}.md`;
+    const reqPath = path.join(repoPath, '.vibecodingmachine', reqFilename);
+    
+    if (!await fs.pathExists(reqPath)) {
+      console.log(chalk.yellow(`\n⚠ Requirements file not found for ${computerId}\n`));
+      console.log(chalk.gray(`Expected: ${reqPath}\n`));
+      return;
+    }
+    
+    const content = await fs.readFile(reqPath, 'utf8');
+    const sections = parseRequirements(content);
+    
+    console.log(chalk.bold.cyan(`\n📋 Requirements for ${computerId}\n`));
+    
+    // Show counts
+    console.log(chalk.white('Summary:'));
+    console.log(chalk.yellow(`  TODO: ${sections.todo.length}`));
+    console.log(chalk.cyan(`  TO VERIFY: ${sections.toVerify.length}`));
+    console.log(chalk.green(`  VERIFIED: ${sections.verified.length}`));
+    console.log('');
+    
+    // Show TODO requirements
+    if (sections.todo.length > 0) {
+      console.log(chalk.bold.yellow('⏳ TODO Requirements:\n'));
+      sections.todo.forEach((req, idx) => {
+        console.log(chalk.yellow(`${idx + 1}. `) + req.title);
+        if (req.description) {
+          console.log(chalk.gray('   ' + req.description.substring(0, 100) + '...'));
+        }
+      });
+      console.log('');
+    }
+    
+    // Show TO VERIFY requirements
+    if (sections.toVerify.length > 0) {
+      console.log(chalk.bold.cyan('🔍 TO VERIFY Requirements:\n'));
+      sections.toVerify.forEach((req, idx) => {
+        console.log(chalk.cyan(`${idx + 1}. `) + req.title);
+      });
+      console.log('');
+    }
+    
+  } catch (error) {
+    console.error(chalk.red('\n✗ Failed to list requirements:'), error.message);
+    throw error;
+  }
+}
+
+/**
+ * Add a requirement to another computer's requirements file
+ */
+async function addRemoteRequirement(computerId, requirementText, options = {}) {
+  try {
+    const repoPath = process.cwd();
+    const reqFilename = `REQUIREMENTS-${computerId}.md`;
+    const reqPath = path.join(repoPath, '.vibecodingmachine', reqFilename);
+    
+    if (!await fs.pathExists(reqPath)) {
+      console.log(chalk.yellow(`\n⚠ Requirements file not found for ${computerId}\n`));
+      console.log(chalk.gray('Creating new requirements file...\n'));
+      
+      // Create basic requirements file structure
+      const template = `# 🤖 Vibe Coding Machine – Requirements File
+
+## 💻 Computer Information
+- **Hostname**: ${computerId}
+- **Type**: Unknown
+- **OS**: Unknown
+
+## 🎯 Focus
+**General Development**
+
+---
+
+## RESPONSE FROM LAST CHAT
+
+
+## 🚦 Current Status
+DONE
+
+## ⏳ Requirements not yet completed
+
+## 🔍 TO VERIFY BY HUMAN
+
+## 📝 VERIFIED
+
+## ❓ Requirements needing manual feedback
+
+## REJECTED by Human
+
+## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG
+
+## ♻️ Recycled
+
+## CHANGELOG
+`;
+      await fs.writeFile(reqPath, template, 'utf8');
+    }
+    
+    // Read current content
+    let content = await fs.readFile(reqPath, 'utf8');
+    
+    // Find the TODO section
+    const todoMarker = '## ⏳ Requirements not yet completed';
+    const todoIndex = content.indexOf(todoMarker);
+    
+    if (todoIndex === -1) {
+      console.log(chalk.red('\n✗ Could not find TODO section in requirements file\n'));
+      return;
+    }
+    
+    // Find the next section after TODO
+    const nextSectionIndex = content.indexOf('\n## ', todoIndex + todoMarker.length);
+    
+    // Insert the new requirement
+    const newRequirement = `\n### ${requirementText}\n`;
+    
+    if (nextSectionIndex === -1) {
+      // No next section, append at end
+      content = content.substring(0, todoIndex + todoMarker.length) + newRequirement + content.substring(todoIndex + todoMarker.length);
+    } else {
+      // Insert before next section
+      content = content.substring(0, nextSectionIndex) + newRequirement + content.substring(nextSectionIndex);
+    }
+    
+    // Write back
+    await fs.writeFile(reqPath, content, 'utf8');
+    
+    console.log(chalk.green(`\n✓ Added requirement to ${computerId}\n`));
+    console.log(chalk.white('Requirement: ') + requirementText);
+    console.log('');
+    
+  } catch (error) {
+    console.error(chalk.red('\n✗ Failed to add requirement:'), error.message);
+    throw error;
+  }
+}
+
+/**
+ * Interactive menu for managing another computer's requirements
+ */
+async function manageRemoteRequirements(computerId) {
+  const choices = [
+    { name: '📋 View Requirements', value: 'view' },
+    { name: '➕ Add Requirement', value: 'add' },
+    { name: '📝 Edit Requirements File', value: 'edit' },
+    { name: chalk.gray('← Back'), value: 'back' }
+  ];
+  
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: `Manage requirements for ${computerId}:`,
+      choices: choices
+    }
+  ]);
+  
+  switch (action) {
+    case 'view':
+      await listRemoteRequirements(computerId);
+      console.log(chalk.gray('Press Enter to continue...'));
+      await new Promise(resolve => {
+        const readline = require('readline');
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+        rl.question('', () => {
+          rl.close();
+          resolve();
+        });
+      });
+      await manageRemoteRequirements(computerId);
+      break;
+      
+    case 'add':
+      const { requirement } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'requirement',
+          message: 'Enter requirement title:'
+        }
+      ]);
+      
+      if (requirement) {
+        await addRemoteRequirement(computerId, requirement);
+        console.log(chalk.gray('Press Enter to continue...'));
+        await new Promise(resolve => {
+          const readline = require('readline');
+          const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+          });
+          rl.question('', () => {
+            rl.close();
+            resolve();
+          });
+        });
+      }
+      await manageRemoteRequirements(computerId);
+      break;
+      
+    case 'edit':
+      const repoPath = process.cwd();
+      const reqFilename = `REQUIREMENTS-${computerId}.md`;
+      const reqPath = path.join(repoPath, '.vibecodingmachine', reqFilename);
+      
+      if (await fs.pathExists(reqPath)) {
+        const { spawn } = require('child_process');
+        const editor = process.env.EDITOR || 'nano';
+        
+        console.log(chalk.cyan(`\nOpening ${reqFilename} in ${editor}...\n`));
+        
+        const child = spawn(editor, [reqPath], {
+          stdio: 'inherit'
+        });
+        
+        await new Promise((resolve) => {
+          child.on('exit', resolve);
+        });
+        
+        console.log(chalk.green('\n✓ File saved\n'));
+      } else {
+        console.log(chalk.yellow(`\n⚠ Requirements file not found\n`));
+      }
+      await manageRemoteRequirements(computerId);
+      break;
+      
+    case 'back':
+      break;
+  }
+}
+
+/**
+ * Parse requirements from markdown content
+ */
+function parseRequirements(content) {
+  const sections = {
+    todo: [],
+    toVerify: [],
+    verified: []
+  };
+  
+  const lines = content.split('\n');
+  let currentSection = null;
+  let currentRequirement = null;
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    
+    // Detect sections
+    if (line.includes('## ⏳ Requirements not yet completed')) {
+      currentSection = 'todo';
+      continue;
+    } else if (line.includes('## 🔍 TO VERIFY')) {
+      currentSection = 'toVerify';
+      continue;
+    } else if (line.includes('## 📝 VERIFIED')) {
+      currentSection = 'verified';
+      continue;
+    } else if (line.startsWith('## ') && !line.startsWith('###')) {
+      currentSection = null;
+      continue;
+    }
+    
+    // Parse requirements
+    if (currentSection && line.startsWith('### ')) {
+      if (currentRequirement) {
+        sections[currentSection].push(currentRequirement);
+      }
+      currentRequirement = {
+        title: line.replace(/^###\s*/, '').trim(),
+        description: ''
+      };
+    } else if (currentRequirement && line.trim() && !line.startsWith('#')) {
+      currentRequirement.description += line + '\n';
+    }
+  }
+  
+  // Add last requirement
+  if (currentRequirement && currentSection) {
+    sections[currentSection].push(currentRequirement);
+  }
+  
+  return sections;
+}
+
+module.exports = {
+  listRemoteRequirements,
+  addRemoteRequirement,
+  manageRemoteRequirements
+};