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

cli/commands/schemas/update/presenter.py

@@ -0,0 +1,53 @@
+"""Presenter for schema update output."""
+
+from cli.infrastructure.formatting.fields import (
+    format_datetime,
+    format_optional,
+    format_uuid,
+)
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+from alloy_runtime_types.dtos.schemas import UpdateSchemaResponse
+
+
+def _derive_scope(response: UpdateSchemaResponse) -> str:
+    """Derive scope string from organization_id and user_id fields."""
+    if response.organization_id is not None and response.user_id is None:
+        return "organization"
+    elif response.user_id is not None:
+        return "user"
+    else:
+        return "global"
+
+
+def present_schema_update_success(response: UpdateSchemaResponse) -> None:
+    """Present successful schema update.
+
+    Args:
+        response: Schema update response from server
+    """
+    output = OutputService.get()
+    output.success("Schema updated successfully")
+
+    fields = [
+        FieldConfig("id", "ID", lambda v: format_uuid(v, short=False)),
+        FieldConfig("schema_name", "Name"),
+        FieldConfig("schema_format_id", "Format"),
+        FieldConfig("version", "Version", str),
+        FieldConfig("description", "Description", format_optional),
+        FieldConfig("scope", "Scope", lambda _: _derive_scope(response)),
+        FieldConfig(
+            "organization_id",
+            "Organization ID",
+            lambda v: format_optional(v, lambda x: format_uuid(x, short=True)),
+        ),
+        FieldConfig(
+            "user_id",
+            "User ID",
+            lambda v: format_optional(v, lambda x: format_uuid(x, short=True)),
+        ),
+        FieldConfig("is_latest", "Is Latest", str),
+        FieldConfig("created_at", "Created At", format_datetime),
+    ]
+
+    output.entity(response, f"Schema: {response.schema_name}", fields)

cli/commands/sessions/__init__.py

@@ -0,0 +1 @@
+# Empty per project convention - import directly from submodules

cli/commands/sessions/delete/__init__.py

@@ -0,0 +1 @@
+# Empty per project convention - import directly from submodules

cli/commands/sessions/delete/command.py

@@ -0,0 +1,47 @@
+"""Session delete command implementation."""
+
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.sessions.delete.presenter import present_delete_result
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.console import Confirm
+
+
+def sessions_delete_command(
+    session_id: str = typer.Argument(
+        ...,
+        help="Session UUID",
+    ),
+    yes: bool = typer.Option(
+        False,
+        "-y",
+        "--yes",
+        help="Skip confirmation",
+    ),
+) -> None:
+    """Delete a chat session and all its messages.
+
+    Examples:
+        ai sessions delete 123e4567-89ab-cdef-0123-456789abcdef
+        ai sessions delete 123e4567-89ab... -y
+    """
+    session_uuid = validate_uuid(session_id, "session")
+
+    if not yes:
+        confirmed = Confirm.ask(f"[yellow]Delete session {session_id}?[/yellow]")
+        if not confirmed:
+            raise typer.Abort()
+
+    _execute_delete(session_id=session_uuid)
+
+
+@async_command
+async def _execute_delete(session_id: UUID) -> None:
+    """Execute delete session operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.delete_session(session_id)
+
+    present_delete_result(response)

cli/commands/sessions/delete/presenter.py

@@ -0,0 +1,10 @@
+"""Presenter for session delete command output."""
+
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.sessions import DeleteSessionResponse
+
+
+def present_delete_result(response: DeleteSessionResponse) -> None:
+    """Present session deletion result."""
+    output = OutputService.get()
+    output.success(f"Deleted session {response.deleted_session.id}")

cli/commands/sessions/get/__init__.py

@@ -0,0 +1 @@
+# Empty per project convention - import directly from submodules

cli/commands/sessions/get/command.py

@@ -0,0 +1,42 @@
+"""Session get command implementation."""
+
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.sessions.get.presenter import present_session
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def sessions_get_command(
+    session_id: str = typer.Argument(
+        ...,
+        help="Session UUID",
+    ),
+    limit: int = typer.Option(
+        20,
+        "-l",
+        "--limit",
+        min=1,
+        max=100,
+        help="Max messages to include",
+    ),
+) -> None:
+    """Get details of a chat session.
+
+    Examples:
+        ai sessions get 123e4567-89ab-cdef-0123-456789abcdef
+        ai sessions get 123e4567-89ab... -l 50
+    """
+    session_uuid = validate_uuid(session_id, "session")
+    _execute_get(session_id=session_uuid, limit=limit)
+
+
+@async_command
+async def _execute_get(session_id: UUID, limit: int) -> None:
+    """Execute get session operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.get_session(session_id, limit=limit)
+
+    present_session(response)

