refactor(builtins): migrate base64 from manual arg parsing to ArgParser

crates/bashkit/src/builtins/base64.rs

@@ -3,6 +3,7 @@
 use async_trait::async_trait;
 use base64::Engine;
 
+use super::arg_parser::ArgParser;
 use super::{Builtin, Context, read_text_file};
 use crate::error::Result;
 use crate::interpreter::ExecResult;
@@ -23,35 +24,32 @@ impl Builtin for Base64 {
         let mut wrap = 76usize;
         let mut file: Option<String> = None;
 
-        let mut i = 0;
-        while i < ctx.args.len() {
-            match ctx.args[i].as_str() {
-                "-d" | "--decode" => decode = true,
-                "-w" => {
-                    i += 1;
-                    if i >= ctx.args.len() {
-                        return Ok(ExecResult::err(
-                            "base64: option requires an argument -- 'w'\n".to_string(),
-                            1,
-                        ));
-                    }
-                    wrap = ctx.args[i].parse().unwrap_or(76);
-                }
-                s if s.starts_with("--wrap=") => {
-                    wrap = s[7..].parse().unwrap_or(76);
-                }
-                "-i" | "--ignore-garbage" => { /* silently accept */ }
-                s if s.starts_with('-') && s != "-" => {
-                    return Ok(ExecResult::err(
-                        format!("base64: invalid option -- '{}'\n", &s[1..]),
-                        1,
-                    ));
+        let mut parser = ArgParser::new(ctx.args);
+        while !parser.is_done() {
+            if parser.flag_any(&["-d", "--decode"]) {
+                decode = true;
+            } else if parser
+                .current()
+                .is_some_and(|s| s.starts_with("--wrap="))
+            {
+                if let Some(s) = parser.positional() {
+                    wrap = s["--wrap=".len()..].parse().unwrap_or(76);
                 }
-                _ => {
-                    file = Some(ctx.args[i].clone());
+            } else if let Some(val) = match parser.flag_value("-w", "base64") {
+                Ok(v) => v,
+                Err(e) => return Ok(ExecResult::err(format!("{e}\n"), 1)),
+            } {
+                wrap = val.parse().unwrap_or(76);
+            } else if parser.flag_any(&["-i", "--ignore-garbage"]) {
+                // silently accept
+            } else if parser.is_flag() {
+                if let Some(s) = parser.positional() {
+                    let msg = format!("base64: invalid option -- '{}'\n", &s[1..]);
+                    return Ok(ExecResult::err(msg, 1));
                 }
+            } else if let Some(arg) = parser.positional() {
+                file = Some(arg.to_string());
             }
-            i += 1;
         }
 
         // Get input: from file, stdin, or empty