10_file_saving/

10_file_saving.rs

//! Agent with File Saving Tool Example
//!
//! This example demonstrates how to create a custom tool that can save
//! content to files, allowing the agent to persist generated output.
//! Files are organized in a dedicated output directory.
//!
//! Run with: cargo run --example 10_file_saving --manifest-path ceylon/Cargo.toml

use ceylon_next::agent::Agent;
use ceylon_next::tasks::{OutputData, TaskRequest};
use ceylon_next::tools::ToolTrait;
use serde_json::{json, Value};
use std::fs;
use std::path::Path;

// Define a custom tool for saving content to files
struct FileSaverTool;

impl ToolTrait for FileSaverTool {
    fn name(&self) -> String {
        "file_saver".to_string()
    }

    fn description(&self) -> String {
        "A tool that saves content to a file. \
         Accepts 'filename' (path to save the file) and 'content' (text content to save). \
         Returns success status and the file path."
            .to_string()
    }

    fn input_schema(&self) -> Value {
        json!({
            "type": "object",
            "properties": {
                "filename": {
                    "type": "string",
                    "description": "The path where the file should be saved (e.g., 'output.txt', 'data/results.json')"
                },
                "content": {
                    "type": "string",
                    "description": "The text content to write to the file"
                }
            },
            "required": ["filename", "content"]
        })
    }

    fn execute(&self, input: Value) -> Value {
        let filename = input["filename"].as_str().unwrap_or("output.txt");
        let content = input["content"].as_str().unwrap_or("");

        // Create parent directories if they don't exist
        if let Some(parent) = Path::new(filename).parent() {
            if !parent.as_os_str().is_empty() {
                if let Err(e) = fs::create_dir_all(parent) {
                    return json!({
                        "success": false,
                        "filename": filename,
                        "error": format!("Failed to create directory: {}", e)
                    });
                }
            }
        }

        // Write content to file
        match fs::write(filename, content) {
            Ok(_) => json!({
                "success": true,
                "filename": filename,
                "bytes_written": content.len(),
                "message": format!("Successfully saved {} bytes to {}", content.len(), filename)
            }),
            Err(e) => json!({
                "success": false,
                "filename": filename,
                "error": format!("Failed to write file: {}", e)
            }),
        }
    }
}

#[tokio::main]
async fn main() {
    println!("🤖 Ceylon Agent - File Saving Example\n");

    // Define the output directory
    let output_dir = "test/web_project_output";

    // Create the output directory if it doesn't exist
    if let Err(e) = fs::create_dir_all(output_dir) {
        eprintln!("❌ Failed to create output directory: {}", e);
        return;
    }
    println!("📁 Output directory: {}/\n", output_dir);

    // Step 1: Create an agent
    let mut agent = Agent::new("ContentGenerator", "ollama::gemma3:latest");

    agent.with_system_prompt(
        &format!(
            "You are a helpful assistant that can generate content and save it to files. \
             When asked to create content, generate it and use the file_saver tool to save it. \
             \
             IMPORTANT: All files MUST be saved inside the '{}' directory. \
             For example, to save 'server.js', use '{}/server.js' as the filename. \
             For files in subdirectories, use '{}/src/app.js' format. \
             \
             Be clear about what you're creating and where you're saving it.",
            output_dir, output_dir, output_dir
        )
    );

    // Step 2: Register the file saver tool
    println!("🔧 Registering file saver tool...");
    agent.add_tool(FileSaverTool);
    println!("✓ Tool registered\n");

    // Step 3: Create a task that generates content and saves it
    let mut task = TaskRequest::new(
        &format!(
            "Create a simple web project with a file upload API. Save all files in the '{}' directory:\
             \n1. server.js - A Node.js Express server with POST /upload endpoint\
             \n2. package.json - Package configuration with dependencies\
             \n3. test.http - HTTP test file to test the upload endpoint\
             \n4. README.md - Instructions on how to install and run the server\
             \n\nMake sure ALL files are saved in the '{}' directory!",
            output_dir, output_dir
        )
    );
    task.with_name("Generate and Save Web Project")
        .with_description("Generate a complete web project with file upload API")
        .with_priority(7);

    // Step 4: Run the agent
    println!("📋 Task: {}\n", task.id());
    println!("🔄 Running agent...\n");

    let response = agent.run(task).await;

    // Step 5: Display the result
    match response.result() {
        OutputData::Text(answer) => {
            println!("\n📝 Agent Response:\n{}\n", answer);
        }
        _ => {
            println!("❌ Unexpected response type");
        }
    }

    // Step 6: Verify files were created
    println!("🔍 Checking created files in '{}/'\n", output_dir);

    let expected_files = vec![
        "server.js",
        "package.json",
        "test.http",
        "README.md"
    ];

    let mut created_count = 0;

    for file in &expected_files {
        let file_path = format!("{}/{}", output_dir, file);
        if Path::new(&file_path).exists() {
            created_count += 1;
            println!("✓ {} created successfully", file);

            if let Ok(content) = fs::read_to_string(&file_path) {
                let preview: String = content.chars().take(100).collect();
                println!("  Preview: {}", preview.replace('\n', " "));
            }
        } else {
            println!("⚠ {} not found", file);
        }
    }

    println!("\n📊 Summary: {}/{} expected files created", created_count, expected_files.len());

    // Show directory structure
    println!("\n📂 Directory structure:");
    if let Ok(entries) = fs::read_dir(output_dir) {
        for entry in entries.flatten() {
            let path = entry.path();
            if path.is_file() {
                if let Some(filename) = path.file_name() {
                    if let Ok(metadata) = entry.metadata() {
                        println!("  - {} ({} bytes)",
                                 filename.to_string_lossy(),
                                 metadata.len());
                    }
                }
            }
        }
    }

    println!("\n✅ Example completed successfully!");
    println!("📁 All files are in: {}/", output_dir);
}