hanuscode 1.0.0__py3-none-any.whl

hanus/memory/manager.py

@@ -0,0 +1,265 @@
+# hanus/memory/manager.py
+"""
+Gestor de memoria persistente entre sesiones.
+
+Inspired by Claude Code's memory system with MEMORY.md index.
+"""
+from __future__ import annotations
+import json
+import os
+from pathlib import Path
+from typing import Dict, List, Optional
+from hanus.memory.types import MemoryType, MemoryEntry
+
+
+class MemoryManager:
+    """
+    Gestiona la memoria persistente del agente.
+
+    Estructura de directorios:
+    .hanus/memory/
+    ├── MEMORY.md          # Índice de memorias
+    ├── user.md            # Preferencias del usuario
+    ├── feedback.md        # Lecciones aprendidas
+    ├── project.md         # Conocimiento del proyecto
+    └── reference/
+        ├── patterns.md    # Patrones de código
+        └── apis.md        # Referencias de APIs
+
+    Features:
+    - Cargar/salvar memorias
+    - Índice automático en MEMORY.md
+    - Búsqueda de memorias
+    - Token-aware loading (solo memorías relevantes)
+    """
+
+    MEMORY_DIR = ".hanus/memory"
+    INDEX_FILE = "MEMORY.md"
+
+    def __init__(self, root_dir: Path, max_memory_tokens: int = 8000):
+        self.root_dir = Path(root_dir)
+        self.memory_dir = self.root_dir / self.MEMORY_DIR
+        self.index_file = self.memory_dir / self.INDEX_FILE
+        self.max_tokens = max_memory_tokens
+        self._memories: Dict[str, MemoryEntry] = {}
+        self._ensure_dirs()
+
+    def _ensure_dirs(self):
+        """Crea los directorios de memoria si no existen."""
+        self.memory_dir.mkdir(parents=True, exist_ok=True)
+        (self.memory_dir / "reference").mkdir(exist_ok=True)
+
+    def load_memories(self) -> str:
+        """
+        Carga todas las memorías y retorna un string formateado para contexto.
+
+        Returns:
+            String con todas las memorías formateadas para inyección en contexto
+        """
+        self._load_all()
+
+        if not self._memories:
+            return ""
+
+        lines = ["## Memoria Persistente\n"]
+
+        # Agrupar por tipo
+        by_type: Dict[MemoryType, List[MemoryEntry]] = {}
+        for mem in self._memories.values():
+            by_type.setdefault(mem.memory_type, []).append(mem)
+
+        type_labels = {
+            MemoryType.USER: "### Preferencias del Usuario",
+            MemoryType.FEEDBACK: "### Lecciones Aprendidas",
+            MemoryType.PROJECT: "### Conocimiento del Proyecto",
+            MemoryType.REFERENCE: "### Referencias",
+        }
+
+        for mem_type in [MemoryType.USER, MemoryType.FEED, MemoryType.PROJECT, MemoryType.REFERENCE]:
+            if mem_type in by_type:
+                lines.append(type_labels[mem_type])
+                for mem in by_type[mem_type]:
+                    lines.append(f"\n**{mem.name}**")
+                    if mem.description:
+                        lines.append(f"*{mem.description}*")
+                    lines.append(mem.content)
+                lines.append("")
+
+        return "\n".join(lines)
+
+    def _load_all(self):
+        """Carga todas las memorias desde disco."""
+        self._memories.clear()
+
+        # Buscar todos los archivos .md
+        for md_file in self.memory_dir.rglob("*.md"):
+            if md_file.name == self.INDEX_FILE:
+                continue
+
+            try:
+                content = md_file.read_text(encoding="utf-8")
+                mem = MemoryEntry.from_markdown(content)
+                mem.name = md_file.stem  # Usar nombre del archivo
+                self._memories[mem.name] = mem
+            except Exception:
+                continue
+
+    def save_memory(
+        self,
+        name: str,
+        memory_type: MemoryType,
+        content: str,
+        description: str = "",
+        tags: List[str] = None
+    ) -> MemoryEntry:
+        """
+        Guarda una nueva memoria.
+
+        Args:
+            name: Nombre identificador (se usará como nombre de archivo)
+            memory_type: Tipo de memoria
+            content: Contenido de la memoria
+            description: Descripción corta
+            tags: Etiquetas opcionales
+
+        Returns:
+            La entrada de memoria guardada
+        """
+        self._ensure_dirs()
+
+        # Sanitizar nombre
+        safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in name)
+
+        # Determinar directorio
+        if memory_type == MemoryType.REFERENCE:
+            mem_dir = self.memory_dir / "reference"
+        else:
+            mem_dir = self.memory_dir
+
+        mem_dir.mkdir(parents=True, exist_ok=True)
+        mem_file = mem_dir / f"{safe_name}.md"
+
+        # Crear entrada
+        entry = MemoryEntry(
+            name=safe_name,
+            memory_type=memory_type,
+            content=content,
+            description=description,
+            tags=tags or [],
+        )
+
+        # Guardar archivo
+        mem_file.write_text(entry.to_markdown(), encoding="utf-8")
+
+        # Actualizar índice
+        self._update_index()
+
+        # Guardar en memoria
+        self._memories[safe_name] = entry
+
+        return entry
+
+    def _update_index(self):
+        """Actualiza el archivo MEMORY.md con un índice de todas las memorias."""
+        self._load_all()
+
+        lines = [
+            "# Hanus Memory Index\n",
+            "Este archivo es generado automáticamente. No editar directamente.\n",
+        ]
+
+        # Agrupar por tipo
+        by_type: Dict[MemoryType, List[MemoryEntry]] = {}
+        for mem in self._memories.values():
+            by_type.setdefault(mem.memory_type, []).append(mem)
+
+        type_labels = {
+            MemoryType.USER: "## Preferencias del Usuario",
+            MemoryType.FEEDBACK: "## Lecciones Aprendidas",
+            MemoryType.PROJECT: "## Proyecto",
+            MemoryType.REFERENCE: "## Referencias",
+        }
+
+        for mem_type, label in type_labels.items():
+            if mem_type in by_type:
+                lines.append(f"\n{label}\n")
+                for mem in sorted(by_type[mem_type], key=lambda m: m.name):
+                    desc = mem.description[:100] if mem.description else mem.content[:100]
+                    lines.append(f"- [{mem.name}]({mem.memory_type.value}/{mem.name}.md) — {desc}")
+
+        self.index_file.write_text("\n".join(lines), encoding="utf-8")
+
+    def get(self, name: str) -> Optional[MemoryEntry]:
+        """Obtiene una memoria por nombre."""
+        if not self._memories:
+            self._load_all()
+        return self._memories.get(name)
+
+    def delete(self, name: str) -> bool:
+        """Elimina una memoria por nombre."""
+        mem = self.get(name)
+        if not mem:
+            return False
+
+        # Determinar archivo
+        if mem.memory_type == MemoryType.REFERENCE:
+            mem_file = self.memory_dir / "reference" / f"{name}.md"
+        else:
+            mem_file = self.memory_dir / f"{name}.md"
+
+        if mem_file.exists():
+            mem_file.unlink()
+
+        del self._memories[name]
+        self._update_index()
+        return True
+
+    def search(self, query: str, limit: int = 5) -> List[MemoryEntry]:
+        """
+        Busca memorias que contengan el query.
+
+        Args:
+            query: Texto a buscar
+            limit: Máximo de resultados
+
+        Returns:
+            Lista de memorias que coinciden
+        """
+        if not self._memories:
+            self._load_all()
+
+        query_lower = query.lower()
+        results = []
+
+        for mem in self._memories.values():
+            score = 0
+            # Buscar en nombre (peso 2)
+            if query_lower in mem.name.lower():
+                score += 2
+            # Buscar en descripción (peso 1)
+            if mem.description and query_lower in mem.description.lower():
+                score += 1
+            # Buscar en contenido (peso 1)
+            if query_lower in mem.content.lower():
+                score += 1
+            # Buscar en tags (peso 2)
+            if any(query_lower in tag.lower() for tag in mem.tags):
+                score += 2
+
+            if score > 0:
+                results.append((score, mem))
+
+        results.sort(key=lambda x: -x[0])
+        return [mem for _, mem in results[:limit]]
+
+    def list_by_type(self, memory_type: MemoryType) -> List[MemoryEntry]:
+        """Lista todas las memorias de un tipo."""
+        if not self._memories:
+            self._load_all()
+        return [mem for mem in self._memories.values() if mem.memory_type == memory_type]
+
+    def list_all(self) -> List[MemoryEntry]:
+        """Lista todas las memorias."""
+        if not self._memories:
+            self._load_all()
+        return list(self._memories.values())

