@girardmedia/bootspring 1.2.0 → 2.0.3

package/cli/monitor.js

@@ -0,0 +1,812 @@
+/**
+ * Bootspring Monitor Command
+ * Production monitoring, hooks, and alerting
+ *
+ * @package bootspring
+ * @command monitor
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const config = require('../core/config');
+const utils = require('../core/utils');
+
+// Supported monitoring providers
+const MONITORING_PROVIDERS = {
+  sentry: {
+    name: 'Sentry',
+    description: 'Error tracking and performance monitoring',
+    envVars: ['SENTRY_DSN', 'SENTRY_AUTH_TOKEN'],
+    docs: 'https://docs.sentry.io/'
+  },
+  datadog: {
+    name: 'Datadog',
+    description: 'Infrastructure and application monitoring',
+    envVars: ['DD_API_KEY', 'DD_APP_KEY'],
+    docs: 'https://docs.datadoghq.com/'
+  },
+  newrelic: {
+    name: 'New Relic',
+    description: 'Full-stack observability platform',
+    envVars: ['NEW_RELIC_LICENSE_KEY', 'NEW_RELIC_APP_NAME'],
+    docs: 'https://docs.newrelic.com/'
+  },
+  logrocket: {
+    name: 'LogRocket',
+    description: 'Session replay and error tracking',
+    envVars: ['LOGROCKET_APP_ID'],
+    docs: 'https://docs.logrocket.com/'
+  },
+  axiom: {
+    name: 'Axiom',
+    description: 'Log management and analytics',
+    envVars: ['AXIOM_TOKEN', 'AXIOM_DATASET'],
+    docs: 'https://axiom.co/docs'
+  }
+};
+
+// Supported alert providers
+const ALERT_PROVIDERS = {
+  slack: {
+    name: 'Slack',
+    description: 'Team messaging and notifications',
+    envVars: ['SLACK_WEBHOOK_URL'],
+    docs: 'https://api.slack.com/messaging/webhooks'
+  },
+  discord: {
+    name: 'Discord',
+    description: 'Community chat notifications',
+    envVars: ['DISCORD_WEBHOOK_URL'],
+    docs: 'https://discord.com/developers/docs/resources/webhook'
+  },
+  pagerduty: {
+    name: 'PagerDuty',
+    description: 'On-call management and incident response',
+    envVars: ['PAGERDUTY_ROUTING_KEY'],
+    docs: 'https://developer.pagerduty.com/'
+  },
+  email: {
+    name: 'Email',
+    description: 'Email notifications',
+    envVars: ['ALERT_EMAIL_TO', 'SMTP_HOST'],
+    docs: 'Configure SMTP settings for email alerts'
+  }
+};
+
+// Performance metrics to track
+const PERFORMANCE_METRICS = {
+  bundleSize: {
+    name: 'Bundle Size',
+    description: 'JavaScript bundle size in KB',
+    command: 'du -sk .next 2>/dev/null || du -sk dist 2>/dev/null || echo "0"',
+    unit: 'KB'
+  },
+  buildTime: {
+    name: 'Build Time',
+    description: 'Time to build in seconds',
+    unit: 'seconds'
+  },
+  testCoverage: {
+    name: 'Test Coverage',
+    description: 'Code coverage percentage',
+    unit: '%'
+  },
+  dependencies: {
+    name: 'Dependencies',
+    description: 'Number of production dependencies',
+    unit: 'count'
+  }
+};
+
+/**
+ * Get monitor state directory
+ */
+function getStateDir(projectRoot) {
+  return path.join(projectRoot, '.bootspring', 'monitor');
+}
+
+/**
+ * Load monitor configuration
+ */
+function loadMonitorConfig(projectRoot) {
+  const stateDir = getStateDir(projectRoot);
+  const configPath = path.join(stateDir, 'config.json');
+
+  if (fs.existsSync(configPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    } catch {
+      return createDefaultConfig();
+    }
+  }
+
+  return createDefaultConfig();
+}
+
+/**
+ * Create default monitor configuration
+ */
+function createDefaultConfig() {
+  return {
+    version: '1.0.0',
+    monitoring: {
+      enabled: false,
+      providers: []
+    },
+    alerts: {
+      enabled: false,
+      providers: [],
+      thresholds: {
+        errorRatePercent: 1,
+        bundleSizeKB: 500,
+        buildTimeSeconds: 120
+      }
+    },
+    metrics: {
+      tracking: true,
+      history: []
+    },
+    hooks: {
+      postDeploy: [],
+      onError: [],
+      onAlert: []
+    }
+  };
+}
+
+/**
+ * Save monitor configuration
+ */
+function saveMonitorConfig(projectRoot, monitorConfig) {
+  const stateDir = getStateDir(projectRoot);
+  if (!fs.existsSync(stateDir)) {
+    fs.mkdirSync(stateDir, { recursive: true });
+  }
+
+  const configPath = path.join(stateDir, 'config.json');
+  fs.writeFileSync(configPath, JSON.stringify(monitorConfig, null, 2));
+}
+
+/**
+ * Initialize monitoring
+ */
+function initMonitoring(projectRoot) {
+  const monitorConfig = loadMonitorConfig(projectRoot);
+  const stateDir = getStateDir(projectRoot);
+
+  if (!fs.existsSync(stateDir)) {
+    fs.mkdirSync(stateDir, { recursive: true });
+  }
+
+  // Create subdirectories
+  const dirs = ['metrics', 'snapshots', 'alerts'];
+  for (const dir of dirs) {
+    const dirPath = path.join(stateDir, dir);
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+  }
+
+  saveMonitorConfig(projectRoot, monitorConfig);
+
+  utils.print.success('Monitoring initialized');
+  console.log(`${utils.COLORS.dim}State directory: ${stateDir}${utils.COLORS.reset}`);
+}
+
+/**
+ * Show monitoring status
+ */
+function showStatus(projectRoot) {
+  const monitorConfig = loadMonitorConfig(projectRoot);
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}📊 Monitoring Status${utils.COLORS.reset}
+${utils.COLORS.dim}Project: ${projectRoot}${utils.COLORS.reset}
+`);
+
+  // Monitoring providers
+  console.log(`${utils.COLORS.bold}Monitoring Providers${utils.COLORS.reset}`);
+  if (monitorConfig.monitoring.providers.length === 0) {
+    console.log(`  ${utils.COLORS.dim}No providers configured${utils.COLORS.reset}`);
+  } else {
+    for (const provider of monitorConfig.monitoring.providers) {
+      const info = MONITORING_PROVIDERS[provider.id];
+      const status = provider.enabled ?
+        `${utils.COLORS.green}✓ enabled${utils.COLORS.reset}` :
+        `${utils.COLORS.yellow}○ disabled${utils.COLORS.reset}`;
+      console.log(`  ${info?.name || provider.id}: ${status}`);
+    }
+  }
+  console.log();
+
+  // Alert providers
+  console.log(`${utils.COLORS.bold}Alert Providers${utils.COLORS.reset}`);
+  if (monitorConfig.alerts.providers.length === 0) {
+    console.log(`  ${utils.COLORS.dim}No alert providers configured${utils.COLORS.reset}`);
+  } else {
+    for (const provider of monitorConfig.alerts.providers) {
+      const info = ALERT_PROVIDERS[provider.id];
+      const status = provider.enabled ?
+        `${utils.COLORS.green}✓ enabled${utils.COLORS.reset}` :
+        `${utils.COLORS.yellow}○ disabled${utils.COLORS.reset}`;
+      console.log(`  ${info?.name || provider.id}: ${status}`);
+    }
+  }
+  console.log();
+
+  // Thresholds
+  console.log(`${utils.COLORS.bold}Alert Thresholds${utils.COLORS.reset}`);
+  const thresholds = monitorConfig.alerts.thresholds;
+  console.log(`  Error rate:  ${thresholds.errorRatePercent}%`);
+  console.log(`  Bundle size: ${thresholds.bundleSizeKB} KB`);
+  console.log(`  Build time:  ${thresholds.buildTimeSeconds}s`);
+  console.log();
+
+  // Recent metrics
+  const metricsDir = path.join(getStateDir(projectRoot), 'metrics');
+  if (fs.existsSync(metricsDir)) {
+    const files = fs.readdirSync(metricsDir).sort().slice(-5);
+    if (files.length > 0) {
+      console.log(`${utils.COLORS.bold}Recent Metrics${utils.COLORS.reset}`);
+      for (const file of files) {
+        try {
+          const metrics = JSON.parse(fs.readFileSync(path.join(metricsDir, file), 'utf-8'));
+          const date = new Date(metrics.timestamp).toLocaleDateString();
+          console.log(`  ${date}: bundle=${metrics.bundleSize || 'N/A'}KB, deps=${metrics.dependencies || 'N/A'}`);
+        } catch {
+          // Skip invalid files
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Collect current metrics
+ */
+function collectMetrics(projectRoot) {
+  const spinner = utils.createSpinner('Collecting metrics...').start();
+
+  const metrics = {
+    timestamp: new Date().toISOString(),
+    bundleSize: null,
+    buildTime: null,
+    testCoverage: null,
+    dependencies: null,
+    devDependencies: null
+  };
+
+  try {
+    // Get bundle size
+    const buildDirs = ['.next', 'dist', 'build', 'out'];
+    for (const dir of buildDirs) {
+      const dirPath = path.join(projectRoot, dir);
+      if (fs.existsSync(dirPath)) {
+        try {
+          const output = execSync(`du -sk "${dirPath}"`, {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe']
+          });
+          metrics.bundleSize = parseInt(output.split('\t')[0], 10);
+          break;
+        } catch {
+          // Continue to next directory
+        }
+      }
+    }
+
+    // Get dependency counts from package.json
+    const pkgPath = path.join(projectRoot, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      metrics.dependencies = Object.keys(pkg.dependencies || {}).length;
+      metrics.devDependencies = Object.keys(pkg.devDependencies || {}).length;
+    }
+
+    // Get test coverage if available
+    const coveragePath = path.join(projectRoot, 'coverage', 'coverage-summary.json');
+    if (fs.existsSync(coveragePath)) {
+      try {
+        const coverage = JSON.parse(fs.readFileSync(coveragePath, 'utf-8'));
+        metrics.testCoverage = coverage.total?.lines?.pct || null;
+      } catch {
+        // Coverage file invalid
+      }
+    }
+
+    spinner.succeed('Metrics collected');
+  } catch (error) {
+    spinner.fail(`Failed to collect metrics: ${error.message}`);
+  }
+
+  // Save metrics
+  const metricsDir = path.join(getStateDir(projectRoot), 'metrics');
+  if (!fs.existsSync(metricsDir)) {
+    fs.mkdirSync(metricsDir, { recursive: true });
+  }
+
+  const filename = `metrics-${new Date().toISOString().split('T')[0]}.json`;
+  fs.writeFileSync(path.join(metricsDir, filename), JSON.stringify(metrics, null, 2));
+
+  // Display metrics
+  console.log();
+  console.log(`${utils.COLORS.bold}Current Metrics${utils.COLORS.reset}`);
+  console.log(`  Bundle size:    ${metrics.bundleSize !== null ? `${metrics.bundleSize} KB` : 'N/A'}`);
+  console.log(`  Dependencies:   ${metrics.dependencies !== null ? metrics.dependencies : 'N/A'}`);
+  console.log(`  Dev deps:       ${metrics.devDependencies !== null ? metrics.devDependencies : 'N/A'}`);
+  console.log(`  Test coverage:  ${metrics.testCoverage !== null ? `${metrics.testCoverage}%` : 'N/A'}`);
+
+  return metrics;
+}
+
+/**
+ * Add monitoring provider
+ */
+function addProvider(projectRoot, type, providerId) {
+  const providers = type === 'monitoring' ? MONITORING_PROVIDERS : ALERT_PROVIDERS;
+
+  if (!providers[providerId]) {
+    utils.print.error(`Unknown ${type} provider: ${providerId}`);
+    console.log(`${utils.COLORS.dim}Available: ${Object.keys(providers).join(', ')}${utils.COLORS.reset}`);
+    return;
+  }
+
+  const provider = providers[providerId];
+  const monitorConfig = loadMonitorConfig(projectRoot);
+
+  // Check if already added
+  const existing = monitorConfig[type].providers.find(p => p.id === providerId);
+  if (existing) {
+    utils.print.warn(`${provider.name} is already configured`);
+    return;
+  }
+
+  // Add provider
+  monitorConfig[type].providers.push({
+    id: providerId,
+    enabled: true,
+    addedAt: new Date().toISOString()
+  });
+  monitorConfig[type].enabled = true;
+
+  saveMonitorConfig(projectRoot, monitorConfig);
+
+  utils.print.success(`Added ${provider.name}`);
+  console.log();
+  console.log(`${utils.COLORS.bold}Required Environment Variables${utils.COLORS.reset}`);
+  for (const envVar of provider.envVars) {
+    const hasVar = process.env[envVar] ?
+      `${utils.COLORS.green}✓${utils.COLORS.reset}` :
+      `${utils.COLORS.yellow}○${utils.COLORS.reset}`;
+    console.log(`  ${hasVar} ${envVar}`);
+  }
+  console.log();
+  console.log(`${utils.COLORS.dim}Documentation: ${provider.docs}${utils.COLORS.reset}`);
+}
+
+/**
+ * Remove monitoring provider
+ */
+function removeProvider(projectRoot, type, providerId) {
+  const monitorConfig = loadMonitorConfig(projectRoot);
+
+  const index = monitorConfig[type].providers.findIndex(p => p.id === providerId);
+  if (index === -1) {
+    utils.print.error(`Provider ${providerId} is not configured`);
+    return;
+  }
+
+  monitorConfig[type].providers.splice(index, 1);
+  if (monitorConfig[type].providers.length === 0) {
+    monitorConfig[type].enabled = false;
+  }
+
+  saveMonitorConfig(projectRoot, monitorConfig);
+  utils.print.success(`Removed ${providerId}`);
+}
+
+/**
+ * Run post-deploy hooks
+ */
+async function runPostDeploy(projectRoot, options = {}) {
+  const monitorConfig = loadMonitorConfig(projectRoot);
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}🚀 Post-Deploy Hooks${utils.COLORS.reset}
+`);
+
+  const results = {
+    timestamp: new Date().toISOString(),
+    deployTarget: options.target || 'unknown',
+    steps: []
+  };
+
+  // Step 1: Collect metrics
+  console.log(`${utils.COLORS.bold}1. Collecting Metrics${utils.COLORS.reset}`);
+  const metrics = collectMetrics(projectRoot);
+  results.steps.push({ name: 'metrics', status: 'success', data: metrics });
+  console.log();
+
+  // Step 2: Check thresholds
+  console.log(`${utils.COLORS.bold}2. Checking Thresholds${utils.COLORS.reset}`);
+  const thresholds = monitorConfig.alerts.thresholds;
+  let hasWarnings = false;
+
+  if (metrics.bundleSize && metrics.bundleSize > thresholds.bundleSizeKB) {
+    console.log(`  ${utils.COLORS.yellow}⚠${utils.COLORS.reset} Bundle size (${metrics.bundleSize}KB) exceeds threshold (${thresholds.bundleSizeKB}KB)`);
+    hasWarnings = true;
+  } else if (metrics.bundleSize) {
+    console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} Bundle size within threshold`);
+  }
+
+  if (hasWarnings) {
+    results.steps.push({ name: 'thresholds', status: 'warning' });
+  } else {
+    results.steps.push({ name: 'thresholds', status: 'success' });
+  }
+  console.log();
+
+  // Step 3: Regenerate context
+  console.log(`${utils.COLORS.bold}3. Regenerating Context${utils.COLORS.reset}`);
+  try {
+    // Update CLAUDE.md with production status
+    await regenerateContext(projectRoot, options);
+    results.steps.push({ name: 'context', status: 'success' });
+    console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} Context updated`);
+  } catch (error) {
+    results.steps.push({ name: 'context', status: 'error', error: error.message });
+    console.log(`  ${utils.COLORS.yellow}⚠${utils.COLORS.reset} Context update failed: ${error.message}`);
+  }
+  console.log();
+
+  // Step 4: Send alerts if configured
+  if (monitorConfig.alerts.enabled && monitorConfig.alerts.providers.length > 0) {
+    console.log(`${utils.COLORS.bold}4. Sending Notifications${utils.COLORS.reset}`);
+    for (const provider of monitorConfig.alerts.providers) {
+      if (provider.enabled) {
+        await sendDeployNotification(provider.id, {
+          target: options.target,
+          metrics,
+          warnings: hasWarnings
+        });
+      }
+    }
+    console.log();
+  }
+
+  // Save post-deploy snapshot
+  const snapshotsDir = path.join(getStateDir(projectRoot), 'snapshots');
+  if (!fs.existsSync(snapshotsDir)) {
+    fs.mkdirSync(snapshotsDir, { recursive: true });
+  }
+
+  const snapshotFile = `deploy-${new Date().toISOString().replace(/[:.]/g, '-')}.json`;
+  fs.writeFileSync(path.join(snapshotsDir, snapshotFile), JSON.stringify(results, null, 2));
+
+  utils.print.success('Post-deploy hooks completed');
+  console.log(`${utils.COLORS.dim}Snapshot saved: ${snapshotFile}${utils.COLORS.reset}`);
+
+  return results;
+}
+
+/**
+ * Regenerate production context
+ */
+async function regenerateContext(projectRoot, options = {}) {
+  // Update the CLAUDE.md with production deployment info
+  const claudeMdPath = path.join(projectRoot, 'CLAUDE.md');
+
+  if (!fs.existsSync(claudeMdPath)) {
+    return;
+  }
+
+  let content = fs.readFileSync(claudeMdPath, 'utf-8');
+
+  // Update status
+  content = content.replace(
+    /\*\*Status\*\*: \w+/,
+    '**Status**: production'
+  );
+
+  // Update last deployed
+  const deployDate = new Date().toISOString().split('T')[0];
+  if (content.includes('**Last Deployed**:')) {
+    content = content.replace(
+      /\*\*Last Deployed\*\*: .*/,
+      `**Last Deployed**: ${deployDate}`
+    );
+  } else if (content.includes('**Last Updated**:')) {
+    content = content.replace(
+      /\*\*Last Updated\*\*: .*/,
+      `**Last Updated**: ${deployDate}\n**Last Deployed**: ${deployDate}`
+    );
+  }
+
+  // Add deployment target if specified
+  if (options.target) {
+    if (content.includes('**Deployed To**:')) {
+      content = content.replace(
+        /\*\*Deployed To\*\*: .*/,
+        `**Deployed To**: ${options.target}`
+      );
+    }
+  }
+
+  fs.writeFileSync(claudeMdPath, content);
+}
+
+/**
+ * Send deploy notification to provider
+ */
+async function sendDeployNotification(providerId, data) {
+  const { target, metrics, warnings } = data;
+
+  switch (providerId) {
+    case 'slack': {
+      const webhookUrl = process.env.SLACK_WEBHOOK_URL;
+      if (!webhookUrl) {
+        console.log(`  ${utils.COLORS.yellow}○${utils.COLORS.reset} Slack: SLACK_WEBHOOK_URL not set`);
+        return;
+      }
+
+      const message = {
+        text: '🚀 Deployment Complete',
+        blocks: [
+          {
+            type: 'section',
+            text: {
+              type: 'mrkdwn',
+              text: `*Deployment Complete*\nTarget: ${target}\nBundle: ${metrics.bundleSize || 'N/A'} KB\n${warnings ? '⚠️ Warnings detected' : '✅ All checks passed'}`
+            }
+          }
+        ]
+      };
+
+      try {
+        execSync(`curl -s -X POST -H 'Content-type: application/json' --data '${JSON.stringify(message)}' "${webhookUrl}"`, {
+          stdio: 'pipe'
+        });
+        console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} Slack notification sent`);
+      } catch {
+        console.log(`  ${utils.COLORS.yellow}○${utils.COLORS.reset} Slack notification failed`);
+      }
+      break;
+    }
+
+    case 'discord': {
+      const webhookUrl = process.env.DISCORD_WEBHOOK_URL;
+      if (!webhookUrl) {
+        console.log(`  ${utils.COLORS.yellow}○${utils.COLORS.reset} Discord: DISCORD_WEBHOOK_URL not set`);
+        return;
+      }
+
+      const message = {
+        content: `🚀 **Deployment Complete**\nTarget: ${target}\nBundle: ${metrics.bundleSize || 'N/A'} KB\n${warnings ? '⚠️ Warnings detected' : '✅ All checks passed'}`
+      };
+
+      try {
+        execSync(`curl -s -X POST -H 'Content-type: application/json' --data '${JSON.stringify(message)}' "${webhookUrl}"`, {
+          stdio: 'pipe'
+        });
+        console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} Discord notification sent`);
+      } catch {
+        console.log(`  ${utils.COLORS.yellow}○${utils.COLORS.reset} Discord notification failed`);
+      }
+      break;
+    }
+
+    default:
+      console.log(`  ${utils.COLORS.dim}${providerId}: Notification not implemented${utils.COLORS.reset}`);
+  }
+}
+
+/**
+ * List available providers
+ */
+function listProviders() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}📊 Available Providers${utils.COLORS.reset}
+
+${utils.COLORS.bold}Monitoring${utils.COLORS.reset}
+`);
+
+  for (const [id, provider] of Object.entries(MONITORING_PROVIDERS)) {
+    console.log(`  ${utils.COLORS.cyan}${id}${utils.COLORS.reset}`);
+    console.log(`    ${provider.description}`);
+    console.log(`    ${utils.COLORS.dim}Env: ${provider.envVars.join(', ')}${utils.COLORS.reset}`);
+    console.log();
+  }
+
+  console.log(`${utils.COLORS.bold}Alerts${utils.COLORS.reset}
+`);
+
+  for (const [id, provider] of Object.entries(ALERT_PROVIDERS)) {
+    console.log(`  ${utils.COLORS.cyan}${id}${utils.COLORS.reset}`);
+    console.log(`    ${provider.description}`);
+    console.log(`    ${utils.COLORS.dim}Env: ${provider.envVars.join(', ')}${utils.COLORS.reset}`);
+    console.log();
+  }
+}
+
+/**
+ * Set alert threshold
+ */
+function setThreshold(projectRoot, name, value) {
+  const validThresholds = ['errorRatePercent', 'bundleSizeKB', 'buildTimeSeconds'];
+
+  if (!validThresholds.includes(name)) {
+    utils.print.error(`Unknown threshold: ${name}`);
+    console.log(`${utils.COLORS.dim}Available: ${validThresholds.join(', ')}${utils.COLORS.reset}`);
+    return;
+  }
+
+  const numValue = parseFloat(value);
+  if (isNaN(numValue)) {
+    utils.print.error('Value must be a number');
+    return;
+  }
+
+  const monitorConfig = loadMonitorConfig(projectRoot);
+  monitorConfig.alerts.thresholds[name] = numValue;
+  saveMonitorConfig(projectRoot, monitorConfig);
+
+  utils.print.success(`Set ${name} to ${numValue}`);
+}
+
+/**
+ * Show help
+ */
+function showHelp() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}📊 Bootspring Monitor${utils.COLORS.reset}
+${utils.COLORS.dim}Production monitoring, hooks, and alerting${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring monitor <command> [options]
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}init${utils.COLORS.reset}                    Initialize monitoring
+  ${utils.COLORS.cyan}status${utils.COLORS.reset}                  Show monitoring status
+  ${utils.COLORS.cyan}metrics${utils.COLORS.reset}                 Collect current metrics
+  ${utils.COLORS.cyan}providers${utils.COLORS.reset}               List available providers
+  ${utils.COLORS.cyan}post-deploy${utils.COLORS.reset}             Run post-deploy hooks
+
+${utils.COLORS.bold}Provider Management:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}add-monitoring${utils.COLORS.reset} <id>     Add monitoring provider
+  ${utils.COLORS.cyan}add-alert${utils.COLORS.reset} <id>          Add alert provider
+  ${utils.COLORS.cyan}remove-monitoring${utils.COLORS.reset} <id>  Remove monitoring provider
+  ${utils.COLORS.cyan}remove-alert${utils.COLORS.reset} <id>       Remove alert provider
+
+${utils.COLORS.bold}Configuration:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}threshold${utils.COLORS.reset} <name> <val>  Set alert threshold
+
+${utils.COLORS.bold}Monitoring Providers:${utils.COLORS.reset}
+  sentry, datadog, newrelic, logrocket, axiom
+
+${utils.COLORS.bold}Alert Providers:${utils.COLORS.reset}
+  slack, discord, pagerduty, email
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring monitor init
+  bootspring monitor status
+  bootspring monitor metrics
+  bootspring monitor add-alert slack
+  bootspring monitor add-monitoring sentry
+  bootspring monitor threshold bundleSizeKB 1000
+  bootspring monitor post-deploy --target=vercel
+`);
+}
+
+/**
+ * Run monitor command
+ */
+async function run(args) {
+  const parsedArgs = utils.parseArgs(args);
+  const subcommand = parsedArgs._[0];
+
+  if (!subcommand) {
+    showHelp();
+    return;
+  }
+
+  const cfg = config.load();
+  const projectRoot = cfg._projectRoot;
+
+  switch (subcommand) {
+    case 'init':
+      initMonitoring(projectRoot);
+      break;
+
+    case 'status':
+      showStatus(projectRoot);
+      break;
+
+    case 'metrics':
+      collectMetrics(projectRoot);
+      break;
+
+    case 'providers':
+      listProviders();
+      break;
+
+    case 'add-monitoring': {
+      const providerId = parsedArgs._[1];
+      if (!providerId) {
+        utils.print.error('Provider ID required');
+        console.log(`${utils.COLORS.dim}Usage: bootspring monitor add-monitoring <provider>${utils.COLORS.reset}`);
+        return;
+      }
+      addProvider(projectRoot, 'monitoring', providerId);
+      break;
+    }
+
+    case 'add-alert': {
+      const providerId = parsedArgs._[1];
+      if (!providerId) {
+        utils.print.error('Provider ID required');
+        console.log(`${utils.COLORS.dim}Usage: bootspring monitor add-alert <provider>${utils.COLORS.reset}`);
+        return;
+      }
+      addProvider(projectRoot, 'alerts', providerId);
+      break;
+    }
+
+    case 'remove-monitoring': {
+      const providerId = parsedArgs._[1];
+      if (!providerId) {
+        utils.print.error('Provider ID required');
+        return;
+      }
+      removeProvider(projectRoot, 'monitoring', providerId);
+      break;
+    }
+
+    case 'remove-alert': {
+      const providerId = parsedArgs._[1];
+      if (!providerId) {
+        utils.print.error('Provider ID required');
+        return;
+      }
+      removeProvider(projectRoot, 'alerts', providerId);
+      break;
+    }
+
+    case 'threshold': {
+      const name = parsedArgs._[1];
+      const value = parsedArgs._[2];
+      if (!name || !value) {
+        utils.print.error('Name and value required');
+        console.log(`${utils.COLORS.dim}Usage: bootspring monitor threshold <name> <value>${utils.COLORS.reset}`);
+        return;
+      }
+      setThreshold(projectRoot, name, value);
+      break;
+    }
+
+    case 'post-deploy':
+      await runPostDeploy(projectRoot, {
+        target: parsedArgs.target
+      });
+      break;
+
+    case 'help':
+    case '--help':
+    case '-h':
+      showHelp();
+      break;
+
+    default:
+      utils.print.error(`Unknown command: ${subcommand}`);
+      showHelp();
+  }
+}
+
+module.exports = {
+  run,
+  MONITORING_PROVIDERS,
+  ALERT_PROVIDERS,
+  collectMetrics,
+  runPostDeploy
+};