vibecodingmachine-cli 2026.1.29-713 → 2026.2.20-423

package/src/utils/trui-specifications.js

@@ -0,0 +1,359 @@
+/**
+ * TRUI Specifications List
+ *
+ * Shows a list of all specifications from the specs directory.
+ */
+
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const { showQuickMenu } = require('./trui-quick-menu');
+const { debugLogger } = require('./trui-debug');
+
+/**
+ * Extract Phase headers from a spec directory's tasks.md.
+ * Matches "## Phase N: ..." lines.
+ * Falls back to User Story headers from spec.md if tasks.md is absent.
+ * Returns an array of title strings.
+ */
+/**
+ * Extract phases from a spec directory's tasks.md, including per-phase checkbox counts.
+ * Falls back to User Story headers from spec.md if tasks.md is absent.
+ * Returns an array of { title, done, total, pct } objects.
+ */
+function extractPhases(specPath) {
+  try {
+    // Primary: tasks.md phases with checkbox roll-up
+    const tasksFile = path.join(specPath, 'tasks.md');
+    if (fs.existsSync(tasksFile)) {
+      const content = fs.readFileSync(tasksFile, 'utf8');
+      const phases = [];
+      let current = null;
+
+      for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (/^## Phase \d+/i.test(trimmed)) {
+          if (current) phases.push(current);
+          current = { title: trimmed.replace(/^##\s*/, ''), done: 0, total: 0 };
+        } else if (current) {
+          if (/^- \[x\]/i.test(trimmed)) { current.done++; current.total++; }
+          else if (/^- \[ \]/.test(trimmed)) { current.total++; }
+        }
+      }
+      if (current) phases.push(current);
+
+      if (phases.length) {
+        return phases.map(p => ({ ...p, pct: p.total > 0 ? Math.round((p.done / p.total) * 100) : 0 }));
+      }
+    }
+    // Fallback: User Story headers from spec.md (no task counts available)
+    const specFile = path.join(specPath, 'spec.md');
+    if (fs.existsSync(specFile)) {
+      const content = fs.readFileSync(specFile, 'utf8');
+      const stories = [];
+      for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (/^### (?:User Story\b|US-\d+)/i.test(trimmed)) {
+          stories.push({ title: trimmed.replace(/^###\s*/, ''), done: 0, total: 0, pct: 0 });
+        }
+      }
+      return stories;
+    }
+    return [];
+  } catch (_) {
+    return [];
+  }
+}
+
+// Legacy alias
+const extractUserStories = extractPhases;
+
+/**
+ * Count checkboxes in a markdown file.
+ * Returns { done, total } counts.
+ */
+function _countCheckboxes(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const totalMatches = content.match(/^- \[[ x]\]/gmi) || [];
+    const doneMatches = content.match(/^- \[x\]/gmi) || [];
+    return { done: doneMatches.length, total: totalMatches.length };
+  } catch (_) {
+    return { done: 0, total: 0 };
+  }
+}
+
+/**
+ * Get list of all specs from specs directory using core helpers
+ */
+async function getSpecsList() {
+  try {
+    const { getAllSpecifications } = require('vibecodingmachine-core');
+
+    // Find the repo root by looking for .git directory
+    let currentDir = process.cwd();
+    while (currentDir !== path.dirname(currentDir)) {
+      if (fs.existsSync(path.join(currentDir, '.git'))) {
+        break;
+      }
+      currentDir = path.dirname(currentDir);
+    }
+
+    // Get specs using core function
+    const specs = await getAllSpecifications(currentDir);
+    if (!specs || !Array.isArray(specs)) {
+      return [];
+    }
+
+    return specs.map(spec => {
+      // Count checkboxes across all markdown files in the spec directory
+      let totalDone = 0;
+      let totalTasks = 0;
+      try {
+        const specDir = spec.path || path.join(currentDir, 'specs', spec.directory);
+        const mdFiles = fs.readdirSync(specDir).filter(f => f.endsWith('.md'));
+        for (const mdFile of mdFiles) {
+          const counts = _countCheckboxes(path.join(specDir, mdFile));
+          totalDone += counts.done;
+          totalTasks += counts.total;
+        }
+      } catch (_) {}
+
+      const pct = totalTasks > 0 ? Math.round((totalDone / totalTasks) * 100) : 0;
+
+      return {
+        id: spec.directory,
+        disabled: spec.directory.startsWith('DISABLED-'),
+        taskDone: totalDone,
+        taskTotal: totalTasks,
+        pct,
+        path: spec.path
+      };
+    }).sort((a, b) => {
+      // Sort by directory name with DISABLED- prefix stripped so disabled specs
+      // stay in their original position rather than moving to the end.
+      const nameA = a.id.replace(/^DISABLED-/, '');
+      const nameB = b.id.replace(/^DISABLED-/, '');
+      return nameA.localeCompare(nameB);
+    });
+  } catch (error) {
+    debugLogger.error('Failed to get specs list', { error: error.message });
+    return [];
+  }
+}
+
+/**
+ * Show specifications list menu
+ */
+async function showSpecificationsList() {
+  debugLogger.info('Opening specifications list');
+
+  console.clear();
+  console.log(chalk.cyan('\n📋 TODO SPECIFICATIONS\n'));
+  console.log(chalk.gray('Available specifications from specs directory\n'));
+
+  const specs = await getSpecsList();
+
+  if (specs.length === 0) {
+    console.log(chalk.yellow('No specifications found in specs directory.'));
+    console.log(chalk.gray('Create a new specification with: vcm create spec <name>'));
+    return;
+  }
+
+  // Build menu items
+  const items = [];
+
+  // Add each spec as a menu item
+  specs.forEach((spec, index) => {
+    let progressStr = '';
+    if (spec.taskTotal > 0) {
+      progressStr = chalk.gray(` [${spec.pct}%, ${spec.taskDone}/${spec.taskTotal} tasks complete]`);
+    }
+    items.push({
+      type: 'action',
+      name: `${spec.id}${progressStr}`,
+      value: `spec:${spec.id}`
+    });
+  });
+
+  // Add blank separator
+  items.push({ type: 'blank', name: '', value: 'blank' });
+
+  // Add actions
+  items.push({ type: 'action', name: '[+ Create New Specification]', value: 'create-spec' });
+  items.push({ type: 'action', name: 'Back to Main Menu', value: '__cancel__' });
+
+  // Show menu
+  const result = await showQuickMenu(items);
+
+  if (result.value === '__cancel__') {
+    return;
+  }
+
+  if (result.value === 'create-spec') {
+    await createNewSpecification();
+    return;
+  }
+
+  // Handle spec selection
+  if (result.value.startsWith('spec:')) {
+    const specId = result.value.substring(5);
+    await showSpecificationDetails(specId);
+    return;
+  }
+}
+
+/**
+ * Get status icon for specification
+ */
+function getStatusIcon(status) {
+  switch (status) {
+    case 'completed': return '✅';
+    case 'in-progress': return '🔄';
+    case 'todo': return '📋';
+    default: return '❓';
+  }
+}
+
+/**
+ * Show specification details
+ */
+async function showSpecificationDetails(specId) {
+  const specDir = path.join(process.cwd(), 'specs', specId);
+  const specFile = path.join(specDir, 'spec.md');
+
+  if (!fs.existsSync(specFile)) {
+    console.log(chalk.red(`Specification ${specId} not found`));
+    return;
+  }
+
+  console.clear();
+  console.log(chalk.cyan(`\n📋 Specification: ${specId}\n`));
+
+  try {
+    const content = fs.readFileSync(specFile, 'utf8');
+    console.log(content);
+  } catch (error) {
+    console.log(chalk.red('Error reading specification: ' + error.message));
+  }
+
+  console.log(chalk.gray('\n─'.repeat(50)));
+  console.log(chalk.gray('Press Enter to return to specifications list...'));
+
+  // Wait for user input - specifically Enter key
+  const readline = require('readline');
+  readline.emitKeypressEvents(process.stdin);
+  if (process.stdin.isTTY && process.stdin.setRawMode) {
+    process.stdin.setRawMode(true);
+  }
+
+  return new Promise(resolve => {
+    const onKeypress = (str, key) => {
+      // Only accept Enter key or Escape
+      if (key && (key.name === 'return' || key.name === 'escape')) {
+        cleanup();
+        resolve();
+        return;
+      }
+    };
+
+    const cleanup = () => {
+      if (process.stdin.isTTY && process.stdin.setRawMode) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.removeListener('keypress', onKeypress);
+      process.stdin.pause();
+    };
+
+    process.stdin.on('keypress', onKeypress);
+    process.stdin.resume();
+  });
+}
+
+/**
+ * Create new specification
+ */
+async function createNewSpecification() {
+  const inquirer = require('inquirer');
+
+  console.log(chalk.cyan('\n📝 Create New Specification\n'));
+
+  const { specName } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'specName',
+      message: 'Specification name (e.g., 008-new-feature):',
+      validate: (input) => {
+        if (!input.trim()) return 'Specification name is required';
+        if (!/^\d{3}-.+$/.test(input.trim())) {
+          return 'Please use format: ###-description (e.g., 008-new-feature)';
+        }
+        return true;
+      }
+    }
+  ]);
+
+  const specDir = path.join(process.cwd(), 'specs', specName.trim());
+
+  if (fs.existsSync(specDir)) {
+    console.log(chalk.yellow(`Specification ${specName} already exists`));
+    return;
+  }
+
+  // Create spec directory
+  fs.mkdirSync(specDir, { recursive: true });
+
+  // Create spec.md with template
+  const template = `# ${specName}
+
+## Background
+
+<!-- Describe the context and motivation for this feature -->
+
+## User Stories
+
+### US-001 — [Story Title] (P1)
+As a [user type], I want [goal] so that [benefit].
+
+**Acceptance Criteria:**
+- [ ] Criterion 1
+- [ ] Criterion 2
+- [ ] Criterion 3
+
+## Functional Requirements
+
+### FR-001
+[Requirement description]
+
+### FR-002
+[Requirement description]
+
+## Success Criteria
+
+### SC-001
+[Measurable success criterion]
+
+## Edge Cases
+
+### EC-001
+[Edge case description and handling]
+
+## Implementation Notes
+
+[Technical implementation details and considerations]
+`;
+
+  fs.writeFileSync(path.join(specDir, 'spec.md'), template);
+
+  console.log(chalk.green(`\n✓ Specification ${specName} created successfully`));
+  console.log(chalk.gray(`Location: ${specDir}/spec.md`));
+}
+
+module.exports = {
+  showSpecificationsList,
+  getSpecsList,
+  showSpecificationDetails,
+  createNewSpecification,
+  extractPhases,
+  extractUserStories, // legacy alias
+};

