ocerebro 0.1.0

package/src/working/memory_view.py

@@ -0,0 +1,150 @@
+"""Geração de MEMORY.md a partir das camadas working/official"""
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .yaml_storage import YAMLStorage
+    from ..official.markdown_storage import MarkdownStorage
+
+
+class MemoryView:
+    """
+    Gera MEMORY.md como view de official + working.
+
+    A memória ativa é uma visão consolidada das camadas:
+    - Official Global (decisions, preferences, policies)
+    - Official do Projeto (decisions, errors, preferences, state)
+    - Working atual (sessions, features em progresso)
+    """
+
+    def __init__(self, cerebro_path: Path, official: "MarkdownStorage", working: "YAMLStorage"):
+        """
+        Inicializa o MemoryView.
+
+        Args:
+            cerebro_path: Diretório base do Cerebro
+            official: Instância do MarkdownStorage
+            working: Instância do YAMLStorage
+        """
+        self.cerebro_path = cerebro_path
+        self.official = official
+        self.working = working
+
+    def generate(self, project: str) -> str:
+        """
+        Gera conteúdo do MEMORY.md para um projeto.
+
+        Args:
+            project: Nome do projeto
+
+        Returns:
+            Conteúdo Markdown do MEMORY.md
+        """
+        sections = ["# Cerebro - Memória Ativa", ""]
+
+        # Official Global
+        sections.append("## Official Global")
+        sections.append("")
+        global_items = self._list_global()
+        if global_items:
+            for item in global_items:
+                sections.append(f"- [{item['title']}](global/{item['_type']}/{item['_file']})")
+        else:
+            sections.append("_Nenhuma memória global_")
+        sections.append("")
+
+        # Official do Projeto
+        sections.append(f"## Official {project}")
+        sections.append("")
+        project_items = self._list_project(project)
+        if project_items:
+            for item in project_items:
+                title = item.get('title', item['_file'])
+                sections.append(f"- [{title}]({project}/{item['_type']}/{item['_file']})")
+        else:
+            sections.append("_Nenhuma memória oficial_")
+        sections.append("")
+
+        # Working atual
+        sections.append("## Working atual")
+        sections.append("")
+        working_items = self._list_working(project)
+        if working_items:
+            for item in working_items:
+                todo = item.get("todo", [])
+                sections.append(f"- {item.get('id', 'unknown')}: {item.get('status', 'unknown')}")
+                if todo:
+                    todo_str = ', '.join(todo[:3])
+                    sections.append(f"  - TODO: {todo_str}")
+        else:
+            sections.append("_Nenhuma sessão em progresso_")
+        sections.append("")
+
+        sections.append("---")
+        sections.append("Outras memórias disponíveis via Cerebro (decisions, errors, preferences, state).")
+
+        return "\n".join(sections)
+
+    def _list_global(self) -> list:
+        """
+        Lista memórias globais.
+
+        Returns:
+            Lista de itens globais com metadados
+        """
+        items = []
+        for subdir in ["decisions", "preferences", "policies"]:
+            for item in self.official.list_official("global", subdir):
+                item["_type"] = subdir
+                items.append(item)
+        return items
+
+    def _list_project(self, project: str) -> list:
+        """
+        Lista memórias do projeto.
+
+        Args:
+            project: Nome do projeto
+
+        Returns:
+            Lista de itens do projeto com metadados
+        """
+        items = []
+        for subdir in ["decisions", "errors", "preferences", "state"]:
+            for item in self.official.list_official(project, subdir):
+                item["_type"] = subdir
+                items.append(item)
+        return items
+
+    def _list_working(self, project: str) -> list:
+        """
+        Lista working do projeto.
+
+        Args:
+            project: Nome do projeto
+
+        Returns:
+            Lista de sessões e features em progresso
+        """
+        items = []
+        for session in self.working.list_sessions(project):
+            items.append(session)
+        for feature in self.working.list_features(project):
+            items.append(feature)
+        return items
+
+    def write_to_file(self, project: str) -> Path:
+        """
+        Gera e escreve MEMORY.md no arquivo.
+
+        Args:
+            project: Nome do projeto
+
+        Returns:
+            Path do arquivo MEMORY.md criado
+        """
+        content = self.generate(project)
+        memory_file = self.cerebro_path / "MEMORY.md"
+        memory_file.write_text(content, encoding="utf-8")
+        return memory_file

package/src/working/yaml_storage.py

