nexo-brain 5.3.13 → 5.3.15

package/src/scripts/nexo-proactive-dashboard 2.py

@@ -0,0 +1,354 @@
+#!/usr/bin/env python3
+"""
+NEXO Proactive Dashboard — Surfaces issues and opportunities without the user asking.
+
+Scans: overdue followups, forgotten reminders, unresolved learnings,
+inactive systems, user patterns, and more.
+
+Usage:
+    python3 nexo-proactive-dashboard.py           # Full scan, text output
+    python3 nexo-proactive-dashboard.py --json     # JSON output for programmatic use
+    python3 nexo-proactive-dashboard.py --brief    # One-liner alerts only
+"""
+
+import json
+import os
+import sqlite3
+import subprocess
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+
+NEXO_DB = NEXO_HOME / "data" / "nexo.db"
+INACTIVE_STATUSES = {"DELETED", "ARCHIVED", "BLOCKED", "WAITING", "CANCELLED"}
+
+
+def get_db():
+    conn = sqlite3.connect(str(NEXO_DB), timeout=10)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def _is_open_status(status: object) -> bool:
+    normalized = str(status or "").strip().upper()
+    if normalized.startswith("COMPLETED"):
+        return False
+    return normalized not in INACTIVE_STATUSES
+
+
+def check_overdue_followups() -> list[dict]:
+    """Find followups that are overdue and not completed."""
+    conn = get_db()
+    rows = conn.execute("""
+        SELECT id, description, date, created_at, reasoning, status
+        FROM followups
+        WHERE date IS NOT NULL AND date != ''
+        ORDER BY date ASC
+    """).fetchall()
+    conn.close()
+    alerts = []
+    for r in rows:
+        if not _is_open_status(r["status"]):
+            continue
+        due_str = r["date"]
+        try:
+            due = datetime.fromisoformat(due_str) if due_str else None
+            if due and due < datetime.now():
+                days_overdue = (datetime.now() - due).days
+                alerts.append({
+                    "type": "overdue_followup",
+                    "severity": "high" if days_overdue > 3 else "medium",
+                    "title": f"Followup overdue by {days_overdue}d: {r['description'][:80]}",
+                    "id": r["id"],
+                    "days_overdue": days_overdue,
+                })
+        except (ValueError, TypeError):
+            pass
+    return alerts
+
+
+def check_overdue_reminders() -> list[dict]:
+    """Find reminders that are overdue."""
+    conn = get_db()
+    rows = conn.execute("""
+        SELECT id, description, date, status
+        FROM reminders
+        WHERE date IS NOT NULL AND date != ''
+        ORDER BY date ASC
+    """).fetchall()
+    conn.close()
+    alerts = []
+    for r in rows:
+        if not _is_open_status(r["status"]):
+            continue
+        due_str = r["date"]
+        try:
+            due = datetime.fromisoformat(due_str) if due_str else None
+            if due and due < datetime.now():
+                days_overdue = (datetime.now() - due).days
+                alerts.append({
+                    "type": "overdue_reminder",
+                    "severity": "high" if days_overdue > 7 else "medium",
+                    "title": f"Reminder overdue by {days_overdue}d: {r['description'][:80]}",
+                    "id": r["id"],
+                    "days_overdue": days_overdue,
+                })
+        except (ValueError, TypeError):
+            pass
+    return alerts
+
+
+def check_stale_ideas() -> list[dict]:
+    """Find reminders/ideas without due dates that have been sitting for too long."""
+    conn = get_db()
+    rows = conn.execute("""
+        SELECT id, description, created_at, status
+        FROM reminders
+        WHERE date IS NULL OR date = ''
+        ORDER BY created_at ASC
+    """).fetchall()
+    conn.close()
+    alerts = []
+    stale_count = 0
+    for r in rows:
+        if not _is_open_status(r["status"]):
+            continue
+        try:
+            # created_at is epoch float
+            created = datetime.fromtimestamp(r["created_at"])
+            age_days = (datetime.now() - created).days
+        except (ValueError, TypeError, OSError):
+            age_days = 0
+        if age_days > 14:
+            stale_count += 1
+
+    if stale_count > 10:
+        alerts.append({
+            "type": "stale_ideas",
+            "severity": "low",
+            "title": f"{stale_count} ideas/reminders without date have been sitting for >14 days. Review or archive.",
+            "count": stale_count,
+        })
+    return alerts
+
+
+def check_session_gaps() -> list[dict]:
+    """Detect if NEXO hasn't been active for unusual periods."""
+    conn = get_db()
+    row = conn.execute("""
+        SELECT MAX(created_at) as last_diary FROM session_diary
+    """).fetchone()
+    conn.close()
+    alerts = []
+    if row and row["last_diary"]:
+        try:
+            last = datetime.fromisoformat(row["last_diary"])
+            gap_hours = (datetime.now() - last).total_seconds() / 3600
+            if gap_hours > 48:
+                alerts.append({
+                    "type": "session_gap",
+                    "severity": "low",
+                    "title": f"No sessions recorded in {gap_hours:.0f}h ({gap_hours/24:.1f} days)",
+                    "gap_hours": gap_hours,
+                })
+        except (ValueError, TypeError):
+            pass
+    return alerts
+
+
+def check_evolution_status() -> list[dict]:
+    """Check if evolution system is healthy."""
+    alerts = []
+    obj_file = NEXO_HOME / "brain" / "evolution-objective.json"
+    if obj_file.exists():
+        obj = json.loads(obj_file.read_text())
+        if not obj.get("evolution_enabled", True):
+            alerts.append({
+                "type": "evolution_disabled",
+                "severity": "high",
+                "title": f"Evolution DISABLED: {obj.get('disabled_reason', 'unknown')}",
+            })
+        if obj.get("consecutive_failures", 0) > 0:
+            alerts.append({
+                "type": "evolution_failures",
+                "severity": "medium",
+                "title": f"Evolution: {obj['consecutive_failures']} consecutive failures",
+            })
+
+        # Check dimension regression
+        for dim, data in obj.get("dimensions", {}).items():
+            current = data.get("current", 0)
+            if current < 30:
+                alerts.append({
+                    "type": "dimension_low",
+                    "severity": "medium",
+                    "title": f"Dimension '{dim}' baja: {current}%",
+                    "dimension": dim,
+                    "score": current,
+                })
+    return alerts
+
+
+def check_pending_proposals() -> list[dict]:
+    """Check for evolution proposals awaiting the user's review."""
+    conn = get_db()
+    rows = conn.execute("""
+        SELECT id, dimension, proposal, created_at
+        FROM evolution_log
+        WHERE status = 'proposed' AND classification = 'propose'
+        ORDER BY created_at DESC
+    """).fetchall()
+    conn.close()
+    if rows:
+        return [{
+            "type": "pending_proposals",
+            "severity": "low",
+            "title": f"{len(rows)} evolution proposals pending review",
+            "count": len(rows),
+            "proposals": [{"id": r["id"], "dim": r["dimension"], "text": r["proposal"][:80]} for r in rows],
+        }]
+    return []
+
+
+def check_recurring_errors() -> list[dict]:
+    """Detect learnings that keep appearing (same issue reported multiple times)."""
+    conn = get_db()
+    rows = conn.execute("""
+        SELECT category, COUNT(*) as cnt
+        FROM learnings
+        WHERE created_at > datetime('now', '-7 days')
+        GROUP BY category
+        HAVING cnt >= 5
+        ORDER BY cnt DESC
+    """).fetchall()
+    conn.close()
+    alerts = []
+    for r in rows:
+        alerts.append({
+            "type": "recurring_errors",
+            "severity": "medium",
+            "title": f"Category '{r['category']}' has {r['cnt']} learnings this week — possible systemic issue",
+            "category": r["category"],
+            "count": r["cnt"],
+        })
+    return alerts
+
+
+def check_cron_health() -> list[dict]:
+    """Check if critical cron jobs are running."""
+    alerts = []
+
+    # Check backup cron
+    backup_dir = NEXO_HOME / "backups"
+    if backup_dir.exists():
+        backups = sorted(backup_dir.glob("nexo-*.db"), key=lambda p: p.stat().st_mtime, reverse=True)
+        if backups:
+            last_backup_age = (datetime.now().timestamp() - backups[0].stat().st_mtime) / 3600
+            if last_backup_age > 4:
+                alerts.append({
+                    "type": "backup_stale",
+                    "severity": "high",
+                    "title": f"Last nexo.db backup {last_backup_age:.1f}h (should be hourly)",
+                })
+
+    # Check immune system
+    immune_status = NEXO_HOME / "coordination" / "immune-status.json"
+    if immune_status.exists():
+        try:
+            status = json.loads(immune_status.read_text())
+            if status.get("status") == "degraded":
+                alerts.append({
+                    "type": "immune_degraded",
+                    "severity": "high",
+                    "title": f"Immune system degraded: {status.get('reason', '?')}",
+                })
+        except (json.JSONDecodeError, KeyError):
+            pass
+
+    return alerts
+
+
+def run_all_checks() -> list[dict]:
+    """Run all proactive checks and return sorted alerts."""
+    all_alerts = []
+    checks = [
+        check_overdue_followups,
+        check_overdue_reminders,
+        check_stale_ideas,
+        check_session_gaps,
+        check_evolution_status,
+        check_pending_proposals,
+        check_recurring_errors,
+        check_cron_health,
+    ]
+
+    for check in checks:
+        try:
+            all_alerts.extend(check())
+        except Exception as e:
+            all_alerts.append({
+                "type": "check_error",
+                "severity": "low",
+                "title": f"Check {check.__name__} failed: {e}",
+            })
+
+    # Sort by severity
+    severity_order = {"high": 0, "medium": 1, "low": 2}
+    all_alerts.sort(key=lambda a: severity_order.get(a.get("severity", "low"), 3))
+
+    return all_alerts
+
+
+def format_text(alerts: list[dict]) -> str:
+    """Format alerts as readable text."""
+    if not alerts:
+        return "No proactive alerts. All clear."
+
+    severity_icons = {"high": "!!!", "medium": " ! ", "low": " . "}
+    lines = [f"NEXO Proactive Dashboard — {len(alerts)} alerts\n"]
+
+    current_severity = None
+    for a in alerts:
+        sev = a.get("severity", "low")
+        if sev != current_severity:
+            current_severity = sev
+            label = {"high": "URGENTE", "medium": "ATENCION", "low": "INFO"}.get(sev, sev)
+            lines.append(f"\n  [{label}]")
+        icon = severity_icons.get(sev, " . ")
+        lines.append(f"  {icon} {a['title']}")
+
+    return "\n".join(lines)
+
+
+def format_brief(alerts: list[dict]) -> str:
+    """One-liner summary."""
+    high = sum(1 for a in alerts if a.get("severity") == "high")
+    med = sum(1 for a in alerts if a.get("severity") == "medium")
+    low = sum(1 for a in alerts if a.get("severity") == "low")
+    if not alerts:
+        return "Dashboard: clean"
+    return f"Dashboard: {high} urgent, {med} attention, {low} info"
+
+
+def main():
+    output_json = "--json" in sys.argv
+    brief = "--brief" in sys.argv
+
+    alerts = run_all_checks()
+
+    if output_json:
+        print(json.dumps(alerts, indent=2, default=str))
+    elif brief:
+        print(format_brief(alerts))
+    else:
+        print(format_text(alerts))
+
+    # Exit code = number of high severity alerts
+    high_count = sum(1 for a in alerts if a.get("severity") == "high")
+    sys.exit(min(high_count, 125))
+
+
+if __name__ == "__main__":
+    main()

