vibecodingmachine-cli 2026.2.26-1739 → 2026.3.9-1621

package/src/commands/requirements/commands.js

@@ -0,0 +1,353 @@
+/**
+ * Requirements Commands
+ * 
+ * Core requirements management commands
+ */
+
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const chokidar = require('chokidar');
+const {
+  getReqPathOrExit,
+  ensureRequirementsFile,
+  loadRequirements,
+  saveRequirements,
+  findRequirementByTitle,
+  findRequirementById,
+  generateRequirementId,
+  validateRequirement,
+  formatRequirement,
+  openInEditor
+} = require('./utils');
+
+/**
+ * List all requirements
+ */
+async function list(options) {
+  try {
+    const { repoPath, reqPath } = await getReqPathOrExit();
+    
+    if (!await fs.pathExists(reqPath)) {
+      console.log(chalk.yellow('No requirements file found. Use "app req add" to create one.'));
+      return;
+    }
+
+    const data = await loadRequirements(reqPath);
+    const { requirements, current } = data;
+
+    if (requirements.length === 0) {
+      console.log(chalk.yellow('No requirements found.'));
+      return;
+    }
+
+    console.log(chalk.blue('\nRequirements:'));
+    
+    if (options.verbose) {
+      requirements.forEach((req, index) => {
+        const isCurrent = current && current.id === req.id;
+        console.log(`${index + 1}. ${formatRequirement(req, isCurrent)}`);
+        if (req.description) {
+          console.log(`   ${chalk.gray(req.description)}`);
+        }
+        if (req.package) {
+          console.log(`   ${chalk.cyan('Package:')} ${req.package}`);
+        }
+        if (req.created) {
+          console.log(`   ${chalk.gray('Created:')} ${new Date(req.created).toLocaleDateString()}`);
+        }
+        console.log();
+      });
+    } else {
+      requirements.forEach((req, index) => {
+        const isCurrent = current && current.id === req.id;
+        console.log(`${index + 1}. ${formatRequirement(req, isCurrent)}`);
+      });
+    }
+
+    if (current) {
+      console.log(chalk.green(`\nCurrent: ${current.title}`));
+    }
+  } catch (error) {
+    console.error(chalk.red('Error listing requirements:'), error.message);
+  }
+}
+
+/**
+ * Add a new requirement
+ */
+async function add(name, pkg, description) {
+  try {
+    const { reqPath, repoPath } = await getReqPathOrExit();
+    await ensureRequirementsFile(reqPath);
+
+    const data = await loadRequirements(reqPath);
+    const { requirements } = data;
+
+    // Check for duplicate
+    if (findRequirementByTitle(requirements, name)) {
+      console.error(chalk.red('Requirement with this title already exists.'));
+      return;
+    }
+
+    // Create new requirement
+    const requirement = {
+      id: generateRequirementId(requirements),
+      title: name,
+      description: description || '',
+      package: pkg || '',
+      status: 'pending',
+      created: new Date().toISOString(),
+      updated: new Date().toISOString()
+    };
+
+    if (!validateRequirement(requirement)) {
+      console.error(chalk.red('Invalid requirement data.'));
+      return;
+    }
+
+    requirements.push(requirement);
+    await saveRequirements(reqPath, data);
+
+    console.log(chalk.green('Requirement added successfully:'));
+    console.log(`  ${formatRequirement(requirement)}`);
+  } catch (error) {
+    console.error(chalk.red('Error adding requirement:'), error.message);
+  }
+}
+
+/**
+ * Show current requirement
+ */
+async function current() {
+  try {
+    const { reqPath } = await getReqPathOrExit();
+    
+    if (!await fs.pathExists(reqPath)) {
+      console.log(chalk.yellow('No requirements file found.'));
+      return;
+    }
+
+    const data = await loadRequirements(reqPath);
+    const { current } = data;
+
+    if (!current) {
+      console.log(chalk.yellow('No current requirement set.'));
+      return;
+    }
+
+    console.log(chalk.blue('\nCurrent Requirement:'));
+    console.log(`  ${formatRequirement(current, true)}`);
+    
+    if (current.description) {
+      console.log(chalk.gray(`\nDescription: ${current.description}`));
+    }
+    
+    if (current.package) {
+      console.log(chalk.cyan(`Package: ${current.package}`));
+    }
+  } catch (error) {
+    console.error(chalk.red('Error getting current requirement:'), error.message);
+  }
+}
+
+/**
+ * Set next requirement as current
+ */
+async function next() {
+  try {
+    const { reqPath } = await getReqPathOrExit();
+    
+    if (!await fs.pathExists(reqPath)) {
+      console.log(chalk.yellow('No requirements file found.'));
+      return;
+    }
+
+    const data = await loadRequirements(reqPath);
+    const { requirements, current } = data;
+
+    if (requirements.length === 0) {
+      console.log(chalk.yellow('No requirements found.'));
+      return;
+    }
+
+    // Find next requirement
+    let nextReq;
+    if (!current) {
+      nextReq = requirements[0];
+    } else {
+      const currentIndex = requirements.findIndex(req => req.id === current.id);
+      if (currentIndex >= 0 && currentIndex < requirements.length - 1) {
+        nextReq = requirements[currentIndex + 1];
+      } else {
+        console.log(chalk.yellow('Already at the last requirement.'));
+        return;
+      }
+    }
+
+    // Update current
+    data.current = nextReq;
+    await saveRequirements(reqPath, data);
+
+    console.log(chalk.green('Current requirement updated:'));
+    console.log(`  ${formatRequirement(nextReq, true)}`);
+  } catch (error) {
+    console.error(chalk.red('Error setting next requirement:'), error.message);
+  }
+}
+
+/**
+ * Edit requirements file
+ */
+async function edit() {
+  try {
+    const { reqPath } = await getReqPathOrExit();
+    
+    if (!await fs.pathExists(reqPath)) {
+      console.log(chalk.yellow('No requirements file found. Creating new one...'));
+      await ensureRequirementsFile(reqPath);
+    }
+
+    console.log(chalk.gray('Opening requirements file in default editor...'));
+    await openInEditor(reqPath);
+  } catch (error) {
+    console.error(chalk.red('Error editing requirements:'), error.message);
+  }
+}
+
+/**
+ * Watch requirements file for changes
+ */
+async function watch() {
+  try {
+    const { reqPath } = await getReqPathOrExit();
+    
+    if (!await fs.pathExists(reqPath)) {
+      console.log(chalk.yellow('No requirements file found.'));
+      return;
+    }
+
+    console.log(chalk.gray('Watching:'), chalk.cyan(reqPath));
+    
+    const watcher = chokidar.watch(reqPath);
+    
+    watcher.on('change', async () => {
+      console.log(chalk.blue('\nRequirements file changed. Reloading...'));
+      const data = await loadRequirements(reqPath);
+      const { requirements, current } = data;
+      
+      console.log(chalk.green(`Found ${requirements.length} requirements`));
+      if (current) {
+        console.log(chalk.cyan(`Current: ${current.title}`));
+      }
+    });
+    
+    console.log(chalk.green('Watching for changes. Press Ctrl+C to stop.'));
+    
+  } catch (error) {
+    console.error(chalk.red('Error watching requirements:'), error.message);
+  }
+}
+
+/**
+ * Rename a requirement
+ */
+async function rename(oldTitle, newTitle, description) {
+  try {
+    const { reqPath } = await getReqPathOrExit();
+    
+    if (!await fs.pathExists(reqPath)) {
+      console.log(chalk.yellow('No requirements file found.'));
+      return;
+    }
+
+    const data = await loadRequirements(reqPath);
+    const { requirements, current } = data;
+
+    const requirement = findRequirementByTitle(requirements, oldTitle);
+    if (!requirement) {
+      console.error(chalk.red('Requirement not found.'));
+      return;
+    }
+
+    // Check for duplicate new title
+    if (findRequirementByTitle(requirements, newTitle)) {
+      console.error(chalk.red('A requirement with the new title already exists.'));
+      return;
+    }
+
+    // Update requirement
+    requirement.title = newTitle;
+    requirement.updated = new Date().toISOString();
+    
+    if (description) {
+      requirement.description = description;
+    }
+
+    // Update current if needed
+    if (current && current.id === requirement.id) {
+      data.current = requirement;
+    }
+
+    await saveRequirements(reqPath, data);
+
+    console.log(chalk.green('Requirement renamed successfully:'));
+    console.log(`  ${formatRequirement(requirement)}`);
+  } catch (error) {
+    console.error(chalk.red('Error renaming requirement:'), error.message);
+  }
+}
+
+/**
+ * Show working requirement (alias for current)
+ */
+async function working() {
+  return await current();
+}
+
+/**
+ * Number all requirements
+ */
+async function numberAll() {
+  try {
+    const { reqPath, repoPath } = await getReqPathOrExit();
+    
+    if (!await fs.pathExists(reqPath)) {
+      console.log(chalk.yellow('No requirements file found.'));
+      return;
+    }
+
+    const data = await loadRequirements(reqPath);
+    const { requirements } = data;
+
+    let changed = false;
+    requirements.forEach((req, index) => {
+      const newId = `R${index + 1}`;
+      if (req.id !== newId) {
+        req.id = newId;
+        req.updated = new Date().toISOString();
+        changed = true;
+      }
+    });
+
+    if (changed) {
+      await saveRequirements(reqPath, data);
+      console.log(chalk.green('Requirements renumbered successfully.'));
+    } else {
+      console.log(chalk.gray('Requirements already numbered correctly.'));
+    }
+  } catch (error) {
+    console.error(chalk.red('Error numbering requirements:'), error.message);
+  }
+}
+
+module.exports = {
+  list,
+  add,
+  current,
+  next,
+  edit,
+  watch,
+  rename,
+  working,
+  numberAll
+};

