webber/webber-cli/webber_cli/main.py

#!/usr/bin/env python3
"""
Webber CLI - Client for the Webber API.

Usage:
    webber-cli --help
    webber-cli chat [OPTIONS]
    webber-cli status
"""
import asyncio
import os
import sys
from pathlib import Path

import typer
from prompt_toolkit import PromptSession
from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
from prompt_toolkit.completion import Completer, Completion, PathCompleter
from prompt_toolkit.history import FileHistory
from prompt_toolkit.styles import Style
from rich.markdown import Markdown
from rich.panel import Panel
from rich.prompt import Confirm

from webber_cli.client import WebberClient, PermissionMode
from webber_cli.theme import get_console, get_theme


# === Prompt Toolkit Setup ===

# History file location
HISTORY_FILE = Path.home() / ".webber_history"

# Built-in commands for completion
BUILTIN_COMMANDS = [
    "exit",
    "quit",
    "clear",
    "mode plan",
    "mode default",
    "mode auto_accept",
    "cd ",
]


class WebberCompleter(Completer):
    """Custom completer for Webber CLI commands."""

    def __init__(self, working_dir: str):
        self.working_dir = working_dir
        self.path_completer = PathCompleter(expanduser=True)

    def get_completions(self, document, complete_event):
        text = document.text_before_cursor.lower()

        # Complete built-in commands
        if not text or not text.startswith("cd "):
            for cmd in BUILTIN_COMMANDS:
                if cmd.startswith(text):
                    yield Completion(
                        cmd,
                        start_position=-len(text),
                        display_meta="command",
                    )

        # Complete file paths after "cd "
        if text.startswith("cd "):
            path_text = text[3:]
            # Create a sub-document for path completion
            from prompt_toolkit.document import Document
            path_doc = Document(path_text, len(path_text))
            for completion in self.path_completer.get_completions(path_doc, complete_event):
                yield Completion(
                    "cd " + (path_text + completion.text),
                    start_position=-len(text),
                    display_meta="directory",
                )


# Prompt style matching Rich theme
PROMPT_STYLE = Style.from_dict({
    "prompt": "#5f87d7 bold",  # info color
    "": "",  # default text
})


def create_prompt_session(working_dir: str) -> PromptSession:
    """Create a configured prompt session with history and completion."""
    return PromptSession(
        history=FileHistory(str(HISTORY_FILE)),
        auto_suggest=AutoSuggestFromHistory(),
        completer=WebberCompleter(working_dir),
        style=PROMPT_STYLE,
        complete_while_typing=False,  # Only complete on Tab
    )

app = typer.Typer(
    name="webber-cli",
    help="CLI client for the Webber API",
    no_args_is_help=True,
    add_completion=False,
)

console = get_console()

# Default API URL (can be overridden via env or option)
# Development port is 8095, production is 8086
DEFAULT_API_URL = os.environ.get("WEBBER_API_URL", "http://localhost:8095")


def version_callback(value: bool) -> None:
    """Display version and exit."""
    if value:
        from webber_cli import __version__
        console.print(f"[title]webber-cli[/] version [success]{__version__}[/]")
        raise typer.Exit()


def _confirm_auto_accept() -> bool:
    """
    Prompt user to confirm auto_accept mode.

    Returns True if user confirms, False otherwise.
    """
    console.print()
    console.print("[warning]WARNING:[/] auto_accept mode bypasses all safety prompts.")
    console.print("The agent will execute write operations without confirmation.")
    console.print()
    return Confirm.ask(
        "[warning]Are you sure you want to enable auto_accept mode?[/]",
        default=False,
        console=console,
    )


@app.callback()
def main(
    version: bool = typer.Option(
        False,
        "--version",
        "-v",
        callback=version_callback,
        is_eager=True,
        help="Show version and exit",
    ),
) -> None:
    """Webber CLI - Talk to the Webber API."""
    pass


