glaip-sdk 0.1.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

glaip_sdk/cli/transcript/viewer.py

@@ -63,12 +63,14 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         console: Console,
         ctx: ViewerContext,
         export_callback: Callable[[Path], Path],
+        *,
+        initial_view: str = "default",
     ) -> None:
         """Initialize viewer state for a captured transcript."""
         self.console = console
         self.ctx = ctx
         self._export_callback = export_callback
-        self._view_mode = "default"
+        self._view_mode = initial_view if initial_view in {"default", "transcript"} else "default"
 
     def run(self) -> None:
         """Enter the interactive loop."""
@@ -795,7 +797,9 @@ def run_viewer_session(
     console: Console,
     ctx: ViewerContext,
     export_callback: Callable[[Path], Path],
+    *,
+    initial_view: str = "default",
 ) -> None:
     """Entry point for creating and running the post-run viewer."""
-    viewer = PostRunViewer(console, ctx, export_callback)
+    viewer = PostRunViewer(console, ctx, export_callback, initial_view=initial_view)
     viewer.run()

glaip_sdk/cli/utils.py

@@ -14,6 +14,7 @@ import os
 import sys
 from collections.abc import Callable, Iterable
 from contextlib import AbstractContextManager, nullcontext
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
 
 import click
@@ -87,6 +88,166 @@ def detect_export_format(file_path: str | os.PathLike[str]) -> str:
     return _detect_export_format(file_path)
 
 
+def format_size(num: int | None) -> str:
+    """Format byte counts using short human-friendly units.
+
+    Args:
+        num: Number of bytes to format (can be None or 0)
+
+    Returns:
+        Human-readable size string (e.g., "1.5KB", "2MB")
+    """
+    if not num or num <= 0:
+        return "0B"
+
+    units = ["B", "KB", "MB", "GB", "TB"]
+    value = float(num)
+    for unit in units:
+        if value < 1024 or unit == units[-1]:
+            if unit == "B" or value >= 100:
+                return f"{value:.0f}{unit}"
+            if value >= 10:
+                return f"{value:.1f}{unit}"
+            return f"{value:.2f}{unit}"
+        value /= 1024
+    return f"{value:.1f}TB"  # pragma: no cover - defensive fallback
+
+
+def parse_json_line(line: str) -> dict[str, Any] | None:
+    """Parse a JSON line into a dictionary payload.
+
+    Args:
+        line: JSON line string to parse
+
+    Returns:
+        Parsed dictionary or None if parsing fails or result is not a dict
+    """
+    line = line.strip()
+    if not line:
+        return None
+    try:
+        payload = json.loads(line)
+    except json.JSONDecodeError:
+        return None
+    return payload if isinstance(payload, dict) else None
+
+
+def format_datetime_fields(
+    data: dict[str, Any], fields: tuple[str, ...] = ("created_at", "updated_at")
+) -> dict[str, Any]:
+    """Format datetime fields in a data dictionary for display.
+
+    Args:
+        data: Dictionary containing the data to format
+        fields: Tuple of field names to format (default: created_at, updated_at)
+
+    Returns:
+        New dictionary with formatted datetime fields
+    """
+    from glaip_sdk.utils import format_datetime
+
+    formatted = data.copy()
+    for field in fields:
+        if field in formatted:
+            formatted[field] = format_datetime(formatted[field])
+    return formatted
+
+
+def fetch_resource_for_export(
+    ctx: Any,
+    resource: Any,
+    resource_type: str,
+    get_by_id_func: Callable[[str], Any],
+    console_override: Console | None = None,
+) -> Any:
+    """Fetch full resource details for export, handling errors gracefully.
+
+    Args:
+        ctx: Click context for spinner management
+        resource: Resource object to fetch details for
+        resource_type: Type of resource (e.g., "MCP", "Agent", "Tool")
+        get_by_id_func: Function to fetch resource by ID
+        console_override: Optional console override
+
+    Returns:
+        Resource object with full details, or original resource if fetch fails
+    """
+    active_console = console_override or console
+    resource_id = str(getattr(resource, "id", "")).strip()
+
+    if not resource_id:
+        return resource
+
+    try:
+        with spinner_context(
+            ctx,
+            f"[bold blue]Fetching {resource_type} details…[/bold blue]",
+            console_override=active_console,
+        ):
+            return get_by_id_func(resource_id)
+    except Exception:
+        # Return original resource if fetch fails
+        return resource
+
+
+def handle_resource_export(
+    ctx: Any,
+    resource: Any,
+    export_path: Path,
+    resource_type: str,
+    get_by_id_func: Callable[[str], Any],
+    console_override: Console | None = None,
+) -> None:
+    """Handle resource export to file with format detection and error handling.
+
+    Args:
+        ctx: Click context for spinner management
+        resource: Resource object to export
+        export_path: Target file path (format detected from extension)
+        resource_type: Type of resource (e.g., "agent", "tool")
+        get_by_id_func: Function to fetch resource by ID
+        console_override: Optional console override
+    """
+    from glaip_sdk.cli.display import handle_rich_output
+    from glaip_sdk.cli.io import export_resource_to_file_with_validation
+    from glaip_sdk.cli.rich_helpers import print_markup
+
+    active_console = console_override or console
+
+    # Auto-detect format from file extension
+    detected_format = detect_export_format(export_path)
+
+    # Try to fetch full details for export
+    full_resource = fetch_resource_for_export(
+        ctx,
+        resource,
+        resource_type.capitalize(),
+        get_by_id_func,
+        console_override=active_console,
+    )
+
+    # Export the resource
+    try:
+        with spinner_context(
+            ctx,
+            f"[bold blue]Exporting {resource_type}…[/bold blue]",
+            console_override=active_console,
+        ):
+            export_resource_to_file_with_validation(full_resource, export_path, detected_format)
+    except Exception:
+        handle_rich_output(
+            ctx,
+            markup_text(f"[{WARNING_STYLE}]⚠️  Failed to fetch full details, using available data[/]"),
+        )
+        # Fallback: export with available data
+        export_resource_to_file_with_validation(resource, export_path, detected_format)
+
+    print_markup(
+        f"[{SUCCESS_STYLE}]✅ {resource_type.capitalize()} exported to: {export_path} (format: {detected_format})[/]",
+        console=active_console,
+    )
+
+
 def in_slash_mode(ctx: click.Context | None = None) -> bool:
     """Return True when running inside the slash command palette."""
     if ctx is None:
@@ -612,6 +773,7 @@ def _fuzzy_score(search: str, target: str) -> int:
 
 
 def _coerce_result_payload(result: Any) -> Any:
+    """Convert renderer outputs into plain dict/list structures when possible."""
     try:
         to_dict = getattr(result, "to_dict", None)
         if callable(to_dict):
@@ -622,6 +784,7 @@ def _coerce_result_payload(result: Any) -> Any:
 
 
 def _ensure_displayable(payload: Any) -> Any:
+    """Best-effort coercion into JSON/str-safe payloads for console rendering."""
     if isinstance(payload, (dict, list, str, int, float, bool)) or payload is None:
         return payload
 
@@ -641,6 +804,7 @@ def _ensure_displayable(payload: Any) -> Any:
 
 
 def _render_markdown_output(data: Any) -> None:
+    """Render markdown output using Rich when available."""
     try:
         console.print(Markdown(str(data)))
     except ImportError:
@@ -694,6 +858,7 @@ def output_result(
 
 
 def _normalise_rows(items: list[Any], transform_func: Callable[[Any], dict[str, Any]] | None) -> list[dict[str, Any]]:
+    """Convert heterogeneous item lists into table rows."""
     try:
         rows: list[dict[str, Any]] = []
         for item in items:
@@ -713,6 +878,7 @@ def _normalise_rows(items: list[Any], transform_func: Callable[[Any], dict[str,
 
 
 def _render_plain_list(rows: list[dict[str, Any]], title: str, columns: list[tuple]) -> None:
+    """Display tabular data as a simple pipe-delimited list."""
     if not rows:
         click.echo(f"No {title.lower()} found.")
         return
@@ -722,6 +888,7 @@ def _render_plain_list(rows: list[dict[str, Any]], title: str, columns: list[tup
 
 
 def _render_markdown_list(rows: list[dict[str, Any]], title: str, columns: list[tuple]) -> None:
+    """Display tabular data using markdown table syntax."""
     if not rows:
         click.echo(f"No {title.lower()} found.")
         return
@@ -734,6 +901,7 @@ def _render_markdown_list(rows: list[dict[str, Any]], title: str, columns: list[
 
 
 def _should_sort_rows(rows: list[dict[str, Any]]) -> bool:
+    """Return True when rows should be name-sorted prior to rendering."""
     return (
         os.getenv("AIP_TABLE_NO_SORT", "0") not in ("1", "true", "on")
         and rows
@@ -743,6 +911,7 @@ def _should_sort_rows(rows: list[dict[str, Any]]) -> bool:
 
 
 def _create_table(columns: list[tuple[str, str, str, int | None]], title: str) -> Any:
+    """Build a configured Rich table for the provided columns."""
     table = AIPTable(title=title, expand=True)
     for _key, header, style, width in columns:
         table.add_column(header, style=style, width=width)
@@ -750,6 +919,7 @@ def _create_table(columns: list[tuple[str, str, str, int | None]], title: str) -
 
 
 def _build_table_group(rows: list[dict[str, Any]], columns: list[tuple], title: str) -> Group:
+    """Return a Rich group containing the table and a small footer summary."""
     table = _create_table(columns, title)
     for row in rows:
         table.add_row(*[str(row.get(key, "N/A")) for key, _, _, _ in columns])

glaip_sdk/client/_agent_payloads.py

@@ -406,6 +406,7 @@ __all__ = [
 
 
 def _build_base_update_payload(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any]:
+    """Populate immutable agent update fields using request data or existing agent defaults."""
     return {
         "name": request.name.strip() if request.name is not None else getattr(current_agent, "name", None),
         "instruction": request.instruction.strip()
@@ -418,6 +419,7 @@ def _build_base_update_payload(request: AgentUpdateRequest, current_agent: Any)
 
 
 def _resolve_update_language_model_fields(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any]:
+    """Resolve the language-model portion of an update request with sensible fallbacks."""
     fields = resolve_language_model_fields(
         model=request.model,
         language_model_id=request.language_model_id,
@@ -430,6 +432,7 @@ def _resolve_update_language_model_fields(request: AgentUpdateRequest, current_a
 
 
 def _collect_optional_update_fields(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any]:
+    """Collect optional agent fields, preserving current values when updates are absent."""
     result: dict[str, Any] = {}
 
     for field_name, value in (
@@ -468,6 +471,7 @@ def _collect_optional_update_fields(request: AgentUpdateRequest, current_agent:
 
 
 def _collect_relationship_fields(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any]:
+    """Return relationship identifiers (tools/agents/mcps) for an update request."""
     return {
         "tools": _resolve_relation_ids(request.tools, current_agent, "tools"),
         "agents": _resolve_relation_ids(request.agents, current_agent, "agents"),
@@ -476,6 +480,7 @@ def _collect_relationship_fields(request: AgentUpdateRequest, current_agent: Any
 
 
 def _resolve_agent_config_update(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any] | None:
+    """Determine the agent_config payload to send, if any."""
     effective_agent_config = _sanitize_agent_config(request.agent_config)
     if effective_agent_config is not None:
         return effective_agent_config

glaip_sdk/payload_schemas/__init__.py

@@ -4,16 +4,4 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
-from glaip_sdk.payload_schemas.agent import (
-    AgentImportOperation,
-    ImportFieldPlan,
-    get_import_field_plan,
-    list_server_only_fields,
-)
-
-__all__ = [
-    "AgentImportOperation",
-    "ImportFieldPlan",
-    "get_import_field_plan",
-    "list_server_only_fields",
-]
+__all__: list[str] = []

glaip_sdk/utils/__init__.py

@@ -4,6 +4,10 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
+from glaip_sdk.utils.datetime_helpers import (
+    coerce_datetime,
+    from_numeric_timestamp,
+)
 from glaip_sdk.utils.display import (
     RICH_AVAILABLE,
     print_agent_created,
@@ -14,20 +18,15 @@ from glaip_sdk.utils.display import (
 from glaip_sdk.utils.general import (
     format_datetime,
     format_file_size,
-    is_uuid,
     progress_bar,
-    sanitize_name,
 )
 from glaip_sdk.utils.rendering.models import RunStats, Step
+from glaip_sdk.utils.rendering.renderer.base import RichStreamRenderer
 from glaip_sdk.utils.rendering.steps import StepManager
-from glaip_sdk.utils.run_renderer import RichStreamRenderer
+from glaip_sdk.utils.resource_refs import is_uuid, sanitize_name
 
 __all__ = [
     "RICH_AVAILABLE",
-    "RichStreamRenderer",
-    "RunStats",
-    "Step",
-    "StepManager",
     "format_datetime",
     "format_file_size",
     "is_uuid",
@@ -37,4 +36,10 @@ __all__ = [
     "print_agent_updated",
     "progress_bar",
     "sanitize_name",
+    "RichStreamRenderer",
+    "RunStats",
+    "Step",
+    "StepManager",
+    "coerce_datetime",
+    "from_numeric_timestamp",
 ]

glaip_sdk/utils/datetime_helpers.py

@@ -0,0 +1,58 @@
+"""Shared datetime parsing helpers used across CLI and rendering modules."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+__all__ = ["coerce_datetime", "from_numeric_timestamp"]
+
+_Z_SUFFIX = "+00:00"
+
+
+def from_numeric_timestamp(raw_value: Any) -> datetime | None:
+    """Convert unix timestamp-like values to datetime with sanity checks."""
+    try:
+        candidate = float(raw_value)
+    except Exception:
+        return None
+
+    if candidate < 1_000_000_000:
+        return None
+
+    try:
+        return datetime.fromtimestamp(candidate, tz=timezone.utc)
+    except Exception:
+        return None
+
+
+def _parse_iso(value: str | None) -> datetime | None:
+    """Parse ISO8601 strings while tolerating legacy 'Z' suffixes."""
+    if not value:
+        return None
+    try:
+        return datetime.fromisoformat(value.replace("Z", _Z_SUFFIX))
+    except Exception:
+        return None
+
+
+def coerce_datetime(value: Any) -> datetime | None:
+    """Best-effort conversion of assorted timestamp inputs to aware UTC datetimes."""
+    if value is None:
+        return None
+
+    if isinstance(value, datetime):
+        dt = value
+    elif isinstance(value, (int, float)):
+        dt = from_numeric_timestamp(value)
+    elif isinstance(value, str):
+        dt = _parse_iso(value) or from_numeric_timestamp(value)
+    else:
+        return None
+
+    if dt is None:
+        return None
+
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc)

glaip_sdk/utils/general.py

@@ -4,46 +4,13 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
-import re
 from collections.abc import Iterable, Iterator
 from datetime import datetime
 from typing import Any
-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.
 

glaip_sdk/utils/import_export.py

@@ -10,9 +10,16 @@ Authors:
 from typing import Any
 
 
-def extract_ids_from_export(items: list[Any]) -> list[str]:
+def extract_ids_from_export(items: list[Any]) -> list[str]:  # pylint: disable=duplicate-code
     """Extract IDs from export format (list of dicts with id/name fields).
 
+    This function is similar to `extract_ids` in `resource_refs.py` but differs in behavior:
+    - This function SKIPS items without IDs (doesn't convert to string)
+    - `extract_ids` converts items without IDs to strings as fallback
+
+    This difference is intentional: export format should only include actual IDs,
+    while general resource reference extraction may need fallback string conversion.
+
     Args:
         items: List of items (dicts with id/name or strings)
 
@@ -36,6 +43,7 @@ def extract_ids_from_export(items: list[Any]) -> list[str]:
         elif isinstance(item, dict) and "id" in item:
             ids.append(str(item["id"]))
         # Skip items without ID (don't convert to string)
+        # Note: This differs from extract_ids() in resource_refs.py which converts all items to strings
 
     return ids
 

glaip_sdk/utils/rendering/renderer/__init__.py

@@ -13,18 +13,6 @@ 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 glaip_sdk.utils.rendering.renderer.progress import (
-    format_tool_title,
-    is_delegation_tool,
-)
-from glaip_sdk.utils.rendering.renderer.stream import StreamProcessor
 
 
 def make_silent_renderer() -> RichStreamRenderer:
@@ -79,15 +67,7 @@ __all__ = [
     "RichStreamRenderer",
     "RendererConfig",
     "CapturingConsole",
-    "StreamProcessor",
     "make_silent_renderer",
     "make_minimal_renderer",
     "print_panel",
-    "render_debug_event",
-    "create_main_panel",
-    "create_tool_panel",
-    "create_context_panel",
-    "create_final_panel",
-    "format_tool_title",
-    "is_delegation_tool",
 ]

glaip_sdk/utils/rendering/renderer/debug.py

@@ -4,6 +4,7 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
+# pylint: disable=duplicate-code
 import json
 from datetime import datetime, timezone
 from typing import Any
@@ -13,25 +14,7 @@ from rich.markdown import Markdown
 
 from glaip_sdk.branding import PRIMARY, SUCCESS, WARNING
 from glaip_sdk.rich_components import AIPPanel
-
-
-def _coerce_datetime(value: Any) -> datetime | None:
-    """Attempt to coerce an arbitrary value to an aware datetime."""
-    if value is None:
-        return None
-
-    if isinstance(value, datetime):
-        return value if value.tzinfo else value.replace(tzinfo=timezone.utc)
-
-    if isinstance(value, str):
-        try:
-            normalised = value.replace("Z", "+00:00")
-            dt = datetime.fromisoformat(normalised)
-        except ValueError:
-            return None
-        return dt if dt.tzinfo else dt.replace(tzinfo=timezone.utc)
-
-    return None
+from glaip_sdk.utils.datetime_helpers import coerce_datetime
 
 
 def _parse_event_timestamp(event: dict[str, Any], received_ts: datetime | None = None) -> datetime | None:
@@ -40,7 +23,7 @@ def _parse_event_timestamp(event: dict[str, Any], received_ts: datetime | None =
         return received_ts if received_ts.tzinfo else received_ts.replace(tzinfo=timezone.utc)
 
     ts_value = event.get("timestamp") or (event.get("metadata") or {}).get("timestamp")
-    return _coerce_datetime(ts_value)
+    return coerce_datetime(ts_value)
 
 
 def _format_timestamp_for_display(dt: datetime) -> str:

glaip_sdk/utils/rendering/steps.py

@@ -996,12 +996,11 @@ class StepManager:
 
     @staticmethod
     def _coerce_server_time(value: Any) -> float | None:
-        if isinstance(value, (int, float)):
-            return float(value)
-        try:
-            return float(value)
-        except (TypeError, ValueError):
-            return None
+        """Convert a raw SSE time payload into a float if possible."""
+        # Reuse the implementation from base renderer
+        from glaip_sdk.utils.rendering.renderer.base import RichStreamRenderer
+
+        return RichStreamRenderer._coerce_server_time(value)
 
     def _update_server_timestamps(self, step: Step, server_time: float | None, status: str) -> None:
         if server_time is None:

glaip_sdk/utils/resource_refs.py

@@ -8,6 +8,7 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
+# pylint: disable=duplicate-code
 import re
 from typing import Any
 from uuid import UUID
@@ -29,7 +30,7 @@ def is_uuid(value: str) -> bool:
         return False
 
 
-def extract_ids(items: list[str | Any] | None) -> list[str]:
+def extract_ids(items: list[str | Any] | None) -> list[str]:  # pylint: disable=duplicate-code
     """Extract IDs from a list of objects or strings.
 
     This function unifies the behavior between CLI and SDK layers, always

glaip_sdk/utils/serialization.py

@@ -287,6 +287,7 @@ def _collect_from_dir(resource: Any, collect_func: Callable[[Iterable[str]], Non
 
 
 def _safe_getattr(resource: Any, name: str) -> Any:
+    """Return getattr(resource, name) but swallow any exception and return None."""
     try:
         return getattr(resource, name)
     except Exception:
@@ -294,6 +295,7 @@ def _safe_getattr(resource: Any, name: str) -> Any:
 
 
 def _should_include_attribute(key: str, value: Any) -> bool:
+    """Return True when an attribute should be serialized."""
     if key in _EXCLUDED_ATTRS or key in _EXCLUDED_NAMES:
         return False
     if key.startswith("_"):

{glaip_sdk-0.1.4.dist-info → glaip_sdk-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: glaip-sdk
-Version: 0.1.4
+Version: 0.2.0
 Summary: Python SDK for GL AIP (GDP Labs AI Agent Package) - Simplified CLI Design
 License: MIT
 Author: Raymond Christopher