nexo-brain 5.3.26 → 5.3.27

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

@@ -1,354 +0,0 @@
-#!/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

@@ -1,256 +0,0 @@
-#!/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()