ceylon_next/runner/

runner.rs

use anyhow::{Context, Result};
use crate::{
    agent::Agent,
    llm::LLMConfig,
    memory::{FileStore, InMemoryStore, Memory, SqliteStore, StorageFormat},
    tasks::{OutputData, TaskRequest},
};
use colored::Colorize;
use log::{debug, info};
use rustyline::{error::ReadlineError, DefaultEditor};
use std::path::Path;
use std::sync::Arc;

use super::config::CeylonConfig;

/// Agent runner that executes agents based on ceylon.toml configuration
pub struct AgentRunner {
    config: CeylonConfig,
    base_dir: std::path::PathBuf,
}

impl AgentRunner {
    /// Create a new AgentRunner from a configuration file
    pub fn new<P: AsRef<Path>>(config_path: P) -> Result<Self> {
        let config_path = config_path.as_ref();
        let config = CeylonConfig::load(config_path)
            .context("Failed to load Ceylon configuration")?;

        let base_dir = config_path
            .parent()
            .unwrap_or_else(|| Path::new("."))
            .to_path_buf();

        Ok(Self { config, base_dir })
    }

    /// Create a new AgentRunner from the current directory
    pub fn from_current_dir() -> Result<Self> {
        Self::new("./ceylon.toml")
    }

    /// Create a new AgentRunner from a specific directory
    pub fn from_dir<P: AsRef<Path>>(dir: P) -> Result<Self> {
        let config_path = dir.as_ref().join("ceylon.toml");
        Self::new(config_path)
    }

    /// Run the agent with a single prompt and exit
    pub async fn run(&mut self, prompt: &str) -> Result<()> {
        println!(
            "{}",
            format!("🤖 Initializing agent '{}'...", self.config.agent.name).cyan()
        );

        let mut agent = self.create_agent().await?;

        println!("{}", format!("📝 Processing: {}", prompt).yellow());
        println!();

        let task = TaskRequest::new(prompt);
        let response = agent.run(task).await;

        self.display_output(&response.result());

        println!();
        println!("{}", "✅ Done!".green());

        Ok(())
    }

    /// Run the agent in interactive mode
    pub async fn run_interactive(&mut self) -> Result<()> {
        println!(
            "{}",
            format!(
                "🤖 Starting interactive session with '{}'",
                self.config.agent.name
            )
            .cyan()
        );
        println!(
            "{}",
            format!("📦 Model: {}", self.config.agent.model).cyan()
        );
        println!();
        println!(
            "{}",
            "Type 'exit', 'quit', or press Ctrl+D to end the session".dimmed()
        );
        println!("{}", "Type 'clear' to clear conversation history".dimmed());
        println!();

        let mut agent = self.create_agent().await?;

        let mut rl = DefaultEditor::new().context("Failed to initialize readline")?;

        loop {
            let readline = rl.readline(&format!("{} ", "You:".green().bold()));
            match readline {
                Ok(line) => {
                    let input = line.trim();

                    if input.is_empty() {
                        continue;
                    }

                    // Handle special commands
                    match input.to_lowercase().as_str() {
                        "exit" | "quit" => {
                            println!("{}", "👋 Goodbye!".cyan());
                            break;
                        }
                        "clear" => {
                            println!("{}", "🗑️  Conversation history cleared".yellow());
                            agent = self.create_agent().await?;
                            continue;
                        }
                        _ => {}
                    }

                    rl.add_history_entry(input)
                        .context("Failed to add history entry")?;

                    // Process the input
                    print!(
                        "{}",
                        format!("{} ", format!("{}:", self.config.agent.name).cyan().bold())
                    );
                    let task = TaskRequest::new(input);
                    let response = agent.run(task).await;
                    self.display_output(&response.result());
                    println!();
                }
                Err(ReadlineError::Interrupted) => {
                    debug!("Received CTRL-C");
                    println!("{}", "👋 Goodbye!".cyan());
                    break;
                }
                Err(ReadlineError::Eof) => {
                    debug!("Received CTRL-D");
                    println!("{}", "👋 Goodbye!".cyan());
                    break;
                }
                Err(err) => {
                    return Err(err.into());
                }
            }
        }

        Ok(())
    }

