glaip-sdk 0.1.2__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

@@ -5,21 +5,66 @@ Authors:
 """
 
 import os
+from copy import deepcopy
 from pathlib import Path
 from typing import Any
 
 import yaml
 
-CONFIG_DIR = Path.home() / ".aip"
+_ENV_CONFIG_DIR = os.getenv("AIP_CONFIG_DIR")
+# Detect pytest environment: check for pytest markers or test session
+# This provides automatic test isolation even if conftest.py doesn't set AIP_CONFIG_DIR
+# Note: conftest.py sets AIP_CONFIG_DIR before imports, which takes precedence
+_TEST_ENV = os.getenv("PYTEST_CURRENT_TEST") or os.getenv("PYTEST_XDIST_WORKER") or os.getenv("_PYTEST_RAISE")
+
+if _ENV_CONFIG_DIR:
+    # Explicit override via environment variable (highest priority)
+    # This is set by conftest.py before imports, ensuring test isolation
+    CONFIG_DIR = Path(_ENV_CONFIG_DIR)
+elif _TEST_ENV:
+    # Isolate test runs (including xdist workers) from the real user config directory
+    # Use a per-process unique temp directory to avoid conflicts in parallel test runs
+    import tempfile
+    import uuid
+
+    # Create a unique temp dir per test process to avoid conflicts
+    temp_base = Path(tempfile.gettempdir())
+    test_config_dir = temp_base / f"aip-test-config-{os.getpid()}-{uuid.uuid4().hex[:8]}"
+    CONFIG_DIR = test_config_dir
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+else:  # pragma: no cover - default path used outside test runs
+    CONFIG_DIR = Path.home() / ".aip"
+
 CONFIG_FILE = CONFIG_DIR / "config.yaml"
-_ALLOWED_KEYS = {"api_url", "api_key", "timeout"}
+_ALLOWED_KEYS = {
+    "api_url",
+    "api_key",
+    "timeout",
+    "history_default_limit",
+}
+# Keys that must be preserved for multi-account support
+_PRESERVE_KEYS = {
+    "version",
+    "active_account",
+    "accounts",
+    "tui",
+}
 
 
 def _sanitize_config(data: dict[str, Any] | None) -> dict[str, Any]:
-    """Return config filtered to allowed keys only."""
+    """Return config filtered to allowed keys only, preserving multi-account keys."""
     if not data:
         return {}
-    return {k: v for k, v in data.items() if k in _ALLOWED_KEYS}
+    result: dict[str, Any] = {}
+    # Preserve multi-account structure (defensively copy to avoid callers mutating source)
+    for key in _PRESERVE_KEYS:
+        if key in data:
+            result[key] = deepcopy(data[key])
+    # Add allowed legacy keys (copied to avoid side effects)
+    for key in _ALLOWED_KEYS:
+        if key in data:
+            result[key] = deepcopy(data[key])
+    return result
 
 
 def load_config() -> dict[str, Any]:

glaip_sdk/cli/constants.py

@@ -0,0 +1,38 @@
+"""CLI-specific constants for glaip-sdk.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+# Minimum length that forces multiline YAML strings to be rendered using the literal
+# block style. This prevents long prompts and instructions from being inlined.
+LITERAL_STRING_THRESHOLD = 200
+
+# Masking configuration
+MASKING_ENABLED = True
+MASK_SENSITIVE_FIELDS = {
+    "api_key",
+    "apikey",
+    "token",
+    "access_token",
+    "secret",
+    "client_secret",
+    "password",
+    "private_key",
+    "bearer",
+}
+
+# Table + pager behaviour
+TABLE_SORT_ENABLED = True
+PAGER_MODE = "auto"  # valid values: "auto", "on", "off"
+PAGER_WRAP_LINES = False
+PAGER_HEADER_ENABLED = True
+
+# Update notification toggle
+UPDATE_CHECK_ENABLED = True
+
+# Agent instruction preview defaults
+DEFAULT_AGENT_INSTRUCTION_PREVIEW_LIMIT = 800
+
+# Remote runs defaults
+DEFAULT_REMOTE_RUNS_PAGE_LIMIT = 20

glaip_sdk/cli/context.py

