padwan-cli 0.2.1__tar.gz

padwan_cli-0.2.1/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.3
+Name: padwan-cli
+Version: 0.2.1
+Summary: CLI and TUI for padwan-llm
+Author-email: julien.brayere@polarsen.com
+Requires-Dist: padwan-llm>=0.1.0
+Requires-Dist: piou[tui]>=0.32.0
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# Padwan CLI
+
+Interactive CLI/TUI for `padwan-llm`.
+
+<img alt="Chat demo" src="https://github.com/Polarsen/padwan-cli/raw/main/docs/static/chat.gif" width="800"/>
+
+## Quick start
+
+```bash
+export OPENAI_API_KEY=...
+uvx padwan-cli
+# then /help for commands
+```
+
+
+## Install
+
+```bash
+pip install padwan-cli
+```
+
+## Local Development
+
+```bash
+uv sync --group dev
+uv run padwan-cli
+```
+
+## One-shot Mode
+
+```bash
+uvx padwan-cli "Hello" -m gpt-4o-mini
+```

padwan_cli-0.2.1/README.md

@@ -0,0 +1,33 @@
+# Padwan CLI
+
+Interactive CLI/TUI for `padwan-llm`.
+
+<img alt="Chat demo" src="https://github.com/Polarsen/padwan-cli/raw/main/docs/static/chat.gif" width="800"/>
+
+## Quick start
+
+```bash
+export OPENAI_API_KEY=...
+uvx padwan-cli
+# then /help for commands
+```
+
+
+## Install
+
+```bash
+pip install padwan-cli
+```
+
+## Local Development
+
+```bash
+uv sync --group dev
+uv run padwan-cli
+```
+
+## One-shot Mode
+
+```bash
+uvx padwan-cli "Hello" -m gpt-4o-mini
+```

padwan_cli-0.2.1/padwan_cli/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .run import cli, main, main_tui
+
+__all__ = ("cli", "main", "main_tui")

padwan_cli-0.2.1/padwan_cli/__main__.py

@@ -0,0 +1,3 @@
+from padwan_cli import main
+
+main()

padwan_cli-0.2.1/padwan_cli/batch/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .run import batch_group
+
+__all__ = ["batch_group"]

padwan_cli-0.2.1/padwan_cli/batch/format.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rich.table import Table
+
+from ..utils import console
+
+if TYPE_CHECKING:
+    from padwan_llm.gemini import BatchJob
+
+
+def format_job(job: BatchJob) -> None:
+    """Pretty print a batch job with colored state and key fields."""
+    from ..widgets import STATE_COLORS
+
+    state_color = STATE_COLORS.get(job.state, "white")
+    console.print(f"  Name:    {job.name}")
+    console.print(f"  State:   [{state_color}]{job.state}[/{state_color}]")
+    if job.display_name:
+        console.print(f"  Display: {job.display_name}")
+    if job.model:
+        console.print(f"  Model:   {job.model}")
+    if job.create_time:
+        console.print(f"  Created: {job.create_time}")
+    if job.stats:
+        stats = job.stats
+        succeeded = stats.get("successfulRequestCount", 0)
+        total = stats.get("requestCount", 0)
+        console.print(f"  Stats:   {succeeded}/{total} succeeded")
+    if job.error:
+        console.print(f"  [red]Error:   {job.error}[/red]")
+
+
+def format_job_table(jobs: list[BatchJob]) -> Table:
+    """Create a rich table displaying batch jobs with state colors and stats."""
+    from ..widgets import STATE_COLORS
+
+    table = Table(title="Batch Jobs")
+    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("State", style="bold")
+    table.add_column("Display Name")
+    table.add_column("Model")
+    table.add_column("Stats", justify="right")
+
+    for job in jobs:
+        state_color = STATE_COLORS.get(job.state, "white")
+        stats_str = ""
+        if job.stats:
+            succeeded = job.stats.get("successfulRequestCount", 0)
+            total = job.stats.get("requestCount", 0)
+            stats_str = f"{succeeded}/{total}"
+
+        table.add_row(
+            job.name.split("/")[-1],  # Just the job ID
+            f"[{state_color}]{job.state.replace('JOB_STATE_', '')}[/{state_color}]",
+            job.display_name or "",
+            job.model or "",
+            stats_str,
+        )
+
+    return table

