use anyhow::{Result, anyhow};use std::{    fs,    path::{Path, PathBuf},}; pub fn get_exercise_name(exercise_path: &Path) -> String {    exercise_path        .file_name()        .unwrap_or_default()        .to_string_lossy()        .to_string()} pub fn get_exercise_language(exercise_path: &Path) -> Result<String> {    // Extract the language from path (data/python/exercises/... => python)    let parts: Vec<_> = exercise_path.components().collect();     for (i, part) in parts.iter().enumerate() {        if i > 0 && part.as_os_str() == "eval_code" {            if i + 1 < parts.len() {                let language = parts[i + 1].as_os_str().to_string_lossy().to_string();                return Ok(language);            }        }    }     Err(anyhow!(        "Could not determine language from path: {:?}",        exercise_path    ))} pub fn find_exercises(    framework_path: &Path,    languages: &[&str],    max_per_language: Option<usize>,) -> Result<Vec<PathBuf>> {    let mut all_exercises = Vec::new();     println!("Searching for exercises in languages: {:?}", languages);     for language in languages {        let language_dir = framework_path            .join("eval_code")            .join(language)            .join("exercises")            .join("practice");         println!("Checking language directory: {:?}", language_dir);        if !language_dir.exists() {            println!("Warning: Language directory not found: {:?}", language_dir);            continue;        }         let mut exercises = Vec::new();        match fs::read_dir(&language_dir) {            Ok(entries) => {                for entry_result in entries {                    match entry_result {                        Ok(entry) => {                            let path = entry.path();                             if path.is_dir() {                                // Special handling for "internal" directory                                if *language == "internal" {                                    // Check for repo_info.json to validate it's an internal exercise                                    let repo_info_path = path.join(".meta").join("repo_info.json");                                    let instructions_path =                                        path.join(".docs").join("instructions.md");                                     if repo_info_path.exists() && instructions_path.exists() {                                        exercises.push(path);                                    }                                } else {                                    // Map the language to the file extension - original code                                    let language_extension = match *language {                                        "python" => "py",                                        "go" => "go",                                        "rust" => "rs",                                        "typescript" => "ts",                                        "javascript" => "js",                                        "ruby" => "rb",                                        "php" => "php",                                        "bash" => "sh",                                        "multi" => "diff",                                        _ => continue, // Skip unsupported languages                                    };                                     // Check if this is a valid exercise with instructions and example                                    let instructions_path =                                        path.join(".docs").join("instructions.md");                                    let has_instructions = instructions_path.exists();                                    let example_path = path                                        .join(".meta")                                        .join(format!("example.{}", language_extension));                                    let has_example = example_path.exists();                                     if has_instructions && has_example {                                        exercises.push(path);                                    }                                }                            }                        }                        Err(err) => println!("Error reading directory entry: {}", err),                    }                }            }            Err(err) => println!(                "Error reading directory {}: {}",                language_dir.display(),                err            ),        }         // Sort exercises by name for consistent selection        exercises.sort_by(|a, b| {            let a_name = a.file_name().unwrap_or_default().to_string_lossy();            let b_name = b.file_name().unwrap_or_default().to_string_lossy();            a_name.cmp(&b_name)        });         // Apply the limit if specified        if let Some(limit) = max_per_language {            if exercises.len() > limit {                println!(                    "Limiting {} exercises to {} for language {}",                    exercises.len(),                    limit,                    language                );                exercises.truncate(limit);            }        }         println!(            "Found {} exercises for language {}: {:?}",            exercises.len(),            language,            exercises                .iter()                .map(|p| p.file_name().unwrap_or_default().to_string_lossy())                .collect::<Vec<_>>()        );        all_exercises.extend(exercises);    }     Ok(all_exercises)}