nexo-brain 2.1.0 → 2.3.0

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)

package/src/scripts/nexo-send-reply 2.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""
+NEXO Email Reply Helper — Sends email replies with correct threading headers.
+NEXO calls this instead of building SMTP manually.
+
+Usage:
+  nexo-send-reply.py --to addr --subject "Re: ..." --in-reply-to "<msg-id>" --body "text"
+  nexo-send-reply.py --to addr --subject "Re: ..." --in-reply-to "<msg-id>" --body-file /tmp/reply.html --html
+  nexo-send-reply.py --to addr --subject "New subject" --body "text"  (new email, no threading)
+
+Options:
+  --to          Recipient (required)
+  --cc          CC recipients (comma-separated, default: info@example.com)
+  --subject     Subject line (required)
+  --in-reply-to Message-ID of the email being replied to (for threading)
+  --references  Full References chain (optional, defaults to in-reply-to value)
+  --body        Plain text body (inline)
+  --body-file   Read body from file instead
+  --html        Treat body as HTML
+  --quote       Original message text to include as quoted reply
+  --quote-file  Read original message from file to quote
+  --quote-from  Sender of the original message (for "On date, X wrote:")
+  --quote-date  Date of the original message
+  --attachment  Path to file attachment (can be repeated)
+"""
+
+import argparse
+import imaplib
+import json
+import os
+import smtplib
+import sys
+import time
+from email.message import EmailMessage
+from email.utils import make_msgid, formatdate
+from pathlib import Path
+import mimetypes
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+CONFIG_PATH = NEXO_HOME / "nexo-email" / "config.json"
+
+
+def load_config():
+    with open(CONFIG_PATH) as f:
+        return json.load(f)
+
+
+def build_message(args, config):
+    msg = EmailMessage()
+
+    # From / To / CC
+    msg["From"] = f"NEXO <{config['email']}>"
+    msg["To"] = args.to
+    if args.cc:
+        msg["Cc"] = args.cc
+
+    # Subject
+    msg["Subject"] = args.subject
+
+    # Threading headers — this is the whole point of this script
+    if args.in_reply_to:
+        msg["In-Reply-To"] = args.in_reply_to
+        msg["References"] = args.references or args.in_reply_to
+
+    # Standard headers
+    msg["Message-ID"] = make_msgid(domain="example.com")
+    msg["Date"] = formatdate(localtime=True)
+
+    # Body
+    if args.body_file:
+        body = Path(args.body_file).read_text(encoding="utf-8")
+    else:
+        body = args.body or ""
+
+    # Quoted original message
+    quote_text = ""
+    if args.quote_file:
+        quote_text = Path(args.quote_file).read_text(encoding="utf-8")
+    elif args.quote:
+        quote_text = args.quote
+
+    if quote_text:
+        quote_from = args.quote_from or args.to
+        quote_date = args.quote_date or ""
+        attribution = f"On {quote_date}, {quote_from} wrote:" if quote_date else f"{quote_from} wrote:"
+
+        if args.html:
+            quoted_html = quote_text.replace("\n", "<br>") if "<" not in quote_text else quote_text
+            body = (
+                f"{body}<br><br>"
+                f"<div style=\"color:#666;\">{attribution}</div>"
+                f"<blockquote style=\"margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex;color:#666;\">"
+                f"{quoted_html}"
+                f"</blockquote>"
+            )
+        else:
+            quoted_lines = "\n".join(f"> {line}" for line in quote_text.splitlines())
+            body = f"{body}\n\n{attribution}\n{quoted_lines}"
+
+    if args.html:
+        msg.set_content(body, subtype="html")
+    else:
+        msg.set_content(body)
+
+    # Attachments
+    if args.attachment:
+        for filepath in args.attachment:
+            p = Path(filepath)
+            if not p.exists():
+                print(f"WARNING: attachment not found: {filepath}", file=sys.stderr)
+                continue
+            mime_type, _ = mimetypes.guess_type(str(p))
+            if mime_type is None:
+                mime_type = "application/octet-stream"
+            maintype, subtype = mime_type.split("/", 1)
+            with open(p, "rb") as f:
+                msg.add_attachment(
+                    f.read(),
+                    maintype=maintype,
+                    subtype=subtype,
+                    filename=p.name
+                )
+
+    return msg
+
+
+def send(msg, config):
+    with smtplib.SMTP_SSL(config["smtp_host"], config["smtp_port"]) as server:
+        server.login(config["email"], config["password"])
+        server.send_message(msg)
+
+
+def save_to_sent(msg, config):
+    """Append the sent message to the IMAP Sent folder."""
+    try:
+        with imaplib.IMAP4_SSL(config["imap_host"], config["imap_port"]) as imap:
+            imap.login(config["email"], config["password"])
+            imap.append(
+                "INBOX.Sent",
+                r"\Seen",
+                imaplib.Time2Internaldate(time.time()),
+                msg.as_bytes(),
+            )
+    except Exception as e:
+        print(f"WARNING: could not save to Sent folder: {e}", file=sys.stderr)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="NEXO Email Reply Helper")
+    parser.add_argument("--to", required=True, help="Recipient email")
+    parser.add_argument("--cc", default=None, help="CC recipients (comma-separated, no default)")
+    parser.add_argument("--subject", required=True, help="Subject line")
+    parser.add_argument("--in-reply-to", default=None, help="Message-ID for threading")
+    parser.add_argument("--references", default=None, help="References chain for threading")
+    parser.add_argument("--body", default=None, help="Body text inline")
+    parser.add_argument("--body-file", default=None, help="Read body from file")
+    parser.add_argument("--html", action="store_true", help="Body is HTML")
+    parser.add_argument("--quote", default=None, help="Original message text to quote inline")
+    parser.add_argument("--quote-file", default=None, help="Read original message from file to quote")
+    parser.add_argument("--quote-from", default=None, help="Sender of original (for attribution line)")
+    parser.add_argument("--quote-date", default=None, help="Date of original message")
+    parser.add_argument("--attachment", action="append", help="File to attach (repeatable)")
+    args = parser.parse_args()
+
+    if not args.body and not args.body_file:
+        print("ERROR: --body or --body-file required", file=sys.stderr)
+        sys.exit(1)
+
+    config = load_config()
+    msg = build_message(args, config)
+    send(msg, config)
+    save_to_sent(msg, config)
+
+    print(f"OK: sent to {args.to} | subject: {args.subject} | threaded: {bool(args.in_reply_to)}")
+
+
+if __name__ == "__main__":
+    main()