glaip-sdk 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

glaip_sdk/cli/display.py

@@ -0,0 +1,244 @@
+"""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.rich_components import AIPPanel
+
+console = Console()
+
+
+def display_creation_success(
+    resource_type: str, resource_name: str, resource_id: str, **additional_fields
+) -> 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"[green]✅ {resource_type} '{resource_name}' created successfully![/green]\n\n"
+        f"ID: {resource_id}{fields_display}",
+        title=f"🤖 {resource_type} Created",
+        border_style="green",
+        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 Text(
+        f"[green]✅ {resource_type} '{resource_name}' updated successfully[/green]"
+    )
+
+
+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 Text(
+        f"[green]✅ {resource_type} '{resource_name}' deleted successfully[/green]"
+    )
+
+
+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__
+    console.print(Text(f"[red]Error during {operation}: {error}[/red]"))
+    console.print(Text(f"[dim]Error type: {error_type}[/dim]"))
+
+
+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
+    """
+    if hasattr(e, "__dict__"):  # Check if it's an APIError-like object
+        error_info = {
+            "error": str(e),
+            "status_code": getattr(e, "status_code", None),
+            "error_type": getattr(e, "error_type", None),
+            "details": getattr(e, "payload", None),
+        }
+
+        # Filter out None values
+        error_info = {k: v for k, v in error_info.items() if v is not None}
+
+        # For JSON view, just return the structured error
+        # (CLI commands handle the JSON formatting)
+        if hasattr(e, "status_code"):
+            console.print(f"[red]API Error: {e}[/red]")
+            if hasattr(e, "status_code"):
+                console.print(f"[yellow]Status: {e.status_code}[/yellow]")
+            if hasattr(e, "payload"):
+                console.print(f"[yellow]Details: {e.payload}[/yellow]")
+        else:
+            console.print(f"[red]Error: {e}[/red]")
+    else:
+        console.print(f"[red]Error: {e}[/red]")
+
+
+_MISSING = object()
+
+
+def build_resource_result_data(resource: Any, fields: list[str]) -> dict[str, Any]:
+    """Return a normalized mapping of ``fields`` extracted from ``resource``."""
+
+    return {
+        field: _normalise_field_value(field, _safe_get_attr(resource, field))
+        for field in fields
+    }
+
+
+def _safe_get_attr(resource: Any, field: str) -> Any:
+    try:
+        return getattr(resource, field, _MISSING)
+    except Exception:
+        return _MISSING
+
+
+def _normalise_field_value(field: str, value: Any) -> Any:
+    if value is _MISSING:
+        return "N/A"
+    if hasattr(value, "_mock_name"):
+        return "N/A"
+    if field == "id":
+        return str(value)
+    return value
+
+
+def handle_json_output(
+    ctx, data: Any = None, error: Exception = None
+) -> None:  # pragma: no cover - formatting covered via integration tests
+    """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 = getattr(ctx, "obj", {}) if ctx is not None else {}
+    if not isinstance(ctx_obj, dict):
+        ctx_obj = {}
+
+    if ctx_obj.get("view") == "json":
+        if error:
+            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
+        else:
+            output_data = data if data is not None else {"success": True}
+
+        click.echo(json.dumps(output_data, indent=2, default=str))
+
+
+def handle_rich_output(ctx, 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."""
+
+    return AIPPanel(
+        f"[bold blue]💡 Next Steps:[/bold blue]\n\n"
+        f"🚀 Run this agent:\n"
+        f'   [green]aip agents run {agent.id} "Your message here"[/green]\n\n'
+        f"📋 Or use the agent name:\n"
+        f'   [green]aip agents run "{agent.name}" "Your message here"[/green]\n\n'
+        f"🔧 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]",
+        title="🤖 Ready to Run Agent",
+        border_style="blue",
+        padding=(0, 1),
+    )

glaip_sdk/cli/io.py

