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

glaip_sdk/utils/display.py

@@ -0,0 +1,100 @@
+"""Rich display utilities for enhanced output.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from glaip_sdk.utils.rich_utils import RICH_AVAILABLE
+
+
+def print_agent_output(output: str, title: str = "Agent Output") -> None:
+    """Print agent output with rich formatting.
+
+    Args:
+        output: The agent's response text
+        title: Title for the output panel
+    """
+    if RICH_AVAILABLE:
+        # Lazy import Rich components
+        from rich.console import Console
+        from rich.text import Text
+
+        from glaip_sdk.rich_components import AIPPanel
+
+        console = Console()
+        panel = AIPPanel(
+            Text(output, style="green"),
+            title=title,
+            border_style="green",
+        )
+        console.print(panel)
+    else:
+        print(f"\n=== {title} ===")
+        print(output)
+        print("=" * (len(title) + 8))
+
+
+def print_agent_created(agent, title: str = "🤖 Agent Created") -> None:
+    """Print agent creation success with rich formatting.
+
+    Args:
+        agent: The created agent object
+        title: Title for the output panel
+    """
+    if RICH_AVAILABLE:
+        # Lazy import Rich components
+        from rich.console import Console
+
+        from glaip_sdk.rich_components import AIPPanel
+
+        console = Console()
+        panel = AIPPanel(
+            f"[green]✅ Agent '{agent.name}' created successfully![/green]\n\n"
+            f"ID: {agent.id}\n"
+            f"Model: {getattr(agent, 'model', 'N/A')}\n"
+            f"Type: {getattr(agent, 'type', 'config')}\n"
+            f"Framework: {getattr(agent, 'framework', 'langchain')}\n"
+            f"Version: {getattr(agent, 'version', '1.0')}",
+            title=title,
+            border_style="green",
+        )
+        console.print(panel)
+    else:
+        print(f"✅ Agent '{agent.name}' created successfully!")
+        print(f"ID: {agent.id}")
+        print(f"Model: {getattr(agent, 'model', 'N/A')}")
+        print(f"Type: {getattr(agent, 'type', 'config')}")
+        print(f"Framework: {getattr(agent, 'framework', 'langchain')}")
+        print(f"Version: {getattr(agent, 'version', '1.0')}")
+
+
+def print_agent_updated(agent) -> None:
+    """Print agent update success with rich formatting.
+
+    Args:
+        agent: The updated agent object
+    """
+    if RICH_AVAILABLE:
+        # Lazy import Rich components
+        from rich.console import Console
+
+        console = Console()
+        console.print(f"[green]✅ Agent '{agent.name}' updated successfully[/green]")
+    else:
+        print(f"✅ Agent '{agent.name}' updated successfully")
+
+
+def print_agent_deleted(agent_id: str) -> None:
+    """Print agent deletion success with rich formatting.
+
+    Args:
+        agent_id: The deleted agent's ID
+    """
+    if RICH_AVAILABLE:
+        # Lazy import Rich components
+        from rich.console import Console
+
+        console = Console()
+        console.print(f"[green]✅ Agent deleted successfully (ID: {agent_id})[/green]")
+    else:
+        print(f"✅ Agent deleted successfully (ID: {agent_id})")

glaip_sdk/utils/general.py

@@ -0,0 +1,94 @@
+"""General utility functions for AIP SDK.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+import re
+from datetime import datetime
+from uuid import UUID
+
+import click
+
+
+def is_uuid(value: str) -> bool:
+    """Check if a string is a valid UUID.
+
+    Args:
+        value: String to check
+
+    Returns:
+        True if value is a valid UUID, False otherwise
+    """
+    try:
+        UUID(value)
+        return True
+    except (ValueError, TypeError):
+        return False
+
+
+def sanitize_name(name: str) -> str:
+    """Sanitize a name for resource creation.
+
+    Args:
+        name: Raw name input
+
+    Returns:
+        Sanitized name suitable for resource creation
+    """
+    # Remove special characters and normalize
+    sanitized = re.sub(r"[^a-zA-Z0-9\-_]", "-", name.strip())
+    sanitized = re.sub(r"-+", "-", sanitized)  # Collapse multiple dashes
+    return sanitized.lower().strip("-")
+
+
+def format_file_size(size_bytes: int) -> str:
+    """Format file size in human readable format.
+
+    Args:
+        size_bytes: Size in bytes
+
+    Returns:
+        Human readable size string (e.g., "1.5 MB")
+    """
+    for unit in ["B", "KB", "MB", "GB"]:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.1f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.1f} TB"
+
+
+def format_datetime(dt):
+    """Format datetime object to readable string.
+
+    Args:
+        dt: Datetime object or string to format
+
+    Returns:
+        Formatted datetime string or "N/A" if None
+    """
+    if isinstance(dt, datetime):
+        return dt.strftime("%Y-%m-%d %H:%M:%S UTC")
+    elif dt is None:
+        return "N/A"
+    return str(dt)
+
+
+def progress_bar(iterable, description: str = "Processing"):
+    """Simple progress bar using click.
+
+    Args:
+        iterable: Iterable to process
+        description: Progress description
+
+    Yields:
+        Items from iterable with progress display
+    """
+    try:
+        with click.progressbar(iterable, label=description) as bar:
+            for item in bar:
+                yield item
+    except ImportError:
+        # Fallback if click not available
+        for item in iterable:
+            yield item

