ocerebro 0.4.6 → 0.4.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ocerebro",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "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.6"
+version = "0.4.8"
 description = "OCerebro - Sistema de Memoria para Agentes (Claude Code/MCP)"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -34,16 +34,22 @@ dependencies = [
     "pyyaml>=6.0",
     "pydantic>=2.0",
     "sqlite-vec>=0.1.0",
-    "sentence-transformers>=2.2.0",
     "mcp>=1.0.0",
     "anthropic>=0.40.0",
-    "spacy>=3.5.0",
     "fastapi>=0.109.0",
     "uvicorn>=0.27.0",
 ]
 
 [project.optional-dependencies]
+semantic = [
+    "sentence-transformers>=2.2.0",
+    "spacy>=3.5.0",
+]
+full = [
+    "ocerebro[semantic]",
+]
 test = [
+    "ocerebro[semantic]",
     "pytest>=7.0",
     "pytest-cov>=4.0",
 ]
@@ -66,6 +72,9 @@ ocerebro-setup = "cerebro.cerebro_setup:main"
 where = ["."]
 include = ["src*", "cerebro*"]
 
+[tool.setuptools.package-data]
+"src.dashboard" = ["static/*", "static/**/*"]
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = "test_*.py"

package/src/cli/main.py

@@ -109,18 +109,31 @@ class CerebroCLI:
         limit: int = 10,
         use_semantic: bool = True
     ) -> str:
+        # Verifica disponibilidade da busca semântica
+        semantic_available = self.query_engine.is_semantic_available()
+
+        if use_semantic and not semantic_available:
+            # Fallback para FTS + Graph apenas
+            lines = [
+                "⚠️  Busca semântica não disponível (sentence-transformers não instalado).",
+                "   Instalando com: npx ocerebro full",
+                ""
+            ]
+        else:
+            lines = []
+
         results = self.query_engine.search(
             query=query,
             project=project,
             mem_type=mem_type,
             limit=limit,
-            use_semantic=use_semantic
+            use_semantic=use_semantic and semantic_available
         )
 
         if not results:
             return "Nenhum resultado encontrado."
 
-        lines = [f"Resultados para '{query}':\n"]
+        lines.append(f"Resultados para '{query}':\n")
         for i, r in enumerate(results, 1):
             lines.append(f"{i}. [{r.type}] {r.title}")
             lines.append(f"   Projeto: {r.project} | Score: {r.score:.3f} | Fonte: {r.source}")
@@ -271,29 +284,108 @@ def _run_init(project_path: Optional[Path] = None):
     print("Como quer usar o OCerebro?")
     print("  1. Neste projeto (cria .ocerebro/ aqui)")
     print("  2. Global (usa ~/.ocerebro/ para todos os projetos)")
-    choice = input("\nEscolha [1/2] (padrão: 1): ").strip() or "1"
+    choice = input("\nEscolha [1/2] (padrao: 1): ").strip() or "1"
 
     if choice == "2":
         base_path = Path.home() / ".ocerebro"
-        print(f"\n✓ Modo global: {base_path}")
+        print(f"\n[OK] Modo global: {base_path}")
     else:
         base_path = (project_path or Path.cwd()) / ".ocerebro"
-        print(f"\n✓ Modo projeto: {base_path}")
+        print(f"\n[OK] Modo projeto: {base_path}")
 
     config_file = Path.home() / ".ocerebro_config"
     config_file.parent.mkdir(parents=True, exist_ok=True)
     config_file.write_text(f"base_path={base_path}\n", encoding="utf-8")
-    print(f"✓ Configuração salva em {config_file}")
+    print(f"[OK] Configuracao salva em {config_file}")
 
     setup_ocerebro_dir(base_path)
     setup_hooks(base_path)
     setup_slash_commands(project_path or Path.cwd())
 
