cerber-core 1.0.0

package/solo/scripts/cerber-performance-budget.js

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+
+/**
+ * Cerber SOLO - Performance Budget Enforcer
+ * 
+ * Extends Cerber Core with automation for solo developers
+ * 
+ * Enforces:
+ * - Total bundle size limit
+ * - Largest chunk limit
+ * - Image size constraints
+ * - Blocks build if exceeded
+ * 
+ * @author Stefan Pitek
+ * @copyright 2026 Stefan Pitek
+ * @license MIT
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+console.log('📊 Cerber SOLO - Performance Budget Enforcer\n');
+
+// Load configuration
+function loadConfig() {
+  const configPath = path.join(__dirname, '../config/performance-budget.json');
+  
+  if (!fs.existsSync(configPath)) {
+    console.log('⚠️  No performance-budget.json found, using defaults');
+    return {
+      bundleSize: { max: 500, warning: 400, unit: 'KB' },
+      largestChunk: { max: 250, warning: 200, unit: 'KB' },
+      images: { max: 200, unit: 'KB' }
+    };
+  }
+  
+  try {
+    return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch (error) {
+    console.log(`❌ Error loading config: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+const config = loadConfig();
+const violations = [];
+const warnings = [];
+
+/**
+ * Get file size in KB
+ */
+function getFileSizeKB(filePath) {
+  const stats = fs.statSync(filePath);
+  return stats.size / 1024;
+}
+
+/**
+ * Find all JS bundle files
+ */
+function findBundleFiles() {
+  const distDirs = ['dist', 'build', 'out', '.next'];
+  
+  for (const dir of distDirs) {
+    const distPath = path.join(process.cwd(), dir);
+    if (fs.existsSync(distPath)) {
+      console.log(`📁 Found build directory: ${dir}`);
+      return { dir, path: distPath };
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Recursively find all files matching pattern
+ */
+function findFiles(dir, pattern, results = []) {
+  if (!fs.existsSync(dir)) return results;
+  
+  const files = fs.readdirSync(dir);
+  
+  files.forEach(file => {
+    const filePath = path.join(dir, file);
+    const stat = fs.statSync(filePath);
+    
+    if (stat.isDirectory()) {
+      findFiles(filePath, pattern, results);
+    } else if (pattern.test(file)) {
+      results.push(filePath);
+    }
+  });
+  
+  return results;
+}
+
+/**
+ * Check bundle sizes
+ */
+function checkBundleSizes() {
+  console.log('\n📦 Checking bundle sizes...\n');
+  
+  const buildInfo = findBundleFiles();
+  
+  if (!buildInfo) {
+    console.log('⚠️  No build directory found (dist/build/out/.next)');
+    console.log('   Run your build command first (npm run build)');
+    return;
+  }
+  
+  // Find all JS files
+  const jsFiles = findFiles(buildInfo.path, /\.js$/);
+  
+  if (jsFiles.length === 0) {
+    console.log('ℹ️  No JavaScript bundles found');
+    return;
+  }
+  
+  let totalSize = 0;
+  let largestFile = null;
+  let largestSize = 0;
+  
+  jsFiles.forEach(file => {
+    const sizeKB = getFileSizeKB(file);
+    totalSize += sizeKB;
+    
+    if (sizeKB > largestSize) {
+      largestSize = sizeKB;
+      largestFile = file;
+    }
+    
+    const relativePath = path.relative(process.cwd(), file);
+    
+    // Check individual chunk size
+    if (config.largestChunk && sizeKB > config.largestChunk.max) {
+      console.log(`  🔴 ${relativePath}: ${sizeKB.toFixed(1)} KB (EXCEEDS ${config.largestChunk.max} KB)`);
+      violations.push({
+        type: 'chunk-size',
+        file: relativePath,
+        size: sizeKB,
+        limit: config.largestChunk.max
+      });
+    } else if (config.largestChunk && sizeKB > config.largestChunk.warning) {
+      console.log(`  🟡 ${relativePath}: ${sizeKB.toFixed(1)} KB (warning: ${config.largestChunk.warning} KB)`);
+      warnings.push({
+        type: 'chunk-size',
+        file: relativePath,
+        size: sizeKB,
+        limit: config.largestChunk.warning
+      });
+    } else {
+      console.log(`  ✅ ${relativePath}: ${sizeKB.toFixed(1)} KB`);
+    }
+  });
+  
+  console.log(`\n📊 Total bundle size: ${totalSize.toFixed(1)} KB`);
+  
+  if (config.bundleSize) {
+    if (totalSize > config.bundleSize.max) {
+      console.log(`  🔴 EXCEEDS limit of ${config.bundleSize.max} KB`);
+      violations.push({
+        type: 'total-size',
+        size: totalSize,
+        limit: config.bundleSize.max
+      });
+    } else if (totalSize > config.bundleSize.warning) {
+      console.log(`  🟡 Warning: Approaching limit (${config.bundleSize.warning} KB)`);
+      warnings.push({
+        type: 'total-size',
+        size: totalSize,
+        limit: config.bundleSize.warning
+      });
+    } else {
+      console.log(`  ✅ Within budget (${config.bundleSize.max} KB)`);
+    }
+  }
+  
+  if (largestFile) {
+    console.log(`\n📦 Largest chunk: ${path.relative(process.cwd(), largestFile)} (${largestSize.toFixed(1)} KB)`);
+  }
+}
+
+/**
+ * Check image sizes
+ */
+function checkImageSizes() {
+  console.log('\n🖼️  Checking image sizes...\n');
+  
+  const imageDirs = ['public', 'static', 'assets', 'src/assets'];
+  let imagesFound = false;
+  
+  imageDirs.forEach(dir => {
+    const dirPath = path.join(process.cwd(), dir);
+    if (!fs.existsSync(dirPath)) return;
+    
+    const images = findFiles(dirPath, /\.(jpg|jpeg|png|gif|webp|svg)$/i);
+    
+    if (images.length === 0) return;
+    
+    imagesFound = true;
+    
+    images.forEach(file => {
+      const sizeKB = getFileSizeKB(file);
+      const relativePath = path.relative(process.cwd(), file);
+      
+      if (config.images && sizeKB > config.images.max) {
+        console.log(`  🔴 ${relativePath}: ${sizeKB.toFixed(1)} KB (EXCEEDS ${config.images.max} KB)`);
+        violations.push({
+          type: 'image-size',
+          file: relativePath,
+          size: sizeKB,
+          limit: config.images.max
+        });
+      } else if (sizeKB > 100) {
+        console.log(`  🟡 ${relativePath}: ${sizeKB.toFixed(1)} KB`);
+      } else {
+        console.log(`  ✅ ${relativePath}: ${sizeKB.toFixed(1)} KB`);
+      }
+    });
+  });
+  
+  if (!imagesFound) {
+    console.log('ℹ️  No images found in common directories');
+  }
+}
+
+// Run checks
+checkBundleSizes();
+checkImageSizes();
+
+// Summary
+console.log('\n' + '='.repeat(60));
+
+if (violations.length > 0) {
+  console.log('\n❌ PERFORMANCE BUDGET VIOLATED\n');
+  violations.forEach(v => {
+    if (v.type === 'total-size') {
+      console.log(`  🔴 Total bundle size: ${v.size.toFixed(1)} KB (limit: ${v.limit} KB)`);
+    } else if (v.type === 'chunk-size') {
+      console.log(`  🔴 ${v.file}: ${v.size.toFixed(1)} KB (limit: ${v.limit} KB)`);
+    } else if (v.type === 'image-size') {
+      console.log(`  🔴 ${v.file}: ${v.size.toFixed(1)} KB (limit: ${v.limit} KB)`);
+    }
+  });
+  
+  console.log('\n💡 Recommendations:');
+  console.log('   - Enable code splitting');
+  console.log('   - Use dynamic imports');
+  console.log('   - Compress images');
+  console.log('   - Remove unused dependencies');
+  console.log('   - Analyze bundle with webpack-bundle-analyzer');
+  
+  console.log('\n='.repeat(60));
+  process.exit(1);
+} else if (warnings.length > 0) {
+  console.log('\n⚠️  Performance warnings detected\n');
+  warnings.forEach(w => {
+    if (w.type === 'total-size') {
+      console.log(`  🟡 Total bundle size: ${w.size.toFixed(1)} KB (warning: ${w.limit} KB)`);
+    } else if (w.type === 'chunk-size') {
+      console.log(`  🟡 ${w.file}: ${w.size.toFixed(1)} KB (warning: ${w.limit} KB)`);
+    }
+  });
+  
+  console.log('\n='.repeat(60));
+  process.exit(0);
+} else {
+  console.log('\n✅ All performance budgets met!\n');
+  console.log('='.repeat(60));
+  process.exit(0);
+}

package/solo/scripts/cerber-rollback.js

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+
+/**
+ * Cerber SOLO - Smart Rollback
+ * 
+ * Extends Cerber Core with automation for solo developers
+ * 
+ * Features:
+ * - Rollback specific file from commit
+ * - Conflict detection
+ * - Safety checks
+ * - Dry-run mode
+ * 
+ * Usage: node cerber-rollback.js <commit-hash> --file=path/to/file.ts [--dry-run]
+ * 
+ * @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 - Smart Rollback\n');
+
+// Parse arguments
+const args = process.argv.slice(2);
+
+if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+  console.log('Usage: node cerber-rollback.js <commit-hash> --file=path/to/file.ts [--dry-run]\n');
+  console.log('Options:');
+  console.log('  <commit-hash>    Git commit hash to rollback from');
+  console.log('  --file=<path>    File path to rollback');
+  console.log('  --dry-run        Show what would be done without making changes');
+  console.log('  --help, -h       Show this help message\n');
+  console.log('Examples:');
+  console.log('  node cerber-rollback.js abc123 --file=src/api/users.ts');
+  console.log('  node cerber-rollback.js abc123 --file=src/api/users.ts --dry-run');
+  process.exit(0);
+}
+
+let commitHash = null;
+let filePath = null;
+let isDryRun = false;
+
+args.forEach(arg => {
+  if (arg === '--dry-run') {
+    isDryRun = true;
+  } else if (arg.startsWith('--file=')) {
+    filePath = arg.split('=')[1];
+  } else if (!arg.startsWith('--')) {
+    commitHash = arg;
+  }
+});
+
+if (!commitHash) {
+  console.error('❌ Error: Commit hash is required\n');
+  console.log('Usage: node cerber-rollback.js <commit-hash> --file=path/to/file.ts\n');
+  process.exit(1);
+}
+
+if (!filePath) {
+  console.error('❌ Error: File path is required\n');
+  console.log('Usage: node cerber-rollback.js <commit-hash> --file=path/to/file.ts\n');
+  process.exit(1);
+}
+
+console.log(`Commit: ${commitHash}`);
+console.log(`File: ${filePath}`);
+console.log(`Mode: ${isDryRun ? 'DRY RUN' : 'LIVE'}\n`);
+
+/**
+ * Check if we're in a git repository
+ */
+function checkGitRepo() {
+  try {
+    execSync('git rev-parse --git-dir', { stdio: 'pipe' });
+    console.log('✅ Git repository detected\n');
+    return true;
+  } catch (error) {
+    console.error('❌ Error: Not a git repository\n');
+    return false;
+  }
+}
+
+/**
+ * Verify commit exists
+ */
+function verifyCommit(hash) {
+  try {
+    execSync(`git cat-file -t ${hash}`, { stdio: 'pipe' });
+    const commitMsg = execSync(`git log -1 --pretty=format:"%s" ${hash}`, { 
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+    console.log(`✅ Commit found: "${commitMsg}"\n`);
+    return true;
+  } catch (error) {
+    console.error(`❌ Error: Commit ${hash} not found\n`);
+    return false;
+  }
+}
+
+/**
+ * Check if file exists in commit
+ */
+function checkFileInCommit(hash, file) {
+  try {
+    execSync(`git cat-file -e ${hash}:${file}`, { stdio: 'pipe' });
+    console.log(`✅ File exists in commit ${hash}\n`);
+    return true;
+  } catch (error) {
+    console.error(`❌ Error: File ${file} does not exist in commit ${hash}\n`);
+    return false;
+  }
+}
+
+/**
+ * Check for uncommitted changes
+ */
+function checkUncommittedChanges(file) {
+  try {
+    const status = execSync(`git status --porcelain ${file}`, { 
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+    
+    if (status.trim()) {
+      console.log(`⚠️  Warning: File ${file} has uncommitted changes\n`);
+      console.log('   Current changes will be lost if you proceed!\n');
+      return true;
+    }
+    
+    console.log(`✅ No uncommitted changes for ${file}\n`);
+    return false;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Show file diff
+ */
+function showDiff(hash, file) {
+  try {
+    console.log('📊 Changes that will be rolled back:\n');
+    console.log('─'.repeat(60));
+    
+    const diff = execSync(`git diff HEAD ${hash} -- ${file}`, { 
+      encoding: 'utf8',
+      maxBuffer: 10 * 1024 * 1024
+    });
+    
+    if (diff) {
+      // Show first 30 lines
+      const lines = diff.split('\n').slice(0, 30);
+      console.log(lines.join('\n'));
+      
+      if (diff.split('\n').length > 30) {
+        console.log('\n... (diff truncated, showing first 30 lines) ...');
+      }
+    } else {
+      console.log('(no changes - file is identical)');
+    }
+    
+    console.log('─'.repeat(60));
+    console.log();
+  } catch (error) {
+    console.log('⚠️  Could not generate diff\n');
+  }
+}
+
+/**
+ * Perform rollback
+ */
+function rollbackFile(hash, file) {
+  try {
+    console.log(`🔄 Rolling back ${file} to ${hash}...\n`);
+    
+    if (!isDryRun) {
+      execSync(`git checkout ${hash} -- ${file}`, { stdio: 'inherit' });
+      console.log('✅ Rollback successful!\n');
+      console.log('💡 Changes are staged. Run `git status` to review.\n');
+      console.log('   To commit: git commit -m "rollback: revert changes to ${file}"');
+      console.log('   To undo: git checkout HEAD -- ${file}\n');
+    } else {
+      console.log('🔍 DRY RUN: Would execute: git checkout ${hash} -- ${file}\n');
+    }
+    
+    return true;
+  } catch (error) {
+    console.error(`❌ Error during rollback: ${error.message}\n`);
+    return false;
+  }
+}
+
+// Run checks and rollback
+if (!checkGitRepo()) {
+  process.exit(1);
+}
+
+if (!verifyCommit(commitHash)) {
+  process.exit(1);
+}
+
+if (!checkFileInCommit(commitHash, filePath)) {
+  process.exit(1);
+}
+
+const hasUncommitted = checkUncommittedChanges(filePath);
+
+if (hasUncommitted && !isDryRun) {
+  console.log('⚠️  SAFETY CHECK: Uncommitted changes detected\n');
+  console.log('   Options:');
+  console.log('   1. Commit your current changes first');
+  console.log('   2. Stash your changes: git stash');
+  console.log('   3. Run with --dry-run to preview\n');
+  console.log('❌ Rollback aborted for safety\n');
+  process.exit(1);
+}
+
+showDiff(commitHash, filePath);
+
+const success = rollbackFile(commitHash, filePath);
+
+console.log('='.repeat(60));
+
+process.exit(success ? 0 : 1);