cli/commands/sessions/get/presenter.py

@@ -0,0 +1,59 @@
+"""Presenter for session get command output."""
+
+from rich.panel import Panel
+from rich.table import Table
+
+from alloy_runtime_types.dtos.sessions import SessionDetailResponse
+
+from cli.infrastructure.output import OutputService
+
+
+def _truncate(text: str | None, max_len: int = 200) -> str:
+    """Truncate text for display."""
+    if not text:
+        return "-"
+    if len(text) > max_len:
+        return text[: max_len - 3] + "..."
+    return text
+
+
+def present_session(response: SessionDetailResponse) -> None:
+    """Present session details with Rich formatting."""
+    output = OutputService.get()
+
+    # Create session info table
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Field", style="cyan")
+    table.add_column("Value")
+
+    table.add_row("ID", str(response.id))
+    table.add_row("Name", response.name or "(unnamed)")
+    table.add_row("Message Count", str(response.total_messages))
+    table.add_row("Created", response.created_at.strftime("%Y-%m-%d %H:%M:%S"))
+
+    output.console.print(
+        Panel(table, title=f"Session: {response.name or str(response.id)}")
+    )
+
+    # Show recent messages if available
+    if response.messages:
+        output.info(f"\nRecent Messages ({len(response.messages)}):")
+        for msg in response.messages:
+            role_style = {
+                "user": "green",
+                "assistant": "blue",
+                "system": "yellow",
+                "tool": "magenta",
+            }.get(msg.role, "white")
+
+            # Get content preview
+            content_preview = "-"
+            if msg.content_parts:
+                first_part = msg.content_parts[0]
+                if first_part.content_text:
+                    content_preview = _truncate(first_part.content_text, 100)
+
+            output.console.print(
+                f"  [{role_style}]{msg.role}[/{role_style}] "
+                f"({msg.sequence_number}): {content_preview}"
+            )

cli/commands/sessions/list/__init__.py

@@ -0,0 +1 @@
+# Empty per project convention - import directly from submodules

cli/commands/sessions/list/command.py

@@ -0,0 +1,61 @@
+"""Sessions list command implementation."""
+
+from typing import Optional
+
+import typer
+
+from cli.commands.sessions.list.presenter import present_sessions_list
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def sessions_list_command(
+    search: Optional[str] = typer.Option(
+        None,
+        "-s",
+        "--search",
+        help="Fuzzy search terms",
+    ),
+    named_only: bool = typer.Option(
+        False,
+        "--named-only",
+        help="Only show named sessions",
+    ),
+    limit: int = typer.Option(
+        50,
+        "-l",
+        "--limit",
+        min=1,
+        max=100,
+        help="Max results",
+    ),
+    offset: int = typer.Option(
+        0,
+        "--offset",
+        min=0,
+        help="Skip N results",
+    ),
+) -> None:
+    """List chat sessions accessible to you.
+
+    Examples:
+        ai sessions list
+        ai sessions list -s "research"
+        ai sessions list --named-only
+    """
+    _execute_list(search=search, named_only=named_only, limit=limit, offset=offset)
+
+
+@async_command
+async def _execute_list(
+    search: Optional[str], named_only: bool, limit: int, offset: int
+) -> None:
+    """Execute list sessions operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.list_sessions(
+            search=search,
+            named_only=named_only,
+            limit=limit,
+            offset=offset,
+        )
+
+    present_sessions_list(response)

cli/commands/sessions/list/presenter.py

@@ -0,0 +1,68 @@
+"""Presenter for sessions list command output."""
+
+from alloy_runtime_types.dtos.sessions import ListSessionsResponse
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.list_renderer import ColumnConfig
+
+
+def _format_name(name: str | None) -> str:
+    """Format session name."""
+    if not name:
+        return "(unnamed)"
+    if len(name) > 50:
+        return name[:47] + "..."
+    return name
+
+
+def present_sessions_list(response: ListSessionsResponse) -> None:
+    """Present list of sessions with Rich table formatting."""
+    output = OutputService.get()
+
+    if not response.sessions:
+        output.info("No sessions found")
+        return
+
+    columns = [
+        ColumnConfig(
+            source_field="id",
+            header_label="ID",
+            compact_line=1,
+            compact_style="cyan",
+        ),
+        ColumnConfig(
+            source_field="message_count",
+            header_label="Messages",
+            align="right",
+            formatter=lambda x: f"{x} msgs" if x else "0 msgs",
+            compact_line=1,
+            compact_style="green",
+        ),
+        ColumnConfig(
+            source_field="created_at",
+            header_label="Created",
+            formatter=lambda x: x.strftime("%Y-%m-%d %H:%M") if x else "-",
+            compact_line=1,
+            compact_style="blue",
+        ),
+        ColumnConfig(
+            source_field="name",
+            header_label="Name",
+            formatter=_format_name,
+            compact_line=2,
+            compact_style="white bold",
+        ),
+        ColumnConfig(
+            source_field="agent_name",
+            header_label="Agent",
+            formatter=lambda x: x or "-",
+            compact_line=2,
+            compact_style="dim",
+        ),
+    ]
+
+    output.table(
+        items=response.sessions,  # type: ignore[arg-type]
+        title=f"Sessions ({response.total})",
+        columns=columns,
+    )

cli/commands/sessions/messages/__init__.py

@@ -0,0 +1 @@
+# Empty per project convention - import directly from submodules

cli/commands/sessions/messages/command.py

@@ -0,0 +1,78 @@
+"""Session messages list command implementation."""
+
+from typing import Optional
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.sessions.messages.presenter import present_messages_list
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def sessions_messages_command(
+    session_id: str = typer.Argument(
+        ...,
+        help="Session UUID",
+    ),
+    role: Optional[str] = typer.Option(
+        None,
+        "--role",
+        help="Filter by role (user, assistant, system, tool)",
+    ),
+    limit: int = typer.Option(
+        50,
+        "-l",
+        "--limit",
+        min=1,
+        max=100,
+        help="Max results",
+    ),
+    offset: int = typer.Option(
+        0,
+        "--offset",
+        min=0,
+        help="Skip N results",
+    ),
+    order: str = typer.Option(
+        "asc",
+        "--order",
+        help="Sort order (asc or desc)",
+    ),
+) -> None:
+    """List messages in a chat session.
+
+    Examples:
+        ai sessions messages 123e4567-89ab...
+        ai sessions messages 123e4567-89ab... --role assistant
+        ai sessions messages 123e4567-89ab... --order desc -l 10
+    """
+    session_uuid = validate_uuid(session_id, "session")
+    _execute_list(
+        session_id=session_uuid,
+        role=role,
+        limit=limit,
+        offset=offset,
+        order=order,
+    )
+
+
+@async_command
+async def _execute_list(
+    session_id: UUID,
+    role: Optional[str],
+    limit: int,
+    offset: int,
+    order: str,
+) -> None:
+    """Execute list messages operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.list_session_messages(
+            session_id,
+            role=role,
+            limit=limit,
+            offset=offset,
+            order=order,
+        )
+
+    present_messages_list(response)

