Struct CodeAgent 

pub struct CodeAgent { /* private fields */ }

CodeAgent: A specialized agent for code analysis and development tasks This agent is built on top of the TemplateAgent and provides code-specific functionality

Implementations

impl CodeAgent

pub async fn new(_config: Config) -> Result<Self, KowalskiError>

Creates a new CodeAgent with the specified configuration

Examples found in repository

examples/java_analysis.rs (line 17)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::init();

    // Load configuration
    let config = Config::default();
    let mut code_agent = CodeAgent::new(config).await?;

    // Start a conversation
    println!("☕ Starting Java Code Analysis...");
    let conversation_id = code_agent.start_conversation("llama3.2");
    println!("Code Agent Conversation ID: {}", conversation_id);

    // Set up the role for code analysis
    let role = Role::new(
        "Java Code Analysis Assistant",
        "You are an expert at analyzing Java code, providing insights on code quality, best practices, and potential improvements.",
    )
    .with_audience(Audience::new(
        "Java Developer",
        "You are speaking to a Java developer who needs detailed code analysis.",
    ))
    .with_preset(Preset::new(
        "Analysis",
        "Provide comprehensive analysis with specific recommendations for improvement.",
    ));

    // Sample Java code for analysis
    let java_code = r#"
import java.util.*;

public class Calculator {
    private int result;
    
    public Calculator() {
        this.result = 0;
    }
    
    public int add(int a, int b) {
        result = a + b;
        return result;
    }
    
    public int subtract(int a, int b) {
        result = a - b;
        return result;
    }
    
    public int multiply(int a, int b) {
        result = a * b;
        return result;
    }
    
    public double divide(int a, int b) {
        if (b == 0) {
            System.out.println("Error: Division by zero");
            return 0;
        }
        result = a / b;
        return (double) result;
    }
    
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println("Addition: " + calc.add(10, 5));
        System.out.println("Subtraction: " + calc.subtract(10, 5));
        System.out.println("Multiplication: " + calc.multiply(10, 5));
        System.out.println("Division: " + calc.divide(10, 5));
    }
}
"#;

    println!("\n📝 Java Code to Analyze:");
    println!("{}", java_code);

    // Analyze the Java code
    let analysis_result = code_agent.analyze_java(java_code).await?;

    println!("\n📊 Java Analysis Results:");
    println!("Language: {}", analysis_result.language);
    println!(
        "Metrics: {}",
        serde_json::to_string_pretty(&analysis_result.metrics)?
    );
    println!("Suggestions: {:?}", analysis_result.suggestions);
    println!("Issues: {:?}", analysis_result.issues);

    // Ask the agent to analyze the code
    let analysis_prompt = format!(
        "Please analyze this Java code and provide insights:\n\n{}\n\nAnalysis results:\nMetrics: {}\nSuggestions: {:?}\nIssues: {:?}",
        java_code,
        serde_json::to_string_pretty(&analysis_result.metrics)?,
        analysis_result.suggestions,
        analysis_result.issues
    );

    let mut response = code_agent
        .chat_with_history(&conversation_id, &analysis_prompt, Some(role))
        .await?;

    println!("\n🤖 AI Analysis:");

    // Process the streaming response
    let mut buffer = String::new();
    while let Some(chunk) = response.chunk().await? {
        match code_agent
            .process_stream_response(&conversation_id, &chunk)
            .await
        {
            Ok(Some(message)) => {
                // Print the content if it exists
                if !message.content.is_empty() {
                    print!("{}", message.content);
                    io::stdout().flush()?;
                    buffer.push_str(&message.content);
                }

                // Handle tool calls if they exist
                if let Some(tool_calls) = &message.tool_calls {
                    for tool_call in tool_calls {
                        print!("\n[Tool Call] {}(", tool_call.function.name);
                        if let Some(obj) = tool_call.function.arguments.as_object() {
                            for (key, value) in obj {
                                print!("{}: {}, ", key, value);
                            }
                        }
                        println!(")");
                        io::stdout().flush()?;
                    }
                }
            }
            Ok(None) => {
                code_agent
                    .add_message(&conversation_id, "assistant", &buffer)
                    .await;
                println!("\n✅ Analysis complete!\n");
                break;
            }
            Err(e) => {
                eprintln!("\n❌ Error processing stream: {}", e);
                break;
            }
        }
    }

    // Ask a follow-up question about specific improvements
    let follow_up = "What specific improvements would you recommend for this Java code?";
    let mut follow_up_response = code_agent
        .chat_with_history(&conversation_id, follow_up, None)
        .await?;

    println!("\n🔍 Follow-up Analysis:");
    let mut buffer = String::new();
    while let Some(chunk) = follow_up_response.chunk().await? {
        match code_agent
            .process_stream_response(&conversation_id, &chunk)
            .await
        {
            Ok(Some(message)) => {
                // Print the content if it exists
                if !message.content.is_empty() {
                    print!("{}", message.content);
                    io::stdout().flush()?;
                    buffer.push_str(&message.content);
                }

                // Handle tool calls if they exist
                if let Some(tool_calls) = &message.tool_calls {
                    for tool_call in tool_calls {
                        print!("\n[Tool Call] {}(", tool_call.function.name);
                        if let Some(obj) = tool_call.function.arguments.as_object() {
                            for (key, value) in obj {
                                print!("{}: {}, ", key, value);
                            }
                        }
                        println!(")");
                        io::stdout().flush()?;
                    }
                }
            }
            Ok(None) => {
                code_agent
                    .add_message(&conversation_id, "assistant", &buffer)
                    .await;
                println!("\n");
                break;
            }
            Err(e) => {
                eprintln!("\n❌ Error processing stream: {}", e);
                break;
            }
        }
    }

    Ok(())
}

