bps-kit 1.0.1 → 1.0.2

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

@@ -0,0 +1,538 @@
+#!/usr/bin/env python3
+"""
+Prof. Euler — Dependency Graph Analyzer
+Gera grafo de dependências de projetos Kotlin/Android com análise matemática
+de grafos: componentes, ciclos, centralidade, instabilidade.
+
+Uso:
+  python dependency_graph.py [path] [--format dot|json|text] [--output FILE]
+  python dependency_graph.py C:/Users/renat/earbudllm
+  python dependency_graph.py C:/Users/renat/earbudllm --format dot --output deps.dot
+"""
+
+import os
+import re
+import sys
+import json
+import argparse
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import Dict, List, Set, Optional, Tuple
+
+# Fix Windows terminal encoding (cp1252 doesn't support emojis/unicode)
+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 collections import defaultdict, deque
+
+
+@dataclass
+class Node:
+    id: str
+    module: str
+    package: str
+    kind: str  # 'class', 'interface', 'object', 'enum', 'data class'
+    is_abstract: bool = False
+    is_open: bool = False
+
+
+@dataclass
+class Edge:
+    src: str   # node id
+    dst: str   # node id
+    kind: str  # 'implements', 'extends', 'uses', 'imports', 'delegates_to'
+    weight: float = 1.0
+
+
+class DependencyGraph:
+    """Grafo de dependências com análise matemática completa."""
+
+    def __init__(self):
+        self.nodes: Dict[str, Node] = {}
+        self.edges: List[Edge] = []
+        self._adj: Dict[str, Set[str]] = defaultdict(set)    # adjacência direta
+        self._radj: Dict[str, Set[str]] = defaultdict(set)   # adjacência reversa
+
+    def add_node(self, node: Node) -> None:
+        self.nodes[node.id] = node
+
+    def add_edge(self, edge: Edge) -> None:
+        if edge.src != edge.dst:  # sem self-loops
+            self.edges.append(edge)
+            self._adj[edge.src].add(edge.dst)
+            self._radj[edge.dst].add(edge.src)
+
+    def successors(self, node_id: str) -> Set[str]:
+        return self._adj.get(node_id, set())
+
+    def predecessors(self, node_id: str) -> Set[str]:
+        return self._radj.get(node_id, set())
+
+    # ─── Algoritmos de Grafos ────────────────────────────────────────────────
+
+    def find_cycles(self) -> List[List[str]]:
+        """Detecta ciclos usando DFS com coloração (branco/cinza/preto)."""
+        WHITE, GRAY, BLACK = 0, 1, 2
+        color = {n: WHITE for n in self.nodes}
+        cycles = []
+        path = []
+
+        def dfs(node: str) -> None:
+            color[node] = GRAY
+            path.append(node)
+
+            for neighbor in self._adj.get(node, set()):
+                if neighbor not in self.nodes:
+                    continue
+                if color[neighbor] == GRAY:
+                    # Ciclo encontrado! Extrair o ciclo do path
+                    cycle_start = path.index(neighbor)
+                    cycle = path[cycle_start:] + [neighbor]
+                    cycles.append(cycle)
+                elif color[neighbor] == WHITE:
+                    dfs(neighbor)
+
+            path.pop()
+            color[node] = BLACK
+
+        for node in list(self.nodes.keys()):
+            if color[node] == WHITE:
+                dfs(node)
+
+        # Deduplicar ciclos
+        unique = []
+        seen = set()
+        for cycle in cycles:
+            key = frozenset(cycle)
+            if key not in seen:
+                seen.add(key)
+                unique.append(cycle)
+
+        return unique
+
+    def strongly_connected_components(self) -> List[List[str]]:
+        """Algoritmo de Kosaraju para SCCs."""
+        visited = set()
+        finish_order = []
+
+        def dfs1(node: str) -> None:
+            visited.add(node)
+            for neighbor in self._adj.get(node, set()):
+                if neighbor in self.nodes and neighbor not in visited:
+                    dfs1(neighbor)
+            finish_order.append(node)
+
+        def dfs2(node: str, component: List[str]) -> None:
+            visited.add(node)
+            component.append(node)
+            for neighbor in self._radj.get(node, set()):
+                if neighbor in self.nodes and neighbor not in visited:
+                    dfs2(neighbor, component)
+
+        # Fase 1: DFS no grafo original
+        for node in self.nodes:
+            if node not in visited:
+                dfs1(node)
+
+        # Fase 2: DFS no grafo transposto na ordem inversa de finalização
+        visited.clear()
+        sccs = []
+        for node in reversed(finish_order):
+            if node not in visited:
+                component = []
+                dfs2(node, component)
+                sccs.append(component)
+
+        return sccs
+
+    def topological_sort(self) -> Optional[List[str]]:
+        """Ordenação topológica (só válida se DAG)."""
+        in_degree = defaultdict(int)
+        for edge in self.edges:
+            if edge.src in self.nodes and edge.dst in self.nodes:
+                in_degree[edge.dst] += 1
+
+        queue = deque([n for n in self.nodes if in_degree[n] == 0])
+        result = []
+
+        while queue:
+            node = queue.popleft()
+            result.append(node)
+            for neighbor in self._adj.get(node, set()):
+                if neighbor in self.nodes:
+                    in_degree[neighbor] -= 1
+                    if in_degree[neighbor] == 0:
+                        queue.append(neighbor)
+
+        if len(result) == len(self.nodes):
+            return result
+        return None  # Há ciclos → não é DAG
+
+    def betweenness_centrality(self) -> Dict[str, float]:
+        """
+        Centralidade de betweenness: nós que fazem "ponte" entre outros.
+        Alto betweenness = single point of failure.
+
+        Algoritmo de Brandes: O(V·E)
+        """
+        betweenness = defaultdict(float)
+        nodes = list(self.nodes.keys())
+
+        for s in nodes:
+            # BFS para encontrar caminhos mais curtos de s para todos
+            stack = []
+            pred = defaultdict(list)
+            sigma = defaultdict(int)
+            sigma[s] = 1
+            dist = defaultdict(lambda: -1)
+            dist[s] = 0
+            queue = deque([s])
+
+            while queue:
+                v = queue.popleft()
+                stack.append(v)
+                for w in self._adj.get(v, set()):
+                    if w not in self.nodes:
+                        continue
+                    if dist[w] < 0:
+                        queue.append(w)
+                        dist[w] = dist[v] + 1
+                    if dist[w] == dist[v] + 1:
+                        sigma[w] += sigma[v]
+                        pred[w].append(v)
+
+            # Acumulação
+            delta = defaultdict(float)
+            while stack:
+                w = stack.pop()
+                for v in pred[w]:
+                    if sigma[w] > 0:
+                        delta[v] += (sigma[v] / sigma[w]) * (1 + delta[w])
+                if w != s:
+                    betweenness[w] += delta[w]
+
+        # Normalizar
+        n = len(nodes)
+        if n > 2:
+            factor = 2 / ((n - 1) * (n - 2))
+            for node in betweenness:
+                betweenness[node] *= factor
+
+        return dict(betweenness)
+
+    def page_rank(self, damping: float = 0.85, iterations: int = 100) -> Dict[str, float]:
+        """
+        PageRank para identificar classes/módulos mais "importantes".
+        Nodes com alto PageRank são frequentemente usados por outros.
+        """
+        n = len(self.nodes)
+        if n == 0:
+            return {}
+
+        rank = {node: 1.0 / n for node in self.nodes}
+
+        for _ in range(iterations):
+            new_rank = {}
+            for node in self.nodes:
+                incoming_sum = sum(
+                    rank.get(pred, 0) / max(len(self._adj.get(pred, set())), 1)
+                    for pred in self._radj.get(node, set())
+                    if pred in self.nodes
+                )
+                new_rank[node] = (1 - damping) / n + damping * incoming_sum
+            rank = new_rank
+
+        return rank
+
+    def coupling_metrics(self) -> Dict[str, Dict]:
+        """Calcula Ca, Ce, instabilidade e abstração por módulo."""
+        module_nodes: Dict[str, Set[str]] = defaultdict(set)
+        for node_id, node in self.nodes.items():
+            module_nodes[node.module].add(node_id)
+
+        metrics = {}
+        for module, nodes in module_nodes.items():
+            # Ce: dependências efetivas (de fora do módulo)
+            efferent = set()
+            for n in nodes:
+                for dep in self._adj.get(n, set()):
+                    if dep in self.nodes and self.nodes[dep].module != module:
+                        efferent.add(self.nodes[dep].module)
+
+            # Ca: acoplamentos aferentes
+            afferent = set()
+            for n in nodes:
+                for dep in self._radj.get(n, set()):
+                    if dep in self.nodes and self.nodes[dep].module != module:
+                        afferent.add(self.nodes[dep].module)
+
+            ca = len(afferent)
+            ce = len(efferent)
+            instability = ce / (ca + ce) if (ca + ce) > 0 else 0.0
+
+            # Abstração: razão de interfaces/abstratas para total
+            abstracts = sum(1 for n in nodes if
+                            n in self.nodes and
+                            (self.nodes[n].is_abstract or self.nodes[n].kind == 'interface'))
+            abstraction = abstracts / max(len(nodes), 1)
+
+            # Distância da sequência principal: D = |A + I - 1|
+            # Sequência principal: A + I = 1 (ideal)
+            distance = abs(abstraction + instability - 1)
+
+            metrics[module] = {
+                'Ca': ca,
+                'Ce': ce,
+                'instability': round(instability, 3),
+                'abstraction': round(abstraction, 3),
+                'distance_from_main_sequence': round(distance, 3),
+                'total_classes': len(nodes),
+                'abstract_classes': abstracts,
+                'depends_on_modules': list(efferent),
+                'used_by_modules': list(afferent),
+            }
+
+        return metrics
+
+
+class ProjectAnalyzer:
+    """Analisa um projeto Kotlin/Android completo."""
+
+    def __init__(self, project_root: str):
+        self.project_root = Path(project_root)
+        self.graph = DependencyGraph()
+        self.module_files: Dict[str, List[Path]] = defaultdict(list)
+
+    def analyze(self) -> None:
+        """Analisa todos os arquivos Kotlin."""
+        kt_files = list(self.project_root.glob("**/*.kt"))
+
+        for kt_file in kt_files:
+            module = self._detect_module(kt_file)
+            self.module_files[module].append(kt_file)
+            self._analyze_file(kt_file, module)
+
+    def _detect_module(self, file_path: Path) -> str:
+        known = ['app', 'bluetooth', 'audio', 'voice', 'llm', 'integrations', 'core-logging']
+        for part in file_path.parts:
+            if part in known:
+                return part
+        return 'unknown'
+
+    def _analyze_file(self, file_path: Path, module: str) -> None:
+        try:
+            content = file_path.read_text(encoding='utf-8', errors='ignore')
+        except Exception:
+            return
+
+        # Extrair package
+        pkg_match = re.search(r'^package\s+(.+)$', content, re.MULTILINE)
+        package = pkg_match.group(1).strip() if pkg_match else 'unknown'
+
+        # Extrair declarações de classe/interface/object
+        class_patterns = [
+            (r'(?:abstract\s+)?(?:open\s+)?(?:data\s+)?class\s+(\w+)', 'class'),
+            (r'interface\s+(\w+)', 'interface'),
+            (r'object\s+(\w+)', 'object'),
+            (r'enum\s+class\s+(\w+)', 'enum'),
+        ]
+
+        for pattern, kind in class_patterns:
+            for match in re.finditer(pattern, content):
+                class_name = match.group(1)
+                node_id = f"{package}.{class_name}"
+                is_abstract = 'abstract' in content[max(0, match.start()-20):match.start()]
+                is_open = 'open' in content[max(0, match.start()-10):match.start()]
+
+                node = Node(
+                    id=node_id,
+                    module=module,
+                    package=package,
+                    kind=kind,
+                    is_abstract=is_abstract,
+                    is_open=is_open
+                )
+                self.graph.add_node(node)
+
+                # Extrair dependências via imports
+                imports = re.findall(r'^import\s+(.+)$', content, re.MULTILINE)
+                for imp in imports:
+                    imp = imp.strip()
+                    if imp.startswith('com.earllm'):
+                        dep_id = imp
+                        if dep_id != node_id:
+                            edge = Edge(src=node_id, dst=dep_id, kind='imports')
+                            self.graph.add_edge(edge)
+
+    def generate_full_report(self) -> Dict:
+        """Gera relatório matemático completo do grafo."""
+        cycles = self.graph.find_cycles()
+        sccs = self.graph.strongly_connected_components()
+        topo = self.graph.topological_sort()
+        betweenness = self.graph.betweenness_centrality()
+        pagerank = self.graph.page_rank()
+        coupling = self.graph.coupling_metrics()
+
+        # Top nodes por betweenness (single points of failure)
+        top_betweenness = sorted(
+            betweenness.items(), key=lambda x: x[1], reverse=True
+        )[:10]
+
+        # Top nodes por pagerank (mais influentes)
+        top_pagerank = sorted(
+            pagerank.items(), key=lambda x: x[1], reverse=True
+        )[:10]
+
+        # SCCs com mais de 1 nó (ciclos reais)
+        real_sccs = [scc for scc in sccs if len(scc) > 1]
+
+        return {
+            'graph_summary': {
+                'nodes': len(self.graph.nodes),
+                'edges': len(self.graph.edges),
+                'is_dag': topo is not None,
+                'cycles_found': len(cycles),
+                'strongly_connected_components': len(real_sccs),
+            },
+            'cycles': cycles[:10],  # primeiros 10 ciclos
+            'real_sccs': real_sccs[:5],
+            'topological_order': topo[:20] if topo else None,
+            'top_betweenness_centrality': [
+                {'node': n, 'betweenness': round(b, 4)} for n, b in top_betweenness
+            ],
+            'top_pagerank': [
+                {'node': n, 'pagerank': round(pr, 4)} for n, pr in top_pagerank
+            ],
+            'module_coupling': coupling,
+            'modules': {mod: len(files) for mod, files in self.module_files.items()},
+        }
+
+    def to_dot(self) -> str:
+        """Exporta grafo em formato DOT para visualização (Graphviz)."""
+        lines = ['digraph AuriDependencies {']
+        lines.append('  rankdir=LR;')
+        lines.append('  node [shape=box, fontname="Arial"];')
+
+        # Cores por módulo
+        module_colors = {
+            'app': '#4CAF50',
+            'bluetooth': '#2196F3',
+            'audio': '#FF9800',
+            'voice': '#9C27B0',
+            'llm': '#F44336',
+            'integrations': '#00BCD4',
+            'core-logging': '#607D8B',
+        }
+
+        # Adicionar nós por módulo
+        modules_seen = defaultdict(list)
+        for node_id, node in self.graph.nodes.items():
+            modules_seen[node.module].append((node_id, node))
+
+        for module, nodes in modules_seen.items():
+            color = module_colors.get(module, '#9E9E9E')
+            lines.append(f'  subgraph cluster_{module.replace("-", "_")} {{')
+            lines.append(f'    label="{module}";')
+            lines.append(f'    style=filled;')
+            lines.append(f'    fillcolor="{color}20";')  # 20 = ~12% opacity
+            for node_id, node in nodes[:20]:  # limitar para visualização
+                short_name = node_id.split('.')[-1]
+                shape = 'diamond' if node.kind == 'interface' else 'box'
+                lines.append(f'    "{node_id}" [label="{short_name}", shape={shape}];')
+            lines.append('  }')
+
+        # Adicionar arestas (amostra)
+        for edge in self.edges[:100]:  # limitar para visualização
+            lines.append(f'  "{edge.src}" -> "{edge.dst}" [label="{edge.kind}"];')
+
+        lines.append('}')
+        return '\n'.join(lines)
+
+    @property
+    def edges(self):
+        return self.graph.edges
+
+    def print_report(self, report: Dict) -> None:
+        print("\n" + "="*70)
+        print("  PROF. EULER — ANÁLISE DE GRAFOS DE DEPENDÊNCIAS")
+        print("="*70)
+
+        gs = report['graph_summary']
+        print(f"\n📊 RESUMO DO GRAFO G = (V={gs['nodes']}, E={gs['edges']}):")
+        print(f"  É DAG (sem ciclos):          {'✅ SIM' if gs['is_dag'] else '❌ NÃO'}")
+        print(f"  Ciclos detectados:           {gs['cycles_found']}")
+        print(f"  SCCs com mais de 1 nó:       {gs['strongly_connected_components']}")
+
+        if report['cycles']:
+            print(f"\n❌ CICLOS DE DEPENDÊNCIA (devem ser eliminados):")
+            for i, cycle in enumerate(report['cycles'][:5], 1):
+                print(f"  {i}. {' → '.join(c.split('.')[-1] for c in cycle)}")
+
+        if report['top_betweenness_centrality']:
+            print(f"\n⚠️  TOP NÓDULOS CRÍTICOS (single points of failure — alto betweenness):")
+            for item in report['top_betweenness_centrality'][:5]:
+                short = item['node'].split('.')[-1]
+                print(f"  {short:<35} betweenness={item['betweenness']:.4f}")
+
+        print(f"\n📦 ACOPLAMENTO DE MÓDULOS (Princípio de Martin):")
+        print(f"  {'Módulo':<20} {'Ca':>5} {'Ce':>5} {'I':>8} {'A':>8} {'D':>8}  Status")
+        print(f"  {'-'*20} {'-'*5} {'-'*5} {'-'*8} {'-'*8} {'-'*8}  {'-'*20}")
+        for mod, data in sorted(report['module_coupling'].items()):
+            i = data['instability']
+            a = data['abstraction']
+            d = data['distance_from_main_sequence']
+            status = "✅ OK" if d < 0.3 else ("⚠️  ZONA DE PROBLEMA" if d < 0.5 else "❌ FORA DA SEQ.")
+            print(f"  {mod:<20} {data['Ca']:>5} {data['Ce']:>5} {i:>8.3f} {a:>8.3f} {d:>8.3f}  {status}")
+
+        print("\n  I=instabilidade, A=abstração, D=distância da sequência principal")
+        print("  D ideal < 0.3 (zona de exclusão = zona de dor/inutilidade)")
+        print("\n" + "="*70 + "\n")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Prof. Euler — Análise de Grafos de Dependências'
+    )
+    parser.add_argument('path', nargs='?',
+                        default=r'C:\Users\renat\earbudllm',
+                        help='Caminho raiz do projeto')
+    parser.add_argument('--format', '-f', choices=['text', 'json', 'dot'],
+                        default='text', help='Formato de saída')
+    parser.add_argument('--output', '-o', help='Arquivo de saída')
+
+    args = parser.parse_args()
+
+    print(f"🔬 Prof. Euler analisando grafos: {args.path}")
+
+    analyzer = ProjectAnalyzer(args.path)
+    analyzer.analyze()
+    report = analyzer.generate_full_report()
+
+    if args.format == 'json':
+        output = json.dumps(report, indent=2, ensure_ascii=False)
+        print(output)
+    elif args.format == 'dot':
+        output = analyzer.to_dot()
+        print(output)
+        if args.output:
+            Path(args.output).write_text(output)
+            print(f"\n✅ Arquivo DOT salvo: {args.output}")
+            print("  Para visualizar: dot -Tpng deps.dot -o deps.png")
+    else:
+        analyzer.print_report(report)
+
+    if args.output and args.format != 'dot':
+        Path(args.output).write_text(
+            json.dumps(report, indent=2, ensure_ascii=False),
+            encoding='utf-8'
+        )
+        print(f"✅ Relatório salvo: {args.output}")
+
+    return report
+
+
+if __name__ == '__main__':
+    main()