@@ -0,0 +1,106 @@
+"""CLI I/O utilities for file import/export orchestration.
+
+This module handles file operations and network requests for CLI commands,
+wrapping core serialization utilities with Click-friendly error handling.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from pathlib import Path
+from typing import Any
+
+import click
+
+from glaip_sdk.utils.serialization import (
+    collect_attributes_for_export,
+    load_resource_from_file,
+    write_resource_export,
+)
+
+
+def load_resource_from_file_with_validation(
+    file_path: Path, resource_type: str
+) -> dict[str, Any]:
+    """Load resource data from JSON or YAML file with CLI-friendly error handling.
+
+    Args:
+        file_path: Path to the file
+        resource_type: Type of resource (for error messages)
+
+    Returns:
+        Dictionary with resource data
+
+    Raises:
+        click.ClickException: If file operations fail
+    """
+    try:
+        return load_resource_from_file(file_path)
+    except FileNotFoundError:
+        raise click.ClickException(f"File not found: {file_path}")
+    except ValueError as e:
+        raise click.ClickException(f"Invalid {resource_type.lower()} file format: {e}")
+    except Exception as e:
+        raise click.ClickException(f"Failed to load {resource_type.lower()} file: {e}")
+
+
+def export_resource_to_file_with_validation(
+    resource: Any, file_path: Path, format: str = "json"
+) -> None:
+    """Export resource to file with CLI-friendly error handling.
+
+    Args:
+        resource: Resource object to export
+        file_path: Path to export file
+        format: Export format ("json" or "yaml")
+
+    Raises:
+        click.ClickException: If export operations fail
+    """
+    try:
+        # Get all available resource attributes dynamically
+        export_data = collect_attributes_for_export(resource)
+        write_resource_export(file_path, export_data, format)
+    except Exception as e:
+        raise click.ClickException(f"Failed to export resource: {e}")
+
+
+def fetch_raw_resource_details(client, resource, resource_type: str):
+    """Fetch raw resource details directly from API to preserve ALL fields.
+
+    Args:
+        client: API client
+        resource: Resource object
+        resource_type: Type of resource ("agents", "tools", "mcps")
+
+    Returns:
+        Raw API response data or None if failed
+
+    Notes:
+        This is CLI-specific functionality for displaying comprehensive resource details.
+    """
+    from rich.console import Console
+
+    console = Console()
+
+    try:
+        resource_id = str(getattr(resource, "id", "")).strip()
+        if resource_id:
+            # Make direct API call to get raw response
+            response = client.http_client.get(f"/{resource_type}/{resource_id}")
+            response.raise_for_status()
+            raw_response = response.json()
+
+            # If it's a wrapped response (success/data/message), extract the data
+            if isinstance(raw_response, dict) and "data" in raw_response:
+                return raw_response["data"]
+            else:
+                # Direct response
+                return raw_response
+    except Exception as e:
+        console.print(
+            f"[yellow]Failed to fetch raw {resource_type} details: {e}[/yellow]"
+        )
+        # Fall back to regular method
+        return None
+    return None

glaip_sdk/cli/main.py

@@ -10,22 +10,21 @@ import sys
 
 import click
 from rich.console import Console
-from rich.panel import Panel
-from rich.table import Table
 
 from glaip_sdk import Client
 from glaip_sdk._version import __version__ as _SDK_VERSION
+from glaip_sdk.branding import AIPBranding
 from glaip_sdk.cli.commands.agents import agents_group
 from glaip_sdk.cli.commands.configure import (
     config_group,
     configure_command,
     load_config,
 )
-from glaip_sdk.cli.commands.init import init_command
 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.config.constants import DEFAULT_AGENT_RUN_TIMEOUT
+from glaip_sdk.rich_components import AIPPanel, AIPTable
 
 
 @click.group()
@@ -43,17 +42,17 @@ from glaip_sdk.config.constants import DEFAULT_AGENT_RUN_TIMEOUT
 @click.option("--no-tty", is_flag=True, help="Disable TTY renderer")
 @click.pass_context
 def main(ctx, api_url, api_key, timeout, view, no_tty):
-    """AIP SDK Command Line Interface.
+    """GL AIP SDK Command Line Interface.
 
-    A comprehensive CLI for managing AI Agent Platform resources including
+    A comprehensive CLI for managing GL AIP resources including
     agents, tools, MCPs, and more.
 
     Examples:
+        aip version                     # Show detailed version info
         aip configure                   # Configure credentials
         aip agents list                   # List all agents
         aip tools create my_tool.py      # Create a new tool
-        aip agents run my-agent "Hello"  # Run an agent
-        aip init                         # Initialize configuration
+        aip agents run my-agent "Hello world"  # Run an agent
     """
 
     # Store configuration in context
@@ -72,7 +71,6 @@ main.add_command(config_group)
 main.add_command(tools_group)
 main.add_command(mcps_group)
 main.add_command(models_group)
-main.add_command(init_command)
 
 # Add top-level commands
 main.add_command(configure_command)
@@ -89,6 +87,12 @@ def status(ctx):
     try:
         console = Console()
 
+        # Display AIP status banner
+        branding = AIPBranding.create_from_sdk(
+            sdk_version=_SDK_VERSION, package_name="glaip-sdk"
+        )
+        branding.display_status_banner("ready")
+
         # Load config from file and merge with context
         file_config = load_config()
         context_config = ctx.obj or {}