examples/python_analysis.rs (line 17)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::init();

    // Load configuration
    let config = Config::default();
    let mut code_agent = CodeAgent::new(config).await?;

    // Start a conversation
    println!("🐍 Starting Python Code Analysis...");
    let conversation_id = code_agent.start_conversation("llama3.2");
    println!("Code Agent Conversation ID: {}", conversation_id);

    // Set up the role for code analysis
    let role = Role::new(
        "Python Code Analysis Assistant",
        "You are an expert at analyzing Python code, providing insights on code quality, PEP 8 compliance, and potential improvements.",
    )
    .with_audience(Audience::new(
        "Python Developer",
        "You are speaking to a Python developer who needs detailed code analysis.",
    ))
    .with_preset(Preset::new(
        "Analysis",
        "Provide comprehensive analysis with specific recommendations for improvement.",
    ));

    // Sample Python code for analysis
    let python_code = r#"
import os
import sys
from typing import List, Optional

class DataProcessor:
    def __init__(self, data: List[int]):
        self.data = data
        self.result = 0
    
    def calculate_sum(self) -> int:
        """Calculate the sum of all data points."""
        total = 0
        for item in self.data:
            total += item
        return total
    
    def calculate_average(self) -> float:
        """Calculate the average of all data points."""
        if len(self.data) == 0:
            print("Error: No data to calculate average")
            return 0.0
        return self.calculate_sum() / len(self.data)
    
    def find_max(self) -> Optional[int]:
        """Find the maximum value in the data."""
        if not self.data:
            return None
        max_val = self.data[0]
        for item in self.data:
            if item > max_val:
                max_val = item
        return max_val

def main():
    # Sample data
    numbers = [10, 20, 30, 40, 50]
    
    # Create processor
    processor = DataProcessor(numbers)
    
    # Calculate statistics
    print(f"Sum: {processor.calculate_sum()}")
    print(f"Average: {processor.calculate_average()}")
    print(f"Maximum: {processor.find_max()}")
    
    # Process empty data
    empty_processor = DataProcessor([])
    print(f"Empty average: {empty_processor.calculate_average()}")

if __name__ == "__main__":
    main()
