glaip-sdk 0.6.12__py3-none-any.whl → 0.6.14__py3-none-any.whl

glaip_sdk/cli/core/rendering.py

@@ -1,187 +0,0 @@
-"""CLI rendering utilities: Rich console helpers, viewer launchers, renderer builders.
-
-Authors:
-    Raymond Christopher (raymond.christopher@gdplabs.id)
-    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
-"""
-
-from __future__ import annotations
-
-import os
-import sys
-from contextlib import AbstractContextManager, contextmanager, nullcontext
-from typing import Any
-
-from rich.console import Console
-
-from glaip_sdk.branding import ACCENT_STYLE
-from glaip_sdk.cli.context import _get_view, get_ctx_value
-from glaip_sdk.utils.rendering.renderer import (
-    CapturingConsole,
-    RendererFactoryOptions,
-    RichStreamRenderer,
-    make_default_renderer,
-    make_verbose_renderer,
-)
-
-# Export console for backward compatibility
-console = Console()
-
-
-def _can_use_spinner(ctx: Any | None, active_console: Console) -> bool:
-    """Check if spinner output is allowed in the current environment."""
-    if ctx is not None:
-        tty_enabled = bool(get_ctx_value(ctx, "tty", True))
-        view = (_get_view(ctx) or "rich").lower()
-        if not tty_enabled or view not in {"", "rich"}:
-            return False
-
-    if not active_console.is_terminal:
-        return False
-
-    return _stream_supports_tty(getattr(active_console, "file", None))
-
-
-def _stream_supports_tty(stream: Any) -> bool:
-    """Return True if the provided stream can safely render a spinner."""
-    target = stream if hasattr(stream, "isatty") else sys.stdout
-    try:
-        return bool(target.isatty())
-    except Exception:
-        return False
-
-
-def update_spinner(status_indicator: Any | None, message: str) -> None:
-    """Update spinner text when a status indicator is active."""
-    if status_indicator is None:
-        return
-
-    try:
-        status_indicator.update(message)
-    except Exception:  # pragma: no cover - defensive update
-        pass
-
-
-def stop_spinner(status_indicator: Any | None) -> None:
-    """Stop an active spinner safely."""
-    if status_indicator is None:
-        return
-
-    try:
-        status_indicator.stop()
-    except Exception:  # pragma: no cover - defensive stop
-        pass
-
-
-# Backwards compatibility aliases for legacy callers
-_spinner_update = update_spinner
-_spinner_stop = stop_spinner
-
-
-def spinner_context(
-    ctx: Any | None,
-    message: str,
-    *,
-    console_override: Console | None = None,
-    spinner: str = "dots",
-    spinner_style: str = ACCENT_STYLE,
-) -> AbstractContextManager[Any]:
-    """Return a context manager that renders a spinner when appropriate."""
-    active_console = console_override or console
-    if not _can_use_spinner(ctx, active_console):
-        return nullcontext()
-
-    status = active_console.status(
-        message,
-        spinner=spinner,
-        spinner_style=spinner_style,
-    )
-
-    if not hasattr(status, "__enter__") or not hasattr(status, "__exit__"):
-        return nullcontext()
-
-    return status
-
-
-def _register_renderer_with_session(ctx: Any, renderer: RichStreamRenderer) -> None:
-    """Attach renderer to an active slash session when present."""
-    try:
-        ctx_obj = getattr(ctx, "obj", None)
-        session = ctx_obj.get("_slash_session") if isinstance(ctx_obj, dict) else None
-        if session and hasattr(session, "register_active_renderer"):
-            session.register_active_renderer(renderer)
-    except Exception:
-        # Never let session bookkeeping break renderer creation
-        pass
-
-
-def build_renderer(
-    _ctx: Any,
-    *,
-    save_path: str | os.PathLike[str] | None,
-    verbose: bool = False,
-    _tty_enabled: bool = True,
-    live: bool | None = None,
-    snapshots: bool | None = None,
-) -> tuple[RichStreamRenderer, Console | CapturingConsole]:
-    """Build renderer and capturing console for CLI commands.
-
-    Args:
-        _ctx: Click context object for CLI operations.
-        save_path: Path to save output to (enables capturing console).
-        verbose: Whether to enable verbose mode.
-        _tty_enabled: Whether TTY is available for interactive features.
-        live: Whether to enable live rendering mode (overrides verbose default).
-        snapshots: Whether to capture and store snapshots.
-
-    Returns:
-        Tuple of (renderer, capturing_console) for streaming output.
-    """
-    # Use capturing console if saving output
-    working_console = CapturingConsole(console, capture=True) if save_path else console
-
-    # Configure renderer based on verbose mode and explicit overrides
-    live_enabled = bool(live) if live is not None else not verbose
-    cfg_overrides = {
-        "live": live_enabled,
-        "append_finished_snapshots": bool(snapshots) if snapshots is not None else False,
-    }
-    renderer_console = (
-        working_console.original_console if isinstance(working_console, CapturingConsole) else working_console
-    )
-    factory = make_verbose_renderer if verbose else make_default_renderer
-    factory_options = RendererFactoryOptions(
-        console=renderer_console,
-        cfg_overrides=cfg_overrides,
-        verbose=verbose if factory is make_default_renderer else None,
-    )
-    renderer = factory_options.build(factory)
-
-    # Link the renderer back to the slash session when running from the palette.
-    _register_renderer_with_session(_ctx, renderer)
-
-    return renderer, working_console
-
-
-@contextmanager
-def with_client_and_spinner(
-    ctx: Any,
-    spinner_message: str,
-    *,
-    console_override: Console | None = None,
-) -> Any:
-    """Context manager for commands that need client and spinner.
-
-    Args:
-        ctx: Click context.
-        spinner_message: Message to display in spinner.
-        console_override: Optional console override.
-
-    Yields:
-        Client instance.
-    """
-    from glaip_sdk.cli.core.context import get_client  # noqa: PLC0415
-
-    client = get_client(ctx)
-    with spinner_context(ctx, spinner_message, console_override=console_override):
-        yield client