package/src/commands/requirements/default-handlers.js

@@ -0,0 +1,272 @@
+/**
+ * Default Requirement Handlers
+ * 
+ * Commands for managing default requirements
+ */
+
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const path = require('path');
+const { getRepoPath } = require('../../utils/config');
+const { DefaultRequirementManager, JSONStorage } = require('vibecodingmachine-core');
+
+/**
+ * Create a new default requirement
+ */
+async function createDefault(title, options = {}) {
+  const { description, maxIterations } = options;
+  const repoPath = await getRepoPath();
+  
+  if (!repoPath) {
+    console.error(chalk.red('No repository configured. Run "app init" first.'));
+    return;
+  }
+
+  try {
+    const storage = new JSONStorage(path.join(repoPath, '.vibecodingmachine'));
+    const manager = new DefaultRequirementManager(storage);
+    
+    await manager.create({
+      title,
+      description: description || '',
+      maxIterations: maxIterations || 5
+    });
+    
+    console.log(chalk.green('Default requirement created successfully:'));
+    console.log(`  ${chalk.cyan('Title:')} ${title}`);
+    if (description) {
+      console.log(`  ${chalk.gray('Description:')} ${description}`);
+    }
+    console.log(`  ${chalk.yellow('Max Iterations:')} ${maxIterations || 5}`);
+    
+  } catch (error) {
+    console.error(chalk.red('Error creating default requirement:'), error.message);
+  }
+}
+
+/**
+ * Edit existing default requirement
+ */
+async function editDefault(options = {}) {
+  const { title, description, maxIterations } = options;
+  const repoPath = await getRepoPath();
+  
+  if (!repoPath) {
+    console.error(chalk.red('No repository configured. Run "app init" first.'));
+    return;
+  }
+
+  try {
+    const storage = new JSONStorage(path.join(repoPath, '.vibecodingmachine'));
+    const manager = new DefaultRequirementManager(storage);
+    
+    const current = await manager.getCurrent();
+    if (!current) {
+      console.error(chalk.red('No default requirement found. Create one first.'));
+      return;
+    }
+
+    const updates = {};
+    if (title !== undefined) updates.title = title;
+    if (description !== undefined) updates.description = description;
+    if (maxIterations !== undefined) updates.maxIterations = maxIterations;
+
+    await manager.update(current.id, updates);
+    
+    console.log(chalk.green('Default requirement updated successfully:'));
+    
+    const updated = await manager.getCurrent();
+    console.log(`  ${chalk.cyan('Title:')} ${updated.title}`);
+    if (updated.description) {
+      console.log(`  ${chalk.gray('Description:')} ${updated.description}`);
+    }
+    console.log(`  ${chalk.yellow('Max Iterations:')} ${updated.maxIterations}`);
+    
+  } catch (error) {
+    console.error(chalk.red('Error editing default requirement:'), error.message);
+  }
+}
+
+/**
+ * Delete default requirement
+ */
+async function deleteDefault() {
+  const repoPath = await getRepoPath();
+  
+  if (!repoPath) {
+    console.error(chalk.red('No repository configured. Run "app init" first.'));
+    return;
+  }
+
+  try {
+    const storage = new JSONStorage(path.join(repoPath, '.vibecodingmachine'));
+    const manager = new DefaultRequirementManager(storage);
+    
+    const current = await manager.getCurrent();
+    if (!current) {
+      console.error(chalk.red('No default requirement found.'));
+      return;
+    }
+
+    await manager.delete(current.id);
+    console.log(chalk.green('Default requirement deleted successfully.'));
+    
+  } catch (error) {
+    console.error(chalk.red('Error deleting default requirement:'), error.message);
+  }
+}
+
+/**
+ * Show current default requirement status
+ */
+async function showDefault() {
+  const repoPath = await getRepoPath();
+  
+  if (!repoPath) {
+    console.error(chalk.red('No repository configured. Run "app init" first.'));
+    return;
+  }
+
+  try {
+    const storage = new JSONStorage(path.join(repoPath, '.vibecodingmachine'));
+    const manager = new DefaultRequirementManager(storage);
+    
+    const current = await manager.getCurrent();
+    if (!current) {
+      console.log(chalk.yellow('No default requirement found.'));
+      return;
+    }
+
+    console.log(chalk.blue('\nDefault Requirement:'));
+    console.log(`  ${chalk.cyan('ID:')} ${current.id}`);
+    console.log(`  ${chalk.cyan('Title:')} ${current.title}`);
+    
+    if (current.description) {
+      console.log(`  ${chalk.gray('Description:')} ${current.description}`);
+    }
+    
+    console.log(`  ${chalk.yellow('Max Iterations:')} ${current.maxIterations}`);
+    console.log(`  ${chalk.gray('Status:')} ${current.status}`);
+    
+    if (current.createdAt) {
+      console.log(`  ${chalk.gray('Created:')} ${new Date(current.createdAt).toLocaleString()}`);
+    }
+    
+    if (current.updatedAt) {
+      console.log(`  ${chalk.gray('Updated:')} ${new Date(current.updatedAt).toLocaleString()}`);
+    }
+    
+    if (current.iterations && current.iterations.length > 0) {
+      console.log(`  ${chalk.blue('Iterations:')} ${current.iterations.length}`);
+      current.iterations.forEach((iteration, index) => {
+        const status = iteration.completed ? '✓' : '○';
+        console.log(`    ${index + 1}. ${status} ${iteration.summary || 'No summary'}`);
+      });
+    }
+    
+  } catch (error) {
+    console.error(chalk.red('Error showing default requirement:'), error.message);
+  }
+}
+
+/**
+ * Pause default requirement
+ */
+async function pauseDefault() {
+  const repoPath = await getRepoPath();
+  
+  if (!repoPath) {
+    console.error(chalk.red('No repository configured. Run "app init" first.'));
+    return;
+  }
+
+  try {
+    const storage = new JSONStorage(path.join(repoPath, '.vibecodingmachine'));
+    const manager = new DefaultRequirementManager(storage);
+    
+    const current = await manager.getCurrent();
+    if (!current) {
+      console.error(chalk.red('No default requirement found.'));
+      return;
+    }
+
+    await manager.pause(current.id);
+    console.log(chalk.green('Default requirement paused successfully.'));
+    
+  } catch (error) {
+    console.error(chalk.red('Error pausing default requirement:'), error.message);
+  }
+}
+
+/**
+ * Resume default requirement
+ */
+async function resumeDefault() {
+  const repoPath = await getRepoPath();
+  
+  if (!repoPath) {
+    console.error(chalk.red('No repository configured. Run "app init" first.'));
+    return;
+  }
+
+  try {
+    const storage = new JSONStorage(path.join(repoPath, '.vibecodingmachine'));
+    const manager = new DefaultRequirementManager(storage);
+    
+    const current = await manager.getCurrent();
+    if (!current) {
+      console.error(chalk.red('No default requirement found.'));
+      return;
+    }
+
+    await manager.resume(current.id);
+    console.log(chalk.green('Default requirement resumed successfully.'));
+    
+  } catch (error) {
+    console.error(chalk.red('Error resuming default requirement:'), error.message);
+  }
+}
+
+/**
+ * Set max iterations for default requirement
+ */
+async function setMaxIterations(maxIterations) {
+  const repoPath = await getRepoPath();
+  
+  if (!repoPath) {
+    console.error(chalk.red('No repository configured. Run "app init" first.'));
+    return;
+  }
+
+  if (!maxIterations || maxIterations < 1) {
+    console.error(chalk.red('Max iterations must be a positive number.'));
+    return;
+  }
+
+  try {
+    const storage = new JSONStorage(path.join(repoPath, '.vibecodingmachine'));
+    const manager = new DefaultRequirementManager(storage);
+    
+    const current = await manager.getCurrent();
+    if (!current) {
+      console.error(chalk.red('No default requirement found.'));
+      return;
+    }
+
+    await manager.update(current.id, { maxIterations: parseInt(maxIterations) });
+    console.log(chalk.green(`Max iterations set to ${maxIterations}`));
+    
+  } catch (error) {
+    console.error(chalk.red('Error setting max iterations:'), error.message);
+  }
+}
+
+module.exports = {
+  createDefault,
+  editDefault,
+  deleteDefault,
+  showDefault,
+  pauseDefault,
+  resumeDefault,
+  setMaxIterations
+};

