nexo-brain 5.3.13 → 5.3.15

package/src/plugins/evolution 2.py

@@ -0,0 +1,167 @@
+"""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

@@ -0,0 +1,142 @@
+"""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."),
+]