@@ -0,0 +1,234 @@
+"""Armazenamento YAML para camada Working"""
+
+import yaml
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+def _sanitize_name(name: str) -> str:
+    """
+    Remove caracteres inseguros de nomes de arquivo.
+
+    SECURITY FIX: Previne path traversal e nomes problemáticos
+
+    Args:
+        name: Nome original
+
+    Returns:
+        Nome sanitizado
+    """
+    sanitized = re.sub(r'[^\w\-.]', '_', name)
+    if sanitized != name:
+        import sys
+        print(f"[CEREBRO] Nome sanitizado: '{name}' → '{sanitized}'", file=sys.stderr)
+    return sanitized
+
+
+class YAMLStorage:
+    """
+    Armazenamento YAML para camada Working.
+
+    Armazena sessões e features em formato YAML estruturado e editável.
+    Organização:
+    - working/{project}/sessions/{session_id}.yaml
+    - working/{project}/features/{feature_name}.yaml
+    """
+
+    def __init__(self, base_path: Path):
+        """
+        Inicializa o armazenamento YAML.
+
+        Args:
+            base_path: Diretório base para a pasta working/
+        """
+        self.base_path = base_path
+        self.base_path.mkdir(parents=True, exist_ok=True)
+
+    def _ensure_project_dir(self, project: str, subdir: str) -> Path:
+        """
+        Garante que diretório do projeto existe.
+
+        Args:
+            project: Nome do projeto
+            subdir: Subdiretório (sessions ou features)
+
+        Returns:
+            Path do diretório criado
+        """
+        dir_path = self.base_path / project / subdir
+        dir_path.mkdir(parents=True, exist_ok=True)
+        return dir_path
+
+    def write_session(self, project: str, session_id: str, data: Dict[str, Any]) -> None:
+        """
+        Escreve sessão em YAML.
+
+        Args:
+            project: Nome do projeto
+            session_id: ID da sessão
+            data: Dados da sessão
+        """
+        # SECURITY FIX: Sanitiza nomes
+        project = _sanitize_name(project)
+        session_id = _sanitize_name(session_id)
+
+        dir_path = self._ensure_project_dir(project, "sessions")
+        yaml_path = dir_path / f"{session_id}.yaml"
+
+        content = {
+            "id": session_id,
+            "type": "session",
+            **data
+        }
+
+        with open(yaml_path, "w", encoding="utf-8") as f:
+            yaml.dump(content, f, allow_unicode=True, default_flow_style=False)
+
+    def read_session(self, project: str, session_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Lê sessão de YAML.
+
+        WINDOWS FIX: encoding="utf-8" explícito
+
+        Args:
+            project: Nome do projeto
+            session_id: ID da sessão
+
+        Returns:
+            Dados da sessão ou None se não existir
+        """
+        # SECURITY FIX: Sanitiza nomes
+        project = _sanitize_name(project)
+        session_id = _sanitize_name(session_id)
+
+        yaml_path = self.base_path / project / "sessions" / f"{session_id}.yaml"
+
+        if not yaml_path.exists():
+            return None
+
+        # WINDOWS FIX: encoding="utf-8" explícito
+        return yaml.safe_load(yaml_path.read_text(encoding="utf-8"))
+
+    def list_sessions(self, project: str, limit: int = 200, status_filter: Optional[str] = None) -> List[Dict[str, Any]]:
+        """
+        Lista todas as sessões de um projeto.
+
+        PERFORMANCE FIX: Adiciona limit e status_filter para evitar carregar tudo
+
+        Args:
+            project: Nome do projeto
+            limit: Limite de sessões (padrão: 200)
+            status_filter: Filtrar por status (opcional)
+
+        Returns:
+            Lista de sessões
+        """
+        # SECURITY FIX: Sanitiza nome do projeto
+        project = _sanitize_name(project)
+
+        dir_path = self.base_path / project / "sessions"
+
+        if not dir_path.exists():
+            return []
+
+        sessions = []
+        # PERFORMANCE: reverse=True para pegar mais recentes primeiro
+        for yaml_file in sorted(dir_path.glob("*.yaml"), reverse=True):
+            # WINDOWS FIX: encoding="utf-8" explícito
+            data = yaml.safe_load(yaml_file.read_text(encoding="utf-8"))
+
+            if status_filter and data.get("status") != status_filter:
+                continue
+
+            sessions.append(data)
+            if len(sessions) >= limit:
+                break
+
+        return sessions
+
+    def write_feature(self, project: str, feature_name: str, data: Dict[str, Any]) -> None:
+        """
+        Escreve feature em YAML.
+
+        Args:
+            project: Nome do projeto
+            feature_name: Nome da feature
+            data: Dados da feature
+        """
+        # SECURITY FIX: Sanitiza nomes
+        project = _sanitize_name(project)
+        feature_name = _sanitize_name(feature_name)
+
+        dir_path = self._ensure_project_dir(project, "features")
+        yaml_path = dir_path / f"{feature_name}.yaml"
+
+        content = {
+            "id": feature_name,
+            "type": "feature",
+            **data
+        }
+
+        with open(yaml_path, "w", encoding="utf-8") as f:
+            yaml.dump(content, f, allow_unicode=True, default_flow_style=False)
+
+    def read_feature(self, project: str, feature_name: str) -> Optional[Dict[str, Any]]:
+        """
+        Lê feature de YAML.
+
+        WINDOWS FIX: encoding="utf-8" explícito
+
+        Args:
+            project: Nome do projeto
+            feature_name: Nome da feature
+
+        Returns:
+            Dados da feature ou None se não existir
+        """
+        # SECURITY FIX: Sanitiza nomes
+        project = _sanitize_name(project)
+        feature_name = _sanitize_name(feature_name)
+
+        yaml_path = self.base_path / project / "features" / f"{feature_name}.yaml"
+
+        if not yaml_path.exists():
+            return None
+
+        # WINDOWS FIX: encoding="utf-8" explícito
+        return yaml.safe_load(yaml_path.read_text(encoding="utf-8"))
+
+    def list_features(self, project: str, limit: int = 200, status_filter: Optional[str] = None) -> List[Dict[str, Any]]:
+        """
+        Lista todas as features de um projeto.
+
+        PERFORMANCE FIX: Adiciona limit e status_filter
+
+        Args:
+            project: Nome do projeto
+            limit: Limite de features (padrão: 200)
+            status_filter: Filtrar por status (opcional)
+
+        Returns:
+            Lista de features
+        """
+        # SECURITY FIX: Sanitiza nome do projeto
+        project = _sanitize_name(project)
+
+        dir_path = self.base_path / project / "features"
+
+        if not dir_path.exists():
+            return []
+
+        features = []
+        for yaml_file in sorted(dir_path.glob("*.yaml"), reverse=True):
+            # WINDOWS FIX: encoding="utf-8" explícito
+            data = yaml.safe_load(yaml_file.read_text(encoding="utf-8"))
+
+            if status_filter and data.get("status") != status_filter:
+                continue
+
+            features.append(data)
+            if len(features) >= limit:
+                break
+
+        return features