@@ -109,7 +113,7 @@ def status(ctx):
 
         if not config.get("api_url") or not config.get("api_key"):
             console.print(
-                Panel(
+                AIPPanel(
                     "[bold red]❌ Configuration incomplete[/bold red]\n\n"
                     f"🔍 Current config:\n"
                     f"   • API URL: {config.get('api_url', 'Not set')}\n"
@@ -137,7 +141,7 @@ def status(ctx):
             mcps = client.list_mcps()
 
             # Create status table
-            table = Table(title="🔗 AIP Platform Status")
+            table = AIPTable(title="🔗 GL AIP Status")
             table.add_column("Resource", style="cyan", width=15)
             table.add_column("Count", style="green", width=10)
             table.add_column("Status", style="green", width=15)
@@ -147,8 +151,8 @@ def status(ctx):
             table.add_row("MCPs", str(len(mcps)), "✅ Available")
 
             console.print(
-                Panel(
-                    f"[bold green]✅ Connected to AIP Platform[/bold green]\n"
+                AIPPanel(
+                    f"[bold green]✅ Connected to GL AIP[/bold green]\n"
                     f"🔗 API URL: {client.api_url}\n"
                     f"🤖 Agent Run Timeout: {DEFAULT_AGENT_RUN_TIMEOUT}s",
                     title="🚀 Connection Status",
@@ -160,7 +164,7 @@ def status(ctx):
 
         except Exception as e:
             console.print(
-                Panel(
+                AIPPanel(
                     f"[bold yellow]⚠️  Connection established but API call failed[/bold yellow]\n"
                     f"🔗 API URL: {client.api_url}\n"
                     f"❌ Error: {e}\n\n"
@@ -177,7 +181,7 @@ def status(ctx):
 
     except Exception as e:
         console.print(
-            Panel(
+            AIPPanel(
                 f"[bold red]❌ Connection failed[/bold red]\n\n"
                 f"🔍 Error: {e}\n\n"
                 f"💡 Troubleshooting steps:\n"
@@ -195,7 +199,10 @@ def status(ctx):
 @main.command()
 def version():
     """Show version information."""
-    click.echo(f"aip version {_SDK_VERSION}")
+    branding = AIPBranding.create_from_sdk(
+        sdk_version=_SDK_VERSION, package_name="glaip-sdk"
+    )
+    branding.display_version_panel()
 
 
 @main.command()
@@ -214,7 +221,7 @@ def update(check_only: bool, force: bool):
 
         if check_only:
             console.print(
-                Panel(
+                AIPPanel(
                     "[bold blue]🔍 Checking for updates...[/bold blue]\n\n"
                     "💡 To install updates, run: aip update",
                     title="📋 Update Check",
@@ -224,7 +231,7 @@ def update(check_only: bool, force: bool):
             return
 
         console.print(
-            Panel(
+            AIPPanel(
                 "[bold blue]🔄 Updating AIP SDK...[/bold blue]\n\n"
                 "📦 This will update the package from PyPI\n"
                 "💡 Use --check-only to just check for updates",
@@ -249,7 +256,7 @@ def update(check_only: bool, force: bool):
             subprocess.run(cmd, capture_output=True, text=True, check=True)
 
             console.print(
-                Panel(
+                AIPPanel(
                     "[bold green]✅ Update successful![/bold green]\n\n"
                     "🔄 AIP SDK has been updated to the latest version\n"
                     "💡 Restart your terminal or run 'aip --version' to verify",
@@ -270,7 +277,7 @@ def update(check_only: bool, force: bool):
 
         except subprocess.CalledProcessError as e:
             console.print(
-                Panel(
+                AIPPanel(
                     f"[bold red]❌ Update failed[/bold red]\n\n"
                     f"🔍 Error: {e.stderr}\n\n"
                     "💡 Troubleshooting:\n"
@@ -286,7 +293,7 @@ def update(check_only: bool, force: bool):
 
     except ImportError:
         console.print(
-            Panel(
+            AIPPanel(
                 "[bold red]❌ Rich library not available[/bold red]\n\n"
                 "💡 Install rich: pip install rich\n"
                 "   Then try: aip update",

glaip_sdk/cli/resolution.py

@@ -0,0 +1,59 @@
+"""CLI resource resolution utilities for handling ID/name references.
+
+This module provides CLI-specific resource resolution functionality,
+including interactive pickers and ambiguity handling.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from collections.abc import Callable
+
+import click
+
+from glaip_sdk.cli.utils import resolve_resource
+
+
+def resolve_resource_reference(
+    ctx,
+    _client,
+    reference: str,
+    resource_type: str,
+    get_by_id_func: Callable,
+    find_by_name_func: Callable,
+    label: str,
+    select: int = None,
+    interface_preference: str | None = None,
+):
+    """Resolve resource reference (ID or name) with ambiguity handling.
+
+    This is a common pattern used across all resource types.
+
+    Args:
+        ctx: Click context
+        client: API client
+        reference: Resource ID or name
+        resource_type: Type of resource
+        get_by_id_func: Function to get resource by ID
+        find_by_name_func: Function to find resources by name
+        label: Label for error messages
+        select: Selection index for ambiguous matches
+
+    Returns:
+        Resolved resource object
+
+    Raises:
+        click.ClickException: If resolution fails
+    """
+    try:
+        return resolve_resource(
+            ctx,
+            reference,
+            get_by_id=get_by_id_func,
+            find_by_name=find_by_name_func,
+            label=label,
+            select=select,
+            interface_preference=interface_preference,
+        )
+    except Exception as e:
+        raise click.ClickException(f"Failed to resolve {resource_type.lower()}: {e}")