vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/utils/interactive/interactive-prompts.js

@@ -0,0 +1,480 @@
+const { t } = require('vibecodingmachine-core');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const boxen = require('boxen');
+const os = require('os');
+
+/**
+ * Show welcome screen with system information
+ */
+async function showWelcomeScreen() {
+  const repoPath = process.cwd(); // Always use current working directory
+  
+  // System information
+  const platform = os.platform();
+  const arch = os.arch();
+  const nodeVersion = process.version;
+  const hostname = os.hostname();
+  
+  // Package information
+  const pkg = require('../../package.json');
+  const version = pkg.version;
+  
+  // Check if in Vibe Coding Machine directory
+  const { checkVibeCodingMachineExists, requirementsExists, isComputerNameEnabled } = require('vibecodingmachine-core');
+  const isVCMDir = await checkVibeCodingMachineExists(repoPath);
+  const hasRequirements = await requirementsExists();
+  const computerNameEnabled = isComputerNameEnabled();
+  
+  console.clear();
+  
+  const welcomeText = chalk.bold.cyan(`
+╔══════════════════════════════════════════════════════════════╗
+║                    🚀 Vibe Coding Machine                      ║
+║                      Version ${version.padEnd(10)}                 ║
+╚══════════════════════════════════════════════════════════════╝
+
+${chalk.bold('📍 Current Directory:')} ${repoPath}
+${chalk.bold('🖥️  System:')} ${platform}-${arch} | Node ${nodeVersion} | Host: ${hostname}
+${chalk.bold('📁 VCM Directory:')} ${isVCMDir ? chalk.green('✅ Yes') : chalk.red('❌ No')}
+${chalk.bold('📋 Requirements:')} ${hasRequirements ? chalk.green('✅ Found') : chalk.yellow('⚠️  Not found')}
+${chalk.bold('🏷️  Computer Name:')} ${computerNameEnabled ? chalk.green('✅ Enabled') : chalk.yellow('⚠️  Disabled')}
+  `);
+
+  console.log(welcomeText);
+  
+  if (!isVCMDir) {
+    console.log(chalk.yellow('\n⚠️  You are not in a Vibe Coding Machine directory.'));
+    console.log(chalk.gray('   Some features may not be available.\n'));
+  }
+  
+  if (!hasRequirements && isVCMDir) {
+    console.log(chalk.yellow('\n⚠️  No requirements file found.'));
+    console.log(chalk.gray('   Run "vibe init" to create one.\n'));
+  }
+}
+
+/**
+ * Show main menu
+ */
+async function showMainMenu() {
+  const { checkAutoModeStatus } = require('../auto-mode');
+  const autoModeStatus = await checkAutoModeStatus();
+  
+  const choices = [
+    { name: '📋 Navigate Requirements', value: 'requirements' },
+    { name: '🔍 Search Requirements', value: 'search' },
+    { name: '📝 Add Requirement', value: 'add' },
+    { name: '📊 Show Statistics', value: 'stats' },
+    { name: '⚙️  Settings', value: 'settings' },
+    { name: '🔄 Sync Status', value: 'sync' },
+    { name: '🚪 Exit', value: 'exit' }
+  ];
+
+  // Add auto mode option if available
+  if (autoModeStatus.available) {
+    choices.splice(-2, 0, { 
+      name: autoModeStatus.running ? '⏹️  Stop Auto Mode' : '▶️  Start Auto Mode', 
+      value: 'auto-mode' 
+    });
+  }
+
+  const { choice } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'choice',
+      message: 'What would you like to do?',
+      choices,
+      pageSize: 10
+    }
+  ]);
+
+  return choice;
+}
+
+/**
+ * Show settings menu
+ */
+async function showSettingsMenu() {
+  const choices = [
+    { name: '🏷️  Computer Name Settings', value: 'computer-name' },
+    { name: '🌐 Language Settings', value: 'language' },
+    { name: '📊 Statistics Settings', value: 'statistics' },
+    { name: '🔄 Sync Settings', value: 'sync' },
+    { name: '⬅️  Back', value: 'back' }
+  ];
+
+  const { choice } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'choice',
+      message: 'Settings:',
+      choices
+    }
+  ]);
+
+  return choice;
+}
+
+/**
+ * Show computer name settings
+ */
+async function showComputerNameSettings() {
+  const { getHostname, setHostname, isComputerNameEnabled, enableComputerName, disableComputerName } = require('vibecodingmachine-core');
+  
+  const currentHostname = getHostname();
+  const isEnabled = isComputerNameEnabled();
+  
+  console.log(chalk.bold('\n🏷️  Computer Name Settings\n'));
+  console.log(chalk.gray(`Current hostname: ${currentHostname}`));
+  console.log(chalk.gray(`Computer name enabled: ${isEnabled ? 'Yes' : 'No'}\n`));
+
+  const choices = [
+    { name: '✏️  Change hostname', value: 'change-hostname' },
+    ...(isEnabled ? [{ name: '🔴 Disable computer name', value: 'disable' }] : [{ name: '🟢 Enable computer name', value: 'enable' }]),
+    { name: '⬅️  Back', value: 'back' }
+  ];
+
+  const { choice } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'choice',
+      message: 'What would you like to do?',
+      choices
+    }
+  ]);
+
+  switch (choice) {
+    case 'change-hostname':
+      await changeHostname();
+      break;
+    case 'enable':
+      await enableComputerName();
+      console.log(chalk.green('✅ Computer name enabled'));
+      break;
+    case 'disable':
+      await disableComputerName();
+      console.log(chalk.green('✅ Computer name disabled'));
+      break;
+  }
+}
+
+/**
+ * Change hostname
+ */
+async function changeHostname() {
+  const { getHostname, setHostname } = require('vibecodingmachine-core');
+  
+  const { newHostname } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'newHostname',
+      message: 'Enter new hostname:',
+      default: getHostname(),
+      validate: input => {
+        if (!input.trim()) return 'Hostname cannot be empty';
+        if (!/^[a-zA-Z0-9-]+$/.test(input.trim())) {
+          return 'Hostname can only contain letters, numbers, and hyphens';
+        }
+        return true;
+      }
+    }
+  ]);
+
+  try {
+    await setHostname(newHostname.trim());
+    console.log(chalk.green(`✅ Hostname changed to: ${newHostname}`));
+  } catch (error) {
+    console.error(chalk.red('❌ Error changing hostname:'), error.message);
+  }
+}
+
+/**
+ * Show statistics
+ */
+async function showStatistics() {
+  console.log(chalk.bold('\n📊 Project Statistics\n'));
+  
+  try {
+    const { countRequirements, getCurrentProgress } = require('./core-ui');
+    const stats = await countRequirements();
+    const progress = await getCurrentProgress();
+    
+    console.log(chalk.yellow('Requirements:'));
+    console.log(chalk.gray(`  • Todo: ${stats.todo} items`));
+    console.log(chalk.gray(`  • Completed: ${stats.completed} items`));
+    console.log(chalk.gray(`  • Total: ${stats.total} items`));
+    console.log(chalk.gray(`  • Progress: ${progress.progress}%`));
+    console.log(chalk.gray(`  • Current Stage: ${progress.stage}\n`));
+    
+    // Show file statistics
+    const fs = require('fs-extra');
+    const path = require('path');
+    
+    const countFiles = async (dir, pattern = /\.js$/) => {
+      let count = 0;
+      const items = await fs.readdir(dir);
+      
+      for (const item of items) {
+        const fullPath = path.join(dir, item);
+        const stat = await fs.stat(fullPath);
+        
+        if (stat.isDirectory() && !item.startsWith('.') && item !== 'node_modules') {
+          count += await countFiles(fullPath, pattern);
+        } else if (stat.isFile() && pattern.test(item)) {
+          count++;
+        }
+      }
+      
+      return count;
+    };
+    
+    const repoPath = process.cwd();
+    const jsFiles = await countFiles(repoPath);
+    const jsxFiles = await countFiles(repoPath, /\.jsx$/);
+    const mdFiles = await countFiles(repoPath, /\.md$/);
+    
+    console.log(chalk.yellow('Files:'));
+    console.log(chalk.gray(`  • JavaScript files: ${jsFiles}`));
+    console.log(chalk.gray(`  • JSX files: ${jsxFiles}`));
+    console.log(chalk.gray(`  • Markdown files: ${mdFiles}\n`));
+    
+  } catch (error) {
+    console.error(chalk.red('❌ Error getting statistics:'), error.message);
+  }
+}
+
+/**
+ * Show sync status
+ */
+async function showSyncStatus() {
+  console.log(chalk.bold('\n🔄 Sync Status\n'));
+  
+  try {
+    const { getSyncStatus } = require('./core-ui');
+    const status = await getSyncStatus();
+    
+    console.log(chalk.yellow('Sync Status:'));
+    console.log(chalk.gray(`  • Status: ${status.status}`));
+    if (status.message) {
+      console.log(chalk.gray(`  • Message: ${status.message}`));
+    }
+    
+    if (status.lastSync) {
+      console.log(chalk.gray(`  • Last sync: ${new Date(status.lastSync).toLocaleString()}`));
+    }
+    
+    console.log();
+    
+  } catch (error) {
+    console.error(chalk.red('❌ Error getting sync status:'), error.message);
+  }
+}
+
+/**
+ * Search requirements
+ */
+async function searchRequirements() {
+  const { getRequirementsPath } = require('vibecodingmachine-core');
+  const fs = require('fs-extra');
+  
+  try {
+    const { query } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'query',
+        message: 'Search for:',
+        validate: input => input.trim().length > 0 || 'Search query cannot be empty'
+      }
+    ]);
+
+    const reqPath = await getRequirementsPath();
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+    
+    const searchTerm = query.toLowerCase();
+    const matches = [];
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.startsWith('- ') && line.toLowerCase().includes(searchTerm)) {
+        matches.push({
+          line: i + 1,
+          content: line.substring(2) // Remove "- " prefix
+        });
+      }
+    }
+    
+    console.log(chalk.bold(`\n🔍 Search Results for "${query}"\n`));
+    
+    if (matches.length === 0) {
+      console.log(chalk.gray('No matches found.\n'));
+    } else {
+      console.log(chalk.yellow(`Found ${matches.length} match(es):\n`));
+      
+      matches.forEach((match, index) => {
+        console.log(chalk.cyan(`${index + 1}. Line ${match.line}:`));
+        console.log(chalk.gray(`   ${match.content}\n`));
+      });
+    }
+    
+  } catch (error) {
+    console.error(chalk.red('❌ Error searching requirements:'), error.message);
+  }
+}
+
+/**
+ * Show confirmation dialog
+ */
+async function showConfirmDialog(message, defaultValue = false) {
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message,
+      default: defaultValue
+    }
+  ]);
+  
+  return confirmed;
+}
+
+/**
+ * Show input dialog
+ */
+async function showInputDialog(message, defaultValue = '', validate = null) {
+  const { input } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'input',
+      message,
+      default: defaultValue,
+      validate: validate || ((input) => input.trim().length > 0 || 'Input cannot be empty')
+    }
+  ]);
+  
+  return input;
+}
+
+/**
+ * Show select dialog
+ */
+async function showSelectDialog(message, choices, pageSize = 10) {
+  const { choice } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'choice',
+      message,
+      choices,
+      pageSize
+    }
+  ]);
+  
+  return choice;
+}
+
+/**
+ * Show multi-select dialog
+ */
+async function showMultiSelectDialog(message, choices, pageSize = 10) {
+  const { selected } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selected',
+      message,
+      choices,
+      pageSize
+    }
+  ]);
+  
+  return selected;
+}
+
+/**
+ * Show error message
+ */
+function showError(message, error = null) {
+  const errorMessage = error ? `${message}\n\n${chalk.red(error.message || error)}` : message;
+  
+  console.log(
+    boxen(
+      chalk.red(errorMessage),
+      {
+        padding: 1,
+        borderStyle: 'double',
+        borderColor: 'red',
+        align: 'center'
+      }
+    )
+  );
+}
+
+/**
+ * Show success message
+ */
+function showSuccess(message) {
+  console.log(
+    boxen(
+      chalk.green(message),
+      {
+        padding: 1,
+        borderStyle: 'double',
+        borderColor: 'green',
+        align: 'center'
+      }
+    )
+  );
+}
+
+/**
+ * Show warning message
+ */
+function showWarning(message) {
+  console.log(
+    boxen(
+      chalk.yellow(message),
+      {
+        padding: 1,
+        borderStyle: 'double',
+        borderColor: 'yellow',
+        align: 'center'
+      }
+    )
+  );
+}
+
+/**
+ * Show info message
+ */
+function showInfo(message) {
+  console.log(
+    boxen(
+      chalk.blue(message),
+      {
+        padding: 1,
+        borderStyle: 'double',
+        borderColor: 'blue',
+        align: 'center'
+      }
+    )
+  );
+}
+
+module.exports = {
+  showWelcomeScreen,
+  showMainMenu,
+  showSettingsMenu,
+  showComputerNameSettings,
+  showStatistics,
+  showSyncStatus,
+  searchRequirements,
+  showConfirmDialog,
+  showInputDialog,
+  showSelectDialog,
+  showMultiSelectDialog,
+  showError,
+  showSuccess,
+  showWarning,
+  showInfo,
+  changeHostname
+};

