ocerebro 0.4.16 → 0.4.17

package/package.json

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

package/src/cli/main.py

@@ -333,6 +333,20 @@ def _run_init(project_path: Optional[Path] = None):
     print()
     setup_claude(auto=True)
 
+    # FIX 1: Verifica e confirma que hook Stop foi registrado
+    print("\n" + "=" * 60)
+    print("HOOK AUTOMÁTICO DE FIM DE SESSÃO")
+    print("=" * 60)
+    print("\nO OCerebro registrou um hook que executa automaticamente")
+    print("o comando 'ocerebro dream' toda vez que você encerra uma sessão.")
+    print("\nIsso garante que:")
+    print("  ✅ Suas memórias são extraídas automaticamente")
+    print("  ✅ Zero esforço — use o Claude Code normalmente")
+    print("  ✅ Próxima sessão já tem todo o contexto")
+    print("\nHook registrado em ~/.claude/settings.json:")
+    print('  hooks.Stop → "ocerebro dream --since 1 --apply"')
+    print("\nPara desativar: edite settings.json e remova o hook 'Stop'")
+
 
 def _install_semantic_deps():
     """Instala dependências de busca semântica (sentence-transformers + spacy)"""

package/src/core/paths.py

@@ -23,7 +23,7 @@ def sanitize_path(absolute_path: str) -> str:
 
     Exemplo:
         /home/user/projects/ocerebro → -home-user-projects-ocerebro
-        C:\\Users\\dev\\my-project → C--Users-dev-my-project
+        C:\\Users\\dev\\my-project → -c--users-dev-my-project
 
     Args:
         absolute_path: Path absoluto para sanitizar
@@ -31,26 +31,27 @@ def sanitize_path(absolute_path: str) -> str:
     Returns:
         String sanitizada para uso como nome de diretório
     """
+    import re
+
     # Normaliza separadores Windows para Unix
     normalized = absolute_path.replace("\\", "/")
 
-    # Substitui separadores de path por '-'
-    sanitized = re.sub(r'[/\\]', '-', normalized)
+    # Normaliza drive letter para lowercase (E:/ → e:/)
+    if len(normalized) >= 2 and normalized[1] == ":":
+        normalized = normalized[0].lower() + normalized[1:]
+
+    # Substitui / e : por -
+    sanitized = re.sub(r'[/\\:]', '-', normalized)
 
-    # Remove caracteres especiais (mantém apenas alfanuméricos, '-', '_')
+    # Remove caracteres especiais
     sanitized = re.sub(r'[^a-zA-Z0-9_-]', '', sanitized)
 
     # Remove múltiplos '-' consecutivos
     sanitized = re.sub(r'-+', '-', sanitized)
 
-    # Garante que começa com '-' se o path original era absoluto
-    if absolute_path.startswith('/') or absolute_path.startswith('\\'):
-        if not sanitized.startswith('-'):
-            sanitized = '-' + sanitized
-    elif len(absolute_path) >= 2 and absolute_path[1] == ':':
-        # Windows path (ex: C:\)
-        if not sanitized.startswith('-'):
-            sanitized = '-' + sanitized
+    # Garante início com -
+    if not sanitized.startswith('-'):
+        sanitized = '-' + sanitized
 
     return sanitized
 

package/src/mcp/server.py

@@ -439,12 +439,38 @@ class CerebroMCP:
             return [TextContent(type="text", text=f"Erro: {str(e)}")]
 
     def _memory(self, args: Dict[str, Any]) -> str:
-        """Gera memória ativa"""
+        """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"
 
-        return self.memory_view.generate(project)
+        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
+        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")
+        except Exception:
+            pass  # Falha silenciosa - não bloqueia o retorno
+
+        return content
 
     def _search(self, args: Dict[str, Any]) -> str:
         """Busca memórias"""
