vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

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

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+/**
+ * Smoke Test Runner
+ * 
+ * Runs smoke tests before and after refactoring to ensure interfaces continue working
+ */
+
+const { SmokeTestOrchestrator } = require('./smoke-test-orchestrator');
+const path = require('path');
+const fs = require('fs');
+
+async function main() {
+  const args = process.argv.slice(2);
+  const phase = args[0] || 'pre-refactor';
+  const verbose = args.includes('--verbose') || args.includes('-v');
+  const saveReport = args.includes('--save-report');
+
+  const orchestrator = new SmokeTestOrchestrator({
+    verbose,
+    rollbackTrigger: async (context) => {
+      console.error('🚨 SMOKE TESTS FAILED - ROLLBACK TRIGGERED');
+      console.error('Phase:', context.phase);
+      console.error('Reason:', context.reason);
+      
+      // In a real implementation, this would trigger git rollback
+      console.error('🔄 Rollback would be triggered here');
+      
+      // Exit with error code to indicate failure
+      process.exit(1);
+    }
+  });
+
+  try {
+    console.log(`🔥 Running ${phase} smoke tests...`);
+    const results = await orchestrator.runSmokeTests(phase);
+    
+    if (saveReport) {
+      const reportPath = path.join(__dirname, `../reports/smoke-test-${phase}-${Date.now()}.json`);
+      await orchestrator.saveReport(results, reportPath);
+    }
+    
+    if (results.success) {
+      console.log('✅ All smoke tests passed!');
+      process.exit(0);
+    } else {
+      console.log('❌ Some smoke tests failed!');
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error('💥 Smoke test runner error:', error.message);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { main };

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

@@ -0,0 +1,347 @@
+/**
+ * Web Smoke Testing Utility
+ * 
+ * Provides smoke testing functionality for the Web interface
+ * to ensure it starts and responds to basic requests.
+ */
+
+const { spawn } = require('child_process');
+const http = require('http');
+const path = require('path');
+const fs = require('fs');
+
+class WebSmokeTest {
+  constructor(options = {}) {
+    this.webPath = options.webPath || path.join(__dirname, '../../../web');
+    this.port = options.port || 3000;
+    this.host = options.host || 'localhost';
+    this.timeout = options.timeout || 60000; // 60 seconds for web server startup
+    this.verbose = options.verbose || false;
+  }
+
+  /**
+   * Run comprehensive Web smoke tests
+   * @returns {Promise<Object>} Test results
+   */
+  async runSmokeTests() {
+    const results = {
+      passed: 0,
+      failed: 0,
+      total: 0,
+      details: []
+    };
+
+    const tests = [
+      { name: 'Web Directory Exists', test: () => this.testWebDirectoryExists() },
+      { name: 'Package.json Exists', test: () => this.testPackageJsonExists() },
+      { name: 'Dependencies Available', test: () => this.testDependenciesAvailable() },
+      { name: 'Web Server Starts', test: () => this.testWebServerStarts() },
+      { name: 'Basic HTTP Response', test: () => this.testBasicHttpResponse() }
+    ];
+
+    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 Web directory exists
+   */
+  async testWebDirectoryExists() {
+    try {
+      const exists = fs.existsSync(this.webPath);
+      if (!exists) {
+        return { passed: false, error: `Web directory not found: ${this.webPath}` };
+      }
+
+      const stats = fs.statSync(this.webPath);
+      if (!stats.isDirectory()) {
+        return { passed: false, error: `Web path is not a directory: ${this.webPath}` };
+      }
+
+      return { passed: true, details: { path: this.webPath } };
+    } catch (error) {
+      return { passed: false, error: error.message };
+    }
+  }
+
+  /**
+   * Test if package.json exists in Web directory
+   */
+  async testPackageJsonExists() {
+    try {
+      const packageJsonPath = path.join(this.webPath, 'package.json');
+      const exists = fs.existsSync(packageJsonPath);
+      if (!exists) {
+        return { passed: false, error: `package.json not found: ${packageJsonPath}` };
+      }
+
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      return { 
+        passed: true, 
+        details: { 
+          name: packageJson.name,
+          version: packageJson.version,
+          hasScripts: !!packageJson.scripts,
+          scriptCount: packageJson.scripts ? Object.keys(packageJson.scripts).length : 0
+        } 
+      };
+    } catch (error) {
+      return { passed: false, error: `package.json error: ${error.message}` };
+    }
+  }
+
+  /**
+   * Test if dependencies are available
+   */
+  async testDependenciesAvailable() {
+    try {
+      const packageJsonPath = path.join(this.webPath, 'package.json');
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      const nodeModulesPath = path.join(this.webPath, 'node_modules');
+
+      const nodeModulesExists = fs.existsSync(nodeModulesPath);
+      const hasDependencies = packageJson.dependencies && Object.keys(packageJson.dependencies).length > 0;
+
+      if (!nodeModulesExists && hasDependencies) {
+        return { 
+          passed: false, 
+          error: 'node_modules directory not found but dependencies exist in package.json' 
+        };
+      }
+
+      // Check for common web dependencies
+      const commonDeps = ['react', 'express', 'next', 'vue', 'angular'];
+      const foundDeps = commonDeps.filter(dep => 
+        packageJson.dependencies && packageJson.dependencies[dep]
+      );
+
+      return { 
+        passed: true, 
+        details: { 
+          nodeModulesExists,
+          dependencyCount: hasDependencies ? Object.keys(packageJson.dependencies).length : 0,
+          commonDeps: foundDeps
+        } 
+      };
+    } catch (error) {
+      return { passed: false, error: `Dependency check error: ${error.message}` };
+    }
+  }
+
+  /**
+   * Test if web server can start
+   */
+  async testWebServerStarts() {
+    return new Promise((resolve) => {
+      const startTime = Date.now();
+      
+      // Check for common start scripts
+      const packageJsonPath = path.join(this.webPath, 'package.json');
+      let startScript = 'start';
+      
+      try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        if (packageJson.scripts) {
+          if (packageJson.scripts.dev) startScript = 'dev';
+          else if (packageJson.scripts.start) startScript = 'start';
+        }
+      } catch (error) {
+        // Continue with default
+      }
+
+      const child = spawn('npm', ['run', startScript], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: this.webPath,
+        env: { ...process.env, PORT: this.port.toString() }
+      });
+
+      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: `Web server startup timeout after ${this.timeout}ms`,
+          details: { stdout, stderr }
+        });
+      }, this.timeout);
+
+      // Listen for successful startup indicators
+      const startupPatterns = [
+        /server.*running/i,
+        /listening.*port/i,
+        /ready.*server/i,
+        /compiled.*successfully/i,
+        new RegExp(`localhost:${this.port}`, 'i')
+      ];
+
+      child.stdout.on('data', (data) => {
+        const output = data.toString();
+        if (startupPatterns.some(pattern => pattern.test(output))) {
+          clearTimeout(timeoutId);
+          child.kill('SIGTERM');
+          const duration = Date.now() - startTime;
+          resolve({
+            passed: true,
+            details: { 
+              startupOutput: output.trim(),
+              duration,
+              script: startScript
+            }
+          });
+        }
+      });
+
+      child.on('close', (code) => {
+        clearTimeout(timeoutId);
+        const duration = Date.now() - startTime;
+        
+        if (code === 0) {
+          resolve({
+            passed: true,
+            details: { 
+              exitCode: code,
+              duration,
+              script: startScript
+            }
+          });
+        } else {
+          resolve({
+            passed: false,
+            error: `Web server failed to start - exit code: ${code}`,
+            details: { exitCode: code, stdout, stderr, duration, script: startScript }
+          });
+        }
+      });
+
+      child.on('error', (error) => {
+        clearTimeout(timeoutId);
+        resolve({
+          passed: false,
+          error: `Web server start error: ${error.message}`,
+          details: { error: error.message }
+        });
+      });
+    });
+  }
+
+  /**
+   * Test basic HTTP response from web server
+   */
+  async testBasicHttpResponse() {
+    return new Promise((resolve) => {
+      const startTime = Date.now();
+      const requestOptions = {
+        hostname: this.host,
+        port: this.port,
+        path: '/',
+        method: 'GET',
+        timeout: 10000
+      };
+
+      const req = http.request(requestOptions, (res) => {
+        let data = '';
+        
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+
+        res.on('end', () => {
+          const duration = Date.now() - startTime;
+          
+          // Consider 2xx and 3xx status codes as success
+          if (res.statusCode >= 200 && res.statusCode < 400) {
+            resolve({
+              passed: true,
+              details: { 
+                statusCode: res.statusCode,
+                headers: res.headers,
+                contentLength: data.length,
+                duration
+              }
+            });
+          } else {
+            resolve({
+              passed: false,
+              error: `HTTP response status: ${res.statusCode}`,
+              details: { statusCode: res.statusCode, headers: res.headers, duration }
+            });
+          }
+        });
+      });
+
+      req.on('error', (error) => {
+        const duration = Date.now() - startTime;
+        
+        // Common errors that indicate server isn't running
+        if (error.code === 'ECONNREFUSED' || error.code === 'ECONNRESET') {
+          resolve({
+            passed: false,
+            error: `Web server not responding on ${this.host}:${this.port}`,
+            details: { error: error.code, duration }
+          });
+        } else {
+          resolve({
+            passed: false,
+            error: `HTTP request error: ${error.message}`,
+            details: { error: error.message, duration }
+          });
+        }
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        resolve({
+          passed: false,
+          error: `HTTP request timeout after 10 seconds`
+        });
+      });
+
+      req.end();
+    });
+  }
+}
+
+module.exports = { WebSmokeTest };

