superqode 0.1.5__py3-none-any.whl

superqode/commands/roles.py

@@ -0,0 +1,380 @@
+"""
+Roles CLI commands for SuperQode.
+
+Commands for listing and showing role execution details.
+"""
+
+import os
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+
+from ..config import load_config, load_enabled_modes, resolve_role
+from ..execution.resolver import ExecutionResolver
+from ..execution.modes import ExecutionMode, GatewayType
+from ..providers.registry import PROVIDERS
+from ..agents.registry import AGENTS, AgentStatus
+
+
+console = Console()
+
+
+@click.group()
+def roles():
+    """Manage team roles and their execution configuration."""
+    pass
+
+
+@roles.command("list")
+@click.option("--mode", "-m", help="Filter by mode (e.g., dev, qe, devops)")
+@click.option("--enabled-only", is_flag=True, help="Show only enabled roles")
+def list_roles(mode: Optional[str], enabled_only: bool):
+    """List all configured roles with their execution mode."""
+
+    config = load_config()
+    enabled_modes = load_enabled_modes(config)
+
+    if not enabled_modes:
+        console.print(
+            "[yellow]No roles configured. Run 'superqode init' to create default configuration.[/yellow]"
+        )
+        return
+
+    # Build table
+    table = Table(title="Team Roles", show_header=True, header_style="bold cyan")
+    table.add_column("Role", style="white")
+    table.add_column("Mode", style="dim")
+    table.add_column("Exec Mode", style="cyan")
+    table.add_column("Provider/Agent", style="green")
+    table.add_column("Model", style="dim")
+    table.add_column("Status", style="white")
+
+    for mode_name, mode_config in enabled_modes.items():
+        if mode and mode_name != mode:
+            continue
+
+        if mode_config.roles:
+            for role_name, role_config in mode_config.roles.items():
+                if enabled_only and not role_config.enabled:
+                    continue
+
+                # Determine execution mode display
+                exec_mode = role_config.execution_mode
+                if exec_mode == "acp":
+                    exec_display = "[blue]ACP[/blue]"
+                    # For ACP, show the agent (new field or legacy coding_agent)
+                    provider_agent = role_config.agent_id or role_config.coding_agent
+                    model = "(agent-managed)"
+                else:
+                    exec_display = "[green]BYOK[/green]"
+                    provider_agent = role_config.provider or "-"
+                    model = role_config.model or "-"
+
+                status = (
+                    "[green]✅ Enabled[/green]" if role_config.enabled else "[red]❌ Disabled[/red]"
+                )
+
+                table.add_row(
+                    f"{mode_name}.{role_name}",
+                    mode_name,
+                    exec_display,
+                    provider_agent,
+                    model,
+                    status,
+                )
+        elif mode_config.direct_role:
+            role_config = mode_config.direct_role
+            if enabled_only and not role_config.enabled:
+                continue
+
+            exec_mode = role_config.execution_mode
+            if exec_mode == "acp":
+                exec_display = "[blue]ACP[/blue]"
+                provider_agent = role_config.agent_id or role_config.coding_agent
+                model = "(agent-managed)"
+            else:
+                exec_display = "[green]BYOK[/green]"
+                provider_agent = role_config.provider or "-"
+                model = role_config.model or "-"
+
+            status = (
+                "[green]✅ Enabled[/green]" if role_config.enabled else "[red]❌ Disabled[/red]"
+            )
+
+            table.add_row(
+                mode_name,
+                mode_name,
+                exec_display,
+                provider_agent,
+                model,
+                status,
+            )
+
+    console.print(table)
+
+    # Legend
+    console.print()
+    console.print("[dim]Execution Modes:[/dim]")
+    console.print("  [green]BYOK[/green] = Bring Your Own Key (direct LLM API via gateway)")
+    console.print("  [blue]ACP[/blue]  = Agent Client Protocol (full coding agent)")
+
+
+@roles.command("info")
+@click.argument("role_path", metavar="MODE.ROLE")
+def role_info(role_path: str):
+    """Show detailed execution information for a role.
+
+    Examples:
+        superqode roles info dev.fullstack
+        superqode roles info qe.api_tester
+    """
+
+    # Parse role path
+    parts = role_path.split(".", 1)
+    mode_name = parts[0]
+    role_name = parts[1] if len(parts) > 1 else None
+
+    config = load_config()
+    resolved = resolve_role(mode_name, role_name, config)
+
+    if not resolved:
+        console.print(f"[red]Error: Role '{role_path}' not found or disabled[/red]")
+        console.print("\nUse 'superqode roles list' to see available roles.")
+        return
+
+    # Build info panel
+    info_lines = []
+
+    # Basic info
+    info_lines.append(f"[bold]Role:[/bold] {role_path}")
+    info_lines.append(f"[bold]Description:[/bold] {resolved.description}")
+    info_lines.append(f"[bold]Enabled:[/bold] {'Yes' if resolved.enabled else 'No'}")
+    info_lines.append("")
+
+    # Execution mode section
+    exec_mode = resolved.execution_mode
+
+    if exec_mode == "byok":
+        info_lines.append("[bold cyan]═══ BYOK MODE (Direct LLM) ═══[/bold cyan]")
+        info_lines.append("")
+        info_lines.append(f"[bold]Provider:[/bold] {resolved.provider or '(not set)'}")
+        info_lines.append(f"[bold]Model:[/bold] {resolved.model or '(not set)'}")
+        info_lines.append(f"[bold]Gateway:[/bold] LiteLLM")
+        info_lines.append("")
+
+        # Check provider status
+        if resolved.provider:
+            provider_def = PROVIDERS.get(resolved.provider)
+            if provider_def:
+                # Check env vars
+                configured = False
+                for env_var in provider_def.env_vars:
+                    if os.environ.get(env_var):
+                        configured = True
+                        break
+
+                if not provider_def.env_vars:
+                    configured = True  # Local provider
+
+                status = (
+                    "[green]✅ Configured[/green]" if configured else "[red]❌ Not configured[/red]"
+                )
+                info_lines.append(f"[bold]Provider Status:[/bold] {status}")
+
+                if provider_def.env_vars:
+                    info_lines.append(f"[bold]Required Env:[/bold] {provider_def.env_vars[0]}")
+
+                if not configured:
+                    info_lines.append("")
+                    info_lines.append(
+                        f'[yellow]To configure: export {provider_def.env_vars[0]}="your-key"[/yellow]'
+                    )
+                    info_lines.append(f"[yellow]Get key at: {provider_def.docs_url}[/yellow]")
+            else:
+                info_lines.append(
+                    f"[yellow]⚠️ Provider '{resolved.provider}' not in registry[/yellow]"
+                )
+
+        info_lines.append("")
+        info_lines.append("[bold]Capabilities:[/bold]")
+        info_lines.append("  • Chat completion")
+        info_lines.append("  • Streaming responses")
+        info_lines.append("  • Tool calling (if model supports)")
+        info_lines.append("")
+        info_lines.append("[bold]Limitations:[/bold]")
+        info_lines.append("  • No file editing")
+        info_lines.append("  • No shell commands")
+        info_lines.append("  • No MCP tools")
+
+    else:  # ACP mode
+        info_lines.append("[bold blue]═══ ACP MODE (Coding Agent) ═══[/bold blue]")
+        info_lines.append("")
+
+        agent_id = resolved.agent_id or resolved.coding_agent
+        info_lines.append(f"[bold]Agent:[/bold] {agent_id}")
+
+        # Check agent status
+        agent_def = AGENTS.get(agent_id)
+        if agent_def:
+            status_str = {
+                AgentStatus.SUPPORTED: "[green]✅ Supported[/green]",
+                AgentStatus.COMING_SOON: "[yellow]⏳ Coming Soon[/yellow]",
+                AgentStatus.EXPERIMENTAL: "[blue]🧪 Experimental[/blue]",
+            }.get(agent_def.status, "[dim]Unknown[/dim]")
+
+            info_lines.append(f"[bold]Agent Status:[/bold] {status_str}")
+            info_lines.append(f"[bold]Protocol:[/bold] {agent_def.protocol.value.upper()}")
+            info_lines.append(f"[bold]Auth:[/bold] {agent_def.auth_info}")
+            info_lines.append("")
+
+            # Show agent's LLM config (new style or legacy)
+            if resolved.agent_config:
+                info_lines.append("[bold]Agent LLM Config:[/bold]")
+                if resolved.agent_config.provider:
+                    info_lines.append(f"  Provider: {resolved.agent_config.provider}")
+                if resolved.agent_config.model:
+                    info_lines.append(f"  Model: {resolved.agent_config.model}")
+                info_lines.append("")
+            elif resolved.provider or resolved.model:
+                # Legacy: provider/model specified at role level for ACP agent
+                info_lines.append("[bold]Agent LLM Config (legacy):[/bold]")
+                if resolved.provider:
+                    info_lines.append(f"  Provider: {resolved.provider}")
+                if resolved.model:
+                    info_lines.append(f"  Model: {resolved.model}")
+                info_lines.append("")
+
+            info_lines.append("[bold]Capabilities:[/bold]")
+            for cap in agent_def.capabilities:
+                info_lines.append(f"  • {cap}")
+
+            if agent_def.status != AgentStatus.SUPPORTED:
+                info_lines.append("")
+                info_lines.append(f"[yellow]Setup: {agent_def.setup_command}[/yellow]")
+        else:
+            info_lines.append(f"[yellow]⚠️ Agent '{agent_id}' not in registry[/yellow]")
+
+    # MCP servers
+    if resolved.mcp_servers:
+        info_lines.append("")
+        info_lines.append("[bold]MCP Servers:[/bold]")
+        for server in resolved.mcp_servers:
+            info_lines.append(f"  • {server}")
+
+    # Job description
+    if resolved.job_description:
+        info_lines.append("")
+        info_lines.append("[bold]Job Description:[/bold]")
+        # Truncate long descriptions
+        desc = resolved.job_description.strip()
+        if len(desc) > 200:
+            desc = desc[:200] + "..."
+        info_lines.append(f"  {desc}")
+
+    # Auth info
+    info_lines.append("")
+    info_lines.append("[bold cyan]═══ SECURITY ═══[/bold cyan]")
+    info_lines.append("")
+    if exec_mode == "byok":
+        info_lines.append("🔒 API key read from YOUR environment variables")
+        info_lines.append("🔒 SuperQode NEVER stores your keys")
+        info_lines.append("🔒 Data flows: You → SuperQode → LiteLLM → Provider")
+    else:
+        info_lines.append("🔒 Auth managed by the agent (not SuperQode)")
+        info_lines.append("🔒 Agent stores its own credentials")
+        info_lines.append("🔒 Data flows: You → SuperQode → Agent → Provider")
+
+    panel = Panel(
+        "\n".join(info_lines),
+        title=f"Role: {role_path}",
+        border_style="cyan",
+    )
+    console.print(panel)
+
+
+@roles.command("check")
+@click.argument("role_path", metavar="MODE.ROLE")
+def role_check(role_path: str):
+    """Check if a role is ready to run (auth configured, etc.)."""
+
+    # Parse role path
+    parts = role_path.split(".", 1)
+    mode_name = parts[0]
+    role_name = parts[1] if len(parts) > 1 else None
+
+    config = load_config()
+    resolved = resolve_role(mode_name, role_name, config)
+
+    if not resolved:
+        console.print(f"[red]❌ Role '{role_path}' not found or disabled[/red]")
+        return
+
+    console.print(f"Checking role: {role_path}")
+    console.print()
+
+    issues = []
+    warnings = []
+
+    exec_mode = resolved.execution_mode
+
+    if exec_mode == "byok":
+        # Check provider
+        if not resolved.provider:
+            issues.append("No provider specified")
+        else:
+            provider_def = PROVIDERS.get(resolved.provider)
+            if not provider_def:
+                warnings.append(f"Provider '{resolved.provider}' not in registry (may still work)")
+            elif provider_def.env_vars:
+                configured = False
+                for env_var in provider_def.env_vars:
+                    if os.environ.get(env_var):
+                        configured = True
+                        break
+                if not configured:
+                    issues.append(f"API key not set. Set {provider_def.env_vars[0]}")
+
+        # Check model
+        if not resolved.model:
+            issues.append("No model specified")
+
+    else:  # ACP
+        agent_id = resolved.agent_id or resolved.coding_agent
+        agent_def = AGENTS.get(agent_id)
+
+        if not agent_def:
+            warnings.append(f"Agent '{agent_id}' not in registry")
+        elif agent_def.status != AgentStatus.SUPPORTED:
+            issues.append(
+                f"Agent '{agent_id}' is not yet supported (status: {agent_def.status.value})"
+            )
+
+    # Display results
+    if issues:
+        console.print("[red]❌ Issues found:[/red]")
+        for issue in issues:
+            console.print(f"  • {issue}")
+        console.print()
+
+    if warnings:
+        console.print("[yellow]⚠️ Warnings:[/yellow]")
+        for warning in warnings:
+            console.print(f"  • {warning}")
+        console.print()
+
+    if not issues and not warnings:
+        console.print("[green]✅ Role is ready to run![/green]")
+    elif not issues:
+        console.print("[green]✅ Role should work (with warnings)[/green]")
+    else:
+        console.print("[red]❌ Role has issues that need to be fixed[/red]")
+
+
+# Register with main CLI
+def register_commands(cli):
+    """Register roles commands with the main CLI."""
+    cli.add_command(roles)

