argsbarg 7.0.8 → 7.0.10

package/src/core/document-leaf.test.ts

@@ -0,0 +1,208 @@
+/*
+Tests for structured document leaves (kind: "document") supporting JSON and YAML document input.
+*/
+
+import { describe, expect, test } from "bun:test";
+import { Cli } from "../index.ts";
+import { LeafInputError, parseDocumentText } from "./leaf-inputs.ts";
+import { ParseKind, parse } from "./parse.ts";
+import { CliOptionKind, type CliProgram, CliSchemaValidationError } from "./types.ts";
+import { cliValidateProgram } from "./validate.ts";
+
+/** JSON Schema for the deployment test document body. */
+const deploySchema = {
+  type: "object",
+  properties: {
+    target: { type: "string", enum: ["staging", "production"] },
+    config: {
+      type: "object",
+      properties: { replicas: { type: "integer" } },
+      required: ["replicas"],
+      additionalProperties: false,
+    },
+  },
+  required: ["target", "config"],
+  additionalProperties: false,
+} as const;
+
+/** Creates a test program with a single `kind: "document"` leaf command. */
+function documentLeafProgram() {
+  return {
+    key: "document-leaf-test",
+    version: "1.0.0",
+    description: "document leaf tests",
+    commands: [
+      {
+        key: "deploy",
+        description: "Deploy from document body",
+        kind: "document",
+        inputSchema: deploySchema,
+        handler: (ctx) => ctx.inputsAs<{ target: string; config: { replicas: number } }>(),
+      },
+    ],
+  } satisfies CliProgram;
+}
+
+/** Tests for `kind: "document"` leaf commands. */
+describe("kind: document leaf", () => {
+  /** Tests validation rules for document leaves. */
+  test("validate requires inputSchema and forbids options/positionals", () => {
+    expect(() =>
+      cliValidateProgram({
+        key: "bad",
+        version: "1",
+        description: "bad",
+        commands: [{ key: "x", description: "x", kind: "document", handler: () => {} }],
+      }),
+    ).toThrow(CliSchemaValidationError);
+
+    expect(() =>
+      cliValidateProgram({
+        key: "bad",
+        version: "1",
+        description: "bad",
+        commands: [
+          {
+            key: "x",
+            description: "x",
+            kind: "document",
+            inputSchema: deploySchema,
+            options: [{ name: "f", description: "f", kind: CliOptionKind.String }],
+            handler: () => {},
+          },
+        ],
+      }),
+    ).toThrow(CliSchemaValidationError);
+
+    expect(() =>
+      cliValidateProgram({
+        key: "bad",
+        version: "1",
+        description: "bad",
+        commands: [
+          {
+            key: "x",
+            description: "x",
+            kind: "document",
+            inputSchema: deploySchema,
+            positionals: [{ name: "file", description: "file", kind: CliOptionKind.String }],
+            handler: () => {},
+          },
+        ],
+      }),
+    ).toThrow(CliSchemaValidationError);
+  });
+
+  /** Tests that flags on document leaves are rejected. */
+  test("parse rejects CLI flags on document leaf", () => {
+    const root = documentLeafProgram();
+    const pr = parse(root, ["deploy", "--target", "staging"]);
+    expect(pr.kind).toBe(ParseKind.Error);
+    expect(pr.errorMsg).toContain("Document commands do not accept options");
+  });
+
+  /** Tests that document leaf accepts positional argument tokens. */
+  test("parse accepts document positional token", () => {
+    const root = documentLeafProgram();
+    const pr = parse(root, ["deploy", "target: staging"]);
+    expect(pr.kind).toBe(ParseKind.Ok);
+    expect(pr.args).toEqual(["target: staging"]);
+  });
+
+  /** Tests reading body from YAML positional argv. */
+  test("invoke reads body from YAML positional argv", async () => {
+    const cli = new Cli(documentLeafProgram());
+    const yaml = "target: staging\nconfig:\n  replicas: 3";
+    const result = await cli.invoke(["deploy", yaml], { invocation: "mcp" });
+    expect(result.kind).toBe("ok");
+    expect(result.response?.body).toEqual({ target: "staging", config: { replicas: 3 } });
+
+    const cliResult = await cli.invoke(["deploy", yaml], { invocation: "cli" });
+    expect(cliResult.kind).toBe("ok");
+    expect(JSON.parse(cliResult.stdout)).toEqual({ target: "staging", config: { replicas: 3 } });
+  });
+
+  /** Tests reading body from JSON positional argv. */
+  test("invoke reads body from JSON positional argv", async () => {
+    const cli = new Cli(documentLeafProgram());
+    const json = '{"target":"production","config":{"replicas":5}}';
+    const result = await cli.invoke(["deploy", json], { invocation: "mcp" });
+    expect(result.kind).toBe("ok");
+    expect(result.response?.body).toEqual({ target: "production", config: { replicas: 5 } });
+  });
+
+  /** Tests reading body from toolArgs. */
+  test("invoke reads body from toolArgs", async () => {
+    const cli = new Cli(documentLeafProgram());
+    const result = await cli.invoke(["deploy"], {
+      invocation: "http",
+      toolArgs: { target: "production", config: { replicas: 10 } },
+    });
+    expect(result.kind).toBe("ok");
+    expect(result.response?.body).toEqual({ target: "production", config: { replicas: 10 } });
+  });
+
+  /** Tests error message when document body is missing. */
+  test("invoke errors when body is missing", async () => {
+    const cli = new Cli(documentLeafProgram());
+    const result = await cli.invoke(["deploy"], { invocation: "cli" });
+    expect(result.kind).toBe("error");
+    expect(result.errorMsg).toContain("Missing document input");
+  });
+
+  /** Tests inputSchema validation error handling. */
+  test("invoke validates inputSchema before handler runs", async () => {
+    let handlerRan = false;
+    const base = documentLeafProgram();
+    const program = {
+      ...base,
+      commands: [
+        {
+          ...base.commands[0],
+          handler: () => {
+            handlerRan = true;
+          },
+        },
+      ],
+    } satisfies CliProgram;
+    const cli = new Cli(program);
+    const result = await cli.invoke(["deploy", "target: invalid-target\nconfig:\n  replicas: 1"], {
+      invocation: "cli",
+    });
+    expect(result.kind).toBe("error");
+    expect(handlerRan).toBe(false);
+  });
+
+  /** Tests non-object document body returns error. */
+  test("non-object document body returns error", async () => {
+    const cli = new Cli(documentLeafProgram());
+    const result = await cli.invoke(["deploy", '"just-a-string"'], { invocation: "cli" });
+    expect(result.kind).toBe("error");
+    expect(result.errorMsg).toContain("Document input must be a JSON or YAML object");
+  });
+});
+
+/** Tests for parseDocumentText helper function. */
+describe("parseDocumentText", () => {
+  /** Tests parsing valid JSON. */
+  test("parses valid JSON object", () => {
+    const parsed = parseDocumentText('{"key":"value"}', "test");
+    expect(parsed).toEqual({ key: "value" });
+  });
+
+  /** Tests parsing valid YAML. */
+  test("parses valid YAML object", () => {
+    const parsed = parseDocumentText("key: value\nnested:\n  count: 2", "test");
+    expect(parsed).toEqual({ key: "value", nested: { count: 2 } });
+  });
+
+  /** Tests empty string throws error. */
+  test("throws on empty string", () => {
+    expect(() => parseDocumentText("   ", "test")).toThrow(LeafInputError);
+  });
+
+  /** Tests invalid syntax throws error. */
+  test("throws on invalid syntax", () => {
+    expect(() => parseDocumentText("{bad json", "test")).toThrow(LeafInputError);
+  });
+});

