vibecodingmachine-cli 2026.2.26-1739 → 2026.3.9-1621

package/src/utils/trui-req-actions-backup.js

@@ -0,0 +1,507 @@
+/**
+ * TRUI Requirement Actions
+ *
+ * Provides an action menu for a selected requirement and the addRequirementFlow.
+ * Uses inquirer for prompted input (rename, add) and showQuickMenu for action selection.
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const fs = require('fs-extra');
+const readline = require('readline');
+const { hasClarificationResponse, editClarificationResponse } = require('./trui-clarifications');
+
+/**
+ * Single-keypress confirm: Y/Enter/- = yes, N/Esc = no. No Enter required.
+ * Shows: `message (Y/n/-)` and echoes the choice.
+ */
+async function _confirmKeypress(message) {
+  return new Promise(resolve => {
+    process.stdout.write(message + ' (Y/n/-)\n\n');
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY && process.stdin.setRawMode) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+
+    const cleanup = () => {
+      process.stdin.removeListener('keypress', onKey);
+      if (process.stdin.isTTY && process.stdin.setRawMode) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+    };
+
+    const onKey = (str, key) => {
+      if (!key) return;
+      if (key.ctrl && key.name === 'c') { cleanup(); process.exit(0); }
+      const ch = (str || '').toLowerCase();
+      if (ch === 'y' || key.name === 'return' || ch === '-') {
+        cleanup();
+        process.stdout.write(chalk.green('y') + '\n');
+        resolve(true);
+      } else if (ch === 'n' || key.name === 'escape') {
+        cleanup();
+        process.stdout.write(chalk.gray('n') + '\n');
+        resolve(false);
+      }
+    };
+
+    process.stdin.on('keypress', onKey);
+  });
+}
+
+/**
+ * Show action menu for a requirement item.
+ * @param {{title: string, status: string}} req
+ * @param {string} sectionKey - 'todo' | 'verify' | 'verified' | 'recycled'
+ * @param {Function} onChanged - called with true when data changes (tree should reload)
+ * @returns {Promise<boolean>} true if data changed
+ */
+async function showRequirementActions(req, sectionKey, onChanged) {
+  const { showQuickMenu } = require('./trui-quick-menu');
+
+  const {
+    promoteToVerified,
+    demoteFromVerifiedToTodo,
+    promoteTodoToVerify,
+    demoteVerifyToTodo,
+    getOrCreateRequirementsFilePath,
+    getRequirementsPath,
+  } = require('vibecodingmachine-core');
+  const { getRepoPath, getEffectiveRepoPath } = require('./config');
+
+  // Build action items based on current section
+  const actions = [];
+
+  if (sectionKey === 'todo') {
+    actions.push({ type: 'action', name: 'Promote to TO VERIFY', value: 'promote' });
+  }
+  if (sectionKey === 'verify') {
+    actions.push({ type: 'action', name: 'Promote to VERIFIED', value: 'verify-promote' });
+    actions.push({ type: 'action', name: 'Demote to TODO', value: 'demote' });
+  }
+  if (sectionKey === 'verified') {
+    actions.push({ type: 'action', name: 'Demote to TODO', value: 'demote-verified' });
+  }
+
+  // Add clarification editing if requirement has clarification response
+  if (hasClarificationResponse(req)) {
+    actions.push({ type: 'action', name: '💬 Edit Clarification Response', value: 'edit-clarification' });
+  }
+
+  // Add bulk operations
+  actions.push({ type: 'separator', name: chalk.gray('  ── Bulk Operations ──'), value: 'separator' });
+  actions.push({ type: 'action', name: '[📋 Select Multiple Items]', value: 'bulk-select' });
+  actions.push({ type: 'action', name: '[🚀 Move Multiple Items]', value: 'bulk-move' });
+
+  actions.push({ type: 'action', name: 'Move Item Up in section', value: 'move-up' });
+  actions.push({ type: 'action', name: 'Move Item Down in section', value: 'move-down' });
+  actions.push({ type: 'action', name: 'Rename', value: 'rename' });
+  actions.push({ type: 'action', name: chalk.red('Delete'), value: 'delete' });
+
+  console.log(chalk.bold.cyan(`\n📌 ${req.title} [${sectionKey}]\n`));
+
+  const result = await showQuickMenu(actions, 0);
+  if (result.value === '__cancel__' || result.value === 'exit') return false;
+
+  let reqPath;
+  try {
+    const repoPath = await getRepoPath();
+    const p = await getRequirementsPath(repoPath);
+    // Use effectiveRepoPath (git root) for creation so .vibecodingmachine is never
+    // created inside a sub-package directory when repoPath is null.
+    reqPath = (p && await fs.pathExists(p)) ? p : await getOrCreateRequirementsFilePath(await getEffectiveRepoPath());
+  } catch (err) {
+    console.log(chalk.red('Cannot find requirements file: ' + err.message));
+    await _pause();
+    return false;
+  }
+
+  try {
+    if (result.value === 'promote') {
+      console.log(chalk.gray('\nEquivalent: vcm req:promote "' + req.title + '"'));
+      await promoteTodoToVerify(reqPath, req.title);
+      console.log(chalk.green('✓ Moved to TO VERIFY'));
+      await _pause();
+      return true;
+    }
+
+    if (result.value === 'verify-promote') {
+      console.log(chalk.gray('\nEquivalent: vcm req:verify "' + req.title + '"'));
+      await promoteToVerified(reqPath, req.title);
+      console.log(chalk.green('✓ Moved to VERIFIED'));
+      await _pause();
+      return true;
+    }
+
+    if (result.value === 'demote') {
+      console.log(chalk.gray('\nEquivalent: vcm req:demote "' + req.title + '"'));
+      await demoteVerifyToTodo(reqPath, req.title);
+      console.log(chalk.green('✓ Moved back to TODO'));
+      await _pause();
+      return true;
+    }
+
+    if (result.value === 'demote-verified') {
+      console.log(chalk.gray('\nEquivalent: vcm req:demote "' + req.title + '"'));
+      await demoteFromVerifiedToTodo(reqPath, req.title);
+      console.log(chalk.green('✓ Moved back to TODO'));
+      await _pause();
+      return true;
+    }
+
+    if (result.value === 'edit-clarification') {
+      console.log(chalk.gray('\nOpening clarification response editor...'));
+      
+      // Create save callback for the requirement
+      const saveCallback = async (updatedReq) => {
+        // Update the requirement in the file
+        const content = await fs.readFile(reqPath, 'utf8');
+        const lines = content.split('\n');
+        
+        // Find and replace the requirement section
+        let inRequirement = false;
+        let reqStart = -1;
+        let reqEnd = -1;
+        
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          if (line.includes(`## ${req.title}`) || line.includes(`### ${req.title}`)) {
+            inRequirement = true;
+            reqStart = i;
+          } else if (inRequirement && (line.startsWith('## ') || line.startsWith('### ')) && !line.includes(req.title)) {
+            reqEnd = i;
+            break;
+          }
+        }
+        
+        if (reqEnd === -1) reqEnd = lines.length;
+        
+        // Replace the requirement content
+        const newContent = [
+          ...lines.slice(0, reqStart),
+          ...updatedReq.content.split('\n'),
+          ...lines.slice(reqEnd)
+        ].join('\n');
+        
+        await fs.writeFile(reqPath, newContent, 'utf8');
+      };
+      
+      await editClarificationResponse(req, saveCallback);
+      return true;
+    }
+
+    if (result.value === 'bulk-select') {
+      await showBulkSelection(sectionKey, navigation);
+      return true;
+    }
+
+    if (result.value === 'bulk-move') {
+      await showBulkMove(sectionKey, navigation);
+      return true;
+    }
+
+    if (result.value === 'move-up' || result.value === 'move-down') {
+      const direction = result.value === 'move-up' ? 'up' : 'down';
+      const moved = await _moveRequirement(reqPath, req.title, sectionKey, direction);
+      if (moved) {
+        console.log(chalk.green(`✓ Moved ${direction}`));
+        console.log(chalk.gray(`Equivalent: vcm req:move-${direction} "${req.title}"`));
+      } else {
+        console.log(chalk.yellow('Already at the ' + (direction === 'up' ? 'top' : 'bottom')));
+      }
+      await _pause();
+      return moved;
+    }
+
+    if (result.value === 'rename') {
+      return await _renameRequirement(reqPath, req.title, sectionKey);
+    }
+
+    if (result.value === 'delete') {
+      return await _deleteRequirement(reqPath, req.title);
+    }
+  } catch (err) {
+    console.log(chalk.red('Error: ' + err.message));
+    await _pause();
+  }
+
+  return false;
+}
+
+/**
+ * Move a requirement up or down within its section
+ */
+async function _moveRequirement(reqPath, title, sectionKey, direction) {
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find section boundaries
+  const sectionHeadings = {
+    todo: /requirements not yet completed/i,
+    verify: /to verify|verified by ai/i,
+    verified: /verified\b/i,
+    recycled: /recycled/i,
+  };
+  const pattern = sectionHeadings[sectionKey];
+
+  let sectionStart = -1;
+  let sectionEnd = lines.length;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (sectionStart === -1 && line.startsWith('##') && pattern && pattern.test(line)) {
+      sectionStart = i;
+    } else if (sectionStart !== -1 && line.startsWith('## ') && i > sectionStart) {
+      sectionEnd = i;
+      break;
+    }
+  }
+
+  if (sectionStart === -1) return false;
+
+  // Find all requirement blocks (### headers) within the section
+  const reqBlocks = [];
+  let currentBlock = null;
+  for (let i = sectionStart + 1; i < sectionEnd; i++) {
+    const line = lines[i];
+    if (line.trim().startsWith('### ')) {
+      if (currentBlock) { currentBlock.end = i; reqBlocks.push(currentBlock); }
+      currentBlock = { title: line.trim().replace(/^###\s*/, ''), start: i, end: sectionEnd };
+    }
+  }
+  if (currentBlock) { currentBlock.end = sectionEnd; reqBlocks.push(currentBlock); }
+
+  const idx = reqBlocks.findIndex(b => b.title === title);
+  if (idx === -1) return false;
+  if (direction === 'up' && idx === 0) return false;
+  if (direction === 'down' && idx === reqBlocks.length - 1) return false;
+
+  const swapIdx = direction === 'up' ? idx - 1 : idx + 1;
+  const blockA = reqBlocks[idx];
+  const blockB = reqBlocks[swapIdx];
+
+  // Extract block content
+  const [first, second] = blockA.start < blockB.start ? [blockA, blockB] : [blockB, blockA];
+  const firstContent = lines.slice(first.start, first.end);
+  const secondContent = lines.slice(second.start, second.end);
+
+  // Swap
+  const newLines = [
+    ...lines.slice(0, first.start),
+    ...secondContent,
+    ...firstContent,
+    ...lines.slice(second.end),
+  ];
+
+  await fs.writeFile(reqPath, newLines.join('\n'), 'utf8');
+  return true;
+}
+
+/**
+ * Rename a requirement
+ */
+async function _renameRequirement(reqPath, oldTitle, sectionKey) {
+  const { newTitle } = await inquirer.prompt([{
+    type: 'input',
+    name: 'newTitle',
+    message: chalk.cyan('New title:'),
+    default: oldTitle,
+    validate: v => v.trim().length > 0 || 'Title required',
+  }]);
+
+  if (newTitle.trim() === oldTitle) return false;
+
+  const content = await fs.readFile(reqPath, 'utf8');
+  const escaped = oldTitle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const updated = content.replace(new RegExp(`^(###\\s*)${escaped}\\s*$`, 'm'), `$1${newTitle.trim()}`);
+
+  if (updated === content) {
+    console.log(chalk.yellow('Could not find requirement to rename'));
+    await _pause();
+    return false;
+  }
+
+  await fs.writeFile(reqPath, updated, 'utf8');
+  console.log(chalk.green(`✓ Renamed to "${newTitle.trim()}"`));
+  console.log(chalk.gray(`Equivalent: vcm req:rename "${oldTitle}" "${newTitle.trim()}"`));
+  await _pause();
+  return true;
+}
+
+/**
+ * Delete a requirement after confirmation
+ */
+async function _deleteRequirement(reqPath, title) {
+  const confirmed = await _confirmKeypress(chalk.red(`Delete "${title}"?`));
+  if (!confirmed) return false;
+
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+  const escaped = title.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const startRe = new RegExp(`^###\\s*${escaped}\\s*$`);
+
+  let startIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (startRe.test(lines[i].trim())) { startIdx = i; break; }
+  }
+  if (startIdx === -1) {
+    console.log(chalk.yellow('Could not find requirement to delete'));
+    return false;
+  }
+
+  // Find end of this requirement block
+  let endIdx = startIdx + 1;
+  while (endIdx < lines.length) {
+    const line = lines[endIdx].trim();
+    if (line.startsWith('### ') || (line.startsWith('## ') && !line.startsWith('### '))) break;
+    endIdx++;
+  }
+
+  lines.splice(startIdx, endIdx - startIdx);
+  await fs.writeFile(reqPath, lines.join('\n'), 'utf8');
+  console.log(chalk.green(`✓ Deleted "${title}"`));
+  return true;
+}
+
+/**
+ * Prompt for a new requirement and append to the TODO section
+ */
+async function addRequirementFlow() {
+  console.log(chalk.bold.cyan('\n📋 Add New Requirement\n'));
+  console.log(chalk.gray('Equivalent: vcm req:add "<title>"\n'));
+
+  const { createNewRequirement } = require('./trui-req-editor');
+  
+  try {
+    const requirement = await createNewRequirement();
+    
+    const { getOrCreateRequirementsFilePath, getRequirementsPath } = require('vibecodingmachine-core');
+    const { getRepoPath: _getRepoPath, getEffectiveRepoPath: _getEffectiveRepoPath } = require('./config');
+    const _repoPath = await _getRepoPath();
+    const _p = await getRequirementsPath(_repoPath);
+    // Use effectiveRepoPath (git root) for creation to avoid nested .vibecodingmachine dirs.
+    const reqPath = (_p && await fs.pathExists(_p)) ? _p : await getOrCreateRequirementsFilePath(await _getEffectiveRepoPath());
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+
+    let insertIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].trim().match(/^##\s+.*(?:Requirements not yet completed|TODO)/i)) {
+        insertIndex = i + 1;
+        for (let j = i + 1; j < lines.length; j++) {
+          const inner = lines[j].trim();
+          if (inner.startsWith('## ') && !inner.startsWith('### ')) { insertIndex = j; break; }
+          if (inner.startsWith('### ') || inner.startsWith('- ')) { insertIndex = j; break; }
+        }
+        break;
+      }
+    }
+
+    const block = requirement.description
+      ? `### ${requirement.title.trim()}\n\n${requirement.description.trim()}\n`
+      : `### ${requirement.title.trim()}\n`;
+
+    if (insertIndex >= 0) {
+      lines.splice(insertIndex, 0, block);
+    } else {
+      lines.push('', '## Requirements not yet completed', '', block);
+    }
+
+    await fs.writeFile(reqPath, lines.join('\n'), 'utf8');
+    console.log(chalk.green(`\n✓ Added "${title.trim()}"`));
+  } catch (err) {
+    console.log(chalk.red('Error: ' + err.message));
+  }
+
+  await _pause();
+}
+
+async function _pause() {
+  await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...') }]);
+}
+
+/**
+ * Handle requirement selection from the tree navigator
+ * @param {number} index - Index of the requirement in the section
+ * @param {Array} requirements - Array of requirements in the section
+ * @param {Object} navigation - Navigation object
+ */
+async function handleRequirementSelection(index, requirements, navigation) {
+  if (index < 0 || index >= requirements.length) {
+    console.log(chalk.red('Invalid requirement index'));
+    return;
+  }
+
+  const req = requirements[index];
+  const sectionKey = navigation.currentSection || 'todo';
+  
+  const changed = await showRequirementActions(req, sectionKey, () => {
+    // Refresh callback - the tree will reload
+  });
+  
+  return changed;
+}
+
+module.exports = { 
+  showRequirementActions, 
+  addRequirementFlow, 
+  _moveRequirement, 
+  _deleteRequirement,
+  handleRequirementSelection,
+  showBulkSelection,
+  showBulkMove
+};
+
+/**
+ * Show bulk selection interface
+ */
+async function showBulkSelection(sectionKey, navigation) {
+  console.clear();
+  console.log(chalk.bold.cyan('📋 Bulk Selection\n'));
+  console.log(chalk.gray('Select multiple requirements for bulk operations\n'));
+  
+  // Load requirements for the section
+  const data = await navigation.resolver.resolve('list requirements');
+  const result = await data.command.execute();
+  const requirements = result.data.sections[sectionKey] || [];
+  
+  if (requirements.length === 0) {
+    console.log(chalk.yellow('No requirements in this section'));
+    await _pause();
+    return;
+  }
+  
+  const { selectedItems } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selectedItems',
+      message: 'Select requirements:',
+      choices: requirements.map((req, index) => ({
+        name: req.title || req.name || 'Untitled',
+        value: index
+      }))
+    }
+  ]);
+  
+  if (selectedItems.length === 0) {
+    console.log(chalk.yellow('No items selected'));
+    await _pause();
+    return;
+  }
+  
+  console.log(chalk.green(`\nSelected ${selectedItems.length} item(s)`));
+  await _pause();
+}
+
+/**
+ * Show bulk move interface
+ */
+async function showBulkMove(sectionKey, navigation) {
+  console.clear();
+  console.log(chalk.bold.cyan('🚀 Bulk Move\n'));
+  console.log(chalk.gray('Move multiple requirements to another section\n'));
+  
+  await _pause();
+}