superqode/commands/serve.py

@@ -0,0 +1,172 @@
+"""
+SuperQode Server Commands.
+
+Start various SuperQode servers:
+- LSP server for IDE integration
+- Web server for browser-based TUI
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich.console import Console
+
+from superqode.enterprise import require_enterprise
+
+console = Console()
+
+
+@click.group()
+def serve():
+    """Server commands for IDE and web integration."""
+    if not require_enterprise("Server integrations"):
+        raise SystemExit(1)
+
+
+@serve.command("lsp")
+@click.option(
+    "--transport",
+    "-t",
+    type=click.Choice(["stdio", "tcp"]),
+    default="stdio",
+    help="Transport mode: stdio (default) for editors, tcp for debugging",
+)
+@click.option("--port", "-p", default=9000, help="Port for TCP transport (default: 9000)")
+@click.option("--project", type=click.Path(exists=True), default=".", help="Project root directory")
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose logging")
+def serve_lsp(transport: str, port: int, project: str, verbose: bool):
+    """Start the LSP server for IDE integration.
+
+    The LSP server exposes QE findings as diagnostics in your IDE.
+    Supports VSCode, Neovim, and other LSP-compatible editors.
+
+    Examples:
+
+        superqode serve lsp                    # Start in stdio mode (for editors)
+
+        superqode serve lsp -t tcp -p 9000    # Start in TCP mode (for debugging)
+
+    VSCode Setup:
+        1. Install the SuperQode VSCode extension
+        2. The extension will automatically connect to the LSP server
+
+    Neovim Setup (with nvim-lspconfig):
+        require('lspconfig.configs').superqode = {
+            default_config = {
+                cmd = { 'superqode', 'serve', 'lsp' },
+                filetypes = { '*' },
+                root_dir = function(fname)
+                    return vim.fn.getcwd()
+                end,
+            },
+        }
+        require('lspconfig').superqode.setup{}
+    """
+    import logging
+
+    if verbose:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.INFO)
+
+    from superqode.server import start_lsp_server
+
+    project_root = Path(project).resolve()
+
+    if transport == "tcp":
+        console.print(f"[cyan]Starting SuperQode LSP server on port {port}[/cyan]")
+        console.print("[dim]Connect your editor to localhost:{port}[/dim]")
+    else:
+        # stdio mode - don't print to stdout as it interferes with LSP
+        import sys
+
+        sys.stderr.write("SuperQode LSP server starting (stdio mode)\n")
+
+    start_lsp_server(
+        project_root=project_root,
+        transport=transport,
+        port=port,
+    )
+
+
+@serve.command("web")
+@click.option("--port", "-p", default=8080, help="Port for web server (default: 8080)")
+@click.option("--host", "-h", default="127.0.0.1", help="Host to bind to (default: 127.0.0.1)")
+@click.option("--project", type=click.Path(exists=True), default=".", help="Project root directory")
+@click.option("--no-open", is_flag=True, help="Don't open browser automatically")
+def serve_web(port: int, host: str, project: str, no_open: bool):
+    """Start the web server for browser-based TUI.
+
+    Run SuperQode's TUI interface in your web browser.
+
+    Examples:
+
+        superqode serve web                  # Start on localhost:8080
+
+        superqode serve web -p 3000          # Use custom port
+
+        superqode serve web -h 0.0.0.0       # Allow external connections
+    """
+    from superqode.server import start_server, WebServerConfig
+
+    project_root = Path(project).resolve()
+
+    console.print(f"[cyan]Starting SuperQode web server on http://{host}:{port}[/cyan]")
+
+    config = WebServerConfig(
+        host=host,
+        port=port,
+        project_root=project_root,
+    )
+
+    start_server(config, open_browser=not no_open)
+
+
+@serve.command("status")
+@click.option("--project", type=click.Path(exists=True), default=".", help="Project root directory")
+def serve_status(project: str):
+    """Show status of running servers."""
+    import socket
+
+    project_root = Path(project).resolve()
+
+    console.print()
+    console.print("[bold]SuperQode Server Status[/bold]")
+    console.print()
+
+    # Check LSP TCP port
+    lsp_port = 9000
+    lsp_running = False
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        result = sock.connect_ex(("127.0.0.1", lsp_port))
+        lsp_running = result == 0
+        sock.close()
+    except Exception:
+        pass
+
+    if lsp_running:
+        console.print(f"[green]LSP Server:[/green] Running on port {lsp_port}")
+    else:
+        console.print(f"[dim]LSP Server:[/dim] Not running (stdio mode doesn't show here)")
+
+    # Check web server port
+    web_port = 8080
+    web_running = False
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        result = sock.connect_ex(("127.0.0.1", web_port))
+        web_running = result == 0
+        sock.close()
+    except Exception:
+        pass
+
+    if web_running:
+        console.print(f"[green]Web Server:[/green] Running on port {web_port}")
+    else:
+        console.print(f"[dim]Web Server:[/dim] Not running")
+
+    console.print()

superqode/commands/suggestions.py

@@ -0,0 +1,127 @@
+"""
+Suggestions command - Review verified fixes from QE sessions.
+
+This command allows users to:
+- List all verified fixes from QE sessions
+- View suggestion details and evidence
+"""
+
+from pathlib import Path
+import json
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from superqode.enterprise import require_enterprise
+
+
+@click.group()
+def suggestions():
+    """Review verified fixes from QE sessions."""
+    if not require_enterprise("QE suggestions"):
+        raise SystemExit(1)
+
+
+console = Console()
+
+
+def load_verified_fixes(project_root: Path) -> list:
+    """Load verified fixes from QIR files."""
+    fixes = []
+    qr_dir = project_root / ".superqode" / "qe-artifacts" / "reports"
+
+    if not qr_dir.exists():
+        return fixes
+
+    # Look for recent QIR files
+    json_files = list(qr_dir.glob("qr-*.json"))
+    if not json_files:
+        return fixes
+
+    # Load the most recent QIR
+    latest_qr = max(json_files, key=lambda f: f.stat().st_mtime)
+
+    try:
+        with open(latest_qr) as f:
+            qir_data = json.load(f)
+
+        # Extract findings with suggestions
+        findings = qir_data.get("findings", [])
+        for finding in findings:
+            if finding.get("suggested_fix"):
+                fixes.append(
+                    {
+                        "id": finding.get("id", "unknown"),
+                        "title": finding.get("title", ""),
+                        "severity": finding.get("severity", "info"),
+                        "suggested_fix": finding.get("suggested_fix", ""),
+                        "confidence": finding.get("confidence", 0.5),
+                        "is_improvement": finding.get("confidence", 0) > 0.7,
+                        "fix_verified": True,  # Assume verified if in QIR
+                    }
+                )
+
+    except Exception as e:
+        console.print(f"[red]Error loading QIR: {e}[/red]")
+
+    return fixes
+
+
+def get_artifacts_dir(project_root: Path) -> Path:
+    """Get the QE artifacts directory."""
+    return project_root / ".superqode" / "qe-artifacts"
+
+
+@suggestions.command("list")
+@click.argument("project_root", type=click.Path(exists=True), default=".")
+@click.option(
+    "--all", "-a", "show_all", is_flag=True, help="Show all suggestions, not just improvements"
+)
+def list_suggestions(project_root, show_all):
+    """List all verified fix suggestions from QE sessions."""
+
+    project_path = Path(project_root)
+    fixes = load_verified_fixes(project_path)
+
+    if not fixes:
+        console.print("[yellow]No verified fixes found.[/yellow]")
+        console.print(
+            "[dim]Run 'superqe run . --mode deep --allow-suggestions' to generate fix suggestions.[/dim]"
+        )
+        return
+
+    # Filter to improvements only by default
+    if not show_all:
+        fixes = [f for f in fixes if f.get("is_improvement", False)]
+
+    if not fixes:
+        console.print(
+            "[green]All suggestions have been processed or none passed verification.[/green]"
+        )
+        return
+
+    # Display table
+    table = Table(title="Verified Fix Suggestions", show_header=True, header_style="bold")
+    table.add_column("#", style="dim", width=3)
+    table.add_column("Finding", style="cyan")
+    table.add_column("Status", justify="center")
+    table.add_column("Confidence", justify="right")
+
+    for i, fix in enumerate(fixes, 1):
+        status = "✅ Verified" if fix.get("fix_verified") else "❌ Failed"
+        improvement = "⬆️" if fix.get("is_improvement") else "➖"
+
+        table.add_row(
+            str(i),
+            fix.get("finding_title", fix.get("title", "Unknown"))[:40],
+            f"{status} {improvement}",
+            f"{fix.get('fix_confidence', fix.get('confidence', 0)) * 100:.0f}%",
+        )
+
+    console.print(table)
+    console.print()
+    console.print(f"[dim]Total: {len(fixes)} verified fix suggestions[/dim]")
+    console.print(f"[dim]Use 'superqe logs' to see detailed agent work logs[/dim]")