hanuscode 1.0.0__py3-none-any.whl

hanus/instincts/manager.py

@@ -0,0 +1,343 @@
+# hanus/instincts/manager.py
+"""
+Gestor de instintos.
+
+Maneja el almacenamiento, carga, y persistencia de instintos
+con scope por proyecto y global.
+"""
+from __future__ import annotations
+import json
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+from datetime import datetime
+
+from hanus.instincts.types import (
+    Instinct, InstinctScope, InstinctStatus, InstinctDomain,
+    InstinctEvidence, InstinctGroup, ProjectInfo
+)
+
+
+class InstinctManager:
+    """
+    Gestiona el ciclo de vida de los instintos.
+
+    Los instintos se almacenan en:
+    - ~/.hanus/instincts/global/          - Instintos globales
+    - ~/.hanus/projects/<id>/instincts/    - Instintos del proyecto
+
+    Estructura de archivos:
+    - active/     - Instintos activos
+    - dormant/     - Instintos inactivos
+    - evolved/     - Instintos convertidos en skills
+    - inherited/   - Instintos importados
+    """
+
+    def __init__(self, base_dir: Path = None, project_path: Path = None):
+        self.base_dir = base_dir or Path.home() / ".hanus"
+        self.project_path = project_path or Path.cwd()
+
+        # Directorios
+        self.global_dir = self.base_dir / "instincts" / "global"
+        self.projects_dir = self.base_dir / "projects"
+
+        # Crear directorios si no existen
+        self.global_dir.mkdir(parents=True, exist_ok=True)
+
+        # Detectar proyecto
+        self.project_info = ProjectInfo.from_path(str(self.project_path))
+        self.project_dir = self.projects_dir / self.project_info.id
+        self.project_instincts_dir = self.project_dir / "instincts"
+
+        # Crear estructura de proyecto
+        self._ensure_project_structure()
+
+        # Cache de instintos
+        self._global_instincts: Dict[str, Instinct] = {}
+        self._project_instincts: Dict[str, Instinct] = {}
+        self._loaded = False
+
+    def _ensure_project_structure(self) -> None:
+        """Asegura que la estructura de directorios existe."""
+        for subdir in ["active", "dormant", "evolved", "inherited"]:
+            (self.project_instincts_dir / subdir).mkdir(parents=True, exist_ok=True)
+
+    def load_all(self) -> Tuple[Dict[str, Instinct], Dict[str, Instinct]]:
+        """Carga todos los instintos (globales y del proyecto)."""
+        self._global_instincts = self._load_instincts(self.global_dir)
+        self._project_instincts = self._load_instincts(self.project_instincts_dir)
+        self._loaded = True
+        return self._global_instincts, self._project_instincts
+
+    def _load_instincts(self, base_dir: Path) -> Dict[str, Instinct]:
+        """Carga instintos desde un directorio."""
+        instincts = {}
+
+        for subdir in ["active", "inherited"]:
+            instinct_dir = base_dir / subdir
+            if not instinct_dir.exists():
+                continue
+
+            for file_path in instinct_dir.glob("*.json"):
+                try:
+                    content = file_path.read_text(encoding="utf-8")
+                    data = json.loads(content)
+                    instinct = Instinct.from_dict(data)
+                    instincts[instinct.id] = instinct
+                except Exception as e:
+                    print(f"[InstinctManager] Error loading {file_path}: {e}")
+
+        return instincts
+
+    def get_all_instincts(self) -> Dict[str, Instinct]:
+        """Obtiene todos los instintos aplicables (proyecto + global)."""
+        if not self._loaded:
+            self.load_all()
+
+        # Fusionar con precedencia: proyecto > global
+        all_instincts = {}
+
+        # Primero globales
+        for id_, instinct in self._global_instincts.items():
+            if instinct.status == InstinctStatus.ACTIVE:
+                all_instincts[id_] = instinct
+
+        # Luego proyecto (sobrescribe globales con mismo ID)
+        for id_, instinct in self._project_instincts.items():
+            if instinct.status == InstinctStatus.ACTIVE:
+                all_instincts[id_] = instinct
+
+        return all_instincts
+
+    def get_instinct(self, instinct_id: str) -> Optional[Instinct]:
+        """Obtiene un instinto por ID."""
+        if not self._loaded:
+            self.load_all()
+
+        # Buscar primero en proyecto, luego en global
+        if instinct_id in self._project_instincts:
+            return self._project_instincts[instinct_id]
+        return self._global_instincts.get(instinct_id)
+
+    def add_instinct(self, instinct: Instinct) -> None:
+        """Añade un nuevo instinto."""
+        if instinct.scope == InstinctScope.GLOBAL:
+            self._global_instincts[instinct.id] = instinct
+            self._save_instinct(instinct, self.global_dir)
+        else:
+            instinct.project_id = self.project_info.id
+            self._project_instincts[instinct.id] = instinct
+            self._save_instinct(instinct, self.project_instincts_dir)
+
+    def _save_instinct(self, instinct: Instinct, base_dir: Path) -> None:
+        """Guarda un instinto en disco."""
+        subdir = "active" if instinct.status == InstinctStatus.ACTIVE else "dormant"
+        file_path = base_dir / subdir / f"{instinct.id}.json"
+
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        file_path.write_text(
+            json.dumps(instinct.to_dict(), indent=2, ensure_ascii=False),
+            encoding="utf-8"
+        )
+
+    def update_instinct(self, instinct: Instinct) -> None:
+        """Actualiza un instinto existente."""
+        instinct.updated_at = datetime.now().isoformat()
+
+        if instinct.scope == InstinctScope.GLOBAL:
+            self._global_instincts[instinct.id] = instinct
+            self._save_instinct(instinct, self.global_dir)
+        else:
+            self._project_instincts[instinct.id] = instinct
+            self._save_instinct(instinct, self.project_instincts_dir)
+
+    def record_usage(self, instinct_id: str, success: bool,
+                     evidence: Optional[InstinctEvidence] = None) -> None:
+        """Registra el uso de un instinto."""
+        instinct = self.get_instinct(instinct_id)
+        if not instinct:
+            return
+
+        instinct.last_used = datetime.now().isoformat()
+        instinct.update_confidence(success)
+
+        if evidence:
+            instinct.evidence.append(evidence)
+
+        self.update_instinct(instinct)
+
+    def get_by_domain(self, domain: InstinctDomain) -> List[Instinct]:
+        """Obtiene instintos por dominio."""
+        all_instincts = self.get_all_instincts()
+        return [i for i in all_instincts.values() if i.domain == domain]
+
+    def get_by_confidence(self, min_confidence: float = 0.7) -> List[Instinct]:
+        """Obtiene instintos con confianza mínima."""
+        all_instincts = self.get_all_instincts()
+        return [i for i in all_instincts.values() if i.confidence >= min_confidence]
+
+    def group_by_domain(self) -> InstinctGroup:
+        """Agrupa instintos por dominio."""
+        all_instincts = self.get_all_instincts()
+        groups: InstinctGroup = {}
+
+        for instinct in all_instincts.values():
+            domain = instinct.domain.value
+            if domain not in groups:
+                groups[domain] = []
+            groups[domain].append(instinct)
+
+        return groups
+
+    def search(self, query: str) -> List[Instinct]:
+        """Busca instintos por nombre, descripción o tags."""
+        all_instincts = self.get_all_instincts()
+        query_lower = query.lower()
+
+        results = []
+        for instinct in all_instincts.values():
+            if (query_lower in instinct.name.lower() or
+                query_lower in instinct.description.lower() or
+                query_lower in instinct.trigger.lower() or
+                any(query_lower in tag.lower() for tag in instinct.tags)):
+                results.append(instinct)
+
+        return results
+
+    def export_instincts(self, scope: InstinctScope = None,
+                          min_confidence: float = 0.5,
+                          domains: List[InstinctDomain] = None) -> Dict:
+        """Exporta instintos a formato portable."""
+        if not self._loaded:
+            self.load_all()
+
+        instincts_to_export = []
+
+        if scope == InstinctScope.GLOBAL:
+            instincts_to_export = list(self._global_instincts.values())
+        elif scope == InstinctScope.PROJECT:
+            instincts_to_export = list(self._project_instincts.values())
+        else:
+            instincts_to_export = list(self.get_all_instincts().values())
+
+        # Filtrar
+        filtered = [
+            i for i in instincts_to_export
+            if i.confidence >= min_confidence and
+               (domains is None or i.domain in domains)
+        ]
+
+        return {
+            "version": "1.0",
+            "exported_at": datetime.now().isoformat(),
+            "project": {
+                "id": self.project_info.id,
+                "name": self.project_info.name,
+            } if scope != InstinctScope.GLOBAL else None,
+            "instincts": [i.to_dict() for i in filtered],
+        }
+
+    def import_instincts(self, data: Dict, scope: InstinctScope,
+                         force: bool = False,
+                         min_confidence: float = 0.5) -> Tuple[int, List[str]]:
+        """
+        Importa instintos desde un diccionario.
+
+        Returns:
+            Tuple de (número importados, lista de mensajes)
+        """
+        if not self._loaded:
+            self.load_all()
+
+        imported = 0
+        messages = []
+
+        for instinct_data in data.get("instincts", []):
+            try:
+                instinct = Instinct.from_dict(instinct_data)
+
+                # Filtrar por confianza
+                if instinct.confidence < min_confidence:
+                    messages.append(f"Skipped {instinct.name}: confidence {instinct.confidence} < {min_confidence}")
+                    continue
+
+                # Verificar duplicados
+                existing = self.get_instinct(instinct.id)
+                if existing:
+                    if existing.confidence >= instinct.confidence:
+                        messages.append(f"Skipped {instinct.name}: existing has higher/equal confidence")
+                        continue
+                    if not force:
+                        messages.append(f"Skipped {instinct.name}: duplicate (use --force)")
+                        continue
+
+                # Ajustar scope
+                instinct.scope = scope
+                if scope == InstinctScope.PROJECT:
+                    instinct.project_id = self.project_info.id
+
+                # Guardar en inherited
+                target_dir = (self.project_instincts_dir if scope == InstinctScope.PROJECT
+                              else self.global_dir) / "inherited"
+                file_path = target_dir / f"{instinct.id}.json"
+                file_path.parent.mkdir(parents=True, exist_ok=True)
+                file_path.write_text(
+                    json.dumps(instinct.to_dict(), indent=2, ensure_ascii=False),
+                    encoding="utf-8"
+                )
+
+                imported += 1
+                messages.append(f"Imported: {instinct.name} ({instinct.confidence:.0%})")
+
+            except Exception as e:
+                messages.append(f"Error importing: {e}")
+
+        # Recargar
+        self._loaded = False
+        self.load_all()
+
+        return imported, messages
+
+    def get_stats(self) -> Dict:
+        """Obtiene estadísticas de los instintos."""
+        if not self._loaded:
+            self.load_all()
+
+        global_count = len([i for i in self._global_instincts.values()
+                           if i.status == InstinctStatus.ACTIVE])
+        project_count = len([i for i in self._project_instincts.values()
+                            if i.status == InstinctStatus.ACTIVE])
+
+        # Por dominio
+        by_domain = {}
+        for instinct in self.get_all_instincts().values():
+            domain = instinct.domain.value
+            by_domain[domain] = by_domain.get(domain, 0) + 1
+
+        # Por confianza
+        high_confidence = len([i for i in self.get_all_instincts().values()
+                              if i.confidence >= 0.8])
+
+        return {
+            "total": global_count + project_count,
+            "global": global_count,
+            "project": project_count,
+            "by_domain": by_domain,
+            "high_confidence": high_confidence,
+            "project_info": {
+                "id": self.project_info.id,
+                "name": self.project_info.name,
+            }
+        }
+
+
+# Instancia global
+_manager: Optional[InstinctManager] = None
+
+
+def get_instinct_manager(project_path: Path = None) -> InstinctManager:
+    """Obtiene el gestor de instintos."""
+    global _manager
+    if _manager is None or (project_path and _manager.project_path != project_path):
+        _manager = InstinctManager(project_path=project_path)
+    return _manager