package/src/commands/requirements/disable.js

@@ -0,0 +1,97 @@
+/**
+ * CLI Command: Disable Requirement
+ * 
+ * Implements "app disable requirement" command for CLI interface.
+ * Follows constitutional requirements: <800 lines, test-first approach.
+ */
+
+const { disableRequirement } = require('@vibecodingmachine/core/src/utils/requirement-enable-disable');
+
+/**
+ * CLI disable requirement command implementation
+ */
+class DisableRequirementCommand {
+  /**
+   * Create command instance
+   * @param {Object} options - Command options
+   */
+  constructor(options = {}) {
+    this.options = options;
+  }
+
+  /**
+   * Execute disable requirement command
+   * @param {Array} args - Command arguments [requirementText]
+   * @param {Object} options - Command options
+   * @returns {Promise<Object>} - Command result
+   */
+  async execute(args = [], options = {}) {
+    try {
+      // Parse arguments - requirement text can contain spaces
+      const requirementText = args.join(' ');
+      if (!requirementText) {
+        return {
+          success: false,
+          error: 'Missing required argument: requirementText',
+          usage: 'app disable requirement <requirementText>',
+          examples: [
+            'app disable requirement "Add user authentication"',
+            'app disable requirement "Implement OAuth2 login"'
+          ]
+        };
+      }
+
+      // Call core disable function
+      const result = await disableRequirement(requirementText);
+      
+      if (!result.success) {
+        return {
+          success: false,
+          error: result.message
+        };
+      }
+
+      return {
+        success: true,
+        message: result.message,
+        data: {
+          requirementText,
+          status: 'disabled',
+          disabledAt: new Date().toISOString()
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to disable requirement: ${error.message}`
+      };
+    }
+  }
+
+  /**
+   * Get command help
+   * @returns {string} - Help text
+   */
+  getHelp() {
+    return `
+Disable a requirement
+
+Usage:
+  app disable requirement <requirementText>
+
+Arguments:
+  requirementText  Exact text of the requirement to disable
+
+Examples:
+  app disable requirement "Add user authentication"
+  app disable requirement "Implement OAuth2 login"
+  app disable requirement "Create user registration page"
+
+Description:
+  Disables a requirement by adding the DISABLED: prefix.
+  Disabled requirements will be skipped by auto-mode when running "start auto".
+    `.trim();
+  }
+}
+
+module.exports = DisableRequirementCommand;