padwan_cli-0.2.1/padwan_cli/batch/run.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+from piou import CommandGroup, Option
+from piou.tui import TuiContext, TuiOption
+
+from padwan_llm import GEMINI_MODELS
+from padwan_llm.gemini import BatchRequest, BatchResult, GeminiClient
+from ..widgets import BatchProgressWidget, BatchResultWidget
+from .format import console, format_job, format_job_table
+from .utils import load_prompts_from_file, save_results_to_file
+
+batch_group = CommandGroup(name="batch", help="Gemini batch operations")
+
+
+def _print_results(results: list[BatchResult]) -> None:
+    """Print batch results as plain text for CLI mode."""
+    for result in results:
+        console.print(
+            f"[cyan][{result.key}][/cyan] "
+            f"[dim]({result.input_tokens} in, {result.output_tokens} out, "
+            f"{result.total_tokens} total tokens)[/dim]"
+        )
+        preview = result.content[:300].replace("\n", " ")
+        if len(result.content) > 300:
+            preview += "..."
+        console.print(f"  {preview}\n")
+
+
+@batch_group.command("create", help="Create a batch job with prompts")
+async def batch_create(
+    prompts: list[str] | None = Option(
+        None, "-p", "--prompt", help="Inline prompts (multiple)"
+    ),
+    file: str | None = Option(
+        None, "-f", "--file", help="Read prompts from JSON/text file"
+    ),
+    model: str = Option(
+        "gemini-2.0-flash",
+        "-m",
+        "--model",
+        help="Model to use",
+        choices=sorted(GEMINI_MODELS),
+    ),
+    name: str = Option("cli-batch", "-n", "--name", help="Display name for the batch"),
+) -> None:
+    """Create a batch job with inline prompts or from a file.
+
+    Prompts can be specified inline with -p (multiple times) or loaded from
+    a file with -f. The file can be JSON (array of strings or objects with
+    'prompt' and 'key' fields) or plain text (one prompt per line).
+    """
+    requests: list[BatchRequest] = []
+
+    if file:
+        requests = load_prompts_from_file(file)
+    elif prompts:
+        requests = [
+            BatchRequest(
+                contents=[{"role": "user", "parts": [{"text": prompt}]}],
+                key=f"prompt-{i}",
+            )
+            for i, prompt in enumerate(prompts)
+        ]
+
+    if not requests:
+        console.print(
+            "[red]No prompts provided. Use -p or -f to specify prompts.[/red]"
+        )
+        return
+
+    async with GeminiClient(model=model) as client:  # pyright: ignore[reportArgumentType]
+        console.print(f"Creating batch with {len(requests)} requests...")
+        job = await client.create_batch(requests, display_name=name)
+        console.print("[green]Batch created:[/green]")
+        format_job(job)
+
+
+@batch_group.command("status", help="Get status of a batch job")
+async def batch_status(
+    job_name: str = Option(..., "-j", "--job", help="Batch job name"),
+    show_results: bool = Option(
+        False, "-r", "--results", help="Show results if completed"
+    ),
+    ctx: TuiContext = TuiOption(),
+) -> None:
+    """Get the current status of a batch job with optional results display."""
+    async with GeminiClient() as client:
+        job = await client.get_batch(job_name)
+        console.print("[bold]Batch status:[/bold]")
+        format_job(job)
+
+        if show_results and job.succeeded and job.inlined_responses:
+            console.print("\n[bold]Results:[/bold]")
+            results = [
+                BatchResult.from_inlined_response(r) for r in job.inlined_responses
+            ]
+            if ctx.is_tui:
+                ctx.mount_widget(BatchResultWidget(results))
+            else:
+                _print_results(results)
+
+
+@batch_group.command("list", help="List batch jobs")
+async def batch_list(
+    limit: int = Option(10, "-l", "--limit", help="Maximum jobs to show"),
+) -> None:
+    """List recent batch jobs with their status."""
+    async with GeminiClient() as client:
+        jobs, next_token = await client.list_batches(page_size=limit)
+
+        if not jobs:
+            console.print("No batch jobs found.")
+            return
+
+        table = format_job_table(jobs)
+        console.print(table)
+
+        if next_token:
+            console.print(
+                f"\n[dim]More jobs available (next_token: {next_token})[/dim]"
+            )
+
+
+@batch_group.command("cancel", help="Cancel a batch job")
+async def batch_cancel(
+    job_name: str = Option(..., "-j", "--job", help="Batch job name to cancel"),
+) -> None:
+    """Cancel a pending or running batch job."""
+    async with GeminiClient() as client:
+        console.print(f"Cancelling batch job: {job_name}")
+        await client.cancel_batch(job_name)
+        console.print("[green]Batch job cancelled.[/green]")
+
+
+@batch_group.command("poll", help="Poll a batch job until completion")
+async def batch_poll(
+    job_name: str = Option(..., "-j", "--job", help="Batch job name to poll"),
+    interval: int = Option(5, "-i", "--interval", help="Poll interval in seconds"),
+    timeout: int | None = Option(
+        None, "-t", "--timeout", help="Max wait time in seconds"
+    ),
+    show_results: bool = Option(
+        True, "-r", "--results", help="Show results on completion"
+    ),
+    output: str | None = Option(None, "-o", "--output", help="Save results to file"),
+    ctx: TuiContext = TuiOption(),
+) -> None:
+    """Poll a batch job until it reaches a terminal state.
+
+    Displays a progress widget showing the job state and stats.
+    Can optionally save results to a file when complete.
+    """
+    async with GeminiClient() as client:
+        console.print(f"Polling batch job: {job_name} (every {interval}s)")
+        job = await client.get_batch(job_name)
+
+        widget = None
+        if ctx.is_tui:
+            widget = BatchProgressWidget(job)
+            ctx.mount_widget(widget)
+
+        elapsed = 0
+        while not job.is_terminal:
+            if timeout and elapsed >= timeout:
+                console.print(f"[yellow]Timeout reached after {elapsed}s[/yellow]")
+                break
+
+            await asyncio.sleep(interval)
+            elapsed += interval
+            job = await client.get_batch(job_name)
+            if widget:
+                widget.update_job(job)
+            else:
+                console.print(f"  [{job.state}] {elapsed}s elapsed")
+
+        if job.is_terminal:
+            console.print("\n[bold]Batch job completed:[/bold]")
+        else:
+            console.print("\n[bold]Batch job status (timed out):[/bold]")
+        format_job(job)
+
+        if job.succeeded and job.inlined_responses:
+            results = [
+                BatchResult.from_inlined_response(r) for r in job.inlined_responses
+            ]
+
+            if output:
+                fmt = Path(output).suffix.lstrip(".") or "json"
+                if fmt not in ("json", "csv", "txt"):
+                    fmt = "json"
+                save_results_to_file(results, output, fmt)
+                console.print(f"[green]Results saved to: {output}[/green]")
+
+            if show_results:
+                console.print("\n[bold]Results:[/bold]")
+                if ctx.is_tui:
+                    ctx.mount_widget(BatchResultWidget(results))
+                else:
+                    _print_results(results)
+
+
+@batch_group.command("retry", help="Retry failed requests from a batch")
+async def batch_retry(
+    job_name: str = Option(..., "-j", "--job", help="Original job name"),
+) -> None:
+    """Create a new batch with only the failed requests from an original job.
+
+    Extracts failed request keys from the original job and creates a new
+    batch job to retry just those requests.
+    """
+    async with GeminiClient() as client:
+        original = await client.get_batch(job_name)
+
+        if not original.is_terminal:
+            console.print("[red]Original job has not completed yet.[/red]")
+            return
+
+        if not original.inlined_responses:
+            console.print("[red]No responses found in original job.[/red]")
+            return
+
+        # Find failed requests by checking for missing or error responses
+        failed_keys: list[str] = []
+        all_keys: set[str] = set()
+
+        for resp in original.inlined_responses:
+            key = resp.get("key", "")
+            all_keys.add(key)
+            response = resp.get("response", {})
+            # Check if response has an error or no candidates
+            if response.get("error") or not response.get("candidates"):
+                failed_keys.append(key)
+
+        if not failed_keys:
+            console.print("[green]No failed requests to retry.[/green]")
+            return
+
+        console.print(
+            f"Found {len(failed_keys)} failed requests out of {len(all_keys)}"
+        )
+
+        # For now, we can't easily recreate the original requests without
+        # storing them. This command would need the original prompts.
+        console.print(
+            "[yellow]Note: Retry requires original prompts to be available.[/yellow]"
+        )
+        console.print("Failed keys: " + ", ".join(failed_keys))
+
+
+@batch_group.command("export", help="Export batch results to a file")
+async def batch_export(
+    job_name: str = Option(..., "-j", "--job", help="Batch job name"),
+    output: str = Option(..., "-o", "--output", help="Output file path"),
+    fmt: str = Option("json", "-f", "--format", help="Format: json, csv, txt"),
+) -> None:
+    """Export completed batch results to a file.
+
+    Supports JSON (structured with all fields), CSV (tabular), and TXT
+    (key-content pairs) formats.
+    """
+    if fmt not in ("json", "csv", "txt"):
+        console.print(f"[red]Unknown format: {fmt}. Use json, csv, or txt.[/red]")
+        return
+
+    async with GeminiClient() as client:
+        job = await client.get_batch(job_name)
+
+        if not job.succeeded:
+            console.print(f"[red]Job not successful. State: {job.state}[/red]")
+            return
+
+        if not job.inlined_responses:
+            console.print("[red]No results found in job.[/red]")
+            return
+
+        results = [BatchResult.from_inlined_response(r) for r in job.inlined_responses]
+        save_results_to_file(results, output, fmt)
+
+        console.print(f"[green]Exported {len(results)} results to: {output}[/green]")

