ocerebro 0.2.0 → 0.2.2

package/package.json

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

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,24 @@ 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="Salva uma memória diretamente em ~/.claude/memory/ (formato nativo Claude Code). Chame uma vez por memória com o conteúdo Markdown completo.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "memory_content": {
+                            "type": "string",
+                            "description": "Conteúdo Markdown completo com frontmatter obrigatório: name, description, type (user|feedback|project|reference)"
+                        }
+                    },
+                    "required": ["memory_content"]
+                }
+            ),
             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 +375,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 +609,91 @@ 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 CRÍTICA: Analise esta conversa usando o prompt acima.
+Para CADA memória identificada, chame cerebro_capture_memory UMA vez:
+
+    cerebro_capture_memory(memory_content="---\\nname: <nome>\\ndescription: <descrição>\\ntype: <user|feedback|project|reference>\\n---\\n\\n<conteúdo>")
+
+NÃO use FileWrite. NÃO use FileEdit. APENAS cerebro_capture_memory.
+Uma chamada por memória. O sistema salva e indexa automaticamente.
+"""
+
+    def _capture_memory(self, args: Dict[str, Any]) -> str:
+        """Salva uma memória no diretório nativo do Claude Code."""
+        import re
+        from datetime import datetime
+        from src.core.paths import get_memory_index
+
+        content = args.get("memory_content", "")
+        if not content:
+            return "Erro: 'memory_content' é obrigatório"
+
+        name_match = re.search(r'name:\s*(.*)', content)
+        if not name_match:
+            return "Erro: frontmatter 'name' é obrigatório no memory_content"
+
+        mem_name = name_match.group(1).strip().lower().replace(' ', '-')
+        mem_dir = get_auto_mem_path()
+        mem_dir.mkdir(parents=True, exist_ok=True)
+
+        file_path = mem_dir / f"{mem_name}.md"
+        file_path.write_text(content, encoding="utf-8")
+
+        desc_match = re.search(r'description:\s*(.*)', content)
+        type_match = re.search(r'type:\s*(.*)', content)
+        desc = desc_match.group(1).strip() if desc_match else "sem descrição"
+        m_type = type_match.group(1).strip() if type_match else "project"
+        ts = datetime.now().strftime("%Y-%m-%d")
+        entry = f"- [{m_type}] {mem_name}.md ({ts}): {desc}\n"
+
+        index_path = get_memory_index(mem_dir)
+        if index_path.exists():
+            existing = index_path.read_text(encoding="utf-8")
+            if mem_name not in existing:
+                with open(index_path, "a", encoding="utf-8") as f:
+                    f.write(entry)
+        else:
+            index_path.write_text(f"# Memórias do Projeto\n\n{entry}", encoding="utf-8")
+
+        return f"✅ Memória '{mem_name}' salva em {file_path}"
 
     def _remember(self, args: Dict[str, Any]) -> str:
         """Revisão e promoção de memórias"""