feat(repx-rs): add show command and improve list jobs filtering (#13)

Author: hakan-demirli

crates/repx-cli/src/main.rs

@@ -12,7 +12,10 @@ use which::which;
 #[command(version)]
 struct Cli {
     #[command(subcommand)]
-    command: Commands,
+    command: Option<Commands>,
+
+    #[arg(long, help = "Print help for all commands recursively")]
+    help_all: bool,
 
     #[arg(short, long, global = true, default_value = "./result")]
     pub lab: PathBuf,
@@ -74,8 +77,8 @@ struct VizArgs {
 
 #[derive(Args)]
 struct TraceParamsArgs {
-    #[arg(help = "Job ID to trace")]
-    job_id: String,
+    #[arg(help = "Job ID to trace (optional, shows all jobs if omitted)")]
+    job_id: Option<String>,
 }
 
 #[derive(Args)]
@@ -93,10 +96,60 @@ struct CompletionsArgs {
     shell: Shell,
 }
 
+fn print_help_all() {
+    let cmd = Cli::command();
+    print_command_help(&cmd, 0);
+}
+
+fn print_command_help(cmd: &clap::Command, depth: usize) {
+    let indent = "  ".repeat(depth);
+    let name = cmd.get_name();
+
+    if cmd.is_hide_set() {
+        return;
+    }
+
+    if depth == 0 {
+        println!("{}", "=".repeat(60));
+        println!("REPX - Complete Command Reference");
+        println!("{}", "=".repeat(60));
+        println!();
+    } else {
+        println!();
+        println!("{}{}", indent, "-".repeat(50 - indent.len()));
+        println!("{}Command: {}", indent, name);
+        println!("{}{}", indent, "-".repeat(50 - indent.len()));
+    }
+
+    let mut help_cmd = cmd.clone();
+    let help_text = help_cmd.render_help();
+
+    for line in help_text.to_string().lines() {
+        println!("{}{}", indent, line);
+    }
+
+    for subcmd in cmd.get_subcommands() {
+        print_command_help(subcmd, depth + 1);
+    }
+}
+
 fn main() {
     let cli = Cli::parse();
 
-    match cli.command {
+    if cli.help_all {
+        print_help_all();
+        return;
+    }
+
+    let command = match cli.command {
+        Some(cmd) => cmd,
+        None => {
+            Cli::command().print_help().unwrap();
+            return;
+        }
+    };
+
+    match command {
         Commands::Runner(cmd) => {
             let is_internal = matches!(
                 cmd.as_ref(),
@@ -153,15 +206,17 @@ fn main() {
         }
         Commands::TraceParams(args) => {
             run_python_tool("repx_py.cli.trace_params", |cmd| {
-                cmd.arg(args.job_id);
-                cmd.arg("--lab").arg(cli.lab);
+                cmd.arg(&cli.lab);
+                if let Some(job_id) = &args.job_id {
+                    cmd.arg("--job").arg(job_id);
+                }
             });
         }
         Commands::DebugRun(args) => {
             run_python_tool("repx_py.cli.debug_runner", |cmd| {
-                cmd.arg(args.job_id);
-                cmd.arg("--lab").arg(cli.lab);
-                if let Some(c) = args.command {
+                cmd.arg(&args.job_id);
+                cmd.arg("--lab").arg(&cli.lab);
+                if let Some(c) = &args.command {
                     cmd.arg("--command").arg(c);
                 }
             });

crates/repx-core/src/store/outcomes.rs

@@ -37,8 +37,9 @@ pub fn get_job_outcomes(
             continue;
         }
 
-        let success_marker = job_path.join(markers::SUCCESS);
-        let fail_marker = job_path.join(markers::FAIL);
+        let repx_dir = job_path.join(dirs::REPX);
+        let success_marker = repx_dir.join(markers::SUCCESS);
+        let fail_marker = repx_dir.join(markers::FAIL);
 
         if success_marker.exists() {
             outcomes.insert(

crates/repx-runner/src/cli.rs

@@ -61,6 +61,9 @@ pub enum Commands {
 
     #[command(about = "List runs, jobs, or dependencies")]
     List(ListArgs),
+
+    #[command(about = "Show detailed information")]
+    Show(ShowArgs),
 }
 
 #[derive(Args)]
@@ -69,18 +72,61 @@ pub struct ListArgs {
     pub entity: Option<ListEntity>,
 }
 
+#[derive(Args)]
+pub struct ShowArgs {
+    #[command(subcommand)]
+    pub entity: ShowEntity,
+}
+
+#[derive(Subcommand)]
+pub enum ShowEntity {
+    #[command(about = "Show detailed information about a job")]
+    Job(ShowJobArgs),
+    #[command(about = "Show contents of a job's output file")]
+    Output(ShowOutputArgs),
+}
+
+#[derive(Args)]
+pub struct ShowJobArgs {
+    #[arg(help = "Job ID (or prefix) to inspect")]
+    pub job_id: String,
+}
+
+#[derive(Args)]
+pub struct ShowOutputArgs {
+    #[arg(help = "Job ID (or prefix)")]
+    pub job_id: String,
+    #[arg(help = "Path to the output file (relative to job's out/ directory)")]
+    pub path: Option<String>,
+}
+
 #[derive(Subcommand)]
 pub enum ListEntity {
     Runs {
         #[arg(required = false, value_name = "RUN_NAME")]
         name: Option<String>,
     },
-    Jobs {
-        #[arg(required = false, value_name = "RUN_NAME")]
-        name: Option<String>,
-    },
+    Jobs(ListJobsArgs),
     #[command(alias = "deps")]
-    Dependencies { job_id: String },
+    Dependencies {
+        job_id: String,
+    },
+}
+
+#[derive(Args)]
+pub struct ListJobsArgs {
+    #[arg(required = false, value_name = "RUN_NAME")]
+    pub name: Option<String>,
+
+    #[arg(
+        long,
+        short = 's',
+        help = "Filter jobs by stage name (substring match)"
+    )]
+    pub stage: Option<String>,
+
+    #[arg(long, help = "Show output directory paths for each job")]
+    pub output_paths: bool,
 }
 
 #[derive(Args)]

crates/repx-runner/src/commands/list.rs

@@ -1,5 +1,8 @@
 use crate::cli::{ListArgs, ListEntity};
+use crate::error::CliError;
 use repx_core::{
+    config,
+    constants::dirs,
     errors::{ConfigError, DomainError},
     lab,
     model::{JobId, Lab, RunId},
@@ -8,17 +11,20 @@ use repx_core::{
 use std::path::Path;
 use std::str::FromStr;
 
-use crate::error::CliError;
-
 pub fn handle_list(args: ListArgs, lab_path: &Path) -> Result<(), CliError> {
     let lab = lab::load_from_path(lab_path)?;
 
     match args.entity.unwrap_or(ListEntity::Runs { name: None }) {
         ListEntity::Runs { name } => match name {
-            Some(n) => list_jobs(&lab, Some(&n)),
+            Some(n) => list_jobs(&lab, Some(&n), None, false),
             None => list_runs(&lab, lab_path),
         },
-        ListEntity::Jobs { name } => list_jobs(&lab, name.as_deref()),
+        ListEntity::Jobs(job_args) => list_jobs(
+            &lab,
+            job_args.name.as_deref(),
+            job_args.stage.as_deref(),
+            job_args.output_paths,
+        ),
         ListEntity::Dependencies { job_id } => list_dependencies(&lab, &job_id),
     }
 }
@@ -35,7 +41,30 @@ fn list_runs(lab: &Lab, lab_path: &Path) -> Result<(), CliError> {
     Ok(())
 }
 
-fn list_jobs(lab: &Lab, run_id_opt: Option<&str>) -> Result<(), CliError> {
+fn list_jobs(
+    lab: &Lab,
+    run_id_opt: Option<&str>,
+    stage_filter: Option<&str>,
+    show_output_paths: bool,
+) -> Result<(), CliError> {
+    let store_path = if show_output_paths {
+        let config = config::load_config()?;
+        let target_name = config.submission_target.as_ref().ok_or_else(|| {
+            CliError::Config(ConfigError::General(
+                "No submission target configured".to_string(),
+            ))
+        })?;
+        let target = config.targets.get(target_name).ok_or_else(|| {
+            CliError::Config(ConfigError::General(format!(
+                "Target '{}' not found in config",
+                target_name
+            )))
+        })?;
+        Some(target.base_path.clone())
+    } else {
+        None
+    };
+
     let run_id_str = match run_id_opt {
         Some(s) => s,
         None => {
@@ -49,8 +78,17 @@ fn list_jobs(lab: &Lab, run_id_opt: Option<&str>) -> Result<(), CliError> {
                 let run = &lab.runs[*run_id];
                 let mut jobs: Vec<_> = run.jobs.iter().collect();
                 jobs.sort();
+
+                let jobs: Vec<_> = if let Some(stage) = stage_filter {
+                    jobs.into_iter()
+                        .filter(|job_id| job_id.0.contains(stage))
+                        .collect()
+                } else {
+                    jobs
+                };
+
                 for job in jobs {
-                    println!("  {}", job);
+                    print_job_line(job, show_output_paths, &store_path);
                 }
             }
             return Ok(());
@@ -86,8 +124,24 @@ fn list_jobs(lab: &Lab, run_id_opt: Option<&str>) -> Result<(), CliError> {
         println!("Jobs in run '{}':", id);
         let mut jobs: Vec<_> = run.jobs.iter().collect();
         jobs.sort();
+
+        let jobs: Vec<_> = if let Some(stage) = stage_filter {
+            jobs.into_iter()
+                .filter(|job_id| job_id.0.contains(stage))
+                .collect()
+        } else {
+            jobs
+        };
+
+        if jobs.is_empty() && stage_filter.is_some() {
+            println!(
+                "  (no jobs matching stage filter '{}')",
+                stage_filter.unwrap()
+            );
+        }
+
         for job in jobs {
-            println!("  {}", job);
+            print_job_line(job, show_output_paths, &store_path);
         }
         Ok(())
     } else {
@@ -117,7 +171,7 @@ fn list_jobs(lab: &Lab, run_id_opt: Option<&str>) -> Result<(), CliError> {
                 }
                 if found_runs.len() == 1 {
                     println!();
-                    return list_jobs(lab, Some(&found_runs[0].0));
+                    return list_jobs(lab, Some(&found_runs[0].0), stage_filter, show_output_paths);
                 }
                 return Ok(());
             }
@@ -127,6 +181,27 @@ fn list_jobs(lab: &Lab, run_id_opt: Option<&str>) -> Result<(), CliError> {
     }
 }
 
+fn print_job_line(
+    job_id: &JobId,
+    show_output_paths: bool,
+    store_path: &Option<std::path::PathBuf>,
+) {
+    if show_output_paths {
+        if let Some(store) = store_path {
+            let output_path = store.join(dirs::OUTPUTS).join(&job_id.0).join(dirs::OUT);
+            if output_path.exists() {
+                println!("  {}  {}", job_id, output_path.display());
+            } else {
+                println!("  {}  (not executed)", job_id);
+            }
+        } else {
+            println!("  {}", job_id);
+        }
+    } else {
+        println!("  {}", job_id);
+    }
+}
+
 fn list_dependencies(lab: &Lab, job_id_str: &str) -> Result<(), CliError> {
     let target_input = RunId(job_id_str.to_string());
     let job_id = resolver::resolve_target_job_id(lab, &target_input)?;

crates/repx-runner/src/commands/mod.rs

@@ -7,6 +7,7 @@ pub mod internal;
 pub mod list;
 pub mod run;
 pub mod scatter_gather;
+pub mod show;
 
 pub struct AppContext<'a> {
     pub lab_path: &'a PathBuf,