Delete scripts

scripts/fusion_brain.py

@@ -1,360 +0,0 @@
-import asyncio
-import hashlib
-import json
-import logging
-import os
-import sys
-import time
-from datetime import datetime
-from typing import Any
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
-
-from dotenv import load_dotenv
-load_dotenv(os.path.join(os.path.dirname(__file__), "..", "backend", ".env"))
-load_dotenv(os.path.join(os.path.dirname(__file__), "..", ".env"))
-
-from backend.services.greenfield import greenfield_client
-from backend.services.groq_client import groq_wrapper
-from config.system_prompts import get_evolution_system
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
-)
-logger = logging.getLogger("synergix.fusion_brain")
-
-# ── Rutas de salida ───────────────────────────────────────────────────────────
-BRAIN_DIR = os.path.join(os.path.dirname(__file__), "..", "SYNERGIXAI")
-BRAIN_FILE = os.path.join(BRAIN_DIR, "Synergix_ia.txt")
-BRAIN_JSON = os.path.join(BRAIN_DIR, "Synergix_ia.json")
-FAISS_INDEX_FILE = os.path.join(BRAIN_DIR, "synergix_index.faiss")
-BACKUP_DIR = os.path.join(os.path.dirname(__file__), "..", "backups")
-DATA_DIR = os.path.join(os.path.dirname(__file__), "..", "data")
-HOT_CACHE_FILE = os.path.join(DATA_DIR, "hot_cache.json")
-
-os.makedirs(BRAIN_DIR, exist_ok=True)
-os.makedirs(BACKUP_DIR, exist_ok=True)
-os.makedirs(DATA_DIR, exist_ok=True)
-
-
-# ── Backup del cerebro actual ─────────────────────────────────────────────────
-
-def backup_brain() -> str:
-    """Crea backup del cerebro actual con hash de integridad."""
-    if not os.path.exists(BRAIN_FILE):
-        return ""
-
-    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
-    backup_path = os.path.join(BACKUP_DIR, f"snapshot_{ts}.bak")
-
-    with open(BRAIN_FILE, "r", encoding="utf-8") as f:
-        content = f.read()
-
-    integrity_hash = hashlib.sha256(content.encode()).hexdigest()
-
-    with open(backup_path, "w", encoding="utf-8") as f:
-        f.write(content)
-
-    # Guardar metadatos del backup
-    meta_path = backup_path + ".meta.json"
-    with open(meta_path, "w", encoding="utf-8") as f:
-        json.dump({
-            "timestamp": ts,
-            "integrity_hash": integrity_hash,
-            "size": len(content),
-            "source": BRAIN_FILE,
-        }, f, indent=2)
-
-    logger.info("💾 Backup creado: %s (hash: %s...)", backup_path, integrity_hash[:16])
-    return backup_path
-
-
-def restore_latest_backup() -> bool:
-    """Restaura el último backup si el cerebro está corrupto."""
-    backups = sorted([
-        f for f in os.listdir(BACKUP_DIR)
-        if f.startswith("snapshot_") and f.endswith(".bak")
-    ], reverse=True)
-
-    if not backups:
-        logger.error("❌ No hay backups disponibles para restaurar")
-        return False
-
-    latest = os.path.join(BACKUP_DIR, backups[0])
-    meta_path = latest + ".meta.json"
-
-    with open(latest, "r", encoding="utf-8") as f:
-        content = f.read()
-
-    # Verificar integridad
-    if os.path.exists(meta_path):
-        with open(meta_path, "r", encoding="utf-8") as f:
-            meta = json.load(f)
-        current_hash = hashlib.sha256(content.encode()).hexdigest()
-        if current_hash != meta.get("integrity_hash"):
-            logger.error("❌ Backup corrupto: hash no coincide")
-            return False
-
-    with open(BRAIN_FILE, "w", encoding="utf-8") as f:
-        f.write(content)
-
-    logger.info("✅ Cerebro restaurado desde: %s", latest)
-    return True
-
-
-# ── Descarga y procesamiento de aportes ──────────────────────────────────────
-
-async def fetch_all_aportes(max_items: int = 100) -> list[dict[str, Any]]:
-    """
-    Descarga aportes de alta calidad desde Greenfield.
-    Incluye contenido completo + metadatos.
-    """
-    logger.info("📥 Descargando aportes de Greenfield...")
-
-    metadata_list = await greenfield_client.get_aportes_metadata(
-        prefix="aportes/",
-        min_quality=5,
-        max_items=max_items,
-    )
-
-    logger.info("📊 %d aportes de calidad encontrados", len(metadata_list))
-
-    # Descargar contenido de los top aportes (máx 50 para no sobrecargar)
-    sem = asyncio.Semaphore(5)
-    aportes = []
-
-    async def download_one(meta: dict) -> dict | None:
-        async with sem:
-            obj_name = meta.get("object_name", "")
-            if not obj_name:
-                return None
-            try:
-                content = await greenfield_client.get_object(obj_name)
-                if content and len(content.strip()) > 10:
-                    return {
-                        "object_name": obj_name,
-                        "content": content,
-                        "summary": meta.get("summary", ""),
-                        "quality_score": meta.get("quality_score", 5),
-                        "knowledge_tag": meta.get("knowledge_tag", "general"),
-                        "user_id": meta.get("user_id", ""),
-                        "impact": meta.get("impact", 0),
-                    }
-            except Exception as exc:
-                logger.warning("⚠️ Error descargando %s: %s", obj_name, exc)
-            return None
-
-    tasks = [download_one(m) for m in metadata_list[:50]]
-    results = await asyncio.gather(*tasks)
-    aportes = [r for r in results if r is not None]
-
-    logger.info("✅ %d aportes descargados con contenido", len(aportes))
-    return aportes
-
-
-# ── Generación del cerebro fusionado ─────────────────────────────────────────
-
-async def generate_fused_brain(aportes: list[dict]) -> str:
-    """
-    Usa Groq para fusionar todos los aportes en un cerebro unificado.
-    """
-    if not aportes:
-        return "Synergix Collective Brain - Sin aportes aún."
-
-    # Construir contexto organizado por categoría
-    by_tag: dict[str, list[str]] = {}
-    for a in aportes:
-        tag = a.get("knowledge_tag", "general")
-        if tag not in by_tag:
-            by_tag[tag] = []
-        by_tag[tag].append(a.get("content", a.get("summary", "")))
-
-    sections = []
-    for tag, contents in by_tag.items():
-        section = f"[Categoría: {tag}]\n" + "\n---\n".join(c[:300] for c in contents[:5])
-        sections.append(section)
-
-    context = "\n\n".join(sections[:10])[:4000]  # Máx 4000 chars para el prompt
-
-    evolution_system = get_evolution_system()
-    logger.info("🧠 Generando cerebro fusionado con Groq...")
-
-    fused = await groq_wrapper.federated_evolve(context, evolution_system)
-    return fused
-
-
-# ── Actualización del índice FAISS ────────────────────────────────────────────
-
-def build_faiss_index(aportes: list[dict]) -> bool:
-    """
-    Construye índice FAISS con embeddings de los aportes.
-    Usa sentence-transformers si disponible, sino TF-IDF simple.
-    """
-    try:
-        import numpy as np
-
-        try:
-            # Intentar con sentence-transformers (calidad alta)
-            from sentence_transformers import SentenceTransformer
-            model = SentenceTransformer("all-MiniLM-L6-v2")
-            texts = [a.get("content", a.get("summary", ""))[:512] for a in aportes]
-            embeddings = model.encode(texts, show_progress_bar=False)
-            logger.info("✅ Embeddings con sentence-transformers shape=%s", embeddings.shape)
-        except ImportError:
-            # Fallback: TF-IDF vectorization simple
-            from sklearn.feature_extraction.text import TfidfVectorizer
-            texts = [a.get("content", a.get("summary", ""))[:512] for a in aportes]
-            vectorizer = TfidfVectorizer(max_features=256)
-            embeddings = vectorizer.fit_transform(texts).toarray().astype(np.float32)
-            logger.info("✅ Embeddings TF-IDF shape=%s", embeddings.shape)
-
-            # Guardar vectorizer para búsquedas futuras
-            import pickle
-            with open(os.path.join(BRAIN_DIR, "tfidf_vectorizer.pkl"), "wb") as f:
-                pickle.dump(vectorizer, f)
-
-        import faiss
-        dim = embeddings.shape[1]
-        index = faiss.IndexFlatL2(dim)
-        index.add(embeddings.astype(np.float32))
-        faiss.write_index(index, FAISS_INDEX_FILE)
-
-        # Guardar mapping índice → aporte
-        mapping = [{"idx": i, "object_name": a.get("object_name", ""), "summary": a.get("summary", "")}
-                   for i, a in enumerate(aportes)]
-        with open(os.path.join(BRAIN_DIR, "index_mapping.json"), "w", encoding="utf-8") as f:
-            json.dump(mapping, f, ensure_ascii=False, indent=2)
-
-        logger.info("✅ FAISS index construido: %d vectores dim=%d", index.ntotal, dim)
-        return True
-
-    except ImportError as exc:
-        logger.warning("⚠️ FAISS/sklearn no disponible, saltando índice vectorial: %s", exc)
-        return False
-    except Exception as exc:
-        logger.error("❌ Error construyendo FAISS: %s", exc)
-        return False
-
-
-# ── Actualizar hot_cache.json ─────────────────────────────────────────────────
-
-def update_hot_cache(aportes: list[dict], fused_brain: str) -> None:
-    """Actualiza el hot_cache.json con los aportes procesados."""
-    try:
-        cache_data = {
-            "last_update_ts": time.time(),
-            "last_update_iso": datetime.now().isoformat(),
-            "count": len(aportes),
-            "metadata_cache": {
-                a["object_name"]: {
-                    "object_name": a["object_name"],
-                    "summary": a.get("summary", ""),
-                    "quality_score": a.get("quality_score", 5),
-                    "knowledge_tag": a.get("knowledge_tag", "general"),
-                    "user_id": a.get("user_id", ""),
-                    "impact": a.get("impact", 0),
-                }
-                for a in aportes if a.get("object_name")
-            },
-            "wisdom_snippets": [
-                {
-                    "name": a.get("object_name", ""),
-                    "summary": a.get("summary", ""),
-                    "score": a.get("quality_score", 5),
-                }
-                for a in aportes[:20]
-            ],
-            "fused_wisdom_preview": fused_brain[:500],
-        }
-        with open(HOT_CACHE_FILE, "w", encoding="utf-8") as f:
-            json.dump(cache_data, f, ensure_ascii=False, indent=2)
-        logger.info("💾 hot_cache.json actualizado con %d aportes", len(aportes))
-    except Exception as exc:
-        logger.error("❌ Error actualizando hot_cache: %s", exc)
-
-
-# ── Main ───────────────────────────────────────────────────────────────────────
-
-async def run_fusion() -> None:
-    """Ejecuta el ciclo completo de fusión del cerebro."""
-    logger.info("🧠 === SYNERGIX FUSION BRAIN INICIADO ===")
-    start = time.time()
-
-    # 1. Backup del cerebro actual
-    backup_path = backup_brain()
-    if backup_path:
-        logger.info("💾 Backup previo: %s", backup_path)
-
-    # 2. Descargar aportes de Greenfield
-    try:
-        aportes = await fetch_all_aportes(max_items=100)
-    except Exception as exc:
-        logger.error("❌ Error descargando aportes: %s", exc)
-        aportes = []
-
-    if not aportes:
-        logger.warning("📭 Sin aportes para procesar. Fusión cancelada.")
-        return
-
-    # 3. Generar cerebro fusionado con Groq
-    try:
-        fused_brain = await generate_fused_brain(aportes)
-    except Exception as exc:
-        logger.error("❌ Error generando cerebro fusionado: %s", exc)
-        fused_brain = "\n".join(a.get("summary", "") for a in aportes[:20])
-
-    # 4. Guardar cerebro actualizado
-    brain_content = f"""=== SYNERGIX COLLECTIVE BRAIN ===
-Actualizado: {datetime.now().isoformat()}
-Aportes procesados: {len(aportes)}
-Vector count: {len(aportes)}
-
-=== CONOCIMIENTO FUSIONADO ===
-{fused_brain}
-
-=== INVENTARIO DE APORTES ===
-{chr(10).join(f"- [{a['knowledge_tag']}] {a['summary']}" for a in aportes[:50])}
-"""
-
-    with open(BRAIN_FILE, "w", encoding="utf-8") as f:
-        f.write(brain_content)
-
-    # 5. Guardar cerebro como JSON (para el bot)
-    brain_json_data = {
-        "last_sync": datetime.now().isoformat(),
-        "x-amz-meta-last-sync": datetime.now().isoformat(),
-        "x-amz-meta-vector-count": len(aportes),
-        "total_aportes": len(aportes),
-        "fused_wisdom": fused_brain,
-        "categories": list({a.get("knowledge_tag", "general") for a in aportes}),
-        "top_aportes": [
-            {
-                "object_name": a["object_name"],
-                "summary": a["summary"],
-                "quality_score": a["quality_score"],
-                "knowledge_tag": a["knowledge_tag"],
-            }
-            for a in sorted(aportes, key=lambda x: -x.get("quality_score", 0))[:20]
-        ],
-    }
-    with open(BRAIN_JSON, "w", encoding="utf-8") as f:
-        json.dump(brain_json_data, f, ensure_ascii=False, indent=2)
-
-    logger.info("✅ Synergix_ia.txt y .json actualizados (%d chars)", len(brain_content))
-
-    # 6. Construir/actualizar índice FAISS
-    faiss_ok = build_faiss_index(aportes)
-    if faiss_ok:
-        logger.info("✅ synergix_index.faiss actualizado")
-
-    # 7. Actualizar hot_cache.json
-    update_hot_cache(aportes, fused_brain)
-
-    elapsed = time.time() - start
-    logger.info("🌟 === FUSION BRAIN COMPLETO en %.1fs ===", elapsed)
-    logger.info("📊 Stats: %d aportes | FAISS: %s", len(aportes), "✅" if faiss_ok else "⚠️ skip")
-
-
-if __name__ == "__main__":
-    asyncio.run(run_fusion())