hanuscode 1.0.0__py3-none-any.whl

hanus/hooks/manager.py

@@ -0,0 +1,247 @@
+# hanus/hooks/manager.py
+"""
+Sistema de hooks de ciclo de vida.
+
+Permite ejecutar callbacks en puntos específicos del flujo de ejecución.
+"""
+from __future__ import annotations
+import time
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any, Callable
+from enum import Enum
+from collections import defaultdict
+import threading
+
+
+class HookType(Enum):
+    """Tipos de hooks disponibles."""
+    # File operations
+    PRE_READ = "pre_read"
+    POST_READ = "post_read"
+    PRE_WRITE = "pre_write"
+    POST_WRITE = "post_write"
+    PRE_EDIT = "pre_edit"
+    POST_EDIT = "post_edit"
+
+    # Command execution
+    PRE_COMMAND = "pre_command"
+    POST_COMMAND = "post_command"
+
+    # Tool execution
+    PRE_TOOL = "pre_tool"
+    POST_TOOL = "post_tool"
+
+    # Error handling
+    ON_ERROR = "on_error"
+
+    # Session lifecycle
+    ON_SESSION_START = "on_session_start"
+    ON_SESSION_END = "on_session_end"
+
+    # Plugin lifecycle
+    ON_PLUGIN_LOAD = "on_plugin_load"
+    ON_PLUGIN_UNLOAD = "on_plugin_unload"
+
+
+@dataclass
+class HookContext:
+    """Contexto pasado a los hooks."""
+    hook_type: HookType
+    timestamp: float
+    data: Dict[str, Any] = field(default_factory=dict)
+    result: Any = None
+    error: Optional[str] = None
+
+    def to_dict(self) -> Dict:
+        return {
+            "hook_type": self.hook_type.value,
+            "timestamp": self.timestamp,
+            "data": self.data,
+            "result": str(self.result)[:200] if self.result else None,
+            "error": self.error,
+        }
+
+
+@dataclass
+class HookRegistration:
+    """Registro de un hook."""
+    hook_type: HookType
+    callback: Callable
+    priority: int = 0  # Lower = runs first
+    name: str = ""
+    enabled: bool = True
+
+
+class HookManager:
+    """
+    Gestiona hooks de ciclo de vida.
+
+    Uso:
+        hooks = HookManager()
+
+        @hooks.register(HookType.PRE_WRITE)
+        def my_hook(ctx):
+            print(f"About to write: {ctx.data['path']}")
+
+        # O usando decorador
+        @hook(HookType.POST_COMMAND)
+        def log_command(ctx):
+            print(f"Command executed: {ctx.data['command']}")
+    """
+
+    def __init__(self):
+        self._hooks: Dict[HookType, List[HookRegistration]] = defaultdict(list)
+        self._lock = threading.RLock()
+        self._hook_counter = 0
+
+    def register(
+        self,
+        hook_type: HookType,
+        callback: Callable,
+        priority: int = 0,
+        name: str = ""
+    ) -> str:
+        """
+        Registra un hook.
+
+        Args:
+            hook_type: Tipo de hook
+            callback: Función a ejecutar
+            priority: Prioridad (menor = se ejecuta antes)
+            name: Nombre opcional
+
+        Returns:
+            ID del hook registrado
+        """
+        with self._lock:
+            self._hook_counter += 1
+            hook_id = f"hook_{self._hook_counter}"
+
+            registration = HookRegistration(
+                hook_type=hook_type,
+                callback=callback,
+                priority=priority,
+                name=name or callback.__name__,
+            )
+
+            self._hooks[hook_type].append(registration)
+            # Ordenar por prioridad
+            self._hooks[hook_type].sort(key=lambda h: h.priority)
+
+            return hook_id
+
+    def unregister(self, hook_id: str) -> bool:
+        """Elimina un hook por ID."""
+        # Simplificado - necesitaríamos tracking de IDs
+        return False
+
+    def trigger(
+        self,
+        hook_type: HookType,
+        data: Dict[str, Any] = None,
+        result: Any = None,
+        error: str = None
+    ) -> List[Any]:
+        """
+        Dispara todos los hooks de un tipo.
+
+        Args:
+            hook_type: Tipo de hook a disparar
+            data: Datos del contexto
+            result: Resultado (si aplica)
+            error: Error (si aplica)
+
+        Returns:
+            Lista de resultados de los hooks
+        """
+        context = HookContext(
+            hook_type=hook_type,
+            timestamp=time.time(),
+            data=data or {},
+            result=result,
+            error=error,
+        )
+
+        results = []
+
+        for registration in self._hooks.get(hook_type, []):
+            if not registration.enabled:
+                continue
+
+            try:
+                result = registration.callback(context)
+                results.append(result)
+            except Exception as e:
+                # No propagar errores de hooks
+                print(f"[HookManager] Error in hook {registration.name}: {e}")
+
+        return results
+
+    def trigger_sync(
+        self,
+        hook_type: HookType,
+        data: Dict[str, Any] = None
+    ) -> None:
+        """Dispara hooks sincrónicamente."""
+        self.trigger(hook_type, data)
+
+    def enable(self, name: str) -> None:
+        """Habilita un hook por nombre."""
+        for hooks in self._hooks.values():
+            for h in hooks:
+                if h.name == name:
+                    h.enabled = True
+
+    def disable(self, name: str) -> None:
+        """Deshabilita un hook por nombre."""
+        for hooks in self._hooks.values():
+            for h in hooks:
+                if h.name == name:
+                    h.enabled = False
+
+    def list_hooks(self) -> List[Dict]:
+        """Lista todos los hooks registrados."""
+        result = []
+        for hook_type, registrations in self._hooks.items():
+            for r in registrations:
+                result.append({
+                    "type": hook_type.value,
+                    "name": r.name,
+                    "priority": r.priority,
+                    "enabled": r.enabled,
+                })
+        return result
+
+    def clear(self, hook_type: Optional[HookType] = None) -> None:
+        """Limpia hooks."""
+        if hook_type:
+            self._hooks[hook_type] = []
+        else:
+            self._hooks.clear()
+
+
+def hook(hook_type: HookType, priority: int = 0):
+    """
+    Decorador para registrar hooks fácilmente.
+
+    Uso:
+        @hook(HookType.PRE_COMMAND)
+        def my_hook(ctx):
+            print(f"Before: {ctx.data}")
+    """
+    def decorator(func: Callable) -> Callable:
+        # Registrar cuando se define
+        get_hook_manager().register(hook_type, func, priority)
+        return func
+    return decorator
+
+
+# Instancia global
+_manager: Optional[HookManager] = None
+
+
+def get_hook_manager() -> HookManager:
+    global _manager
+    if _manager is None:
+        _manager = HookManager()
+    return _manager

