mammoth-cli 0.1.0

A frontend project scaffolding CLI tool
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
100
101
102
103
104
105
106

use anyhow::Result;
use clap::Parser;

use mammoth_cli::{
    cli::{Cli, Commands, ConfigCommands, RepoCommands, TemplateCommands},
    manager::TemplateManager,
    project::new_project,
};

#[tokio::main]
async fn main() -> Result<()> {
    let cli = Cli::parse();
    
    let mut manager = TemplateManager::new()?;
    
    match &cli.command {
        Some(Commands::New {
            template,
            name,
            output,
        }) => {
            new_project(&mut manager, template.as_deref(), name.as_deref(), output).await?;
        }
        Some(Commands::Template { command }) => match command {
            TemplateCommands::List { verbose } => {
                manager.list_templates(*verbose);
            }
            TemplateCommands::Download { template_id, force } => {
                let template = manager
                    .get_template_by_id(template_id)
                    .ok_or_else(|| anyhow::anyhow!("Template '{}' not found", template_id))?;
                manager.download_template(template, *force).await?;
            }
            TemplateCommands::DownloadAll { force } => {
                manager.download_all_templates(*force).await?;
            }
            TemplateCommands::Add {
                template_id,
                name,
                repo,
                path,
                description,
                language,
                tags,
            } => {
                manager.add_template(
                    template_id.clone(),
                    name.clone(),
                    repo.clone(),
                    path.clone(),
                    description.clone(),
                    language.clone(),
                    tags.clone(),
                )?;
            }
            TemplateCommands::Remove { template_id } => {
                manager.remove_template(template_id)?;
            }
        },
        Some(Commands::Clean { all, force }) => {
            manager.clean_templates(*all, *force)?;
        }
        Some(Commands::Info { json }) => {
            manager.show_info(*json)?;
        }
        Some(Commands::Repo { command }) => match command {
            RepoCommands::Add {
                repo_name,
                url,
                branch,
            } => {
                manager.add_repo(repo_name.clone(), url.clone(), branch.clone())?;
            }
            RepoCommands::Remove { repo_name } => {
                manager.remove_repo(repo_name)?;
            }
            RepoCommands::List => {
                manager.list_repos();
            }
        },
        Some(Commands::Config { command }) => match command {
            ConfigCommands::Export {
                output,
                include_cache,
            } => {
                manager.export_config(output, *include_cache)?;
            }
            ConfigCommands::Import {
                file,
                mode,
                skip_validation,
            } => {
                manager.import_config(file, mode, *skip_validation)?;
            }
            ConfigCommands::Validate { file } => {
                manager.validate_config_file(file)?;
            }
        },
        None => {
            // Default to new project creation
            new_project(&mut manager, None, None, ".").await?;
        }
    }
    
    Ok(())
}