glaip-sdk 0.6.12__py3-none-any.whl → 0.6.14__py3-none-any.whl

glaip_sdk/cli/slash/agent_session.py

@@ -1,285 +0,0 @@
-"""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. Ctrl+T opens the last transcript."
-        )
-        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

@@ -1,256 +0,0 @@
-"""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()
-
-    @bindings.add("c-t")  # type: ignore[misc]
-    def _handle_ctrl_t_key(event: Any) -> None:  # vulture: ignore
-        """Handle Ctrl+T key - open the transcript viewer (when available)."""
-        buffer = event.app.current_buffer
-        if buffer.complete_state is not None:
-            buffer.cancel_completion()
-
-        open_viewer = getattr(_session, "open_transcript_viewer", None)
-        if callable(open_viewer):
-            open_viewer(announce=True)
-
-    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",
-]