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

cli/commands/content/edit/command.py

@@ -0,0 +1,155 @@
+"""Content edit command implementation."""
+
+from pathlib import Path
+from typing import Any
+from uuid import UUID
+
+import typer
+
+from cli.commands.content.edit.editor import (
+    ContentValidationError,
+    format_content_for_editor,
+    open_editor_for_content,
+    parse_edited_content,
+)
+from cli.infrastructure.editor import EditorError
+from cli.commands.content.edit.presenter import present_content_edit_success
+from cli.commands.flag_utils import parse_tags, require_exclusive, validate_uuid
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.error_display import display_error
+from cli.infrastructure.output import OutputService
+from alloy_runtime_types.dtos.content import UpdateContentPartRequest
+
+
+def content_edit_command(
+    content_part_id: str = typer.Argument(
+        ...,
+        help="Content part UUID",
+    ),
+    tags: str | None = typer.Option(
+        None,
+        "-t",
+        "--tags",
+        help="Replace tags (comma-separated)",
+    ),
+    no_edit: bool = typer.Option(
+        False,
+        "--no-edit",
+        help="Skip editor, only update tags",
+    ),
+    content: str | None = typer.Option(
+        None,
+        "-c",
+        "--content",
+        help="Inline content replacement",
+    ),
+    content_file: Path | None = typer.Option(
+        None,
+        "-f",
+        "--file",
+        help="Read replacement from file",
+        exists=True,
+        readable=True,
+    ),
+) -> None:
+    """Edit a content part.
+
+    By default opens $EDITOR. Use --content or --file to bypass.
+
+    Examples:
+        ai content edit 019405e0-...
+        ai content edit <id> -t "email.final,reviewed"
+        ai content edit <id> --no-edit -t "archived"
+        ai content edit <id> -c "New content"
+        ai content edit <id> -f output.txt
+    """
+    content_uuid = validate_uuid(content_part_id, "content")
+
+    # Validate exclusive content modes
+    require_exclusive(
+        ("--no-edit", no_edit),
+        ("--content", content),
+        ("--file", content_file),
+    )
+
+    # Parse tags
+    tag_paths: list[str] | None = None
+    if tags is not None:
+        tag_paths = parse_tags(tags)
+
+    # Validate at least one operation
+    if no_edit and tag_paths is None:
+        raise typer.BadParameter("--tags required with --no-edit")
+
+    _execute_edit(
+        content_part_id=content_uuid,
+        tag_paths=tag_paths,
+        no_edit=no_edit,
+        inline_content=content,
+        content_file=content_file,
+    )
+
+
+@async_command
+async def _execute_edit(
+    content_part_id: UUID,
+    tag_paths: list[str] | None,
+    no_edit: bool,
+    inline_content: str | None,
+    content_file: Path | None,
+) -> None:
+    """Execute edit content part operation."""
+    async with authenticated_client() as (_config, client):
+        current = await client.get_content_part(content_part_id)
+
+        new_content_text: str | None = None
+        new_content_structured: dict[str, Any] | None = None
+        updated_content = False
+
+        if not no_edit:
+            try:
+                if inline_content is not None:
+                    edited_content = inline_content
+                    is_structured = current.content_structured is not None
+                elif content_file is not None:
+                    edited_content = content_file.read_text()
+                    is_structured = current.content_structured is not None
+                else:
+                    initial_content, is_structured = format_content_for_editor(
+                        current.content_text,
+                        current.content_structured,
+                    )
+                    edited_content = open_editor_for_content(
+                        initial_content, is_structured
+                    )
+
+                    if edited_content is None:
+                        output = OutputService.get()
+                        output.warning("Editor cancelled")
+                        raise typer.Exit(code=1)
+
+                new_content_text, new_content_structured = parse_edited_content(
+                    edited_content, is_structured
+                )
+                updated_content = True
+
+            except EditorError as e:
+                display_error(e)
+                raise typer.Exit(code=1)
+            except ContentValidationError as e:
+                display_error(e)
+                raise typer.Exit(code=1)
+
+        request = UpdateContentPartRequest(
+            content_text=new_content_text,
+            content_structured=new_content_structured,
+            tag_paths=tag_paths,
+        )
+
+        response = await client.update_content_part(content_part_id, request)
+
+    present_content_edit_success(
+        response,
+        updated_content=updated_content,
+        updated_tags=(tag_paths is not None),
+    )