@app.command()
def chat(
    directory: str = typer.Option(
        ".",
        "--directory",
        "-d",
        help="Working directory for the agent",
    ),
    api_url: str = typer.Option(
        DEFAULT_API_URL,
        "--api",
        "-a",
        help="Webber API URL",
    ),
    mode: str = typer.Option(
        "default",
        "--mode",
        "-m",
        help="Permission mode: default, plan (read-only), auto_accept (no prompts)",
    ),
    stream: bool = typer.Option(
        True,
        "--stream/--no-stream",
        "-s",
        help="Stream responses in real-time",
    ),
) -> None:
    """
    Start interactive chat session with the Task agent.

    The Task agent is the main orchestrator that can:
    - Explore and analyze codebases
    - Plan implementation strategies
    - Execute code modifications (in default/auto_accept modes)
    - Spawn sub-agents for focused tasks

    Permission modes:
    - default: Full capabilities with approval prompts for writes
    - plan: Read-only mode for safe exploration and planning
    - auto_accept: Full capabilities without approval prompts (use with caution)
    """
    working_dir = str(Path(directory).resolve())

    if not Path(working_dir).exists():
        console.print(f"[error]Error:[/] Directory not found: {working_dir}")
        raise typer.Exit(1)

    # Parse and validate mode
    try:
        permission_mode = PermissionMode(mode)
    except ValueError:
        console.print(f"[error]Error:[/] Invalid mode: {mode}")
        console.print("[dim]Valid modes: default, plan, auto_accept[/]")
        raise typer.Exit(1)

    # Confirm auto_accept mode (security risk)
    if permission_mode == PermissionMode.auto_accept:
        if not _confirm_auto_accept():
            console.print("[dim]Cancelled. Using default mode instead.[/]")
            permission_mode = PermissionMode.default

    try:
        asyncio.run(_chat_loop(api_url, working_dir, permission_mode, stream))
    except KeyboardInterrupt:
        console.print("\n[dim]Goodbye![/]")


async def _chat_loop(
    api_url: str,
    working_dir: str,
    mode: PermissionMode,
    stream: bool = True,
) -> None:
    """Interactive chat loop with the Task agent."""
    theme = get_theme()
    agent_type = "task"

    async with WebberClient(api_url) as client:
        # Check API health
        if not await client.health_check():
            console.print(f"[error]Error:[/] Cannot connect to Webber API at {api_url}")
            console.print("[dim]Make sure the server is running: ./wakeup.sh[/]")
            return

        # Get agent info
        agent_info = await client.get_agent(agent_type)
        if not agent_info:
            console.print(f"[error]Error:[/] Task agent not found")
            return

        # Mode display
        mode_display = {
            PermissionMode.default: "[info]default[/] (full with approvals)",
            PermissionMode.plan: "[success]plan[/] (read-only)",
            PermissionMode.auto_accept: "[warning]auto_accept[/] (no prompts)",
        }

        # Welcome message
        console.print()
        console.print(f"[title]Webber CLI[/] [dim]→ {api_url}[/]")
        console.print(f"[dim]Working in:[/] [path]{working_dir}[/]")
        console.print(f"[dim]Mode:[/] {mode_display[mode]}")
        console.print(f"[dim]Streaming:[/] {'enabled' if stream else 'disabled'}")
        console.print()
        console.print("[dim]Commands: 'exit' to quit, 'clear' to clear, 'mode <plan|default|auto_accept>' to switch[/]")
        console.print("[dim]Tab for completion, Up/Down for history[/]")
        console.print()

        current_mode = mode

        # Create prompt session with history and completion
        session = create_prompt_session(working_dir)

        # Chat loop
        while True:
            try:
                # Use prompt_toolkit for input (with history and completion)
                try:
                    user_input = await session.prompt_async(
                        [("class:prompt", "> ")],
                    )
                    user_input = user_input.strip()
                except EOFError:
                    # Ctrl+D pressed
                    console.print("[dim]Goodbye![/]")
                    break

                if not user_input:
                    continue

                if user_input.lower() in ("exit", "quit", "/exit", "/quit"):
                    console.print("[dim]Goodbye![/]")
                    break

                if user_input.lower() in ("clear", "/clear"):
                    console.clear()
                    continue

                if user_input.lower().startswith("cd "):
                    new_dir = user_input[3:].strip()
                    # Handle ~ expansion
                    new_path = Path(new_dir).expanduser().resolve()
                    if new_path.exists() and new_path.is_dir():
                        working_dir = str(new_path)
                        # Update completer's working directory
                        session.completer.working_dir = working_dir
                        console.print(f"[info]Changed to:[/] [path]{working_dir}[/]")
                    else:
                        console.print(f"[error]Directory not found:[/] {new_dir}")
                    continue

                # Mode switching
                if user_input.lower().startswith("mode "):
                    new_mode_str = user_input[5:].strip()
                    try:
                        new_mode = PermissionMode(new_mode_str)
                        if new_mode == PermissionMode.auto_accept:
                            if not _confirm_auto_accept():
                                console.print("[dim]Mode unchanged.[/]")
                                continue
                        current_mode = new_mode
                        console.print(f"[info]Mode changed to:[/] {mode_display[current_mode]}")
                    except ValueError:
                        console.print(f"[error]Invalid mode:[/] {new_mode_str}")
                        console.print("[dim]Valid modes: default, plan, auto_accept[/]")
                    continue

                console.print()

                if stream:
                    # Stream response in real-time
                    try:
                        async for chunk in client.run_agent_stream(
                            agent_type, user_input, working_dir, current_mode
                        ):
                            sys.stdout.write(chunk)
                            sys.stdout.flush()
                        console.print()  # Newline after streaming
                    except Exception as e:
                        console.print(f"\n[error]Stream error:[/] {e}")
                else:
                    # Batch mode with spinner
                    with console.status("[info]Thinking...[/]", spinner=theme.spinner):
                        result = await client.run_agent(
                            agent_type, user_input, working_dir, current_mode
                        )

                    if result.success:
                        console.print(Markdown(result.response))
                    else:
                        console.print(f"[error]Error:[/] {result.error}")

                console.print()

            except KeyboardInterrupt:
                console.print("\n[dim]Use 'exit' to quit.[/]")

            except Exception as e:
                console.print(f"[error]Error:[/] {e}")


