glaip-sdk 0.0.19__py3-none-any.whl → 0.0.20__py3-none-any.whl

glaip_sdk/cli/slash/agent_session.py

@@ -6,16 +6,19 @@ Authors:
 
 from __future__ import annotations
 
+from contextlib import contextmanager
 from typing import TYPE_CHECKING, Any
 
 import click
 
+from glaip_sdk.branding import ERROR_STYLE, HINT_PREFIX_STYLE
 from glaip_sdk.cli.commands.agents import get as agents_get_command
 from glaip_sdk.cli.commands.agents import run as agents_run_command
 from glaip_sdk.cli.slash.prompt import _HAS_PROMPT_TOOLKIT, FormattedText
+from glaip_sdk.cli.utils import format_command_hint
 
 if TYPE_CHECKING:  # pragma: no cover - type checking only
-    from .session import SlashSession
+    from glaip_sdk.cli.slash.session import SlashSession
 
 
 class AgentRunSession:
@@ -33,15 +36,12 @@ class AgentRunSession:
         self.console = session.console
         self._agent_id = str(getattr(agent, "id", ""))
         self._agent_name = getattr(agent, "name", "") or self._agent_id
-        self._prompt_placeholder: str = (
-            "Chat with this agent here; use / for shortcuts."
-        )
+        self._prompt_placeholder: str = "Chat with this agent here; use / for shortcuts. Alt+Enter inserts a newline."
         self._contextual_completion_help: dict[str, str] = {
             "details": "Show this agent's full configuration.",
             "help": "Display this context-aware menu.",
             "exit": "Return to the command palette.",
             "q": "Return to the command palette.",
-            "verbose": "Toggle verbose streaming output.",
         }
 
     def run(self) -> None:
@@ -49,11 +49,17 @@ class AgentRunSession:
         self.session.set_contextual_commands(
             self._contextual_completion_help, include_global=False
         )
+        previous_agent = getattr(self.session, "_current_agent", None)
+        self.session._current_agent = self.agent
+        clear_ready = getattr(self.session, "clear_agent_transcript_ready", None)
+        if callable(clear_ready):
+            clear_ready(self._agent_id)
         try:
             self._display_agent_info()
             self._run_agent_loop()
         finally:
             self.session.set_contextual_commands(None)
+            self.session._current_agent = previous_agent
 
     def _display_agent_info(self) -> None:
         """Display agent information and summary."""
@@ -82,25 +88,17 @@ class AgentRunSession:
         try:
 
             def _prompt_message() -> Any:
-                verbose_enabled = self.session.verbose_enabled
-                verbose_tag = "[verbose:on]" if verbose_enabled else "[verbose:off]"
                 prompt_prefix = f"{self._agent_name} ({self._agent_id}) "
 
                 # Use FormattedText if prompt_toolkit is available, otherwise use simple string
                 if _HAS_PROMPT_TOOLKIT and FormattedText is not None:
                     segments = [
                         ("class:prompt", prompt_prefix),
-                        (
-                            "class:prompt-verbose-on"
-                            if verbose_enabled
-                            else "class:prompt-verbose-off",
-                            verbose_tag,
-                        ),
                         ("class:prompt", "\n› "),
                     ]
                     return FormattedText(segments)
 
