refactor: extract helper functions and improve code organization

- README: Update tagline to clarify declarative nature
- command.rs: Extract test helper functions for better readability
- retry.rs: Split complex functions into smaller, focused helpers
- parsers.rs: Refactor git status parsing with dedicated functions

Author: iepathos

README.md

@@ -4,7 +4,7 @@
 [![Security](https://github.com/iepathos/mmm/actions/workflows/security.yml/badge.svg)](https://github.com/iepathos/mmm/actions/workflows/security.yml)
 [![Release](https://github.com/iepathos/mmm/actions/workflows/release.yml/badge.svg)](https://github.com/iepathos/mmm/actions/workflows/release.yml)
 
-Define AI-assisted development workflows in YAML. Run bounded, testable improvement loops. Ship better code.
+Define declarative AI development workflows in YAML. Run bounded, testable improvement loops. Ship better code.
 
 ## What Is MMM?
 

src/config/command.rs

@@ -802,7 +802,15 @@ commit_required: false
 
     #[test]
     fn test_workflow_config_with_new_syntax() {
-        // Test parsing the exact structure used in coverage.yml
+        let config = parse_test_workflow_config();
+        assert_eq!(config.commands.len(), 3);
+
+        verify_coverage_command(&config.commands[0]);
+        verify_implement_spec_command(&config.commands[1]);
+        verify_lint_command(&config.commands[2]);
+    }
+
+    fn parse_test_workflow_config() -> WorkflowConfig {
         let yaml = r#"
 commands:
     - claude: "/mmm-coverage"
@@ -820,65 +828,72 @@ commands:
       commit_required: false
 "#;
 
-        let config: WorkflowConfig = match serde_yaml::from_str(yaml) {
-            Ok(c) => c,
-            Err(e) => {
-                // Try to parse just the commands array to debug
-                let yaml_value: serde_yaml::Value = serde_yaml::from_str(yaml).unwrap();
-                if let Some(commands) = yaml_value.get("commands") {
-                    println!("Commands value: {commands:?}");
-
-                    // Try to parse each command
-                    if let Some(seq) = commands.as_sequence() {
-                        for (i, cmd) in seq.iter().enumerate() {
-                            println!("\nCommand {i}: {cmd:?}");
-                            match serde_yaml::from_value::<WorkflowStepCommand>(cmd.clone()) {
-                                Ok(_parsed) => println!("  Parsed as WorkflowStepCommand: success"),
-                                Err(e2) => println!("  Failed as WorkflowStepCommand: {e2}"),
-                            }
-                            match serde_yaml::from_value::<WorkflowCommand>(cmd.clone()) {
-                                Ok(parsed) => println!("  Parsed as WorkflowCommand: {parsed:?}"),
-                                Err(e2) => println!("  Failed as WorkflowCommand: {e2}"),
-                            }
-                        }
-                    }
-                }
-                panic!("Failed to parse WorkflowConfig: {e}");
+        serde_yaml::from_str(yaml).unwrap_or_else(|e| {
+            debug_workflow_parsing_error(yaml, &e);
+            panic!("Failed to parse WorkflowConfig: {e}");
+        })
+    }
+
+    fn debug_workflow_parsing_error(yaml: &str, _error: &serde_yaml::Error) {
+        let yaml_value: serde_yaml::Value = serde_yaml::from_str(yaml).unwrap();
+        if let Some(commands) = yaml_value.get("commands") {
+            println!("Commands value: {commands:?}");
+            if let Some(seq) = commands.as_sequence() {
+                debug_command_sequence(seq);
             }
-        };
-        assert_eq!(config.commands.len(), 3);
+        }
+    }
+
+    fn debug_command_sequence(seq: &[serde_yaml::Value]) {
+        for (i, cmd) in seq.iter().enumerate() {
+            println!("\nCommand {i}: {cmd:?}");
+            try_parse_as::<WorkflowStepCommand>(cmd, "WorkflowStepCommand");
+            try_parse_as::<WorkflowCommand>(cmd, "WorkflowCommand");
+        }
+    }
 
-        // Verify first command
-        match &config.commands[0] {
+    fn try_parse_as<T: serde::de::DeserializeOwned + std::fmt::Debug>(
+        value: &serde_yaml::Value,
+        type_name: &str,
+    ) {
+        match serde_yaml::from_value::<T>(value.clone()) {
+            Ok(parsed) => println!("  Parsed as {type_name}: {parsed:?}"),
+            Err(e) => println!("  Failed as {type_name}: {e}"),
+        }
+    }
+
+    fn verify_coverage_command(command: &WorkflowCommand) {
+        match command {
             WorkflowCommand::WorkflowStep(step) => {
                 assert_eq!(step.claude, Some("/mmm-coverage".to_string()));
                 assert_eq!(step.id, Some("coverage".to_string()));
                 assert!(!step.commit_required);
                 assert!(step.outputs.is_some());
                 assert!(step.analysis.is_some());
             }
-            _ => panic!("Expected WorkflowStep variant for first command"),
+            _ => panic!("Expected WorkflowStep variant for coverage command"),
         }
+    }
 
-        // Verify second command
-        match &config.commands[1] {
+    fn verify_implement_spec_command(command: &WorkflowCommand) {
+        match command {
             WorkflowCommand::WorkflowStep(step) => {
                 assert_eq!(
                     step.claude,
                     Some("/mmm-implement-spec ${coverage.spec}".to_string())
                 );
-                // inputs removed - arguments now passed directly in command string
             }
-            _ => panic!("Expected WorkflowStep variant for second command"),
+            _ => panic!("Expected WorkflowStep variant for implement-spec command"),
         }
+    }
 
-        // Verify third command
-        match &config.commands[2] {
+    fn verify_lint_command(command: &WorkflowCommand) {
+        match command {
             WorkflowCommand::WorkflowStep(step) => {
                 assert_eq!(step.claude, Some("/mmm-lint".to_string()));
                 assert!(!step.commit_required);
             }
-            _ => panic!("Expected WorkflowStep variant for third command"),
+            _ => panic!("Expected WorkflowStep variant for lint command"),
         }
     }
 }

src/cook/retry.rs

@@ -38,54 +38,29 @@ pub async fn execute_with_retry(
 
     while attempt <= max_retries {
         if attempt > 0 {
-            let delay = Duration::from_secs(2u64.pow(attempt.min(3))); // Exponential backoff, max 8s
-            if verbose {
-                println!(
-                    "⏳ Retrying {description} after {delay:?} (attempt {attempt}/{max_retries})"
-                );
-            }
-            sleep(delay).await;
+            await_retry_delay(attempt, description, max_retries, verbose).await;
         }
 
         match command.output().await {
             Ok(output) => {
-                // Check if it's a transient error we should retry
-                if !output.status.success() {
-                    let stderr = String::from_utf8_lossy(&output.stderr);
-
-                    // Retry on specific error conditions
-                    if is_transient_error(&stderr) && attempt < max_retries {
-                        if verbose {
-                            eprintln!(
-                                "⚠️  Transient error detected: {}",
-                                stderr.lines().next().unwrap_or("Unknown error")
-                            );
-                        }
-                        last_error = Some(stderr.to_string());
-                        attempt += 1;
-                        continue;
+                if let Some(retry_reason) = should_retry_output(&output, attempt, max_retries) {
+                    if verbose {
+                        eprintln!("⚠️  Transient error detected: {retry_reason}");
                     }
+                    last_error = Some(retry_reason);
+                    attempt += 1;
+                    continue;
                 }
-
                 return Ok(output);
             }
             Err(e) => {
-                // System-level errors (e.g., command not found) shouldn't be retried
-                if e.kind() == std::io::ErrorKind::NotFound {
-                    return Err(e).context(format!("Command not found for {description}"));
-                }
-
-                // Other IO errors might be transient
-                if attempt < max_retries {
-                    if verbose {
-                        eprintln!("⚠️  IO error: {e}");
-                    }
-                    last_error = Some(e.to_string());
+                let retry_result =
+                    handle_command_error(e, description, attempt, max_retries, verbose)?;
+                if let Some(error_msg) = retry_result {
+                    last_error = Some(error_msg);
                     attempt += 1;
                     continue;
                 }
-
-                return Err(e).context(format!("Failed to execute {description}"));
             }
         }
     }
@@ -98,6 +73,51 @@ pub async fn execute_with_retry(
     ))
 }
 
+async fn await_retry_delay(attempt: u32, description: &str, max_retries: u32, verbose: bool) {
+    let delay = Duration::from_secs(2u64.pow(attempt.min(3))); // Exponential backoff, max 8s
+    if verbose {
+        println!("⏳ Retrying {description} after {delay:?} (attempt {attempt}/{max_retries})");
+    }
+    sleep(delay).await;
+}
+
+fn should_retry_output(
+    output: &std::process::Output,
+    attempt: u32,
+    max_retries: u32,
+) -> Option<String> {
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        if is_transient_error(&stderr) && attempt < max_retries {
+            return Some(stderr.lines().next().unwrap_or("Unknown error").to_string());
+        }
+    }
+    None
+}
+
+fn handle_command_error(
+    error: std::io::Error,
+    description: &str,
+    attempt: u32,
+    max_retries: u32,
+    verbose: bool,
+) -> Result<Option<String>> {
+    // System-level errors (e.g., command not found) shouldn't be retried
+    if error.kind() == std::io::ErrorKind::NotFound {
+        return Err(error).context(format!("Command not found for {description}"));
+    }
+
+    // Other IO errors might be transient
+    if attempt < max_retries {
+        if verbose {
+            eprintln!("⚠️  IO error: {error}");
+        }
+        return Ok(Some(error.to_string()));
+    }
+
+    Err(error).context(format!("Failed to execute {description}"))
+}
+
 /// Check if an error message indicates a transient failure
 ///
 /// Detects common patterns that indicate temporary failures which