"#;

    println!("\n📝 Python Code to Analyze:");
    println!("{}", python_code);

    // Analyze the Python code
    let analysis_result = code_agent.analyze_python(python_code).await?;

    println!("\n📊 Python Analysis Results:");
    println!("Language: {}", analysis_result.language);
    println!(
        "Metrics: {}",
        serde_json::to_string_pretty(&analysis_result.metrics)?
    );
    println!("Suggestions: {:?}", analysis_result.suggestions);
    println!("PEP 8 Issues: {:?}", analysis_result.issues);

    // Ask the agent to analyze the code
    let analysis_prompt = format!(
        "Please analyze this Python code and provide insights:\n\n{}\n\nAnalysis results:\nMetrics: {}\nSuggestions: {:?}\nPEP 8 Issues: {:?}",
        python_code,
        serde_json::to_string_pretty(&analysis_result.metrics)?,
        analysis_result.suggestions,
        analysis_result.issues
    );

    let mut response = code_agent
        .chat_with_history(&conversation_id, &analysis_prompt, Some(role))
        .await?;

    println!("\n🤖 AI Analysis:");

    // Process the streaming response
    let mut buffer = String::new();
    while let Some(chunk) = response.chunk().await? {
        match code_agent
            .process_stream_response(&conversation_id, &chunk)
            .await
        {
            Ok(Some(message)) => {
                // Print the content if it exists
                if !message.content.is_empty() {
                    print!("{}", message.content);
                    io::stdout().flush()?;
                    buffer.push_str(&message.content);
                }

                // Handle tool calls if they exist
                if let Some(tool_calls) = &message.tool_calls {
                    for tool_call in tool_calls {
                        print!("\n[Tool Call] {}(", tool_call.function.name);
                        if let Some(obj) = tool_call.function.arguments.as_object() {
                            for (key, value) in obj {
                                print!("{}: {}, ", key, value);
                            }
                        }
                        println!(")");
                        io::stdout().flush()?;
                    }
                }
            }
            Ok(None) => {
                code_agent
                    .add_message(&conversation_id, "assistant", &buffer)
                    .await;
                println!("\n✅ Analysis complete!\n");
                break;
            }
            Err(e) => {
                eprintln!("\n❌ Error processing stream: {}", e);
                break;
            }
        }
    }

    // Ask a follow-up question about PEP 8 compliance
    let follow_up = "How can this Python code be improved to better follow PEP 8 guidelines?";
    let mut follow_up_response = code_agent
        .chat_with_history(&conversation_id, follow_up, None)
        .await?;

    println!("\n🔍 Follow-up Analysis:");
    let mut buffer = String::new();
    while let Some(chunk) = follow_up_response.chunk().await? {
        match code_agent
            .process_stream_response(&conversation_id, &chunk)
            .await
        {
            Ok(Some(message)) => {
                // Print the content if it exists
                if !message.content.is_empty() {
                    print!("{}", message.content);
                    io::stdout().flush()?;
                    buffer.push_str(&message.content);
                }

                // Handle tool calls if they exist
                if let Some(tool_calls) = &message.tool_calls {
                    for tool_call in tool_calls {
                        print!("\n[Tool Call] {}(", tool_call.function.name);
                        if let Some(obj) = tool_call.function.arguments.as_object() {
                            for (key, value) in obj {
                                print!("{}: {}, ", key, value);
                            }
                        }
                        println!(")");
                        io::stdout().flush()?;
                    }
                }
            }
            Ok(None) => {
                code_agent
                    .add_message(&conversation_id, "assistant", &buffer)
                    .await;
                println!("\n");
                break;
            }
            Err(e) => {
                eprintln!("\n❌ Error processing stream: {}", e);
                break;
            }
        }
    }

    Ok(())
}

examples/rust_analysis.rs (line 17)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::init();

    // Load configuration
    let config = Config::default();
    let mut code_agent = CodeAgent::new(config).await?;

    // Start a conversation
    println!("🦀 Starting Rust Code Analysis...");
    let conversation_id = code_agent.start_conversation("llama3.2");
    println!("Code Agent Conversation ID: {}", conversation_id);

    // Set up the role for code analysis
    let role = Role::new(
        "Rust Code Analysis Assistant",
        "You are an expert at analyzing Rust code, providing insights on code quality, safety, and potential improvements.",
    )
    .with_audience(Audience::new(
        "Rust Developer",
        "You are speaking to a Rust developer who needs detailed code analysis.",
    ))
    .with_preset(Preset::new(
        "Analysis",
        "Provide comprehensive analysis with specific recommendations for improvement.",
    ));

    // Sample Rust code for analysis
    let rust_code = r#"
use std::collections::HashMap;
use std::error::Error;

#[derive(Debug)]
struct DataProcessor {
    data: Vec<i32>,
    cache: HashMap<String, i32>,
}

impl DataProcessor {
    fn new(data: Vec<i32>) -> Self {
        Self {
            data,
            cache: HashMap::new(),
        }
    }
    
    fn calculate_sum(&self) -> i32 {
        self.data.iter().sum()
    }
    
    fn calculate_average(&self) -> Option<f64> {
        if self.data.is_empty() {
            None
        } else {
            Some(self.calculate_sum() as f64 / self.data.len() as f64)
        }
    }
    
    fn find_max(&self) -> Option<&i32> {
        self.data.iter().max()
    }
    
    fn process_with_cache(&mut self, key: String) -> Result<i32, Box<dyn Error>> {
        if let Some(&cached_value) = self.cache.get(&key) {
            return Ok(cached_value);
        }
        
        let result = self.calculate_sum();
        self.cache.insert(key, result);
        Ok(result)
    }
}

fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    let mut processor = DataProcessor::new(numbers);
    
    println!("Sum: {}", processor.calculate_sum());
    
    match processor.calculate_average() {
        Some(avg) => println!("Average: {}", avg),
        None => println!("No data to calculate average"),
    }
    
    match processor.find_max() {
        Some(max) => println!("Maximum: {}", max),
        None => println!("No data to find maximum"),
    }
    
    match processor.process_with_cache("sum".to_string()) {
        Ok(result) => println!("Cached result: {}", result),
        Err(e) => println!("Error: {}", e),
    }
}
"#;

    println!("\n📝 Rust Code to Analyze:");
    println!("{}", rust_code);

    // Analyze the Rust code
    let analysis_result = code_agent.analyze_rust(rust_code).await?;

    println!("\n📊 Rust Analysis Results:");
    println!("Language: {}", analysis_result.language);
    println!(
        "Metrics: {}",
        serde_json::to_string_pretty(&analysis_result.metrics)?
    );
    println!("Suggestions: {:?}", analysis_result.suggestions);
    println!("Rust Issues: {:?}", analysis_result.issues);

    // Ask the agent to analyze the code
    let analysis_prompt = format!(
        "Please analyze this Rust code and provide insights:\n\n{}\n\nAnalysis results:\nMetrics: {}\nSuggestions: {:?}\nRust Issues: {:?}",
        rust_code,
        serde_json::to_string_pretty(&analysis_result.metrics)?,
        analysis_result.suggestions,
        analysis_result.issues
    );

    let mut response = code_agent
        .chat_with_history(&conversation_id, &analysis_prompt, Some(role))
        .await?;

    println!("\n🤖 AI Analysis:");

    // Process the streaming response
    let mut buffer = String::new();
    while let Some(chunk) = response.chunk().await? {
        match code_agent
            .process_stream_response(&conversation_id, &chunk)
            .await
        {
            Ok(Some(message)) => {
                // Print the content if it exists
                if !message.content.is_empty() {
                    print!("{}", message.content);
                    io::stdout().flush()?;
                    buffer.push_str(&message.content);
                }

                // Handle tool calls if they exist
                if let Some(tool_calls) = &message.tool_calls {
                    for tool_call in tool_calls {
                        print!("\n[Tool Call] {}(", tool_call.function.name);
                        if let Some(obj) = tool_call.function.arguments.as_object() {
                            for (key, value) in obj {
                                print!("{}: {}, ", key, value);
                            }
                        }
                        println!(")");
                        io::stdout().flush()?;
                    }
                }
            }
            Ok(None) => {
                code_agent
                    .add_message(&conversation_id, "assistant", &buffer)
                    .await;
                println!("\n✅ Analysis complete!\n");
                break;
            }
            Err(e) => {
                eprintln!("\n❌ Error processing stream: {}", e);
                break;
            }
        }
    }

    // Ask a follow-up question about Rust-specific improvements
    let follow_up = "What Rust-specific improvements would you recommend for this code?";
    let mut follow_up_response = code_agent
        .chat_with_history(&conversation_id, follow_up, None)
        .await?;

    println!("\n🔍 Follow-up Analysis:");
    let mut buffer = String::new();
    while let Some(chunk) = follow_up_response.chunk().await? {
        match code_agent
            .process_stream_response(&conversation_id, &chunk)
            .await
        {
            Ok(Some(message)) => {
                // Print the content if it exists
                if !message.content.is_empty() {
                    print!("{}", message.content);
                    io::stdout().flush()?;
                    buffer.push_str(&message.content);
                }

                // Handle tool calls if they exist
                if let Some(tool_calls) = &message.tool_calls {
                    for tool_call in tool_calls {
                        print!("\n[Tool Call] {}(", tool_call.function.name);
                        if let Some(obj) = tool_call.function.arguments.as_object() {
                            for (key, value) in obj {
                                print!("{}: {}, ", key, value);
                            }
                        }
                        println!(")");
                        io::stdout().flush()?;
                    }
                }
            }
            Ok(None) => {
                code_agent
                    .add_message(&conversation_id, "assistant", &buffer)
                    .await;
                println!("\n");
                break;
            }
            Err(e) => {
                eprintln!("\n❌ Error processing stream: {}", e);
                break;
            }
        }
    }

    Ok(())
}

pub async fn analyze_java( &self, code: &str, ) -> Result<CodeAnalysisResult, KowalskiError>

Analyzes Java code

Examples found in repository

examples/java_analysis.rs (line 87)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::init();

    // Load configuration
    let config = Config::default();
    let mut code_agent = CodeAgent::new(config).await?;

    // Start a conversation
    println!("☕ Starting Java Code Analysis...");
    let conversation_id = code_agent.start_conversation("llama3.2");
    println!("Code Agent Conversation ID: {}", conversation_id);

    // Set up the role for code analysis
    let role = Role::new(
        "Java Code Analysis Assistant",
        "You are an expert at analyzing Java code, providing insights on code quality, best practices, and potential improvements.",
    )
    .with_audience(Audience::new(
        "Java Developer",
        "You are speaking to a Java developer who needs detailed code analysis.",
    ))
    .with_preset(Preset::new(
        "Analysis",
        "Provide comprehensive analysis with specific recommendations for improvement.",
    ));

    // Sample Java code for analysis
    let java_code = r#"
