aios-core 2.1.0

package/.aios-core/cli/commands/migrate/validate.js

@@ -0,0 +1,452 @@
+/**
+ * Migration Validation Module
+ *
+ * Validates migrated structure and runs post-migration checks.
+ *
+ * @module cli/commands/migrate/validate
+ * @version 1.0.0
+ * @story 2.14 - Migration Script v2.0 → v2.1
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { MODULE_MAPPING } = require('./analyze');
+const { verifyImports } = require('./update-imports');
+// formatSize available but currently unused
+// const { formatSize } = require('./analyze');
+
+/**
+ * Validate the v2.1 module structure exists
+ * @param {string} aiosCoreDir - Path to .aios-core
+ * @returns {Promise<Object>} Validation result
+ */
+async function validateStructure(aiosCoreDir) {
+  const result = {
+    valid: true,
+    modules: {},
+    errors: [],
+    warnings: [],
+  };
+
+  const expectedModules = ['core', 'development', 'product', 'infrastructure'];
+
+  for (const moduleName of expectedModules) {
+    const moduleDir = path.join(aiosCoreDir, moduleName);
+    const moduleResult = {
+      exists: false,
+      fileCount: 0,
+      totalSize: 0,
+      hasExpectedDirs: true,
+      missingDirs: [],
+    };
+
+    if (fs.existsSync(moduleDir)) {
+      moduleResult.exists = true;
+
+      // Count files
+      const files = await countFiles(moduleDir);
+      moduleResult.fileCount = files.count;
+      moduleResult.totalSize = files.size;
+
+      // Check expected subdirectories
+      const expectedDirs = MODULE_MAPPING[moduleName]?.directories || [];
+      for (const dir of expectedDirs) {
+        const dirPath = path.join(moduleDir, dir);
+        if (!fs.existsSync(dirPath)) {
+          moduleResult.missingDirs.push(dir);
+          moduleResult.hasExpectedDirs = false;
+        }
+      }
+
+      if (moduleResult.missingDirs.length > 0) {
+        result.warnings.push({
+          module: moduleName,
+          message: `Missing expected directories: ${moduleResult.missingDirs.join(', ')}`,
+        });
+      }
+    } else {
+      result.warnings.push({
+        module: moduleName,
+        message: `Module directory not found: ${moduleName}/`,
+      });
+    }
+
+    result.modules[moduleName] = moduleResult;
+  }
+
+  // Check for leftover v2.0 directories at root level
+  const rootEntries = await fs.promises.readdir(aiosCoreDir, { withFileTypes: true });
+
+  for (const entry of rootEntries) {
+    if (entry.isDirectory() && !expectedModules.includes(entry.name)) {
+      // Check if this is a v2.0 directory that should have been migrated
+      for (const config of Object.values(MODULE_MAPPING)) {
+        if (config.directories.includes(entry.name)) {
+          result.warnings.push({
+            type: 'leftover',
+            message: `Leftover v2.0 directory found: ${entry.name}/ (should be in module)`,
+          });
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Count files and total size in a directory
+ * @param {string} dir - Directory path
+ * @returns {Promise<Object>} File count and total size
+ */
+async function countFiles(dir) {
+  let count = 0;
+  let size = 0;
+
+  async function walk(d) {
+    const entries = await fs.promises.readdir(d, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(d, entry.name);
+
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else {
+        count++;
+        const stats = await fs.promises.stat(fullPath);
+        size += stats.size;
+      }
+    }
+  }
+
+  await walk(dir);
+
+  return { count, size };
+}
+
+/**
+ * Run lint check on migrated files
+ * @param {string} projectRoot - Project root
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Lint result
+ */
+async function runLintCheck(projectRoot, options = {}) {
+  const { timeout = 60000 } = options;
+
+  return new Promise((resolve) => {
+    const result = {
+      ran: false,
+      passed: false,
+      errors: 0,
+      warnings: 0,
+      output: '',
+      error: null,
+    };
+
+    // Check if package.json has lint script
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+
+    if (!fs.existsSync(packageJsonPath)) {
+      result.error = 'No package.json found';
+      resolve(result);
+      return;
+    }
+
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+
+    if (!packageJson.scripts?.lint) {
+      result.error = 'No lint script found in package.json';
+      resolve(result);
+      return;
+    }
+
+    result.ran = true;
+
+    const isWindows = process.platform === 'win32';
+    const shell = isWindows ? 'cmd' : '/bin/sh';
+    const shellArgs = isWindows ? ['/c', 'npm run lint'] : ['-c', 'npm run lint'];
+
+    const child = spawn(shell, shellArgs, {
+      cwd: projectRoot,
+      timeout,
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout?.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      result.output = stdout + stderr;
+      result.passed = code === 0;
+
+      // Try to parse error/warning counts from output
+      const errorMatch = result.output.match(/(\d+)\s*error/i);
+      const warningMatch = result.output.match(/(\d+)\s*warning/i);
+
+      if (errorMatch) result.errors = parseInt(errorMatch[1], 10);
+      if (warningMatch) result.warnings = parseInt(warningMatch[1], 10);
+
+      resolve(result);
+    });
+
+    child.on('error', (err) => {
+      result.error = err.message;
+      resolve(result);
+    });
+  });
+}
+
+/**
+ * Run test suite
+ * @param {string} projectRoot - Project root
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Test result
+ */
+async function runTests(projectRoot, options = {}) {
+  const { timeout = 300000 } = options; // 5 min default for tests
+
+  return new Promise((resolve) => {
+    const result = {
+      ran: false,
+      passed: false,
+      total: 0,
+      passed: 0,
+      failed: 0,
+      output: '',
+      error: null,
+    };
+
+    // Check if package.json has test script
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+
+    if (!fs.existsSync(packageJsonPath)) {
+      result.error = 'No package.json found';
+      resolve(result);
+      return;
+    }
+
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+
+    if (!packageJson.scripts?.test) {
+      result.error = 'No test script found in package.json';
+      resolve(result);
+      return;
+    }
+
+    result.ran = true;
+
+    const isWindows = process.platform === 'win32';
+    const shell = isWindows ? 'cmd' : '/bin/sh';
+    const shellArgs = isWindows ? ['/c', 'npm test'] : ['-c', 'npm test'];
+
+    const child = spawn(shell, shellArgs, {
+      cwd: projectRoot,
+      timeout,
+      env: { ...process.env, CI: 'true' }, // Disable watch mode
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout?.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      result.output = stdout + stderr;
+      result.passed = code === 0;
+
+      // Try to parse test counts from output (Jest format)
+      const passedMatch = result.output.match(/(\d+)\s*passed/i);
+      const failedMatch = result.output.match(/(\d+)\s*failed/i);
+      const totalMatch = result.output.match(/Tests:\s*(\d+)/i);
+
+      if (passedMatch) result.passedCount = parseInt(passedMatch[1], 10);
+      if (failedMatch) result.failed = parseInt(failedMatch[1], 10);
+      if (totalMatch) result.total = parseInt(totalMatch[1], 10);
+
+      resolve(result);
+    });
+
+    child.on('error', (err) => {
+      result.error = err.message;
+      resolve(result);
+    });
+  });
+}
+
+/**
+ * Run full validation suite after migration
+ * @param {string} projectRoot - Project root
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Full validation result
+ */
+async function runFullValidation(projectRoot, options = {}) {
+  const { onProgress = () => {}, skipTests = false, skipLint = false } = options;
+  const aiosCoreDir = path.join(projectRoot, '.aios-core');
+
+  const result = {
+    valid: true,
+    structure: null,
+    imports: null,
+    lint: null,
+    tests: null,
+    summary: {
+      passed: [],
+      failed: [],
+      skipped: [],
+    },
+  };
+
+  // Validate structure
+  onProgress({ phase: 'structure', message: '✓ Validating structure...' });
+  result.structure = await validateStructure(aiosCoreDir);
+
+  if (result.structure.errors.length > 0) {
+    result.valid = false;
+    result.summary.failed.push('Structure validation');
+  } else {
+    result.summary.passed.push('Structure validation');
+  }
+
+  // Verify imports
+  onProgress({ phase: 'imports', message: '✓ Verifying imports...' });
+  result.imports = await verifyImports(aiosCoreDir);
+
+  if (!result.imports.valid) {
+    result.valid = false;
+    result.summary.failed.push('Import verification');
+  } else {
+    result.summary.passed.push('Import verification');
+  }
+
+  // Run lint
+  if (!skipLint) {
+    onProgress({ phase: 'lint', message: '✓ Running lint...' });
+    result.lint = await runLintCheck(projectRoot);
+
+    if (result.lint.ran) {
+      if (result.lint.passed) {
+        result.summary.passed.push(`Lint (${result.lint.errors} errors)`);
+      } else {
+        result.valid = false;
+        result.summary.failed.push(`Lint (${result.lint.errors} errors)`);
+      }
+    } else {
+      result.summary.skipped.push('Lint (no script)');
+    }
+  } else {
+    result.summary.skipped.push('Lint (skipped)');
+  }
+
+  // Run tests
+  if (!skipTests) {
+    onProgress({ phase: 'tests', message: '✓ Running tests...' });
+    result.tests = await runTests(projectRoot);
+
+    if (result.tests.ran) {
+      if (result.tests.passed) {
+        result.summary.passed.push(`Tests (${result.tests.passedCount || 'all'} passed)`);
+      } else {
+        result.valid = false;
+        result.summary.failed.push(`Tests (${result.tests.failed} failed)`);
+      }
+    } else {
+      result.summary.skipped.push('Tests (no script)');
+    }
+  } else {
+    result.summary.skipped.push('Tests (skipped)');
+  }
+
+  return result;
+}
+
+/**
+ * Generate migration summary report
+ * @param {Object} migrationResult - Result from executeMigration
+ * @param {Object} validationResult - Result from runFullValidation
+ * @param {Object} options - Options
+ * @returns {string} Formatted summary
+ */
+function generateSummary(migrationResult, validationResult, options = {}) {
+  const { backupLocation = null, duration = null } = options;
+
+  const lines = [];
+
+  lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+  if (validationResult?.valid !== false) {
+    lines.push('✅ Migration complete!' + (duration ? ` (${duration})` : ''));
+  } else {
+    lines.push('⚠️  Migration completed with issues');
+  }
+
+  lines.push('');
+  lines.push('Summary:');
+  lines.push(`  • Files migrated: ${migrationResult.totalFiles}`);
+
+  if (migrationResult.modules) {
+    for (const [name, data] of Object.entries(migrationResult.modules)) {
+      if (data.files > 0) {
+        lines.push(`    - ${name}: ${data.files} files`);
+      }
+    }
+  }
+
+  if (validationResult?.imports) {
+    lines.push(`  • Imports verified: ${validationResult.imports.totalImports}`);
+  }
+
+  if (backupLocation) {
+    lines.push(`  • Backup location: ${backupLocation}`);
+  }
+
+  if (validationResult?.summary) {
+    if (validationResult.summary.passed.length > 0) {
+      lines.push('');
+      lines.push('Passed:');
+      for (const item of validationResult.summary.passed) {
+        lines.push(`  ✓ ${item}`);
+      }
+    }
+
+    if (validationResult.summary.failed.length > 0) {
+      lines.push('');
+      lines.push('Failed:');
+      for (const item of validationResult.summary.failed) {
+        lines.push(`  ✗ ${item}`);
+      }
+    }
+  }
+
+  lines.push('');
+  lines.push('Next steps:');
+  lines.push('  1. Test your project: npm test');
+  lines.push('  2. Review changes: git diff');
+  lines.push('  3. Report issues: github.com/aios/issues');
+  lines.push('');
+  lines.push('To rollback: aios migrate --rollback');
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  validateStructure,
+  countFiles,
+  runLintCheck,
+  runTests,
+  runFullValidation,
+  generateSummary,
+};

package/.aios-core/cli/commands/qa/index.js

@@ -0,0 +1,56 @@
+/**
+ * QA Command Module
+ *
+ * Entry point for all quality gate CLI commands.
+ * Includes run and status subcommands.
+ *
+ * @module cli/commands/qa
+ * @version 1.0.0
+ * @story 2.10 - Quality Gate Manager
+ */
+
+const { Command } = require('commander');
+const { createRunCommand } = require('./run');
+const { createStatusCommand } = require('./status');
+
+/**
+ * Create the qa command with all subcommands
+ * @returns {Command} Commander command instance
+ */
+function createQaCommand() {
+  const qa = new Command('qa');
+
+  qa
+    .description('Quality Gate Manager - orchestrate 3-layer quality pipeline')
+    .addHelpText('after', `
+Commands:
+  run               Execute quality gate pipeline
+  status            Show current gate status
+
+Examples:
+  $ aios qa run                    Run full pipeline
+  $ aios qa run --layer=1          Run only Layer 1 (pre-commit)
+  $ aios qa run --layer=2          Run only Layer 2 (PR automation)
+  $ aios qa run --verbose          Run with detailed output
+  $ aios qa status                 Show current gate status
+
+Layers:
+  Layer 1: Pre-commit (lint, test, typecheck) - Fast local checks
+  Layer 2: PR Automation (CodeRabbit, Quinn) - Automated review
+  Layer 3: Human Review (checklist, sign-off) - Strategic review
+
+Exit Codes:
+  0 = All gates passed (or pending human review)
+  1 = Gates failed (fix required)
+`);
+
+  // Add subcommands
+  qa.addCommand(createRunCommand());
+  qa.addCommand(createStatusCommand());
+
+  return qa;
+}
+
+module.exports = {
+  createQaCommand,
+};

package/.aios-core/cli/commands/qa/run.js

@@ -0,0 +1,163 @@
+/**
+ * QA Run Command
+ *
+ * Execute quality gate pipeline.
+ * Supports running full pipeline or specific layers.
+ *
+ * @module cli/commands/qa/run
+ * @version 1.0.0
+ * @story 2.10 - Quality Gate Manager
+ */
+
+const { Command } = require('commander');
+const { QualityGateManager } = require('../../../core/quality-gates/quality-gate-manager');
+
+/**
+ * Create the run subcommand
+ * @returns {Command} Commander command instance
+ */
+function createRunCommand() {
+  const run = new Command('run');
+
+  run
+    .description('Execute quality gate pipeline')
+    .option('-l, --layer <number>', 'Run specific layer only (1, 2, or 3)')
+    .option('-v, --verbose', 'Show detailed output', false)
+    .option('-s, --story <id>', 'Story ID for reporting')
+    .option('--save-report', 'Save detailed report to file', false)
+    .option('--no-fail-fast', 'Continue on Layer 1 failures')
+    .action(async (options) => {
+      try {
+        const manager = await QualityGateManager.load();
+
+        const context = {
+          verbose: options.verbose,
+          storyId: options.story,
+          failFast: options.failFast !== false,
+        };
+
+        let result;
+
+        if (options.layer) {
+          // Run specific layer
+          const layerNum = parseInt(options.layer, 10);
+          if (![1, 2, 3].includes(layerNum)) {
+            console.error('Error: Layer must be 1, 2, or 3');
+            process.exit(1);
+          }
+
+          if (context.verbose) {
+            console.log(`\n🔍 Running Layer ${layerNum} only`);
+            console.log('━'.repeat(50));
+          }
+
+          result = await manager.runLayer(layerNum, context);
+
+          // Format single layer output
+          printLayerResult(result, context.verbose);
+        } else {
+          // Run full pipeline
+          result = await manager.orchestrate(context);
+
+          if (!context.verbose) {
+            // Print summary for non-verbose mode
+            printSummary(result);
+          }
+        }
+
+        // Save status
+        await manager.saveStatus();
+
+        // Save report if requested
+        if (options.saveReport) {
+          const reportPath = await manager.saveReport(options.story);
+          console.log(`\n📄 Report saved to: ${reportPath}`);
+        }
+
+        // Exit with appropriate code
+        process.exit(result.exitCode || (result.pass ? 0 : 1));
+      } catch (error) {
+        console.error(`\n❌ Error: ${error.message}`);
+        if (options.verbose) {
+          console.error(error.stack);
+        }
+        process.exit(1);
+      }
+    });
+
+  return run;
+}
+
+/**
+ * Print single layer result
+ * @param {Object} result - Layer result
+ * @param {boolean} verbose - Verbose mode
+ */
+function printLayerResult(result, verbose = false) {
+  if (verbose) {
+    // Verbose output already printed by layer
+    return;
+  }
+
+  const icon = result.pass ? '✅' : '❌';
+  console.log(`\n${icon} ${result.layer}`);
+
+  result.results?.forEach((check) => {
+    const checkIcon = check.pass ? '✓' : '✗';
+    const skipped = check.skipped ? ' (skipped)' : '';
+    console.log(`  ${checkIcon} ${check.check}: ${check.message}${skipped}`);
+  });
+
+  console.log(`\nDuration: ${formatDuration(result.duration)}`);
+}
+
+/**
+ * Print pipeline summary
+ * @param {Object} result - Pipeline result
+ */
+function printSummary(result) {
+  console.log('\n🔍 Quality Gate Pipeline');
+  console.log('━'.repeat(50));
+
+  result.layers?.forEach((layer) => {
+    const icon = layer.pass ? '✅' : '❌';
+    const status = layer.pass ? 'PASSED' : 'FAILED';
+    console.log(`\n${layer.layer}`);
+
+    layer.results?.forEach((check) => {
+      const checkIcon = check.pass ? '✓' : '✗';
+      const skipped = check.skipped ? ' (skipped)' : '';
+      console.log(`  ${checkIcon} ${check.check}: ${check.message}${skipped}`);
+    });
+
+    console.log(`  ${icon} ${status}`);
+  });
+
+  console.log('\n━'.repeat(50));
+
+  const statusIcon = result.status === 'passed' ? '✅' :
+    result.status === 'pending' ? '⏳' : '❌';
+
+  console.log(`Result: ${statusIcon} ${result.status.toUpperCase()}`);
+  console.log(`Duration: ${formatDuration(result.duration)}`);
+
+  if (result.message) {
+    console.log(`Message: ${result.message}`);
+  }
+}
+
+/**
+ * Format duration for display
+ * @param {number} ms - Duration in milliseconds
+ * @returns {string} Formatted duration
+ */
+function formatDuration(ms) {
+  if (!ms) return '0ms';
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${(ms / 60000).toFixed(1)}m`;
+}
+
+module.exports = {
+  createRunCommand,
+};