alloy-runtime-cli 0.1.0__py3-none-any.whl

cli/tui/chat/commands/regenerate.py

@@ -0,0 +1,120 @@
+"""Command for regenerating the last AI response."""
+
+from dataclasses import dataclass
+from typing import Callable
+from uuid import UUID
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+from alloy_runtime_types.dtos.generation import (
+    AgentSource,
+    DirectModelSource,
+    GenerateTextRequest,
+)
+from alloy_runtime_types.enums.provider import Provider
+from alloy_runtime_sdk.logging.config import get_logger
+
+from cli.tui.chat.commands.base import CommandResult
+from cli.tui.chat.store import ChatStore
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class RegenerateCommand:
+    """Command to regenerate the last AI response.
+
+    Supports two modes:
+    - Agent mode: Uses agent_id to determine model and system instruction
+    - Model mode: Uses provider_key/provider_model_name/system_instruction directly
+
+    This command:
+    1. Transitions store to STREAMING phase
+    2. Sends a regenerate request to the API
+    3. Streams the new response chunks via callbacks (content and thinking)
+    4. Transitions back to IDLE when complete
+
+    Attributes:
+        client: Server client for API calls.
+        store: Chat store for state management.
+        session_id: ID of the current chat session.
+        on_chunk: Callback invoked with each streamed text chunk.
+        on_thinking_chunk: Callback invoked with each reasoning/thinking chunk.
+        agent_id: ID of the agent to use for regeneration (agent mode).
+        provider_key: Provider key (model mode).
+        provider_model_name: Model name (model mode).
+        system_instruction: System instruction (model mode).
+    """
+
+    client: ApiClient
+    store: ChatStore
+    session_id: UUID
+    on_chunk: Callable[[str], None]
+    on_thinking_chunk: Callable[[str], None] | None = None
+    # Agent mode
+    agent_id: UUID | None = None
+    # Model mode
+    provider_key: str | None = None
+    provider_model_name: str | None = None
+    system_instruction: str | None = None
+
+    async def execute(self) -> CommandResult[None]:
+        """Execute the regenerate response operation.
+
+        Returns:
+            CommandResult indicating success or failure.
+        """
+        logger.info("regenerate_starting", session_id=str(self.session_id))
+        self.store.start_streaming()
+
+        was_cancelled = False
+        try:
+            # Build model source based on mode
+            if self.agent_id is not None:
+                model_source = AgentSource(agent=self.agent_id)
+            elif self.provider_key and self.provider_model_name:
+                model_source = DirectModelSource(
+                    provider_key=Provider(self.provider_key),
+                    provider_model_name=self.provider_model_name,
+                )
+            else:
+                return CommandResult[None](
+                    success=False,
+                    error="No agent or model configured for this session",
+                )
+
+            request = GenerateTextRequest(
+                model_source=model_source,
+                chat_session_id=self.session_id,
+                regenerate=True,
+                stream=True,
+                tags=[],
+                # Only include system instruction for model mode
+                system_instruction=self.system_instruction
+                if self.agent_id is None
+                else None,
+            )
+
+            async for chunk in self.client.generate_text_stream(request):
+                # Check for cancellation request
+                if self.store.state.cancel_requested:
+                    logger.info("regenerate_cancelled_by_user")
+                    was_cancelled = True
+                    return CommandResult[None](success=True, data=None)
+
+                # Handle thinking/reasoning chunks
+                if chunk.chunk_type == "thinking" and chunk.reasoning_content:
+                    if self.on_thinking_chunk:
+                        self.on_thinking_chunk(chunk.reasoning_content)
+                # Handle regular text content chunks
+                elif chunk.content:
+                    self.on_chunk(chunk.content)
+
+            logger.info("regenerate_completed")
+            return CommandResult[None](success=True, data=None)
+
+        except Exception as e:
+            logger.warning("regenerate_failed", error=str(e))
+            return CommandResult[None](success=False, error=str(e))
+
+        finally:
+            self.store.finish_streaming(cancelled=was_cancelled)

