nexo-brain 2.6.21 → 3.0.0

package/src/cli.py

@@ -41,6 +41,11 @@ 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)))
+TERMINAL_CLIENT_LABELS = {
+    "claude_code": "Claude Code",
+    "codex": "Codex",
+}
+TERMINAL_CLIENT_ORDER = ("claude_code", "codex")
 
 
 def _get_version() -> str:
@@ -844,8 +849,73 @@ def _dashboard(args):
     return _service_control("dashboard", args.action)
 
 
+def _terminal_client_label(client: str) -> str:
+    return TERMINAL_CLIENT_LABELS.get(client, client.replace("_", " ").title())
+
+
+def _ordered_available_terminal_clients(preferences: dict, detected: dict) -> list[str]:
+    enabled = preferences.get("interactive_clients", {})
+    last_used = str(preferences.get("last_terminal_client", "")).strip()
+    preferred = str(preferences.get("default_terminal_client", "")).strip()
+    ordered: list[str] = []
+
+    for client in (last_used, preferred, *TERMINAL_CLIENT_ORDER):
+        if client in TERMINAL_CLIENT_ORDER and client not in ordered:
+            ordered.append(client)
+
+    return [
+        client
+        for client in ordered
+        if enabled.get(client, False) and detected.get(client, {}).get("installed", False)
+    ]
+
+
+def _preferred_terminal_client_label(preferences: dict, clients: list[str]) -> str:
+    last_used = str(preferences.get("last_terminal_client", "")).strip()
+    if clients and clients[0] == last_used:
+        return "last choice"
+    return "default"
+
+
+def _prompt_for_terminal_client(
+    clients: list[str],
+    normalize_client_key,
+    *,
+    preferred_label: str = "default",
+) -> str | None:
+    if not clients:
+        return None
+    if len(clients) == 1:
+        return clients[0]
+
+    while True:
+        print("Select terminal client for this chat:")
+        for index, client in enumerate(clients, start=1):
+            suffix = f" [{preferred_label}]" if index == 1 else ""
+            print(f"  {index}. {_terminal_client_label(client)}{suffix}")
+
+        try:
+            response = input(f"Choose 1-{len(clients)} [1]: ").strip()
+        except EOFError:
+            return clients[0]
+
+        if not response:
+            return clients[0]
+        if response.isdigit():
+            choice = int(response)
+            if 1 <= choice <= len(clients):
+                return clients[choice - 1]
+
+        client_key = normalize_client_key(response)
+        if client_key in clients:
+            return client_key
+
+        print("Invalid choice. Try again.", file=sys.stderr)
+
+
 def _chat(args):
     target = args.path or "."
+    selected_client = getattr(args, "client", None)
 
     try:
         from auto_update import startup_preflight
@@ -867,20 +937,44 @@ def _chat(args):
         pass
 
     try:
+        from client_preferences import (
+            detect_installed_clients,
+            load_client_preferences,
+            normalize_client_key,
+            save_client_preferences,
+        )
         from agent_runner import TerminalClientUnavailableError, launch_interactive_client
     except ImportError:
         print("Agent runner module not found. Ensure NEXO is properly installed.", file=sys.stderr)
         return 1
 
+    if not selected_client:
+        try:
+            preferences = load_client_preferences()
+            detected = detect_installed_clients()
+            clients = _ordered_available_terminal_clients(preferences, detected)
+            selected_client = _prompt_for_terminal_client(
+                clients,
+                normalize_client_key,
+                preferred_label=_preferred_terminal_client_label(preferences, clients),
+            )
+        except Exception:
+            selected_client = None
+
     try:
         result = launch_interactive_client(
             target=target,
-            client=getattr(args, "client", None),
+            client=selected_client,
             env=os.environ.copy(),
         )
     except TerminalClientUnavailableError as exc:
         print(str(exc), file=sys.stderr)
         return 1
+    if result.returncode == 0 and selected_client:
+        try:
+            save_client_preferences(last_terminal_client=normalize_client_key(selected_client))
+        except Exception:
+            pass
     return int(result.returncode)
 
 
