vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/utils/requirement-file-operations.js

@@ -0,0 +1,259 @@
+/**
+ * Requirement File Operations Module
+ * 
+ * Contains file reading/writing operations for requirement management.
+ */
+
+const fs = require('fs-extra');
+const { getRequirementsPath } = require('vibecodingmachine-core');
+
+/**
+ * Helper to edit clarification responses
+ */
+async function editClarificationResponses(req, tree) {
+  const reqPath = await getRequirementsPath();
+
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find the clarification requirement
+  let startIdx = -1;
+  let endIdx = -1;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(`### ${req.title}`)) {
+      startIdx = i;
+      // Find the end of this requirement
+      for (let j = i + 1; j < lines.length; j++) {
+        if (lines[j].startsWith('###') || lines[j].startsWith('##')) {
+          endIdx = j;
+          break;
+        }
+      }
+      if (endIdx === -1) endIdx = lines.length;
+      break;
+    }
+  }
+
+  if (startIdx === -1) return;
+
+  // Extract current responses
+  const reqLines = lines.slice(startIdx, endIdx);
+  const currentResponses = [];
+  
+  for (const line of reqLines) {
+    if (line.startsWith('- **Response:**')) {
+      currentResponses.push(line.replace('- **Response:**', '').trim());
+    }
+  }
+
+  console.log('\n📝 Current Responses:');
+  currentResponses.forEach((response, index) => {
+    console.log(`${index + 1}. ${response}`);
+  });
+
+  // Add new responses
+  const inquirer = require('inquirer');
+  const { confirmAction } = require('./requirement-helpers');
+  
+  let addMore = true;
+  while (addMore) {
+    const { newResponse } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'newResponse',
+        message: 'Enter new response (or empty to finish):'
+      }
+    ]);
+
+    if (newResponse && newResponse.trim()) {
+      currentResponses.push(newResponse.trim());
+      console.log('✓ Response added');
+    } else {
+      addMore = false;
+    }
+  }
+
+  // Update the requirement with new responses
+  const newReqLines = [];
+  let inResponses = false;
+  
+  for (const line of reqLines) {
+    if (line.startsWith('- **Response:**')) {
+      if (!inResponses) {
+        // Add all new responses
+        currentResponses.forEach(response => {
+          newReqLines.push(`- **Response:** ${response}`);
+        });
+        inResponses = true;
+      }
+    } else if (inResponses && line.startsWith('- **')) {
+      // Skip old response lines
+      continue;
+    } else {
+      newReqLines.push(line);
+    }
+  }
+
+  // Replace the requirement
+  lines.splice(startIdx, endIdx - startIdx, ...newReqLines);
+  await fs.writeFile(reqPath, lines.join('\n'));
+  console.log('\n✓ Responses updated!');
+}
+
+/**
+ * Helper to move clarification requirement back to TODO
+ */
+async function moveClarificationToTodo(req, tree) {
+  const reqPath = await getRequirementsPath();
+
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find and remove the clarification requirement
+  let startIdx = -1;
+  let endIdx = -1;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(`### ${req.title}`)) {
+      startIdx = i;
+      // Find the end of this requirement
+      for (let j = i + 1; j < lines.length; j++) {
+        if (lines[j].startsWith('###') || lines[j].startsWith('##')) {
+          endIdx = j;
+          break;
+        }
+      }
+      if (endIdx === -1) endIdx = lines.length;
+      break;
+    }
+  }
+
+  if (startIdx === -1) return;
+
+  // Extract the requirement content
+  const reqContent = lines.slice(startIdx, endIdx);
+
+  // Remove from clarification section
+  lines.splice(startIdx, endIdx - startIdx);
+
+  // Find TODO section and add there
+  let todoIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes('⏳ Requirements not yet completed')) {
+      todoIdx = i;
+      break;
+    }
+  }
+
+  if (todoIdx !== -1) {
+    // Insert after the TODO header
+    let insertIdx = todoIdx + 1;
+    while (insertIdx < lines.length && lines[insertIdx].trim() === '') {
+      insertIdx++;
+    }
+    
+    lines.splice(insertIdx, 0, ...reqContent);
+  }
+
+  await fs.writeFile(reqPath, lines.join('\n'));
+  console.log('\n✓ Moved to TODO!');
+}
+
+/**
+ * Helper to move clarification requirement to recycled (used to delete)
+ */
+async function deleteClarification(req, tree) {
+  const reqPath = await getRequirementsPath();
+  const { confirmAction } = require('./requirement-helpers');
+
+  const confirmed = await confirmAction(`Delete "${req.title}"? This cannot be undone. (r/y/N)`);
+  if (!confirmed) {
+    console.log('Cancelled.');
+    return;
+  }
+
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find and remove the clarification requirement
+  let startIdx = -1;
+  let endIdx = -1;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(`### ${req.title}`)) {
+      startIdx = i;
+      // Find the end of this requirement
+      for (let j = i + 1; j < lines.length; j++) {
+        if (lines[j].startsWith('###') || lines[j].startsWith('##')) {
+          endIdx = j;
+          break;
+        }
+      }
+      if (endIdx === -1) endIdx = lines.length;
+      break;
+    }
+  }
+
+  if (startIdx !== -1) {
+    lines.splice(startIdx, endIdx - startIdx);
+    await fs.writeFile(reqPath, lines.join('\n'));
+  }
+}
+
+/**
+ * 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 the section
+  let sectionStart = -1;
+  let sectionEnd = -1;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(sectionTitle)) {
+      sectionStart = i;
+      // Find the end of this section
+      for (let j = i + 1; j < lines.length; j++) {
+        if (lines[j].startsWith('##')) {
+          sectionEnd = j;
+          break;
+        }
+      }
+      if (sectionEnd === -1) sectionEnd = lines.length;
+      break;
+    }
+  }
+
+  if (sectionStart === -1) return;
+
+  // Build new section content
+  const newSection = [lines[sectionStart]]; // Keep the header
+  newSection.push(''); // Empty line after header
+
+  // Add requirements in new order
+  requirements.forEach(req => {
+    newSection.push(`### ${req.title}`);
+    if (req.details && req.details.length > 0) {
+      req.details.forEach(detail => {
+        newSection.push(detail);
+      });
+    }
+    newSection.push(''); // Empty line after requirement
+  });
+
+  // Replace the section
+  lines.splice(sectionStart, sectionEnd - sectionStart, ...newSection);
+
+  // Save
+  await fs.writeFile(reqPath, lines.join('\n'));
+}
+
+module.exports = {
+  editClarificationResponses,
+  moveClarificationToTodo,
+  deleteClarification,
+  saveRequirementsOrder
+};

package/src/utils/requirement-helpers.js

@@ -0,0 +1,128 @@
+/**
+ * Requirement Helpers Module
+ * 
+ * Contains helper functions for requirement management.
+ */
+
+const chalk = require('chalk');
+const readline = require('readline');
+
+/**
+ * Helper to show goodbye message
+ */
+function showGoodbyeMessage() {
+  const hour = new Date().getHours();
+  const message = hour < 21
+    ? '\n👋 Goodbye! Thanks for using Vibe Coding Machine!\n'
+    : '\n👋 Goodbye! Go get some sleep!\n';
+  console.log(chalk.cyan(message));
+}
+
+/**
+ * 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';
+  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 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) => {
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+
+    process.stdin.resume();
+    process.stdin.on('keypress', (str, key) => {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdin.removeAllListeners('keypress');
+
+      if (key.name === 'return' || key.name === 'escape') {
+        resolve(false);
+      } else if ((key.name === 'r' || key.name === 'y') && !key.ctrl) {
+        resolve(true);
+      } else {
+        resolve(false);
+      }
+    });
+  });
+}
+
+/**
+ * Helper to confirm and exit
+ */
+async function confirmAndExit(message = 'Are you sure you want to exit? (r/y/N)') {
+  const confirmed = await confirmAction(message);
+  if (confirmed) {
+    showGoodbyeMessage();
+    process.exit(0);
+  }
+}
+
+/**
+ * Helper to format requirement title for display
+ */
+function formatRequirementTitle(req, index = null) {
+  const prefix = index !== null ? `${index + 1}. ` : '';
+  const status = req.status ? `[${req.status}] ` : '';
+  return `${prefix}${status}${req.title}`;
+}
+
+/**
+ * Helper to validate requirement title
+ */
+function validateRequirementTitle(title) {
+  if (!title || title.trim().length === 0) {
+    return 'Requirement title cannot be empty';
+  }
+  if (title.length > 200) {
+    return 'Requirement title must be less than 200 characters';
+  }
+  return null;
+}
+
+/**
+ * Helper to find requirement by title in any section
+ */
+function findRequirementInTree(tree, title) {
+  for (const sectionKey of ['todo', 'verify', 'clarification', 'recycled']) {
+    const reqList = getRequirementList(tree, sectionKey);
+    const req = reqList.find(r => r.title === title);
+    if (req) {
+      return { req, sectionKey };
+    }
+  }
+  return null;
+}
+
+module.exports = {
+  showGoodbyeMessage,
+  getSectionTitle,
+  getRequirementList,
+  confirmAction,
+  confirmAndExit,
+  formatRequirementTitle,
+  validateRequirementTitle,
+  findRequirementInTree
+};

