ralph_workflow/cli/

providers.rs

//! Provider listing and information display.
//!
//! Contains functions for displaying `OpenCode` provider information.

use crate::agents::OpenCodeProviderType;
use crate::logger::Colors;

/// Provider category for display organization
#[derive(Debug, Clone, Copy)]
struct ProviderCategory {
    name: &'static str,
    providers: &'static [(OpenCodeProviderType, &'static str)],
}

/// Provider categories with their providers and example aliases
const PROVIDER_CATEGORIES: &[ProviderCategory] = &[
    ProviderCategory {
        name: "OPENCODE GATEWAY",
        providers: &[(OpenCodeProviderType::OpenCodeZen, "opencode-zen-glm")],
    },
    ProviderCategory {
        name: "CHINESE AI PROVIDERS",
        providers: &[
            (OpenCodeProviderType::ZaiDirect, "opencode-zai-glm"),
            (
                OpenCodeProviderType::ZaiCodingPlan,
                "opencode-zai-glm-codingplan",
            ),
            (OpenCodeProviderType::Moonshot, "opencode-moonshot"),
            (OpenCodeProviderType::MiniMax, "opencode-minimax"),
        ],
    },
    ProviderCategory {
        name: "MAJOR CLOUD PROVIDERS",
        providers: &[
            (OpenCodeProviderType::Anthropic, "opencode-direct-claude"),
            (OpenCodeProviderType::OpenAI, "opencode-openai"),
            (OpenCodeProviderType::Google, "opencode-google"),
            (OpenCodeProviderType::GoogleVertex, "opencode-vertex"),
            (OpenCodeProviderType::AmazonBedrock, "opencode-bedrock"),
            (OpenCodeProviderType::AzureOpenAI, "opencode-azure"),
            (OpenCodeProviderType::GithubCopilot, "opencode-copilot"),
        ],
    },
    ProviderCategory {
        name: "FAST INFERENCE PROVIDERS",
        providers: &[
            (OpenCodeProviderType::Groq, "opencode-groq"),
            (OpenCodeProviderType::Together, "opencode-together"),
            (OpenCodeProviderType::Fireworks, "opencode-fireworks"),
            (OpenCodeProviderType::Cerebras, "opencode-cerebras"),
            (OpenCodeProviderType::SambaNova, "opencode-sambanova"),
            (OpenCodeProviderType::DeepInfra, "opencode-deepinfra"),
        ],
    },
    ProviderCategory {
        name: "GATEWAY PROVIDERS",
        providers: &[
            (OpenCodeProviderType::OpenRouter, "opencode-openrouter"),
            (OpenCodeProviderType::Cloudflare, "opencode-cloudflare"),
        ],
    },
    ProviderCategory {
        name: "SPECIALIZED PROVIDERS",
        providers: &[
            (OpenCodeProviderType::DeepSeek, "opencode-deepseek"),
            (OpenCodeProviderType::Xai, "opencode-xai"),
            (OpenCodeProviderType::Mistral, "opencode-mistral"),
            (OpenCodeProviderType::Cohere, "opencode-cohere"),
            (OpenCodeProviderType::Perplexity, "opencode-perplexity"),
            (OpenCodeProviderType::AI21, "opencode-ai21"),
            (OpenCodeProviderType::VeniceAI, "opencode-venice"),
        ],
    },
    ProviderCategory {
        name: "OPEN-SOURCE MODEL PROVIDERS",
        providers: &[
            (OpenCodeProviderType::HuggingFace, "opencode-huggingface"),
            (OpenCodeProviderType::Replicate, "opencode-replicate"),
        ],
    },
    ProviderCategory {
        name: "CLOUD PLATFORM PROVIDERS",
        providers: &[
            (OpenCodeProviderType::Baseten, "opencode-baseten"),
            (OpenCodeProviderType::Cortecs, "opencode-cortecs"),
            (OpenCodeProviderType::Scaleway, "opencode-scaleway"),
            (OpenCodeProviderType::OVHcloud, "opencode-ovhcloud"),
            (OpenCodeProviderType::IONet, "opencode-ionet"),
            (OpenCodeProviderType::Nebius, "opencode-nebius"),
        ],
    },
    ProviderCategory {
        name: "AI GATEWAY PROVIDERS",
        providers: &[
            (OpenCodeProviderType::Vercel, "opencode-vercel"),
            (OpenCodeProviderType::Helicone, "opencode-helicone"),
            (OpenCodeProviderType::ZenMux, "opencode-zenmux"),
        ],
    },
    ProviderCategory {
        name: "ENTERPRISE PROVIDERS",
        providers: &[
            (OpenCodeProviderType::SapAICore, "opencode-sap"),
            (
                OpenCodeProviderType::AzureCognitiveServices,
                "opencode-azure-cognitive",
            ),
        ],
    },
    ProviderCategory {
        name: "LOCAL PROVIDERS",
        providers: &[
            (OpenCodeProviderType::Ollama, "opencode-ollama"),
            (OpenCodeProviderType::LMStudio, "opencode-lmstudio"),
            (OpenCodeProviderType::OllamaCloud, "opencode-ollama-cloud"),
            (OpenCodeProviderType::LlamaCpp, "opencode-llamacpp"),
        ],
    },
    ProviderCategory {
        name: "CUSTOM",
        providers: &[(OpenCodeProviderType::Custom, "(custom)")],
    },
];

