bps-kit 1.0.1 → 1.0.2

package/templates/vault/matematico-tao/scripts/complexity_analyzer.py

@@ -0,0 +1,544 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Prof. Euler — Complexity Analyzer
+Análise automática de complexidade ciclomática, cognitiva e acoplamento
+para projetos Kotlin/Android.
+
+Uso:
+  python complexity_analyzer.py [path] [--module MODULE] [--threshold N]
+  python complexity_analyzer.py C:/Users/renat/earbudllm
+  python complexity_analyzer.py C:/Users/renat/earbudllm --module llm --threshold 10
+"""
+
+import os
+import re
+import sys
+import json
+import argparse
+from pathlib import Path
+
+# Fix Unicode output on Windows (cp1252 terminal)
+if sys.platform == 'win32':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+        sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+    except AttributeError:
+        pass  # Python < 3.7 fallback
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Tuple
+from collections import defaultdict
+
+
+@dataclass
+class FunctionMetrics:
+    name: str
+    file: str
+    line: int
+    cyclomatic: int
+    cognitive: int
+    lines: int
+    parameters: int
+    nullable_params: int
+    has_try_catch: bool
+    coroutine: bool  # is suspend fun
+
+
+@dataclass
+class FileMetrics:
+    path: str
+    module: str
+    functions: List[FunctionMetrics] = field(default_factory=list)
+    imports: List[str] = field(default_factory=list)
+    total_lines: int = 0
+    blank_lines: int = 0
+    comment_lines: int = 0
+
+    @property
+    def code_lines(self):
+        return self.total_lines - self.blank_lines - self.comment_lines
+
+    @property
+    def max_cyclomatic(self):
+        return max((f.cyclomatic for f in self.functions), default=0)
+
+    @property
+    def avg_cyclomatic(self):
+        if not self.functions:
+            return 0.0
+        return sum(f.cyclomatic for f in self.functions) / len(self.functions)
+
+    @property
+    def max_cognitive(self):
+        return max((f.cognitive for f in self.functions), default=0)
+
+
+@dataclass
+class ModuleCoupling:
+    module: str
+    efferent: List[str] = field(default_factory=list)  # Ce: modules this depends on
+    afferent: List[str] = field(default_factory=list)   # Ca: modules that depend on this
+
+    @property
+    def instability(self) -> float:
+        ca = len(self.afferent)
+        ce = len(self.efferent)
+        if ca + ce == 0:
+            return 0.0
+        return ce / (ca + ce)
+
+
+class KotlinComplexityAnalyzer:
+    """Analisa complexidade de código Kotlin com rigor matemático."""
+
+    # Tokens que incrementam complexidade ciclomática
+    CYCLOMATIC_TOKENS = [
+        r'\bif\b', r'\belse if\b', r'\bwhen\b', r'\bfor\b', r'\bwhile\b',
+        r'\bdo\b', r'\btry\b', r'\bcatch\b', r'\band\b', r'\bor\b',
+        r'\?\?', r'\?\.',  # Elvis operator e safe call
+        r'&&', r'\|\|',
+    ]
+
+    # Tokens de quebra de fluxo (aumentam complexidade cognitiva mais que cicl.)
+    COGNITIVE_BREAK_TOKENS = [
+        r'\bbreak\b', r'\bcontinue\b', r'\breturn\b(?!\s+\w+\s*$)',  # return no meio
+        r'\bthrow\b',
+    ]
+
+    def __init__(self, project_root: str, threshold: int = 10):
+        self.project_root = Path(project_root)
+        self.threshold = threshold
+        self.metrics: List[FileMetrics] = []
+
+    def analyze(self, module_filter: Optional[str] = None) -> None:
+        """Analisa todos os arquivos Kotlin no projeto."""
+        pattern = "**/*.kt"
+        kt_files = list(self.project_root.glob(pattern))
+
+        for kt_file in kt_files:
+            # Filtra arquivos de teste se não especificado
+            if 'test' in kt_file.parts and module_filter is None:
+                continue
+
+            # Filtro de módulo
+            module = self._detect_module(kt_file)
+            if module_filter and module != module_filter:
+                continue
+
+            metrics = self._analyze_file(kt_file, module)
+            self.metrics.append(metrics)
+
+    def _detect_module(self, file_path: Path) -> str:
+        """Detecta qual módulo um arquivo pertence."""
+        parts = file_path.parts
+        known_modules = ['app', 'bluetooth', 'audio', 'voice', 'llm',
+                         'integrations', 'core-logging']
+        for part in parts:
+            if part in known_modules:
+                return part
+        return 'unknown'
+
+    def _analyze_file(self, file_path: Path, module: str) -> FileMetrics:
+        """Analisa um arquivo Kotlin."""
+        try:
+            content = file_path.read_text(encoding='utf-8', errors='ignore')
+        except Exception:
+            return FileMetrics(str(file_path), module)
+
+        lines = content.split('\n')
+        metrics = FileMetrics(
+            path=str(file_path.relative_to(self.project_root)),
+            module=module,
+            total_lines=len(lines)
+        )
+
+        # Contar linhas
+        for line in lines:
+            stripped = line.strip()
+            if not stripped:
+                metrics.blank_lines += 1
+            elif stripped.startswith('//') or stripped.startswith('*') or stripped.startswith('/*'):
+                metrics.comment_lines += 1
+
+        # Extrair imports
+        metrics.imports = re.findall(r'^import\s+(.+)$', content, re.MULTILINE)
+
+        # Analisar funções
+        metrics.functions = self._extract_functions(content, str(file_path))
+
+        return metrics
+
+    def _extract_functions(self, content: str, filepath: str) -> List[FunctionMetrics]:
+        """Extrai e analisa todas as funções do arquivo."""
+        functions = []
+        lines = content.split('\n')
+
+        # Pattern para declarações de função Kotlin
+        fun_pattern = re.compile(
+            r'^(\s*)((?:suspend\s+)?(?:private\s+|protected\s+|internal\s+|public\s+)?'
+            r'(?:override\s+)?(?:suspend\s+)?fun\s+(\w+)\s*\(([^)]*)\))',
+            re.MULTILINE
+        )
+
+        for match in fun_pattern.finditer(content):
+            fun_name = match.group(3)
+            params_str = match.group(4)
+            is_suspend = 'suspend' in match.group(2)
+            line_num = content[:match.start()].count('\n') + 1
+
+            # Extrair corpo da função
+            body = self._extract_function_body(content, match.end())
+            if not body:
+                continue
+
+            # Calcular métricas
+            cc = self._cyclomatic_complexity(body)
+            cog = self._cognitive_complexity(body)
+            params = self._count_parameters(params_str)
+            nullable = self._count_nullable_params(params_str)
+            has_try = bool(re.search(r'\btry\b', body))
+
+            functions.append(FunctionMetrics(
+                name=fun_name,
+                file=filepath,
+                line=line_num,
+                cyclomatic=cc,
+                cognitive=cog,
+                lines=body.count('\n'),
+                parameters=params,
+                nullable_params=nullable,
+                has_try_catch=has_try,
+                coroutine=is_suspend
+            ))
+
+        return functions
+
+    def _extract_function_body(self, content: str, start: int) -> str:
+        """Extrai o corpo de uma função por contagem de chaves."""
+        i = start
+        depth = 0
+        started = False
+
+        while i < len(content):
+            c = content[i]
+            if c == '{':
+                depth += 1
+                started = True
+            elif c == '}':
+                depth -= 1
+                if started and depth == 0:
+                    return content[start:i+1]
+            i += 1
+
+        return content[start:min(start + 500, len(content))]
+
+    def _cyclomatic_complexity(self, code: str) -> int:
+        """Calcula CC de McCabe."""
+        cc = 1  # Base
+        for pattern in self.CYCLOMATIC_TOKENS:
+            matches = re.findall(pattern, code)
+            cc += len(matches)
+        return cc
+
+    def _cognitive_complexity(self, code: str) -> int:
+        """Calcula complexidade cognitiva (aproximação)."""
+        cog = 0
+        nesting = 0
+        lines = code.split('\n')
+
+        for line in lines:
+            stripped = line.strip()
+
+            # Aumenta nesting
+            if re.search(r'\b(if|when|for|while|try)\b', stripped):
+                cog += (1 + nesting)
+                nesting += 1
+
+            # Fecha nesting
+            elif stripped == '}':
+                nesting = max(0, nesting - 1)
+
+            # Breaks de fluxo
+            for pattern in self.COGNITIVE_BREAK_TOKENS:
+                if re.search(pattern, stripped):
+                    cog += 1
+
+        return cog
+
+    def _count_parameters(self, params_str: str) -> int:
+        """Conta parâmetros de uma função."""
+        if not params_str.strip():
+            return 0
+        return len([p for p in params_str.split(',') if p.strip()])
+
+    def _count_nullable_params(self, params_str: str) -> int:
+        """Conta parâmetros nullable (tipo?)."""
+        return len(re.findall(r'\w+\?', params_str))
+
+    def analyze_coupling(self) -> Dict[str, ModuleCoupling]:
+        """Analisa acoplamento entre módulos."""
+        module_imports: Dict[str, set] = defaultdict(set)
+
+        for file_metrics in self.metrics:
+            for imp in file_metrics.imports:
+                # Detecta qual módulo está sendo importado
+                for mod in ['bluetooth', 'audio', 'voice', 'llm', 'integrations', 'core.logging']:
+                    if mod in imp:
+                        module_imports[file_metrics.module].add(mod.replace('.', '-'))
+
+        coupling = {}
+        all_modules = set(m.module for m in self.metrics)
+
+        for mod in all_modules:
+            c = ModuleCoupling(module=mod)
+            c.efferent = list(module_imports.get(mod, set()))
+            for other_mod, deps in module_imports.items():
+                if mod.replace('-', '.') in deps or mod in deps:
+                    c.afferent.append(other_mod)
+            coupling[mod] = c
+
+        return coupling
+
+    def generate_report(self) -> Dict:
+        """Gera relatório completo com análise matemática."""
+        # Funções problemáticas
+        high_cc = []
+        high_cognitive = []
+        too_long = []
+        too_many_params = []
+        unsafe_nullable = []
+        coroutine_issues = []
+
+        for file_m in self.metrics:
+            for func in file_m.functions:
+                if func.cyclomatic > self.threshold:
+                    high_cc.append({
+                        'function': func.name,
+                        'file': file_m.path,
+                        'line': func.line,
+                        'cc': func.cyclomatic,
+                        'risk': self._cc_risk_label(func.cyclomatic)
+                    })
+
+                if func.cognitive > self.threshold * 1.5:
+                    high_cognitive.append({
+                        'function': func.name,
+                        'file': file_m.path,
+                        'line': func.line,
+                        'cognitive': func.cognitive
+                    })
+
+                if func.lines > 50:
+                    too_long.append({
+                        'function': func.name,
+                        'file': file_m.path,
+                        'line': func.line,
+                        'lines': func.lines
+                    })
+
+                if func.parameters > 5:
+                    too_many_params.append({
+                        'function': func.name,
+                        'file': file_m.path,
+                        'params': func.parameters
+                    })
+
+                if func.nullable_params > 2:
+                    unsafe_nullable.append({
+                        'function': func.name,
+                        'file': file_m.path,
+                        'nullable_params': func.nullable_params
+                    })
+
+                if func.coroutine and func.has_try_catch:
+                    coroutine_issues.append({
+                        'function': func.name,
+                        'file': file_m.path,
+                        'note': 'suspend fun with try-catch: verify structured concurrency'
+                    })
+
+        # Ordenar por severidade
+        high_cc.sort(key=lambda x: x['cc'], reverse=True)
+
+        # Módulos com maior complexidade
+        module_stats = defaultdict(lambda: {'total_cc': 0, 'max_cc': 0, 'functions': 0, 'files': 0})
+        for file_m in self.metrics:
+            mod = file_m.module
+            module_stats[mod]['files'] += 1
+            module_stats[mod]['functions'] += len(file_m.functions)
+            for f in file_m.functions:
+                module_stats[mod]['total_cc'] += f.cyclomatic
+                module_stats[mod]['max_cc'] = max(module_stats[mod]['max_cc'], f.cyclomatic)
+
+        # Calcular média CC por módulo
+        for mod, stats in module_stats.items():
+            if stats['functions'] > 0:
+                stats['avg_cc'] = round(stats['total_cc'] / stats['functions'], 2)
+            else:
+                stats['avg_cc'] = 0
+
+        coupling = self.analyze_coupling()
+        coupling_data = {}
+        for mod, c in coupling.items():
+            coupling_data[mod] = {
+                'Ca': len(c.afferent),
+                'Ce': len(c.efferent),
+                'instability': round(c.instability, 3),
+                'depends_on': c.efferent,
+                'depended_by': c.afferent
+            }
+
+        return {
+            'summary': {
+                'total_files': len(self.metrics),
+                'total_functions': sum(len(f.functions) for f in self.metrics),
+                'total_code_lines': sum(f.code_lines for f in self.metrics),
+                'high_cc_functions': len(high_cc),
+                'high_cognitive_functions': len(high_cognitive),
+            },
+            'high_cyclomatic_complexity': high_cc[:20],  # top 20
+            'high_cognitive_complexity': high_cognitive[:10],
+            'overly_long_functions': too_long[:10],
+            'too_many_parameters': too_many_params[:10],
+            'nullable_risks': unsafe_nullable[:10],
+            'coroutine_issues': coroutine_issues[:10],
+            'module_statistics': dict(module_stats),
+            'module_coupling': coupling_data,
+        }
+
+    def _cc_risk_label(self, cc: int) -> str:
+        if cc <= 5:
+            return "LOW"
+        elif cc <= 10:
+            return "MODERATE"
+        elif cc <= 20:
+            return "HIGH — refactor recommended"
+        else:
+            return "CRITICAL — must refactor"
+
+    def print_report(self, report: Dict) -> None:
+        """Imprime relatório formatado."""
+        print("\n" + "="*70)
+        print("  PROF. EULER — ANÁLISE DE COMPLEXIDADE MATEMÁTICA")
+        print("="*70)
+
+        s = report['summary']
+        print(f"\n📊 RESUMO:")
+        print(f"  Arquivos analisados:    {s['total_files']}")
+        print(f"  Funções analisadas:     {s['total_functions']}")
+        print(f"  Linhas de código:       {s['total_code_lines']}")
+        print(f"  Funções alta CC:        {s['high_cc_functions']} (threshold={self.threshold})")
+        print(f"  Funções alta cognitiva: {s['high_cognitive_functions']}")
+
+        if report['high_cyclomatic_complexity']:
+            print(f"\n⚠️  TOP FUNÇÕES POR COMPLEXIDADE CICLOMÁTICA:")
+            print(f"  {'Função':<35} {'CC':>5}  {'Arquivo':<40} Risco")
+            print(f"  {'-'*35} {'-'*5}  {'-'*40} {'-'*25}")
+            for item in report['high_cyclomatic_complexity'][:10]:
+                fname = item['function'][:34]
+                ffile = item['file'][:39]
+                print(f"  {fname:<35} {item['cc']:>5}  {ffile:<40} {item['risk']}")
+
+        if report['module_statistics']:
+            print(f"\n📦 ESTATÍSTICAS POR MÓDULO:")
+            print(f"  {'Módulo':<20} {'Arquivos':>8} {'Funções':>8} {'CC Médio':>10} {'CC Máximo':>10} {'Instabilidade':>14}")
+            print(f"  {'-'*20} {'-'*8} {'-'*8} {'-'*10} {'-'*10} {'-'*14}")
+            coupling = report['module_coupling']
+            for mod, stats in sorted(report['module_statistics'].items()):
+                inst = coupling.get(mod, {}).get('instability', 'N/A')
+                inst_str = f"{inst:.3f}" if isinstance(inst, float) else inst
+                print(f"  {mod:<20} {stats['files']:>8} {stats['functions']:>8} "
+                      f"{stats['avg_cc']:>10.2f} {stats['max_cc']:>10} {inst_str:>14}")
+
+        if report['coroutine_issues']:
+            print(f"\n🔄 PROBLEMAS POTENCIAIS EM COROUTINES:")
+            for item in report['coroutine_issues'][:5]:
+                print(f"  ⚠️  {item['function']} ({item['file']})")
+                print(f"     → {item['note']}")
+
+        if report['nullable_risks']:
+            print(f"\n❓ NULLABLE RISKS (muitos parâmetros nullable):")
+            for item in report['nullable_risks'][:5]:
+                print(f"  {item['function']}: {item['nullable_params']} nullable params ({item['file']})")
+
+        print("\n" + "="*70)
+        print("  Análise matemática completa. Consulte Prof. Euler para interpretação.")
+        print("="*70 + "\n")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Prof. Euler — Análise de Complexidade Matemática para Kotlin/Android'
+    )
+    parser.add_argument('path', nargs='?',
+                        default=r'C:\Users\renat\earbudllm',
+                        help='Caminho raiz do projeto')
+    parser.add_argument('--module', '-m', help='Analisar apenas este módulo')
+    parser.add_argument('--threshold', '-t', type=int, default=10,
+                        help='Threshold de complexidade ciclomática (default: 10)')
+    parser.add_argument('--json', '-j', action='store_true',
+                        help='Saída em formato JSON')
+    parser.add_argument('--output', '-o', help='Salvar relatório em arquivo')
+
+    args = parser.parse_args()
+
+    print(f"🔬 Prof. Euler analisando: {args.path}")
+    if args.module:
+        print(f"   Módulo: {args.module}")
+
+    analyzer = KotlinComplexityAnalyzer(args.path, threshold=args.threshold)
+    analyzer.analyze(module_filter=args.module)
+
+    report = analyzer.generate_report()
+
+    if args.json:
+        output = json.dumps(report, indent=2, ensure_ascii=False)
+        print(output)
+    else:
+        analyzer.print_report(report)
+
+    if args.output:
+        output_path = Path(args.output)
+        if args.json:
+            output_path.write_text(json.dumps(report, indent=2, ensure_ascii=False))
+        else:
+            # Salvar como markdown
+            save_as_markdown(report, output_path, args.threshold)
+        print(f"✅ Relatório salvo em: {args.output}")
+
+    return report
+
+
+def save_as_markdown(report: Dict, path: Path, threshold: int) -> None:
+    """Salva relatório em formato Markdown."""
+    lines = [
+        "# Prof. Euler — Relatório de Complexidade Matemática\n",
+        f"Threshold CC: {threshold}\n\n",
+        "## Resumo\n",
+        f"- **Arquivos**: {report['summary']['total_files']}\n",
+        f"- **Funções**: {report['summary']['total_functions']}\n",
+        f"- **Linhas de código**: {report['summary']['total_code_lines']}\n",
+        f"- **Alta CC**: {report['summary']['high_cc_functions']}\n\n",
+        "## Funções de Alta Complexidade Ciclomática\n",
+        "| Função | CC | Arquivo | Risco |\n",
+        "|--------|-----|---------|-------|\n",
+    ]
+    for item in report['high_cyclomatic_complexity'][:15]:
+        lines.append(
+            f"| `{item['function']}` | {item['cc']} | `{item['file']}` | {item['risk']} |\n"
+        )
+
+    lines.append("\n## Acoplamento de Módulos\n")
+    lines.append("| Módulo | Ca | Ce | Instabilidade | Depende de |\n")
+    lines.append("|--------|----|----|--------------|------------|\n")
+    for mod, data in sorted(report['module_coupling'].items()):
+        deps = ', '.join(data['depends_on']) or 'nenhum'
+        lines.append(
+            f"| {mod} | {data['Ca']} | {data['Ce']} | {data['instability']:.3f} | {deps} |\n"
+        )
+
+    path.write_text(''.join(lines), encoding='utf-8')
+
+
+if __name__ == '__main__':
+    main()