vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

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

@@ -0,0 +1,356 @@
+const { t, getRequirementsPath, promoteTodoToVerify, promoteToVerified, demoteVerifyToTodo, demoteFromVerifiedToTodo } = require('vibecodingmachine-core');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const fs = require('fs-extra');
+
+// Helper to get section title from section key
+function getSectionTitle(sectionKey) {
+  if (sectionKey === 'todo') return '⏳ Requirements not yet completed';
+  if (sectionKey === 'verify') return '✅ Verified by AI screenshot';
+  if (sectionKey === 'recycled') return '♻️ Recycled';
+  if (sectionKey === 'clarification') return '❓ Needs clarification';
+  return '';
+}
+
+// Helper to get requirement list from tree by section key
+function getRequirementList(tree, sectionKey) {
+  if (sectionKey === 'todo') return tree.todoReqs;
+  if (sectionKey === 'verify') return tree.verifyReqs;
+  if (sectionKey === 'clarification') return tree.clarificationReqs;
+  if (sectionKey === 'recycled') return tree.recycledReqs;
+  return [];
+}
+
+// Helper to rename requirement (title and description)
+async function renameRequirement(req, sectionKey, tree) {
+  const { newTitle, newDescription } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'newTitle',
+      message: 'Enter new title:',
+      default: req.title,
+      validate: input => input.trim().length > 0 || 'Title cannot be empty'
+    },
+    {
+      type: 'input',
+      name: 'newDescription',
+      message: 'Enter new description:',
+      default: req.content
+    }
+  ]);
+
+  const reqPath = await getRequirementsPath();
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find and replace the requirement
+  const reqIndex = lines.findIndex(line => line.includes(req.title));
+  if (reqIndex !== -1) {
+    lines[reqIndex] = `- ${newTitle}. ${newDescription}`;
+    await fs.writeFile(reqPath, lines.join('\n'));
+    console.log(chalk.green('✅ Requirement renamed'));
+  }
+}
+
+// Helper to move requirement to recycled section (used to delete)
+async function deleteRequirement(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;
+  }
+
+  const confirmed = await confirmAction('Delete this requirement? (r/y/N):');
+  if (!confirmed) return;
+
+  const reqPath = await getRequirementsPath();
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find the requirement line
+  const lineIndex = lines.findIndex(line => line.includes(req.title));
+  if (lineIndex !== -1) {
+    // Remove the requirement
+    const requirementLine = lines[lineIndex];
+    lines.splice(lineIndex, 1);
+
+    // Add to recycled section
+    await moveRequirementToRecycled(reqPath, req.title, sectionKey, [requirementLine]);
+
+    await fs.writeFile(reqPath, lines.join('\n'));
+    console.log(chalk.green('✅ Requirement deleted'));
+  }
+}
+
+// Helper to permanently delete requirement from file (used for recycled items)
+async function permanentlyDeleteRequirement(req, sectionKey, tree) {
+  const reqList = getRequirementList(tree, sectionKey);
+  const reqIndex = reqList.findIndex(r => r.title === req.title);
+
+  if (reqIndex === -1) {
+    console.error(chalk.red('❌ Requirement not found'));
+    return;
+  }
+
+  const confirmed = await confirmAction('Permanently delete this requirement? (r/y/N):');
+  if (!confirmed) return;
+
+  const reqPath = await getRequirementsPath();
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find and remove the requirement
+  const lineIndex = lines.findIndex(line => line.includes(req.title));
+  if (lineIndex !== -1) {
+    lines.splice(lineIndex, 1);
+    await fs.writeFile(reqPath, lines.join('\n'));
+    console.log(chalk.green('✅ Requirement permanently deleted'));
+  }
+}
+
+// Helper to move requirement to recycled section
+async function moveRequirementToRecycled(reqPath, requirementTitle, fromSection, requirementLines = null) {
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find recycled section
+  const recycledIndex = lines.findIndex(line => line.includes('♻️ Recycled'));
+  if (recycledIndex === -1) {
+    // Create recycled section
+    lines.push('## ♻️ Recycled');
+    lines.push('');
+    lines.push(`- ${requirementTitle}`);
+  } else {
+    // Add to existing recycled section
+    let insertIndex = recycledIndex + 1;
+    while (insertIndex < lines.length && lines[insertIndex].trim() === '') {
+      insertIndex++;
+    }
+    
+    if (requirementLines) {
+      lines.splice(insertIndex, 0, ...requirementLines);
+    } else {
+      lines.splice(insertIndex, 0, `- ${requirementTitle}`);
+    }
+  }
+
+  await fs.writeFile(reqPath, lines.join('\n'));
+}
+
+// Helper to move requirement down with 'j' key
+async function moveRequirementDown(req, sectionKey, tree) {
+  const reqList = getRequirementList(tree, sectionKey);
+  const sectionTitle = getSectionTitle(sectionKey);
+  const reqIndex = reqList.findIndex(r => r.title === req.title);
+
+  if (reqIndex === -1 || reqIndex === reqList.length - 1) {
+    return; // Can't move down if already at bottom
+  }
+
+  // Swap with next item
+  [reqList[reqIndex], reqList[reqIndex + 1]] = [reqList[reqIndex + 1], reqList[reqIndex]];
+
+  const reqPath = await getRequirementsPath();
+  await saveRequirementsOrder(reqPath, sectionTitle, reqList);
+  console.log(chalk.green('✅ Requirement moved down'));
+}
+
+// Helper to move requirement up with 'k' key
+async function moveRequirementUp(req, sectionKey, tree) {
+  const reqList = getRequirementList(tree, sectionKey);
+  const sectionTitle = getSectionTitle(sectionKey);
+  const reqIndex = reqList.findIndex(r => r.title === req.title);
+
+  if (reqIndex <= 0) {
+    return; // Can't move up if already at top
+  }
+
+  // Swap with previous item
+  [reqList[reqIndex], reqList[reqIndex - 1]] = [reqList[reqIndex - 1], reqList[reqIndex]];
+
+  const reqPath = await getRequirementsPath();
+  await saveRequirementsOrder(reqPath, sectionTitle, reqList);
+  console.log(chalk.green('✅ Requirement moved up'));
+}
+
+// Helper to promote requirement to next list (TODO -> TO VERIFY -> VERIFIED)
+async function promoteRequirement(req, sectionKey, tree, loadSection, loadVerified) {
+  const reqPath = await getRequirementsPath();
+  
+  if (sectionKey === 'todo') {
+    await promoteTodoToVerify(reqPath, req.title);
+    console.log(chalk.green('✅ Requirement promoted to verification'));
+  } else if (sectionKey === 'verify') {
+    await promoteToVerified(reqPath, req.title);
+    console.log(chalk.green('✅ Requirement promoted to verified'));
+  }
+}
+
+// Helper to demote requirement to previous list (VERIFIED -> TODO, TO VERIFY -> TODO)
+async function demoteRequirement(reqTitle, sectionKey, tree, loadSection, loadVerified) {
+  const reqPath = await getRequirementsPath();
+  
+  if (sectionKey === 'verify') {
+    await demoteVerifyToTodo(reqPath, reqTitle);
+    console.log(chalk.green('✅ Requirement demoted to TODO'));
+  } else if (sectionKey === 'verified') {
+    await demoteFromVerifiedToTodo(reqPath, reqTitle);
+    console.log(chalk.green('✅ Requirement demoted to TODO'));
+  }
+}
+
+// Helper to restore requirement from recycled to TODO
+async function restoreRequirement(req, sectionKey, tree) {
+  const reqPath = await getRequirementsPath();
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find requirement in recycled section
+  const reqIndex = lines.findIndex(line => line.includes(req.title));
+  if (reqIndex === -1) {
+    console.error(chalk.red('❌ Requirement not found'));
+    return;
+  }
+
+  // Remove from recycled
+  const requirementLine = lines[reqIndex];
+  lines.splice(reqIndex, 1);
+
+  // Add to TODO section
+  const todoIndex = lines.findIndex(line => line.includes('Requirements not yet completed'));
+  if (todoIndex !== -1) {
+    let insertIndex = todoIndex + 1;
+    while (insertIndex < lines.length && lines[insertIndex].trim() === '') {
+      insertIndex++;
+    }
+    lines.splice(insertIndex, 0, requirementLine);
+  }
+
+  await fs.writeFile(reqPath, lines.join('\n'));
+  console.log(chalk.green('✅ Requirement restored to TODO'));
+}
+
+// Helper to move requirement to clarification section
+async function moveRequirementToClarification(req, sectionKey, tree) {
+  const reqPath = await getRequirementsPath();
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find requirement
+  const reqIndex = lines.findIndex(line => line.includes(req.title));
+  if (reqIndex === -1) {
+    console.error(chalk.red('❌ Requirement not found'));
+    return;
+  }
+
+  // Remove from current section
+  const requirementLine = lines[reqIndex];
+  lines.splice(reqIndex, 1);
+
+  // Add to clarification section
+  const clarificationIndex = lines.findIndex(line => line.includes('Needs clarification'));
+  if (clarificationIndex !== -1) {
+    let insertIndex = clarificationIndex + 1;
+    while (insertIndex < lines.length && lines[insertIndex].trim() === '') {
+      insertIndex++;
+    }
+    lines.splice(insertIndex, 0, requirementLine);
+  }
+
+  await fs.writeFile(reqPath, lines.join('\n'));
+  console.log(chalk.green('✅ Requirement moved to clarification'));
+}
+
+// Helper to save reordered requirements back to file
+async function saveRequirementsOrder(reqPath, sectionTitle, requirements) {
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find section start
+  const sectionIndex = lines.findIndex(line => line.includes(sectionTitle));
+  if (sectionIndex === -1) {
+    console.error(chalk.red('❌ Section not found'));
+    return;
+  }
+
+  // Find section end (next section or end of file)
+  let sectionEnd = sectionIndex + 1;
+  while (sectionEnd < lines.length && !lines[sectionEnd].startsWith('##')) {
+    sectionEnd++;
+  }
+
+  // Build new section content
+  const newLines = lines.slice(0, sectionIndex + 1);
+  newLines.push(''); // Empty line after header
+  
+  // Add requirements in new order
+  requirements.forEach(req => {
+    if (typeof req === 'string') {
+      newLines.push(req);
+    } else {
+      newLines.push(`- ${req.title}`);
+    }
+  });
+
+  // Add remaining lines
+  const remainingLines = lines.slice(sectionEnd);
+  newLines.push(...remainingLines);
+
+  await fs.writeFile(reqPath, newLines.join('\n'));
+}
+
+// Helper to show confirmation prompt (r/y for yes, N for no, default N)
+async function confirmAction(message) {
+  console.log();
+  process.stdout.write(chalk.yellow(`${message} `));
+
+  return new Promise((resolve) => {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+
+    let data = '';
+    process.stdin.on('data', (key) => {
+      data += key;
+
+      // Accept 'r' or 'y' for yes, anything else for no
+      if (key.toLowerCase() === 'r' || key.toLowerCase() === 'y') {
+        process.stdout.write(key);
+        process.stdout.write('\n');
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        resolve(true);
+      } else if (key === '\r' || key === '\n' || key === '\u0003') { // Enter, Esc, or Ctrl+C
+        process.stdout.write('N\n');
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        resolve(false);
+      } else if (data.length > 1) { // Any other input
+        process.stdout.write('N\n');
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        resolve(false);
+      }
+    });
+  });
+}
+
+module.exports = {
+  renameRequirement,
+  deleteRequirement,
+  permanentlyDeleteRequirement,
+  moveRequirementToRecycled,
+  moveRequirementDown,
+  moveRequirementUp,
+  promoteRequirement,
+  demoteRequirement,
+  restoreRequirement,
+  moveRequirementToClarification,
+  saveRequirementsOrder,
+  confirmAction,
+  getSectionTitle,
+  getRequirementList
+};