cli/commands/content/edit/editor.py

@@ -0,0 +1,150 @@
+"""External editor integration for content part editing.
+
+Opens the user's preferred $EDITOR to edit content,
+with content-type-aware file extensions for syntax highlighting.
+"""
+
+import json
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Any, cast
+
+from cli.infrastructure.editor import get_editor
+
+
+class ContentValidationError(Exception):
+    """Raised when edited content fails validation."""
+
+
+__all__ = [
+    "ContentValidationError",
+    "open_editor_for_content",
+    "format_content_for_editor",
+    "parse_edited_content",
+]
+
+
+def open_editor_for_content(
+    initial_content: str,
+    is_structured: bool,
+) -> str | None:
+    """Open the user's editor with content, using appropriate file extension.
+
+    Creates a temporary file with the right extension for syntax highlighting:
+    - .json for structured content
+    - .txt for text content
+
+    Args:
+        initial_content: Initial content to populate the file with
+        is_structured: Whether the content is JSON (structured) or plain text
+
+    Returns:
+        The edited content from the file, or None if the editor failed
+        or the user quit without saving.
+
+    Raises:
+        EditorError: If no editor is available
+        ContentValidationError: If JSON content is malformed after editing
+    """
+    editor = get_editor()
+
+    # Choose extension based on content type
+    suffix = ".json" if is_structured else ".txt"
+
+    # Create temp file with appropriate extension
+    with tempfile.NamedTemporaryFile(
+        mode="w",
+        suffix=suffix,
+        delete=False,
+    ) as f:
+        f.write(initial_content)
+        temp_path = Path(f.name)
+
+    try:
+        # Get file modification time before editing
+        mtime_before = temp_path.stat().st_mtime
+
+        # Open editor and wait for it to close
+        editor_parts = editor.split()
+        cmd = editor_parts + [str(temp_path)]
+
+        result = subprocess.call(cmd)
+
+        if result != 0:
+            return None
+
+        # Check if file was modified
+        mtime_after = temp_path.stat().st_mtime
+        if mtime_after == mtime_before:
+            # File wasn't modified - still return content in case
+            # user just didn't change anything
+            pass
+
+        # Read the edited content
+        content = temp_path.read_text()
+
+        # Validate JSON if structured content
+        if is_structured:
+            try:
+                json.loads(content)
+            except json.JSONDecodeError as e:
+                raise ContentValidationError(
+                    f"Invalid JSON after editing: {e.msg} at line {e.lineno}"
+                )
+
+        return content
+
+    finally:
+        # Clean up temp file
+        try:
+            temp_path.unlink()
+        except OSError:
+            pass  # Best effort cleanup
+
+
+def format_content_for_editor(
+    content_text: str | None, content_structured: dict[str, Any] | None
+) -> tuple[str, bool]:
+    """Format content for editing in $EDITOR.
+
+    Args:
+        content_text: Plain text content (if text type)
+        content_structured: Structured JSON content (if structured type)
+
+    Returns:
+        Tuple of (formatted_content, is_structured)
+    """
+    if content_structured is not None:
+        # Format JSON with indentation for readability
+        return json.dumps(content_structured, indent=2, ensure_ascii=False), True
+    elif content_text is not None:
+        return content_text, False
+    else:
+        return "", False
+
+
+def parse_edited_content(
+    edited_content: str,
+    is_structured: bool,
+) -> tuple[str | None, dict[str, Any] | None]:
+    """Parse edited content back to appropriate type.
+
+    Args:
+        edited_content: Content string from editor
+        is_structured: Whether content should be parsed as JSON
+
+    Returns:
+        Tuple of (content_text, content_structured) with appropriate field set
+
+    Raises:
+        ContentValidationError: If JSON parsing fails for structured content
+    """
+    if is_structured:
+        try:
+            parsed = json.loads(edited_content)
+            return None, cast(dict[str, Any], parsed)
+        except json.JSONDecodeError as e:
+            raise ContentValidationError(f"Invalid JSON: {e.msg} at line {e.lineno}")
+    else:
+        return edited_content, None

