use anyhow::{anyhow, Result}; use std::env; use std::fs; use std::path::{Path, PathBuf}; use crate::config::paths::Paths; use crate::recipe::read_recipe_file_content::{read_recipe_file, RecipeFile}; use crate::recipe::Recipe; use crate::recipe::RECIPE_FILE_EXTENSIONS; const GOOSE_RECIPE_PATH_ENV_VAR: &str = "GOOSE_RECIPE_PATH"; pub fn get_recipe_library_dir(is_global: bool) -> PathBuf { if is_global { Paths::config_dir().join("recipes") } else { env::current_dir().unwrap().join(".goose/recipes") } } fn local_recipe_dirs() -> Vec { let mut local_dirs = vec![PathBuf::from(".")]; if let Ok(recipe_path_env) = env::var(GOOSE_RECIPE_PATH_ENV_VAR) { let path_separator = if cfg!(windows) { ';' } else { ':' }; local_dirs.extend(recipe_path_env.split(path_separator).map(PathBuf::from)); } local_dirs.push(get_recipe_library_dir(true)); local_dirs.push(get_recipe_library_dir(false)); // Also scan .agents/recipes/ for consistency with the .agents/ convention if let Ok(cwd) = env::current_dir() { local_dirs.push(cwd.join(".agents/recipes")); } if let Some(home) = dirs::home_dir() { local_dirs.push(home.join(".agents/recipes")); } let mut dirs: Vec = local_dirs .into_iter() .map(|dir| dir.canonicalize().unwrap_or(dir)) .collect(); dirs.sort(); dirs.dedup(); dirs } pub fn load_local_recipe_file(recipe_name: &str) -> Result { if RECIPE_FILE_EXTENSIONS .iter() .any(|ext| recipe_name.ends_with(&format!(".{}", ext))) { let path = PathBuf::from(recipe_name); return read_recipe_file(path); } if is_file_path(recipe_name) || is_file_name(recipe_name) { return Err(anyhow!( "Recipe file {} is not a json or yaml file", recipe_name )); } let search_dirs = local_recipe_dirs(); for dir in &search_dirs { if let Ok(result) = load_recipe_file_from_dir(dir, recipe_name) { return Ok(result); } } let search_dirs_str = search_dirs .iter() .map(|p| p.display().to_string()) .collect::>() .join(":"); Err(anyhow!( "ℹ️ Failed to retrieve {}.yaml or {}.json in {}", recipe_name, recipe_name, search_dirs_str )) } pub fn list_local_recipes() -> Result> { let mut recipes = Vec::new(); for dir in local_recipe_dirs() { if let Ok(dir_recipes) = scan_directory_for_recipes(&dir) { recipes.extend(dir_recipes); } } Ok(recipes) } fn is_file_path(recipe_name: &str) -> bool { recipe_name.contains('/') || recipe_name.contains('\\') || recipe_name.starts_with('~') || recipe_name.starts_with('.') } fn is_file_name(recipe_name: &str) -> bool { Path::new(recipe_name).extension().is_some() } fn load_recipe_file_from_dir(dir: &Path, recipe_name: &str) -> Result { for ext in RECIPE_FILE_EXTENSIONS { let recipe_path = dir.join(format!("{}.{}", recipe_name, ext)); if let Ok(result) = read_recipe_file(recipe_path) { return Ok(result); } } Err(anyhow!(format!( "No {}.yaml or {}.json recipe file found in directory: {}", recipe_name, recipe_name, dir.display() ))) } fn scan_directory_for_recipes(dir: &Path) -> Result> { let mut recipes = Vec::new(); if !dir.exists() || !dir.is_dir() { return Ok(recipes); } for entry in fs::read_dir(dir)? { let entry = entry?; let path = entry.path(); if path.is_file() { if let Some(extension) = path.extension() { if RECIPE_FILE_EXTENSIONS.contains(&extension.to_string_lossy().as_ref()) { match Recipe::from_file_path(&path) { Ok(recipe) => recipes.push((path.clone(), recipe)), Err(e) => { let error_message = format!( "Failed to load recipe from file {}: {}", path.display(), e ); tracing::error!("{}", error_message); } } } } } } Ok(recipes) } fn generate_recipe_filename(title: &str, recipe_library_dir: &Path) -> PathBuf { let base_name = title .to_lowercase() .chars() .filter(|c| c.is_alphanumeric() || c.is_whitespace() || *c == '-') .collect::() .split_whitespace() .collect::>() .join("-"); let filename = if base_name.is_empty() { "untitled-recipe".to_string() } else { base_name }; let mut candidate = recipe_library_dir.join(format!("{}.yaml", filename)); if !candidate.exists() { return candidate; } let mut counter = 1; loop { candidate = recipe_library_dir.join(format!("{}-{}.yaml", filename, counter)); if !candidate.exists() { return candidate; } counter += 1; } } pub fn save_recipe_to_file(recipe: Recipe, file_path: Option) -> anyhow::Result { let recipe_library_dir = get_recipe_library_dir(true); let file_path_value = match file_path { Some(path) => path, None => generate_recipe_filename(&recipe.title, &recipe_library_dir), }; if let Some(parent) = file_path_value.parent() { fs::create_dir_all(parent)?; } let yaml_content = recipe.to_yaml()?; fs::write(&file_path_value, yaml_content)?; Ok(file_path_value) }