agent-scout-cli 0.1.0__tar.gz

agent_scout_cli-0.1.0/.gitignore

@@ -0,0 +1,81 @@
+# ===========================
+# Python
+# ===========================
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg-info/
+*.egg
+dist/
+build/
+.eggs/
+*.whl
+.venv/
+venv/
+.uv/
+.python-version
+
+# ===========================
+# Node.js / Next.js
+# ===========================
+node_modules/
+.next/
+out/
+.turbo/
+*.tsbuildinfo
+
+# ===========================
+# IDE / Editors
+# ===========================
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+Thumbs.db
+
+# ===========================
+# Environment / Secrets
+# ===========================
+.env
+.env.local
+.env.*.local
+!.env.example
+
+# ===========================
+# Database
+# ===========================
+*.db
+*.sqlite
+*.sqlite3
+
+# ===========================
+# Logs
+# ===========================
+*.log
+logs/
+
+# ===========================
+# Testing / Coverage
+# ===========================
+.coverage
+htmlcov/
+.pytest_cache/
+coverage/
+.nyc_output/
+
+# ===========================
+# OS
+# ===========================
+.DS_Store
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+
+# ===========================
+# Build artifacts
+# ===========================
+*.pyc
+*.pyo

agent_scout_cli-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,14 @@
+# 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/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "agent-scout-cli"
+version = "0.1.0"
+description = "CLI interface for AgentScout — your personal AI assistant agent"
+readme = "README.md"
+license = "AGPL-3.0-or-later"
+requires-python = ">=3.12"
+authors = [{ name = "AgentScout Contributors" }]
+
+dependencies = [
+    "agent-scout-core",
+    "typer>=0.24",
+    "rich>=13",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+    "ruff>=0.8",
+]
+
+[project.scripts]
+agent-scout = "agent_scout_cli.main:app"
+
+[tool.uv.sources]
+agent-scout-core = { path = "../core", editable = true }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/agent_scout_cli"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "N", "UP", "B", "A", "SIM"]

agent_scout_cli-0.1.0/src/agent_scout_cli/__init__.py

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

agent_scout_cli-0.1.0/src/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-0.1.0/src/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),
+    )