ocerebro 0.4.4 → 0.4.5

package/package.json

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

package/src/dashboard/api.py

@@ -6,6 +6,7 @@ from typing import Any, Dict, List, Optional
 import sqlite3
 import json
 from datetime import datetime
+from src.forgetting.gc import calculate_rfms_score
 
 
 def create_router(
@@ -24,6 +25,11 @@ def create_router(
     router.entities_db = entities_db
     router.cerebro_path = cerebro_path
 
+    @router.get("/ping")
+    async def get_ping():
+        """Retorna o cerebro_path atual do servidor"""
+        return {"cerebro_path": str(router.cerebro_path)}
+
     @router.get("/status")
     async def get_status():
         """Retorna status geral do sistema"""
@@ -242,7 +248,6 @@ def create_router(
             memories = []
             for row in rows:
                 # Calcula GC risk
-                from src.forgetting.gc import calculate_rfms_score
                 memory_dict = dict(row)
                 gc_risk = 1.0 - calculate_rfms_score(memory_dict)
 

package/src/dashboard/standalone_server.py

@@ -1,5 +1,6 @@
 """Servidor standalone do Dashboard do OCerebro - roda como processo separado"""
 
+import os
 import sys
 from pathlib import Path
 
@@ -13,9 +14,10 @@ from src.mcp.server import CerebroMCP
 def main():
     """Inicia o servidor standalone"""
     port = int(sys.argv[1]) if len(sys.argv) > 1 else 7999
+    cerebro_path = Path(sys.argv[2]) if len(sys.argv) > 2 else None
 
-    # Inicializa componentes
-    mcp = CerebroMCP()
+    # Inicializa componentes com o path correto
+    mcp = CerebroMCP(cerebro_path=cerebro_path)
 
     dashboard = DashboardServer(
         cerebro_path=mcp.cerebro_path,
@@ -25,7 +27,14 @@ def main():
     )
 
     if dashboard.start(port):
+        # Salva PID para poder ser morto quando precisar trocar de contexto
+        pid_file = Path.home() / ".ocerebro_dashboard.pid"
+        pid_file.write_text(str(os.getpid()), encoding="utf-8")
+
         print(f"Dashboard rodando em http://localhost:{port}")
+        print(f"Cerebro path: {mcp.cerebro_path}")
+        print(f"PID: {os.getpid()}")
+
         # Mantém vivo
         import time
         while True:

package/src/mcp/server.py

@@ -791,6 +791,22 @@ Uma chamada por memória. O sistema salva e indexa automaticamente.
             except Exception:
                 pass  # Falha silenciosa se frontmatter inválido
 
+        # Indexar no metadata_db para aparecer no dashboard
+        if self.metadata_db:
+            tags_str = tags if isinstance(tags, str) else ",".join(tags) if isinstance(tags, list) else ""
+            self.metadata_db.insert({
+                "id": mem_name,
+                "type": m_type,
+                "project": 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),
+            })
+
         return f"✅ Memória '{mem_name}' salva em {file_path}"
 
     def _remember(self, args: Dict[str, Any]) -> str:
@@ -900,6 +916,7 @@ Uma chamada por memória. O sistema salva e indexa automaticamente.
         try:
             import subprocess
             import sys
+            import requests
 
             port = args.get("port", 7999)
 
@@ -911,6 +928,33 @@ Uma chamada por memória. O sistema salva e indexa automaticamente.
             sock.close()
             is_running = result == 0
 
+            if is_running:
+                # Verifica se o servidor está usando o cerebro_path correto
+                try:
+                    resp = requests.get(f"http://127.0.0.1:{port}/api/ping", timeout=2)
+                    if resp.status_code == 200:
+                        data = resp.json()
+                        running_path = data.get("cerebro_path", "")
+                        current_path = str(self.cerebro_path.absolute())
+
+                        if running_path != current_path:
+                            # Path diferente - precisa reiniciar o servidor
+                            # Lê o PID e mata o processo antigo
+                            pid_file = Path.home() / ".ocerebro_dashboard.pid"
+                            if pid_file.exists():
+                                try:
+                                    old_pid = int(pid_file.read_text(encoding="utf-8").strip())
+                                    import os
+                                    os.kill(old_pid, 9)  # SIGKILL
+                                    pid_file.unlink()  # Remove o arquivo PID
+                                except Exception:
+                                    pass  # Processo já morreu ou erro ao matar
+
+                            # Agora is_running será False e vamos reiniciar abaixo
+                            is_running = False
+                except Exception:
+                    pass  # Se falhar o ping, tenta reiniciar mesmo assim
+
             if not is_running:
                 # Inicia como processo separado (persiste após o MCP terminar)
                 server_script = Path(__file__).parent.parent / "dashboard" / "standalone_server.py"
@@ -919,8 +963,7 @@ Uma chamada por memória. O sistema salva e indexa automaticamente.
 
                 # Inicia processo em background
                 subprocess.Popen(
-                    [sys.executable, str(server_script), str(port)],
-                    cwd=str(Path(__file__).parent.parent.parent),
+                    [sys.executable, str(server_script), str(port), str(self.cerebro_path.absolute())],
                     stdout=subprocess.DEVNULL,
                     stderr=subprocess.DEVNULL,
                     start_new_session=True  # Desacoplado do processo pai