@@ -962,6 +1056,23 @@ def _skills_apply(args):
     return 0 if result.get("ok") else 1
 
 
+def _skills_test(args):
+    from skills_runtime import test_skill
+
+    try:
+        params = json.loads(args.params) if args.params else {}
+    except json.JSONDecodeError as e:
+        print(f"Invalid params JSON: {e}", file=sys.stderr)
+        return 1
+
+    result = test_skill(args.id, params=params, mode=args.mode, context=args.context)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0 if result.get("ok") else 1
+
+
 def _skills_sync(args):
     from skills_runtime import sync_skills
 
@@ -1009,12 +1120,68 @@ def _skills_evolution(args):
     return 0
 
 
+def _skills_promote(args):
+    from skills_runtime import promote_skill
+
+    result = promote_skill(args.id, target_level=args.target_level, reason=args.reason)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0 if result.get("ok") else 1
+
+
+def _skills_retire(args):
+    from skills_runtime import retire_skill
+
+    result = retire_skill(args.id, replacement_id=args.replacement_id, reason=args.reason)
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0 if result.get("ok") else 1
+
+
+def _skills_compose(args):
+    from skills_runtime import compose_skills
+
+    try:
+        component_ids = json.loads(args.component_ids) if args.component_ids.strip().startswith("[") else [
+            item.strip() for item in args.component_ids.split(",") if item.strip()
+        ]
+        tags = json.loads(args.tags) if args.tags.strip().startswith("[") else [
+            item.strip() for item in args.tags.split(",") if item.strip()
+        ]
+        trigger_patterns = json.loads(args.trigger_patterns) if args.trigger_patterns.strip().startswith("[") else [
+            item.strip() for item in args.trigger_patterns.split(",") if item.strip()
+        ]
+    except json.JSONDecodeError as e:
+        print(f"Invalid JSON: {e}", file=sys.stderr)
+        return 1
+
+    result = compose_skills(
+        new_skill_id=args.new_id,
+        name=args.name,
+        component_ids=component_ids,
+        description=args.description,
+        level=args.level,
+        mode=args.mode,
+        tags=tags,
+        trigger_patterns=trigger_patterns,
+    )
+    if args.json:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0 if result.get("ok") else 1
+
+
 def _print_help():
     v = _get_version()
     print(f"""NEXO Runtime CLI v{v}
 
 Commands:
-  nexo chat [path] [--client claude_code|codex]      Launch the selected terminal client
+  nexo chat [path] [--client claude_code|codex]      Launch a NEXO terminal client
   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
@@ -1036,12 +1203,12 @@ def main():
     sub = parser.add_subparsers(dest="command")
 
     # -- chat --
-    chat_parser = sub.add_parser("chat", help="Launch the selected terminal client")
+    chat_parser = sub.add_parser("chat", help="Launch a NEXO terminal client")
     chat_parser.add_argument("path", nargs="?", default=".", help="Working directory (default: current directory)")
     chat_parser.add_argument(
         "--client",
         choices=["claude_code", "codex"],
-        help="Override the configured default terminal client",
+        help="Override the chat picker and launch a specific terminal client",
     )
 
     # -- scripts --
@@ -1154,6 +1321,13 @@ def main():
     skills_apply_p.add_argument("--context", default="", help="Usage context for feedback loop")
     skills_apply_p.add_argument("--json", action="store_true", help="JSON output")
 
+    skills_test_p = skills_sub.add_parser("test", help="Dry-run test a skill")
+    skills_test_p.add_argument("id", help="Skill ID")
+    skills_test_p.add_argument("--params", default="{}", help="JSON parameters")
+    skills_test_p.add_argument("--mode", default="auto", choices=["auto", "guide", "execute", "hybrid"])
+    skills_test_p.add_argument("--context", default="", help="Testing context")
+    skills_test_p.add_argument("--json", action="store_true", help="JSON output")
+
     skills_sync_p = skills_sub.add_parser("sync", help="Sync filesystem skills")
     skills_sync_p.add_argument("--json", action="store_true", help="JSON output")
 
@@ -1170,6 +1344,29 @@ 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")
 
+    skills_promote_p = skills_sub.add_parser("promote", help="Promote a skill lifecycle level")
+    skills_promote_p.add_argument("id", help="Skill ID")
+    skills_promote_p.add_argument("--target-level", default="published", choices=["draft", "published", "stable"])
+    skills_promote_p.add_argument("--reason", default="", help="Why promote this skill")
+    skills_promote_p.add_argument("--json", action="store_true", help="JSON output")
+
+    skills_retire_p = skills_sub.add_parser("retire", help="Archive a skill")
+    skills_retire_p.add_argument("id", help="Skill ID")
+    skills_retire_p.add_argument("--replacement-id", default="", help="Optional replacement skill ID")
+    skills_retire_p.add_argument("--reason", default="", help="Why retire this skill")
+    skills_retire_p.add_argument("--json", action="store_true", help="JSON output")
+
+    skills_compose_p = skills_sub.add_parser("compose", help="Compose multiple skills into one")
+    skills_compose_p.add_argument("new_id", help="New skill ID")
+    skills_compose_p.add_argument("name", help="New skill name")
+    skills_compose_p.add_argument("--component-ids", required=True, help="JSON array or comma-separated skill IDs")
+    skills_compose_p.add_argument("--description", default="", help="Composite skill description")
+    skills_compose_p.add_argument("--level", default="draft", choices=["trace", "draft", "published", "stable"])
+    skills_compose_p.add_argument("--mode", default="guide", choices=["guide", "hybrid"])
+    skills_compose_p.add_argument("--tags", default="[]", help="JSON array or comma-separated tags")
+    skills_compose_p.add_argument("--trigger-patterns", default="[]", help="JSON array or comma-separated trigger patterns")
+    skills_compose_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")
@@ -1238,6 +1435,8 @@ def main():
             return _skills_get(args)
         elif args.skills_command == "apply":
             return _skills_apply(args)
+        elif args.skills_command == "test":
+            return _skills_test(args)
         elif args.skills_command == "sync":
             return _skills_sync(args)
         elif args.skills_command == "approve":
@@ -1246,6 +1445,12 @@ def main():
             return _skills_featured(args)
         elif args.skills_command == "evolution":
             return _skills_evolution(args)
+        elif args.skills_command == "promote":
+            return _skills_promote(args)
+        elif args.skills_command == "retire":
+            return _skills_retire(args)
+        elif args.skills_command == "compose":
+            return _skills_compose(args)
         else:
             skills_parser.print_help()
             return 0

package/src/client_preferences.py

@@ -30,6 +30,12 @@ AUTOMATION_BACKEND_KEYS = (
     CLIENT_CLAUDE_CODE,
     CLIENT_CODEX,
 )
+AUTOMATION_TASK_PROFILE_KEYS = (
+    "default",
+    "fast",
+    "balanced",
+    "deep",
+)
 INSTALL_PREFERENCE_KEYS = {
     "ask",
     "auto",
@@ -40,6 +46,10 @@ DEFAULT_CLAUDE_CODE_MODEL = "claude-opus-4-6[1m]"
 DEFAULT_CLAUDE_CODE_REASONING_EFFORT = ""
 DEFAULT_CODEX_MODEL = "gpt-5.4"
 DEFAULT_CODEX_REASONING_EFFORT = "xhigh"
+DEFAULT_FAST_MODEL = "gpt-5.4-mini"
+DEFAULT_FAST_REASONING_EFFORT = "medium"
+
+
 def _user_home() -> Path:
     return Path(os.environ.get("HOME", str(Path.home()))).expanduser()
 
@@ -73,9 +83,11 @@ def default_client_preferences() -> dict:
             CLIENT_CLAUDE_DESKTOP: False,
         },
         "default_terminal_client": CLIENT_CLAUDE_CODE,
+        "last_terminal_client": "",
         "automation_enabled": True,
         "automation_backend": CLIENT_CLAUDE_CODE,
         "client_runtime_profiles": default_client_runtime_profiles(),
+        "automation_task_profiles": default_automation_task_profiles(),
         "client_install_preferences": {
             CLIENT_CLAUDE_CODE: "ask",
             CLIENT_CODEX: "ask",
@@ -189,6 +201,14 @@ def normalize_default_terminal_client(value, interactive_clients: dict[str, bool
     return CLIENT_CLAUDE_CODE
 
 
+def normalize_last_terminal_client(value, interactive_clients: dict[str, bool] | None = None) -> str:
+    interactive_clients = normalize_interactive_clients(interactive_clients or {})
+    candidate = normalize_client_key(value)
+    if candidate in TERMINAL_CLIENT_KEYS and interactive_clients.get(candidate, False):
+        return candidate
+    return ""
+
+
 def normalize_automation_enabled(value) -> bool:
     return _coerce_bool(value, True)
 
@@ -228,6 +248,31 @@ def default_client_runtime_profiles() -> dict[str, dict[str, str]]:
     }
 
 
+def default_automation_task_profiles() -> dict[str, dict[str, str]]:
+    return {
+        "default": {
+            "backend": "",
+            "model": "",
+            "reasoning_effort": "",
+        },
+        "fast": {
+            "backend": CLIENT_CODEX,
+            "model": DEFAULT_FAST_MODEL,
+            "reasoning_effort": DEFAULT_FAST_REASONING_EFFORT,
+        },
+        "balanced": {
+            "backend": "",
+            "model": "",
+            "reasoning_effort": "",
+        },
+        "deep": {
+            "backend": CLIENT_CLAUDE_CODE,
+            "model": DEFAULT_CLAUDE_CODE_MODEL,
+            "reasoning_effort": DEFAULT_CLAUDE_CODE_REASONING_EFFORT,
+        },
+    }
+
+
 def _normalize_runtime_model(value, *, default: str) -> str:
     candidate = str(value or "").strip()
     return candidate or default
@@ -267,6 +312,31 @@ def normalize_client_runtime_profiles(value) -> dict[str, dict[str, str]]:
     return normalized
 
 
+def normalize_automation_task_profiles(value) -> dict[str, dict[str, str]]:
+    defaults = default_automation_task_profiles()
+    normalized = {key: dict(profile) for key, profile in defaults.items()}
+    if not isinstance(value, dict):
+        return normalized
+
+    for raw_profile, raw_value in value.items():
+        profile_key = str(raw_profile or "").strip().lower()
+        if profile_key not in AUTOMATION_TASK_PROFILE_KEYS:
+            continue
+        if not isinstance(raw_value, dict):
+            continue
+        backend = normalize_backend_key(raw_value.get("backend"))
+        if backend == BACKEND_NONE:
+            backend = ""
+        normalized[profile_key] = {
+            "backend": backend or defaults[profile_key]["backend"],
+            "model": str(raw_value.get("model") or defaults[profile_key]["model"]).strip(),
+            "reasoning_effort": str(
+                raw_value.get("reasoning_effort") or defaults[profile_key]["reasoning_effort"]
+            ).strip().lower(),
+        }
+    return normalized
+
+
 def normalize_client_preferences(
     schedule: dict | None = None,
     *,
@@ -282,6 +352,10 @@ def normalize_client_preferences(
         schedule.get("default_terminal_client"),
         interactive_clients=interactive_clients,
     )
+    last_terminal_client = normalize_last_terminal_client(
+        schedule.get("last_terminal_client"),
+        interactive_clients=interactive_clients,
+    )
     automation_backend = normalize_automation_backend(
         schedule.get("automation_backend"),
         automation_enabled=automation_enabled,
@@ -295,9 +369,13 @@ def normalize_client_preferences(
     return {
         "interactive_clients": interactive_clients,
         "default_terminal_client": default_terminal_client,
+        "last_terminal_client": last_terminal_client,
         "automation_enabled": automation_enabled,
         "automation_backend": automation_backend,
         "client_runtime_profiles": runtime_profiles,
+        "automation_task_profiles": normalize_automation_task_profiles(
+            schedule.get("automation_task_profiles")
+        ),
         "client_install_preferences": install_preferences,
     }
 
@@ -307,9 +385,11 @@ def apply_client_preferences(
     *,
     interactive_clients: dict | None = None,
     default_terminal_client: str | None = None,
+    last_terminal_client: str | None = None,
     automation_enabled=None,
     automation_backend: str | None = None,
     client_runtime_profiles: dict | None = None,
+    automation_task_profiles: dict | None = None,
     client_install_preferences: dict | None = None,
 ) -> dict:
     merged = dict(schedule or {})
@@ -324,6 +404,10 @@ def apply_client_preferences(
         default_terminal_client if default_terminal_client is not None else current["default_terminal_client"],
         interactive_clients=merged["interactive_clients"],
     )
+    merged["last_terminal_client"] = normalize_last_terminal_client(
+        last_terminal_client if last_terminal_client is not None else current.get("last_terminal_client", ""),
+        interactive_clients=merged["interactive_clients"],
+    )
     merged["automation_backend"] = normalize_automation_backend(
         automation_backend if automation_backend is not None else current["automation_backend"],
         automation_enabled=merged["automation_enabled"],
@@ -333,6 +417,11 @@ def apply_client_preferences(
         if client_runtime_profiles is not None
         else current["client_runtime_profiles"]
     )
+    merged["automation_task_profiles"] = normalize_automation_task_profiles(
+        automation_task_profiles
+        if automation_task_profiles is not None
+        else current["automation_task_profiles"]
+    )
     merged["client_install_preferences"] = normalize_client_install_preferences(
         client_install_preferences
         if client_install_preferences is not None
@@ -349,18 +438,22 @@ def save_client_preferences(
     *,
     interactive_clients: dict | None = None,
     default_terminal_client: str | None = None,
+    last_terminal_client: str | None = None,
     automation_enabled=None,
     automation_backend: str | None = None,
     client_runtime_profiles: dict | None = None,
+    automation_task_profiles: dict | None = None,
     client_install_preferences: dict | None = None,
 ) -> Path:
     schedule = apply_client_preferences(
         load_schedule_config(),
         interactive_clients=interactive_clients,
         default_terminal_client=default_terminal_client,
+        last_terminal_client=last_terminal_client,
         automation_enabled=automation_enabled,
         automation_backend=automation_backend,
         client_runtime_profiles=client_runtime_profiles,
+        automation_task_profiles=automation_task_profiles,
         client_install_preferences=client_install_preferences,
     )
     return save_schedule_config(schedule)
@@ -456,3 +549,25 @@ def resolve_client_runtime_profile(
             default=defaults[client_key]["reasoning_effort"],
         ),
     }
+
+
+def resolve_automation_task_profile(
+    profile: str | None,
+    *,
+    preferences: dict | None = None,
+) -> dict[str, str]:
+    normalized = preferences or load_client_preferences()
+    defaults = default_automation_task_profiles()
+    profile_key = str(profile or "").strip().lower() or "default"
+    if profile_key not in AUTOMATION_TASK_PROFILE_KEYS:
+        profile_key = "default"
+    configured = normalize_automation_task_profiles(normalized.get("automation_task_profiles"))
+    selected = dict(configured.get(profile_key) or defaults[profile_key])
+    backend = selected.get("backend") or resolve_automation_backend(normalized)
+    runtime_profile = resolve_client_runtime_profile(backend, preferences=normalized)
+    return {
+        "name": profile_key,
+        "backend": backend,
+        "model": selected.get("model") or runtime_profile["model"],
+        "reasoning_effort": selected.get("reasoning_effort") or runtime_profile["reasoning_effort"],
+    }