Refactor to use run module and add config CLI

- Add run module with ContainerEngine enum and run function
- Store pixi as Cow<'static, str> and adjust API
- Add util::dirs with cache_root
- Extend CLI with Config set of commands (Show/Get/Set/Unset/Edit/Path)
- Update imports and module structure to use crate::app and crate::run

Author: lyskov

src/app.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::{borrow::Cow, collections::HashMap};
 
 use clap::ValueEnum;
 
@@ -69,7 +69,7 @@ pub struct RunSpec {
 
     pub mounts: HashMap<MountRole, String>,
 
-    pub pixi: Option<String>,
+    pub pixi: Option<Cow<'static, str>>,
 }
 
 impl RunSpec {
@@ -90,7 +90,7 @@ impl RunSpec {
         self
     }
 
-    pub fn pixi(mut self, p: impl Into<String>) -> Self {
+    pub fn pixi(mut self, p: impl Into<Cow<'static, str>>) -> Self {
         self.pixi = Some(p.into());
         self
     }

src/executor.rs

@@ -5,23 +5,20 @@ mod native;
 use std::path::{Path, PathBuf};
 
 use anyhow::Result;
-use yansi::Paint;
 
-use super::App;
 use crate::{
-    ContainerEngine,
-    app::{Image, RunSpec},
+    app::{App, Image, RunSpec},
+    run::ContainerEngine,
 };
 
 pub struct Executor {
-    #[allow(dead_code)]
     app: App,
     working_dir: PathBuf,
     engine: ContainerEngine,
 }
 
 impl Executor {
-    fn new(app: App, engine: ContainerEngine, working_dir: PathBuf) -> Self {
+    pub fn new(app: App, engine: ContainerEngine, working_dir: PathBuf) -> Self {
         Executor {
             app,
             working_dir,
@@ -52,29 +49,6 @@ impl Executor {
     // }
 }
 
-pub fn run(
-    app: &App,
-    app_args: Vec<String>,
-    container_engine: &ContainerEngine,
-    working_dir: PathBuf,
-) -> Result<()> {
-    println!(
-        "Running app: {} in directory: {}{}",
-        app.green(),
-        working_dir.display(),
-        if app_args.is_empty() {
-            "".into()
-        } else {
-            format!(
-                " with arguments: {}",
-                format!("{:?}", app_args).bright_blue()
-            )
-        }
-    );
-
-    Executor::new(app.to_owned(), *container_engine, working_dir).execute(app.run_spec(app_args))
-}
-
 struct Telemetry {
     working_dir: PathBuf,
     prefix: String,

src/executor/docker.rs

@@ -4,15 +4,14 @@ use anyhow::Result;
 use yansi::Paint;
 
 use crate::{
-    ContainerEngine,
     app::{MountRole, RunSpec},
     executor::{Executor, Telemetry},
-    util,
+    run, util,
 };
 
 impl Executor {
     pub(super) fn execute_with_docker(&self, spec: RunSpec) -> Result<()> {
-        assert!(matches!(self.engine, ContainerEngine::Docker));
+        assert!(matches!(self.engine, run::ContainerEngine::Docker));
 
         util::Command::shell(format!(
             "docker image inspect {0} >/dev/null 2>&1 || docker image pull {0}",

src/executor/hpc_container.rs

@@ -1,10 +1,10 @@
-use std::{env::home_dir, fs, path::PathBuf};
+use std::{fs, path::PathBuf};
 
 use crate::{
-    ContainerEngine,
     app::{MountRole, RunSpec},
     executor::{Executor, Image, Telemetry},
-    util::{self, Command},
+    run,
+    util::{self, Command, dirs},
 };
 
 use anyhow::Result;
@@ -19,7 +19,7 @@ impl Executor {
     pub(super) fn execute_with_hpc_container_engine(&self, spec: RunSpec) -> Result<()> {
         assert!(matches!(
             self.engine,
-            ContainerEngine::Singularity | ContainerEngine::Apptainer
+            run::ContainerEngine::Singularity | run::ContainerEngine::Apptainer
         ));
 
         //self.log_execute_info(&spec);
@@ -112,7 +112,7 @@ impl Executor {
     }
 
     fn images_root(&self) -> PathBuf {
-        let root = home_dir().unwrap().join(".cache/rosettacommons/rc/hpc");
+        let root = dirs::cache_root().join("hpc");
         std::fs::create_dir_all(&root).unwrap();
         root
     }

src/executor/native.rs

@@ -4,13 +4,14 @@ use anyhow::anyhow;
 use home::home_dir;
 use yansi::Paint;
 
+use crate::run;
 use crate::util::Command;
 use crate::util::ensure_dir_signature;
-use crate::{ContainerEngine, app::RunSpec, executor::Executor};
+use crate::{app::RunSpec, executor::Executor};
 
 impl Executor {
     pub(super) fn execute_native(&self, spec: RunSpec) -> Result<()> {
-        assert!(matches!(self.engine, ContainerEngine::None));
+        assert!(matches!(self.engine, run::ContainerEngine::None));
 
         let recipe = spec
             .pixi
@@ -23,21 +24,25 @@ impl Executor {
             .unwrap()
             .join(format!(".cache/rosettacommons/rc/native/{}.pixi", self.app));
 
-        ensure_dir_signature(&pixi_evn_root, &[&spec.image.0, &recipe], |d| {
-            std::fs::write(d.join("pixi.toml"), &recipe)?;
-            Command::new("pixi")
-                .cd(d)
-                .arg("run")
-                .arg("setup")
-                .live()
-                .exec()?;
-            Ok(())
-        })?;
+        ensure_dir_signature(
+            &pixi_evn_root,
+            &[spec.image.0.as_ref(), recipe.as_ref()],
+            |d| {
+                std::fs::write(d.join("pixi.toml"), recipe.as_ref())?;
+                Command::new("pixi")
+                    .cd(d)
+                    .arg("run")
+                    .arg("setup")
+                    .live()
+                    .exec()?;
+                Ok(())
+            },
+        )?;
 
         Ok(())
     }
 
-    /// Check if Pixi is installed
+    /// Check if Pixi is installed, fail if not
     fn check_if_pixi_is_installed() -> Result<()> {
         match which::which("pixi") {
             Ok(_) => Ok(()),

src/main.rs

@@ -1,14 +1,16 @@
 mod app;
 mod executor;
+mod run;
 mod util;
 
-use std::{path::PathBuf, process};
+use std::path::PathBuf;
+use std::process;
 
 use anyhow::Result;
-use clap::{Parser, Subcommand, ValueEnum};
+use clap::{Parser, Subcommand};
 use yansi::Paint;
 
-use app::App;
+use crate::app::App;
 
 /// A command line tool to run various Rosetta applications
 #[derive(Parser, Debug)]
@@ -27,15 +29,6 @@ struct Args {
     verbose: bool,
 }
 
-#[derive(ValueEnum, Clone, Copy, Debug, strum::Display)]
-#[strum(serialize_all = "lowercase")] //  "kebab-case"
-enum ContainerEngine {
-    Docker,
-    Singularity,
-    Apptainer,
-    None,
-}
-
 #[derive(Subcommand, Debug)]
 enum Commands {
     /// Clean an app installation
@@ -67,8 +60,65 @@ enum Commands {
         working_dir: Option<PathBuf>,
 
         #[arg(short = 'e', long, default_value = "docker")]
-        container_engine: ContainerEngine,
+        container_engine: run::ContainerEngine,
+    },
+
+    Config {
+        #[command(subcommand)]
+        config_command: ConfigCmd,
+    },
+}
+
+#[derive(Subcommand, Debug)]
+enum ConfigCmd {
+    /// Show the effective configuration
+    Show(ConfigShowArgs),
+
+    /// Get a single configuration value
+    Get {
+        /// Dotted key path, e.g. `cache.root`
+        key: String,
+
+        /// Output as JSON (useful for scripting)
+        #[arg(long)]
+        json: bool,
+    },
+
+    /// Set a configuration value
+    Set {
+        /// Dotted key path, e.g. `cache.root`
+        key: String,
+
+        /// Value to set (stringly-typed; you parse/validate per key)
+        value: String,
     },
+
+    /// Remove a configuration override (fall back to defaults)
+    Unset {
+        /// Dotted key path, e.g. `cache.root`
+        key: String,
+    },
+
+    /// Open the config file in $EDITOR
+    Edit,
+
+    /// Print the config file path
+    Path,
+}
+
+#[derive(clap::Args, Debug)]
+struct ConfigShowArgs {
+    /// Output as JSON (useful for scripting)
+    #[arg(long)]
+    json: bool,
+
+    /// Output as TOML (optional; pick what you support)
+    #[arg(long, conflicts_with = "json")]
+    toml: bool,
+
+    /// Include where each value came from (defaults/env/file)
+    #[arg(long)]
+    origin: bool,
 }
 
 fn main() -> Result<()> {
@@ -100,8 +150,12 @@ fn main() -> Result<()> {
                 .canonicalize()
                 .unwrap();
 
-            executor::run(app, app_args.clone(), container_engine, working_dir)
+            run::run(app, app_args.clone(), container_engine, working_dir)
         }
+        Some(Commands::Config { config_command: _ }) => {
+            todo!();
+        }
+
         None => {
             eprintln!("Error: No command specified");
             eprintln!("Use --help to see available commands");

src/run.rs

@@ -0,0 +1,40 @@
+use std::path::PathBuf;
+
+use anyhow::Result;
+use clap::ValueEnum;
+use yansi::Paint;
+
+use crate::{app, executor};
+
+#[derive(ValueEnum, Clone, Copy, Debug, strum::Display)]
+#[strum(serialize_all = "lowercase")] //  "kebab-case"
+pub enum ContainerEngine {
+    Docker,
+    Singularity,
+    Apptainer,
+    None,
+}
+
+pub fn run(
+    app: &app::App,
+    app_args: Vec<String>,
+    container_engine: &ContainerEngine,
+    working_dir: PathBuf,
+) -> Result<()> {
+    println!(
+        "Running app: {} in directory: {}{}",
+        app.green(),
+        working_dir.display(),
+        if app_args.is_empty() {
+            "".into()
+        } else {
+            format!(
+                " with arguments: {}",
+                format!("{:?}", app_args).bright_blue()
+            )
+        }
+    );
+
+    executor::Executor::new(app.to_owned(), *container_engine, working_dir)
+        .execute(app.run_spec(app_args))
+}

src/util.rs

@@ -2,6 +2,7 @@
 
 mod command;
 mod dir_guard;
+pub mod dirs;
 mod yansi;
 
 use std::io::{self, Write};

src/util/dirs.rs

@@ -0,0 +1,7 @@
+use std::path::PathBuf;
+
+use home::home_dir;
+
+pub fn cache_root() -> PathBuf {
+    home_dir().unwrap().join(".cache/rosettacommons/rc")
+}