superqode 0.1.5__py3-none-any.whl

superqode/commands/agents.py

@@ -0,0 +1,180 @@
+"""
+Agent CLI commands for SuperQode.
+
+Commands for listing and showing ACP/External agents.
+"""
+
+import click
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from ..agents.registry import (
+    AGENTS,
+    AgentProtocol,
+    AgentStatus,
+    get_supported_agents,
+    get_acp_agents,
+    get_external_agents,
+)
+
+
+console = Console()
+
+
+@click.group()
+def agents():
+    """Manage coding agents (ACP mode)."""
+    pass
+
+
+@agents.command("list")
+@click.option(
+    "--protocol",
+    type=click.Choice(["acp", "external"]),
+    help="Filter by protocol",
+)
+@click.option(
+    "--supported",
+    is_flag=True,
+    help="Show only supported agents",
+)
+def list_agents(protocol: str, supported: bool):
+    """List available coding agents."""
+
+    # Filter agents
+    filtered = dict(AGENTS)
+
+    if protocol:
+        proto = AgentProtocol.ACP if protocol == "acp" else AgentProtocol.EXTERNAL
+        filtered = {k: v for k, v in filtered.items() if v.protocol == proto}
+
+    if supported:
+        filtered = {k: v for k, v in filtered.items() if v.status == AgentStatus.SUPPORTED}
+
+    # Build table
+    table = Table(title="Coding Agents", show_header=True, header_style="bold cyan")
+    table.add_column("Agent", style="white")
+    table.add_column("Name", style="white")
+    table.add_column("Protocol", style="dim")
+    table.add_column("Status", style="white")
+    table.add_column("Description", style="dim", max_width=40)
+
+    # Sort by status (supported first) then name
+    sorted_agents = sorted(filtered.items(), key=lambda x: (x[1].status.value, x[0]))
+
+    for agent_id, agent_def in sorted_agents:
+        status_map = {
+            AgentStatus.SUPPORTED: "[green]✅ Supported[/green]",
+            AgentStatus.COMING_SOON: "[yellow]🔜 Coming Soon[/yellow]",
+            AgentStatus.EXPERIMENTAL: "[blue]🧪 Experimental[/blue]",
+        }
+        status = status_map.get(agent_def.status, agent_def.status.value)
+
+        protocol_str = agent_def.protocol.value.upper()
+
+        table.add_row(
+            agent_id,
+            agent_def.name,
+            protocol_str,
+            status,
+            agent_def.description[:40] + "..."
+            if len(agent_def.description) > 40
+            else agent_def.description,
+        )
+
+    console.print(table)
+
+    # Summary
+    supported_count = sum(1 for v in filtered.values() if v.status == AgentStatus.SUPPORTED)
+    console.print(f"\n[dim]Total: {len(filtered)} agents, {supported_count} supported[/dim]")
+
+
+@agents.command("show")
+@click.argument("agent_id")
+def show_agent(agent_id: str):
+    """Show details for a specific agent."""
+
+    agent_def = AGENTS.get(agent_id)
+
+    if not agent_def:
+        console.print(f"[red]Error: Agent '{agent_id}' not found[/red]")
+        console.print("\nAvailable agents:")
+        for aid in sorted(AGENTS.keys()):
+            console.print(f"  • {aid}")
+        return
+
+    # Build info panel
+    status_map = {
+        AgentStatus.SUPPORTED: "[green]✅ Supported[/green]",
+        AgentStatus.COMING_SOON: "[yellow]🔜 Coming Soon[/yellow]",
+        AgentStatus.EXPERIMENTAL: "[blue]🧪 Experimental[/blue]",
+    }
+    status = status_map.get(agent_def.status, agent_def.status.value)
+
+    info_lines = [
+        f"[bold]Agent:[/bold] {agent_def.name}",
+        f"[bold]ID:[/bold] {agent_id}",
+        f"[bold]Protocol:[/bold] {agent_def.protocol.value.upper()}",
+        f"[bold]Status:[/bold] {status}",
+        f"[bold]Connection:[/bold] {agent_def.connection_type}",
+        "",
+        f"[bold]Description:[/bold]",
+        f"  {agent_def.description}",
+        "",
+    ]
+
+    # Capabilities
+    if agent_def.capabilities:
+        info_lines.append("[bold]Capabilities:[/bold]")
+        for cap in agent_def.capabilities:
+            info_lines.append(f"  • {cap}")
+        info_lines.append("")
+
+    # Auth info
+    info_lines.append("[bold]Authentication:[/bold]")
+    info_lines.append(f"  {agent_def.auth_info}")
+    info_lines.append("")
+
+    # Setup
+    info_lines.append("[bold]Setup:[/bold]")
+    info_lines.append(f"  {agent_def.setup_command}")
+    info_lines.append("")
+
+    # Command
+    if agent_def.command:
+        info_lines.append(f"[bold]Command:[/bold] {agent_def.command}")
+        info_lines.append("")
+
+    # Docs
+    info_lines.append(f"[bold]Documentation:[/bold] {agent_def.docs_url}")
+
+    panel = Panel(
+        "\n".join(info_lines),
+        title=f"Agent: {agent_def.name}",
+        border_style="cyan",
+    )
+    console.print(panel)
+
+    # Usage example
+    if agent_def.status == AgentStatus.SUPPORTED:
+        console.print("\n[bold]Usage in superqode.yaml:[/bold]")
+        console.print(f"""
+[dim]team:
+  dev:
+    roles:
+      my-role:
+        mode: "acp"
+        agent: "{agent_id}"
+        agent_config:
+          provider: "anthropic"
+          model: "claude-sonnet-4-20250514"
+        job_description: |
+          Your job description here...[/dim]
+""")
+
+
+# Register with main CLI
+def register_commands(cli):
+    """Register agent commands with the main CLI."""
+    cli.add_command(agents)