@@ -712,11 +738,11 @@ 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."""
+        """Salva uma memória no diretório nativo do Claude Code e no OCerebro (dual-write)."""
         import re
         import yaml
         from datetime import datetime
-        from src.core.paths import get_memory_index
+        from src.core.paths import get_memory_index, get_auto_mem_path
 
         content = args.get("memory_content", "")
         if not content:
@@ -727,11 +753,6 @@ Uma chamada por memória. O sistema salva e indexa automaticamente.
             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")
 
         # Parse frontmatter uma única vez com yaml.safe_load
         frontmatter_match = re.match(r'^---\n(.*?)\n---\n(.*)$', content, re.DOTALL)
@@ -767,18 +788,52 @@ Uma chamada por memória. O sistema salva e indexa automaticamente.
         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")
+        # =========================================================================
+        # DUAL-WRITE: Salva em ambos os diretórios
+        # =========================================================================
+
+        # 1. Diretório nativo do Claude Code (~/.claude/projects/<slug>/memory/)
+        #    → Claude Code carrega automaticamente na próxima sessão
+        claude_mem_dir = get_auto_mem_path()
+        claude_mem_dir.mkdir(parents=True, exist_ok=True)
+        claude_file_path = claude_mem_dir / f"{mem_name}.md"
+        claude_file_path.write_text(content, encoding="utf-8")
+
+        # Atualiza MEMORY.md nativo
+        claude_index_path = get_memory_index(claude_mem_dir)
+        if claude_index_path.exists():
+            existing = claude_index_path.read_text(encoding="utf-8")
             if mem_name not in existing:
-                with open(index_path, "a", encoding="utf-8") as f:
+                with open(claude_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")
+            claude_index_path.write_text(f"# Memórias do Projeto\n\n{entry}", encoding="utf-8")
+
+        # 2. Diretório OCerebro (.ocerebro/official/<subdir>/)
+        #    → OCerebro indexa e busca via cerebro_memory/cerebro_search
+        # Mapeamento: Claude Code type → OCerebro subdir
+        type_to_subdir = {
+            "user": "decisions",      # user → decisions (global)
+            "feedback": "preferences", # feedback → preferences
+            "project": "decisions",    # project → decisions
+            "reference": "state",      # reference → state
+        }
+        subdir = type_to_subdir.get(m_type, "decisions")  # default: decisions
+
+        # Para tipo "user", salva em global/; para outros, usa project do frontmatter
+        if m_type == "user":
+            cerebro_project = "global"
+        else:
+            cerebro_project = project if project != "unknown" else "default"
+
+        cerebro_dir = self.cerebro_path / "official" / cerebro_project / subdir
+        cerebro_dir.mkdir(parents=True, exist_ok=True)
+        cerebro_file_path = cerebro_dir / f"{mem_name}.md"
+        cerebro_file_path.write_text(content, encoding="utf-8")
 
+        # =========================================================================
         # Registrar entidades no grafo (frontmatter + conteúdo)
-        # ORDEM IMPORTANTE: content primeiro, frontmatter depois
-        # extract_from_content() deleta apenas entidades 'content', preservando 'frontmatter'
+        # =========================================================================
         if self.entities_db and frontmatter_match:
             try:
                 # 1. Extrai entidades do conteúdo (spaCy NER)
@@ -791,7 +846,7 @@ Uma chamada por memória. O sistema salva e indexa automaticamente.
                 self.entities_db.extract_from_frontmatter(
                     memory_id=mem_name,
                     frontmatter=frontmatter,
-                    project=project
+                    project=cerebro_project
                 )
             except Exception:
                 pass  # Falha silenciosa se frontmatter inválido
@@ -802,17 +857,17 @@ Uma chamada por memória. O sistema salva e indexa automaticamente.
             self.metadata_db.insert({
                 "id": mem_name,
                 "type": m_type,
-                "project": project,
+                "project": cerebro_project,
                 "title": frontmatter.get("title", mem_name) if frontmatter else mem_name,
                 "content": body_content,
                 "tags": tags_str,
                 "created_at": datetime.now().isoformat(),
                 "updated_at": datetime.now().isoformat(),
                 "layer": "auto",
-                "path": str(file_path),
+                "path": str(cerebro_file_path),
             })
 
-        return f"✅ Memória '{mem_name}' salva em {file_path}"
+        return f"✅ Memória '{mem_name}' salva (dual-write: Claude + OCerebro)"
 
     def _remember(self, args: Dict[str, Any]) -> str:
         """Revisão e promoção de memórias"""

package/src/working/memory_view.py

@@ -136,7 +136,7 @@ class MemoryView:
 
     def write_to_file(self, project: str) -> Path:
         """
-        Gera e escreve MEMORY.md no arquivo.
+        Gera e escreve MEMORY.md no arquivo (dual-write: OCerebro + Claude Code nativo).
 
         Args:
             project: Nome do projeto
@@ -145,6 +145,30 @@ class MemoryView:
             Path do arquivo MEMORY.md criado
         """
         content = self.generate(project)
+
+        # 1. Escreve em .ocerebro/MEMORY.md
         memory_file = self.cerebro_path / "MEMORY.md"
         memory_file.write_text(content, encoding="utf-8")
+
+        # 2. Escreve em ~/.claude/projects/<slug>/memory/MEMORY.md (Claude Code nativo)
+        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 formato Claude Code
+            claude_format_lines = ["# OCerebro - Memória Ativa", ""]
+            claude_format_lines.append(f"## {project}")
+            claude_format_lines.append("")
+
+            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")
+        except Exception:
+            pass  # Falha silenciosa
+
         return memory_file