agent-scout-cli 0.1.0__py3-none-any.whl

agent_scout_cli/__init__.py

@@ -0,0 +1,3 @@
+"""AgentScout CLI — Command-line interface for AgentScout."""
+
+__version__ = "0.1.0"

agent_scout_cli/commands/runner.py

@@ -0,0 +1,256 @@
+"""Agent runner — wire up and execute tasks from the CLI."""
+
+from __future__ import annotations
+
+import uuid
+
+from agent_scout.agent import Agent
+from agent_scout.config.settings import Settings
+from agent_scout.db.models import AutonomyLevel, Task
+from agent_scout.events import Event, EventBus, EventType
+from agent_scout.llm.budget import BudgetConfig, BudgetEngine
+from agent_scout.llm.estimator import CostEstimator
+from agent_scout.llm.provider import (
+    AgentLLMProvider,
+    CustomEndpoint,
+    LLMClient,
+    ProviderConfig,
+)
+from agent_scout.llm.router import ModelRouter, RouterConfig
+from agent_scout.plugins.registry import PluginRegistry
+from agent_scout.plugins.web_search import WebSearchPlugin
+from rich.console import Console
+
+from agent_scout_cli.display.components import (
+    action_panel,
+    cost_display,
+    error_panel,
+    finish_panel,
+    observation_panel,
+    thought_panel,
+)
+
+
+def _build_provider_config(settings: Settings) -> ProviderConfig:
+    """Build ProviderConfig from Settings."""
+    endpoints = [
+        CustomEndpoint(
+            name=ep.name,
+            base_url=ep.base_url,
+            api_key=ep.api_key,
+            model_name=ep.model_name,
+        )
+        for ep in settings.custom_endpoints
+    ]
+    return ProviderConfig(
+        default_model=settings.llm.default_model,
+        temperature=settings.llm.temperature,
+        max_tokens=settings.llm.max_tokens,
+        custom_endpoints=endpoints,
+    )
+
+
+def _build_router(settings: Settings) -> ModelRouter:
+    """Build ModelRouter from Settings."""
+    config = RouterConfig(
+        fast_model=settings.llm.fast_model,
+        balanced_model=settings.llm.default_model,
+        best_model=settings.llm.best_model,
+        enabled=settings.llm.enable_routing,
+    )
+    return ModelRouter(config)
+
+
+def _build_budget(settings: Settings, bus: EventBus) -> BudgetEngine:
+    """Build BudgetEngine from Settings."""
+    config = BudgetConfig(
+        task_limit=settings.budget.task_limit,
+        daily_limit=settings.budget.daily_limit,
+        monthly_limit=settings.budget.monthly_limit,
+        enforce=settings.budget.enforce,
+    )
+    return BudgetEngine(config=config, event_bus=bus)
+
+
+def _build_registry(settings: Settings) -> PluginRegistry:
+    """Build and populate the plugin registry."""
+    from agent_scout.plugins.base import PluginConfig
+
+    registry = PluginRegistry()
+
+    if "web_search" in settings.plugins:
+        ws_config = PluginConfig(
+            settings={
+                "tavily_api_key": settings.search.tavily_api_key,
+                "serpapi_api_key": settings.search.serpapi_api_key,
+                "brave_api_key": settings.search.brave_api_key,
+            }
+        )
+        registry.register(WebSearchPlugin(config=ws_config))
+
+    return registry
+
+
+class CLIEventHandler:
+    """Display agent events in the terminal."""
+
+    def __init__(self, console: Console, verbose: bool = False) -> None:
+        self._console = console
+        self._verbose = verbose
+        self._step_count = 0
+        self._total_input = 0
+        self._total_output = 0
+        self._total_cost = 0.0
+
+    async def handle(self, event: Event) -> None:
+        """Route events to display methods."""
+        handlers = {
+            EventType.THOUGHT: self._on_thought,
+            EventType.ACTION: self._on_action,
+            EventType.OBSERVATION: self._on_observation,
+            EventType.TOOL_CALL_START: self._on_tool_start,
+            EventType.TOOL_CALL_END: self._on_tool_end,
+            EventType.TOOL_ERROR: self._on_tool_error,
+            EventType.COST_UPDATE: self._on_cost,
+            EventType.BUDGET_WARNING: self._on_budget_warning,
+            EventType.BUDGET_EXCEEDED: self._on_budget_exceeded,
+            EventType.TASK_COMPLETED: self._on_completed,
+            EventType.TASK_FAILED: self._on_failed,
+            EventType.ERROR: self._on_error,
+        }
+        handler = handlers.get(event.event_type)
+        if handler:
+            handler(event)
+
+    def _on_thought(self, event: Event) -> None:
+        self._step_count += 1
+        self._console.print(thought_panel(event.data.get("thought", ""), self._step_count))
+
+    def _on_action(self, event: Event) -> None:
+        tool = event.data.get("tool_name", "")
+        if tool:
+            self._console.print(action_panel(tool, event.data.get("tool_input")))
+
+    def _on_observation(self, event: Event) -> None:
+        obs = event.data.get("observation", "")
+        if obs and self._verbose:
+            self._console.print(observation_panel(obs))
+        elif obs:
+            short = obs[:200] + "..." if len(obs) > 200 else obs
+            self._console.print(f"  [dim]{short}[/dim]")
+
+    def _on_tool_start(self, event: Event) -> None:
+        tool = event.data.get("tool_name", "")
+        self._console.print(f"  [dim]Running {tool}...[/dim]")
+
+    def _on_tool_end(self, event: Event) -> None:
+        pass  # observation handles the output
+
+    def _on_tool_error(self, event: Event) -> None:
+        err = event.data.get("error", "")
+        self._console.print(f"  [red]Tool error: {err}[/red]")
+
+    def _on_cost(self, event: Event) -> None:
+        self._total_input += event.data.get("input_tokens", 0)
+        self._total_output += event.data.get("output_tokens", 0)
+        self._total_cost += event.data.get("cost_usd", 0.0)
+
+    def _on_budget_warning(self, event: Event) -> None:
+        pct = event.data.get("percentage", 0)
+        limit_type = event.data.get("limit_type", "")
+        self._console.print(f"  [yellow]Budget warning: {limit_type} at {pct}%[/yellow]")
+
+    def _on_budget_exceeded(self, event: Event) -> None:
+        limit_type = event.data.get("limit_type", "")
+        self._console.print(f"  [bold red]Budget exceeded: {limit_type}[/bold red]")
+
+    def _on_completed(self, event: Event) -> None:
+        result = event.data.get("result", {})
+        message = result.get("message", "") if isinstance(result, dict) else str(result)
+        if message:
+            self._console.print(finish_panel(message))
+        self._print_summary()
+
+    def _on_failed(self, event: Event) -> None:
+        err = event.data.get("error", "Task failed")
+        self._console.print(error_panel(err))
+        self._print_summary()
+
+    def _on_error(self, event: Event) -> None:
+        err = event.data.get("error", "")
+        self._console.print(f"  [red]{err}[/red]")
+
+    def _print_summary(self) -> None:
+        if self._total_input > 0 or self._total_output > 0:
+            self._console.print(
+                cost_display(
+                    self._total_input,
+                    self._total_output,
+                    self._total_cost,
+                )
+            )
+        self._console.print(f"[dim]Completed in {self._step_count} steps[/dim]")
+
+
+async def run_task(
+    task_description: str,
+    settings: Settings,
+    console: Console,
+    model_override: str | None = None,
+    budget_override: float | None = None,
+    verbose: bool = False,
+) -> None:
+    """Build the full agent stack and execute a task."""
+    bus = EventBus()
+
+    # Event display
+    handler = CLIEventHandler(console, verbose=verbose)
+    bus.subscribe(handler.handle)
+
+    # LLM stack
+    provider_config = _build_provider_config(settings)
+    client = LLMClient(config=provider_config, event_bus=bus)
+    router = _build_router(settings)
+    estimator = CostEstimator()
+    budget = _build_budget(settings, bus)
+
+    if budget_override is not None:
+        budget.config.task_limit = budget_override
+
+    # Route to best model for this task
+    model = router.route(task_description, override_model=model_override)
+    llm_provider = AgentLLMProvider(client, model=model)
+
+    # Plugin registry
+    registry = _build_registry(settings)
+    await registry.load_all()
+
+    # Build autonomy level
+    autonomy_map = {
+        "full": AutonomyLevel.FULL,
+        "semi": AutonomyLevel.SEMI,
+        "step": AutonomyLevel.STEP_BY_STEP,
+    }
+    autonomy = autonomy_map.get(settings.autonomy, AutonomyLevel.FULL)
+
+    # Pre-execution cost estimate
+    estimate = estimator.estimate(model=model, input_tokens=500, expected_output_tokens=1000)
+    console.print(f"[dim]Model: {model} | Estimated cost: {estimate.formatted}[/dim]")
+
+    # Build and run agent
+    agent = Agent(
+        llm=llm_provider,
+        tools=registry,
+        event_bus=bus,
+        autonomy=autonomy,
+    )
+
+    task = Task(
+        id=uuid.uuid4().hex[:12],
+        description=task_description,
+    )
+
+    await agent.run_task(task)
+
+    # Cleanup
+    await registry.unload_all()