package/src/utils/interactive/requirement-actions.js

@@ -0,0 +1,127 @@
+/**
+ * Requirement Actions - Orchestrates requirement operations
+ * 
+ * This module coordinates between CRUD operations and clarification actions.
+ * It serves as the main entry point for requirement-related actions.
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+// Import split modules
+const {
+  renameRequirement,
+  deleteRequirement,
+  permanentlyDeleteRequirement,
+  moveRequirementDown,
+  moveRequirementUp,
+  promoteRequirement,
+  demoteRequirement,
+  restoreRequirement,
+  moveRequirementToClarification,
+  confirmAction,
+  getSectionTitle,
+  getRequirementList
+} = require('./requirement-crud');
+
+const {
+  editClarificationResponses,
+  moveClarificationToTodo,
+  deleteClarification,
+  showClarificationActions,
+  confirmAndExit,
+  moveRequirementToRecycled
+} = require('./clarification-actions');
+
+// Helper to perform action on requirement
+async function performRequirementAction(action, req, sectionKey, tree) {
+  const reqList = getRequirementList(tree, sectionKey);
+  const sectionTitle = getSectionTitle(sectionKey);
+  const reqIndex = reqList.findIndex(r => r.title === req.title);
+
+  if (reqIndex === -1) {
+    console.error(chalk.red('❌ Requirement not found'));
+    return;
+  }
+
+  switch (action) {
+    case 'rename':
+      await renameRequirement(req, sectionKey, tree);
+      break;
+    case 'thumbs-up':
+      await promoteRequirement(req, sectionKey, tree, loadSection, loadVerified);
+      break;
+    case 'needs-clarification':
+      await moveRequirementToClarification(req, sectionKey, tree);
+      break;
+    case 'delete':
+      await deleteRequirement(req, sectionKey, tree);
+      break;
+    case 'move-up':
+      await moveRequirementUp(req, sectionKey, tree);
+      break;
+    case 'move-down':
+      await moveRequirementDown(req, sectionKey, tree);
+      break;
+    case 'move-to-todo':
+      if (sectionKey === 'verify') {
+        await demoteRequirement(req.title, sectionKey, tree, loadSection, loadVerified);
+      } else if (sectionKey === 'clarification') {
+        await moveClarificationToTodo(req, tree);
+      }
+      break;
+    case 'restore':
+      await restoreRequirement(req, sectionKey, tree);
+      break;
+    case 'permanent-delete':
+      await permanentlyDeleteRequirement(req, sectionKey, tree);
+      break;
+  }
+
+  await new Promise(resolve => setTimeout(resolve, 1000));
+}
+
+// Helper functions for loading sections (placeholders for now)
+async function loadSection() {
+  // TODO: Implement section loading
+  return [];
+}
+
+async function loadVerified() {
+  // TODO: Implement verified loading
+  return [];
+}
+
+// Re-export all functions for backward compatibility
+module.exports = {
+  // Main orchestrator
+  performRequirementAction,
+  
+  // CRUD operations
+  renameRequirement,
+  deleteRequirement,
+  permanentlyDeleteRequirement,
+  moveRequirementDown,
+  moveRequirementUp,
+  promoteRequirement,
+  demoteRequirement,
+  restoreRequirement,
+  moveRequirementToClarification,
+  
+  // Clarification actions
+  editClarificationResponses,
+  moveClarificationToTodo,
+  deleteClarification,
+  showClarificationActions,
+  
+  // Utilities
+  confirmAction,
+  confirmAndExit,
+  getSectionTitle,
+  getRequirementList,
+  moveRequirementToRecycled,
+  
+  // Loaders (placeholders)
+  loadSection,
+  loadVerified
+};