mecha10_behavior_runtime/config/

loader.rs

//! Configuration loading for behavior trees
//!
//! Resolves `config.json` across a 2-tier scope layout rooted at `configs/behaviors/`, picking

use super::validator::behavior_capabilities_satisfied;
use anyhow::{Context as _, Result};
use mecha10_cli_core::paths::config::behavior_config_candidates;
use mecha10_cli_core::paths::project::BEHAVIORS_DIR;
use mecha10_core::node::Capability;
use serde_json::Value;
use std::collections::{BTreeSet, HashSet};
use std::path::{Path, PathBuf};

/// Resolve the on-disk `config.json` path for a behavior, checking the 2 tiers in override
/// precedence order (project -> framework) and returning the highest-precedence one that
/// exists. Returns an error listing both attempted paths if neither exists.
pub fn resolve_behavior_config_path(behavior_name: &str, project_root: &Path) -> Result<PathBuf> {
    let tiers = behavior_config_candidates(behavior_name);

    for tier in &tiers {
        let path = project_root.join(tier);
        if path.exists() {
            return Ok(path);
        }
    }

    anyhow::bail!(
        "Behavior config '{}' not found - checked {}",
        behavior_name,
        tiers
            .iter()
            .map(|c| project_root.join(c).display().to_string())
            .collect::<Vec<_>>()
            .join(", ")
    )
}

/// List the names of every behavior available to a project, across both tiers
/// (`configs/behaviors/{name}/config.json` and `configs/behaviors/@mecha10/{name}/config.json`).
/// A name present in both tiers is only listed once.
pub fn list_available_behaviors(project_root: &Path) -> Vec<String> {
    let mut names = BTreeSet::new();

    for tier_dir in [
        project_root.join(BEHAVIORS_DIR),
        project_root.join(BEHAVIORS_DIR).join("@mecha10"),
    ] {
        let Ok(entries) = std::fs::read_dir(&tier_dir) else {
            continue;
        };

        for entry in entries.flatten() {
            let path = entry.path();
            if path.is_dir() && path.join("config.json").is_file() {
                if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
                    names.insert(name.to_string());
                }
            }
        }
    }

    names.into_iter().collect()
}

/// List the names of every behavior available to a project (see [`list_available_behaviors`]),
/// excluding any whose `requires_capabilities` isn't fully satisfied by
/// `available_capabilities` -- e.g. so a robot with no `Flight` capability never reports a
/// flight-only behavior as available on `/behavior/available`. A behavior whose config can't be
/// loaded or parsed is excluded rather than reported as available.
///
/// NOT YET WIRED IN: nothing in *this* repo calls this function. The process that actually
/// publishes the `/behavior/available` list to clients (dashboard, over a websocket relay) is
/// the `behavior-executor` node runtime itself, which is NOT part of this workspace -- it's the
/// separately-released `mecha10-nodes-behavior-executor` crate (see
/// `scripts/release/yank-orphaned-node-crates.sh` and `packages/behavior-runtime/README.md`'s
/// "integrates with... Dashboard: Real-time behavior visualization" note), which lives in the
/// sibling `mecha10-nodes` repo. That node holds the live `ProjectConfig.capabilities` and the
/// `Context`/relay it publishes status on, so the actual call site -- replacing whatever builds
/// its available-behaviors list today with `list_capable_behaviors(project_root,
/// &robot_capabilities)` -- has to be made there, not here. See that repo's behavior-executor
/// node source for the status-publish path.
pub async fn list_capable_behaviors(project_root: &Path, available_capabilities: &HashSet<Capability>) -> Vec<String> {
    let mut names = Vec::new();

    for name in list_available_behaviors(project_root) {
        let Ok(config) = load_behavior_config(&name, project_root).await else {
            continue;
        };

        if behavior_capabilities_satisfied(&config, available_capabilities) {
            names.push(name);
        }
    }

    names
}

/// Load a behavior's `config.json`, resolved via [`resolve_behavior_config_path`].
pub async fn load_behavior_config(behavior_name: &str, project_root: &Path) -> Result<Value> {
    let config_path = resolve_behavior_config_path(behavior_name, project_root)?;
    load_json_file(&config_path).await.with_context(|| {
        format!(
            "Failed to load behavior config '{}' from {}",
            behavior_name,
            config_path.display()
        )
    })
}

/// Load a JSON file from disk
async fn load_json_file(path: &Path) -> Result<Value> {
    let content = tokio::fs::read_to_string(path)
        .await
        .with_context(|| format!("Failed to read file: {}", path.display()))?;

    serde_json::from_str(&content).with_context(|| format!("Failed to parse JSON from: {}", path.display()))
}

/// Get the current environment from environment variable
///
/// Falls back to "dev" if MECHA10_ENVIRONMENT is not set.
pub fn get_current_environment() -> String {
    mecha10_core::config::env_or_default("MECHA10_ENVIRONMENT", "dev")
}

