hanuscode 1.0.0__py3-none-any.whl

hanus/monitor.py

@@ -0,0 +1,341 @@
+# hanus/monitor.py — Sistema de Monitoreo en Background
+"""
+Monitor para ejecutar comandos largos en background y recibir notificaciones.
+
+Permite:
+- Ejecutar comandos que tardan (builds, tests, scans)
+- Recibir notificaciones cuando termina o hay eventos
+- Filtrar output para solo ver lo importante
+
+Uso:
+    from hanus.monitor import MonitorManager
+
+    monitor = MonitorManager()
+
+    # Iniciar monitor
+    monitor.start("build", "npm run build", on_event=callback)
+
+    # Ver monitores activos
+    monitor.list()
+
+    # Parar monitor
+    monitor.stop("build")
+"""
+from __future__ import annotations
+import subprocess
+import threading
+import time
+import queue
+import uuid
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Callable, Any
+from pathlib import Path
+from enum import Enum
+
+
+class MonitorStatus(Enum):
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    STOPPED = "stopped"
+
+
+@dataclass
+class MonitorEvent:
+    """Un evento del monitor."""
+    monitor_id: str
+    event_type: str  # "line", "complete", "error"
+    content: str
+    timestamp: float = field(default_factory=time.time)
+
+
+@dataclass
+class MonitorTask:
+    """Una tarea de monitoreo."""
+    id: str
+    name: str
+    command: str
+    status: MonitorStatus = MonitorStatus.RUNNING
+    process: Optional[subprocess.Popen] = None
+    output_file: Optional[Path] = None
+    started_at: float = field(default_factory=time.time)
+    ended_at: Optional[float] = None
+    exit_code: Optional[int] = None
+    lines_count: int = 0
+    events_matched: int = 0
+
+
+class MonitorManager:
+    """
+    Gestiona tareas de monitoreo en background.
+
+    Cada monitor ejecuta un comando y emite eventos por cada línea
+    que coincide con el filtro configurado.
+    """
+
+    def __init__(self, output_dir: Optional[Path] = None):
+        self.monitors: Dict[str, MonitorTask] = {}
+        self._event_queues: Dict[str, queue.Queue] = {}
+        self._callbacks: Dict[str, Callable] = {}
+        self._threads: Dict[str, threading.Thread] = {}
+        self.output_dir = output_dir or (Path.home() / ".hanus" / "monitor_logs")
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+    def start(
+        self,
+        name: str,
+        command: str,
+        filter_pattern: str = "",
+        on_event: Optional[Callable[[MonitorEvent], None]] = None,
+        cwd: Optional[Path] = None,
+        timeout: int = 3600,
+    ) -> str:
+        """
+        Inicia un nuevo monitor.
+
+        Args:
+            name: Nombre descriptivo del monitor
+            command: Comando a ejecutar
+            filter_pattern: Regex para filtrar líneas (vacío = todas)
+            on_event: Callback para cada evento
+            cwd: Directorio de trabajo
+            timeout: Timeout en segundos
+
+        Returns:
+            ID del monitor
+        """
+        import re
+
+        monitor_id = f"{name}_{uuid.uuid4().hex[:8]}"
+
+        # Crear archivo de log
+        log_file = self.output_dir / f"{monitor_id}.log"
+
+        task = MonitorTask(
+            id=monitor_id,
+            name=name,
+            command=command,
+            output_file=log_file,
+        )
+
+        self.monitors[monitor_id] = task
+        self._event_queues[monitor_id] = queue.Queue()
+
+        if on_event:
+            self._callbacks[monitor_id] = on_event
+
+        # Compilar patrón de filtro
+        pattern = re.compile(filter_pattern) if filter_pattern else None
+
+        def run_monitor():
+            try:
+                # Abrir archivo de log
+                with open(log_file, "w", encoding="utf-8") as log:
+                    log.write(f"# Monitor: {name}\n")
+                    log.write(f"# Command: {command}\n")
+                    log.write(f"# Started: {time.strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+                    log.flush()
+
+                    # Ejecutar comando
+                    process = subprocess.Popen(
+                        command,
+                        shell=True,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.STDOUT,
+                        text=True,
+                        cwd=str(cwd) if cwd else None,
+                    )
+
+                    task.process = process
+
+                    # Leer output línea por línea
+                    for line in process.stdout:
+                        task.lines_count += 1
+
+                        # Escribir a log
+                        log.write(line)
+                        log.flush()
+
+                        # Verificar si coincide con filtro
+                        should_emit = True
+                        if pattern and not pattern.search(line):
+                            should_emit = False
+
+                        if should_emit:
+                            task.events_matched += 1
+                            event = MonitorEvent(
+                                monitor_id=monitor_id,
+                                event_type="line",
+                                content=line.rstrip(),
+                            )
+
+                            # Poner en cola
+                            self._event_queues[monitor_id].put(event)
+
+                            # Llamar callback
+                            if monitor_id in self._callbacks:
+                                try:
+                                    self._callbacks[monitor_id](event)
+                                except Exception:
+                                    pass
+
+                    # Esperar a que termine
+                    process.wait()
+                    task.exit_code = process.returncode
+                    task.ended_at = time.time()
+                    task.status = MonitorStatus.COMPLETED if process.returncode == 0 else MonitorStatus.FAILED
+
+                    # Emitir evento de finalización
+                    final_event = MonitorEvent(
+                        monitor_id=monitor_id,
+                        event_type="complete" if process.returncode == 0 else "error",
+                        content=f"Exit code: {process.returncode}",
+                    )
+                    self._event_queues[monitor_id].put(final_event)
+
+                    if monitor_id in self._callbacks:
+                        try:
+                            self._callbacks[monitor_id](final_event)
+                        except Exception:
+                            pass
+
+            except Exception as e:
+                task.status = MonitorStatus.FAILED
+                task.ended_at = time.time()
+
+                error_event = MonitorEvent(
+                    monitor_id=monitor_id,
+                    event_type="error",
+                    content=str(e),
+                )
+                self._event_queues[monitor_id].put(error_event)
+
+        # Iniciar thread
+        thread = threading.Thread(target=run_monitor, daemon=True)
+        thread.start()
+        self._threads[monitor_id] = thread
+
+        return monitor_id
+
+    def stop(self, monitor_id: str) -> str:
+        """Detiene un monitor activo."""
+        task = self.monitors.get(monitor_id)
+        if not task:
+            return f"Monitor '{monitor_id}' no encontrado"
+
+        if task.status != MonitorStatus.RUNNING:
+            return f"Monitor '{monitor_id}' ya terminó"
+
+        if task.process:
+            task.process.terminate()
+            task.status = MonitorStatus.STOPPED
+            task.ended_at = time.time()
+
+        return f"Monitor '{monitor_id}' detenido"
+
+    def get(self, monitor_id: str) -> Optional[MonitorTask]:
+        """Obtiene info de un monitor."""
+        return self.monitors.get(monitor_id)
+
+    def list(self) -> List[MonitorTask]:
+        """Lista todos los monitores."""
+        return list(self.monitors.values())
+
+    def list_active(self) -> List[MonitorTask]:
+        """Lista monitores activos."""
+        return [t for t in self.monitors.values() if t.status == MonitorStatus.RUNNING]
+
+    def get_events(self, monitor_id: str, block: bool = False, timeout: float = 0) -> List[MonitorEvent]:
+        """Obtiene eventos pendientes de un monitor."""
+        if monitor_id not in self._event_queues:
+            return []
+
+        q = self._event_queues[monitor_id]
+        events = []
+
+        while True:
+            try:
+                if block:
+                    event = q.get(timeout=timeout if timeout else None)
+                else:
+                    event = q.get_nowait()
+                events.append(event)
+            except queue.Empty:
+                break
+
+        return events
+
+    def wait(self, monitor_id: str, timeout: float = None) -> Optional[MonitorTask]:
+        """Espera a que un monitor termine."""
+        if monitor_id not in self._threads:
+            return None
+
+        thread = self._threads[monitor_id]
+        thread.join(timeout=timeout)
+
+        return self.monitors.get(monitor_id)
+
+    def cleanup(self, max_age_hours: int = 24):
+        """Limpia monitores antiguos."""
+        now = time.time()
+        to_remove = []
+
+        for mid, task in self.monitors.items():
+            if task.status != MonitorStatus.RUNNING:
+                if task.ended_at and (now - task.ended_at) > max_age_hours * 3600:
+                    to_remove.append(mid)
+
+        for mid in to_remove:
+            del self.monitors[mid]
+            if mid in self._event_queues:
+                del self._event_queues[mid]
+            if mid in self._callbacks:
+                del self._callbacks[mid]
+            if mid in self._threads:
+                del self._threads[mid]
+
+    def format_status(self, task: MonitorTask) -> str:
+        """Formatea el estado de un monitor para mostrar."""
+        status_icons = {
+            MonitorStatus.RUNNING: "🔄",
+            MonitorStatus.COMPLETED: "✅",
+            MonitorStatus.FAILED: "❌",
+            MonitorStatus.STOPPED: "⏹️",
+        }
+
+        icon = status_icons.get(task.status, "❓")
+
+        duration = ""
+        if task.ended_at:
+            duration = f" ({task.ended_at - task.started_at:.1f}s)"
+        elif task.status == MonitorStatus.RUNNING:
+            duration = f" ({time.time() - task.started_at:.1f}s)"
+
+        lines = [
+            f"{icon} **{task.name}** `{task.id}`",
+            f"  Comando: `{task.command}`",
+            f"  Estado: {task.status.value}{duration}",
+        ]
+
+        if task.status == MonitorStatus.RUNNING:
+            lines.append(f"  Líneas: {task.lines_count} | Eventos: {task.events_matched}")
+        else:
+            lines.append(f"  Total líneas: {task.lines_count}")
+            lines.append(f"  Exit code: {task.exit_code}")
+
+        if task.output_file:
+            lines.append(f"  Log: `{task.output_file}`")
+
+        return "\n".join(lines)
+
+
+# Singleton global
+_monitor_manager: Optional[MonitorManager] = None
+
+
+def get_monitor_manager() -> MonitorManager:
+    """Obtiene el gestor de monitores."""
+    global _monitor_manager
+    if _monitor_manager is None:
+        _monitor_manager = MonitorManager()
+    return _monitor_manager

hanus/parallel/__init__.py

@@ -0,0 +1,5 @@
+# hanus/parallel/__init__.py
+"""Parallel execution for HanusCode."""
+from .executor import ParallelExecutor, Task, TaskResult
+
+__all__ = ["ParallelExecutor", "Task", "TaskResult"]

hanus/parallel/executor.py

@@ -0,0 +1,300 @@
+# hanus/parallel/executor.py
+"""
+Ejecutor paralelo de tareas.
+
+Detecta comandos/búsquedas independientes y los ejecuta en paralelo.
+"""
+from __future__ import annotations
+import asyncio
+import time
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any, Callable, Set, Tuple
+from enum import Enum
+from concurrent.futures import ThreadPoolExecutor
+import threading
+
+
+class TaskStatus(Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+@dataclass
+class Task:
+    """Una tarea ejecutable."""
+    id: str
+    name: str
+    func: Callable
+    args: Tuple = ()
+    kwargs: Dict = field(default_factory=dict)
+    dependencies: List[str] = field(default_factory=list)
+    status: TaskStatus = TaskStatus.PENDING
+    result: Any = None
+    error: Optional[str] = None
+    start_time: float = 0
+    end_time: float = 0
+
+    def to_dict(self) -> Dict:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "status": self.status.value,
+            "error": self.error,
+            "duration": self.end_time - self.start_time if self.end_time else 0,
+        }
+
+
+@dataclass
+class TaskResult:
+    """Resultado de una tarea."""
+    task_id: str
+    success: bool
+    result: Any
+    error: Optional[str] = None
+    duration: float = 0
+
+    def to_dict(self) -> Dict:
+        return {
+            "task_id": self.task_id,
+            "success": self.success,
+            "result": str(self.result)[:500] if self.result else None,
+            "error": self.error,
+            "duration": self.duration,
+        }
+
+
+class DependencyGraph:
+    """Grafo de dependencias entre tareas."""
+
+    def __init__(self):
+        self.nodes: Dict[str, Task] = {}
+        self.edges: Dict[str, Set[str]] = {}  # task -> tasks it depends on
+
+    def add_task(self, task: Task) -> None:
+        self.nodes[task.id] = task
+        self.edges[task.id] = set(task.dependencies)
+
+    def get_ready_tasks(self) -> List[str]:
+        """Obtiene tareas sin dependencias pendientes."""
+        ready = []
+        for task_id, task in self.nodes.items():
+            if task.status != TaskStatus.PENDING:
+                continue
+            # Verificar si todas las dependencias están completas
+            deps = self.edges.get(task_id, set())
+            all_done = all(
+                self.nodes[dep_id].status == TaskStatus.COMPLETED
+                for dep_id in deps if dep_id in self.nodes
+            )
+            if all_done:
+                ready.append(task_id)
+        return ready
+
+    def topological_sort(self) -> List[str]:
+        """Ordena tareas por dependencias."""
+        visited = set()
+        result = []
+
+        def visit(task_id: str):
+            if task_id in visited:
+                return
+            visited.add(task_id)
+            for dep in self.edges.get(task_id, []):
+                if dep in self.nodes:
+                    visit(dep)
+            result.append(task_id)
+
+        for task_id in self.nodes:
+            visit(task_id)
+
+        return result
+
+
+class ParallelExecutor:
+    """
+    Ejecuta tareas en paralelo respetando dependencias.
+
+    Features:
+    - Detección de tareas independientes
+    - Límite de concurrencia
+    - Manejo de errores
+    - Timeout por tarea
+    """
+
+    def __init__(self, max_workers: int = 4):
+        self.max_workers = max_workers
+        self._task_counter = 0
+        self._lock = threading.Lock()
+
+    async def execute_parallel(
+        self,
+        tasks: List[Task],
+        timeout: float = 60.0
+    ) -> List[TaskResult]:
+        """
+        Ejecuta tareas en paralelo respetando dependencias.
+
+        Args:
+            tasks: Lista de tareas a ejecutar
+            timeout: Timeout global en segundos
+
+        Returns:
+            Lista de resultados
+        """
+        # Construir grafo de dependencias
+        graph = DependencyGraph()
+        for task in tasks:
+            graph.add_task(task)
+
+        results: Dict[str, TaskResult] = {}
+        running: Set[str] = set()
+
+        async def run_task(task: Task) -> TaskResult:
+            """Ejecuta una tarea."""
+            task.status = TaskStatus.RUNNING
+            task.start_time = time.time()
+
+            try:
+                # Ejecutar función
+                if asyncio.iscoroutinefunction(task.func):
+                    result = await task.func(*task.args, **task.kwargs)
+                else:
+                    # Ejecutar en thread pool
+                    loop = asyncio.get_event_loop()
+                    result = await loop.run_in_executor(
+                        None, lambda: task.func(*task.args, **task.kwargs)
+                    )
+
+                task.result = result
+                task.status = TaskStatus.COMPLETED
+                task.end_time = time.time()
+
+                return TaskResult(
+                    task_id=task.id,
+                    success=True,
+                    result=result,
+                    duration=task.end_time - task.start_time
+                )
+
+            except Exception as e:
+                task.status = TaskStatus.FAILED
+                task.error = str(e)
+                task.end_time = time.time()
+
+                return TaskResult(
+                    task_id=task.id,
+                    success=False,
+                    result=None,
+                    error=str(e),
+                    duration=task.end_time - task.start_time
+                )
+
+        # Ejecutar tareas respetando dependencias
+        pending = set(task.id for task in tasks)
+        start_time = time.time()
+
+        while pending:
+            # Verificar timeout
+            if time.time() - start_time > timeout:
+                for task_id in pending:
+                    graph.nodes[task_id].status = TaskStatus.CANCELLED
+                break
+
+            # Obtener tareas listas
+            ready = graph.get_ready_tasks()
+
+            if not ready:
+                if running:
+                    await asyncio.sleep(0.1)
+                    continue
+                else:
+                    break
+
+            # Lanzar tareas hasta el límite de concurrencia
+            for task_id in ready:
+                if len(running) >= self.max_workers:
+                    break
+
+                task = graph.nodes[task_id]
+                task.status = TaskStatus.RUNNING
+                running.add(task_id)
+                pending.discard(task_id)
+
+                # Crear coroutine
+                asyncio.create_task(run_task(task)).add_done_callback(
+                    lambda fut, tid=task_id: self._task_done(tid, results, running)
+                )
+
+            await asyncio.sleep(0.05)
+
+        return list(results.values())
+
+    def _task_done(
+        self,
+        task_id: str,
+        results: Dict[str, TaskResult],
+        running: Set[str]
+    ) -> None:
+        """Callback cuando una tarea termina."""
+        running.discard(task_id)
+
+    def create_task(
+        self,
+        name: str,
+        func: Callable,
+        args: Tuple = (),
+        kwargs: Dict = None,
+        dependencies: List[str] = None
+    ) -> Task:
+        """Crea una nueva tarea."""
+        with self._lock:
+            self._task_counter += 1
+            task_id = f"task_{self._task_counter}"
+
+        return Task(
+            id=task_id,
+            name=name,
+            func=func,
+            args=args,
+            kwargs=kwargs or {},
+            dependencies=dependencies or [],
+        )
+
+    def analyze_dependencies(
+        self,
+        tasks: List[Task]
+    ) -> Dict[str, List[str]]:
+        """
+        Analiza dependencias entre tareas.
+
+        Returns:
+            Dict mapeando task_id -> lista de task_ids que dependen de él
+        """
+        dependents: Dict[str, List[str]] = defaultdict(list)
+
+        for task in tasks:
+            for dep_id in task.dependencies:
+                dependents[dep_id].append(task.id)
+
+        return dict(dependents)
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Obtiene estadísticas del ejecutor."""
+        return {
+            "max_workers": self.max_workers,
+            "tasks_created": self._task_counter,
+        }
+
+
+# Instancia global
+_executor: Optional[ParallelExecutor] = None
+
+
+def get_executor() -> ParallelExecutor:
+    global _executor
+    if _executor is None:
+        _executor = ParallelExecutor()
+    return _executor