hanuscode 1.0.0__py3-none-any.whl

hanus/session_manager.py

@@ -0,0 +1,547 @@
+# session_manager.py
+"""
+Persistencia de sesiones: guarda historial, costos, archivos modificados.
+Soporta pausa/reanudación, undo de archivos, y timeline de cambios.
+"""
+from __future__ import annotations
+import gzip
+import json
+import time
+from dataclasses import dataclass, field, asdict
+from pathlib import Path
+from typing import List, Dict, Optional, Any
+from datetime import datetime
+from enum import Enum
+
+
+SESSIONS_DIR = Path.home() / ".hanus" / "sessions"
+MAX_SESSIONS = 50
+
+
+class ChangeType(Enum):
+    """Tipo de cambio en el timeline."""
+    FILE_CREATED = "file_created"
+    FILE_MODIFIED = "file_modified"
+    FILE_DELETED = "file_deleted"
+    COMMAND_EXECUTED = "command_executed"
+    COMMAND_SUCCESS = "command_success"
+    COMMAND_ERROR = "command_error"
+    TOOL_USED = "tool_used"
+    MESSAGE_SENT = "message_sent"
+    MESSAGE_RECEIVED = "message_received"
+    SESSION_STARTED = "session_started"
+    SESSION_PAUSED = "session_paused"
+    SESSION_RESUMED = "session_resumed"
+    MILESTONE = "milestone"
+    ERROR = "error"
+    NOTE = "note"
+
+
+@dataclass
+class FileSnapshot:
+    path: str
+    content_before: str
+    content_after: str = ""
+    timestamp: float = field(default_factory=time.time)
+
+
+@dataclass
+class TimelineEvent:
+    """Un evento en el timeline de la sesión."""
+    id: str
+    type: ChangeType
+    timestamp: float
+    description: str
+    details: Dict[str, Any] = field(default_factory=dict)
+    tags: List[str] = field(default_factory=list)
+    importance: int = 1  # 1=bajo, 2=medio, 3=alto
+
+    def to_dict(self) -> Dict:
+        return {
+            "id": self.id,
+            "type": self.type.value,
+            "timestamp": self.timestamp,
+            "description": self.description,
+            "details": self.details,
+            "tags": self.tags,
+            "importance": self.importance,
+            "time_ago": self._time_ago(),
+        }
+
+    def _time_ago(self) -> str:
+        """Retorna una representación legible del tiempo transcurrido."""
+        elapsed = time.time() - self.timestamp
+        if elapsed < 60:
+            return "just now"
+        elif elapsed < 3600:
+            return f"{int(elapsed / 60)}m ago"
+        elif elapsed < 86400:
+            return f"{int(elapsed / 3600)}h ago"
+        else:
+            return f"{int(elapsed / 86400)}d ago"
+
+
+@dataclass
+class SessionData:
+    session_id: str
+    project_dir: str
+    model_provider: str
+    model_id: str
+    created_at: float = field(default_factory=time.time)
+    updated_at: float = field(default_factory=time.time)
+    messages: List[Dict] = field(default_factory=list)
+    total_input_tokens: int = 0
+    total_output_tokens: int = 0
+    total_cost_usd: float = 0.0
+    files_modified: List[str] = field(default_factory=list)
+    commands_executed: List[str] = field(default_factory=list)
+    snapshots: List[Dict] = field(default_factory=list)
+    timeline: List[Dict] = field(default_factory=list)  # Nuevo: timeline de eventos
+    name: str = ""
+    status: str = "active"  # active, paused, completed
+    milestones: List[Dict] = field(default_factory=list)  # Hitos importantes
+
+
+class SessionManager:
+
+    def __init__(self, sessions_dir: Optional[Path] = None):
+        self.dir = sessions_dir or SESSIONS_DIR
+        self.dir.mkdir(parents=True, exist_ok=True)
+        self.current: Optional[SessionData] = None
+        self._event_counter = 0
+
+    def new_session(self, project_dir: str, provider: str, model_id: str) -> SessionData:
+        ts = time.strftime("%Y%m%d_%H%M%S")
+        proj_name = Path(project_dir).name
+        sid = f"{ts}_{proj_name}"
+        self.current = SessionData(
+            session_id=sid,
+            project_dir=project_dir,
+            model_provider=provider,
+            model_id=model_id,
+            name=f"{proj_name} — {time.strftime('%d %b %H:%M')}",
+        )
+        # Añadir evento de inicio
+        self._add_timeline_event(
+            ChangeType.SESSION_STARTED,
+            f"Session started: {self.current.name}",
+            {"project_dir": project_dir, "provider": provider, "model": model_id},
+            importance=3
+        )
+        return self.current
+
+    def save(self):
+        if not self.current:
+            return
+        self.current.updated_at = time.time()
+        path = self.dir / f"{self.current.session_id}.json.gz"
+        with gzip.open(path, "wt", encoding="utf-8") as f:
+            f.write(json.dumps(asdict(self.current), ensure_ascii=False))
+        self._prune()
+
+    def load_latest(self, project_dir: str) -> Optional[SessionData]:
+        proj_name = Path(project_dir).name
+        candidates = sorted(
+            self.dir.glob(f"*_{proj_name}.json.gz"),
+            key=lambda f: f.stat().st_mtime,
+            reverse=True,
+        )
+        return self._load(candidates[0]) if candidates else None
+
+    def load_by_id(self, session_id: str) -> Optional[SessionData]:
+        p = self.dir / f"{session_id}.json.gz"
+        return self._load(p) if p.exists() else None
+
+    def list_sessions(self, limit: int = 20) -> List[Dict]:
+        files = sorted(self.dir.glob("*.json.gz"), key=lambda f: f.stat().st_mtime, reverse=True)
+        result = []
+        for f in files[:limit]:
+            sd = self._load(f)
+            if sd:
+                result.append({
+                    "id": sd.session_id,
+                    "name": sd.name,
+                    "project": sd.project_dir,
+                    "model": f"{sd.model_provider}/{sd.model_id}",
+                    "cost": sd.total_cost_usd,
+                    "messages": len(sd.messages),
+                    "updated": time.strftime("%d/%m %H:%M", time.localtime(sd.updated_at)),
+                    "status": sd.status,
+                    "files_modified": len(sd.files_modified),
+                    "events": len(sd.timeline),
+                })
+        return result
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # TIMELINE API
+    # ══════════════════════════════════════════════════════════════════════════
+
+    def record_file_created(self, path: str, content_preview: str = ""):
+        """Registra la creación de un archivo."""
+        if self.current:
+            self._add_timeline_event(
+                ChangeType.FILE_CREATED,
+                f"Created: {path}",
+                {"path": path, "preview": content_preview[:200]},
+                tags=["file", "create"],
+                importance=2
+            )
+            self.record_file_modified(path)
+
+    def record_file_modified(self, path: str, diff_preview: str = ""):
+        """Registra la modificación de un archivo."""
+        if self.current:
+            self._add_timeline_event(
+                ChangeType.FILE_MODIFIED,
+                f"Modified: {path}",
+                {"path": path, "diff": diff_preview[:200]},
+                tags=["file", "modify"],
+                importance=2
+            )
+            if path not in self.current.files_modified:
+                self.current.files_modified.append(path)
+
+    def record_file_deleted(self, path: str):
+        """Registra la eliminación de un archivo."""
+        if self.current:
+            self._add_timeline_event(
+                ChangeType.FILE_DELETED,
+                f"Deleted: {path}",
+                {"path": path},
+                tags=["file", "delete"],
+                importance=2
+            )
+
+    def record_command(self, cmd: str, success: bool = True, output_preview: str = ""):
+        """Registra la ejecución de un comando."""
+        if not self.current:
+            return
+
+        self.current.commands_executed.append(cmd)
+
+        event_type = ChangeType.COMMAND_SUCCESS if success else ChangeType.COMMAND_ERROR
+        description = f"Executed: {cmd[:50]}..." if len(cmd) > 50 else f"Executed: {cmd}"
+
+        self._add_timeline_event(
+            event_type,
+            description,
+            {"command": cmd, "success": success, "output": output_preview[:200]},
+            tags=["command", "success" if success else "error"],
+            importance=3 if not success else 1
+        )
+
+    def record_tool_use(self, tool_name: str, args: Dict, result_preview: str = ""):
+        """Registra el uso de una herramienta."""
+        if self.current:
+            self._add_timeline_event(
+                ChangeType.TOOL_USED,
+                f"Tool: {tool_name}",
+                {"tool": tool_name, "args": args, "result": result_preview[:200]},
+                tags=["tool", tool_name],
+                importance=1
+            )
+
+    def record_message(self, role: str, content_preview: str = ""):
+        """Registra un mensaje enviado o recibido."""
+        if not self.current:
+            return
+
+        event_type = ChangeType.MESSAGE_SENT if role == "user" else ChangeType.MESSAGE_RECEIVED
+        description = f"You: {content_preview[:50]}..." if role == "user" else f"Assistant: {content_preview[:50]}..."
+
+        self._add_timeline_event(
+            event_type,
+            description,
+            {"role": role, "preview": content_preview[:100]},
+            tags=["message", role],
+            importance=2
+        )
+
+    def record_milestone(self, title: str, description: str = ""):
+        """Registra un hito importante en la sesión."""
+        if not self.current:
+            return
+
+        milestone = {
+            "id": f"milestone_{self._event_counter}",
+            "title": title,
+            "description": description,
+            "timestamp": time.time(),
+        }
+        self.current.milestones.append(milestone)
+
+        self._add_timeline_event(
+            ChangeType.MILESTONE,
+            f"🎯 {title}",
+            {"description": description},
+            tags=["milestone"],
+            importance=3
+        )
+
+    def record_error(self, error: str, context: Dict = None):
+        """Registra un error."""
+        if self.current:
+            self._add_timeline_event(
+                ChangeType.ERROR,
+                f"Error: {error[:100]}",
+                {"error": error, "context": context or {}},
+                tags=["error"],
+                importance=3
+            )
+
+    def record_note(self, note: str):
+        """Registra una nota personal."""
+        if self.current:
+            self._add_timeline_event(
+                ChangeType.NOTE,
+                f"Note: {note[:100]}",
+                {"note": note},
+                tags=["note"],
+                importance=1
+            )
+
+    def get_timeline(
+        self,
+        event_types: List[str] = None,
+        tags: List[str] = None,
+        min_importance: int = 1,
+        limit: int = 100
+    ) -> List[Dict]:
+        """
+        Obtiene el timeline filtrado.
+
+        Args:
+            event_types: Filtrar por tipos de evento
+            tags: Filtrar por tags
+            min_importance: Importancia mínima (1-3)
+            limit: Máximo número de eventos
+
+        Returns:
+            Lista de eventos ordenados por tiempo
+        """
+        if not self.current:
+            return []
+
+        events = []
+        for event_data in self.current.timeline:
+            event = self._dict_to_event(event_data)
+
+            # Filtros
+            if event_types and event.type.value not in event_types:
+                continue
+            if tags and not any(tag in event.tags for tag in tags):
+                continue
+            if event.importance < min_importance:
+                continue
+
+            events.append(event.to_dict())
+
+        # Ordenar por timestamp descendente
+        events.sort(key=lambda e: e["timestamp"], reverse=True)
+
+        return events[:limit]
+
+    def get_timeline_summary(self) -> Dict:
+        """Obtiene un resumen del timeline."""
+        if not self.current:
+            return {}
+
+        events = self.current.timeline
+        by_type = {}
+        for event_data in events:
+            event_type = event_data.get("type", "unknown")
+            by_type[event_type] = by_type.get(event_type, 0) + 1
+
+        return {
+            "total_events": len(events),
+            "files_created": by_type.get("file_created", 0),
+            "files_modified": by_type.get("file_modified", 0),
+            "commands_executed": by_type.get("command_success", 0) + by_type.get("command_error", 0),
+            "commands_failed": by_type.get("command_error", 0),
+            "errors": by_type.get("error", 0),
+            "milestones": len(self.current.milestones),
+            "by_type": by_type,
+        }
+
+    def export_timeline(self, format: str = "markdown") -> str:
+        """Exporta el timeline a diferentes formatos."""
+        if not self.current:
+            return ""
+
+        events = self.get_timeline(limit=1000)
+
+        if format == "markdown":
+            lines = [
+                f"# Session Timeline: {self.current.name}",
+                f"\n**Session ID:** {self.current.session_id}",
+                f"**Created:** {datetime.fromtimestamp(self.current.created_at).isoformat()}",
+                f"**Status:** {self.current.status}",
+                f"\n## Events\n"
+            ]
+
+            for event in events:
+                time_str = datetime.fromtimestamp(event["timestamp"]).strftime("%H:%M:%S")
+                emoji = self._get_event_emoji(event["type"])
+                lines.append(f"- **{time_str}** {emoji} {event['description']}")
+
+            # Add milestones
+            if self.current.milestones:
+                lines.append("\n## Milestones\n")
+                for m in self.current.milestones:
+                    time_str = datetime.fromtimestamp(m["timestamp"]).strftime("%H:%M:%S")
+                    lines.append(f"- **{time_str}** 🎯 {m['title']}: {m['description']}")
+
+            return "\n".join(lines)
+
+        elif format == "json":
+            return json.dumps(events, indent=2)
+
+        return ""
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # MÉTODOS ORIGINALES
+    # ══════════════════════════════════════════════════════════════════════════
+
+    def snapshot_file(self, path_str: str):
+        """Guarda una copia del archivo antes de modificarlo (para /undo)."""
+        if not self.current:
+            return
+        p = Path(path_str)
+        if p.exists():
+            try:
+                content = p.read_text(encoding="utf-8", errors="replace")
+                snap = FileSnapshot(path=str(p.resolve()), content_before=content)
+                self.current.snapshots.append(asdict(snap))
+                # Máximo 20 snapshots
+                if len(self.current.snapshots) > 20:
+                    self.current.snapshots = self.current.snapshots[-20:]
+            except Exception:
+                pass
+
+    def update_costs(self, input_tokens: int, output_tokens: int, cost: float):
+        if self.current:
+            self.current.total_input_tokens += input_tokens
+            self.current.total_output_tokens += output_tokens
+            self.current.total_cost_usd += cost
+
+    def undo_last(self) -> Optional[str]:
+        """Revierte el último cambio de archivo. Retorna path o None."""
+        if not self.current or not self.current.snapshots:
+            return None
+        snap = FileSnapshot(**self.current.snapshots[-1])
+        p = Path(snap.path)
+        if snap.content_before:
+            p.write_text(snap.content_before, encoding="utf-8")
+            self.current.snapshots.pop()
+
+            # Añadir evento de undo
+            self._add_timeline_event(
+                ChangeType.FILE_MODIFIED,
+                f"Undo: {snap.path}",
+                {"path": snap.path, "action": "undo"},
+                tags=["file", "undo"],
+                importance=2
+            )
+            return snap.path
+        return None
+
+    def pause_session(self):
+        """Pausa la sesión actual."""
+        if self.current:
+            self.current.status = "paused"
+            self._add_timeline_event(
+                ChangeType.SESSION_PAUSED,
+                "Session paused",
+                importance=2
+            )
+            self.save()
+
+    def resume_session(self):
+        """Reanuda la sesión actual."""
+        if self.current:
+            self.current.status = "active"
+            self._add_timeline_event(
+                ChangeType.SESSION_RESUMED,
+                "Session resumed",
+                importance=2
+            )
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # MÉTODOS PRIVADOS
+    # ══════════════════════════════════════════════════════════════════════════
+
+    def _add_timeline_event(
+        self,
+        event_type: ChangeType,
+        description: str,
+        details: Dict = None,
+        tags: List[str] = None,
+        importance: int = 1
+    ):
+        """Añade un evento al timeline."""
+        if not self.current:
+            return
+
+        self._event_counter += 1
+        event = TimelineEvent(
+            id=f"evt_{self._event_counter}_{int(time.time() * 1000)}",
+            type=event_type,
+            timestamp=time.time(),
+            description=description,
+            details=details or {},
+            tags=tags or [],
+            importance=importance
+        )
+
+        self.current.timeline.append(event.to_dict())
+
+        # Limitar tamaño del timeline (mantener últimos 1000 eventos)
+        if len(self.current.timeline) > 1000:
+            self.current.timeline = self.current.timeline[-1000:]
+
+    def _dict_to_event(self, data: Dict) -> TimelineEvent:
+        """Convierte un diccionario a TimelineEvent."""
+        return TimelineEvent(
+            id=data.get("id", ""),
+            type=ChangeType(data.get("type", "note")),
+            timestamp=data.get("timestamp", 0),
+            description=data.get("description", ""),
+            details=data.get("details", {}),
+            tags=data.get("tags", []),
+            importance=data.get("importance", 1)
+        )
+
+    def _get_event_emoji(self, event_type: str) -> str:
+        """Obtiene un emoji para un tipo de evento."""
+        emojis = {
+            "file_created": "📄",
+            "file_modified": "✏️",
+            "file_deleted": "🗑️",
+            "command_success": "✅",
+            "command_error": "❌",
+            "tool_used": "🔧",
+            "message_sent": "💬",
+            "message_received": "🤖",
+            "session_started": "▶️",
+            "session_paused": "⏸️",
+            "session_resumed": "▶️",
+            "milestone": "🎯",
+            "error": "⚠️",
+            "note": "📝",
+        }
+        return emojis.get(event_type, "•")
+
+    def _load(self, path: Path) -> Optional[SessionData]:
+        try:
+            with gzip.open(path, "rt", encoding="utf-8") as f:
+                return SessionData(**json.loads(f.read()))
+        except Exception:
+            return None
+
+    def _prune(self):
+        files = sorted(self.dir.glob("*.json.gz"), key=lambda f: f.stat().st_mtime, reverse=True)
+        for old in files[MAX_SESSIONS:]:
+            try:
+                old.unlink()
+            except Exception:
+                pass