cerber-core 1.0.0

package/solo/scripts/cerber-dashboard.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+/**
+ * Cerber SOLO - Dashboard
+ * 
+ * Extends Cerber Core with automation for solo developers
+ * 
+ * Features:
+ * - Colored terminal output
+ * - System health summary
+ * - Quick actions menu
+ * 
+ * @author Stefan Pitek
+ * @copyright 2026 Stefan Pitek
+ * @license MIT
+ */
+
+const { execSync } = require('child_process');
+
+// Terminal colors
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m'
+};
+
+function colorize(text, color) {
+  return `${colors[color] || ''}${text}${colors.reset}`;
+}
+
+function header(text) {
+  console.log();
+  console.log(colorize('='.repeat(60), 'cyan'));
+  console.log(colorize(text, 'bright'));
+  console.log(colorize('='.repeat(60), 'cyan'));
+  console.log();
+}
+
+function section(title) {
+  console.log(colorize(`\n${title}`, 'yellow'));
+  console.log(colorize('-'.repeat(40), 'dim'));
+}
+
+function success(text) {
+  console.log(colorize(`✅ ${text}`, 'green'));
+}
+
+function warning(text) {
+  console.log(colorize(`⚠️  ${text}`, 'yellow'));
+}
+
+function error(text) {
+  console.log(colorize(`❌ ${text}`, 'red'));
+}
+
+function info(text) {
+  console.log(colorize(`ℹ️  ${text}`, 'blue'));
+}
+
+function metric(label, value, status = 'normal') {
+  const statusColor = status === 'good' ? 'green' : 
+                      status === 'warning' ? 'yellow' : 
+                      status === 'error' ? 'red' : 'white';
+  console.log(`   ${colorize(label + ':', 'dim')} ${colorize(value, statusColor)}`);
+}
+
+// Main dashboard
+header('🛡️  Cerber SOLO Dashboard');
+
+// System status
+section('📊 System Status');
+
+try {
+  const packagePath = require('path').join(process.cwd(), 'package.json');
+  const fs = require('fs');
+  
+  if (fs.existsSync(packagePath)) {
+    const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    metric('Project', pkg.name || 'unknown');
+    metric('Version', pkg.version || '0.0.0');
+    success('Package configuration found');
+  } else {
+    warning('No package.json found');
+  }
+} catch (err) {
+  error('Could not read package.json');
+}
+
+// Git status
+section('📂 Git Status');
+
+try {
+  const branch = execSync('git rev-parse --abbrev-ref HEAD', { 
+    encoding: 'utf8',
+    stdio: 'pipe'
+  }).trim();
+  
+  metric('Branch', branch);
+  
+  const status = execSync('git status --short', { encoding: 'utf8', stdio: 'pipe' }).trim();
+  
+  if (status) {
+    const lines = status.split('\n').length;
+    warning(`${lines} file(s) with changes`);
+  } else {
+    success('Working directory clean');
+  }
+  
+  // Check for unpushed commits
+  try {
+    const unpushed = execSync('git log @{u}.. --oneline 2>/dev/null || true', { 
+      encoding: 'utf8',
+      stdio: 'pipe'
+    }).trim();
+    
+    if (unpushed) {
+      const count = unpushed.split('\n').filter(l => l.trim()).length;
+      info(`${count} unpushed commit(s)`);
+    }
+  } catch (err) {
+    // No upstream
+  }
+} catch (err) {
+  info('Not a git repository');
+}
+
+// Guardian status
+section('🛡️  Guardian Status');
+
+const guardianPaths = [
+  'scripts/validate-schema.mjs',
+  'scripts/validate-schema.js',
+  '.husky/pre-commit'
+];
+
+const guardianExists = guardianPaths.some(p => {
+  const fs = require('fs');
+  const path = require('path');
+  return fs.existsSync(path.join(process.cwd(), p));
+});
+
+if (guardianExists) {
+  success('Guardian installed and active');
+} else {
+  warning('Guardian not detected');
+}
+
+// SOLO tools
+section('⚡ SOLO Tools');
+
+const tools = [
+  { name: 'Auto-repair', cmd: 'cerber:repair' },
+  { name: 'Deps health', cmd: 'cerber:deps' },
+  { name: 'Performance', cmd: 'cerber:perf' },
+  { name: 'Docs sync', cmd: 'cerber:docs' },
+  { name: 'Feature flags', cmd: 'cerber:flags' },
+  { name: 'Snapshot', cmd: 'cerber:snapshot' }
+];
+
+console.log();
+tools.forEach(tool => {
+  console.log(`   ${colorize('•', 'cyan')} ${tool.name}: ${colorize(`npm run ${tool.cmd}`, 'dim')}`);
+});
+
+// Quick actions
+section('🚀 Quick Actions');
+
+console.log();
+console.log(colorize('  1.', 'bright') + ' Run morning check:     ' + colorize('npm run cerber:morning', 'cyan'));
+console.log(colorize('  2.', 'bright') + ' Auto-fix issues:       ' + colorize('npm run cerber:repair', 'cyan'));
+console.log(colorize('  3.', 'bright') + ' Check dependencies:    ' + colorize('npm run cerber:deps', 'cyan'));
+console.log(colorize('  4.', 'bright') + ' Before pushing:        ' + colorize('npm run cerber:pre-push', 'cyan'));
+console.log(colorize('  5.', 'bright') + ' End of day snapshot:   ' + colorize('npm run cerber:snapshot', 'cyan'));
+
+// Footer
+console.log();
+console.log(colorize('='.repeat(60), 'cyan'));
+console.log(colorize('\n✨ Cerber SOLO - Built by Stefan Pitek\n', 'magenta'));
+
+process.exit(0);

