aios-core 2.1.0

package/.aios-core/cli/commands/metrics/cleanup.js

@@ -0,0 +1,91 @@
+/**
+ * Metrics Cleanup Command
+ *
+ * Remove old records beyond retention period.
+ *
+ * @module cli/commands/metrics/cleanup
+ * @version 1.0.0
+ * @story 3.11a - Quality Gates Metrics Collector
+ */
+
+const { Command } = require('commander');
+const { MetricsCollector } = require('../../../quality/metrics-collector');
+
+/**
+ * Create the cleanup subcommand
+ * @returns {Command} Commander command instance
+ */
+function createCleanupCommand() {
+  const cleanup = new Command('cleanup');
+
+  cleanup
+    .description('Remove old records beyond retention period')
+    .option('-d, --dry-run', 'Show what would be deleted without deleting', false)
+    .option('-r, --retention <days>', 'Override retention period (days)', '30')
+    .option('-v, --verbose', 'Show detailed output', false)
+    .action(async (options) => {
+      try {
+        const retentionDays = parseInt(options.retention, 10);
+        const collector = new MetricsCollector({ retentionDays });
+        const metrics = await collector.getMetrics();
+
+        const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+        const cutoffDate = new Date(cutoff).toISOString();
+
+        // Count records that would be removed
+        const toRemove = metrics.history.filter(
+          (r) => new Date(r.timestamp).getTime() <= cutoff,
+        );
+
+        if (options.dryRun) {
+          console.log('\n🔍 Cleanup Dry Run');
+          console.log('━'.repeat(40));
+          console.log(`Retention Period: ${retentionDays} days`);
+          console.log(`Cutoff Date: ${cutoffDate.split('T')[0]}`);
+          console.log(`Records to Remove: ${toRemove.length}`);
+          console.log(`Records to Keep: ${metrics.history.length - toRemove.length}`);
+
+          if (options.verbose && toRemove.length > 0) {
+            console.log('\n📜 Records to be removed:');
+            toRemove.forEach((r) => {
+              const time = r.timestamp.substring(0, 19).replace('T', ' ');
+              const status = r.passed ? 'PASS' : 'FAIL';
+              console.log(`  ${time} Layer ${r.layer} ${status}`);
+            });
+          }
+
+          console.log('\nRun without --dry-run to perform cleanup');
+          process.exit(0);
+        }
+
+        // Perform actual cleanup
+        const removedCount = await collector.cleanup();
+
+        console.log('\n🧹 Cleanup Complete');
+        console.log('━'.repeat(40));
+        console.log(`Retention Period: ${retentionDays} days`);
+        console.log(`Records Removed: ${removedCount}`);
+        console.log(`Records Remaining: ${metrics.history.length - removedCount}`);
+
+        if (removedCount > 0) {
+          console.log('\n✅ Metrics recalculated after cleanup');
+        } else {
+          console.log('\n✅ No records needed cleanup');
+        }
+
+        process.exit(0);
+      } catch (error) {
+        console.error(`\n❌ Error: ${error.message}`);
+        if (options.verbose) {
+          console.error(error.stack);
+        }
+        process.exit(1);
+      }
+    });
+
+  return cleanup;
+}
+
+module.exports = {
+  createCleanupCommand,
+};

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