glaip_sdk/utils/import_export.py

@@ -0,0 +1,140 @@
+"""Import/export utilities for schema transforms and data merging.
+
+This module provides functions for converting between export and import formats,
+merging imported data with CLI arguments, and handling relationship flattening.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from typing import Any
+
+
+def extract_ids_from_export(items: list[Any]) -> list[str]:
+    """Extract IDs from export format (list of dicts with id/name fields).
+
+    Args:
+        items: List of items (dicts with id/name or strings)
+
+    Returns:
+        List of extracted IDs (only items with actual IDs)
+
+    Examples:
+        extract_ids_from_export([{"id": "123", "name": "tool"}]) -> ["123"]
+        extract_ids_from_export(["123", "456"]) -> ["123", "456"]
+        extract_ids_from_export([{"name": "tool"}, "123"]) -> ["123"]  # Skip items without ID
+    """
+    if not items:
+        return []
+
+    ids = []
+    for item in items:
+        if isinstance(item, str):
+            ids.append(item)
+        elif hasattr(item, "id"):
+            ids.append(str(item.id))
+        elif isinstance(item, dict) and "id" in item:
+            ids.append(str(item["id"]))
+        # Skip items without ID (don't convert to string)
+
+    return ids
+
+
+def convert_export_to_import_format(data: dict[str, Any]) -> dict[str, Any]:
+    """Convert export format to import-compatible format (extract IDs from objects).
+
+    Args:
+        data: Export format data with full objects
+
+    Returns:
+        Import format data with extracted IDs
+
+    Notes:
+        - Converts tools/agents from dict objects to ID lists
+        - Preserves all other data unchanged
+    """
+    import_data = data.copy()
+
+    # Convert tools from dicts to IDs
+    if "tools" in import_data and isinstance(import_data["tools"], list):
+        import_data["tools"] = extract_ids_from_export(import_data["tools"])
+
+    # Convert agents from dicts to IDs
+    if "agents" in import_data and isinstance(import_data["agents"], list):
+        import_data["agents"] = extract_ids_from_export(import_data["agents"])
+
+    return import_data
+
+
+def merge_import_with_cli_args(
+    import_data: dict[str, Any],
+    cli_args: dict[str, Any],
+    array_fields: list[str] = None,
+) -> dict[str, Any]:
+    """Merge imported data with CLI arguments, preferring CLI args.
+
+    Args:
+        import_data: Data loaded from import file
+        cli_args: Arguments passed via CLI
+        array_fields: Fields that should be combined (merged) rather than replaced
+
+    Returns:
+        Merged data dictionary
+
+    Notes:
+        - CLI arguments take precedence over imported data
+        - Array fields (tools, agents) are combined rather than replaced
+        - Empty arrays/lists are treated as None (no override)
+    """
+    if array_fields is None:
+        array_fields = ["tools", "agents"]
+
+    merged = {}
+
+    for key, cli_value in cli_args.items():
+        if cli_value is not None and (
+            not isinstance(cli_value, list | tuple) or len(cli_value) > 0
+        ):
+            # CLI value takes precedence (for non-empty values)
+            if key in array_fields and key in import_data:
+                # For array fields, combine CLI and imported values
+                import_value = import_data[key]
+                if isinstance(import_value, list):
+                    merged[key] = list(cli_value) + import_value
+                else:
+                    merged[key] = cli_value
+            else:
+                merged[key] = cli_value
+        elif key in import_data:
+            # Use imported value if no CLI value
+            merged[key] = import_data[key]
+
+    # Add any import-only fields
+    for key, import_value in import_data.items():
+        if key not in merged:
+            merged[key] = import_value
+
+    return merged
+
+
+def flatten_relationships_for_import(
+    data: dict[str, Any], fields: tuple[str, ...] = ("tools", "agents")
+) -> dict[str, Any]:
+    """Flatten relationship fields for import format.
+
+    This is an alias for convert_export_to_import_format with configurable fields.
+
+    Args:
+        data: Export format data with full objects
+        fields: Tuple of field names to flatten to IDs
+
+    Returns:
+        Import format data with specified fields flattened to IDs
+    """
+    import_data = data.copy()
+
+    for field in fields:
+        if field in import_data and isinstance(import_data[field], list):
+            import_data[field] = extract_ids_from_export(import_data[field])
+
+    return import_data

glaip_sdk/utils/rendering/formatting.py

@@ -108,7 +108,7 @@ def pretty_args(args: dict | None, max_len: int = DEFAULT_ARGS_MAX_LEN) -> str:
     try:
         import json
 
-        args_str = json.dumps(masked_args, ensure_ascii=False)
+        args_str = json.dumps(masked_args, ensure_ascii=False, separators=(",", ":"))
         return _truncate_string(args_str, max_len)
     except (TypeError, ValueError, Exception):
         # Fallback to string representation if JSON serialization fails
@@ -124,6 +124,11 @@ def pretty_out(output: any, max_len: int = DEFAULT_ARGS_MAX_LEN) -> str:
     if isinstance(output, str):
         # Mask secrets in string output
         masked_output = mask_secrets_in_string(output)
+
+        # Remove LaTeX commands (common math expressions)
+        masked_output = re.sub(r"\\[a-zA-Z]+\{[^}]*\}", "", masked_output)
+        masked_output = re.sub(r"\\[a-zA-Z]+", "", masked_output)
+
         # Strip leading/trailing whitespace but preserve internal spacing
         masked_output = masked_output.strip()
         # Replace newlines with spaces to preserve formatting

glaip_sdk/utils/rendering/renderer/__init__.py

@@ -5,21 +5,78 @@ with clean separation of concerns between configuration, console handling,
 debug output, panel rendering, progress tracking, and event routing.
 """
 
