nexo-brain 2.5.0 → 2.6.0

package/src/cli.py

@@ -2,7 +2,16 @@
 """NEXO Runtime CLI — operational commands for scripts and diagnostics.
 
 Entry points:
+  nexo chat [PATH]
   nexo scripts list [--all] [--json]
+  nexo scripts create NAME [--runtime python|shell] [--description TEXT]
+  nexo scripts classify [--json]
+  nexo scripts sync [--json]
+  nexo scripts reconcile [--dry-run] [--json]
+  nexo scripts ensure-schedules [--dry-run] [--json]
+  nexo scripts schedules [--json]
+  nexo scripts unschedule NAME [--json]
+  nexo scripts remove NAME [--keep-file] [--json]
   nexo scripts run NAME_OR_PATH [-- args...]
   nexo scripts doctor [NAME_OR_PATH] [--json]
   nexo scripts call TOOL --input JSON [--json-output]
@@ -23,6 +32,7 @@ import contextlib
 import io
 import json
 import os
+import shutil
 import subprocess
 import sys
 from pathlib import Path
@@ -30,14 +40,39 @@ from pathlib import Path
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent)))
 
+
+def _get_version() -> str:
+    """Read version from runtime version.json or package.json automatically."""
+    json_candidates = [
+        (NEXO_HOME / "version.json", "version"),
+        (NEXO_CODE.parent / "version.json", "version"),
+        (NEXO_CODE.parent / "package.json", "version"),
+        (NEXO_HOME / "package.json", "version"),
+    ]
+    for candidate, key in json_candidates:
+        try:
+            if candidate.is_file():
+                return json.loads(candidate.read_text()).get(key, "?")
+        except Exception:
+            continue
+    return "?"
+
 # Ensure src/ is on path for imports
 if str(NEXO_CODE) not in sys.path:
     sys.path.insert(0, str(NEXO_CODE))
 
 
 def _scripts_list(args):
-    from script_registry import list_scripts
-    scripts = list_scripts(include_core=args.all)
+    from db import init_db, list_personal_scripts
+    from script_registry import list_scripts, sync_personal_scripts
+
+    init_db()
+    sync_personal_scripts()
+    if args.all:
+        scripts = list_scripts(include_core=True)
+    else:
+        scripts = list_personal_scripts()
+
     if args.json:
         print(json.dumps(scripts, indent=2))
     else:
@@ -49,13 +84,169 @@ def _scripts_list(args):
         rt_w = max(len(s["runtime"]) for s in scripts)
         for s in scripts:
             tag = " [core]" if s.get("core") else ""
-            print(f"  {s['name']:<{name_w}}  {s['runtime']:<{rt_w}}  {s['description']}{tag}")
+            schedule_tag = ""
+            if s.get("has_schedule"):
+                schedule_labels = [sch.get("schedule_label", "") for sch in s.get("schedules", []) if sch.get("schedule_label")]
+                if schedule_labels:
+                    schedule_tag = f" [{'; '.join(schedule_labels[:2])}]"
+            print(f"  {s['name']:<{name_w}}  {s['runtime']:<{rt_w}}  {s.get('description', '')}{schedule_tag}{tag}")
+    return 0
+
+
+def _scripts_sync(args):
+    from db import init_db
+    from script_registry import sync_personal_scripts
+
+    init_db()
+    result = sync_personal_scripts()
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        print(
+            f"Synced personal scripts: {result['scripts_upserted']} script(s), "
+            f"{result['schedules_upserted']} schedule(s), "
+            f"{result['scripts_pruned']} script(s) pruned, "
+            f"{result['schedules_pruned']} schedule(s) pruned."
+        )
     return 0
 
 
+def _scripts_classify(args):
+    from script_registry import classify_scripts_dir
+
+    report = classify_scripts_dir()
+    if args.json:
+        print(json.dumps(report, indent=2, ensure_ascii=False))
+        return 0
+
+    entries = report.get("entries", [])
+    if not entries:
+        print("No scripts directory found:", report.get("scripts_dir", NEXO_HOME / "scripts"))
+        return 0
+
+    path_w = max(len(Path(entry["path"]).name) for entry in entries)
+    for entry in entries:
+        reason = f" — {entry['reason']}" if entry.get("reason") else ""
+        print(f"  {Path(entry['path']).name:<{path_w}}  {entry['classification']}{reason}")
+    return 0
+
+
+def _scripts_reconcile(args):
+    from script_registry import reconcile_personal_scripts
+
+    result = reconcile_personal_scripts(dry_run=args.dry_run)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        sync = result.get("sync", {})
+        ensured = result.get("ensure_schedules", {})
+        print(
+            f"Reconciled personal scripts: {sync.get('registered_scripts', 0)} registered, "
+            f"{len(ensured.get('created', []))} schedule(s) created, "
+            f"{len(ensured.get('repaired', []))} repaired, "
+            f"{len(ensured.get('invalid', []))} invalid."
+        )
+        if args.dry_run:
+            print("  Dry run only — no schedules changed.")
+    return 0 if not result.get("ensure_schedules", {}).get("invalid") else 1
+
+
+def _scripts_ensure_schedules(args):
+    from script_registry import ensure_personal_schedules
+
+    result = ensure_personal_schedules(dry_run=args.dry_run)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        print(
+            f"Ensured schedules: {len(result.get('created', []))} created, "
+            f"{len(result.get('repaired', []))} repaired, "
+            f"{len(result.get('already_present', []))} already present, "
+            f"{len(result.get('invalid', []))} invalid."
+        )
+        if args.dry_run:
+            print("  Dry run only — no schedules changed.")
+    return 0 if not result.get("invalid") else 1
+
+
+def _scripts_create(args):
+    from script_registry import create_script
+
+    try:
+        result = create_script(
+            args.name,
+            description=args.description,
+            runtime=args.runtime,
+            force=args.force,
+        )
+    except FileExistsError as e:
+        print(str(e), file=sys.stderr)
+        return 1
+
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        print(f"Created personal script: {result['path']}")
+    return 0
+
+
+def _scripts_schedules(args):
+    from db import init_db, list_personal_script_schedules
+    from script_registry import sync_personal_scripts
+
+    init_db()
+    sync_personal_scripts()
+    schedules = list_personal_script_schedules()
+    if args.json:
+        print(json.dumps(schedules, indent=2, ensure_ascii=False))
+        return 0
+
+    if not schedules:
+        print("No personal script schedules registered.")
+        return 0
+
+    cron_w = max(len(s["cron_id"]) for s in schedules)
+    for schedule in schedules:
+        label = schedule.get("schedule_label") or schedule.get("schedule_value") or schedule.get("schedule_type")
+        print(f"  {schedule['cron_id']:<{cron_w}}  {label}")
+    return 0
+
+
+def _scripts_unschedule(args):
+    from script_registry import unschedule_personal_script
+
+    result = unschedule_personal_script(args.name)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        if not result.get("ok"):
+            print(result.get("error", "Failed to unschedule script"), file=sys.stderr)
+            return 1
+        print(f"Removed {len(result.get('removed_schedules', []))} schedule(s) from {result['script']}")
+    return 0 if result.get("ok") else 1
+
+
+def _scripts_remove(args):
+    from script_registry import remove_personal_script
+
+    result = remove_personal_script(args.name, keep_file=args.keep_file)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        if not result.get("ok"):
+            print(result.get("error", "Failed to remove script"), file=sys.stderr)
+            return 1
+        action = "unregistered" if args.keep_file else "removed"
+        print(f"Script {result['script']} {action}")
+    return 0 if result.get("ok") else 1
+
+
 def _scripts_run(args):
-    from script_registry import resolve_script_reference
+    from db import init_db, record_personal_script_run
+    from script_registry import resolve_script_reference, sync_personal_scripts
 
+    init_db()
+    sync_personal_scripts()
     info = resolve_script_reference(args.name)
     if not info:
         print(f"Script not found: {args.name}", file=sys.stderr)
@@ -95,23 +286,37 @@ def _scripts_run(args):
         cmd = [sys.executable, str(path)] + args.script_args
     elif runtime == "shell":
         cmd = ["bash", str(path)] + args.script_args
+    elif runtime == "node":
+        cmd = ["node", str(path)] + args.script_args
+    elif runtime == "php":
+        cmd = ["php", str(path)] + args.script_args
     else:
         # Try to execute directly
         cmd = [str(path)] + args.script_args
 
     try:
         result = subprocess.run(cmd, env=env, timeout=timeout)
+        if not is_core:
+            record_personal_script_run(str(path), result.returncode)
         return result.returncode
     except subprocess.TimeoutExpired:
+        if not is_core:
+            record_personal_script_run(str(path), 124)
         print(f"Script timed out after {timeout}s", file=sys.stderr)
         return 124
     except Exception as e:
+        if not is_core:
+            record_personal_script_run(str(path), 1)
         print(f"Error running script: {e}", file=sys.stderr)
         return 1
 
 
 def _scripts_doctor(args):
-    from script_registry import doctor_script, doctor_all_scripts
+    from db import init_db
+    from script_registry import doctor_script, doctor_all_scripts, sync_personal_scripts
+
+    init_db()
+    sync_personal_scripts()
 
     if args.name:
         results = [doctor_script(args.name)]
@@ -238,13 +443,90 @@ def _scripts_call(args):
 
 
 def _update(args):
-    """Sync all repo files to NEXO_HOME."""
+    """Update the installed runtime.
+
+    Modes:
+    - Dev-linked runtime: sync from the source repo recorded in version.json
+    - Explicit dev env: sync from NEXO_CODE/src
+    - Packaged/runtime-only install: delegate to plugins.update handle_update()
+    """
     import shutil
 
-    src_dir = NEXO_CODE
-    repo_dir = NEXO_CODE.parent
     dest = NEXO_HOME
 
+    def _runtime_version_source() -> Path | None:
+        version_file = NEXO_HOME / "version.json"
+        if not version_file.is_file():
+            return None
+        try:
+            data = json.loads(version_file.read_text())
+        except Exception:
+            return None
+        source = str(data.get("source", "")).strip()
+        if not source:
+            return None
+        candidate = Path(source).expanduser()
+        if (candidate / "src").is_dir() and (candidate / "package.json").is_file():
+            return candidate
+        return None
+
+    def _resolve_sync_source() -> tuple[Path | None, Path | None]:
+        try:
+            same_as_runtime = NEXO_CODE.resolve() == dest.resolve()
+        except Exception:
+            same_as_runtime = NEXO_CODE == dest
+
+        # Explicit dev mode: NEXO_CODE points at repo/src, never the installed runtime itself.
+        if (
+            not same_as_runtime
+            and (NEXO_CODE / "db").is_dir()
+            and (NEXO_CODE.parent / "package.json").is_file()
+        ):
+            return NEXO_CODE, NEXO_CODE.parent
+
+        # Installed runtime linked back to a source checkout
+        version_source = _runtime_version_source()
+        if version_source:
+            return version_source / "src", version_source
+
+        return None, None
+
+    src_dir, repo_dir = _resolve_sync_source()
+
+    if src_dir is not None:
+        try:
+            if src_dir.resolve() == dest.resolve():
+                version_source = _runtime_version_source()
+                if version_source:
+                    src_dir = version_source / "src"
+                    repo_dir = version_source
+                else:
+                    src_dir = None
+                    repo_dir = None
+        except Exception:
+            pass
+
+    if src_dir is None or repo_dir is None:
+        try:
+            from plugins.update import handle_update
+        except Exception as e:
+            print(
+                "No source repo recorded for this runtime and packaged updater is unavailable: "
+                f"{e}",
+                file=sys.stderr,
+            )
+            return 1
+
+        result = handle_update()
+        if args.json:
+            print(json.dumps({
+                "mode": "packaged",
+                "message": result,
+            }, indent=2, ensure_ascii=False))
+        else:
+            print(result)
+        return 0 if "UPDATE SUCCESSFUL" in result or "Already up to date" in result else 1
+
     # Packages (directories with __init__.py or known structure)
     packages = ["db", "cognitive", "doctor", "dashboard", "rules", "crons", "hooks"]
     copied_packages = 0
@@ -269,6 +551,7 @@ def _update(args):
         "tools_reminders.py", "tools_reminders_crud.py", "tools_learnings.py",
         "tools_credentials.py", "tools_task_history.py", "tools_menu.py",
         "cli.py", "script_registry.py", "skills_runtime.py", "user_context.py",
+        "cron_recovery.py",
         "requirements.txt",
     ]
     copied_files = 0
@@ -291,6 +574,7 @@ def _update(args):
     scripts_src = src_dir / "scripts"
     scripts_dest = dest / "scripts"
     if scripts_src.is_dir():
+        scripts_dest.mkdir(parents=True, exist_ok=True)
         for f in scripts_src.iterdir():
             if f.name == "__pycache__" or f.name.startswith("."):
                 continue
@@ -313,6 +597,20 @@ def _update(args):
             if f.is_file():
                 shutil.copy2(str(f), str(templates_dest / f.name))
 
+    # Runtime version metadata
+    package_json = repo_dir / "package.json"
+    if package_json.is_file():
+        shutil.copy2(str(package_json), str(dest / "package.json"))
+        try:
+            pkg = json.loads(package_json.read_text())
+            version_payload = {
+                "version": pkg.get("version", "?"),
+                "source": str(repo_dir),
+            }
+            (dest / "version.json").write_text(json.dumps(version_payload, indent=2))
+        except Exception:
+            pass
+
     # Core skills
     skills_src = src_dir / "skills"
     skills_dest = dest / "skills-core"
@@ -343,7 +641,17 @@ def _update(args):
     wrapper.write_text(wrapper_content)
     wrapper.chmod(0o755)
 
+    try:
+        from db import init_db
+        from script_registry import sync_personal_scripts
+
+        init_db()
+        sync_personal_scripts()
+    except Exception:
+        pass
+
     result = {
+        "mode": "sync",
         "packages": copied_packages,
         "files": copied_files,
         "nexo_home": str(dest),
@@ -357,6 +665,81 @@ def _update(args):
     return 0
 
 
+def _service_control(service_name: str, action: str) -> int:
+    """Control a LaunchAgent/systemd service: on, off, status."""
+    import platform as plat
+
+    label = f"com.nexo.{service_name}"
+
+    if plat.system() != "Darwin":
+        print(f"Service control only supported on macOS for now.", file=sys.stderr)
+        return 1
+
+    plist_path = Path.home() / "Library" / "LaunchAgents" / f"{label}.plist"
+    uid = os.getuid()
+
+    if action == "status":
+        result = subprocess.run(
+            ["launchctl", "list"],
+            capture_output=True, text=True,
+        )
+        running = label in (result.stdout or "")
+        if running:
+            print(f"{service_name}: running")
+        else:
+            print(f"{service_name}: stopped")
+        return 0
+
+    if action == "on":
+        if not plist_path.is_file():
+            print(f"LaunchAgent not found: {plist_path}", file=sys.stderr)
+            print(f"Run 'nexo-brain' to install it, or enable it during setup.", file=sys.stderr)
+            return 1
+        subprocess.run(
+            ["launchctl", "bootout", f"gui/{uid}", str(plist_path)],
+            capture_output=True,
+        )
+        result = subprocess.run(
+            ["launchctl", "bootstrap", f"gui/{uid}", str(plist_path)],
+            capture_output=True, text=True,
+        )
+        if result.returncode == 0:
+            print(f"{service_name}: started")
+        else:
+            print(f"Failed to start {service_name}: {result.stderr.strip()}", file=sys.stderr)
+            return 1
+        return 0
+
+    if action == "off":
+        result = subprocess.run(
+            ["launchctl", "bootout", f"gui/{uid}", str(plist_path)],
+            capture_output=True, text=True,
+        )
+        print(f"{service_name}: stopped")
+        return 0
+
+    print(f"Unknown action: {action}. Use on, off, or status.", file=sys.stderr)
+    return 1
+
+
+def _dashboard(args):
+    return _service_control("dashboard", args.action)
+
+
+def _chat(args):
+    target = args.path or "."
+    claude_bin = os.environ.get("CLAUDE_BIN") or shutil.which("claude")
+    if not claude_bin:
+        print("Claude Code launcher not found in PATH. Install `claude` first.", file=sys.stderr)
+        return 1
+
+    result = subprocess.run(
+        [claude_bin, "--dangerously-skip-permissions", target],
+        env=os.environ.copy(),
+    )
+    return int(result.returncode)
+
+
 def _doctor(args):
     """Run unified doctor diagnostics."""
     try:
@@ -482,10 +865,34 @@ def _skills_evolution(args):
     return 0
 
 
+def _print_help():
+    v = _get_version()
+    print(f"""NEXO Runtime CLI v{v}
+
+Commands:
+  nexo chat [path]                                    Launch Claude Code
+  nexo doctor [--tier boot|runtime|deep|all] [--fix]   System diagnostics
+  nexo scripts list|create|classify|sync|reconcile|ensure-schedules|schedules|run|doctor|call|unschedule|remove
+                                                      Personal scripts
+  nexo skills list|apply|sync|approve                  Executable skills
+  nexo update                                          Update installed runtime
+  nexo dashboard on|off|status                         Web dashboard control
+
+Run 'nexo <command> --help' for details.
+Homepage: https://nexo-brain.com
+GitHub:   https://github.com/wazionapps/nexo""")
+
+
 def main():
