glaip-sdk 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

glaip_sdk/cli/transcript/cache.py

@@ -124,9 +124,7 @@ def _json_default(value: Any) -> Any:
     return repr(value)
 
 
-def _write_manifest(
-    entries: Iterable[dict[str, Any]], cache_dir: Path | None = None
-) -> None:
+def _write_manifest(entries: Iterable[dict[str, Any]], cache_dir: Path | None = None) -> None:
     path = manifest_path(cache_dir)
     with path.open("w", encoding="utf-8") as fh:
         for entry in entries:
@@ -212,8 +210,7 @@ def latest_manifest_entry(cache_dir: Path | None = None) -> dict[str, Any] | Non
         return None
     return max(
         entries,
-        key=lambda e: _parse_iso(e.get("created_at"))
-        or datetime.min.replace(tzinfo=timezone.utc),
+        key=lambda e: _parse_iso(e.get("created_at")) or datetime.min.replace(tzinfo=timezone.utc),
     )
 
 
@@ -237,11 +234,7 @@ def export_transcript(
 ) -> Path:
     """Copy a cached transcript to the requested destination path."""
     directory = ensure_cache_dir(cache_dir)
-    entry = (
-        resolve_manifest_entry(run_id, directory)
-        if run_id
-        else latest_manifest_entry(directory)
-    )
+    entry = resolve_manifest_entry(run_id, directory) if run_id else latest_manifest_entry(directory)
     if entry is None:
         raise FileNotFoundError("No cached transcripts available for export.")
 
