nexo-brain 2.4.0 → 2.5.1

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "nexo-brain",
-  "version": "2.4.0",
+  "version": "2.5.1",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO — Cognitive co-operator for Claude Code. Memory, emotional intelligence, overnight learning (Deep Sleep), cron management, trust scoring, and adaptive calibration.",
   "bin": {
-    "nexo-brain": "./bin/nexo-brain.js"
+    "nexo-brain": "./bin/nexo-brain.js",
+    "nexo": "./bin/nexo.js"
   },
   "keywords": [
     "claude-code",
@@ -38,7 +39,12 @@
     "cron-manifest",
     "session-tone",
     "mood-tracking",
-    "productivity-analysis"
+    "productivity-analysis",
+    "runtime-cli",
+    "doctor",
+    "executable-skills",
+    "day-orchestrator",
+    "work-continuity"
   ],
   "author": "NEXO Brain <info@nexo-brain.com>",
   "license": "AGPL-3.0",
@@ -54,8 +60,10 @@
   },
   "files": [
     "bin/nexo-brain.js",
+    "bin/nexo.js",
     "bin/postinstall.js",
     "src/",
+    "community/",
     "!src/**/__pycache__",
     "!src/**/*.pyc",
     "!src/**/*.pyo",

package/src/auto_update.py

@@ -8,6 +8,7 @@ This is separate from plugins/update.py which handles MANUAL updates with rollba
 """
 
 import json
+import hashlib
 import os
 import re
 import subprocess
@@ -56,6 +57,30 @@ def _write_last_check(data: dict):
         _log(f"Failed to write last-check file: {e}")
 
 
+def _sync_watchdog_hash_registry():
+    """Keep the immutable-hash registry aligned with the installed watchdog script."""
+    try:
+        watchdog_file = NEXO_HOME / "scripts" / "nexo-watchdog.sh"
+        if not watchdog_file.exists():
+            return
+        registry_file = NEXO_HOME / "scripts" / ".watchdog-hashes"
+        entries: dict[str, str] = {}
+        if registry_file.exists():
+            for line in registry_file.read_text().splitlines():
+                if "|" not in line:
+                    continue
+                filepath, expected = line.split("|", 1)
+                if filepath:
+                    entries[filepath] = expected
+        actual_hash = hashlib.sha256(watchdog_file.read_bytes()).hexdigest()
+        entries[str(watchdog_file)] = actual_hash
+        registry_file.write_text(
+            "\n".join(f"{filepath}|{digest}" for filepath, digest in sorted(entries.items())) + "\n"
+        )
+    except Exception as e:
+        _log(f"watchdog hash registry sync error: {e}")
+
+
 def _is_git_repo() -> bool:
     """Check if REPO_DIR is inside a git repository."""
     try:
@@ -94,6 +119,61 @@ def _read_package_version() -> str:
     return "unknown"
 
 
+def _runtime_cli_wrapper_text() -> str:
+    return (
+        "#!/usr/bin/env bash\n"
+        "set -euo pipefail\n\n"
+        f'NEXO_HOME="{NEXO_HOME}"\n'
+        'PYTHON="$NEXO_HOME/.venv/bin/python3"\n'
+        'if [ ! -x "$PYTHON" ]; then\n'
+        '  if command -v python3 >/dev/null 2>&1; then\n'
+        '    PYTHON="python3"\n'
+        "  else\n"
+        '    PYTHON="python"\n'
+        "  fi\n"
+        "fi\n"
+        'export NEXO_HOME\n'
+        'export NEXO_CODE="$NEXO_HOME"\n'
+        'exec "$PYTHON" "$NEXO_HOME/cli.py" "$@"\n'
+    )
+
+
+def _shell_rc_files() -> list[Path]:
+    shell = os.environ.get("SHELL", "/bin/bash")
+    home_dir = Path.home()
+    if "zsh" in shell:
+        return [home_dir / ".zshrc"]
+    return [home_dir / ".bash_profile", home_dir / ".bashrc"]
+
+
+def _ensure_runtime_cli_in_shell():
+    path_line = f'export PATH="{NEXO_HOME / "bin"}:$PATH"'
+    comment = "# NEXO runtime CLI"
+    for rc_file in _shell_rc_files():
+        try:
+            content = rc_file.read_text() if rc_file.exists() else ""
+            if path_line not in content:
+                with rc_file.open("a") as fh:
+                    fh.write(f"\n{comment}\n{path_line}\n")
+                _log(f"Backfilled runtime CLI PATH in {rc_file.name}")
+        except Exception as e:
+            _log(f"Shell PATH backfill error for {rc_file.name}: {e}")
+
+
+def _ensure_runtime_cli_wrapper():
+    try:
+        bin_dir = NEXO_HOME / "bin"
+        bin_dir.mkdir(parents=True, exist_ok=True)
+        wrapper = bin_dir / "nexo"
+        content = _runtime_cli_wrapper_text()
+        if not wrapper.exists() or wrapper.read_text() != content:
+            wrapper.write_text(content)
+            wrapper.chmod(0o755)
+            _log("Backfilled runtime CLI wrapper")
+    except Exception as e:
+        _log(f"Runtime CLI wrapper backfill error: {e}")
+
+
 # ── Hook sync ────────────────────────────────────────────────────────
 
 def _requirements_hash() -> str:
@@ -402,7 +482,12 @@ def _check_npm_version() -> str | None:
         if not latest:
             return None
         if latest != current and not current.endswith(latest):
-            return f"NEXO update available: {current} -> {latest}. Run: npm update -g {pkg_name}"
+            try:
+                from user_context import get_context
+                _name = get_context().assistant_name
+            except Exception:
+                _name = "NEXO"
+            return f"{_name} update available: {current} -> {latest}. Run: npm update -g {pkg_name}"
     except Exception:
         pass
     return None
@@ -577,15 +662,12 @@ def _find_user_claude_md() -> Path | None:
 
 def _resolve_placeholders(template_text: str) -> str:
     """Fill {{NAME}} and {{NEXO_HOME}} from the user's existing CLAUDE.md or config."""
-    # Try to read operator name from version.json
-    name = "NEXO"
+    # Read operator name from calibration/version
     try:
-        vf = NEXO_HOME / "version.json"
-        if vf.exists():
-            data = json.loads(vf.read_text())
-            name = data.get("operator_name", name)
+        from user_context import get_context
+        name = get_context().assistant_name
     except Exception:
-        pass
+        name = "NEXO"
 
     return (
         template_text
@@ -754,13 +836,14 @@ def auto_update_check() -> dict:
     # Backfill evolution-objective.json for existing installs
     try:
         evo_obj_path = NEXO_HOME / "brain" / "evolution-objective.json"
+        from evolution_cycle import normalize_objective
         if not evo_obj_path.exists():
             (NEXO_HOME / "brain").mkdir(parents=True, exist_ok=True)
             default_objective = {
                 "objective": "Improve operational excellence and reduce repeated errors",
                 "focus_areas": ["error_prevention", "proactivity", "memory_quality"],
                 "evolution_enabled": True,
-                "evolution_mode": "review",
+                "evolution_mode": "auto",
                 "dimensions": {
                     "episodic_memory": {"current": 0, "target": 90},
                     "autonomy": {"current": 0, "target": 80},
@@ -774,6 +857,12 @@ def auto_update_check() -> dict:
             }
             evo_obj_path.write_text(json.dumps(default_objective, indent=2))
             _log("Backfilled evolution-objective.json for existing install")
+        else:
+            raw_objective = json.loads(evo_obj_path.read_text())
+            normalized = normalize_objective(raw_objective)
+            if normalized != raw_objective:
+                evo_obj_path.write_text(json.dumps(normalized, indent=2, ensure_ascii=False))
+                _log("Normalized legacy evolution-objective.json")
     except Exception as e:
         _log(f"evolution-objective.json backfill error: {e}")
 
@@ -796,6 +885,101 @@ def auto_update_check() -> dict:
     except Exception as e:
         _log(f"scripts backfill error: {e}")
 
+    _sync_watchdog_hash_registry()
+
+    # Backfill runtime CLI modules for existing installs
+    try:
+        for fname in ("cli.py", "script_registry.py", "skills_runtime.py"):
+            src_file = SRC_DIR / fname
+            dest_file = NEXO_HOME / fname
+            if src_file.is_file() and (not dest_file.exists() or src_file.stat().st_mtime > dest_file.stat().st_mtime):
+                import shutil
+                shutil.copy2(str(src_file), str(dest_file))
+                _log(f"Backfilled {fname}")
+    except Exception as e:
+        _log(f"CLI backfill error: {e}")
+
+    _ensure_runtime_cli_wrapper()
+    _ensure_runtime_cli_in_shell()
+
+    # Backfill doctor package for existing installs
+    try:
+        doctor_src = SRC_DIR / "doctor"
+        doctor_dest = NEXO_HOME / "doctor"
+        if doctor_src.is_dir():
+            import shutil
+            if not doctor_dest.is_dir():
+                shutil.copytree(str(doctor_src), str(doctor_dest), ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
+                _log("Backfilled doctor package")
+            else:
+                # Update existing files
+                for root, dirs, files in os.walk(str(doctor_src)):
+                    dirs[:] = [d for d in dirs if d != "__pycache__"]
+                    rel = os.path.relpath(root, str(doctor_src))
+                    dest_dir = doctor_dest / rel
+                    dest_dir.mkdir(parents=True, exist_ok=True)
+                    for f in files:
+                        if f.endswith(".pyc"):
+                            continue
+                        src_f = Path(root) / f
+                        dst_f = dest_dir / f
+                        if not dst_f.exists() or src_f.stat().st_mtime > dst_f.stat().st_mtime:
+                            shutil.copy2(str(src_f), str(dst_f))
+    except Exception as e:
+        _log(f"Doctor backfill error: {e}")
+
+    # Backfill packaged core skills to a dedicated directory.
+    try:
+        skills_src = SRC_DIR / "skills"
+        skills_dest = NEXO_HOME / "skills-core"
+        if skills_src.is_dir():
+            import shutil
+            if not skills_dest.is_dir():
+                shutil.copytree(str(skills_src), str(skills_dest), ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
+                _log("Backfilled skills-core")
+            else:
+                for root, dirs, files in os.walk(str(skills_src)):
+                    dirs[:] = [d for d in dirs if d != "__pycache__"]
+                    rel = os.path.relpath(root, str(skills_src))
+                    dest_dir = skills_dest / rel
+                    dest_dir.mkdir(parents=True, exist_ok=True)
+                    for f in files:
+                        if f.endswith(".pyc"):
+                            continue
+                        src_f = Path(root) / f
+                        dst_f = dest_dir / f
+                        if not dst_f.exists() or src_f.stat().st_mtime > dst_f.stat().st_mtime:
+                            shutil.copy2(str(src_f), str(dst_f))
+    except Exception as e:
+        _log(f"Skills backfill error: {e}")
+
+    # Backfill MCP doctor plugin so existing installs expose nexo_doctor.
+    try:
+        plugin_src = SRC_DIR / "plugins" / "doctor.py"
+        plugin_dest = NEXO_HOME / "plugins" / "doctor.py"
+        plugin_dest.parent.mkdir(parents=True, exist_ok=True)
+        if plugin_src.is_file() and (not plugin_dest.exists() or plugin_src.stat().st_mtime > plugin_dest.stat().st_mtime):
+            import shutil
+            shutil.copy2(str(plugin_src), str(plugin_dest))
+            _log("Backfilled doctor plugin")
+    except Exception as e:
+        _log(f"Doctor plugin backfill error: {e}")
+
+    # Backfill script/skill templates for existing installs
+    try:
+        templates_src = REPO_DIR / "templates"
+        templates_dest = NEXO_HOME / "templates"
+        templates_dest.mkdir(parents=True, exist_ok=True)
+        for fname in ("script-template.py", "nexo_helper.py", "skill-template.md", "skill-script-template.py"):
+            src_file = templates_src / fname
+            dest_file = templates_dest / fname
+            if src_file.is_file() and (not dest_file.exists() or src_file.stat().st_mtime > dest_file.stat().st_mtime):
+                import shutil
+                shutil.copy2(str(src_file), str(dest_file))
+                _log(f"Backfilled template {fname}")
+    except Exception as e:
+        _log(f"Template backfill error: {e}")
+
     # CLAUDE.md version migration
     try:
         result["claude_md_update"] = _migrate_claude_md()