package/templates/vault/mcp-builder/scripts/connections.py

@@ -0,0 +1,151 @@
+"""Lightweight connection handling for MCP servers."""
+
+from abc import ABC, abstractmethod
+from contextlib import AsyncExitStack
+from typing import Any
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.sse import sse_client
+from mcp.client.stdio import stdio_client
+from mcp.client.streamable_http import streamablehttp_client
+
+
+class MCPConnection(ABC):
+    """Base class for MCP server connections."""
+
+    def __init__(self):
+        self.session = None
+        self._stack = None
+
+    @abstractmethod
+    def _create_context(self):
+        """Create the connection context based on connection type."""
+
+    async def __aenter__(self):
+        """Initialize MCP server connection."""
+        self._stack = AsyncExitStack()
+        await self._stack.__aenter__()
+
+        try:
+            ctx = self._create_context()
+            result = await self._stack.enter_async_context(ctx)
+
+            if len(result) == 2:
+                read, write = result
+            elif len(result) == 3:
+                read, write, _ = result
+            else:
+                raise ValueError(f"Unexpected context result: {result}")
+
+            session_ctx = ClientSession(read, write)
+            self.session = await self._stack.enter_async_context(session_ctx)
+            await self.session.initialize()
+            return self
+        except BaseException:
+            await self._stack.__aexit__(None, None, None)
+            raise
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Clean up MCP server connection resources."""
+        if self._stack:
+            await self._stack.__aexit__(exc_type, exc_val, exc_tb)
+        self.session = None
+        self._stack = None
+
+    async def list_tools(self) -> list[dict[str, Any]]:
+        """Retrieve available tools from the MCP server."""
+        response = await self.session.list_tools()
+        return [
+            {
+                "name": tool.name,
+                "description": tool.description,
+                "input_schema": tool.inputSchema,
+            }
+            for tool in response.tools
+        ]
+
+    async def call_tool(self, tool_name: str, arguments: dict[str, Any]) -> Any:
+        """Call a tool on the MCP server with provided arguments."""
+        result = await self.session.call_tool(tool_name, arguments=arguments)
+        return result.content
+
+
+class MCPConnectionStdio(MCPConnection):
+    """MCP connection using standard input/output."""
+
+    def __init__(self, command: str, args: list[str] = None, env: dict[str, str] = None):
+        super().__init__()
+        self.command = command
+        self.args = args or []
+        self.env = env
+
+    def _create_context(self):
+        return stdio_client(
+            StdioServerParameters(command=self.command, args=self.args, env=self.env)
+        )
+
+
+class MCPConnectionSSE(MCPConnection):
+    """MCP connection using Server-Sent Events."""
+
+    def __init__(self, url: str, headers: dict[str, str] = None):
+        super().__init__()
+        self.url = url
+        self.headers = headers or {}
+
+    def _create_context(self):
+        return sse_client(url=self.url, headers=self.headers)
+
+
+class MCPConnectionHTTP(MCPConnection):
+    """MCP connection using Streamable HTTP."""
+
+    def __init__(self, url: str, headers: dict[str, str] = None):
+        super().__init__()
+        self.url = url
+        self.headers = headers or {}
+
+    def _create_context(self):
+        return streamablehttp_client(url=self.url, headers=self.headers)
+
+
+def create_connection(
+    transport: str,
+    command: str = None,
+    args: list[str] = None,
+    env: dict[str, str] = None,
+    url: str = None,
+    headers: dict[str, str] = None,
+) -> MCPConnection:
+    """Factory function to create the appropriate MCP connection.
+
+    Args:
+        transport: Connection type ("stdio", "sse", or "http")
+        command: Command to run (stdio only)
+        args: Command arguments (stdio only)
+        env: Environment variables (stdio only)
+        url: Server URL (sse and http only)
+        headers: HTTP headers (sse and http only)
+
+    Returns:
+        MCPConnection instance
+    """
+    transport = transport.lower()
+
+    if transport == "stdio":
+        if not command:
+            raise ValueError("Command is required for stdio transport")
+        return MCPConnectionStdio(command=command, args=args, env=env)
+
+    elif transport == "sse":
+        if not url:
+            raise ValueError("URL is required for sse transport")
+        return MCPConnectionSSE(url=url, headers=headers)
+
+    elif transport in ["http", "streamable_http", "streamable-http"]:
+        if not url:
+            raise ValueError("URL is required for http transport")
+        return MCPConnectionHTTP(url=url, headers=headers)
+
+    else:
+        raise ValueError(f"Unsupported transport type: {transport}. Use 'stdio', 'sse', or 'http'")