performance-optimizer 2.5.0__py3-none-any.whl

analyzers/sql_analyzer.py

@@ -0,0 +1,184 @@
+import os
+import re
+from pathlib import Path
+from typing import List, Tuple
+from core.issue import Issue, Severity, Layer
+
+class SqlAnalyzer:
+    def __init__(self, path: str):
+        self.path = Path(path)
+        self.issues: List[Issue] = []
+
+    def analyze(self) -> List[Issue]:
+        # Scan dedicated .sql files
+        for f in self.path.rglob('*.sql'):
+            if any(x in str(f) for x in ['node_modules', 'dist/', '.git']):
+                continue
+            try:
+                src = f.read_text(encoding='utf-8', errors='ignore')
+                rel = str(f.relative_to(self.path)).replace('\\', '/')
+                lines = src.splitlines()
+                self._check_sql_file(src, lines, rel)
+            except Exception:
+                pass
+
+        # Scan .js and .ts files for inline SQL strings
+        for f in list(self.path.rglob('*.js')) + list(self.path.rglob('*.ts')):
+            if any(x in str(f) for x in ['node_modules', 'dist/', '.spec.', '.d.ts', '.git']):
+                continue
+            try:
+                src = f.read_text(encoding='utf-8', errors='ignore')
+                rel = str(f.relative_to(self.path)).replace('\\', '/')
+                lines = src.splitlines()
+                self._check_inline_sql(src, lines, rel)
+            except Exception:
+                pass
+
+        return self.issues
+
+    def _is_suppressed(self, lines: List[str], line_idx: int, rule_id: str) -> bool:
+        check_lines = []
+        if 0 <= line_idx < len(lines):
+            check_lines.append(lines[line_idx])
+        if 0 <= line_idx - 1 < len(lines):
+            check_lines.append(lines[line_idx - 1])
+        for cl in check_lines:
+            if f'perf-ignore {rule_id}' in cl or 'perf-ignore-all' in cl:
+                return True
+        return False
+
+    def _find_line(self, lines: List[str], regex_or_str) -> Tuple[int, str]:
+        for idx, line in enumerate(lines, 1):
+            if isinstance(regex_or_str, str) and regex_or_str.lower() in line.lower():
+                return idx, line.strip()
+            elif hasattr(regex_or_str, 'search') and regex_or_str.search(line):
+                return idx, line.strip()
+        return 1, (lines[0].strip() if lines else '')
+
+    def _check_sql_file(self, src: str, lines: List[str], rel: str):
+        # SQL001: SELECT * Usage
+        select_star_count = len(re.findall(r'SELECT\s+\*\s+FROM', src, re.IGNORECASE))
+        if select_star_count > 0:
+            line_no, snippet = self._find_line(lines, re.compile(r'SELECT\s+\*\s+FROM', re.IGNORECASE))
+            if not self._is_suppressed(lines, line_no - 1, 'SQL001'):
+                self.issues.append(Issue(
+                    id='SQL001',
+                    title=f'SELECT * Over-fetching ({select_star_count} occurrences)',
+                    description='Fetching all table columns with SELECT * wastes database memory, network bandwidth, and prevents index-only query execution plans.',
+                    fix='Explicitly enumerate the necessary columns: `SELECT id, name, status FROM table`.',
+                    code_before='SELECT * FROM orders WHERE user_id = ?;',
+                    code_after='SELECT id, total_amount, status, created_at FROM orders WHERE user_id = ?;',
+                    file=rel,
+                    line_number=line_no,
+                    code_snippet=snippet,
+                    category='Database I/O',
+                    severity=Severity.HIGH,
+                    layer=Layer.DATABASE,
+                    impact=7,
+                    effort=2,
+                    occurrences=select_star_count,
+                    perf_gain='Reduces row serialization size and network transfer'
+                ))
+
+        # SQL004: Missing indexes on foreign keys
+        table_defs = re.finditer(r'CREATE\s+TABLE\s+(\w+)\s*\(([^;]+)\)', src, re.IGNORECASE | re.DOTALL)
+        for tbl in table_defs:
+            tname = tbl.group(1)
+            tbody = tbl.group(2)
+            has_fk = re.search(r'(\w+_id|\w+_fk)\s+INT', tbody, re.IGNORECASE) or 'FOREIGN KEY' in tbody.upper()
+            has_idx = any(idx_kw in tbody.upper() for idx_kw in ['INDEX', 'KEY ', 'UNIQUE'])
+            if has_fk and not has_idx:
+                line_no, snippet = self._find_line(lines, re.compile(rf'CREATE\s+TABLE\s+{tname}', re.IGNORECASE))
+                if not self._is_suppressed(lines, line_no - 1, 'SQL004'):
+                    self.issues.append(Issue(
+                        id='SQL004',
+                        title=f'Missing Foreign Key Index on Table `{tname}`',
+                        description=f'Table `{tname}` defines relationship foreign keys without explicit B-Tree indexes. Queries using JOIN or WHERE on foreign keys will execute full table scans.',
+                        fix=f'Add B-Tree indexes to foreign key columns: `INDEX idx_{tname.lower()}_fk (user_id)`.',
+                        code_before=f'CREATE TABLE {tname} (\n  id INT PRIMARY KEY,\n  user_id INT -- No index: causes O(N) table scans\n);',
+                        code_after=f'CREATE TABLE {tname} (\n  id INT PRIMARY KEY,\n  user_id INT,\n  INDEX idx_{tname.lower()}_user (user_id)\n);',
+                        file=rel,
+                        line_number=line_no,
+                        code_snippet=snippet,
+                        category='Indexing & Optimization',
+                        severity=Severity.CRITICAL,
+                        layer=Layer.DATABASE,
+                        impact=9,
+                        effort=2,
+                        occurrences=1,
+                        perf_gain='Converts O(N) table scans into O(log N) B-Tree seeks'
+                    ))
+
+        # SQL007: Deep OFFSET pagination antipattern
+        if re.search(r'OFFSET\s+[1-9]\d{3,}', src, re.IGNORECASE):
+            line_no, snippet = self._find_line(lines, re.compile(r'OFFSET\s+[1-9]\d{3,}', re.IGNORECASE))
+            if not self._is_suppressed(lines, line_no - 1, 'SQL007'):
+                self.issues.append(Issue(
+                    id='SQL007',
+                    title='Deep OFFSET Pagination Antipattern (O(N) Discard Waste)',
+                    description='High OFFSET values force the database engine to fetch and discard thousands of rows before returning the requested slice. Response latency degrades proportionally with page depth.',
+                    fix='Use keyset / cursor-based pagination: `WHERE id > :last_id ORDER BY id LIMIT 50`.',
+                    code_before='SELECT id, name FROM orders ORDER BY id LIMIT 50 OFFSET 10000;',
+                    code_after='SELECT id, name FROM orders WHERE id > :cursor ORDER BY id LIMIT 50;',
+                    file=rel,
+                    line_number=line_no,
+                    code_snippet=snippet,
+                    category='Query Performance',
+                    severity=Severity.HIGH,
+                    layer=Layer.DATABASE,
+                    impact=8,
+                    effort=3,
+                    occurrences=1,
+                    perf_gain='Constant O(1) query time regardless of pagination depth'
+                ))
+
+    def _check_inline_sql(self, src: str, lines: List[str], rel: str):
+        # SQL005: String concatenation in SQL queries
+        concat_matches = re.finditer(r'[`\'"](SELECT[^`\'"]+)[`\'"]\s*\+', src, re.IGNORECASE)
+        for m in concat_matches:
+            matched_text = m.group(0)
+            line_no, snippet = self._find_line(lines, matched_text[:20])
+            if not self._is_suppressed(lines, line_no - 1, 'SQL005'):
+                self.issues.append(Issue(
+                    id='SQL005',
+                    title='SQL Built via String Concatenation (Disables Execution Plan Cache)',
+                    description='Dynamic string concatenation generates a unique SQL text for every argument, preventing the database from reusing compiled execution plans. Also opens SQL injection risk.',
+                    fix='Use parameterized queries with `?` or `$1` placeholders so execution plans are cached.',
+                    code_before='const sql = "SELECT * FROM users WHERE status = \'" + status + "\'";',
+                    code_after='const sql = "SELECT id, name, status FROM users WHERE status = ?";\nawait db.query(sql, [status]);',
+                    file=rel,
+                    line_number=line_no,
+                    code_snippet=snippet,
+                    category='Execution Plan Cache',
+                    severity=Severity.HIGH,
+                    layer=Layer.DATABASE,
+                    impact=8,
+                    effort=2,
+                    occurrences=1,
+                    perf_gain='Enables query plan caching and eliminates SQL injection'
+                ))
+                break
+
+        # SQL006: LIKE with leading wildcard
+        leading_like = re.search(r"LIKE\s+['\"]%[^'\"]+['\"]", src, re.IGNORECASE)
+        if leading_like:
+            line_no, snippet = self._find_line(lines, re.compile(r"LIKE\s+['\"]%", re.IGNORECASE))
+            if not self._is_suppressed(lines, line_no - 1, 'SQL006'):
+                self.issues.append(Issue(
+                    id='SQL006',
+                    title='SQL LIKE Query with Leading Wildcard (%query)',
+                    description='A leading wildcard pattern like `LIKE "%keyword"` prevents the database engine from using B-Tree indexes, triggering a full table scan across all rows.',
+                    fix='Use trailing wildcard `LIKE "keyword%"` or implement Full-Text Search (FTS) / trigram indexing.',
+                    code_before='SELECT id, title FROM articles WHERE title LIKE "%performance%";',
+                    code_after='-- Use Full-Text index:\nSELECT id, title FROM articles WHERE MATCH(title) AGAINST(? IN NATURAL LANGUAGE MODE);',
+                    file=rel,
+                    line_number=line_no,
+                    code_snippet=snippet,
+                    category='Indexing & Search',
+                    severity=Severity.MEDIUM,
+                    layer=Layer.DATABASE,
+                    impact=7,
+                    effort=3,
+                    occurrences=1,
+                    perf_gain='Avoids full table scan on text searches'
+                ))