glaip_sdk/cli/display.py

@@ -1,355 +0,0 @@
-"""CLI display utilities for success/failure panels and Rich renderers.
-
-This module handles all display-related functionality for CLI commands,
-including success messages, error handling, and output formatting.
-
-Authors:
-    Raymond Christopher (raymond.christopher@gdplabs.id)
-"""
-
-import json
-from typing import Any
-
-import click
-from rich.console import Console
-from rich.panel import Panel
-from rich.text import Text
-
-from glaip_sdk.branding import ERROR_STYLE, SUCCESS, SUCCESS_STYLE, WARNING_STYLE
-from glaip_sdk.cli.hints import command_hint, format_command_hint, in_slash_mode
-from glaip_sdk.cli.rich_helpers import markup_text
-from glaip_sdk.icons import ICON_AGENT, ICON_TOOL
-from glaip_sdk.rich_components import AIPPanel
-
-console = Console()
-
-
-def display_creation_success(
-    resource_type: str, resource_name: str, resource_id: str, **additional_fields: Any
-) -> Panel:
-    """Create standardized success message for resource creation.
-
-    Args:
-        resource_type: Type of resource (e.g., "Agent", "Tool", "MCP")
-        resource_name: Name of the created resource
-        resource_id: ID of the created resource
-        **additional_fields: Additional fields to display
-
-    Returns:
-        Rich Panel object for display
-    """
-    # Build additional fields display
-    fields_display = ""
-    if additional_fields:
-        fields_display = "\n" + "\n".join(f"{key}: {value}" for key, value in additional_fields.items())
-
-    return AIPPanel(
-        f"[{SUCCESS_STYLE}]✅ {resource_type} '{resource_name}' created successfully![/]\n\n"
-        f"ID: {resource_id}{fields_display}",
-        title=f"{ICON_AGENT} {resource_type} Created",
-        border_style=SUCCESS,
-        padding=(0, 1),
-    )
-
-
-def display_update_success(resource_type: str, resource_name: str) -> Text:
-    """Create standardized success message for resource update.
-
-    Args:
-        resource_type: Type of resource (e.g., "Agent", "Tool", "MCP")
-        resource_name: Name of the updated resource
-
-    Returns:
-        Rich Text object for display
-    """
-    return markup_text(f"[{SUCCESS_STYLE}]✅ {resource_type} '{resource_name}' updated successfully[/]")
-
-
-def display_deletion_success(resource_type: str, resource_name: str) -> Text:
-    """Create standardized success message for resource deletion.
-
-    Args:
-        resource_type: Type of resource (e.g., "Agent", "Tool", "MCP")
-        resource_name: Name of the deleted resource
-
-    Returns:
-        Rich Text object for display
-    """
-    return markup_text(f"[{SUCCESS_STYLE}]✅ {resource_type} '{resource_name}' deleted successfully[/]")
-
-
-def display_api_error(error: Exception, operation: str = "operation") -> None:
-    """Display standardized API error message.
-
-    Args:
-        error: The exception that occurred
-        operation: Description of the operation that failed
-    """
-    error_type = type(error).__name__
-    error_message = markup_text(f"[{ERROR_STYLE}]Error during {operation}: {error}[/]")
-    error_message.no_wrap = True
-    error_message.overflow = "ignore"
-    console.print(error_message)
-
-    error_type_message = markup_text(f"[dim]Error type: {error_type}[/dim]")
-    error_type_message.no_wrap = True
-    error_type_message.overflow = "ignore"
-    console.print(error_type_message)
-
-
-def print_api_error(e: Exception) -> None:
-    """Print API error with consistent formatting for both JSON and Rich views.
-
-    Args:
-        e: The exception to format and display
-
-    Notes:
-        - Extracts status_code, error_type, and payload from APIError exceptions
-        - Provides consistent error reporting across CLI commands
-        - Handles both JSON and Rich output formats
-        - Special handling for validation errors with detailed field-level errors
-    """
-    if not hasattr(e, "__dict__"):
-        console.print(f"[{ERROR_STYLE}]Error: {e}[/]")
-        return
-
-    if not hasattr(e, "status_code"):
-        console.print(f"[{ERROR_STYLE}]Error: {e}[/]")
-        return
-
-    error_text = str(e).strip()
-    if not error_text:
-        error_text = "Unknown error"
-    if "\n" in error_text:
-        error_text = error_text.splitlines()[0]
-    console.print(f"[{ERROR_STYLE}]API Error: {error_text}[/]")
-    status_code = getattr(e, "status_code", None)
-    if status_code is not None:
-        console.print(f"[{WARNING_STYLE}]Status: {status_code}[/]")
-
-    payload = getattr(e, "payload", _MISSING)
-    if payload is _MISSING:
-        return
-
-    if payload:
-        if not _print_structured_payload(payload):
-            console.print(f"[{WARNING_STYLE}]Details: {payload}[/]")
-    else:
-        console.print(f"[{WARNING_STYLE}]Details: {payload}[/]")
-
-
-def _print_structured_payload(payload: Any) -> bool:
-    """Print structured payloads with enhanced formatting. Returns True if handled."""
-    if not isinstance(payload, dict):
-        return False
-
-    if "detail" in payload and _print_validation_details(payload["detail"]):
-        return True
-
-    if "details" in payload and _print_details_field(payload["details"]):
-        return True
-
-    return False
-
-
-def _print_validation_details(detail: Any) -> bool:
-    """Render FastAPI-style validation errors."""
-    if not isinstance(detail, list) or not detail:
-        return False
-
-    console.print(f"[{ERROR_STYLE}]Validation Errors:[/]")
-    for error in detail:
-        if isinstance(error, dict):
-            loc = " -> ".join(str(x) for x in error.get("loc", []))
-            msg = error.get("msg", "Unknown error")
-            error_type = error.get("type", "unknown")
-            location = loc if loc else "field"
-            console.print(f"  [{WARNING_STYLE}]• {location}:[/] {msg}")
-            if error_type != "unknown":
-                console.print(f"    [dim]({error_type})[/dim]")
-        else:
-            console.print(f"  [{WARNING_STYLE}]•[/] {error}")
-    return True
-
-
-def _print_details_field(details: Any) -> bool:
-    """Render custom error details from API payloads."""
-    if not details:
-        return False
-
-    console.print(f"[{ERROR_STYLE}]Error Details:[/]")
-    if isinstance(details, str):
-        console.print(f"  [{WARNING_STYLE}]•[/] {details}")
-    elif isinstance(details, list):
-        for detail in details:
-            console.print(f"  [{WARNING_STYLE}]•[/] {detail}")
-    else:
-        console.print(f"  [{WARNING_STYLE}]•[/] {details}")
-    return True
-
-
-_MISSING = object()
-
-
-def build_resource_result_data(resource: Any, fields: list[str]) -> dict[str, Any]:
-    """Return a normalized mapping of ``fields`` extracted from ``resource``."""
-    result: dict[str, Any] = {}
-    for field in fields:
-        try:
-            value = getattr(resource, field)
-        except AttributeError:
-            value = _MISSING
-        except Exception:
-            value = _MISSING
-
-        result[field] = _normalise_field_value(field, value)
-
-    return result
-
-
-def _normalise_field_value(field: str, value: Any) -> Any:
-    """Convert special sentinel values into display-friendly text."""
-    if value is _MISSING:
-        return "N/A"
-    if hasattr(value, "_mock_name"):
-        return "N/A"
-    if field == "id":
-        return str(value)
-    return value
-
-
-def _get_context_object(ctx: Any) -> dict[str, Any]:
-    """Get context object safely."""
-    ctx_obj = getattr(ctx, "obj", {}) if ctx is not None else {}
-    return ctx_obj if isinstance(ctx_obj, dict) else {}
-
-
-def _should_output_json(ctx_obj: dict[str, Any]) -> bool:
-    """Check if output should be in JSON format."""
-    return ctx_obj.get("view") == "json"
-
-
-def _build_error_output_data(error: Exception) -> dict[str, Any]:
-    """Build error output data with additional error details."""
-    output_data = {"error": str(error)}
-
-    # Add additional error details if available
-    if hasattr(error, "status_code"):
-        output_data["status_code"] = error.status_code
-    if hasattr(error, "error_type"):
-        output_data["error_type"] = error.error_type
-    if hasattr(error, "payload"):
-        output_data["details"] = error.payload
-
-    return output_data
-
-
-def _build_success_output_data(data: Any) -> dict[str, Any]:
-    """Build success output data."""
-    return data if data is not None else {"success": True}
-
-
-def handle_json_output(ctx: Any, data: Any = None, error: Exception = None) -> None:
-    """Handle JSON output format for CLI commands.
-
-    Args:
-        ctx: Click context
-        data: Data to output (for successful operations)
-        error: Error to output (for failed operations)
-    """
-    ctx_obj = _get_context_object(ctx)
-
-    if _should_output_json(ctx_obj):
-        if error:
-            output_data = _build_error_output_data(error)
-        else:
-            output_data = _build_success_output_data(data)
-
-        click.echo(json.dumps(output_data, indent=2, default=str))
-
-
-def handle_rich_output(ctx: Any, rich_content: Any = None) -> None:
-    """Handle Rich output format for CLI commands.
-
-    Args:
-        ctx: Click context
-        rich_content: Rich content to display
-    """
-    ctx_obj = getattr(ctx, "obj", {}) if ctx is not None else {}
-    if not isinstance(ctx_obj, dict):
-        ctx_obj = {}
-
-    if ctx_obj.get("view") != "json" and rich_content:
-        console.print(rich_content)
-
-
-def display_confirmation_prompt(resource_type: str, resource_name: str) -> bool:
-    """Display standardized confirmation prompt for destructive operations.
-
-    Args:
-        resource_type: Type of resource (e.g., "Agent", "Tool", "MCP")
-        resource_name: Name of the resource
-
-    Returns:
-        True if user confirms, False otherwise
-    """
-    if not click.confirm(f"Are you sure you want to delete {resource_type.lower()} '{resource_name}'?"):
-        if console.is_terminal:
-            console.print(Text("Deletion cancelled."))
-        return False
-    return True
-
-
-def display_agent_run_suggestions(agent: Any) -> Panel:
-    """Return a panel with post-creation suggestions for an agent."""
-    agent_id = getattr(agent, "id", "")
-    agent_name = getattr(agent, "name", "")
-    slash_mode = in_slash_mode()
-    run_hint_id = command_hint(
-        f'agents run {agent_id} "Your message here"',
-        slash_command=None,
-    )
-    run_hint_name = command_hint(
-        f'agents run "{agent_name}" "Your message here"',
-        slash_command=None,
-    )
-
-    content_parts: list[str] = ["[bold blue]💡 Next Steps:[/bold blue]\n\n"]
-
-    if slash_mode:
-        slash_shortcuts = "\n".join(
-            f"   {format_command_hint(command, description) or command}"
-            for command, description in (
-                ("/details", "Show configuration (toggle preview)"),
-                ("/help", "Show command palette menu"),
-                ("/exit", "Return to the palette"),
-            )
-        )
-        content_parts.append(
-            f"🚀 Start chatting with [bold]{agent_name}[/bold] right here:\n"
-            f"   Type your message below and press Enter to run it immediately.\n\n"
-            f"{ICON_TOOL} Slash shortcuts:\n"
-            f"{slash_shortcuts}"
-        )
-    else:
-        cli_hint_lines = [format_command_hint(hint) or hint for hint in (run_hint_id, run_hint_name) if hint]
-        if cli_hint_lines:
-            joined_hints = "\n".join(f"   {hint}" for hint in cli_hint_lines)
-            content_parts.append(f"🚀 Run this agent from the CLI:\n{joined_hints}\n\n")
-        content_parts.append(
-            f"{ICON_TOOL} Available options:\n"
-            f"   [dim]--chat-history[/dim]  Include previous conversation\n"
-            f"   [dim]--file[/dim]          Attach files\n"
-            f"   [dim]--input[/dim]         Alternative input method\n"
-            f"   [dim]--timeout[/dim]       Set execution timeout\n"
-            f"   [dim]--save[/dim]          Save transcript to file\n"
-            f"   [dim]--verbose[/dim]       Show detailed execution\n\n"
-            f"💡 [dim]Input text can be positional OR use --input flag (both work!)[/dim]"
-        )
-
-    return AIPPanel(
-        "".join(content_parts),
-        title=f"{ICON_AGENT} Ready to Run Agent",
-        border_style="blue",
-        padding=(0, 1),
-    )

