add dynamic shell completions (#51)

* add remote path shell completion

* add completion for job id and allow job name as well

* update readme

Author: Panaetius

Cargo.lock

@@ -16,6 +16,7 @@ Table of contents
    * [Usage](#usage)
       * [Logging in](#logging-in)
       * [CLI](#cli)
+        * [Shell Completions](#shell-completions)
       * [Terminal UI](#tui)
       * [SSH](#ssh)
       * [coman.toml config file](#comantoml-config-file)
@@ -227,28 +228,26 @@ Upload a file:
 coman cscs file upload /my/local/file /capstor/scratch/cscs/your_user/your_file
 ```
 
+#### Shell Completions
 You can set up shell completions as follows:
 
 ```shell
 # Bash
-mkdir -p ~/.local/share/bash-completion/completions
-coman completions bash > ~/.local/share/bash-completion/completions/coman
+echo "source <(COMPLETE=bash coman)" >> ~/.bashrc
 
-# Bash (macOS/Homebrew)
-mkdir -p $(brew --prefix)/etc/bash_completion.d/
-coman completions bash > $(brew --prefix)/etc/bash_completion.d/coman.bash-completion
 
 # Fish
-mkdir -p ~/.config/fish/completions
-coman completions fish > ~/.config/fish/completions/coman.fish
+echo "COMPLETE=fish coman | source" >> ~/.config/fish/config.fish
 
 # Zsh
-mkdir ~/.zfunc
-# Then add the following lines to your `.zshrc` just before
-# `compinit`:
-# 
-#         fpath+=~/.zfunc
-coman completions zsh > ~/.zfunc/_coman
+echo "source <(COMPLETE=zsh coman)" >> ~/.zshrc
+
+# Powershell
+echo '$env:COMPLETE = "powershell"; coman | Out-String | Invoke-Expression; Remove-Item Env:\COMPLETE' >> $PROFILE
+
+# Elvish
+echo "eval (E:COMPLETE=elvish coman | slurp)" >> ~/.elvish/rc.elv
+
 ```
 ### TUI
 

README.md

@@ -1,6 +1,6 @@
 [package]
 name = "coman"
-version = "0.5.7"
+version = "0.6.0"
 edition = "2024"
 description = "Compute Manager for managing HPC compute"
 authors = ["Ralf Grubenmann <ralf.grubenmann@sdsc.ethz.ch>"]
@@ -73,7 +73,7 @@ openssl = { version = "0.10.75", features = ["vendored"] }
 tui-realm-treeview = "3.0.0"
 aws-sdk-s3 = "1.115.0"
 toml_edit = "0.23.9"
-clap_complete = "4.5.61"
+clap_complete = { version = "4.5.61", features = ["unstable-dynamic"] }
 pid1 = "0.1.5"
 rust_supervisor = "0.2.0"
 iroh-ssh = "0.2.7"

coman/Cargo.toml

@@ -1,22 +1,24 @@
-use std::{error::Error, path::PathBuf, thread, time::Duration};
+use std::{error::Error, path::PathBuf, str::FromStr, thread, time::Duration};
 
 use base64::prelude::*;
 use clap::{Args, Command, Parser, Subcommand, ValueHint, builder::TypedValueParser};
-use clap_complete::{Generator, Shell, generate};
-use color_eyre::{Result, eyre::eyre};
+use clap_complete::{ArgValueCompleter, CompletionCandidate, Generator, Shell, generate};
+use color_eyre::{Report, Result, eyre::eyre};
 use iroh_ssh::IrohSsh;
+use itertools::Itertools;
 use pid1::Pid1Settings;
 use rust_supervisor::{ChildType, Supervisor, SupervisorConfig};
 use strum::VariantNames;
+use tokio::sync::mpsc;
 
 use crate::{
     config::{ComputePlatform, Config, get_config_dir, get_data_dir, get_project_local_config_file},
     cscs::{
         api_client::{
             client::{EdfSpec as EdfSpecEnum, ScriptSpec as ScriptSpecEnum},
-            types::JobStatus,
+            types::{JobStatus, PathType},
         },
-        handlers::cscs_job_details,
+        handlers::{cscs_file_list, cscs_job_details, cscs_job_list, file_system_roots},
     },
     util::types::DockerImageUrl,
 };
@@ -143,7 +145,7 @@ pub struct ScriptSpec {
     generate_script: bool,
     #[arg(long, value_name = "PATH", help = "upload local script file", value_hint=ValueHint::FilePath)]
     local_script: Option<PathBuf>,
-    #[arg(long, value_name = "PATH", help = "use script file already present on remote", value_hint=ValueHint::Other)]
+    #[arg(long, value_name = "PATH", help = "use script file already present on remote", add = ArgValueCompleter::new(remote_path_completer))]
     remote_script: Option<PathBuf>,
 }
 impl Default for ScriptSpec {
@@ -178,7 +180,7 @@ pub struct EdfSpec {
     generate_edf: bool,
     #[arg(long, value_name = "PATH", help = "upload local edf file", value_hint=ValueHint::FilePath)]
     local_edf: Option<PathBuf>,
-    #[arg(long, value_name = "PATH", help = "use edf file already present on remote", value_hint=ValueHint::Other)]
+    #[arg(long, value_name = "PATH", help = "use edf file already present on remote", add = ArgValueCompleter::new(remote_path_completer))]
     remote_edf: Option<PathBuf>,
 }
 
@@ -204,22 +206,38 @@ impl From<EdfSpec> for EdfSpecEnum {
     }
 }
 
+#[derive(Debug, Clone)]
+pub enum JobIdOrName {
+    Id(i64),
+    Name(String),
+}
+
+impl FromStr for JobIdOrName {
+    type Err = Report;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        Ok(s.parse::<i64>()
+            .map(JobIdOrName::Id)
+            .unwrap_or_else(|_| JobIdOrName::Name(s.to_string())))
+    }
+}
+
 #[allow(clippy::large_enum_variant)]
 #[derive(Subcommand, Debug)]
 pub enum CscsJobCommands {
     #[clap(alias("ls"), about = "List all jobs [aliases: ls]")]
     List,
     #[clap(alias("g"), about = "Get metadata for a specific job [aliases: g]")]
     Get {
-        #[arg(help="id of the job", value_hint=ValueHint::Other)]
-        job_id: i64,
+        #[arg(help="id or name of the job (name uses newest job of that name)", add = ArgValueCompleter::new(job_id_or_name_completer))]
+        job: JobIdOrName,
     },
     #[clap(about = "Get the stdout of a job")]
     Log {
         #[clap(short, long, action, help = "whether to get stderr instead of stdout")]
         stderr: bool,
-        #[arg(help="id of the job", value_hint=ValueHint::Other)]
-        job_id: i64,
+        #[arg(help="id or name of the job (name uses newest job of that name)", add = ArgValueCompleter::new(job_id_or_name_completer))]
+        job: JobIdOrName,
     },
 
     #[clap(alias("s"), about = "Submit a new compute job [aliases: s]")]
@@ -269,26 +287,80 @@ pub enum CscsJobCommands {
         about = "Cancel a running job, fails if the job isn't running [aliases: c]"
     )]
     Cancel {
-        #[clap(help="id of the job", value_hint=ValueHint::Other)]
-        job_id: i64,
+        #[clap(help="id or name of the job (name uses newest job of that name)",  add = ArgValueCompleter::new(job_id_or_name_completer))]
+        job: JobIdOrName,
     },
 }
+fn job_id_or_name_completer(current: &std::ffi::OsStr) -> Vec<CompletionCandidate> {
+    let mut completions = vec![];
+    let Some(current) = current.to_str() else {
+        return completions;
+    };
+    let jn = JobIdOrName::from_str(current).unwrap();
+    // the tokio shenanigans here are to be able to call async code from this sync method,
+    // with an already running async runtime from tokio::main, and getting back the result,
+    // all without blocking the async runtime in sync code (hence the extra thread).
+    let (send, mut recv) = mpsc::unbounded_channel();
+    match jn {
+        JobIdOrName::Id(id) => {
+            tokio::spawn(async move {
+                let jobs = cscs_job_list(None, None).await.unwrap();
+                let partial_id = id.to_string();
+                let ids: Vec<_> = jobs
+                    .iter()
+                    .map(|j| (j.id.to_string(), j.name.clone()))
+                    .filter(|i| i.0.starts_with(&partial_id))
+                    .sorted_by_key(|i| i.0.clone())
+                    .collect();
+                for (id, name) in ids {
+                    send.send(CompletionCandidate::new(id).help(Some(name.into()))).unwrap();
+                }
+            });
+        }
+        JobIdOrName::Name(name) => {
+            tokio::spawn(async move {
+                let jobs = cscs_job_list(None, None).await.unwrap();
+                let names: Vec<_> = jobs
+                    .into_iter()
+                    .map(|j| j.name)
+                    .filter(|n| n.starts_with(&name))
+                    .sorted()
+                    .dedup()
+                    .collect();
+                for name in names {
+                    send.send(CompletionCandidate::new(name)).unwrap();
+                }
+            });
+        }
+    }
+    let sync_recv = thread::spawn(move || {
+        let mut completions = vec![];
+        while let Some(candidate) = recv.blocking_recv() {
+            completions.push(candidate);
+        }
+        completions
+    });
+    let comp = sync_recv.join().unwrap();
+    completions.extend(comp);
+
+    completions
+}
 
 #[derive(Subcommand, Debug)]
 pub enum CscsFileCommands {
     #[clap(alias("ls"), about = "List folders and files in a remote path [aliases: ls]")]
     List {
-        #[arg(help ="remote path to list", value_hint=ValueHint::Other)]
+        #[arg(help ="remote path to list", add = ArgValueCompleter::new(remote_path_completer))]
         path: PathBuf,
     },
     #[clap(alias("rm"), about = "Remove remote files or folders [aliases: rm]")]
     Remove {
-        #[arg(help ="remote path to remove", value_hint=ValueHint::Other)]
+        #[arg(help ="remote path to remove", add = ArgValueCompleter::new(remote_path_completer))]
         path: PathBuf,
     },
     #[clap(alias("dl"), about = "Download a remote file [aliases: dl]")]
     Download {
-        #[clap(help = "The path in the cluster to download", value_hint=ValueHint::Other)]
+        #[clap(help = "The path in the cluster to download", add = ArgValueCompleter::new(remote_path_completer))]
         remote: PathBuf,
         #[clap(help = "The local path to download the file to", value_hint=ValueHint::AnyPath)]
         local: PathBuf,
@@ -298,11 +370,78 @@ pub enum CscsFileCommands {
         #[clap(help = "The local path to upload to the cluster", value_hint=ValueHint::AnyPath)]
         local: PathBuf,
 
-        #[clap(help = "the path in the cluster to upload to", value_hint=ValueHint::Other)]
+        #[clap(help = "the path in the cluster to upload to", add = ArgValueCompleter::new(remote_path_completer))]
         remote: PathBuf,
     },
 }
 
+fn remote_path_completer(current: &std::ffi::OsStr) -> Vec<CompletionCandidate> {
+    let mut completions = vec![];
+    let Some(current) = current.to_str() else {
+        return completions;
+    };
+
+    // the tokio shenanigans here are to be able to call async code from this sync method,
+    // with an already running async runtime from tokio::main, and getting back the result,
+    // all without blocking the async runtime in sync code (hence the extra thread).
+    let (send, mut recv) = mpsc::unbounded_channel();
+    if current.is_empty() || current == "/" {
+        tokio::spawn(async move {
+            let roots = file_system_roots().await;
+            if let Ok(roots) = roots {
+                for root in roots {
+                    send.send(CompletionCandidate::new(root.name.clone())).unwrap();
+                }
+            }
+        });
+    } else {
+        let current = PathBuf::from(current);
+        tokio::spawn(async move {
+            let parent = current.parent().unwrap();
+            let roots = cscs_file_list(current.clone(), None, None).await;
+            if let Ok(roots) = roots {
+                for root in roots {
+                    if root.path_type == PathType::File {
+                        send.send(CompletionCandidate::new(current.join(root.name.clone())))
+                            .unwrap();
+                    } else {
+                        // joining with "" ensures trailing slash
+                        send.send(CompletionCandidate::new(current.join(root.name.clone()).join("")))
+                            .unwrap();
+                    }
+                }
+            } else {
+                // file listing only work for full paths, so if we want to complet a partial result, we need
+                // to list the parent folder and take it from there
+                if let Ok(roots) = cscs_file_list(parent.to_path_buf(), None, None).await {
+                    let partial = current.file_name().unwrap().to_string_lossy().into_owned();
+                    for root in roots {
+                        if root.name.starts_with(&partial) {
+                            if root.path_type == PathType::File {
+                                send.send(CompletionCandidate::new(parent.join(root.name))).unwrap();
+                            } else {
+                                // joining with "" ensures trailing slash
+                                send.send(CompletionCandidate::new(parent.join(root.name.clone()).join("")))
+                                    .unwrap();
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    }
+    let sync_recv = thread::spawn(move || {
+        let mut completions = vec![];
+        while let Some(candidate) = recv.blocking_recv() {
+            completions.push(candidate);
+        }
+        completions
+    });
+    let comp = sync_recv.join().unwrap();
+    completions.extend(comp);
+
+    completions
+}
 #[derive(Subcommand, Debug)]
 pub enum CscsSystemCommands {
     #[clap(alias("ls"), about = "List available compute systems [aliases: ls]")]