nexo-brain 2.4.0 → 2.5.0

package/src/tools_sessions.py

@@ -101,9 +101,74 @@ def handle_startup(task: str = "Startup", claude_session_id: str = "") -> str:
             age = _format_age(m["created_epoch"])
             lines.append(f"  [{m['from_sid']}] ({age}): {m['text']}")
 
+    # Check LaunchAgent health (macOS only)
+    la_warnings = _check_launchagents()
+    if la_warnings:
+        lines.append("")
+        lines.append("⚠ LAUNCHAGENT MISMATCH (plist on disk ≠ loaded in memory):")
+        for w in la_warnings:
+            lines.append(f"  {w}")
+        lines.append("  Fix: launchctl unload + load the affected plists, or restart.")
+
     return "\n".join(lines)
 
 
+def _check_launchagents() -> list[str]:
+    """Compare on-disk plists with what launchctl has loaded. macOS only."""
+    import platform
+    if platform.system() != "Darwin":
+        return []
+
+    import os, subprocess, plistlib, glob
+
+    plist_dir = os.path.expanduser("~/Library/LaunchAgents")
+    warnings = []
+
+    for plist_path in glob.glob(os.path.join(plist_dir, "com.nexo.*.plist")):
+        label = os.path.basename(plist_path).replace(".plist", "")
+        try:
+            with open(plist_path, "rb") as f:
+                disk = plistlib.load(f)
+            disk_args = disk.get("ProgramArguments", [])
+
+            result = subprocess.run(
+                ["launchctl", "list", label],
+                capture_output=True, text=True, timeout=5
+            )
+            if result.returncode != 0:
+                warnings.append(f"{label}: not loaded (plist exists on disk)")
+                continue
+
+            # Parse loaded ProgramArguments from launchctl output
+            loaded_args = []
+            in_args = False
+            for line in result.stdout.splitlines():
+                if '"ProgramArguments"' in line:
+                    in_args = True
+                    continue
+                if in_args:
+                    line = line.strip().rstrip(";")
+                    if line == ");":
+                        break
+                    if line.startswith('"') and line.endswith('"'):
+                        loaded_args.append(line.strip('"'))
+
+            if loaded_args and disk_args and loaded_args != disk_args:
+                # Check if loaded path points to /tmp or nonexistent path
+                stale = any("/tmp/" in a or not os.path.exists(a) for a in loaded_args if "/" in a)
+                if stale:
+                    # Auto-repair: reload the plist
+                    subprocess.run(["launchctl", "unload", plist_path], capture_output=True, timeout=5)
+                    subprocess.run(["launchctl", "load", plist_path], capture_output=True, timeout=5)
+                    warnings.append(f"{label}: AUTO-REPAIRED (was pointing to stale/tmp path, reloaded from disk)")
+                else:
+                    warnings.append(f"{label}: loaded args differ from disk plist")
+        except Exception:
+            continue
+
+    return warnings
+
+
 def handle_heartbeat(sid: str, task: str, context_hint: str = '') -> str:
     """Update session, check inbox + questions. Lightweight — no embeddings, no RAG.
 
@@ -209,6 +274,18 @@ def handle_heartbeat(sid: str, task: str, context_hint: str = '') -> str:
             parts.append("")
             parts.append(f"⚠ DIARY_OVERDUE: {_hb_count} heartbeats, {int(age_seconds/60)}min active, no diary. Write nexo_session_diary_write NOW.")
 
+    # Guard check reminder: if context_hint mentions code editing and no guard_check this session
+    if context_hint and _hint_suggests_code_edit(context_hint):
+        try:
+            guard_used = conn.execute(
+                "SELECT COUNT(*) FROM guard_log WHERE session_id = ?", (sid,)
+            ).fetchone()[0]
+            if guard_used == 0:
+                parts.append("")
+                parts.append("⚠ GUARD REMINDER: You appear to be editing code but haven't called `nexo_guard_check` this session. Do it NOW before any edits.")
+        except Exception:
+            pass  # guard_log table may not exist in older installs
+
     return "\n".join(parts)
 
 
@@ -445,11 +522,60 @@ def handle_smart_startup_query() -> str:
             lines.append("")
             lines.append(tone)
 
+        # Toolbox reminder: skills + behavioral learnings count
+        toolbox = _toolbox_summary(conn)
+        if toolbox:
+            lines.append("")
+            lines.append(toolbox)
+
         return "\n".join(lines)
     except Exception as e:
         return f"Smart startup query error: {e}"
 
 
+def _hint_suggests_code_edit(hint: str) -> bool:
+    """Check if a heartbeat context_hint suggests the agent is editing code."""
+    hint_lower = hint.lower()
+    edit_signals = ['edit', 'fix', 'patch', 'modify', 'implement', 'refactor', 'add function',
+                    'change code', 'update script', 'write code', '.py', '.js', '.ts', '.php',
+                    'commit', 'arregl', 'modific', 'implement', 'correg']
+    return any(signal in hint_lower for signal in edit_signals)
+
+
+def _toolbox_summary(conn) -> str:
+    """Quick count of available skills and behavioral learnings for startup reminder."""
+    try:
+        skill_count = conn.execute(
+            "SELECT COUNT(*) FROM skills"
+        ).fetchone()[0]
+        learning_count = conn.execute(
+            "SELECT COUNT(*) FROM learnings WHERE status = 'active' AND priority IN ('critical', 'high')"
+        ).fetchone()[0]
+        parts = []
+        if skill_count > 0:
+            parts.append(f"{skill_count} skills available — use `nexo_skill_match(task)` before multi-step tasks")
+            try:
+                from skills_runtime import get_featured_skill_summaries
+
+                featured = get_featured_skill_summaries(limit=3)
+                if featured:
+                    parts.append("Featured skills:")
+                    for skill in featured:
+                        triggers = ", ".join(skill.get("trigger_patterns", [])[:2]) or "no triggers"
+                        parts.append(
+                            f"- {skill['id']} — {skill['mode']}/{skill['execution_level']} — triggers: {triggers}"
+                        )
+            except Exception:
+                pass
+        if learning_count > 0:
+            parts.append(f"{learning_count} high-priority learnings — use `nexo_guard_check` before editing code")
+        if parts:
+            return "TOOLBOX REMINDER:\n  " + "\n  ".join(parts)
+    except Exception:
+        pass
+    return ""
+
+
 def handle_stop(sid: str) -> str:
     """Cleanly close a session, removing it from active sessions immediately."""
     _stop_keepalive(sid)

package/src/user_context.py

@@ -0,0 +1,46 @@
+"""User context singleton — loads operator/user identity from calibration.json."""
+from __future__ import annotations
+import json
+import os
+from pathlib import Path
+
+_ctx = None
+
+class UserContext:
+    """Cached user/operator identity loaded once from calibration.json."""
+
+    def __init__(self):
+        nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+        cal_path = nexo_home / "brain" / "calibration.json"
+        ver_path = nexo_home / "version.json"
+
+        self.assistant_name = "NEXO"
+        self.user_name = ""
+        self.user_language = "en"
+
+        # calibration.json has operator_name + user info
+        if cal_path.exists():
+            try:
+                cal = json.loads(cal_path.read_text())
+                self.assistant_name = cal.get("operator_name", "") or \
+                    cal.get("user", {}).get("assistant_name", "") or "NEXO"
+                self.user_name = cal.get("user", {}).get("name", "")
+                self.user_language = cal.get("user", {}).get("language", "en")
+            except Exception:
+                pass
+
+        # Fallback: version.json also has operator_name
+        if self.assistant_name == "NEXO" and ver_path.exists():
+            try:
+                ver = json.loads(ver_path.read_text())
+                self.assistant_name = ver.get("operator_name", "") or "NEXO"
+            except Exception:
+                pass
+
+
+def get_context() -> UserContext:
+    """Get or create the singleton UserContext."""
+    global _ctx
+    if _ctx is None:
+        _ctx = UserContext()
+    return _ctx

package/templates/nexo_helper.py

@@ -0,0 +1,45 @@
+"""NEXO Helper — vendorable utility for personal scripts.
+
+Provides stable access to NEXO MCP tools via the CLI.
+Copy this file next to your script or keep it in NEXO_HOME/templates/.
+
+This module does NOT import any NEXO internals (db, server, cognitive).
+All communication goes through the stable `nexo scripts call` CLI.
+"""
+from __future__ import annotations
+
+import json
+import subprocess
+
+
+def run_nexo(args: list[str]) -> str:
+    """Run a nexo CLI command and return stdout.
+
+    Raises RuntimeError on non-zero exit.
+    """
+    result = subprocess.run(
+        ["nexo", *args],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(result.stderr.strip() or result.stdout.strip() or f"nexo exited {result.returncode}")
+    return result.stdout
+
+
+def call_tool(name: str, payload: dict | None = None) -> str:
+    """Call a NEXO MCP tool by name. Returns raw text output."""
+    args = ["scripts", "call", name, "--input", json.dumps(payload or {})]
+    return run_nexo(args)
+
+
+def call_tool_text(name: str, payload: dict | None = None) -> str:
+    """Call a NEXO MCP tool and return text output."""
+    return call_tool(name, payload)
+
+
+def call_tool_json(name: str, payload: dict | None = None) -> dict:
+    """Call a NEXO MCP tool and return parsed JSON output."""
+    args = ["scripts", "call", name, "--input", json.dumps(payload or {}), "--json-output"]
+    out = run_nexo(args)
+    return json.loads(out)

package/templates/script-template.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+# nexo: name=example-script
+# nexo: description=Example personal script using the stable NEXO CLI
+# nexo: runtime=python
+# nexo: timeout=60
+# nexo: tools=nexo_learning_search,nexo_schedule_status
+
+"""Example personal script for NEXO.
+
+This template demonstrates:
+- Inline metadata for auto-discovery
+- Safe CLI calls through nexo_helper
+- Timeout handling (via metadata)
+- argparse for user arguments
+- No direct DB access
+- Clean exit codes
+"""
+
+import argparse
+import sys
+
+# nexo_helper.py is in NEXO_HOME/templates/ — copy it next to your script
+# or add the templates dir to your path
+try:
+    from nexo_helper import call_tool_text
+except ImportError:
+    import os
+    sys.path.insert(0, os.path.join(os.environ.get("NEXO_HOME", "~/.nexo"), "templates"))
+    from nexo_helper import call_tool_text
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Example NEXO personal script")
+    parser.add_argument("--query", default="cron", help="Search query for learnings")
+    args = parser.parse_args()
+
+    print(f"Searching learnings for: {args.query}")
+    result = call_tool_text("nexo_learning_search", {"query": args.query})
+    print(result)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/templates/skill-script-template.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""Skill script template.
+
+This script is meant to be referenced by a Skill v2 definition.
+It should use the stable NEXO CLI rather than importing internal DB modules.
+"""
+
+import argparse
+import os
+import subprocess
+import sys
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--query", default="")
+    args = parser.parse_args()
+
+    nexo_code = os.environ.get("NEXO_CODE", "")
+    if not nexo_code:
+        print("NEXO_CODE not set", file=sys.stderr)
+        return 1
+
+    cli_py = os.path.join(nexo_code, "cli.py")
+    cmd = [
+        sys.executable,
+        cli_py,
+        "scripts",
+        "call",
+        "nexo_learning_search",
+        "--input",
+        '{"query": %r}' % args.query,
+    ]
+    result = subprocess.run(cmd, text=True)
+    return result.returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/templates/skill-template.md

@@ -0,0 +1,33 @@
+# Skill Template
+
+Create a directory under one of:
+- `NEXO_HOME/skills/<slug>/`
+- `src/skills/<slug>/`
+- `community/skills/<slug>/`
+
+Required files:
+- `skill.json`
+- `guide.md`
+
+Optional:
+- `script.py` or `script.sh`
+
+Example `skill.json`:
+
+```json
+{
+  "id": "SK-EXAMPLE",
+  "name": "Example Skill",
+  "description": "What this skill does.",
+  "level": "draft",
+  "mode": "guide",
+  "source_kind": "personal",
+  "execution_level": "none",
+  "approval_required": false,
+  "tags": ["example"],
+  "trigger_patterns": ["example task"],
+  "params_schema": {},
+  "command_template": {},
+  "stable_after_uses": 10
+}
+```