cli/commands/content/edit/presenter.py

@@ -0,0 +1,146 @@
+"""Presenter for content edit command output."""
+
+import json
+import sys
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from cli.infrastructure.formatting.fields import (
+    format_cost,
+    format_datetime,
+    format_optional,
+    format_tokens,
+    format_uuid,
+)
+from alloy_runtime_types.dtos.content import UpdateContentPartResponse
+from alloy_runtime_types.dtos.templates import TagResponse
+
+
+def present_content_edit_success(
+    response: UpdateContentPartResponse, updated_content: bool, updated_tags: bool
+) -> None:
+    """Present content edit success with piping support.
+
+    Metadata goes to stderr (visible in terminal but not piped).
+    Content goes to stdout (for piping to other commands).
+
+    Args:
+        response: Updated content part response from server
+        updated_content: Whether content was updated
+        updated_tags: Whether tags were updated
+    """
+    # Create console for stderr output (metadata)
+    stderr_console = Console(file=sys.stderr, force_terminal=True)
+
+    # Build update summary
+    updates: list[str] = []
+    if updated_content:
+        updates.append("content")
+    if updated_tags:
+        updates.append("tags")
+    update_summary = " and ".join(updates) if updates else "no changes"
+
+    # Print success message to stderr
+    stderr_console.print(
+        f"[green]✓[/green] Content part updated ({update_summary}): {format_uuid(response.id, short=True)}"
+    )
+
+    # Build and display metadata table to stderr
+    _display_metadata(response, stderr_console)
+
+    # Print content to stdout for piping
+    _display_content(response)
+
+
+def _display_metadata(response: UpdateContentPartResponse, console: Console) -> None:
+    """Display content part metadata to stderr.
+
+    Args:
+        response: Content part response
+        console: Console for stderr output
+    """
+    meta_table = Table(show_header=False, box=None, padding=(0, 1))
+    meta_table.add_column("Field", style="dim", width=20)
+    meta_table.add_column("Value")
+
+    # Basic info
+    meta_table.add_row("ID", str(response.id))
+    meta_table.add_row("Message ID", format_uuid(response.message_id, short=True))
+    meta_table.add_row("Part Index", str(response.part_index))
+    meta_table.add_row("Content Type", response.content_type_id)
+    meta_table.add_row(
+        "Storage Type",
+        "structured" if response.content_structured else "text",
+    )
+    meta_table.add_row("Created", format_datetime(response.created_at))
+
+    # Tags
+    meta_table.add_row("Tags", _format_tags(response.tags))
+
+    # Execution metadata
+    exec_meta = response.execution_metadata
+    meta_table.add_row("", "")  # Separator
+    meta_table.add_row("[bold]Execution Info[/bold]", "")
+    meta_table.add_row(
+        "Execution ID",
+        format_uuid(exec_meta.agent_execution_id, short=True),
+    )
+    meta_table.add_row(
+        "Agent",
+        format_optional(exec_meta.agent_name, placeholder="(direct model call)"),
+    )
+    meta_table.add_row("Provider", exec_meta.provider_key)
+    meta_table.add_row("Model", exec_meta.provider_model_name)
+    meta_table.add_row(
+        "Cost",
+        format_optional(exec_meta.total_cost_usd, formatter=format_cost),
+    )
+    meta_table.add_row(
+        "Tokens",
+        format_optional(exec_meta.total_tokens, formatter=format_tokens),
+    )
+    meta_table.add_row("Queued At", format_datetime(exec_meta.queued_at))
+
+    meta_panel = Panel(meta_table, title="Content Part Updated", border_style="green")
+    console.print(meta_panel)
+
+
+def _format_tags(tags: list[TagResponse]) -> str:
+    """Format tags list for display.
+
+    Args:
+        tags: List of tag responses
+
+    Returns:
+        Formatted tags string
+    """
+    if not tags:
+        return "(no tags)"
+
+    tag_paths = [t.tag_path for t in tags]
+    return ", ".join(tag_paths)
+
+
+def _display_content(response: UpdateContentPartResponse) -> None:
+    """Display content to stdout for piping.
+
+    Text content is printed directly.
+    Structured content is formatted as indented JSON.
+
+    Args:
+        response: Content part response
+    """
+    if response.content_text is not None:
+        # Plain text content
+        print(response.content_text, file=sys.stdout)
+    elif response.content_structured is not None:
+        # Structured JSON content - pretty print
+        print(
+            json.dumps(response.content_structured, indent=2, ensure_ascii=False),
+            file=sys.stdout,
+        )
+    else:
+        # No content (shouldn't happen but handle gracefully)
+        print("(no content)", file=sys.stdout)