@@ -0,0 +1,65 @@
+/**
+ * Metrics Command Module
+ *
+ * Entry point for all quality metrics CLI commands.
+ * Includes record, show, seed, and cleanup subcommands.
+ *
+ * @module cli/commands/metrics
+ * @version 1.0.0
+ * @story 3.11a - Quality Gates Metrics Collector
+ */
+
+const { Command } = require('commander');
+const { createRecordCommand } = require('./record');
+const { createShowCommand } = require('./show');
+const { createSeedCommand } = require('./seed');
+const { createCleanupCommand } = require('./cleanup');
+
+/**
+ * Create the metrics command with all subcommands
+ * @returns {Command} Commander command instance
+ */
+function createMetricsCommand() {
+  const metrics = new Command('metrics');
+
+  metrics
+    .description('Quality Gates Metrics - collect and analyze quality data')
+    .addHelpText('after', `
+Commands:
+  record            Record a quality gate run
+  show              Display current metrics
+  seed              Generate seed data for testing
+  cleanup           Remove old records beyond retention period
+
+Data Storage:
+  Metrics are stored in .aios/data/quality-metrics.json
+  History is retained for 30 days by default
+
+Layers:
+  Layer 1: Pre-commit (lint, test, typecheck)
+  Layer 2: PR Automation (CodeRabbit, Quinn)
+  Layer 3: Human Review (checklist, sign-off)
+
+Examples:
+  $ aios metrics record --layer 1 --passed --duration 3200
+  $ aios metrics record --layer 2 --passed --findings 3 --coderabbit
+  $ aios metrics show
+  $ aios metrics show --layer 2
+  $ aios metrics show --format json
+  $ aios metrics seed --days 30
+  $ aios metrics cleanup
+  $ aios metrics cleanup --dry-run
+`);
+
+  // Add subcommands
+  metrics.addCommand(createRecordCommand());
+  metrics.addCommand(createShowCommand());
+  metrics.addCommand(createSeedCommand());
+  metrics.addCommand(createCleanupCommand());
+
+  return metrics;
+}
+
+module.exports = {
+  createMetricsCommand,
+};

package/.aios-core/cli/commands/metrics/record.js

