stitchkit 0.100.2 → 0.101.0

package/dist/{index-r066jx76.js → index-c6aagrbd.js}

@@ -1,44 +1,44 @@
 import {
-  isWithinDir
-} from "./index-sbdmyz75.js";
+  validateDeclaredOutput
+} from "./index-b2bz0kdm.js";
 import {
-  collectToolSurface
-} from "./index-9t3dffv2.js";
+  toolResultFromError,
+  toolErrorFromResult
+} from "./index-dvwj1f43.js";
 import {
-  createToolRunner,
-  formatToolError
-} from "./index-bm5rx7n6.js";
+  coerceJsonArgs2
+} from "./index-9pw0a51a.js";
 import {
-  toolErrorFromResult,
-  toolResultFromError
-} from "./index-8qt2m66q.js";
-import {
-  coerceJsonArgs
-} from "./index-1zbbzgfh.js";
+  jsonSchemaFields
+} from "./index-ct75c3at.js";
 import {
+  objectShapeKeys,
   assertUniqueToolName,
-  buildToolPresentationSchema,
-  objectShapeKeys
-} from "./index-0r0fbk7z.js";
+  buildToolPresentationSchema
+} from "./index-7z9ym7t8.js";
 import {
-  jsonSchemaFields
-} from "./index-eqqvgdb3.js";
+  createToolRunner,
+  formatToolError
+} from "./index-n9tyz8z3.js";
 import {
-  validateDeclaredOutput
-} from "./index-znfs20ss.js";
+  isWithinDir2
+} from "./index-5cc6r990.js";
 import {
-  formatZodError
-} from "./index-p5r7qpdd.js";
+  collectToolSurface
+} from "./index-ewbaywk5.js";
+import {
+  formatZodError2
+} from "./index-1eeqpadm.js";
 import {
   isUnsafeKey,
   safeJsonParse
-} from "./index-kzfs85xp.js";
+} from "./index-zsarb5xp.js";
 import {
   isRecord
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/tools/cli/command.ts
-function defineCliCommand(definition) {
+function defineCliCommand2(definition) {
   return definition;
 }
 function cliCommandReturnsResult(definition) {
@@ -78,7 +78,7 @@ function cliCommandPresentationSchema(definition) {
 async function executeCliCommand(definition, rawArgs, options, writers, coerceJson, globals = {}) {
   let parsed;
   try {
-    parsed = definition.input.safeParse(coerceJson ? coerceJsonArgs(rawArgs, definition.input) : rawArgs);
+    parsed = definition.input.safeParse(coerceJson ? coerceJsonArgs2(rawArgs, definition.input) : rawArgs);
   } catch (error) {
     return toolResultFromError(error);
   }
@@ -86,7 +86,7 @@ async function executeCliCommand(definition, rawArgs, options, writers, coerceJs
     return {
       ok: false,
       code: "VALIDATION_ERROR",
-      details: { message: `Invalid input: ${formatZodError(parsed.error)}` }
+      details: { message: `Invalid input: ${formatZodError2(parsed.error)}` }
     };
   }
   try {
@@ -111,7 +111,7 @@ async function executeCliCommand(definition, rawArgs, options, writers, coerceJs
 }
 
 // src/tools/cli/format.ts
-var DEFAULT_EXIT_CODES = {
+var DEFAULT_EXIT_CODES2 = {
   VALIDATION_ERROR: 1,
   BAD_REQUEST: 1,
   UNAUTHORIZED: 2,
@@ -123,18 +123,18 @@ var DEFAULT_EXIT_CODES = {
   WAIT_FAILED: 1,
   INTERNAL_SERVER_ERROR: 1
 };
-function cliExitCode(result, exitCodes) {
+function cliExitCode2(result, exitCodes) {
   if (result.ok)
     return 0;
-  const codes = { ...DEFAULT_EXIT_CODES, ...exitCodes };
+  const codes = { ...DEFAULT_EXIT_CODES2, ...exitCodes };
   return Object.hasOwn(codes, result.code) ? codes[result.code] ?? 1 : 1;
 }
-function emitResult(result, writers, opts) {
+function emitResult2(result, writers, opts) {
   if (result.ok) {
     if (result.data === undefined)
       return 0;
-    const text2 = opts.json ? JSON.stringify(result.data) : JSON.stringify(result.data, null, 2);
-    writers.stdout(`${text2}
+    const text = opts.json ? JSON.stringify(result.data) : JSON.stringify(result.data, null, 2);
+    writers.stdout(`${text}
 `);
     return 0;
   }
@@ -142,11 +142,11 @@ function emitResult(result, writers, opts) {
   const text = opts.json ? JSON.stringify(error) : JSON.stringify(error, null, 2);
   writers.stderr(`${text}
 `);
-  return cliExitCode(result, opts.exitCodes);
+  return cliExitCode2(result, opts.exitCodes);
 }
 
 // src/tools/cli/argument-error.ts
-class CliArgumentError extends Error {
+class CliArgumentError2 extends Error {
   name = "CliArgumentError";
 }
 
@@ -230,6 +230,13 @@ function describeSchemaFields(schema) {
 }
 var TRUE_WORDS = new Set(["true", "1", "yes", "on"]);
 var FALSE_WORDS = new Set(["false", "0", "no", "off"]);
+function separateBoolValue(next) {
+  if (next === "true")
+    return true;
+  if (next === "false")
+    return false;
+  return;
+}
 function isReservedBoolWord(value) {
   const word = value.toLowerCase();
   return TRUE_WORDS.has(word) || FALSE_WORDS.has(word);
@@ -240,7 +247,7 @@ function parseReservedBool(name, value) {
     return true;
   if (FALSE_WORDS.has(v))
     return false;
-  throw new CliArgumentError(`--${name} expects a boolean (true/false), got "${value}"`);
+  throw new CliArgumentError2(`--${name} expects a boolean (true/false), got "${value}"`);
 }
 function coerceScalar(kind, value) {
   switch (kind) {
@@ -295,10 +302,10 @@ function coerceNamed(label, kind, integer, value) {
   const coerced = coerceScalar(kind, value);
   const expected = expectedValue(kind, integer);
   if (expected !== undefined && typeof coerced === "string") {
-    throw new CliArgumentError(`${label} expects ${expected}, got "${value}"`);
+    throw new CliArgumentError2(`${label} expects ${expected}, got "${value}"`);
   }
   if (integer && typeof coerced === "number" && !Number.isInteger(coerced)) {
-    throw new CliArgumentError(`${label} expects ${expected}, got "${value}"`);
+    throw new CliArgumentError2(`${label} expects ${expected}, got "${value}"`);
   }
   return coerced;
 }
@@ -318,7 +325,7 @@ function coerceField(info, values, label) {
 function setNested(target, path, value) {
   const unsafe = path.find(isUnsafeKey);
   if (unsafe !== undefined) {
-    throw new CliArgumentError(`Unsafe option path segment "${unsafe}"`);
+    throw new CliArgumentError2(`Unsafe option path segment "${unsafe}"`);
   }
   let node = target;
   for (let i = 0;i < path.length - 1; i++) {
@@ -425,7 +432,7 @@ function parseCliGlobals(schema, globals) {
     return globals ?? {};
   return schema.parse(globals ?? {});
 }
-function cliInvocationResult(result, toolName, config) {
+function cliInvocationResult2(result, toolName, config) {
   if (result.ok)
     return { ok: true, exitCode: 0, data: result.data };
   const normalized = toolErrorFromResult(result);
@@ -437,7 +444,7 @@ function cliInvocationResult(result, toolName, config) {
     hints.push(global);
   return {
     ok: false,
-    exitCode: cliExitCode(result, config.exitCodes),
+    exitCode: cliExitCode2(result, config.exitCodes),
     error: {
       code: result.code,
       message: normalized.message,
@@ -447,7 +454,7 @@ function cliInvocationResult(result, toolName, config) {
     }
   };
 }
-async function createCliInvoker(config, globals) {
+async function createCliInvoker2(config, globals) {
   const typedGlobals = parseCliGlobals(config.globalOptions, globals);
   const auth = await (config.resolveAuth ? config.resolveAuth(typedGlobals) : config.auth);
   const natives = new Map((config.commands ?? []).filter(cliCommandReturnsResult).map((definition) => [definition.name, definition]));
@@ -475,7 +482,7 @@ async function createCliInvoker(config, globals) {
         return runNativeCommand(native, args, config, typedGlobals);
       const tool = tools.get(command);
       if (!tool) {
-        return cliInvocationResult({
+        return cliInvocationResult2({
           ok: false,
           code: "NOT_FOUND",
           details: { message: `Unknown command "${command}"` }
@@ -487,7 +494,7 @@ async function createCliInvoker(config, globals) {
       } catch (error) {
         result = toolResultFromError(error);
       }
-      return cliInvocationResult(result, command, config);
+      return cliInvocationResult2(result, command, config);
     }
   };
 }
@@ -509,7 +516,7 @@ async function runNativeCommand(definition, args, config, globals) {
       err += text;
     }
   }, config.coerceJsonArgs ?? true, globals);
-  let invocation = cliInvocationResult(result, definition.name, config);
+  let invocation = cliInvocationResult2(result, definition.name, config);
   if (invocation.ok) {
     try {
       invocation = {
@@ -517,7 +524,7 @@ async function runNativeCommand(definition, args, config, globals) {
         exitCode: cliCommandSuccessExitCode(definition, result.ok ? result.data : undefined)
       };
     } catch (error) {
-      invocation = cliInvocationResult(toolResultFromError(error), definition.name, config);
+      invocation = cliInvocationResult2(toolResultFromError(error), definition.name, config);
     }
   }
   if (out === "" && err === "")
@@ -588,7 +595,7 @@ function helpFilterFrom(token, rest) {
   const next = rest[0];
   return next !== undefined && !next.startsWith("-") ? next : undefined;
 }
-function routeCliArgv(argv, defaultCommand) {
+function routeCliArgv2(argv, defaultCommand) {
   if (defaultCommand === undefined) {
     const [command, ...commandArgv] = argv;
     const helpFilter = helpFilterFrom(command, commandArgv);
@@ -655,6 +662,11 @@ function routeCliArgv(argv, defaultCommand) {
     if (option.globalKind === "boolean") {
       globals.push(token);
       index += 1;
+      const next = argv[index];
+      if (option.value === undefined && next !== undefined && separateBoolValue(next) !== undefined) {
+        globals.push(next);
+        index += 1;
+      }
       continue;
     }
     if (option.globalKind === "value") {
@@ -700,7 +712,7 @@ function routeCliArgv(argv, defaultCommand) {
 function resolveCliView(flags, ascending) {
   if (flags.size === 0) {
     if (ascending) {
-      throw new CliArgumentError("--ascending orders a record view; pass --sort with it");
+      throw new CliArgumentError2("--ascending orders a record view; pass --sort with it");
     }
     return;
   }
@@ -714,31 +726,31 @@ function resolveCliView(flags, ascending) {
     ["--sum", sum]
   ].filter(([, value]) => value !== undefined);
   if (named.length > 1) {
-    throw new CliArgumentError(`${named.map(([flag]) => flag).join(" and ")} ask for different shapes — pass one`);
+    throw new CliArgumentError2(`${named.map(([flag]) => flag).join(" and ")} ask for different shapes — pass one`);
   }
   let top;
   if (rawTop !== undefined) {
     top = Number(rawTop);
     if (!Number.isInteger(top) || top <= 0) {
-      throw new CliArgumentError("--top must be a positive whole number");
+      throw new CliArgumentError2("--top must be a positive whole number");
     }
   }
   const sort = flags.get("sort");
   if (table !== undefined || sort !== undefined) {
     if (countBy !== undefined || sum !== undefined) {
-      throw new CliArgumentError(`${table !== undefined ? "--table" : "--sort"} lists records; --count-by and --sum aggregate them — pass one`);
+      throw new CliArgumentError2(`${table !== undefined ? "--table" : "--sort"} lists records; --count-by and --sum aggregate them — pass one`);
     }
     if (by !== undefined) {
-      throw new CliArgumentError("--by groups a view; a record view orders with --sort");
+      throw new CliArgumentError2("--by groups a view; a record view orders with --sort");
     }
     if (top !== undefined && sort === undefined) {
-      throw new CliArgumentError("--top needs --sort here: unordered records have no n largest");
+      throw new CliArgumentError2("--top needs --sort here: unordered records have no n largest");
     }
     let fields;
     if (table !== undefined) {
       fields = table.split(",").map((field) => field.trim()).filter(Boolean);
       if (fields.length === 0)
-        throw new CliArgumentError("--table needs at least one field");
+        throw new CliArgumentError2("--table needs at least one field");
     }
     return {
       kind: "records",
@@ -749,11 +761,11 @@ function resolveCliView(flags, ascending) {
     };
   }
   if (ascending) {
-    throw new CliArgumentError("--ascending orders a record view; pass --sort with it");
+    throw new CliArgumentError2("--ascending orders a record view; pass --sort with it");
   }
   if (sum !== undefined) {
     if (top !== undefined && by === undefined) {
-      throw new CliArgumentError("--top needs --by: a single sum has nothing to rank");
+      throw new CliArgumentError2("--top needs --by: a single sum has nothing to rank");
     }
     return {
       kind: "sum",
@@ -764,17 +776,17 @@ function resolveCliView(flags, ascending) {
   }
   if (countBy !== undefined) {
     if (by !== undefined) {
-      throw new CliArgumentError("--count-by already names the grouping field; drop --by");
+      throw new CliArgumentError2("--count-by already names the grouping field; drop --by");
     }
     return { kind: "count", field: countBy, ...top !== undefined && { top } };
   }
   if (by !== undefined) {
     if (top === undefined) {
-      throw new CliArgumentError("--by groups a view; pass --count-by, --sum or --top with it");
+      throw new CliArgumentError2("--by groups a view; pass --count-by, --sum or --top with it");
     }
     return { kind: "count", field: by, top };
   }
-  throw new CliArgumentError("--top needs --sort, --by, --count-by or --sum to rank");
+  throw new CliArgumentError2("--top needs --sort, --by, --count-by or --sum to rank");
 }
 
 // src/tools/cli/args.ts
@@ -820,35 +832,41 @@ function readCliTokens(argv, fields, config) {
       const alias = match?.[1];
       const field = alias === undefined ? undefined : config.optionAliases?.get(alias);
       if (!alias || !field)
-        throw new CliArgumentError(`Unknown option "${tok}"`);
+        throw new CliArgumentError2(`Unknown option "${tok}"`);
       const inline = match?.[2];
-      const info2 = fields.get(field);
-      if (info2?.kind === "boolean") {
-        boolFlags.set(field, inline === undefined ? true : parseReservedBool(field, inline));
+      const info = fields.get(field);
+      if (info?.kind === "boolean") {
+        const separate = inline === undefined ? separateBoolValue(argv[i + 1]) : undefined;
+        if (separate !== undefined)
+          i++;
+        boolFlags.set(field, inline === undefined ? separate ?? true : parseReservedBool(field, inline));
         continue;
       }
-      let value2 = inline;
-      if (value2 === undefined) {
+      let value = inline;
+      if (value === undefined) {
         const next = argv[i + 1];
         if (next !== undefined && !isOptionToken(next)) {
-          value2 = next;
+          value = next;
           i++;
         } else {
-          throw new CliArgumentError(`--${field} requires a value`);
+          throw new CliArgumentError2(`--${field} requires a value`);
         }
       }
-      pushFlag(field, value2);
+      pushFlag(field, value);
       continue;
     }
     const option = classifyLongOptionToken(tok);
     if (!option)
-      throw new CliArgumentError(`Unknown option "${tok}"`);
+      throw new CliArgumentError2(`Unknown option "${tok}"`);
     const { name } = option;
     let { value } = option;
     if (name.length === 0)
-      throw new CliArgumentError("Invalid empty option name");
+      throw new CliArgumentError2("Invalid empty option name");
     if (option.globalKind === "boolean") {
-      const enabled = value === undefined ? true : parseReservedBool(name, value);
+      const separate = value === undefined ? separateBoolValue(argv[i + 1]) : undefined;
+      if (separate !== undefined)
+        i++;
+      const enabled = value === undefined ? separate ?? true : parseReservedBool(name, value);
       if (name === "dry-run")
         options.dryRun = enabled;
       else if (name === "json")
@@ -867,19 +885,19 @@ function readCliTokens(argv, fields, config) {
       const next = argv[i + 1];
       value = value ?? next;
       if (value === undefined || !option.inline && isOptionToken(value)) {
-        throw new CliArgumentError(`--${name} requires a value`);
+        throw new CliArgumentError2(`--${name} requires a value`);
       }
       if (!option.inline)
         i++;
       if (name === "wait-timeout") {
         const timeout = Number(value);
         if (!Number.isFinite(timeout) || timeout <= 0) {
-          throw new CliArgumentError("--wait-timeout must be a positive number");
+          throw new CliArgumentError2("--wait-timeout must be a positive number");
         }
         options.waitTimeout = timeout;
       } else if (VIEW_OPTIONS.has(name)) {
         if (viewFlags.has(name))
-          throw new CliArgumentError(`--${name} was given twice`);
+          throw new CliArgumentError2(`--${name} was given twice`);
         viewFlags.set(name, value);
       } else {
         options.outputDir = value;
@@ -892,16 +910,19 @@ function readCliTokens(argv, fields, config) {
     }
     const unsafeSegment = name.split(".").find(isUnsafeKey);
     if (unsafeSegment !== undefined) {
-      throw new CliArgumentError(`Unsafe option name "--${name}"`);
+      throw new CliArgumentError2(`Unsafe option name "--${name}"`);
     }
     const info = fields.get(name);
     const rootName = name.split(".")[0] ?? name;
     if (!fields.has(rootName) && !config.allowUnknown) {
-      throw new CliArgumentError(`Unknown option "--${name}"`);
+      throw new CliArgumentError2(`Unknown option "--${name}"`);
     }
     if (value === undefined) {
       if (info?.kind === "boolean") {
-        boolFlags.set(name, true);
+        const separate = separateBoolValue(argv[i + 1]);
+        if (separate !== undefined)
+          i++;
+        boolFlags.set(name, separate ?? true);
         continue;
       }
       const next = argv[i + 1];
@@ -909,7 +930,7 @@ function readCliTokens(argv, fields, config) {
         value = next;
         i++;
       } else {
-        throw new CliArgumentError(`--${name} requires a value`);
+        throw new CliArgumentError2(`--${name} requires a value`);
       }
     }
     pushFlag(name, value);
@@ -927,7 +948,7 @@ function buildToolArgs(tokens, fields, declaredPositionals) {
       break;
     if (key === variadicTail) {
       if (flags.has(key)) {
-        throw new CliArgumentError(`--${key} conflicts with the positional values for "${key}" — pass one form, not both`);
+        throw new CliArgumentError2(`--${key} conflicts with the positional values for "${key}" — pass one form, not both`);
       }
       toolArgs[key] = coerceField(fields.get(key), positionals.slice(pi), `<${key}>`);
       pi = positionals.length;
@@ -941,7 +962,7 @@ function buildToolArgs(tokens, fields, declaredPositionals) {
     }
   }
   if (pi < positionals.length) {
-    throw new CliArgumentError(`Unexpected positional argument "${positionals[pi]}"`);
+    throw new CliArgumentError2(`Unexpected positional argument "${positionals[pi]}"`);
   }
   for (const [key, value] of boolFlags) {
     toolArgs[key] = value;
@@ -954,26 +975,26 @@ function buildToolArgs(tokens, fields, declaredPositionals) {
   }
   for (const [root, dotted] of dottedRoots) {
     if (flags.has(root)) {
-      throw new CliArgumentError(`--${root} conflicts with --${dotted} — pass one form, not both`);
+      throw new CliArgumentError2(`--${root} conflicts with --${dotted} — pass one form, not both`);
     }
   }
   for (const [key, values] of flags) {
     if (key.includes(".")) {
       if (values.length > 1) {
-        throw new CliArgumentError(`--${key} was passed ${values.length} times`);
+        throw new CliArgumentError2(`--${key} was passed ${values.length} times`);
       }
       setNested(toolArgs, key.split("."), looseCoerce(values[0] ?? ""));
       continue;
     }
     const info = fields.get(key);
     if (values.length > 1 && info !== undefined && info.kind !== "array" && info.kind !== "other") {
-      throw new CliArgumentError(`--${key} was passed ${values.length} times`);
+      throw new CliArgumentError2(`--${key} was passed ${values.length} times`);
     }
     toolArgs[key] = coerceField(info, values, `--${key}`);
   }
   return toolArgs;
 }
-function parseCliArgs(argv, schema, config = {}) {
+function parseCliArgs2(argv, schema, config = {}) {
   const fields = describeSchemaFields(schema);
   for (const name of config.knownFields ?? []) {
     if (!fields.has(name))
@@ -986,7 +1007,7 @@ function parseCliArgs(argv, schema, config = {}) {
     options.view = view;
   return { toolArgs: buildToolArgs(tokens, fields, config.positionals), options };
 }
-function extractCliGlobalOptions(argv, schema) {
+function extractCliGlobalOptions2(argv, schema) {
   if (schema === undefined)
     return { argv: [...argv], globals: {} };
   const fields = describeSchemaFields(schema);
@@ -1007,14 +1028,17 @@ function extractCliGlobalOptions(argv, schema) {
     }
     let { value } = option;
     if (value === undefined && info.kind === "boolean") {
-      value = "true";
+      const separate = separateBoolValue(argv[i + 1]);
+      if (separate !== undefined)
+        i++;
+      value = String(separate ?? true);
     } else if (value === undefined) {
       const next = argv[i + 1];
       if (next !== undefined && !isOptionToken(next)) {
         value = next;
         i++;
       } else {
-        throw new CliArgumentError(`--${option.name} requires a value`);
+        throw new CliArgumentError2(`--${option.name} requires a value`);
       }
     }
     const existing = raw.get(option.name);
@@ -1027,12 +1051,12 @@ function extractCliGlobalOptions(argv, schema) {
   for (const [name, values] of raw) {
     args[name] = coerceField(fields.get(name), values, `--${name}`);
   }
-  const parsed = schema.safeParse(coerceJsonArgs(args, schema));
+  const parsed = schema.safeParse(coerceJsonArgs2(args, schema));
   if (!parsed.success) {
     const issue = parsed.error.issues[0];
     const field = issue?.path[0];
     const where = typeof field === "string" ? `--${field}` : "application option";
-    throw new CliArgumentError(`${where}: ${issue?.message ?? "invalid value"}`);
+    throw new CliArgumentError2(`${where}: ${issue?.message ?? "invalid value"}`);
   }
   return { argv: rest, globals: parsed.data };
 }
@@ -1048,10 +1072,10 @@ function selectRecords(data) {
     if (arrays.length === 1 && only && Array.isArray(only[1]))
       return only[1];
     if (arrays.length > 1) {
-      throw new CliArgumentError(`an aggregate needs one collection, but the result carries several: ${arrays.map(([key]) => key).join(", ")} — name the shape you want with jq instead`);
+      throw new CliArgumentError2(`an aggregate needs one collection, but the result carries several: ${arrays.map(([key]) => key).join(", ")} — name the shape you want with jq instead`);
     }
   }
-  throw new CliArgumentError("an aggregate needs a collection; this result is not one");
+  throw new CliArgumentError2("an aggregate needs a collection; this result is not one");
 }
 function readField(record, path) {
   let current = record;
@@ -1065,7 +1089,7 @@ function readField(record, path) {
 function fieldPath(field) {
   const path = field.split(".");
   if (path.some((segment) => segment.length === 0 || isUnsafeKey(segment))) {
-    throw new CliArgumentError(`"${field}" is not a readable field path`);
+    throw new CliArgumentError2(`"${field}" is not a readable field path`);
   }
   return path;
 }
@@ -1083,7 +1107,7 @@ function assertFieldPresent(records, field) {
   const present = records.some((record) => readField(record, path) !== undefined);
   if (!present) {
     const available = availableFields(records);
-    throw new CliArgumentError(`no record carries the field "${field}"${available.length > 0 ? ` — available: ${available.join(", ")}` : ""}`);
+    throw new CliArgumentError2(`no record carries the field "${field}"${available.length > 0 ? ` — available: ${available.join(", ")}` : ""}`);
   }
   return path;
 }
@@ -1108,7 +1132,7 @@ function numericValue(value, field) {
     return value;
   if (typeof value === "bigint")
     return Number(value);
-  throw new CliArgumentError(`--sum ${field}: "${groupKey(value)}" is not a number`);
+  throw new CliArgumentError2(`--sum ${field}: "${groupKey(value)}" is not a number`);
 }
 function renderTable(records, fields) {
   const paths = fields.map((field) => assertFieldPresent(records, field));
@@ -1155,18 +1179,18 @@ function renderRecords(records, view) {
     selected = selected.slice(0, view.top);
   return view.table ? { kind: "text", text: renderTable(selected, view.table) } : { kind: "json", data: selected };
 }
-function renderCliView(data, view) {
+function renderCliView2(data, view) {
   const records = selectRecords(data);
   if (view.kind === "records")
     return renderRecords(records, view);
   if (view.kind === "count") {
-    const path2 = assertFieldPresent(records, view.field);
-    const totals2 = new Map;
+    const path = assertFieldPresent(records, view.field);
+    const totals = new Map;
     for (const record of records) {
-      const key = groupKey(readField(record, path2));
-      totals2.set(key, (totals2.get(key) ?? 0) + 1);
+      const key = groupKey(readField(record, path));
+      totals.set(key, (totals.get(key) ?? 0) + 1);
     }
-    return { kind: "json", data: ordered(totals2, view.top) };
+    return { kind: "json", data: ordered(totals, view.top) };
   }
   const path = assertFieldPresent(records, view.field);
   if (view.by === undefined) {
@@ -1292,7 +1316,7 @@ function waitFailure(tool, result) {
     }
   };
 }
-async function pollUntilDone(params) {
+async function pollUntilDone2(params) {
   const { initial, wait, call } = params;
   if (!initial.ok)
     return initial;
@@ -1609,8 +1633,8 @@ async function resolvePublicAddress(url, signal) {
   }
   const pending = lookup(host, { all: true });
   const records = signal ? await raceWithAbort(pending, signal) : await pending;
-  for (const record2 of records) {
-    if (isPrivateIp(record2.address)) {
+  for (const record of records) {
+    if (isPrivateIp(record.address)) {
       throw new PrivateAddressRefusal("refusing to fetch a host that resolves to a private address");
     }
   }
@@ -1727,7 +1751,7 @@ async function readCapped(res, max) {
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 async function writeDownload(root, target, data) {
-  if (!isWithinDir(root, target)) {
+  if (!isWithinDir2(root, target)) {
     throw new Error("download name escapes the output dir");
   }
   await mkdir(dirname(target), { recursive: true });
@@ -1882,6 +1906,10 @@ function renderCommandHelp(name, command, descriptor, applicationOptions = []) {
       const label = labels.get(f.name) ?? `--${f.name}`;
       lines.push(`  ${padRight(label, width)}  <${typeLabel(f.schema)}>${req}${desc}`);
     }
+    const flag = [...kinds].find(([, info]) => info.kind === "boolean")?.[0];
+    if (flag !== undefined) {
+      lines.push("", `A boolean flag is on alone or takes true/false: --${flag}, --${flag} false, --no-${flag}`);
+    }
     lines.push("");
   }
   const applicationLines = applicationOptionLines(applicationOptions);
@@ -1955,11 +1983,11 @@ function resolveCliRoute(session, argv) {
   let globals;
   let routableArgv;
   try {
-    const lifted = extractCliGlobalOptions(argv, config.globalOptions);
+    const lifted = extractCliGlobalOptions2(argv, config.globalOptions);
     globals = lifted.globals;
     routableArgv = lifted.argv;
   } catch (error) {
-    if (!(error instanceof CliArgumentError))
+    if (!(error instanceof CliArgumentError2))
       throw error;
     stderr(`${error.message}
 `);
@@ -1967,7 +1995,7 @@ function resolveCliRoute(session, argv) {
     return;
   }
   const typedGlobals = globals;
-  const route = routeCliArgv(routableArgv, config.defaultCommand);
+  const route = routeCliArgv2(routableArgv, config.defaultCommand);
   if (route.error) {
     stderr(`${route.error}
 `);
@@ -1998,7 +2026,7 @@ function emitOptionsFor(config, json, toolName) {
     json,
     toolName,
     errorHint: config.errorHint,
-    exitCodes: { ...DEFAULT_EXIT_CODES, ...config.exitCodes }
+    exitCodes: { ...DEFAULT_EXIT_CODES2, ...config.exitCodes }
   };
 }
 
@@ -2072,14 +2100,14 @@ function collectPassthrough(toolArgs, field, knownKeys) {
 async function prepareInvocation(command, commandArgv, descriptor, config, readStdin) {
   let parsed;
   try {
-    parsed = parseCliArgs(commandArgv, descriptor.argumentSchema, {
+    parsed = parseCliArgs2(commandArgv, descriptor.argumentSchema, {
       allowUnknown: config.passthrough?.[command] !== undefined,
       knownFields: jsonSchemaFields(descriptor.presentationSchema).map((field) => field.name),
       optionAliases: new Map([...descriptor.aliases].map(([field, alias]) => [alias, field])),
       positionals: descriptor.positionals
     });
   } catch (error) {
-    if (!(error instanceof CliArgumentError))
+    if (!(error instanceof CliArgumentError2))
       throw error;
     return { ok: false, message: error.message };
   }
@@ -2091,7 +2119,7 @@ async function prepareInvocation(command, commandArgv, descriptor, config, readS
       if (descriptor.positionals === undefined) {
         toolArgs[firstUnset.name] = piped;
       } else {
-        const stdinArgs = parseCliArgs([`--${firstUnset.name}`, piped], descriptor.argumentSchema);
+        const stdinArgs = parseCliArgs2([`--${firstUnset.name}`, piped], descriptor.argumentSchema);
         toolArgs[firstUnset.name] = stdinArgs.toolArgs[firstUnset.name];
       }
     }
@@ -2113,7 +2141,7 @@ async function runManagedInvocation(session, route) {
   if (topLevelHelp)
     return respondTopLevelHelp(session, route, managed);
   if (!managed.resolved) {
-    return exit(emitResult(managed.failure, { stdout, stderr }, emitOptionsFor(config, beforeSeparator.includes("--json"), command ?? config.name)));
+    return exit(emitResult2(managed.failure, { stdout, stderr }, emitOptionsFor(config, beforeSeparator.includes("--json"), command ?? config.name)));
   }
   return runManagedCommand(session, route, command, managed);
 }
@@ -2127,7 +2155,7 @@ function respondTopLevelHelp(session, route, managed) {
     stderr(`no command matches "${filter}" (${managed.help.size} available)
 ` + (managed.resolved ? "" : `Managed commands are unavailable: ${managed.reason}
 `));
-    const codes = { ...DEFAULT_EXIT_CODES, ...config.exitCodes };
+    const codes = { ...DEFAULT_EXIT_CODES2, ...config.exitCodes };
     exit(codes.NOT_FOUND ?? 4);
     return;
   }
@@ -2214,7 +2242,7 @@ async function executeManagedTool(session, route, command, managed, tool, { tool
   }
   const waitConfig = config.wait?.[command];
   if (options.wait && waitConfig) {
-    result = await pollUntilDone({
+    result = await pollUntilDone2({
       initial: result,
       wait: waitConfig,
       call: async (toolName, args) => {
@@ -2247,9 +2275,9 @@ async function emitManagedResult(session, command, initial, options) {
   if (options.view && result.ok) {
     let viewed;
     try {
-      viewed = renderCliView(result.data, options.view);
+      viewed = renderCliView2(result.data, options.view);
     } catch (error) {
-      if (!(error instanceof CliArgumentError))
+      if (!(error instanceof CliArgumentError2))
         throw error;
       stderr(`${error.message}
 `);
@@ -2261,7 +2289,7 @@ async function emitManagedResult(session, command, initial, options) {
     }
     result = { ...result, data: viewed.data };
   }
-  const exitCode = emitResult(result, { stdout, stderr }, emitOptionsFor(config, options.json, command));
+  const exitCode = emitResult2(result, { stdout, stderr }, emitOptionsFor(config, options.json, command));
   return exit(downloadsOk ? exitCode : 1);
 }
 
@@ -2315,13 +2343,13 @@ async function runNativeCommand2(session, route, command, native) {
     stdout(emission.presentation);
     emittedExitCode = 0;
   } else {
-    emittedExitCode = emitResult(emission.result, { stdout, stderr }, emitOptionsFor(config, options.json, command));
+    emittedExitCode = emitResult2(emission.result, { stdout, stderr }, emitOptionsFor(config, options.json, command));
   }
   return exit(emission.result.ok ? emission.successExitCode : emittedExitCode);
 }
 
 // src/tools/cli/create-cli.ts
-async function createCli(config) {
+async function createCli2(config) {
   const io = createCliIo(config);
   const argv = config.argv ?? process.argv.slice(2);
   if (config.auth !== undefined && config.resolveAuth !== undefined) {
@@ -2339,4 +2367,4 @@ async function createCli(config) {
   return runManagedInvocation(session, route);
 }
 
-export { fetchGuarded, PrivateAddressRefusal, fetchPinnedDocument, readCapped, WaitTimeoutError, runWaitOperation, defineCliCommand, DEFAULT_EXIT_CODES, cliExitCode, emitResult, CliArgumentError, cliInvocationResult, createCliInvoker, routeCliArgv, parseCliArgs, extractCliGlobalOptions, renderCliView, pollUntilDone, createCli };
+export { fetchGuarded, PrivateAddressRefusal, fetchPinnedDocument, readCapped, WaitTimeoutError, runWaitOperation, defineCliCommand2, DEFAULT_EXIT_CODES2, cliExitCode2, emitResult2, CliArgumentError2, cliInvocationResult2, createCliInvoker2, routeCliArgv2, parseCliArgs2, extractCliGlobalOptions2, renderCliView2, pollUntilDone2, createCli2 };