cli/commands/content/get/__init__.py

@@ -0,0 +1 @@
+

cli/commands/content/get/command.py

@@ -0,0 +1,39 @@
+"""Content get command implementation."""
+
+from uuid import UUID
+
+import typer
+
+from cli.commands.content.get.presenter import present_content_part
+from cli.commands.flag_utils import validate_uuid
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def content_get_command(
+    content_part_id: str = typer.Argument(
+        ...,
+        help="Content part UUID",
+    ),
+) -> None:
+    """Get a content part by UUID.
+
+    Output is piping-friendly:
+    - Content goes to stdout
+    - Metadata goes to stderr
+
+    Examples:
+        ai content get 019405e0-e000-7000-f100-000000000001
+        ai content get <id> | jq .
+        ai content get <id> > output.txt
+    """
+    content_uuid = validate_uuid(content_part_id, "content")
+    _execute_get(content_part_id=content_uuid)
+
+
+@async_command
+async def _execute_get(content_part_id: UUID) -> None:
+    """Execute get content part operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.get_content_part(content_part_id)
+
+    present_content_part(response)

cli/commands/content/get/presenter.py

@@ -0,0 +1,176 @@
+"""Presenter for content get command output."""
+
+import json
+import sys
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from cli.infrastructure.formatting.fields import (
+    format_cost,
+    format_datetime,
+    format_optional,
+    format_tokens,
+    format_uuid,
+)
+from alloy_runtime_types.dtos.content import ContentPartItemResponse
+from alloy_runtime_types.dtos.templates import TagResponse
+
+
+def present_content_part(response: ContentPartItemResponse) -> None:
+    """Present content part details with piping support.
+
+    Metadata goes to stderr (visible in terminal but not piped).
+    Content goes to stdout (for piping to other commands).
+
+    Args:
+        response: Content part response from server
+    """
+    # Write content to stdout FIRST - this is what gets piped
+    # Must happen before any stderr output to avoid blocking issues with vim/less
+    _display_content(response)
+
+    # Now write metadata to stderr (won't be piped)
+    # Wrap in try/except since stderr can also block when stdout is piped
+    try:
+        stderr_console = Console(file=sys.stderr)
+        stderr_console.print(
+            f"[green]✓[/green] Content part retrieved: {format_uuid(response.id, short=True)}"
+        )
+        _display_metadata(response, stderr_console)
+    except (BlockingIOError, BrokenPipeError):
+        # stderr blocked or closed - that's fine, content already went to stdout
+        pass
+
+
+def _display_metadata(response: ContentPartItemResponse, console: Console) -> None:
+    """Display content part metadata to stderr.
+
+    Args:
+        response: Content part response
+        console: Console for stderr output
+    """
+    meta_table = Table(show_header=False, box=None, padding=(0, 1))
+    meta_table.add_column("Field", style="dim", width=20)
+    meta_table.add_column("Value")
+
+    # Basic info
+    meta_table.add_row("ID", str(response.id))
+    meta_table.add_row("Message ID", format_uuid(response.message_id, short=True))
+    meta_table.add_row("Part Index", str(response.part_index))
+    meta_table.add_row("Content Type", response.content_type_id)
+    meta_table.add_row(
+        "Storage Type",
+        "structured" if response.content_structured else "text",
+    )
+    meta_table.add_row("Created", format_datetime(response.created_at))
+
+    # Tags
+    meta_table.add_row("Tags", _format_tags(response.tags))
+
+    # Execution metadata
+    exec_meta = response.execution_metadata
+    meta_table.add_row("", "")  # Separator
+    meta_table.add_row("[bold]Execution Info[/bold]", "")
+    meta_table.add_row(
+        "Execution ID",
+        format_uuid(exec_meta.agent_execution_id, short=True),
+    )
+    meta_table.add_row(
+        "Agent",
+        format_optional(exec_meta.agent_name, placeholder="(direct model call)"),
+    )
+    meta_table.add_row("Provider", exec_meta.provider_key)
+    meta_table.add_row("Model", exec_meta.provider_model_name)
+    meta_table.add_row(
+        "Cost",
+        format_optional(exec_meta.total_cost_usd, formatter=format_cost),
+    )
+    meta_table.add_row(
+        "Tokens",
+        format_optional(exec_meta.total_tokens, formatter=format_tokens),
+    )
+    meta_table.add_row("Queued At", format_datetime(exec_meta.queued_at))
+
+    meta_panel = Panel(meta_table, title="Content Part Details", border_style="blue")
+    console.print(meta_panel)
+
+
+def _format_tags(tags: list[TagResponse]) -> str:
+    """Format tags list for display.
+
+    Args:
+        tags: List of tag responses
+
+    Returns:
+        Formatted tags string
+    """
+    if not tags:
+        return "(no tags)"
+
+    tag_paths = [t.tag_path for t in tags]
+    return ", ".join(tag_paths)
+
+
+def _display_content(response: ContentPartItemResponse) -> None:
+    """Display content to stdout for piping.
+
+    Text content is printed directly.
+    Structured content is formatted as indented JSON.
+
+    Args:
+        response: Content part response
+    """
+    if response.content_text is not None:
+        content = response.content_text
+    elif response.content_structured is not None:
+        content = json.dumps(response.content_structured, indent=2, ensure_ascii=False)
+    else:
+        content = "(no content)"
+
+    _write_stdout_safe(content)
+
+
+def _write_stdout_safe(content: str) -> None:
+    """Write content to stdout safely, handling non-blocking pipes.
+
+    When piping to programs like vim that don't immediately consume stdin,
+    the pipe can be set to non-blocking mode, causing BlockingIOError.
+    This function handles that by using a binary write with proper encoding.
+
+    Args:
+        content: Text content to write
+    """
+    # Check if stdout has a binary buffer (real stdout does, StringIO in tests doesn't)
+    stdout_bin = getattr(sys.stdout, "buffer", None)
+
+    if stdout_bin is None:
+        # Fallback for testing with StringIO or other text-mode streams
+        print(content)
+        return
+
+    # Encode the content
+    data = (content + "\n").encode("utf-8")
+
+    # Write in a loop to handle partial writes
+    written = 0
+    while written < len(data):
+        try:
+            n = stdout_bin.write(data[written:])
+            if n is None:
+                # Non-blocking mode returned None, flush and retry
+                stdout_bin.flush()
+                continue
+            written += n
+        except BlockingIOError:
+            # Pipe is full, flush and continue
+            stdout_bin.flush()
+            continue
+        except BrokenPipeError:
+            # Consumer closed the pipe (e.g., head -n 1)
+            # This is expected behavior, exit quietly
+            sys.stderr.close()
+            sys.exit(0)
+
+    stdout_bin.flush()

cli/commands/content/list/__init__.py

@@ -0,0 +1 @@
+