agent_scout_cli/display/components.py

@@ -0,0 +1,181 @@
+"""Rich display components for the AgentScout CLI."""
+
+from __future__ import annotations
+
+from rich.panel import Panel
+from rich.table import Table
+
+
+def thought_panel(thought: str, step_number: int) -> Panel:
+    """Display an agent thought."""
+    return Panel(
+        thought,
+        title=f"[bold cyan]Thought #{step_number}[/bold cyan]",
+        border_style="cyan",
+        padding=(0, 1),
+    )
+
+
+def action_panel(tool_name: str, tool_input: dict | None = None) -> Panel:
+    """Display an agent action (tool call)."""
+    content = f"[bold]{tool_name}[/bold]"
+    if tool_input:
+        args = ", ".join(f"{k}={v!r}" for k, v in tool_input.items())
+        content += f"\n[dim]{args}[/dim]"
+    return Panel(
+        content,
+        title="[bold yellow]Action[/bold yellow]",
+        border_style="yellow",
+        padding=(0, 1),
+    )
+
+
+def observation_panel(observation: str, max_length: int = 500) -> Panel:
+    """Display an observation (tool result)."""
+    display = observation[:max_length]
+    if len(observation) > max_length:
+        display += f"\n[dim]... ({len(observation) - max_length} chars truncated)[/dim]"
+    return Panel(
+        display,
+        title="[bold green]Observation[/bold green]",
+        border_style="green",
+        padding=(0, 1),
+    )
+
+
+def finish_panel(message: str) -> Panel:
+    """Display the final result."""
+    return Panel(
+        message,
+        title="[bold green]Result[/bold green]",
+        border_style="bold green",
+        padding=(1, 2),
+    )
+
+
+def error_panel(error: str) -> Panel:
+    """Display an error."""
+    return Panel(
+        f"[red]{error}[/red]",
+        title="[bold red]Error[/bold red]",
+        border_style="red",
+        padding=(0, 1),
+    )
+
+
+def cost_display(
+    input_tokens: int,
+    output_tokens: int,
+    cost_usd: float,
+    budget_remaining: float | None = None,
+) -> Panel:
+    """Display cost information."""
+    lines = [
+        f"Tokens: [cyan]{input_tokens:,}[/cyan] in / [cyan]{output_tokens:,}[/cyan] out",
+        f"Cost: [bold]${cost_usd:.4f}[/bold]",
+    ]
+    if budget_remaining is not None:
+        color = "green" if budget_remaining > 0.5 else "yellow" if budget_remaining > 0.1 else "red"
+        lines.append(f"Budget remaining: [{color}]${budget_remaining:.2f}[/{color}]")
+    return Panel(
+        "\n".join(lines),
+        title="[bold]Cost[/bold]",
+        border_style="dim",
+        padding=(0, 1),
+    )
+
+
+def comparison_table(
+    title: str,
+    columns: list[str],
+    rows: list[list[str]],
+    highlight_col: int | None = None,
+    highlight_row: int | None = 0,
+) -> Table:
+    """Build a comparison table with optional row highlighting."""
+    table = Table(title=title, show_lines=True)
+
+    for i, col in enumerate(columns):
+        style = "bold cyan" if i == highlight_col else ""
+        table.add_column(col, style=style)
+
+    for i, row in enumerate(rows):
+        style = "bold green" if i == highlight_row else ""
+        table.add_row(*row, style=style)
+
+    return table
+
+
+def task_progress(
+    step_count: int,
+    max_steps: int,
+    current_action: str = "",
+) -> Panel:
+    """Display task progress."""
+    pct = min(100, int((step_count / max_steps) * 100)) if max_steps > 0 else 0
+    bar_filled = pct // 5
+    bar_empty = 20 - bar_filled
+    bar = f"[green]{'=' * bar_filled}[/green][dim]{'.' * bar_empty}[/dim]"
+
+    lines = [
+        f"Step {step_count}/{max_steps} [{bar}] {pct}%",
+    ]
+    if current_action:
+        lines.append(f"[dim]{current_action}[/dim]")
+
+    return Panel(
+        "\n".join(lines),
+        title="[bold]Progress[/bold]",
+        border_style="blue",
+        padding=(0, 1),
+    )
+
+
+def sparkline(values: list[float], width: int = 20) -> str:
+    """Generate a simple text-based sparkline from values."""
+    if not values:
+        return ""
+
+    blocks = " ▁▂▃▄▅▆▇█"
+    mn, mx = min(values), max(values)
+    rng = mx - mn if mx != mn else 1
+
+    # Sample values to fit width
+    if len(values) > width:
+        step = len(values) / width
+        sampled = [values[int(i * step)] for i in range(width)]
+    else:
+        sampled = values
+
+    chars = []
+    for v in sampled:
+        idx = int(((v - mn) / rng) * (len(blocks) - 1))
+        chars.append(blocks[idx])
+    return "".join(chars)
+
+
+def price_trend_display(
+    item_name: str,
+    prices: list[float],
+    currency: str = "USD",
+) -> Panel:
+    """Display a price trend with sparkline."""
+    if not prices:
+        return Panel(f"No price data for '{item_name}'", border_style="dim")
+
+    chart = sparkline(prices)
+    current = prices[-1]
+    mn = min(prices)
+    mx = max(prices)
+
+    lines = [
+        f"[bold]{item_name}[/bold]",
+        f"Current: {currency} {current:.2f}",
+        f"Range: {currency} {mn:.2f} - {currency} {mx:.2f}",
+        f"Trend: {chart}",
+    ]
+    return Panel(
+        "\n".join(lines),
+        border_style="cyan",
+        padding=(0, 1),
+    )

