gitgrip 0.19.0

Multi-repo workflow tool - manage multiple git repositories as one
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

//! Run command implementation
//!
//! Runs workspace scripts defined in manifest.

use crate::cli::output::Output;
use crate::core::manifest::Manifest;
use std::path::PathBuf;
use std::process::Command;

/// Run the run command
pub fn run_run(
    workspace_root: &PathBuf,
    manifest: &Manifest,
    script_name: Option<&str>,
    list: bool,
) -> anyhow::Result<()> {
    let scripts = manifest.workspace.as_ref().and_then(|w| w.scripts.as_ref());

    if list || script_name.is_none() {
        // List available scripts
        Output::header("Workspace Scripts");
        println!();

        match scripts {
            Some(scripts) if !scripts.is_empty() => {
                for (name, script) in scripts {
                    let desc = script
                        .command
                        .as_deref()
                        .or_else(|| script.steps.as_ref().map(|_| "[multi-step]"))
                        .unwrap_or("[no command]");
                    println!("  {} - {}", name, desc);
                }
            }
            _ => {
                println!("  No scripts defined in manifest.");
                println!();
                println!("Define scripts in gripspace.yml:");
                println!("  workspace:");
                println!("    scripts:");
                println!("      build:");
                println!("        command: pnpm build");
            }
        }
        return Ok(());
    }

    let Some(name) = script_name else {
        return Ok(());
    };

    // Find the script
    let script = scripts.and_then(|s| s.get(name)).ok_or_else(|| {
        anyhow::anyhow!(
            "Script '{}' not found. Run `gr run --list` to see available scripts.",
            name
        )
    })?;

    Output::header(&format!("Running script: {}", name));
    println!();

    // Execute the script
    if let Some(ref command) = script.command {
        // Single command script
        run_command(workspace_root, command)?;
    } else if let Some(ref steps) = script.steps {
        // Multi-step script
        for (i, step) in steps.iter().enumerate() {
            println!(
                "Step {}/{}: {} - {}",
                i + 1,
                steps.len(),
                step.name,
                step.command
            );
            let working_dir = step
                .cwd
                .as_ref()
                .map(|p| workspace_root.join(p))
                .unwrap_or_else(|| workspace_root.clone());
            run_command(&working_dir, &step.command)?;
            println!();
        }
    } else {
        anyhow::bail!(
            "Script '{}' has no command or steps defined. \
             Check your gripspace.yml workspace.scripts section.",
            name
        );
    }

    Output::success(&format!("Script '{}' completed", name));
    Ok(())
}

fn run_command(working_dir: &PathBuf, command: &str) -> anyhow::Result<()> {
    let status = Command::new("sh")
        .arg("-c")
        .arg(command)
        .current_dir(working_dir)
        .status()?;

    if !status.success() {
        anyhow::bail!("Command failed with exit code: {:?}", status.code());
    }

    Ok(())
}