offbyt 1.0.0

package/lib/utils/performanceAnalyzer.js

@@ -0,0 +1,298 @@
+/**
+ * Performance Analyzer - Analyzes load test results and generates insights
+ */
+
+import chalk from 'chalk';
+
+/**
+ * Analyze performance results
+ */
+export function analyzePerformance(results, routes) {
+  const analysis = {
+    summary: {},
+    bottlenecks: [],
+    recommendations: [],
+    scalabilityScore: 0
+  };
+
+  // Analyze each load level
+  for (const levelResult of results) {
+    const level = levelResult.level;
+    const routeResults = levelResult.routes;
+
+    let totalLatency = 0;
+    let slowRoutes = [];
+    let errorRoutes = [];
+
+    for (const routeResult of routeResults) {
+      const avgLatency = routeResult.latency.mean;
+      totalLatency += avgLatency;
+
+      // Detect slow routes
+      if (avgLatency > 500) {
+        slowRoutes.push({
+          route: routeResult.route,
+          latency: avgLatency.toFixed(2)
+        });
+      }
+
+      // Detect errors
+      if (routeResult.errors > 0 || routeResult.non2xx > 0) {
+        errorRoutes.push({
+          route: routeResult.route,
+          errors: routeResult.errors,
+          non2xx: routeResult.non2xx
+        });
+      }
+    }
+
+    const avgLatency = routeResults.length > 0 ? totalLatency / routeResults.length : 0;
+
+    analysis.summary[level] = {
+      avgLatency: avgLatency.toFixed(2),
+      slowRoutes,
+      errorRoutes
+    };
+
+    // Identify bottlenecks
+    if (avgLatency > 500) {
+      analysis.bottlenecks.push({
+        level,
+        issue: `High average latency (${avgLatency.toFixed(2)}ms)`,
+        severity: 'critical'
+      });
+    } else if (avgLatency > 200) {
+      analysis.bottlenecks.push({
+        level,
+        issue: `Moderate latency (${avgLatency.toFixed(2)}ms)`,
+        severity: 'warning'
+      });
+    }
+
+    if (slowRoutes.length > 0) {
+      for (const slow of slowRoutes) {
+        analysis.bottlenecks.push({
+          level,
+          issue: `${slow.route} is slow (${slow.latency}ms)`,
+          severity: 'critical'
+        });
+      }
+    }
+
+    if (errorRoutes.length > 0) {
+      for (const err of errorRoutes) {
+        analysis.bottlenecks.push({
+          level,
+          issue: `${err.route} has errors (${err.errors} errors, ${err.non2xx} non-2xx)`,
+          severity: 'critical'
+        });
+      }
+    }
+  }
+
+  // Generate recommendations
+  analysis.recommendations = generateRecommendations(analysis);
+
+  // Calculate scalability score (0-100)
+  analysis.scalabilityScore = calculateScalabilityScore(analysis);
+
+  return analysis;
+}
+
+/**
+ * Generate recommendations based on analysis
+ */
+function generateRecommendations(analysis) {
+  const recommendations = [];
+
+  // Check if there are critical bottlenecks
+  const criticalBottlenecks = analysis.bottlenecks.filter(b => b.severity === 'critical');
+  
+  if (criticalBottlenecks.length > 0) {
+    recommendations.push({
+      priority: 'high',
+      issue: 'Critical performance bottlenecks detected',
+      suggestions: [
+        'Add database indexes on frequently queried fields',
+        'Implement caching (Redis/Memcached) for read-heavy operations',
+        'Optimize database queries (avoid N+1 queries)',
+        'Use connection pooling for database connections',
+        'Consider horizontal scaling (load balancing)'
+      ]
+    });
+  }
+
+  // Check latency trends
+  const levels = Object.keys(analysis.summary).map(Number).sort((a, b) => a - b);
+  if (levels.length >= 2) {
+    const firstLatency = parseFloat(analysis.summary[levels[0]].avgLatency);
+    const lastLatency = parseFloat(analysis.summary[levels[levels.length - 1]].avgLatency);
+    
+    if (lastLatency > firstLatency * 3) {
+      recommendations.push({
+        priority: 'high',
+        issue: 'Performance degrades significantly at scale',
+        suggestions: [
+          'Implement API rate limiting',
+          'Add request queuing for burst traffic',
+          'Scale backend horizontally (multiple instances)',
+          'Use a CDN for static assets',
+          'Implement database read replicas'
+        ]
+      });
+    }
+  }
+
+  // General optimization recommendations
+  recommendations.push({
+    priority: 'medium',
+    issue: 'General optimizations',
+    suggestions: [
+      'Enable GZIP compression for responses',
+      'Implement pagination for list endpoints',
+      'Use async/await properly to avoid blocking',
+      'Monitor database query performance',
+      'Set up proper logging and monitoring'
+    ]
+  });
+
+  return recommendations;
+}
+
+/**
+ * Calculate scalability score (0-100)
+ */
+function calculateScalabilityScore(analysis) {
+  let score = 100;
+
+  // Deduct for bottlenecks
+  const criticalCount = analysis.bottlenecks.filter(b => b.severity === 'critical').length;
+  const warningCount = analysis.bottlenecks.filter(b => b.severity === 'warning').length;
+
+  score -= criticalCount * 15;
+  score -= warningCount * 5;
+
+  // Deduct for high latency
+  const levels = Object.keys(analysis.summary);
+  for (const level of levels) {
+    const avgLatency = parseFloat(analysis.summary[level].avgLatency);
+    if (avgLatency > 1000) score -= 10;
+    else if (avgLatency > 500) score -= 5;
+    else if (avgLatency > 200) score -= 2;
+  }
+
+  return Math.max(0, Math.min(100, score));
+}
+
+/**
+ * Generate formatted report
+ */
+export function generateReport(analysis, startupMode = false) {
+  let report = '';
+
+  report += chalk.bold.cyan('\n╔════════════════════════════════════════════════════════════╗\n');
+report += chalk.bold.cyan('â•'         offbyt SCALABILITY REPORT                      â•'\n');
+  report += chalk.bold.cyan('╚════════════════════════════════════════════════════════════╝\n\n');
+
+  // Scalability Score
+  const score = analysis.scalabilityScore;
+  let scoreColor = chalk.green;
+  let scoreLabel = 'Excellent';
+  
+  if (score < 50) {
+    scoreColor = chalk.red;
+    scoreLabel = 'Poor';
+  } else if (score < 70) {
+    scoreColor = chalk.yellow;
+    scoreLabel = 'Fair';
+  } else if (score < 85) {
+    scoreColor = chalk.blue;
+    scoreLabel = 'Good';
+  }
+
+  report += chalk.bold('📊 Scalability Score: ') + scoreColor.bold(`${score}/100 (${scoreLabel})`) + '\n\n';
+
+  // Summary for each load level
+  report += chalk.bold.yellow('📈 Performance Summary:\n\n');
+  
+  const levels = Object.keys(analysis.summary).map(Number).sort((a, b) => a - b);
+  for (const level of levels) {
+    const summary = analysis.summary[level];
+    const latency = parseFloat(summary.avgLatency);
+    
+    let icon = '✅';
+    let color = chalk.green;
+    
+    if (latency > 500) {
+      icon = '❌';
+      color = chalk.red;
+    } else if (latency > 200) {
+      icon = '⚠️ ';
+      color = chalk.yellow;
+    }
+    
+    report += color(`${icon} ${level} concurrent users → Avg latency: ${summary.avgLatency}ms\n`);
+    
+    if (summary.slowRoutes.length > 0) {
+      for (const slow of summary.slowRoutes) {
+        report += color(`   └─ ${slow.route} is slow (${slow.latency}ms)\n`);
+      }
+    }
+  }
+
+  report += '\n';
+
+  // Startup Growth Simulation (if enabled)
+  if (startupMode) {
+    report += chalk.bold.magenta('🚀 Startup Growth Simulation:\n\n');
+    report += chalk.gray('Month 1  →   100 users    ✅ Stable\n');
+    report += chalk.gray('Month 3  →   1,000 users  ✅ Stable\n');
+    
+    if (score < 70) {
+      report += chalk.yellow('Month 6  →  10,000 users  ⚠️  Performance issues expected\n');
+      report += chalk.red('Month 12 → 100,000 users  ❌ System will struggle\n\n');
+      report += chalk.red.bold('⚠️  System needs optimization before scaling to 10k+ users\n');
+    } else {
+      report += chalk.green('Month 6  →  10,000 users  ✅ Stable\n');
+      report += chalk.cyan('Month 12 → 100,000 users  🔵 Consider scaling plan\n');
+    }
+    
+    report += '\n';
+  }
+
+  // Bottlenecks
+  if (analysis.bottlenecks.length > 0) {
+    report += chalk.bold.red('🔴 Detected Bottlenecks:\n\n');
+    
+    for (const bottleneck of analysis.bottlenecks.slice(0, 10)) {
+      const icon = bottleneck.severity === 'critical' ? '❌' : '⚠️ ';
+      const color = bottleneck.severity === 'critical' ? chalk.red : chalk.yellow;
+      report += color(`${icon} ${bottleneck.issue} (at ${bottleneck.level} users)\n`);
+    }
+    
+    report += '\n';
+  }
+
+  // Recommendations
+  report += chalk.bold.blue('💡 Recommended Optimizations:\n\n');
+  
+  for (const rec of analysis.recommendations) {
+    const priorityLabel = rec.priority === 'high' ? chalk.red('[HIGH]') : chalk.yellow('[MEDIUM]');
+    report += `${priorityLabel} ${chalk.bold(rec.issue)}\n`;
+    
+    for (const suggestion of rec.suggestions.slice(0, 5)) {
+      report += chalk.gray(`   • ${suggestion}\n`);
+    }
+    
+    report += '\n';
+  }
+
+  // Footer
+  report += chalk.cyan('─────────────────────────────────────────────────────────────\n');
+  report += chalk.gray('Generated by offbyt Benchmark Tool\n');
+  
+  return report;
+}
+
+export default { analyzePerformance, generateReport };
+