/// Detect project root by looking for mecha10.json
///
/// Walks up the directory tree from the current directory until it finds a directory containing mecha10.json.
pub fn detect_project_root() -> Result<PathBuf> {
    let mut current = std::env::current_dir()?;

    loop {
        let mecha10_json = current.join("mecha10.json");
        if mecha10_json.exists() {
            return Ok(current);
        }

        if !current.pop() {
            anyhow::bail!("Could not find project root (no mecha10.json found in parent directories)");
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    use tempfile::TempDir;

    fn write_behavior_config(project_root: &Path, relative_path: &str, name: &str) {
        let full_path = project_root.join(relative_path);
        fs::create_dir_all(full_path.parent().unwrap()).unwrap();
        fs::write(
            full_path,
            format!(r#"{{"name": "{name}", "root": {{"type": "node", "node": "noop"}}}}"#),
        )
        .unwrap();
    }

    #[test]
    fn resolve_behavior_config_path_finds_framework_default() {
        let project = TempDir::new().unwrap();
        write_behavior_config(
            project.path(),
            "configs/behaviors/@mecha10/idle_wander/config.json",
            "framework",
        );

        let resolved = resolve_behavior_config_path("idle_wander", project.path()).unwrap();

        assert_eq!(
            resolved,
            project
                .path()
                .join("configs/behaviors/@mecha10/idle_wander/config.json")
        );
    }

    #[test]
    fn resolve_behavior_config_path_project_override_wins_over_framework() {
        let project = TempDir::new().unwrap();
        write_behavior_config(
            project.path(),
            "configs/behaviors/@mecha10/idle_wander/config.json",
            "framework",
        );
        write_behavior_config(project.path(), "configs/behaviors/idle_wander/config.json", "project");

        let resolved = resolve_behavior_config_path("idle_wander", project.path()).unwrap();

        assert_eq!(
            resolved,
            project.path().join("configs/behaviors/idle_wander/config.json")
        );
    }

    #[test]
    fn resolve_behavior_config_path_errors_when_no_tier_exists() {
        let project = TempDir::new().unwrap();

        let err = resolve_behavior_config_path("missing_behavior", project.path()).unwrap_err();

        let message = err.to_string();
        assert!(message.contains("missing_behavior"));
        assert!(message.contains("configs/behaviors/missing_behavior/config.json"));
        assert!(message.contains("configs/behaviors/@mecha10/missing_behavior/config.json"));
    }

    #[tokio::test]
    async fn load_behavior_config_reads_resolved_tier() {
        let project = TempDir::new().unwrap();
        write_behavior_config(
            project.path(),
            "configs/behaviors/@mecha10/idle_wander/config.json",
            "framework",
        );
        write_behavior_config(project.path(), "configs/behaviors/idle_wander/config.json", "project");

        let config = load_behavior_config("idle_wander", project.path()).await.unwrap();

        assert_eq!(config["name"], "project");
    }

    #[test]
    fn test_get_current_environment_default() {
        std::env::remove_var("MECHA10_ENVIRONMENT");
        assert_eq!(get_current_environment(), "dev");
    }

    #[test]
    fn list_available_behaviors_returns_empty_for_project_with_no_behaviors_dir() {
        let project = TempDir::new().unwrap();
        assert_eq!(list_available_behaviors(project.path()), Vec::<String>::new());
    }

    #[test]
    fn list_available_behaviors_collects_both_tiers_deduped_and_sorted() {
        let project = TempDir::new().unwrap();
        write_behavior_config(
            project.path(),
            "configs/behaviors/@mecha10/idle_wander/config.json",
            "f",
        );
        write_behavior_config(
            project.path(),
            "configs/behaviors/@mecha10/patrol_simple/config.json",
            "f",
        );
        write_behavior_config(project.path(), "configs/behaviors/patrol_simple/config.json", "p");
        write_behavior_config(project.path(), "configs/behaviors/custom_dance/config.json", "p");

        assert_eq!(
            list_available_behaviors(project.path()),
            vec!["custom_dance", "idle_wander", "patrol_simple"]
        );
    }

    #[test]
    fn list_available_behaviors_ignores_directories_without_config_json() {
        let project = TempDir::new().unwrap();
        fs::create_dir_all(project.path().join("configs/behaviors/incomplete")).unwrap();

        assert_eq!(list_available_behaviors(project.path()), Vec::<String>::new());
    }

    fn write_behavior_config_requiring(project_root: &Path, name: &str, requires_capabilities: &[&str]) {
        let full_path = project_root.join("configs/behaviors").join(name).join("config.json");
        fs::create_dir_all(full_path.parent().unwrap()).unwrap();
        fs::write(
            full_path,
            serde_json::json!({
                "name": name,
                "root": {"type": "node", "node": "noop"},
                "requires_capabilities": requires_capabilities,
            })
            .to_string(),
        )
        .unwrap();
    }

    #[tokio::test]
    async fn list_capable_behaviors_excludes_behavior_requiring_missing_capability() {
        let project = TempDir::new().unwrap();
        write_behavior_config_requiring(project.path(), "fly_around", &["flight"]);
        write_behavior_config_requiring(project.path(), "patrol", &["locomotion"]);

        let available = HashSet::from([Capability::Locomotion]);
        let capable = list_capable_behaviors(project.path(), &available).await;

        assert_eq!(capable, vec!["patrol".to_string()]);
    }

    #[tokio::test]
    async fn list_capable_behaviors_includes_behavior_whose_requirements_are_fully_met() {
        let project = TempDir::new().unwrap();
        write_behavior_config_requiring(project.path(), "patrol", &["locomotion", "vision"]);

        let available = HashSet::from([Capability::Locomotion, Capability::Vision]);
        let capable = list_capable_behaviors(project.path(), &available).await;

        assert_eq!(capable, vec!["patrol".to_string()]);
    }
}