cli/commands/sessions/messages/presenter.py

@@ -0,0 +1,79 @@
+"""Presenter for session messages command output."""
+
+from alloy_runtime_types.dtos.sessions import (
+    ListSessionMessagesResponse,
+    MessageResponse,
+)
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.list_renderer import ColumnConfig
+
+
+def _format_content(msg: MessageResponse) -> str:
+    """Format message content for display."""
+    if not msg.content_parts:
+        return "-"
+    first_part = msg.content_parts[0]
+    text = first_part.content_text or ""
+    if len(text) > 80:
+        return text[:77] + "..."
+    return text or "-"
+
+
+def present_messages_list(response: ListSessionMessagesResponse) -> None:
+    """Present list of messages with Rich table formatting."""
+    output = OutputService.get()
+
+    if not response.messages:
+        output.info("No messages found")
+        return
+
+    columns = [
+        ColumnConfig(
+            source_field="sequence_number",
+            header_label="#",
+            align="right",
+            compact_line=1,
+            compact_style="cyan",
+        ),
+        ColumnConfig(
+            source_field="role",
+            header_label="Role",
+            compact_line=1,
+            compact_style="yellow",
+        ),
+        ColumnConfig(
+            source_field="created_at",
+            header_label="Time",
+            formatter=lambda x: x.strftime("%H:%M:%S") if x else "-",
+            compact_line=1,
+            compact_style="blue",
+        ),
+        ColumnConfig(
+            source_field="id",
+            header_label="ID",
+            compact_line=2,
+            compact_style="dim",
+        ),
+    ]
+
+    output.table(
+        items=response.messages,  # type: ignore[arg-type]
+        title=f"Messages ({response.total})",
+        columns=columns,
+    )
+
+    # Show content preview for each message
+    output.info("\nContent:")
+    for msg in response.messages:
+        role_style = {
+            "user": "green",
+            "assistant": "blue",
+            "system": "yellow",
+            "tool": "magenta",
+        }.get(msg.role, "white")
+
+        content = _format_content(msg)
+        output.console.print(
+            f"  [{role_style}]{msg.sequence_number}. {msg.role}[/{role_style}]: {content}"
+        )