@@ -0,0 +1,154 @@
+/**
+ * Metrics Record Command
+ *
+ * Record a quality gate run with metrics.
+ *
+ * @module cli/commands/metrics/record
+ * @version 1.0.0
+ * @story 3.11a - Quality Gates Metrics Collector
+ */
+
+const { Command } = require('commander');
+const { MetricsCollector } = require('../../../quality/metrics-collector');
+
+/**
+ * Create the record subcommand
+ * @returns {Command} Commander command instance
+ */
+function createRecordCommand() {
+  const record = new Command('record');
+
+  record
+    .description('Record a quality gate run')
+    .requiredOption('-l, --layer <number>', 'Layer number (1, 2, or 3)')
+    .option('-p, --passed', 'Mark run as passed', false)
+    .option('-f, --failed', 'Mark run as failed', false)
+    .option('-d, --duration <ms>', 'Duration in milliseconds')
+    .option('--findings <count>', 'Number of findings')
+    .option('-s, --story <id>', 'Story ID for metadata')
+    .option('-b, --branch <name>', 'Branch name for metadata')
+    .option('--commit <hash>', 'Commit hash for metadata')
+    .option('--coderabbit', 'Include CodeRabbit metrics', false)
+    .option('--cr-critical <count>', 'CodeRabbit critical findings', '0')
+    .option('--cr-high <count>', 'CodeRabbit high findings', '0')
+    .option('--cr-medium <count>', 'CodeRabbit medium findings', '0')
+    .option('--cr-low <count>', 'CodeRabbit low findings', '0')
+    .option('--quinn', 'Include Quinn metrics', false)
+    .option('--quinn-findings <count>', 'Quinn findings count', '0')
+    .option('--quinn-categories <list>', 'Quinn categories (comma-separated)')
+    .option('-v, --verbose', 'Show detailed output', false)
+    .action(async (options) => {
+      try {
+        const collector = new MetricsCollector();
+
+        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);
+        }
+
+        // Determine pass/fail status
+        let passed = true;
+        if (options.failed) {
+          passed = false;
+        } else if (options.passed) {
+          passed = true;
+        }
+
+        // Build result object
+        const result = {
+          passed,
+          durationMs: options.duration ? parseInt(options.duration, 10) : 0,
+          findingsCount: options.findings ? parseInt(options.findings, 10) : 0,
+          metadata: {},
+        };
+
+        // Add metadata
+        if (options.story) result.metadata.storyId = options.story;
+        if (options.branch) result.metadata.branchName = options.branch;
+        if (options.commit) result.metadata.commitHash = options.commit;
+        result.metadata.triggeredBy = 'cli';
+
+        // Handle Layer 2 specific metrics
+        if (layerNum === 2) {
+          if (options.coderabbit) {
+            result.coderabbit = {
+              findingsCount: parseInt(options.crCritical, 10) +
+                parseInt(options.crHigh, 10) +
+                parseInt(options.crMedium, 10) +
+                parseInt(options.crLow, 10),
+              severityBreakdown: {
+                critical: parseInt(options.crCritical, 10),
+                high: parseInt(options.crHigh, 10),
+                medium: parseInt(options.crMedium, 10),
+                low: parseInt(options.crLow, 10),
+              },
+            };
+          }
+
+          if (options.quinn) {
+            result.quinn = {
+              findingsCount: parseInt(options.quinnFindings, 10),
+              topCategories: options.quinnCategories
+                ? options.quinnCategories.split(',').map((c) => c.trim())
+                : [],
+            };
+          }
+
+          // Record as PR review for Layer 2
+          const run = await collector.recordPRReview(result);
+
+          if (options.verbose) {
+            console.log('\n📊 Layer 2 PR Review Recorded');
+            console.log('━'.repeat(40));
+            console.log(`Timestamp: ${run.timestamp}`);
+            console.log(`Passed: ${run.passed ? '✅' : '❌'}`);
+            console.log(`Duration: ${run.durationMs}ms`);
+            console.log(`Findings: ${run.findingsCount}`);
+            if (options.coderabbit) {
+              console.log(`CodeRabbit: ${JSON.stringify(result.coderabbit)}`);
+            }
+            if (options.quinn) {
+              console.log(`Quinn: ${JSON.stringify(result.quinn)}`);
+            }
+          } else {
+            const icon = run.passed ? '✅' : '❌';
+            console.log(`${icon} Layer 2 run recorded`);
+          }
+        } else {
+          // Record Layer 1 or 3
+          const run = await collector.recordRun(layerNum, result);
+
+          if (options.verbose) {
+            const layerName = layerNum === 1 ? 'Pre-commit' : 'Human Review';
+            console.log(`\n📊 Layer ${layerNum} ${layerName} Recorded`);
+            console.log('━'.repeat(40));
+            console.log(`Timestamp: ${run.timestamp}`);
+            console.log(`Passed: ${run.passed ? '✅' : '❌'}`);
+            console.log(`Duration: ${run.durationMs}ms`);
+            console.log(`Findings: ${run.findingsCount}`);
+            if (Object.keys(result.metadata).length > 0) {
+              console.log(`Metadata: ${JSON.stringify(result.metadata)}`);
+            }
+          } else {
+            const icon = run.passed ? '✅' : '❌';
+            console.log(`${icon} Layer ${layerNum} run recorded`);
+          }
+        }
+
+        process.exit(0);
+      } catch (error) {
+        console.error(`\n❌ Error: ${error.message}`);
+        if (options.verbose) {
+          console.error(error.stack);
+        }
+        process.exit(1);
+      }
+    });
+
+  return record;
+}
+
+module.exports = {
+  createRecordCommand,
+};

package/.aios-core/cli/commands/metrics/seed.js