@app.command()
def status(
    api_url: str = typer.Option(
        DEFAULT_API_URL,
        "--api",
        "-a",
        help="Webber API URL",
    ),
) -> None:
    """Check API status and list available agents."""
    asyncio.run(_status(api_url))


async def _status(api_url: str) -> None:
    """Check API status."""
    async with WebberClient(api_url) as client:
        console.print(f"[dim]API URL:[/] {api_url}")

        if await client.health_check():
            console.print("[success]Status:[/] Connected")

            agents = await client.list_agents()
            console.print(f"\n[dim]Available agents ({len(agents)}):[/]")
            for agent in agents:
                console.print(f"  [info]{agent.name}[/]: {agent.description}")
        else:
            console.print("[error]Status:[/] Cannot connect")


# Keep 'explore' as an alias for 'chat --mode plan' for backwards compatibility
@app.command(hidden=True)
def explore(
    query: str = typer.Argument(..., help="What to search for"),
    directory: str = typer.Option(
        ".",
        "--directory",
        "-d",
        help="Working directory",
    ),
    api_url: str = typer.Option(
        DEFAULT_API_URL,
        "--api",
        "-a",
        help="Webber API URL",
    ),
    stream: bool = typer.Option(
        True,
        "--stream/--no-stream",
        "-s",
        help="Stream responses in real-time",
    ),
) -> None:
    """
    [DEPRECATED] One-shot exploration (use 'chat --mode plan' instead).

    Runs the Task agent in plan (read-only) mode for a single query.
    """
    console.print("[dim]Note: 'explore' is deprecated. Use 'chat --mode plan' for interactive mode.[/]")
    console.print()

    working_dir = str(Path(directory).resolve())

    if not Path(working_dir).exists():
        console.print(f"[error]Error:[/] Directory not found: {working_dir}")
        raise typer.Exit(1)

    asyncio.run(_explore(api_url, query, working_dir, stream))


async def _explore(
    api_url: str, query: str, working_dir: str, stream: bool = True
) -> None:
    """Execute exploration query in plan mode."""
    theme = get_theme()
    mode = PermissionMode.plan

    async with WebberClient(api_url) as client:
        # Check API health
        if not await client.health_check():
            console.print(f"[error]Error:[/] Cannot connect to Webber API at {api_url}")
            console.print("[dim]Make sure the server is running: ./wakeup.sh[/]")
            return

        console.print(f"[dim]Exploring:[/] [path]{working_dir}[/]")
        console.print(f"[dim]Query:[/] {query}")
        console.print(f"[dim]Mode:[/] [success]plan[/] (read-only)")
        console.print()

        if stream:
            # Stream response in real-time
            try:
                async for chunk in client.run_agent_stream(
                    "task", query, working_dir, mode
                ):
                    sys.stdout.write(chunk)
                    sys.stdout.flush()
                console.print()  # Newline after streaming
            except Exception as e:
                console.print(f"\n[error]Stream error:[/] {e}")
        else:
            # Batch mode with spinner
            with console.status("[info]Searching...[/]", spinner=theme.spinner):
                result = await client.run_agent("task", query, working_dir, mode)

            if result.success:
                console.print(Panel(
                    Markdown(result.response),
                    title="[success]Findings[/]",
                    border_style=theme.colors.border_success,
                ))
            else:
                console.print(Panel(
                    f"[error]{result.error}[/]",
                    title="[error]Error[/]",
                    border_style=theme.colors.border_error,
                ))


if __name__ == "__main__":
    app()