zackstrap 1.6.2

A CLI tool to bootstrap project configuration files
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use clap::{Parser, Subcommand};
use std::path::PathBuf;

mod commands;
mod config;
mod error;
mod generators;

use commands::CommandHandler;
use error::ZackstrapError;

#[derive(Parser)]
#[command(
    name = "zackstrap",
    about = "Bootstrap project configuration files",
    version,
    long_about = "A CLI tool to quickly generate common project configuration files like .editorconfig, .prettierrc, and more."
)]
struct Cli {
    #[command(subcommand)]
    command: Commands,

    /// Target directory (defaults to current directory)
    #[arg(short, long, value_name = "DIR")]
    target: Option<PathBuf>,

    /// Force overwrite existing files
    #[arg(short, long)]
    force: bool,

    /// Fail if files already exist (default: false - will skip existing files)
    #[arg(short = 'e', long)]
    fail_on_exists: bool,

    /// Show what would be created without actually creating files
    #[arg(long)]
    dry_run: bool,

    /// Generate git hooks for the project
    #[arg(long)]
    hooks: bool,
}

#[derive(Subcommand)]
enum Commands {
    /// Generate configuration files for a basic project
    Basic {
        /// Template to use (e.g., 'google', 'airbnb')
        #[arg(short, long)]
        template: Option<String>,
    },
    /// Generate configuration files for a Ruby project
    Ruby {
        /// Template to use (e.g., 'rails', 'sinatra', 'gem')
        #[arg(short, long)]
        template: Option<String>,
    },
    /// Generate configuration files for a Python project
    Python {
        /// Template to use (e.g., 'default', 'django', 'flask')
        #[arg(short, long)]
        template: Option<String>,
    },
    /// Generate configuration files for a Node.js project
    Node {
        /// Template to use (e.g., 'default', 'express', 'react')
        #[arg(short, long)]
        template: Option<String>,
    },
    /// Generate configuration files for a Go project
    Go {
        /// Template to use (e.g., 'default', 'web', 'cli')
        #[arg(short, long)]
        template: Option<String>,
    },
    /// Generate configuration files for a Rust project
    Rust {
        /// Template to use (e.g., 'default', 'web', 'cli')
        #[arg(short, long)]
        template: Option<String>,
    },
    /// Generate configuration files for a Bash project
    Bash {
        /// Template to use (e.g., 'default', 'devops', 'cli')
        #[arg(short, long)]
        template: Option<String>,
    },
    /// Automatically detect project type and generate appropriate configs
    Auto,
    /// Interactive mode - guided configuration setup
    Interactive,
    /// List all available configuration files
    List,
}

#[tokio::main]
async fn main() -> Result<(), ZackstrapError> {
    let cli = Cli::parse();

    let target_dir = cli
        .target
        .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")));

    if !target_dir.exists() {
        return Err(ZackstrapError::DirectoryNotFound(target_dir));
    }

    if !target_dir.is_dir() {
        return Err(ZackstrapError::NotADirectory(target_dir));
    }

    let handler = CommandHandler::new(
        target_dir,
        cli.force,
        cli.fail_on_exists,
        cli.dry_run,
        cli.hooks,
    );

    match cli.command {
        Commands::Basic { template } => handler.handle_basic(template).await?,
        Commands::Ruby { template } => handler.handle_ruby(template).await?,
        Commands::Python { template } => handler.handle_python(template).await?,
        Commands::Node { template } => handler.handle_node(template).await?,
        Commands::Go { template } => handler.handle_go(template).await?,
        Commands::Rust { template } => handler.handle_rust(template).await?,
        Commands::Bash { template } => handler.handle_bash(template).await?,
        Commands::Auto => handler.handle_auto().await?,
        Commands::Interactive => handler.handle_interactive().await?,
        Commands::List => handler.handle_list(),
    }

    Ok(())
}