-    parser = argparse.ArgumentParser(prog="nexo", description="NEXO Runtime CLI")
+    parser = argparse.ArgumentParser(prog="nexo", description="NEXO Runtime CLI", add_help=False)
+    parser.add_argument("-h", "--help", action="store_true", help="Show help")
+    parser.add_argument("-v", "--version", action="store_true", help="Show version")
     sub = parser.add_subparsers(dest="command")
 
+    # -- chat --
+    chat_parser = sub.add_parser("chat", help="Launch Claude Code")
+    chat_parser.add_argument("path", nargs="?", default=".", help="Working directory (default: current directory)")
+
     # -- scripts --
     scripts_parser = sub.add_parser("scripts", help="Manage personal scripts")
     scripts_sub = scripts_parser.add_subparsers(dest="scripts_command")
@@ -495,6 +902,47 @@ def main():
     list_p.add_argument("--all", action="store_true", help="Include core/internal scripts")
     list_p.add_argument("--json", action="store_true", help="JSON output")
 
+    # scripts create
+    create_p = scripts_sub.add_parser("create", help="Create a personal script scaffold")
+    create_p.add_argument("name", help="Human/script name")
+    create_p.add_argument("--description", default="", help="One-line description")
+    create_p.add_argument("--runtime", default="python", choices=["python", "shell"], help="Script runtime")
+    create_p.add_argument("--force", action="store_true", help="Overwrite if the target file exists")
+    create_p.add_argument("--json", action="store_true", help="JSON output")
+
+    # scripts classify
+    classify_p = scripts_sub.add_parser("classify", help="Classify all files in NEXO_HOME/scripts")
+    classify_p.add_argument("--json", action="store_true", help="JSON output")
+
+    # scripts sync
+    sync_p = scripts_sub.add_parser("sync", help="Sync script registry from filesystem and personal LaunchAgents")
+    sync_p.add_argument("--json", action="store_true", help="JSON output")
+
+    # scripts reconcile
+    reconcile_p = scripts_sub.add_parser("reconcile", help="Classify, sync, and ensure declared schedules")
+    reconcile_p.add_argument("--dry-run", action="store_true", help="Show what would change without editing schedules")
+    reconcile_p.add_argument("--json", action="store_true", help="JSON output")
+
+    # scripts ensure-schedules
+    ensure_p = scripts_sub.add_parser("ensure-schedules", help="Create or repair declared personal schedules")
+    ensure_p.add_argument("--dry-run", action="store_true", help="Show what would change without editing schedules")
+    ensure_p.add_argument("--json", action="store_true", help="JSON output")
+
+    # scripts schedules
+    schedules_p = scripts_sub.add_parser("schedules", help="List registered personal script schedules")
+    schedules_p.add_argument("--json", action="store_true", help="JSON output")
+
+    # scripts unschedule
+    unschedule_p = scripts_sub.add_parser("unschedule", help="Remove all personal schedules from a script")
+    unschedule_p.add_argument("name", help="Script name or path")
+    unschedule_p.add_argument("--json", action="store_true", help="JSON output")
+
+    # scripts remove
+    remove_p = scripts_sub.add_parser("remove", help="Remove a personal script and any attached schedules")
+    remove_p.add_argument("name", help="Script name or path")
+    remove_p.add_argument("--keep-file", action="store_true", help="Keep the script file and only unregister/unschedule it")
+    remove_p.add_argument("--json", action="store_true", help="JSON output")
+
     # scripts run
     run_p = scripts_sub.add_parser("run", help="Run a script by name")
     run_p.add_argument("name", help="Script name")
