Skip to main content

greentic_dev/
cli.rs

1use std::{ffi::OsString, path::PathBuf};
2
3use crate::secrets_cli::SecretsCommand;
4use clap::{Arg, ArgAction, Args, CommandFactory, Parser, Subcommand};
5
6#[derive(Parser, Debug)]
7#[command(name = "greentic-dev")]
8#[command(version)]
9#[command(about = "cli.root.about")]
10pub struct Cli {
11    #[command(subcommand)]
12    pub command: Command,
13}
14
15pub fn localized_help_command(locale: &str) -> clap::Command {
16    let mut command = Cli::command()
17        .about(crate::i18n::t(locale, "cli.root.about"))
18        .disable_help_subcommand(true)
19        .disable_help_flag(true)
20        .disable_version_flag(true)
21        .arg(
22            Arg::new("help")
23                .short('h')
24                .long("help")
25                .action(ArgAction::Help)
26                .help(crate::i18n::t(locale, "cli.help.flag")),
27        )
28        .arg(
29            Arg::new("version")
30                .short('V')
31                .long("version")
32                .action(ArgAction::Version)
33                .help(crate::i18n::t(locale, "cli.version.flag")),
34        )
35        .arg(
36            Arg::new("locale")
37                .long("locale")
38                .global(true)
39                .value_name("LOCALE")
40                .help(crate::i18n::t(locale, "cli.option.locale")),
41        );
42
43    for (name, key) in [
44        ("flow", "cli.command.flow.about"),
45        ("pack", "cli.command.pack.about"),
46        ("component", "cli.command.component.about"),
47        ("bundle", "cli.command.bundle.about"),
48        ("runner", "cli.command.runner.about"),
49        ("config", "cli.command.config.about"),
50        ("coverage", "cli.command.coverage.about"),
51        ("mcp", "cli.command.mcp.about"),
52        ("gui", "cli.command.gui.about"),
53        ("secrets", "cli.command.secrets.about"),
54        ("tools", "cli.command.tools.about"),
55        ("install", "cli.command.install.about"),
56        ("release", "cli.command.release.about"),
57        ("cbor", "cli.command.cbor.about"),
58        ("wizard", "cli.command.wizard.about"),
59    ] {
60        command = command.mut_subcommand(name, |sub| sub.about(crate::i18n::t(locale, key)));
61    }
62
63    command = command.mut_subcommand("secrets", |sub| {
64        sub.about(crate::i18n::t(locale, "cli.command.secrets.about"))
65            .mut_subcommand("init", |sub| {
66                sub.about(crate::i18n::t(locale, "cli.command.secrets.init.about"))
67                    .mut_arg("pack", |arg| {
68                        arg.help(crate::i18n::t(locale, "cli.command.secrets.init.pack"))
69                    })
70                    .mut_arg("passthrough", |arg| {
71                        arg.help(crate::i18n::t(
72                            locale,
73                            "cli.command.secrets.init.passthrough",
74                        ))
75                    })
76            })
77    });
78    command = command
79        .mut_subcommand("config", |sub| {
80            sub.about(crate::i18n::t(locale, "cli.command.config.about"))
81                .mut_subcommand("set", |sub| {
82                    sub.about(crate::i18n::t(locale, "cli.command.config.set.about"))
83                        .mut_arg("key", |arg| {
84                            arg.help(crate::i18n::t(locale, "cli.command.config.set.key"))
85                        })
86                        .mut_arg("value", |arg| {
87                            arg.help(crate::i18n::t(locale, "cli.command.config.set.value"))
88                        })
89                        .mut_arg("file", |arg| {
90                            arg.help(crate::i18n::t(locale, "cli.command.config.set.file"))
91                        })
92                })
93        })
94        .mut_subcommand("mcp", |sub| {
95            sub.about(crate::i18n::t(locale, "cli.command.mcp.about"))
96                .mut_subcommand("doctor", |sub| {
97                    sub.about(crate::i18n::t(locale, "cli.command.mcp.doctor.about"))
98                        .mut_arg("provider", |arg| {
99                            arg.help(crate::i18n::t(locale, "cli.command.mcp.doctor.provider"))
100                        })
101                        .mut_arg("json", |arg| {
102                            arg.help(crate::i18n::t(locale, "cli.command.mcp.doctor.json"))
103                        })
104                })
105        })
106        .mut_subcommand("tools", |sub| {
107            sub.about(crate::i18n::t(locale, "cli.command.tools.about"))
108                .mut_subcommand("install", |sub| {
109                    sub.about(crate::i18n::t(locale, "cli.command.tools.install.about"))
110                        .mut_arg("latest", |arg| {
111                            arg.help(crate::i18n::t(locale, "cli.command.tools.install.latest"))
112                        })
113                })
114        })
115        .mut_subcommand("install", |sub| {
116            sub.about(crate::i18n::t(locale, "cli.command.install.about"))
117                .mut_subcommand("tools", |sub| {
118                    sub.about(crate::i18n::t(locale, "cli.command.install.tools.about"))
119                        .mut_arg("latest", |arg| {
120                            arg.help(crate::i18n::t(locale, "cli.command.tools.install.latest"))
121                        })
122                })
123                .mut_arg("tenant", |arg| {
124                    arg.help(crate::i18n::t(locale, "cli.command.install.tenant"))
125                })
126                .mut_arg("token", |arg| {
127                    arg.help(crate::i18n::t(locale, "cli.command.install.token"))
128                })
129                .mut_arg("bin_dir", |arg| {
130                    arg.help(crate::i18n::t(locale, "cli.command.install.bin_dir"))
131                })
132                .mut_arg("docs_dir", |arg| {
133                    arg.help(crate::i18n::t(locale, "cli.command.install.docs_dir"))
134                })
135                .mut_arg("locale", |arg| {
136                    arg.help(crate::i18n::t(locale, "cli.command.install.locale"))
137                })
138        })
139        .mut_subcommand("release", |sub| {
140            sub.about(crate::i18n::t(locale, "cli.command.release.about"))
141                .mut_subcommand("generate", |sub| {
142                    sub.about(crate::i18n::t(locale, "cli.command.release.generate.about"))
143                        .mut_arg("release", |arg| {
144                            arg.help(crate::i18n::t(locale, "cli.command.release.release"))
145                        })
146                        .mut_arg("from", |arg| {
147                            arg.help(crate::i18n::t(locale, "cli.command.release.from"))
148                        })
149                        .mut_arg("repo", |arg| {
150                            arg.help(crate::i18n::t(locale, "cli.command.release.repo"))
151                        })
152                        .mut_arg("token", |arg| {
153                            arg.help(crate::i18n::t(locale, "cli.command.release.token"))
154                        })
155                        .mut_arg("out", |arg| {
156                            arg.help(crate::i18n::t(locale, "cli.command.release.out"))
157                        })
158                        .mut_arg("dry_run", |arg| {
159                            arg.help(crate::i18n::t(locale, "cli.command.release.dry_run"))
160                        })
161                })
162                .mut_subcommand("publish", |sub| {
163                    sub.about(crate::i18n::t(locale, "cli.command.release.publish.about"))
164                        .mut_arg("release", |arg| {
165                            arg.help(crate::i18n::t(locale, "cli.command.release.release"))
166                        })
167                        .mut_arg("from", |arg| {
168                            arg.help(crate::i18n::t(locale, "cli.command.release.from"))
169                        })
170                        .mut_arg("tag", |arg| {
171                            arg.help(crate::i18n::t(locale, "cli.command.release.tag"))
172                        })
173                        .mut_arg("manifest", |arg| {
174                            arg.help(crate::i18n::t(locale, "cli.command.release.manifest"))
175                        })
176                        .mut_arg("repo", |arg| {
177                            arg.help(crate::i18n::t(locale, "cli.command.release.repo"))
178                        })
179                        .mut_arg("token", |arg| {
180                            arg.help(crate::i18n::t(locale, "cli.command.release.token"))
181                        })
182                        .mut_arg("out", |arg| {
183                            arg.help(crate::i18n::t(locale, "cli.command.release.out"))
184                        })
185                        .mut_arg("dry_run", |arg| {
186                            arg.help(crate::i18n::t(locale, "cli.command.release.dry_run"))
187                        })
188                        .mut_arg("force", |arg| {
189                            arg.help(crate::i18n::t(locale, "cli.command.release.force"))
190                        })
191                })
192                .mut_subcommand("view", |sub| {
193                    sub.about(crate::i18n::t(locale, "cli.command.release.view.about"))
194                        .mut_arg("release", |arg| {
195                            arg.help(crate::i18n::t(locale, "cli.command.release.release"))
196                        })
197                        .mut_arg("tag", |arg| {
198                            arg.help(crate::i18n::t(locale, "cli.command.release.tag"))
199                        })
200                        .mut_arg("repo", |arg| {
201                            arg.help(crate::i18n::t(locale, "cli.command.release.repo"))
202                        })
203                        .mut_arg("token", |arg| {
204                            arg.help(crate::i18n::t(locale, "cli.command.release.token"))
205                        })
206                })
207                .mut_subcommand("latest", |sub| {
208                    sub.about(crate::i18n::t(locale, "cli.command.release.latest.about"))
209                        .mut_arg("repo", |arg| {
210                            arg.help(crate::i18n::t(locale, "cli.command.release.repo"))
211                        })
212                        .mut_arg("token", |arg| {
213                            arg.help(crate::i18n::t(locale, "cli.command.release.token"))
214                        })
215                        .mut_arg("dry_run", |arg| {
216                            arg.help(crate::i18n::t(locale, "cli.command.release.dry_run"))
217                        })
218                        .mut_arg("force", |arg| {
219                            arg.help(crate::i18n::t(locale, "cli.command.release.force"))
220                        })
221                })
222                .mut_subcommand("promote", |sub| {
223                    sub.about(crate::i18n::t(locale, "cli.command.release.promote.about"))
224                        .mut_arg("release", |arg| {
225                            arg.help(crate::i18n::t(locale, "cli.command.release.release"))
226                        })
227                        .mut_arg("tag", |arg| {
228                            arg.help(crate::i18n::t(locale, "cli.command.release.tag"))
229                        })
230                        .mut_arg("repo", |arg| {
231                            arg.help(crate::i18n::t(locale, "cli.command.release.repo"))
232                        })
233                        .mut_arg("token", |arg| {
234                            arg.help(crate::i18n::t(locale, "cli.command.release.token"))
235                        })
236                        .mut_arg("dry_run", |arg| {
237                            arg.help(crate::i18n::t(locale, "cli.command.release.dry_run"))
238                        })
239                })
240        })
241        .mut_subcommand("cbor", |sub| {
242            sub.about(crate::i18n::t(locale, "cli.command.cbor.about"))
243                .mut_arg("path", |arg| {
244                    arg.help(crate::i18n::t(locale, "cli.command.cbor.path"))
245                })
246        })
247        .mut_subcommand("coverage", |sub| {
248            sub.about(crate::i18n::t(locale, "cli.command.coverage.about"))
249                .mut_arg("skip_run", |arg| {
250                    arg.help(crate::i18n::t(locale, "cli.command.coverage.skip_run"))
251                })
252        })
253        .mut_subcommand("wizard", |sub| {
254            sub.about(crate::i18n::t(locale, "cli.command.wizard.about"))
255                .mut_arg("answers", |arg| {
256                    arg.help(crate::i18n::t(locale, "cli.command.wizard.answers"))
257                })
258                .mut_arg("frontend", |arg| {
259                    arg.help(crate::i18n::t(locale, "cli.command.wizard.frontend"))
260                })
261                .mut_arg("locale", |arg| {
262                    arg.help(crate::i18n::t(locale, "cli.command.wizard.locale"))
263                })
264                .mut_arg("emit_answers", |arg| {
265                    arg.help(crate::i18n::t(locale, "cli.command.wizard.emit_answers"))
266                })
267                .mut_arg("schema", |arg| {
268                    arg.help(crate::i18n::t(locale, "cli.command.wizard.schema"))
269                        .long_help(crate::i18n::t(locale, "cli.command.wizard.schema_long"))
270                })
271                .mut_arg("schema_version", |arg| {
272                    arg.help(crate::i18n::t(locale, "cli.command.wizard.schema_version"))
273                })
274                .mut_arg("migrate", |arg| {
275                    arg.help(crate::i18n::t(locale, "cli.command.wizard.migrate"))
276                })
277                .mut_arg("out", |arg| {
278                    arg.help(crate::i18n::t(locale, "cli.command.wizard.out"))
279                })
280                .mut_arg("dry_run", |arg| {
281                    arg.help(crate::i18n::t(locale, "cli.command.wizard.dry_run"))
282                })
283                .mut_arg("yes", |arg| {
284                    arg.help(crate::i18n::t(locale, "cli.command.wizard.yes"))
285                })
286                .mut_arg("non_interactive", |arg| {
287                    arg.help(crate::i18n::t(locale, "cli.command.wizard.non_interactive"))
288                })
289                .mut_arg("unsafe_commands", |arg| {
290                    arg.help(crate::i18n::t(locale, "cli.command.wizard.unsafe_commands"))
291                })
292                .mut_arg("allow_destructive", |arg| {
293                    arg.help(crate::i18n::t(
294                        locale,
295                        "cli.command.wizard.allow_destructive",
296                    ))
297                })
298                .mut_subcommand("validate", |sub| {
299                    sub.about(crate::i18n::t(locale, "cli.command.wizard.validate.about"))
300                        .mut_arg("answers", |arg| {
301                            arg.help(crate::i18n::t(locale, "cli.command.wizard.answers"))
302                        })
303                        .mut_arg("frontend", |arg| {
304                            arg.help(crate::i18n::t(locale, "cli.command.wizard.frontend"))
305                        })
306                        .mut_arg("locale", |arg| {
307                            arg.help(crate::i18n::t(locale, "cli.command.wizard.locale"))
308                        })
309                        .mut_arg("emit_answers", |arg| {
310                            arg.help(crate::i18n::t(locale, "cli.command.wizard.emit_answers"))
311                        })
312                        .mut_arg("schema_version", |arg| {
313                            arg.help(crate::i18n::t(locale, "cli.command.wizard.schema_version"))
314                        })
315                        .mut_arg("migrate", |arg| {
316                            arg.help(crate::i18n::t(locale, "cli.command.wizard.migrate"))
317                        })
318                        .mut_arg("out", |arg| {
319                            arg.help(crate::i18n::t(locale, "cli.command.wizard.out"))
320                        })
321                })
322                .mut_subcommand("apply", |sub| {
323                    sub.about(crate::i18n::t(locale, "cli.command.wizard.apply.about"))
324                        .mut_arg("answers", |arg| {
325                            arg.help(crate::i18n::t(locale, "cli.command.wizard.answers"))
326                        })
327                        .mut_arg("frontend", |arg| {
328                            arg.help(crate::i18n::t(locale, "cli.command.wizard.frontend"))
329                        })
330                        .mut_arg("locale", |arg| {
331                            arg.help(crate::i18n::t(locale, "cli.command.wizard.locale"))
332                        })
333                        .mut_arg("emit_answers", |arg| {
334                            arg.help(crate::i18n::t(locale, "cli.command.wizard.emit_answers"))
335                        })
336                        .mut_arg("schema_version", |arg| {
337                            arg.help(crate::i18n::t(locale, "cli.command.wizard.schema_version"))
338                        })
339                        .mut_arg("migrate", |arg| {
340                            arg.help(crate::i18n::t(locale, "cli.command.wizard.migrate"))
341                        })
342                        .mut_arg("out", |arg| {
343                            arg.help(crate::i18n::t(locale, "cli.command.wizard.out"))
344                        })
345                        .mut_arg("yes", |arg| {
346                            arg.help(crate::i18n::t(locale, "cli.command.wizard.yes"))
347                        })
348                        .mut_arg("non_interactive", |arg| {
349                            arg.help(crate::i18n::t(locale, "cli.command.wizard.non_interactive"))
350                        })
351                        .mut_arg("unsafe_commands", |arg| {
352                            arg.help(crate::i18n::t(locale, "cli.command.wizard.unsafe_commands"))
353                        })
354                        .mut_arg("allow_destructive", |arg| {
355                            arg.help(crate::i18n::t(
356                                locale,
357                                "cli.command.wizard.allow_destructive",
358                            ))
359                        })
360                })
361        });
362
363    localize_help_tree(command, locale, true)
364}
365
366fn localize_help_tree(mut command: clap::Command, locale: &str, is_root: bool) -> clap::Command {
367    command = command
368        .disable_help_subcommand(true)
369        .disable_help_flag(true);
370    let arg_ids = command
371        .get_arguments()
372        .map(|arg| arg.get_id().as_str().to_string())
373        .collect::<Vec<_>>();
374    if arg_ids.iter().any(|id| id == "help") {
375        command = command.mut_arg("help", |arg| {
376            arg.help(crate::i18n::t(locale, "cli.help.flag"))
377        });
378    } else {
379        command = command.arg(
380            Arg::new("help")
381                .short('h')
382                .long("help")
383                .action(ArgAction::Help)
384                .help(crate::i18n::t(locale, "cli.help.flag")),
385        );
386    }
387    if is_root && arg_ids.iter().any(|id| id == "version") {
388        command = command.mut_arg("version", |arg| {
389            arg.help(crate::i18n::t(locale, "cli.version.flag"))
390        });
391    }
392
393    let sub_names = command
394        .get_subcommands()
395        .map(|sub| sub.get_name().to_string())
396        .collect::<Vec<_>>();
397    for name in sub_names {
398        command = command.mut_subcommand(name, |sub| localize_help_tree(sub, locale, false));
399    }
400
401    command
402}
403
404#[derive(Subcommand, Debug)]
405pub enum Command {
406    /// cli.command.flow.about
407    Flow(PassthroughArgs),
408    /// cli.command.pack.about
409    Pack(PassthroughArgs),
410    /// cli.command.component.about
411    Component(PassthroughArgs),
412    /// cli.command.bundle.about
413    Bundle(PassthroughArgs),
414    /// cli.command.runner.about
415    Runner(PassthroughArgs),
416    /// cli.command.config.about
417    #[command(subcommand)]
418    Config(ConfigCommand),
419    /// cli.command.coverage.about
420    Coverage(CoverageArgs),
421    /// cli.command.mcp.about
422    #[command(subcommand)]
423    Mcp(McpCommand),
424    /// cli.command.gui.about
425    Gui(PassthroughArgs),
426    /// cli.command.secrets.about
427    #[command(subcommand)]
428    Secrets(SecretsCommand),
429    /// cli.command.tools.about
430    #[command(subcommand)]
431    Tools(ToolsCommand),
432    /// cli.command.install.about
433    Install(InstallArgs),
434    /// cli.command.release.about
435    #[command(subcommand)]
436    Release(ReleaseCommand),
437    /// cli.command.cbor.about
438    Cbor(CborArgs),
439    /// cli.command.wizard.about
440    Wizard(Box<WizardCommand>),
441}
442
443#[derive(Args, Debug, Clone)]
444#[command(disable_help_flag = true)]
445pub struct PassthroughArgs {
446    /// cli.command.passthrough.args
447    #[arg(
448        value_name = "ARGS",
449        trailing_var_arg = true,
450        allow_hyphen_values = true
451    )]
452    pub args: Vec<OsString>,
453}
454
455#[derive(Subcommand, Debug)]
456pub enum McpCommand {
457    /// cli.command.mcp.doctor.about
458    Doctor(McpDoctorArgs),
459}
460
461#[derive(Args, Debug)]
462pub struct McpDoctorArgs {
463    /// cli.command.mcp.doctor.provider
464    pub provider: String,
465    /// cli.command.mcp.doctor.json
466    #[arg(long = "json")]
467    pub json: bool,
468}
469
470#[derive(Subcommand, Debug)]
471pub enum ConfigCommand {
472    /// cli.command.config.set.about
473    Set(ConfigSetArgs),
474}
475
476#[derive(Subcommand, Debug)]
477pub enum ToolsCommand {
478    /// cli.command.tools.install.about
479    Install(ToolsInstallArgs),
480}
481
482#[derive(Subcommand, Debug)]
483pub enum InstallSubcommand {
484    /// cli.command.install.tools.about
485    Tools(ToolsInstallArgs),
486}
487
488#[derive(Subcommand, Debug)]
489pub enum ReleaseCommand {
490    /// cli.command.release.generate.about
491    Generate(ReleaseGenerateArgs),
492    /// cli.command.release.publish.about
493    Publish(ReleasePublishArgs),
494    /// cli.command.release.view.about
495    View(ReleaseViewArgs),
496    /// cli.command.release.latest.about
497    Latest(ReleaseLatestArgs),
498    /// cli.command.release.promote.about
499    Promote(ReleasePromoteArgs),
500    /// cli.command.release.snapshot.about
501    Snapshot(ReleaseSnapshotArgs),
502}
503
504#[derive(Args, Debug)]
505pub struct InstallArgs {
506    #[command(subcommand)]
507    pub command: Option<InstallSubcommand>,
508    /// cli.command.install.tenant
509    #[arg(long = "tenant")]
510    pub tenant: Option<String>,
511    /// cli.command.install.token
512    #[arg(long = "token")]
513    pub token: Option<String>,
514    /// cli.command.install.bin_dir
515    #[arg(long = "bin-dir")]
516    pub bin_dir: Option<PathBuf>,
517    /// cli.command.install.docs_dir
518    #[arg(long = "docs-dir")]
519    pub docs_dir: Option<PathBuf>,
520    /// cli.command.install.locale
521    #[arg(long = "locale")]
522    pub locale: Option<String>,
523}
524
525#[derive(Args, Debug)]
526pub struct ToolsInstallArgs {
527    /// cli.command.tools.install.latest
528    #[arg(long = "latest")]
529    pub latest: bool,
530}
531
532#[derive(Args, Debug)]
533pub struct ReleaseGenerateArgs {
534    /// cli.command.release.release
535    #[arg(long = "release")]
536    pub release: String,
537    /// cli.command.release.from
538    #[arg(long = "from", default_value = "latest")]
539    pub from: String,
540    /// cli.command.release.repo
541    #[arg(
542        long = "repo",
543        default_value = "ghcr.io/greenticai/greentic-versions/gtc"
544    )]
545    pub repo: String,
546    /// cli.command.release.token
547    #[arg(long = "token")]
548    pub token: Option<String>,
549    /// cli.command.release.out
550    #[arg(long = "out", default_value = "dist/toolchains")]
551    pub out: PathBuf,
552    /// cli.command.release.dry_run
553    #[arg(long = "dry-run")]
554    pub dry_run: bool,
555}
556
557#[derive(Args, Debug)]
558pub struct ReleasePublishArgs {
559    /// cli.command.release.release
560    #[arg(long = "release", required_unless_present = "manifest")]
561    pub release: Option<String>,
562    /// cli.command.release.from
563    #[arg(long = "from", default_value = "latest", requires = "release")]
564    pub from: Option<String>,
565    /// cli.command.release.tag
566    #[arg(long = "tag")]
567    pub tag: Option<String>,
568    /// cli.command.release.manifest
569    #[arg(long = "manifest", required_unless_present = "release")]
570    pub manifest: Option<PathBuf>,
571    /// cli.command.release.repo
572    #[arg(
573        long = "repo",
574        default_value = "ghcr.io/greenticai/greentic-versions/gtc"
575    )]
576    pub repo: String,
577    /// cli.command.release.token
578    #[arg(long = "token")]
579    pub token: Option<String>,
580    /// cli.command.release.out
581    #[arg(long = "out", default_value = "dist/toolchains")]
582    pub out: PathBuf,
583    /// cli.command.release.dry_run
584    #[arg(long = "dry-run")]
585    pub dry_run: bool,
586    /// cli.command.release.force
587    #[arg(long = "force")]
588    pub force: bool,
589}
590
591#[derive(Args, Debug)]
592pub struct ReleaseViewArgs {
593    /// cli.command.release.release
594    #[arg(
595        long = "release",
596        conflicts_with = "tag",
597        required_unless_present = "tag"
598    )]
599    pub release: Option<String>,
600    /// cli.command.release.tag
601    #[arg(
602        long = "tag",
603        conflicts_with = "release",
604        required_unless_present = "release"
605    )]
606    pub tag: Option<String>,
607    /// cli.command.release.repo
608    #[arg(
609        long = "repo",
610        default_value = "ghcr.io/greenticai/greentic-versions/gtc"
611    )]
612    pub repo: String,
613    /// cli.command.release.token
614    #[arg(long = "token")]
615    pub token: Option<String>,
616}
617
618#[derive(Args, Debug)]
619pub struct ReleaseLatestArgs {
620    /// cli.command.release.repo
621    #[arg(
622        long = "repo",
623        default_value = "ghcr.io/greenticai/greentic-versions/gtc"
624    )]
625    pub repo: String,
626    /// cli.command.release.token
627    #[arg(long = "token")]
628    pub token: Option<String>,
629    /// cli.command.release.dry_run
630    #[arg(long = "dry-run")]
631    pub dry_run: bool,
632    /// cli.command.release.force
633    #[arg(long = "force")]
634    pub force: bool,
635}
636
637#[derive(Args, Debug)]
638pub struct ReleasePromoteArgs {
639    /// cli.command.release.release
640    #[arg(long = "release")]
641    pub release: String,
642    /// cli.command.release.tag
643    #[arg(long = "tag")]
644    pub tag: String,
645    /// cli.command.release.repo
646    #[arg(
647        long = "repo",
648        default_value = "ghcr.io/greenticai/greentic-versions/gtc"
649    )]
650    pub repo: String,
651    /// cli.command.release.token
652    #[arg(long = "token")]
653    pub token: Option<String>,
654    /// cli.command.release.dry_run
655    #[arg(long = "dry-run")]
656    pub dry_run: bool,
657}
658
659#[derive(Args, Debug)]
660pub struct ReleaseSnapshotArgs {
661    /// cli.command.release.release
662    #[arg(long = "release")]
663    pub release: String,
664    /// cli.command.release.snapshot.channel
665    #[arg(long = "channel", default_value = "dev")]
666    pub channel: String,
667    /// cli.command.release.tag
668    #[arg(long = "tag")]
669    pub tag: Option<String>,
670    /// cli.command.release.repo
671    #[arg(
672        long = "repo",
673        default_value = "ghcr.io/greenticai/greentic-versions/gtc"
674    )]
675    pub repo: String,
676    /// cli.command.release.token
677    #[arg(long = "token")]
678    pub token: Option<String>,
679    /// cli.command.release.out
680    #[arg(long = "out", default_value = "dist/toolchains")]
681    pub out: PathBuf,
682    /// cli.command.release.dry_run
683    #[arg(long = "dry-run")]
684    pub dry_run: bool,
685    /// cli.command.release.force
686    #[arg(long = "force")]
687    pub force: bool,
688}
689
690#[derive(Args, Debug)]
691pub struct ConfigSetArgs {
692    /// cli.command.config.set.key
693    pub key: String,
694    /// cli.command.config.set.value
695    pub value: String,
696    /// cli.command.config.set.file
697    #[arg(long = "file")]
698    pub file: Option<PathBuf>,
699}
700
701#[derive(Args, Debug)]
702pub struct CborArgs {
703    /// cli.command.cbor.path
704    #[arg(value_name = "PATH")]
705    pub path: PathBuf,
706}
707
708#[derive(Args, Debug, Clone)]
709pub struct CoverageArgs {
710    /// cli.command.coverage.skip_run
711    #[arg(long = "skip-run")]
712    pub skip_run: bool,
713}
714
715#[derive(Args, Debug, Clone)]
716pub struct WizardCommand {
717    #[command(subcommand)]
718    pub command: Option<WizardSubcommand>,
719    #[command(flatten)]
720    pub launch: WizardLaunchArgs,
721}
722
723#[derive(Subcommand, Debug, Clone)]
724pub enum WizardSubcommand {
725    /// cli.command.wizard.validate.about
726    Validate(WizardValidateArgs),
727    /// cli.command.wizard.apply.about
728    Apply(WizardApplyArgs),
729}
730
731#[derive(Args, Debug, Clone)]
732pub struct WizardLaunchArgs {
733    /// cli.command.wizard.answers (local path or http/https URL)
734    #[arg(long = "answers")]
735    pub answers: Option<String>,
736    /// cli.command.wizard.frontend
737    #[arg(long = "frontend", default_value = "json")]
738    pub frontend: String,
739    /// cli.command.wizard.locale
740    #[arg(long = "locale")]
741    pub locale: Option<String>,
742    /// cli.command.wizard.emit_answers
743    #[arg(long = "emit-answers")]
744    pub emit_answers: Option<PathBuf>,
745    /// cli.command.wizard.schema
746    #[arg(long = "schema")]
747    pub schema: bool,
748    /// cli.command.wizard.schema_version
749    #[arg(long = "schema-version")]
750    pub schema_version: Option<String>,
751    /// cli.command.wizard.migrate
752    #[arg(long = "migrate")]
753    pub migrate: bool,
754    /// cli.command.wizard.out
755    #[arg(long = "out")]
756    pub out: Option<PathBuf>,
757    /// cli.command.wizard.dry_run
758    #[arg(long = "dry-run")]
759    pub dry_run: bool,
760    /// cli.command.wizard.yes
761    #[arg(long = "yes")]
762    pub yes: bool,
763    /// cli.command.wizard.non_interactive
764    #[arg(long = "non-interactive")]
765    pub non_interactive: bool,
766    /// cli.command.wizard.unsafe_commands
767    #[arg(long = "unsafe-commands")]
768    pub unsafe_commands: bool,
769    /// cli.command.wizard.allow_destructive
770    #[arg(long = "allow-destructive")]
771    pub allow_destructive: bool,
772}
773
774#[derive(Args, Debug, Clone)]
775pub struct WizardValidateArgs {
776    /// cli.command.wizard.answers (local path or http/https URL)
777    #[arg(long = "answers")]
778    pub answers: String,
779    /// cli.command.wizard.frontend
780    #[arg(long = "frontend", default_value = "json")]
781    pub frontend: String,
782    /// cli.command.wizard.locale
783    #[arg(long = "locale")]
784    pub locale: Option<String>,
785    /// cli.command.wizard.emit_answers
786    #[arg(long = "emit-answers")]
787    pub emit_answers: Option<PathBuf>,
788    /// cli.command.wizard.schema_version
789    #[arg(long = "schema-version")]
790    pub schema_version: Option<String>,
791    /// cli.command.wizard.migrate
792    #[arg(long = "migrate")]
793    pub migrate: bool,
794    /// cli.command.wizard.out
795    #[arg(long = "out")]
796    pub out: Option<PathBuf>,
797}
798
799#[derive(Args, Debug, Clone)]
800pub struct WizardApplyArgs {
801    /// cli.command.wizard.answers (local path or http/https URL)
802    #[arg(long = "answers")]
803    pub answers: String,
804    /// cli.command.wizard.frontend
805    #[arg(long = "frontend", default_value = "json")]
806    pub frontend: String,
807    /// cli.command.wizard.locale
808    #[arg(long = "locale")]
809    pub locale: Option<String>,
810    /// cli.command.wizard.emit_answers
811    #[arg(long = "emit-answers")]
812    pub emit_answers: Option<PathBuf>,
813    /// cli.command.wizard.schema_version
814    #[arg(long = "schema-version")]
815    pub schema_version: Option<String>,
816    /// cli.command.wizard.migrate
817    #[arg(long = "migrate")]
818    pub migrate: bool,
819    /// cli.command.wizard.out
820    #[arg(long = "out")]
821    pub out: Option<PathBuf>,
822    /// cli.command.wizard.yes
823    #[arg(long = "yes")]
824    pub yes: bool,
825    /// cli.command.wizard.non_interactive
826    #[arg(long = "non-interactive")]
827    pub non_interactive: bool,
828    /// cli.command.wizard.unsafe_commands
829    #[arg(long = "unsafe-commands")]
830    pub unsafe_commands: bool,
831    /// cli.command.wizard.allow_destructive
832    #[arg(long = "allow-destructive")]
833    pub allow_destructive: bool,
834}