nexo-brain 2.5.1 → 2.6.1

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
@@ -32,11 +42,17 @@ NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent
 
 
 def _get_version() -> str:
-    """Read version from package.json automatically."""
-    for candidate in [NEXO_CODE.parent / "package.json", NEXO_HOME / "package.json"]:
+    """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("version", "?")
+                return json.loads(candidate.read_text()).get(key, "?")
         except Exception:
             continue
     return "?"
@@ -47,8 +63,16 @@ if str(NEXO_CODE) not in sys.path:
 
 
 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:
@@ -60,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)
@@ -106,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)]
@@ -249,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
@@ -280,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
@@ -302,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
@@ -324,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"
@@ -354,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),
@@ -429,8 +726,18 @@ def _dashboard(args):
     return _service_control("dashboard", args.action)
 
 
-def _orchestrator(args):
-    return _service_control("day-orchestrator", 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):
@@ -563,12 +870,13 @@ def _print_help():
     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|run|doctor|call                    Personal scripts
+  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                                          Sync repo to NEXO_HOME
+  nexo update                                          Update installed runtime
   nexo dashboard on|off|status                         Web dashboard control
-  nexo orchestrator on|off|status                      Autonomous mode control
 
 Run 'nexo <command> --help' for details.
 Homepage: https://nexo-brain.com
@@ -581,6 +889,10 @@ def main():
     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")
@@ -590,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")
@@ -607,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 --
@@ -659,10 +1012,6 @@ def main():
     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")
 
-    # -- orchestrator --
-    orchestrator_parser = sub.add_parser("orchestrator", help="Autonomous mode control")
-    orchestrator_parser.add_argument("action", choices=["on", "off", "status"], help="Start, stop, or check orchestrator")
-
     args = parser.parse_args()
 
     if args.help or (not args.command and not args.version):
@@ -675,6 +1024,22 @@ def main():
     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":
@@ -684,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":
@@ -708,8 +1075,6 @@ def main():
             return 0
     elif args.command == "dashboard":
         return _dashboard(args)
-    elif args.command == "orchestrator":
-        return _orchestrator(args)
     else:
         _print_help()
         return 0