package/src/utils/specification-helpers.js

@@ -7,6 +7,7 @@
 
 const fs = require('fs-extra');
 const path = require('path');
+const { migrateAllDisabledSpecs, isMigrationNeeded } = require('./specification-migration');
 
 /**
  * Extract the title from spec.md content (first H1 or H2)
@@ -79,11 +80,12 @@ async function isSpecComplete(specPath) {
  * Get all specifications in repo's specs/ directory
  * @param {string} repoPath
  * @param {Object} [options] - Optional configuration
- * @param {boolean} [options.skipDisabled=false] - Skip specs with DISABLED- prefix
- * @returns {Promise<Array<{directory, title, path, hasPlan, hasPlanPrompt, hasTasks}>>}
+ * @param {boolean} [options.skipDisabled=false] - Skip specs with DISABLED.txt file
+ * @param {boolean} [options.includeWithoutSpec=false] - Include spec directories even without spec.md
+ * @returns {Promise<Array<{directory, title, path, hasPlan, hasPlanPrompt, hasTasks, hasSpec}>>}
  */
 async function getAllSpecifications(repoPath, options = {}) {
-  const { skipDisabled = false } = options;
+  const { skipDisabled = false, includeWithoutSpec = false } = options;
   const specsDir = path.join(repoPath, 'specs');
   if (!await fs.pathExists(specsDir)) return [];
 
@@ -91,25 +93,28 @@ async function getAllSpecifications(repoPath, options = {}) {
   const specs = [];
 
   for (const entry of entries) {
-    // Skip disabled specs if skipDisabled is true
-    if (skipDisabled && entry.startsWith('DISABLED-')) {
-      continue;
-    }
-
     const specPath = path.join(specsDir, entry);
     const stat = await fs.stat(specPath).catch(() => null);
     if (!stat || !stat.isDirectory()) continue;
 
+    // Skip disabled specs if skipDisabled is true and DISABLED.txt exists or directory starts with DISABLED-
+    if (skipDisabled && (await fs.pathExists(path.join(specPath, 'DISABLED.txt')) || entry.startsWith('DISABLED-'))) {
+      continue;
+    }
+
     const specMdPath = path.join(specPath, 'spec.md');
-    if (!await fs.pathExists(specMdPath)) continue;
+    const hasSpec = await fs.pathExists(specMdPath);
 
-    const content = await fs.readFile(specMdPath, 'utf8').catch(() => '');
-    const title = extractSpecTitle(content) || entry;
+    // Skip specs without spec.md unless includeWithoutSpec is true
+    if (!hasSpec && !includeWithoutSpec) continue;
+
+    const content = hasSpec ? await fs.readFile(specMdPath, 'utf8').catch(() => '') : '';
+    const title = extractSpecTitle(content, entry) || entry;
     const hasPlan = await fs.pathExists(path.join(specPath, 'plan.md'));
     const hasPlanPrompt = await fs.pathExists(path.join(specPath, 'plan-prompt.md'));
     const hasTasks = await fs.pathExists(path.join(specPath, 'tasks.md'));
 
-    specs.push({ directory: entry, title, path: specPath, hasPlan, hasPlanPrompt, hasTasks });
+    specs.push({ directory: entry, title, path: specPath, hasPlan, hasPlanPrompt, hasTasks, hasSpec });
   }
 
   return specs.sort((a, b) => a.directory.localeCompare(b.directory));
@@ -202,7 +207,27 @@ async function updateSpecification(specPath, content) {
   const specMdPath = path.join(specPath, 'spec.md');
   await fs.writeFile(specMdPath, content, 'utf8');
 }
+/**
+ * Initialize specification system (e.g., run migrations if needed)
+ * Call this once during application startup
+ * @param {string} repoPath - root repository path
+ * @returns {Promise<{migrationRan: boolean, migrationResults: Object|null}>}
+ */
+async function initializeSpecifications(repoPath) {
+  try {
+    const needsMigration = await isMigrationNeeded(repoPath);
 
+    if (needsMigration) {
+      const migrationResults = await migrateAllDisabledSpecs(repoPath);
+      return { migrationRan: true, migrationResults };
+    }
+
+    return { migrationRan: false, migrationResults: null };
+  } catch (error) {
+    console.error('Error during specification initialization:', error);
+    return { migrationRan: false, migrationResults: null, error: error.message };
+  }
+}
 module.exports = {
   extractSpecTitle,
   extractCompletionPercentage,
@@ -212,5 +237,6 @@ module.exports = {
   getNextSpecificationNumber,
   getTodoSpecifications,
   createSpecification,
-  updateSpecification
+  updateSpecification,
+  initializeSpecifications
 };

package/src/utils/specification-migration.js

@@ -0,0 +1,97 @@
+/**
+ * Specification Migration Utilities
+ * Handles migration from old DISABLED- prefix naming convention
+ * to the new DISABLED.txt file-based disable tracking.
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Migrate a single specification from DISABLED- prefix to DISABLED.txt file
+ * @param {string} specsDir - path to specs/ directory
+ * @param {string} dirName - directory name (e.g., "DISABLED-001-example")
+ * @returns {Promise<{success: boolean, oldName: string, newName: string|null, error: string|null}>}
+ */
+async function migrateDisabledSpec(specsDir, dirName) {
+  if (!dirName.startsWith('DISABLED-')) {
+    return { success: false, oldName: dirName, newName: null, error: 'Not a DISABLED- directory' };
+  }
+
+  const oldPath = path.join(specsDir, dirName);
+  const newName = dirName.substring(9); // Remove "DISABLED-" prefix
+  const newPath = path.join(specsDir, newName);
+
+  try {
+    // Check if spec.md exists (only migrate valid specs)
+    const specMdPath = path.join(oldPath, 'spec.md');
+    if (!await fs.pathExists(specMdPath)) {
+      return { success: false, oldName: dirName, newName: null, error: 'No spec.md found' };
+    }
+
+    // Create DISABLED.txt in the old directory before renaming
+    const disabledFilePath = path.join(oldPath, 'DISABLED.txt');
+    await fs.writeFile(disabledFilePath, '');
+
+    // Rename directory to remove DISABLED- prefix
+    await fs.rename(oldPath, newPath);
+
+    return { success: true, oldName: dirName, newName, error: null };
+  } catch (error) {
+    return { success: false, oldName: dirName, newName: null, error: error.message };
+  }
+}
+
+/**
+ * Migrate all DISABLED- prefixed specs to the new DISABLED.txt format
+ * @param {string} repoPath - root repository path
+ * @returns {Promise<{totalFound: number, migrated: number, failed: number, results: Array}>}
+ */
+async function migrateAllDisabledSpecs(repoPath) {
+  const specsDir = path.join(repoPath, 'specs');
+
+  if (!await fs.pathExists(specsDir)) {
+    return { totalFound: 0, migrated: 0, failed: 0, results: [] };
+  }
+
+  const entries = await fs.readdir(specsDir);
+  const disabledDirs = entries.filter(entry => entry.startsWith('DISABLED-'));
+
+  const results = [];
+  for (const dirName of disabledDirs) {
+    const result = await migrateDisabledSpec(specsDir, dirName);
+    results.push(result);
+  }
+
+  const migrated = results.filter(r => r.success).length;
+  const failed = results.filter(r => !r.success).length;
+
+  return {
+    totalFound: disabledDirs.length,
+    migrated,
+    failed,
+    results
+  };
+}
+
+/**
+ * Check if migration is needed (any DISABLED- prefixed directories exist)
+ * @param {string} repoPath - root repository path
+ * @returns {Promise<boolean>}
+ */
+async function isMigrationNeeded(repoPath) {
+  const specsDir = path.join(repoPath, 'specs');
+
+  if (!await fs.pathExists(specsDir)) {
+    return false;
+  }
+
+  const entries = await fs.readdir(specsDir);
+  return entries.some(entry => entry.startsWith('DISABLED-'));
+}
+
+module.exports = {
+  migrateDisabledSpec,
+  migrateAllDisabledSpecs,
+  isMigrationNeeded
+};