package/src/core/json-leaf.test.ts

@@ -1,9 +1,14 @@
+/*
+Tests for pure JSON leaves (kind: "json") including backward-compatibility and YAML document input.
+*/
+
 import { describe, expect, test } from "bun:test";
 import { Cli } from "../index.ts";
 import { ParseKind, parse } from "./parse.ts";
 import { CliOptionKind, type CliProgram, CliSchemaValidationError } from "./types.ts";
 import { cliValidateProgram } from "./validate.ts";
 
+/** JSON Schema for the invoice render test body. */
 const bodySchema = {
   type: "object",
   properties: {
@@ -19,6 +24,7 @@ const bodySchema = {
   additionalProperties: false,
 } as const;
 
+/** Creates a test program with a single `kind: "json"` leaf command. */
 function jsonLeafProgram() {
   return {
     key: "json-leaf-test",
@@ -36,7 +42,9 @@ function jsonLeafProgram() {
   } satisfies CliProgram;
 }
 
+/** Tests for `kind: "json"` leaf commands. */
 describe("kind: json leaf", () => {
+  /** Tests validation rules for json leaves. */
   test("validate requires inputSchema and forbids options/positionals", () => {
     expect(() =>
       cliValidateProgram({
@@ -84,6 +92,7 @@ describe("kind: json leaf", () => {
     ).toThrow(CliSchemaValidationError);
   });
 
+  /** Tests that flags on json leaves are rejected. */
   test("parse rejects CLI flags on json leaf", () => {
     const root = jsonLeafProgram();
     const pr = parse(root, ["render", "--format", "pdf"]);
@@ -91,6 +100,7 @@ describe("kind: json leaf", () => {
     expect(pr.errorMsg).toContain("JSON commands do not accept options");
   });
 
+  /** Tests that json leaf accepts JSON positional arguments. */
   test("parse accepts JSON positional", () => {
     const root = jsonLeafProgram();
     const pr = parse(root, ["render", '{"format":"pdf","invoice":{"id":"1"}}']);
@@ -98,6 +108,7 @@ describe("kind: json leaf", () => {
     expect(pr.args).toEqual(['{"format":"pdf","invoice":{"id":"1"}}']);
   });
 
+  /** Tests reading body from toolArgs. */
   test("invoke reads body from toolArgs", async () => {
     const cli = new Cli(jsonLeafProgram());
     const result = await cli.invoke(["render"], {
@@ -108,6 +119,7 @@ describe("kind: json leaf", () => {
     expect(result.response?.body).toEqual({ format: "pdf", invoice: { id: "INV-1" } });
   });
 
+  /** Tests reading body from JSON positional argv. */
   test("invoke reads body from JSON positional argv", async () => {
     const cli = new Cli(jsonLeafProgram());
     const result = await cli.invoke(["render", '{"format":"html","invoice":{"id":"2"}}'], {
@@ -117,6 +129,18 @@ describe("kind: json leaf", () => {
     expect(result.response?.body).toEqual({ format: "html", invoice: { id: "2" } });
   });
 
+  /** Tests reading body from YAML positional argv for kind: "json" leaf. */
+  test("invoke reads body from YAML positional argv", async () => {
+    const cli = new Cli(jsonLeafProgram());
+    const yamlBody = "format: pdf\ninvoice:\n  id: 'INV-YAML-1'";
+    const result = await cli.invoke(["render", yamlBody], {
+      invocation: "mcp",
+    });
+    expect(result.kind).toBe("ok");
+    expect(result.response?.body).toEqual({ format: "pdf", invoice: { id: "INV-YAML-1" } });
+  });
+
+  /** Tests error when body is missing. */
   test("invoke errors when body missing", async () => {
     const cli = new Cli(jsonLeafProgram());
     const result = await cli.invoke(["render"], { invocation: "http" });
@@ -124,6 +148,7 @@ describe("kind: json leaf", () => {
     expect(result.errorMsg).toContain("Missing JSON input");
   });
 
+  /** Tests inputSchema validation before handler runs. */
   test("invoke validates inputSchema before handler", async () => {
     let called = false;
     const base = jsonLeafProgram();
@@ -147,6 +172,7 @@ describe("kind: json leaf", () => {
     expect(called).toBe(false);
   });
 
+  /** Tests error on non-object JSON body. */
   test("non-object JSON body returns error", async () => {
     const cli = new Cli(jsonLeafProgram());
     const result = await cli.invoke(["render", '"not-an-object"'], { invocation: "cli" });

package/src/core/leaf-inputs.ts

@@ -7,7 +7,7 @@ import { isInteractiveTty } from "../utils.ts";
 import type { CliContext, CliLeafInputs } from "./context.ts";
 import { collectOptionDefs } from "./parse.ts";
 import type { CliInvocation, CliLeaf, CliNode, CliOption, CliProgram } from "./types.ts";
-import { CliOptionKind, CliValueFormat, isCliLeaf, isCliRouter, isJsonLeaf } from "./types.ts";
+import { type CliLeafKind, CliOptionKind, CliValueFormat, isCliLeaf, isCliRouter, isDocumentLeaf } from "./types.ts";
 
 /** Thrown when leaf input resolution or validation fails. */
 export class LeafInputError extends Error {
@@ -17,8 +17,11 @@ export class LeafInputError extends Error {
   }
 }
 
-/** Internal key for piped stdin on `kind: "json"` leaves. */
-export const JSON_LEAF_BODY_KEY = "__jsonLeafBody";
+/** Internal key for piped stdin on `kind: "document"` or `kind: "json"` leaves. */
+export const DOCUMENT_LEAF_BODY_KEY = "__documentLeafBody";
+
+/** Internal key for piped stdin on `kind: "json"` leaves (backward-compatible alias). */
+export const JSON_LEAF_BODY_KEY = DOCUMENT_LEAF_BODY_KEY;
 
 function resolveLeaf(program: CliProgram, commandPath: string[]): CliLeaf | undefined {
   let node: CliNode = program;
@@ -36,7 +39,12 @@ function leafNode(ctx: CliContext): CliLeaf | undefined {
 }
 
 /** Parses a JSON string from a `--name` flag value. */
-export function parseJsonText(raw: string, label: string): unknown {
+export function parseJsonText(
+  /** Raw text to parse as JSON. */
+  raw: string,
+  /** Field or argument label for error reporting. */
+  label: string,
+): unknown {
   const trimmed = raw.trim();
   if (trimmed.length === 0) {
     throw new LeafInputError(`${label}: JSON value is empty`);
@@ -48,6 +56,31 @@ export function parseJsonText(raw: string, label: string): unknown {
   }
 }
 
+/** Parses a JSON or YAML string from a command argument or document body. */
+export function parseDocumentText(
+  /** Raw text containing a JSON or YAML document. */
+  raw: string,
+  /** Field or argument label for error reporting. */
+  label: string,
+): unknown {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    throw new LeafInputError(`${label}: value is empty`);
+  }
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      // Fall through to YAML if JSON parse fails
+    }
+  }
+  try {
+    return Bun.YAML.parse(trimmed);
+  } catch {
+    throw new LeafInputError(`${label}: invalid JSON or YAML`);
+  }
+}
+
 async function readPipedJsonStdin(): Promise<unknown> {
   const raw = await new Response(Bun.stdin).text();
   const trimmed = raw.trim();
@@ -61,20 +94,38 @@ async function readPipedJsonStdin(): Promise<unknown> {
   }
 }
 
-function jsonLeafBodyHelp(): string {
+/** Returns the error message when document input is missing. */
+function jsonLeafBodyHelp(
+  /** Leaf kind: document or json. */
+  kind: CliLeafKind = "json",
+): string {
+  if (kind === "document") {
+    return "Missing document input: pass a JSON or YAML document as an argument or pipe to stdin";
+  }
   return "Missing JSON input: pass a JSON document as an argument or pipe to stdin";
 }
 
-async function readPipedJsonStdinForJsonLeaf(): Promise<unknown> {
+/** Reads piped stdin for a document or json leaf command. */
+async function readPipedJsonStdinForJsonLeaf(
+  /** Leaf kind: document or json. */
+  kind: CliLeafKind = "json",
+): Promise<unknown> {
   const raw = await new Response(Bun.stdin).text();
   const trimmed = raw.trim();
   if (trimmed.length === 0) {
-    throw new LeafInputError(jsonLeafBodyHelp());
+    throw new LeafInputError(jsonLeafBodyHelp(kind));
+  }
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      // Fall through to YAML
+    }
   }
   try {
-    return JSON.parse(trimmed);
+    return Bun.YAML.parse(trimmed);
   } catch {
-    throw new LeafInputError("stdin is not valid JSON");
+    throw new LeafInputError("stdin is not valid JSON or YAML");
   }
 }
 
@@ -130,8 +181,8 @@ export async function preloadPipableJson(
   }
 
   const leaf = resolveLeaf(program, commandPath);
-  if (leaf && isJsonLeaf(leaf) && args.length === 0) {
-    return { [JSON_LEAF_BODY_KEY]: await readPipedJsonStdinForJsonLeaf() };
+  if (leaf && isDocumentLeaf(leaf) && args.length === 0) {
+    return { [JSON_LEAF_BODY_KEY]: await readPipedJsonStdinForJsonLeaf(leaf.kind) };
   }
 
   for (const opt of collectOptionDefs(program, commandPath)) {
@@ -181,22 +232,26 @@ export function loadLeafInputs(ctx: CliContext): CliLeafInputs {
   const leaf = leafNode(ctx);
   if (!leaf) return {};
 
-  if (isJsonLeaf(leaf)) {
+  if (isDocumentLeaf(leaf)) {
     let body: unknown;
     if (ctx.toolArgs !== undefined) {
       body = ctx.toolArgs;
     } else if (ctx.args.length > 0) {
       const [arg0] = ctx.args;
       if (arg0 === undefined) {
-        throw new LeafInputError(jsonLeafBodyHelp());
+        throw new LeafInputError(jsonLeafBodyHelp(leaf.kind));
       }
-      body = parseJsonText(arg0, "JSON argument");
+      const label = leaf.kind === "document" ? "Document argument" : "JSON argument";
+      body = parseDocumentText(arg0, label);
     } else if (JSON_LEAF_BODY_KEY in ctx.preloadedJson) {
       body = ctx.preloadedJson[JSON_LEAF_BODY_KEY];
     } else {
-      throw new LeafInputError(jsonLeafBodyHelp());
+      throw new LeafInputError(jsonLeafBodyHelp(leaf.kind));
     }
     if (typeof body !== "object" || body === null || Array.isArray(body)) {
+      if (leaf.kind === "document") {
+        throw new LeafInputError("Document input must be a JSON or YAML object");
+      }
       throw new LeafInputError("JSON input must be a JSON object");
     }
     const out = body as CliLeafInputs;

package/src/core/parse.ts

@@ -19,7 +19,7 @@ import {
   type CliRouter,
   isCliLeaf,
   isCliRouter,
-  isJsonLeaf,
+  isDocumentLeaf,
 } from "./types.ts";
 
 // ── Parse Result ──────────────────────────────────────────────────────────────
@@ -292,9 +292,9 @@ export function collectOptionDefs(root: CliNode, path: string[]): CliOption[] {
   return [...(node.options ?? [])];
 }
 
-/** Fills `args` for a json leaf from `startIdx` (0 or 1 JSON string positional). */
+/** Fills `args` for a document / json leaf from `startIdx` (0 or 1 JSON or YAML string positional). */
 function finishJsonLeaf(
-  _node: CliLeaf,
+  node: CliLeaf,
   startIdx: number,
   argv: string[],
   path: string[],
@@ -313,7 +313,8 @@ function finishJsonLeaf(
       return errorResult("Unexpected extra arguments", path, [], pathParams);
     }
     if (tok.startsWith("-")) {
-      return errorResult(`JSON commands do not accept options: ${tok}`, path, [], pathParams);
+      const kindLabel = node.kind === "document" ? "Document" : "JSON";
+      return errorResult(`${kindLabel} commands do not accept options: ${tok}`, path, [], pathParams);
     }
     args.push(tok);
     idx += 1;
@@ -552,7 +553,7 @@ export function parse(root: CliNode, argv: string[]): ParseResult {
   let node: CliNode | undefined;
 
   if (isCliLeaf(root)) {
-    if (isJsonLeaf(root)) {
+    if (isDocumentLeaf(root)) {
       return finishJsonLeaf(root, i, argv, path, opts, pathParams);
     }
     return finishLeaf(root, i, argv, path, opts, root.options ?? [], forcePositionals, pathParams);
@@ -645,7 +646,7 @@ export function parse(root: CliNode, argv: string[]): ParseResult {
 
   // Walk the command tree
   while (true) {
-    if (isCliLeaf(current) && isJsonLeaf(current)) {
+    if (isCliLeaf(current) && isDocumentLeaf(current)) {
       return finishJsonLeaf(current, i, argv, path, opts, pathParams);
     }
 

package/src/core/schema.ts

@@ -6,6 +6,7 @@ import { type CliSchemaExport, exportPresentationBuiltins } from "../builtins/ex
 import { cliResolveNotes } from "../help.ts";
 import { isCliSchemaHidden, visibleOptions } from "../runtime/exposure.ts";
 import { type CliNode, type CliProgram, isCliLeaf, isCliRouter, leafOutputSchema } from "./types.ts";
+import { buildLeafInputSchema } from "./wire-schema.ts";
 
 const RESERVED = new Set(["http", "completion", "configure", "docs", "mcp", "version"]);
 
@@ -32,6 +33,7 @@ function exportCommand(cmd: CliNode, root: CliProgram): CliSchemaExport | null {
     if ((cmd.positionals ?? []).length > 0) {
       out.positionals = cmd.positionals;
     }
+    out.inputSchema = buildLeafInputSchema(cmd);
     const outputSchema = leafOutputSchema(cmd);
     if (outputSchema !== undefined) {
       out.outputSchema = outputSchema;

package/src/core/types.ts

@@ -500,16 +500,17 @@ export interface CliNodeBase {
   options?: CliOption[];
 }
 
-/** Leaf input mode: `json` = pure JSON body (no CLI flags). */
-export type CliLeafKind = "json";
+/** Leaf input mode: `document` (or legacy `json`) = structured JSON or YAML document body (no CLI flags). */
+export type CliLeafKind = "document" | "json";
 
 /**
  * A leaf command node with a handler and optional positionals.
  */
 export type CliLeaf = CliNodeBase & {
   /**
-   * When `"json"`, the leaf accepts a single JSON document (CLI positional or piped stdin;
-   * MCP/HTTP tool args = body). Requires `inputSchema`; forbids `options` and `positionals`.
+   * When `"document"` (or legacy `"json"`), the leaf accepts a single JSON or YAML document
+   * (CLI positional or piped stdin; MCP/HTTP tool args = body). Requires `inputSchema`;
+   * forbids `options` and `positionals`.
    */
   kind?: CliLeafKind;
   /** Handler function for leaf commands. */
@@ -691,9 +692,20 @@ export function isCliLeaf(node: CliNode): node is CliLeaf {
   return "handler" in node && typeof node.handler === "function";
 }
 
-/** True when the leaf accepts a pure JSON body (no CLI flags). */
-export function isJsonLeaf(leaf: CliLeaf): boolean {
-  return leaf.kind === "json";
+/** True when the leaf accepts a structured JSON or YAML document body (no CLI flags). */
+export function isDocumentLeaf(
+  /** Leaf command node to inspect. */
+  leaf: CliLeaf,
+): boolean {
+  return leaf.kind === "document" || leaf.kind === "json";
+}
+
+/** True when the leaf accepts a structured document body (backward-compatible alias for `isDocumentLeaf`). */
+export function isJsonLeaf(
+  /** Leaf command node to inspect. */
+  leaf: CliLeaf,
+): boolean {
+  return isDocumentLeaf(leaf);
 }
 
 /** True when the node is a router (has subcommands). */

package/src/core/validate.ts

@@ -17,7 +17,7 @@ import {
   CliValueFormat,
   isCliLeaf,
   isCliRouter,
-  isJsonLeaf,
+  isDocumentLeaf,
 } from "./types.ts";
 
 /** Validates `docs` configuration on the program root. */
@@ -264,15 +264,16 @@ function walkNode(node: CliNode, program: CliProgram, isRoot: boolean): void {
     if (isRoot && node.mcpTool !== undefined) {
       throw new CliSchemaValidationError("mcpTool is only supported on leaf commands");
     }
-    if (isJsonLeaf(node)) {
+    if (isDocumentLeaf(node)) {
+      const kindStr = `kind: "${node.kind ?? "document"}"`;
       if (node.inputSchema === undefined) {
-        throw new CliSchemaValidationError(`kind: "json" requires inputSchema on ${node.key}`);
+        throw new CliSchemaValidationError(`${kindStr} requires inputSchema on ${node.key}`);
       }
       if ((node.options ?? []).length > 0) {
-        throw new CliSchemaValidationError(`kind: "json" forbids options on ${node.key}`);
+        throw new CliSchemaValidationError(`${kindStr} forbids options on ${node.key}`);
       }
       if ((node.positionals ?? []).length > 0) {
-        throw new CliSchemaValidationError(`kind: "json" forbids positionals on ${node.key}`);
+        throw new CliSchemaValidationError(`${kindStr} forbids positionals on ${node.key}`);
       }
     }
     const outputSchema = node.outputSchema;