glaip-sdk 0.0.0b99__py3-none-any.whl

glaip_sdk/cli/commands/update.py

@@ -0,0 +1,192 @@
+"""Update command for upgrading the glaip-sdk package.
+
+Author:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+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
+
+from glaip_sdk.branding import ACCENT_STYLE, ERROR_STYLE, INFO_STYLE, SUCCESS_STYLE
+
+PACKAGE_NAME = "glaip-sdk"
+
+
+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, 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")
+@click.option(
+    "--pre",
+    "include_prerelease",
+    is_flag=True,
+    help="Include pre-release versions when upgrading.",
+)
+def update_command(include_prerelease: bool) -> None:
+    """Upgrade the glaip-sdk package using pip or uv tool install."""
+    console = Console()
+    # 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,
+        )
+        raise click.ClickException(f"{error_detail}\n{troubleshooting}")
+    upgrade_cmd = _build_upgrade_command(include_prerelease, is_uv=is_uv)
+
+    # Determine the appropriate manual command for error messages
+    manual_cmd = _build_manual_upgrade_command(include_prerelease, is_uv=is_uv)
+
+    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 `{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

@@ -0,0 +1,95 @@
+"""Configuration management utilities.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+import os
+from copy import deepcopy
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+_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",
+    "history_default_limit",
+}
+# Keys that must be preserved for multi-account support
+_PRESERVE_KEYS = {
+    "version",
+    "active_account",
+    "accounts",
+}
+
+
+def _sanitize_config(data: dict[str, Any] | None) -> dict[str, Any]:
+    """Return config filtered to allowed keys only, preserving multi-account keys."""
+    if not data:
+        return {}
+    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]:
+    """Load configuration from file."""
+    if not CONFIG_FILE.exists():
+        return {}
+
+    try:
+        with open(CONFIG_FILE) as f:
+            loaded = yaml.safe_load(f) or {}
+            return _sanitize_config(loaded)
+    except yaml.YAMLError:
+        return {}
+
+
+def save_config(config: dict[str, Any]) -> None:
+    """Save configuration to file."""
+    CONFIG_DIR.mkdir(exist_ok=True)
+
+    sanitized = _sanitize_config(config)
+
+    with open(CONFIG_FILE, "w") as f:
+        yaml.dump(sanitized, f, default_flow_style=False)
+
+    # Set secure file permissions
+    try:
+        os.chmod(CONFIG_FILE, 0o600)
+    except OSError:  # pragma: no cover - permission errors are expected in some environments
+        pass

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

@@ -0,0 +1,150 @@
+"""Context-related helpers for the glaip CLI.
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+import click
+
+__all__ = [
+    "get_ctx_value",
+    "_get_view",
+    "_set_view",
+    "_set_json",
+    "output_flags",
+    "detect_export_format",
+]
+
+
+def get_ctx_value(ctx: Any, key: str, default: Any = None) -> Any:
+    """Safely resolve a value from a click context object.
+
+    Args:
+        ctx: Click context object to extract value from
+        key: Key to retrieve from the context
+        default: Default value if key is not found
+
+    Returns:
+        The value associated with the key, or the default if not found
+    """
+    if ctx is None:
+        return default
+
+    obj = getattr(ctx, "obj", None)
+    if obj is None:
+        return default
+
+    if isinstance(obj, dict):
+        return obj.get(key, default)
+
+    getter = getattr(obj, "get", None)
+    if callable(getter):
+        try:
+            return getter(key, default)
+        except TypeError:
+            return default
+
+    return getattr(obj, key, default) if hasattr(obj, key) else default
+
+
+def _get_view(ctx: Any) -> str:
+    """Resolve the active view preference from context.
+
+    Args:
+        ctx: Click context object containing view preferences
+
+    Returns:
+        The view format string (rich, plain, json, md), defaults to 'rich'
+    """
+    view = get_ctx_value(ctx, "view")
+    if view:
+        return view
+
+    fallback = get_ctx_value(ctx, "format")
+    return fallback or "rich"
+
+
+def _set_view(ctx: Any, _param: Any, value: str) -> None:
+    """Click callback to persist the `--view/--output` option.
+
+    Args:
+        ctx: Click context object to store the view preference
+        _param: Click parameter object (unused)
+        value: The view format string to store
+    """
+    if not value:
+        return
+    ctx.ensure_object(dict)
+    ctx.obj["view"] = value
+
+
+def _set_json(ctx: Any, _param: Any, value: bool) -> None:
+    """Click callback for the `--json` shorthand flag.
+
+    Args:
+        ctx: Click context object to store the view preference
+        _param: Click parameter object (unused)
+        value: Boolean flag indicating json mode
+    """
+    if not value:
+        return
+    ctx.ensure_object(dict)
+    ctx.obj["view"] = "json"
+
+
+def output_flags() -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Decorator to add shared output flags (`--view`, `--json`) to commands.
+
+    Returns:
+        A decorator function that adds output format options to click commands
+    """
+
+    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",
+            is_flag=True,
+            expose_value=False,
+            help="Shortcut for --view json",
+            callback=_set_json,
+        )(f)
+        f = click.option(
+            "-o",
+            "--output",
+            "--view",
+            "view_opt",
+            type=click.Choice(["rich", "plain", "json", "md"]),
+            expose_value=False,
+            help="Output format",
+            callback=_set_view,
+        )(f)
+        return f
+
+    return decorator
+
+
+def detect_export_format(file_path: str | Path) -> str:
+    """Detect the export format from the file extension.
+
+    Args:
+        file_path: Path to the file to analyze
+
+    Returns:
+        The format string ('yaml' or 'json') based on file extension
+    """
+    path = Path(file_path)
+    return "yaml" if path.suffix.lower() in {".yaml", ".yml"} else "json"

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),
+    )