refactor: continue simplifying entrypoint

src/main.rs

@@ -36,12 +36,20 @@ use ui::view_panel::ViewPanel;
 
 struct CmdLineArgs {
     file_path: Option<PathBuf>,
-    headless_cmds: Vec<String>,
-    headless_script: Option<PathBuf>,
     import_path: Option<PathBuf>,
 }
 
-fn parse_args(args: Vec<String>) -> Option<CmdLineArgs> {
+enum ArgConfig {
+    Help,
+    Headless {
+        file_path: Option<PathBuf>,
+        commands: Vec<String>,
+        script: Option<PathBuf>,
+    },
+    Default(CmdLineArgs),
+}
+
+fn parse_args(args: Vec<String>) -> ArgConfig {
     let mut file_path: Option<PathBuf> = None;
     let mut headless_cmds: Vec<String> = Vec::new();
     let mut headless_script: Option<PathBuf> = None;
@@ -65,8 +73,7 @@ fn parse_args(args: Vec<String>) -> Option<CmdLineArgs> {
                 import_path = args.get(i).map(PathBuf::from);
             }
             "--help" | "-h" => {
-                print_usage();
+                return ArgConfig::Help;
-                return None;
             }
             arg if !arg.starts_with('-') => {
                 file_path = Some(PathBuf::from(arg));
@@ -76,10 +83,16 @@ fn parse_args(args: Vec<String>) -> Option<CmdLineArgs> {
         i += 1;
     }
 
-    return Some(CmdLineArgs {
+    if !headless_cmds.is_empty() || headless_script.is_some() {
+        return ArgConfig::Headless {
+            file_path,
+            commands: headless_cmds,
+            script: headless_script,
+        };
+    }
+
+    return ArgConfig::Default(CmdLineArgs {
         file_path,
-        headless_cmds,
-        headless_script,
         import_path,
     });
 }
@@ -107,45 +120,47 @@ fn get_initial_model(file_path: &Option<PathBuf>) -> Result<Model> {
 fn main() -> Result<()> {
     let args: Vec<String> = std::env::args().collect();
 
-    let cmd_line_args = if let Some(args) = parse_args(args) {
+    let arg_config = parse_args(args);
-        args
-    } else {
-        return Ok(());
-    };
 
-    // Load or create model
+    match arg_config {
-    let mut model = get_initial_model(&cmd_line_args.file_path)?;
+        ArgConfig::Default(cmd_line_args) => {
+            // Load or create model
+            let model = get_initial_model(&cmd_line_args.file_path)?;
 
-    // Headless mode
+            // Pre-TUI import: parse JSON and open wizard
-    if !cmd_line_args.headless_cmds.is_empty() || cmd_line_args.headless_script.is_some() {
+            let import_json = if let Some(ref path) = cmd_line_args.import_path {
-        return run_headless(
+                match std::fs::read_to_string(path) {
-            &mut model,
+                    Err(e) => {
-            cmd_line_args.file_path,
+                        eprintln!("Cannot read '{}': {e}", path.display());
-            cmd_line_args.headless_cmds,
+                        return Ok(());
-            cmd_line_args.headless_script,
+                    }
-        );
+                    Ok(content) => match serde_json::from_str::<serde_json::Value>(&content) {
-    }
+                        Err(e) => {
-
+                            eprintln!("JSON parse error: {e}");
-    // Pre-TUI import: parse JSON and open wizard
+                            return Ok(());
-    let import_json = if let Some(ref path) = cmd_line_args.import_path {
+                        }
-        match std::fs::read_to_string(path) {
+                        Ok(json) => Some(json),
-            Err(e) => {
+                    },
-                eprintln!("Cannot read '{}': {e}", path.display());
-                return Ok(());
-            }
-            Ok(content) => match serde_json::from_str::<serde_json::Value>(&content) {
-                Err(e) => {
-                    eprintln!("JSON parse error: {e}");
-                    return Ok(());
                 }
-                Ok(json) => Some(json),
+            } else {
-            },
+                None
-        }
+            };
-    } else {
-        None
-    };
 
-    run_tui(model, cmd_line_args.file_path, import_json)
+            run_tui(model, cmd_line_args.file_path, import_json)
+        }
+        ArgConfig::Headless {
+            file_path,
+            commands,
+            script,
+        } => {
+            let mut model = get_initial_model(&file_path)?;
+            return run_headless(&mut model, file_path, commands, script);
+        }
+        ArgConfig::Help => {
+            print_usage();
+            Ok(())
+        }
+    }
 }
 
 fn run_headless(