ocerebro 0.1.9 → 0.2.1

package/cerebro/cerebro_setup.py

@@ -187,41 +187,77 @@ def merge_configs(existing: dict, new: dict) -> dict:
     return result
 
 
-def setup_slash_commands(project_path: Path) -> bool:
-    """Cria slash commands /cerebro no .claude/commands/ do projeto."""
+def setup_slash_commands(project_path: Path | None = None, global_commands: bool = True) -> bool:
+    """Cria slash commands /cerebro no .claude/commands/ do projeto e global."""
 
-    commands_dir = project_path / ".claude" / "commands"
-    commands_dir.mkdir(parents=True, exist_ok=True)
+    if project_path:
+        commands_dir = project_path / ".claude" / "commands"
+        commands_dir.mkdir(parents=True, exist_ok=True)
 
-    dream_cmd = commands_dir / "cerebro-dream.md"
-    if not dream_cmd.exists():
-        dream_cmd.write_text("""---
+        dream_cmd = commands_dir / "cerebro-dream.md"
+        if not dream_cmd.exists():
+            dream_cmd.write_text("""---
 description: Extrair memórias da sessão atual
 ---
 Execute: ocerebro dream --since 7 --apply
 Mostre o relatório completo do que foi salvo.
 """, encoding="utf-8")
-        print(f"[OK] Slash command criado: {dream_cmd}")
+            print(f"[OK] Slash command criado: {dream_cmd}")
 
-    status_cmd = commands_dir / "cerebro-status.md"
-    if not status_cmd.exists():
-        status_cmd.write_text("""---
+        status_cmd = commands_dir / "cerebro-status.md"
+        if not status_cmd.exists():
+            status_cmd.write_text("""---
 description: Ver status da memória do projeto
 ---
 Execute: ocerebro status
 Liste quantas memórias existem por tipo.
 """, encoding="utf-8")
-        print(f"[OK] Slash command criado: {status_cmd}")
+            print(f"[OK] Slash command criado: {status_cmd}")
 
-    gc_cmd = commands_dir / "cerebro-gc.md"
-    if not gc_cmd.exists():
-        gc_cmd.write_text("""---
+        gc_cmd = commands_dir / "cerebro-gc.md"
+        if not gc_cmd.exists():
+            gc_cmd.write_text("""---
 description: Limpeza de memórias antigas
 ---
 Execute: ocerebro gc --threshold 30
 Mostre o que será arquivado antes de confirmar.
 """, encoding="utf-8")
-        print(f"[OK] Slash command criado: {gc_cmd}")
+            print(f"[OK] Slash command criado: {gc_cmd}")
+
+    # Slash commands globais em ~/.claude/commands/
+    if global_commands:
+        global_commands_dir = Path.home() / ".claude" / "commands"
+        global_commands_dir.mkdir(parents=True, exist_ok=True)
+
+        dream_global = global_commands_dir / "cerebro-dream.md"
+        if not dream_global.exists():
+            dream_global.write_text("""---
+description: Extrair memórias da sessão atual (global)
+---
+Execute: ocerebro dream --since 7 --apply
+Mostre o relatório completo do que foi salvo.
+""", encoding="utf-8")
+            print(f"[OK] Slash command global criado: {dream_global}")
+
+        status_global = global_commands_dir / "cerebro-status.md"
+        if not status_global.exists():
+            status_global.write_text("""---
+description: Ver status da memória (global)
+---
+Execute: ocerebro status
+Liste quantas memórias existem por tipo.
+""", encoding="utf-8")
+            print(f"[OK] Slash command global criado: {status_global}")
+
+        gc_global = global_commands_dir / "cerebro-gc.md"
+        if not gc_global.exists():
+            gc_global.write_text("""---
+description: Limpeza de memórias antigas (global)
+---
+Execute: ocerebro gc --threshold 30
+Mostre o que será arquivado antes de confirmar.
+""", encoding="utf-8")
+            print(f"[OK] Slash command global criado: {gc_global}")
 
     return True
 
@@ -358,6 +394,23 @@ def setup_claude(auto: bool = True) -> bool:
                 existing_config["mcp"] = {}
             existing_config["mcp"]["enabled"] = True
 
+            # Adiciona hook para dream automatico ao final da sessao
+            if "hooks" not in existing_config:
+                existing_config["hooks"] = {}
+
+            # Hook Stop: roda dream ao final de cada sessao
+            existing_config["hooks"]["Stop"] = [
+                {
+                    "matcher": "",
+                    "hooks": [
+                        {
+                            "type": "command",
+                            "command": f"{python_cmd} -m src.cli.main dream --since 1 --apply --silent"
+                        }
+                    ]
+                }
+            ]
+
             config_path.write_text(
                 json.dumps(existing_config, indent=2, ensure_ascii=False),
                 encoding="utf-8"
@@ -503,7 +556,7 @@ def main():
             project = Path(sys.argv[2]) if len(sys.argv) > 2 else Path.cwd()
             setup_ocerebro_dir(project)
             setup_hooks(project)
-            setup_slash_commands(project)
+            setup_slash_commands(project=project)
             setup_claude(auto=True)
             sys.exit(0)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ocerebro",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "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.1.9"
+version = "0.2.1"
 description = "OCerebro - Sistema de Memoria para Agentes (Claude Code/MCP)"
 readme = "README.md"
 requires-python = ">=3.10"

package/src/cli/main.py

@@ -363,6 +363,7 @@ def main():
     dream_parser = subparsers.add_parser("dream", help="Extração automática de memórias")
     dream_parser.add_argument("--since", type=int, default=7, dest="since_days")
     dream_parser.add_argument("--apply", action="store_true", dest="apply")
+    dream_parser.add_argument("--silent", action="store_true", dest="silent", help="Não imprimir output (para hooks)")
 
     # Comando: remember
     remember_parser = subparsers.add_parser("remember", help="Revisão e promoção de memórias")
@@ -434,6 +435,8 @@ def main():
         )
     elif args.command == "dream":
         result = cli.dream(since_days=args.since_days, dry_run=not args.apply)
+        if getattr(args, 'silent', False):
+            sys.exit(0)
     elif args.command == "remember":
         result = cli.remember(dry_run=not args.apply)
     elif args.command == "gc":
@@ -442,6 +445,8 @@ def main():
         parser.print_help()
         sys.exit(1)
 
+    if getattr(args, 'silent', False):
+        sys.exit(0)
     print(result)
 
 

package/src/mcp/server.py

@@ -282,7 +282,7 @@ class CerebroMCP:
             ),
             Tool(
                 name="cerebro_dream",
-                description="Extração automática de memórias (replica extractMemories do Claude Code) - analisa transcript e extrai memórias para user/feedback/project/reference",
+                description="Prepara prompt para extração de memórias - use cerebro_capture_memory após receber o prompt",
                 inputSchema={
                     "type": "object",
                     "properties": {
@@ -290,15 +290,28 @@ class CerebroMCP:
                             "type": "integer",
                             "description": "Dias para analisar (padrão: 7)",
                             "default": 7
-                        },
-                        "dry_run": {
-                            "type": "boolean",
-                            "description": "Se True, apenas simula (padrão: True)",
-                            "default": True
                         }
                     }
                 }
             ),
+            Tool(
+                name="cerebro_capture_memory",
+                description="Captura memórias da conversa atual e salva nos arquivos - requer prompt do cerebro_dream",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "prompt": {
+                            "type": "string",
+                            "description": "Prompt de extração retornado por cerebro_dream"
+                        },
+                        "memory_dir": {
+                            "type": "string",
+                            "description": "Diretório de memória (opcional)"
+                        }
+                    },
+                    "required": ["prompt"]
+                }
+            ),
             Tool(
                 name="cerebro_remember",
                 description="Revisão e promoção de memórias (replica /remember do Claude Code) - classifica memórias por tipo e detecta duplicatas/conflitos entre camadas",
@@ -366,6 +379,8 @@ class CerebroMCP:
                 result = self._remember(arguments)
             elif name == "cerebro_gc":
                 result = self._gc(arguments)
+            elif name == "cerebro_capture_memory":
+                result = self._capture_memory(arguments)
             else:
                 return [TextContent(type="text", text=f"Ferramenta desconhecida: {name}")]
 
@@ -598,13 +613,78 @@ class CerebroMCP:
         return self.memory_diff.generate_report(result, format=format)
 
     def _dream(self, args: Dict[str, Any]) -> str:
-        """Extração automática de memórias"""
-        since_days = args.get("since_days", 7)
-        dry_run = args.get("dry_run", True)
+        """Prepara prompt para extração de memórias.
+
+        Retorna o prompt de extração + instruções para usar cerebro_capture_memory.
+        """
+        from src.consolidation.dream import (
+            run_dream,
+            build_extract_dream_prompt,
+            scan_memory_files,
+            format_memory_manifest,
+            count_transcript_messages
+        )
 
+        since_days = args.get("since_days", 7)
         memory_dir = get_auto_mem_path()
-        result = run_dream(memory_dir=memory_dir, since_days=since_days, dry_run=dry_run)
-        return generate_dream_report(result)
+
+        # Scan de memórias existentes
+        existing = scan_memory_files(memory_dir)
+        existing_manifest = format_memory_manifest(existing)
+
+        # Contagem de mensagens novas
+        message_count = count_transcript_messages(since_days)
+
+        if message_count == 0:
+            return "Nenhuma mensagem nova nos últimos {} dias. O prompt de extração não será gerado.".format(since_days)
+
+        # Build do prompt
+        prompt_sections = build_extract_dream_prompt(
+            new_message_count=message_count,
+            existing_memories=existing_manifest,
+            memory_dir=memory_dir,
+        )
+        full_prompt = "\n".join(prompt_sections)
+
+        return f"""=== PROMPT DE EXTRAÇÃO ({message_count} mensagens, {since_days} dias) ===
+
+{full_prompt}
+
+---
+INSTRUÇÃO: Copie este prompt e use a ferramenta cerebro_capture_memory com:
+{{"prompt": "<cole o prompt acima>"}}
+
+Ou execute manualmente: ocerebro dream --since {since_days} --apply
+"""
+
+    def _capture_memory(self, args: Dict[str, Any]) -> str:
+        """Captura memórias usando o prompt fornecido.
+
+        Esta ferramenta deve ser chamada após cerebro_dream retornar o prompt.
+        """
+        prompt = args.get("prompt")
+        if not prompt:
+            return "Erro: 'prompt' é obrigatório para cerebro_capture_memory"
+
+        memory_dir_str = args.get("memory_dir")
+        memory_dir = Path(memory_dir_str) if memory_dir_str else get_auto_mem_path()
+
+        # Instrui o Claude a usar o prompt para extrair memórias
+        return f"""Prompt de extração recebido.
+
+Diretório de memória: {memory_dir}
+
+O Claude deve agora analisar a conversa usando este prompt e salvar as memórias
+nos arquivos .md apropriados em {memory_dir}
+
+Formato esperado:
+- user_*.md para memórias sobre o usuário
+- feedback_*.md para feedbacks e convenções
+- project_*.md para decisões e fatos do projeto
+- reference_*.md para ponteiros externos
+
+Use FileWrite para criar os arquivos de memória.
+"""
 
     def _remember(self, args: Dict[str, Any]) -> str:
         """Revisão e promoção de memórias"""