package/src/utils/trui-text-editor.js

@@ -0,0 +1,350 @@
+/**
+ * TRUI Multi-line Text Editor
+ *
+ * Provides a simple multi-line text editor for requirement descriptions,
+ * clarification responses, and feedback text.
+ */
+
+const chalk = require('chalk');
+const readline = require('readline');
+const { debugLogger } = require('./trui-debug');
+
+/**
+ * Multi-line text editor with basic navigation
+ */
+class MultiLineEditor {
+  constructor(options = {}) {
+    this.lines = options.initialText ? options.initialText.split('\n') : [''];
+    this.cursorX = 0;
+    this.cursorY = 0;
+    this.scrollY = 0;
+    this.maxLines = options.maxLines || 20;
+    this.maxWidth = options.maxWidth || 80;
+    this.prompt = options.prompt || '> ';
+    this.isEditing = false;
+    this.rl = null;
+  }
+
+  /**
+   * Start the editor
+   */
+  async start() {
+    return new Promise((resolve) => {
+      this.isEditing = true;
+      this.resolve = resolve;
+
+      // Set up readline interface
+      this.rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true
+      });
+
+      // Hide cursor initially
+      process.stdout.write('\x1B[?25l');
+
+      // Set up raw mode for direct key handling
+      if (process.stdin.isTTY && process.stdin.setRawMode) {
+        process.stdin.setRawMode(true);
+      }
+
+      // Render initial state
+      this.render();
+
+      // Set up keypress handling
+      this.setupKeypressHandling();
+    });
+  }
+
+  /**
+   * Set up keypress handling for the editor
+   */
+  setupKeypressHandling() {
+    const onKeypress = (str, key) => {
+      if (!this.isEditing) return;
+
+      debugLogger.info('Editor keypress', { str, key: key ? { name: key.name, ctrl: key.ctrl, shift: key.shift } : null });
+
+      // Handle special keys
+      if (key) {
+        if (key.ctrl && key.name === 'c') {
+          // Cancel with Ctrl+C
+          this.cleanup();
+          this.resolve(null);
+          return;
+        }
+
+        if (key.ctrl && key.name === 'd') {
+          // Finish with Ctrl+D
+          this.cleanup();
+          this.resolve(this.getText());
+          return;
+        }
+
+        if (key.name === 'escape') {
+          // Cancel with Escape
+          this.cleanup();
+          this.resolve(null);
+          return;
+        }
+
+        if (key.name === 'return') {
+          // New line
+          this.insertNewline();
+          this.render();
+          return;
+        }
+
+        if (key.name === 'backspace') {
+          // Backspace
+          this.backspace();
+          this.render();
+          return;
+        }
+
+        if (key.name === 'delete') {
+          // Delete
+          this.delete();
+          this.render();
+          return;
+        }
+
+        if (key.name === 'up') {
+          // Move cursor up
+          this.moveCursorUp();
+          this.render();
+          return;
+        }
+
+        if (key.name === 'down') {
+          // Move cursor down
+          this.moveCursorDown();
+          this.render();
+          return;
+        }
+
+        if (key.name === 'left') {
+          // Move cursor left
+          this.moveCursorLeft();
+          this.render();
+          return;
+        }
+
+        if (key.name === 'right') {
+          // Move cursor right
+          this.moveCursorRight();
+          this.render();
+          return;
+        }
+
+        if (key.name === 'home') {
+          // Move to start of line
+          this.cursorX = 0;
+          this.render();
+          return;
+        }
+
+        if (key.name === 'end') {
+          // Move to end of line
+          this.cursorX = this.lines[this.cursorY].length;
+          this.render();
+          return;
+        }
+      }
+
+      // Handle regular characters
+      if (str && str.length === 1 && str.charCodeAt(0) >= 32 && str.charCodeAt(0) <= 126) {
+        this.insertCharacter(str);
+        this.render();
+      }
+    };
+
+    // Set up keypress event handling
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.on('keypress', onKeypress);
+    this.keypressHandler = onKeypress;
+  }
+
+  /**
+   * Insert a character at cursor position
+   */
+  insertCharacter(char) {
+    const line = this.lines[this.cursorY];
+    this.lines[this.cursorY] = line.slice(0, this.cursorX) + char + line.slice(this.cursorX);
+    this.cursorX++;
+  }
+
+  /**
+   * Insert a new line
+   */
+  insertNewline() {
+    const line = this.lines[this.cursorY];
+    const beforeCursor = line.slice(0, this.cursorX);
+    const afterCursor = line.slice(this.cursorX);
+
+    this.lines[this.cursorY] = beforeCursor;
+    this.lines.splice(this.cursorY + 1, 0, afterCursor);
+
+    this.cursorX = 0;
+    this.cursorY++;
+
+    // Ensure we don't exceed max lines
+    if (this.lines.length > this.maxLines) {
+      this.lines.shift();
+      this.cursorY--;
+    }
+  }
+
+  /**
+   * Delete character before cursor
+   */
+  backspace() {
+    if (this.cursorX > 0) {
+      const line = this.lines[this.cursorY];
+      this.lines[this.cursorY] = line.slice(0, this.cursorX - 1) + line.slice(this.cursorX);
+      this.cursorX--;
+    } else if (this.cursorY > 0) {
+      // Join with previous line
+      const prevLine = this.lines[this.cursorY - 1];
+      const currentLine = this.lines[this.cursorY];
+      this.cursorX = prevLine.length;
+      this.lines[this.cursorY - 1] = prevLine + currentLine;
+      this.lines.splice(this.cursorY, 1);
+      this.cursorY--;
+    }
+  }
+
+  /**
+   * Delete character at cursor
+   */
+  delete() {
+    const line = this.lines[this.cursorY];
+    if (this.cursorX < line.length) {
+      this.lines[this.cursorY] = line.slice(0, this.cursorX) + line.slice(this.cursorX + 1);
+    } else if (this.cursorY < this.lines.length - 1) {
+      // Join with next line
+      const currentLine = this.lines[this.cursorY];
+      const nextLine = this.lines[this.cursorY + 1];
+      this.lines[this.cursorY] = currentLine + nextLine;
+      this.lines.splice(this.cursorY + 1, 1);
+    }
+  }
+
+  /**
+   * Move cursor up
+   */
+  moveCursorUp() {
+    if (this.cursorY > 0) {
+      this.cursorY--;
+      const lineLength = this.lines[this.cursorY].length;
+      this.cursorX = Math.min(this.cursorX, lineLength);
+    }
+  }
+
+  /**
+   * Move cursor down
+   */
+  moveCursorDown() {
+    if (this.cursorY < this.lines.length - 1) {
+      this.cursorY++;
+      const lineLength = this.lines[this.cursorY].length;
+      this.cursorX = Math.min(this.cursorX, lineLength);
+    }
+  }
+
+  /**
+   * Move cursor left
+   */
+  moveCursorLeft() {
+    if (this.cursorX > 0) {
+      this.cursorX--;
+    }
+  }
+
+  /**
+   * Move cursor right
+   */
+  moveCursorRight() {
+    const lineLength = this.lines[this.cursorY].length;
+    if (this.cursorX < lineLength) {
+      this.cursorX++;
+    }
+  }
+
+  /**
+   * Render the editor
+   */
+  render() {
+    // Clear screen and move to top
+    process.stdout.write('\x1B[2J\x1B[H');
+
+    // Show instructions
+    console.log(chalk.cyan('Multi-line Editor'));
+    console.log(chalk.gray('Ctrl+D: Save & Exit  |  Ctrl+C/ESC: Cancel  |  Arrow Keys: Navigate'));
+    console.log(chalk.gray('─'.repeat(50)));
+
+    // Show lines
+    const visibleLines = this.lines.slice(this.scrollY, this.scrollY + this.maxLines);
+    visibleLines.forEach((line, index) => {
+      const actualIndex = this.scrollY + index;
+      const isCursorLine = actualIndex === this.cursorY;
+      const lineNumber = chalk.gray(`${(actualIndex + 1).toString().padStart(2)}: `);
+
+      if (isCursorLine) {
+        const beforeCursor = line.slice(0, this.cursorX);
+        const atCursor = line.slice(this.cursorX, this.cursorX + 1) || ' ';
+        const afterCursor = line.slice(this.cursorX + 1);
+
+        console.log(`${lineNumber}${beforeCursor}${chalk.bgCyan(atCursor)}${afterCursor}`);
+      } else {
+        console.log(`${lineNumber}${line}`);
+      }
+    });
+
+    // Show status
+    const status = `Line ${this.cursorY + 1}/${this.lines.length} | Col ${this.cursorX + 1}`;
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(chalk.cyan(status));
+  }
+
+  /**
+   * Get the edited text
+   */
+  getText() {
+    return this.lines.join('\n').trim();
+  }
+
+  /**
+   * Clean up resources
+   */
+  cleanup() {
+    this.isEditing = false;
+
+    if (this.keypressHandler) {
+      process.stdin.removeListener('keypress', this.keypressHandler);
+    }
+
+    if (this.rl) {
+      this.rl.close();
+    }
+
+    if (process.stdin.isTTY && process.stdin.setRawMode) {
+      process.stdin.setRawMode(false);
+    }
+
+    // Show cursor again
+    process.stdout.write('\x1B[?25h');
+
+    debugLogger.info('Editor cleaned up');
+  }
+}
+
+/**
+ * Show multi-line editor
+ */
+async function showMultiLineEditor(options = {}) {
+  const editor = new MultiLineEditor(options);
+  return await editor.start();
+}
+
+module.exports = { MultiLineEditor, showMultiLineEditor };