Continuous Learning GRPO - Cross-Platform Integration Plan¶

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Experience {
    id: String,
    text: String,
}

pub struct ExperienceManager {
    experiences: HashMap<String, String>,
    next_id: usize,
}

impl ExperienceManager {
    pub fn new() -> Self {
        Self {
            experiences: HashMap::new(),
            next_id: 0,
        }
    }

    pub fn add(&mut self, text: String) -> String {
        let id = format!("G{}", self.next_id);
        self.next_id += 1;
        self.experiences.insert(id.clone(), text);
        id
    }

    pub fn format_for_prompt(&self) -> String {
        let mut lines = Vec::new();
        for (id, text) in &self.experiences {
            lines.push(format!("[{}]. {}", id, text));
        }
        lines.join("\\n")
    }
}

// MCP tool definition
pub async fn register_grpo_tools(server: &mut McpServer) {
    server.add_tool(
        "grpo_generate",
        "Generate code with Continuous Learning GRPO",
        |params| async {
            // Implementation
        }
    );
}

mod experience;
mod semantic;
mod trainer;

pub use experience::ExperienceManager;
pub use semantic::SemanticExtractor;
pub use trainer::ContinuousLearningGRPO;

/// Core Continuous Learning GRPO implementation for hanzo-node
pub struct ContinuousLearningGRPO {
    experience_manager: ExperienceManager,
    semantic_extractor: SemanticExtractor,
}

impl ContinuousLearningGRPO {
    pub fn new(api_key: String) -> Self {
        Self {
            experience_manager: ExperienceManager::new(),
            semantic_extractor: SemanticExtractor::new(api_key),
        }
    }

    pub async fn generate_with_experiences(
        &self,
        query: &str,
    ) -> Result<String, Box<dyn std::error::Error>> {
        let experiences = self.experience_manager.format_for_prompt();

        // Call inference with experiences injected
        let prompt = format!(
            "Please solve: {}\\n\\nExperiences:\\n{}",
            query, experiences
        );

        self.semantic_extractor.generate(&prompt).await
    }
}

// In hanzo-node/src/inference/mod.rs

use hanzo_grpo::ContinuousLearningGRPO;

pub struct HanzoInference {
    grpo: Option<ContinuousLearningGRPO>,
    // ... existing fields
}

impl HanzoInference {
    pub fn with_grpo(mut self, api_key: String) -> Self {
        self.grpo = Some(ContinuousLearningGRPO::new(api_key));
        self
    }

    pub async fn infer_with_grpo(&self, query: &str) -> Result<String> {
        if let Some(grpo) = &self.grpo {
            grpo.generate_with_experiences(query).await
        } else {
            // Fall back to regular inference
            self.infer(query).await
        }
    }
}

use clap::{Parser, Subcommand};
use serde_json::json;
use reqwest;

#[derive(Parser)]
#[command(name = "grpo")]
#[command(about = "Continuous Learning GRPO CLI (Rust)", long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    Generate {
        query: String,

        #[arg(short, long)]
        experiences: Option<String>,
    },
}

#[tokio::main]
async fn main() {
    let cli = Cli::parse();

    match cli.command {
        Commands::Generate { query, experiences } => {
            generate_command(query, experiences).await;
        }
    }
}

async fn generate_command(query: String, _experiences: Option<String>) {
    let api_key = std::env::var("DEEPSEEK_API_KEY")
        .expect("DEEPSEEK_API_KEY not set");

    let client = reqwest::Client::new();

    let body = json!({
        "model": "deepseek-chat",
        "messages": [
            {"role": "user", "content": query}
        ],
        "temperature": 0.7
    });

    let response = client
        .post("https://api.deepseek.com/v1/chat/completions")
        .header("Authorization", format!("Bearer {}", api_key))
        .json(&body)
        .send()
        .await
        .expect("Failed to call API");

    let json: serde_json::Value = response.json().await.unwrap();
    let content = json["choices"][0]["message"]["content"]
        .as_str()
        .unwrap();

    println!("{}", content);
}