-                return f"{prompt_prefix}{verbose_tag}\n› "
+                return f"{prompt_prefix}\n› "
 
             raw = self.session._prompt(
                 _prompt_message,
@@ -159,39 +157,93 @@ class AgentRunSession:
         try:
             self.session.ctx.invoke(agents_get_command, agent_ref=agent_id)
             self.console.print(
-                "[dim]Tip: Continue the conversation in this prompt, or use /help for shortcuts."
+                f"[{HINT_PREFIX_STYLE}]Tip:[/] Continue the conversation in this prompt, or use {format_command_hint('/help') or '/help'} for shortcuts."
             )
         except click.ClickException as exc:
-            self.console.print(f"[red]{exc}[/red]")
+            self.console.print(f"[{ERROR_STYLE}]{exc}[/]")
+
+    def _after_agent_run(self) -> None:
+        """Handle transcript viewer behaviour after a successful run."""
+        payload, manifest = self.session._get_last_transcript()
+        if not self._transcript_matches(payload, manifest):
+            return
+        run_id = str(manifest.get("run_id") or "")
+        mark_ready = getattr(self.session, "mark_agent_transcript_ready", None)
+        if callable(mark_ready):
+            mark_ready(self._agent_id, run_id)
+        if self._open_transcript_viewer():
+            return
+        self.console.print(
+            "[dim]Transcript viewer is unavailable in this environment.[/dim]"
+        )
+
+    def _transcript_matches(self, payload: Any, manifest: Any) -> bool:
+        """Return True when the latest transcript belongs to this agent."""
+        if not payload or not isinstance(manifest, dict):
+            return False
+        if not manifest.get("run_id"):
+            return False
+        return manifest.get("agent_id") == self._agent_id
+
+    def _open_transcript_viewer(self) -> bool:
+        """Launch the transcript viewer when terminal support is available."""
+        if not getattr(self.console, "is_terminal", False):
+            return False
+        try:
+            current_agent = getattr(self.session, "_current_agent", None)
+            self.session.open_transcript_viewer(announce=True)
+            if getattr(self.session.console, "is_terminal", False):
+                try:
+                    self.session.console.clear()
+                except Exception:  # pragma: no cover - defensive cleanup
+                    pass
+                if (
+                    current_agent is not None
+                ):  # pragma: no cover - UI refresh best effort
+                    try:
+                        self.session._render_header(current_agent, focus_agent=True)
+                    except Exception:  # pragma: no cover - defensive cleanup
+                        pass
+            return True
+        except Exception:  # pragma: no cover - defensive cleanup
+            return False
+
+    @contextmanager
+    def _bind_session_context(self) -> Any:
+        """Temporarily attach this slash session to the Click context."""
+        ctx_obj = getattr(self.session.ctx, "obj", None)
+        has_context = isinstance(ctx_obj, dict)
+        previous_session = ctx_obj.get("_slash_session") if has_context else None
+        if has_context:
+            ctx_obj["_slash_session"] = self.session
+        try:
+            yield
+        finally:
+            if has_context:
+                if previous_session is None:
+                    ctx_obj.pop("_slash_session", None)
+                else:
+                    ctx_obj["_slash_session"] = previous_session
 
     def _run_agent(self, agent_id: str, message: str) -> None:
         if not message:
             return
 
         try:
-            ctx = self.session.ctx
-            ctx_obj = getattr(ctx, "obj", None)
-            previous_session = None
-            if isinstance(ctx_obj, dict):
-                previous_session = ctx_obj.get("_slash_session")
-                ctx_obj["_slash_session"] = self.session
-
             self.session.notify_agent_run_started()
-            self.session.ctx.invoke(
-                agents_run_command,
-                agent_ref=agent_id,
-                input_text=message,
-                verbose=self.session.verbose_enabled,
-            )
+            with self._bind_session_context():
+                self.session.ctx.invoke(
+                    agents_run_command,
+                    agent_ref=agent_id,
+                    input_text=message,
+                    verbose=False,
+                )
             self.session.last_run_input = message
+            self._after_agent_run()
         except click.ClickException as exc:
-            self.console.print(f"[red]{exc}[/red]")
+            self.console.print(f"[{ERROR_STYLE}]{exc}[/]")
         finally:
             try:
                 self.session.notify_agent_run_finished()
-            finally:
-                if isinstance(ctx_obj, dict):
-                    if previous_session is None:
-                        ctx_obj.pop("_slash_session", None)
-                    else:
-                        ctx_obj["_slash_session"] = previous_session
+            except Exception:
+                pass

glaip_sdk/cli/slash/prompt.py

@@ -19,11 +19,6 @@ try:  # pragma: no cover - optional dependency
     from prompt_toolkit.patch_stdout import patch_stdout
     from prompt_toolkit.styles import Style
 
-    try:
-        from prompt_toolkit.application import run_in_terminal as ptk_run_in_terminal
-    except Exception:  # pragma: no cover - compatibility fallback
-        ptk_run_in_terminal = None
-
     _HAS_PROMPT_TOOLKIT = True
 except Exception:  # pragma: no cover - optional dependency
     PromptSession = None  # type: ignore[assignment]
@@ -34,10 +29,9 @@ except Exception:  # pragma: no cover - optional dependency
     KeyBindings = None  # type: ignore[assignment]
     Style = None  # type: ignore[assignment]
     patch_stdout = None  # type: ignore[assignment]
-    ptk_run_in_terminal = None
 
 if TYPE_CHECKING:  # pragma: no cover - typing only
-    from .session import SlashSession
+    from glaip_sdk.cli.slash.session import SlashSession
 
 
 if _HAS_PROMPT_TOOLKIT:
@@ -57,7 +51,7 @@ if _HAS_PROMPT_TOOLKIT:
             self,
             document: Any,
             _complete_event: Any,  # type: ignore[no-any-return]
-        ) -> Iterable[Completion]:  # pragma: no cover - UI
+        ) -> Iterable[Completion]:
             """Get completions for slash commands.
 
             Args:
@@ -82,7 +76,7 @@ else:  # pragma: no cover - fallback when prompt_toolkit is missing
     class SlashCompleter:  # type: ignore[too-many-ancestors]
         """Fallback slash completer when prompt_toolkit is not available."""
 
-        def __init__(self, session: SlashSession) -> None:  # noqa: D401 - stub
+        def __init__(self, session: SlashSession) -> None:
             """Initialize the fallback slash completer.
 
             Args:
