nexo-brain 1.4.0 → 1.4.1

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

@@ -0,0 +1,342 @@
+#!/usr/bin/env python3
+"""
+NEXO Proactive Dashboard — Surfaces issues and opportunities without the user asking.
+
+Scans: followups vencidos, reminders olvidados, learnings sin resolver,
+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_DB = Path.home() / ".nexo" / "nexo-mcp" / "nexo.db"
+
+
+def get_db():
+    conn = sqlite3.connect(str(NEXO_DB), timeout=10)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def check_overdue_followups() -> list[dict]:
+    """Find followups that are overdue and not completed."""
+    conn = get_db()
+    now_epoch = datetime.now().timestamp()
+    rows = conn.execute("""
+        SELECT id, description, date, created_at, reasoning
+        FROM followups
+        WHERE status NOT LIKE 'COMPLETED%'
+        AND date IS NOT NULL AND date != ''
+        ORDER BY date ASC
+    """).fetchall()
+    conn.close()
+    alerts = []
+    for r in rows:
+        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 vencido hace {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 status NOT IN ('COMPLETED', 'CANCELADO')
+        AND date IS NOT NULL AND date != ''
+        ORDER BY date ASC
+    """).fetchall()
+    conn.close()
+    alerts = []
+    for r in rows:
+        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 vencido hace {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
+        FROM reminders
+        WHERE status NOT IN ('COMPLETED', 'CANCELADO')
+        AND (date IS NULL OR date = '')
+        ORDER BY created_at ASC
+    """).fetchall()
+    conn.close()
+    alerts = []
+    stale_count = 0
+    for r in rows:
+        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 are >14 days old. 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 registered 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 = Path.home() / ".nexo" / "cortex" / "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 DESACTIVADO: {obj.get('disabled_reason', 'desconocido')}",
+            })
+        if obj.get("consecutive_failures", 0) > 0:
+            alerts.append({
+                "type": "evolution_failures",
+                "severity": "medium",
+                "title": f"Evolution: {obj['consecutive_failures']} fallos consecutivos",
+            })
+
+        # 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)} pending evolution proposals awaiting 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"Categoria '{r['category']}' tiene {r['cnt']} learnings esta semana — posible problema sistémico",
+            "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 = Path.home() / ".nexo" / "nexo-mcp" / "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"Ultimo backup de nexo.db hace {last_backup_age:.1f}h (deberia ser cada 1h)",
+                })
+
+    # Check immune system
+    immune_status = Path.home() / ".nexo" / "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"Sistema inmune degradado: {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 hay alertas proactivas. Todo en orden."
+
+    severity_icons = {"high": "!!!", "medium": " ! ", "low": " . "}
+    lines = [f"NEXO Proactive Dashboard — {len(alerts)} alertas\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: limpio"
+    return f"Dashboard: {high} urgente, {med} atencion, {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-runtime-preflight.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""
+NEXO Runtime Preflight
+
+Runs safe end-to-end smoke tests for Cortex and Evolution using a temporary
+workspace and a copied SQLite database. No external API calls are performed.
+Results are written to ~/.nexo/logs/runtime-preflight-summary.json.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import shutil
+import sqlite3
+import sys
+import tempfile
+import traceback
+from datetime import datetime
+from pathlib import Path
+
+HOME = Path.home()
+CLAUDE_DIR = HOME / ".nexo"
+LOG_DIR = CLAUDE_DIR / "logs"
+LOG_DIR.mkdir(parents=True, exist_ok=True)
+SUMMARY_FILE = LOG_DIR / "runtime-preflight-summary.json"
+DB_FILE = CLAUDE_DIR / "nexo-mcp" / "nexo.db"
+CORTEX_OBJECTIVE = CLAUDE_DIR / "cortex" / "evolution-objective.json"
+CORTEX_PROMPT = CLAUDE_DIR / "cortex" / "evolution-prompt.md"
+
+
+def _load_module(name: str, path: Path):
+    spec = importlib.util.spec_from_file_location(name, str(path))
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    assert spec.loader is not None
+    spec.loader.exec_module(module)
+    return module
+
+
+def _write_summary(summary: dict):
+    SUMMARY_FILE.write_text(json.dumps(summary, indent=2, ensure_ascii=False))
+
+
+def _fake_cortex_response(model: str) -> str:
+    if "opus" in model:
+        payload = {
+            "analysis": "Smoke evolution run over temp workspace",
+            "proposals": [
+                {
+                    "dimension": "self_improvement",
+                    "classification": "propose",
+                    "action": "Add a regression smoke before live cycles",
+                    "reasoning": "Smoke run should stay side-effect free",
+                }
+            ],
+            "dimension_scores": {
+                "episodic_memory": 86,
+                "autonomy": 53,
+                "proactivity": 34,
+                "self_improvement": 30,
+                "agi": 6,
+            },
+            "score_evidence": {
+                "self_improvement": "Temp evolution smoke completed successfully",
+            },
+        }
+    else:
+        payload = {
+            "actions_taken": ["preflight perception completed"],
+            "signals_detected": 1,
+            "pending_questions": [],
+            "execute": [],
+            "next_interval_suggestion": 600,
+            "reflection_done": False,
+            "dmn_done": False,
+            "briefing_update": {
+                "actions_taken": ["perception smoke ok"],
+                "signals_active": [{"summary": "Smoke signal", "urgency": "INFO", "score": 10}],
+                "recommendations": ["keep runtime checks green"],
+                "pending_questions_unanswered": [],
+                "dmn_summary": "",
+            },
+            "working_memory": {
+                "current_threads": ["runtime preflight"],
+                "attention_focus": "runtime integrity",
+                "last_reasoning": "API mocked successfully",
+                "watching": ["state writes", "briefing writes"],
+                "momentum": "stable",
+            },
+            "error": None,
+        }
+    return json.dumps(payload, ensure_ascii=False)
+
+
+def _fake_runner_response() -> tuple[str, dict]:
+    payload = {
+        "analysis": "Standalone evolution smoke over temp DB",
+        "patterns": [
+            {"type": "smoke", "description": "runner executed over temp workspace", "frequency": "once"}
+        ],
+        "proposals": [
+            {
+                "dimension": "self_improvement",
+                "classification": "propose",
+                "action": "Keep standalone evolution covered by preflight",
+                "reasoning": "Regression prevention",
+            }
+        ],
+        "dimension_scores": {
+            "episodic_memory": 87,
+            "autonomy": 54,
+            "proactivity": 35,
+            "self_improvement": 31,
+            "agi": 6,
+        },
+        "score_evidence": {
+            "self_improvement": "standalone runner smoke ok",
+        },
+    }
+    usage = {"input_tokens": 1234, "output_tokens": 432}
+    return json.dumps(payload, ensure_ascii=False), usage
+
+
+def main() -> int:
+    started = datetime.now().isoformat()
+    summary = {
+        "timestamp": started,
+        "ok": False,
+        "checks": {},
+        "errors": [],
+    }
+
+    if not DB_FILE.exists():
+        summary["errors"].append("nexo.db missing")
+        _write_summary(summary)
+        return 1
+
+    preflight_root = HOME / ".codex" / "memories"
+    preflight_root.mkdir(parents=True, exist_ok=True)
+    temp_root = Path(tempfile.mkdtemp(prefix="nexo-runtime-preflight-", dir=str(preflight_root)))
+    try:
+        temp_db = temp_root / "nexo.db"
+        shutil.copy2(DB_FILE, temp_db)
+
+        temp_cortex_dir = temp_root / "cortex"
+        temp_logs_dir = temp_root / "logs"
+        temp_coord_dir = temp_root / "coordination"
+        temp_daily_dir = temp_root / "daily_summaries"
+        temp_dmn_dir = temp_root / "dmn_insights"
+        temp_snapshots_dir = temp_root / "snapshots"
+        temp_sandbox_dir = temp_root / "sandbox" / "workspace"
+        temp_scripts_dir = temp_root / "scripts"
+        for directory in [
+            temp_cortex_dir, temp_logs_dir, temp_coord_dir, temp_daily_dir,
+            temp_dmn_dir, temp_snapshots_dir, temp_sandbox_dir, temp_scripts_dir,
+        ]:
+            directory.mkdir(parents=True, exist_ok=True)
+
+        temp_objective = temp_cortex_dir / "evolution-objective.json"
+        temp_prompt = temp_cortex_dir / "evolution-prompt.md"
+        shutil.copy2(CORTEX_OBJECTIVE, temp_objective)
+        if CORTEX_PROMPT.exists():
+            shutil.copy2(CORTEX_PROMPT, temp_prompt)
+        shutil.copy2(CLAUDE_DIR / "scripts" / "nexo-snapshot-restore.sh", temp_scripts_dir / "nexo-snapshot-restore.sh")
+
+        temp_api_key = temp_root / "anthropic-api-key.txt"
+        temp_api_key.write_text("smoke-test-key")
+
+        evolution_cycle = _load_module("evolution_cycle", CLAUDE_DIR / "cortex" / "evolution_cycle.py")
+        evolution_cycle.NEXO_DB = temp_db
+        evolution_cycle.CLAUDE_DIR = temp_root
+        evolution_cycle.CORTEX_DIR = temp_cortex_dir
+        evolution_cycle.SANDBOX_DIR = temp_sandbox_dir
+        evolution_cycle.SNAPSHOTS_DIR = temp_snapshots_dir
+        evolution_cycle.OBJECTIVE_FILE = temp_objective
+        evolution_cycle.PROMPT_FILE = temp_prompt
+        evolution_cycle.RESTORE_LOG = temp_logs_dir / "snapshot-restores.log"
+
+        week_data = evolution_cycle.get_week_data(str(temp_db))
+        prompt = evolution_cycle.build_evolution_prompt(week_data, evolution_cycle.load_objective())
+        restore_ok = evolution_cycle.dry_run_restore_test()
+        if not restore_ok:
+            raise RuntimeError("dry_run_restore_test failed")
+        summary["checks"]["evolution_cycle"] = {
+            "learnings": len(week_data.get("learnings", [])),
+            "decisions": len(week_data.get("decisions", [])),
+            "prompt_chars": len(prompt),
+            "restore_ok": restore_ok,
+        }
+
+        cortex = _load_module("cortex_wrapper", CLAUDE_DIR / "cortex" / "cortex-wrapper.py")
+        cortex.NEXO_DB = temp_db
+        cortex.DRY_RUN = True
+        cortex.BRIEFING_FILE = temp_cortex_dir / "briefing.json"
+        cortex.HEALTH_FILE = temp_cortex_dir / "health.json"
+        cortex.STATE_FILE = temp_cortex_dir / "state.json"
+        cortex.STATE_TMP = temp_cortex_dir / "state.tmp"
+        cortex.LOG_DIR = temp_logs_dir
+        cortex.COORD_DIR = temp_coord_dir
+        cortex.SIGNALS_FILE = temp_coord_dir / "pending-signals.json"
+        cortex.DAILY_SUMMARIES_DIR = temp_daily_dir
+        cortex.DMN_INSIGHTS_DIR = temp_dmn_dir
+        cortex.FAILURE_COUNT_FILE = temp_cortex_dir / ".failure-count"
+        cortex.PID_FILE = temp_cortex_dir / "cortex.pid"
+        cortex.API_KEY_FILE = temp_api_key
+        cortex.wa_notify = lambda *args, **kwargs: None
+        cortex.poll_wa_inbox = lambda state: None
+        cortex._check_health_endpoints = lambda: []
+        cortex._call_anthropic = lambda prompt, model=None, max_tokens=4096: _fake_cortex_response(model or "")
+
+        state = cortex.load_state()
+        state = cortex.run_perception_cycle(state)
+        if not cortex.BRIEFING_FILE.exists() or not cortex.HEALTH_FILE.exists():
+            raise RuntimeError("cortex perception did not write briefing/health")
+
+        before_logs = sqlite3.connect(str(temp_db)).execute("SELECT COUNT(*) FROM evolution_log").fetchone()[0]
+        state = cortex.run_evolution_cycle(state)
+        after_logs = sqlite3.connect(str(temp_db)).execute("SELECT COUNT(*) FROM evolution_log").fetchone()[0]
+        if after_logs <= before_logs:
+            raise RuntimeError("cortex evolution smoke did not log proposals")
+        summary["checks"]["cortex_wrapper"] = {
+            "state_status": state.get("status"),
+            "briefing_written": cortex.BRIEFING_FILE.exists(),
+            "health_written": cortex.HEALTH_FILE.exists(),
+            "evolution_logs_added": after_logs - before_logs,
+        }
+
+        runner = _load_module("nexo_evolution_run", CLAUDE_DIR / "scripts" / "nexo-evolution-run.py")
+        runner.CLAUDE_DIR = temp_root
+        runner.NEXO_DB = temp_db
+        runner.CORTEX_DIR = temp_cortex_dir
+        runner.OBJECTIVE_FILE = temp_objective
+        runner.LOG_DIR = temp_logs_dir
+        runner.LOG_FILE = temp_logs_dir / "evolution.log"
+        runner.SNAPSHOTS_DIR = temp_snapshots_dir
+        runner.SANDBOX_DIR = temp_sandbox_dir
+        runner.API_KEY_FILE = temp_api_key
+        runner.BUDGET_FILE = temp_logs_dir / "evolution-budget.json"
+        runner.call_anthropic = lambda prompt: _fake_runner_response()
+        runner.check_budget = lambda: True
+
+        before_runner_logs = sqlite3.connect(str(temp_db)).execute("SELECT COUNT(*) FROM evolution_log").fetchone()[0]
+        runner.run()
+        conn = sqlite3.connect(str(temp_db))
+        after_runner_logs = conn.execute("SELECT COUNT(*) FROM evolution_log").fetchone()[0]
+        latest_cycle = conn.execute("SELECT MAX(cycle_number) FROM evolution_log").fetchone()[0]
+        conn.close()
+        if after_runner_logs <= before_runner_logs:
+            raise RuntimeError("standalone evolution runner did not log proposals")
+        summary["checks"]["standalone_runner"] = {
+            "evolution_logs_added": after_runner_logs - before_runner_logs,
+            "latest_cycle": latest_cycle,
+            "budget_file_written": runner.BUDGET_FILE.exists(),
+        }
+
+        summary["ok"] = True
+        _write_summary(summary)
+        return 0
+    except Exception as exc:
+        summary["errors"].append(f"{type(exc).__name__}: {exc}")
+        summary["errors"].append(traceback.format_exc())
+        _write_summary(summary)
+        return 1
+    finally:
+        shutil.rmtree(temp_root, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/src/scripts/nexo-send-email.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""Quick email sender for NEXO progress updates."""
+import smtplib, sys
+from email.mime.text import MIMEText
+from email.utils import formataddr
+
+def send(subject, body, to="userp@gmail.com", cc="user.example.com@gmail.com"):
+    msg = MIMEText(body, 'plain', 'utf-8')
+    msg['From'] = formataddr(('NEXO', 'nexo@example.com'))
+    msg['To'] = to
+    msg['Cc'] = cc
+    msg['Subject'] = subject
+    smtp = smtplib.SMTP_SSL('cl105e.server.com', 465)
+    smtp.login(FROM_EMAIL, os.environ.get('NEXO_SMTP_PASSWORD', ''))
+    recipients = [to]
+    if cc:
+        recipients.append(cc)
+    smtp.send_message(msg)
+    smtp.quit()
+    print(f"OK — sent to {to}")
+
+if __name__ == "__main__":
+    subject = sys.argv[1] if len(sys.argv) > 1 else "NEXO Update"
+    body = sys.argv[2] if len(sys.argv) > 2 else "No body"
+    send(subject, body)