hanuscode 1.0.0__py3-none-any.whl

hanus/instincts/detector.py

@@ -0,0 +1,281 @@
+# hanus/instincts/detector.py
+"""
+Detector de patrones para crear instintos desde sesiones.
+
+Analiza las interacciones y detecta patrones que pueden convertirse
+en instintos.
+"""
+from __future__ import annotations
+import re
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Set, Tuple
+from collections import Counter
+from datetime import datetime
+
+from hanus.instincts.types import (
+    Instinct, InstinctScope, InstinctDomain, InstinctEvidence
+)
+
+
+@dataclass
+class SessionAction:
+    """Acción realizada en una sesión."""
+    timestamp: str
+    tool: str                  # Herramienta usada (read, write, edit, bash, etc.)
+    action: str                # Acción específica
+    context: str               # Contexto (archivo, comando, etc.)
+    outcome: str               # success/failure
+    metadata: Dict = field(default_factory=dict)
+
+
+@dataclass
+class Pattern:
+    """Patrón detectado en las acciones."""
+    name: str
+    trigger: str               # Cuándo aplicar
+    actions: List[str]         # Secuencia de acciones
+    frequency: int             # Frecuencia de aparición
+    confidence: float          # Confianza del patrón
+    domain: InstinctDomain
+    evidence: List[SessionAction] = field(default_factory=list)
+
+
+class PatternDetector:
+    """
+    Detecta patrones en sesiones que pueden convertirse en instintos.
+
+    Tipos de patrones detectados:
+    1. WORKFLOW: Secuencia de acciones repetidas
+    2. ERROR_RECOVERY: Respuestas a errores
+    3. CODE_STYLE: Preferencias de código
+    4. SECURITY: Comportamientos de seguridad
+    5. TESTING: Patrones de testing
+    """
+
+    # Patrones predefinidos que buscamos
+    PREDEFINED_PATTERNS = {
+        "read_before_edit": {
+            "trigger": "when modifying code",
+            "domain": InstinctDomain.WORKFLOW,
+            "pattern": [
+                ("read", "before", "edit"),
+            ],
+        },
+        "test_after_write": {
+            "trigger": "when writing new code",
+            "domain": InstinctDomain.TESTING,
+            "pattern": [
+                ("write", "then", "test"),
+            ],
+        },
+        "validate_input": {
+            "trigger": "when handling user input",
+            "domain": InstinctDomain.SECURITY,
+            "pattern": [
+                ("validate", "before", "process"),
+            ],
+        },
+        "grep_for_context": {
+            "trigger": "when understanding codebase",
+            "domain": InstinctDomain.WORKFLOW,
+            "pattern": [
+                ("grep", "before", "modify"),
+            ],
+        },
+        "commit_after_changes": {
+            "trigger": "when completing feature",
+            "domain": InstinctDomain.GIT,
+            "pattern": [
+                ("test", "then", "commit"),
+            ],
+        },
+        "check_types": {
+            "trigger": "when modifying TypeScript/Python",
+            "domain": InstinctDomain.WORKFLOW,
+            "pattern": [
+                ("edit", "then", "typecheck"),
+            ],
+        },
+        "security_review": {
+            "trigger": "when handling sensitive data",
+            "domain": InstinctDomain.SECURITY,
+            "pattern": [
+                ("check", "secrets", "before"),
+                ("validate", "input", "always"),
+            ],
+        },
+    }
+
+    def __init__(self, min_frequency: int = 2, min_confidence: float = 0.3):
+        self.min_frequency = min_frequency
+        self.min_confidence = min_confidence
+        self._actions: List[SessionAction] = []
+        self._detected_patterns: Dict[str, Pattern] = {}
+
+    def record_action(self, action: SessionAction) -> None:
+        """Registra una acción para análisis."""
+        self._actions.append(action)
+
+    def analyze_session(self, actions: List[SessionAction]) -> List[Pattern]:
+        """
+        Analiza una sesión y detecta patrones.
+
+        Returns:
+            Lista de patrones detectados
+        """
+        self._actions = actions
+        patterns = []
+
+        # Detectar patrones predefinidos
+        for pattern_name, pattern_def in self.PREDEFINED_PATTERNS.items():
+            detected = self._detect_pattern(pattern_name, pattern_def)
+            if detected:
+                patterns.append(detected)
+
+        # Detectar patrones de secuencia
+        sequence_patterns = self._detect_sequence_patterns()
+        patterns.extend(sequence_patterns)
+
+        # Detectar patrones de error/recovery
+        error_patterns = self._detect_error_recovery_patterns()
+        patterns.extend(error_patterns)
+
+        return patterns
+
+    def _detect_pattern(self, name: str, definition: Dict) -> Optional[Pattern]:
+        """Detecta si un patrón predefinido aparece en las acciones."""
+        matching_actions = []
+
+        for action in self._actions:
+            # Verificar si la acción coincide con el patrón
+            for pattern_part in definition["pattern"]:
+                if self._action_matches_pattern(action, pattern_part):
+                    matching_actions.append(action)
+
+        # Calcular frecuencia y confianza
+        frequency = len(matching_actions)
+        if frequency < self.min_frequency:
+            return None
+
+        # Calcular confianza basada en frecuencia y consistencia
+        confidence = min(0.9, 0.3 + (frequency * 0.1))
+
+        return Pattern(
+            name=name,
+            trigger=definition["trigger"],
+            actions=[a.action for a in matching_actions],
+            frequency=frequency,
+            confidence=confidence,
+            domain=definition["domain"],
+            evidence=matching_actions,
+        )
+
+    def _action_matches_pattern(self, action: SessionAction, pattern_part: Tuple) -> bool:
+        """Verifica si una acción coincide con un patrón."""
+        # Implementación simplificada
+        tool_match = pattern_part[0] in action.tool.lower()
+        action_match = pattern_part[1] in action.action.lower()
+        return tool_match and action_match
+
+    def _detect_sequence_patterns(self) -> List[Pattern]:
+        """Detecta patrones de secuencia (acciones que ocurren en orden)."""
+        patterns = []
+
+        # Buscar secuencias de 2-4 acciones que se repiten
+        for length in range(2, 5):
+            sequences = []
+            for i in range(len(self._actions) - length + 1):
+                seq = tuple(a.tool for a in self._actions[i:i+length])
+                sequences.append(seq)
+
+            # Contar frecuencias
+            counter = Counter(sequences)
+
+            for seq, freq in counter.most_common():
+                if freq >= self.min_frequency:
+                    # Generar patrón
+                    pattern_name = "-".join(seq)
+                    trigger = f"when performing {seq[0]}"
+
+                    patterns.append(Pattern(
+                        name=pattern_name,
+                        trigger=trigger,
+                        actions=list(seq),
+                        frequency=freq,
+                        confidence=min(0.9, 0.3 + (freq * 0.1)),
+                        domain=InstinctDomain.WORKFLOW,
+                        evidence=[a for a in self._actions if a.tool in seq],
+                    ))
+
+        return patterns
+
+    def _detect_error_recovery_patterns(self) -> List[Pattern]:
+        """Detecta patrones de recuperación de errores."""
+        patterns = []
+
+        # Buscar fallos seguidos de acciones correctivas
+        for i, action in enumerate(self._actions):
+            if action.outcome == "failure":
+                # Ver qué acciones siguen al fallo
+                recovery_actions = []
+                for j in range(i + 1, min(i + 5, len(self._actions))):
+                    if self._actions[j].outcome == "success":
+                        recovery_actions.append(self._actions[j])
+
+                if recovery_actions:
+                    pattern_name = f"recover-from-{action.tool}"
+                    patterns.append(Pattern(
+                        name=pattern_name,
+                        trigger=f"when {action.tool} fails",
+                        actions=[a.action for a in recovery_actions],
+                        frequency=1,
+                        confidence=0.5,
+                        domain=InstinctDomain.DEBUGGING,
+                        evidence=[action] + recovery_actions,
+                    ))
+
+        return patterns
+
+    def create_instinct_from_pattern(self, pattern: Pattern,
+                                      scope: InstinctScope = InstinctScope.PROJECT) -> Instinct:
+        """Crea un instinto desde un patrón detectado."""
+        evidence = [
+            InstinctEvidence(
+                timestamp=a.timestamp,
+                action=a.action,
+                context=a.context,
+                outcome=a.outcome,
+                file_path=a.metadata.get("file_path"),
+                snippet=a.metadata.get("snippet"),
+            )
+            for a in pattern.evidence
+        ]
+
+        return Instinct(
+            id=Instinct.generate_id(pattern.name, pattern.trigger),
+            name=pattern.name,
+            description=f"Learned behavior: {pattern.trigger}",
+            trigger=pattern.trigger,
+            action=", ".join(pattern.actions[:3]),  # Top 3 actions
+            domain=pattern.domain,
+            scope=scope,
+            confidence=pattern.confidence,
+            evidence=evidence,
+            observations=pattern.frequency,
+            successes=pattern.frequency,  # Asumimos éxito
+            failures=0,
+        )
+
+    def get_pattern_summary(self) -> Dict:
+        """Obtiene un resumen de los patrones detectados."""
+        return {
+            "total_actions": len(self._actions),
+            "patterns_detected": len(self._detected_patterns),
+            "by_domain": {
+                domain.value: len([p for p in self._detected_patterns.values()
+                                   if p.domain == domain])
+                for domain in InstinctDomain
+            },
+            "high_confidence": len([p for p in self._detected_patterns.values()
+                                   if p.confidence >= 0.8]),
+        }

