varforge 0.1.1

Synthetic cancer sequencing test data generator
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! Command-line interface definitions for VarForge.
//!
//! Defines the top-level [`Args`] parser, the [`Command`] enum, and per-subcommand
//! option structs used by each subcommand module.
pub mod benchmark_suite;
pub mod cancer_presets;
pub mod edit;
pub mod learn_profile;
pub mod presets;
pub mod simulate;
pub mod validate;

use clap::{Parser, Subcommand};
use std::path::PathBuf;

#[derive(Parser)]
#[command(
    name = "varforge",
    version,
    about = "Synthetic cancer sequencing data generator"
)]
pub struct Args {
    #[command(subcommand)]
    pub command: Command,

    /// Log level: error, warn, info, debug, trace
    #[arg(long, global = true, default_value = "info")]
    pub log_level: String,

    /// Number of threads (default: all available cores)
    #[arg(short = 't', long, global = true)]
    pub threads: Option<usize>,
}

impl Args {
    pub fn log_level(&self) -> &str {
        &self.log_level
    }
}

#[derive(Subcommand)]
pub enum Command {
    /// Run a simulation from a YAML config
    Simulate(SimulateOpts),
    /// Validate a YAML config without running
    Validate(ValidateOpts),
    /// Spike variants into an existing BAM file
    Edit(edit::EditOpts),
    /// Learn an error/quality profile from a real BAM file
    LearnProfile(learn_profile::LearnProfileOpts),
    /// Run a VAF × coverage benchmark grid
    BenchmarkSuite(BenchmarkSuiteOpts),
}

#[derive(Parser)]
pub struct BenchmarkSuiteOpts {
    /// Path to base YAML configuration file
    #[arg(short, long)]
    pub config: PathBuf,
    /// VAF values to sweep (e.g. 0.01,0.05,0.1)
    #[arg(long, num_args = 1.., value_delimiter = ',')]
    pub vafs: Vec<f64>,
    /// Coverage values to sweep (e.g. 100,500,1000)
    #[arg(long, num_args = 1.., value_delimiter = ',')]
    pub coverages: Vec<f64>,
    /// Output base directory (overrides config)
    #[arg(short, long)]
    pub output: Option<PathBuf>,
}

#[derive(Parser)]
pub struct SimulateOpts {
    /// Path to YAML configuration file
    #[arg(short, long)]
    pub config: PathBuf,

    /// Override output directory
    #[arg(short, long)]
    pub output_dir: Option<PathBuf>,

    /// Override random seed
    #[arg(long)]
    pub seed: Option<u64>,

    /// Override coverage depth
    #[arg(long)]
    pub coverage: Option<f64>,

    /// Override read length (bp)
    #[arg(long)]
    pub read_length: Option<usize>,

    /// Override tumour purity (0.0–1.0)
    #[arg(long)]
    pub purity: Option<f64>,

    /// Override fragment mean length (bp)
    #[arg(long)]
    pub fragment_mean: Option<f64>,

    /// Override fragment length standard deviation (bp)
    #[arg(long)]
    pub fragment_sd: Option<f64>,

    /// Generate N random mutations (no VCF needed)
    #[arg(long)]
    pub random_mutations: Option<usize>,

    /// VAF range for random mutations (e.g., 0.001-0.05)
    #[arg(long)]
    pub vaf_range: Option<String>,

    /// Simulation preset: small, panel, wgs, cfdna, ffpe, umi
    #[arg(long)]
    pub preset: Option<String>,

    /// Validate config only, report estimated output size
    #[arg(long)]
    pub dry_run: bool,

    /// List all available presets and exit
    #[arg(long)]
    pub list_presets: bool,

    /// Set config variables: --set key=value (repeatable). Replaces ${key} in the YAML.
    #[arg(long = "set", value_name = "KEY=VALUE", action = clap::ArgAction::Append)]
    pub set: Option<Vec<String>>,
}

#[derive(Parser)]
pub struct ValidateOpts {
    /// Path to YAML configuration file
    #[arg(short, long)]
    pub config: PathBuf,
}