@@ -0,0 +1,126 @@
+/**
+ * Metrics Seed Command
+ *
+ * Generate seed data for testing metrics dashboard.
+ *
+ * @module cli/commands/metrics/seed
+ * @version 1.0.0
+ * @story 3.11a - Quality Gates Metrics Collector
+ */
+
+const { Command } = require('commander');
+const { seedMetrics } = require('../../../quality/seed-metrics');
+
+/**
+ * Create the seed subcommand
+ * @returns {Command} Commander command instance
+ */
+function createSeedCommand() {
+  const seed = new Command('seed');
+
+  seed
+    .description('Generate seed data for testing metrics dashboard')
+    .option('-d, --days <number>', 'Number of days of history to generate', '30')
+    .option('-r, --runs <number>', 'Average runs per day', '8')
+    .option('--no-weekends', 'Include full activity on weekends', false)
+    .option('--dry-run', 'Preview generated data without saving', false)
+    .option('-v, --verbose', 'Show detailed output', false)
+    .action(async (options) => {
+      try {
+        const seedOptions = {
+          days: parseInt(options.days, 10),
+          runsPerDay: parseInt(options.runs, 10),
+          weekendReduction: options.weekends !== false,
+        };
+
+        console.log('\n🌱 Generating Seed Data');
+        console.log('━'.repeat(40));
+        console.log(`Days: ${seedOptions.days}`);
+        console.log(`Runs/Day: ${seedOptions.runsPerDay}`);
+        console.log(`Weekend Reduction: ${seedOptions.weekendReduction ? 'Yes' : 'No'}`);
+
+        if (options.dryRun) {
+          // Generate but don't save
+          const { generateSeedData } = require('../../../quality/seed-metrics');
+          const metrics = generateSeedData(seedOptions);
+
+          console.log('\n📊 Generated Data Preview (dry run)');
+          console.log('─'.repeat(40));
+          console.log(`Total History Records: ${metrics.history.length}`);
+          console.log(`Layer 1 Runs: ${metrics.layers.layer1.totalRuns}`);
+          console.log(`Layer 2 Runs: ${metrics.layers.layer2.totalRuns}`);
+          console.log(`Layer 3 Runs: ${metrics.layers.layer3.totalRuns}`);
+
+          console.log('\n📈 Layer Pass Rates:');
+          console.log(`  Layer 1: ${(metrics.layers.layer1.passRate * 100).toFixed(1)}%`);
+          console.log(`  Layer 2: ${(metrics.layers.layer2.passRate * 100).toFixed(1)}%`);
+          console.log(`  Layer 3: ${(metrics.layers.layer3.passRate * 100).toFixed(1)}%`);
+
+          if (options.verbose) {
+            console.log('\n📜 Sample History (first 5 records):');
+            metrics.history.slice(0, 5).forEach((r) => {
+              const time = r.timestamp.substring(0, 19).replace('T', ' ');
+              const status = r.passed ? 'PASS' : 'FAIL';
+              console.log(`  ${time} Layer ${r.layer} ${status}`);
+            });
+          }
+
+          console.log('\n⚠️  Dry run mode - data not saved');
+          console.log('Run without --dry-run to save data');
+          process.exit(0);
+        }
+
+        // Generate and save
+        const metrics = await seedMetrics(seedOptions);
+
+        console.log('\n✅ Seed Data Generated');
+        console.log('─'.repeat(40));
+        console.log(`Total History Records: ${metrics.history.length}`);
+        console.log(`Layer 1 Runs: ${metrics.layers.layer1.totalRuns}`);
+        console.log(`Layer 2 Runs: ${metrics.layers.layer2.totalRuns}`);
+        console.log(`Layer 3 Runs: ${metrics.layers.layer3.totalRuns}`);
+
+        console.log('\n📈 Layer Pass Rates:');
+        console.log(`  Layer 1: ${(metrics.layers.layer1.passRate * 100).toFixed(1)}%`);
+        console.log(`  Layer 2: ${(metrics.layers.layer2.passRate * 100).toFixed(1)}%`);
+        console.log(`  Layer 3: ${(metrics.layers.layer3.passRate * 100).toFixed(1)}%`);
+
+        console.log('\n🔗 CodeRabbit Metrics:');
+        const cr = metrics.layers.layer2.coderabbit;
+        if (cr?.active) {
+          console.log(`  Total Findings: ${cr.findingsCount}`);
+          console.log(`  Critical: ${cr.severityBreakdown.critical}`);
+          console.log(`  High: ${cr.severityBreakdown.high}`);
+          console.log(`  Medium: ${cr.severityBreakdown.medium}`);
+          console.log(`  Low: ${cr.severityBreakdown.low}`);
+        }
+
+        console.log('\n🔍 Quinn Metrics:');
+        const q = metrics.layers.layer2.quinn;
+        if (q) {
+          console.log(`  Findings: ${q.findingsCount}`);
+          console.log(`  Top Categories: ${q.topCategories.join(', ')}`);
+        }
+
+        console.log('\n📊 Trend Data:');
+        console.log(`  Pass Rate Points: ${metrics.trends.passRates.length}`);
+        console.log(`  Auto-Catch Points: ${metrics.trends.autoCatchRate.length}`);
+
+        console.log('\n✅ Data saved to .aios/data/quality-metrics.json');
+
+        process.exit(0);
+      } catch (error) {
+        console.error(`\n❌ Error: ${error.message}`);
+        if (options.verbose) {
+          console.error(error.stack);
+        }
+        process.exit(1);
+      }
+    });
+
+  return seed;
+}
+
+module.exports = {
+  createSeedCommand,
+};

