cli: Add shell completion generation command

Add a hidden 'bootc completion <shell>' subcommand that generates
shell completion scripts for bash, zsh, and fish.

This enables distributions to generate and package shell completions
during RPM/deb build by calling 'bootc completion bash' etc.

The completion scripts include descriptions for all visible subcommands
and support prefix filtering for a better user experience.

Signed-off-by: Shion Tanaka <[email protected]>

Author: tnk4on

Cargo.lock

@@ -70,6 +70,7 @@ uuid = { version = "1.8.0", features = ["v4"] }
 uapi-version = "0.4.0"
 
 [dev-dependencies]
+clap_complete = "4"
 similar-asserts = { workspace = true }
 static_assertions = { workspace = true }
 

crates/lib/Cargo.toml

@@ -14,6 +14,7 @@ use cap_std_ext::cap_std;
 use cap_std_ext::cap_std::fs::Dir;
 use clap::Parser;
 use clap::ValueEnum;
+use clap::CommandFactory;
 use composefs::dumpfile;
 use composefs_boot::BootOps as _;
 use etc_merge::{compute_diff, print_diff};
@@ -406,6 +407,15 @@ pub(crate) enum ImageCmdOpts {
     },
 }
 
+/// Supported completion shells
+#[derive(Debug, Clone, ValueEnum, PartialEq, Eq)]
+#[clap(rename_all = "lowercase")]
+pub(crate) enum CompletionShell {
+    Bash,
+    Zsh,
+    Fish,
+}
+
 #[derive(ValueEnum, Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
 #[serde(rename_all = "kebab-case")]
 pub(crate) enum ImageListType {
@@ -733,6 +743,15 @@ pub(crate) enum Opt {
     /// Diff current /etc configuration versus default
     #[clap(hide = true)]
     ConfigDiff,
+    /// Generate shell completion script for supported shells.
+    ///
+    /// Example: `bootc completion bash` prints a bash completion script to stdout.
+    #[clap(hide = true)]
+    Completion {
+        /// Shell type to generate (bash, zsh, fish)
+        #[clap(value_enum)]
+        shell: CompletionShell,
+    },
     #[clap(hide = true)]
     DeleteDeployment {
         depl_id: String,
@@ -1573,6 +1592,83 @@ async fn run_from_opt(opt: Opt) -> Result<()> {
                 Ok(())
             }
         },
+        Opt::Completion { shell } => {
+            // Build the clap Command from our derived Opt
+            let cmd = Opt::command();
+
+            // Collect visible top-level subcommands and their about text
+            fn visible_subcommands(cmd: &clap::Command) -> Vec<(String, String)> {
+                let mut subs: Vec<(String, String)> = cmd
+                    .get_subcommands()
+                    .filter(|c| {
+                        // skip hidden subcommands and the help pseudo-command
+                        if c.is_hide_set() {
+                            return false;
+                        }
+                        if c.get_name() == "help" {
+                            return false;
+                        }
+                        true
+                    })
+                    .map(|c| {
+                        let name = c.get_name().to_string();
+                        let about = c.get_about().map(|s| s.to_string()).unwrap_or_default();
+                        (name, about)
+                    })
+                    .collect();
+                subs.sort_by_key(|(n, _)| n.clone());
+                subs
+            }
+
+            let subs = visible_subcommands(&cmd);
+
+            match shell {
+                CompletionShell::Zsh => {
+                    // zsh: produce a simple _describe-based completion with descriptions
+                    println!("#compdef bootc");
+                    println!("# Generated by bootc");
+                    println!("_bootc() {{");
+                    println!("  local -a commands");
+                    print!("  commands=(");
+                    for (name, about) in &subs {
+                        // escape single quotes
+                        let about_esc = about.replace('\'', "'\\''");
+                        print!(" '{}:{}'", name, about_esc);
+                    }
+                    println!(" )");
+                    println!("  _describe 'bootc commands' commands");
+                    println!("}}");
+                    println!("compdef _bootc bootc");
+                }
+                CompletionShell::Fish => {
+                    // fish: emit a complete line per command with description
+                    println!("# Generated by bootc");
+                    for (name, about) in &subs {
+                        let about_esc = about.replace('"', "\\\"");
+                        println!("complete -c bootc -n '__fish_use_subcommand' -a '{}' -d \"{}\"", name, about_esc);
+                    }
+                }
+                CompletionShell::Bash => {
+                    // bash: generate a simple completer that only lists top-level subcommands
+                    println!("# Generated by bootc");
+                    println!("_bootc() {{");
+                    println!("  local cur prev words cword");
+                    println!("  _init_completion || return");
+                    print!("  local -a cmds=(");
+                    for (name, _about) in &subs {
+                        print!(" {}", name);
+                    }
+                    println!(" )");
+                    println!("  if [ $COMP_CWORD -eq 1 ]; then");
+                    println!("    COMPREPLY=( $(compgen -W \"${{cmds[*]}}\" -- \"$cur\") )");
+                    println!("    return 0");
+                    println!("  fi");
+                    println!("}}");
+                    println!("complete -F _bootc bootc");
+                }
+            };
+            Ok(())
+        }
         Opt::Image(opts) => match opts {
             ImageOpts::List {
                 list_type,
@@ -1841,6 +1937,41 @@ async fn run_from_opt(opt: Opt) -> Result<()> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn visible_subcommands_filter_and_sort() {
+        let cmd = Opt::command();
+        // use the same helper as completion
+        let subs = {
+            fn visible_subcommands_for_test(cmd: &clap::Command) -> Vec<String> {
+                let mut names: Vec<String> = cmd
+                    .get_subcommands()
+                    .filter(|c| {
+                        if c.is_hide_set() {
+                            return false;
+                        }
+                        if c.get_name() == "help" {
+                            return false;
+                        }
+                        true
+                    })
+                    .map(|c| c.get_name().to_string())
+                    .collect();
+                names.sort();
+                names
+            }
+            visible_subcommands_for_test(&cmd)
+        };
+
+        // basic expectations: completion subcommand is hidden and must not appear
+        assert!(!subs.iter().any(|s| s == "completion"));
+        // help must not be present
+        assert!(!subs.iter().any(|s| s == "help"));
+        // ensure sorted order
+        let mut sorted = subs.clone();
+        sorted.sort();
+        assert_eq!(subs, sorted);
+    }
+
     #[test]
     fn test_callname() {
         use std::os::unix::ffi::OsStrExt;
@@ -1978,4 +2109,52 @@ mod tests {
         ]));
         assert_eq!(args.as_slice(), ["container", "image", "pull"]);
     }
+
+    #[test]
+    fn test_generate_completion_scripts_contain_commands() {
+        use clap_complete::{generate, shells::{Bash, Zsh, Fish}};
+
+        // For each supported shell, generate the completion script and
+        // ensure obvious subcommands appear in the output. This mirrors
+        // the style of completion checks used in other projects (e.g.
+        // podman) where the generated script is examined for expected
+        // tokens.
+
+        // `completion` is intentionally hidden from --help / suggestions;
+        // ensure other visible subcommands are present instead.
+        let want = ["install", "upgrade"];
+
+        // Bash
+        {
+            let mut cmd = Opt::command();
+            let mut buf = Vec::new();
+            generate(Bash, &mut cmd, "bootc", &mut buf);
+            let s = String::from_utf8(buf).expect("bash completion should be utf8");
+            for w in &want {
+                assert!(s.contains(w), "bash completion missing {w}");
+            }
+        }
+
+        // Zsh
+        {
+            let mut cmd = Opt::command();
+            let mut buf = Vec::new();
+            generate(Zsh, &mut cmd, "bootc", &mut buf);
+            let s = String::from_utf8(buf).expect("zsh completion should be utf8");
+            for w in &want {
+                assert!(s.contains(w), "zsh completion missing {w}");
+            }
+        }
+
+        // Fish
+        {
+            let mut cmd = Opt::command();
+            let mut buf = Vec::new();
+            generate(Fish, &mut cmd, "bootc", &mut buf);
+            let s = String::from_utf8(buf).expect("fish completion should be utf8");
+            for w in &want {
+                assert!(s.contains(w), "fish completion missing {w}");
+            }
+        }
+    }
 }