performance-optimizer 2.5.0__py3-none-any.whl

optimizer.py

@@ -0,0 +1,339 @@
+#!/usr/bin/env python3
+"""
+Performance Optimizer v2.0 - Advanced Multi-Stack Analyzer
+Angular • Node.js • Seneca • SQL • AWS
+NOT SonarQube — Performance-Specific Only
+
+Usage:
+  python optimizer.py --frontend /path/to/angular-repo
+  python optimizer.py --backend /path/to/node-repo
+  python optimizer.py --project /path/to/monorepo
+  python optimizer.py --frontend ./fe --backend ./be --fail-on critical --min-score 70
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import List, Set
+
+sys.path.insert(0, os.path.dirname(__file__))
+
+from analyzers.angular_analyzer import AngularAnalyzer
+from analyzers.react_analyzer import ReactAnalyzer
+from analyzers.node_analyzer import NodeAnalyzer
+from analyzers.sql_analyzer import SqlAnalyzer
+from analyzers.aws_analyzer import AwsAnalyzer
+from core.scorer import Scorer
+from core.issue import Severity, Issue
+from reporter.html_reporter import HtmlReporter
+
+BANNER = """
+┌─────────────────────────────────────────────────────────────┐
+│   PERFORMANCE OPTIMIZER v2.5 PRO                            │
+│   Enterprise Multi-Stack Performance Intelligence          │
+│   Angular • React • Node.js • SQL • AWS Cloud               │
+│   NOT SonarQube — Performance-Specific Only                 │
+└─────────────────────────────────────────────────────────────┘
+"""
+
+DEFAULT_EXCLUDES = [
+    'node_modules', '.git', 'dist', 'build', '.angular', '.next',
+    'coverage', '.vscode', '.idea', 'package-lock.json', 'yarn.lock'
+]
+
+def should_exclude(path_str: str, custom_excludes: List[str]) -> bool:
+    normalized = path_str.replace('\\', '/')
+    all_excludes = DEFAULT_EXCLUDES + custom_excludes
+    return any(ex in normalized for ex in all_excludes if ex)
+
+def count_files(path: str, custom_excludes: List[str]) -> int:
+    p = Path(path)
+    count = 0
+    extensions = ['*.ts', '*.js', '*.jsx', '*.tsx', '*.html', '*.sql', '*.json', '*.yml', '*.yaml', '*.tf']
+    for ext in extensions:
+        for f in p.rglob(ext):
+            if not should_exclude(str(f), custom_excludes):
+                count += 1
+    return count
+
+def detect_tech(frontend_path: str, backend_path: str) -> str:
+    techs = []
+    checked_paths = set(filter(None, [frontend_path, backend_path]))
+    for path in checked_paths:
+        p = Path(path)
+        pkg = p / 'package.json'
+        if pkg.exists():
+            try:
+                data = json.loads(pkg.read_text(encoding='utf-8', errors='ignore'))
+                deps = {**data.get('dependencies', {}), **data.get('devDependencies', {})}
+                if '@angular/core' in deps:
+                    ver = deps['@angular/core'].lstrip('^~')
+                    techs.append(f'Angular {ver.split(".")[0]}')
+                if 'react' in deps:
+                    ver = deps['react'].lstrip('^~')
+                    techs.append(f'React {ver.split(".")[0]}')
+                if 'next' in deps:
+                    techs.append('Next.js')
+                if 'vue' in deps:
+                    techs.append('Vue')
+                if 'seneca' in deps:
+                    techs.append('Seneca.js')
+                if 'express' in deps:
+                    techs.append('Express')
+                if 'nest' in deps or '@nestjs/core' in deps:
+                    techs.append('NestJS')
+                node_ver = data.get('engines', {}).get('node', '')
+                if node_ver:
+                    techs.append(f'Node {node_ver}')
+            except Exception:
+                pass
+
+        # Check for AWS Infra
+        if any(p.rglob('serverless.yml')) or any(p.rglob('*.tf')) or any(p.rglob('cloudformation*.yml')):
+            if 'AWS' not in techs:
+                techs.append('AWS Cloud')
+        # Check for SQL files
+        if any(p.rglob('*.sql')):
+            if 'SQL/RDS' not in techs:
+                techs.append('SQL/RDS')
+
+    return ' • '.join(techs) if techs else 'Angular • React • Node.js • SQL • AWS'
+
+def run_analyzers(frontend_path: str, backend_path: str, verbose: bool = False) -> List[Issue]:
+    all_issues = []
+    is_monorepo = (frontend_path and backend_path and Path(frontend_path).resolve() == Path(backend_path).resolve())
+
+    if is_monorepo or (frontend_path and not backend_path):
+        target = frontend_path
+        print(f'  🔍 Analyzing unified project: {target}')
+        if Path(target).exists():
+            print('     🅰️  Running Angular Analyzer...')
+            all_issues.extend(AngularAnalyzer(target).analyze())
+            print('     ⚛️  Running React Analyzer...')
+            all_issues.extend(ReactAnalyzer(target).analyze())
+            print('     🟢  Running Node.js & Seneca Analyzer...')
+            all_issues.extend(NodeAnalyzer(target).analyze())
+            print('     🗄️  Running SQL & Database Analyzer...')
+            all_issues.extend(SqlAnalyzer(target).analyze())
+            print('     ☁️  Running AWS & Infrastructure Analyzer...')
+            all_issues.extend(AwsAnalyzer(target).analyze())
+        return all_issues
+
+    # Separate frontend and backend paths
+    if frontend_path:
+        fp = Path(frontend_path)
+        if fp.exists():
+            print(f'  🅰️  Analyzing Angular/Frontend: {frontend_path}')
+            issues = AngularAnalyzer(frontend_path).analyze()
+            all_issues.extend(issues)
+            print(f'     Found {len(issues)} Angular performance issues')
+
+            print(f'  ⚛️  Analyzing React/Frontend: {frontend_path}')
+            react_issues = ReactAnalyzer(frontend_path).analyze()
+            all_issues.extend(react_issues)
+            print(f'     Found {len(react_issues)} React performance issues')
+        else:
+            print(f'  ❌ Frontend path not found: {frontend_path}')
+
+    if backend_path:
+        bp = Path(backend_path)
+        if bp.exists():
+            print(f'  🟢  Analyzing Node.js/Seneca: {backend_path}')
+            node_issues = NodeAnalyzer(backend_path).analyze()
+            all_issues.extend(node_issues)
+            print(f'     Found {len(node_issues)} backend performance issues')
+
+            print(f'  🗄️  Analyzing SQL/Database: {backend_path}')
+            sql_issues = SqlAnalyzer(backend_path).analyze()
+            all_issues.extend(sql_issues)
+            print(f'     Found {len(sql_issues)} database performance issues')
+
+            print(f'  ☁️  Analyzing AWS/Infra config: {backend_path}')
+            aws_issues = AwsAnalyzer(backend_path).analyze()
+            all_issues.extend(aws_issues)
+            print(f'     Found {len(aws_issues)} infrastructure issues')
+        else:
+            print(f'  ❌ Backend path not found: {backend_path}')
+
+    return all_issues
+
+def print_summary(scores: dict, issues: List[Issue]):
+    s = scores
+    print(f'''
+┌{'─'*58}┐
+│  PERFORMANCE SCAN RESULTS                                │
+├{'─'*58}┤
+│  Overall Score : {s['overall']:>3}/100  {'(🔴 Critical)' if s['overall']<45 else '(⚠️ Needs Work)' if s['overall']<65 else '(🟡 Fair)' if s['overall']<80 else '(✅ Good)':16}{'':13}│
+│  Frontend      : {s['frontend']:>3}/100{'':36}│
+│  Backend       : {s['backend']:>3}/100{'':36}│
+│  Database      : {s['database']:>3}/100{'':36}│
+│  Infra         : {s['infra']:>3}/100{'':36}│
+├{'─'*58}┤
+│  🔴 Critical: {s['by_severity']['critical']:<4}  🟠 High: {s['by_severity']['high']:<4}  🟡 Medium: {s['by_severity']['medium']:<4}  🟢 Low: {s['by_severity']['low']:<4}  │
+│  Total Issues : {s['total_issues']:>3}{'':42}│
+└{'─'*58}┘''')
+
+    if s.get('top3'):
+        print('\n  🚨 TOP ACTIONABLE FIXES (Show to leadership):')
+        for idx, t in enumerate(s['top3'], 1):
+            line_str = f":{t['line_number']}" if t.get('line_number') else ""
+            print(f'   {idx}. [{t["severity"].upper()}] {t["title"]}')
+            print(f'      Location : {t["file"]}{line_str}')
+            print(f'      Gain     : {t["perf_gain"]}')
+
+def generate_markdown_summary(out_path: str, scores: dict, meta: dict, issues: List[Issue]):
+    s = scores
+    md = f"""# Performance Optimizer Scan Summary
+
+**Overall Health Score**: `{s['overall']}/100`  
+**Target Project**: `{meta.get('project', 'Application')}`  
+**Scan Timestamp**: `{meta.get('scan_time')}`  
+**Analyzed Files**: `{meta.get('files_scanned')}` in `{meta.get('duration')}s`  
+
+---
+
+### 📊 Layer Breakdown
+| Layer | Score | Status |
+| :--- | :--- | :--- |
+| **Frontend (Angular / React)** | `{s['frontend']}/100` | {'🔴 Critical' if s['frontend']<50 else '🟠 High Risk' if s['frontend']<70 else '✅ Good'} |
+| **Node.js / Seneca** | `{s['backend']}/100` | {'🔴 Critical' if s['backend']<50 else '🟠 High Risk' if s['backend']<70 else '✅ Good'} |
+| **SQL / Database** | `{s['database']}/100` | {'🔴 Critical' if s['database']<50 else '🟠 High Risk' if s['database']<70 else '✅ Good'} |
+| **AWS / Cloud Infra** | `{s['infra']}/100` | {'🔴 Critical' if s['infra']<50 else '🟠 High Risk' if s['infra']<70 else '✅ Good'} |
+
+### 🚨 Top Critical Bottlenecks
+"""
+    for idx, t in enumerate(s.get('top3', []), 1):
+        md += f"\n{idx}. **[{t['severity'].upper()}] {t['title']}**\n"
+        md += f"   - **File**: `{t['file']}`\n"
+        md += f"   - **Impact**: {t['perf_gain']}\n"
+
+    md += "\n> 💡 *Generated by [Performance Optimizer v2.5 PRO](https://github.com/Ravik27280/Performance-Optimizer)*\n"
+
+    with open(out_path, 'w', encoding='utf-8') as fh:
+        fh.write(md)
+    print(f'  📝 Markdown summary saved: {out_path}')
+
+def main():
+    print(BANNER)
+
+    parser = argparse.ArgumentParser(
+        description='Performance Optimizer v2.5 PRO - Enterprise Multi-Stack Performance Analyzer'
+    )
+    parser.add_argument('--frontend', '-f', help='Path to Angular frontend repo', default=None)
+    parser.add_argument('--backend',  '-b', help='Path to Node.js/Seneca backend repo', default=None)
+    parser.add_argument('--project',  '-p', help='Path to monorepo (scans entire workspace)', default=None)
+    parser.add_argument('--output',   '-o', help='Output HTML report path', default='performance_report.html')
+    parser.add_argument('--json',     '-j', help='Output machine-readable JSON report', action='store_true')
+    parser.add_argument('--markdown-summary', '-m', help='Generate markdown report summary for PR comments', default=None)
+    parser.add_argument('--exclude',  '-e', help='Comma-separated directory patterns to exclude', default='')
+    parser.add_argument('--fail-on',  help='Fail CI with exit 1 if issues matching severity exist (critical, high)', default=None)
+    parser.add_argument('--min-score', help='Fail CI with exit 1 if overall score is below threshold (0-100)', type=int, default=None)
+    parser.add_argument('--verbose',  '-v', help='Verbose terminal output', action='store_true')
+    args = parser.parse_args()
+
+    frontend_path = args.frontend or args.project
+    backend_path  = args.backend  or args.project
+    custom_excludes = [x.strip() for x in args.exclude.split(',') if x.strip()]
+
+    if not frontend_path and not backend_path:
+        print('  ❌ ERROR: Provide at least one of --frontend, --backend, or --project')
+        print('  Example: python optimizer.py --frontend ./angular-app --backend ./node-api')
+        parser.print_help()
+        sys.exit(1)
+
+    print(f'  📁 Frontend path : {frontend_path or "(not provided)"}')
+    print(f'  📁 Backend path  : {backend_path  or "(not provided)"}')
+    print(f'  💾 HTML Output   : {args.output}')
+
+    total_files = 0
+    if frontend_path and Path(frontend_path).exists():
+        total_files += count_files(frontend_path, custom_excludes)
+    if backend_path and Path(backend_path).exists() and Path(backend_path).resolve() != Path(frontend_path or '').resolve():
+        total_files += count_files(backend_path, custom_excludes)
+
+    tech = detect_tech(frontend_path, backend_path)
+    print(f'  🔎 Detected tech : {tech}')
+    print(f'  📁 Files to scan : {total_files}')
+    print('\n  Running analyzers...')
+
+    start_time = time.time()
+    all_issues = run_analyzers(frontend_path, backend_path, verbose=args.verbose)
+    duration = round(time.time() - start_time, 2)
+
+    print(f'\n  ✔ Scan completed in {duration}s')
+
+    # Deduplicate issues with same (id, file, line_number)
+    seen: Set[tuple] = set()
+    unique_issues = []
+    for issue in all_issues:
+        key = (issue.id, issue.file, issue.line_number)
+        if key not in seen:
+            seen.add(key)
+            unique_issues.append(issue)
+    all_issues = unique_issues
+
+    # Compute scores
+    scorer = Scorer()
+    scores = scorer.compute(all_issues)
+    print_summary(scores, all_issues)
+
+    # Render HTML Dashboard
+    scan_time = datetime.now().strftime('%d %b %Y, %I:%M %p')
+    project_name = Path(frontend_path or backend_path).name or "Performance Project"
+    meta = {
+        'project': project_name,
+        'scan_time': scan_time,
+        'files_scanned': total_files,
+        'duration': duration,
+        'tech': tech,
+    }
+
+    reporter = HtmlReporter(all_issues, scores, meta)
+    reporter.render(args.output)
+    print(f'\n  📊 Interactive HTML Dashboard saved: {args.output}')
+
+    # JSON export
+    if args.json:
+        json_path = args.output.replace('.html', '.json') if args.output.endswith('.html') else f"{args.output}.json"
+        report_data = {
+            'meta': meta,
+            'scores': scores,
+            'issues': [i.to_dict() for i in all_issues],
+        }
+        with open(json_path, 'w', encoding='utf-8') as jf:
+            json.dump(report_data, jf, indent=2)
+        print(f'  💾 Machine-readable JSON saved: {json_path}')
+
+    # Markdown summary
+    if args.markdown_summary:
+        generate_markdown_summary(args.markdown_summary, scores, meta, all_issues)
+
+    # CI/CD Quality Gate evaluation
+    exit_code = 0
+    if args.fail_on:
+        threshold_sev = args.fail_on.lower()
+        critical_count = scores['by_severity'].get('critical', 0)
+        high_count = scores['by_severity'].get('high', 0)
+
+        if threshold_sev == 'critical' and critical_count > 0:
+            print(f'\n  ❌ CI QUALITY GATE FAILED: Found {critical_count} critical performance issues (--fail-on critical)')
+            exit_code = 1
+        elif threshold_sev == 'high' and (critical_count > 0 or high_count > 0):
+            print(f'\n  ❌ CI QUALITY GATE FAILED: Found {critical_count} critical and {high_count} high issues (--fail-on high)')
+            exit_code = 1
+
+    if args.min_score is not None:
+        if scores['overall'] < args.min_score:
+            print(f'\n  ❌ CI QUALITY GATE FAILED: Overall score {scores["overall"]} is below minimum threshold of {args.min_score} (--min-score {args.min_score})')
+            exit_code = 1
+
+    if exit_code == 0:
+        print('\n  ✔ Done! All quality checks passed.\n')
+    sys.exit(exit_code)
+
+if __name__ == '__main__':
+    main()

performance_optimizer-2.5.0.dist-info/METADATA

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: performance-optimizer
+Version: 2.5.0
+Summary: Ultra-fast zero-dependency static performance analyzer for Angular, React, Node.js, SQL, and AWS.
+Author: Performance Optimizer Core Team
+License: MIT
+Keywords: performance,static-analysis,angular,react,nodejs,sql,aws,latency,optimizer
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Bug Tracking
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Performance Optimizer v2.5 PRO — Advanced Multi-Stack Analyzer
+
+> **NOT SonarQube.** This is an enterprise static performance & latency intelligence engine.  
+> **Targeted Runtimes**: Angular (14–19+), React (17–19+) & Next.js, Node.js & Seneca.js, SQL / Database Indexes, and AWS Serverless.  
+> Zero external dependencies — runs in `<0.05s` with Python 3.7+ standard library.
+
+[![Live Portal](https://img.shields.io/badge/Live_Portal-GitHub_Pages-6366f1?style=for-the-badge&logo=github)](https://ravik27280.github.io/Performance-Optimizer/)
+[![Python 3.7+](https://img.shields.io/badge/Python-3.7+-06b6d4?style=for-the-badge&logo=python)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-10b981?style=for-the-badge)](https://opensource.org/licenses/MIT)
+
+🌐 **Live Interactive Web Portal & Diagnostic Scanner**: [https://ravik27280.github.io/Performance-Optimizer/](https://ravik27280.github.io/Performance-Optimizer/)
+
+---
+
+## ⚡ Installation & CLI Setup
+
+Install locally or as an editable package for global terminal access:
+
+```bash
+# Clone the repository
+git clone https://github.com/Ravik27280/Performance-Optimizer.git
+cd Performance-Optimizer
+
+# Install package globally / in virtual environment
+pip install -e .
+
+# Verify CLI installation
+perf-optimizer --help
+```
+
+---
+
+## 🚀 Quick Start Examples
+
+```bash
+# 1. Scan current repository / monorepo
+perf-optimizer --project .
+
+# 2. Scan separate frontend and backend directories
+perf-optimizer --frontend ./angular-app --backend ./node-api
+
+# 3. Enforce CI/CD Quality Gate (Exit 1 on critical issues or score < 75)
+perf-optimizer --project . --fail-on critical --min-score 75
+
+# 4. Generate HTML dashboard, JSON audit, and PR Markdown summary
+perf-optimizer --project . --json --markdown-summary pr_summary.md --output report.html
+
+# 5. Alternatively, run directly with python (zero pip packages required)
+python optimizer.py --project . --verbose
+```
+
+---
+
+## 📊 Output Formats
+
+- **`performance_report.html`** — Interactive executive dashboard with code diff previews, ROI impact calculations, and dark/light modes.
+- **`performance_report.json`** — Machine-readable audit data with exact line numbers and defect categories for custom tooling.
+- **`pr_summary.md`** — Markdown report table designed for automated Pull Request comments in GitHub Actions and GitLab CI.
+
+---
+
+## 🤖 GitHub Actions CI/CD Integration
+
+Create `.github/workflows/perf-audit.yml` to automatically run audits on every Pull Request:
+
+```yaml
+name: Performance Quality Gate
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  audit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Install Performance Optimizer
+        run: pip install -e .
+      - name: Run Performance Audit
+        run: |
+          perf-optimizer --project . --fail-on critical --min-score 75
+```
+
+---
+
+## 🛡️ CLI Flags & Options
+
+| Argument | Description | Example |
+|---|---|---|
+| `--project`, `-p` | Path to monorepo or project (scans entire workspace) | `--project .` |
+| `--frontend`, `-f` | Path to Angular or React frontend codebase | `--frontend ./src/web` |
+| `--backend`, `-b` | Path to Node.js/Seneca/Express codebase | `--backend ./src/api` |
+| `--fail-on` | Fails CI with exit code `1` if issues matching severity exist | `--fail-on critical` or `--fail-on high` |
+| `--min-score` | Fails CI with exit code `1` if overall score is below threshold | `--min-score 75` |
+| `--exclude`, `-e` | Comma-separated directory patterns to exclude | `--exclude "legacy,tmp,e2e"` |
+| `--json`, `-j` | Generates machine-readable JSON report | `--json` |
+| `--markdown-summary`, `-m` | Generates PR comment summary file | `--markdown-summary pr_summary.md` |
+| `--output`, `-o` | Custom HTML report output path | `--output ./dist/perf_report.html` |
+| `--verbose`, `-v` | Detailed terminal output during scan | `--verbose` |
+
+---
+
+## 🔇 Inline Rule Suppression
+
+Suppress false positives or accepted trade-offs directly in code:
+
+```typescript
+// Angular / TypeScript / JavaScript
+// perf-ignore ANG001
+@Component({ ... })
+
+// Node.js
+// perf-ignore NODE001
+const bootConfig = fs.readFileSync('boot.json', 'utf8');
+
+// SQL / Schema
+-- perf-ignore SQL004
+CREATE TABLE temp_session ( ... );
+```
+
+---
+
+## 🔍 What It Detects (Performance-Specific)
+
+### Angular / Modern Frontend (Angular 16–19+)
+| ID | Check | Category | Impact |
+|---|---|---|---|
+| **ANG001** | Missing OnPush Change Detection | DOM Re-render | 65% re-render reduction |
+| **ANG002** | Direct @Input Property Mutation | Change Detection | Restores OnPush change detection |
+| **ANG003** | `detectChanges()` Synchronously Inside Loop | Render Cycle | Eliminates N render cycles |
+| **ANG004** | Observable Memory Leak (Missing Unsubscribe / Teardown) | Memory Leak | Eliminates heap growth per route |
+| **ANG005** | Nested `subscribe()` Callback Anti-pattern | Concurrency | Eliminates race conditions & request leaks |
+| **ANG006** | API Call Without Pagination (Full Collection Fetch) | Network & Heap | 70%+ TTI improvement |
+| **ANG007** | Missing `debounceTime` on Reactive Form Streams | Network | Up to 85% fewer API requests |
+| **ANG008** | Missing HTTP Response Caching (`shareReplay`) | Network | Eliminates duplicate network calls |
+| **ANG009** | `*ngFor` Without `trackBy` or `@for` Without `track` | DOM Performance | 99% fewer DOM node recreations |
+| **ANG010** | Missing Virtual Scrolling for Large Lists | DOM Performance | Renders only ~20 DOM nodes |
+| **ANG011** | Method Calls in Template Interpolation | DOM Re-render | Eliminates expensive method re-evaluations |
+| **ANG012** | Wildcard / Full Library Imports (`lodash`, `rxjs/Rx`) | Bundle Size | 50–80KB bundle reduction |
+| **ANG013** | No Lazy Loading Routes (All Eager at Startup) | Bundle Size | 40–60% initial bundle cut |
+| **ANG014** | Heavy Subcomponents Rendered Without `@defer` | Core Web Vitals | Speeds up LCP & initial chunk parse |
+
+### React & Next.js (React 17–19+)
+| ID | Check | Category | Impact |
+|---|---|---|---|
+| **REACT001** | Array Index as `key` in List Rendering | Reconciliation | Enables DOM node reuse on mutations |
+| **REACT002** | Direct State Mutation Anti-pattern | State Management | Prevents broken re-render schedules |
+| **REACT003** | `useEffect` Missing Dependency Array | Render Loop | Eliminates runaway infinite re-render loops |
+| **REACT004** | Expensive Array Calculations Without `useMemo` | CPU Efficiency | Avoids heavy sorting/filtering recalculations |
+| **REACT005** | Eager Route Components Without `React.lazy()` | Bundle Size | 30–50% smaller initial JS chunks |
+| **REACT006** | Context Value Recreated as New Object on Render | Re-render Cascade | Stops cascading subtree re-renders |
+
+### Node.js / Seneca / Express Backend
+| ID | Check | Category | Impact |
+|---|---|---|---|
+| **NODE001** | Synchronous `fs` Calls in Runtime Execution Paths | Event Loop | Unblocks Node.js event loop |
+| **NODE002** | Sequential `await` on Independent Operations | Concurrency | Up to 50% latency reduction |
+| **NODE003** | Promise Chains Without `.catch()` | Stability | Prevents unhandled rejections |
+| **NODE004** | **N+1 Database Query Pattern in Loop** | Database I/O | O(N) → O(1) query roundtrips |
+| **NODE005** | **Database Queries Without LIMIT (Returns All Rows)** | Database I/O | Caps payload and memory bounds |
+| **NODE006** | No Caching Layer for Repeated Queries (Redis) | Database I/O | 60–90% database load reduction |
+| **NODE007** | API Response Over-fetching (`SELECT *` to `res.json`) | Serialization | Smaller payloads, faster JSON encode |
+| **NODE008** | Express Missing Gzip/Brotli Compression | Network | 70–90% smaller response sizes |
+| **NODE009** | Unbounded In-Memory Array Growth | Memory Leak | Prevents OOM crashes |
+| **NODE010** | Database Connection Pool Configured Too Small | Database I/O | Eliminates connection queue delays |
+| **NODE011** | **EventEmitter Memory Leak (Missing Listener Teardown)** | Memory Leak | Eliminates closure/listener leaks |
+| **NODE012** | **HTTP Requests Missing Connection Reuse (`keepAlive: true`)** | Network | Saves 50–100ms TLS handshakes |
+| **SEN001** | Seneca `.act()` Inside Iteration Loop | Microservice RPC | N×latency → max(latency) |
+| **SEN002** | Seneca `.act()` Without Explicit Timeout | Stability | Prevents cascading request hangs |
+
+### SQL / RDS / Database
+| ID | Check | Category | Impact |
+|---|---|---|---|
+| **SQL001** | `SELECT *` Column Over-fetching | Database I/O | Faster queries, less I/O |
+| **SQL002** | UPDATE/DELETE Without WHERE Clause | Data Integrity | Prevents full table locks & corruption |
+| **SQL003** | SELECT Without LIMIT | Result Bounds | Fixed result set size |
+| **SQL004** | **Missing Index on Foreign Key Columns** | Indexing | Converts O(N) table scan to O(log N) |
+| **SQL005** | SQL Query Built via String Concatenation | Plan Cache | Reuses compiled query plans |
+| **SQL006** | `LIKE '%query'` Leading Wildcard (B-Tree Incompatible) | Indexing | Enables index seeks |
+| **SQL007** | **Deep OFFSET Pagination Antipattern** | Query Optimization | Keyset pagination saves O(N) discard |
+
+### AWS / Serverless / Cloud Infrastructure
+| ID | Check | Category | Impact |
+|---|---|---|---|
+| **AWS001** | Lambda Memory Allocated Too Low (<512MB) | CPU & Latency | 50–75% faster execution |
+| **AWS002** | Static S3 Hosting Without CloudFront CDN | Edge Delivery | 300ms → 20ms global asset delivery |
+| **AWS003** | Lambda Functions Without Explicit Timeout | Cost & Timeouts | Prevents runaway costs on hangs |
+| **AWS005** | **Lambda Direct to RDS Without RDS Proxy** | Connection Pool | Prevents DB connection exhaustion |
+
+---
+
+## 📈 Scoring Engine
+
+- **Asymptotic Logarithmic Curve**: Avoids artificial zero-score cliffs; accurately reflects true performance health for codebases of any size.
+- **Architectural Layer Weights**:
+  $$\text{Overall} = 40\% \text{Frontend} + 30\% \text{Backend} + 20\% \text{Database} + 10\% \text{Infra}$$
+- **Priority Rank**: Calculated via $\text{Impact} / \max(\text{Effort}, 1)$ to prioritize high-impact, low-effort wins.
+
+---
+
+## 🧪 Automated Testing
+
+Run the included unit test suite:
+```bash
+python -m unittest discover -s tests -p "test_*.py" -v
+```

performance_optimizer-2.5.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+optimizer.py,sha256=jYzzYY2gHi9KJZz8imEemfXB9-c9DGrgggYrVk0Oq8s,15309
+analyzers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+analyzers/angular_analyzer.py,sha256=UvkfTo3TZLPr7VseslcwP3qDxqt_v-n6a37xe8HxHko,23901
+analyzers/aws_analyzer.py,sha256=sEyCWv3p36deftVe2wgxNILXAt3mtV4zkUoiFTpECQ8,6670
+analyzers/node_analyzer.py,sha256=AEQKtI0g_YxWsV9r4HgJdbBYKOv0FNl9g8xqli2nWfY,18093
+analyzers/react_analyzer.py,sha256=PlAhlDqUllVLOgnN1CVVHtRWgbOofUrq22ACh1jd0Ao,13332
+analyzers/sql_analyzer.py,sha256=FExpp-9OA2FaajmwzHIh-JlP85tM9NsxZiLtEcBRR9k,10205
+core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/issue.py,sha256=snKmRSeNZb_wLX8uAdJ3ntMAjAKcABuVisbuxegvC1Q,1893
+core/scorer.py,sha256=zLGzxBkCxE3mz9J1_h6mk41Yc1UxTxyizSow5IVjoQw,3821
+performance_optimizer-2.5.0.dist-info/licenses/LICENSE,sha256=-mOdQJ_EYbSVRnT-XOh0MmAbdBFoH2w8_llqcxHs57k,1079
+reporter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reporter/html_reporter.py,sha256=i0MT232a4RC0I027XPNe6wI8Q7MD9s7dkZBkDclWeUs,51997
+performance_optimizer-2.5.0.dist-info/METADATA,sha256=tgUb9YgwuMxrPH-sonB8TXWm1RzNqAF-54QkO2KqWNM,11735
+performance_optimizer-2.5.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+performance_optimizer-2.5.0.dist-info/entry_points.txt,sha256=_pux5PibB9PvVJgNwAYOf0JlEV_SIRJLxdk57cg-gC8,89
+performance_optimizer-2.5.0.dist-info/top_level.txt,sha256=GlwwpDftYMHkQlHF0kBSvUXtJFaARCBoPn_kCwyMEss,34
+performance_optimizer-2.5.0.dist-info/RECORD,,

performance_optimizer-2.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

performance_optimizer-2.5.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+perf-optimizer = optimizer:main
+performance-optimizer = optimizer:main

performance_optimizer-2.5.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ravi Kumar Vishwakarma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

performance_optimizer-2.5.0.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+analyzers
+core
+optimizer
+reporter