glaip-sdk 0.6.5b3__py3-none-any.whl → 0.7.17__py3-none-any.whl

glaip_sdk/cli/commands/update.py

@@ -6,9 +6,12 @@ Author:
 
 from __future__ import annotations
 
+import importlib.util
+import os
 import subprocess
 import sys
 from collections.abc import Sequence
+from pathlib import Path
 
 import click
 from rich.console import Console
@@ -18,19 +21,132 @@ from glaip_sdk.branding import ACCENT_STYLE, ERROR_STYLE, INFO_STYLE, SUCCESS_ST
 PACKAGE_NAME = "glaip-sdk"
 
 
-def _build_upgrade_command(include_prerelease: bool) -> Sequence[str]:
-    """Return the pip command used to upgrade the SDK."""
-    command = [
-        sys.executable,
-        "-m",
-        "pip",
-        "install",
-        "--upgrade",
-        PACKAGE_NAME,
-    ]
+def _is_uv_managed_environment() -> bool:
+    """Check if running in a uv-managed tool environment.
+
+    Uses a path-based heuristic against sys.executable, sys.prefix, and UV_TOOL_DIR
+    or UV_TOOL_BIN to detect a case-insensitive "uv/tools" segment. Update if uv
+    changes its layout.
+    """
+    if _has_uv_tool_path(sys.executable):
+        return True
+    if _has_uv_tool_path(sys.prefix):
+        return True
+    uv_tool_dir = os.environ.get("UV_TOOL_DIR") or os.environ.get("UV_TOOL_BIN")
+    if uv_tool_dir and _has_uv_tool_path(uv_tool_dir):
+        return True
+    return False
+
+
+def _has_uv_tool_path(path: str) -> bool:
+    """Return True when a path contains a case-insensitive uv/tools segment."""
+    parts = [part.lower() for part in Path(path).parts]
+    for idx, part in enumerate(parts[:-1]):
+        if part == "uv" and parts[idx + 1] == "tools":
+            return True
+    return False
+
+
+def _is_pip_available() -> bool:
+    """Return True when pip can be imported in the current interpreter."""
+    return importlib.util.find_spec("pip") is not None
+
+
+def _build_missing_pip_guidance(
+    *,
+    include_prerelease: bool,
+    package_name: str = PACKAGE_NAME,
+    force_reinstall: bool = False,
+) -> tuple[str, str]:
+    """Return error and troubleshooting guidance when pip is unavailable."""
+    manual_cmd = _build_manual_upgrade_command(
+        include_prerelease,
+        package_name=package_name,
+        is_uv=True,
+        force_reinstall=force_reinstall,
+    )
+    error_detail = "pip is not available in this environment."
+    troubleshooting = (
+        "💡 Troubleshooting:\n"
+        f"   • If you installed via uv tool, run: {manual_cmd}\n"
+        "   • Otherwise install pip: python -m ensurepip"
+    )
+    return error_detail, troubleshooting
+
+
+def _build_command_parts(
+    *,
+    package_name: str = PACKAGE_NAME,
+    is_uv: bool | None = None,
+    force_reinstall: bool = False,
+    include_prerelease: bool = False,
+) -> tuple[list[str], str]:
+    """Build the common parts of upgrade commands.
+
+    Returns:
+        Tuple of (command parts list, force_reinstall flag name).
+        For uv: (["uv", "tool", "install", "--upgrade", package_name], "--reinstall")
+        For pip: (["pip", "install", "--upgrade", package_name], "--force-reinstall")
+    """
+    if is_uv is None:
+        is_uv = _is_uv_managed_environment()
+
+    if is_uv:
+        command = ["uv", "tool", "install", "--upgrade", package_name]
+        reinstall_flag = "--reinstall"
+    else:
+        command = ["pip", "install", "--upgrade", package_name]
+        reinstall_flag = "--force-reinstall"
+
+    if force_reinstall:
+        command.insert(-1, reinstall_flag)
+
     if include_prerelease:
         command.append("--pre")