@@ -106,6 +106,14 @@ def output_flags() -> Callable[[Callable[..., Any]], Callable[..., Any]]:
     """
 
     def decorator(f: Callable[..., Any]) -> Callable[..., Any]:
+        """Apply output flags to a click command.
+
+        Args:
+            f: Click command function to decorate.
+
+        Returns:
+            Decorated command function.
+        """
         f = click.option(
             "--json",
             "json_mode",

glaip_sdk/cli/core/__init__.py

@@ -0,0 +1,79 @@
+"""CLI core modules for glaip-sdk.
+
+This package contains focused modules extracted from the monolithic cli/utils.py:
+- context: Click context helpers, config loading, credential resolution
+- prompting: prompt_toolkit + questionary wrappers, validators
+- rendering: Rich console helpers, viewer launchers, renderer builders
+- output: Table/console output utilities, list rendering
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""  # pylint: disable=duplicate-code
+
+from __future__ import annotations
+
+# Re-export all public APIs from submodules for convenience
+from glaip_sdk.cli.core.context import (
+    bind_slash_session_context,
+    get_client,
+    handle_best_effort_check,
+    restore_slash_session_context,
+)
+from glaip_sdk.cli.core.output import (
+    coerce_to_row,
+    detect_export_format,
+    fetch_resource_for_export,
+    format_datetime_fields,
+    format_size,
+    handle_resource_export,
+    output_list,
+    output_result,
+    parse_json_line,
+    resolve_resource,
+    handle_ambiguous_resource,
+    sdk_version,
+)
+from glaip_sdk.cli.core.prompting import (
+    _fuzzy_pick_for_resources,
+    prompt_export_choice_questionary,
+    questionary_safe_ask,
+)
+from glaip_sdk.cli.core.rendering import (
+    build_renderer,
+    spinner_context,
+    stop_spinner,
+    update_spinner,
+    with_client_and_spinner,
+)
+
+__all__ = [
+    # Context
+    "bind_slash_session_context",
+    "get_client",
+    "handle_best_effort_check",
+    "restore_slash_session_context",
+    # Prompting
+    "_fuzzy_pick_for_resources",
+    "prompt_export_choice_questionary",
+    "questionary_safe_ask",
+    # Rendering
+    "build_renderer",
+    "spinner_context",
+    "stop_spinner",
+    "update_spinner",
+    "with_client_and_spinner",
+    # Output
+    "coerce_to_row",
+    "detect_export_format",
+    "fetch_resource_for_export",
+    "format_datetime_fields",
+    "format_size",
+    "handle_resource_export",
+    "output_list",
+    "output_result",
+    "parse_json_line",
+    "resolve_resource",
+    "handle_ambiguous_resource",
+    "sdk_version",
+]

glaip_sdk/cli/core/context.py

@@ -0,0 +1,124 @@
+"""CLI context helpers, config loading, and credential resolution.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import importlib
+import os
+from collections.abc import Mapping
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Any, cast
+
+import click
+
+from glaip_sdk.cli.config import load_config
+from glaip_sdk.cli.hints import command_hint
+
+if TYPE_CHECKING:  # pragma: no cover - import-only during type checking
+    from glaip_sdk import Client
+
+
+@contextmanager
+def bind_slash_session_context(ctx: Any, session: Any) -> Any:
+    """Temporarily attach a slash session to the Click context.
+
+    Args:
+        ctx: Click context object.
+        session: SlashSession instance to bind.
+
+    Yields:
+        None - context manager for use in with statement.
+    """
+    ctx_obj = getattr(ctx, "obj", None)
+    has_context = isinstance(ctx_obj, dict)
+    previous_session = ctx_obj.get("_slash_session") if has_context else None
+    if has_context:
+        ctx_obj["_slash_session"] = session
+    try:
+        yield
+    finally:
+        if has_context:
+            if previous_session is None:
+                ctx_obj.pop("_slash_session", None)
+            else:
+                ctx_obj["_slash_session"] = previous_session
+
+
+def restore_slash_session_context(ctx_obj: dict[str, Any], previous_session: Any | None) -> None:
+    """Restore slash session context after operation.
+
+    Args:
+        ctx_obj: Click context obj dictionary.
+        previous_session: Previous session to restore, or None to remove.
+    """
+    if previous_session is None:
+        ctx_obj.pop("_slash_session", None)
+    else:
+        ctx_obj["_slash_session"] = previous_session
+
+
+def handle_best_effort_check(
+    check_func: Any,
+) -> None:
+    """Handle best-effort duplicate/existence checks with proper exception handling.
+
+    Args:
+        check_func: Function that performs the check and raises ClickException if duplicate found.
+    """
+    try:
+        check_func()
+    except click.ClickException:
+        raise
+    except Exception:
+        # Non-fatal: best-effort duplicate check
+        pass
+
+
+def get_client(ctx: Any) -> Client:  # pragma: no cover
+    """Get configured client from context and account store (ctx > account)."""
+    # Import here to avoid circular import
+    from glaip_sdk.cli.auth import resolve_credentials  # noqa: PLC0415
+
+    module = importlib.import_module("glaip_sdk")
+    client_class = cast("type[Client]", module.Client)
+    context_config_obj = getattr(ctx, "obj", None)
+    context_config = context_config_obj if isinstance(context_config_obj, Mapping) else {}
+
+    account_name = context_config.get("account_name")
+    api_url, api_key, _ = resolve_credentials(
+        account_name=account_name,
+        api_url=context_config.get("api_url"),
+        api_key=context_config.get("api_key"),
+    )
+
+    if not api_url or not api_key:
+        configure_hint = command_hint("accounts add", slash_command="login", ctx=ctx)
+        actions: list[str] = []
+        if configure_hint:
+            actions.append(f"Run `{configure_hint}` to add an account profile")
+        else:
+            actions.append("add an account with 'aip accounts add'")
+        raise click.ClickException(f"Missing api_url/api_key. {' or '.join(actions)}.")
+
+    # Get timeout from context or config
+    timeout = context_config.get("timeout")
+    if timeout is None:
+        raw_timeout = os.getenv("AIP_TIMEOUT", "0") or "0"
+        try:
+            timeout = float(raw_timeout) if raw_timeout != "0" else None
+        except ValueError:
+            timeout = None
+    if timeout is None:
+        # Fallback to legacy config
+        file_config = load_config() or {}
+        timeout = file_config.get("timeout")
+
+    return client_class(
+        api_url=api_url,
+        api_key=api_key,
+        timeout=float(timeout or 30.0),
+    )