superqode/commands/auth.py

@@ -0,0 +1,278 @@
+"""
+Auth CLI commands for SuperQode.
+
+Commands for showing authentication information and security details.
+SuperQode NEVER stores API keys - this shows where keys are stored
+and who controls them.
+"""
+
+import os
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from ..providers.registry import PROVIDERS, ProviderCategory
+from ..agents.registry import AGENTS, AgentStatus
+
+
+console = Console()
+
+
+@click.group()
+def auth():
+    """Show authentication and security information."""
+    pass
+
+
+@auth.command("info")
+def auth_info():
+    """Show comprehensive auth information."""
+
+    # Header
+    console.print(
+        Panel(
+            "[bold]🔒 SECURITY PRINCIPLE:[/bold] SuperQode [bold red]NEVER[/bold red] stores your API keys.\n\n"
+            "All credentials are read from YOUR environment at runtime.\n"
+            "You control where and how your keys are stored.",
+            title="SuperQode Auth Information",
+            border_style="cyan",
+        )
+    )
+
+    console.print()
+
+    # BYOK Section
+    console.print("[bold cyan]═══ BYOK MODE (Direct LLM) ═══[/bold cyan]")
+    console.print()
+    console.print("Your API keys are read from YOUR environment variables:")
+    console.print()
+
+    # Build provider status table
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Provider", style="white")
+    table.add_column("Env Variable", style="dim")
+    table.add_column("Status", style="white")
+    table.add_column("Source", style="dim")
+
+    # Check common providers
+    priority_providers = [
+        "anthropic",
+        "openai",
+        "google",
+        "xai",
+        "deepseek",
+        "groq",
+        "openrouter",
+        "ollama",
+        "zhipu",
+        "alibaba",
+    ]
+
+    for provider_id in priority_providers:
+        provider_def = PROVIDERS.get(provider_id)
+        if not provider_def:
+            continue
+
+        # Check env vars
+        configured = False
+        configured_var = None
+
+        for env_var in provider_def.env_vars:
+            if os.environ.get(env_var):
+                configured = True
+                configured_var = env_var
+                break
+
+        if not provider_def.env_vars:
+            # Local provider
+            status = "[blue]🏠 Local[/blue]"
+            source = provider_def.default_base_url or "localhost"
+        elif configured:
+            status = "[green]✅ Set[/green]"
+            source = _detect_env_source(configured_var)
+        else:
+            status = "[red]❌ Not set[/red]"
+            source = "-"
+
+        env_var_display = provider_def.env_vars[0] if provider_def.env_vars else "(none)"
+
+        table.add_row(
+            provider_id,
+            env_var_display,
+            status,
+            source,
+        )
+
+    console.print(table)
+    console.print()
+    console.print("[dim]💡 Keys are read at runtime, never stored by SuperQode[/dim]")
+    console.print()
+
+    # ACP Section
+    console.print("[bold cyan]═══ ACP MODE (Coding Agents) ═══[/bold cyan]")
+    console.print()
+    console.print("Agent authentication is managed by each agent, not SuperQode:")
+    console.print()
+
+    # Build agent status table
+    agent_table = Table(show_header=True, header_style="bold")
+    agent_table.add_column("Agent", style="white")
+    agent_table.add_column("Auth Location", style="dim")
+    agent_table.add_column("Status", style="white")
+
+    for agent_id, agent_def in AGENTS.items():
+        if agent_def.status != AgentStatus.SUPPORTED:
+            continue
+
+        # Check if agent auth exists
+        auth_exists = _check_agent_auth(agent_id)
+        status = "[green]✅ Configured[/green]" if auth_exists else "[yellow]⚠️ Check agent[/yellow]"
+
+        agent_table.add_row(
+            agent_id,
+            agent_def.auth_info,
+            status,
+        )
+
+    console.print(agent_table)
+    console.print()
+    console.print("[dim]💡 Agent auth is managed by the agent itself, not SuperQode[/dim]")
+    console.print("[dim]💡 Run the agent directly to configure: e.g., 'opencode' → /connect[/dim]")
+    console.print()
+
+    # Data Flow Section
+    console.print("[bold cyan]═══ DATA FLOW ═══[/bold cyan]")
+    console.print()
+    console.print("[bold]BYOK:[/bold]  You → SuperQode → LiteLLM → Provider API")
+    console.print("[bold]ACP:[/bold]   You → SuperQode → Agent (e.g., opencode) → Provider API")
+    console.print()
+    console.print("[dim]SuperQode is a pass-through orchestrator. Your data goes directly[/dim]")
+    console.print("[dim]to the LLM provider or agent. We don't intercept or store anything.[/dim]")
+
+
+@auth.command("check")
+@click.argument("provider_or_agent")
+def auth_check(provider_or_agent: str):
+    """Check auth status for a specific provider or agent."""
+
+    # Check if it's a provider
+    provider_def = PROVIDERS.get(provider_or_agent)
+    if provider_def:
+        _check_provider_auth(provider_or_agent, provider_def)
+        return
+
+    # Check if it's an agent
+    agent_def = AGENTS.get(provider_or_agent)
+    if agent_def:
+        _check_agent_auth_detailed(provider_or_agent, agent_def)
+        return
+
+    console.print(f"[red]Error: '{provider_or_agent}' not found as provider or agent[/red]")
+    console.print(
+        "\nUse 'superqode providers list' or 'superqode agents list' to see available options."
+    )
+
+
+def _detect_env_source(env_var: str) -> str:
+    """Try to detect where an env var is set."""
+    # This is a best-effort detection
+    home = Path.home()
+
+    # Check common shell config files
+    shell_files = [
+        home / ".zshrc",
+        home / ".bashrc",
+        home / ".bash_profile",
+        home / ".profile",
+    ]
+
+    for shell_file in shell_files:
+        if shell_file.exists():
+            try:
+                content = shell_file.read_text()
+                if env_var in content:
+                    return f"~/{shell_file.name}"
+            except Exception:
+                pass
+
+    # Check .env file in current directory
+    env_file = Path.cwd() / ".env"
+    if env_file.exists():
+        try:
+            content = env_file.read_text()
+            if env_var in content:
+                return ".env"
+        except Exception:
+            pass
+
+    return "environment"
+
+
+def _check_agent_auth(agent_id: str) -> bool:
+    """Check if agent auth exists."""
+    if agent_id == "opencode":
+        auth_file = Path.home() / ".local" / "share" / "opencode" / "auth.json"
+        return auth_file.exists()
+    return False
+
+
+def _check_provider_auth(provider_id: str, provider_def):
+    """Check and display provider auth status."""
+    console.print(f"\n[bold]Provider: {provider_def.name}[/bold]")
+    console.print()
+
+    if not provider_def.env_vars:
+        console.print("[blue]🏠 Local provider - no API key required[/blue]")
+        if provider_def.default_base_url:
+            console.print(f"Default URL: {provider_def.default_base_url}")
+        return
+
+    configured = False
+    for env_var in provider_def.env_vars:
+        value = os.environ.get(env_var)
+        if value:
+            configured = True
+            # Mask the key
+            masked = value[:8] + "..." + value[-4:] if len(value) > 12 else "***"
+            source = _detect_env_source(env_var)
+            console.print(f"[green]✅ {env_var}[/green] = {masked}")
+            console.print(f"   Source: {source}")
+        else:
+            console.print(f"[red]❌ {env_var}[/red] = (not set)")
+
+    if not configured:
+        console.print()
+        console.print("[yellow]To configure:[/yellow]")
+        console.print(f'  export {provider_def.env_vars[0]}="your-api-key"')
+        console.print(f"\n  Get your key at: {provider_def.docs_url}")
+
+
+def _check_agent_auth_detailed(agent_id: str, agent_def):
+    """Check and display agent auth status."""
+    console.print(f"\n[bold]Agent: {agent_def.name}[/bold]")
+    console.print()
+
+    console.print(f"[bold]Auth managed by:[/bold] {agent_def.name} (not SuperQode)")
+    console.print(f"[bold]Auth location:[/bold] {agent_def.auth_info}")
+    console.print()
+
+    if agent_id == "opencode":
+        auth_file = Path.home() / ".local" / "share" / "opencode" / "auth.json"
+        if auth_file.exists():
+            console.print(f"[green]✅ Auth file exists:[/green] {auth_file}")
+        else:
+            console.print(f"[yellow]⚠️ Auth file not found:[/yellow] {auth_file}")
+            console.print()
+            console.print("[yellow]To configure:[/yellow]")
+            console.print(f"  {agent_def.setup_command}")
+    else:
+        console.print(f"[dim]Setup: {agent_def.setup_command}[/dim]")
+
+
+# Register with main CLI
+def register_commands(cli):
+    """Register auth commands with the main CLI."""
+    cli.add_command(auth)