glaip_sdk/cli/hints.py

@@ -1,57 +0,0 @@
-"""Helpers for formatting CLI/slash command hints.
-
-Authors:
-    Raymond Christopher (raymond.christopher@gdplabs.id)
-"""
-
-from __future__ import annotations
-
-import click
-
-from glaip_sdk.branding import HINT_COMMAND_STYLE, HINT_DESCRIPTION_COLOR
-
-
-def in_slash_mode(ctx: click.Context | None = None) -> bool:
-    """Return True when running inside the slash command palette."""
-    if ctx is None:
-        try:
-            ctx = click.get_current_context(silent=True)
-        except RuntimeError:
-            ctx = None
-
-    if ctx is None:
-        return False
-
-    obj = getattr(ctx, "obj", None)
-    if isinstance(obj, dict):
-        return bool(obj.get("_slash_session"))
-
-    return bool(getattr(obj, "_slash_session", False))
-
-
-def command_hint(
-    cli_command: str | None,
-    slash_command: str | None = None,
-    *,
-    ctx: click.Context | None = None,
-) -> str | None:
-    """Return the appropriate command string for the current mode."""
-    if in_slash_mode(ctx):
-        if not slash_command:
-            return None
-        return slash_command if slash_command.startswith("/") else f"/{slash_command}"
-
-    if not cli_command:
-        return None
-    return f"aip {cli_command}"
-
-
-def format_command_hint(command: str | None, description: str | None = None) -> str | None:
-    """Return a Rich markup string that highlights a command hint."""
-    if not command:
-        return None
-
-    highlighted = f"[{HINT_COMMAND_STYLE}]{command}[/]"
-    if description:
-        highlighted += f"  [{HINT_DESCRIPTION_COLOR}]{description}[/{HINT_DESCRIPTION_COLOR}]"
-    return highlighted