vibecodingmachine-cli 2026.2.26-1752 → 2026.3.9-1621

package/src/commands/requirements/enable.js

@@ -0,0 +1,97 @@
+/**
+ * CLI Command: Enable Requirement
+ * 
+ * Implements "app enable requirement" command for CLI interface.
+ * Follows constitutional requirements: <800 lines, test-first approach.
+ */
+
+const { enableRequirement } = require('@vibecodingmachine/core/src/utils/requirement-enable-disable');
+
+/**
+ * CLI enable requirement command implementation
+ */
+class EnableRequirementCommand {
+  /**
+   * Create command instance
+   * @param {Object} options - Command options
+   */
+  constructor(options = {}) {
+    this.options = options;
+  }
+
+  /**
+   * Execute enable 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 enable requirement <requirementText>',
+          examples: [
+            'app enable requirement "Add user authentication"',
+            'app enable requirement "Implement OAuth2 login"'
+          ]
+        };
+      }
+
+      // Call core enable function
+      const result = await enableRequirement(requirementText);
+      
+      if (!result.success) {
+        return {
+          success: false,
+          error: result.message
+        };
+      }
+
+      return {
+        success: true,
+        message: result.message,
+        data: {
+          requirementText,
+          status: 'enabled',
+          enabledAt: new Date().toISOString()
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to enable requirement: ${error.message}`
+      };
+    }
+  }
+
+  /**
+   * Get command help
+   * @returns {string} - Help text
+   */
+  getHelp() {
+    return `
+Enable a requirement
+
+Usage:
+  app enable requirement <requirementText>
+
+Arguments:
+  requirementText  Exact text of the requirement to enable
+
+Examples:
+  app enable requirement "Add user authentication"
+  app enable requirement "Implement OAuth2 login"
+  app enable requirement "Create user registration page"
+
+Description:
+  Enables a requirement that was previously disabled by removing the DISABLED: prefix.
+  Enabled requirements will be processed by auto-mode when running "start auto".
+    `.trim();
+  }
+}
+
+module.exports = EnableRequirementCommand;

package/src/commands/requirements/utils.js

