fix(parse): handle variadic ellipsis inside brackets like [args...]

The spec parser was not recognizing `[args...]` or `<args...>` as
variadic arguments. The ellipsis check only ran before bracket
stripping, so `[args...]` (ending with `]` not `...`) was missed.

Add a second ellipsis check after brackets are stripped so both
`[args]...` and `[args...]` correctly set var=true.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: jdx

lib/src/parse.rs

@@ -1746,4 +1746,107 @@ mod tests {
         // Should fail - env var is missing from both custom and process env
         assert!(result.is_err());
     }
+
+    #[test]
+    fn test_variadic_arg_captures_unknown_flags_from_spec_string() {
+        let spec: Spec = r#"
+            flag "-v --verbose" var=#true
+            arg "[database]" default="myapp_dev"
+            arg "[args...]"
+        "#
+        .parse()
+        .unwrap();
+        let input: Vec<String> = vec!["test", "mydb", "--host", "localhost"]
+            .into_iter()
+            .map(String::from)
+            .collect();
+        let parsed = parse(&spec, &input).unwrap();
+        let env = parsed.as_env();
+        assert_eq!(env.get("usage_database").unwrap(), "mydb");
+        assert_eq!(env.get("usage_args").unwrap(), "--host localhost");
+    }
+
+    #[test]
+    fn test_variadic_arg_captures_unknown_flags() {
+        let cmd = SpecCommand::builder()
+            .name("test")
+            .flag(SpecFlag::builder().short('v').long("verbose").build())
+            .arg(SpecArg::builder().name("database").required(false).build())
+            .arg(
+                SpecArg::builder()
+                    .name("args")
+                    .required(false)
+                    .var(true)
+                    .build(),
+            )
+            .build();
+        let spec = Spec {
+            name: "test".to_string(),
+            bin: "test".to_string(),
+            cmd,
+            ..Default::default()
+        };
+
+        // Unknown --host flag and its value should be captured by [args...]
+        let input: Vec<String> = vec!["test", "mydb", "--host", "localhost"]
+            .into_iter()
+            .map(String::from)
+            .collect();
+        let parsed = parse(&spec, &input).unwrap();
+        assert_eq!(parsed.args.len(), 2);
+        let args_val = parsed
+            .args
+            .iter()
+            .find(|(a, _)| a.name == "args")
+            .unwrap()
+            .1;
+        match args_val {
+            ParseValue::MultiString(v) => {
+                assert_eq!(v, &vec!["--host".to_string(), "localhost".to_string()]);
+            }
+            _ => panic!("Expected MultiString, got {:?}", args_val),
+        }
+    }
+
+    #[test]
+    fn test_variadic_arg_captures_unknown_flags_with_double_dash() {
+        let cmd = SpecCommand::builder()
+            .name("test")
+            .flag(SpecFlag::builder().short('v').long("verbose").build())
+            .arg(SpecArg::builder().name("database").required(false).build())
+            .arg(
+                SpecArg::builder()
+                    .name("args")
+                    .required(false)
+                    .var(true)
+                    .build(),
+            )
+            .build();
+        let spec = Spec {
+            name: "test".to_string(),
+            bin: "test".to_string(),
+            cmd,
+            ..Default::default()
+        };
+
+        // With explicit -- separator
+        let input: Vec<String> = vec!["test", "--", "mydb", "--host", "localhost"]
+            .into_iter()
+            .map(String::from)
+            .collect();
+        let parsed = parse(&spec, &input).unwrap();
+        assert_eq!(parsed.args.len(), 2);
+        let args_val = parsed
+            .args
+            .iter()
+            .find(|(a, _)| a.name == "args")
+            .unwrap()
+            .1;
+        match args_val {
+            ParseValue::MultiString(v) => {
+                assert_eq!(v, &vec!["--host".to_string(), "localhost".to_string()]);
+            }
+            _ => panic!("Expected MultiString, got {:?}", args_val),
+        }
+    }
 }

lib/src/spec/arg.rs

@@ -256,6 +256,17 @@ impl From<&str> for SpecArg {
             }
             _ => {}
         }
+        // Also handle ellipsis inside brackets: "[args...]" or "<args...>"
+        if !arg.var {
+            if let Some(name) = arg
+                .name
+                .strip_suffix("...")
+                .or_else(|| arg.name.strip_suffix("…"))
+            {
+                arg.var = true;
+                arg.name = name.to_string();
+            }
+        }
         if let Some(name) = arg.name.strip_prefix("-- ") {
             arg.double_dash = SpecDoubleDashChoices::Required;
             arg.name = name.to_string();
@@ -425,5 +436,22 @@ arg "<output>" {
         assert_eq!(arg.name, "files");
         assert!(arg.var);
         assert!(!arg.required);
+
+        // Ellipsis inside brackets: [args...] and <args...>
+        let arg: SpecArg = "[args...]".into();
+        assert_eq!(arg.name, "args");
+        assert!(arg.var);
+        assert!(!arg.required);
+
+        let arg: SpecArg = "<args...>".into();
+        assert_eq!(arg.name, "args");
+        assert!(arg.var);
+        assert!(arg.required);
+
+        // Unicode ellipsis inside brackets
+        let arg: SpecArg = "[args…]".into();
+        assert_eq!(arg.name, "args");
+        assert!(arg.var);
+        assert!(!arg.required);
     }
 }

lib/tests/dump.rs

@@ -26,5 +26,5 @@ tests_same! {
     choices bash fish zsh
 }"#,
 
-    double_dash: r#"arg "<-- shell...>""#,
+    double_dash: r#"arg "<-- shell>…" var=#true"#,
 }

lib/tests/parse.rs

@@ -240,6 +240,24 @@ multi_flag:
     args="-v --verbose",
     expected=r#"{"usage_verbose": "2"}"#,
 
+variadic_arg_captures_unknown_flags:
+    spec=r#"
+    flag "-v --verbose" var=#true
+    arg "[database]" default="myapp_dev"
+    arg "[args...]"
+    "#,
+    args="mydb --host localhost",
+    expected=r#"{"usage_args": "--host localhost", "usage_database": "mydb"}"#,
+
+variadic_arg_captures_unknown_short_flags:
+    spec=r#"
+    flag "-v --verbose" var=#true
+    arg "[database]" default="myapp_dev"
+    arg "[args...]"
+    "#,
+    args="mydb -x localhost",
+    expected=r#"{"usage_args": "-x localhost", "usage_database": "mydb"}"#,
+
 //shell_escape_arg:
 //    spec=r#"
 //    arg "<vars>" shell_escape=#true