hanuscode 1.0.0__py3-none-any.whl

hanus/context/selective.py

@@ -0,0 +1,626 @@
+# hanus/context/selective.py
+"""
+Cargador selectivo de contexto por archivo.
+
+Analiza imports/dependencias y carga solo las partes relevantes
+de archivos grandes, ahorrando tokens y mejorando precisión.
+"""
+from __future__ import annotations
+import ast
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Any, Tuple
+from enum import Enum
+from collections import defaultdict
+import time
+
+
+class SymbolType(Enum):
+    """Tipo de símbolo en código."""
+    CLASS = "class"
+    FUNCTION = "function"
+    METHOD = "method"
+    VARIABLE = "variable"
+    CONSTANT = "constant"
+    IMPORT = "import"
+    MODULE = "module"
+
+
+@dataclass
+class Symbol:
+    """Un símbolo de código (clase, función, etc.)."""
+    name: str
+    type: SymbolType
+    file_path: str
+    line_start: int
+    line_end: int
+    docstring: Optional[str] = None
+    signature: Optional[str] = None      # Para funciones/métodos
+    parent: Optional[str] = None          # Para métodos (clase padre)
+    dependencies: List[str] = field(default_factory=list)  # Símbolos que usa
+    exported: bool = True                 # Si es parte de la API pública
+
+    def to_dict(self) -> Dict:
+        return {
+            "name": self.name,
+            "type": self.type.value,
+            "file_path": self.file_path,
+            "line_start": self.line_start,
+            "line_end": self.line_end,
+            "docstring": self.docstring,
+            "signature": self.signature,
+            "parent": self.parent,
+            "dependencies": self.dependencies,
+            "exported": self.exported,
+        }
+
+
+@dataclass
+class FileIndex:
+    """Índice de un archivo analizado."""
+    path: str
+    language: str
+    symbols: List[Symbol]
+    imports: List[str]
+    exports: List[str]
+    last_modified: float
+    content_hash: str
+
+    def get_symbol(self, name: str) -> Optional[Symbol]:
+        """Obtiene un símbolo por nombre."""
+        for sym in self.symbols:
+            if sym.name == name:
+                return sym
+        return None
+
+    def get_symbols_by_type(self, symbol_type: SymbolType) -> List[Symbol]:
+        """Obtiene símbolos por tipo."""
+        return [s for s in self.symbols if s.type == symbol_type]
+
+
+class SelectiveLoader:
+    """
+    Carga contexto de forma selectiva, extrayendo solo lo relevante.
+
+    Features:
+    - Análisis de imports/dependencias
+    - Extracción de símbolos específicos
+    - Lazy loading de dependencias
+    - Cache de índices por archivo
+    """
+
+    # Extensiones soportadas por lenguaje
+    LANGUAGE_EXTENSIONS = {
+        '.py': 'python',
+        '.js': 'javascript',
+        '.ts': 'typescript',
+        '.jsx': 'javascript',
+        '.tsx': 'typescript',
+        '.java': 'java',
+        '.go': 'go',
+        '.rs': 'rust',
+        '.c': 'c',
+        '.cpp': 'cpp',
+        '.h': 'c',
+        '.hpp': 'cpp',
+    }
+
+    def __init__(self, project_root: Path, cache_dir: Optional[Path] = None):
+        self.project_root = project_root
+        self.cache_dir = cache_dir or (Path.home() / ".hanus" / "context_cache")
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+        # Cache de índices
+        self._index_cache: Dict[str, FileIndex] = {}
+        self._symbol_index: Dict[str, List[Symbol]] = defaultdict(list)  # name -> [symbols]
+
+        # Cache de contenido parcial
+        self._content_cache: Dict[str, str] = {}
+
+    def load_relevant_context(
+        self,
+        file_path: str,
+        query: str,
+        max_tokens: int = 4000
+    ) -> str:
+        """
+        Carga contexto relevante para una consulta sobre un archivo.
+
+        Args:
+            file_path: Archivo objetivo
+            query: Consulta del usuario
+            max_tokens: Límite de tokens
+
+        Returns:
+            Contexto relevante como string
+        """
+        path = Path(file_path)
+        if not path.exists():
+            return f"File not found: {file_path}"
+
+        # Obtener índice del archivo
+        index = self._get_or_create_index(path)
+
+        # Identificar símbolos relevantes basados en la query
+        relevant_symbols = self._find_relevant_symbols(index, query)
+
+        # Construir contexto
+        context_parts = []
+
+        # Añadir imports primero
+        if index.imports:
+            imports_text = "## Imports\n```python\n" + "\n".join(index.imports[:20]) + "\n```\n"
+            context_parts.append(imports_text)
+
+        # Añadir símbolos relevantes
+        content = self._read_file(path)
+        lines = content.split('\n')
+
+        for sym in relevant_symbols:
+            # Extraer código del símbolo
+            symbol_code = "\n".join(lines[sym.line_start - 1:sym.line_end])
+
+            header = f"## {sym.type.value}: {sym.name}"
+            if sym.docstring:
+                header += f"\n{sym.docstring[:200]}"
+
+            context_parts.append(f"{header}\n```python\n{symbol_code}\n```\n")
+
+            # Verificar límite de tokens
+            current_length = sum(len(p) for p in context_parts)
+            if current_length > max_tokens * 4:  # ~4 chars per token
+                break
+
+        return "\n".join(context_parts)
+
+    def get_file_symbols(self, file_path: str) -> List[Symbol]:
+        """
+        Obtiene todos los símbolos de un archivo.
+
+        Args:
+            file_path: Ruta del archivo
+
+        Returns:
+            Lista de símbolos
+        """
+        path = Path(file_path)
+        if not path.exists():
+            return []
+
+        index = self._get_or_create_index(path)
+        return index.symbols
+
+    def build_dependency_graph(self, file_path: str) -> Dict[str, List[str]]:
+        """
+        Construye el grafo de dependencias de un archivo.
+
+        Args:
+            file_path: Archivo objetivo
+
+        Returns:
+            Dict con dependencias {symbol: [dependencies]}
+        """
+        path = Path(file_path)
+        if not path.exists():
+            return {}
+
+        index = self._get_or_create_index(path)
+
+        graph = {}
+        for sym in index.symbols:
+            graph[sym.name] = sym.dependencies
+
+        return graph
+
+    def find_symbol_definition(
+        self,
+        symbol_name: str,
+        from_file: Optional[str] = None
+    ) -> Optional[Tuple[str, Symbol]]:
+        """
+        Encuentra la definición de un símbolo.
+
+        Args:
+            symbol_name: Nombre del símbolo
+            from_file: Archivo desde donde se busca (para resolver imports)
+
+        Returns:
+            (file_path, Symbol) si se encuentra
+        """
+        # Buscar en índice global
+        if symbol_name in self._symbol_index:
+            symbols = self._symbol_index[symbol_name]
+            if symbols:
+                sym = symbols[0]
+                return (sym.file_path, sym)
+
+        # Si hay archivo origen, buscar en sus imports
+        if from_file:
+            from_path = Path(from_file)
+            if from_path.exists():
+                index = self._get_or_create_index(from_path)
+                for imp in index.imports:
+                    # Intentar resolver import
+                    if symbol_name in imp:
+                        resolved = self._resolve_import(imp, from_path)
+                        if resolved:
+                            resolved_index = self._get_or_create_index(resolved)
+                            sym = resolved_index.get_symbol(symbol_name)
+                            if sym:
+                                return (str(resolved), sym)
+
+        return None
+
+    def extract_symbol_content(
+        self,
+        file_path: str,
+        symbol_name: str
+    ) -> Optional[str]:
+        """
+        Extrae el contenido de un símbolo específico.
+
+        Args:
+            file_path: Ruta del archivo
+            symbol_name: Nombre del símbolo
+
+        Returns:
+            Código del símbolo o None
+        """
+        path = Path(file_path)
+        if not path.exists():
+            return None
+
+        index = self._get_or_create_index(path)
+        sym = index.get_symbol(symbol_name)
+
+        if not sym:
+            return None
+
+        content = self._read_file(path)
+        lines = content.split('\n')
+
+        return "\n".join(lines[sym.line_start - 1:sym.line_end])
+
+    def get_index_stats(self) -> Dict[str, Any]:
+        """Obtiene estadísticas del índice."""
+        return {
+            "files_indexed": len(self._index_cache),
+            "total_symbols": sum(len(idx.symbols) for idx in self._index_cache.values()),
+            "symbols_by_type": {
+                t.value: len([s for s in self._symbol_index.values()
+                             for s in s if s.type == t])
+                for t in SymbolType
+            },
+        }
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # MÉTODOS PRIVADOS
+    # ══════════════════════════════════════════════════════════════════════════
+
+    def _get_or_create_index(self, file_path: Path) -> FileIndex:
+        """Obtiene o crea el índice de un archivo."""
+        path_str = str(file_path.resolve())
+
+        # Verificar cache
+        if path_str in self._index_cache:
+            cached = self._index_cache[path_str]
+            # Verificar si el archivo cambió
+            if file_path.stat().st_mtime <= cached.last_modified:
+                return cached
+
+        # Crear nuevo índice
+        index = self._create_index(file_path)
+        self._index_cache[path_str] = index
+
+        # Actualizar índice global de símbolos
+        for sym in index.symbols:
+            self._symbol_index[sym.name].append(sym)
+
+        return index
+
+    def _create_index(self, file_path: Path) -> FileIndex:
+        """Crea el índice de un archivo."""
+        content = self._read_file(file_path)
+        ext = file_path.suffix.lower()
+        language = self.LANGUAGE_EXTENSIONS.get(ext, 'unknown')
+
+        symbols = []
+        imports = []
+        exports = []
+
+        if language == 'python':
+            symbols, imports, exports = self._analyze_python(file_path, content)
+        elif language in ('javascript', 'typescript'):
+            symbols, imports, exports = self._analyze_javascript(file_path, content)
+
+        content_hash = str(hash(content))
+
+        return FileIndex(
+            path=str(file_path),
+            language=language,
+            symbols=symbols,
+            imports=imports,
+            exports=exports,
+            last_modified=time.time(),
+            content_hash=content_hash,
+        )
+
+    def _analyze_python(
+        self,
+        file_path: Path,
+        content: str
+    ) -> Tuple[List[Symbol], List[str], List[str]]:
+        """Analiza código Python."""
+        symbols = []
+        imports = []
+        exports = []
+
+        try:
+            tree = ast.parse(content)
+            lines = content.split('\n')
+        except SyntaxError:
+            return symbols, imports, exports
+
+        # Extraer imports
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    name = alias.asname if alias.asname else alias.name
+                    imports.append(f"import {alias.name}" + (f" as {alias.asname}" if alias.asname else ""))
+            elif isinstance(node, ast.ImportFrom):
+                module = node.module or ""
+                names = ", ".join(alias.name for alias in node.names)
+                imports.append(f"from {module} import {names}")
+
+        # Extraer clases y funciones
+        for node in ast.iter_child_nodes(tree):
+            if isinstance(node, ast.ClassDef):
+                # Docstring
+                docstring = ast.get_docstring(node)
+
+                # Métodos
+                methods = []
+                for item in node.body:
+                    if isinstance(item, ast.FunctionDef):
+                        method_sym = self._create_function_symbol(
+                            item, str(file_path), parent=node.name
+                        )
+                        symbols.append(method_sym)
+                        methods.append(item.name)
+
+                # Símbolo de clase
+                class_sym = Symbol(
+                    name=node.name,
+                    type=SymbolType.CLASS,
+                    file_path=str(file_path),
+                    line_start=node.lineno,
+                    line_end=node.end_lineno or node.lineno,
+                    docstring=docstring,
+                    dependencies=self._extract_class_dependencies(node),
+                )
+                symbols.append(class_sym)
+                exports.append(node.name)
+
+            elif isinstance(node, ast.FunctionDef):
+                func_sym = self._create_function_symbol(node, str(file_path))
+                symbols.append(func_sym)
+                exports.append(node.name)
+
+        return symbols, imports, exports
+
+    def _create_function_symbol(
+        self,
+        node: ast.FunctionDef,
+        file_path: str,
+        parent: Optional[str] = None
+    ) -> Symbol:
+        """Crea un símbolo de función/método."""
+        # Construir firma
+        args = []
+        for arg in node.args.args:
+            arg_str = arg.arg
+            if arg.annotation:
+                arg_str += f": {ast.unparse(arg.annotation)}"
+            args.append(arg_str)
+
+        defaults = node.args.defaults
+        if defaults:
+            for i, default in enumerate(defaults):
+                idx = len(args) - len(defaults) + i
+                if idx < len(args):
+                    args[idx] += f" = {ast.unparse(default)}"
+
+        signature = f"{node.name}({', '.join(args)})"
+        if node.returns:
+            signature += f" -> {ast.unparse(node.returns)}"
+
+        sym_type = SymbolType.METHOD if parent else SymbolType.FUNCTION
+
+        return Symbol(
+            name=node.name,
+            type=sym_type,
+            file_path=file_path,
+            line_start=node.lineno,
+            line_end=node.end_lineno or node.lineno,
+            docstring=ast.get_docstring(node),
+            signature=signature,
+            parent=parent,
+            dependencies=self._extract_function_dependencies(node),
+        )
+
+    def _extract_function_dependencies(self, node: ast.FunctionDef) -> List[str]:
+        """Extrae dependencias de una función."""
+        deps = set()
+
+        for child in ast.walk(node):
+            if isinstance(child, ast.Name):
+                deps.add(child.id)
+            elif isinstance(child, ast.Attribute):
+                if isinstance(child.value, ast.Name):
+                    deps.add(child.value.id)
+
+        # Filtrar builtins y parámetros
+        builtins = {'True', 'False', 'None', 'print', 'len', 'str', 'int', 'list', 'dict', 'set'}
+        params = {arg.arg for arg in node.args.args}
+
+        return list(deps - builtins - params)
+
+    def _extract_class_dependencies(self, node: ast.ClassDef) -> List[str]:
+        """Extrae dependencias de una clase."""
+        deps = set()
+
+        # Herencia
+        for base in node.bases:
+            if isinstance(base, ast.Name):
+                deps.add(base.id)
+
+        # Contenido
+        for child in ast.walk(node):
+            if isinstance(child, ast.Name):
+                deps.add(child.id)
+
+        return list(deps)
+
+    def _analyze_javascript(
+        self,
+        file_path: Path,
+        content: str
+    ) -> Tuple[List[Symbol], List[str], List[str]]:
+        """Analiza código JavaScript/TypeScript."""
+        symbols = []
+        imports = []
+        exports = []
+
+        # Regex patterns para JS/TS
+        import_patterns = [
+            r'import\s+.*?\s+from\s+[\'"]([^\'"]+)[\'"]',
+            r'import\s+[\'"]([^\'"]+)[\'"]',
+            r'require\s*\(\s*[\'"]([^\'"]+)[\'"]\s*\)',
+        ]
+
+        for pattern in import_patterns:
+            for match in re.finditer(pattern, content):
+                imports.append(match.group(0))
+
+        # Funciones
+        func_pattern = r'(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\([^)]*\)'
+        for match in re.finditer(func_pattern, content):
+            name = match.group(1)
+            line_num = content[:match.start()].count('\n') + 1
+            symbols.append(Symbol(
+                name=name,
+                type=SymbolType.FUNCTION,
+                file_path=str(file_path),
+                line_start=line_num,
+                line_end=line_num,  # Simplificado
+            ))
+            exports.append(name)
+
+        # Clases
+        class_pattern = r'(?:export\s+)?class\s+(\w+)'
+        for match in re.finditer(class_pattern, content):
+            name = match.group(1)
+            line_num = content[:match.start()].count('\n') + 1
+            symbols.append(Symbol(
+                name=name,
+                type=SymbolType.CLASS,
+                file_path=str(file_path),
+                line_start=line_num,
+                line_end=line_num,
+            ))
+            exports.append(name)
+
+        return symbols, imports, exports
+
+    def _find_relevant_symbols(
+        self,
+        index: FileIndex,
+        query: str
+    ) -> List[Symbol]:
+        """Encuentra símbolos relevantes basados en la query."""
+        query_lower = query.lower()
+        query_words = set(query_lower.split())
+
+        scored = []
+        for sym in index.symbols:
+            score = 0
+
+            # Nombre del símbolo en query
+            if sym.name.lower() in query_lower:
+                score += 10
+
+            # Palabras del query en nombre o docstring
+            name_lower = sym.name.lower()
+            doc_lower = (sym.docstring or "").lower()
+
+            for word in query_words:
+                if word in name_lower:
+                    score += 3
+                if word in doc_lower:
+                    score += 1
+
+            # Símbolos exportados son más relevantes
+            if sym.exported:
+                score += 2
+
+            if score > 0:
+                scored.append((score, sym))
+
+        # Ordenar por score
+        scored.sort(key=lambda x: -x[0])
+
+        return [sym for _, sym in scored[:10]]
+
+    def _read_file(self, path: Path) -> str:
+        """Lee el contenido de un archivo con cache."""
+        path_str = str(path)
+        if path_str in self._content_cache:
+            return self._content_cache[path_str]
+
+        try:
+            content = path.read_text(encoding="utf-8", errors="replace")
+            # Solo cachear archivos pequeños
+            if len(content) < 100000:
+                self._content_cache[path_str] = content
+            return content
+        except Exception:
+            return ""
+
+    def _resolve_import(self, import_stmt: str, from_file: Path) -> Optional[Path]:
+        """Intenta resolver un import a un archivo."""
+        # Simplificado - busca archivos con el mismo nombre
+        # TODO: Implementar resolución completa de imports
+
+        # Extraer nombre del módulo
+        match = re.search(r'(?:from\s+(\S+)\s+import|import\s+(\S+))', import_stmt)
+        if not match:
+            return None
+
+        module = match.group(1) or match.group(2)
+        if not module:
+            return None
+
+        # Buscar archivo
+        module_path = module.replace('.', '/')
+        for ext in ['.py', '.js', '.ts']:
+            candidate = self.project_root / f"{module_path}{ext}"
+            if candidate.exists():
+                return candidate
+
+        return None
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# INSTANCIA GLOBAL
+# ══════════════════════════════════════════════════════════════════════════════
+
+_loader_instance: Optional[SelectiveLoader] = None
+
+
+def get_selective_loader(project_root: Path = None) -> SelectiveLoader:
+    """Obtiene la instancia global del cargador selectivo."""
+    global _loader_instance
+    if _loader_instance is None or (project_root and _loader_instance.project_root != project_root):
+        _loader_instance = SelectiveLoader(project_root or Path.cwd())
+    return _loader_instance

hanus/error_recovery/__init__.py

@@ -0,0 +1,5 @@
+# hanus/error_recovery/__init__.py
+"""Error recovery and auto-fix system for HanusCode."""
+from .auto_fix import ErrorRecovery, FixSuggestion, ErrorPattern
+
+__all__ = ["ErrorRecovery", "FixSuggestion", "ErrorPattern"]