devcompass 1.0.5 → 2.2.0

package/src/commands/analyze.js

@@ -7,19 +7,37 @@ const fs = require('fs');
 const { findUnusedDeps } = require('../analyzers/unused-deps');
 const { findOutdatedDeps } = require('../analyzers/outdated');
 const { calculateScore } = require('../analyzers/scoring');
+const { checkEcosystemAlerts } = require('../alerts');
+const { 
+  formatAlerts, 
+  getSeverityDisplay, 
+  calculateAlertPenalty 
+} = require('../alerts/formatter');
 const { 
   log, 
   logSection, 
   logDivider,
   getScoreColor 
 } = require('../utils/logger');
+const { loadConfig, filterAlerts } = require('../config/loader');
+const { getCached, setCache } = require('../cache/manager');
+const { formatAsJson } = require('../utils/json-formatter');
+const { handleCiMode } = require('../utils/ci-handler');
 const packageJson = require('../../package.json');
 
 async function analyze(options) {
   const projectPath = options.path || process.cwd();
   
-  console.log('\n');
-  log(chalk.cyan.bold(`🔍 DevCompass v${packageJson.version}`) + ' - Analyzing your project...\n');
+  // Load config
+  const config = loadConfig(projectPath);
+  
+  // Handle output modes
+  const outputMode = options.json ? 'json' : (options.ci ? 'ci' : (options.silent ? 'silent' : 'normal'));
+  
+  if (outputMode !== 'silent') {
+    console.log('\n');
+    log(chalk.cyan.bold(`🔍 DevCompass v${packageJson.version}`) + ' - Analyzing your project...\n');
+  }
   
   const spinner = ora({
     text: 'Loading project...',
@@ -58,35 +76,101 @@ async function analyze(options) {
       process.exit(0);
     }
     
-    spinner.text = 'Detecting unused dependencies...';
+    // Check for ecosystem alerts (with cache)
+    spinner.text = 'Checking ecosystem alerts...';
+    let alerts = [];
+    
+    if (config.cache) {
+      alerts = getCached(projectPath, 'alerts');
+    }
     
+    if (!alerts) {
+      try {
+        alerts = await checkEcosystemAlerts(projectPath, dependencies);
+        if (config.cache) {
+          setCache(projectPath, 'alerts', alerts);
+        }
+      } catch (error) {
+        if (outputMode !== 'silent') {
+          console.log(chalk.yellow('\n⚠️  Could not check ecosystem alerts'));
+          console.log(chalk.gray(`   Error: ${error.message}\n`));
+        }
+        alerts = [];
+      }
+    }
+    
+    // Filter alerts based on config
+    alerts = filterAlerts(alerts, config);
+    
+    // Unused dependencies
+    spinner.text = 'Detecting unused dependencies...';
     let unusedDeps = [];
-    try {
-      unusedDeps = await findUnusedDeps(projectPath, dependencies);
-    } catch (error) {
-      console.log(chalk.yellow('\n⚠️  Could not detect unused dependencies'));
-      console.log(chalk.gray(`   Error: ${error.message}\n`));
+    
+    if (config.cache) {
+      unusedDeps = getCached(projectPath, 'unused');
     }
     
-    spinner.text = 'Checking for outdated packages...';
+    if (!unusedDeps) {
+      try {
+        unusedDeps = await findUnusedDeps(projectPath, dependencies);
+        if (config.cache) {
+          setCache(projectPath, 'unused', unusedDeps);
+        }
+      } catch (error) {
+        if (outputMode !== 'silent') {
+          console.log(chalk.yellow('\n⚠️  Could not detect unused dependencies'));
+          console.log(chalk.gray(`   Error: ${error.message}\n`));
+        }
+        unusedDeps = [];
+      }
+    }
     
+    // Outdated packages
+    spinner.text = 'Checking for outdated packages...';
     let outdatedDeps = [];
-    try {
-      outdatedDeps = await findOutdatedDeps(projectPath, dependencies);
-    } catch (error) {
-      console.log(chalk.yellow('\n⚠️  Could not check for outdated packages'));
-      console.log(chalk.gray(`   Error: ${error.message}\n`));
+    
+    if (config.cache) {
+      outdatedDeps = getCached(projectPath, 'outdated');
+    }
+    
+    if (!outdatedDeps) {
+      try {
+        outdatedDeps = await findOutdatedDeps(projectPath, dependencies);
+        if (config.cache) {
+          setCache(projectPath, 'outdated', outdatedDeps);
+        }
+      } catch (error) {
+        if (outputMode !== 'silent') {
+          console.log(chalk.yellow('\n⚠️  Could not check for outdated packages'));
+          console.log(chalk.gray(`   Error: ${error.message}\n`));
+        }
+        outdatedDeps = [];
+      }
     }
     
+    const alertPenalty = calculateAlertPenalty(alerts);
     const score = calculateScore(
       totalDeps,
       unusedDeps.length,
-      outdatedDeps.length
+      outdatedDeps.length,
+      alerts.length,
+      alertPenalty
     );
     
     spinner.succeed(chalk.green(`Scanned ${totalDeps} dependencies in project`));
     
-    displayResults(unusedDeps, outdatedDeps, score, totalDeps);
+    // Handle different output modes
+    if (outputMode === 'json') {
+      const jsonOutput = formatAsJson(alerts, unusedDeps, outdatedDeps, score, totalDeps);
+      console.log(jsonOutput);
+    } else if (outputMode === 'ci') {
+      displayResults(alerts, unusedDeps, outdatedDeps, score, totalDeps);
+      handleCiMode(score, config, alerts, unusedDeps);
+    } else if (outputMode === 'silent') {
+      // Silent mode - no output
+    } else {
+      displayResults(alerts, unusedDeps, outdatedDeps, score, totalDeps);
+    }
     
   } catch (error) {
     spinner.fail(chalk.red('Analysis failed'));
@@ -98,13 +182,53 @@ async function analyze(options) {
   }
 }
 
-function displayResults(unusedDeps, outdatedDeps, score, totalDeps) {
+function displayResults(alerts, unusedDeps, outdatedDeps, score, totalDeps) {
   logDivider();
   
+  // ECOSYSTEM ALERTS (NEW SECTION)
+  if (alerts.length > 0) {
+    logSection('🚨 ECOSYSTEM ALERTS', alerts.length);
+    
+    const grouped = formatAlerts(alerts);
+    
+    Object.entries(grouped).forEach(([packageName, packageAlerts]) => {
+      const firstAlert = packageAlerts[0];
+      const display = getSeverityDisplay(firstAlert.severity);
+      
+      log(`\n${display.emoji} ${display.color(display.label)}`);
+      log(`  ${chalk.bold(packageName)}${chalk.gray('@' + firstAlert.version)}`);
+      
+      packageAlerts.forEach((alert, index) => {
+        if (index > 0) {
+          const alertDisplay = getSeverityDisplay(alert.severity);
+          log(`\n  ${alertDisplay.emoji} ${alertDisplay.color(alertDisplay.label)}`);
+        }
+        
+        log(`    ${chalk.yellow('Issue:')} ${alert.title}`);
+        log(`    ${chalk.gray('Affected:')} ${alert.affected}`);
+        
+        if (alert.fix) {
+          log(`    ${chalk.green('Fix:')} ${alert.fix}`);
+        }
+        
+        if (alert.source) {
+          log(`    ${chalk.gray('Source:')} ${alert.source}`);
+        }
+      });
+    });
+    
+    log('');
+  } else {
+    logSection('✅ ECOSYSTEM ALERTS');
+    log(chalk.green('  No known issues detected!\n'));
+  }
+  
+  logDivider();
+  
+  // UNUSED DEPENDENCIES
   if (unusedDeps.length > 0) {
     logSection('🔴 UNUSED DEPENDENCIES', unusedDeps.length);
     
-    // Show ALL unused deps
     unusedDeps.forEach(dep => {
       log(`  ${chalk.red('●')} ${dep.name}`);
     });
@@ -120,10 +244,10 @@ function displayResults(unusedDeps, outdatedDeps, score, totalDeps) {
   
   logDivider();
   
+  // OUTDATED PACKAGES
   if (outdatedDeps.length > 0) {
     logSection('🟡 OUTDATED PACKAGES', outdatedDeps.length);
     
-    // Show ALL outdated packages
     outdatedDeps.forEach(dep => {
       const nameCol = dep.name.padEnd(20);
       const currentVer = chalk.yellow(dep.current);
@@ -142,39 +266,84 @@ function displayResults(unusedDeps, outdatedDeps, score, totalDeps) {
   
   logDivider();
   
+  // PROJECT HEALTH
   logSection('📊 PROJECT HEALTH');
   
   const scoreColor = getScoreColor(score.total);
   log(`  Overall Score:              ${scoreColor(score.total + '/10')}`);
   log(`  Total Dependencies:         ${chalk.cyan(totalDeps)}`);
+  
+  if (alerts.length > 0) {
+    log(`  Ecosystem Alerts:           ${chalk.red(alerts.length)}`);
+  }
+  
   log(`  Unused:                     ${chalk.red(unusedDeps.length)}`);
   log(`  Outdated:                   ${chalk.yellow(outdatedDeps.length)}\n`);
   
   logDivider();
   
-  if (unusedDeps.length > 0) {
-    logSection('💡 QUICK WIN');
-    log('  Clean up unused dependencies:\n');
-    
-    const packagesToRemove = unusedDeps
-      .map(d => d.name)
-      .join(' ');
+  // QUICK WINS
+  displayQuickWins(alerts, unusedDeps, outdatedDeps, score, totalDeps);
+}
+
+function displayQuickWins(alerts, unusedDeps, outdatedDeps, score, totalDeps) {
+  const hasCriticalAlerts = alerts.some(a => a.severity === 'critical' || a.severity === 'high');
+  
+  if (hasCriticalAlerts || unusedDeps.length > 0) {
+    logSection('💡 QUICK WINS');
     
-    log(chalk.cyan(`  npm uninstall ${packagesToRemove}\n`));
+    // Fix critical alerts first
+    if (hasCriticalAlerts) {
+      const criticalAlerts = alerts.filter(a => a.severity === 'critical' || a.severity === 'high');
+      
+      log('  🔴 Fix critical issues:\n');
+      
+      criticalAlerts.forEach(alert => {
+        if (alert.fix && alert.fix.includes('.')) {
+          // It's a version number
+          log(chalk.cyan(`  npm install ${alert.package}@${alert.fix}`));
+        } else {
+          log(chalk.gray(`  ${alert.package}: ${alert.fix}`));
+        }
+      });
+      
+      log('');
+    }
     
-    log('  Expected impact:');
-    log(`  ${chalk.green('✓')} Remove ${unusedDeps.length} unused package${unusedDeps.length > 1 ? 's' : ''}`);
-    log(`  ${chalk.green('✓')} Reduce node_modules size`);
+    // Remove unused deps
+    if (unusedDeps.length > 0) {
+      log('  🧹 Clean up unused dependencies:\n');
+      
+      const packagesToRemove = unusedDeps.map(d => d.name).join(' ');
+      log(chalk.cyan(`  npm uninstall ${packagesToRemove}\n`));
+    }
     
+    // Show expected impact
+    const alertPenalty = calculateAlertPenalty(alerts.filter(a => a.severity !== 'critical' && a.severity !== 'high'));
     const improvedScore = calculateScore(
       totalDeps - unusedDeps.length,
       0,
-      outdatedDeps.length
+      outdatedDeps.length,
+      alerts.length - alerts.filter(a => a.severity === 'critical' || a.severity === 'high').length,
+      alertPenalty
     );
     
+    log('  Expected impact:');
+    
+    if (hasCriticalAlerts) {
+      log(`  ${chalk.green('✓')} Resolve critical security/stability issues`);
+    }
+    
+    if (unusedDeps.length > 0) {
+      log(`  ${chalk.green('✓')} Remove ${unusedDeps.length} unused package${unusedDeps.length > 1 ? 's' : ''}`);
+      log(`  ${chalk.green('✓')} Reduce node_modules size`);
+    }
+    
     const improvedScoreColor = getScoreColor(improvedScore.total);
     log(`  ${chalk.green('✓')} Improve health score → ${improvedScoreColor(improvedScore.total + '/10')}\n`);
     
+    log(chalk.cyan('💡 TIP: Run') + chalk.bold(' devcompass fix ') + chalk.cyan('to apply these fixes automatically!\n'));
+    
     logDivider();
   }
 }

package/src/commands/fix.js

@@ -0,0 +1,247 @@
+// src/commands/fix.js
+const chalk = require('chalk');
+const ora = require('ora');
+const { execSync } = require('child_process');
+const readline = require('readline');
+
+const { findUnusedDeps } = require('../analyzers/unused-deps');
+const { findOutdatedDeps } = require('../analyzers/outdated');
+const { checkEcosystemAlerts } = require('../alerts');
+const { getSeverityDisplay } = require('../alerts/formatter');
+
+async function fix(options) {
+  const projectPath = options.path || process.cwd();
+  
+  console.log('\n');
+  console.log(chalk.cyan.bold('🔧 DevCompass Fix') + ' - Analyzing and fixing your project...\n');
+  
+  const spinner = ora({
+    text: 'Analyzing project...',
+    color: 'cyan'
+  }).start();
+  
+  try {
+    const fs = require('fs');
+    const path = require('path');
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    
+    if (!fs.existsSync(packageJsonPath)) {
+      spinner.fail(chalk.red('No package.json found'));
+      process.exit(1);
+    }
+    
+    const projectPackageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const dependencies = {
+      ...(projectPackageJson.dependencies || {}),
+      ...(projectPackageJson.devDependencies || {})
+    };
+    
+    // Check for critical alerts first
+    spinner.text = 'Checking for critical issues...';
+    const alerts = await checkEcosystemAlerts(projectPath, dependencies);
+    const criticalAlerts = alerts.filter(a => a.severity === 'critical' || a.severity === 'high');
+    
+    // Find unused dependencies
+    spinner.text = 'Finding unused dependencies...';
+    const unusedDeps = await findUnusedDeps(projectPath, dependencies);
+    
+    // Find outdated packages
+    spinner.text = 'Checking for updates...';
+    const outdatedDeps = await findOutdatedDeps(projectPath, dependencies);
+    
+    spinner.succeed(chalk.green('Analysis complete!\n'));
+    
+    // Show what will be fixed
+    await showFixPlan(criticalAlerts, unusedDeps, outdatedDeps, options);
+    
+  } catch (error) {
+    spinner.fail(chalk.red('Analysis failed'));
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+async function showFixPlan(criticalAlerts, unusedDeps, outdatedDeps, options) {
+  const actions = [];
+  
+  // Critical alerts
+  if (criticalAlerts.length > 0) {
+    console.log(chalk.red.bold('🔴 CRITICAL ISSUES TO FIX:\n'));
+    
+    criticalAlerts.forEach(alert => {
+      const display = getSeverityDisplay(alert.severity);
+      console.log(`${display.emoji} ${chalk.bold(alert.package)}@${alert.version}`);
+      console.log(`   ${chalk.gray('Issue:')} ${alert.title}`);
+      
+      if (alert.fix && /^\d+\.\d+/.test(alert.fix)) {
+        console.log(`   ${chalk.green('Fix:')} Upgrade to ${alert.fix}\n`);
+        actions.push({
+          type: 'upgrade',
+          package: alert.package,
+          version: alert.fix,
+          reason: 'Critical security/stability issue'
+        });
+      } else {
+        console.log(`   ${chalk.yellow('Fix:')} ${alert.fix}\n`);
+      }
+    });
+    
+    console.log('━'.repeat(70) + '\n');
+  }
+  
+  // Unused dependencies
+  if (unusedDeps.length > 0) {
+    console.log(chalk.yellow.bold('🧹 UNUSED DEPENDENCIES TO REMOVE:\n'));
+    
+    unusedDeps.forEach(dep => {
+      console.log(`  ${chalk.red('●')} ${dep.name}`);
+      actions.push({
+        type: 'uninstall',
+        package: dep.name,
+        reason: 'Not used in project'
+      });
+    });
+    
+    console.log('\n' + '━'.repeat(70) + '\n');
+  }
+  
+  // Safe updates (patch/minor only)
+  const safeUpdates = outdatedDeps.filter(dep => 
+    dep.versionsBehind === 'patch update' || dep.versionsBehind === 'minor update'
+  );
+  
+  if (safeUpdates.length > 0) {
+    console.log(chalk.cyan.bold('⬆️  SAFE UPDATES (patch/minor):\n'));
+    
+    safeUpdates.forEach(dep => {
+      console.log(`  ${dep.name}: ${chalk.yellow(dep.current)} → ${chalk.green(dep.latest)} ${chalk.gray(`(${dep.versionsBehind})`)}`);
+      actions.push({
+        type: 'update',
+        package: dep.name,
+        version: dep.latest,
+        reason: dep.versionsBehind
+      });
+    });
+    
+    console.log('\n' + '━'.repeat(70) + '\n');
+  }
+  
+  // Major updates (show but don't auto-apply)
+  const majorUpdates = outdatedDeps.filter(dep => dep.versionsBehind === 'major update');
+  
+  if (majorUpdates.length > 0) {
+    console.log(chalk.gray.bold('⚠️  MAJOR UPDATES (skipped - may have breaking changes):\n'));
+    
+    majorUpdates.forEach(dep => {
+      console.log(`  ${chalk.gray(dep.name)}: ${dep.current} → ${dep.latest}`);
+    });
+    
+    console.log(chalk.gray('\n  Run these manually after reviewing changelog:\n'));
+    majorUpdates.forEach(dep => {
+      console.log(chalk.gray(`  npm install ${dep.name}@${dep.latest}`));
+    });
+    
+    console.log('\n' + '━'.repeat(70) + '\n');
+  }
+  
+  if (actions.length === 0) {
+    console.log(chalk.green('✨ Everything looks good! No fixes needed.\n'));
+    return;
+  }
+  
+  // Summary
+  console.log(chalk.bold('📊 FIX SUMMARY:\n'));
+  console.log(`  Critical fixes:  ${criticalAlerts.length}`);
+  console.log(`  Remove unused:   ${unusedDeps.length}`);
+  console.log(`  Safe updates:    ${safeUpdates.length}`);
+  console.log(`  Skipped major:   ${majorUpdates.length}\n`);
+  
+  console.log('━'.repeat(70) + '\n');
+  
+  // Confirm
+  if (options.yes) {
+    await applyFixes(actions);
+  } else {
+    const confirmed = await askConfirmation('\n❓ Apply these fixes?');
+    
+    if (confirmed) {
+      await applyFixes(actions);
+    } else {
+      console.log(chalk.yellow('\n⚠️  Fix cancelled. No changes made.\n'));
+    }
+  }
+}
+
+async function applyFixes(actions) {
+  console.log(chalk.cyan.bold('\n🔧 Applying fixes...\n'));
+  
+  const spinner = ora('Processing...').start();
+  
+  try {
+    // Group by type
+    const toUninstall = actions.filter(a => a.type === 'uninstall').map(a => a.package);
+    const toUpgrade = actions.filter(a => a.type === 'upgrade');
+    const toUpdate = actions.filter(a => a.type === 'update');
+    
+    // Uninstall unused
+    if (toUninstall.length > 0) {
+      spinner.text = `Removing ${toUninstall.length} unused packages...`;
+      
+      const cmd = `npm uninstall ${toUninstall.join(' ')}`;
+      execSync(cmd, { stdio: 'pipe' });
+      
+      spinner.succeed(chalk.green(`✅ Removed ${toUninstall.length} unused packages`));
+      spinner.start();
+    }
+    
+    // Upgrade critical packages
+    for (const action of toUpgrade) {
+      spinner.text = `Fixing ${action.package}@${action.version}...`;
+      
+      const cmd = `npm install ${action.package}@${action.version}`;
+      execSync(cmd, { stdio: 'pipe' });
+      
+      spinner.succeed(chalk.green(`✅ Fixed ${action.package}@${action.version}`));
+      spinner.start();
+    }
+    
+    // Update safe packages
+    if (toUpdate.length > 0) {
+      spinner.text = `Updating ${toUpdate.length} packages...`;
+      
+      for (const action of toUpdate) {
+        const cmd = `npm install ${action.package}@${action.version}`;
+        execSync(cmd, { stdio: 'pipe' });
+      }
+      
+      spinner.succeed(chalk.green(`✅ Updated ${toUpdate.length} packages`));
+    } else {
+      spinner.stop();
+    }
+    
+    console.log(chalk.green.bold('\n✨ All fixes applied successfully!\n'));
+    console.log(chalk.cyan('💡 Run') + chalk.bold(' devcompass analyze ') + chalk.cyan('to see the new health score.\n'));
+    
+  } catch (error) {
+    spinner.fail(chalk.red('Fix failed'));
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    console.log(chalk.yellow('💡 You may need to fix this manually.\n'));
+    process.exit(1);
+  }
+}
+
+function askConfirmation(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  return new Promise(resolve => {
+    rl.question(chalk.cyan(question) + chalk.gray(' (y/N): '), answer => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+module.exports = { fix };

package/src/config/loader.js

@@ -0,0 +1,72 @@
+// src/config/loader.js
+const fs = require('fs');
+const path = require('path');
+
+function loadConfig(projectPath) {
+  const configPath = path.join(projectPath, 'devcompass.config.json');
+  
+  if (!fs.existsSync(configPath)) {
+    return getDefaultConfig();
+  }
+  
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    return { ...getDefaultConfig(), ...config };
+  } catch (error) {
+    console.warn('Warning: Could not parse devcompass.config.json, using defaults');
+    return getDefaultConfig();
+  }
+}
+
+function getDefaultConfig() {
+  return {
+    ignore: [],
+    ignoreSeverity: [], // e.g., ["low", "medium"]
+    minSeverity: null,  // e.g., "medium" - only show medium+ alerts
+    minScore: 0,
+    cache: true,
+    outputMode: 'normal' // normal, json, silent, ci
+  };
+}
+
+/**
+ * Check if alert should be ignored based on config
+ */
+function shouldIgnoreAlert(alert, config) {
+  // Check if package is in ignore list
+  if (config.ignore.includes(alert.package)) {
+    return true;
+  }
+  
+  // Check if severity is ignored
+  if (config.ignoreSeverity.includes(alert.severity)) {
+    return true;
+  }
+  
+  // Check minimum severity level
+  if (config.minSeverity) {
+    const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    const minLevel = severityOrder[config.minSeverity];
+    const alertLevel = severityOrder[alert.severity];
+    
+    if (alertLevel > minLevel) {
+      return true; // Alert is below minimum severity
+    }
+  }
+  
+  return false;
+}
+
+/**
+ * Filter alerts based on config
+ */
+function filterAlerts(alerts, config) {
+  return alerts.filter(alert => !shouldIgnoreAlert(alert, config));
+}
+
+module.exports = { 
+  loadConfig,
+  getDefaultConfig,
+  shouldIgnoreAlert,
+  filterAlerts
+};

package/src/utils/ci-handler.js

@@ -0,0 +1,33 @@
+// src/utils/ci-handler.js
+const chalk = require('chalk');
+
+/**
+ * Handle CI mode - exit with error code if score below threshold
+ */
+function handleCiMode(score, config, alerts, unusedDeps) {
+  const minScore = config.minScore || 7;
+  
+  if (score.total < minScore) {
+    console.log(chalk.red(`\n❌ CI CHECK FAILED`));
+    console.log(chalk.red(`Health score ${score.total}/10 is below minimum ${minScore}/10\n`));
+    
+    // Show critical issues
+    const criticalAlerts = alerts.filter(a => a.severity === 'critical' || a.severity === 'high');
+    
+    if (criticalAlerts.length > 0) {
+      console.log(chalk.red(`Critical issues: ${criticalAlerts.length}`));
+    }
+    
+    if (unusedDeps.length > 0) {
+      console.log(chalk.yellow(`Unused dependencies: ${unusedDeps.length}`));
+    }
+    
+    process.exit(1); // Fail CI
+  } else {
+    console.log(chalk.green(`\n✅ CI CHECK PASSED`));
+    console.log(chalk.green(`Health score ${score.total}/10 meets minimum ${minScore}/10\n`));
+    process.exit(0);
+  }
+}
+
+module.exports = { handleCiMode };