-    return command
+
+    return command, reinstall_flag
+
+
+def _build_upgrade_command(
+    include_prerelease: bool,
+    *,
+    package_name: str = PACKAGE_NAME,
+    is_uv: bool | None = None,
+    force_reinstall: bool = False,
+) -> Sequence[str]:
+    """Return the command used to upgrade the SDK (pip or uv tool install)."""
+    if is_uv is None:
+        is_uv = _is_uv_managed_environment()
+
+    command_parts, _ = _build_command_parts(
+        package_name=package_name,
+        is_uv=is_uv,
+        force_reinstall=force_reinstall,
+        include_prerelease=include_prerelease,
+    )
+
+    # For pip, prepend sys.executable and -m
+    if not is_uv:
+        command_parts = [sys.executable, "-m"] + command_parts
+
+    return command_parts
+
+
+def _build_manual_upgrade_command(
+    include_prerelease: bool,
+    *,
+    package_name: str = PACKAGE_NAME,
+    is_uv: bool | None = None,
+    force_reinstall: bool = False,
+) -> str:
+    """Return a manual upgrade command string matching the active environment."""
+    command_parts, _ = _build_command_parts(
+        package_name=package_name,
+        is_uv=is_uv,
+        force_reinstall=force_reinstall,
+        include_prerelease=include_prerelease,
+    )
+    return " ".join(command_parts)
 
 
 @click.command(name="update")
@@ -40,22 +156,52 @@ def _build_upgrade_command(include_prerelease: bool) -> Sequence[str]:
     is_flag=True,
     help="Include pre-release versions when upgrading.",
 )
-def update_command(include_prerelease: bool) -> None:
-    """Upgrade the glaip-sdk package using pip."""
+@click.option(
+    "--reinstall",
+    "force_reinstall",
+    is_flag=True,
+    help="Force reinstall even if already up-to-date.",
+)
+def update_command(include_prerelease: bool, force_reinstall: bool) -> None:
+    """Upgrade the glaip-sdk package using pip or uv tool install."""
     console = Console()
-    upgrade_cmd = _build_upgrade_command(include_prerelease)
+    # Call _is_uv_managed_environment() once and pass explicitly to avoid redundant calls
+    is_uv = _is_uv_managed_environment()
+    if not is_uv and not _is_pip_available():
+        error_detail, troubleshooting = _build_missing_pip_guidance(
+            include_prerelease=include_prerelease,
+            force_reinstall=force_reinstall,
+        )
+        raise click.ClickException(f"{error_detail}\n{troubleshooting}")
+    upgrade_cmd = _build_upgrade_command(
+        include_prerelease,
+        is_uv=is_uv,
+        force_reinstall=force_reinstall,
+    )
+
+    # Determine the appropriate manual command for error messages
+    manual_cmd = _build_manual_upgrade_command(
+        include_prerelease,
+        is_uv=is_uv,
+        force_reinstall=force_reinstall,
+    )
+
     console.print(f"[{ACCENT_STYLE}]Upgrading {PACKAGE_NAME} using[/] [{INFO_STYLE}]{' '.join(upgrade_cmd)}[/]")
 
     try:
         subprocess.run(upgrade_cmd, check=True)
     except FileNotFoundError as exc:
+        if is_uv:
+            raise click.ClickException(
+                f"Unable to locate uv executable. Please ensure uv is installed and on your PATH.\n"
+                f"Install uv: curl -LsSf https://astral.sh/uv/install.sh | sh\n"
+                f"Or run manually: {manual_cmd}"
+            ) from exc
         raise click.ClickException(
             "Unable to locate Python executable to run pip. Please ensure Python is installed and try again."
         ) from exc
     except subprocess.CalledProcessError as exc:
-        console.print(
-            f"[{ERROR_STYLE}]Automatic upgrade failed.[/] Please run `pip install -U {PACKAGE_NAME}` manually."
-        )
+        console.print(f"[{ERROR_STYLE}]Automatic upgrade failed.[/] Please run `{manual_cmd}` manually.")
         raise click.ClickException("Automatic upgrade failed.") from exc
 
     console.print(f"[{SUCCESS_STYLE}]✅ {PACKAGE_NAME} upgraded successfully.[/]")

glaip_sdk/cli/config.py

@@ -47,6 +47,7 @@ _PRESERVE_KEYS = {
     "version",
     "active_account",
     "accounts",
+    "tui",
 }
 
 

glaip_sdk/cli/core/output.py

@@ -29,12 +29,6 @@ from glaip_sdk.cli.io import export_resource_to_file_with_validation
 from glaip_sdk.cli.rich_helpers import markup_text, print_markup
 from glaip_sdk.rich_components import AIPPanel, AIPTable
 from glaip_sdk.utils import format_datetime, is_uuid