-from .base import RichStreamRenderer
-from .config import RendererConfig
-from .console import CapturingConsole
-from .debug import render_debug_event
-from .panels import (
+import io
+
+from rich.console import Console
+
+from glaip_sdk.rich_components import AIPPanel
+from glaip_sdk.utils.rendering.renderer.base import RichStreamRenderer
+from glaip_sdk.utils.rendering.renderer.config import RendererConfig
+from glaip_sdk.utils.rendering.renderer.console import CapturingConsole
+from glaip_sdk.utils.rendering.renderer.debug import render_debug_event
+from glaip_sdk.utils.rendering.renderer.panels import (
     create_context_panel,
     create_final_panel,
     create_main_panel,
     create_tool_panel,
 )
-from .progress import (
+from glaip_sdk.utils.rendering.renderer.progress import (
     format_tool_title,
     is_delegation_tool,
 )
-from .stream import StreamProcessor
+from glaip_sdk.utils.rendering.renderer.stream import StreamProcessor
+
+
+def make_silent_renderer() -> RichStreamRenderer:
+    """Create a renderer that suppresses all terminal output.
+
+    Uses an in-memory console and disables live updates/panels.
+    """
+    cfg = RendererConfig(
+        live=False,
+        persist_live=False,
+        show_delegate_tool_panels=False,
+        render_thinking=False,
+    )
+    return RichStreamRenderer(
+        console=Console(file=io.StringIO(), force_terminal=False), cfg=cfg
+    )
+
+
+def make_minimal_renderer() -> RichStreamRenderer:
+    """Create a minimal renderer.
+
+    Prints a compact header and the user request panel, but no live updates or tool panels.
+    """
+    cfg = RendererConfig(
+        live=False,
+        persist_live=False,
+        show_delegate_tool_panels=False,
+        render_thinking=False,
+    )
+    return RichStreamRenderer(console=Console(), cfg=cfg)
+
+
+def print_panel(
+    content: str,
+    *,
+    title: str | None = None,
+    border_style: str = "blue",
+    padding: tuple[int, int] = (1, 2),
+    console: Console | None = None,
+) -> None:
+    """Print boxed content using Rich without exposing Console/Panel at call site.
+
+    Args:
+        content: The text to display inside the panel.
+        title: Optional title for the panel.
+        border_style: Rich style string for the border color.
+        padding: (vertical, horizontal) padding inside the panel.
+        console: Optional Rich Console to print to; created if not provided.
+    """
+    c = console or Console()
+    c.print(AIPPanel(content, title=title, border_style=border_style, padding=padding))
+
 
 __all__ = [
     # Main classes
@@ -27,7 +84,9 @@ __all__ = [
     "RendererConfig",
     "CapturingConsole",
     "StreamProcessor",
-    # Key functions
+    "make_silent_renderer",
+    "make_minimal_renderer",
+    "print_panel",
     "render_debug_event",
     "create_main_panel",
     "create_tool_panel",