ixt-cli 0.8.0__py3-none-any.whl

ixt/cli/cmd_apply.py

@@ -0,0 +1,404 @@
+"""``ixt tool apply``, ``ixt tool export``, and ``ixt asset-index export`` handlers."""
+
+from __future__ import annotations
+
+import argparse
+import time
+from collections.abc import Callable
+from pathlib import Path
+from typing import TYPE_CHECKING, cast
+
+from ixt.cli.render import (
+    format_exposed_bins,
+    format_source_tag,
+    source_label_for_spec,
+)
+from ixt.config.models import ToolRecord
+from ixt.config.settings import get_settings
+from ixt.libs.logger import get_logger
+from ixt.libs.output import data
+from ixt.libs.style import bold, cyan, dim, green, red, yellow
+
+if TYPE_CHECKING:
+    from ixt.core.apply import (
+        ApplyAction,
+        ApplyPlan,
+        ApplyResult,
+        InjectAction,
+        InstallAction,
+        ReexposeAction,
+        ReinstallAction,
+        UninjectAction,
+    )
+
+
+def cmd_apply(args: argparse.Namespace) -> int:
+    from ixt.core.apply import RemovalsRefused, apply_config
+
+    logger = get_logger("apply")
+    dry_run = getattr(args, "dry_run", False)
+    yes = getattr(args, "yes", False)
+
+    config_path = Path(args.config_file) if args.config_file else None
+
+    if dry_run:
+        return _cmd_apply_dry_run(config_path, args.remove, logger)
+
+    confirm: Callable[[list[str]], bool] | None = None
+    if args.remove and not yes:
+        confirm = _make_remove_confirmer(logger)
+
+    try:
+        start = time.monotonic()
+        result = apply_config(
+            config_path=config_path,
+            remove_unlisted=args.remove,
+            confirm_removals=confirm,
+            progress=_make_apply_progress(logger),
+        )
+    except FileNotFoundError:
+        logger.error("No ixt.toml found")
+        logger.error(f"  {dim('Hint: create one with ixt tool export > ixt.toml')}")
+        return 1
+    except RemovalsRefused:
+        logger.info("aborted by user")
+        return 0
+
+    total = len(result.installed) + len(result.updated) + len(result.removed)
+    if not total and not result.errors:
+        logger.info("Already in sync")
+    else:
+        logger.info(_apply_footer(result, time.monotonic() - start))
+
+    return 1 if result.errors else 0
+
+
+def _make_apply_progress(logger):
+    """Create a progress callback for apply_config."""
+    settings = get_settings()
+    started = False
+
+    def progress(
+        phase: str,
+        kind: str,
+        action: ApplyAction,
+        index: int,
+        total: int,
+        _result: ApplyResult,
+        error: Exception | None,
+    ) -> None:
+        nonlocal started
+        prefix = dim(f"[{index}/{total}]")
+        if phase == "start":
+            if not started:
+                logger.info(f"applying {total} change(s)")
+                started = True
+            logger.info(_apply_progress_line(prefix, kind, action))
+            return
+        if phase == "done" and error is not None:
+            logger.error(f"{prefix}   {red('x')} {_apply_action_name(action)}: {error}")
+            return
+        if phase == "done":
+            line = _apply_done_line(kind, action, settings)
+            if line is not None:
+                logger.info(line)
+
+    return progress
+
+
+def _apply_action_name(action: ApplyAction) -> str:
+    if isinstance(action, str):
+        return action
+    return action.name
+
+
+def _apply_progress_line(prefix: str, kind: str, action: ApplyAction) -> str:
+    name = _apply_action_name(action)
+    if kind == "install":
+        install = cast("InstallAction", action)
+        source = format_source_tag(
+            source_label_for_spec(
+                install.install_spec,
+                backend_hint=install.backend,
+                tool_id=install.name,
+            )
+        )
+        source_suffix = f" {source}" if source else ""
+        display = bold(install.install_spec)
+        return f"{prefix} {dim('installing')} {display}{source_suffix}"
+    if kind == "reinstall":
+        reinstall = cast("ReinstallAction", action)
+        reasons = "+".join(reinstall.reasons)
+        source = format_source_tag(
+            source_label_for_spec(
+                reinstall.install_spec,
+                backend_hint=reinstall.backend,
+                tool_id=reinstall.name,
+            )
+        )
+        source_suffix = f" {source}" if source else ""
+        return (
+            f"{prefix} {dim('reinstalling')} "
+            f"{bold(reinstall.install_spec)} {dim(reasons)}{source_suffix}"
+        )
+    if kind == "inject":
+        inject = cast("InjectAction", action)
+        packages = ", ".join(inject.packages)
+        return f"{prefix} {green('+')} {dim('injecting')} {bold(name)} {dim(packages)}"
+    if kind == "uninject":
+        uninject = cast("UninjectAction", action)
+        packages = ", ".join(uninject.packages)
+        return f"{prefix} {red('-')} {dim('uninjecting')} {bold(name)} {dim(packages)}"
+    if kind == "re-expose":
+        reexpose = cast("ReexposeAction", action)
+        old = ",".join(reexpose.old_rules) or "(none)"
+        new = ",".join(reexpose.new_rules) or "(none)"
+        return f"{prefix} {cyan('~')} {dim('re-exposing')} {bold(name)} {dim(old)} -> {dim(new)}"
+    if kind == "policy":
+        return f"{prefix} {cyan('~')} {dim('applying policy')} {bold(name)}"
+    return f"{prefix} {red('-')} {dim('removing')} {bold(name)}"
+
+
+def _load_action_record(action: ApplyAction, settings) -> ToolRecord | None:
+    if isinstance(action, str):
+        return None
+    meta_file = settings.get_tool_metadata_file(action.name)
+    try:
+        return ToolRecord.load_json(meta_file)
+    except (FileNotFoundError, ValueError):
+        return None
+
+
+def _apply_record_done_line(status: str, record: ToolRecord) -> str:
+    version = dim(record.version or "unknown")
+    exposes = format_exposed_bins(record.exposed_bins)
+    marker = green("+") if status == "installed" else yellow("*")
+    return f"       {marker} {status} {version} {dim('·')} exposes: {exposes}"
+
+
+def _apply_done_line(kind: str, action: ApplyAction, settings) -> str | None:
+    if kind not in {"install", "reinstall", "re-expose"}:
+        return None
+    record = _load_action_record(action, settings)
+    if record is None:
+        return None
+    if kind == "install":
+        return _apply_record_done_line("installed", record)
+    if kind == "reinstall":
+        return _apply_record_done_line("reinstalled", record)
+    return (
+        f"       {cyan('re-exposed')} {dim('·')} "
+        f"exposes: {format_exposed_bins(record.exposed_bins)}"
+    )
+
+
+def _apply_footer(result: ApplyResult, elapsed: float) -> str:
+    labels = [
+        (len(result.installed), "installed"),
+        (len(result.updated), "updated"),
+        (len(result.removed), "removed"),
+        (len(result.errors), "failed"),
+    ]
+    parts = [f"{count} {label}" for count, label in labels if count]
+    summary = ", ".join(parts) if parts else "nothing to do"
+    return f"{summary} {dim(f'in {elapsed:.1f}s')}"
+
+
+def _make_remove_confirmer(logger) -> Callable[[list[str]], bool]:
+    """Build a confirmer that prompts y/N on TTY, refuses in non-interactive."""
+    import sys
+
+    def confirm(names: list[str]) -> bool:
+        summary = f"About to remove {len(names)} tool(s): {', '.join(sorted(names))}"
+        if not sys.stdin.isatty():
+            logger.error(summary)
+            logger.error(f"  {dim('non-interactive session; pass --yes to confirm')}")
+            return False
+        print(summary, file=sys.stderr)
+        try:
+            answer = input("Proceed? [y/N] ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            print("", file=sys.stderr)
+            return False
+        return answer in ("y", "yes")
+
+    return confirm
+
+
+def _load_apply_plan(
+    config_path: Path | None, remove_unlisted: bool, logger
+) -> tuple[ApplyPlan, Path] | int:
+    """Load the ixt.toml and build an ApplyPlan, or return an exit code on error."""
+    from ixt.config.toml import find_config_file, load_config
+    from ixt.core.apply import _get_installed_tools, _normalize_config_for_apply, plan_apply
+
+    path = config_path or find_config_file()
+    if path is None:
+        logger.error("No ixt.toml found")
+        logger.error(f"  {dim('Hint: create one with ixt tool export > ixt.toml')}")
+        return 1
+
+    try:
+        config = load_config(path)
+    except Exception as exc:
+        logger.error(f"Failed to load {path}: {exc}")
+        return 1
+
+    settings = get_settings()
+    installed = _get_installed_tools(settings)
+    config = _normalize_config_for_apply(config, settings)
+    plan = plan_apply(config, installed, remove_unlisted=remove_unlisted)
+    return plan, path
+
+
+def _print_apply_installs(actions, logger) -> None:
+    for action in actions:
+        source = format_source_tag(
+            source_label_for_spec(
+                action.install_spec,
+                backend_hint=action.backend,
+                tool_id=action.name,
+            )
+        )
+        source_suffix = f" {source}" if source else ""
+        display = bold(action.install_spec)
+        logger.info(f"  {green('+')} {dim('would install')} {display}{source_suffix}")
+
+
+def _print_apply_reinstalls(actions, logger) -> None:
+    for action in actions:
+        reason_str = "+".join(action.reasons)
+        source = format_source_tag(
+            source_label_for_spec(
+                action.install_spec,
+                backend_hint=action.backend,
+                tool_id=action.name,
+            )
+        )
+        source_suffix = f" {source}" if source else ""
+        logger.info(
+            f"  {yellow('*')} {dim('would reinstall')} {bold(action.install_spec)} "
+            f"{dim(f'(reinstall: {reason_str})')}{source_suffix}"
+        )
+        if "version" in action.reasons:
+            old = action.old_version or "?"
+            new = action.pinned_version or "?"
+            logger.info(f"      {dim('version:')} {old} {dim('->')} {new}")
+        if "inject" in action.reasons:
+            added = sorted(set(action.new_inject) - set(action.old_inject))
+            removed = sorted(set(action.old_inject) - set(action.new_inject))
+            if added:
+                logger.info(f"      {dim('inject +:')} {', '.join(added)}")
+            if removed:
+                logger.info(f"      {dim('inject -:')} {', '.join(removed)}")
+
+
+def _print_apply_injects(actions, logger) -> None:
+    for action in actions:
+        logger.info(
+            f"  {green('+')} {dim('would inject')} {bold(action.name)} {dim('(inject:')} "
+            f"{', '.join(action.packages)}{dim(')')}"
+        )
+
+
+def _print_apply_uninjects(actions, logger) -> None:
+    for action in actions:
+        logger.info(
+            f"  {red('-')} {dim('would uninject')} {bold(action.name)} {dim('(uninject:')} "
+            f"{', '.join(action.packages)}{dim(')')}"
+        )
+
+
+def _print_apply_reexposes(actions, logger) -> None:
+    for action in actions:
+        old = ",".join(action.old_rules) or "(none)"
+        new = ",".join(action.new_rules) or "(none)"
+        logger.info(
+            f"  {cyan('~')} {dim('would re-expose')} {bold(action.name)} "
+            f"{dim('(re-expose:')} {old} "
+            f"{dim('->')} {new}{dim(')')}"
+        )
+
+
+def _print_apply_repolicies(actions, logger) -> None:
+    for action in actions:
+        logger.info(f"  {cyan('~')} {dim('would apply policy')} {bold(action.name)}")
+
+
+def _print_apply_removes(names, logger) -> None:
+    for name in names:
+        logger.info(f"  {red('-')} {dim('would remove')} {bold(name)}")
+
+
+def _print_apply_summary(plan, logger) -> None:
+    """Print the ``total: N install, M reinstall, ...`` summary line."""
+    sections: list[tuple[list, str]] = [
+        (plan.to_install, "install"),
+        (plan.to_reinstall, "reinstall"),
+        (plan.to_inject, "inject"),
+        (plan.to_uninject, "uninject"),
+        (plan.to_reexpose, "re-expose"),
+        (plan.to_repolicy, "policy"),
+        (plan.to_remove, "remove"),
+    ]
+    parts = [f"{len(items)} {label}" for items, label in sections if items]
+    if parts:
+        logger.info(f"  {dim('total: ' + ', '.join(parts))}")
+
+
+def _cmd_apply_dry_run(config_path: Path | None, remove_unlisted: bool, logger) -> int:
+    result = _load_apply_plan(config_path, remove_unlisted, logger)
+    if isinstance(result, int):
+        return result
+    plan, path = result
+
+    logger.info(f"{dim('dry-run: no changes will be applied')}")
+    logger.info(f"{dim('config:  ')}{path}")
+
+    if plan.is_empty:
+        logger.info("Already in sync")
+        return 0
+
+    _print_apply_installs(plan.to_install, logger)
+    _print_apply_reinstalls(plan.to_reinstall, logger)
+    _print_apply_injects(plan.to_inject, logger)
+    _print_apply_uninjects(plan.to_uninject, logger)
+    _print_apply_reexposes(plan.to_reexpose, logger)
+    _print_apply_repolicies(plan.to_repolicy, logger)
+    _print_apply_removes(plan.to_remove, logger)
+    _print_apply_summary(plan, logger)
+    return 0
+
+
+def cmd_export(args: argparse.Namespace) -> int:
+    action = getattr(args, "export_action", None)
+    if action == "asset-index":
+        import sys
+
+        from ixt.core.export import export_asset_index_json
+
+        from_registry = getattr(args, "from_registry", None)
+        json_text = export_asset_index_json(
+            from_registry=Path(from_registry) if from_registry else None,
+            all_platforms=bool(getattr(args, "all_platforms", False)),
+            warn=lambda message: print(message, file=sys.stderr),
+        )
+        data(json_text.rstrip("\n"))
+        return 0
+    if action != "tools":
+        get_logger("export").error("Specify what to export: tools or asset-index")
+        return 1
+
+    # lazy: keeps `ixt.core.export` (and its TOML serializer chain)
+    # off the import path of every other CLI command.
+    from ixt.core.export import ToolNotInstalledError, export_toml
+
+    names = list(getattr(args, "names", []) or [])
+    try:
+        toml_text = export_toml(names or None)
+    except (ToolNotInstalledError, ValueError) as exc:
+        get_logger("export").error(str(exc))
+        return 1
+
+    data(toml_text.rstrip("\n"))
+    return 0

ixt/cli/cmd_cache.py

@@ -0,0 +1,86 @@
+"""Cache management subcommands."""
+
+from __future__ import annotations
+
+import argparse
+
+from ixt.config.settings import get_settings
+from ixt.core.cache import cache_sizes, clear_caches, humanize_size, prune_downloads
+from ixt.libs.logger import get_logger
+from ixt.libs.style import bold, cyan, dim, green
+
+
+def cmd_cache(args: argparse.Namespace) -> int:
+    """Dispatch ``ixt cache <subcommand>``."""
+    action = getattr(args, "cache_action", None)
+    if action == "info":
+        return _cmd_cache_info(args)
+    if action == "clear":
+        return _cmd_cache_clear(args)
+    if action == "prune":
+        return _cmd_cache_prune(args)
+
+    logger = get_logger("cache")
+    logger.error("Specify a cache subcommand (info, prune, clear)")
+    return 1
+
+
+def _cmd_cache_info(args: argparse.Namespace) -> int:
+    _ = args
+    logger = get_logger("cache")
+    settings = get_settings()
+    entries = cache_sizes(settings=settings)
+    total = sum(entry.bytes for entry in entries)
+
+    logger.info(f"  {bold('ixt cache')}")
+    logger.info(f"  Root:       {cyan(str(settings.cache_home))}")
+    logger.info("")
+    for entry in entries:
+        files = _files(entry.files)
+        logger.info(
+            f"  {entry.name:10s} {humanize_size(entry.bytes):>8s}  "
+            f"{entry.files} {files}  {dim(str(entry.path))}"
+        )
+    logger.info("")
+    logger.info(f"  Total:      {bold(humanize_size(total))}")
+    return 0
+
+
+def _cmd_cache_clear(args: argparse.Namespace) -> int:
+    logger = get_logger("cache")
+    for result in clear_caches(args.target):
+        files = _files(result.removed_count)
+        logger.info(
+            f"  {green('ok')}  cleared {result.target}: "
+            f"{humanize_size(result.removed_bytes)}, "
+            f"{result.removed_count} {files} ({dim(str(result.path))})"
+        )
+    return 0
+
+
+def _cmd_cache_prune(args: argparse.Namespace) -> int:
+    logger = get_logger("cache")
+    try:
+        result = prune_downloads(keep=args.keep)
+    except ValueError as exc:
+        logger.error(str(exc))
+        return 1
+
+    files = _files(result.removed_count)
+    stale = (
+        f", dropped {result.stale_entries} stale metadata "
+        f"{'entry' if result.stale_entries == 1 else 'entries'}"
+        if result.stale_entries
+        else ""
+    )
+    logger.info(
+        f"  {green('ok')}  pruned downloads: "
+        f"removed {humanize_size(result.removed_bytes)}, "
+        f"{result.removed_count} {files}; kept {result.kept_count} indexed artifacts"
+        f"{stale}"
+    )
+    return 0
+
+
+def _files(count: int) -> str:
+    return "file" if count == 1 else "files"