hanus/instincts/types.py

@@ -0,0 +1,253 @@
+# hanus/instincts/types.py
+"""
+Tipos de datos para el sistema de instintos.
+"""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Any
+from enum import Enum
+from datetime import datetime
+import hashlib
+import json
+
+
+class InstinctScope(Enum):
+    """Alcance del instinto."""
+    PROJECT = "project"   # Solo para el proyecto actual
+    GLOBAL = "global"      # Aplica a todos los proyectos
+
+
+class InstinctStatus(Enum):
+    """Estado del instinto."""
+    ACTIVE = "active"      # Activo y siendo usado
+    DORMANT = "dormant"    # No usado recientemente
+    EVOLVED = "evolved"    # Convertido en skill/comando/agente
+
+
+class InstinctDomain(Enum):
+    """Dominios de conocimiento."""
+    WORKFLOW = "workflow"          # Flujos de trabajo
+    SECURITY = "security"          # Seguridad
+    TESTING = "testing"           # Testing
+    PERFORMANCE = "performance"   # Performance
+    PATTERNS = "patterns"         # Patrones de código
+    ARCHITECTURE = "architecture" # Arquitectura
+    DEBUGGING = "debugging"       # Debugging
+    REFACTORING = "refactoring"   # Refactoring
+    DOCUMENTATION = "documentation" # Documentación
+    GIT = "git"                   # Git y versionado
+    DATABASE = "database"         # Base de datos
+    API = "api"                   # APIs
+    UI = "ui"                     # UI/Frontend
+    GENERAL = "general"           # General
+
+
+@dataclass
+class InstinctEvidence:
+    """Evidencia que respalda un instinto."""
+    timestamp: str
+    action: str              # Acción realizada
+    context: str             # Contexto en el que ocurrió
+    outcome: str             # Resultado (success/failure)
+    file_path: Optional[str] = None
+    snippet: Optional[str] = None
+
+    def to_dict(self) -> Dict:
+        return {
+            "timestamp": self.timestamp,
+            "action": self.action,
+            "context": self.context,
+            "outcome": self.outcome,
+            "file_path": self.file_path,
+            "snippet": self.snippet,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'InstinctEvidence':
+        return cls(
+            timestamp=data["timestamp"],
+            action=data["action"],
+            context=data["context"],
+            outcome=data["outcome"],
+            file_path=data.get("file_path"),
+            snippet=data.get("snippet"),
+        )
+
+
+@dataclass
+class Instinct:
+    """
+    Un instinto es un comportamiento aprendido.
+
+    Es atómico, tiene un score de confianza (0.3-0.9), está
+    etiquetado por dominio, respaldado por evidencia, y
+    tiene scope (proyecto o global).
+    """
+    id: str                          # ID único
+    name: str                        # Nombre descriptivo
+    description: str                 # Descripción del comportamiento
+    trigger: str                     # Cuándo aplicar
+    action: str                      # Qué hacer
+    domain: InstinctDomain           # Dominio de conocimiento
+    scope: InstinctScope             # Proyecto o global
+    confidence: float                # 0.3 - 0.9
+    evidence: List[InstinctEvidence] = field(default_factory=list)
+    observations: int = 0            # Número de veces observado
+    successes: int = 0               # Número de éxitos
+    failures: int = 0                # Número de fallos
+    created_at: str = ""
+    updated_at: str = ""
+    last_used: str = ""
+    project_id: Optional[str] = None # ID del proyecto (si scope=project)
+    evolved_to: Optional[str] = None # ID del skill/comando/agente evolucionado
+    status: InstinctStatus = InstinctStatus.ACTIVE
+    tags: List[str] = field(default_factory=list)
+
+    def __post_init__(self):
+        if not self.created_at:
+            self.created_at = datetime.now().isoformat()
+        if not self.updated_at:
+            self.updated_at = self.created_at
+
+    @property
+    def success_rate(self) -> float:
+        """Calcula la tasa de éxito."""
+        total = self.successes + self.failures
+        if total == 0:
+            return 0.5
+        return self.successes / total
+
+    @property
+    def confidence_bar(self) -> str:
+        """Barra de confianza visual."""
+        filled = int(self.confidence * 10)
+        empty = 10 - filled
+        return "█" * filled + "░" * empty
+
+    def update_confidence(self, success: bool) -> None:
+        """Actualiza la confianza basada en un resultado."""
+        # Factor de aprendizaje (más lento conforme más observaciones)
+        alpha = 1.0 / (self.observations + 1)
+
+        if success:
+            # Aumentar confianza, pero nunca más de 0.95
+            self.confidence = min(0.95, self.confidence + alpha * (1 - self.confidence) * 0.5)
+            self.successes += 1
+        else:
+            # Disminuir confianza, pero nunca menos de 0.3
+            self.confidence = max(0.3, self.confidence - alpha * self.confidence * 0.3)
+            self.failures += 1
+
+        self.observations += 1
+        self.updated_at = datetime.now().isoformat()
+
+    def add_evidence(self, evidence: InstinctEvidence) -> None:
+        """Añade evidencia al instinto."""
+        self.evidence.append(evidence)
+        self.update_confidence(evidence.outcome == "success")
+
+    def to_dict(self) -> Dict:
+        """Convierte a diccionario para serialización."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "trigger": self.trigger,
+            "action": self.action,
+            "domain": self.domain.value,
+            "scope": self.scope.value,
+            "confidence": self.confidence,
+            "evidence": [e.to_dict() for e in self.evidence],
+            "observations": self.observations,
+            "successes": self.successes,
+            "failures": self.failures,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "last_used": self.last_used,
+            "project_id": self.project_id,
+            "evolved_to": self.evolved_to,
+            "status": self.status.value,
+            "tags": self.tags,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'Instinct':
+        """Crea desde diccionario."""
+        return cls(
+            id=data["id"],
+            name=data["name"],
+            description=data["description"],
+            trigger=data["trigger"],
+            action=data["action"],
+            domain=InstinctDomain(data["domain"]),
+            scope=InstinctScope(data["scope"]),
+            confidence=data["confidence"],
+            evidence=[InstinctEvidence.from_dict(e) for e in data.get("evidence", [])],
+            observations=data.get("observations", 0),
+            successes=data.get("successes", 0),
+            failures=data.get("failures", 0),
+            created_at=data.get("created_at", ""),
+            updated_at=data.get("updated_at", ""),
+            last_used=data.get("last_used", ""),
+            project_id=data.get("project_id"),
+            evolved_to=data.get("evolved_to"),
+            status=InstinctStatus(data.get("status", "active")),
+            tags=data.get("tags", []),
+        )
+
+    @classmethod
+    def generate_id(cls, name: str, trigger: str) -> str:
+        """Genera un ID único para un instinto."""
+        content = f"{name}:{trigger}"
+        return hashlib.md5(content.encode()).hexdigest()[:12]
+
+
+@dataclass
+class ProjectInfo:
+    """Información del proyecto actual."""
+    id: str
+    name: str
+    path: str
+    remote_url: Optional[str] = None
+
+    @classmethod
+    def from_path(cls, path: str) -> 'ProjectInfo':
+        """Detecta información del proyecto desde el path."""
+        import os
+        import subprocess
+
+        # Intentar obtener git remote
+        remote_url = None
+        try:
+            result = subprocess.run(
+                ["git", "remote", "get-url", "origin"],
+                cwd=path,
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                remote_url = result.stdout.strip()
+        except Exception:
+            pass
+
+        # Generar ID único
+        if remote_url:
+            project_id = hashlib.md5(remote_url.encode()).hexdigest()[:12]
+        else:
+            # Usar path como fallback
+            project_id = hashlib.md5(path.encode()).hexdigest()[:12]
+
+        # Nombre del directorio
+        name = os.path.basename(path)
+
+        return cls(
+            id=project_id,
+            name=name,
+            path=path,
+            remote_url=remote_url,
+        )
+
+
+# Type alias para instintos agrupados
+InstinctGroup = Dict[str, List[Instinct]]

hanus/logger.py

@@ -0,0 +1,81 @@
+# hanus/logger.py — Sistema de logs centralizado
+"""
+Escribe logs a ~/.hanus/logs/hanus_YYYYMMDD.log
+Niveles: DEBUG, INFO, WARN, ERROR
+"""
+from __future__ import annotations
+import logging
+import time
+from pathlib import Path
+from typing import Optional
+
+LOG_DIR = Path.home() / ".hanus" / "logs"
+
+_logger: Optional[logging.Logger] = None
+
+
+def setup(verbose: bool = False) -> logging.Logger:
+    global _logger
+    if _logger:
+        return _logger
+
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    log_file = LOG_DIR / f"hanus_{time.strftime('%Y%m%d')}.log"
+
+    fmt = logging.Formatter(
+        "%(asctime)s  %(levelname)-7s  %(name)s  %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+    fh = logging.FileHandler(log_file, encoding="utf-8")
+    fh.setLevel(logging.DEBUG)
+    fh.setFormatter(fmt)
+
+    _logger = logging.getLogger("hanus")
+    _logger.setLevel(logging.DEBUG if verbose else logging.INFO)
+    _logger.addHandler(fh)
+
+    # No propagar al root logger (evita doble salida)
+    _logger.propagate = False
+
+    return _logger
+
+
+def get() -> logging.Logger:
+    global _logger
+    if _logger is None:
+        _logger = setup()
+    return _logger
+
+
+# Shortcuts
+def debug(msg: str, **kw): get().debug(msg, **kw)
+def info(msg: str, **kw):  get().info(msg, **kw)
+def warn(msg: str, **kw):  get().warning(msg, **kw)
+def error(msg: str, **kw): get().error(msg, **kw)
+
+
+def log_request(provider: str, model: str, n_messages: int, attempt: int = 0):
+    get().info(f"REQUEST  {provider}/{model}  msgs={n_messages}  attempt={attempt}")
+
+
+def log_response(provider: str, model: str, tokens_in: int, tokens_out: int,
+                 cost: float, elapsed: float, stop_reason: str):
+    get().info(
+        f"RESPONSE {provider}/{model}  "
+        f"in={tokens_in} out={tokens_out} cost=${cost:.5f} "
+        f"elapsed={elapsed:.1f}s stop={stop_reason}"
+    )
+
+
+def log_tool(tool: str, args: dict, success: bool, elapsed: float):
+    status = "OK" if success else "FAIL"
+    get().info(f"TOOL     {tool:<20} {status}  elapsed={elapsed:.2f}s  args={str(args)[:120]}")
+
+
+def log_plugin(name: str, args: str, elapsed: float):
+    get().info(f"PLUGIN   {name:<20} elapsed={elapsed:.2f}s  args={args[:80]}")
+
+
+def log_error(ctx: str, exc: Exception):
+    get().error(f"ERROR    {ctx}: {type(exc).__name__}: {exc}")

hanus/memory/__init__.py

@@ -0,0 +1,8 @@
+# hanus/memory/__init__.py
+"""
+Sistema de memoria persistente entre sesiones.
+"""
+from hanus.memory.types import MemoryType, MemoryEntry
+from hanus.memory.manager import MemoryManager
+
+__all__ = ["MemoryType", "MemoryEntry", "MemoryManager"]