vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/utils/specification-enable-disable.js

@@ -0,0 +1,122 @@
+/**
+ * Specification Enable/Disable Utilities
+ * Provides functions to enable and disable specifications using DISABLED.vcm files
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Enable a specification by removing DISABLED.vcm file if it exists
+ * @param {string} specId - Specification ID (e.g., "001-agent-defaults")
+ * @param {string} repoPath - Repository root path
+ * @returns {Promise<{success: boolean, message: string}>}
+ */
+async function enableSpec(specId, repoPath = process.cwd()) {
+  try {
+    const specPath = path.join(repoPath, 'specs', specId);
+    const disabledFile = path.join(specPath, 'DISABLED.vcm');
+    
+    // Check if spec directory exists
+    if (!await fs.pathExists(specPath)) {
+      return {
+        success: false,
+        message: `Specification ${specId} not found`
+      };
+    }
+    
+    // Check if spec is currently disabled
+    const isDisabled = await fs.pathExists(disabledFile);
+    if (!isDisabled) {
+      return {
+        success: true,
+        message: `Specification ${specId} is already enabled`
+      };
+    }
+    
+    // Remove DISABLED.vcm file to enable the spec
+    await fs.remove(disabledFile);
+    
+    return {
+      success: true,
+      message: `Specification ${specId} enabled successfully`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to enable specification ${specId}: ${error.message}`
+    };
+  }
+}
+
+/**
+ * Disable a specification by creating DISABLED.vcm file
+ * @param {string} specId - Specification ID (e.g., "001-agent-defaults")
+ * @param {string} repoPath - Repository root path
+ * @returns {Promise<{success: boolean, message: string}>}
+ */
+async function disableSpec(specId, repoPath = process.cwd()) {
+  try {
+    const specPath = path.join(repoPath, 'specs', specId);
+    const disabledFile = path.join(specPath, 'DISABLED.vcm');
+    
+    // Check if spec directory exists
+    if (!await fs.pathExists(specPath)) {
+      return {
+        success: false,
+        message: `Specification ${specId} not found`
+      };
+    }
+    
+    // Check if spec is already disabled
+    const isDisabled = await fs.pathExists(disabledFile);
+    if (isDisabled) {
+      return {
+        success: true,
+        message: `Specification ${specId} is already disabled`
+      };
+    }
+    
+    // Create DISABLED.vcm file to disable the spec
+    const disabledContent = `# Specification Disabled\n\nThis specification is disabled and will be skipped by auto-mode.\nDisabled at: ${new Date().toISOString()}\n`;
+    await fs.writeFile(disabledFile, disabledContent, 'utf8');
+    
+    return {
+      success: true,
+      message: `Specification ${specId} disabled successfully`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to disable specification ${specId}: ${error.message}`
+    };
+  }
+}
+
+/**
+ * Check if a specification is disabled
+ * @param {string} specId - Specification ID
+ * @param {string} repoPath - Repository root path
+ * @returns {Promise<boolean>} - True if disabled, false otherwise
+ */
+async function isSpecDisabled(specId, repoPath = process.cwd()) {
+  try {
+    const specPath = path.join(repoPath, 'specs', specId);
+    const disabledFile = path.join(specPath, 'DISABLED.vcm');
+    
+    if (!await fs.pathExists(specPath)) {
+      return false; // Spec doesn't exist, treat as not disabled
+    }
+    
+    return await fs.pathExists(disabledFile);
+  } catch (error) {
+    // logger.error(`Error checking if spec is disabled: ${error.message}`);
+    return false; // Default to not disabled on error
+  }
+};
+
+module.exports = {
+  enableSpec,
+  disableSpec,
+  isSpecDisabled
+};

package/src/utils/specification-helpers.js

@@ -8,6 +8,7 @@
 const fs = require('fs-extra');
 const path = require('path');
 const { migrateAllDisabledSpecs, isMigrationNeeded } = require('./specification-migration');
+const { enableSpec, disableSpec, isSpecDisabled } = require('./specification-enable-disable');
 
 /**
  * Extract the title from spec.md content (first H1 or H2)
@@ -57,6 +58,27 @@ function extractCompletionPercentage(text) {
   return null;
 }
 
+/**
+ * Extract task counts from arbitrary text
+ * Looks for patterns like "N/M tasks" or "N of M tasks"
+ * @param {string} text
+ * @returns {{completed: number, total: number}|null} task counts or null if not found
+ */
+function extractTaskCounts(text) {
+  if (!text || typeof text !== 'string') return null;
+
+  // Match patterns like "5/10 tasks" or "5 / 10 tasks" or "5 of 10 tasks"
+  const p1 = text.match(/(\d+)\s*(?:\/|of)\s*(\d+)\s+tasks?/i);
+  if (p1) {
+    return {
+      completed: parseInt(p1[1]),
+      total: parseInt(p1[2])
+    };
+  }
+
+  return null;
+}
+
 /**
  * Check whether a spec directory has a tasks.md file
  * @param {string} specPath - absolute path to spec directory
@@ -80,7 +102,7 @@ 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.txt file
+ * @param {boolean} [options.skipDisabled=false] - Skip specs with DISABLED.vcm file
  * @param {boolean} [options.includeWithoutSpec=false] - Include spec directories even without spec.md
  * @returns {Promise<Array<{directory, title, path, hasPlan, hasPlanPrompt, hasTasks, hasSpec}>>}
  */
@@ -97,8 +119,8 @@ async function getAllSpecifications(repoPath, options = {}) {
     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-'))) {
+    // Skip disabled specs if skipDisabled is true and DISABLED.vcm exists or directory starts with DISABLED-
+    if (skipDisabled && (await fs.pathExists(path.join(specPath, 'DISABLED.vcm')) || entry.startsWith('DISABLED-'))) {
       continue;
     }
 
@@ -231,6 +253,7 @@ async function initializeSpecifications(repoPath) {
 module.exports = {
   extractSpecTitle,
   extractCompletionPercentage,
+  extractTaskCounts,
   hasImplementation,
   isSpecComplete,
   getAllSpecifications,
@@ -238,5 +261,8 @@ module.exports = {
   getTodoSpecifications,
   createSpecification,
   updateSpecification,
-  initializeSpecifications
+  initializeSpecifications,
+  enableSpec,
+  disableSpec,
+  isSpecDisabled
 };

package/src/utils/specification-migration.js

@@ -1,14 +1,14 @@
 /**
  * Specification Migration Utilities
  * Handles migration from old DISABLED- prefix naming convention
- * to the new DISABLED.txt file-based disable tracking.
+ * to new DISABLED.vcm file-based disable tracking.
  */
 
 const fs = require('fs-extra');
 const path = require('path');
 
 /**
- * Migrate a single specification from DISABLED- prefix to DISABLED.txt file
+ * Migrate a single specification from DISABLED- prefix to DISABLED.vcm 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}>}
@@ -29,8 +29,8 @@ async function migrateDisabledSpec(specsDir, dirName) {
       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');
+    // Create DISABLED.vcm in the old directory before renaming
+    const disabledFilePath = path.join(oldPath, 'DISABLED.vcm');
     await fs.writeFile(disabledFilePath, '');
 
     // Rename directory to remove DISABLED- prefix
@@ -43,7 +43,7 @@ async function migrateDisabledSpec(specsDir, dirName) {
 }
 
 /**
- * Migrate all DISABLED- prefixed specs to the new DISABLED.txt format
+ * Migrate all DISABLED- prefixed specs to the new DISABLED.vcm format
  * @param {string} repoPath - root repository path
  * @returns {Promise<{totalFound: number, migrated: number, failed: number, results: Array}>}
  */

package/src/utils/test-comparator.js

@@ -0,0 +1,118 @@
+/**
+ * Test Comparator
+ * 
+ * Compares test results to detect regressions and improvements.
+ */
+
+/**
+ * Compare baseline and current results
+ */
+function compareResults(baseline, current) {
+  const comparison = {
+    hasRegressions: false,
+    regressions: [],
+    improvements: [],
+    unchanged: [],
+    summary: {
+      baseline: {
+        total: baseline.total,
+        passed: baseline.passed,
+        failed: baseline.failed,
+        duration: baseline.duration
+      },
+      current: {
+        total: current.total,
+        passed: current.passed,
+        failed: current.failed,
+        duration: current.duration
+      }
+    }
+  };
+
+  // Check for test count changes
+  if (current.total < baseline.total) {
+    comparison.regressions.push({
+      type: 'missing_tests',
+      message: `${baseline.total - current.total} tests are missing`,
+      severity: 'high'
+    });
+    comparison.hasRegressions = true;
+  }
+
+  if (current.total > baseline.total) {
+    comparison.improvements.push({
+      type: 'new_tests',
+      message: `${current.total - baseline.total} new tests added`,
+      severity: 'info'
+    });
+  }
+
+  // Check for test failures
+  if (current.failed > baseline.failed) {
+    comparison.regressions.push({
+      type: 'new_failures',
+      message: `${current.failed - baseline.failed} new test failures`,
+      severity: 'high'
+    });
+    comparison.hasRegressions = true;
+  }
+
+  if (current.failed < baseline.failed) {
+    comparison.improvements.push({
+      type: 'fixed_failures',
+      message: `${baseline.failed - current.failed} test failures fixed`,
+      severity: 'good'
+    });
+  }
+
+  // Check for performance regression
+  const performanceIncrease = current.duration - baseline.duration;
+  const performancePercent = (performanceIncrease / baseline.duration) * 100;
+
+  if (performanceIncrease > 5000 && performancePercent > 10) { // 5s and 10%
+    comparison.regressions.push({
+      type: 'performance',
+      message: `Test execution increased by ${Math.round(performancePercent)}% (${Math.round(performanceIncrease/1000)}s)`,
+      severity: 'medium'
+    });
+    comparison.hasRegressions = true;
+  }
+
+  // Compare individual test results
+  const baselineTests = new Map();
+  for (const test of baseline.tests) {
+    baselineTests.set(test.fullName, test);
+  }
+
+  for (const test of current.tests) {
+    const baselineTest = baselineTests.get(test.fullName);
+    
+    if (!baselineTest) {
+      comparison.improvements.push({
+        type: 'new_test',
+        message: `New test: ${test.title}`,
+        severity: 'info'
+      });
+    } else if (baselineTest.status === 'passed' && test.status === 'failed') {
+      comparison.regressions.push({
+        type: 'test_regression',
+        message: `Test now failing: ${test.title}`,
+        severity: 'high',
+        test: test
+      });
+      comparison.hasRegressions = true;
+    } else if (baselineTest.status === 'failed' && test.status === 'passed') {
+      comparison.improvements.push({
+        type: 'test_fixed',
+        message: `Test now passing: ${test.title}`,
+        severity: 'good'
+      });
+    }
+  }
+
+  return comparison;
+}
+
+module.exports = {
+  compareResults
+};

package/src/utils/test-config.js

@@ -0,0 +1,54 @@
+/**
+ * Test Configuration
+ * 
+ * Handles test configuration detection and validation.
+ */
+
+const fs = require('fs');
+
+/**
+ * Check if tests are available
+ */
+function checkTestAvailability() {
+  const testPaths = [
+    'package.json',
+    'tests',
+    '__tests__',
+    'test',
+    'spec'
+  ];
+
+  for (const testPath of testPaths) {
+    if (fs.existsSync(testPath)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Get test configuration
+ */
+function getTestConfig() {
+  try {
+    const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+    return {
+      hasTestScript: !!packageJson.scripts?.test,
+      testScript: packageJson.scripts?.test,
+      jestConfig: packageJson.jest,
+      dependencies: {
+        jest: packageJson.dependencies?.jest || packageJson.devDependencies?.jest,
+        mocha: packageJson.dependencies?.mocha || packageJson.devDependencies?.mocha,
+        jasmine: packageJson.dependencies?.jasmine || packageJson.devDependencies?.jasmine
+      }
+    };
+  } catch (error) {
+    return { hasTestScript: false };
+  }
+}
+
+module.exports = {
+  checkTestAvailability,
+  getTestConfig
+};

package/src/utils/test-executor.js

@@ -0,0 +1,133 @@
+/**
+ * Test Executor
+ * 
+ * Handles test execution and process management.
+ */
+
+const { spawn } = require('child_process');
+
+/**
+ * Execute tests and collect results
+ */
+async function executeTests(options = {}) {
+  const defaultOptions = {
+    verbose: false,
+    timeout: 300000, // 5 minutes
+    cwd: process.cwd()
+  };
+  
+  const opts = { ...defaultOptions, ...options };
+  
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+    let output = '';
+    let errorOutput = '';
+
+    try {
+      // Use npm test with JSON reporter if available
+      const testProcess = spawn('npm', ['test', '--', '--json', '--verbose'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: opts.cwd
+      });
+
+      testProcess.stdout.on('data', (data) => {
+        output += data.toString();
+        if (opts.verbose) {
+          process.stdout.write(data);
+        }
+      });
+
+      testProcess.stderr.on('data', (data) => {
+        errorOutput += data.toString();
+        if (opts.verbose) {
+          process.stderr.write(data);
+        }
+      });
+
+      testProcess.on('close', (code) => {
+        const duration = Date.now() - startTime;
+        resolve({
+          stdout: output,
+          stderr: errorOutput,
+          exitCode: code,
+          duration
+        });
+      });
+
+      testProcess.on('error', (error) => {
+        reject(new Error(`Test process failed: ${error.message}`));
+      });
+
+      // Set timeout
+      if (opts.timeout) {
+        setTimeout(() => {
+          testProcess.kill('SIGKILL');
+          reject(new Error(`Test execution timed out after ${opts.timeout}ms`));
+        }, opts.timeout);
+      }
+
+    } catch (error) {
+      reject(new Error(`Failed to start test process: ${error.message}`));
+    }
+  });
+}
+
+/**
+ * Run specific test files
+ */
+async function runSpecificTests(testFiles, options = {}) {
+  const defaultOptions = {
+    verbose: false,
+    cwd: process.cwd()
+  };
+  
+  const opts = { ...defaultOptions, ...options };
+  
+  console.log(`Running ${testFiles.length} specific tests...`);
+  
+  const testArgs = ['test', '--', ...testFiles];
+  
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+    let output = '';
+    let errorOutput = '';
+
+    const testProcess = spawn('npm', testArgs, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      cwd: opts.cwd
+    });
+
+    testProcess.stdout.on('data', (data) => {
+      output += data.toString();
+      if (opts.verbose) {
+        process.stdout.write(data);
+      }
+    });
+
+    testProcess.stderr.on('data', (data) => {
+      errorOutput += data.toString();
+      if (opts.verbose) {
+        process.stderr.write(data);
+      }
+    });
+
+    testProcess.on('close', (code) => {
+      const duration = Date.now() - startTime;
+      resolve({
+        stdout: output,
+        stderr: errorOutput,
+        exitCode: code,
+        duration
+      });
+    });
+
+    testProcess.on('error', (error) => {
+      reject(new Error(`Test process failed: ${error.message}`));
+    });
+  });
+}
+
+module.exports = {
+  executeTests,
+  runSpecificTests
+};