nexo-brain 2.4.0 → 2.5.0

package/src/auto_update.py

@@ -94,6 +94,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 +457,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 +637,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
@@ -796,6 +853,99 @@ def auto_update_check() -> dict:
     except Exception as e:
         _log(f"scripts backfill error: {e}")
 
+    # 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()