hanuscode 1.0.0__py3-none-any.whl

hanus/tasks/manager.py

@@ -0,0 +1,330 @@
+# hanus/tasks/manager.py
+"""
+Gestor de tareas integrado en el motor del agente.
+"""
+from __future__ import annotations
+import json
+import time
+from pathlib import Path
+from typing import Dict, List, Optional
+from hanus.tasks.models import Task, TaskStatus
+
+
+class TaskManager:
+    """
+    Gestiona el ciclo de vida de las tareas del agente.
+
+    Features:
+    - Crear/actualizar/listar/obtener tareas
+    - Tracking de dependencias (blocked_by/blocks)
+    - Tracking de progreso por tarea
+    - Persistencia en archivo JSON
+    """
+
+    TASKS_FILE = ".hanus_tasks.json"
+
+    def __init__(self, root_dir: Path):
+        self.root_dir = Path(root_dir)
+        self._tasks: Dict[str, Task] = {}
+        self._next_id: int = 1
+        self._load()
+
+    def _load(self):
+        """Carga tareas desde archivo JSON."""
+        tasks_file = self.root_dir / self.TASKS_FILE
+        if not tasks_file.exists():
+            return
+
+        try:
+            data = json.loads(tasks_file.read_text(encoding="utf-8"))
+            for task_data in data.get("tasks", []):
+                task = Task.from_dict(task_data)
+                self._tasks[task.id] = task
+                # Actualizar next_id
+                try:
+                    task_id_int = int(task.id)
+                    self._next_id = max(self._next_id, task_id_int + 1)
+                except ValueError:
+                    pass
+        except Exception:
+            # Si hay error, empezar con tareas vacías
+            self._tasks = {}
+
+    def _save(self):
+        """Guarda tareas a archivo JSON."""
+        tasks_file = self.root_dir / self.TASKS_FILE
+        data = {
+            "tasks": [t.to_dict() for t in self._tasks.values()],
+            "updated_at": time.time(),
+        }
+        tasks_file.write_text(
+            json.dumps(data, indent=2, ensure_ascii=False),
+            encoding="utf-8"
+        )
+
+    def create(
+        self,
+        subject: str,
+        description: str = "",
+        activeForm: str = "",
+        metadata: Optional[Dict] = None
+    ) -> Task:
+        """
+        Crea una nueva tarea.
+
+        Args:
+            subject: Título breve de la tarea
+            description: Descripción completa
+            activeForm: Forma presente continuo (ej: "Implementando login")
+            metadata: Datos adicionales
+
+        Returns:
+            La tarea creada
+        """
+        task_id = str(self._next_id)
+        self._next_id += 1
+
+        task = Task(
+            id=task_id,
+            subject=subject,
+            description=description or subject,
+            activeForm=activeForm or f"{subject}...",
+            metadata=metadata or {},
+        )
+
+        self._tasks[task_id] = task
+        self._save()
+        return task
+
+    def update(self, task_id: str, **kwargs) -> Optional[Task]:
+        """
+        Actualiza campos de una tarea existente.
+
+        Args:
+            task_id: ID de la tarea
+            **kwargs: Campos a actualizar (status, subject, description, etc.)
+
+        Returns:
+            La tarea actualizada o None si no existe
+        """
+        task = self._tasks.get(task_id)
+        if not task:
+            return None
+
+        # Campos permitidos para actualizar
+        allowed = {
+            "status", "subject", "description", "owner",
+            "blocked_by", "blocks", "metadata", "activeForm"
+        }
+
+        for key, value in kwargs.items():
+            if key in allowed:
+                if key == "status" and isinstance(value, str):
+                    value = TaskStatus(value)
+                setattr(task, key, value)
+
+        task.updated_at = time.time()
+
+        # Si se marca como completada, registrar timestamp
+        if task.status == TaskStatus.COMPLETED and not task.completed_at:
+            task.completed_at = time.time()
+
+        self._save()
+        return task
+
+    def get(self, task_id: str) -> Optional[Task]:
+        """Obtiene una tarea por ID."""
+        return self._tasks.get(task_id)
+
+    def list(
+        self,
+        status: Optional[TaskStatus] = None,
+        owner: Optional[str] = None
+    ) -> List[Task]:
+        """
+        Lista tareas con filtros opcionales.
+
+        Args:
+            status: Filtrar por estado
+            owner: Filtrar por owner
+
+        Returns:
+            Lista de tareas ordenadas por ID
+        """
+        tasks = list(self._tasks.values())
+
+        if status:
+            tasks = [t for t in tasks if t.status == status]
+        if owner:
+            tasks = [t for t in tasks if t.owner == owner]
+
+        # Ordenar por ID numérico
+        def sort_key(t: Task) -> int:
+            try:
+                return int(t.id)
+            except ValueError:
+                return 999999
+
+        return sorted(tasks, key=sort_key)
+
+    def claim(self, task_id: str, owner: str) -> Optional[Task]:
+        """
+        Reclama una tarea (la marca como in_progress y asigna owner).
+
+        Returns:
+            La tarea reclamada o None si no está disponible
+        """
+        task = self._tasks.get(task_id)
+        if not task:
+            return None
+
+        if task.status != TaskStatus.PENDING:
+            return None
+
+        # Verificar que no está bloqueada
+        if self._is_blocked(task):
+            return None
+
+        task.status = TaskStatus.IN_PROGRESS
+        task.owner = owner
+        task.updated_at = time.time()
+        self._save()
+        return task
+
+    def complete(self, task_id: str) -> Optional[Task]:
+        """Marca una tarea como completada."""
+        return self.update(task_id, status=TaskStatus.COMPLETED)
+
+    def fail(self, task_id: str, reason: str = "") -> Optional[Task]:
+        """Marca una tarea como fallida."""
+        task = self._tasks.get(task_id)
+        if not task:
+            return None
+
+        task.status = TaskStatus.FAILED
+        task.updated_at = time.time()
+        if reason:
+            task.metadata["fail_reason"] = reason
+
+        self._save()
+        return task
+
+    def get_next_available(self) -> Optional[Task]:
+        """
+        Obtiene la siguiente tarea disponible para trabajar.
+
+        Returns:
+            La siguiente tarea pending y no bloqueada, o None
+        """
+        # Primero, tareas que ya están in_progress
+        for task in self.list(status=TaskStatus.IN_PROGRESS):
+            return task
+
+        # Luego, tareas pending ordenadas por ID
+        for task in self.list(status=TaskStatus.PENDING):
+            if not self._is_blocked(task):
+                return task
+
+        return None
+
+    def _is_blocked(self, task: Task) -> bool:
+        """Verifica si una tarea está bloqueada por tareas incompletas."""
+        for blocker_id in task.blocked_by:
+            blocker = self._tasks.get(blocker_id)
+            if blocker and blocker.status != TaskStatus.COMPLETED:
+                return True
+        return False
+
+    def resolve_dependencies(self) -> List[str]:
+        """
+        Resuelve el orden de ejecución basado en dependencias.
+
+        Returns:
+            Lista de IDs de tareas en orden de ejecución
+        """
+        # Topological sort
+        result = []
+        visited = set()
+        temp_mark = set()
+
+        def visit(task_id: str):
+            if task_id in temp_mark:
+                # Ciclo detectado - ignorar
+                return
+            if task_id in visited:
+                return
+
+            temp_mark.add(task_id)
+            task = self._tasks.get(task_id)
+            if task:
+                for dep_id in task.blocked_by:
+                    visit(dep_id)
+
+            temp_mark.remove(task_id)
+            visited.add(task_id)
+            result.append(task_id)
+
+        for task_id in self._tasks:
+            if task_id not in visited:
+                visit(task_id)
+
+        return result
+
+    def clear_completed(self) -> int:
+        """Elimina las tareas completadas. Retorna el número eliminadas."""
+        to_remove = [
+            tid for tid, t in self._tasks.items()
+            if t.status == TaskStatus.COMPLETED
+        ]
+        for tid in to_remove:
+            del self._tasks[tid]
+        if to_remove:
+            self._save()
+        return len(to_remove)
+
+    def reset(self) -> int:
+        """Elimina todas las tareas. Retorna el número eliminadas."""
+        count = len(self._tasks)
+        self._tasks.clear()
+        self._next_id = 1
+        if count:
+            self._save()
+        return count
+
+    def status_summary(self) -> Dict[str, int]:
+        """Retorna resumen de estados de tareas."""
+        summary = {s.value: 0 for s in TaskStatus}
+        for task in self._tasks.values():
+            summary[task.status.value] += 1
+        return summary
+
+    def format_status(self) -> str:
+        """Format current task status for display."""
+        summary = self.status_summary()
+        total = sum(summary.values())
+        if total == 0:
+            return "No tasks registered."
+
+        lines = [f"Tasks: {summary['pending']} pending, "
+                f"{summary['in_progress']} in progress, "
+                f"{summary['completed']} completed, "
+                f"{summary['failed']} failed"]
+
+        # Progress bar
+        done = summary['completed']
+        pct = done / total * 100 if total > 0 else 0
+        bar_len = 20
+        filled = int(bar_len * done / total) if total > 0 else 0
+        bar = "█" * filled + "░" * (bar_len - filled)
+        lines.append(f"[{bar}] {pct:.0f}%")
+
+        # Tasks in progress and pending
+        for task in self.list():
+            if task.status == TaskStatus.IN_PROGRESS:
+                blocked = " (blocked)" if self._is_blocked(task) else ""
+                lines.append(f"  ● {task.id}: {task.subject}{blocked}")
+            elif task.status == TaskStatus.PENDING:
+                blocked = " ◎ blocked" if self._is_blocked(task) else ""
+                lines.append(f"  ○ {task.id}: {task.subject}{blocked}")
+
+        return "\n".join(lines)