+    # Pergunta sobre busca semantica
+    print("\n" + "="*60)
+    print("BUSCA SEMANTICA (opcional)")
+    print("="*60)
+    print("O OCerebro oferece dois modos de busca:")
+    print("  1. FTS + Graph (padrao) - Leve, rapido, sem dependencias extras")
+    print("     - Full-text search (FTS) no conteudo")
+    print("     - Busca por grafo de entidades")
+    print("     - ~100MB de footprint")
+    print("")
+    print("  2. FTS + Graph + Semantica (recomendado para producao)")
+    print("     - Tudo acima + busca por significado")
+    print("     - Encontra 'banco travando' mesmo sem palavra 'deadlock'")
+    print("     - ~500MB adicionais de dependencias")
+    print("")
+    semantic_choice = input("Instalar busca semantica agora? [y/N] (padrao: N): ").strip().lower()
+
+    if semantic_choice == "y":
+        _install_semantic_deps()
+    else:
+        print("\n[OK] Semantica nao instalada. Use FTS + Graph apenas.")
+        print("  Para instalar depois: npx ocerebro full")
+
     # Auto-configura Claude
     print()
     setup_claude(auto=True)
 
 
+def _install_semantic_deps():
+    """Instala dependências de busca semântica (sentence-transformers + spacy)"""
+    import subprocess
+
+    print("\n📦 Instalando dependências de busca semântica...")
+    print("   Isso pode levar alguns minutos (~500MB de downloads)")
+    print("")
+
+    pkgs = [
+        "sentence-transformers>=2.2.0",
+        "spacy>=3.5.0"
+    ]
+
+    # Usa o mesmo Python do ambiente atual
+    python = sys.executable
+
+    try:
+        for pkg in pkgs:
+            print(f"   Instalando {pkg}...")
+            subprocess.check_call([
+                python, "-m", "pip", "install", pkg, "-q"
+            ])
+            print(f"   ✓ {pkg} instalado")
+
+        # Pergunta qual modelo de linguagem baixar
+        print("\n   Qual modelo de linguagem deseja instalar?")
+        print("   1. português (pt_core_news_sm) ~50MB")
+        print("   2. inglês (en_core_web_sm) ~15MB")
+        print("   3. ambos")
+        lang_choice = input("\n   Escolha [1/2/3] (padrão: 1): ").strip() or "1"
+
+        if lang_choice in ["1", "3"]:
+            print("   Baixando modelo português (pt_core_news_sm)...")
+            subprocess.check_call([
+                python, "-m", "spacy", "download", "pt_core_news_sm", "-q"
+            ])
+            print("   ✓ pt_core_news_sm baixado")
+
+        if lang_choice in ["2", "3"]:
+            print("   Baixando modelo inglês (en_core_web_sm)...")
+            subprocess.check_call([
+                python, "-m", "spacy", "download", "en_core_web_sm", "-q"
+            ])
+            print("   ✓ en_core_web_sm baixado")
+
+        print("\n✅ Dependências instaladas com sucesso!")
+        print("   A busca semântica agora está disponível.")
+        print("\n   Para usar: npx ocerebro search \"sua query\"")
+
+    except subprocess.CalledProcessError as e:
+        print(f"\n❌ Erro ao instalar dependências: {e}")
+        print("   Tente manualmente: pip install sentence-transformers spacy")
+        print("   E depois: python -m spacy download pt_core_news_sm")
+        sys.exit(1)
+
+
 def main():
     """Entry point da CLI"""
     parser = argparse.ArgumentParser(
@@ -374,6 +466,9 @@ def main():
     gc_parser.add_argument("--threshold", type=int, default=7, dest="threshold_days")
     gc_parser.add_argument("--apply", action="store_true", dest="apply")
 
+    # Comando: full (instala dependências semânticas)
+    subparsers.add_parser("full", help="Instalar dependências de busca semântica")
+
     args = parser.parse_args()
 
     if not args.command:
@@ -441,6 +536,9 @@ def main():
         result = cli.remember(dry_run=not args.apply)
     elif args.command == "gc":
         result = cli.gc_cmd(threshold_days=args.threshold_days, dry_run=not args.apply)
+    elif args.command == "full":
+        _install_semantic_deps()
+        sys.exit(0)
     else:
         parser.print_help()
         sys.exit(1)

package/src/consolidation/promoter.py

@@ -8,6 +8,7 @@ from dataclasses import dataclass
 from src.working.yaml_storage import YAMLStorage
 from src.official.markdown_storage import MarkdownStorage
 from src.official.templates import ErrorTemplate, DecisionTemplate
+from src.consolidation.scorer import Scorer, ScoringConfig
 
 
 @dataclass
@@ -53,6 +54,9 @@ class Promoter:
         self.entities_db_path = entities_db_path
         self._entities_db = None
 
+        # Inicializa scorer RFM
+        self.scorer = Scorer(ScoringConfig())
+
     def promote_session(
         self,
         project: str,
@@ -178,6 +182,23 @@ class Promoter:
             frontmatter["events_from"] = draft["events_range"].get("from")
             frontmatter["events_to"] = draft["events_range"].get("to")
 
+        # Calcula scores RFM
+        scores = self.scorer.calculate_all_scores({
+            "type": "decision",
+            "last_accessed": datetime.now(timezone.utc),
+            "access_count": 0,
+            "status": "approved",
+            "severity": None,
+            "related_to": frontmatter.get("related_to", [])
+        })
+
+        # Adiciona scores ao frontmatter
+        frontmatter["importance_score"] = scores["importance_score"]
+        frontmatter["recency_score"] = scores["recency_score"]
+        frontmatter["frequency_score"] = scores["frequency_score"]
+        frontmatter["links_score"] = scores["links_score"]
+        frontmatter["total_score"] = scores["total_score"]
+
         # Gera corpo
         body_sections = [
             "## Resumo",
@@ -286,6 +307,22 @@ class Promoter:
             tags=["auto-promoted"]
         )
 
+        # Calcula scores RFM
+        scores = self.scorer.calculate_all_scores({
+            "type": "error",
+            "last_accessed": datetime.now(timezone.utc),
+            "access_count": 0,
+            "severity": error.get("severity", "high"),
+            "related_to": frontmatter.get("related_to", [])
+        })
+
+        # Adiciona scores ao frontmatter
+        frontmatter["importance_score"] = scores["importance_score"]
+        frontmatter["recency_score"] = scores["recency_score"]
+        frontmatter["frequency_score"] = scores["frequency_score"]
+        frontmatter["links_score"] = scores["links_score"]
+        frontmatter["total_score"] = scores["total_score"]
+
         # Gera corpo
         error_original = str(error.get("context", {}))[:500]
 

package/src/dashboard/server.py

@@ -5,6 +5,7 @@ import threading
 import webbrowser
 from pathlib import Path
 from typing import Any, Optional
+import importlib.resources
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
@@ -44,6 +45,16 @@ class DashboardServer:
         self.embeddings_db = embeddings_db
         self.entities_db = entities_db
 
+        # Usa importlib.resources para encontrar static files corretamente
+        # Funciona tanto em desenvolvimento quanto em pacote instalado
+        try:
+            # Python 3.9+
+            static_path = importlib.resources.files("src.dashboard") / "static"
+            self._static_path = Path(str(static_path))
+        except AttributeError:
+            # Fallback para Python < 3.9
+            self._static_path = Path(__file__).parent / "static"
+
         self.app = self._create_app()
         self._server_thread: Optional[threading.Thread] = None
         self._port: Optional[int] = None
@@ -66,9 +77,8 @@ class DashboardServer:
         )
 
         # Monta static files
-        static_path = Path(__file__).parent / "static"
-        if static_path.exists():
-            app.mount("/static", StaticFiles(directory=str(static_path)), name="static")
+        if self._static_path.exists():
+            app.mount("/static", StaticFiles(directory=str(self._static_path)), name="static")
 
         # Monta API router
         from src.dashboard.api import create_router
@@ -84,10 +94,10 @@ class DashboardServer:
         @app.get("/")
         async def root():
             from fastapi.responses import FileResponse
-            index_path = static_path / "index.html"
+            index_path = self._static_path / "index.html"
             if index_path.exists():
                 return FileResponse(str(index_path))
-            return {"error": "index.html not found"}
+            return {"error": "index.html not found", "path": str(index_path)}
 
         return app
 

package/src/forgetting/gc.py

@@ -22,14 +22,16 @@ class GarbageCollector:
     baseado em policies de forgetting.
     """
 
-    def __init__(self, config_path: Path):
+    def __init__(self, config_path: Path, metadata_db: Optional[Any] = None):
         """
         Inicializa o GarbageCollector.
 
         Args:
             config_path: Path para configuração
+            metadata_db: Instância opcional do MetadataDB para consultar scores
         """
         self.config_path = config_path
+        self.metadata_db = metadata_db
 
     def find_candidates_for_archive(
         self,
@@ -72,6 +74,14 @@ class GarbageCollector:
                     if mem_type in ['user', 'feedback']:
                         continue
 
+                    # Tarefa 2: Verifica total_score se metadata_db estiver disponível
+                    if self.metadata_db:
+                        mem_id = frontmatter.get("name", file_path.stem)
+                        memory_data = self.metadata_db.get_by_id(mem_id)
+                        if memory_data and memory_data.get("total_score", 0) >= 0.5:
+                            # Memória com alto score não é candidata
+                            continue
+
                     candidates.append({
                         "file_path": str(file_path),
                         "filename": file_path.name,

package/src/index/embeddings_db.py

@@ -32,6 +32,7 @@ class EmbeddingsDB:
         self.db_path = db_path
         self.model_name = model_name
         self._model = None
+        self._semantic_available = False
         # Cria diretório pai se não existir
         db_path.parent.mkdir(parents=True, exist_ok=True)
         self._init_sqlite_vec()
@@ -44,11 +45,10 @@ class EmbeddingsDB:
             try:
                 from sentence_transformers import SentenceTransformer
                 self._model = SentenceTransformer(self.model_name)
+                self._semantic_available = True
             except ImportError:
-                raise ImportError(
-                    "sentence-transformers não instalado. "
-                    "Instale com: pip install sentence-transformers"
-                )
+                self._semantic_available = False
+                return None
         return self._model
 
     def _init_sqlite_vec(self):
@@ -116,6 +116,8 @@ class EmbeddingsDB:
         Returns:
             Lista de floats (vetor de embedding)
         """
+        if self.model is None:
+            return []
         embedding = self.model.encode(text, convert_to_numpy=True)
         return embedding.tolist()
 
@@ -271,6 +273,10 @@ class EmbeddingsDB:
         Returns:
             Lista de memórias similares com score
         """
+        # Retorna vazio se busca semântica não estiver disponível
+        if not self._semantic_available:
+            return []
+
         # Computa embedding da query
         query_embedding = self._compute_embedding(query)
 
@@ -419,3 +425,12 @@ class EmbeddingsDB:
             "model_name": self.model_name,
             "sqlite_vec_available": self._sqlite_vec_available
         }
+
+    def is_semantic_available(self) -> bool:
+        """
+        Verifica se busca semântica está disponível.
+
+        Returns:
+            True se sentence-transformers está instalado, False caso contrário
+        """
+        return self._semantic_available

package/src/index/queries.py

@@ -204,7 +204,11 @@ class QueryEngine:
         Returns:
             Lista de resultados
         """
-        similar = self.embeddings_db.search_similar(query, project, limit * 2)
+        try:
+            similar = self.embeddings_db.search_similar(query, project, limit * 2)
+        except (ImportError, Exception):
+            # Busca semântica não disponível ou falhou
+            return []
 
         results = []
         for item in similar:
@@ -425,3 +429,12 @@ class QueryEngine:
         )
 
         return sorted_related[:limit]
+
+    def is_semantic_available(self) -> bool:
+        """
+        Verifica se busca semântica está disponível.
+
+        Returns:
+            True se sentence-transformers está instalado e operacional, False caso contrário
+        """
+        return self.embeddings_db.is_semantic_available()