padwan_cli-0.2.1/padwan_cli/batch/utils.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import csv
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from padwan_llm.gemini import BatchRequest, BatchResult
+
+if TYPE_CHECKING:
+    from typing import Any
+
+
+def load_prompts_from_file(file_path: str) -> list[BatchRequest]:
+    """Load prompts from a JSON array or newline-delimited text file.
+
+    For JSON files, accepts either a simple string array or an array of objects
+    with 'prompt' and optional 'key' fields. For text files, each line becomes
+    a separate prompt.
+    """
+    path = Path(file_path)
+    content = path.read_text()
+
+    if path.suffix.lower() == ".json":
+        data: list[str | dict[str, Any]] = json.loads(content)
+        requests: list[BatchRequest] = []
+        for i, item in enumerate(data):
+            if isinstance(item, str):
+                requests.append(
+                    BatchRequest(
+                        contents=[{"role": "user", "parts": [{"text": item}]}],
+                        key=f"prompt-{i}",
+                    )
+                )
+            else:
+                prompt = item.get("prompt", "")
+                key = item.get("key", f"prompt-{i}")
+                requests.append(
+                    BatchRequest(
+                        contents=[{"role": "user", "parts": [{"text": prompt}]}],
+                        key=key,
+                    )
+                )
+        return requests
+
+    # Text file: one prompt per line
+    lines = [line.strip() for line in content.splitlines() if line.strip()]
+    return [
+        BatchRequest(
+            contents=[{"role": "user", "parts": [{"text": line}]}],
+            key=f"prompt-{i}",
+        )
+        for i, line in enumerate(lines)
+    ]
+
+
+def save_results_to_file(results: list[BatchResult], path: str, fmt: str) -> None:
+    """Export batch results in the specified format (json, csv, or txt)."""
+    output = Path(path)
+
+    if fmt == "json":
+        data = [
+            {
+                "key": r.key,
+                "content": r.content,
+                "input_tokens": r.input_tokens,
+                "output_tokens": r.output_tokens,
+                "total_tokens": r.total_tokens,
+            }
+            for r in results
+        ]
+        output.write_text(json.dumps(data, indent=2))
+
+    elif fmt == "csv":
+        with output.open("w", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow(
+                ["key", "content", "input_tokens", "output_tokens", "total_tokens"]
+            )
+            for r in results:
+                writer.writerow(
+                    [r.key, r.content, r.input_tokens, r.output_tokens, r.total_tokens]
+                )
+
+    else:  # txt
+        lines = [f"[{r.key}]\n{r.content}\n" for r in results]
+        output.write_text("\n".join(lines))

padwan_cli-0.2.1/padwan_cli/chat.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from piou import Option, CommandGroup
+from piou.tui import PromptStyle, TuiContext, TuiOption
+
+from padwan_llm import LLMClient
+
+from .utils import ALL_MODELS, console
+from .conversation import Conversation, Message
+from .widgets import StreamingMessage, UserMessage
+
+if TYPE_CHECKING:
+    from padwan_llm import LLMClientBase
+
+chat_group = CommandGroup(name="chat", help="Chat with an LLM")
+
+# Persistent conversation sessions keyed by model name
+_sessions: dict[str, tuple[LLMClientBase, Conversation]] = {}
+
+
+def _get_or_create_session(
+    model: str,
+    system: str | None = None,
+) -> tuple[LLMClientBase, Conversation]:
+    """Get existing session or create a new one for the given model."""
+    if model in _sessions:
+        client, conv = _sessions[model]
+        # Update system prompt if provided and different
+        if system and conv.system != system:
+            conv.system = system
+            # Rebuild messages with new system prompt
+            old_messages = [m for m in conv.messages if m["role"] != "system"]
+            conv.messages = []
+            if system:
+                conv.messages.append(Message(role="system", content=system))
+            conv.messages.extend(old_messages)
+        return client, conv
+
+    client = LLMClient(model=model)
+    conv = Conversation(client, system=system)
+    _sessions[model] = (client, conv)
+    return client, conv
+
+
+CHAT_PROMPT = PromptStyle(text="You: ", css_class="chat-mode")
+
+
+def _format_tokens(conv: Conversation, ctx: TuiContext | None = None) -> str:
+    """Format token usage for display."""
+    if not conv.last_usage:
+        return ""
+    last = conv.last_usage
+    total = conv.total_usage
+    parts = [f"in: {last['input']}", f"out: {last['output']}"]
+    if "cached" in last:
+        parts.append(f"cached: {last['cached']}")
+    parts.append(f"| session: {total['total']}")
+    if ctx and ctx.pending_count > 0:
+        parts.append(f"| {ctx.pending_count} queued")
+    return " ".join(parts)
+
+
+@chat_group.command("send", help="Send a message to the LLM")
+async def chat_send_fn(
+    message: str = Option(..., help="Message to send"),
+    model: str = Option(
+        "gpt-4o-mini", "-m", "--model", help="Model to use", choices=ALL_MODELS
+    ),
+    ctx: TuiContext = TuiOption(),
+) -> None:
+    """Start a conversation. Use Ctrl+C to exit."""
+    try:
+        client, conv = _get_or_create_session(model)
+    except Exception as e:
+        console.print(f"[red]Error creating session for {model}: {e}[/red]")
+        return
+
+    async with client:
+        user_input: str | None = message
+        original_style = ctx.set_prompt_style(CHAT_PROMPT)
+        ctx.set_hint("Chat mode - press Ctrl+C to exit")
+        ctx.set_rule_above(add_class="chat-mode")
+        ctx.set_rule_below(add_class="chat-mode")
+
+        try:
+            while user_input:
+                if ctx.is_tui:
+                    ctx.mount_widget(UserMessage(user_input))
+                    widget = StreamingMessage()
+                    ctx.mount_widget(widget)
+                    ctx.set_hint("Responding...")
+                    ctx.set_silent_queue(True)
+                    async for chunk in conv.stream(user_input):
+                        widget.append(chunk)
+                        if (n := ctx.pending_count) > 0:
+                            ctx.set_hint(f"Responding... ({n} queued)")
+                    ctx.set_silent_queue(False)
+                    ctx.set_hint("Chat mode - press Ctrl+C to exit")
+                    ctx.set_status_above(_format_tokens(conv, ctx) or None)
+                    user_input = await ctx.prompt()
+                else:
+                    async for chunk in conv.stream(user_input):
+                        console.print(chunk, end="")
+                    console.print()
+                    if tokens := _format_tokens(conv):
+                        console.print(f"[dim]{tokens}[/dim]")
+                    break
+        finally:
+            ctx.set_silent_queue(False)
+            ctx.clear_queue()  # Discard any messages typed during streaming
+            ctx.set_status_above(None)
+            ctx.set_hint(None)
+            ctx.set_rule_above(remove_class="chat-mode")
+            ctx.set_rule_below(remove_class="chat-mode")
+            if original_style:
+                ctx.set_prompt_style(original_style)
+
+
+@chat_group.command("clear", help="Clear conversation history")
+async def chat_clear_fn(
+    model: str | None = Option(
+        None,
+        "-m",
+        "--model",
+        help="Model session to clear (all if omitted)",
+        choices=ALL_MODELS,
+    ),
+    ctx: TuiContext = TuiOption(),
+) -> None:
+    """Clear conversation history for a model or all models."""
+    if model:
+        if model in _sessions:
+            _sessions[model][1].clear()
+            ctx.notify(f"Cleared history for {model}", title="Chat")
+            print(f"Cleared conversation history for {model}")
+        else:
+            print(f"No active session for {model}")
+    else:
+        for _, conv in _sessions.values():
+            conv.clear()
+        ctx.notify("Cleared all chat history", title="Chat")
+        print("Cleared all conversation history")

padwan_cli-0.2.1/padwan_cli/conversation.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from dataclasses import dataclass, field
+
+from padwan_llm._base import LLMClientBase
+from padwan_llm.conversation import ConversationState, Message
+from padwan_llm.models import UsageToken
+
+__all__ = ("Conversation", "Message")
+
+
+@dataclass
+class Conversation:
+    """Manages a multi-turn conversation with an LLM client.
+
+    The Conversation class wraps ConversationState and provides streaming
+    interface for chat interactions. Provider-specific details are handled
+    by the client's stream_chat method.
+
+    Example:
+        async with LLMClient(model="gpt-4o") as client:
+            conv = Conversation(client, system="You are a helpful assistant.")
+            async for chunk in conv.stream("Hello!"):
+                print(chunk, end="", flush=True)
+    """
+
+    client: LLMClientBase
+    system: str | None = None
+    _state: ConversationState = field(init=False)
+
+    def __post_init__(self) -> None:
+        self._state = ConversationState(system=self.system)
+
+    @property
+    def messages(self) -> list[Message]:
+        """Access the conversation message history."""
+        return self._state.messages
+
+    @messages.setter
+    def messages(self, value: list[Message]) -> None:
+        """Set the conversation message history."""
+        self._state.messages = value
+
+    @property
+    def last_usage(self) -> UsageToken | None:
+        """Token usage from the last request."""
+        return self._state.last_usage
+
+    @property
+    def total_usage(self) -> UsageToken:
+        """Cumulative token usage across all requests."""
+        return self._state.total_usage
+
+    def add_user_message(self, content: str) -> Message:
+        """Add a user message to the conversation history."""
+        return self._state.add_user_message(content)
+
+    def add_assistant_message(self, content: str) -> Message:
+        """Add an assistant message to the conversation history."""
+        return self._state.add_assistant_message(content)
+
+    def clear(self) -> None:
+        """Clear conversation history, keeping only the system message if set."""
+        self._state.clear()
+
+    async def stream(self, user_input: str) -> AsyncIterator[str]:
+        """Send a user message and stream the assistant's response.
+
+        Adds the user message to history, streams the response via the client's
+        stream_chat method, yields text as it arrives, and saves the complete
+        response to history when done. Also tracks token usage.
+        """
+        self.add_user_message(user_input)
+
+        response_chunks: list[str] = []
+        chat_stream = self.client.stream_chat(list(self.messages))
+
+        async for text in chat_stream:
+            response_chunks.append(text)
+            yield text
+
+        if chat_stream.usage:
+            self._state.accumulate_usage(chat_stream.usage)
+
+        full_response = "".join(response_chunks)
+        self.add_assistant_message(full_response)
+
+    async def send(self, user_input: str) -> str:
+        """Send a user message and return the complete response (non-streaming)."""
+        chunks = []
+        async for chunk in self.stream(user_input):
+            chunks.append(chunk)
+        return "".join(chunks)

padwan_cli-0.2.1/padwan_cli/run.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import sys
+
+from piou import Cli, Option
+
+from rich.table import Table
+
+from padwan_llm import (
+    GEMINI_MODELS,
+    GROK_MODELS,
+    MISTRAL_MODELS,
+    OPENAI_MODELS,
+    LLMClient,
+)
+from padwan_llm.conversation import Message
+from padwan_llm.errors import Provider
+
+from .utils import ALL_MODELS, console
+from .batch import batch_group
+from .chat import chat_group
+
+CUSTOM_CSS = """
+Rule.chat-mode {
+    color: #87ceeb;
+}
+"""
+
+cli = Cli(description="Padwan CLI for the unified LLM client library")
+
+cli.add_command_group(batch_group)
+cli.add_command_group(chat_group)
+
+
+@cli.command("models", help="List available models")
+def list_models(
+    provider: Provider | None = Option(
+        None, "-p", "--provider", help="Filter by provider"
+    ),
+) -> None:
+    """List all available models, optionally filtered by provider."""
+    provider_models: dict[str, list[str]] = {}
+    if not provider or provider == "openai":
+        provider_models["OpenAI"] = list(OPENAI_MODELS)
+    if not provider or provider == "gemini":
+        provider_models["Gemini"] = list(GEMINI_MODELS)
+    if not provider or provider == "mistral":
+        provider_models["Mistral"] = list(MISTRAL_MODELS)
+    if not provider or provider == "grok":
+        provider_models["Grok"] = list(GROK_MODELS)
+
+    if not provider_models:
+        console.print(f"[red]Unknown provider: {provider}[/red]")
+        return
+
+    table = Table(title="Available Models")
+    table.add_column("Provider", style="cyan")
+    table.add_column("Model", style="green")
+
+    for prov, models in provider_models.items():
+        for i, model in enumerate(sorted(models)):
+            table.add_row(prov if i == 0 else "", model)
+
+    console.print(table)
+
+
+@cli.command("info", help="Show library information")
+def info() -> None:
+    """Show library information."""
+    table = Table(title="Padwan LLM Library")
+    table.add_column("Provider", style="cyan")
+    table.add_column("Models", style="green", justify="right")
+
+    table.add_row("OpenAI", str(len(OPENAI_MODELS)))
+    table.add_row("Gemini", str(len(GEMINI_MODELS)))
+    table.add_row("Mistral", str(len(MISTRAL_MODELS)))
+    table.add_row("Grok", str(len(GROK_MODELS)))
+
+    total = (
+        len(OPENAI_MODELS) + len(GEMINI_MODELS) + len(MISTRAL_MODELS) + len(GROK_MODELS)
+    )
+    table.add_section()
+    table.add_row("[bold]Total[/bold]", f"[bold]{total}[/bold]")
+
+    console.print(table)
+
+
+@cli.main(help="One-shot LLM query")
+async def oneshot(
+    prompt: str = Option(..., help="Prompt to send"),
+    model: str = Option(
+        "gpt-4o-mini", "-m", "--model", help="Model to use", choices=ALL_MODELS
+    ),
+    stream: bool = Option(False, "--stream", "-s", help="Stream output as it arrives"),
+) -> None:
+    """Send a single prompt and print the response."""
+    client = LLMClient(model=model)
+    messages: list[Message] = [Message(role="user", content=prompt)]
+    async with client:
+        if stream:
+            async for chunk in client.stream_chat(messages):
+                sys.stdout.write(chunk)
+                sys.stdout.flush()
+        else:
+            text, _ = await client.complete_chat(messages)
+            print(text)
+    print()
+
+
+def main() -> None:
+    """Entry point for the CLI."""
+    cli.run(css=CUSTOM_CSS)
+
+
+def main_tui() -> None:
+    """Entry point for the TUI CLI."""
+    cli.tui = True
+    main()
+
+
+if __name__ == "__main__":
+    main()

padwan_cli-0.2.1/padwan_cli/utils.py

@@ -0,0 +1,7 @@
+from rich.console import Console
+
+from padwan_llm import GEMINI_MODELS, GROK_MODELS, MISTRAL_MODELS, OPENAI_MODELS
+
+console = Console()
+
+ALL_MODELS = sorted([*OPENAI_MODELS, *GEMINI_MODELS, *MISTRAL_MODELS, *GROK_MODELS])

padwan_cli-0.2.1/padwan_cli/widgets.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+from rich.text import Text
+from textual.widgets import Static
+
+from piou.tui import StreamingMessage as _StreamingMessage
+
+if TYPE_CHECKING:
+    from padwan_llm.gemini import BatchJob, BatchResult
+
+# Colors for chat messages
+USER_COLOR = "#87ceeb"
+ASSISTANT_COLOR = "#98fb98"
+
+# Colors for batch job states
+STATE_COLORS = {
+    "JOB_STATE_PENDING": "#ffa500",
+    "JOB_STATE_QUEUED": "#ffff00",
+    "JOB_STATE_RUNNING": "#00bfff",
+    "JOB_STATE_SUCCEEDED": "#98fb98",
+    "JOB_STATE_FAILED": "#ff6b6b",
+    "JOB_STATE_CANCELLED": "#808080",
+    "JOB_STATE_EXPIRED": "#808080",
+}
+
+
+class UserMessage(Static):
+    """A styled widget for displaying user messages."""
+
+    def __init__(self, content: str, **kwargs) -> None:
+        text = Text(content, style=USER_COLOR)
+        super().__init__(text, **kwargs)
+
+
+class StreamingMessage(_StreamingMessage):
+    """Streaming message with assistant color styling.
+
+    Extends piou's StreamingMessage (which handles autoscroll) to render
+    text in the assistant color.
+    """
+
+    def append(self, text: str) -> None:
+        self._text += text
+        self.update(Text(self._text, style=ASSISTANT_COLOR))
+        from piou.tui import TuiApp
+
+        if isinstance(self.app, TuiApp):
+            self.call_after_refresh(self.app._scroll_to_bottom)
+
+
+class BatchProgressWidget(Static):
+    """A widget that displays batch job progress with state coloring.
+
+    Shows job name, current state (with color), progress bar showing
+    succeeded/total requests, and elapsed time. Call update() to refresh
+    with new job data.
+    """
+
+    def __init__(self, job: BatchJob, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._job = job
+        self._state_history: list[str] = [job.state]
+        self._refresh_display()
+
+    def _refresh_display(self) -> None:
+        """Update the display with current job state."""
+        job = self._job
+        state_color = STATE_COLORS.get(job.state, "white")
+
+        # Build progress info
+        succeeded = 0
+        total = 0
+        if job.stats:
+            succeeded = cast(int, job.stats.get("successfulRequestCount", 0))
+            total = cast(int, job.stats.get("requestCount", 0))
+
+        # Create progress bar
+        bar_width = 30
+        if total > 0:
+            filled = int((succeeded / total) * bar_width)
+        else:
+            filled = 0
+        bar = "\u2588" * filled + "\u2591" * (bar_width - filled)
+
+        # Build display text
+        lines = [
+            f"Job: {job.name.split('/')[-1]}",
+            f"State: [{state_color}]{job.state}[/{state_color}]",
+            f"Progress: [{bar}] {succeeded}/{total}",
+        ]
+
+        if job.display_name:
+            lines.insert(1, f"Name: {job.display_name}")
+
+        # Show state history if there were transitions
+        if len(self._state_history) > 1:
+            history = " -> ".join(
+                s.replace("JOB_STATE_", "") for s in self._state_history
+            )
+            lines.append(f"History: {history}")
+
+        text = Text("\n".join(lines))
+        self.update(text)
+
+    def update_job(self, job: BatchJob) -> None:
+        """Update with new job data and refresh display."""
+        if job.state != self._job.state:
+            self._state_history.append(job.state)
+        self._job = job
+        self._refresh_display()
+
+
+class BatchResultWidget(Static):
+    """A widget that displays batch results in a styled format.
+
+    Shows each result with its key, token counts, and content preview.
+    Useful for viewing results in TUI mode.
+    """
+
+    def __init__(self, results: list[BatchResult], **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._results = results
+        self._refresh_display()
+
+    def _refresh_display(self) -> None:
+        """Update the display with results."""
+        lines: list[str] = []
+
+        for result in self._results:
+            # Header with key and token info
+            lines.append(
+                f"[cyan][{result.key}][/cyan] "
+                f"[dim]({result.input_tokens} in, {result.output_tokens} out, "
+                f"{result.total_tokens} total tokens)[/dim]"
+            )
+
+            # Content preview (truncated)
+            preview = result.content[:300].replace("\n", " ")
+            if len(result.content) > 300:
+                preview += "..."
+            lines.append(f"  {preview}")
+            lines.append("")
+
+        text = Text.from_markup("\n".join(lines))
+        self.update(text)

padwan_cli-0.2.1/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "padwan-cli"
+version = "0.2.1"
+description = "CLI and TUI for padwan-llm"
+readme = "README.md"
+authors = [
+    { email = "julien.brayere@polarsen.com" }
+]
+requires-python = ">=3.14"
+dependencies = [
+    "padwan-llm>=0.1.0",
+    "piou[tui]>=0.32.0",
+]
+
+[project.scripts]
+padwan-cli = "padwan_cli:main_tui"
+
+[build-system]
+requires = ["uv_build>=0.9.28,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-root = ""
+
+[tool.uv.sources]
+padwan-llm = { path = "../padwan-llm", editable = true }
+
+[dependency-groups]
+dev = [
+    "piou[tui-reload]>=0.33.0",
+    "pytest>=8.0.0",
+    "ruff>=0.11.0",
+]
+docs = [
+    "mkdocs>=1.6.0",
+    "mkdocs-material>=9.5.0",
+]
+bump = [
+    "commitizen>=4.0.0",
+]
+
+[tool.commitizen]
+name = "cz_conventional_commits"
+version_provider = "pep621"
+tag_format = "$version"
+update_changelog_on_bump = true
+bump_message = "chore(release): release $current_version → $new_version [skip ci]"