@@ -0,0 +1,194 @@
+/**
+ * Requirements Command Utilities
+ * 
+ * Shared utilities for requirements command operations
+ */
+
+const path = require('path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const { getRepoPath, setRepoPath } = require('../../utils/config');
+const { getRequirementsPath } = require('vibecodingmachine-core');
+
+/**
+ * Get requirements path or exit
+ * @returns {Promise<Object>} Repository and requirements paths
+ */
+async function getReqPathOrExit() {
+  let repoPath = await getRepoPath();
+
+  // Auto-detect and initialize if we're in a git repository
+  if (!repoPath) {
+    const currentDir = process.cwd();
+    if (fs.existsSync(path.join(currentDir, '.git'))) {
+      console.log(chalk.yellow('No repository configured. Auto-detecting git repository...'));
+      repoPath = currentDir;
+      await setRepoPath(repoPath);
+      console.log(chalk.green(`Repository set to: ${repoPath}`));
+    } else {
+      console.error(chalk.red('No repository configured. Run "app init" first.'));
+      process.exit(1);
+    }
+  }
+
+  const reqPath = getRequirementsPath(repoPath);
+  return { repoPath, reqPath };
+}
+
+/**
+ * Ensure requirements file exists
+ * @param {string} reqPath - Requirements file path
+ */
+async function ensureRequirementsFile(reqPath) {
+  await fs.ensureFile(reqPath);
+  
+  // Check if file is empty and create initial structure
+  const content = await fs.readFile(reqPath, 'utf8');
+  if (!content.trim()) {
+    await fs.writeJson(reqPath, {
+      requirements: [],
+      current: null,
+      created: new Date().toISOString(),
+      version: '1.0'
+    }, { spaces: 2 });
+  }
+}
+
+/**
+ * Load requirements from file
+ * @param {string} reqPath - Requirements file path
+ * @returns {Promise<Object>} Requirements data
+ */
+async function loadRequirements(reqPath) {
+  try {
+    if (!await fs.pathExists(reqPath)) {
+      return { requirements: [], current: null };
+    }
+    return await fs.readJson(reqPath);
+  } catch (error) {
+    console.error(chalk.red('Error loading requirements:'), error.message);
+    return { requirements: [], current: null };
+  }
+}
+
+/**
+ * Save requirements to file
+ * @param {string} reqPath - Requirements file path
+ * @param {Object} data - Requirements data
+ */
+async function saveRequirements(reqPath, data) {
+  try {
+    data.updated = new Date().toISOString();
+    await fs.writeJson(reqPath, data, { spaces: 2 });
+  } catch (error) {
+    console.error(chalk.red('Error saving requirements:'), error.message);
+    throw error;
+  }
+}
+
+/**
+ * Find requirement by title
+ * @param {Array} requirements - Requirements array
+ * @param {string} title - Requirement title
+ * @returns {Object|null} Found requirement
+ */
+function findRequirementByTitle(requirements, title) {
+  return requirements.find(req => req.title === title);
+}
+
+/**
+ * Find requirement by ID
+ * @param {Array} requirements - Requirements array
+ * @param {string} id - Requirement ID
+ * @returns {Object|null} Found requirement
+ */
+function findRequirementById(requirements, id) {
+  return requirements.find(req => req.id === id);
+}
+
+/**
+ * Generate unique requirement ID
+ * @param {Array} requirements - Existing requirements
+ * @returns {string} Unique ID
+ */
+function generateRequirementId(requirements) {
+  const maxId = requirements.reduce((max, req) => {
+    const match = req.id && req.id.match(/^R(\d+)$/);
+    return match ? Math.max(max, parseInt(match[1])) : max;
+  }, 0);
+  
+  return `R${maxId + 1}`;
+}
+
+/**
+ * Validate requirement data
+ * @param {Object} requirement - Requirement object
+ * @returns {boolean} Whether requirement is valid
+ */
+function validateRequirement(requirement) {
+  return (
+    requirement &&
+    typeof requirement.title === 'string' &&
+    requirement.title.trim().length > 0 &&
+    typeof requirement.description === 'string' &&
+    requirement.description.trim().length > 0
+  );
+}
+
+/**
+ * Format requirement for display
+ * @param {Object} requirement - Requirement object
+ * @param {boolean} showCurrent - Whether to show current indicator
+ * @returns {string} Formatted requirement string
+ */
+function formatRequirement(requirement, showCurrent = false) {
+  const current = showCurrent && requirement.current ? ' (CURRENT)' : '';
+  const status = requirement.status ? ` [${requirement.status}]` : '';
+  const id = requirement.id ? `${requirement.id}: ` : '';
+  
+  return `${chalk.cyan(id)}${chalk.white(requirement.title)}${status}${current}`;
+}
+
+/**
+ * Open file in default editor
+ * @param {string} filePath - File path to open
+ */
+async function openInEditor(filePath) {
+  const { exec } = require('child_process');
+  const platform = process.platform;
+  
+  let command;
+  switch (platform) {
+    case 'darwin':
+      command = `open "${filePath}"`;
+      break;
+    case 'win32':
+      command = `start "" "${filePath}"`;
+      break;
+    default:
+      command = `xdg-open "${filePath}"`;
+  }
+  
+  return new Promise((resolve, reject) => {
+    exec(command, (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+module.exports = {
+  getReqPathOrExit,
+  ensureRequirementsFile,
+  loadRequirements,
+  saveRequirements,
+  findRequirementByTitle,
+  findRequirementById,
+  generateRequirementId,
+  validateRequirement,
+  formatRequirement,
+  openInEditor
+};

package/src/commands/requirements-refactored.js

@@ -0,0 +1,60 @@
+/**
+ * Refactored Requirements Commands
+ * 
+ * Splits monolithic requirements command into modular components
+ */
+
+// Import command modules
+const {
+  list,
+  add,
+  current,
+  next,
+  edit,
+  watch,
+  rename,
+  working,
+  numberAll
+} = require('./requirements/commands');
+
+const {
+  createDefault,
+  editDefault,
+  deleteDefault,
+  showDefault,
+  pauseDefault,
+  resumeDefault,
+  setMaxIterations
+} = require('./requirements/default-handlers');
+
+// Export all commands for compatibility
+module.exports = {
+  // Basic requirement commands
+  list,
+  add,
+  current,
+  next,
+  edit,
+  watch,
+  rename,
+  working,
+  numberAll,
+  
+  // Default requirement commands
+  'default:create': createDefault,
+  'default:edit': editDefault,
+  'default:delete': deleteDefault,
+  'default:show': showDefault,
+  'default:pause': pauseDefault,
+  'default:resume': resumeDefault,
+  'default:max-iterations': setMaxIterations,
+  
+  // Aliases for backward compatibility
+  createDefault,
+  editDefault,
+  deleteDefault,
+  showDefault,
+  pauseDefault,
+  resumeDefault,
+  setMaxIterations
+};