glaip-sdk 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

glaip_sdk/cli/resolution.py

@@ -12,7 +12,7 @@ from typing import Any
 
 import click
 
-from glaip_sdk.cli.utils import resolve_resource
+from glaip_sdk.cli.utils import resolve_resource, spinner_context
 
 
 def resolve_resource_reference(
@@ -25,6 +25,7 @@ def resolve_resource_reference(
     label: str,
     select: int | None = None,
     interface_preference: str | None = None,
+    spinner_message: str | None = None,
 ) -> Any | None:
     """Resolve resource reference (ID or name) with ambiguity handling.
 
@@ -47,14 +48,21 @@ def resolve_resource_reference(
         click.ClickException: If resolution fails
     """
     try:
-        return resolve_resource(
-            ctx,
-            reference,
-            get_by_id=get_by_id_func,
-            find_by_name=find_by_name_func,
-            label=label,
-            select=select,
-            interface_preference=interface_preference,
+        message = (
+            spinner_message
+            if spinner_message is not None
+            else f"[bold blue]Fetching {label}…[/bold blue]"
         )
+        with spinner_context(ctx, message, spinner_style="cyan") as status_indicator:
+            return resolve_resource(
+                ctx,
+                reference,
+                get_by_id=get_by_id_func,
+                find_by_name=find_by_name_func,
+                label=label,
+                select=select,
+                interface_preference=interface_preference,
+                status_indicator=status_indicator,
+            )
     except Exception as e:
         raise click.ClickException(f"Failed to resolve {resource_type.lower()}: {e}")

glaip_sdk/cli/slash/__init__.py

@@ -0,0 +1,25 @@
+"""Slash command palette entrypoints.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+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.commands.configure import configure_command, load_config
+from glaip_sdk.cli.utils import get_client
+
+from .agent_session import AgentRunSession
+from .prompt import _HAS_PROMPT_TOOLKIT
+from .session import SlashSession
+
+__all__ = [
+    "AgentRunSession",
+    "SlashSession",
+    "_HAS_PROMPT_TOOLKIT",
+    "agents_get_command",
+    "agents_run_command",
+    "configure_command",
+    "get_client",
+    "load_config",
+]

glaip_sdk/cli/slash/agent_session.py

@@ -0,0 +1,146 @@
+"""Agent-specific interaction loop for the command palette.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import click
+
+from glaip_sdk.cli.commands.agents import get as agents_get_command
+from glaip_sdk.cli.commands.agents import run as agents_run_command
+
+if TYPE_CHECKING:  # pragma: no cover - type checking only
+    from .session import SlashSession
+
+
+class AgentRunSession:
+    """Per-agent execution context for the command palette."""
+
+    def __init__(self, session: SlashSession, agent: Any) -> None:
+        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."
+        )
+        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.",
+        }
+
+    def run(self) -> None:
+        self.session.set_contextual_commands(
+            self._contextual_completion_help, include_global=False
+        )
+        try:
+            self._display_agent_info()
+            self._run_agent_loop()
+        finally:
+            self.session.set_contextual_commands(None)
+
+    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:
+            raw = self.session._prompt(
+                f"{self._agent_name} ({self._agent_id})\n› ",
+                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 in {"/details", "/detail"}:
+            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) -> None:
+        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."
+            )
+        except click.ClickException as exc:
+            self.console.print(f"[red]{exc}[/red]")
+
+    def _run_agent(self, agent_id: str, message: str) -> None:
+        if not message:
+            return
+
+        try:
+            self.session.ctx.invoke(
+                agents_run_command, agent_ref=agent_id, input_text=message
+            )
+            self.session.last_run_input = message
+        except click.ClickException as exc:
+            self.console.print(f"[red]{exc}[/red]")

glaip_sdk/cli/slash/prompt.py

@@ -0,0 +1,198 @@
+"""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
+    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]
+    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 .session import SlashSession
+
+
+if _HAS_PROMPT_TOOLKIT:
+
+    class SlashCompleter(Completer):
+        """Provide slash command completions inside the prompt."""
+
+        def __init__(self, session: SlashSession) -> None:
+            self._session = session
+
+        def get_completions(
+            self,
+            document: Any,
+            _complete_event: Any,  # type: ignore[no-any-return]
+        ) -> Iterable[Completion]:  # pragma: no cover - UI
+            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]
+        def __init__(self, session: SlashSession) -> None:  # noqa: D401 - stub
+            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()
+
+    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() -> 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]
+        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 _trigger_slash_completion(event: Any) -> None:  # pragma: no cover - UI
+        buffer = event.app.current_buffer
+        buffer.insert_text("/")
+        _refresh_completions(buffer)
+
+    @bindings.add("backspace")  # type: ignore[misc]
+    def _handle_backspace(event: Any) -> None:  # pragma: no cover - UI
+        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(event: Any) -> None:  # pragma: no cover - UI
+        buffer = event.app.current_buffer
+        if buffer.document.cursor_position > 0:
+            buffer.delete_before_cursor()
+        _refresh_completions(buffer)
+
+    return bindings
+
+
+def _iter_command_completions(
+    session: SlashSession, text: str
+) -> Iterable[Completion]:  # pragma: no cover - thin wrapper
+    prefix = text[1:]
+    seen: set[str] = set()
+
+    if (
+        session.get_contextual_commands()
+        and not session.should_include_global_commands()
+    ):
+        return []
+
+    commands = sorted(session._unique_commands.values(), key=lambda c: c.name)
+
+    for cmd in commands:
+        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
+    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",
+    "patch_stdout",
+    "PromptSession",
+    "Style",
+    "_HAS_PROMPT_TOOLKIT",
+]