import java.util.*;

public class Calculator {
    private int result;
    
    public Calculator() {
        this.result = 0;
    }
    
    public int add(int a, int b) {
        result = a + b;
        return result;
    }
    
    public int subtract(int a, int b) {
        result = a - b;
        return result;
    }
    
    public int multiply(int a, int b) {
        result = a * b;
        return result;
    }
    
    public double divide(int a, int b) {
        if (b == 0) {
            System.out.println("Error: Division by zero");
            return 0;
        }
        result = a / b;
        return (double) result;
    }
    
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println("Addition: " + calc.add(10, 5));
        System.out.println("Subtraction: " + calc.subtract(10, 5));
        System.out.println("Multiplication: " + calc.multiply(10, 5));
        System.out.println("Division: " + calc.divide(10, 5));
    }
}
"#;

    println!("\n📝 Java Code to Analyze:");
    println!("{}", java_code);

    // Analyze the Java code
    let analysis_result = code_agent.analyze_java(java_code).await?;

    println!("\n📊 Java Analysis Results:");
    println!("Language: {}", analysis_result.language);
    println!(
        "Metrics: {}",
        serde_json::to_string_pretty(&analysis_result.metrics)?
    );
    println!("Suggestions: {:?}", analysis_result.suggestions);
    println!("Issues: {:?}", analysis_result.issues);

    // Ask the agent to analyze the code
    let analysis_prompt = format!(
        "Please analyze this Java code and provide insights:\n\n{}\n\nAnalysis results:\nMetrics: {}\nSuggestions: {:?}\nIssues: {:?}",
        java_code,
        serde_json::to_string_pretty(&analysis_result.metrics)?,
        analysis_result.suggestions,
        analysis_result.issues
    );

    let mut response = code_agent
        .chat_with_history(&conversation_id, &analysis_prompt, Some(role))
        .await?;

    println!("\n🤖 AI Analysis:");

    // Process the streaming response
    let mut buffer = String::new();
    while let Some(chunk) = response.chunk().await? {
        match code_agent
            .process_stream_response(&conversation_id, &chunk)
            .await
        {
            Ok(Some(message)) => {
                // Print the content if it exists
                if !message.content.is_empty() {
                    print!("{}", message.content);
                    io::stdout().flush()?;
                    buffer.push_str(&message.content);
                }

                // Handle tool calls if they exist
                if let Some(tool_calls) = &message.tool_calls {
                    for tool_call in tool_calls {
                        print!("\n[Tool Call] {}(", tool_call.function.name);
                        if let Some(obj) = tool_call.function.arguments.as_object() {
                            for (key, value) in obj {
                                print!("{}: {}, ", key, value);
                            }
                        }
                        println!(")");
                        io::stdout().flush()?;
                    }
                }
            }
            Ok(None) => {
                code_agent
                    .add_message(&conversation_id, "assistant", &buffer)
                    .await;
                println!("\n✅ Analysis complete!\n");
                break;
            }
            Err(e) => {
                eprintln!("\n❌ Error processing stream: {}", e);
                break;
            }
        }
    }

    // Ask a follow-up question about specific improvements
    let follow_up = "What specific improvements would you recommend for this Java code?";
    let mut follow_up_response = code_agent
        .chat_with_history(&conversation_id, follow_up, None)
        .await?;

    println!("\n🔍 Follow-up Analysis:");
    let mut buffer = String::new();
    while let Some(chunk) = follow_up_response.chunk().await? {
        match code_agent
            .process_stream_response(&conversation_id, &chunk)
            .await
        {
            Ok(Some(message)) => {
                // Print the content if it exists
                if !message.content.is_empty() {
                    print!("{}", message.content);
                    io::stdout().flush()?;
                    buffer.push_str(&message.content);
                }

                // Handle tool calls if they exist
                if let Some(tool_calls) = &message.tool_calls {
                    for tool_call in tool_calls {
                        print!("\n[Tool Call] {}(", tool_call.function.name);
                        if let Some(obj) = tool_call.function.arguments.as_object() {
                            for (key, value) in obj {
                                print!("{}: {}, ", key, value);
                            }
                        }
                        println!(")");
                        io::stdout().flush()?;
                    }
                }
            }
            Ok(None) => {
                code_agent
                    .add_message(&conversation_id, "assistant", &buffer)
                    .await;
                println!("\n");
                break;
            }
            Err(e) => {
                eprintln!("\n❌ Error processing stream: {}", e);
                break;
            }
        }
    }

    Ok(())
}