cli/tui/chat/commands/reload_session.py

@@ -0,0 +1,63 @@
+"""Command for reloading the current session's messages."""
+
+from dataclasses import dataclass
+from uuid import UUID
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+from alloy_runtime_types.dtos.sessions import MessageResponse
+
+from cli.tui.chat.commands.base import CommandResult
+from cli.tui.chat.store import ChatStore
+
+
+@dataclass
+class ReloadSessionResult:
+    """Result data for reload session operation.
+
+    Attributes:
+        messages: Updated list of messages.
+    """
+
+    messages: list[MessageResponse]
+
+
+@dataclass
+class ReloadSessionCommand:
+    """Command to reload the current session's messages.
+
+    This is a lightweight operation that only fetches messages,
+    without changing the session context. Useful after sending
+    a message or regenerating to get the updated message list.
+
+    Attributes:
+        client: Server client for API calls.
+        store: Chat store for state management.
+        session_id: ID of the session to reload.
+        message_limit: Maximum number of messages to fetch.
+    """
+
+    client: ApiClient
+    store: ChatStore
+    session_id: UUID
+    message_limit: int = 100
+
+    async def execute(self) -> CommandResult[ReloadSessionResult]:
+        """Execute the reload session operation.
+
+        Returns:
+            CommandResult with updated messages on success.
+        """
+        try:
+            session = await self.client.get_session(
+                self.session_id, limit=self.message_limit
+            )
+            self.store.set_messages(list(session.messages))
+
+            return CommandResult[ReloadSessionResult](
+                success=True,
+                data=ReloadSessionResult(messages=list(session.messages)),
+            )
+
+        except Exception as e:
+            # Silently fail for reload - the user already saw the response
+            return CommandResult[ReloadSessionResult](success=False, error=str(e))

cli/tui/chat/commands/send_message.py