@@ -113,8 +107,6 @@ def setup_prompt_toolkit(
     prompt_style = Style.from_dict(
         {
             "prompt": "bg:#0f172a #facc15 bold",
-            "prompt-verbose-on": "bg:#0f172a #34d399 bold",
-            "prompt-verbose-off": "bg:#0f172a #f87171 bold",
             "": "bg:#0f172a #e2e8f0",
             "placeholder": "bg:#0f172a #94a3b8 italic",
         }
@@ -123,7 +115,7 @@ def setup_prompt_toolkit(
     return prompt_session, prompt_style
 
 
-def _create_key_bindings(session: SlashSession) -> Any:
+def _create_key_bindings(_session: SlashSession) -> Any:
     """Create prompt_toolkit key bindings for the command palette."""
     if KeyBindings is None:
         return None
@@ -137,57 +129,37 @@ def _create_key_bindings(session: SlashSession) -> Any:
         elif buffer.complete_state is not None:
             buffer.cancel_completion()
 
-    def _trigger_slash_completion(event: Any) -> None:  # pragma: no cover - UI
+    @bindings.add("/")  # type: ignore[misc]
+    def _handle_slash_key(event: Any) -> None:  # vulture: ignore
+        """Handle '/' key press - insert slash and trigger completion."""
         buffer = event.app.current_buffer
         buffer.insert_text("/")
         _refresh_completions(buffer)
 
-    def _handle_backspace(event: Any) -> None:  # pragma: no cover - UI
+    @bindings.add("backspace")  # type: ignore[misc]
+    def _handle_backspace_key(event: Any) -> None:  # vulture: ignore
+        """Handle backspace key - delete character and refresh completions."""
         buffer = event.app.current_buffer
         if buffer.document.cursor_position > 0:
             buffer.delete_before_cursor()
         _refresh_completions(buffer)
 
-    def _toggle_verbose(event: Any) -> None:  # pragma: no cover - UI
-        _execute_toggle_verbose(session, event.app)
-
-    @bindings.add("/")  # type: ignore[misc]
-    def _add_trigger_slash_completion(event: Any) -> None:
-        _trigger_slash_completion(event)
-
-    @bindings.add("backspace")  # type: ignore[misc]
-    def _add_handle_backspace(event: Any) -> None:
-        _handle_backspace(event)
-
     @bindings.add("c-h")  # type: ignore[misc]
-    def _add_handle_ctrl_h(event: Any) -> None:
-        _handle_backspace(event)  # Reuse backspace handler
+    def _handle_ctrl_h_key(event: Any) -> None:  # vulture: ignore
+        """Handle Ctrl+H key - same as backspace."""
+        _handle_backspace_key(event)  # Reuse backspace handler
 
-    @bindings.add("c-t")  # type: ignore[misc]
-    def _add_toggle_verbose(event: Any) -> None:
-        _toggle_verbose(event)
+    @bindings.add("escape", "enter")  # type: ignore[misc]
+    def _handle_alt_enter_key(event: Any) -> None:  # vulture: ignore
+        """Handle Alt+Enter key - insert line break and cancel completion."""
+        buffer = event.app.current_buffer
+        buffer.insert_text("\n")
+        if buffer.complete_state is not None:
+            buffer.cancel_completion()
 
     return bindings
 
 
-def _execute_toggle_verbose(
-    session: SlashSession, app: Any
-) -> None:  # pragma: no cover - UI
-    """Execute verbose toggle with proper terminal handling."""
-
-    def _announce() -> None:
-        session.toggle_verbose(announce=False)
-
-    run_in_terminal = getattr(app, "run_in_terminal", None)
-    if callable(run_in_terminal):
-        run_in_terminal(_announce)
-    elif ptk_run_in_terminal is not None:
-        ptk_run_in_terminal(_announce)
-    else:
-        _announce()
-    app.invalidate()
-
-
 def _iter_command_completions(
     session: SlashSession, text: str
 ) -> Iterable[Completion]:  # pragma: no cover - thin wrapper