mecha10_templates/services/

init_service.rs

//! Init service for project initialization
//!
//! Handles business logic for creating new Mecha10 projects including:
//! - Directory structure creation
//! - Component addition

use crate::paths;
use anyhow::Result;
use std::path::Path;

/// Service for initializing new Mecha10 projects
///
/// # Examples
///
/// ```rust,ignore
/// use mecha10_cli::services::InitService;
///
/// let service = InitService::new();
///
/// // Create project structure
/// service.create_project_directories(&project_path).await?;
///
/// // Add example nodes
/// service.add_example_node(&project_path, "speaker").await?;
/// ```
pub struct InitService;

impl InitService {
    /// Create a new InitService
    pub fn new() -> Self {
        Self
    }

    /// Create project directory structure
    ///
    /// Creates all the necessary directories for a new Mecha10 project:
    /// - nodes/ - Custom node implementations
    /// - drivers/ - Hardware driver implementations
    /// - types/ - Shared type definitions
    /// - configs/behaviors/ - Behavior tree definitions (LAB-2072: nested under configs/ so
    ///   `mecha10 config push` syncs them)
    /// - config/ - Configuration files
    /// - logs/ - Runtime logs
    /// - models/ - ML/AI models (ONNX, etc.) for remote nodes
    /// - simulation/ - Simulation environments
    /// - simulation/models/ - Robot physical models
    /// - assets/ - Static assets for simulation and visualization
    /// - assets/images/ - Image assets for simulation textures, UI, etc.
    pub async fn create_project_directories(&self, path: &Path) -> Result<()> {
        let dirs = vec![
            paths::project::NODES_DIR,
            paths::project::DRIVERS_DIR,
            paths::project::TYPES_DIR,
            paths::project::BEHAVIORS_DIR,
            paths::project::LOGS_DIR,
            paths::project::MODELS_DIR,
            paths::project::SIMULATION_DIR,
            paths::project::SIMULATION_MODELS_DIR,
            paths::project::SIMULATION_ENVIRONMENTS_DIR,
            paths::project::SIMULATION_TASKS_DIR,
            paths::project::ASSETS_DIR,
            paths::project::ASSETS_IMAGES_DIR,
            // Config directories (nodes grouped by scope: @mecha10/, plain project override)
            paths::config::NODES_DIR,
            paths::config::SIMULATION_DIR,
        ];

        for dir in dirs {
            let dir_path = path.join(dir);
            tokio::fs::create_dir_all(&dir_path).await?;

            // Create .gitkeep to ensure empty directories are tracked
            tokio::fs::write(dir_path.join(".gitkeep"), "").await?;
        }

        Ok(())
    }

    /// Add an example node from the catalog to the project
    ///
    /// This method:
    /// 1. Searches the component catalog for the component
    /// 2. Generates component files from templates (if any)
    /// 3. Updates Cargo.toml (workspace members or dependencies)
    /// 4. Updates mecha10.json configuration
    ///
    /// # Arguments
    ///
    /// * `project_root` - Root path of the project
    /// * `component_name` - Name of the component to add (e.g., "speaker", "listener")
    pub async fn add_example_node(&self, project_root: &Path, component_name: &str) -> Result<()> {
        use crate::component_catalog::ComponentCatalog;

        // Load catalog and find component
        let catalog = ComponentCatalog::new();
        let components = catalog.search(component_name);

        if components.is_empty() {
            return Err(anyhow::anyhow!("Component '{}' not found in catalog", component_name));
        }

        let component = &components[0];

        // Generate component files from catalog templates (if any)
        // For monorepo nodes like speaker/listener, files vec is empty
        for file_template in &component.files {
            let file_path = project_root.join(&file_template.path);

            // Create parent directories
            if let Some(parent) = file_path.parent() {
                tokio::fs::create_dir_all(parent).await?;
            }

            // Write file content
            tokio::fs::write(&file_path, &file_template.content).await?;
        }

        // Only update workspace Cargo.toml if files were generated
        // For monorepo nodes, skip workspace member updates since there's no wrapper directory
        if !component.files.is_empty() {
            self.add_workspace_member(project_root, component_name).await?;
        }

        // For monorepo nodes, add as dependency to Cargo.toml
        let is_monorepo_node = component.files.is_empty();
        if is_monorepo_node {
            self.add_dependency(project_root, component).await?;
        }

        // Update mecha10.json configuration
        self.add_node_to_config(project_root, component_name, component, is_monorepo_node)
            .await?;

        Ok(())
    }

