Just: size batches for the argument a command hands on, not the line it is on

A single argument is capped far below the whole command line, at 128KB against 2MB on
Linux, and a command that passes its arguments on through a shell arrives as one of
them. Sizing batches by the line alone let a large enough tree build one argument over
that cap, which fails as an `execv` error from whatever did the handing on, naming
neither this file nor the files it was given.

Also says how an exclusion is matched, as it is against the path the walk built rather
than the one on the command line, and the natural way to name a directory only matches
when the walk starts above it.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: redsun82

misc/just/format.just

@@ -25,7 +25,9 @@ _bazel_formatter := "bazel run --noshow_progress --ui_event_filters=,+error,+fai
 #
 # Both lists are comma-separated, so a root defining its own `_root_format` can name
 # several patterns in one variable. It has no need to repeat the ones here: the files
-# they cover belong to this repository, which formats them itself.
+# they cover belong to this repository, which formats them itself. Exclusions match the
+# path as walked rather than as spelled on the command line, so one naming a directory
+# has to cover both the path it is reached by and the path it is walked from.
 #
 # As with the QL formatter, buildifier only names what it rewrote if it also accounts for
 # every file it did not, so that accounting is dropped. It counts the warnings it could

misc/just/run_on_files.py

@@ -26,23 +26,31 @@ def batch_limit():
     along with some slack. This is worth doing rather than assuming the tightest of the
     two: `ARG_MAX` is 2MB on Linux, which turns the couple of thousand QL files of a
     language into a single invocation rather than several.
+
+    A single argument is capped far lower than the whole line, at 128KB on Linux, and a
+    command that hands its arguments on through a shell arrives as one of them. Batches
+    are kept below that too, as the resulting failure is reported by whatever did the
+    handing on rather than by anything naming this file.
     """
     if sys.platform == "win32":
         return 30000
+    single_argument = 100000
     try:
         arg_max = os.sysconf("SC_ARG_MAX")
     except (ValueError, OSError):
         return 30000
     environment = sum(len(name) + len(value) + 2 for name, value in os.environ.items())
-    return max(4096, arg_max - environment - 4096)
+    return max(4096, min(arg_max - environment - 4096, single_argument))
 
 
 def files_under(paths, patterns, excludes=(), absolute=False, within=None):
     """Collect the files matching one of the patterns at or below each path.
 
     Patterns are matched against the file name, as bazel files are identified by name
     rather than by extension. Exclusions are matched against the whole path instead,
-    which is how a directory of generated files is left alone.
+    which is how a directory of generated files is left alone. That path is the one the
+    walk built, so an exclusion has to allow for how the paths it is given are spelled:
+    `*/<directory>/*` does not match what is walked from `<directory>` itself.
 
     A `within` directory bounds the result to the files below it, for a command that
     answers for one project and may be handed a path reaching outside it.