package/lib/utils/resourceDetector.js

@@ -0,0 +1,281 @@
+/**
+ * Resource Detector - Detects data resources from frontend code patterns
+ * Detects from: useState, useEffect, data arrays, forms, etc.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { globSync } from 'glob';
+import * as parser from '@babel/parser';
+import traverse from '@babel/traverse';
+
+/**
+ * Scan frontend and detect resources from state variables and data patterns
+ */
+export function detectResourcesFromFrontend(projectPath) {
+  const resources = new Map();
+  
+  // Find all frontend files
+  const patterns = [
+    'src/**/*.{js,jsx,ts,tsx}',
+    'app/**/*.{js,jsx,ts,tsx}',
+    'pages/**/*.{js,jsx,ts,tsx}',
+    'components/**/*.{js,jsx,ts,tsx}',
+    '*.{js,jsx,ts,tsx}'
+  ];
+
+  const files = [];
+  for (const pattern of patterns) {
+    files.push(...globSync(pattern, { nodir: true, cwd: projectPath }));
+  }
+
+  console.log(`   📁 Scanning ${files.length} files...`);
+
+  for (const file of files) {
+    try {
+      const fullPath = path.join(projectPath, file);
+      const content = fs.readFileSync(fullPath, 'utf8');
+      
+      // Detect resources from code patterns
+      const detected = detectFromCode(content, file);
+      
+      for (const resource of detected) {
+        if (!resources.has(resource.name)) {
+          resources.set(resource.name, {
+            name: resource.name,
+            singular: resource.singular,
+            fields: new Set(resource.fields || []),
+            sources: []
+          });
+        }
+        
+        resources.get(resource.name).sources.push({
+          file,
+          type: resource.type
+        });
+        
+        // Merge fields
+        if (resource.fields) {
+          for (const field of resource.fields) {
+            resources.get(resource.name).fields.add(field);
+          }
+        }
+      }
+    } catch (error) {
+      // Ignore parse errors
+    }
+  }
+
+  // Convert to array
+  return Array.from(resources.values()).map(r => ({
+    ...r,
+    fields: Array.from(r.fields).filter(field => 
+      field !== '_id' && field !== 'id' && field.toLowerCase() !== 'id'
+    )
+  }));
+}
+
+/**
+ * Detect resources from code content using AST and patterns
+ */
+function detectFromCode(content, fileName) {
+  const resources = [];
+
+  // Pattern 1: useState hooks
+  // Example: const [products, setProducts] = useState([])
+  const statePattern = /const\s+\[(\w+),\s*set\w+\]\s*=\s*useState/g;
+  let match;
+  while ((match = statePattern.exec(content)) !== null) {
+    const varName = match[1];
+    if (isResourceVariable(varName)) {
+      resources.push({
+        name: varName,
+        singular: singularize(varName),
+        type: 'useState',
+        fields: extractFieldsFromVariable(content, varName)
+      });
+    }
+  }
+
+  // Pattern 2: Data arrays
+  // Example: const products = []
+  const arrayPattern = /const\s+(\w+)\s*=\s*\[\]/g;
+  while ((match = arrayPattern.exec(content)) !== null) {
+    const varName = match[1];
+    if (isResourceVariable(varName)) {
+      resources.push({
+        name: varName,
+        singular: singularize(varName),
+        type: 'array',
+        fields: extractFieldsFromVariable(content, varName)
+      });
+    }
+  }
+
+  // Pattern 3: map operations (indicates list rendering)
+  // Example: products.map(product => ...)
+  const mapPattern = /(\w+)\.map\s*\(\s*(?:\()?(\w+)(?:\))?\s*=>/g;
+  while ((match = mapPattern.exec(content)) !== null) {
+    const listName = match[1];
+    const itemName = match[2];
+    
+    if (isResourceVariable(listName)) {
+      const fields = extractFieldsFromItemVariable(content, itemName);
+      resources.push({
+        name: listName,
+        singular: itemName,
+        type: 'map',
+        fields
+      });
+    }
+  }
+
+  // Pattern 4: Form fields (input names)
+  // Example: <input name="productName" />
+  const inputPattern = /name=["'](\w+)["']/g;
+  const formFields = [];
+  while ((match = inputPattern.exec(content)) !== null) {
+    formFields.push(match[1]);
+  }
+
+  if (formFields.length > 0) {
+    // Try to infer resource from form fields
+    const resourceName = inferResourceFromFields(formFields);
+    if (resourceName) {
+      resources.push({
+        name: resourceName,
+        singular: singularize(resourceName),
+        type: 'form',
+        fields: formFields
+      });
+    }
+  }
+
+  // Pattern 5: useEffect with fetch/axios placeholder
+  // Example: useEffect(() => { /* TODO: fetch products */ }, [])
+  const effectPattern = /useEffect\s*\([^)]*?(?:fetch|load|get)\s*(\w+)/gi;
+  while ((match = effectPattern.exec(content)) !== null) {
+    const varName = match[1];
+    if (isResourceVariable(varName)) {
+      resources.push({
+        name: varName,
+        singular: singularize(varName),
+        type: 'useEffect'
+      });
+    }
+  }
+
+  return resources;
+}
+
+/**
+ * Check if variable name looks like a resource
+ */
+function isResourceVariable(name) {
+  // Skip common non-resource variables
+  const excluded = ['data', 'loading', 'error', 'fetching', 'isLoading', 'isError', 
+                      'response', 'result', 'value', 'state', 'props', 'params', 'filter', 
+                      'filtered', 'sorted', 'paginated', 'searched'];
+  
+    // Skip derived/transformed variables (filteredTodos, sortedProducts, etc.)
+    const derivedPrefixes = ['filtered', 'sorted', 'paginated', 'searched', 'visible', 'active', 'selected', 'new'];
+    if (derivedPrefixes.some(prefix => name.toLowerCase().startsWith(prefix))) {
+      return false;
+    }
+  
+  if (excluded.includes(name.toLowerCase())) return false;
+  
+  // Should be plural or common resource name
+  return name.length > 2 && (
+    name.endsWith('s') || 
+    name.endsWith('List') ||
+    name.endsWith('Data') ||
+    isCommonResource(name)
+  );
+}
+
+/**
+ * Check if it's a common resource name
+ */
+function isCommonResource(name) {
+  const common = ['user', 'product', 'order', 'cart', 'item', 'post', 'comment', 
+                  'review', 'category', 'tag', 'customer', 'invoice', 'payment'];
+  const lowerName = name.toLowerCase();
+  // Check if name equals or ends with (singular or plural) a common resource
+  return common.some(r => {
+    const plural = r + 's';
+    return lowerName === r || lowerName === plural || 
+           lowerName.endsWith(r) && (lowerName[lowerName.length - r.length - 1] === 's' || lowerName.length === r.length);
+  });
+}
+
+/**
+ * Convert plural to singular (simple version)
+ */
+function singularize(word) {
+  if (word.endsWith('ies')) return word.slice(0, -3) + 'y';
+  if (word.endsWith('ses')) return word.slice(0, -2);
+  if (word.endsWith('s')) return word.slice(0, -1);
+  return word;
+}
+
+/**
+ * Extract fields from variable usage in code
+ */
+function extractFieldsFromVariable(content, varName) {
+  const fields = new Set();
+  
+  // Pattern: varName.field
+  const dotPattern = new RegExp(`${varName}\\.\\w+\\.(\\w+)`, 'g');
+  let match;
+  while ((match = dotPattern.exec(content)) !== null) {
+    fields.add(match[1]);
+  }
+  
+  return Array.from(fields).filter(field => 
+    field !== '_id' && field !== 'id' && field.toLowerCase() !== 'id'
+  );
+}
+
+/**
+ * Extract fields from item variable in map operations
+ */
+function extractFieldsFromItemVariable(content, itemName) {
+  const fields = new Set();
+  
+  // Pattern: item.fieldName
+  const fieldPattern = new RegExp(`${itemName}\\.([a-zA-Z_][a-zA-Z0-9_]*)`, 'g');
+  let match;
+  while ((match = fieldPattern.exec(content)) !== null) {
+    const field = match[1];
+    // Skip common methods and MongoDB _id
+    if (!['map', 'filter', 'reduce', 'forEach', 'length'].includes(field) &&
+        field !== '_id' && field !== 'id' && field.toLowerCase() !== 'id') {
+      fields.add(field);
+    }
+  }
+  
+  return Array.from(fields);
+}
+
+/**
+ * Infer resource name from form fields
+ */
+function inferResourceFromFields(fields) {
+  // Look for common patterns in field names
+  const patterns = {
+    product: ['productName', 'productPrice', 'productDescription'],
+    user: ['userName', 'userEmail', 'userPassword'],
+    order: ['orderDate', 'orderTotal', 'orderStatus']
+  };
+  
+  for (const [resource, keywords] of Object.entries(patterns)) {
+    if (keywords.some(kw => fields.some(f => f.toLowerCase().includes(kw.toLowerCase())))) {
+      return resource + 's';
+    }
+  }
+  
+  return null;
+}
+
+export default { detectResourcesFromFrontend };

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "offbyt",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Code generation and deployment tool",
+  "main": "index.js",
+  "bin": {
+    "offbyt": "cli.js"
+  },
+  "scripts": {
+    "start": "node cli.js",
+    "dev": "node cli.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "glob": "^13.0.6"
+  }
+}

package/templates/.env.template

@@ -0,0 +1,31 @@
+# ========== SERVER ==========
+NODE_ENV=development
+PORT=5000
+
+# ========== DATABASE ==========
+MONGODB_URI=mongodb://localhost:27017/<DB_NAME>
+DB_NAME=<DB_NAME>
+
+# ========== SECURITY ==========
+JWT_SECRET=your_jwt_secret_key_here_change_in_production
+JWT_EXPIRE=7d
+JWT_EXPIRES_IN=7d
+PASSWORD_SALT_ROUNDS=10
+
+# ========== CORS ==========
+CORS_ORIGIN=http://localhost:3000,http://localhost:5173
+
+# ========== API ==========
+API_VERSION=v1
+API_RATE_LIMIT=100
+
+# ========== LOGGING ==========
+LOG_LEVEL=info
+ENABLE_LOGGING=true
+ENABLE_METRICS=false
+
+# ========== CACHE ==========
+CACHE_TTL=300
+
+# ========== API KEYS (Optional) ==========
+# API_KEY=your_api_key_here