zacor 0.1.0

Package manager and dispatcher for zr — install, manage, and run modular CLI packages
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

use crate::{dispatch, paths, receipt};
use clap::{CommandFactory, FromArgMatches, Parser};
use std::path::Path;

#[derive(Parser)]
#[command(
    name = "zr",
    version,
    about = "Module dispatcher",
    disable_help_subcommand = true,
    allow_external_subcommands = true,
)]
struct ZrCli {
    /// Output raw JSONL instead of rendered text
    #[arg(long, conflicts_with = "text")]
    json: bool,

    /// Force rendered text output even when piped
    #[arg(long, conflicts_with = "json")]
    text: bool,

    #[command(subcommand)]
    command: Option<ZrCommand>,
}

#[derive(clap::Subcommand)]
enum ZrCommand {
    #[command(external_subcommand)]
    Module(Vec<String>),
}

/// Build the dynamic "Available packages" section for `zr --help`.
fn build_package_list_help(home: &Path) -> String {
    let mut out = String::new();

    if let Ok(packages) = receipt::list_all(home) {
        let active: Vec<_> = packages.iter().filter(|(_, r)| r.active).collect();
        if active.is_empty() {
            out.push_str("No packages installed. Use `zacor install` to add packages.");
        } else {
            out.push_str("Available packages:");
            for (name, r) in active {
                out.push_str(&format!("\n  {}  v{}", name, r.current));
            }
        }
    } else {
        out.push_str("No packages installed. Use `zacor install` to add packages.");
    }

    out
}

pub fn run() -> i32 {
    let home = match paths::zr_home() {
        Ok(h) => h,
        Err(e) => {
            eprintln!("error: {:#}", e);
            return 1;
        }
    };

    if let Err(e) = paths::ensure_dirs(&home) {
        eprintln!("error: {:#}", e);
        return 1;
    }

    let package_list = build_package_list_help(&home);
    let cli = match ZrCli::command()
        .after_help(package_list)
        .try_get_matches()
    {
        Ok(matches) => match ZrCli::from_arg_matches(&matches) {
            Ok(cli) => cli,
            Err(e) => {
                eprintln!("{}", e);
                return 1;
            }
        },
        Err(e) => {
            if e.use_stderr() {
                eprintln!("{}", e);
                return 1;
            } else {
                print!("{}", e);
                return 0;
            }
        }
    };

    match cli.command {
        Some(ZrCommand::Module(args)) => {
            let module_name = &args[0];
            let module_args: Vec<String> = args[1..].to_vec();
            match dispatch::run(&home, module_name, &module_args, cli.json, cli.text) {
                Ok(code) => code,
                Err(e) => {
                    eprintln!("error: {:#}", e);
                    1
                }
            }
        }
        None => {
            // No command given — show help with package list
            let package_list = build_package_list_help(&home);
            let _ = ZrCli::command()
                .after_help(package_list)
                .print_help();
            println!();
            0
        }
    }
}