/// Helper function to print provider information for --list-providers.
pub fn print_provider_info(colors: Colors, provider: OpenCodeProviderType, agent_alias: &str) {
    let examples = provider.example_models();
    let example_str = if examples.is_empty() {
        String::new()
    } else {
        format!(" (e.g., {})", examples[0])
    };

    println!("{}{}{}", colors.bold(), provider.name(), colors.reset());
    println!("  Prefix: {}{}", provider.prefix(), example_str);
    println!("  Auth: {}", provider.auth_command());
    println!("  Agent: {agent_alias}");
}

/// Print a provider category with all its providers
fn print_category(colors: Colors, category: &ProviderCategory) {
    println!(
        "{}═══ {} ═══{}",
        colors.bold(),
        category.name,
        colors.reset()
    );
    for (provider, alias) in category.providers {
        print_provider_info(colors, *provider, alias);
    }
    println!();
}

/// Print important notes about providers
fn print_notes(colors: Colors) {
    println!("{}═══ IMPORTANT NOTES ═══{}", colors.bold(), colors.reset());
    println!(
        "• OpenCode Zen (opencode/*) and Z.AI Direct (zai/* or zhipuai/*) are SEPARATE endpoints!"
    );
    println!("  - opencode/* routes through OpenCode's Zen gateway at opencode.ai");
    println!("  - zai/* or zhipuai/* connects directly to Z.AI's API at api.z.ai");
    println!("  - Z.AI Coding Plan is an auth tier; model prefix remains zai/* or zhipuai/*");
    println!("• Cloud providers (Vertex, Bedrock, Azure, SAP) require additional configuration");
    println!(
        "• Local providers (Ollama, LM Studio, llama.cpp) run on your hardware - no API key needed"
    );
    println!("• Use clear naming: opencode-zen-*, opencode-zai-*, opencode-direct-* aliases");
    println!();
}

/// Handle --list-providers command.
///
/// Displays a categorized list of all `OpenCode` provider types with their
/// model prefixes, authentication commands, and example agent aliases.
pub fn handle_list_providers(colors: Colors) {
    println!("{}OpenCode Provider Types{}", colors.bold(), colors.reset());
    println!();
    println!("Ralph includes built-in guidance for major OpenCode provider prefixes (plus a custom fallback).");
    println!("OpenCode may support additional providers; consult OpenCode docs for the full set.");
    println!();

    for category in PROVIDER_CATEGORIES {
        print_category(colors, category);
    }

    print_notes(colors);
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_provider_categories_count() {
        // Verify we have all expected categories
        assert_eq!(PROVIDER_CATEGORIES.len(), 12);
    }

    #[test]
    fn test_category_names() {
        let expected_names = &[
            "OPENCODE GATEWAY",
            "CHINESE AI PROVIDERS",
            "MAJOR CLOUD PROVIDERS",
            "FAST INFERENCE PROVIDERS",
            "GATEWAY PROVIDERS",
            "SPECIALIZED PROVIDERS",
            "OPEN-SOURCE MODEL PROVIDERS",
            "CLOUD PLATFORM PROVIDERS",
            "AI GATEWAY PROVIDERS",
            "ENTERPRISE PROVIDERS",
            "LOCAL PROVIDERS",
            "CUSTOM",
        ];
        let actual_names: Vec<_> = PROVIDER_CATEGORIES.iter().map(|c| c.name).collect();
        assert_eq!(actual_names, expected_names);
    }

    #[test]
    fn test_no_empty_categories() {
        for category in PROVIDER_CATEGORIES {
            assert!(
                !category.providers.is_empty(),
                "Category '{}' is empty",
                category.name
            );
        }
    }

    #[test]
    fn test_all_providers_have_aliases() {
        for category in PROVIDER_CATEGORIES {
            for (provider, alias) in category.providers {
                assert!(!alias.is_empty(), "Provider {provider:?} has empty alias");
            }
        }
    }
}