    /// Add a workspace member to Cargo.toml
    async fn add_workspace_member(&self, project_root: &Path, component_name: &str) -> Result<()> {
        let cargo_toml_path = project_root.join(paths::rust::CARGO_TOML);
        let content = tokio::fs::read_to_string(&cargo_toml_path).await?;

        let new_member = format!("nodes/{}", component_name);
        let updated_content = if content.contains("members = []") {
            // Replace empty array
            content.replace("members = []", &format!("members = [\n    \"{}\",\n]", new_member))
        } else if let Some(start) = content.find("members = [") {
            // Find the closing bracket
            if let Some(end) = content[start..].find(']') {
                let insert_pos = start + end;
                // Check if there are existing members
                let members_section = &content[start..insert_pos];
                if members_section.contains('\"') {
                    // Has existing members, add comma and new member
                    format!(
                        "{}\n    \"{}\",{}",
                        &content[..insert_pos],
                        new_member,
                        &content[insert_pos..]
                    )
                } else {
                    // Empty but not [], add member
                    format!(
                        "{}\n    \"{}\",\n{}",
                        &content[..insert_pos],
                        new_member,
                        &content[insert_pos..]
                    )
                }
            } else {
                content
            }
        } else {
            content
        };

        tokio::fs::write(&cargo_toml_path, updated_content).await?;
        Ok(())
    }

    /// Add a dependency to Cargo.toml
    async fn add_dependency(&self, project_root: &Path, component: &crate::component_catalog::Component) -> Result<()> {
        let cargo_toml_path = project_root.join(paths::rust::CARGO_TOML);
        let content = tokio::fs::read_to_string(&cargo_toml_path).await?;

        // Get the actual package name from the component's cargo dependencies
        let package_name = if let Some(dep) = component.cargo_dependencies.first() {
            dep.name.clone()
        } else {
            // Fallback to old behavior if no cargo dependencies specified
            format!("mecha10-nodes-{}", component.id)
        };

        // Add dependency after mecha10-core if not already present
        if !content.contains(&package_name) {
            let updated_content = if let Some(pos) = content.find("mecha10-core = \"0.1\"") {
                // Find end of line
                if let Some(newline_pos) = content[pos..].find('\n') {
                    let insert_pos = pos + newline_pos + 1;
                    format!(
                        "{}{} = \"0.1\"\n{}",
                        &content[..insert_pos],
                        package_name,
                        &content[insert_pos..]
                    )
                } else {
                    content
                }
            } else {
                content
            };

            tokio::fs::write(&cargo_toml_path, updated_content).await?;
        }

        Ok(())
    }

    /// Add node entry to mecha10.json
    async fn add_node_to_config(
        &self,
        project_root: &Path,
        component_name: &str,
        component: &crate::component_catalog::Component,
        is_monorepo_node: bool,
    ) -> Result<()> {
        use crate::services::ConfigService;
        use mecha10_cli_core::types::project::{LifecycleConfig, ModeConfig};
        use std::collections::HashMap;

        let config_path = project_root.join(paths::PROJECT_CONFIG);
        let mut config = ConfigService::load_from(&config_path).await?;

        // Create node identifier and version based on source
        let (node_identifier, version) = if is_monorepo_node {
            // Framework node: @mecha10/node-name with framework version
            (
                format!("@mecha10/{}", component_name),
                env!("CARGO_PKG_VERSION").to_string(),
            )
        } else {
            // Project node: plain node-name (no @local/ prefix) with default version.
            // Plain, unscoped identifiers are the preferred project-node form; @local/*
            // remains supported for parsing existing configs (NodeSpec::parse) but is no
            // longer minted for newly scaffolded nodes.
            (component_name.to_string(), "0.1.0".to_string())
        };

        // Add node using the new format with version
        config.nodes.add_node(&node_identifier, &version);

        // Keep `lifecycle.modes.*.nodes` in sync with newly added/selected nodes. Those lists
        // are seeded once from the static `mecha10.json.template` and otherwise never grow, so
        // without this a node selected via `mecha10 init` (or added via `mecha10 add`) is
        // registered in `nodes`/`targets` but never actually gets spawned by
        // `CliLifecycleManager::nodes_for_current_mode`, which only reads
        // `lifecycle.modes.<mode>.nodes`.
        let relevant_modes = component.relevant_lifecycle_modes();
        if !relevant_modes.is_empty() {
            let lifecycle = config
                .lifecycle
                .get_or_insert_with(|| LifecycleConfig { modes: HashMap::new() });

            for mode in relevant_modes {
                let mode_config = lifecycle
                    .modes
                    .entry(mode.to_string())
                    .or_insert_with(|| ModeConfig { nodes: Vec::new() });

                if !mode_config.nodes.contains(&node_identifier) {
                    mode_config.nodes.push(node_identifier.clone());
                }
            }
        }

        // Save updated config
        let config_json = serde_json::to_string_pretty(&config)?;
        tokio::fs::write(&config_path, config_json).await?;

        Ok(())
    }
}

