with-watch: fall back for opaque codegen args

Author: kdy1

crates/with-watch/src/analysis.rs

@@ -1917,7 +1917,8 @@ fn analyze_fd(
         matches!(
             token.as_str(),
             "-x" | "-X" | "--exec" | "--exec-batch" | "--list-details"
-        )
+        ) || token.starts_with("--exec=")
+            || token.starts_with("--exec-batch=")
     }) {
         return analyze_fallback(argv, redirects, cwd);
     }
@@ -2794,9 +2795,23 @@ fn analyze_protoc(
         }
 
         if token.starts_with('@') {
-            push_inferred_input(&mut inputs, &token[1..], cwd)?;
-            index += 1;
-            continue;
+            let mut analysis = analyze_fallback(argv, redirects, cwd)?;
+            analysis.status = CommandAnalysisStatus::AmbiguousFallback;
+            for argfile_token in argv.iter().skip(1).filter(|value| value.starts_with('@')) {
+                let literal_argfile_path = absolutize(argfile_token, cwd);
+                analysis.inputs.retain(|input| {
+                    !matches!(
+                        input,
+                        WatchInput::Path { path, .. } if path == &literal_argfile_path
+                    )
+                });
+                if let Some(argfile_path) = argfile_token.strip_prefix('@') {
+                    if !argfile_path.is_empty() {
+                        push_inferred_input(&mut analysis.inputs, argfile_path, cwd)?;
+                    }
+                }
+            }
+            return Ok(analysis);
         }
 
         if !positional_only {
@@ -4025,6 +4040,21 @@ mod tests {
         .expect("analyze");
         assert_eq!(fallback.adapter_ids, vec![CommandAdapterId::Fallback]);
         assert_path_inputs(&fallback, &[cwd.path().join("src")]);
+
+        let inline_exec_fallback = analyze_argv(
+            &[
+                OsString::from("fd"),
+                OsString::from("--exec-batch=echo"),
+                OsString::from("src"),
+            ],
+            cwd.path(),
+        )
+        .expect("analyze");
+        assert_eq!(
+            inline_exec_fallback.adapter_ids,
+            vec![CommandAdapterId::Fallback]
+        );
+        assert_path_inputs(&inline_exec_fallback, &[cwd.path().join("src")]);
     }
 
     #[test]
@@ -4218,6 +4248,28 @@ mod tests {
         assert_eq!(protoc_plugin.adapter_ids, vec![CommandAdapterId::Fallback]);
         assert_path_inputs(&protoc_plugin, &[cwd.path().join("src/service.proto")]);
 
+        fs::write(
+            cwd.path().join("args.txt"),
+            "--proto_path=src src/service.proto",
+        )
+        .expect("write args file");
+        let protoc_argfile = analyze_argv(
+            &[
+                OsString::from("protoc"),
+                OsString::from("@args.txt"),
+                OsString::from("--go_out"),
+                OsString::from("gen"),
+            ],
+            cwd.path(),
+        )
+        .expect("analyze");
+        assert_eq!(protoc_argfile.adapter_ids, vec![CommandAdapterId::Fallback]);
+        assert_eq!(
+            protoc_argfile.status,
+            CommandAnalysisStatus::AmbiguousFallback
+        );
+        assert_path_inputs(&protoc_argfile, &[cwd.path().join("args.txt")]);
+
         let capnp_non_compile = analyze_argv(
             &[
                 OsString::from("capnp"),

docs/crates-with-watch-foundation.md

@@ -47,7 +47,7 @@
 - Plain `ls`/`dir`/`vdir` directory operands must watch only the named directory plus immediate children, `-R` must switch them to recursive metadata tree snapshots, and `-d`/`--directory` must watch only the named path entry.
 - Built-in inference must exclude known outputs, scripts, inline patterns, and opaque fallback operands from the watch set.
 - First-class search adapters must cover `grep`, `rg`, `ag`, and `fd`; inline search patterns, globs, and type filters must be treated as control data while explicit search roots and file-valued pattern/ignore inputs stay watchable.
-- First-class schema/codegen adapters must cover `protoc`, `flatc`, `thrift`, and `capnp compile`; explicit schema inputs, include/import roots, descriptor/arg files, and conform-reference inputs stay watchable while generated output paths remain filtered. When `protoc` runs without `--proto_path`, the current working directory stays watchable as the implicit import root.
+- First-class schema/codegen adapters must cover `protoc`, `flatc`, `thrift`, and `capnp compile`; explicit schema inputs, include/import roots, descriptor inputs, and conform-reference inputs stay watchable while generated output paths remain filtered. `protoc` response files (`@argfile`) are too opaque for v1 inference and must degrade to `exec --input` guidance rather than remaining partially watchable. When `protoc` runs without `--proto_path`, the current working directory stays watchable as the implicit import root.
 - Wrapper commands (`env`, `nice`, `nohup`, `stdbuf`, and `timeout`) must unwrap to the delegated command before adapter selection.
 - `exec --input` remains the canonical explicit input contract when inference is insufficient, but command-side side-effect metadata may still be inferred for rerun suppression and logging.
 - Commands marked as `WritesWatchedInputs` must refresh the baseline snapshot after each run and suppress reruns caused only by their own writes while they were executing.

docs/project-with-watch.md

@@ -27,7 +27,7 @@ Provide a Rust-based CLI wrapper that reruns delegated shell utilities and arbit
 - Commands without safe inferred filesystem inputs must fail clearly and direct operators to `with-watch exec --input ...`.
 - Passthrough and shell modes must use adapter-driven input inference that excludes known outputs, scripts, and pattern operands from the watch set.
 - First-class search adapters must include `grep`, `rg`, `ag`, and `fd`; search patterns, globs, and type filters must stay out of the watch set while explicit search roots and file-valued pattern/ignore inputs remain watchable.
-- First-class schema/codegen adapters must include `protoc`, `flatc`, `thrift`, and `capnp compile`; explicit source files, include/import roots, descriptor/arg files, and conform-reference inputs must remain watchable while generated output paths stay filtered out of the watch set. When `protoc` omits `--proto_path`, the current working directory must be treated as an implicit import root and remain watchable.
+- First-class schema/codegen adapters must include `protoc`, `flatc`, `thrift`, and `capnp compile`; explicit source files, include/import roots, descriptor inputs, and conform-reference inputs must remain watchable while generated output paths stay filtered out of the watch set. `protoc` response files (`@argfile`) are too opaque for v1 inference and must fall back to `exec --input` guidance instead of being partially watched. When `protoc` omits `--proto_path`, the current working directory must be treated as an implicit import root and remain watchable.
 - `ls`, `dir`, and `vdir` must use metadata listing snapshots instead of recursive file-content hashing: the default watch scope is immediate children, `-R` stays recursive, and `-d` watches only the named path.
 - Shell redirects must treat `<` and `<>` targets as watched inputs and `>`, `>>`, `&>`, `&>>`, and `>|` targets as filtered outputs.
 - Shell parsing support is limited to command-line expressions plus `&&`, `||`, and `|`; broader shell control-flow stays out of scope until documented otherwise.