package/src/scripts/nexo-reflection 2.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+"""
+NEXO Reflection Engine — Processes session_buffer.jsonl entries.
+
+Triggered by the stop hook when >=3 sessions have accumulated and
+the last reflection was >4 hours ago.
+
+What it does:
+1. Reads all entries from session_buffer.jsonl
+2. Extracts patterns: recurring tasks, common errors, user mood trends
+3. Updates user_model.json with observed patterns
+4. Writes a reflection summary to reflection-log.json
+5. Clears processed entries from the buffer
+
+Runs as a standalone Python script (no LLM needed).
+"""
+
+import json
+import os
+import sys
+from datetime import datetime
+from collections import Counter
+
+NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
+BUFFER_PATH = os.path.join(NEXO_HOME, "brain", "session_buffer.jsonl")
+USER_MODEL_PATH = os.path.join(NEXO_HOME, "brain", "user_model.json")
+REFLECTION_LOG_PATH = os.path.join(NEXO_HOME, "coordination", "reflection-log.json")
+
+
+def load_buffer():
+    """Load all entries from session buffer."""
+    entries = []
+    if not os.path.exists(BUFFER_PATH):
+        return entries
+    with open(BUFFER_PATH, "r") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                entries.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+    return entries
+
+
+def load_user_model():
+    """Load existing user model or create empty one."""
+    if os.path.exists(USER_MODEL_PATH):
+        try:
+            return json.load(open(USER_MODEL_PATH))
+        except (json.JSONDecodeError, IOError):
+            pass
+    return {
+        "created": datetime.now().strftime("%Y-%m-%d"),
+        "traits": {},
+        "work_patterns": {},
+        "mood_history": [],
+        "common_tasks": [],
+        "error_patterns": [],
+        "reflections_count": 0,
+    }
+
+
+def load_reflection_log():
+    """Load existing reflection log."""
+    if os.path.exists(REFLECTION_LOG_PATH):
+        try:
+            return json.load(open(REFLECTION_LOG_PATH))
+        except (json.JSONDecodeError, IOError):
+            pass
+    return []
+
+
+def analyze_entries(entries):
+    """Extract patterns from buffer entries."""
+    tasks = []
+    decisions = []
+    errors = []
+    moods = Counter()
+    user_patterns = []
+    files_modified = []
+    self_critiques = []
+
+    for entry in entries:
+        source = entry.get("source", "")
+        # Skip hook-fallback entries (they have no real data)
+        if source == "hook-fallback":
+            continue
+
+        # Collect tasks
+        for t in entry.get("tasks", []):
+            if t and t != "session ended":
+                tasks.append(t)
+
+        # Collect decisions
+        for d in entry.get("decisions", []):
+            if d:
+                decisions.append(d)
+
+        # Collect errors
+        for e in entry.get("errors_resolved", []):
+            if e:
+                errors.append(e)
+
+        # Count moods
+        mood = entry.get("mood", "unknown")
+        if mood and mood != "unknown":
+            moods[mood] += 1
+
+        # User patterns
+        for p in entry.get("user_patterns", []):
+            if p:
+                user_patterns.append(p)
+
+        # Files
+        for f in entry.get("files_modified", []):
+            if f:
+                files_modified.append(f)
+
+        # Self-critiques
+        critique = entry.get("self_critique", "")
+        if critique and "hook-fallback" not in critique:
+            self_critiques.append(critique)
+
+    return {
+        "tasks": tasks,
+        "decisions": decisions,
+        "errors": errors,
+        "moods": dict(moods),
+        "user_patterns": user_patterns,
+        "files_modified": files_modified,
+        "self_critiques": self_critiques,
+        "entry_count": len(entries),
+        "source_counts": dict(Counter(e.get("source") or "unknown" for e in entries)),
+    }
+
+
+def update_user_model(model, analysis):
+    """Update user model with new patterns."""
+    # Update mood history (keep last 50)
+    if analysis["moods"]:
+        model["mood_history"].append({
+            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M"),
+            "moods": analysis["moods"],
+        })
+        model["mood_history"] = model["mood_history"][-50:]
+
+    # Update common tasks (top 20)
+    task_counter = Counter(model.get("common_tasks", []))
+    task_counter.update(analysis["tasks"])
+    model["common_tasks"] = [t for t, _ in task_counter.most_common(20)]
+
+    # Update error patterns (keep last 30)
+    existing_errors = model.get("error_patterns", [])
+    existing_errors.extend(analysis["errors"])
+    model["error_patterns"] = existing_errors[-30:]
+
+    # Update work patterns
+    if analysis["files_modified"]:
+        file_counter = Counter(model.get("work_patterns", {}).get("frequent_files", []))
+        file_counter.update(analysis["files_modified"])
+        if "work_patterns" not in model:
+            model["work_patterns"] = {}
+        model["work_patterns"]["frequent_files"] = [
+            f for f, _ in file_counter.most_common(20)
+        ]
+
+    # Derive traits from mood patterns
+    total_moods = sum(analysis["moods"].values())
+    if total_moods >= 3:
+        dominant_mood = max(analysis["moods"], key=analysis["moods"].get)
+        model["traits"]["recent_dominant_mood"] = dominant_mood
+        model["traits"]["mood_updated"] = datetime.now().strftime("%Y-%m-%d")
+
+    model["reflections_count"] = model.get("reflections_count", 0) + 1
+    model["last_reflection"] = datetime.now().strftime("%Y-%m-%d %H:%M")
+
+    return model
+
+
+def main():
+    entries = load_buffer()
+    if not entries:
+        print("No entries in buffer.")
+        return
+
+    # Filter out pure hook entries (tool captures)
+    session_entries = [
+        e for e in entries
+        if e.get("source") in ("claude", "hook-fallback", "codex", "codex_cli", "codex_cli_rs")
+        or "tasks" in e
+    ]
+
+    if not session_entries:
+        print("No session entries to process.")
+        return
+
+    analysis = analyze_entries(session_entries)
+    model = load_user_model()
+    model = update_user_model(model, analysis)
+
+    # Save updated model
+    os.makedirs(os.path.dirname(USER_MODEL_PATH), exist_ok=True)
+    with open(USER_MODEL_PATH, "w") as f:
+        json.dump(model, f, indent=2)
+
+    # Append to reflection log
+    log = load_reflection_log()
+    reflection = {
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M"),
+        "entries_processed": analysis["entry_count"],
+        "source_counts": analysis["source_counts"],
+        "tasks_seen": len(analysis["tasks"]),
+        "decisions_made": len(analysis["decisions"]),
+        "errors_resolved": len(analysis["errors"]),
+        "mood_distribution": analysis["moods"],
+        "self_critiques": analysis["self_critiques"][:5],
+        "user_patterns_observed": analysis["user_patterns"][:5],
+    }
+    log.append(reflection)
+    # Keep last 100 reflections
+    log = log[-100:]
+
+    os.makedirs(os.path.dirname(REFLECTION_LOG_PATH), exist_ok=True)
+    with open(REFLECTION_LOG_PATH, "w") as f:
+        json.dump(log, f, indent=2)
+
+    # Clear buffer (processed)
+    with open(BUFFER_PATH, "w") as f:
+        f.write("")
+
+    # Adaptive personality: decay inter-session tension
+    try:
+        import sys
+        sys.path.insert(0, os.path.join(NEXO_HOME))
+        from plugins.adaptive_mode import decay_tension
+        decay_result = decay_tension()
+        if decay_result:
+            reflection["adaptive_decay"] = decay_result
+            print(f"Adaptive decay: tension {decay_result['old_tension']} → {decay_result['new_tension']} "
+                  f"({decay_result['hours_elapsed']}h elapsed)")
+    except Exception as e:
+        print(f"Adaptive decay skipped: {e}")
+
+    source_summary = ", ".join(
+        f"{source}={count}" for source, count in sorted(analysis["source_counts"].items())
+    ) or "none"
+    print(f"Reflection complete: {analysis['entry_count']} entries processed, "
+          f"sources: {source_summary}, "
+          f"{len(analysis['errors'])} errors, "
+          f"{len(analysis['self_critiques'])} critiques.")
+
+
+if __name__ == "__main__":
+    main()