package/src/utils/requirement-management.js

@@ -0,0 +1,279 @@
+/**
+ * Requirement Management Module
+ * 
+ * Handles basic requirement management actions like rename, delete, promote, demote.
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const fs = require('fs-extra');
+const { getRequirementsPath } = require('vibecodingmachine-core');
+const { getSectionTitle, getRequirementList, confirmAction } = require('./requirement-helpers');
+
+/**
+ * Show requirement actions menu
+ */
+async function showRequirementActions(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.log(chalk.red('Requirement not found'));
+    return;
+  }
+
+  let actions = [
+    { label: '✏️  Rename/Edit', value: 'rename' },
+    { label: '👍 Thumbs Up (promote)', value: 'thumbs-up' },
+    { label: '👎 Thumbs Down (demote)', value: 'thumbs-down' },
+    { label: '🗑️  Delete', value: 'delete' },
+    { label: '↩️  Back', value: 'back' }
+  ];
+
+  // Add move actions based on current section
+  if (sectionKey === 'todo') {
+    actions.splice(-2, 0, { label: '↪️  Move to Clarification', value: 'move-to-clarification' });
+  } else if (sectionKey === 'clarification') {
+    actions.splice(-2, 0, { label: '↩️  Move back to TODO', value: 'move-to-todo' });
+  }
+
+  console.log(chalk.bold.cyan(`\n📋 ${sectionTitle}\n`));
+  console.log(chalk.bold(`${reqIndex + 1}. ${req.title}`));
+  
+  if (req.details && req.details.length > 0) {
+    console.log(chalk.gray('Description:'));
+    req.details.forEach(detail => {
+      console.log(chalk.gray(`  ${detail}`));
+    });
+  }
+  console.log();
+
+  try {
+    const { action } = await inquirer.prompt([{
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do?',
+      choices: actions
+    }]);
+
+    if (action !== 'back') {
+      await performRequirementAction(action, req, sectionKey, tree);
+    }
+  } catch (error) {
+    console.error(chalk.red('Error performing requirement action:'), error);
+  }
+}
+
+/**
+ * Perform action on requirement
+ */
+async function performRequirementAction(action, req, sectionKey, tree) {
+  const reqList = getRequirementList(tree, sectionKey);
+  const reqIndex = reqList.findIndex(r => r.title === req.title);
+
+  if (reqIndex === -1) {
+    console.log(chalk.red('Requirement not found'));
+    return;
+  }
+
+  switch (action) {
+    case 'rename':
+      await renameRequirement(req, sectionKey, tree);
+      break;
+    case 'thumbs-up':
+      await promoteRequirement(req, sectionKey, tree);
+      break;
+    case 'thumbs-down':
+      await demoteRequirement(req.title, sectionKey, tree);
+      break;
+    case 'delete':
+      await deleteRequirement(req, sectionKey, tree);
+      break;
+    case 'move-to-clarification':
+      await moveToClarification(req, sectionKey, tree);
+      break;
+    case 'move-to-todo':
+      await moveToTodo(req, sectionKey, tree);
+      break;
+  }
+
+  await new Promise(resolve => setTimeout(resolve, 1000));
+}
+
+/**
+ * Rename requirement (title and description)
+ */
+async function renameRequirement(req, sectionKey, tree) {
+  const reqPath = await getRequirementsPath();
+
+  console.log(chalk.cyan('\n✏️  Rename/Edit Requirement\n'));
+  console.log(chalk.gray('Current title:'), chalk.white(req.title));
+  if (req.details && req.details.length > 0) {
+    console.log(chalk.gray('Current description:'));
+    req.details.forEach(line => console.log(chalk.white('  ' + line)));
+  }
+  console.log();
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'title',
+      message: 'New title (leave blank to keep current):',
+      default: ''
+    }
+  ]);
+
+  const newTitle = answers.title.trim() || req.title;
+
+  // Ask for description using multi-line input
+  console.log(chalk.gray('\nEnter new description (leave blank to keep current).'));
+  console.log(chalk.gray('Press Enter twice on empty line to finish:\n'));
+
+  const descriptionLines = [];
+  let emptyLineCount = 0;
+  let isFirstLine = true;
+  let newDescription = '';
+  let keptCurrent = false;
+
+  while (true) {
+    try {
+      const { line } = await inquirer.prompt([{
+        type: 'input',
+        name: 'line',
+        message: isFirstLine ? 'Description:' : ''
+      }]);
+
+      if (isFirstLine && line.trim() === '') {
+        // If first line is empty, keep current description
+        keptCurrent = true;
+        break;
+      }
+
+      isFirstLine = false;
+
+      if (line.trim() === '') {
+        emptyLineCount++;
+        if (emptyLineCount >= 2) break;
+      } else {
+        emptyLineCount = 0;
+        descriptionLines.push(line);
+      }
+    } catch (err) {
+      break;
+    }
+  }
+
+  if (!keptCurrent) {
+    newDescription = descriptionLines.join('\n');
+  }
+
+  // Read the requirements file
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find and update the requirement
+  let startIdx = -1;
+  let endIdx = -1;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(`### ${req.title}`)) {
+      startIdx = i;
+      // Find the end of this requirement
+      for (let j = i + 1; j < lines.length; j++) {
+        if (lines[j].startsWith('###') || lines[j].startsWith('##')) {
+          endIdx = j;
+          break;
+        }
+      }
+      if (endIdx === -1) endIdx = lines.length;
+      break;
+    }
+  }
+
+  if (startIdx !== -1) {
+    // Build new requirement content
+    const newReqContent = [`### ${newTitle}`, ''];
+
+    if (newDescription && !keptCurrent) {
+      newReqContent.push(newDescription, '');
+    } else if (req.details && req.details.length > 0) {
+      req.details.forEach(detail => newReqContent.push(detail));
+      newReqContent.push('');
+    }
+
+    // Replace the requirement
+    lines.splice(startIdx, endIdx - startIdx, ...newReqContent);
+    await fs.writeFile(reqPath, lines.join('\n'));
+    console.log(chalk.green('\n✓ Requirement updated!'));
+  }
+}
+
+/**
+ * Delete requirement
+ */
+async function deleteRequirement(req, sectionKey, tree) {
+  const reqList = getRequirementList(tree, sectionKey);
+  const reqIndex = reqList.findIndex(r => r.title === req.title);
+
+  if (reqIndex === -1) return;
+
+  const confirmed = await confirmAction(`Delete "${req.title}"? This cannot be undone. (r/y/N)`);
+  if (!confirmed) {
+    console.log(chalk.gray('Cancelled.'));
+    return;
+  }
+
+  const reqPath = await getRequirementsPath();
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find and remove the requirement
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(`### ${req.title}`)) {
+      // Find the end of this requirement
+      let endIdx = i + 1;
+      while (endIdx < lines.length && !lines[endIdx].startsWith('###') && !lines[endIdx].startsWith('##')) {
+        endIdx++;
+      }
+      
+      lines.splice(i, endIdx - i);
+      break;
+    }
+  }
+
+  await fs.writeFile(reqPath, lines.join('\n'));
+  reqList.splice(reqIndex, 1);
+  console.log(chalk.green('\n✓ Requirement deleted!'));
+}
+
+/**
+ * Promote requirement (thumbs up)
+ */
+async function promoteRequirement(req, sectionKey, tree) {
+  console.log(chalk.cyan(`\n👍 Promoting: ${req.title}`));
+  
+  // Implementation would depend on specific promotion logic
+  // This is a placeholder for the actual promotion functionality
+  console.log(chalk.yellow('Promotion functionality not yet implemented'));
+}
+
+/**
+ * Demote requirement (thumbs down)
+ */
+async function demoteRequirement(title, sectionKey, tree) {
+  console.log(chalk.cyan(`\n👎 Demoting: ${title}`));
+  
+  // Implementation would depend on specific demotion logic
+  // This is a placeholder for the actual demotion functionality
+  console.log(chalk.yellow('Demotion functionality not yet implemented'));
+}
+
+module.exports = {
+  showRequirementActions,
+  performRequirementAction,
+  renameRequirement,
+  deleteRequirement,
+  promoteRequirement,
+  demoteRequirement
+};