ocerebro 0.4.17 → 0.4.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ocerebro",
-  "version": "0.4.17",
+  "version": "0.4.19",
   "description": "OCerebro - Sistema de Memoria para Agentes (Claude Code/MCP)",
   "main": "bin/ocerebro.js",
   "bin": {

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ocerebro"
-version = "0.4.17"
+version = "0.4.19"
 description = "OCerebro - Sistema de Memoria para Agentes (Claude Code/MCP)"
 readme = "README.md"
 requires-python = ">=3.10"

package/src/cli/main.py

@@ -94,7 +94,13 @@ class CerebroCLI:
         self.raw_storage.append(checkpoint_event)
         return f"Checkpoint criado: {draft_name} ({len(result.events)} eventos)"
 
-    def memory(self, project: str, output: Optional[Path] = None) -> str:
+    def memory(self, project: str = None, output: Optional[Path] = None) -> str:
+        if not project:
+            try:
+                from src.core.paths import get_git_root
+                project = get_git_root().name
+            except Exception:
+                project = Path.cwd().name
         content = self.memory_view.generate(project)
         if output:
             output.write_text(content, encoding="utf-8")
@@ -432,7 +438,10 @@ def main():
 
     # Comando: memory
     memory_parser = subparsers.add_parser("memory", help="Visualizar memória ativa")
-    memory_parser.add_argument("project", help="Nome do projeto")
+    memory_parser.add_argument(
+        "project", nargs="?", default=None,
+        help="Nome do projeto (opcional, detecta pelo git root)"
+    )
     memory_parser.add_argument("--output", type=Path, help="Arquivo de saída")
 
     # Comando: search

package/src/mcp/server.py

@@ -138,10 +138,9 @@ class CerebroMCP:
                     "properties": {
                         "project": {
                             "type": "string",
-                            "description": "Nome do projeto"
+                            "description": "Nome do projeto (omitir = auto-detectar pelo working directory)"
                         }
-                    },
-                    "required": ["project"]
+                    }
                 }
             ),
             Tool(
@@ -438,39 +437,19 @@ class CerebroMCP:
         except Exception as e:
             return [TextContent(type="text", text=f"Erro: {str(e)}")]
 
-    def _memory(self, args: Dict[str, Any]) -> str:
-        """Gera memória ativa e escreve no diretório nativo do Claude Code para auto-load."""
-        project = args.get("project")
-        if not project:
-            return "Erro: project é obrigatório"
-
-        content = self.memory_view.generate(project)
-
-        # FIX 4: Escreve MEMORY.md no diretório nativo do Claude Code
-        # Assim o Claude Code carrega automaticamente na próxima sessão
+    def _detect_project(self) -> str:
+        """Detecta projeto pelo git root do cwd. Nome exato da pasta."""
         try:
-            from src.core.paths import get_auto_mem_path, get_memory_index
-            auto_mem_dir = get_auto_mem_path()
-            auto_mem_dir.mkdir(parents=True, exist_ok=True)
-            index_path = get_memory_index(auto_mem_dir)
-
-            # Gera conteúdo compatível com o formato que Claude Code espera
-            # Formato: # <title>\n\n- [type] filename (date): description
-            claude_format_lines = ["# OCerebro - Memória Ativa", ""]
-            claude_format_lines.append(f"## {project}")
-            claude_format_lines.append("")
-
-            # Parse do conteúdo gerado para extrair itens
-            for line in content.splitlines():
-                if line.startswith("- ["):
-                    claude_format_lines.append(line)
-
-            claude_content = "\n".join(claude_format_lines)
-            index_path.write_text(claude_content, encoding="utf-8")
+            from src.core.paths import get_git_root
+            return get_git_root().name
         except Exception:
-            pass  # Falha silenciosa - não bloqueia o retorno
+            return Path.cwd().name
 
-        return content
+    def _memory(self, args: Dict[str, Any]) -> str:
+        """Gera memória ativa e escreve no diretório nativo do Claude Code para auto-load."""
+        project = args.get("project") or self._detect_project()
+        path = self.memory_view.write_to_file(project)
+        return self.memory_view.generate(project)
 
     def _search(self, args: Dict[str, Any]) -> str:
         """Busca memórias"""
@@ -564,27 +543,65 @@ class CerebroMCP:
             return f"Promoção falhou: {result.metadata.get('reason', 'desconhecido')}"
 
     def _status(self) -> str:
-        """Status do sistema"""
+        """Status do sistema com contagem de memórias por tipo"""
         session_id = self.session_manager.get_session_id()
 
         lines = [
-            "Status do Cerebro:",
-            f"  Session ID: {session_id}",
-            f"  Path: {self.cerebro_path.absolute()}",
+            "╔══════════════════════════════════════════════════════════════╗",
+            "║                    🧠 OCEREBRO STATUS                        ║",
+            "╚══════════════════════════════════════════════════════════════╝",
             "",
-            "Storages:",
-            f"  Raw: {self.cerebro_path / 'raw'}",
-            f"  Working: {self.cerebro_path / 'working'}",
-            f"  Official: {self.cerebro_path / 'official'}",
+            f"Session ID: {session_id}",
+            f"Path: {self.cerebro_path.absolute()}",
             "",
-            "Índice:",
-            f"  Metadata DB: {self.cerebro_path / 'index' / 'metadata.db'}",
-            f"  Embeddings DB: {self.cerebro_path / 'index' / 'embeddings.db'}",
-            f"  Entities DB: {self.cerebro_path / 'index' / 'entities.db'}"
         ]
 
+        # Contagem de memórias por tipo (entities DB)
+        try:
+            import sqlite3
+            conn = sqlite3.connect(str(self.cerebro_path / "index" / "entities.db"))
+            cursor = conn.cursor()
+            cursor.execute("SELECT entity_type, COUNT(*) FROM entities GROUP BY entity_type ORDER BY COUNT(*) DESC")
+            type_counts = cursor.fetchall()
+            conn.close()
+
+            if type_counts:
+                total = sum(c for _, c in type_counts)
+                lines.append(f"📊 Memórias: {total} total")
+                lines.append("")
+                lines.append("Por tipo:")
+                for entity_type, count in type_counts:
+                    icon = self._get_type_icon(entity_type)
+                    lines.append(f"  {icon} {entity_type}: {count}")
+            else:
+                lines.append("📊 Memórias: 0")
+        except Exception:
+            lines.append("📊 Memórias: (banco não acessível)")
+
+        lines.append("")
+        lines.append("Storages:")
+        lines.append(f"  📁 Raw: {self.cerebro_path / 'raw'}")
+        lines.append(f"  📝 Working: {self.cerebro_path / 'working'}")
+        lines.append(f"  📋 Official: {self.cerebro_path / 'official'}")
+
         return "\n".join(lines)
 
+    def _get_type_icon(self, entity_type: str) -> str:
+        """Retorna ícone para tipo de memória"""
+        icons = {
+            "USER": "👤",
+            "FEEDBACK": "💬",
+            "PROJECT": "📂",
+            "REFERENCE": "🔗",
+            "TAG": "🏷️",
+            "TYPE": "📌",
+            "META": "⚙️",
+            "DECISION": "✅",
+            "ERROR": "❌",
+            "DRAFT": "📝",
+        }
+        return icons.get(entity_type, "📄")
+
     def _hooks(self, args: Dict[str, Any]) -> str:
         """Lista e gerencia hooks customizados"""
         action = args.get("action", "list")
@@ -777,7 +794,10 @@ Uma chamada por memória. O sistema salva e indexa automaticamente.
             m_type = type_match.group(1).strip() if type_match else "project"
         if not project:
             project_match = re.search(r'project:\s*(.*)', content)
-            project = project_match.group(1).strip() if project_match else "unknown"
+            if project_match and project_match.group(1).strip():
+                project = project_match.group(1).strip()
+            else:
+                project = self._detect_project()
         if not tags:
             tags_match = re.search(r'tags:\s*(.*)', content)
             tags = tags_match.group(1).strip() if tags_match else ""