hanus/instincts/evolver.py

@@ -0,0 +1,361 @@
+# hanus/instincts/evolver.py
+"""
+Evolucionador de instintos.
+
+Analiza instintos y los agrupa en estructuras de mayor nivel:
+- Skills: Comportamientos auto-triggered
+- Commands: Acciones invocadas por usuario
+- Agents: Procesos multi-paso complejos
+"""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Tuple
+from collections import defaultdict
+from datetime import datetime
+
+from hanus.instincts.types import (
+    Instinct, InstinctScope, InstinctDomain, InstinctStatus
+)
+from hanus.instincts.manager import InstinctManager
+
+
+@dataclass
+class EvolutionCandidate:
+    """Candidato para evolución."""
+    name: str
+    type: str                  # "skill", "command", "agent"
+    instincts: List[Instinct]
+    avg_confidence: float
+    domains: List[InstinctDomain]
+    scope: InstinctScope
+    reason: str                # Por qué es candidato
+
+
+@dataclass
+class EvolvedStructure:
+    """Estructura evolucionada."""
+    name: str
+    type: str                  # "skill", "command", "agent"
+    description: str
+    instincts: List[str]       # IDs de instintos origen
+    content: str              # Contenido generado
+    scope: InstinctScope
+    created_at: str = field(default_factory=lambda: datetime.now().isoformat())
+
+
+class InstinctEvolver:
+    """
+    Analiza instintos y sugiere o genera estructuras evolucionadas.
+
+    Reglas de evolución:
+    - → Command: Cuando instintos describen acciones invocadas por usuario
+    - → Skill: Cuando instintos describen comportamientos auto-triggered
+    - → Agent: Cuando instintos describen procesos multi-paso complejos
+    """
+
+    # Umbrales
+    MIN_INSTINCTS_FOR_SKILL = 2
+    MIN_INSTINCTS_FOR_COMMAND = 2
+    MIN_INSTINCTS_FOR_AGENT = 3
+    MIN_CONFIDENCE = 0.7
+
+    def __init__(self, manager: InstinctManager):
+        self.manager = manager
+
+    def analyze(self, min_confidence: float = None) -> List[EvolutionCandidate]:
+        """
+        Analiza instintos y encuentra candidatos para evolución.
+
+        Returns:
+            Lista de candidatos de evolución
+        """
+        min_conf = min_confidence or self.MIN_CONFIDENCE
+
+        # Obtener instintos con suficiente confianza
+        all_instincts = self.manager.get_by_confidence(min_conf)
+
+        # Agrupar por dominio y trigger patterns
+        groups = self._group_instincts(all_instincts)
+
+        candidates = []
+
+        for group_key, group_instincts in groups.items():
+            # Verificar si es candidato a skill
+            if len(group_instincts) >= self.MIN_INSTINCTS_FOR_SKILL:
+                if self._is_skill_candidate(group_instincts):
+                    candidates.append(self._create_skill_candidate(group_instincts))
+
+            # Verificar si es candidato a command
+            if len(group_instincts) >= self.MIN_INSTINCTS_FOR_COMMAND:
+                if self._is_command_candidate(group_instincts):
+                    candidates.append(self._create_command_candidate(group_instincts))
+
+            # Verificar si es candidato a agent
+            if len(group_instincts) >= self.MIN_INSTINCTS_FOR_AGENT:
+                if self._is_agent_candidate(group_instincts):
+                    candidates.append(self._create_agent_candidate(group_instincts))
+
+        # Ordenar por confianza promedio
+        candidates.sort(key=lambda c: c.avg_confidence, reverse=True)
+
+        return candidates
+
+    def _group_instincts(self, instincts: List[Instinct]) -> Dict[str, List[Instinct]]:
+        """Agrupa instintos por patrones de trigger y dominio."""
+        groups = defaultdict(list)
+
+        for instinct in instincts:
+            # Crear clave de grupo basada en palabras clave del trigger
+            trigger_words = set(instinct.trigger.lower().split())
+            for word in trigger_words:
+                if len(word) > 3:  # Ignorar palabras cortas
+                    groups[word].append(instinct)
+
+            # También agrupar por dominio
+            domain_key = f"domain:{instinct.domain.value}"
+            groups[domain_key].append(instinct)
+
+        # Filtrar grupos con pocos instintos
+        return {k: v for k, v in groups.items() if len(v) >= 2}
+
+    def _is_skill_candidate(self, instincts: List[Instinct]) -> bool:
+        """Determina si un grupo de instintos es candidato a skill."""
+        # Skills son auto-triggered behaviors
+        trigger_keywords = ["when", "if", "on", "always", "before", "after"]
+
+        for instinct in instincts:
+            if any(kw in instinct.trigger.lower() for kw in trigger_keywords):
+                return True
+
+        return False
+
+    def _is_command_candidate(self, instincts: List[Instinct]) -> bool:
+        """Determina si un grupo de instintos es candidato a command."""
+        # Commands son user-invoked actions
+        trigger_keywords = ["when user asks", "when creating", "when adding", "when running"]
+
+        for instinct in instincts:
+            if any(kw in instinct.trigger.lower() for kw in trigger_keywords):
+                return True
+
+        return False
+
+    def _is_agent_candidate(self, instincts: List[Instinct]) -> bool:
+        """Determina si un grupo de instintos es candidato a agent."""
+        # Agents son multi-step processes complejos
+        step_indicators = ["step", "first", "then", "finally", "check", "verify"]
+
+        # Verificar si hay secuencia de pasos
+        has_sequence = False
+        for instinct in instincts:
+            if any(ind in instinct.name.lower() for ind in step_indicators):
+                has_sequence = True
+                break
+
+        # Verificar si es dominio complejo
+        complex_domains = [
+            InstinctDomain.DEBUGGING,
+            InstinctDomain.ARCHITECTURE,
+            InstinctDomain.REFACTORING,
+        ]
+
+        has_complex_domain = any(i.domain in complex_domains for i in instincts)
+
+        return len(instincts) >= 3 and (has_sequence or has_complex_domain)
+
+    def _create_skill_candidate(self, instincts: List[Instinct]) -> EvolutionCandidate:
+        """Crea un candidato a skill."""
+        avg_conf = sum(i.confidence for i in instincts) / len(instincts)
+        domains = list(set(i.domain for i in instincts))
+
+        # Generar nombre
+        trigger_words = set()
+        for i in instincts:
+            trigger_words.update(i.trigger.lower().split())
+
+        name = "-".join(sorted(trigger_words)[:2]) or "learned-skill"
+
+        return EvolutionCandidate(
+            name=name,
+            type="skill",
+            instincts=instincts,
+            avg_confidence=avg_conf,
+            domains=domains,
+            scope=instincts[0].scope,
+            reason="Auto-triggered behaviors grouped by common trigger pattern",
+        )
+
+    def _create_command_candidate(self, instincts: List[Instinct]) -> EvolutionCandidate:
+        """Crea un candidato a command."""
+        avg_conf = sum(i.confidence for i in instincts) / len(instincts)
+        domains = list(set(i.domain for i in instincts))
+
+        # Generar nombre
+        name = instincts[0].name.split("-")[0] if instincts else "learned-command"
+
+        return EvolutionCandidate(
+            name=name,
+            type="command",
+            instincts=instincts,
+            avg_confidence=avg_conf,
+            domains=domains,
+            scope=instincts[0].scope,
+            reason="User-invoked actions grouped by common workflow",
+        )
+
+    def _create_agent_candidate(self, instincts: List[Instinct]) -> EvolutionCandidate:
+        """Crea un candidato a agent."""
+        avg_conf = sum(i.confidence for i in instincts) / len(instincts)
+        domains = list(set(i.domain for i in instincts))
+
+        # Generar nombre basado en dominio
+        domain_name = domains[0].value if domains else "general"
+        name = f"{domain_name}-agent"
+
+        return EvolutionCandidate(
+            name=name,
+            type="agent",
+            instincts=instincts,
+            avg_confidence=avg_conf,
+            domains=domains,
+            scope=instincts[0].scope,
+            reason="Multi-step process requiring isolation and depth",
+        )
+
+    def evolve(self, candidate: EvolutionCandidate) -> EvolvedStructure:
+        """
+        Genera la estructura evolucionada para un candidato.
+
+        Returns:
+            Estructura evolucionada
+        """
+        if candidate.type == "skill":
+            return self._generate_skill(candidate)
+        elif candidate.type == "command":
+            return self._generate_command(candidate)
+        elif candidate.type == "agent":
+            return self._generate_agent(candidate)
+        else:
+            raise ValueError(f"Unknown type: {candidate.type}")
+
+    def _generate_skill(self, candidate: EvolutionCandidate) -> EvolvedStructure:
+        """Genera un skill desde un candidato."""
+        # Agrupar triggers
+        triggers = set(i.trigger for i in candidate.instincts)
+        actions = set(i.action for i in candidate.instincts)
+
+        content = f"""# {candidate.name}
+
+## Description
+Auto-generated skill from learned instincts.
+
+## Triggers
+{chr(10).join(f'- {t}' for t in triggers)}
+
+## Actions
+{chr(10).join(f'- {a}' for a in actions)}
+
+## Confidence
+{candidate.avg_confidence:.0%}
+
+## Evolved From
+{chr(10).join(f'- {i.name} ({i.confidence:.0%})' for i in candidate.instincts)}
+"""
+
+        return EvolvedStructure(
+            name=candidate.name,
+            type="skill",
+            description=f"Auto-triggered skill for {candidate.domains[0].value}",
+            instincts=[i.id for i in candidate.instincts],
+            content=content,
+            scope=candidate.scope,
+        )
+
+    def _generate_command(self, candidate: EvolutionCandidate) -> EvolvedStructure:
+        """Genera un command desde un candidato."""
+        steps = []
+        for i, instinct in enumerate(sorted(candidate.instincts,
+                                            key=lambda x: x.created_at), 1):
+            steps.append(f"{i}. {instinct.action}")
+
+        content = f"""# /{candidate.name}
+
+## Description
+Auto-generated command from learned workflow.
+
+## Usage
+`/{candidate.name}`
+
+## Steps
+{chr(10).join(steps)}
+
+## Confidence
+{candidate.avg_confidence:.0%}
+
+## Evolved From
+{chr(10).join(f'- {i.name} ({i.confidence:.0%})' for i in candidate.instincts)}
+"""
+
+        return EvolvedStructure(
+            name=candidate.name,
+            type="command",
+            description=f"User-invoked command for {candidate.domains[0].value}",
+            instincts=[i.id for i in candidate.instincts],
+            content=content,
+            scope=candidate.scope,
+        )
+
+    def _generate_agent(self, candidate: EvolutionCandidate) -> EvolvedStructure:
+        """Genera un agent desde un candidato."""
+        steps = []
+        for i, instinct in enumerate(sorted(candidate.instincts,
+                                            key=lambda x: x.created_at), 1):
+            steps.append(f"{i}. {instinct.trigger}: {instinct.action}")
+
+        model = "sonnet" if candidate.avg_confidence < 0.85 else "opus"
+
+        content = f"""# {candidate.name}
+
+## Description
+Auto-generated agent from learned multi-step process.
+
+## Model
+{model}
+
+## Triggers
+{chr(10).join(f'- {i.trigger}' for i in candidate.instincts[:3])}
+
+## Process
+{chr(10).join(steps)}
+
+## Confidence
+{candidate.avg_confidence:.0%}
+
+## Evolved From
+{chr(10).join(f'- {i.name} ({i.confidence:.0%})' for i in candidate.instincts)}
+"""
+
+        return EvolvedStructure(
+            name=candidate.name,
+            type="agent",
+            description=f"Multi-step agent for {candidate.domains[0].value}",
+            instincts=[i.id for i in candidate.instincts],
+            content=content,
+            scope=candidate.scope,
+        )
+
+    def get_evolution_summary(self) -> Dict:
+        """Obtiene un resumen de posibles evoluciones."""
+        candidates = self.analyze()
+
+        return {
+            "skill_candidates": len([c for c in candidates if c.type == "skill"]),
+            "command_candidates": len([c for c in candidates if c.type == "command"]),
+            "agent_candidates": len([c for c in candidates if c.type == "agent"]),
+            "total_candidates": len(candidates),
+            "avg_confidence": sum(c.avg_confidence for c in candidates) / len(candidates) if candidates else 0,
+            "top_candidates": [
+                {"name": c.name, "type": c.type, "confidence": c.avg_confidence}
+                for c in candidates[:5]
+            ],
+        }