hanuscode 1.0.0__py3-none-any.whl

hanus/error_recovery/auto_fix.py

@@ -0,0 +1,605 @@
+# hanus/error_recovery/auto_fix.py
+"""
+Sistema de auto-corrección de errores.
+
+Funcionalidades:
+- Detectar errores en salida de comandos
+- Proponer fixes automáticamente
+- Learning de errores comunes por proyecto
+- Base de conocimiento de soluciones
+"""
+from __future__ import annotations
+import re
+import json
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Callable, Tuple
+from datetime import datetime
+from enum import Enum
+
+
+class ErrorSeverity(Enum):
+    """Severidad del error."""
+    LOW = "low"          # Warning, puede ignorarse
+    MEDIUM = "medium"    # Error pero hay workaround
+    HIGH = "high"        # Error crítico, requiere fix
+    CRITICAL = "critical"  # Error que impide continuar
+
+
+class FixType(Enum):
+    """Tipo de fix sugerido."""
+    COMMAND_FIX = "command_fix"      # Corregir comando
+    FILE_EDIT = "file_edit"          # Editar archivo
+    PACKAGE_INSTALL = "package"       # Instalar paquete
+    CONFIG_CHANGE = "config"          # Cambiar configuración
+    PERMISSION_FIX = "permission"     # Arreglar permisos
+    ENVIRONMENT = "environment"       # Problema de entorno
+    SYNTAX_FIX = "syntax"             # Error de sintaxis
+    DEPENDENCY = "dependency"         # Problema de dependencia
+
+
+@dataclass
+class ErrorPattern:
+    """Patrón de error reconocido."""
+    id: str
+    name: str
+    pattern: str                      # Regex pattern
+    severity: ErrorSeverity
+    fix_type: FixType
+    description: str
+    fix_template: str                 # Template para el fix
+    fix_command: Optional[str] = None  # Comando para arreglar
+    auto_fixable: bool = True
+    tags: List[str] = field(default_factory=list)
+
+
+@dataclass
+class FixSuggestion:
+    """Sugerencia de fix para un error."""
+    error_id: str
+    error_message: str
+    error_type: str
+    severity: ErrorSeverity
+    fix_type: FixType
+    description: str
+    fix_command: Optional[str] = None
+    fix_file: Optional[str] = None
+    fix_content: Optional[str] = None
+    confidence: float = 0.0           # 0-1, confianza en el fix
+    auto_apply: bool = False          # Si se puede aplicar automáticamente
+    requires_confirmation: bool = True
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict:
+        return {
+            "error_id": self.error_id,
+            "error_message": self.error_message,
+            "error_type": self.error_type,
+            "severity": self.severity.value,
+            "fix_type": self.fix_type.value,
+            "description": self.description,
+            "fix_command": self.fix_command,
+            "fix_file": self.fix_file,
+            "fix_content": self.fix_content,
+            "confidence": self.confidence,
+            "auto_apply": self.auto_apply,
+            "requires_confirmation": self.requires_confirmation,
+        }
+
+
+class ErrorRecovery:
+    """
+    Sistema de detección y corrección automática de errores.
+
+    Características:
+    - Patrones de error predefinidos
+    - Learning de errores del proyecto
+    - Sugerencias de fix con confianza
+    - Auto-aplicación de fixes seguros
+    """
+
+    # Patrones de error predefinidos
+    BUILTIN_PATTERNS = [
+        # Python errors
+        ErrorPattern(
+            id="python_module_not_found",
+            name="Module Not Found",
+            pattern=r"ModuleNotFoundError: No module named '([^']+)'",
+            severity=ErrorSeverity.HIGH,
+            fix_type=FixType.PACKAGE_INSTALL,
+            description="Missing Python module",
+            fix_template="pip install {module}",
+            fix_command="pip install {module}",
+            auto_fixable=True,
+            tags=["python", "import"]
+        ),
+        ErrorPattern(
+            id="python_syntax_error",
+            name="Syntax Error",
+            pattern=r"SyntaxError: (.+)",
+            severity=ErrorSeverity.HIGH,
+            fix_type=FixType.SYNTAX_FIX,
+            description="Python syntax error",
+            fix_template="Check syntax in file",
+            auto_fixable=False,
+            tags=["python", "syntax"]
+        ),
+        ErrorPattern(
+            id="python_indentation_error",
+            name="Indentation Error",
+            pattern=r"IndentationError: (.+)",
+            severity=ErrorSeverity.HIGH,
+            fix_type=FixType.SYNTAX_FIX,
+            description="Python indentation error",
+            fix_template="Fix indentation",
+            auto_fixable=False,
+            tags=["python", "indentation"]
+        ),
+        ErrorPattern(
+            id="python_attribute_error",
+            name="Attribute Error",
+            pattern=r"AttributeError: '(\w+)' object has no attribute '(\w+)'",
+            severity=ErrorSeverity.MEDIUM,
+            fix_type=FixType.FILE_EDIT,
+            description="Object missing attribute",
+            fix_template="Check if attribute exists or object type is correct",
+            auto_fixable=False,
+            tags=["python", "attribute"]
+        ),
+        ErrorPattern(
+            id="python_type_error",
+            name="Type Error",
+            pattern=r"TypeError: (.+)",
+            severity=ErrorSeverity.MEDIUM,
+            fix_type=FixType.FILE_EDIT,
+            description="Type mismatch",
+            fix_template="Check types and conversions",
+            auto_fixable=False,
+            tags=["python", "type"]
+        ),
+        ErrorPattern(
+            id="python_index_error",
+            name="Index Error",
+            pattern=r"IndexError: (.+)",
+            severity=ErrorSeverity.MEDIUM,
+            fix_type=FixType.FILE_EDIT,
+            description="List index out of range",
+            fix_template="Check list length before indexing",
+            auto_fixable=False,
+            tags=["python", "index"]
+        ),
+        ErrorPattern(
+            id="python_key_error",
+            name="Key Error",
+            pattern=r"KeyError: '([^']+)'",
+            severity=ErrorSeverity.MEDIUM,
+            fix_type=FixType.FILE_EDIT,
+            description="Dictionary key not found",
+            fix_template="Check if key exists: if '{key}' in dict:",
+            auto_fixable=False,
+            tags=["python", "dict"]
+        ),
+        ErrorPattern(
+            id="python_file_not_found",
+            name="File Not Found",
+            pattern=r"FileNotFoundError: \[Errno 2\] No such file or directory: '([^']+)'",
+            severity=ErrorSeverity.HIGH,
+            fix_type=FixType.FILE_EDIT,
+            description="File does not exist",
+            fix_template="Create file or check path",
+            auto_fixable=False,
+            tags=["python", "file"]
+        ),
+
+        # Node.js errors
+        ErrorPattern(
+            id="node_module_not_found",
+            name="Node Module Not Found",
+            pattern=r"Error: Cannot find module '([^']+)'",
+            severity=ErrorSeverity.HIGH,
+            fix_type=FixType.PACKAGE_INSTALL,
+            description="Missing Node.js module",
+            fix_template="npm install {module}",
+            fix_command="npm install {module}",
+            auto_fixable=True,
+            tags=["nodejs", "import"]
+        ),
+        ErrorPattern(
+            id="node_syntax_error",
+            name="JavaScript Syntax Error",
+            pattern=r"SyntaxError: (.+)",
+            severity=ErrorSeverity.HIGH,
+            fix_type=FixType.SYNTAX_FIX,
+            description="JavaScript syntax error",
+            fix_template="Check syntax",
+            auto_fixable=False,
+            tags=["nodejs", "syntax"]
+        ),
+
+        # Git errors
+        ErrorPattern(
+            id="git_not_a_repository",
+            name="Not a Git Repository",
+            pattern=r"fatal: not a git repository",
+            severity=ErrorSeverity.HIGH,
+            fix_type=FixType.COMMAND_FIX,
+            description="Not in a git repository",
+            fix_template="git init",
+            fix_command="git init",
+            auto_fixable=True,
+            tags=["git"]
+        ),
+        ErrorPattern(
+            id="git_merge_conflict",
+            name="Git Merge Conflict",
+            pattern=r"CONFLICT \\(content\\): Merge conflict in (.+)",
+            severity=ErrorSeverity.HIGH,
+            fix_type=FixType.FILE_EDIT,
+            description="Merge conflict in file",
+            fix_template="Resolve conflicts in {file}",
+            auto_fixable=False,
+            tags=["git", "merge"]
+        ),
+        ErrorPattern(
+            id="git_uncommitted_changes",
+            name="Uncommitted Changes",
+            pattern=r"error: Your local changes to the following files would be overwritten",
+            severity=ErrorSeverity.MEDIUM,
+            fix_type=FixType.COMMAND_FIX,
+            description="Uncommitted local changes",
+            fix_template="git stash or commit changes",
+            auto_fixable=False,
+            tags=["git"]
+        ),
+
+        # Permission errors
+        ErrorPattern(
+            id="permission_denied",
+            name="Permission Denied",
+            pattern=r"Permission denied: '([^']+)'|EACCES: permission denied",
+            severity=ErrorSeverity.HIGH,
+            fix_type=FixType.PERMISSION_FIX,
+            description="Permission denied",
+            fix_template="chmod +x {file} or run with sudo",
+            fix_command="chmod +x {file}",
+            auto_fixable=True,
+            tags=["permission"]
+        ),
+
+        # Command not found
+        ErrorPattern(
+            id="command_not_found",
+            name="Command Not Found",
+            pattern=r"command not found: (\w+)|'(\w+)' is not recognized",
+            severity=ErrorSeverity.HIGH,
+            fix_type=FixType.ENVIRONMENT,
+            description="Command not installed or not in PATH",
+            fix_template="Install {command} or check PATH",
+            auto_fixable=False,
+            tags=["environment", "command"]
+        ),
+
+        # Network errors
+        ErrorPattern(
+            id="connection_refused",
+            name="Connection Refused",
+            pattern=r"Connection refused|ECONNREFUSED",
+            severity=ErrorSeverity.MEDIUM,
+            fix_type=FixType.ENVIRONMENT,
+            description="Cannot connect to server",
+            fix_template="Check if service is running",
+            auto_fixable=False,
+            tags=["network"]
+        ),
+        ErrorPattern(
+            id="dns_resolution",
+            name="DNS Resolution Failed",
+            pattern=r"getaddrinfo ENOTFOUND|Temporary failure in name resolution",
+            severity=ErrorSeverity.MEDIUM,
+            fix_type=FixType.ENVIRONMENT,
+            description="DNS resolution failed",
+            fix_template="Check internet connection or DNS settings",
+            auto_fixable=False,
+            tags=["network", "dns"]
+        ),
+
+        # Build errors
+        ErrorPattern(
+            id="missing_make_target",
+            name="Missing Make Target",
+            pattern=r"make: \*\*\* No rule to make target '([^']+)'.",
+            severity=ErrorSeverity.MEDIUM,
+            fix_type=FixType.FILE_EDIT,
+            description="Makefile missing target",
+            fix_template="Add target to Makefile or check spelling",
+            auto_fixable=False,
+            tags=["build", "make"]
+        ),
+    ]
+
+    def __init__(self, project_dir: Optional[Path] = None):
+        self.project_dir = project_dir or Path.cwd()
+
+        # Patrones de error (builtins + aprendidos)
+        self._patterns: Dict[str, ErrorPattern] = {p.id: p for p in self.BUILTIN_PATTERNS}
+        self._learned_patterns: Dict[str, ErrorPattern] = {}
+
+        # Historial de errores del proyecto
+        self._error_history: List[Dict] = []
+
+        # Base de conocimiento de fixes aplicados
+        self._fixes_applied: Dict[str, int] = {}  # error_id -> count
+
+        # Archivos de persistencia
+        self._learned_file = Path.home() / ".hanus" / "error_recovery" / "learned_patterns.json"
+        self._history_file = Path.home() / ".hanus" / "error_recovery" / "history.json"
+        self._load_learned()
+
+    def analyze_error(self, output: str) -> Optional[FixSuggestion]:
+        """
+        Analiza la salida de un comando para detectar errores y sugerir fixes.
+
+        Args:
+            output: Salida del comando (stdout + stderr)
+
+        Returns:
+            FixSuggestion si se encontró un error conocido, None si no
+        """
+        # Buscar en patrones builtin y aprendidos
+        all_patterns = {**self._patterns, **self._learned_patterns}
+
+        for pattern in all_patterns.values():
+            match = re.search(pattern.pattern, output, re.IGNORECASE | re.MULTILINE)
+            if match:
+                suggestion = self._create_suggestion(pattern, match, output)
+                self._record_error(suggestion)
+                return suggestion
+
+        # Si no encontramos patrón, intentar análisis genérico
+        generic = self._generic_error_analysis(output)
+        if generic:
+            self._record_error(generic)
+            return generic
+
+        return None
+
+    def apply_fix(self, suggestion: FixSuggestion) -> Tuple[bool, str]:
+        """
+        Aplica un fix sugerido.
+
+        Args:
+            suggestion: La sugerencia de fix
+
+        Returns:
+            (success, message)
+        """
+        if not suggestion.auto_apply and suggestion.requires_confirmation:
+            return False, "This fix requires confirmation before applying"
+
+        if suggestion.fix_type == FixType.PACKAGE_INSTALL and suggestion.fix_command:
+            # Registrar fix aplicado
+            self._fixes_applied[suggestion.error_id] = self._fixes_applied.get(suggestion.error_id, 0) + 1
+            return True, f"Run: {suggestion.fix_command}"
+
+        if suggestion.fix_type == FixType.COMMAND_FIX and suggestion.fix_command:
+            self._fixes_applied[suggestion.error_id] = self._fixes_applied.get(suggestion.error_id, 0) + 1
+            return True, f"Run: {suggestion.fix_command}"
+
+        if suggestion.fix_type == FixType.FILE_EDIT and suggestion.fix_file:
+            self._fixes_applied[suggestion.error_id] = self._fixes_applied.get(suggestion.error_id, 0) + 1
+            return True, f"Edit {suggestion.fix_file}: {suggestion.description}"
+
+        return False, "No automatic fix available"
+
+    def learn_from_fix(self, error_message: str, fix_description: str, fix_command: str = None):
+        """
+        Aprende de un fix aplicado para futuras sugerencias.
+
+        Args:
+            error_message: El mensaje de error original
+            fix_description: Descripción del fix aplicado
+            fix_command: Comando ejecutado para arreglar (si aplica)
+        """
+        # Crear patrón simple
+        pattern_id = f"learned_{int(time.time())}"
+
+        # Extraer patrón del error
+        # Simplificar el mensaje para crear un patrón regex básico
+        simplified = re.escape(error_message[:50])
+        simplified = re.sub(r'\\s+', r'\\s+', simplified)
+
+        pattern = ErrorPattern(
+            id=pattern_id,
+            name=f"Learned: {fix_description[:30]}",
+            pattern=simplified,
+            severity=ErrorSeverity.MEDIUM,
+            fix_type=FixType.COMMAND_FIX if fix_command else FixType.FILE_EDIT,
+            description=fix_description,
+            fix_template=fix_description,
+            fix_command=fix_command,
+            auto_fixable=bool(fix_command),
+            tags=["learned"]
+        )
+
+        self._learned_patterns[pattern_id] = pattern
+        self._save_learned()
+
+    def get_error_stats(self) -> Dict[str, Any]:
+        """Obtiene estadísticas de errores."""
+        return {
+            "total_errors": len(self._error_history),
+            "patterns_known": len(self._patterns) + len(self._learned_patterns),
+            "learned_patterns": len(self._learned_patterns),
+            "fixes_applied": sum(self._fixes_applied.values()),
+            "top_errors": sorted(
+                self._fixes_applied.items(),
+                key=lambda x: -x[1]
+            )[:5],
+        }
+
+    def get_error_history(self, limit: int = 50) -> List[Dict]:
+        """Obtiene el historial de errores."""
+        return self._error_history[-limit:]
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # MÉTODOS PRIVADOS
+    # ══════════════════════════════════════════════════════════════════════════
+
+    def _create_suggestion(
+        self,
+        pattern: ErrorPattern,
+        match: re.Match,
+        output: str
+    ) -> FixSuggestion:
+        """Crea una sugerencia de fix a partir de un patrón encontrado."""
+
+        # Extraer grupos del match para personalizar el fix
+        groups = match.groups() if match.groups() else []
+        group_dict = match.groupdict() if hasattr(match, 'groupdict') else {}
+
+        # Personalizar fix con grupos capturados
+        fix_command = pattern.fix_command
+        fix_template = pattern.fix_template
+
+        if groups:
+            # Primer grupo como variable principal
+            main_var = groups[0] if groups else ""
+            if fix_command:
+                fix_command = fix_command.format(module=main_var, file=main_var, command=main_var, key=main_var)
+            fix_template = fix_template.format(module=main_var, file=main_var, command=main_var, key=main_var)
+
+        # Calcular confianza basada en historial
+        confidence = 0.5
+        if pattern.id in self._fixes_applied:
+            # Más confianza si el fix se ha aplicado antes con éxito
+            confidence = min(0.95, 0.5 + self._fixes_applied[pattern.id] * 0.1)
+
+        return FixSuggestion(
+            error_id=pattern.id,
+            error_message=match.group(0),
+            error_type=pattern.name,
+            severity=pattern.severity,
+            fix_type=pattern.fix_type,
+            description=fix_template,
+            fix_command=fix_command,
+            confidence=confidence,
+            auto_apply=pattern.auto_fixable and confidence > 0.7,
+            requires_confirmation=not pattern.auto_fixable,
+            metadata={"pattern": pattern.id, "groups": groups}
+        )
+
+    def _generic_error_analysis(self, output: str) -> Optional[FixSuggestion]:
+        """Análisis genérico cuando no hay patrón conocido."""
+        # Buscar palabras clave de error
+        error_keywords = ["error", "failed", "exception", "fatal", "critical"]
+
+        for keyword in error_keywords:
+            if keyword in output.lower():
+                # Encontrar la línea con el error
+                lines = output.split('\n')
+                error_line = None
+                for line in lines:
+                    if keyword in line.lower():
+                        error_line = line.strip()
+                        break
+
+                if error_line:
+                    return FixSuggestion(
+                        error_id="generic",
+                        error_message=error_line[:200],
+                        error_type="Generic Error",
+                        severity=ErrorSeverity.MEDIUM,
+                        fix_type=FixType.FILE_EDIT,
+                        description="Review error and fix manually",
+                        confidence=0.3,
+                        auto_apply=False,
+                        requires_confirmation=True,
+                    )
+
+        return None
+
+    def _record_error(self, suggestion: FixSuggestion) -> None:
+        """Registra un error en el historial."""
+        self._error_history.append({
+            "timestamp": time.time(),
+            "error_id": suggestion.error_id,
+            "error_type": suggestion.error_type,
+            "error_message": suggestion.error_message[:200],
+            "severity": suggestion.severity.value,
+        })
+
+        # Limitar historial
+        if len(self._error_history) > 1000:
+            self._error_history = self._error_history[-500:]
+
+    def _load_learned(self) -> None:
+        """Carga patrones aprendidos desde disco."""
+        if self._learned_file.exists():
+            try:
+                data = json.loads(self._learned_file.read_text(encoding="utf-8"))
+                for pattern_data in data.get("patterns", []):
+                    pattern = ErrorPattern(
+                        id=pattern_data["id"],
+                        name=pattern_data["name"],
+                        pattern=pattern_data["pattern"],
+                        severity=ErrorSeverity(pattern_data["severity"]),
+                        fix_type=FixType(pattern_data["fix_type"]),
+                        description=pattern_data["description"],
+                        fix_template=pattern_data["fix_template"],
+                        fix_command=pattern_data.get("fix_command"),
+                        auto_fixable=pattern_data.get("auto_fixable", False),
+                        tags=pattern_data.get("tags", []),
+                    )
+                    self._learned_patterns[pattern.id] = pattern
+
+                self._fixes_applied = data.get("fixes_applied", {})
+            except Exception:
+                pass
+
+    def _save_learned(self) -> None:
+        """Guarda patrones aprendidos a disco."""
+        try:
+            self._learned_file.parent.mkdir(parents=True, exist_ok=True)
+
+            data = {
+                "patterns": [
+                    {
+                        "id": p.id,
+                        "name": p.name,
+                        "pattern": p.pattern,
+                        "severity": p.severity.value,
+                        "fix_type": p.fix_type.value,
+                        "description": p.description,
+                        "fix_template": p.fix_template,
+                        "fix_command": p.fix_command,
+                        "auto_fixable": p.auto_fixable,
+                        "tags": p.tags,
+                    }
+                    for p in self._learned_patterns.values()
+                ],
+                "fixes_applied": self._fixes_applied,
+                "updated": datetime.now().isoformat(),
+            }
+
+            self._learned_file.write_text(
+                json.dumps(data, indent=2, ensure_ascii=False),
+                encoding="utf-8"
+            )
+        except Exception:
+            pass
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# INSTANCIA GLOBAL
+# ══════════════════════════════════════════════════════════════════════════════
+
+_recovery_instance: Optional[ErrorRecovery] = None
+
+
+def get_error_recovery() -> ErrorRecovery:
+    """Obtiene la instancia global del sistema de recuperación."""
+    global _recovery_instance
+    if _recovery_instance is None:
+        _recovery_instance = ErrorRecovery()
+    return _recovery_instance

hanus/hooks/__init__.py

@@ -0,0 +1,5 @@
+# hanus/hooks/__init__.py
+"""Lifecycle hooks for HanusCode."""
+from .manager import HookManager, hook, HookType
+
+__all__ = ["HookManager", "hook", "HookType"]