pub async fn analyze_python( &self, code: &str, ) -> Result<CodeAnalysisResult, KowalskiError>

Analyzes Python code

Examples found in repository

examples/python_analysis.rs (line 97)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::init();

    // Load configuration
    let config = Config::default();
    let mut code_agent = CodeAgent::new(config).await?;

    // Start a conversation
    println!("🐍 Starting Python Code Analysis...");
    let conversation_id = code_agent.start_conversation("llama3.2");
    println!("Code Agent Conversation ID: {}", conversation_id);

    // Set up the role for code analysis
    let role = Role::new(
        "Python Code Analysis Assistant",
        "You are an expert at analyzing Python code, providing insights on code quality, PEP 8 compliance, and potential improvements.",
    )
    .with_audience(Audience::new(
        "Python Developer",
        "You are speaking to a Python developer who needs detailed code analysis.",
    ))
    .with_preset(Preset::new(
        "Analysis",
        "Provide comprehensive analysis with specific recommendations for improvement.",
    ));

    // Sample Python code for analysis
    let python_code = r#"
import os
import sys
from typing import List, Optional

class DataProcessor:
    def __init__(self, data: List[int]):
        self.data = data
        self.result = 0
    
    def calculate_sum(self) -> int:
        """Calculate the sum of all data points."""
        total = 0
        for item in self.data:
            total += item
        return total
    
    def calculate_average(self) -> float:
        """Calculate the average of all data points."""
        if len(self.data) == 0:
            print("Error: No data to calculate average")
            return 0.0
        return self.calculate_sum() / len(self.data)
    
    def find_max(self) -> Optional[int]:
        """Find the maximum value in the data."""
        if not self.data:
            return None
        max_val = self.data[0]
        for item in self.data:
            if item > max_val:
                max_val = item
        return max_val

def main():
    # Sample data
    numbers = [10, 20, 30, 40, 50]
    
    # Create processor
    processor = DataProcessor(numbers)
    
    # Calculate statistics
    print(f"Sum: {processor.calculate_sum()}")
    print(f"Average: {processor.calculate_average()}")
    print(f"Maximum: {processor.find_max()}")
    
    # Process empty data
    empty_processor = DataProcessor([])
    print(f"Empty average: {empty_processor.calculate_average()}")

if __name__ == "__main__":
    main()
"#;

    println!("\n📝 Python Code to Analyze:");
    println!("{}", python_code);

    // Analyze the Python code
    let analysis_result = code_agent.analyze_python(python_code).await?;

    println!("\n📊 Python Analysis Results:");
    println!("Language: {}", analysis_result.language);
    println!(
        "Metrics: {}",
        serde_json::to_string_pretty(&analysis_result.metrics)?
    );
    println!("Suggestions: {:?}", analysis_result.suggestions);
    println!("PEP 8 Issues: {:?}", analysis_result.issues);

    // Ask the agent to analyze the code
    let analysis_prompt = format!(
        "Please analyze this Python code and provide insights:\n\n{}\n\nAnalysis results:\nMetrics: {}\nSuggestions: {:?}\nPEP 8 Issues: {:?}",
        python_code,
        serde_json::to_string_pretty(&analysis_result.metrics)?,
        analysis_result.suggestions,
        analysis_result.issues
    );

    let mut response = code_agent
        .chat_with_history(&conversation_id, &analysis_prompt, Some(role))
        .await?;

    println!("\n🤖 AI Analysis:");

    // Process the streaming response
    let mut buffer = String::new();
    while let Some(chunk) = response.chunk().await? {
        match code_agent
            .process_stream_response(&conversation_id, &chunk)
            .await
        {
            Ok(Some(message)) => {
                // Print the content if it exists
                if !message.content.is_empty() {
                    print!("{}", message.content);
                    io::stdout().flush()?;
                    buffer.push_str(&message.content);
                }

                // Handle tool calls if they exist
                if let Some(tool_calls) = &message.tool_calls {
                    for tool_call in tool_calls {
                        print!("\n[Tool Call] {}(", tool_call.function.name);
                        if let Some(obj) = tool_call.function.arguments.as_object() {
                            for (key, value) in obj {
                                print!("{}: {}, ", key, value);
                            }
                        }
                        println!(")");
                        io::stdout().flush()?;
                    }
                }
            }
            Ok(None) => {
                code_agent
                    .add_message(&conversation_id, "assistant", &buffer)
                    .await;
                println!("\n✅ Analysis complete!\n");
                break;
            }
            Err(e) => {
                eprintln!("\n❌ Error processing stream: {}", e);
                break;
            }
        }
    }

    // Ask a follow-up question about PEP 8 compliance
    let follow_up = "How can this Python code be improved to better follow PEP 8 guidelines?";
    let mut follow_up_response = code_agent
        .chat_with_history(&conversation_id, follow_up, None)
        .await?;

    println!("\n🔍 Follow-up Analysis:");
    let mut buffer = String::new();
    while let Some(chunk) = follow_up_response.chunk().await? {
        match code_agent
            .process_stream_response(&conversation_id, &chunk)
            .await
        {
            Ok(Some(message)) => {
                // Print the content if it exists
                if !message.content.is_empty() {
                    print!("{}", message.content);
                    io::stdout().flush()?;
                    buffer.push_str(&message.content);
                }

                // Handle tool calls if they exist
                if let Some(tool_calls) = &message.tool_calls {
                    for tool_call in tool_calls {
                        print!("\n[Tool Call] {}(", tool_call.function.name);
                        if let Some(obj) = tool_call.function.arguments.as_object() {
                            for (key, value) in obj {
                                print!("{}: {}, ", key, value);
                            }
                        }
                        println!(")");
                        io::stdout().flush()?;
                    }
                }
            }
            Ok(None) => {
                code_agent
                    .add_message(&conversation_id, "assistant", &buffer)
                    .await;
                println!("\n");
                break;
            }
            Err(e) => {
                eprintln!("\n❌ Error processing stream: {}", e);
                break;
            }
        }
    }

    Ok(())
}