agent_scout_cli/main.py

@@ -0,0 +1,445 @@
+"""AgentScout CLI entry point."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+import typer
+from agent_scout import __version__ as core_version
+from agent_scout.config.settings import (
+    DEFAULT_CONFIG_FILE,
+    CustomEndpointSettings,
+    Settings,
+    load_settings,
+    save_settings,
+)
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+
+from . import __version__ as cli_version
+
+app = typer.Typer(
+    name="agent-scout",
+    help="AgentScout — Your personal AI assistant agent that scouts the web for you.",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+def _load_settings() -> Settings:
+    """Load settings with error display."""
+    return load_settings()
+
+
+# ---- run ----
+
+
+@app.command()
+def run(
+    task: str = typer.Argument(
+        help="Natural language description of what you want the agent to do",
+    ),
+    model: str | None = typer.Option(
+        None, "--model", "-m", help="LLM model to use (overrides routing)"
+    ),
+    budget: float | None = typer.Option(
+        None, "--budget", "-b", help="Max budget for this task (USD)"
+    ),
+    autonomy: str = typer.Option(None, "--autonomy", "-a", help="Autonomy level: full, semi, step"),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Show full observations and debug info"
+    ),
+):
+    """Run a scouting task."""
+    settings = _load_settings()
+
+    if autonomy:
+        settings.autonomy = autonomy
+    if verbose:
+        settings.verbose = True
+
+    console.print(
+        Panel(
+            f"[bold]Task:[/bold] {task}",
+            title="[bold green]AgentScout[/bold green]",
+            subtitle="Starting...",
+            border_style="green",
+        )
+    )
+
+    from agent_scout_cli.commands.runner import run_task
+
+    asyncio.run(
+        run_task(
+            task_description=task,
+            settings=settings,
+            console=console,
+            model_override=model,
+            budget_override=budget,
+            verbose=verbose,
+        )
+    )
+
+
+# ---- setup ----
+
+
+@app.command()
+def setup(
+    reconfigure: bool = typer.Option(False, "--reconfigure", help="Reconfigure existing settings"),
+):
+    """Run the interactive setup wizard."""
+    settings = _load_settings() if reconfigure else Settings()
+
+    console.print(
+        Panel(
+            "[bold]Welcome to AgentScout![/bold]\n\n"
+            "This wizard will help you configure your AI assistant.\n"
+            "You can re-run this anytime with: [cyan]agent-scout setup --reconfigure[/cyan]",
+            title="[bold green]Setup Wizard[/bold green]",
+            border_style="green",
+        )
+    )
+
+    # Step 1: LLM model
+    console.print("\n[bold]Step 1: LLM Configuration[/bold]")
+    settings.llm.default_model = Prompt.ask(
+        "Default model",
+        default=settings.llm.default_model,
+    )
+
+    # Step 2: API keys (optional)
+    console.print("\n[bold]Step 2: Search API Keys[/bold] [dim](optional, Enter to skip)[/dim]")
+    settings.search.tavily_api_key = Prompt.ask(
+        "Tavily API key", default=settings.search.tavily_api_key or "", show_default=False
+    )
+    settings.search.serpapi_api_key = Prompt.ask(
+        "SerpAPI key", default=settings.search.serpapi_api_key or "", show_default=False
+    )
+    settings.search.brave_api_key = Prompt.ask(
+        "Brave Search key", default=settings.search.brave_api_key or "", show_default=False
+    )
+
+    # Step 3: Custom endpoints
+    console.print("\n[bold]Step 3: Custom LLM Endpoints[/bold]")
+    while Confirm.ask("Add a custom LLM endpoint?", default=False):
+        ep = CustomEndpointSettings(
+            name=Prompt.ask("Endpoint name (e.g., 'myapi')"),
+            base_url=Prompt.ask("Base URL"),
+            api_key=Prompt.ask("API key"),
+            model_name=Prompt.ask("Model name"),
+        )
+        settings.custom_endpoints.append(ep)
+
+    # Step 4: Budget
+    console.print("\n[bold]Step 4: Budget Limits[/bold]")
+    settings.budget.task_limit = float(
+        Prompt.ask("Max per-task spend (USD)", default=str(settings.budget.task_limit))
+    )
+    settings.budget.daily_limit = float(
+        Prompt.ask("Max daily spend (USD)", default=str(settings.budget.daily_limit))
+    )
+    settings.budget.monthly_limit = float(
+        Prompt.ask("Max monthly spend (USD)", default=str(settings.budget.monthly_limit))
+    )
+
+    # Step 5: Personality
+    console.print("\n[bold]Step 5: Personality[/bold]")
+    settings.personality = Prompt.ask(
+        "Agent personality",
+        choices=["helpful", "concise", "detailed", "casual"],
+        default=settings.personality,
+    )
+
+    # Save
+    save_settings(settings)
+    console.print(
+        Panel(
+            f"Configuration saved to [cyan]{DEFAULT_CONFIG_FILE}[/cyan]\n\n"
+            "You're all set! Run a task with:\n"
+            '[bold]agent-scout run "Find me the best deal on..."[/bold]',
+            title="[bold green]Setup Complete[/bold green]",
+            border_style="green",
+        )
+    )
+
+
+# ---- config ----
+
+
+@app.command()
+def config(
+    action: str = typer.Argument("show", help="Action: show, set, add-endpoint"),
+    key: str | None = typer.Argument(None, help="Config key (for 'set')"),
+    value: str | None = typer.Argument(None, help="Config value (for 'set')"),
+):
+    """View or modify configuration."""
+    settings = _load_settings()
+
+    if action == "show":
+        _config_show(settings)
+    elif action == "set":
+        if not key or value is None:
+            console.print("[red]Usage: agent-scout config set <key> <value>[/red]")
+            raise typer.Exit(1)
+        _config_set(settings, key, value)
+    elif action == "add-endpoint":
+        _config_add_endpoint(settings)
+    else:
+        console.print(f"[red]Unknown action: {action}[/red]")
+        raise typer.Exit(1)
+
+
+def _config_show(settings: Settings) -> None:
+    """Display current configuration."""
+    table = Table(title="AgentScout Configuration")
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value", style="white")
+
+    table.add_row("Default model", settings.llm.default_model)
+    table.add_row("Fast model", settings.llm.fast_model)
+    table.add_row("Best model", settings.llm.best_model)
+    table.add_row("Temperature", str(settings.llm.temperature))
+    table.add_row("Max tokens", str(settings.llm.max_tokens))
+    table.add_row("Smart routing", str(settings.llm.enable_routing))
+    table.add_row("---", "---")
+    table.add_row("Task budget", f"${settings.budget.task_limit}")
+    table.add_row("Daily budget", f"${settings.budget.daily_limit}")
+    table.add_row("Monthly budget", f"${settings.budget.monthly_limit}")
+    table.add_row("Enforce budgets", str(settings.budget.enforce))
+    table.add_row("---", "---")
+    table.add_row("Personality", settings.personality)
+    table.add_row("Autonomy", settings.autonomy)
+    table.add_row("Plugins", ", ".join(settings.plugins))
+    table.add_row("---", "---")
+    table.add_row("Tavily key", "***" if settings.search.tavily_api_key else "(not set)")
+    table.add_row("SerpAPI key", "***" if settings.search.serpapi_api_key else "(not set)")
+    table.add_row("Brave key", "***" if settings.search.brave_api_key else "(not set)")
+
+    if settings.custom_endpoints:
+        table.add_row("---", "---")
+        for ep in settings.custom_endpoints:
+            table.add_row(f"Endpoint: {ep.name}", f"{ep.base_url} ({ep.model_name})")
+
+    console.print(table)
+    console.print(f"\n[dim]Config file: {DEFAULT_CONFIG_FILE}[/dim]")
+
+
+def _config_set(settings: Settings, key: str, value: str) -> None:
+    """Set a single config value."""
+    parts = key.split(".")
+    try:
+        if len(parts) == 2:
+            section, field = parts
+            obj = getattr(settings, section, None)
+            if obj is None:
+                console.print(f"[red]Unknown section: {section}[/red]")
+                raise typer.Exit(1)
+            if not hasattr(obj, field):
+                console.print(f"[red]Unknown field: {section}.{field}[/red]")
+                raise typer.Exit(1)
+            current = getattr(obj, field)
+            # Type coercion
+            if isinstance(current, bool):
+                setattr(obj, field, value.lower() in ("true", "1", "yes"))
+            elif isinstance(current, float):
+                setattr(obj, field, float(value))
+            elif isinstance(current, int):
+                setattr(obj, field, int(value))
+            else:
+                setattr(obj, field, value)
+        elif len(parts) == 1:
+            if not hasattr(settings, key):
+                console.print(f"[red]Unknown key: {key}[/red]")
+                raise typer.Exit(1)
+            setattr(settings, key, value)
+        else:
+            console.print(f"[red]Invalid key format: {key}[/red]")
+            raise typer.Exit(1)
+
+        save_settings(settings)
+        console.print(f"[green]Set {key} = {value}[/green]")
+
+    except (ValueError, TypeError) as e:
+        console.print(f"[red]Invalid value: {e}[/red]")
+        raise typer.Exit(1) from e
+
+
+def _config_add_endpoint(settings: Settings) -> None:
+    """Interactively add a custom endpoint."""
+    ep = CustomEndpointSettings(
+        name=Prompt.ask("Endpoint name"),
+        base_url=Prompt.ask("Base URL"),
+        api_key=Prompt.ask("API key"),
+        model_name=Prompt.ask("Model name"),
+    )
+    settings.custom_endpoints.append(ep)
+    save_settings(settings)
+    console.print(f"[green]Added endpoint '{ep.name}'[/green]")
+
+
+# ---- history ----
+
+
+@app.command()
+def history(
+    task_id: str | None = typer.Argument(None, help="Task ID to view details"),
+    search: str | None = typer.Option(None, "--search", "-s", help="Search task descriptions"),
+    export_format: str | None = typer.Option(
+        None, "--export", "-e", help="Export format: json, markdown, csv"
+    ),
+):
+    """View task history."""
+    console.print("[bold]Task History[/bold]")
+
+    from agent_scout.config.settings import DEFAULT_CONFIG_DIR
+    from agent_scout.db.database import Database
+
+    db_path = Path(DEFAULT_CONFIG_DIR) / "agent_scout.db"
+
+    if not db_path.exists():
+        console.print("[dim]No task history yet. Run a task first![/dim]")
+        return
+
+    async def _show_history() -> None:
+        db = Database(str(db_path))
+        await db.connect()
+        try:
+            tasks = await db.list_tasks()
+
+            if search:
+                tasks = [t for t in tasks if search.lower() in t.description.lower()]
+
+            if task_id:
+                task = await db.get_task(task_id)
+                if task:
+                    _display_task_detail(task)
+                else:
+                    console.print(f"[red]Task '{task_id}' not found[/red]")
+                return
+
+            if not tasks:
+                console.print("[dim]No tasks found.[/dim]")
+                return
+
+            table = Table(title="Task History")
+            table.add_column("ID", style="cyan", max_width=12)
+            table.add_column("Description", max_width=50)
+            table.add_column("Status", style="bold")
+            table.add_column("Created")
+
+            for t in tasks[:50]:
+                status_color = {
+                    "completed": "green",
+                    "failed": "red",
+                    "executing": "yellow",
+                }.get(t.status.value, "white")
+
+                import time
+
+                created = time.strftime("%Y-%m-%d %H:%M", time.localtime(t.created_at))
+                table.add_row(
+                    t.id[:12],
+                    t.description[:50],
+                    f"[{status_color}]{t.status.value}[/{status_color}]",
+                    created,
+                )
+
+            console.print(table)
+        finally:
+            await db.disconnect()
+
+    asyncio.run(_show_history())
+
+
+def _display_task_detail(task) -> None:  # noqa: ANN001
+    """Display detailed task information."""
+    import time
+
+    created = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(task.created_at))
+    updated = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(task.updated_at))
+
+    console.print(
+        Panel(
+            f"[bold]ID:[/bold] {task.id}\n"
+            f"[bold]Description:[/bold] {task.description}\n"
+            f"[bold]Status:[/bold] {task.status.value}\n"
+            f"[bold]Created:[/bold] {created}\n"
+            f"[bold]Updated:[/bold] {updated}\n"
+            f"[bold]Result:[/bold] {task.result or '(none)'}\n"
+            f"[bold]Error:[/bold] {task.error or '(none)'}",
+            title="[bold]Task Detail[/bold]",
+        )
+    )
+
+
+# ---- schedule ----
+
+
+@app.command()
+def schedule(
+    action: str = typer.Argument("list", help="Action: list, add, remove"),
+    schedule_id: str | None = typer.Argument(None, help="Schedule ID (for remove)"),
+    task_desc: str | None = typer.Option(None, "--task", "-t", help="Task description"),
+    cron: str | None = typer.Option(None, "--cron", "-c", help="Cron expression"),
+):
+    """Manage scheduled tasks."""
+    if action == "list":
+        console.print("[bold]Scheduled Tasks[/bold]")
+        console.print("[dim]No scheduled tasks. Add one with:[/dim]")
+        console.print(
+            '[dim]agent-scout schedule add --task "Check prices" --cron "0 8 * * *"[/dim]'
+        )
+    elif action == "add":
+        if not task_desc or not cron:
+            console.print("[red]Usage: agent-scout schedule add --task '...' --cron '...'[/red]")
+            raise typer.Exit(1)
+        console.print(f"[green]Scheduled: '{task_desc}' with cron '{cron}'[/green]")
+        console.print("[yellow]Note: Scheduling persistence coming in Phase 7[/yellow]")
+    elif action == "remove":
+        if not schedule_id:
+            console.print("[red]Usage: agent-scout schedule remove <schedule-id>[/red]")
+            raise typer.Exit(1)
+        console.print(f"[green]Removed schedule '{schedule_id}'[/green]")
+    else:
+        console.print(f"[red]Unknown action: {action}[/red]")
+        raise typer.Exit(1)
+
+
+# ---- status ----
+
+
+@app.command()
+def status():
+    """Show agent status and cost summary."""
+    settings = _load_settings()
+
+    console.print(
+        Panel(
+            f"[bold]Model:[/bold] {settings.llm.default_model}\n"
+            f"[bold]Routing:[/bold] {'enabled' if settings.llm.enable_routing else 'disabled'}\n"
+            f"[bold]Autonomy:[/bold] {settings.autonomy}\n"
+            f"[bold]Budget:[/bold] ${settings.budget.task_limit}/task, "
+            f"${settings.budget.daily_limit}/day, "
+            f"${settings.budget.monthly_limit}/month\n"
+            f"[bold]Plugins:[/bold] {', '.join(settings.plugins)}",
+            title="[bold green]AgentScout Status[/bold green]",
+            border_style="green",
+        )
+    )
+
+
+# ---- version ----
+
+
+@app.command()
+def version():
+    """Show version information."""
+    console.print(f"[bold]AgentScout[/bold] CLI v{cli_version} | Core v{core_version}")
+
+
+if __name__ == "__main__":
+    app()

agent_scout_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: agent-scout-cli
+Version: 0.1.0
+Summary: CLI interface for AgentScout — your personal AI assistant agent
+Author: AgentScout Contributors
+License-Expression: AGPL-3.0-or-later
+Requires-Python: >=3.12
+Requires-Dist: agent-scout-core
+Requires-Dist: rich>=13
+Requires-Dist: typer>=0.24
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# agent-scout-cli
+
+CLI interface for AgentScout — your personal AI assistant agent.
+
+## Usage
+
+```bash
+agent-scout run "Find me the best flight from NYC to London on Feb 28"
+agent-scout setup
+agent-scout config show
+agent-scout history
+agent-scout schedule list
+agent-scout web
+```

agent_scout_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+agent_scout_cli/__init__.py,sha256=2rlDEZnw95ylM3JIK-INxpQJvyNjH-oFyYq0_uI7urs,87
+agent_scout_cli/main.py,sha256=ZY5vWRlwIKDa1wTeu1ZekXC08uGgCFDeWc3xYGoQlD8,15063
+agent_scout_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_scout_cli/commands/runner.py,sha256=qGLk8pLNy5WId4PnnwD6NG8PbaiJEcSLXnk4YtGGPQQ,8613
+agent_scout_cli/display/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_scout_cli/display/components.py,sha256=_AHH8Q5kmTu_pQvxdTbsRcrecRgSwCIq1fmAOoXL6I4,4939
+agent_scout_cli-0.1.0.dist-info/METADATA,sha256=nALbGjGIwX85_PydvOOD79aaCeprFtfhcnPThVenN9k,738
+agent_scout_cli-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+agent_scout_cli-0.1.0.dist-info/entry_points.txt,sha256=pij6m7OIa1ibq9o2Tnq1frz43k6Z5_cdWMp6uc6d1zo,57
+agent_scout_cli-0.1.0.dist-info/RECORD,,

agent_scout_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

agent_scout_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agent-scout = agent_scout_cli.main:app