package/src/utils/interactive/requirements-navigation.js

@@ -0,0 +1,286 @@
+const { t, getRequirementsPath } = require('vibecodingmachine-core');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const fs = require('fs-extra');
+
+// Helper to get section title from section key
+function getSectionTitle(sectionKey) {
+  if (sectionKey === 'todo') return '⏳ Requirements not yet completed';
+  if (sectionKey === 'verify') return '✅ Verified by AI screenshot';
+  if (sectionKey === 'recycled') return '♻️ Recycled';
+  if (sectionKey === 'clarification') return '❓ Needs clarification';
+  return '';
+}
+
+// Helper to get requirement list from tree by section key
+function getRequirementList(tree, sectionKey) {
+  if (sectionKey === 'todo') return tree.todoReqs;
+  if (sectionKey === 'verify') return tree.verifyReqs;
+  if (sectionKey === 'clarification') return tree.clarificationReqs;
+  if (sectionKey === 'recycled') return tree.recycledReqs;
+  return [];
+}
+
+// Tree-style requirements navigator
+async function showRequirementsTree() {
+  console.log(chalk.bold.cyan('\n📋 ' + t('requirements.navigator.title') + '\n'));
+  console.log(chalk.gray(t('requirements.navigator.basic.instructions') + '\n'));
+
+  try {
+    const reqPath = await getRequirementsPath();
+    const content = await fs.readFile(reqPath, 'utf8');
+    
+    // Parse requirements into tree structure
+    const tree = parseRequirementsTree(content);
+    
+    // Show summary
+    console.log(chalk.yellow(`📊 Summary:`));
+    console.log(chalk.gray(`   • Todo: ${tree.todoReqs.length} items`));
+    console.log(chalk.gray(`   • Needs clarification: ${tree.clarificationReqs.length} items`));
+    console.log(chalk.gray(`   • Verified: ${tree.verifyReqs.length} items`));
+    console.log(chalk.gray(`   • Recycled: ${tree.recycledReqs.length} items\n`));
+
+    // Interactive navigation
+    await navigateRequirements(tree);
+    
+  } catch (error) {
+    console.error(chalk.red('❌ Error loading requirements:'), error.message);
+  }
+}
+
+function parseRequirementsTree(content) {
+  const lines = content.split('\n');
+  const tree = {
+    todoReqs: [],
+    verifyReqs: [],
+    clarificationReqs: [],
+    recycledReqs: []
+  };
+
+  let currentSection = null;
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    
+    // Detect section headers
+    if (line.includes('Requirements not yet completed')) {
+      currentSection = 'todo';
+    } else if (line.includes('Verified by AI screenshot')) {
+      currentSection = 'verify';
+    } else if (line.includes('Needs clarification')) {
+      currentSection = 'clarification';
+    } else if (line.includes('Recycled')) {
+      currentSection = 'recycled';
+    } else if (line.startsWith('- ') && currentSection) {
+      // Parse requirement
+      const req = parseRequirement(line, i);
+      if (req) {
+        tree[`${currentSection}Reqs`].push(req);
+      }
+    }
+  }
+
+  return tree;
+}
+
+function parseRequirement(line, index) {
+  // Remove the "- " prefix
+  const content = line.substring(2);
+  
+  // Extract title (first sentence or up to 100 chars)
+  const titleEnd = content.indexOf('.') !== -1 ? content.indexOf('.') + 1 : 100;
+  const title = content.substring(0, Math.min(titleEnd, 100)).trim();
+  
+  return {
+    title,
+    content,
+    index,
+    originalLine: line
+  };
+}
+
+async function navigateRequirements(tree) {
+  const sections = [
+    { key: 'todo', name: '⏳ Todo', count: tree.todoReqs.length },
+    { key: 'clarification', name: '❓ Needs clarification', count: tree.clarificationReqs.length },
+    { key: 'verify', name: '✅ Verified', count: tree.verifyReqs.length },
+    { key: 'recycled', name: '♻️ Recycled', count: tree.recycledReqs.length }
+  ];
+
+  while (true) {
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'Navigate to section:',
+        choices: [
+          ...sections.filter(s => s.count > 0).map(s => ({
+            name: `${s.name} (${s.count} items)`,
+            value: s.key
+          })),
+          { name: '🔄 Refresh', value: 'refresh' },
+          { name: '📝 Add new requirement', value: 'add' },
+          { name: '🚪 Exit', value: 'exit' }
+        ]
+      }
+    ]);
+
+    if (action === 'exit') break;
+    if (action === 'refresh') {
+      // Reload requirements
+      const reqPath = await getRequirementsPath();
+      const content = await fs.readFile(reqPath, 'utf8');
+      Object.assign(tree, parseRequirementsTree(content));
+      continue;
+    }
+    if (action === 'add') {
+      await handleAddRequirement();
+      continue;
+    }
+
+    // Show section details
+    await showSectionDetails(action, tree);
+  }
+}
+
+async function showSectionDetails(sectionKey, tree) {
+  const reqList = getRequirementList(tree, sectionKey);
+  const sectionTitle = getSectionTitle(sectionKey);
+  
+  if (reqList.length === 0) {
+    console.log(chalk.gray(`\nNo items in ${sectionTitle}\n`));
+    return;
+  }
+
+  console.log(chalk.bold(`\n${sectionTitle}\n`));
+
+  while (true) {
+    const { choice } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'choice',
+        message: 'Select requirement:',
+        choices: [
+          ...reqList.map((req, index) => ({
+            name: `${index + 1}. ${req.title}`,
+            value: index
+          })),
+          { name: '⬅️  Back to sections', value: 'back' }
+        ]
+      }
+    ]);
+
+    if (choice === 'back') break;
+
+    const req = reqList[choice];
+    await showRequirementDetails(req, sectionKey, tree);
+    
+    // Reload tree in case of changes
+    const reqPath = await getRequirementsPath();
+    const content = await fs.readFile(reqPath, 'utf8');
+    Object.assign(tree, parseRequirementsTree(content));
+  }
+}
+
+async function showRequirementDetails(req, sectionKey, tree) {
+  console.log(chalk.bold(`\n${req.title}\n`));
+  console.log(chalk.gray(req.content));
+  console.log();
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do?',
+      choices: getRequirementActions(sectionKey)
+    }
+  ]);
+
+  if (action !== 'back') {
+    await performRequirementAction(action, req, sectionKey, tree);
+  }
+}
+
+function getRequirementActions(sectionKey) {
+  const baseActions = [
+    { name: '⬅️  Back', value: 'back' }
+  ];
+
+  switch (sectionKey) {
+    case 'todo':
+      return [
+        { name: '✏️  Rename/Edit', value: 'rename' },
+        { name: '👍 Thumbs up (promote to Verified)', value: 'thumbs-up' },
+        { name: '❓ Needs clarification', value: 'needs-clarification' },
+        { name: '🗑️  Delete', value: 'delete' },
+        { name: '⬆️  Move up', value: 'move-up' },
+        { name: '⬇️  Move down', value: 'move-down' },
+        ...baseActions
+      ];
+    case 'clarification':
+      return [
+        { name: '✍️  Add/Edit Responses', value: 'edit-responses' },
+        { name: '↩️  Move back to TODO (after clarification)', value: 'move-to-todo' },
+        { name: '🗑️  Delete', value: 'delete' },
+        ...baseActions
+      ];
+    case 'verify':
+      return [
+        { name: '↩️  Move back to TODO', value: 'move-to-todo' },
+        { name: '🗑️  Delete', value: 'delete' },
+        ...baseActions
+      ];
+    case 'recycled':
+      return [
+        { name: '♻️  Restore to TODO', value: 'restore' },
+        { name: '🗑️  Permanently delete', value: 'permanent-delete' },
+        ...baseActions
+      ];
+    default:
+      return baseActions;
+  }
+}
+
+async function performRequirementAction(action, req, sectionKey, tree) {
+  const { performRequirementAction: actionHandler } = require('./requirement-actions');
+  await actionHandler(action, req, sectionKey, tree);
+}
+
+async function handleAddRequirement(type) {
+  const reqCommands = require('../commands/requirements');
+  const packages = ['all', 'cli', 'core', 'electron-app', 'web', 'mobile'];
+
+  const { package: pkg, requirement } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'package',
+      message: 'Select package:',
+      choices: packages
+    },
+    {
+      type: 'input',
+      name: 'requirement',
+      message: 'Enter requirement:',
+      validate: input => input.trim().length > 0 || 'Requirement cannot be empty'
+    }
+  ]);
+
+  try {
+    await reqCommands.add(pkg, requirement);
+    console.log(chalk.green('✅ Requirement added successfully'));
+  } catch (error) {
+    console.error(chalk.red('❌ Error adding requirement:'), error.message);
+  }
+}
+
+module.exports = {
+  showRequirementsTree,
+  getSectionTitle,
+  getRequirementList,
+  parseRequirementsTree,
+  navigateRequirements,
+  showSectionDetails,
+  showRequirementDetails,
+  getRequirementActions,
+  handleAddRequirement
+};