vanguard_plugin_sdk/

template.rs

use std::{fs, path::Path};
use thiserror::Error;

/// Plugin template generation errors
#[derive(Error, Debug)]
pub enum TemplateError {
    #[error("Invalid plugin name: {0}")]
    InvalidName(String),

    #[error("I/O error: {0}")]
    Io(#[from] std::io::Error),
}

/// Result type for template operations
pub type TemplateResult<T> = Result<T, TemplateError>;

/// Options for plugin generation
#[derive(Debug, Clone)]
pub struct PluginOptions {
    /// Plugin name (crate name)
    pub name: String,
    /// Plugin description
    pub description: String,
    /// Plugin author
    pub author: String,
    /// Plugin version
    pub version: String,
    /// Minimum required Vanguard version
    pub min_vanguard_version: Option<String>,
}

/// Convert a string to PascalCase
///
/// - "my-plugin" -> "MyPlugin"
/// - "my_plugin" -> "MyPlugin"
/// - "my plugin" -> "MyPlugin"
fn to_pascal_case(s: &str) -> String {
    let mut result = String::new();
    let mut capitalize_next = true;

    for c in s.chars() {
        if c.is_alphanumeric() {
            if capitalize_next {
                result.push(c.to_ascii_uppercase());
                capitalize_next = false;
            } else {
                result.push(c);
            }
        } else {
            capitalize_next = true;
        }
    }

    result
}

/// Detect if we're running inside the Vanguard repo
fn is_inside_vanguard_repo() -> bool {
    // Try to find the Vanguard repo root by checking for specific directories and files
    let current_dir = std::env::current_dir().ok();
    if let Some(dir) = current_dir {
        // Look for markers of the Vanguard repo
        let mut path = dir.clone();
        loop {
            // Check if this directory contains crates/vanguard-plugin-sdk
            if path.join("crates").join("vanguard-plugin-sdk").exists() {
                return true;
            }

            // Try parent directory
            if let Some(parent) = path.parent() {
                path = parent.to_path_buf();
            } else {
                break;
            }
        }
    }
    false
}

/// Generate the Cargo.toml template
fn generate_cargo_toml(
    plugin_name: &str,
    description: &str,
    _author: &str,
    version: &str,
) -> String {
    let inside_vanguard_repo = is_inside_vanguard_repo();
    
    // Determine the SDK dependency line based on whether we're inside the repo
    let sdk_dependency = if inside_vanguard_repo {
        // Use local path dependency if inside the Vanguard repo
        "vanguard-plugin-sdk = { path = \"../../crates/vanguard-plugin-sdk\" }".to_string()
    } else {
        // Check if we have a local SDK package in ~/.vanguard/sdk
        if let Some(home_dir) = std::env::var_os("HOME").map(std::path::PathBuf::from) {
            let local_sdk_path = home_dir.join(".vanguard").join("sdk");
            
            if local_sdk_path.exists() {
                // Use the local SDK package
                format!("vanguard-plugin-sdk = {{ path = \"{}\" }}", 
                    local_sdk_path.to_string_lossy())
            } else {
                // If no local SDK, fall back to git dependency
                "vanguard-plugin-sdk = { git = \"https://github.com/find-how/pioneer-vanguard\", branch = \"main\" }".to_string()
            }
        } else {
            // Fallback if HOME is not set
            "vanguard-plugin-sdk = { git = \"https://github.com/find-how/pioneer-vanguard\", branch = \"main\" }".to_string()
        }
    };
    
    format!(
        r#"[package]
name = "{plugin_name}"
version = "{version}"
edition = "2021"
description = "{description}"
license = "MIT"

[lib]
crate-type = ["cdylib"]

[dependencies]
{sdk_dependency}
async-trait = "0.1"
serde = {{ version = "1.0", features = ["derive"] }}
serde_json = "1.0"
tokio = {{ version = "1.0", features = ["full"] }}

[dev-dependencies]
tokio-test = "0.4"

# Make this plugin independent from the parent workspace
[workspace]
"#
    )
}

/// Generate a basic plugin README
fn generate_readme(plugin_name: &str, description: &str, author: &str) -> String {
    let inside_vanguard_repo = is_inside_vanguard_repo();
    
    // Check for local SDK
    let using_local_sdk = if inside_vanguard_repo {
        false
    } else {
        if let Some(home_dir) = std::env::var_os("HOME").map(std::path::PathBuf::from) {
            let local_sdk_path = home_dir.join(".vanguard").join("sdk");
            local_sdk_path.exists()
        } else {
            false
        }
    };
    
    let installation_note = if inside_vanguard_repo {
        "This plugin is configured to work within the Vanguard repository. If you want to use it outside the repository, you'll need to update the dependency in Cargo.toml."
    } else if using_local_sdk {
        "This plugin is configured to use a local SDK installation. It doesn't require the Vanguard source code repository."
    } else {
        "This plugin is configured to work independently from the Vanguard repository. It uses the SDK from the main GitHub repository."
    };
    
    format!(
        r#"# {plugin_name}

{description}

## Author

{author}

## Installation

1. Build the plugin:
   ```bash
   cargo build --release
   ```

2. Install the plugin in Vanguard:
   ```bash
   # On macOS:
   vanguard plugin install ./target/release/lib{plugin_name}.dylib
   
   # On Linux:
   vanguard plugin install ./target/release/lib{plugin_name}.so
   
   # On Windows:
   vanguard plugin install ./target/release/{plugin_name}.dll
   ```

## Notes

{installation_note}
"#
    )
}

/// Generate lib.rs content
fn generate_lib_rs(
    plugin_name: &str,
    struct_name: &str,
    description: &str,
    author: &str,
    version: &str,
    min_vanguard_version: Option<&str>,
) -> String {
    let min_version = min_vanguard_version.unwrap_or("0.1.0");

    format!(
        r#"use serde::{{Deserialize, Serialize}};
use vanguard_plugin_sdk::{{metadata, plugin, plugin_config, PluginMetadata, PluginMetadataBuilder}};

/// Configuration for the {plugin_name} plugin
#[derive(Debug, Serialize, Deserialize)]
pub struct {struct_name}Config {{
    /// Example configuration field
    pub value: String,
}}

plugin_config!({struct_name}Config, serde_json::json!({{
    "type": "object",
    "required": ["value"],
    "properties": {{
        "value": {{
            "type": "string",
            "description": "Example configuration value"
        }}
    }}
}}));

/// A plugin that {description}
#[derive(Debug)]
pub struct {struct_name}Plugin {{
    metadata: PluginMetadata,
    config: Option<{struct_name}Config>,
}}

impl {struct_name}Plugin {{
    /// Create a new plugin instance
    pub fn new() -> Self {{
        Self {{
            metadata: metadata()
                .name("{plugin_name}")
                .version("{version}")
                .description("{description}")
                .author("{author}")
                .min_vanguard_version("{min_version}")
                .build(),
            config: None,
        }}
    }}
}}

plugin!({struct_name}Plugin, {struct_name}Config);

#[cfg(test)]
mod tests {{
    use super::*;
    use vanguard_plugin_sdk::{{ValidationResult, VanguardPlugin}};

    #[tokio::test]
    async fn test_plugin_metadata() {{
        let plugin = {struct_name}Plugin::new();
        assert_eq!(plugin.metadata().name, "{plugin_name}");
        assert_eq!(plugin.metadata().version, "{version}");
    }}

    #[tokio::test]
    async fn test_plugin_validation() {{
        let plugin = {struct_name}Plugin::new();
        assert!(matches!(plugin.validate().await, ValidationResult::Passed));
    }}
}}
"#
    )
}

/// Generate a new plugin from a template
pub fn generate_plugin(path: impl AsRef<Path>, options: PluginOptions) -> TemplateResult<()> {
    let path = path.as_ref();

    // Validate plugin name
    let name = options.name.to_lowercase();
    if name.is_empty()
        || !name
            .chars()
            .all(|c| c.is_alphanumeric() || c == '_' || c == '-')
    {
        return Err(TemplateError::InvalidName(name));
    }

    // Create plugin directory
    fs::create_dir_all(path)?;

    // Generate plugin files
    let struct_name = to_pascal_case(&options.name);

    // Create the src directory
    let src_dir = path.join("src");
    fs::create_dir_all(&src_dir)?;

    // Create the README.md
    let readme_path = path.join("README.md");
    let readme_content = generate_readme(&options.name, &options.description, &options.author);
    fs::write(readme_path, readme_content)?;

    // Create Cargo.toml
    let cargo_toml_path = path.join("Cargo.toml");
    let cargo_toml_content = generate_cargo_toml(
        &options.name,
        &options.description,
        &options.author,
        &options.version,
    );
    fs::write(cargo_toml_path, cargo_toml_content)?;

    // Create lib.rs
    let lib_rs_path = src_dir.join("lib.rs");
    let lib_rs_content = generate_lib_rs(
        &options.name,
        &struct_name,
        &options.description,
        &options.author,
        &options.version,
        options.min_vanguard_version.as_deref(),
    );
    fs::write(lib_rs_path, lib_rs_content)?;

    Ok(())
}