stkd-cli 0.1.0

CLI for Stkd - stacked diffs for Git
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
135
136
137
138
139

//! Create a new branch

use anyhow::Result;
use clap::Args;
use stkd_core::{Repository, TemplateStore};

use crate::output;

#[derive(Args)]
pub struct CreateArgs {
    /// Name for the new branch (or base name when using --template)
    name: String,

    /// Create branch from trunk instead of current branch
    #[arg(long)]
    from_trunk: bool,

    /// Use a template to create multiple branches
    #[arg(long, short)]
    template: Option<String>,

    /// List available templates
    #[arg(long)]
    list_templates: bool,
}

pub async fn execute(args: CreateArgs) -> Result<()> {
    let repo = Repository::open(".")?;
    let stack_dir = repo.git().path().join("stkd");

    // List templates mode
    if args.list_templates {
        let store = TemplateStore::load(&stack_dir);
        let templates = store.list();

        if templates.is_empty() {
            output::info("No templates available");
        } else {
            output::info("Available templates:");
            output::info("");
            for template in templates {
                let branch_count = template.branches.len();
                let plural = if branch_count == 1 { "" } else { "es" };
                output::info(&format!(
                    "  {} - {} ({} branch{})",
                    output::bold(&template.name),
                    template.description,
                    branch_count,
                    plural
                ));
            }
            output::info("");
            output::hint("Use --template <name> to create from a template");
        }
        return Ok(());
    }

    // Ensure clean working directory
    repo.ensure_clean()?;

    // If from_trunk, checkout trunk first
    if args.from_trunk {
        repo.checkout(repo.trunk())?;
    }

    // Template mode: create multiple branches
    if let Some(template_name) = &args.template {
        let store = TemplateStore::load(&stack_dir);
        let template = store.find(template_name).ok_or_else(|| {
            anyhow::anyhow!(
                "Template '{}' not found. Use --list-templates to see available templates.",
                template_name
            )
        })?;

        let branch_names = template.generate_names(&args.name);

        if branch_names.is_empty() {
            return Err(anyhow::anyhow!("Template '{}' has no branches defined", template_name));
        }

        output::info(&format!(
            "Creating stack from template '{}':",
            template_name
        ));

        let mut created = Vec::new();
        for (i, branch_name) in branch_names.iter().enumerate() {
            let info = repo.create_branch(branch_name)?;
            let desc = &template.branches[i].description;
            if desc.is_empty() {
                output::success(&format!("  {} Created '{}'", output::CHECKMARK, branch_name));
            } else {
                output::success(&format!(
                    "  {} Created '{}' ({})",
                    output::CHECKMARK,
                    branch_name,
                    desc
                ));
            }
            created.push(info);
        }

        output::info("");
        output::success(&format!(
            "Created {} branches from template '{}'",
            created.len(),
            template_name
        ));

        // Show the stack structure
        output::info("");
        output::info("Stack structure:");
        let parent = if args.from_trunk {
            repo.trunk().to_string()
        } else {
            created.first().map(|i| i.parent.clone()).unwrap_or_default()
        };
        output::info(&format!("  {}", parent));
        for (i, info) in created.iter().enumerate() {
            let prefix = if i == created.len() - 1 { "└─" } else { "├─" };
            let marker = if i == created.len() - 1 { "●" } else { "○" };
            output::info(&format!("  {} {} {}", prefix, marker, info.name));
        }

        return Ok(());
    }

    // Single branch mode
    let info = repo.create_branch(&args.name)?;

    output::success(&format!(
        "Created branch '{}' on top of '{}'",
        output::branch(&info.name, true),
        info.parent
    ));

    Ok(())
}