@@ -259,9 +252,7 @@ def export_transcript(
         lines = cache_file.read_text(encoding="utf-8").splitlines()
         records = [json.loads(line) for line in lines if line.strip()]
     except json.JSONDecodeError as exc:
-        raise FileNotFoundError(
-            f"Cached transcript file is corrupted: {cache_file}"
-        ) from exc
+        raise FileNotFoundError(f"Cached transcript file is corrupted: {cache_file}") from exc
 
     with destination.open("w", encoding="utf-8") as fh:
         for idx, record in enumerate(records):
@@ -276,12 +267,8 @@ def export_transcript(
 def suggest_filename(entry: dict[str, Any] | None = None) -> str:
     """Return a friendly filename suggestion for exporting a transcript."""
     run_id = entry.get("run_id") if entry else uuid.uuid4().hex
-    created_at = (
-        entry.get("created_at") if entry else datetime.now(timezone.utc).isoformat()
-    )
-    timestamp = (
-        created_at.replace(":", "").replace("-", "").replace("T", "_").split("+")[0]
-    )
+    created_at = entry.get("created_at") if entry else datetime.now(timezone.utc).isoformat()
+    timestamp = created_at.replace(":", "").replace("-", "").replace("T", "_").split("+")[0]
     return f"aip-run-{timestamp}-{run_id}.jsonl"
 
 

glaip_sdk/cli/transcript/capture.py

@@ -65,11 +65,7 @@ def compute_finished_at(renderer: Any) -> float | None:
 
     if started_at is None:
         stream_processor = getattr(renderer, "stream_processor", None)
-        started_at = (
-            getattr(stream_processor, "streaming_started_at", None)
-            if stream_processor is not None
-            else None
-        )
+        started_at = getattr(stream_processor, "streaming_started_at", None) if stream_processor is not None else None
     if started_at is None or duration is None:
         return None
     try:
@@ -78,9 +74,7 @@ def compute_finished_at(renderer: Any) -> float | None:
         return None
 
 
-def extract_server_run_id(
-    meta: dict[str, Any], events: list[dict[str, Any]]
-) -> str | None:
+def extract_server_run_id(meta: dict[str, Any], events: list[dict[str, Any]]) -> str | None:
     """Derive a server-side run identifier from renderer metadata."""
     run_id = meta.get("run_id") or meta.get("id")
     if run_id:
@@ -107,9 +101,7 @@ def _coerce_meta(meta: Any) -> dict[str, Any]:
     return {"value": coerce_result_text(meta)}
 
 
-def register_last_transcript(
-    ctx: Any, payload: TranscriptPayload, store_result: TranscriptStoreResult
-) -> None:
+def register_last_transcript(ctx: Any, payload: TranscriptPayload, store_result: TranscriptStoreResult) -> None:
     """Persist last-run transcript references onto the Click context."""
     ctx_obj = getattr(ctx, "obj", None)
     if not isinstance(ctx_obj, dict):
@@ -213,9 +205,7 @@ def _derive_transcript_meta(
 
     stream_processor = getattr(renderer, "stream_processor", None)
     stream_started_at = (
-        getattr(stream_processor, "streaming_started_at", None)
-        if stream_processor is not None
-        else None
+        getattr(stream_processor, "streaming_started_at", None) if stream_processor is not None else None
     )
     finished_at = compute_finished_at(renderer)
     model_name = meta.get("model") or model
@@ -236,16 +226,12 @@ def store_transcript_for_session(
     if not hasattr(renderer, "get_transcript_events"):
         return None
 
-    events, aggregated_output, final_output = _collect_renderer_outputs(
-        renderer, final_result
-    )
+    events, aggregated_output, final_output = _collect_renderer_outputs(renderer, final_result)
 
     if not (events or aggregated_output or final_output):
         return None
 
-    meta, stream_started_at, finished_at, model_name = _derive_transcript_meta(
-        renderer, model
-    )
+    meta, stream_started_at, finished_at, model_name = _derive_transcript_meta(renderer, model)
 
     payload: TranscriptPayload = build_transcript_payload(
         events=events,

glaip_sdk/cli/transcript/launcher.py

@@ -20,9 +20,7 @@ from glaip_sdk.cli.transcript.capture import StoredTranscriptContext
 from glaip_sdk.cli.transcript.viewer import ViewerContext, run_viewer_session
 
 
-def should_launch_post_run_viewer(
-    ctx: Any, console: Console, *, slash_mode: bool
-) -> bool:
+def should_launch_post_run_viewer(ctx: Any, console: Console, *, slash_mode: bool) -> bool:
     """Return True if the viewer should open automatically."""
     if slash_mode:
         return False

glaip_sdk/cli/transcript/viewer.py

@@ -72,9 +72,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
 
     def run(self) -> None:
         """Enter the interactive loop."""
-        if not self.ctx.events and not (
-            self.ctx.default_output or self.ctx.final_output
-        ):
+        if not self.ctx.events and not (self.ctx.default_output or self.ctx.final_output):
             return
         if self._view_mode == "transcript":
             self._render()
@@ -91,9 +89,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         except Exception:  # pragma: no cover - platform quirks
             pass
 
-        header = (
-            f"Agent transcript viewer · run {self.ctx.manifest_entry.get('run_id')}"
-        )
+        header = f"Agent transcript viewer · run {self.ctx.manifest_entry.get('run_id')}"
         agent_label = self.ctx.manifest_entry.get("agent_name") or "unknown agent"
         model = self.ctx.manifest_entry.get("model") or self.ctx.meta.get("model")
         agent_id = self.ctx.manifest_entry.get("agent_id")
@@ -134,9 +130,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         self._render_final_panel()
 
         self.console.print("[bold]Transcript Events[/bold]")
-        self.console.print(
-            "[dim]────────────────────────────────────────────────────────[/dim]"
-        )
+        self.console.print("[dim]────────────────────────────────────────────────────────[/dim]")
 
         base_received_ts: datetime | None = None
         for event in self.ctx.events:
@@ -152,11 +146,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         self.console.print()
 
     def _render_final_panel(self) -> None:
-        content = (
-            self.ctx.final_output
-            or self.ctx.default_output
-            or "No response content captured."
-        )
+        content = self.ctx.final_output or self.ctx.default_output or "No response content captured."
         title = "Final Result"
         duration_text = self._extract_final_duration()
         if duration_text:
@@ -218,9 +208,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
             raw = str(path)
             return raw if len(raw) <= 80 else f"…{raw[-77:]}"
 
-        selection = self._prompt_export_choice(
-            default_path, _display_path(default_path)
-        )
+        selection = self._prompt_export_choice(default_path, _display_path(default_path))
         if selection is None:
             self._legacy_export_prompt(default_path, _display_path)
             return
@@ -246,9 +234,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         except Exception as exc:  # pragma: no cover - unexpected IO failures
             self.console.print(f"[red]Failed to export transcript: {exc}[/red]")
 
-    def _prompt_export_choice(
-        self, default_path: Path, default_display: str
-    ) -> tuple[str, Any] | None:
+    def _prompt_export_choice(self, default_path: Path, default_display: str) -> tuple[str, Any] | None:
         """Render interactive export menu with numeric shortcuts."""
         if not self.console.is_terminal or questionary is None or Choice is None:
             return None
@@ -305,9 +291,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
             candidate = Path.cwd() / candidate
         return candidate
 
-    def _legacy_export_prompt(
-        self, default_path: Path, formatter: Callable[[Path], str]
-    ) -> None:
+    def _legacy_export_prompt(self, default_path: Path, formatter: Callable[[Path], str]) -> None:
         """Fallback export workflow when interactive UI is unavailable."""
         self.console.print("[dim]Export options (fallback mode)[/dim]")
         self.console.print(f"  1. Save to default ({formatter(default_path)})")
@@ -353,20 +337,13 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
             self.console.print(f"[red]Failed to export transcript: {exc}[/red]")
 
     def _print_command_hint(self) -> None:
-        self.console.print(
-            "[dim]Ctrl+T to toggle transcript · type `e` to export · press Enter to exit[/dim]"
-        )
+        self.console.print("[dim]Ctrl+T to toggle transcript · type `e` to export · press Enter to exit[/dim]")
         self.console.print()
 
     def _get_user_query(self) -> str | None:
         meta = self.ctx.meta or {}
         manifest = self.ctx.manifest_entry or {}
-        return (
-            meta.get("input_message")
-            or meta.get("query")
-            or meta.get("message")
-            or manifest.get("input_message")
-        )
+        return meta.get("input_message") or meta.get("query") or meta.get("message") or manifest.get("input_message")
 
     def _render_user_query(self, query: str) -> None:
         panel = AIPPanel(
@@ -730,11 +707,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         status = metadata.get("status")
         event_time = metadata.get("time")
 
-        if (
-            status == "running"
-            and step.get("started_at") is None
-            and isinstance(event_time, (int, float))
-        ):
+        if status == "running" and step.get("started_at") is None and isinstance(event_time, (int, float)):
             try:
                 step["started_at"] = float(event_time)
             except Exception:
@@ -760,9 +733,7 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         started_at = step.get("started_at")
         duration_value: float | None = None
 
-        if isinstance(event_time, (int, float)) and isinstance(
-            started_at, (int, float)
-        ):
+        if isinstance(event_time, (int, float)) and isinstance(started_at, (int, float)):
             try:
                 delta = float(event_time) - float(started_at)
                 if delta >= 0:

glaip_sdk/cli/update_notifier.py

@@ -6,10 +6,14 @@ Author:
 
 from __future__ import annotations
 
+import importlib
+import logging
 import os
-from collections.abc import Callable
+from collections.abc import Callable, Iterable, Iterator
+from contextlib import contextmanager
 from typing import Any, Literal
 
+import click
 import httpx
 from packaging.version import InvalidVersion, Version
 from rich import box
@@ -17,9 +21,11 @@ from rich.console import Console
 
 from glaip_sdk.branding import (
     ACCENT_STYLE,
+    ERROR_STYLE,
     SUCCESS_STYLE,
     WARNING_STYLE,
 )
+from glaip_sdk.cli.commands.update import update_command
 from glaip_sdk.cli.utils import command_hint, format_command_hint
 from glaip_sdk.rich_components import AIPPanel
 
@@ -28,6 +34,8 @@ FetchLatestVersion = Callable[[], str | None]
 PYPI_JSON_URL = "https://pypi.org/pypi/{package}/json"
 DEFAULT_TIMEOUT = 1.5  # seconds
 
+_LOGGER = logging.getLogger(__name__)
+
 
 def _parse_version(value: str) -> Version | None:
     """Parse a version string into a `Version`, returning None on failure."""
@@ -43,13 +51,16 @@ def _fetch_latest_version(package_name: str) -> str | None:
     timeout = httpx.Timeout(DEFAULT_TIMEOUT)
 
     try:
-        with httpx.Client(timeout=timeout) as client:
-            response = client.get(url, headers={"Accept": "application/json"})
-            response.raise_for_status()
-            payload = response.json()
-    except httpx.HTTPError:
+        with _suppress_library_logging():
+            with httpx.Client(timeout=timeout) as client:
+                response = client.get(url, headers={"Accept": "application/json"})
+                response.raise_for_status()
+                payload = response.json()
+    except httpx.HTTPError as exc:
+        _LOGGER.debug("Update check failed: %s", exc, exc_info=True)
         return None
-    except ValueError:
+    except ValueError as exc:
+        _LOGGER.debug("Invalid JSON while checking for updates: %s", exc, exc_info=True)
         return None
 
     info = payload.get("info") if isinstance(payload, dict) else None
@@ -68,6 +79,8 @@ def _build_update_panel(
     current_version: str,
     latest_version: str,
     command_text: str,
+    *,
+    show_command_hint: bool,
 ) -> AIPPanel:
     """Create a Rich panel that prompts the user to update."""
     command_markup = format_command_hint(command_text) or command_text
@@ -75,9 +88,10 @@ def _build_update_panel(
         f"[{WARNING_STYLE}]✨ Update available![/] "
         f"{current_version} → {latest_version}\n\n"
         "See the latest release notes:\n"
-        f"https://pypi.org/project/glaip-sdk/{latest_version}/\n\n"
-        f"[{ACCENT_STYLE}]Run[/] {command_markup} to install."
+        f"https://pypi.org/project/glaip-sdk/{latest_version}/"
     )
+    if show_command_hint:
+        message += f"\n\n[{ACCENT_STYLE}]Run[/] {command_markup} to install."
     return AIPPanel(
         message,
         title=f"[{SUCCESS_STYLE}]AIP SDK Update[/]",
@@ -97,11 +111,7 @@ def maybe_notify_update(
     slash_command: str | None = None,
     style: Literal["panel", "inline"] = "panel",
 ) -> None:
-    """Check PyPI for a newer version and display a prompt if one exists.
-
-    This function deliberately swallows network errors to avoid impacting CLI
-    startup time when offline or when PyPI is unavailable.
-    """
+    """Check PyPI for a newer version and display a prompt if one exists."""
     if not _should_check_for_updates():
         return
 
@@ -120,18 +130,152 @@ def maybe_notify_update(
         return
 
     active_console = console or Console()
+    should_prompt = _should_prompt_for_action(active_console, ctx)
+
     if style == "inline":
+        if should_prompt:
+            message = (
+                f"[{WARNING_STYLE}]✨ Update[/] "
+                f"{current_version} → {latest_version} "
+                "- choose Update now or Skip to continue."
+            )
+            active_console.print(message)
+            _handle_update_decision(active_console, ctx)
+            return
+
         command_markup = format_command_hint(command_text) or command_text
-        message = (
-            f"[{WARNING_STYLE}]✨ Update[/] "
-            f"{current_version} → {latest_version} "
-            f"- {command_markup}"
-        )
-        active_console.print(message)
+        active_console.print(f"[{WARNING_STYLE}]✨ Update[/] {current_version} → {latest_version} - {command_markup}")
         return
 
-    panel = _build_update_panel(current_version, latest_version, command_text)
+    panel = _build_update_panel(
+        current_version,
+        latest_version,
+        command_text,
+        show_command_hint=not should_prompt,
+    )
     active_console.print(panel)
+    if should_prompt:
+        _handle_update_decision(active_console, ctx)
+
+
+def _handle_update_decision(console: Console, ctx: Any) -> None:
+    """Prompt the user to take action on the available update."""
+    choice = _prompt_update_decision(console)
+    if choice == "skip":
+        return
+
+    _run_update_command(console, ctx)
+
+
+def _should_prompt_for_action(console: Console, ctx: Any | None) -> bool:
+    """Return True when we can safely block for interactive input."""
+    if ctx is None or not hasattr(ctx, "invoke"):
+        return False
+
+    is_interactive = getattr(console, "is_interactive", False)
+    if not isinstance(is_interactive, bool) or not is_interactive:
+        return False
+
+    is_terminal = getattr(console, "is_terminal", False)
+    if not isinstance(is_terminal, bool) or not is_terminal:
+        return False
+
+    input_method = getattr(console, "input", None)
+    return callable(input_method)
+
+
+def _prompt_update_decision(console: Console) -> Literal["update", "skip"]:
+    """Ask the user to choose between updating now or skipping."""
+    console.print(
+        f"[{ACCENT_STYLE}]Select an option to continue:[/]\n"
+        f"  [{SUCCESS_STYLE}]1.[/] Update now\n"
+        f"  [{WARNING_STYLE}]2.[/] Skip\n"
+    )
+    console.print("[dim]Press Enter after typing your choice.[/]")
+
+    while True:
+        try:
+            response = console.input("Choice [1/2]: ").strip().lower()
+        except (KeyboardInterrupt, EOFError):
+            console.print(f"\n[{WARNING_STYLE}]Update skipped.[/]")
+            return "skip"
+
+        if response in {"1", "update", "u"}:
+            return "update"
+        if response in {"2", "skip", "s"}:
+            return "skip"
+
+        console.print(f"[{ERROR_STYLE}]Please enter 1 to update now or 2 to skip.[/]")
+
+
+def _run_update_command(console: Console, ctx: Any) -> None:
+    """Invoke the built-in update command and surface any errors."""
+    try:
+        ctx.invoke(update_command)
+    except click.ClickException as exc:
+        exc.show()
+        console.print(f"[{ERROR_STYLE}]Update command exited with an error.[/]")
+    except click.Abort:
+        console.print(f"[{WARNING_STYLE}]Update aborted by user.[/]")
+    except Exception as exc:  # pragma: no cover - defensive guard
+        console.print(f"[{ERROR_STYLE}]Unexpected error while running update: {exc}[/]")
+    else:
+        _refresh_installed_version(console, ctx)
+
+
+@contextmanager
+def _suppress_library_logging(
+    logger_names: Iterable[str] | None = None, *, level: int = logging.WARNING
+) -> Iterator[None]:
+    """Temporarily raise log level for selected libraries during update checks."""
+    names = tuple(logger_names) if logger_names is not None else ("httpx",)
+    captured: list[tuple[logging.Logger, int]] = []
+    try:
+        for name in names:
+            logger = logging.getLogger(name)
+            captured.append((logger, logger.level))
+            logger.setLevel(level)
+        yield
+    finally:
+        for logger, previous_level in captured:
+            logger.setLevel(previous_level)
+
+
+def _refresh_installed_version(console: Console, ctx: Any) -> None:
+    """Reload runtime metadata after an in-process upgrade."""
+    new_version: str | None = None
+
+    try:
+        version_module = importlib.reload(importlib.import_module("glaip_sdk._version"))
+        new_version = getattr(version_module, "__version__", None)
+    except Exception as exc:  # pragma: no cover - defensive guard
+        _LOGGER.debug("Failed to reload glaip_sdk._version: %s", exc, exc_info=True)
+
+    try:
+        branding_module = importlib.import_module("glaip_sdk.branding")
+        if new_version:
+            branding_module.SDK_VERSION = new_version
+    except Exception as exc:  # pragma: no cover - defensive guard
+        _LOGGER.debug("Failed to update branding metadata: %s", exc, exc_info=True)
+
+    session = _get_slash_session(ctx)
+    if session and hasattr(session, "refresh_branding"):
+        try:
+            session.refresh_branding(new_version)
+            return
+        except Exception as exc:  # pragma: no cover - defensive guard
+            _LOGGER.debug("Failed to refresh active slash session: %s", exc, exc_info=True)
+
+    if new_version:
+        console.print(f"[{SUCCESS_STYLE}]CLI now running glaip-sdk {new_version}.[/]")
+
+
+def _get_slash_session(ctx: Any) -> Any | None:
+    """Return active slash session from the Click context if present."""
+    ctx_obj = getattr(ctx, "obj", None)
+    if isinstance(ctx_obj, dict):
+        return ctx_obj.get("_slash_session")
+    return None
 
 
 __all__ = ["maybe_notify_update"]