nexo-brain 2.3.0 → 2.3.1

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

@@ -1,253 +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),
-        "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

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

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

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

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