@@ -0,0 +1,190 @@
+"""Command for sending a message and streaming the response."""
+
+from dataclasses import dataclass
+from typing import Callable
+from uuid import UUID
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+from alloy_runtime_types.dtos.generation import (
+    AgentSource,
+    DirectModelSource,
+    GenerateTextRequest,
+)
+from alloy_runtime_types.enums.provider import Provider
+from alloy_runtime_sdk.logging.config import get_logger
+
+from cli.infrastructure.injection.parser import has_injections
+from cli.infrastructure.injection.resolver import ResolvedMessage
+from cli.tui.chat.commands.base import CommandResult
+from cli.tui.chat.services.injection import InjectionService
+from cli.tui.chat.store import ChatStore
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class SendMessageCommand:
+    """Command to send a user message and stream the AI response.
+
+    Supports two modes:
+    - Agent mode: Uses agent_id to determine model and system instruction
+    - Model mode: Uses provider_key/provider_model_name/system_instruction directly
+
+    Also supports injection resolution:
+    - @template('name') - Inject rendered template
+    - @text('uuid') - Inject text content
+    - @json('uuid') - Inject JSON content
+    - @schema('name') - Inject schema definition
+
+    This command:
+    1. Resolves any injection patterns in the message
+    2. Transitions store to STREAMING phase
+    3. Builds and sends the generation request
+    4. Streams response chunks via callbacks (content and thinking)
+    5. Transitions back to IDLE when complete
+
+    Attributes:
+        client: Server client for API calls.
+        store: Chat store for state management.
+        session_id: ID of the current chat session.
+        user_message: The user's message to send.
+        on_chunk: Callback invoked with each streamed text chunk.
+        on_thinking_chunk: Callback invoked with each reasoning/thinking chunk.
+        agent_id: ID of the agent to use for generation (agent mode).
+        provider_key: Provider key (model mode).
+        provider_model_name: Model name (model mode).
+        system_instruction: System instruction (model mode).
+        injection_service: Optional service for resolving injection patterns.
+        on_injection_resolved: Callback invoked with resolution result.
+    """
+
+    client: ApiClient
+    store: ChatStore
+    session_id: UUID
+    user_message: str
+    on_chunk: Callable[[str], None]
+    on_thinking_chunk: Callable[[str], None] | None = None
+    # Agent mode
+    agent_id: UUID | None = None
+    # Model mode
+    provider_key: str | None = None
+    provider_model_name: str | None = None
+    system_instruction: str | None = None
+    # Injection support
+    injection_service: InjectionService | None = None
+    on_injection_resolved: Callable[[ResolvedMessage], None] | None = None
+
+    async def execute(self) -> CommandResult[None]:
+        """Execute the send message and stream operation.
+
+        Returns:
+            CommandResult indicating success or failure.
+        """
+        message_to_send = self.user_message
+
+        # Resolve injections if service is available and message has patterns
+        if self.injection_service and has_injections(self.user_message):
+            try:
+                resolved = await self.injection_service.resolve_message(
+                    self.user_message
+                )
+
+                # Check for errors
+                if resolved.has_errors:
+                    error_messages = [e.message for e in resolved.errors]
+                    return CommandResult[None](
+                        success=False,
+                        error=f"Injection resolution failed: {error_messages[0]}",
+                    )
+
+                # Notify callback about successful resolution
+                if self.on_injection_resolved:
+                    self.on_injection_resolved(resolved)
+
+                # Use resolved text
+                message_to_send = resolved.text
+
+                logger.debug(
+                    "injection_resolved",
+                    extra={
+                        "fragments_used": len(resolved.fragments_used),
+                        "content_used": len(resolved.content_used),
+                        "schemas_used": len(resolved.schemas_used),
+                    },
+                )
+
+            except Exception as e:
+                logger.error(
+                    "injection_resolution_error",
+                    extra={"error": str(e)},
+                )
+                return CommandResult[None](
+                    success=False,
+                    error=f"Failed to resolve injections: {e}",
+                )
+
+        # Start streaming with the user message shown optimistically
+        # Note: We show the original message, not the resolved one
+        self.store.start_streaming(user_message=self.user_message)
+
+        was_cancelled = False
+        try:
+            # Build model source based on mode
+            if self.agent_id is not None:
+                model_source = AgentSource(agent=self.agent_id)
+            elif self.provider_key and self.provider_model_name:
+                model_source = DirectModelSource(
+                    provider_key=Provider(self.provider_key),
+                    provider_model_name=self.provider_model_name,
+                )
+            else:
+                return CommandResult[None](
+                    success=False,
+                    error="No agent or model configured for this session",
+                )
+
+            request = GenerateTextRequest(
+                model_source=model_source,
+                user_message=message_to_send,  # Use resolved message
+                stream=True,
+                tags=[],
+                chat_session_id=self.session_id,
+                # Only include system instruction for model mode
+                system_instruction=self.system_instruction
+                if self.agent_id is None
+                else None,
+            )
+
+            async for chunk in self.client.generate_text_stream(request):
+                # Check for cancellation request
+                if self.store.state.cancel_requested:
+                    logger.info("stream_cancelled_by_user")
+                    was_cancelled = True
+                    return CommandResult[None](success=True, data=None)
+
+                # Debug: log chunk info for first few chunks
+                logger.debug(
+                    "stream_chunk",
+                    extra={
+                        "chunk_type": chunk.chunk_type,
+                        "has_content": bool(chunk.content),
+                        "has_reasoning": bool(chunk.reasoning_content),
+                        "sequence": chunk.sequence,
+                    },
+                )
+
+                # Handle thinking/reasoning chunks
+                if chunk.chunk_type == "thinking" and chunk.reasoning_content:
+                    if self.on_thinking_chunk:
+                        self.on_thinking_chunk(chunk.reasoning_content)
+                # Handle regular text content chunks
+                elif chunk.content:
+                    self.on_chunk(chunk.content)
+
+            return CommandResult[None](success=True, data=None)
+
+        except Exception as e:
+            return CommandResult[None](success=False, error=str(e))
+
+        finally:
+            self.store.finish_streaming(cancelled=was_cancelled)

