hanuscode 1.0.0__py3-none-any.whl

hanus/suggestions/proactive.py

@@ -0,0 +1,451 @@
+# hanus/suggestions/proactive.py
+"""
+Sistema de sugerencias proactivas.
+
+Analiza código durante operaciones de lectura y sugiere mejoras
+sin ser solicitado explícitamente.
+"""
+from __future__ import annotations
+import re
+import ast
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Set, Tuple
+from enum import Enum
+from collections import defaultdict
+
+
+class SuggestionType(Enum):
+    """Tipo de sugerencia."""
+    UNUSED_IMPORT = "unused_import"
+    CODE_DUPLICATION = "code_duplication"
+    MISSING_DOCSTRING = "missing_docstring"
+    COMPLEX_FUNCTION = "complex_function"
+    NAMING_CONVENTION = "naming_convention"
+    SECURITY_ISSUE = "security_issue"
+    PERFORMANCE = "performance"
+    DEPRECATED_USAGE = "deprecated_usage"
+    MISSING_TYPE_HINT = "missing_type_hint"
+    TODO_COMMENT = "todo_comment"
+    HARDCODED_VALUE = "hardcoded_value"
+    ERROR_HANDLING = "error_handling"
+
+
+class SuggestionPriority(Enum):
+    """Prioridad de la sugerencia."""
+    LOW = 1      # Nice to have
+    MEDIUM = 2   # Should fix
+    HIGH = 3     # Important
+    CRITICAL = 4 # Security or correctness issue
+
+
+@dataclass
+class Suggestion:
+    """Una sugerencia proactiva."""
+    id: str
+    type: SuggestionType
+    priority: SuggestionPriority
+    title: str
+    description: str
+    file_path: str
+    line_start: int
+    line_end: int
+    suggestion: str                    # Código sugerido o acción
+    auto_fixable: bool = False
+    fix_template: Optional[str] = None  # Template para auto-fix
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict:
+        return {
+            "id": self.id,
+            "type": self.type.value,
+            "priority": self.priority.value,
+            "title": self.title,
+            "description": self.description,
+            "file_path": self.file_path,
+            "line_start": self.line_start,
+            "line_end": self.line_end,
+            "suggestion": self.suggestion,
+            "auto_fixable": self.auto_fixable,
+            "fix_template": self.fix_template,
+        }
+
+
+class ProactiveSuggester:
+    """
+    Analiza código y genera sugerencias proactivas.
+
+    Características:
+    - Detección de imports sin usar
+    - Detección de código duplicado
+    - Detección de problemas de seguridad
+    - Detección de complejidad excesiva
+    - Detección de convenciones de nombre
+    """
+
+    def __init__(self, proactivity_level: str = "normal"):
+        """
+        Args:
+            proactivity_level: "minimal", "normal", or "aggressive"
+        """
+        self.proactivity_level = proactivity_level
+        self._seen_files: Set[str] = set()
+        self._all_imports: Dict[str, Set[str]] = {}  # file -> imports
+        self._all_functions: Dict[str, List[str]] = {}  # file -> function names
+        self._suggestion_counter = 0
+
+    def analyze_file(
+        self,
+        file_path: str,
+        content: str
+    ) -> List[Suggestion]:
+        """
+        Analiza un archivo y genera sugerencias.
+
+        Args:
+            file_path: Ruta del archivo
+            content: Contenido del archivo
+
+        Returns:
+            Lista de sugerencias encontradas
+        """
+        suggestions = []
+        ext = Path(file_path).suffix.lower()
+
+        # Solo analizar archivos de código
+        if ext not in (".py", ".js", ".ts", ".jsx", ".tsx", ".java", ".go"):
+            return suggestions
+
+        self._seen_files.add(file_path)
+
+        if ext == ".py":
+            suggestions.extend(self._analyze_python(file_path, content))
+        elif ext in (".js", ".ts", ".jsx", ".tsx"):
+            suggestions.extend(self._analyze_javascript(file_path, content))
+
+        return suggestions
+
+    def get_summary(self) -> Dict[str, Any]:
+        """Obtiene un resumen del análisis."""
+        return {
+            "files_analyzed": len(self._seen_files),
+            "total_imports": sum(len(i) for i in self._all_imports.values()),
+            "total_functions": sum(len(f) for f in self._all_functions.values()),
+        }
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # ANÁLISIS PYTHON
+    # ══════════════════════════════════════════════════════════════════════════
+
+    def _analyze_python(self, file_path: str, content: str) -> List[Suggestion]:
+        """Analiza código Python."""
+        suggestions = []
+        lines = content.split('\n')
+
+        try:
+            tree = ast.parse(content)
+        except SyntaxError:
+            # Si hay error de sintaxis, no analizar
+            return suggestions
+
+        # Analizar imports
+        imports = set()
+        import_nodes = []
+
+        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.add(name.split('.')[0])
+                    import_nodes.append((node.lineno, name))
+
+            elif isinstance(node, ast.ImportFrom):
+                module = node.module or ""
+                for alias in node.names:
+                    name = alias.asname if alias.asname else alias.name
+                    imports.add(name)
+                    import_nodes.append((node.lineno, name))
+
+        self._all_imports[file_path] = imports
+
+        # Verificar imports usados
+        used_names = set()
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Name):
+                used_names.add(node.id)
+            elif isinstance(node, ast.Attribute):
+                if isinstance(node.value, ast.Name):
+                    used_names.add(node.value.id)
+
+        unused = imports - used_names - {'__future__'}
+        if unused and self._should_suggest("unused_import"):
+            for line, imp in import_nodes:
+                if imp in unused or imp.split('.')[0] in unused:
+                    suggestions.append(self._create_suggestion(
+                        SuggestionType.UNUSED_IMPORT,
+                        SuggestionPriority.LOW,
+                        "Unused Import",
+                        f"Import '{imp}' is not used in this file",
+                        file_path, line, line,
+                        f"Remove: import {imp}",
+                        auto_fixable=True,
+                        fix_template=f"Remove line {line}"
+                    ))
+
+        # Analizar funciones
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                # Verificar docstring
+                if not ast.get_docstring(node):
+                    if self._should_suggest("missing_docstring"):
+                        suggestions.append(self._create_suggestion(
+                            SuggestionType.MISSING_DOCSTRING,
+                            SuggestionPriority.LOW,
+                            "Missing Docstring",
+                            f"Function '{node.name}' has no docstring",
+                            file_path, node.lineno, node.lineno,
+                            f'Add docstring: """Description"""',
+                        ))
+
+                # Verificar complejidad
+                complexity = self._calculate_complexity(node)
+                if complexity > 10 and self._should_suggest("complex_function"):
+                    suggestions.append(self._create_suggestion(
+                        SuggestionType.COMPLEX_FUNCTION,
+                        SuggestionPriority.MEDIUM,
+                        "Complex Function",
+                        f"Function '{node.name}' has high complexity ({complexity})",
+                        file_path, node.lineno, node.end_lineno or node.lineno,
+                        "Consider breaking into smaller functions",
+                    ))
+
+                # Verificar type hints
+                if not node.returns and self._should_suggest("missing_type_hint"):
+                    suggestions.append(self._create_suggestion(
+                        SuggestionType.MISSING_TYPE_HINT,
+                        SuggestionPriority.LOW,
+                        "Missing Return Type",
+                        f"Function '{node.name}' has no return type hint",
+                        file_path, node.lineno, node.lineno,
+                        "Add return type hint: -> ReturnType",
+                    ))
+
+                # Verificar parámetros sin type hint
+                for arg in node.args.args:
+                    if arg.annotation is None and arg.arg != 'self' and arg.arg != 'cls':
+                        if self._should_suggest("missing_type_hint"):
+                            suggestions.append(self._create_suggestion(
+                                SuggestionType.MISSING_TYPE_HINT,
+                                SuggestionPriority.LOW,
+                                "Missing Parameter Type",
+                                f"Parameter '{arg.arg}' in '{node.name}' has no type hint",
+                                file_path, node.lineno, node.lineno,
+                                f"Add type hint: {arg.arg}: Type",
+                            ))
+
+        # Buscar TODO comments
+        for i, line in enumerate(lines, 1):
+            if 'TODO' in line or 'FIXME' in line or 'XXX' in line:
+                if self._should_suggest("todo_comment"):
+                    suggestions.append(self._create_suggestion(
+                        SuggestionType.TODO_COMMENT,
+                        SuggestionPriority.LOW,
+                        "TODO Comment",
+                        f"Pending task found",
+                        file_path, i, i,
+                        "Consider implementing or tracking this task",
+                    ))
+
+        # Buscar problemas de seguridad potenciales
+        security_patterns = [
+            (r'password\s*=\s*["\'][^"\']+["\']', "Hardcoded password"),
+            (r'api_key\s*=\s*["\'][^"\']+["\']', "Hardcoded API key"),
+            (r'secret\s*=\s*["\'][^"\']+["\']', "Hardcoded secret"),
+            (r'eval\s*\(', "Use of eval() - potential security risk"),
+            (r'exec\s*\(', "Use of exec() - potential security risk"),
+            (r'shell=True', "subprocess with shell=True - potential injection risk"),
+        ]
+
+        for i, line in enumerate(lines, 1):
+            for pattern, message in security_patterns:
+                if re.search(pattern, line, re.IGNORECASE):
+                    if self._should_suggest("security_issue"):
+                        suggestions.append(self._create_suggestion(
+                            SuggestionType.SECURITY_ISSUE,
+                            SuggestionPriority.HIGH,
+                            "Security Issue",
+                            message,
+                            file_path, i, i,
+                            "Review and secure this code",
+                        ))
+
+        # Buscar hardcoded values (IPs, URLs, paths)
+        hardcoded_patterns = [
+            (r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', "Hardcoded IP address"),
+            (r'["\']https?://[^"\']+["\']', "Hardcoded URL"),
+        ]
+
+        for i, line in enumerate(lines, 1):
+            # Skip comments
+            if line.strip().startswith('#'):
+                continue
+            for pattern, message in hardcoded_patterns:
+                if re.search(pattern, line):
+                    if self._should_suggest("hardcoded_value"):
+                        suggestions.append(self._create_suggestion(
+                            SuggestionType.HARDCODED_VALUE,
+                            SuggestionPriority.LOW,
+                            "Hardcoded Value",
+                            message,
+                            file_path, i, i,
+                            "Consider using a configuration file or environment variable",
+                        ))
+
+        return suggestions
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # ANÁLISIS JAVASCRIPT
+    # ══════════════════════════════════════════════════════════════════════════
+
+    def _analyze_javascript(self, file_path: str, content: str) -> List[Suggestion]:
+        """Analiza código JavaScript/TypeScript."""
+        suggestions = []
+        lines = content.split('\n')
+
+        # Buscar console.log
+        for i, line in enumerate(lines, 1):
+            if 'console.log' in line:
+                if self._should_suggest("deprecated_usage"):
+                    suggestions.append(self._create_suggestion(
+                        SuggestionType.DEPRECATED_USAGE,
+                        SuggestionPriority.LOW,
+                        "Console Log",
+                        "console.log found - remove before production",
+                        file_path, i, i,
+                        "Remove or replace with proper logging",
+                    ))
+
+        # Buscar var (debería usar let/const)
+        for i, line in enumerate(lines, 1):
+            if re.search(r'\bvar\s+\w+', line):
+                if self._should_suggest("deprecated_usage"):
+                    suggestions.append(self._create_suggestion(
+                        SuggestionType.DEPRECATED_USAGE,
+                        SuggestionPriority.MEDIUM,
+                        "Use of 'var'",
+                        "Use 'let' or 'const' instead of 'var'",
+                        file_path, i, i,
+                        "Replace 'var' with 'let' or 'const'",
+                    ))
+
+        # Buscar problemas de seguridad
+        security_patterns = [
+            (r'innerHTML\s*=', "innerHTML - potential XSS risk"),
+            (r'dangerouslySetInnerHTML', "dangerouslySetInnerHTML - potential XSS risk"),
+            (r'eval\s*\(', "Use of eval() - potential security risk"),
+            (r'password\s*[=:]\s*["\'][^"\']+["\']', "Hardcoded password"),
+            (r'apiKey\s*[=:]\s*["\'][^"\']+["\']', "Hardcoded API key"),
+        ]
+
+        for i, line in enumerate(lines, 1):
+            for pattern, message in security_patterns:
+                if re.search(pattern, line, re.IGNORECASE):
+                    if self._should_suggest("security_issue"):
+                        suggestions.append(self._create_suggestion(
+                            SuggestionType.SECURITY_ISSUE,
+                            SuggestionPriority.HIGH,
+                            "Security Issue",
+                            message,
+                            file_path, i, i,
+                            "Review and secure this code",
+                        ))
+
+        # Buscar TODO comments
+        for i, line in enumerate(lines, 1):
+            if 'TODO' in line or 'FIXME' in line or 'XXX' in line:
+                if self._should_suggest("todo_comment"):
+                    suggestions.append(self._create_suggestion(
+                        SuggestionType.TODO_COMMENT,
+                        SuggestionPriority.LOW,
+                        "TODO Comment",
+                        "Pending task found",
+                        file_path, i, i,
+                        "Consider implementing or tracking this task",
+                    ))
+
+        return suggestions
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # MÉTODOS PRIVADOS
+    # ══════════════════════════════════════════════════════════════════════════
+
+    def _calculate_complexity(self, node: ast.FunctionDef) -> int:
+        """Calcula la complejidad ciclomática de una función."""
+        complexity = 1  # Base
+
+        for child in ast.walk(node):
+            if isinstance(child, (ast.If, ast.While, ast.For, ast.ExceptHandler)):
+                complexity += 1
+            elif isinstance(child, ast.BoolOp):
+                complexity += len(child.values) - 1
+            elif isinstance(child, ast.comprehension):
+                complexity += 1
+                if child.ifs:
+                    complexity += len(child.ifs)
+
+        return complexity
+
+    def _should_suggest(self, suggestion_type: str) -> bool:
+        """Determina si se debe hacer una sugerencia según el nivel de proactividad."""
+        if self.proactivity_level == "minimal":
+            # Solo sugerencias críticas
+            return suggestion_type in ("security_issue",)
+        elif self.proactivity_level == "normal":
+            # Excluir algunas sugerencias de baja prioridad
+            return suggestion_type not in ("missing_docstring", "todo_comment")
+        else:  # aggressive
+            return True
+
+    def _create_suggestion(
+        self,
+        type: SuggestionType,
+        priority: SuggestionPriority,
+        title: str,
+        description: str,
+        file_path: str,
+        line_start: int,
+        line_end: int,
+        suggestion: str,
+        auto_fixable: bool = False,
+        fix_template: str = None,
+    ) -> Suggestion:
+        """Crea una nueva sugerencia."""
+        self._suggestion_counter += 1
+        return Suggestion(
+            id=f"sugg_{self._suggestion_counter}_{type.value}",
+            type=type,
+            priority=priority,
+            title=title,
+            description=description,
+            file_path=file_path,
+            line_start=line_start,
+            line_end=line_end,
+            suggestion=suggestion,
+            auto_fixable=auto_fixable,
+            fix_template=fix_template,
+        )
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# INSTANCIA GLOBAL
+# ══════════════════════════════════════════════════════════════════════════════
+
+_suggester_instance: Optional[ProactiveSuggester] = None
+
+
+def get_suggester() -> ProactiveSuggester:
+    """Obtiene la instancia global del sugeridor."""
+    global _suggester_instance
+    if _suggester_instance is None:
+        _suggester_instance = ProactiveSuggester()
+    return _suggester_instance

hanus/tasks/__init__.py

@@ -0,0 +1,8 @@
+# hanus/tasks/__init__.py
+"""
+Sistema de tareas integrado en el motor del agente.
+"""
+from hanus.tasks.models import Task, TaskStatus
+from hanus.tasks.manager import TaskManager
+
+__all__ = ["Task", "TaskStatus", "TaskManager"]