hanus/memory/types.py

@@ -0,0 +1,119 @@
+# hanus/memory/types.py
+"""
+Tipos de datos para el sistema de memoria.
+"""
+from __future__ import annotations
+import time
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional
+from enum import Enum
+
+
+class MemoryType(Enum):
+    """
+    Tipos de memoria disponibles.
+
+    - USER: Preferencias del usuario, rol, conocimientos
+    - FEEDBACK: Lecciones aprendidas de errores y aciertos
+    - PROJECT: Conocimiento del proyecto actual
+    - REFERENCE: Referencias externas (APIs, patrones)
+    """
+    USER = "user"
+    FEEDBACK = "feedback"
+    PROJECT = "project"
+    REFERENCE = "reference"
+
+
+@dataclass
+class MemoryEntry:
+    """
+    Una entrada de memoria individual.
+    """
+    name: str                    # Nombre identificador
+    memory_type: MemoryType      # Tipo de memoria
+    content: str                 # Contenido de la memoria
+    description: str = ""        # Descripción corta (para el índice)
+    created_at: float = field(default_factory=time.time)
+    updated_at: float = field(default_factory=time.time)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    tags: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serializa la entrada a diccionario."""
+        return {
+            "name": self.name,
+            "type": self.memory_type.value,
+            "content": self.content,
+            "description": self.description,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "metadata": self.metadata,
+            "tags": self.tags,
+        }
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "MemoryEntry":
+        """Deserializa desde diccionario."""
+        return cls(
+            name=d["name"],
+            memory_type=MemoryType(d.get("type", "project")),
+            content=d.get("content", ""),
+            description=d.get("description", ""),
+            created_at=d.get("created_at", time.time()),
+            updated_at=d.get("updated_at", time.time()),
+            metadata=d.get("metadata", {}),
+            tags=d.get("tags", []),
+        )
+
+    def to_markdown(self) -> str:
+        """
+        Formatea la memoria como markdown con frontmatter.
+
+        Formato compatible con Claude Code.
+        """
+        lines = [
+            "---",
+            f"name: {self.name}",
+            f"description: {self.description}",
+            f"type: {self.memory_type.value}",
+        ]
+        if self.tags:
+            lines.append(f"tags: {', '.join(self.tags)}")
+        lines.extend([
+            "---",
+            "",
+            self.content,
+        ])
+        return "\n".join(lines)
+
+    @classmethod
+    def from_markdown(cls, content: str) -> "MemoryEntry":
+        """Parsea una memoria desde formato markdown con frontmatter."""
+        import re
+
+        # Parsear frontmatter
+        frontmatter = {}
+        if content.startswith("---"):
+            parts = content.split("---", 2)
+            if len(parts) >= 3:
+                for line in parts[1].strip().split("\n"):
+                    if ":" in line:
+                        key, _, value = line.partition(":")
+                        key = key.strip()
+                        value = value.strip()
+                        if key == "tags":
+                            value = [t.strip() for t in value.split(",")]
+                        frontmatter[key] = value
+                body = parts[2].strip()
+            else:
+                body = content
+        else:
+            body = content
+
+        return cls(
+            name=frontmatter.get("name", "unnamed"),
+            memory_type=MemoryType(frontmatter.get("type", "project")),
+            content=body,
+            description=frontmatter.get("description", ""),
+            tags=frontmatter.get("tags", []),
+        )