impl Default for InitService {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod add_node_to_config_tests {
    use super::*;
    use crate::component_catalog::{Component, ComponentType, Mecha10Config};
    use mecha10_cli_core::services::ConfigService;

    /// Minimal valid mecha10.json content for a freshly-initialized project.
    fn minimal_project_config_json() -> &'static str {
        r#"{
            "name": "test-project",
            "version": "0.1.0",
            "robot": { "id": "test-robot" }
        }"#
    }

    /// Build a placeholder `Component` sufficient for `add_node_to_config`. Plain (untagged)
    /// components have no `relevant_lifecycle_modes()`, so they exercise only the
    /// `nodes`/`targets` bookkeeping, not the `lifecycle.modes.*.nodes` sync.
    fn placeholder_component(name: &str) -> Component {
        Component {
            id: name.to_string(),
            name: name.to_string(),
            description: String::new(),
            component_type: ComponentType::Package,
            version: "0.1.0".to_string(),
            category: "custom".to_string(),
            tags: Vec::new(),
            cargo_dependencies: Vec::new(),
            files: Vec::new(),
            mecha10_config: Mecha10Config {
                driver: None,
                custom_node: None,
                behavior: None,
            },
        }
    }

    /// Same as [`placeholder_component`] but tagged as an AI/perception node (e.g.
    /// `image-classifier`), so `relevant_lifecycle_modes()` returns both `simulation` and
    /// `hardware` (see `Component::relevant_lifecycle_modes` in
    /// `mecha10-cli-core/src/component_catalog/types.rs`).
    fn ai_perception_component(name: &str) -> Component {
        Component {
            tags: vec!["vision".to_string()],
            ..placeholder_component(name)
        }
    }

    #[tokio::test]
    async fn mints_project_nodes_with_plain_identifier() {
        let temp_dir = tempfile::tempdir().expect("create temp dir");
        let project_root = temp_dir.path();
        tokio::fs::write(project_root.join(paths::PROJECT_CONFIG), minimal_project_config_json())
            .await
            .expect("write mecha10.json");

        let service = InitService::new();
        let component = placeholder_component("my-custom");

        service
            .add_node_to_config(project_root, "my-custom", &component, false)
            .await
            .expect("add_node_to_config should succeed");

        let config = ConfigService::load_from(&project_root.join(paths::PROJECT_CONFIG))
            .await
            .expect("reload config");

        assert!(
            config.nodes.identifiers().contains(&"my-custom"),
            "expected plain identifier 'my-custom' in nodes, got: {:?}",
            config.nodes.identifiers()
        );
        assert!(
            !config.nodes.identifiers().contains(&"@local/my-custom"),
            "new project nodes must not be minted with the legacy @local/ prefix, got: {:?}",
            config.nodes.identifiers()
        );
    }

    #[tokio::test]
    async fn mints_framework_nodes_with_mecha10_scope() {
        let temp_dir = tempfile::tempdir().expect("create temp dir");
        let project_root = temp_dir.path();
        tokio::fs::write(project_root.join(paths::PROJECT_CONFIG), minimal_project_config_json())
            .await
            .expect("write mecha10.json");

        let service = InitService::new();
        let component = placeholder_component("speaker");

        service
            .add_node_to_config(project_root, "speaker", &component, true)
            .await
            .expect("add_node_to_config should succeed");

        let config = ConfigService::load_from(&project_root.join(paths::PROJECT_CONFIG))
            .await
            .expect("reload config");

        assert!(
            config.nodes.identifiers().contains(&"@mecha10/speaker"),
            "expected framework identifier '@mecha10/speaker' in nodes, got: {:?}",
            config.nodes.identifiers()
        );
    }

    #[tokio::test]
    async fn appends_ai_perception_node_to_simulation_and_hardware_modes_when_lifecycle_absent() {
        let temp_dir = tempfile::tempdir().expect("create temp dir");
        let project_root = temp_dir.path();
        // No `lifecycle` key at all - mirrors a freshly-initialized project before any mode
        // config exists.
        tokio::fs::write(project_root.join(paths::PROJECT_CONFIG), minimal_project_config_json())
            .await
            .expect("write mecha10.json");

        let service = InitService::new();
        let component = ai_perception_component("image-classifier");

        service
            .add_node_to_config(project_root, "image-classifier", &component, true)
            .await
            .expect("add_node_to_config should succeed");

        let config = ConfigService::load_from(&project_root.join(paths::PROJECT_CONFIG))
            .await
            .expect("reload config");

        let lifecycle = config
            .lifecycle
            .expect("lifecycle should be created when a relevant node is added");
        for mode in ["simulation", "hardware"] {
            let mode_nodes = &lifecycle
                .modes
                .get(mode)
                .unwrap_or_else(|| panic!("expected '{mode}' mode to be created"))
                .nodes;
            assert!(
                mode_nodes.contains(&"@mecha10/image-classifier".to_string()),
                "expected @mecha10/image-classifier in lifecycle.modes.{mode}.nodes, got {mode_nodes:?}"
            );
        }
    }

    #[tokio::test]
    async fn appends_ai_perception_node_to_existing_mode_lists_without_duplicating() {
        let temp_dir = tempfile::tempdir().expect("create temp dir");
        let project_root = temp_dir.path();
        let config_with_lifecycle = r#"{
            "name": "test-project",
            "version": "0.1.0",
            "robot": { "id": "test-robot" },
            "lifecycle": {
                "modes": {
                    "simulation": { "nodes": ["@mecha10/simulator"] },
                    "hardware": { "nodes": ["@mecha10/websocket-bridge", "@mecha10/image-classifier"] }
                }
            }
        }"#;
        tokio::fs::write(project_root.join(paths::PROJECT_CONFIG), config_with_lifecycle)
            .await
            .expect("write mecha10.json");

        let service = InitService::new();
        let component = ai_perception_component("image-classifier");

        service
            .add_node_to_config(project_root, "image-classifier", &component, true)
            .await
            .expect("add_node_to_config should succeed");

        let config = ConfigService::load_from(&project_root.join(paths::PROJECT_CONFIG))
            .await
            .expect("reload config");
        let lifecycle = config.lifecycle.expect("lifecycle should be preserved");

        let simulation_nodes = &lifecycle.modes.get("simulation").unwrap().nodes;
        assert_eq!(
            simulation_nodes,
            &vec![
                "@mecha10/simulator".to_string(),
                "@mecha10/image-classifier".to_string()
            ],
            "expected image-classifier appended to the existing simulation mode nodes"
        );

        let hardware_nodes = &lifecycle.modes.get("hardware").unwrap().nodes;
        assert_eq!(
            hardware_nodes,
            &vec![
                "@mecha10/websocket-bridge".to_string(),
                "@mecha10/image-classifier".to_string()
            ],
            "expected no duplicate @mecha10/image-classifier entry in hardware mode nodes, got {hardware_nodes:?}"
        );
    }

    #[tokio::test]
    async fn plain_component_does_not_create_lifecycle_config() {
        let temp_dir = tempfile::tempdir().expect("create temp dir");
        let project_root = temp_dir.path();
        tokio::fs::write(project_root.join(paths::PROJECT_CONFIG), minimal_project_config_json())
            .await
            .expect("write mecha10.json");

        let service = InitService::new();
        let component = placeholder_component("my-custom");

        service
            .add_node_to_config(project_root, "my-custom", &component, false)
            .await
            .expect("add_node_to_config should succeed");

        let config = ConfigService::load_from(&project_root.join(paths::PROJECT_CONFIG))
            .await
            .expect("reload config");

        assert!(
            config.lifecycle.is_none(),
            "a component with no relevant lifecycle modes must not synthesize a lifecycle config"
        );
    }
}