package/.aios-core/cli/commands/metrics/show.js

@@ -0,0 +1,209 @@
+/**
+ * Metrics Show Command
+ *
+ * Display current quality gate metrics.
+ *
+ * @module cli/commands/metrics/show
+ * @version 1.0.0
+ * @story 3.11a - Quality Gates Metrics Collector
+ */
+
+const { Command } = require('commander');
+const { MetricsCollector } = require('../../../quality/metrics-collector');
+
+/**
+ * Format percentage for display
+ * @param {number} value - Value between 0 and 1
+ * @returns {string} Formatted percentage
+ */
+function formatPercent(value) {
+  if (value === null || value === undefined) return 'N/A';
+  return `${(value * 100).toFixed(1)}%`;
+}
+
+/**
+ * Format duration for display
+ * @param {number} ms - Duration in milliseconds
+ * @returns {string} Formatted duration
+ */
+function formatDuration(ms) {
+  if (!ms) return 'N/A';
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${(ms / 60000).toFixed(1)}m`;
+}
+
+/**
+ * Format relative time
+ * @param {string} timestamp - ISO timestamp
+ * @returns {string} Relative time string
+ */
+function formatRelativeTime(timestamp) {
+  if (!timestamp) return 'Never';
+  const diff = Date.now() - new Date(timestamp).getTime();
+  const minutes = Math.floor(diff / 60000);
+  const hours = Math.floor(diff / 3600000);
+  const days = Math.floor(diff / 86400000);
+
+  if (minutes < 1) return 'Just now';
+  if (minutes < 60) return `${minutes}m ago`;
+  if (hours < 24) return `${hours}h ago`;
+  return `${days}d ago`;
+}
+
+/**
+ * Create the show subcommand
+ * @returns {Command} Commander command instance
+ */
+function createShowCommand() {
+  const show = new Command('show');
+
+  show
+    .description('Display current quality gate metrics')
+    .option('-l, --layer <number>', 'Show specific layer only (1, 2, or 3)')
+    .option('-f, --format <type>', 'Output format (table, json, csv)', 'table')
+    .option('--history <count>', 'Show recent history', '10')
+    .option('--trends', 'Show trend data', false)
+    .option('-v, --verbose', 'Show detailed output', false)
+    .action(async (options) => {
+      try {
+        const collector = new MetricsCollector();
+        const metrics = await collector.getMetrics();
+
+        // Handle JSON/CSV export
+        if (options.format === 'json') {
+          console.log(JSON.stringify(metrics, null, 2));
+          process.exit(0);
+        }
+
+        if (options.format === 'csv') {
+          const csv = await collector.export('csv');
+          console.log(csv);
+          process.exit(0);
+        }
+
+        // Table format display
+        console.log('\n📊 Quality Gates Metrics');
+        console.log('━'.repeat(60));
+        console.log(`Last Updated: ${formatRelativeTime(metrics.lastUpdated)}`);
+        console.log(`Retention: ${metrics.retentionDays} days`);
+        console.log(`Total History: ${metrics.history.length} records`);
+
+        // Filter by layer if specified
+        const layers = options.layer
+          ? [`layer${options.layer}`]
+          : ['layer1', 'layer2', 'layer3'];
+
+        // Display layer metrics
+        for (const layerKey of layers) {
+          const layer = metrics.layers[layerKey];
+          const layerNum = layerKey.replace('layer', '');
+          const layerNames = {
+            1: 'Pre-commit',
+            2: 'PR Automation',
+            3: 'Human Review',
+          };
+
+          console.log(`\n📋 Layer ${layerNum}: ${layerNames[layerNum]}`);
+          console.log('─'.repeat(40));
+
+          if (!layer || layer.totalRuns === 0) {
+            console.log('  No data available');
+            continue;
+          }
+
+          const passIcon = layer.passRate >= 0.9 ? '🟢' :
+            layer.passRate >= 0.7 ? '🟡' : '🔴';
+
+          console.log(`  Pass Rate:   ${passIcon} ${formatPercent(layer.passRate)}`);
+          console.log(`  Avg Time:    ${formatDuration(layer.avgTimeMs)}`);
+          console.log(`  Total Runs:  ${layer.totalRuns}`);
+          console.log(`  Last Run:    ${formatRelativeTime(layer.lastRun)}`);
+
+          // Layer 2 specific metrics
+          if (layerKey === 'layer2' && layer.autoCatchRate !== undefined) {
+            console.log(`  Auto-Catch:  ${formatPercent(layer.autoCatchRate)}`);
+
+            if (layer.coderabbit?.active) {
+              const cr = layer.coderabbit;
+              console.log('\n  CodeRabbit:');
+              console.log(`    Findings: ${cr.findingsCount}`);
+              if (cr.severityBreakdown) {
+                const sb = cr.severityBreakdown;
+                console.log(`    Critical: ${sb.critical}, High: ${sb.high}, Medium: ${sb.medium}, Low: ${sb.low}`);
+              }
+            }
+
+            if (layer.quinn?.findingsCount > 0) {
+              const q = layer.quinn;
+              console.log('\n  Quinn:');
+              console.log(`    Findings: ${q.findingsCount}`);
+              if (q.topCategories?.length > 0) {
+                console.log(`    Top Categories: ${q.topCategories.join(', ')}`);
+              }
+            }
+          }
+        }
+
+        // Show trends if requested
+        if (options.trends) {
+          console.log('\n📈 Trends');
+          console.log('─'.repeat(40));
+
+          if (metrics.trends.passRates?.length > 0) {
+            console.log('\n  Pass Rates (last 7 days):');
+            const recentPassRates = metrics.trends.passRates.slice(-7);
+            recentPassRates.forEach((t) => {
+              const bar = '█'.repeat(Math.floor(t.value * 20));
+              console.log(`    ${t.date}: ${bar} ${formatPercent(t.value)}`);
+            });
+          }
+
+          if (metrics.trends.autoCatchRate?.length > 0) {
+            console.log('\n  Auto-Catch Rate (last 7 days):');
+            const recentAuto = metrics.trends.autoCatchRate.slice(-7);
+            recentAuto.forEach((t) => {
+              console.log(`    ${t.date}: ${t.value.toFixed(2)}`);
+            });
+          }
+        }
+
+        // Show recent history if verbose
+        if (options.verbose || parseInt(options.history, 10) > 0) {
+          const historyCount = parseInt(options.history, 10);
+          const recentHistory = metrics.history.slice(-historyCount);
+
+          if (recentHistory.length > 0) {
+            console.log(`\n📜 Recent History (${recentHistory.length} records)`);
+            console.log('─'.repeat(60));
+            console.log('  Timestamp              Layer  Status  Duration  Findings');
+            console.log('  ' + '─'.repeat(56));
+
+            recentHistory.forEach((r) => {
+              const status = r.passed ? '✅ PASS' : '❌ FAIL';
+              const time = r.timestamp.substring(0, 19).replace('T', ' ');
+              const duration = formatDuration(r.durationMs).padEnd(8);
+              console.log(`  ${time}  L${r.layer}     ${status}  ${duration}  ${r.findingsCount || 0}`);
+            });
+          }
+        }
+
+        console.log('\n' + '━'.repeat(60));
+        console.log('Use --format json for full data export');
+
+        process.exit(0);
+      } catch (error) {
+        console.error(`\n❌ Error: ${error.message}`);
+        if (options.verbose) {
+          console.error(error.stack);
+        }
+        process.exit(1);
+      }
+    });
+
+  return show;
+}
+
+module.exports = {
+  createShowCommand,
+};