    /// Create an agent based on the configuration
    async fn create_agent(&self) -> Result<Agent> {
        debug!("Creating agent with model: {}", self.config.agent.model);

        // Create LLM config
        let mut llm_config = LLMConfig::new(&self.config.agent.model);

        if let Some(temp) = self.config.agent.temperature {
            llm_config = llm_config.with_temperature(temp);
        }

        if let Some(tokens) = self.config.agent.max_tokens {
            llm_config = llm_config.with_max_tokens(tokens);
        }

        // Create agent
        let mut agent = Agent::new_with_config(&self.config.agent.name, llm_config)
            .map_err(|e| anyhow::anyhow!("Failed to create agent: {}", e))?;

        // Set system prompt if configured
        if let Some(prompt) = self.config.read_system_prompt(&self.base_dir)? {
            agent.with_system_prompt(&prompt);
        }

        // Configure memory backend
        let memory_backend = self.create_memory_backend().await?;
        agent.with_memory(memory_backend);

        // Configure agent settings
        let mut agent_config = crate::agent::AgentConfig::default();
        if self.config.agent.analyze_goals {
            agent_config.with_goal_analysis(true);
        }
        agent.with_config(agent_config);

        info!("Agent '{}' created successfully", self.config.agent.name);
        Ok(agent)
    }

    /// Create memory backend based on configuration
    async fn create_memory_backend(&self) -> Result<Arc<dyn Memory>> {
        let backend: Arc<dyn Memory> = match self.config.memory.backend.as_str() {
            "in-memory" => {
                debug!("Using in-memory storage");
                Arc::new(InMemoryStore::new())
            }
            "file" => {
                let path = self
                    .config
                    .memory_path(&self.base_dir)
                    .context("Memory path required for file backend")?;

                debug!("Using file storage at: {:?}", path);

                // Create parent directory if it doesn't exist
                if let Some(parent) = path.parent() {
                    std::fs::create_dir_all(parent)
                        .context("Failed to create memory directory")?;
                }

                Arc::new(
                    FileStore::new(
                        path.to_str().context("Invalid memory path")?,
                        StorageFormat::Json,
                    )
                    .await
                    .map_err(|e| anyhow::anyhow!("Failed to create file memory: {}", e))?,
                )
            }
            "sqlite" => {
                let path = self
                    .config
                    .memory_path(&self.base_dir)
                    .context("Memory path required for sqlite backend")?;

                debug!("Using SQLite storage at: {:?}", path);

                // Create parent directory if it doesn't exist
                if let Some(parent) = path.parent() {
                    std::fs::create_dir_all(parent)
                        .context("Failed to create memory directory")?;
                }

                Arc::new(
                    SqliteStore::new(path.to_str().context("Invalid memory path")?)
                        .await
                        .map_err(|e| anyhow::anyhow!("Failed to create SQLite memory: {}", e))?,
                )
            }
            backend => {
                anyhow::bail!("Unknown memory backend: {}", backend);
            }
        };

        Ok(backend)
    }

    /// Display output based on its type
    fn display_output(&self, output: &OutputData) {
        match output {
            OutputData::Text(text) => {
                println!("{}", text);
            }
            OutputData::File(_) => {
                println!("{}", "📁 Received file data".blue().bold());
            }
            OutputData::Image(_) => {
                println!("{}", "🖼️  Received image data".magenta().bold());
            }
            OutputData::Audio(_) => {
                println!("{}", "🔊 Received audio data".cyan().bold());
            }
            OutputData::Video(_) => {
                println!("{}", "🎬 Received video data".purple().bold());
            }
            OutputData::Raw(_) => {
                println!("{}", "📦 Received raw binary data".dimmed());
            }
        }
    }

    /// Get the configuration
    pub fn config(&self) -> &CeylonConfig {
        &self.config
    }
}