argsbarg 3.3.13 → 3.4.0

package/src/index.test.ts

@@ -26,7 +26,7 @@ import { buildToolCallSuccess } from "./mcp/result.ts";
 import { generateSkillBundle } from "./skill/generate.ts";
 import { cliSkillInstall } from "./skill/install.ts";
 import { ParseKind, parse, postParseValidate } from "./parse.ts";
-import { cliSchemaJson } from "./schema.ts";
+import { cliSchemaExport, cliSchemaJson } from "./schema.ts";
 import { cliValidateProgram } from "./validate.ts";
 import { expect, test } from "bun:test";
 
@@ -496,7 +496,7 @@ test("leaf completion help prints correctly", async () => {
   const out = stdout.toString();
   expect(exitCode).toBe(0);
   expect(out).toContain("Show help for this command.");
-  expect(out).toContain("Output is the whole script.");
+  expect(out).toContain("Manual install:");
   expect(stderr.toString()).toBe("");
 });
 
@@ -658,7 +658,7 @@ test("docs help lists schema, api, and skill subcommands", () => {
   expect(help).toContain("api");
   expect(help).toContain("markdown");
   expect(help).toContain("skill");
-  expect(help).toContain("SKILL.md");
+  expect(help).toContain("reference agent SKILL");
 });
 
 test("root help omits legacy --schema flag", () => {
@@ -690,7 +690,8 @@ test("root help shows agent docs hint when docs enabled", () => {
     commands: [{ key: "run", description: "Run.", handler: () => {} }],
   });
   const help = cliHelpRender(cliPresentationRoot(root), [], false);
-  expect(help).toContain("Agents: run `myapp docs skill` to learn how to use this app");
+  expect(help).toContain("For AI agents: `myapp docs skill`.");
+  expect(help).not.toContain("install --skill");
 });
 
 test("root help omits agent hint when docs disabled", () => {
@@ -852,6 +853,146 @@ test("collectMcpTools lists user leaf commands only", () => {
   expect(lookup.description).toBe("stat owner lookup — Resolve owner info.");
 });
 
+test("collectMcpTools appends leaf notes to MCP tool description", () => {
+  const root = testProgram({
+    key: "app",
+    version: "1.0.0",
+    description: "Notes demo.",
+    mcpServer: { enabled: true },
+    commands: [
+      {
+        key: "run",
+        description: "Run.",
+        notes: "Use `--json` for structured output.",
+        handler: () => {},
+      },
+    ],
+  });
+  const tools = collectMcpTools(root);
+  expect(tools[0]!.description).toBe("run — Run.\n\nUse `--json` for structured output.");
+});
+
+test("collectMcpTools appends notes after mcpTool.description override", () => {
+  const root = testProgram({
+    key: "app",
+    version: "1.0.0",
+    description: "Notes demo.",
+    mcpServer: { enabled: true },
+    commands: [
+      {
+        key: "run",
+        description: "Run.",
+        notes: "Operational hint.",
+        mcpTool: { description: "Custom MCP text." },
+        handler: () => {},
+      },
+    ],
+  });
+  const tools = collectMcpTools(root);
+  expect(tools[0]!.description).toBe("Custom MCP text.\n\nOperational hint.");
+});
+
+test("collectMcpTools resolves {argsbarg:program} in appended notes", () => {
+  const root = testProgram({
+    key: "myapp",
+    version: "1.0.0",
+    description: "Notes demo.",
+    mcpServer: { enabled: true },
+    commands: [
+      {
+        key: "run",
+        description: "Run.",
+        notes: "See `{argsbarg:program} docs api`.",
+        handler: () => {},
+      },
+    ],
+  });
+  const tools = collectMcpTools(root);
+  expect(tools[0]!.description).toContain("See `myapp docs api`.");
+});
+
+test("cliSchemaExport includes leaf outputSchema", () => {
+  const root = testProgram({
+    key: "app",
+    version: "1.0.0",
+    description: "Schema export demo.",
+    mcpServer: { enabled: true },
+    commands: [
+      {
+        key: "run",
+        description: "Run.",
+        outputSchema: {
+          type: "object",
+          properties: { ok: { type: "boolean" } },
+        },
+        handler: () => {},
+      },
+    ],
+  });
+  const schema = cliSchemaExport(root);
+  expect(schema.commands![0]!.outputSchema).toEqual({
+    type: "object",
+    properties: { ok: { type: "boolean" } },
+  });
+});
+
+test("cliSchemaExport accepts legacy mcpTool.outputSchema", () => {
+  const root = testProgram({
+    key: "app",
+    version: "1.0.0",
+    description: "Schema export demo.",
+    commands: [
+      {
+        key: "run",
+        description: "Run.",
+        mcpTool: {
+          outputSchema: { type: "object", properties: { id: { type: "string" } } },
+        },
+        handler: () => {},
+      },
+    ],
+  });
+  expect(cliSchemaExport(root).commands![0]!.outputSchema).toEqual({
+    type: "object",
+    properties: { id: { type: "string" } },
+  });
+});
+
+test("outputSchema must be a JSON Schema object", () => {
+  const root = testProgram({
+    key: "app",
+    version: "1.0.0",
+    description: "Bad output schema.",
+    commands: [
+      {
+        key: "run",
+        description: "Run.",
+        outputSchema: [] as unknown as Record<string, unknown>,
+        handler: () => {},
+      },
+    ],
+  });
+  expect(() => cliValidateProgram(root)).toThrow(/outputSchema must be a JSON Schema object/);
+});
+
+test("outputSchema cannot be set on both leaf and mcpTool", () => {
+  const root = testProgram({
+    key: "app",
+    version: "1.0.0",
+    description: "Duplicate output schema.",
+    commands: [
+      {
+        key: "run",
+        description: "Run.",
+        outputSchema: { type: "object" },
+        mcpTool: { outputSchema: { type: "object" } },
+        handler: () => {},
+      },
+    ],
+  });
+  expect(() => cliValidateProgram(root)).toThrow(/Set outputSchema on the leaf only/);
+});
+
 test("collectMcpTools merges parent options into inputSchema", () => {
   const tools = collectMcpTools(nestedMcpFixture);
   const lookup = tools.find((t) => t.name === "stat_owner_lookup")!;
@@ -860,6 +1001,40 @@ test("collectMcpTools merges parent options into inputSchema", () => {
   expect(schema.required).toContain("path");
 });
 
+test("collectMcpTools includes outputSchema when set on leaf", () => {
+  const root = testProgram({
+    key: "app",
+    version: "1.0.0",
+    description: "Output schema demo.",
+    mcpServer: { enabled: true },
+    commands: [
+      {
+        key: "run",
+        description: "Run with JSON output.",
+        outputSchema: {
+          type: "object",
+          properties: { ok: { type: "boolean" } },
+          required: ["ok"],
+        },
+        handler: () => {},
+      },
+    ],
+  });
+  const tools = collectMcpTools(root);
+  expect(tools).toHaveLength(1);
+  expect(tools[0]!.outputSchema).toEqual({
+    type: "object",
+    properties: { ok: { type: "boolean" } },
+    required: ["ok"],
+  });
+});
+
+test("collectMcpTools omits outputSchema when leaf has none", () => {
+  const tools = collectMcpTools(nestedMcpFixture);
+  const lookup = tools.find((t) => t.name === "stat_owner_lookup")!;
+  expect(lookup.outputSchema).toBeUndefined();
+});
+
 test("mcpToolCallToArgv builds nested lookup argv", () => {
   const tools = collectMcpTools(nestedMcpFixture);
   const lookup = tools.find((t) => t.name === "stat_owner_lookup")!;
@@ -1815,7 +1990,7 @@ test("generateSkillBundle includes frontmatter and compact command index", () =>
   expect(bundle.skillMd).toContain("## Commands");
   expect(bundle.skillMd).toContain("`nested.ts stat owner lookup <path>`");
   expect(bundle.skillMd).toContain("Invoke via shell:");
-  expect(bundle.skillMd).toContain("read `reference.md`");
+  expect(bundle.skillMd).toContain("For full detail, open `reference.md`");
   expect(bundle.skillMd).not.toContain("#### Options");
   expect(bundle.skillMd).not.toContain("CLI API reference");
   expect(bundle.skillMd).not.toContain("mcp.json");

package/src/index.ts

@@ -18,6 +18,7 @@ export type {
   CliInvocation,
   CliMcpResource,
   CliMcpServerConfig,
+  CliMcpBundleConfig,
   CliMcpToolConfig,
   CliInstallConfig,
   CliUpdateArtifact,
@@ -45,3 +46,5 @@ export {
   parseReleaseTag,
 } from "./install/gh-release-update.ts";
 export type { GhReleaseUpdateConfig, GhVersionCheckConfig } from "./install/gh-release-update.ts";
+export { generateMcpManifest, packMcpBundle, defaultMcpBundlePaths } from "./mcp/bundle.ts";
+export type { McpBundlePaths, PackMcpBundleOpts } from "./mcp/bundle.ts";

package/src/invoke.ts

@@ -6,7 +6,7 @@ process.exit so MCP tool calls can run handlers repeatedly.
 
 import { CliContext } from "./context.ts";
 import { builtinInterceptRoot, dispatchBuiltin } from "./builtins/dispatch.ts";
-import { cliPresentationRoot } from "./builtins/presentation.ts";
+import { cliParseRoot, cliPresentationRoot } from "./builtins/presentation.ts";
 import { parse, postParseValidate, ParseKind } from "./parse.ts";
 import { type CliNode, type CliProgram, type CliRouter, isCliLeaf, isCliRouter } from "./types.ts";
 import { format } from "node:util";
@@ -65,7 +65,7 @@ export async function cliInvoke(root: CliProgram, argv: string[]): Promise<CliIn
       isLeafCompletionIntercept = intercept.isLeafCompletionIntercept;
     }
   } else {
-    parseRoot = cliPresentationRoot(root);
+    parseRoot = cliParseRoot(root);
   }
 
   let pr = parse(parseRoot, argv);

package/src/mcp/bundle.ts

@@ -0,0 +1,251 @@
+/*
+Packs a CLI program into an MCP Bundle (`.mcpb`) for Claude Desktop.
+macOS-only v1: expects `dist/<program.key>` as the compiled binary input.
+*/
+
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { collectMcpTools, mcpServerId } from "./tools.ts";
+import type { CliMcpBundleConfig, CliProgram } from "../types.ts";
+
+const MANIFEST_VERSION = "0.3";
+const DIST_DIR = "dist";
+
+/** Resolved paths for `mcp bundle`. */
+export interface McpBundlePaths {
+  binaryPath: string;
+  outPath: string;
+  binaryName: string;
+}
+
+/** Default `dist/<key>` binary and `dist/<key>.mcpb` output under cwd. */
+export function defaultMcpBundlePaths(program: CliProgram, cwd = process.cwd()): McpBundlePaths {
+  const binaryName = program.key;
+  const dist = join(cwd, DIST_DIR);
+  return {
+    binaryName,
+    binaryPath: join(dist, binaryName),
+    outPath: join(dist, `${binaryName}.mcpb`),
+  };
+}
+
+/** Collects unique env var names from MCP tool `requiresEnv` for manifest `user_config`. */
+function collectUserConfigEnvVars(program: CliProgram): string[] {
+  const names = new Set<string>();
+  for (const tool of collectMcpTools(program)) {
+    for (const env of tool.leaf.mcpTool?.requiresEnv ?? []) {
+      if (env.length > 0) {
+        names.add(env);
+      }
+    }
+  }
+  return [...names].sort();
+}
+
+/** Builds manifest `user_config` entries for required environment variables. */
+function buildUserConfig(program: CliProgram): Record<string, unknown> | undefined {
+  const envVars = collectUserConfigEnvVars(program);
+  if (envVars.length === 0) {
+    return undefined;
+  }
+  const out: Record<string, unknown> = {};
+  for (const name of envVars) {
+    const key = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "") || "env_var";
+    out[key] = {
+      type: "string",
+      title: name,
+      description: `Value for environment variable ${name}`,
+      sensitive: /key|token|secret|password/i.test(name),
+      required: true,
+    };
+  }
+  return out;
+}
+
+/** Default author when `mcpServer.bundle.author` is unset. */
+function defaultAuthor(bundle?: CliMcpBundleConfig): { name: string; email?: string; url?: string } {
+  return bundle?.author ?? { name: "Unknown" };
+}
+
+/** Generates MCPB `manifest.json` object from program schema and MCP tools. */
+export function generateMcpManifest(program: CliProgram, binaryName: string): Record<string, unknown> {
+  const bundle = program.mcpServer?.bundle;
+  const tools = collectMcpTools(program).map((t) => ({
+    name: t.name,
+    description: t.description.split("\n")[0] ?? t.description,
+  }));
+
+  const manifest: Record<string, unknown> = {
+    manifest_version: MANIFEST_VERSION,
+    name: mcpServerId(program),
+    version: program.version,
+    description: program.description,
+    author: defaultAuthor(bundle),
+    server: {
+      type: "binary",
+      entry_point: binaryName,
+      mcp_config: {
+        command: `\${__dirname}/${binaryName}`,
+        args: ["mcp"],
+      },
+    },
+    tools,
+    tools_generated: false,
+    compatibility: {
+      claude_desktop: ">=0.10.0",
+      platforms: ["darwin"],
+    },
+  };
+
+  const longDescription = bundle?.longDescription ?? program.description;
+  if (longDescription !== program.description) {
+    manifest.long_description = longDescription;
+  }
+
+  const userConfig = buildUserConfig(program);
+  if (userConfig) {
+    manifest.user_config = userConfig;
+  }
+
+  if (bundle?.icon) {
+    manifest.icon = basename(bundle.icon);
+  }
+
+  return manifest;
+}
+
+/** CRC-32 table for ZIP local headers (store method). */
+function crc32(data: Buffer): number {
+  let crc = 0xffffffff;
+  for (let i = 0; i < data.length; i++) {
+    crc ^= data[i]!;
+    for (let j = 0; j < 8; j++) {
+      crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
+    }
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+/** Writes a minimal ZIP (store, no compression) with one or more files. */
+function zipStore(files: { name: string; data: Buffer }[]): Buffer {
+  const parts: Buffer[] = [];
+  const central: Buffer[] = [];
+  let offset = 0;
+
+  for (const file of files) {
+    const nameBuf = Buffer.from(file.name, "utf8");
+    const crc = crc32(file.data);
+    const local = Buffer.alloc(30 + nameBuf.length);
+    local.writeUInt32LE(0x04034b50, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(0, 6);
+    local.writeUInt16LE(0, 8);
+    local.writeUInt16LE(0, 10);
+    local.writeUInt16LE(0, 12);
+    local.writeUInt32LE(crc, 14);
+    local.writeUInt32LE(file.data.length, 18);
+    local.writeUInt32LE(file.data.length, 22);
+    local.writeUInt32LE(nameBuf.length, 26);
+    local.writeUInt16LE(0, 28);
+    nameBuf.copy(local, 30);
+
+    const centralHdr = Buffer.alloc(46 + nameBuf.length);
+    centralHdr.writeUInt32LE(0x02014b50, 0);
+    centralHdr.writeUInt16LE(20, 4);
+    centralHdr.writeUInt16LE(20, 6);
+    centralHdr.writeUInt16LE(0, 8);
+    centralHdr.writeUInt16LE(0, 10);
+    centralHdr.writeUInt16LE(0, 12);
+    centralHdr.writeUInt16LE(0, 14);
+    centralHdr.writeUInt32LE(crc, 16);
+    centralHdr.writeUInt32LE(file.data.length, 20);
+    centralHdr.writeUInt32LE(file.data.length, 24);
+    centralHdr.writeUInt32LE(nameBuf.length, 28);
+    centralHdr.writeUInt16LE(0, 30);
+    centralHdr.writeUInt16LE(0, 32);
+    centralHdr.writeUInt16LE(0, 34);
+    centralHdr.writeUInt16LE(0, 36);
+    centralHdr.writeUInt32LE(0, 38);
+    centralHdr.writeUInt32LE(offset, 42);
+    nameBuf.copy(centralHdr, 46);
+
+    parts.push(local, file.data);
+    central.push(centralHdr);
+    offset += local.length + file.data.length;
+  }
+
+  const centralStart = offset;
+  const centralBuf = Buffer.concat(central);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50, 0);
+  end.writeUInt16LE(0, 4);
+  end.writeUInt16LE(0, 6);
+  end.writeUInt16LE(files.length, 8);
+  end.writeUInt16LE(files.length, 10);
+  end.writeUInt32LE(centralBuf.length, 12);
+  end.writeUInt32LE(centralStart, 16);
+  end.writeUInt16LE(0, 20);
+
+  return Buffer.concat([...parts, centralBuf, end]);
+}
+
+export interface PackMcpBundleOpts {
+  cwd?: string;
+  binaryPath?: string;
+  outPath?: string;
+}
+
+/**
+ * Stages manifest + binary (+ optional icon) and writes a `.mcpb` ZIP.
+ * macOS-only v1; requires the compiled binary to exist.
+ */
+export function packMcpBundle(program: CliProgram, opts: PackMcpBundleOpts = {}): string {
+  if (process.platform !== "darwin") {
+    throw new Error("mcp bundle is macOS-only in this release. Build the bundle on darwin.");
+  }
+
+  const cwd = opts.cwd ?? process.cwd();
+  const defaults = defaultMcpBundlePaths(program, cwd);
+  const binaryPath = resolve(cwd, opts.binaryPath ?? defaults.binaryPath);
+  const outPath = resolve(cwd, opts.outPath ?? defaults.outPath);
+  const binaryName = basename(binaryPath);
+
+  if (!existsSync(binaryPath)) {
+    throw new Error(`Binary not found: ${binaryPath}. Build with compile first (expected dist/${program.key}).`);
+  }
+
+  const staging = mkdtempSync(join(tmpdir(), "mcpb-"));
+  try {
+    const stagedBinary = join(staging, binaryName);
+    cpSync(binaryPath, stagedBinary, { mode: 0o755 });
+
+    const manifest = generateMcpManifest(program, binaryName);
+    const files: { name: string; data: Buffer }[] = [
+      { name: "manifest.json", data: Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`, "utf8") },
+      { name: binaryName, data: readFileSync(stagedBinary) },
+    ];
+
+    const iconRel = program.mcpServer?.bundle?.icon;
+    if (iconRel) {
+      const iconSrc = resolve(cwd, iconRel);
+      if (!existsSync(iconSrc)) {
+        throw new Error(`Bundle icon not found: ${iconRel}`);
+      }
+      const iconName = basename(iconRel);
+      files.push({ name: iconName, data: readFileSync(iconSrc) });
+    }
+
+    mkdirSync(join(outPath, ".."), { recursive: true });
+    writeFileSync(outPath, zipStore(files));
+    return outPath;
+  } finally {
+    rmSync(staging, { recursive: true, force: true });
+  }
+}
+
+/** Runs `mcp bundle`: writes `dist/<key>.mcpb` and prints the path on stdout. */
+export function runMcpBundle(program: CliProgram): void {
+  const outPath = packMcpBundle(program);
+  process.stdout.write(`${outPath}\n`);
+}

package/src/mcp/server.ts

@@ -95,6 +95,7 @@ async function handleRequestLine(root: CliProgram, line: string): Promise<void>
         name: t.name,
         description: t.description,
         inputSchema: t.inputSchema,
+        ...(t.outputSchema === undefined ? {} : { outputSchema: t.outputSchema }),
       }));
       writeResponse({ jsonrpc: "2.0", id, result: { tools } });
       return;

package/src/mcp/tools.ts

@@ -3,9 +3,11 @@ This module maps CliProgram leaf nodes to MCP tool definitions and converts
 flat JSON tool arguments into argv for cliInvoke.
 */
 
+import { cliResolveNotes } from "../help.ts";
 import { collectOptionDefs } from "../parse.ts";
+import { visibleOptions } from "../hidden.ts";
 import { cliSchemaJson } from "../schema.ts";
-import { CliProgram, CliLeaf, CliNode, CliOption, CliOptionKind, CliPositional, isCliLeaf, isCliRouter } from "../types.ts";
+import { CliProgram, CliLeaf, CliNode, CliOption, CliOptionKind, CliPositional, isCliLeaf, isCliRouter, leafOutputSchema } from "../types.ts";
 
 /** Default URI pattern for the CLI schema MCP resource (`<mcpId>://schema`). */
 export function defaultMcpSchemaUri(mcpId: string): string {
@@ -34,6 +36,8 @@ export interface McpToolDef {
   leaf: CliLeaf;
   /** JSON Schema for tools/call arguments. */
   inputSchema: Record<string, unknown>;
+  /** JSON Schema for structured tool results when set on the leaf `mcpTool`. */
+  outputSchema?: Record<string, unknown>;
 }
 
 /** Builds MCP tool description: "{cli path} — {description}". */
@@ -80,7 +84,7 @@ function buildInputSchema(root: CliProgram, path: string[], leaf: CliLeaf): Reco
   const properties: Record<string, unknown> = {};
   const required: string[] = [];
 
-  for (const opt of collectOptionDefs(root, path)) {
+  for (const opt of visibleOptions(collectOptionDefs(root, path))) {
     properties[opt.name] = optionProperty(opt);
     if (opt.required) {
       required.push(opt.name);
@@ -106,15 +110,21 @@ function buildInputSchema(root: CliProgram, path: string[], leaf: CliLeaf): Reco
   return schema;
 }
 
-/** Resolves MCP tool description with optional override and requiresEnv suffix. */
+/** Resolves MCP tool description with optional override, requiresEnv suffix, and leaf notes. */
 function resolveToolDescription(root: CliProgram, path: string[], leaf: CliLeaf): string {
+  let desc: string;
   if (leaf.mcpTool?.description) {
-    return leaf.mcpTool.description;
+    desc = leaf.mcpTool.description;
+  } else {
+    desc = mcpToolDescription(path, root.key, leaf.description);
+    const env = leaf.mcpTool?.requiresEnv;
+    if (env && env.length > 0) {
+      desc += ` [requires env: ${env.join(", ")}]`;
+    }
   }
-  let desc = mcpToolDescription(path, root.key, leaf.description);
-  const env = leaf.mcpTool?.requiresEnv;
-  if (env && env.length > 0) {
-    desc += ` [requires env: ${env.join(", ")}]`;
+  const notes = (leaf.notes ?? "").trim();
+  if (notes.length > 0) {
+    desc += `\n\n${cliResolveNotes(notes, root.key)}`;
   }
   return desc;
 }
@@ -155,18 +165,25 @@ export function collectMcpTools(root: CliProgram): McpToolDef[] {
   /** Walks the command tree and appends leaf tools. */
   function walk(cmd: CliNode, path: string[]): void {
     if (isCliLeaf(cmd)) {
-      if (cmd.key === "completion" || cmd.key === "install" || cmd.key === "mcp" || cmd.key === "version") {
+      if (
+        cmd.key === "completion" ||
+        cmd.key === "install" ||
+        cmd.key === "mcp" ||
+        cmd.key === "version"
+      ) {
         return;
       }
-      if (cmd.mcpTool?.enabled === false) {
+      if (cmd.hidden || cmd.mcpTool?.enabled === false) {
         return;
       }
+      const outputSchema = leafOutputSchema(cmd);
       out.push({
         name: mcpToolName(root, path),
         description: resolveToolDescription(root, path, cmd),
         path,
         leaf: cmd,
         inputSchema: buildInputSchema(root, path, cmd),
+        ...(outputSchema === undefined ? {} : { outputSchema }),
       });
       return;
     }

package/src/runtime.ts

@@ -4,7 +4,7 @@ This module runs parsed commands, help, errors, completion, and leaf handlers.
 
 import { resolveCapabilities } from "./capabilities.ts";
 import { builtinInterceptRoot, dispatchBuiltin } from "./builtins/dispatch.ts";
-import { cliPresentationRoot } from "./builtins/presentation.ts";
+import { cliParseRoot, cliPresentationRoot } from "./builtins/presentation.ts";
 import type { CliRouter } from "./types.ts";
 import { type CliNode, type CliProgram, isCliLeaf, isCliRouter } from "./types.ts";
 import { CliContext } from "./context.ts";
@@ -13,7 +13,7 @@ import { parse, postParseValidate, ParseKind } from "./parse.ts";
 import { cliValidateProgram } from "./validate.ts";
 
 function cliRootMergedWithBuiltins(program: CliProgram): CliRouter {
-  return cliPresentationRoot(program);
+  return cliParseRoot(program);
 }
 
 export async function cliRun(program: CliProgram, argv: string[] = process.argv.slice(2)): Promise<never> {
@@ -68,7 +68,7 @@ export async function cliRun(program: CliProgram, argv: string[] = process.argv.
   pr = postParseValidate(parseRoot, pr);
 
   if (pr.kind === ParseKind.Help) {
-    process.stdout.write(cliHelpRender(cliPresentationRoot(program), pr.helpPath, false));
+    process.stdout.write(cliHelpRender(cliParseRoot(program), pr.helpPath, false));
     process.exit(pr.helpExplicit ? 0 : 1);
   }