nexo-brain 2.0.0 → 2.2.0

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

@@ -0,0 +1,253 @@
+#!/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),
+        "claude_entries": sum(1 for e in entries if e.get("source") == "claude"),
+    }
+
+
+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")
+        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"],
+        "claude_entries": analysis["claude_entries"],
+        "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}")
+
+    print(f"Reflection complete: {analysis['entry_count']} entries processed, "
+          f"{analysis['claude_entries']} from Claude, "
+          f"{len(analysis['errors'])} errors, "
+          f"{len(analysis['self_critiques'])} critiques.")
+
+
+if __name__ == "__main__":
+    main()

package/src/scripts/nexo-runtime-preflight 2.py

@@ -0,0 +1,274 @@
+#!/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_HOME/logs/runtime-preflight-summary.json.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import os
+import shutil
+import sqlite3
+import sys
+import tempfile
+import traceback
+from datetime import datetime
+from pathlib import Path
+
+HOME = Path.home()
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(HOME / ".nexo")))
+# Auto-detect: if running from repo (src/scripts/), use src/ as NEXO_CODE
+_script_dir = Path(__file__).resolve().parent
+_repo_src = _script_dir.parent  # src/scripts/ -> src/
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(_repo_src) if (_repo_src / "server.py").exists() else str(NEXO_HOME)))
+
+LOG_DIR = NEXO_HOME / "logs"
+LOG_DIR.mkdir(parents=True, exist_ok=True)
+SUMMARY_FILE = LOG_DIR / "runtime-preflight-summary.json"
+DB_FILE = NEXO_HOME / "data" / "nexo.db"
+# Evolution config: NEXO_HOME/brain/ (canonical), NEXO_HOME/cortex/ (legacy fallback), NEXO_CODE (dev fallback)
+def _find_evolution_file(name: str) -> Path:
+    for candidate in [NEXO_HOME / "brain" / name, NEXO_HOME / "cortex" / name, NEXO_CODE / name]:
+        if candidate.exists():
+            return candidate
+    return NEXO_HOME / "brain" / name  # default canonical path
+
+CORTEX_OBJECTIVE = _find_evolution_file("evolution-objective.json")
+CORTEX_PROMPT = _find_evolution_file("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 / "brain"
+        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"
+        if CORTEX_OBJECTIVE.exists():
+            shutil.copy2(CORTEX_OBJECTIVE, temp_objective)
+        else:
+            # Create a minimal objective so evolution smoke tests can proceed
+            temp_objective.write_text(json.dumps({"evolution_enabled": True, "dimensions": {}}, indent=2))
+        if CORTEX_PROMPT.exists():
+            shutil.copy2(CORTEX_PROMPT, temp_prompt)
+        snapshot_restore = NEXO_CODE / "scripts" / "nexo-snapshot-restore.sh"
+        if snapshot_restore.exists():
+            shutil.copy2(snapshot_restore, 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", NEXO_CODE / "evolution_cycle.py")
+        evolution_cycle.NEXO_DB = temp_db
+        evolution_cycle.NEXO_HOME = temp_root
+        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_plugin", NEXO_CODE / "plugins" / "cortex.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 "")
+
+        # Smoke test: verify cortex plugin loads and has expected tools
+        cortex_path = NEXO_CODE / "plugins" / "cortex.py"
+        if cortex_path.exists():
+            import importlib.util
+            spec = importlib.util.spec_from_file_location("cortex_plugin", str(cortex_path))
+            cortex_mod = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(cortex_mod)
+            assert hasattr(cortex_mod, 'TOOLS'), "cortex plugin missing TOOLS"
+            tool_names = [t[1] for t in cortex_mod.TOOLS]
+            assert "nexo_cortex_check" in tool_names, "cortex plugin missing nexo_cortex_check tool"
+        else:
+            tool_names = ["cortex.py not found"]
+        summary["checks"]["cortex_plugin"] = {
+            "status": "pass",
+            "tools_found": tool_names,
+        }
+
+        # Evolution runner: component verification (not full execution — that needs CLI)
+        runner_path = NEXO_CODE / "scripts" / "nexo-evolution-run.py"
+        if runner_path.exists():
+            runner = _load_module("nexo_evolution_run", runner_path)
+            checks = {
+                "module_loads": True,
+                "has_run": hasattr(runner, 'run'),
+                "has_load_objective": hasattr(runner, 'load_objective'),
+                "has_get_week_data": hasattr(runner, 'get_week_data'),
+            }
+            summary["checks"]["standalone_runner"] = checks
+        else:
+            summary["checks"]["standalone_runner"] = {"status": "skip", "reason": "runner not found"}
+
+        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 2.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="user@example.com", cc="user@example.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(os.environ.get('NEXO_SMTP_HOST', 'smtp.example.com'), int(os.environ.get('NEXO_SMTP_PORT', '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)