core/issue.py

@@ -0,0 +1,67 @@
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+
+class Severity(Enum):
+    CRITICAL = 'critical'
+    HIGH     = 'high'
+    MEDIUM   = 'medium'
+    LOW      = 'low'
+
+class Layer(Enum):
+    FRONTEND    = 'frontend'
+    BACKEND     = 'backend'
+    DATABASE    = 'database'
+    INFRA       = 'infra'
+
+@dataclass
+class Issue:
+    id: str
+    title: str
+    description: str
+    fix: str
+    code_before: str
+    code_after: str
+    file: str
+    severity: Severity
+    layer: Layer
+    impact: int        # 1-10
+    effort: int        # 1-10
+    occurrences: int
+    perf_gain: str
+    line_number: Optional[int] = None
+    code_snippet: Optional[str] = None
+    category: str = 'Performance'
+    doc_url: Optional[str] = None
+
+    @property
+    def priority_score(self) -> float:
+        """Higher = fix first. Impact/Effort ratio."""
+        return round(self.impact / max(self.effort, 1), 2)
+
+    @property
+    def severity_order(self) -> int:
+        order = {Severity.CRITICAL: 0, Severity.HIGH: 1, Severity.MEDIUM: 2, Severity.LOW: 3}
+        return order.get(self.severity, 3)
+
+    def to_dict(self) -> dict:
+        return {
+            'id': self.id,
+            'title': self.title,
+            'description': self.description,
+            'fix': self.fix,
+            'code_before': self.code_before,
+            'code_after': self.code_after,
+            'file': self.file,
+            'line_number': self.line_number,
+            'code_snippet': self.code_snippet,
+            'category': self.category,
+            'doc_url': self.doc_url,
+            'severity': self.severity.value,
+            'layer': self.layer.value,
+            'impact': self.impact,
+            'effort': self.effort,
+            'occurrences': self.occurrences,
+            'perf_gain': self.perf_gain,
+            'priority_score': self.priority_score,
+        }

