lmrc-cli 0.3.16

CLI tool for scaffolding LMRC Stack infrastructure projects
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use colored::Colorize;
use lmrc_config_validator::LmrcConfig;
use std::path::PathBuf;

use crate::error::{CliError, Result};
use crate::generator::ProjectGenerator;

pub async fn execute(
    name: String,
    path: Option<String>,
) -> Result<()> {
    println!(
        "{}\n",
        "Creating new LMRC Stack project...".green().bold()
    );

    // Create minimal config with the provided name
    let project_config = create_minimal_config(Some(name))?;

    // Determine target path
    let target_path = if let Some(p) = path {
        PathBuf::from(p)
    } else {
        std::env::current_dir()?
    };

    let project_path = target_path.join(&project_config.project.name);

    // Check if project already exists
    if project_path.exists() {
        return Err(CliError::ProjectExists(project_path.display().to_string()));
    }

    println!(
        "\n{} {}",
        "Creating project at:".green(),
        project_path.display().to_string().cyan()
    );

    // Generate minimal project structure
    let generator = ProjectGenerator::new(project_config, project_path);
    generator.generate_minimal().await?;

    println!("\n{}", "Project created successfully!".green().bold());
    println!("\nProject structure:");
    println!("  {} - Project configuration", "lmrc.toml".cyan());
    println!("  {} - Applications directory (empty)", "apps/".cyan());
    println!("  {} - Shared libraries directory", "libs/".cyan());
    println!("  {} - Infrastructure directory", "infra/".cyan());
    println!("  {} - Docker files directory", "docker/".cyan());
    println!("  {} - Documentation directory", "docs/".cyan());
    println!("\nNext steps:");
    println!("  1. cd {}", generator.project_path().display());
    println!("  2. Add components to create the Cargo workspace:");
    println!("     - lmrc add app <name> --type <api|basic>");
    println!("     - lmrc add pipeline");
    println!("     - lmrc add ci");
    println!("     - lmrc add docs");
    println!("  3. After adding components: cargo build");
    println!("\nFor help: lmrc add --help\n");

    Ok(())
}

fn create_minimal_config(name: Option<String>) -> Result<LmrcConfig> {
    use lmrc_config_validator::*;

    let project_name = name.unwrap_or_else(|| "my-project".to_string());

    Ok(LmrcConfig {
        project: ProjectConfig {
            name: project_name,
            description: "My LMRC Stack project".to_string(),
        },
        providers: ProviderConfig {
            server: "hetzner".to_string(),
            kubernetes: "k3s".to_string(),
            database: "postgres".to_string(),
            queue: "rabbitmq".to_string(),
            dns: "cloudflare".to_string(),
            git: "gitlab".to_string(),
        },
        apps: AppsConfig {
            applications: vec![],
        },
        infrastructure: InfrastructureConfig {
            provider: "hetzner".to_string(),
            network: None,
            servers: vec![],
            load_balancer: None,
            k3s: None,
            postgres: None,
            rabbitmq: None,
            vault: None,
            dns: None,
            gitlab: None,
        },
    })
}