package/solo/scripts/cerber-deps-health.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+
+/**
+ * Cerber SOLO - Dependency Health Checker
+ * 
+ * Extends Cerber Core with automation for solo developers
+ * 
+ * Checks:
+ * - npm audit (vulnerabilities)
+ * - Outdated packages
+ * - Deprecated packages
+ * - Unmaintained packages (no updates 2+ years)
+ * 
+ * @author Stefan Pitek
+ * @copyright 2026 Stefan Pitek
+ * @license MIT
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+console.log('🏥 Cerber SOLO - Dependency Health Check\n');
+
+let healthScore = 100;
+const issues = [];
+
+/**
+ * Check for security vulnerabilities
+ */
+function checkVulnerabilities() {
+  console.log('🔒 Checking security vulnerabilities...');
+  
+  try {
+    execSync('npm audit --json > /tmp/audit-result.json 2>/dev/null', { 
+      stdio: 'pipe',
+      encoding: 'utf8' 
+    });
+    
+    const auditData = JSON.parse(fs.readFileSync('/tmp/audit-result.json', 'utf8'));
+    
+    const critical = auditData.metadata?.vulnerabilities?.critical || 0;
+    const high = auditData.metadata?.vulnerabilities?.high || 0;
+    const moderate = auditData.metadata?.vulnerabilities?.moderate || 0;
+    const low = auditData.metadata?.vulnerabilities?.low || 0;
+    
+    if (critical > 0 || high > 0 || moderate > 0 || low > 0) {
+      console.log(`  ⚠️  Found vulnerabilities:`);
+      if (critical > 0) console.log(`     🔴 Critical: ${critical}`);
+      if (high > 0) console.log(`     🟠 High: ${high}`);
+      if (moderate > 0) console.log(`     🟡 Moderate: ${moderate}`);
+      if (low > 0) console.log(`     🟢 Low: ${low}`);
+      
+      healthScore -= (critical * 20) + (high * 10) + (moderate * 5) + (low * 2);
+      issues.push({
+        type: 'security',
+        severity: critical > 0 ? 'critical' : high > 0 ? 'high' : 'moderate',
+        message: `${critical + high + moderate + low} vulnerabilities found`,
+        action: 'Run: npm audit fix'
+      });
+    } else {
+      console.log('  ✅ No vulnerabilities found');
+    }
+  } catch (error) {
+    console.log('  ℹ️  npm audit check skipped (may not be available)');
+  }
+}
+
+/**
+ * Check for outdated packages
+ */
+function checkOutdated() {
+  console.log('\n📦 Checking outdated packages...');
+  
+  try {
+    const outdated = execSync('npm outdated --json 2>/dev/null', { 
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+    
+    if (!outdated) {
+      console.log('  ✅ All packages are up to date');
+      return;
+    }
+    
+    const packages = JSON.parse(outdated);
+    const count = Object.keys(packages).length;
+    
+    if (count > 0) {
+      console.log(`  ⚠️  ${count} outdated packages found`);
+      
+      // Show top 5 outdated packages
+      const entries = Object.entries(packages).slice(0, 5);
+      entries.forEach(([name, info]) => {
+        console.log(`     ${name}: ${info.current} → ${info.latest}`);
+      });
+      
+      if (count > 5) {
+        console.log(`     ... and ${count - 5} more`);
+      }
+      
+      healthScore -= Math.min(count * 2, 30);
+      issues.push({
+        type: 'outdated',
+        severity: 'low',
+        message: `${count} packages are outdated`,
+        action: 'Run: npm update'
+      });
+    }
+  } catch (error) {
+    // npm outdated exits with code 1 when packages are outdated
+    console.log('  ℹ️  Could not check outdated packages');
+  }
+}
+
+/**
+ * Check for deprecated packages
+ */
+function checkDeprecated() {
+  console.log('\n⚠️  Checking for deprecated packages...');
+  
+  const packagePath = path.join(process.cwd(), 'package.json');
+  
+  if (!fs.existsSync(packagePath)) {
+    console.log('  ⚠️  No package.json found');
+    return;
+  }
+  
+  try {
+    const packageData = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    const allDeps = {
+      ...packageData.dependencies || {},
+      ...packageData.devDependencies || {}
+    };
+    
+    // Known deprecated packages (example list)
+    const knownDeprecated = [
+      'request',
+      'node-uuid',
+      'babel-preset-es2015',
+      'gulp-util',
+      'coffee-script'
+    ];
+    
+    const deprecated = Object.keys(allDeps).filter(dep => 
+      knownDeprecated.some(d => dep.includes(d))
+    );
+    
+    if (deprecated.length > 0) {
+      console.log(`  ⚠️  ${deprecated.length} deprecated packages found:`);
+      deprecated.forEach(pkg => {
+        console.log(`     - ${pkg}`);
+      });
+      
+      healthScore -= deprecated.length * 10;
+      issues.push({
+        type: 'deprecated',
+        severity: 'moderate',
+        message: `${deprecated.length} deprecated packages in use`,
+        action: 'Replace with maintained alternatives'
+      });
+    } else {
+      console.log('  ✅ No known deprecated packages');
+    }
+  } catch (error) {
+    console.log(`  ❌ Error checking deprecated packages: ${error.message}`);
+  }
+}
+
+/**
+ * Check package-lock.json health
+ */
+function checkLockFile() {
+  console.log('\n🔒 Checking package-lock.json...');
+  
+  const lockPath = path.join(process.cwd(), 'package-lock.json');
+  const packagePath = path.join(process.cwd(), 'package.json');
+  
+  if (!fs.existsSync(lockPath)) {
+    console.log('  ⚠️  No package-lock.json found');
+    issues.push({
+      type: 'lock-file',
+      severity: 'moderate',
+      message: 'Missing package-lock.json',
+      action: 'Run: npm install'
+    });
+    healthScore -= 10;
+    return;
+  }
+  
+  try {
+    const lockStat = fs.statSync(lockPath);
+    const packageStat = fs.statSync(packagePath);
+    
+    if (packageStat.mtime > lockStat.mtime) {
+      console.log('  ⚠️  package.json is newer than package-lock.json');
+      issues.push({
+        type: 'lock-file',
+        severity: 'low',
+        message: 'package-lock.json may be out of sync',
+        action: 'Run: npm install'
+      });
+      healthScore -= 5;
+    } else {
+      console.log('  ✅ package-lock.json is up to date');
+    }
+  } catch (error) {
+    console.log(`  ❌ Error checking lock file: ${error.message}`);
+  }
+}
+
+// Run all checks
+checkVulnerabilities();
+checkOutdated();
+checkDeprecated();
+checkLockFile();
+
+// Generate report
+console.log('\n' + '='.repeat(60));
+console.log('\n📊 Dependency Health Report\n');
+
+healthScore = Math.max(0, healthScore);
+const grade = healthScore >= 90 ? 'A' : 
+              healthScore >= 75 ? 'B' : 
+              healthScore >= 60 ? 'C' : 
+              healthScore >= 40 ? 'D' : 'F';
+
+const gradeEmoji = grade === 'A' ? '✅' : 
+                   grade === 'B' ? '👍' : 
+                   grade === 'C' ? '⚠️' : 
+                   grade === 'D' ? '🔴' : '💀';
+
+console.log(`${gradeEmoji} Health Score: ${healthScore}/100 (Grade: ${grade})`);
+console.log(`   Issues Found: ${issues.length}`);
+
+if (issues.length > 0) {
+  console.log('\n🔧 Recommended Actions:\n');
+  issues.forEach((issue, idx) => {
+    console.log(`${idx + 1}. [${issue.severity.toUpperCase()}] ${issue.message}`);
+    console.log(`   → ${issue.action}\n`);
+  });
+}
+
+console.log('='.repeat(60));
+
+// Exit with appropriate code
+process.exit(healthScore < 60 ? 1 : 0);