Function parse_invocation_with_stdin

src/tool_command/args.rs:61–185

(
    def: &ToolDefinition,
    args: &[String],
    mut read_stdin: impl FnMut() -> Result<String>,
)

}

pub(super) fn parse_invocation_with_stdin(
    def: &ToolDefinition,
    args: &[String],
    mut read_stdin: impl FnMut() -> Result<String>,
) -> Result<ParsedInvocation> {
    let schema_properties = def
        .input_schema
        .get("properties")
        .and_then(Value::as_object)
        .cloned()
        .unwrap_or_default();

    let required = schema_required_keys(def);

    let mut out = ParsedInvocation {
        tool_args: Value::Object(Map::new()),
        project: None,
        raw_json: false,
        dry_run: false,
        show_help: false,
    };

    let mut explicit_args: Option<Value> = None;
    let mut collected: Map<String, Value> = Map::new();
    let mut positionals: Vec<String> = Vec::new();

    let mut iter = args.iter();
    while let Some(raw) = iter.next() {
        // GNU-style `--flag=value` is accepted everywhere clap is, so accept
        // it here too: split once on `=` and treat the remainder as the value.
        let (flag_part, inline_value): (&str, Option<&str>) = if raw.starts_with("--") {
            match raw.split_once('=') {
                Some((flag, value)) => (flag, Some(value)),
                None => (raw.as_str(), None),
            }
        } else {
            (raw.as_str(), None)
        };
        match flag_part {
            "-h" | "--help" => {
                out.show_help = true;
                return Ok(out);
            }
            "--json" => out.raw_json = true,
            "--dry-run" => out.dry_run = true,
            "--project" => {
                out.project = Some(take_flag_value(&mut iter, "--project", inline_value)?);
            }
            "--args" => {
                // `--args` is a whole-payload arg: inline JSON, `-` for stdin,
                // or a file path (bare or `@`-prefixed). Reading from a file or
                // stdin sidesteps the kernel's per-argv-string cap
                // (MAX_ARG_STRLEN, 128 KiB on Linux) for large payloads.
                let raw_args = take_flag_value(&mut iter, "--args", inline_value)?;
                let json_str = resolve_args_payload(&raw_args, &mut read_stdin)?;
                let value: Value =
                    serde_json::from_str(&json_str).map_err(|e| TraceDecayError::Config {
                        message: format!(