ocerebro 0.4.3 → 0.4.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ocerebro",
-  "version": "0.4.3",
+  "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.3"
+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

@@ -0,0 +1,47 @@
+"""Servidor standalone do Dashboard do OCerebro - roda como processo separado"""
+
+import os
+import sys
+from pathlib import Path
+
+# Adiciona project root ao path
+project_root = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from src.dashboard.server import DashboardServer
+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 com o path correto
+    mcp = CerebroMCP(cerebro_path=cerebro_path)
+
+    dashboard = DashboardServer(
+        cerebro_path=mcp.cerebro_path,
+        metadata_db=mcp.metadata_db,
+        embeddings_db=mcp.embeddings_db,
+        entities_db=mcp.entities_db
+    )
+
+    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:
+            time.sleep(3600)  # Dorme por 1 hora, loop infinito
+    else:
+        print(f"Falha ao iniciar dashboard na porta {port}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

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:
@@ -898,26 +914,77 @@ Uma chamada por memória. O sistema salva e indexa automaticamente.
     def _cerebro_dashboard(self, args: Dict[str, Any]) -> str:
         """Abre o dashboard visual do OCerebro no browser"""
         try:
-            from src.dashboard.server import DashboardServer
+            import subprocess
+            import sys
+            import requests
 
             port = args.get("port", 7999)
 
-            # Instancia servidor
-            dashboard_server = DashboardServer(
-                cerebro_path=self.cerebro_path,
-                metadata_db=self.metadata_db,
-                embeddings_db=self.embeddings_db,
-                entities_db=self.entities_db
-            )
+            # Verifica se já está rodando
+            import socket
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(1)
+            result = sock.connect_ex(('127.0.0.1', port))
+            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"
+                if not server_script.exists():
+                    return "⚠️ Erro: standalone_server.py não encontrado."
+
+                # Inicia processo em background
+                subprocess.Popen(
+                    [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
+                )
 
-            # Inicia se não estiver rodando
-            if not dashboard_server.is_running(port):
-                started = dashboard_server.start(port)
-                if not started:
-                    return "⚠️ Não foi possível iniciar o servidor do dashboard. Verifique se a porta está disponível."
+                # Aguarda servidor estar pronto (até 5s)
+                import time
+                for _ in range(50):
+                    time.sleep(0.1)
+                    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                    sock.settimeout(1)
+                    result = sock.connect_ex(('127.0.0.1', port))
+                    sock.close()
+                    if result == 0:
+                        break
+                else:
+                    return "⚠️ Servidor não iniciou em 5 segundos."
 
             # Abre browser
-            dashboard_server.open_browser(port)
+            import webbrowser
+            webbrowser.open(f"http://localhost:{port}")
 
             return f"✅ Dashboard aberto em http://localhost:{port}"
         except ImportError as e: