vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/utils/rollback-manager.js

@@ -0,0 +1,202 @@
+/**
+ * Rollback Manager
+ * 
+ * Manages rollback capabilities for refactoring operations.
+ * Provides safe backup and restore functionality.
+ * 
+ * Refactored into modular components for better maintainability.
+ */
+
+const path = require('path');
+const { DEFAULT_BACKUP_DIR } = require('./rollback/rollback-types');
+const { RollbackOperation } = require('./rollback/rollback-operation');
+const { RollbackRecorder } = require('./rollback/rollback-recorder');
+const { RollbackHandlers } = require('./rollback/rollback-handlers');
+const { RollbackStateManager } = require('./rollback/rollback-state-manager');
+
+/**
+ * Main rollback manager class
+ */
+class RollbackManager {
+  constructor(backupDir = DEFAULT_BACKUP_DIR) {
+    this.backupDir = path.resolve(backupDir);
+    this.operations = [];
+    this.stateManager = new RollbackStateManager(this.backupDir);
+    this.sessionId = this.stateManager.generateSessionId();
+    this.recorder = new RollbackRecorder(this.backupDir, this.sessionId);
+    
+    this.ensureBackupDirectory();
+  }
+
+  /**
+   * Generate unique session ID
+   */
+  generateSessionId() {
+    return this.stateManager.generateSessionId();
+  }
+
+  /**
+   * Ensure backup directory exists
+   */
+  ensureBackupDirectory() {
+    this.stateManager.ensureBackupDirectory(this.sessionId);
+  }
+
+  /**
+   * Get session backup directory
+   */
+  getSessionBackupDir() {
+    return path.join(this.backupDir, this.sessionId);
+  }
+
+  /**
+   * Create backup of a file before modification
+   */
+  backupFile(filePath) {
+    const operation = this.recorder.backupFile(filePath);
+    this.operations.push(operation);
+    return operation;
+  }
+
+  /**
+   * Record file creation
+   */
+  recordFileCreation(filePath) {
+    const operation = this.recorder.recordFileCreation(filePath);
+    this.operations.push(operation);
+    return operation;
+  }
+
+  /**
+   * Record file deletion (with backup)
+   */
+  recordFileDeletion(filePath) {
+    const operation = this.recorder.recordFileDeletion(filePath);
+    this.operations.push(operation);
+    return operation;
+  }
+
+  /**
+   * Record file move/rename
+   */
+  recordFileMove(oldPath, newPath) {
+    const operation = this.recorder.recordFileMove(oldPath, newPath);
+    this.operations.push(operation);
+    return operation;
+  }
+
+  /**
+   * Record directory creation
+   */
+  recordDirectoryCreation(dirPath) {
+    const operation = this.recorder.recordDirectoryCreation(dirPath);
+    this.operations.push(operation);
+    return operation;
+  }
+
+  /**
+   * Record directory deletion (with backup)
+   */
+  recordDirectoryDeletion(dirPath) {
+    const operation = this.recorder.recordDirectoryDeletion(dirPath);
+    this.operations.push(operation);
+    return operation;
+  }
+
+  /**
+   * Execute rollback for all operations
+   */
+  async rollback() {
+    const results = {
+      success: [],
+      failed: [],
+      skipped: []
+    };
+
+    // Execute rollbacks in reverse order
+    for (let i = this.operations.length - 1; i >= 0; i--) {
+      const operation = this.operations[i];
+      
+      try {
+        await RollbackHandlers.rollbackOperation(operation);
+        results.success.push(operation);
+      } catch (error) {
+        operation.error = error.message;
+        results.failed.push(operation);
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Rollback a single operation
+   */
+  async rollbackOperation(operation) {
+    return await RollbackHandlers.rollbackOperation(operation);
+  }
+
+  /**
+   * Get operation summary
+   */
+  getSummary() {
+    return this.stateManager.generateSummary(this.sessionId, this.operations);
+  }
+
+  /**
+   * Save rollback state to file
+   */
+  saveState() {
+    const summary = this.getSummary();
+    return this.stateManager.saveState(this.sessionId, this.operations, summary);
+  }
+
+  /**
+   * Load rollback state from file
+   */
+  loadState(sessionId) {
+    const state = this.stateManager.loadState(sessionId);
+    this.sessionId = state.sessionId;
+    this.operations = state.operations;
+    this.recorder = new RollbackRecorder(this.backupDir, this.sessionId);
+    return state;
+  }
+
+  /**
+   * List available rollback sessions
+   */
+  listSessions() {
+    return this.stateManager.listSessions();
+  }
+
+  /**
+   * Cleanup old backup sessions
+   */
+  cleanup(maxAge) {
+    return this.stateManager.cleanup(maxAge);
+  }
+
+  /**
+   * Clear current session operations
+   */
+  clear() {
+    this.operations = [];
+  }
+
+  /**
+   * Get backup size
+   */
+  getBackupSize() {
+    return this.stateManager.getBackupSize(this.sessionId);
+  }
+}
+
+// Export all components for backward compatibility
+module.exports = {
+  RollbackManager,
+  RollbackOperation,
+  RollbackRecorder,
+  RollbackHandlers,
+  RollbackStateManager,
+  DEFAULT_BACKUP_DIR
+};

package/src/utils/smoke-test-cli.js

@@ -0,0 +1,362 @@
+/**
+ * CLI Smoke Testing Utility
+ * 
+ * Provides smoke testing functionality for the CLI interface
+ * to ensure it starts and responds to basic commands correctly.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+class CliSmokeTest {
+  constructor(options = {}) {
+    this.cliPath = options.cliPath || path.join(__dirname, '../../../cli/bin/vibecodingmachine.js');
+    this.timeout = options.timeout || 30000; // 30 seconds default
+    this.verbose = options.verbose || false;
+  }
+
+  /**
+   * Run comprehensive CLI smoke tests
+   * @returns {Promise<Object>} Test results
+   */
+  async runSmokeTests() {
+    const results = {
+      passed: 0,
+      failed: 0,
+      total: 0,
+      details: []
+    };
+
+    const tests = [
+      { name: 'CLI File Exists', test: () => this.testCliFileExists() },
+      { name: 'CLI Starts Without Crashing', test: () => this.testCliStarts() },
+      { name: 'CLI --help Command', test: () => this.testHelpCommand() },
+      { name: 'CLI --version Command', test: () => this.testVersionCommand() },
+      { name: 'CLI Basic Commands Available', test: () => this.testBasicCommands() }
+    ];
+
+    for (const test of tests) {
+      results.total++;
+      try {
+        const result = await test.test();
+        if (result.passed) {
+          results.passed++;
+          if (this.verbose) {
+            console.log(`✅ ${test.name}: PASSED`);
+          }
+        } else {
+          results.failed++;
+          console.error(`❌ ${test.name}: FAILED - ${result.error}`);
+        }
+        results.details.push({
+          name: test.name,
+          passed: result.passed,
+          error: result.error,
+          details: result.details
+        });
+      } catch (error) {
+        results.failed++;
+        console.error(`❌ ${test.name}: ERROR - ${error.message}`);
+        results.details.push({
+          name: test.name,
+          passed: false,
+          error: error.message,
+          details: null
+        });
+      }
+    }
+
+    return {
+      success: results.failed === 0,
+      ...results
+    };
+  }
+
+  /**
+   * Test if CLI file exists and is executable
+   */
+  async testCliFileExists() {
+    try {
+      const exists = fs.existsSync(this.cliPath);
+      if (!exists) {
+        return { passed: false, error: `CLI file not found: ${this.cliPath}` };
+      }
+
+      const stats = fs.statSync(this.cliPath);
+      if (!stats.isFile()) {
+        return { passed: false, error: `CLI path is not a file: ${this.cliPath}` };
+      }
+
+      return { passed: true, details: { path: this.cliPath, size: stats.size } };
+    } catch (error) {
+      return { passed: false, error: error.message };
+    }
+  }
+
+  /**
+   * Test if CLI starts without crashing
+   */
+  async testCliStarts() {
+    return new Promise((resolve) => {
+      const startTime = Date.now();
+      const child = spawn('node', [this.cliPath, '--help'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: path.dirname(this.cliPath)
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      const timeoutId = setTimeout(() => {
+        child.kill('SIGTERM');
+        resolve({
+          passed: false,
+          error: `CLI startup timeout after ${this.timeout}ms`,
+          details: { stdout, stderr }
+        });
+      }, this.timeout);
+
+      child.on('close', (code) => {
+        clearTimeout(timeoutId);
+        const duration = Date.now() - startTime;
+        
+        // Allow exit code 0 or 1 (help command might exit with 1)
+        if (code === 0 || code === 1) {
+          resolve({
+            passed: true,
+            details: { 
+              exitCode: code, 
+              duration,
+              stdout: stdout.substring(0, 500), // First 500 chars
+              hasOutput: stdout.length > 0
+            }
+          });
+        } else {
+          resolve({
+            passed: false,
+            error: `CLI exited with code ${code}`,
+            details: { exitCode: code, stdout, stderr, duration }
+          });
+        }
+      });
+
+      child.on('error', (error) => {
+        clearTimeout(timeoutId);
+        resolve({
+          passed: false,
+          error: `CLI failed to start: ${error.message}`,
+          details: { error: error.message }
+        });
+      });
+    });
+  }
+
+  /**
+   * Test --help command specifically
+   */
+  async testHelpCommand() {
+    return new Promise((resolve) => {
+      const child = spawn('node', [this.cliPath, '--help'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: path.dirname(this.cliPath)
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      const timeoutId = setTimeout(() => {
+        child.kill('SIGTERM');
+        resolve({
+          passed: false,
+          error: `Help command timeout after ${this.timeout}ms`
+        });
+      }, this.timeout);
+
+      child.on('close', (code) => {
+        clearTimeout(timeoutId);
+        
+        // Check for help-related content
+        const hasHelpContent = stdout.includes('Usage:') || 
+                              stdout.includes('Options:') || 
+                              stdout.includes('Commands:') ||
+                              stdout.includes('help');
+        
+        // Allow exit code 0 or 1 for help
+        if ((code === 0 || code === 1) && hasHelpContent) {
+          resolve({
+            passed: true,
+            details: { 
+              exitCode: code,
+              hasHelpContent,
+              outputLength: stdout.length
+            }
+          });
+        } else {
+          resolve({
+            passed: false,
+            error: `Help command failed - exit code: ${code}, has help content: ${hasHelpContent}`,
+            details: { exitCode: code, stdout: stdout.substring(0, 200), stderr }
+          });
+        }
+      });
+
+      child.on('error', (error) => {
+        clearTimeout(timeoutId);
+        resolve({
+          passed: false,
+          error: `Help command error: ${error.message}`
+        });
+      });
+    });
+  }
+
+  /**
+   * Test --version command
+   */
+  async testVersionCommand() {
+    return new Promise((resolve) => {
+      const child = spawn('node', [this.cliPath, '--version'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: path.dirname(this.cliPath)
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      const timeoutId = setTimeout(() => {
+        child.kill('SIGTERM');
+        resolve({
+          passed: false,
+          error: `Version command timeout after ${this.timeout}ms`
+        });
+      }, this.timeout);
+
+      child.on('close', (code) => {
+        clearTimeout(timeoutId);
+        
+        // Check for version-like content
+        const hasVersionContent = /\d+\.\d+\.\d+/.test(stdout) || 
+                                  stdout.includes('version') ||
+                                  stdout.length > 0;
+        
+        if (code === 0 && hasVersionContent) {
+          resolve({
+            passed: true,
+            details: { 
+              exitCode: code,
+              version: stdout.trim(),
+              hasVersionContent
+            }
+          });
+        } else {
+          resolve({
+            passed: false,
+            error: `Version command failed - exit code: ${code}`,
+            details: { exitCode: code, stdout, stderr }
+          });
+        }
+      });
+
+      child.on('error', (error) => {
+        clearTimeout(timeoutId);
+        resolve({
+          passed: false,
+          error: `Version command error: ${error.message}`
+        });
+      });
+    });
+  }
+
+  /**
+   * Test that basic commands are available
+   */
+  async testBasicCommands() {
+    return new Promise((resolve) => {
+      const child = spawn('node', [this.cliPath, '--help'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: path.dirname(this.cliPath)
+      });
+
+      let stdout = '';
+
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      const timeoutId = setTimeout(() => {
+        child.kill('SIGTERM');
+        resolve({
+          passed: false,
+          error: `Basic commands check timeout after ${this.timeout}ms`
+        });
+      }, this.timeout);
+
+      child.on('close', (code) => {
+        clearTimeout(timeoutId);
+        
+        // Look for basic command patterns
+        const basicCommands = [
+          'repo', 'auto', 'help', 'version'
+        ];
+        
+        const foundCommands = basicCommands.filter(cmd => 
+          stdout.toLowerCase().includes(cmd.toLowerCase())
+        );
+        
+        const hasEnoughCommands = foundCommands.length >= 2;
+        
+        if ((code === 0 || code === 1) && hasEnoughCommands) {
+          resolve({
+            passed: true,
+            details: { 
+              exitCode: code,
+              foundCommands,
+              commandCount: foundCommands.length
+            }
+          });
+        } else {
+          resolve({
+            passed: false,
+            error: `Basic commands check failed - found ${foundCommands.length} commands`,
+            details: { exitCode: code, foundCommands, stdout: stdout.substring(0, 300) }
+          });
+        }
+      });
+
+      child.on('error', (error) => {
+        clearTimeout(timeoutId);
+        resolve({
+          passed: false,
+          error: `Basic commands check error: ${error.message}`
+        });
+      });
+    });
+  }
+}
+
+module.exports = { CliSmokeTest };