hanus/tasks/models.py

@@ -0,0 +1,106 @@
+# hanus/tasks/models.py
+"""
+Modelos de datos para el sistema de tareas.
+"""
+from __future__ import annotations
+import time
+from dataclasses import dataclass, field
+from typing import Dict, List, Any, Optional
+from enum import Enum
+import json
+
+
+class TaskStatus(Enum):
+    """Estados posibles de una tarea."""
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    BLOCKED = "blocked"
+
+
+@dataclass
+class Task:
+    """
+    Representa una tarea de seguimiento para el agente.
+
+    Attributes:
+        id: Identificador único de la tarea (string como "1", "2", etc.)
+        subject: Título breve de la tarea (imperativo, ej: "Implementar login")
+        description: Descripción completa de lo que se necesita hacer
+        status: Estado actual de la tarea
+        owner: ID del agente que tiene la tarea asignada (opcional)
+        created_at: Timestamp de creación
+        updated_at: Timestamp de última actualización
+        completed_at: Timestamp de completado (opcional)
+        blocked_by: Lista de IDs de tareas que deben completarse primero
+        blocks: Lista de IDs de tareas que dependen de esta
+        metadata: Datos adicionales arbitrarios
+        activeForm: Forma presente continuo para mostrar en UI (ej: "Implementando login")
+    """
+    id: str
+    subject: str
+    description: str
+    status: TaskStatus = TaskStatus.PENDING
+    owner: Optional[str] = None
+    created_at: float = field(default_factory=time.time)
+    updated_at: float = field(default_factory=time.time)
+    completed_at: Optional[float] = None
+    blocked_by: List[str] = field(default_factory=list)
+    blocks: List[str] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    activeForm: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serializa la tarea a diccionario para persistencia."""
+        return {
+            "id": self.id,
+            "subject": self.subject,
+            "description": self.description,
+            "status": self.status.value,
+            "owner": self.owner,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "completed_at": self.completed_at,
+            "blocked_by": self.blocked_by,
+            "blocks": self.blocks,
+            "metadata": self.metadata,
+            "activeForm": self.activeForm,
+        }
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "Task":
+        """Deserializa una tarea desde diccionario."""
+        return cls(
+            id=d["id"],
+            subject=d["subject"],
+            description=d["description"],
+            status=TaskStatus(d.get("status", "pending")),
+            owner=d.get("owner"),
+            created_at=d.get("created_at", time.time()),
+            updated_at=d.get("updated_at", time.time()),
+            completed_at=d.get("completed_at"),
+            blocked_by=d.get("blocked_by", []),
+            blocks=d.get("blocks", []),
+            metadata=d.get("metadata", {}),
+            activeForm=d.get("activeForm", ""),
+        )
+
+    def is_available(self) -> bool:
+        """Retorna True si la tarea puede ser empezada (pending y no bloqueada)."""
+        if self.status != TaskStatus.PENDING:
+            return False
+        # Las tareas bloqueadas no están disponibles
+        # (el manager debe verificar que las blocked_by estén completadas)
+        return True
+
+    def __str__(self) -> str:
+        status_icons = {
+            TaskStatus.PENDING: "○",
+            TaskStatus.IN_PROGRESS: "●",
+            TaskStatus.COMPLETED: "✓",
+            TaskStatus.FAILED: "✗",
+            TaskStatus.BLOCKED: "◎",
+        }
+        icon = status_icons.get(self.status, "?")
+        return f"[{icon}] {self.id}: {self.subject}"

hanus/terminal_prompt.py

@@ -0,0 +1,166 @@
+# hanus/terminal_prompt.py — Prompt de terminal robusto
+"""
+Maneja input del usuario con soporte para:
+- Multiline (pegar código)
+- Streaming toggle
+- Caracteres de control correctos
+- Background input (typing while agent works)
+"""
+from __future__ import annotations
+import sys
+import os
+import threading
+import select
+
+
+class TerminalPrompt:
+    """
+    Prompt de terminal que maneja correctamente el input del usuario.
+    """
+
+    def __init__(self):
+        self.streaming_enabled = False  # Streaming DESACTIVADO por defecto
+        self._background_buffer: str = ""
+        self._background_thread: threading.Thread | None = None
+        self._background_stop = threading.Event()
+        self._background_active = False
+        self._buffer_lock = threading.Lock()
+
+    def read_line(self, prompt_text: str = "▶") -> str:
+        """
+        Lee una línea del usuario.
+        """
+        try:
+            # Usar input() estándar - más confiable
+            line = input(f"\033[96m\033[1m{prompt_text}\033[0m ")
+            return line.strip()
+
+        except KeyboardInterrupt:
+            print("^C")
+            return ""
+        except EOFError:
+            return ""
+
+    def read_multiline(self, prompt_text: str = "") -> str:
+        """
+        Lee múltiples líneas hasta recibir una línea vacía.
+        Útil para pegar código.
+        """
+        if prompt_text:
+            print(f"\n\033[96m▶ {prompt_text}\033[0m")
+
+        print("\033[90m  (línea vacía para terminar)\033[0m")
+        print("\033[96m│\033[0m ", end="", flush=True)
+
+        lines = []
+        try:
+            while True:
+                line = input()
+                if not line:  # Línea vacía termina
+                    break
+                lines.append(line)
+                print("\033[96m│\033[0m ", end="", flush=True)
+
+        except KeyboardInterrupt:
+            print("^C")
+        except EOFError:
+            pass
+
+        return "\n".join(lines)
+
+    def toggle_streaming(self) -> bool:
+        """Activa/desactiva streaming. Retorna el nuevo estado."""
+        self.streaming_enabled = not self.streaming_enabled
+        return self.streaming_enabled
+
+    def is_streaming(self) -> bool:
+        """Retorna si el streaming está activado."""
+        return self.streaming_enabled
+
+    def start_background_input(self):
+        """
+        Start collecting input in the background while agent works.
+        User can type while the agent is processing.
+        Input is collected silently (blind typing) and shown after agent finishes.
+        """
+        if self._background_active:
+            return
+
+        self._background_active = True
+        self._background_stop.clear()
+        with self._buffer_lock:
+            self._background_buffer = ""
+
+        def collect_input():
+            """Background thread that collects stdin silently."""
+            try:
+                while not self._background_stop.is_set():
+                    try:
+                        if hasattr(sys.stdin, 'fileno') and os.isatty(sys.stdin.fileno()):
+                            # Use select for non-blocking stdin check (Unix only)
+                            ready, _, _ = select.select([sys.stdin], [], [], 0.1)
+                            if ready:
+                                line = sys.stdin.readline()
+                                if line:
+                                    with self._buffer_lock:
+                                        self._background_buffer += line
+                    except (ValueError, OSError):
+                        # stdin might be closed or not a tty
+                        break
+                    except Exception:
+                        pass
+            except Exception:
+                pass
+
+        # Only start background thread on Unix-like systems with a TTY
+        if hasattr(sys.stdin, 'fileno'):
+            try:
+                if os.isatty(sys.stdin.fileno()):
+                    self._background_thread = threading.Thread(target=collect_input, daemon=True)
+                    self._background_thread.start()
+                else:
+                    self._background_active = False
+            except Exception:
+                self._background_active = False
+
+    def stop_background_input(self) -> str:
+        """
+        Stop background input collection and return collected input.
+        """
+        self._background_stop.set()
+        self._background_active = False
+
+        if self._background_thread:
+            self._background_thread.join(timeout=0.5)
+            self._background_thread = None
+
+        with self._buffer_lock:
+            collected = self._background_buffer
+            self._background_buffer = ""
+
+        # Show what was collected if any
+        if collected:
+            print(f"\n\033[90m  📝 Queued input ({len(collected)} chars): {collected[:50]}{'...' if len(collected) > 50 else ''}\033[0m")
+
+        return collected
+
+    def restore_terminal(self):
+        """No-op, mantenemos por compatibilidad."""
+        pass
+
+
+# Singleton global
+_prompt_instance: TerminalPrompt | None = None
+
+
+def get_prompt() -> TerminalPrompt:
+    """Obtiene la instancia global del prompt."""
+    global _prompt_instance
+    if _prompt_instance is None:
+        _prompt_instance = TerminalPrompt()
+    return _prompt_instance
+
+
+def restore_terminal():
+    """Restaura el terminal al salir."""
+    pass