core/scorer.py

@@ -0,0 +1,94 @@
+import math
+from typing import List, Dict, Any
+from core.issue import Issue, Severity, Layer
+
+class Scorer:
+    def compute(self, issues: List[Issue]) -> Dict[str, Any]:
+        severity_weights = {
+            Severity.CRITICAL: 22,
+            Severity.HIGH: 12,
+            Severity.MEDIUM: 5,
+            Severity.LOW: 2
+        }
+
+        def compute_layer_score(layer: Layer) -> int:
+            sub = [i for i in issues if i.layer == layer]
+            if not sub:
+                return 100
+            # Diminishing returns penalty calculation
+            raw_penalty = sum(severity_weights.get(i.severity, 2) * min(max(i.occurrences, 1), 5) for i in sub)
+            # Smooth asymptotic curve: 100 / (1 + (penalty / 38)^1.15)
+            damped_score = 100.0 / (1.0 + (raw_penalty / 38.0) ** 1.15)
+            return max(5, min(100, round(damped_score)))
+
+        frontend_score = compute_layer_score(Layer.FRONTEND)
+        backend_score  = compute_layer_score(Layer.BACKEND)
+        db_score       = compute_layer_score(Layer.DATABASE)
+        infra_score    = compute_layer_score(Layer.INFRA)
+
+        overall = round(
+            frontend_score * 0.40 +
+            backend_score  * 0.30 +
+            db_score       * 0.20 +
+            infra_score    * 0.10
+        )
+
+        by_sev = {s.value: 0 for s in Severity}
+        by_layer = {l.value: 0 for l in Layer}
+        for i in issues:
+            by_sev[i.severity.value] += 1
+            by_layer[i.layer.value]  += 1
+
+        # File breakdown
+        file_issues: Dict[str, List[Issue]] = {}
+        for i in issues:
+            file_issues.setdefault(i.file, []).append(i)
+
+        worst_files = sorted(file_issues.items(), key=lambda x: (
+            -sum(severity_weights.get(ii.severity, 2) for ii in x[1])
+        ))[:10]
+
+        file_scores = []
+        for fp, fi in worst_files:
+            file_raw = sum(severity_weights.get(ii.severity, 2) for ii in fi)
+            f_score = max(5, min(100, round(100.0 / (1.0 + (file_raw / 28.0) ** 1.15))))
+            file_scores.append({
+                'file': fp,
+                'issues': len(fi),
+                'score': f_score,
+                'critical': sum(1 for ii in fi if ii.severity == Severity.CRITICAL),
+                'high': sum(1 for ii in fi if ii.severity == Severity.HIGH),
+                'medium': sum(1 for ii in fi if ii.severity == Severity.MEDIUM),
+                'low': sum(1 for ii in fi if ii.severity == Severity.LOW)
+            })
+
+        # Top issues sorted by priority_score (Impact/Effort) and severity
+        sorted_issues = sorted(issues, key=lambda i: (i.severity_order, -i.priority_score))
+        top3 = sorted_issues[:3]
+
+        # Projected impact calculations
+        has_dom_issues = any(i.id in ['ANG001', 'ANG003', 'ANG009', 'ANG010'] for i in issues)
+        has_db_loop = any(i.id in ['NODE004', 'SQL004', 'SQL003', 'NODE005'] for i in issues)
+        mem_leak_count = sum(1 for i in issues if i.id in ['ANG004', 'NODE009', 'NODE011'])
+        bundle_reduction = sum(45 if i.id == 'ANG013' else 25 if i.id == 'ANG012' else 0 for i in issues)
+
+        metrics = {
+            'dom_render_waste_pct': 65 if has_dom_issues else 0,
+            'db_query_reduction_pct': 85 if has_db_loop else 0,
+            'memory_leak_count': mem_leak_count,
+            'bundle_reduction_kb': bundle_reduction,
+        }
+
+        return {
+            'overall': overall,
+            'frontend': frontend_score,
+            'backend':  backend_score,
+            'database': db_score,
+            'infra':    infra_score,
+            'by_severity': by_sev,
+            'by_layer': by_layer,
+            'total_issues': len(issues),
+            'top3': [i.to_dict() for i in top3],
+            'worst_files': file_scores,
+            'metrics': metrics,
+        }