nexo-brain 5.3.26 → 5.3.28

package/src/plugins/evolution 2.py

@@ -1,167 +0,0 @@
-"""Evolution plugin — NEXO self-improvement tools for interactive sessions."""
-
-import json
-import os
-from pathlib import Path
-from db import get_latest_metrics, get_evolution_history, update_evolution_log_status, get_db
-
-
-CANONICAL_DIMENSIONS = {
-    "episodic_memory": "Episodic Memory",
-    "autonomy": "Autonomy",
-    "proactivity": "Proactivity",
-    "self_improvement": "Self-improvement",
-    "agi": "AGI",
-}
-
-
-def _resolve_objective_file() -> Path:
-    nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-    for candidate in (
-        nexo_home / "brain" / "evolution-objective.json",
-        nexo_home / "cortex" / "evolution-objective.json",
-    ):
-        if candidate.exists():
-            return candidate
-    return nexo_home / "brain" / "evolution-objective.json"
-
-
-def _load_objective() -> dict:
-    try:
-        raw = json.loads(_resolve_objective_file().read_text())
-    except Exception:
-        return {}
-    return raw if isinstance(raw, dict) else {}
-
-
-def handle_evolution_status() -> str:
-    """Show current NEXO dimension scores and recent trend."""
-    metrics = get_latest_metrics()
-    objective = _load_objective()
-    objective_dims = objective.get("dimensions", {}) if isinstance(objective.get("dimensions"), dict) else {}
-
-    from user_context import get_context
-    lines = [f"{get_context().assistant_name} EVOLUTION STATUS:"]
-    has_output = False
-    for key, label in CANONICAL_DIMENSIONS.items():
-        m = metrics.get(key)
-        if m:
-            score = m["score"]
-            delta = m["delta"]
-            bar = "█" * (score // 5) + "░" * (20 - score // 5)
-            delta_str = f" (+{delta})" if delta > 0 else f" ({delta})" if delta < 0 else " (=)"
-            target = ""
-            if isinstance(objective_dims.get(key), dict) and objective_dims[key].get("target") is not None:
-                target = f" / target {int(objective_dims[key].get('target', 0) or 0)}%"
-            lines.append(f"  {label:<20} {bar} {score}%{delta_str}{target}")
-            has_output = True
-            continue
-
-        objective_entry = objective_dims.get(key)
-        if isinstance(objective_entry, dict):
-            score = int(objective_entry.get("current", 0) or 0)
-            target = int(objective_entry.get("target", 0) or 0)
-            bar = "█" * (score // 5) + "░" * (20 - score // 5)
-            lines.append(f"  {label:<20} {bar} {score}% (objective fallback, target {target}%)")
-            has_output = True
-
-    if not has_output:
-        return "No evolution metrics recorded."
-
-    if not metrics:
-        lines.append("  Note: no persisted evolution_metrics rows yet; showing objective fallback.")
-    if objective.get("last_evolution"):
-        lines.append(f"  Last evolution: {objective['last_evolution']}")
-    return "\n".join(lines)
-
-
-def handle_evolution_history(limit: int = 10) -> str:
-    """Show past evolution cycles and their outcomes.
-
-    Args:
-        limit: Number of entries to return (default 10)
-    """
-    history = get_evolution_history(limit)
-    if not history:
-        return "No evolution history."
-
-    lines = [f"EVOLUTION HISTORY ({len(history)} entries):"]
-    for h in history:
-        status_icon = {
-            "applied": "✓",
-            "rolled_back": "↺",
-            "blocked": "⛔",
-            "proposed": "?",
-            "pending_review": "…",
-            "accepted": "✓✓",
-            "rejected": "✗✗",
-        }.get(h["status"], "·")
-        lines.append(f"  {status_icon} #{h['id']} [{h['classification']}] {h['dimension']}")
-        lines.append(f"    {h['proposal'][:100]}")
-        if h.get("test_result"):
-            lines.append(f"    Test: {h['test_result'][:80]}")
-        if h.get("impact"):
-            lines.append(f"    Impact: {h['impact']:+d}")
-    return "\n".join(lines)
-
-
-def handle_evolution_propose() -> str:
-    """Manually trigger an evolution analysis outside the weekly schedule.
-    This sets a flag that the Cortex wrapper reads on the next cycle.
-    """
-    import json
-    from pathlib import Path
-    nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-    # Check brain/ (canonical) first, fall back to cortex/ (legacy)
-    obj_file = nexo_home / "brain" / "evolution-objective.json"
-    if not obj_file.exists():
-        obj_file = nexo_home / "cortex" / "evolution-objective.json"
-    if not obj_file.exists():
-        return "ERROR: evolution-objective.json not found. Run the installer or create one in ~/.nexo/brain/"
-    try:
-        obj = json.loads(obj_file.read_text())
-        if not obj.get("evolution_enabled", True):
-            return f"Evolution is DISABLED: {obj.get('disabled_reason', 'unknown')}"
-        obj["force_next_cycle"] = True
-        obj_file.write_text(json.dumps(obj, indent=2, ensure_ascii=False))
-        return "Evolution cycle queued. Will run on next Cortex cycle (within ~10 min)."
-    except Exception as e:
-        return f"ERROR: {e}"
-
-
-def handle_evolution_approve(log_id: int, notes: str = '') -> str:
-    """Approve a pending Evolution proposal.
-
-    Args:
-        log_id: Evolution log entry ID to approve
-        notes: Optional notes from user
-    """
-    update_evolution_log_status(log_id, "accepted",
-                                test_result=f"Approved by user. {notes}".strip())
-    return f"Proposal #{log_id} APPROVED. Will be applied in next Evolution cycle."
-
-
-def handle_evolution_reject(log_id: int, reason: str = '') -> str:
-    """Reject a pending Evolution proposal.
-
-    Args:
-        log_id: Evolution log entry ID to reject
-        reason: Why this proposal was rejected
-    """
-    update_evolution_log_status(log_id, "rejected",
-                                test_result=f"Rejected: {reason}" if reason else "Rejected by user")
-    return f"Proposal #{log_id} REJECTED. Reason: {reason or 'no reason given'}"
-
-
-TOOLS = [
-    (handle_evolution_status, "nexo_evolution_status",
-     "Show current NEXO dimension scores (episodic memory, autonomy, proactivity, self-improvement, AGI)"),
-    (handle_evolution_history, "nexo_evolution_history",
-     "Show past evolution cycles, proposals, and their outcomes"),
-    (handle_evolution_propose, "nexo_evolution_propose",
-     "Manually trigger an evolution analysis outside weekly schedule"),
-    (handle_evolution_approve, "nexo_evolution_approve",
-     "Approve a pending Evolution proposal (user only)"),
-    (handle_evolution_reject, "nexo_evolution_reject",
-     "Reject a pending Evolution proposal with reason"),
-]

package/src/plugins/goal_engine 2.py

@@ -1,142 +0,0 @@
-"""Goal Engine v1 — explicit optimization profiles that Cortex can resolve and trace."""
-
-from __future__ import annotations
-
-import json
-
-from db import (
-    get_db,
-    ensure_default_goal_profiles,
-    get_goal_profile,
-    list_goal_profiles,
-    resolve_goal_profile,
-    upsert_goal_profile,
-)
-
-
-def handle_goal_profile_set(
-    profile_id: str,
-    weights: str = "{}",
-    goal_labels: str = "[]",
-    profile_name: str = "",
-    description: str = "",
-    scope_type: str = "default",
-    scope_value: str = "",
-    status: str = "active",
-    source: str = "manual",
-) -> str:
-    """Create or update an explicit goal profile for Goal Engine v1."""
-    try:
-        profile = upsert_goal_profile(
-            profile_id=profile_id,
-            profile_name=profile_name,
-            description=description,
-            scope_type=scope_type,
-            scope_value=scope_value,
-            goal_labels=json.loads(goal_labels) if str(goal_labels).strip() else [],
-            weights=json.loads(weights) if str(weights).strip() else {},
-            status=status,
-            source=source,
-        )
-    except json.JSONDecodeError as exc:
-        return json.dumps({"ok": False, "error": f"Invalid JSON payload: {exc}"}, ensure_ascii=False, indent=2)
-    except ValueError as exc:
-        return json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False, indent=2)
-
-    return json.dumps({"ok": True, "profile": profile}, ensure_ascii=False, indent=2)
-
-
-def handle_goal_profile_get(
-    profile_id: str = "",
-    area: str = "",
-    task_type: str = "",
-    goal_id: str = "",
-) -> str:
-    """Get one goal profile directly or resolve the active one for a context."""
-    if (profile_id or "").strip():
-        profile = get_goal_profile(profile_id)
-        if not profile:
-            return json.dumps({"ok": False, "error": f"Unknown goal profile: {profile_id}"}, ensure_ascii=False, indent=2)
-        return json.dumps({"ok": True, "profile": profile}, ensure_ascii=False, indent=2)
-    try:
-        profile = resolve_goal_profile(
-            area=area,
-            task_type=task_type,
-            goal_id=goal_id,
-        )
-    except ValueError as exc:
-        return json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False, indent=2)
-    return json.dumps({"ok": True, "profile": profile}, ensure_ascii=False, indent=2)
-
-
-def handle_goal_profile_list(scope_type: str = "", status: str = "active", limit: int = 20) -> str:
-    """List Goal Engine profiles currently available in the runtime."""
-    profiles = list_goal_profiles(scope_type=scope_type, status=status, limit=limit)
-    return json.dumps(
-        {
-            "ok": True,
-            "count": len(profiles),
-            "profiles": profiles,
-        },
-        ensure_ascii=False,
-        indent=2,
-    )
-
-
-def handle_goal_engine_status() -> str:
-    """Report the telemetry readiness of Goal Engine v1 and Cortex v2 inputs."""
-    ensure_default_goal_profiles()
-    conn = get_db()
-    outcomes_total = conn.execute("SELECT COUNT(*) FROM outcomes").fetchone()[0]
-    outcomes_met = conn.execute("SELECT COUNT(*) FROM outcomes WHERE status = 'met'").fetchone()[0]
-    outcomes_missed = conn.execute("SELECT COUNT(*) FROM outcomes WHERE status = 'missed'").fetchone()[0]
-    evaluations_total = conn.execute("SELECT COUNT(*) FROM cortex_evaluations").fetchone()[0]
-    overrides_total = conn.execute("SELECT COUNT(*) FROM cortex_evaluations WHERE selection_source = 'override'").fetchone()[0]
-    linked_total = conn.execute(
-        "SELECT COUNT(*) FROM cortex_evaluations WHERE linked_outcome_id IS NOT NULL"
-    ).fetchone()[0]
-    active_profiles = conn.execute("SELECT COUNT(*) FROM goal_profiles WHERE status = 'active'").fetchone()[0]
-    active_goals = conn.execute("SELECT COUNT(*) FROM workflow_goals WHERE status = 'active'").fetchone()[0]
-
-    readiness = {
-        "has_outcome_history": bool(outcomes_total >= 3),
-        "has_cortex_history": bool(evaluations_total >= 3),
-        "has_linked_decisions": bool(linked_total >= 1),
-        "has_active_profiles": bool(active_profiles >= 1),
-        "has_active_goals": bool(active_goals >= 1),
-    }
-    next_gap = []
-    if not readiness["has_outcome_history"]:
-        next_gap.append("Necesita acumular outcomes reales antes de optimizar por historico.")
-    if not readiness["has_cortex_history"]:
-        next_gap.append("Necesita acumular evaluaciones reales del cortex antes de medir Decision Cortex v2.")
-    if not readiness["has_linked_decisions"]:
-        next_gap.append("Necesita decisiones de impacto enlazadas a outcome para cerrar el loop.")
-
-    return json.dumps(
-        {
-            "ok": True,
-            "telemetry": {
-                "outcomes_total": outcomes_total,
-                "outcomes_met": outcomes_met,
-                "outcomes_missed": outcomes_missed,
-                "cortex_evaluations_total": evaluations_total,
-                "cortex_overrides_total": overrides_total,
-                "cortex_linked_outcomes_total": linked_total,
-                "active_goal_profiles": active_profiles,
-                "active_workflow_goals": active_goals,
-            },
-            "readiness": readiness,
-            "next_gaps": next_gap,
-        },
-        ensure_ascii=False,
-        indent=2,
-    )
-
-
-TOOLS = [
-    (handle_goal_profile_set, "nexo_goal_profile_set", "Create or update a Goal Engine profile with explicit weights and labels."),
-    (handle_goal_profile_get, "nexo_goal_profile_get", "Get or resolve the active Goal Engine profile for a context, area, task type, or workflow goal."),
-    (handle_goal_profile_list, "nexo_goal_profile_list", "List Goal Engine profiles currently available in the runtime."),
-    (handle_goal_engine_status, "nexo_goal_engine_status", "Report Goal Engine telemetry readiness: outcomes, cortex history, linked decisions, and active profiles."),
-]