glaip-sdk 0.0.7__py3-none-any.whl → 0.6.5b6__py3-none-any.whl

glaip_sdk/cli/slash/agent_session.py

@@ -0,0 +1,282 @@
+"""Agent-specific interaction loop for the command palette.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+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.constants import DEFAULT_AGENT_INSTRUCTION_PREVIEW_LIMIT
+from glaip_sdk.cli.hints import format_command_hint
+from glaip_sdk.cli.slash.prompt import _HAS_PROMPT_TOOLKIT, FormattedText
+from glaip_sdk.cli.utils import bind_slash_session_context
+
+if TYPE_CHECKING:  # pragma: no cover - type checking only
+    from glaip_sdk.cli.slash.session import SlashSession
+
+
+class AgentRunSession:
+    """Per-agent execution context for the command palette."""
+
+    def __init__(self, session: SlashSession, agent: Any) -> None:
+        """Initialize the agent run session.
+
+        Args:
+            session: The slash session context
+            agent: The agent to interact with
+        """
+        self.session = session
+        self.agent = agent
+        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. Alt+Enter inserts a newline."
+        self._contextual_completion_help: dict[str, str] = {
+            "details": "Show this agent's configuration (+ expands prompt).",
+            "help": "Display this context-aware menu.",
+            "runs": "✨ NEW · Browse remote run history for this agent.",
+            "exit": "Return to the command palette.",
+            "q": "Return to the command palette.",
+        }
+        self._instruction_preview_limit = DEFAULT_AGENT_INSTRUCTION_PREVIEW_LIMIT
+
+    def run(self) -> None:
+        """Run the interactive agent session loop."""
+        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."""
+        self.session._render_header(self.agent, focus_agent=True)
+
+    def _run_agent_loop(self) -> None:
+        """Run the main agent interaction loop."""
+        while True:
+            raw = self._get_user_input()
+            if raw is None:
+                return
+
+            raw = raw.strip()
+            if not raw:
+                continue
+
+            if raw.startswith("/"):
+                if not self._handle_slash_command(raw, self._agent_id):
+                    return
+                continue
+
+            self._run_agent(self._agent_id, raw)
+
+    def _get_user_input(self) -> str | None:
+        """Get user input with proper error handling."""
+        try:
+
+            def _prompt_message() -> Any:
+                """Get formatted prompt message for agent session."""
+                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", "\n› "),
+                    ]
+                    return FormattedText(segments)
+
+                return f"{prompt_prefix}\n› "
+
+            raw = self.session._prompt(
+                _prompt_message,
+                placeholder=self._prompt_placeholder,
+            )
+            if self._prompt_placeholder:
+                # Show the guidance once, then fall back to a clean prompt.
+                self._prompt_placeholder = ""
+            return raw
+        except EOFError:
+            self.console.print("\nExiting agent context.")
+            return None
+        except KeyboardInterrupt:
+            self.console.print("")
+            return ""
+
+    def _handle_slash_command(self, raw: str, agent_id: str) -> bool:
+        """Handle slash commands in agent context. Returns False if should exit."""
+        # Handle simple commands first
+        if raw == "/":
+            return self._handle_help_command()
+
+        if raw in {"/exit", "/back", "/q"}:
+            return self._handle_exit_command()
+
+        if raw == "/details":
+            return self._handle_details_command(agent_id)
+
+        if raw in {"/help", "/?"}:
+            return self._handle_help_command()
+
+        # Handle other commands through the main session
+        return self._handle_other_command(raw)
+
+    def _handle_help_command(self) -> bool:
+        """Handle help command."""
+        self.session._cmd_help([], True)
+        return True
+
+    def _handle_exit_command(self) -> bool:
+        """Handle exit command."""
+        self.console.print("[dim]Returning to the main prompt.[/dim]")
+        return False
+
+    def _handle_details_command(self, agent_id: str) -> bool:
+        """Handle details command."""
+        self._show_details(agent_id)
+        return True
+
+    def _handle_other_command(self, raw: str) -> bool:
+        """Handle other commands through the main session."""
+        self.session.handle_command(raw, invoked_from_agent=True)
+        return not self.session._should_exit
+
+    def _show_details(self, agent_id: str, *, enable_prompt: bool = True) -> None:
+        """Render the agent's configuration export inside the command palette."""
+        try:
+            self.session.ctx.invoke(
+                agents_get_command,
+                agent_ref=agent_id,
+                instruction_preview=self._instruction_preview_limit,
+            )
+            if enable_prompt:
+                self._prompt_instruction_view_toggle(agent_id)
+                self.console.print(
+                    f"[{HINT_PREFIX_STYLE}]Tip:[/] Continue the conversation in this prompt, or use "
+                    f"{format_command_hint('/help') or '/help'} for shortcuts."
+                )
+        except click.ClickException as exc:
+            self.console.print(f"[{ERROR_STYLE}]{exc}[/]")
+
+    def _prompt_instruction_view_toggle(self, agent_id: str) -> None:
+        """Offer a prompt to expand or collapse the instruction preview after details."""
+        if not getattr(self.console, "is_terminal", False):
+            return
+
+        while True:
+            mode = "expanded" if self._instruction_preview_limit == 0 else "trimmed"
+            self.console.print(f"[dim]Instruction view is {mode}. Press Ctrl+T to toggle, Enter to continue.[/dim]")
+            try:
+                ch = click.getchar()
+            except (EOFError, KeyboardInterrupt):  # pragma: no cover - defensive guard
+                return
+
+            if not self._handle_instruction_toggle_input(agent_id, ch):
+                break
+
+        if self._instruction_preview_limit == 0:
+            self._instruction_preview_limit = DEFAULT_AGENT_INSTRUCTION_PREVIEW_LIMIT
+        self.console.print("")
+
+    def _handle_instruction_toggle_input(self, agent_id: str, ch: str) -> bool:
+        """Process a single toggle keypress; return False when the loop should exit."""
+        if ch in {"\r", "\n"}:
+            return False
+
+        lowered = ch.lower()
+        if lowered == "t" or ch == "\x14":  # support literal 't' or Ctrl+T
+            self._instruction_preview_limit = (
+                DEFAULT_AGENT_INSTRUCTION_PREVIEW_LIMIT if self._instruction_preview_limit == 0 else 0
+            )
+            self._show_details(agent_id, enable_prompt=False)
+            return True
+
+        # Ignore other keys and continue prompting.
+        return True
+
+    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."""
+        with bind_slash_session_context(self.session.ctx, self.session):
+            yield
+
+    def _run_agent(self, agent_id: str, message: str) -> None:
+        """Execute the agents run command for the active agent."""
+        if not message:
+            return
+
+        try:
+            self.session.notify_agent_run_started()
+            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"[{ERROR_STYLE}]{exc}[/]")
+        finally:
+            try:
+                self.session.notify_agent_run_finished()
+            except Exception:
+                pass

glaip_sdk/cli/slash/prompt.py

@@ -0,0 +1,245 @@
+"""prompt_toolkit integration helpers for the slash session.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any
+
+_HAS_PROMPT_TOOLKIT = False
+
+try:  # pragma: no cover - optional dependency
+    from prompt_toolkit import PromptSession
+    from prompt_toolkit.completion import Completer, Completion
+    from prompt_toolkit.formatted_text import FormattedText, to_formatted_text
+    from prompt_toolkit.key_binding import KeyBindings
+    from prompt_toolkit.patch_stdout import patch_stdout
+    from prompt_toolkit.styles import Style
+
+    _HAS_PROMPT_TOOLKIT = True
+except Exception:  # pragma: no cover - optional dependency
+    PromptSession = None  # type: ignore[assignment]
+    Completer = None  # type: ignore[assignment]
+    Completion = None  # type: ignore[assignment]
+    FormattedText = None  # type: ignore[assignment]
+    to_formatted_text = None  # type: ignore[assignment]
+    KeyBindings = None  # type: ignore[assignment]
+    Style = None  # type: ignore[assignment]
+    patch_stdout = None  # type: ignore[assignment]
+
+if TYPE_CHECKING:  # pragma: no cover - typing only
+    from glaip_sdk.cli.slash.session import SlashSession
+
+
+if _HAS_PROMPT_TOOLKIT:
+
+    class SlashCompleter(Completer):
+        """Provide slash command completions inside the prompt."""
+
+        def __init__(self, session: SlashSession) -> None:
+            """Initialize the slash completer.
+
+            Args:
+                session: The slash session context
+            """
+            self._session = session
+
+        def get_completions(
+            self,
+            document: Any,
+            _complete_event: Any,  # type: ignore[no-any-return]
+        ) -> Iterable[Completion]:
+            """Get completions for slash commands.
+
+            Args:
+                document: The document being edited
+                _complete_event: The completion event
+
+            Yields:
+                Completion objects for matching commands
+            """
+            if Completion is None:
+                return
+
+            text = document.text_before_cursor or ""
+            if not text.startswith("/") or " " in text:
+                return
+
+            yield from _iter_command_completions(self._session, text)
+            yield from _iter_contextual_completions(self._session, text)
+
+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:
+            """Initialize the fallback slash completer.
+
+            Args:
+                session: The slash session context
+            """
+            self._session = session
+
+
+def setup_prompt_toolkit(
+    session: SlashSession,
+    *,
+    interactive: bool,
+) -> tuple[Any | None, Any | None]:
+    """Configure prompt_toolkit session and style for interactive mode."""
+    if not (interactive and _HAS_PROMPT_TOOLKIT):
+        return None, None
+
+    if PromptSession is None or Style is None:
+        return None, None
+
+    bindings = _create_key_bindings(session)
+
+    prompt_session = PromptSession(
+        completer=SlashCompleter(session),
+        complete_while_typing=True,
+        key_bindings=bindings,
+    )
+    prompt_style = Style.from_dict(
+        {
+            "prompt": "bg:#0f172a #facc15 bold",
+            "": "bg:#0f172a #e2e8f0",
+            "placeholder": "bg:#0f172a #94a3b8 italic",
+        }
+    )
+
+    return prompt_session, prompt_style
+
+
+def _create_key_bindings(_session: SlashSession) -> Any:
+    """Create prompt_toolkit key bindings for the command palette."""
+    if KeyBindings is None:
+        return None
+
+    bindings = KeyBindings()
+
+    def _refresh_completions(buffer: Any) -> None:  # type: ignore[no-any-return]
+        """Refresh completions when slash command is typed.
+
+        Args:
+            buffer: Prompt buffer instance.
+        """
+        text = buffer.document.text_before_cursor or ""
+        if text.startswith("/") and " " not in text:
+            buffer.start_completion(select_first=False)
+        elif buffer.complete_state is not None:
+            buffer.cancel_completion()
+
+    @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)
+
+    @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)
+
+    @bindings.add("c-h")  # type: ignore[misc]
+    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("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 _iter_command_completions(
+    session: SlashSession, text: str
+) -> Iterable[Completion]:  # pragma: no cover - thin wrapper
+    """Yield completions for global slash commands."""
+    prefix = text[1:]
+    seen: set[str] = set()
+
+    # Early return for contextual commands scenario
+    if not _should_include_commands(session):
+        return []
+
+    commands = sorted(session._unique_commands.values(), key=lambda c: c.name)
+    agent_context = bool(getattr(session, "_current_agent", None))
+
+    for cmd in commands:
+        if getattr(cmd, "agent_only", False) and not agent_context:
+            continue
+        yield from _generate_command_completions(cmd, prefix, text, seen)
+
+
+def _should_include_commands(session: SlashSession) -> bool:
+    """Check if commands should be included in completions."""
+    return not (session.get_contextual_commands() and not session.should_include_global_commands())
+
+
+def _generate_command_completions(cmd: Any, prefix: str, text: str, seen: set[str]) -> Iterable[Completion]:
+    """Generate completion items for a single command."""
+    for alias in (cmd.name, *cmd.aliases):
+        if alias in seen or alias.startswith("?"):
+            continue
+
+        if prefix and not alias.startswith(prefix):
+            continue
+
+        seen.add(alias)
+        label = f"/{alias}"
+        yield Completion(
+            text=label,
+            start_position=-len(text),
+            display=label,
+            display_meta=cmd.help,
+        )
+
+
+def _iter_contextual_completions(
+    session: SlashSession, text: str
+) -> Iterable[Completion]:  # pragma: no cover - thin wrapper
+    """Yield completions for context-specific slash commands."""
+    prefix = text[1:]
+    seen: set[str] = set()
+
+    contextual_commands = sorted(session.get_contextual_commands().items(), key=lambda item: item[0])
+
+    for alias, help_text in contextual_commands:
+        if alias in seen:
+            continue
+        if prefix and not alias.startswith(prefix):
+            continue
+        seen.add(alias)
+        label = f"/{alias}"
+        yield Completion(
+            text=label,
+            start_position=-len(text),
+            display=label,
+            display_meta=help_text,
+        )
+
+
+__all__ = [
+    "SlashCompleter",
+    "setup_prompt_toolkit",
+    "FormattedText",
+    "to_formatted_text",
+    "patch_stdout",
+    "PromptSession",
+    "Style",
+    "_HAS_PROMPT_TOOLKIT",
+]