hanuscode 1.0.0__py3-none-any.whl

hanus/analysis/dependencies.py

@@ -0,0 +1,475 @@
+# hanus/analysis/dependencies.py
+"""
+Analizador de dependencias de código.
+
+Funcionalidades:
+- Análisis de imports/dependencias
+- Detección de dependencias circulares
+- Visualización de grafo de dependencias
+- Métricas de acoplamiento
+"""
+from __future__ import annotations
+import ast
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Set, Optional, Any, Tuple
+from collections import defaultdict
+from enum import Enum
+
+
+class DependencyType(Enum):
+    """Tipo de dependencia."""
+    IMPORT = "import"          # import X
+    FROM_IMPORT = "from"       # from X import Y
+    RELATIVE = "relative"      # from . import X
+    DYNAMIC = "dynamic"        # __import__, importlib
+
+
+class NodeType(Enum):
+    """Tipo de nodo en el grafo."""
+    FILE = "file"
+    MODULE = "module"
+    PACKAGE = "package"
+    CLASS = "class"
+    FUNCTION = "function"
+    VARIABLE = "variable"
+
+
+@dataclass
+class DependencyNode:
+    """Un nodo en el grafo de dependencias."""
+    id: str                          # Identificador único (ruta o nombre)
+    name: str                        # Nombre legible
+    type: NodeType
+    path: Optional[str] = None       # Ruta del archivo si aplica
+    imports: List[str] = field(default_factory=list)  # Lo que este nodo importa
+    imported_by: List[str] = field(default_factory=list)  # Quien importa este nodo
+    exports: List[str] = field(default_factory=list)  # Lo que exporta
+    loc: int = 0                     # Lines of code
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "type": self.type.value,
+            "path": self.path,
+            "imports": self.imports,
+            "imported_by": self.imported_by,
+            "exports": self.exports,
+            "loc": self.loc,
+            "metadata": self.metadata,
+        }
+
+
+@dataclass
+class DependencyEdge:
+    """Una arista en el grafo de dependencias."""
+    source: str                     # ID del nodo origen
+    target: str                     # ID del nodo destino
+    type: DependencyType
+    symbols: List[str] = field(default_factory=list)  # Símbolos importados
+    line: int = 0                   # Línea donde aparece el import
+
+    def to_dict(self) -> Dict:
+        return {
+            "source": self.source,
+            "target": self.target,
+            "type": self.type.value,
+            "symbols": self.symbols,
+            "line": self.line,
+        }
+
+
+@dataclass
+class DependencyGraph:
+    """Grafo completo de dependencias."""
+    nodes: Dict[str, DependencyNode] = field(default_factory=dict)
+    edges: List[DependencyEdge] = field(default_factory=list)
+
+    # Índices para búsqueda rápida
+    _outgoing: Dict[str, List[str]] = field(default_factory=dict)  # nodo -> [nodos destino]
+    _incoming: Dict[str, List[str]] = field(default_factory=dict)  # nodo -> [nodos origen]
+
+    def add_node(self, node: DependencyNode) -> None:
+        """Añade un nodo al grafo."""
+        self.nodes[node.id] = node
+        if node.id not in self._outgoing:
+            self._outgoing[node.id] = []
+        if node.id not in self._incoming:
+            self._incoming[node.id] = []
+
+    def add_edge(self, edge: DependencyEdge) -> None:
+        """Añade una arista al grafo."""
+        self.edges.append(edge)
+        if edge.source not in self._outgoing:
+            self._outgoing[edge.source] = []
+        self._outgoing[edge.source].append(edge.target)
+
+        if edge.target not in self._incoming:
+            self._incoming[edge.target] = []
+        self._incoming[edge.target].append(edge.source)
+
+    def get_dependencies(self, node_id: str) -> List[str]:
+        """Obtiene los nodos de los que depende un nodo."""
+        return self._outgoing.get(node_id, [])
+
+    def get_dependents(self, node_id: str) -> List[str]:
+        """Obtiene los nodos que dependen de un nodo."""
+        return self._incoming.get(node_id, [])
+
+    def find_cycles(self) -> List[List[str]]:
+        """Encuentra todos los ciclos en el grafo."""
+        cycles = []
+        visited = set()
+        rec_stack = set()
+        path = []
+
+        def dfs(node: str) -> None:
+            visited.add(node)
+            rec_stack.add(node)
+            path.append(node)
+
+            for neighbor in self._outgoing.get(node, []):
+                if neighbor not in visited:
+                    dfs(neighbor)
+                elif neighbor in rec_stack:
+                    # Encontramos un ciclo
+                    cycle_start = path.index(neighbor)
+                    cycle = path[cycle_start:] + [neighbor]
+                    cycles.append(cycle)
+
+            path.pop()
+            rec_stack.remove(node)
+
+        for node in self.nodes:
+            if node not in visited:
+                dfs(node)
+
+        return cycles
+
+    def get_coupling_metrics(self) -> Dict[str, Any]:
+        """Calcula métricas de acoplamiento."""
+        afferent = {}   # Cuántos nodos dependen de este (incoming)
+        efferent = {}   # De cuántos nodos depende este (outgoing)
+
+        for node_id in self.nodes:
+            afferent[node_id] = len(self._incoming.get(node_id, []))
+            efferent[node_id] = len(self._outgoing.get(node_id, []))
+
+        # Calcular inestabilidad: I = Ce / (Ca + Ce)
+        # I cercano a 0 = estable, I cercano a 1 = inestable
+        instability = {}
+        for node_id in self.nodes:
+            ca = afferent.get(node_id, 0)
+            ce = efferent.get(node_id, 0)
+            total = ca + ce
+            instability[node_id] = ce / total if total > 0 else 0
+
+        return {
+            "afferent_coupling": afferent,   # Afferent coupling (Ca)
+            "efferent_coupling": efferent,   # Efferent coupling (Ce)
+            "instability": instability,
+            "total_nodes": len(self.nodes),
+            "total_edges": len(self.edges),
+        }
+
+    def get_top_dependencies(self, limit: int = 10) -> List[Dict]:
+        """Obtiene los nodos más importados."""
+        incoming_counts = [
+            (node_id, len(self._incoming.get(node_id, [])))
+            for node_id in self.nodes
+        ]
+        incoming_counts.sort(key=lambda x: -x[1])
+
+        return [
+            {
+                "id": node_id,
+                "name": self.nodes[node_id].name,
+                "imported_by_count": count,
+            }
+            for node_id, count in incoming_counts[:limit]
+        ]
+
+    def to_dict(self) -> Dict:
+        """Convierte el grafo a diccionario para serialización."""
+        return {
+            "nodes": [n.to_dict() for n in self.nodes.values()],
+            "edges": [e.to_dict() for e in self.edges],
+            "metrics": self.get_coupling_metrics(),
+        }
+
+    def to_vis_format(self) -> Dict:
+        """Convierte el grafo a formato para visualización (vis.js, d3.js)."""
+        nodes = []
+        for node in self.nodes.values():
+            # Determinar grupo/color
+            if node.type == NodeType.FILE:
+                group = "file"
+            elif node.type == NodeType.MODULE:
+                group = "module"
+            else:
+                group = "other"
+
+            nodes.append({
+                "id": node.id,
+                "label": node.name,
+                "group": group,
+                "title": f"{node.name}\nImports: {len(node.imports)}\nImported by: {len(node.imported_by)}",
+                "value": len(node.imported_by) + 1,  # Tamaño basado en uso
+            })
+
+        edges = []
+        for edge in self.edges:
+            edges.append({
+                "from": edge.source,
+                "to": edge.target,
+                "arrows": "to",
+                "title": f"{edge.type.value}: {', '.join(edge.symbols[:3])}",
+            })
+
+        return {"nodes": nodes, "edges": edges}
+
+
+class DependencyAnalyzer:
+    """
+    Analiza dependencias de código en un proyecto.
+
+    Soporta:
+    - Python (.py)
+    - JavaScript/TypeScript (.js, .ts)
+    - JSON dependencies (package.json, requirements.txt)
+    """
+
+    PYTHON_IMPORT_PATTERNS = [
+        # import X
+        re.compile(r'^import\s+([a-zA-Z_][\w\.]*)', re.MULTILINE),
+        # from X import Y
+        re.compile(r'^from\s+([a-zA-Z_][\w\.]*)\s+import', re.MULTILINE),
+    ]
+
+    JS_IMPORT_PATTERNS = [
+        # import X from 'Y'
+        re.compile(r'''import\s+.*?\s+from\s+['"]([^'"]+)['"]'''),
+        # import 'X'
+        re.compile(r'''import\s+['"]([^'"]+)['"]'''),
+        # require('X')
+        re.compile(r'''require\s*\(\s*['"]([^'"]+)['"]\s*\)'''),
+    ]
+
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+        self._file_cache: Dict[str, str] = {}
+
+    def analyze_project(
+        self,
+        include_patterns: List[str] = None,
+        exclude_patterns: List[str] = None
+    ) -> DependencyGraph:
+        """
+        Analiza todo el proyecto y construye el grafo de dependencias.
+
+        Args:
+            include_patterns: Patrones de archivos a incluir (ej: ["*.py", "*.js"])
+            exclude_patterns: Patrones a excluir (ej: ["test_*", "__pycache__"])
+
+        Returns:
+            DependencyGraph con todas las dependencias
+        """
+        graph = DependencyGraph()
+
+        include_patterns = include_patterns or ["*.py", "*.js", "*.ts"]
+        exclude_patterns = exclude_patterns or ["__pycache__", "node_modules", ".git", "venv", "env"]
+
+        # Recopilar todos los archivos
+        files = self._collect_files(include_patterns, exclude_patterns)
+
+        # Analizar cada archivo
+        for file_path in files:
+            self._analyze_file(file_path, graph)
+
+        # Construir índices inversos
+        self._build_reverse_indices(graph)
+
+        return graph
+
+    def analyze_file(self, file_path: Path) -> DependencyGraph:
+        """Analiza un solo archivo."""
+        graph = DependencyGraph()
+        self._analyze_file(file_path, graph)
+        return graph
+
+    def find_circular_dependencies(self, graph: DependencyGraph) -> List[List[str]]:
+        """Encuentra dependencias circulares."""
+        return graph.find_cycles()
+
+    def get_dependency_path(self, graph: DependencyGraph, from_node: str, to_node: str) -> List[str]:
+        """Encuentra el camino de dependencia entre dos nodos."""
+        visited = set()
+        path = []
+
+        def dfs(current: str) -> bool:
+            if current == to_node:
+                path.append(current)
+                return True
+
+            if current in visited:
+                return False
+
+            visited.add(current)
+            path.append(current)
+
+            for neighbor in graph.get_dependencies(current):
+                if dfs(neighbor):
+                    return True
+
+            path.pop()
+            return False
+
+        dfs(from_node)
+        return path
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # MÉTODOS PRIVADOS
+    # ══════════════════════════════════════════════════════════════════════════
+
+    def _collect_files(
+        self,
+        include_patterns: List[str],
+        exclude_patterns: List[str]
+    ) -> List[Path]:
+        """Recolecta archivos del proyecto."""
+        files = []
+
+        for pattern in include_patterns:
+            for file_path in self.project_root.rglob(pattern):
+                # Verificar exclusiones
+                rel_path = file_path.relative_to(self.project_root)
+                if any(exc in str(rel_path) for exc in exclude_patterns):
+                    continue
+                files.append(file_path)
+
+        return files
+
+    def _analyze_file(self, file_path: Path, graph: DependencyGraph) -> None:
+        """Analiza un archivo y añade sus dependencias al grafo."""
+        try:
+            content = file_path.read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            return
+
+        rel_path = str(file_path.relative_to(self.project_root))
+        node_id = rel_path.replace("/", ".").replace("\\", ".")
+
+        # Crear nodo para el archivo
+        node = DependencyNode(
+            id=node_id,
+            name=file_path.name,
+            type=NodeType.FILE,
+            path=str(file_path),
+            loc=content.count("\n") + 1,
+        )
+
+        # Detectar imports según el tipo de archivo
+        ext = file_path.suffix.lower()
+
+        if ext == ".py":
+            imports = self._parse_python_imports(content, file_path)
+        elif ext in (".js", ".ts", ".jsx", ".tsx"):
+            imports = self._parse_js_imports(content, file_path)
+        else:
+            imports = []
+
+        node.imports = [imp["module"] for imp in imports]
+
+        # Añadir nodo y aristas
+        graph.add_node(node)
+
+        for imp in imports:
+            target_id = imp["module"]
+
+            # Crear nodo para el módulo importado si no existe
+            if target_id not in graph.nodes:
+                graph.add_node(DependencyNode(
+                    id=target_id,
+                    name=target_id.split(".")[-1],
+                    type=NodeType.MODULE,
+                ))
+
+            # Añadir arista
+            graph.add_edge(DependencyEdge(
+                source=node_id,
+                target=target_id,
+                type=DependencyType(imp["type"]),
+                symbols=imp.get("names", []),
+                line=imp.get("line", 0),
+            ))
+
+    def _parse_python_imports(self, content: str, file_path: Path) -> List[Dict]:
+        """Parsea imports de Python usando AST."""
+        imports = []
+
+        try:
+            tree = ast.parse(content)
+
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        imports.append({
+                            "module": alias.name,
+                            "names": [alias.name],
+                            "type": "import",
+                            "line": node.lineno,
+                        })
+
+                elif isinstance(node, ast.ImportFrom):
+                    module = node.module or ""
+                    if node.level > 0:
+                        # Import relativo
+                        module = "." * node.level + module
+
+                    names = [alias.name for alias in node.names]
+                    imports.append({
+                        "module": module,
+                        "names": names,
+                        "type": "from" if node.level == 0 else "relative",
+                        "line": node.lineno,
+                    })
+
+        except SyntaxError:
+            # Fallback a regex si hay error de sintaxis
+            imports = self._parse_imports_regex(content, self.PYTHON_IMPORT_PATTERNS, "import")
+
+        return imports
+
+    def _parse_js_imports(self, content: str, file_path: Path) -> List[Dict]:
+        """Parsea imports de JavaScript/TypeScript."""
+        return self._parse_imports_regex(content, self.JS_IMPORT_PATTERNS, "import")
+
+    def _parse_imports_regex(
+        self,
+        content: str,
+        patterns: List[re.Pattern],
+        default_type: str
+    ) -> List[Dict]:
+        """Parsea imports usando expresiones regulares."""
+        imports = []
+
+        for pattern in patterns:
+            for match in pattern.finditer(content):
+                module = match.group(1)
+                imports.append({
+                    "module": module,
+                    "names": [],
+                    "type": default_type,
+                    "line": content[:match.start()].count("\n") + 1,
+                })
+
+        return imports
+
+    def _build_reverse_indices(self, graph: DependencyGraph) -> None:
+        """Construye índices inversos (imported_by) para cada nodo."""
+        for edge in graph.edges:
+            if edge.target in graph.nodes:
+                graph.nodes[edge.target].imported_by.append(edge.source)

hanus/cache/__init__.py

@@ -0,0 +1,5 @@
+# hanus/cache/__init__.py
+"""Cache system for HanusCode."""
+from .response_cache import ResponseCache, CacheEntry, CacheStats
+
+__all__ = ["ResponseCache", "CacheEntry", "CacheStats"]