cli/tui/chat/commands/undo.py

@@ -0,0 +1,66 @@
+"""Command for undoing the last conversation turn."""
+
+from dataclasses import dataclass
+
+from alloy_runtime_sdk.api_client.client import ApiClient
+from alloy_runtime_types.dtos.messages import UpdateMessageRequest
+from alloy_runtime_types.dtos.sessions import MessageResponse
+
+from cli.tui.chat.commands.base import CommandResult
+from cli.tui.chat.types import extract_message_text
+
+
+@dataclass
+class UndoResult:
+    """Result data for undo operation.
+
+    Attributes:
+        user_preview: Preview of the undone user message.
+    """
+
+    user_preview: str
+
+
+@dataclass
+class UndoCommand:
+    """Command to undo the last conversation turn.
+
+    This marks both the last user message and assistant response as
+    excluded from context, effectively removing them from the conversation.
+
+    Attributes:
+        client: Server client for API calls.
+        user_message: The user message to exclude.
+        assistant_message: The assistant message to exclude.
+    """
+
+    client: ApiClient
+    user_message: MessageResponse
+    assistant_message: MessageResponse
+
+    async def execute(self) -> CommandResult[UndoResult]:
+        """Execute the undo operation.
+
+        Returns:
+            CommandResult with preview of undone message on success.
+        """
+        try:
+            # Mark both messages as excluded from context
+            for msg in [self.user_message, self.assistant_message]:
+                await self.client.update_message(
+                    msg.id, UpdateMessageRequest(include_in_context=False)
+                )
+
+            # Get preview text for user feedback
+            user_text = extract_message_text(self.user_message)
+            user_preview = user_text[:50]
+            if len(user_text) > 50:
+                user_preview += "..."
+
+            return CommandResult[UndoResult](
+                success=True,
+                data=UndoResult(user_preview=user_preview),
+            )
+
+        except Exception as e:
+            return CommandResult[UndoResult](success=False, error=str(e))

cli/tui/chat/editor.py

@@ -0,0 +1,71 @@
+"""External editor integration for the chat TUI.
+
+Provides functionality to open text in $EDITOR for composition of long messages.
+"""
+
+import os
+import subprocess
+import tempfile
+
+
+class EditorError(Exception):
+    """Raised when editor operations fail."""
+
+    pass
+
+
+def open_in_editor(current_text: str = "") -> str | None:
+    """Open text in $EDITOR and return the edited content.
+
+    Uses the editor specified by $EDITOR, falling back to $VISUAL, then 'vi'.
+
+    Args:
+        current_text: The initial text to populate the editor with.
+
+    Returns:
+        The edited text if successful, None if editor failed or was cancelled.
+
+    Raises:
+        EditorError: If the editor could not be found or execution failed.
+    """
+    editor = os.environ.get("EDITOR", os.environ.get("VISUAL", "vi"))
+
+    try:
+        # Create a temporary file with the current text
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            suffix=".md",
+            delete=False,
+        ) as tmp_file:
+            tmp_file.write(current_text)
+            tmp_path = tmp_file.name
+
+        try:
+            # Open the editor and wait for it to close
+            result = subprocess.run([editor, tmp_path], check=False)
+
+            if result.returncode != 0:
+                raise EditorError(f"Editor exited with code {result.returncode}")
+
+            # Read the edited content back
+            with open(tmp_path, encoding="utf-8") as f:
+                edited_text = f.read()
+
+            # Strip trailing newlines that editors often add
+            return edited_text.rstrip("\n")
+
+        finally:
+            # Clean up the temporary file
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+
+    except FileNotFoundError:
+        raise EditorError(
+            f"Editor '{editor}' not found. Set $EDITOR environment variable."
+        )
+    except Exception as e:
+        if isinstance(e, EditorError):
+            raise
+        raise EditorError(f"Failed to open editor: {e}")