dynamic_grounding_for_github_copilot 0.1.0

//! Example: Using the Gemini client directly
//!
//! This example shows how to use the Gemini API client as a library
//! in your own Rust projects.

use dynamic_grounding_for_github_copilot::*;
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Create a quota tracker
    let quota_tracker = Arc::new(QuotaTracker::new());

    // Create an API key provider (you'll need to implement this)
    struct SimpleKeyProvider {
        key: String,
    }

    #[async_trait::async_trait]
    impl api_key::ApiKeyProvider for SimpleKeyProvider {
        async fn get_key(&self) -> error::Result<api_key::SecureString> {
            Ok(api_key::SecureString::new(self.key.clone()))
        }
    }

    let api_key_provider = Arc::new(SimpleKeyProvider {
        key: std::env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set"),
    });

    // Create the Gemini client
    let client = GeminiClient::new(api_key_provider, quota_tracker.clone());

    // Example 1: Ask a simple question
    println!("Example 1: Simple code question");
    let answer = client
        .ask_about_code(
            "fn add(a: i32, b: i32) -> i32 { a + b }",
            "What does this function do?",
        )
        .await?;
    println!("Answer: {}", answer.text);
    println!("Quota: {}\n", answer.quota_status.format_message());

    // Example 2: Search codebase
    println!("Example 2: Codebase search");
    let files = vec![
        gemini::FileContent {
            path: "src/main.rs".to_string(),
            content: "fn main() { println!(\"Hello\"); }".to_string(),
        },
        gemini::FileContent {
            path: "src/lib.rs".to_string(),
            content: "pub fn greet(name: &str) { println!(\"Hello, {}!\", name); }".to_string(),
        },
    ];

    let search_results = client
        .search_codebase("Find functions that print to stdout", &files)
        .await?;
    println!("Search results: {}", search_results.text);
    println!("Quota: {}\n", search_results.quota_status.format_message());

    // Example 3: Analyze file relationships
    println!("Example 3: File analysis");
    let analysis = client
        .analyze_files(&files, "How does main.rs use lib.rs?")
        .await?;
    println!("Analysis: {}", analysis.text);
    println!("Quota: {}\n", analysis.quota_status.format_message());

    // Example 4: Summarize directory
    println!("Example 4: Directory summary");
    let summary = client
        .summarize_directory(
            "src/\n  main.rs\n  lib.rs\n  utils/\n    helpers.rs",
            &files,
        )
        .await?;
    println!("Summary: {}", summary.text);
    println!("Quota: {}", summary.quota_status.format_message());

    // Check final quota status
    let status = quota_tracker.get_status();
    println!("\nFinal quota status:");
    println!("  RPM: {:.1}% used", status.rpm_usage);
    println!("  RPD: {:.1}% used", status.rpd_usage);
    println!("  TPM: {:.1}% used", status.tpm_usage);

    Ok(())
}