hanus/instincts/__init__.py

@@ -0,0 +1,44 @@
+# hanus/instincts/__init__.py
+"""
+Sistema de Instintos - Continuous Learning.
+
+Los instintos son comportamientos aprendidos automáticamente desde
+sesiones de interacción, con scoring de confianza y scope por proyecto.
+
+Comandos:
+- instinct-status: Ver instintos aprendidos
+- instinct-import: Importar instintos
+- instinct-export: Exportar instintos
+- evolve: Evolucionar instintos a skills/comandos/agentes
+"""
+from __future__ import annotations
+
+from hanus.instincts.types import (
+    Instinct,
+    InstinctScope,
+    InstinctStatus,
+    InstinctDomain,
+    InstinctEvidence,
+    InstinctGroup,
+    ProjectInfo,
+)
+from hanus.instincts.manager import (
+    InstinctManager,
+    get_instinct_manager,
+)
+from hanus.instincts.detector import PatternDetector
+from hanus.instincts.evolver import InstinctEvolver
+
+__all__ = [
+    'Instinct',
+    'InstinctScope',
+    'InstinctStatus',
+    'InstinctDomain',
+    'InstinctEvidence',
+    'InstinctGroup',
+    'ProjectInfo',
+    'InstinctManager',
+    'get_instinct_manager',
+    'PatternDetector',
+    'InstinctEvolver',
+]

hanus/instincts/cli.py