pub async fn analyze_rust( &self, code: &str, ) -> Result<CodeAnalysisResult, KowalskiError>

Analyzes Rust code

Examples found in repository

examples/rust_analysis.rs (line 111)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::init();

    // Load configuration
    let config = Config::default();
    let mut code_agent = CodeAgent::new(config).await?;

    // Start a conversation
    println!("🦀 Starting Rust Code Analysis...");
    let conversation_id = code_agent.start_conversation("llama3.2");
    println!("Code Agent Conversation ID: {}", conversation_id);

    // Set up the role for code analysis
    let role = Role::new(
        "Rust Code Analysis Assistant",
        "You are an expert at analyzing Rust code, providing insights on code quality, safety, and potential improvements.",
    )
    .with_audience(Audience::new(
        "Rust Developer",
        "You are speaking to a Rust developer who needs detailed code analysis.",
    ))
    .with_preset(Preset::new(
        "Analysis",
        "Provide comprehensive analysis with specific recommendations for improvement.",
    ));

    // Sample Rust code for analysis
    let rust_code = r#"
use std::collections::HashMap;
use std::error::Error;

#[derive(Debug)]
struct DataProcessor {
    data: Vec<i32>,
    cache: HashMap<String, i32>,
}

impl DataProcessor {
    fn new(data: Vec<i32>) -> Self {
        Self {
            data,
            cache: HashMap::new(),
        }
    }
    
    fn calculate_sum(&self) -> i32 {
        self.data.iter().sum()
    }
    
    fn calculate_average(&self) -> Option<f64> {
        if self.data.is_empty() {
            None
        } else {
            Some(self.calculate_sum() as f64 / self.data.len() as f64)
        }
    }
    
    fn find_max(&self) -> Option<&i32> {
        self.data.iter().max()
    }
    
    fn process_with_cache(&mut self, key: String) -> Result<i32, Box<dyn Error>> {
        if let Some(&cached_value) = self.cache.get(&key) {
            return Ok(cached_value);
        }
        
        let result = self.calculate_sum();
        self.cache.insert(key, result);
        Ok(result)
    }
}

fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    let mut processor = DataProcessor::new(numbers);
    
    println!("Sum: {}", processor.calculate_sum());
    
    match processor.calculate_average() {
        Some(avg) => println!("Average: {}", avg),
        None => println!("No data to calculate average"),
    }
    
    match processor.find_max() {
        Some(max) => println!("Maximum: {}", max),
        None => println!("No data to find maximum"),
    }
    
    match processor.process_with_cache("sum".to_string()) {
        Ok(result) => println!("Cached result: {}", result),
        Err(e) => println!("Error: {}", e),
    }
}
"#;

    println!("\n📝 Rust Code to Analyze:");
    println!("{}", rust_code);

    // Analyze the Rust code
    let analysis_result = code_agent.analyze_rust(rust_code).await?;

    println!("\n📊 Rust Analysis Results:");
    println!("Language: {}", analysis_result.language);
    println!(
        "Metrics: {}",
        serde_json::to_string_pretty(&analysis_result.metrics)?
    );
    println!("Suggestions: {:?}", analysis_result.suggestions);
    println!("Rust Issues: {:?}", analysis_result.issues);

    // Ask the agent to analyze the code
    let analysis_prompt = format!(
        "Please analyze this Rust code and provide insights:\n\n{}\n\nAnalysis results:\nMetrics: {}\nSuggestions: {:?}\nRust Issues: {:?}",
        rust_code,
        serde_json::to_string_pretty(&analysis_result.metrics)?,
        analysis_result.suggestions,
        analysis_result.issues
    );

    let mut response = code_agent
        .chat_with_history(&conversation_id, &analysis_prompt, Some(role))
        .await?;

    println!("\n🤖 AI Analysis:");

    // Process the streaming response
    let mut buffer = String::new();
    while let Some(chunk) = response.chunk().await? {
        match code_agent
            .process_stream_response(&conversation_id, &chunk)
            .await
        {
            Ok(Some(message)) => {
                // Print the content if it exists
                if !message.content.is_empty() {
                    print!("{}", message.content);
                    io::stdout().flush()?;
                    buffer.push_str(&message.content);
                }

                // Handle tool calls if they exist
                if let Some(tool_calls) = &message.tool_calls {
                    for tool_call in tool_calls {
                        print!("\n[Tool Call] {}(", tool_call.function.name);
                        if let Some(obj) = tool_call.function.arguments.as_object() {
                            for (key, value) in obj {
                                print!("{}: {}, ", key, value);
                            }
                        }
                        println!(")");
                        io::stdout().flush()?;
                    }
                }
            }
            Ok(None) => {
                code_agent
                    .add_message(&conversation_id, "assistant", &buffer)
                    .await;
                println!("\n✅ Analysis complete!\n");
                break;
            }
            Err(e) => {
                eprintln!("\n❌ Error processing stream: {}", e);
                break;
            }
        }
    }

    // Ask a follow-up question about Rust-specific improvements
    let follow_up = "What Rust-specific improvements would you recommend for this code?";
    let mut follow_up_response = code_agent
        .chat_with_history(&conversation_id, follow_up, None)
        .await?;

    println!("\n🔍 Follow-up Analysis:");
    let mut buffer = String::new();
    while let Some(chunk) = follow_up_response.chunk().await? {
        match code_agent
            .process_stream_response(&conversation_id, &chunk)
            .await
        {
            Ok(Some(message)) => {
                // Print the content if it exists
                if !message.content.is_empty() {
                    print!("{}", message.content);
                    io::stdout().flush()?;
                    buffer.push_str(&message.content);
                }

                // Handle tool calls if they exist
                if let Some(tool_calls) = &message.tool_calls {
                    for tool_call in tool_calls {
                        print!("\n[Tool Call] {}(", tool_call.function.name);
                        if let Some(obj) = tool_call.function.arguments.as_object() {
                            for (key, value) in obj {
                                print!("{}: {}, ", key, value);
                            }
                        }
                        println!(")");
                        io::stdout().flush()?;
                    }
                }
            }
            Ok(None) => {
                code_agent
                    .add_message(&conversation_id, "assistant", &buffer)
                    .await;
                println!("\n");
                break;
            }
            Err(e) => {
                eprintln!("\n❌ Error processing stream: {}", e);
                break;
            }
        }
    }

    Ok(())
}

Trait Implementations

impl Agent for CodeAgent

fn new<'async_trait>( config: Config, ) -> Pin<Box<dyn Future<Output = Result<Self, KowalskiError>> + Send + 'async_trait>>

where Self: 'async_trait,

Creates a new agent with the specified configuration.

fn start_conversation(&mut self, model: &str) -> String

Starts a new conversation

fn get_conversation(&self, id: &str) -> Option<&Conversation>

Gets a conversation by ID

fn list_conversations(&self) -> Vec<&Conversation>

Lists all conversations

fn delete_conversation(&mut self, id: &str) -> bool

Deletes a conversation

fn chat_with_history<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, conversation_id: &'life1 str, content: &'life2 str, role: Option<Role>, ) -> Pin<Box<dyn Future<Output = Result<Response, KowalskiError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Chats with history

fn process_stream_response<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, conversation_id: &'life1 str, chunk: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<Option<Message>, KowalskiError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Processes a stream response

fn add_message<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, conversation_id: &'life1 str, role: &'life2 str, content: &'life3 str, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Adds a message to a conversation

fn name(&self) -> &str

Gets the agent’s name

fn description(&self) -> &str

Gets the agent’s description