-
-try:
-    from glaip_sdk import _version as _version_module
-except ImportError:  # pragma: no cover - defensive import
-    _version_module = None
-
 from .prompting import (
     _fuzzy_pick,
     _fuzzy_pick_for_resources,
@@ -43,6 +37,9 @@ from .prompting import (
 )
 from .rendering import _spinner_stop, _spinner_update, spinner_context
 
+_VERSION_MODULE_MISSING = object()
+_version_module: Any | None = _VERSION_MODULE_MISSING
+
 console = Console()
 pager.console = console
 logger = logging.getLogger("glaip_sdk.cli.core.output")
@@ -236,7 +233,15 @@ def handle_resource_export(
 
 def sdk_version() -> str:
     """Return the current SDK version, warning if metadata is unavailable."""
-    global _WARNED_SDK_VERSION_FALLBACK
+    global _WARNED_SDK_VERSION_FALLBACK, _version_module
+
+    if _version_module is _VERSION_MODULE_MISSING:
+        try:
+            from importlib import import_module  # noqa: PLC0415
+
+            _version_module = import_module("glaip_sdk._version")
+        except Exception:  # pragma: no cover - defensive fallback
+            _version_module = None
 
     if _version_module is None:
         if not _WARNED_SDK_VERSION_FALLBACK:

glaip_sdk/cli/entrypoint.py

@@ -0,0 +1,20 @@
+"""Entry point wrapper for early logging configuration.
+
+This must be imported BEFORE glaip_sdk.cli.main to catch import-time warnings.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+import sys
+
+# Configure logging BEFORE importing anything else
+from glaip_sdk.runner.logging_config import setup_cli_logging
+
+setup_cli_logging()
+
+# Now import and run CLI
+from glaip_sdk.cli import main  # noqa: E402
+
+if __name__ == "__main__":
+    sys.exit(main())  # pylint: disable=no-value-for-parameter

glaip_sdk/cli/main.py

@@ -11,8 +11,6 @@ from typing import Any
 
 import click
 from rich.console import Console
-
-from glaip_sdk import Client
 from glaip_sdk.branding import (
     ERROR,
     ERROR_STYLE,
@@ -37,21 +35,50 @@ from glaip_sdk.cli.commands.mcps import mcps_group
 from glaip_sdk.cli.commands.models import models_group
 from glaip_sdk.cli.commands.tools import tools_group
 from glaip_sdk.cli.commands.transcripts import transcripts_group
-from glaip_sdk.cli.commands.update import _build_upgrade_command, update_command
+from glaip_sdk.cli.commands.update import (
+    _build_missing_pip_guidance,
+    _build_manual_upgrade_command,
+    _build_upgrade_command,
+    _is_pip_available,
+    _is_uv_managed_environment,
+    update_command,
+)
 from glaip_sdk.cli.config import load_config
 from glaip_sdk.cli.hints import in_slash_mode
+from glaip_sdk.cli.core.output import format_size, sdk_version
+from glaip_sdk.cli.core.rendering import spinner_context, update_spinner
 from glaip_sdk.cli.transcript import get_transcript_cache_stats
 from glaip_sdk.cli.update_notifier import maybe_notify_update
-from glaip_sdk.cli.utils import format_size, sdk_version, spinner_context, update_spinner
 from glaip_sdk.config.constants import (
     DEFAULT_AGENT_RUN_TIMEOUT,
 )
 from glaip_sdk.icons import ICON_AGENT
 from glaip_sdk.rich_components import AIPPanel, AIPTable
 
+# Constants
+UPDATE_ERROR_TITLE = "❌ Update Error"
+
+Client: type[Any] | None = None
+
+
+def _resolve_client_class() -> type[Any]:
+    """Resolve the Client class lazily to avoid heavy imports at CLI startup."""
+    global Client
+    if Client is None:
+        from glaip_sdk import Client as ClientClass  # noqa: PLC0415
+
+        Client = ClientClass
+    return Client
+
 
 def _suppress_chatty_loggers() -> None:
     """Silence noisy SDK/httpx logs for CLI output."""
+    # Ensure CLI logging is configured (idempotent)
+    from glaip_sdk.runner.logging_config import setup_cli_logging  # noqa: PLC0415
+
+    setup_cli_logging()
+
+    # Also suppress SDK-specific loggers
     noisy_loggers = [
         "glaip_sdk.client",
         "httpx",
@@ -227,26 +254,40 @@ def _load_and_merge_config(ctx: click.Context) -> dict:
 
 def _validate_config_and_show_error(config: dict, console: Console) -> None:
     """Validate configuration and show error if incomplete."""
-    store = get_account_store()
-    has_accounts = bool(store.list_accounts())
-    if not config.get("api_url") or not config.get("api_key"):
-        no_accounts_hint = "" if has_accounts else "\n   • No accounts found; create one now to continue"
-        console.print(
-            AIPPanel(
-                f"[{ERROR_STYLE}]❌ Configuration incomplete[/]\n\n"
-                f"🔍 Current config:\n"
-                f"   • API URL: {config.get('api_url', 'Not set')}\n"
-                f"   • API Key: {'***' + config.get('api_key', '')[-4:] if config.get('api_key') else 'Not set'}\n\n"
-                f"💡 To fix this:\n"
-                f"   • Run 'aip accounts add default' to set up credentials\n"
-                f"   • Or run 'aip configure' for interactive setup\n"
-                f"   • Or run 'aip accounts list' to see current accounts{no_accounts_hint}",
-                title="❌ Configuration Error",
-                border_style=ERROR,
-            ),
-        )
-        console.print(f"\n[{SUCCESS_STYLE}]✅ AIP - Ready[/] (SDK v{sdk_version()}) - Configure to connect")
-        sys.exit(1)
+    if config.get("api_url") and config.get("api_key"):
+        return
+
+    # Best effort: avoid failing validation due to config I/O issues.
+    has_accounts = True
+    logger = logging.getLogger(__name__)
+    try:
+        store = get_account_store()
+        try:
+            has_accounts = bool(store.list_accounts())
+        except Exception:
+            logger.warning("Failed to list accounts from account store.", exc_info=True)
+            has_accounts = True
+    except Exception:
+        logger.warning("Failed to initialize account store.", exc_info=True)
+        has_accounts = True
+
+    no_accounts_hint = "" if has_accounts else "\n   • No accounts found; create one now to continue"
+    console.print(
+        AIPPanel(
+            f"[{ERROR_STYLE}]❌ Configuration incomplete[/]\n\n"
+            f"🔍 Current config:\n"
+            f"   • API URL: {config.get('api_url', 'Not set')}\n"
+            f"   • API Key: {'***' + config.get('api_key', '')[-4:] if config.get('api_key') else 'Not set'}\n\n"
+            f"💡 To fix this:\n"
+            f"   • Run 'aip accounts add default' to set up credentials\n"
+            f"   • Or run 'aip configure' for interactive setup\n"
+            f"   • Or run 'aip accounts list' to see current accounts{no_accounts_hint}",
+            title="❌ Configuration Error",
+            border_style=ERROR,
+        ),
+    )
+    console.print(f"\n[{SUCCESS_STYLE}]✅ AIP - Ready[/] (SDK v{sdk_version()}) - Configure to connect")
+    sys.exit(1)
 
 
 def _resolve_status_console(ctx: Any) -> tuple[Console, bool]:
@@ -339,14 +380,15 @@ def _safe_list_call(obj: Any, attr: str) -> list[Any]:
 
 def _get_client_from_config(config: dict) -> Any:
     """Return a Client instance built from config."""
-    return Client(
+    client_class = _resolve_client_class()
+    return client_class(
         api_url=config["api_url"],
         api_key=config["api_key"],
         timeout=config.get("timeout", 30.0),
     )
 
 
-def _create_and_test_client(config: dict, console: Console, *, compact: bool = False) -> Client:
+def _create_and_test_client(config: dict, console: Console, *, compact: bool = False) -> Any:
     """Create client and test connection by fetching resources."""
     client: Any = _get_client_from_config(config)
 
@@ -538,13 +580,39 @@ def update(check_only: bool, force: bool) -> None:
             ),
         )
 
-        # Update using pip
+        # Update using pip or uv tool install
         try:
-            cmd = list(_build_upgrade_command(include_prerelease=False))
-            # Replace package name with "glaip-sdk" (main.py uses different name)
-            cmd[-1] = "glaip-sdk"
-            if force:
-                cmd.insert(5, "--force-reinstall")
+            is_uv = _is_uv_managed_environment()
+            if not is_uv and not _is_pip_available():
+                error_detail, troubleshooting = _build_missing_pip_guidance(
+                    include_prerelease=False,
+                    package_name="glaip-sdk",
+                    force_reinstall=force,
+                )
+                console.print(
+                    AIPPanel(
+                        f"[{ERROR_STYLE}]❌ Update failed[/]\n\n🔍 Error: {error_detail}\n\n{troubleshooting}",
+                        title=UPDATE_ERROR_TITLE,
+                        border_style=ERROR,
+                        padding=(0, 1),
+                    ),
+                )
+                sys.exit(1)
+            cmd = list(
+                _build_upgrade_command(
+                    include_prerelease=False,
+                    package_name="glaip-sdk",
+                    is_uv=is_uv,
+                    force_reinstall=force,
+                )
+            )
+
+            manual_cmd = _build_manual_upgrade_command(
+                include_prerelease=False,
+                package_name="glaip-sdk",
+                is_uv=is_uv,
+                force_reinstall=force,
+            )
             subprocess.run(cmd, capture_output=True, text=True, check=True)
 
             verify_hint = ""
@@ -571,16 +639,36 @@ def update(check_only: bool, force: bool) -> None:
             )
             console.print(f"📋 New version: {version_result.stdout.strip()}")
 
+        except FileNotFoundError:
+            troubleshooting = f"💡 Troubleshooting:\n   • Try running: {manual_cmd}\n"
+            if is_uv:
+                troubleshooting += "   • Ensure uv is installed: curl -LsSf https://astral.sh/uv/install.sh | sh"
+                error_detail = "uv executable not found in your PATH."
+            else:
+                troubleshooting += "   • Ensure Python and pip are installed"
+                error_detail = "Python executable not found to run pip."
+            console.print(
+                AIPPanel(
+                    f"[{ERROR_STYLE}]❌ Update failed[/]\n\n🔍 Error: {error_detail}\n\n{troubleshooting}",
+                    title=UPDATE_ERROR_TITLE,
+                    border_style=ERROR,
+                    padding=(0, 1),
+                ),
+            )
+            sys.exit(1)
         except subprocess.CalledProcessError as e:
+            troubleshooting = (
+                f"💡 Troubleshooting:\n   • Check your internet connection\n   • Try running: {manual_cmd}\n"
+            )
+            if is_uv:
+                troubleshooting += "   • Ensure uv is installed: curl -LsSf https://astral.sh/uv/install.sh | sh"
+            else:
+                troubleshooting += "   • Check if you have write permissions"
+
             console.print(
                 AIPPanel(
-                    f"[{ERROR_STYLE}]❌ Update failed[/]\n\n"
-                    f"🔍 Error: {e.stderr}\n\n"
-                    "💡 Troubleshooting:\n"
-                    "   • Check your internet connection\n"
-                    "   • Try running: pip install --upgrade glaip-sdk\n"
-                    "   • Check if you have write permissions",
-                    title="❌ Update Error",
+                    f"[{ERROR_STYLE}]❌ Update failed[/]\n\n🔍 Error: {e.stderr}\n\n{troubleshooting}",
+                    title=UPDATE_ERROR_TITLE,
                     border_style=ERROR,
                     padding=(0, 1),
                 ),

glaip_sdk/cli/pager.py

@@ -46,11 +46,11 @@ def _get_console() -> Console:
     """
     global console
     try:
-        cli_utils = importlib.import_module("glaip_sdk.cli.utils")
+        cli_output = importlib.import_module("glaip_sdk.cli.core.output")
     except Exception:  # pragma: no cover - fallback during import cycles
-        cli_utils = None
+        cli_output = None
 
-    current_console = getattr(cli_utils, "console", None) if cli_utils else None
+    current_console = getattr(cli_output, "console", None) if cli_output else None
     if current_console is not None and current_console is not console:
         console = current_console
 

glaip_sdk/cli/resolution.py

@@ -13,7 +13,8 @@ from typing import Any
 import click
 
 from glaip_sdk.branding import ACCENT_STYLE
-from glaip_sdk.cli.utils import resolve_resource, spinner_context
+from glaip_sdk.cli.core.output import resolve_resource
+from glaip_sdk.cli.core.rendering import spinner_context
 
 
 def resolve_resource_reference(