@@ -0,0 +1,372 @@
+#!/usr/bin/env python3
+"""
+CLI para el sistema de instintos.
+
+Comandos:
+- instinct-status: Muestra instintos aprendidos
+- instinct-import: Importa instintos desde archivo/URL
+- instinct-export: Exporta instintos a archivo
+- evolve: Analiza y evoluciona instintos
+"""
+from __future__ import annotations
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Optional
+
+from hanus.instincts.manager import get_instinct_manager, InstinctManager
+from hanus.instincts.evolver import InstinctEvolver
+from hanus.instincts.types import InstinctScope, InstinctDomain
+
+
+def cmd_status(args):
+    """Muestra el estado de los instintos."""
+    manager = get_instinct_manager()
+    manager.load_all()
+
+    stats = manager.get_stats()
+    all_instincts = manager.get_all_instincts()
+
+    # Header
+    print("=" * 60)
+    print(f"  INSTINCT STATUS - {stats['total']} total")
+    print("=" * 60)
+    print()
+    print(f"  Project: {stats['project_info']['name']} ({stats['project_info']['id'][:8]}...)")
+    print(f"  Project instincts: {stats['project']}")
+    print(f"  Global instincts:  {stats['global']}")
+    print()
+
+    # Agrupar por dominio
+    by_domain = manager.group_by_domain()
+
+    if not by_domain:
+        print("  No instincts learned yet.")
+        return 0
+
+    # Mostrar instintos del proyecto primero
+    project_instincts = [i for i in all_instincts.values()
+                         if i.scope == InstinctScope.PROJECT]
+    if project_instincts:
+        print(f"## PROJECT-SCOPED ({stats['project_info']['name']})")
+        _print_instincts_by_domain(project_instincts, "project")
+        print()
+
+    # Mostrar instintos globales
+    global_instincts = [i for i in all_instincts.values()
+                       if i.scope == InstinctScope.GLOBAL]
+    if global_instincts:
+        print("## GLOBAL (apply to all projects)")
+        _print_instincts_by_domain(global_instincts, "global")
+        print()
+
+    return 0
+
+
+def _print_instincts_by_domain(instincts: list, scope: str):
+    """Imprime instintos agrupados por dominio."""
+    from collections import defaultdict
+
+    by_domain = defaultdict(list)
+    for i in instincts:
+        by_domain[i.domain.value].append(i)
+
+    for domain, domain_instincts in sorted(by_domain.items()):
+        print(f"  ### {domain.upper()} ({len(domain_instincts)})")
+        for instinct in sorted(domain_instincts, key=lambda x: x.confidence, reverse=True):
+            confidence_bar = instinct.confidence_bar
+            print(f"    {confidence_bar}  {instinct.confidence:.0%}  {instinct.name} [{scope}]")
+            print(f"              trigger: {instinct.trigger}")
+        print()
+
+
+def cmd_import(args):
+    """Importa instintos desde archivo o URL."""
+    manager = get_instinct_manager()
+
+    # Leer archivo o URL
+    if args.file.startswith("http"):
+        import urllib.request
+        try:
+            with urllib.request.urlopen(args.file, timeout=10) as response:
+                content = response.read().decode("utf-8")
+        except Exception as e:
+            print(f"Error fetching URL: {e}")
+            return 1
+    else:
+        file_path = Path(args.file)
+        if not file_path.exists():
+            print(f"File not found: {file_path}")
+            return 1
+        content = file_path.read_text(encoding="utf-8")
+
+    # Parsear JSON
+    try:
+        data = json.loads(content)
+    except json.JSONDecodeError as e:
+        print(f"Invalid JSON: {e}")
+        return 1
+
+    # Determinar scope
+    scope = InstinctScope.PROJECT if args.scope == "project" else InstinctScope.GLOBAL
+
+    # Importar
+    if args.dry_run:
+        print("DRY RUN - Would import:")
+        for i in data.get("instincts", []):
+            print(f"  - {i.get('name', 'unknown')} ({i.get('confidence', 0):.0%})")
+        return 0
+
+    imported, messages = manager.import_instincts(
+        data,
+        scope=scope,
+        force=args.force,
+        min_confidence=args.min_confidence
+    )
+
+    print(f"Imported {imported} instincts:")
+    for msg in messages:
+        print(f"  {msg}")
+
+    return 0 if imported > 0 else 1
+
+
+def cmd_export(args):
+    """Exporta instintos a archivo."""
+    manager = get_instinct_manager()
+
+    # Determinar scope
+    scope = None
+    if args.scope == "global":
+        scope = InstinctScope.GLOBAL
+    elif args.scope == "project":
+        scope = InstinctScope.PROJECT
+
+    # Filtrar dominios
+    domains = None
+    if args.domains:
+        domains = [InstinctDomain(d) for d in args.domains.split(",")]
+
+    # Exportar
+    data = manager.export_instincts(
+        scope=scope,
+        min_confidence=args.min_confidence,
+        domains=domains
+    )
+
+    # Escribir archivo
+    output_path = Path(args.output) if args.output else Path("instincts.json")
+    output_path.write_text(
+        json.dumps(data, indent=2, ensure_ascii=False),
+        encoding="utf-8"
+    )
+
+    print(f"Exported {len(data['instincts'])} instincts to {output_path}")
+    return 0
+
+
+def cmd_evolve(args):
+    """Analiza instintos y sugiere evoluciones."""
+    manager = get_instinct_manager()
+    manager.load_all()
+
+    evolver = InstinctEvolver(manager)
+    candidates = evolver.analyze(min_confidence=args.min_confidence)
+
+    stats = manager.get_stats()
+
+    # Header
+    print("=" * 60)
+    print(f"  EVOLVE ANALYSIS - {stats['total']} instincts")
+    print(f"  Project: {stats['project_info']['name']} ({stats['project_info']['id'][:8]}...)")
+    print(f"  Project-scoped: {stats['project']} | Global: {stats['global']}")
+    print("=" * 60)
+    print()
+
+    high_conf = [c for c in candidates if c.avg_confidence >= 0.8]
+    print(f"High confidence instincts (>=80%): {len(high_conf)}")
+    print()
+
+    # Mostrar candidatos por tipo
+    skill_candidates = [c for c in candidates if c.type == "skill"]
+    command_candidates = [c for c in candidates if c.type == "command"]
+    agent_candidates = [c for c in candidates if c.type == "agent"]
+
+    if skill_candidates:
+        print("## SKILL CANDIDATES")
+        for i, c in enumerate(skill_candidates[:5], 1):
+            print(f"  {i}. Cluster: \"{c.name}\"")
+            print(f"     Instincts: {len(c.instincts)}")
+            print(f"     Avg confidence: {c.avg_confidence:.0%}")
+            print(f"     Domains: {', '.join(d.value for d in c.domains)}")
+            print(f"     Reason: {c.reason}")
+        print()
+
+    if command_candidates:
+        print("## COMMAND CANDIDATES")
+        for i, c in enumerate(command_candidates[:5], 1):
+            print(f"  /{c.name}")
+            print(f"     From: {', '.join(i.name for i in c.instincts[:3])}")
+            print(f"     Confidence: {c.avg_confidence:.0%}")
+        print()
+
+    if agent_candidates:
+        print("## AGENT CANDIDATES")
+        for i, c in enumerate(agent_candidates[:3], 1):
+            print(f"  {c.name}-agent")
+            print(f"     Covers {len(c.instincts)} instincts")
+            print(f"     Avg confidence: {c.avg_confidence:.0%}")
+        print()
+
+    # Generar archivos si --generate
+    if args.generate:
+        evolved_dir = manager.project_instincts_dir / "evolved"
+        evolved_dir.mkdir(parents=True, exist_ok=True)
+
+        generated = 0
+        for candidate in candidates[:args.max_generate]:
+            structure = evolver.evolve(candidate)
+
+            # Determinar subdirectorio
+            subdir = evolved_dir / f"{structure.type}s"
+            subdir.mkdir(parents=True, exist_ok=True)
+
+            # Escribir archivo
+            file_path = subdir / f"{structure.name}.md"
+            file_path.write_text(structure.content, encoding="utf-8")
+
+            # Marcar instintos como evolucionados
+            for instinct_id in structure.instincts:
+                instinct = manager.get_instinct(instinct_id)
+                if instinct:
+                    instinct.status = InstinctStatus.EVOLVED
+                    instinct.evolved_to = structure.name
+                    manager.update_instinct(instinct)
+
+            print(f"  Generated: {structure.type}/{structure.name}.md")
+            generated += 1
+
+        print(f"\nGenerated {generated} structures in {evolved_dir}")
+
+    return 0
+
+
+def cmd_promote(args):
+    """Promueve instintos del proyecto a global."""
+    manager = get_instinct_manager()
+    manager.load_all()
+
+    # Obtener instintos del proyecto
+    project_instincts = [i for i in manager._project_instincts.values()
+                        if i.confidence >= args.min_confidence]
+
+    if not project_instincts:
+        print("No project instincts meet the confidence threshold.")
+        return 1
+
+    promoted = 0
+    for instinct in project_instincts:
+        if args.dry_run:
+            print(f"Would promote: {instinct.name} ({instinct.confidence:.0%})")
+            continue
+
+        # Cambiar scope
+        instinct.scope = InstinctScope.GLOBAL
+        instinct.project_id = None
+
+        # Mover a global
+        manager._global_instincts[instinct.id] = instinct
+        del manager._project_instincts[instinct.id]
+        manager._save_instinct(instinct, manager.global_dir)
+
+        print(f"Promoted: {instinct.name}")
+        promoted += 1
+
+    if args.dry_run:
+        print(f"Would promote {len(project_instincts)} instincts")
+    else:
+        print(f"Promoted {promoted} instincts to global scope")
+
+    return 0
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Hanuscode Instincts CLI",
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # instinct-status
+    status_parser = subparsers.add_parser(
+        "status",
+        help="Show learned instincts with confidence"
+    )
+    status_parser.set_defaults(func=cmd_status)
+
+    # instinct-import
+    import_parser = subparsers.add_parser(
+        "import",
+        help="Import instincts from file or URL"
+    )
+    import_parser.add_argument("file", help="File path or URL to import")
+    import_parser.add_argument("--scope", choices=["project", "global"],
+                              default="project", help="Target scope")
+    import_parser.add_argument("--dry-run", action="store_true",
+                              help="Preview without importing")
+    import_parser.add_argument("--force", action="store_true",
+                              help="Skip confirmation prompts")
+    import_parser.add_argument("--min-confidence", type=float, default=0.5,
+                              help="Minimum confidence threshold")
+    import_parser.set_defaults(func=cmd_import)
+
+    # instinct-export
+    export_parser = subparsers.add_parser(
+        "export",
+        help="Export instincts to file"
+    )
+    export_parser.add_argument("--output", "-o", help="Output file path")
+    export_parser.add_argument("--scope", choices=["project", "global", "all"],
+                               default="all", help="Scope to export")
+    export_parser.add_argument("--domains", help="Comma-separated domains")
+    export_parser.add_argument("--min-confidence", type=float, default=0.5,
+                              help="Minimum confidence threshold")
+    export_parser.set_defaults(func=cmd_export)
+
+    # evolve
+    evolve_parser = subparsers.add_parser(
+        "evolve",
+        help="Analyze instincts and suggest evolutions"
+    )
+    evolve_parser.add_argument("--generate", action="store_true",
+                              help="Generate evolved files")
+    evolve_parser.add_argument("--min-confidence", type=float, default=0.7,
+                              help="Minimum confidence for candidates")
+    evolve_parser.add_argument("--max-generate", type=int, default=10,
+                              help="Maximum structures to generate")
+    evolve_parser.set_defaults(func=cmd_evolve)
+
+    # promote
+    promote_parser = subparsers.add_parser(
+        "promote",
+        help="Promote project instincts to global scope"
+    )
+    promote_parser.add_argument("--min-confidence", type=float, default=0.8,
+                               help="Minimum confidence to promote")
+    promote_parser.add_argument("--dry-run", action="store_true",
+                               help="Preview without promoting")
+    promote_parser.set_defaults(func=cmd_promote)
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        parser.print_help()
+        return 1
+
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())