@@ -512,7 +960,7 @@ def main():
     call_p.add_argument("--json-output", action="store_true", help="Force JSON output")
 
     # -- update --
-    update_parser = sub.add_parser("update", help="Sync all repo files to NEXO_HOME")
+    update_parser = sub.add_parser("update", help="Update installed runtime")
     update_parser.add_argument("--json", action="store_true", help="JSON output")
 
     # -- doctor --
@@ -560,11 +1008,38 @@ def main():
     skills_evolution_p = skills_sub.add_parser("evolution", help="Evolution candidates")
     skills_evolution_p.add_argument("--json", action="store_true", help="JSON output")
 
+    # -- dashboard --
+    dashboard_parser = sub.add_parser("dashboard", help="Web dashboard control")
+    dashboard_parser.add_argument("action", choices=["on", "off", "status"], help="Start, stop, or check dashboard")
+
     args = parser.parse_args()
 
+    if args.help or (not args.command and not args.version):
+        _print_help()
+        return 0
+    if args.version:
+        print(f"nexo v{_get_version()}")
+        return 0
+
     if args.command == "scripts":
         if args.scripts_command == "list":
             return _scripts_list(args)
+        elif args.scripts_command == "create":
+            return _scripts_create(args)
+        elif args.scripts_command == "classify":
+            return _scripts_classify(args)
+        elif args.scripts_command == "sync":
+            return _scripts_sync(args)
+        elif args.scripts_command == "reconcile":
+            return _scripts_reconcile(args)
+        elif args.scripts_command == "ensure-schedules":
+            return _scripts_ensure_schedules(args)
+        elif args.scripts_command == "schedules":
+            return _scripts_schedules(args)
+        elif args.scripts_command == "unschedule":
+            return _scripts_unschedule(args)
+        elif args.scripts_command == "remove":
+            return _scripts_remove(args)
         elif args.scripts_command == "run":
             return _scripts_run(args)
         elif args.scripts_command == "doctor":
@@ -574,6 +1049,8 @@ def main():
         else:
             scripts_parser.print_help()
             return 0
+    elif args.command == "chat":
+        return _chat(args)
     elif args.command == "update":
         return _update(args)
     elif args.command == "doctor":
@@ -596,8 +1073,10 @@ def main():
         else:
             skills_parser.print_help()
             return 0
+    elif args.command == "dashboard":
+        return _dashboard(args)
     else:
-        parser.print_help()
+        _print_help()
         return 0