ixt-cli 0.8.0__py3-none-any.whl

ixt/cli/cmd_misc.py

@@ -0,0 +1,261 @@
+"""Standalone utility subcommands."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+from typing import cast
+
+from ixt.config.models import ToolRecord
+from ixt.config.settings import get_settings
+from ixt.core.install import resolve_tool_arg
+from ixt.libs.logger import get_logger
+from ixt.libs.style import bold, cyan, dim, green, yellow
+from ixt.platform import get_platform_info
+
+
+def cmd_setup_path(args: argparse.Namespace) -> int:
+    from ixt.core.setup_path import setup_path
+
+    logger = get_logger("setup-path")
+    result = setup_path(check_only=args.check, shell=getattr(args, "shell", None))
+    if result.warning:
+        logger.warn(result.warning)
+    logger.info(result.message)
+    if result.snippet:
+        logger.info("")
+        for line in result.snippet.rstrip("\n").splitlines():
+            logger.info(f"    {line}")
+    return 0 if result.status in ("ok", "ok_restart", "added", "migrated") else 1
+
+
+def cmd_setup_completions(args: argparse.Namespace) -> int:
+    from ixt.core.setup_completions import generate_completion
+
+    script = generate_completion(args.shell)
+    sys.stdout.write(script)
+    if not script.endswith("\n"):
+        sys.stdout.write("\n")
+    return 0
+
+
+def cmd_runtime_upgrade(args: argparse.Namespace) -> int:
+    from ixt.core.bootstrap import BootstrapError, RuntimeName, upgrade_runtime
+
+    logger = get_logger("runtime")
+    target = getattr(args, "name", None)
+    if not target:
+        logger.error("Specify a runtime to upgrade (e.g. 'ixt runtime upgrade uv')")
+        return 1
+
+    names = ("uv", "bun") if target == "all" else (target,)
+    ok = True
+    for name in names:
+        try:
+            path = upgrade_runtime(cast(RuntimeName, name))
+        except BootstrapError as exc:
+            logger.error(f"Failed to upgrade {name}: {exc}")
+            ok = False
+            continue
+        logger.info(f"  {green('ok')}  {name} upgraded at {dim(path)}")
+    return 0 if ok else 1
+
+
+def cmd_setup(args: argparse.Namespace) -> int:
+    """Dispatch ``ixt setup <subcommand>``."""
+    sub = getattr(args, "setup_command", None)
+    if sub == "path":
+        return cmd_setup_path(args)
+    if sub == "completions":
+        return cmd_setup_completions(args)
+    logger = get_logger("setup")
+    logger.error("Specify a setup subcommand (e.g. 'ixt setup path')")
+    return 1
+
+
+def cmd_runtimes(args: argparse.Namespace) -> int:
+    """Dispatch ``ixt runtime <subcommand>``."""
+    action = getattr(args, "runtimes_action", None)
+    if action == "info":
+        return _cmd_runtimes_info(args)
+    if action == "prune":
+        return _cmd_runtimes_prune(args)
+    if action == "upgrade":
+        return cmd_runtime_upgrade(args)
+
+    logger = get_logger("runtime")
+    logger.error("Specify a runtime subcommand (info, prune, upgrade)")
+    return 1
+
+
+def _cmd_runtimes_info(args: argparse.Namespace) -> int:
+    from ixt.core.cache import humanize_size
+    from ixt.core.runtimes import runtime_statuses
+
+    _ = args
+    logger = get_logger("runtime")
+    settings = get_settings()
+
+    logger.info(f"  {bold('ixt runtime')}")
+    logger.info(f"  Root:       {cyan(str(settings.runtimes_dir))}")
+    logger.info("")
+    for status in runtime_statuses(settings=settings):
+        state = green("present") if status.present else dim("missing")
+        use = yellow("used") if status.used else dim("unused")
+        version = f"  {dim(status.version)}" if status.version else ""
+        logger.info(
+            f"  {status.name:3s}  {state:10s} {use:8s} "
+            f"{humanize_size(status.bytes):>8s}  {dim(str(status.path))}{version}"
+        )
+        if status.used_by:
+            logger.info(f"       {dim('used by: ' + ', '.join(status.used_by))}")
+        elif status.present:
+            logger.info(f"       {dim('prunable: ' + status.prune_reason)}")
+    return 0
+
+
+def _cmd_runtimes_prune(args: argparse.Namespace) -> int:
+    from ixt.core.cache import humanize_size
+    from ixt.core.runtimes import prune_runtimes
+
+    logger = get_logger("runtime")
+    results = prune_runtimes(all_=getattr(args, "all", False))
+    removed = [result for result in results if result.removed]
+    for result in results:
+        if result.removed:
+            logger.info(
+                f"  {green('ok')}  removed {result.name}: "
+                f"{humanize_size(result.bytes)}, {result.files} "
+                f"{'file' if result.files == 1 else 'files'} ({dim(str(result.path))})"
+            )
+        else:
+            logger.info(f"  {dim('--')}  kept {result.name}: {result.reason}")
+    logger.info("")
+    logger.info(f"  Removed:    {bold(str(len(removed)))} runtime(s)")
+    return 0
+
+
+def cmd_doctor(args: argparse.Namespace) -> int:
+    from ixt.core.doctor import run_doctor
+
+    logger = get_logger("doctor")
+
+    pinfo = get_platform_info()
+    report = run_doctor(network=not getattr(args, "no_network", False))
+
+    logger.info(f"  {bold('ixt doctor')}")
+    shell = next((c.detail for c in report.checks if c.name == "Shell"), "unknown")
+    logger.info(
+        f"  Platform:  {pinfo.os.value}/{pinfo.arch.value}  "
+        f"Shell {shell}  Python {pinfo.python_version}"
+    )
+    logger.info("")
+
+    for check in report.checks:
+        if check.ok:
+            logger.info(f"  {green('ok')}  {check.name:15s} {dim(check.detail)}")
+        else:
+            logger.info(f"  {yellow('!!')}  {check.name:15s} {check.detail}")
+        if check.hint:
+            logger.info(f"      {dim('Hint: ' + check.hint)}")
+
+    logger.info("")
+    if report.ok:
+        logger.info(f"  {green('All checks passed')}")
+    else:
+        n = len(report.warnings)
+        logger.info(f"  {yellow(f'{n} warning(s)')}")
+
+    return 0
+
+
+def cmd_environment(args: argparse.Namespace) -> int:
+    from ixt.core.cache import humanize_size, storage_sizes
+
+    logger = get_logger("environment")
+    settings = get_settings()
+    pinfo = get_platform_info()
+
+    logger.info(f"  {bold('ixt environment')}")
+    logger.info(f"  Platform:   {pinfo.os.value}/{pinfo.arch.value}")
+    logger.info(f"  Python:     {pinfo.python_version}")
+    logger.info("")
+    logger.info(f"  Home:       {cyan(str(settings.home))}")
+    logger.info(f"  Config:     {cyan(str(settings.config_dir))}")
+    logger.info(f"  Installed:  {cyan(str(settings.installed_dir))}")
+    logger.info(f"  Bin dir:    {cyan(str(settings.bin_dir))}")
+    logger.info(f"  Envs dir:   {cyan(str(settings.envs_dir))}")
+    logger.info(f"  Runtimes:   {cyan(str(settings.runtimes_dir))}")
+    logger.info(f"  Cache:      {cyan(str(settings.cache_home))}")
+    logger.info(f"  Downloads:  {cyan(str(settings.downloads_dir))}")
+    logger.info(f"  Metadata:   {cyan(str(settings.metadata_dir))}")
+
+    count = len(settings.iter_installed_metadata())
+    logger.info("")
+    logger.info(f"  Tools:      {bold(str(count))} installed")
+
+    if getattr(args, "sizes", False):
+        logger.info("")
+        logger.info("  Sizes:")
+        for entry in storage_sizes(settings=settings):
+            files = "file" if entry.files == 1 else "files"
+            logger.info(
+                f"    {entry.name:10s} {humanize_size(entry.bytes):>8s}  {entry.files} {files}"
+            )
+
+    return 0
+
+
+def _get_installed_env_dir(tool: str, *, logger_name: str) -> Path | None:
+    logger = get_logger(logger_name)
+    settings = get_settings()
+
+    try:
+        tool_name = resolve_tool_arg(tool, settings=settings)
+    except ValueError as e:
+        logger.error(str(e))
+        return None
+
+    meta_file = settings.get_tool_metadata_file(tool_name)
+
+    if not meta_file.exists():
+        logger.error(f"Tool '{tool}' is not installed")
+        return None
+
+    record = ToolRecord.load_json(meta_file)
+    env_dir = Path(record.env_dir).expanduser()
+
+    if not env_dir.is_dir():
+        logger.error(f"Environment directory missing: {env_dir}")
+        return None
+
+    return env_dir
+
+
+def cmd_shell(args: argparse.Namespace) -> int:
+    import os
+    import subprocess  # nosemgrep: gitlab.bandit.B404
+
+    logger = get_logger("shell")
+    env_dir = _get_installed_env_dir(args.tool, logger_name="shell")
+    if env_dir is None:
+        return 1
+
+    # Launch a subshell in the tool's environment directory
+    shell = os.environ.get("SHELL", "/bin/sh")
+    logger.info(f"  Entering {bold(args.tool)} env ({dim(str(env_dir))})")
+    logger.info(f"  {dim('Type exit to return')}")
+    # Safe: $SHELL is the intended source, exec as list (no shell interpretation),
+    # env_dir from stored ToolRecord.
+    # nosemgrep: python.lang.security.audit.dangerous-subprocess-use-tainted-env-args.dangerous-subprocess-use-tainted-env-args  # noqa: E501
+    result = subprocess.run([shell], cwd=env_dir)
+    return result.returncode
+
+
+def cmd_where(args: argparse.Namespace) -> int:
+    env_dir = _get_installed_env_dir(args.tool, logger_name="where")
+    if env_dir is None:
+        return 1
+    sys.stdout.write(f"{env_dir.resolve()}\n")
+    return 0

ixt/cli/cmd_registry.py

@@ -0,0 +1,35 @@
+"""Registry inspection subcommands."""
+
+from __future__ import annotations
+
+import argparse
+
+from ixt.config.registry import load_registry
+from ixt.libs.logger import get_logger
+from ixt.libs.output import data
+from ixt.libs.style import bold, dim
+
+
+def cmd_registry(args: argparse.Namespace) -> int:
+    """Dispatch ``ixt registry <subcommand>``."""
+    action = getattr(args, "registry_action", None)
+    if action == "list":
+        return _cmd_registry_list(args)
+
+    logger = get_logger("registry")
+    logger.error("Specify a registry subcommand (list)")
+    return 1
+
+
+def _cmd_registry_list(args: argparse.Namespace) -> int:
+    """Print known short-name registry entries."""
+    _ = args
+    registry = load_registry()
+    if not registry:
+        data("No registry entries")
+        return 0
+
+    width = max(len(name) for name in registry)
+    for name, entry in sorted(registry.items()):
+        data(f"  {bold(name.ljust(width))}  {dim(entry.spec)}")
+    return 0

ixt/cli/cmd_upgrade.py

@@ -0,0 +1,336 @@
+"""``ixt tool upgrade`` subcommand."""
+
+from __future__ import annotations
+
+import argparse
+import time
+from contextlib import nullcontext
+
+from ixt.cli.parser import normalize_verbosity
+from ixt.cli.render import format_source_tag, source_label_for_record
+from ixt.config.models import ToolRecord
+from ixt.config.settings import get_settings
+from ixt.core.install import display_tool_name, resolve_tool_arg
+from ixt.core.resolution_stats import collect_resolution_stats
+from ixt.libs.logger import get_logger, get_verbosity
+from ixt.libs.semver import compare_versions
+from ixt.libs.style import bold, dim, green, red
+
+
+def cmd_upgrade(args: argparse.Namespace) -> int:
+    normalize_verbosity(args)
+    logger = get_logger("upgrade")
+    dry_run = getattr(args, "dry_run", False)
+    use_cache = not getattr(args, "no_cache", False)
+
+    if dry_run:
+        return _cmd_upgrade_dry_run(args, logger, use_cache=use_cache)
+
+    from ixt.core.upgrade import (
+        ToolLocalInstallError,
+        ToolNotInstalledError,
+        ToolPinnedError,
+        upgrade_all,
+        upgrade_tool,
+    )
+
+    if args.upgrade_all:
+        settings = get_settings()
+        total = len(settings.iter_installed_metadata())
+        if not total:
+            logger.info("No tools installed")
+            return 0
+        up_to_date = upgraded = pinned = skipped = errors = 0
+        start = time.monotonic()
+        logger.info(f"checking {total} tool(s)")
+        with _resolution_stats_context(args) as resolution_stats:
+            for i, (name, result) in enumerate(
+                upgrade_all(settings=settings, use_cache=use_cache), 1
+            ):
+                prefix = dim(f"[{i}/{total}]")
+                if isinstance(result, ToolPinnedError):
+                    pinned += 1
+                    logger.info(f"{prefix} {_pinned_msg(result, settings=settings)}")
+                elif isinstance(result, ToolLocalInstallError):
+                    skipped += 1
+                    display = _display_for_tool_name(name, settings)
+                    styled_display = bold(display)
+                    logger.info(
+                        f"{prefix} {dim('=')} {dim('skipped')} "
+                        f"{styled_display} {dim('(local install)')}"
+                    )
+                elif isinstance(result, Exception):
+                    errors += 1
+                    logger.error(f"{prefix} {red('x')} {red('failed')} {name}: {result}")
+                else:
+                    record, old_version = result
+                    if old_version and record.version and old_version == record.version:
+                        up_to_date += 1
+                    else:
+                        upgraded += 1
+                    logger.info(f"{prefix} {_upgrade_msg(record, old_version)}")
+        logger.info(
+            _upgrade_all_footer(
+                up_to_date=up_to_date,
+                upgraded=upgraded,
+                pinned=pinned,
+                skipped=skipped,
+                failed=errors,
+                elapsed=time.monotonic() - start,
+                use_cache=use_cache,
+                settings=settings,
+            )
+        )
+        _log_resolution_summary(logger, resolution_stats)
+        return 1 if errors else 0
+
+    if not args.tool:
+        logger.error("Specify a tool name or use --all")
+        return 1
+
+    try:
+        tool_name = resolve_tool_arg(args.tool)
+    except ValueError as e:
+        logger.error(str(e))
+        return 1
+
+    try:
+        record, old_version = upgrade_tool(tool_name, use_cache=use_cache)
+    except ToolNotInstalledError:
+        logger.error(f"Tool '{args.tool}' is not installed")
+        logger.error(f"  {dim('Hint: run ixt tool list to see installed tools')}")
+        return 1
+    except ToolPinnedError as exc:
+        logger.info(_pinned_msg(exc, settings=get_settings()))
+        return 0
+    except ToolLocalInstallError as exc:
+        logger.error(str(exc))
+        return 1
+    except ValueError as exc:
+        logger.error(str(exc))
+        return 1
+
+    logger.info(_upgrade_msg(record, old_version))
+    return 0
+
+
+def _fmt_ttl(seconds: int) -> str:
+    if seconds <= 0:
+        return "off"
+    return f"{seconds // 60}m" if seconds % 60 == 0 else f"{seconds}s"
+
+
+def _fmt_remaining(seconds: int) -> str:
+    return f"~{seconds // 60}m" if seconds >= 60 else "<1m"
+
+
+def _cache_tail(use_cache: bool, settings) -> str:
+    """Footer suffix describing the cache policy (or the --no-cache override)."""
+    if not use_cache:
+        return f" {dim('· fresh (--no-cache)')}"
+    from ixt.core.resolve_cache import min_remaining_ttl, ttl_seconds
+
+    ttl = ttl_seconds()
+    if ttl <= 0:
+        return ""
+    remaining = min_remaining_ttl(settings)
+    note = (
+        f"cached, expires in {_fmt_remaining(remaining)}"
+        if remaining is not None
+        else f"cache TTL {_fmt_ttl(ttl)}"
+    )
+    return f" {dim(f'· {note} · --no-cache to refresh')}"
+
+
+def _upgrade_all_footer(
+    *,
+    up_to_date: int,
+    upgraded: int,
+    pinned: int,
+    skipped: int,
+    failed: int,
+    elapsed: float,
+    use_cache: bool,
+    settings,
+) -> str:
+    labels = [
+        (up_to_date, "up-to-date"),
+        (upgraded, "upgraded"),
+        (pinned, "pinned"),
+        (skipped, "skipped"),
+        (failed, "failed"),
+    ]
+    parts = [f"{n} {label}" for n, label in labels if n]
+    summary = ", ".join(parts) if parts else "nothing to do"
+    return f"{summary} {dim(f'in {elapsed:.1f}s')}{_cache_tail(use_cache, settings)}"
+
+
+def _resolution_stats_context(args: argparse.Namespace | None = None):
+    verbosity = max(get_verbosity(), getattr(args, "verbose", 0) if args is not None else 0)
+    if verbosity > 0:
+        return collect_resolution_stats()
+    return nullcontext(None)
+
+
+def _log_resolution_summary(logger, stats) -> None:
+    if stats is None or not stats.has_activity():
+        return
+    summary = stats.format_summary()
+    if summary:
+        logger.info(f"resolution: {summary}")
+
+
+def _record_for_tool_name(name: str, settings) -> ToolRecord | None:
+    try:
+        return ToolRecord.load_json(settings.get_tool_metadata_file(name))
+    except (FileNotFoundError, ValueError):
+        return None
+
+
+def _display_for_tool_name(name: str, settings) -> str:
+    record = _record_for_tool_name(name, settings)
+    return display_tool_name(record, settings) if record is not None else name
+
+
+def _source_suffix(record: ToolRecord) -> str:
+    tag = format_source_tag(source_label_for_record(record))
+    return f" {tag}" if tag else ""
+
+
+def _pinned_msg(err, *, settings=None) -> str:
+    """Format the info line shown when upgrade is skipped due to an == pin."""
+    tail = ""
+    if err.latest_available:
+        tail = f"  {dim('latest:')} {err.latest_available}"
+    record = _record_for_tool_name(err.tool_name, settings) if settings is not None else None
+    display = display_tool_name(record, settings) if record is not None else err.tool_name
+    source = _source_suffix(record) if record is not None else ""
+    return (
+        f"{dim('=')} {dim('pinned')} {bold(display)} "
+        f"{dim(err.pinned_version)}{source} {dim('(ixt.toml)')}{tail}"
+    )
+
+
+def _resolve_spec_for_record(record: ToolRecord) -> str:
+    """Build the resolver spec from a stored record (strips @tag for binary)."""
+    if record.backend == "binary":
+        from ixt.net.source import strip_version_suffix
+
+        return strip_version_suffix(record.spec)
+    # Python/Node: registry queries need the underlying package name
+    # (``record.name`` is the installed id and may include a slot prefix).
+    return record.pkg()
+
+
+def _dry_run_upgrade_line(record: ToolRecord, new_version: str | None) -> str:
+    old = record.version or "unknown"
+    source = _source_suffix(record)
+    display = display_tool_name(record)
+    if new_version is None:
+        return f"  {red('?')} {red('resolve failed')} {bold(display)} {dim(old)}{source}"
+    if compare_versions(old, new_version) == 0:
+        return f"  {dim('=')} {dim('up-to-date')} {bold(display)} {dim(old)}{source}"
+    return (
+        f"  {green('^')} {dim('would upgrade')} {bold(display)} "
+        f"{dim(old)} -> {dim(new_version)}{source}"
+    )
+
+
+def _cmd_upgrade_dry_run(args: argparse.Namespace, logger, *, use_cache: bool = True) -> int:
+    from ixt.core.backend import BackendType
+    from ixt.core.resolve import resolve_latest_many
+    from ixt.core.upgrade import load_config_pins
+
+    settings = get_settings()
+
+    if args.upgrade_all:
+        meta_files = settings.iter_installed_metadata()
+    else:
+        if not args.tool:
+            logger.error("Specify a tool name or use --all")
+            return 1
+        try:
+            tool_name = resolve_tool_arg(args.tool, settings=settings)
+        except ValueError as e:
+            logger.error(str(e))
+            return 1
+        meta_file = settings.get_tool_metadata_file(tool_name)
+        if not meta_file.exists():
+            logger.error(f"Tool '{args.tool}' is not installed")
+            logger.error(f"  {dim('Hint: run ixt tool list to see installed tools')}")
+            return 1
+        meta_files = [meta_file]
+
+    if not meta_files:
+        logger.info(f"{dim('[dry-run]')} no tools installed")
+        return 0
+
+    records = [ToolRecord.load_json(meta_file) for meta_file in meta_files]
+    # Parse ixt.toml once for all tools, then resolve every latest in parallel.
+    pins = load_config_pins(record.name for record in records)
+    invalid: set[str] = set()
+    requests: list[tuple[str, BackendType, str]] = []
+    for record in records:
+        try:
+            backend = BackendType(record.backend)
+        except ValueError:
+            invalid.add(record.name)
+            continue
+        requests.append((record.name, backend, _resolve_spec_for_record(record)))
+    start = time.monotonic()
+    with _resolution_stats_context(args) as resolution_stats:
+        resolved = resolve_latest_many(requests, use_cache=use_cache, settings=settings)
+    elapsed = time.monotonic() - start
+
+    logger.info(f"{dim('[dry-run]')} would upgrade {len(records)} tool(s):")
+    any_failed = False
+    for record in records:
+        if record.name in invalid:
+            any_failed = True
+            logger.info(_dry_run_upgrade_line(record, None))
+            continue
+
+        pinned = pins.get(record.name)
+        new_version = resolved.get(record.name)
+        if new_version is None and pinned is None:
+            any_failed = True
+
+        if pinned is not None:
+            logger.info(_dry_run_pinned_line(record, pinned, new_version))
+            continue
+        logger.info(_dry_run_upgrade_line(record, new_version))
+
+    if args.upgrade_all:
+        logger.info(
+            f"  {dim(f'checked {len(records)} in {elapsed:.1f}s')}"
+            f"{_cache_tail(use_cache, settings)}"
+        )
+        _log_resolution_summary(logger, resolution_stats)
+    if any_failed:
+        logger.info(f"  {dim('hint: set GITHUB_TOKEN for higher GH rate limits')}")
+    return 0
+
+
+def _dry_run_pinned_line(record: ToolRecord, pinned: str, latest: str | None) -> str:
+    source = _source_suffix(record)
+    tail = f"  {dim('latest:')} {latest}" if latest else ""
+    return (
+        f"  {dim('=')} {dim('pinned')} {bold(display_tool_name(record))} "
+        f"{dim(record.version or '?')} {dim(f'(pinned: {pinned})')}{source}{tail}"
+    )
+
+
+def _upgrade_msg(record, old_version: str | None = None) -> str:
+    """Format an upgrade result message."""
+    ver = record.version or ""
+    display = display_tool_name(record)
+    source = _source_suffix(record)
+    if old_version and ver and old_version == ver:
+        return f"{dim('=')} {dim('up-to-date')} {bold(display)} {dim(ver)}{source}"
+    if old_version and ver and old_version != ver:
+        return (
+            f"{green('^')} {dim('upgraded')} {bold(display)} "
+            f"{dim(old_version)} -> {dim(ver)}{source}"
+        )
+    version = f" {dim(ver)}" if ver else ""
+    return f"{green('^')} {dim('upgraded')} {bold(display)}{version}{source}"

ixt/cli/commands.py

@@ -0,0 +1,70 @@
+"""Command dispatch — re-exports each ``cmd_*`` from its dedicated module.
+
+The actual implementations live in ``cli/cmd_install.py``,
+``cli/cmd_upgrade.py``, ``cli/cmd_info.py``, ``cli/cmd_config.py``,
+``cli/cmd_apply.py`` and ``cli/cmd_misc.py``. This module aggregates them
+and exposes the ``COMMANDS`` dispatch table consumed by ``cli.main``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from ixt.cli.cmd_apply import cmd_apply, cmd_export
+from ixt.cli.cmd_cache import cmd_cache
+from ixt.cli.cmd_config import cmd_config
+from ixt.cli.cmd_info import cmd_info, cmd_list
+from ixt.cli.cmd_install import _log_not_found_hint, cmd_add, cmd_install, cmd_uninstall
+from ixt.cli.cmd_misc import (
+    cmd_doctor,
+    cmd_environment,
+    cmd_runtimes,
+    cmd_setup,
+    cmd_shell,
+    cmd_where,
+)
+from ixt.cli.cmd_registry import cmd_registry
+from ixt.cli.cmd_upgrade import cmd_upgrade
+
+__all__ = [
+    "COMMANDS",
+    "_log_not_found_hint",
+    "cmd_add",
+    "cmd_apply",
+    "cmd_cache",
+    "cmd_config",
+    "cmd_doctor",
+    "cmd_environment",
+    "cmd_export",
+    "cmd_info",
+    "cmd_install",
+    "cmd_list",
+    "cmd_registry",
+    "cmd_runtimes",
+    "cmd_setup",
+    "cmd_shell",
+    "cmd_uninstall",
+    "cmd_upgrade",
+    "cmd_where",
+]
+
+
+COMMANDS: dict[str, Callable] = {
+    "add": cmd_add,
+    "install": cmd_install,
+    "uninstall": cmd_uninstall,
+    "upgrade": cmd_upgrade,
+    "list": cmd_list,
+    "info": cmd_info,
+    "config": cmd_config,
+    "shell": cmd_shell,
+    "where": cmd_where,
+    "apply": cmd_apply,
+    "export": cmd_export,
+    "cache": cmd_cache,
+    "registry": cmd_registry,
+    "runtime": cmd_runtimes,
+    "setup": cmd_setup,
+    "environment": cmd_environment,
+    "doctor": cmd_doctor,
+}