argsbarg 4.1.1 → 5.0.1

package/examples/full-example/src/program.ts

@@ -32,7 +32,7 @@ const configSchema = {
 export const program = {
   key: createIdentity.key,
   version: "1.0.0",
-  description: "Argsbarg full example — all builtins, schemagen, ctx.appConfig.",
+  description: createIdentity.desc,
   appConfig: {
     jsonSchema: APP_CONFIG_JSON_SCHEMA,
     entries: configSchema,
@@ -50,8 +50,8 @@ export const program = {
     mcpd: true,
     claudePlugin: true,
   },
-  install: {
-    // Defaults: agentIntegration picks skill vs MCP for --all; configure is opt-in.
+  configure: {
+    // Defaults: agentIntegration picks skill vs MCP for sync; app config is opt-in in interactive configure.
   },
   commands: [echoCommand, statusCommand],
 } satisfies CliProgram;

package/examples/nested.ts

@@ -21,7 +21,7 @@ const program = {
       readme: { text: "# nested.ts\n\nNested groups demo.\n" },
     },
   },
-  install: {},
+  configure: {},
   commands: [
     {
       key: "stat",

package/index.d.ts

@@ -307,18 +307,23 @@ export interface CliAppConfig {
 	/** Per-key metadata; keys must match `jsonSchema.properties` when `jsonSchema` is set. */
 	entries: Record<string, CliAppConfigEntry>;
 }
-export interface CliInstallConfig {
-	/** When `false`, hide/disable `install` (default: enabled). */
+/** Opt-out for the `completion` built-in (default: enabled). */
+export interface CliCompletionConfig {
+	/** When `false`, hide/disable `completion` (default: enabled). */
+	enabled?: boolean;
+}
+export interface CliConfigureConfig {
+	/** When `false`, hide/disable `configure` (default: enabled). */
 	enabled?: boolean;
 	/**
-	 * Default agent integration for full install (`install --all`).
-	 * - `'mcp'` when `mcpServer.enabled` (default): MCP targets in `--all`; paired skills excluded.
-	 * - `'skill'` when MCP is off (default): skill targets in `--all`; paired MCP excluded.
-	 * - `'both'`: install MCP and skill for the same host when both are available.
+	 * Default agent integration for sync (`configure --sync`).
+	 * - `'mcp'` when `mcpServer.enabled` (default): MCP targets in sync; paired skills excluded.
+	 * - `'skill'` when MCP is off (default): skill targets in sync; paired MCP excluded.
+	 * - `'both'`: sync MCP and skill for the same host when both are available.
 	 */
 	agentIntegration?: InstallAgentIntegration;
-	/** Per-artifact gates for full install/uninstall. See {@link resolveEffectiveInstallTargets}. */
-	targets?: CliInstallTargets;
+	/** Per-artifact gates for configure sync and interactive wizard. See {@link resolveEffectiveInstallTargets}. */
+	targets?: CliConfigureTargets;
 }
 /** Agent integration mode for install — MCP vs shell skill per host. */
 export type InstallAgentIntegration = "mcp" | "skill" | "both";
@@ -326,15 +331,15 @@ export type InstallAgentIntegration = "mcp" | "skill" | "both";
 export type InstallTargetSpec = boolean | {
 	/** When false, artifact is never installed (even with scoped CLI flags). Default true. */
 	enabled?: boolean;
-	/** When true, included in bare `install` / `install --all`. Default varies by key. */
+	/** When true, included in `configure --sync`. Default varies by key. */
 	includedInAll?: boolean;
 };
 export interface ResolvedInstallTarget {
 	enabled: boolean;
 	includedInAll: boolean;
 }
-/** Per-artifact gates for full install/uninstall. See {@link resolveEffectiveInstallTargets}. */
-export interface CliInstallTargets {
+/** Per-artifact gates for configure. See {@link resolveEffectiveInstallTargets}. */
+export interface CliConfigureTargets {
 	/** App binary status only (Homebrew PATH); no self-install. */
 	app?: InstallTargetSpec;
 	/** ChatGPT desktop MCP. Default false. */
@@ -349,7 +354,7 @@ export interface CliInstallTargets {
 	codexMcp?: InstallTargetSpec;
 	/** Codex skill. Default false. */
 	codexSkill?: InstallTargetSpec;
-	/** App config: wizard via install --configure only. Default not in --all. */
+	/** App config: interactive wizard step in `configure`. Default not in sync. */
 	configure?: InstallTargetSpec;
 	/** Cursor MCP. Default false. */
 	cursorMcp?: InstallTargetSpec;
@@ -447,8 +452,10 @@ export type CliProgram = CliNode & {
 	appConfig?: CliAppConfig;
 	/** When set with `enabled: true`, enables the `mcp` built-in subcommand. */
 	mcpServer?: CliMcpServerConfig;
-	/** Opt-out and defaults for `install`. */
-	install?: CliInstallConfig;
+	/** Opt-out and defaults for `configure`. */
+	configure?: CliConfigureConfig;
+	/** Opt-out for shell completion generation (`completion bash|zsh|fish`). */
+	completion?: CliCompletionConfig;
 	/** When set with `enabled: true`, enables the `docs` built-in command group. */
 	docs?: CliDocsConfig;
 };
@@ -466,9 +473,9 @@ export declare class CliSchemaValidationError extends Error {
 }
 /** Platform builtins derived from program config and runtime. */
 export interface CliCapabilities {
-	completion: true;
+	completion: boolean;
 	mcp: boolean;
-	install: boolean;
+	configure: boolean;
 	docs: boolean;
 	configCommands: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "argsbarg",
-  "version": "4.1.1",
+  "version": "5.0.1",
   "type": "module",
   "engines": {
     "bun": ">=1.3"

package/src/builtins/builtins.test.ts

@@ -1,12 +1,14 @@
 import { describe, expect, test } from "bun:test";
+import { resolveCapabilities } from "../capabilities.ts";
+import { cliBuiltinDocsGroup } from "../docs/builtin.ts";
 import { ParseKind, parse, postParseValidate } from "../parse.ts";
 import type { CliProgram } from "../types.ts";
+import { cliBuiltinConfigureCommand, configureBuiltinOptions } from "./configure.ts";
+import { configureCommandDescription, configureSyncOptionDescription } from "./configure-copy.ts";
 import { exportPresentationBuiltins } from "./export.ts";
 import { completionBashScript, completionFishScript, completionZshScript } from "./index.ts";
-import { cliBuiltinInstallCommand, installBuiltinOptions } from "./install.ts";
 import { cliBuiltinMcpCommand } from "./mcp.ts";
 import { cliParseRoot, cliPresentationRoot } from "./presentation.ts";
-import { cliBuiltinUninstallCommand, uninstallBuiltinOptions } from "./uninstall.ts";
 
 const fixture: CliProgram = {
   key: "myapp",
@@ -22,54 +24,63 @@ const fixture: CliProgram = {
   ],
 };
 
+const noMcp: CliProgram = {
+  key: "skillonly",
+  version: "0.0.0",
+  description: "Skills only.",
+  commands: [{ key: "ping", description: "Ping.", handler: () => {} }],
+};
+
 describe("builtins help copy", () => {
-  test("install command includes Homebrew-oriented description", () => {
-    const install = cliBuiltinInstallCommand(fixture);
-    expect(install.description).toContain("agent skills");
-    expect(install.notes).toContain("brew install");
-    const names = installBuiltinOptions(fixture).map((o) => o.name);
-    expect(names).toContain("all");
-    expect(names).toContain("mcp");
-    expect(names).not.toContain("app");
-    expect(names).not.toContain("completions");
-    expect(names).not.toContain("update");
-    expect(names.indexOf("all")).toBeLessThan(names.indexOf("mcp"));
-    expect(names.indexOf("mcp")).toBeLessThan(names.indexOf("status"));
-    expect(names).not.toContain("uninstall");
-    const yesOpt = installBuiltinOptions(fixture).find((o) => o.name === "yes");
+  test("configure command includes Homebrew-oriented description", () => {
+    const configure = cliBuiltinConfigureCommand(fixture);
+    expect(configure.description).toContain("agent skills");
+    expect(configure.description).toContain("MCP config");
+    expect(configure.notes).toContain("brew install");
+    const names = configureBuiltinOptions(fixture).map((o) => o.name);
+    expect(names).toContain("sync");
+    expect(names).toContain("remove-all");
+    expect(names).toContain("status");
+    const yesOpt = configureBuiltinOptions(fixture).find((o) => o.name === "yes");
     expect(yesOpt?.shortName).toBe("y");
   });
 
-  test("uninstall command includes removal guidance", () => {
-    const uninstall = cliBuiltinUninstallCommand(fixture);
-    expect(uninstall.notes).toContain("brew uninstall");
-    const names = uninstallBuiltinOptions(fixture).map((o) => o.name);
-    expect(names).toContain("all");
-    expect(names).not.toContain("status");
-    expect(names).not.toContain("reinstall");
+  test("configure copy omits MCP when mcpServer unset", () => {
+    const caps = resolveCapabilities(noMcp);
+    expect(configureCommandDescription(noMcp, caps)).toBe(
+      "Set up agent skills for this app (binary via Homebrew).",
+    );
+    expect(configureCommandDescription(noMcp, caps)).not.toContain("MCP");
+    expect(configureSyncOptionDescription(noMcp, caps)).not.toContain("MCP");
+    const configure = cliBuiltinConfigureCommand(noMcp);
+    expect(configure.description).not.toContain("MCP");
   });
 
-  test("install -y parses as --yes", () => {
+  test("configure notes mention brew upgrade and interactive configure", () => {
+    const configure = cliBuiltinConfigureCommand(fixture);
+    expect(configure.notes).toContain("brew upgrade");
+    expect(configure.notes).toContain("configure --sync --yes");
+    expect(configure.notes).toContain(`${fixture.key} configure`);
+
+    const withConfig: CliProgram = {
+      ...fixture,
+      appConfig: {
+        entries: { token: { description: "Token.", env: "TOKEN" } },
+      },
+    };
+    expect(configureBuiltinOptions(withConfig).map((o) => o.name)).toContain("remove-config");
+  });
+
+  test("configure -y parses as --yes", () => {
     const root = cliParseRoot(fixture);
-    const pr = postParseValidate(root, parse(root, ["install", "-y"]));
+    const pr = postParseValidate(root, parse(root, ["configure", "-y", "--sync"]));
     expect(pr.kind).toBe(ParseKind.Ok);
     if (pr.kind === ParseKind.Ok) {
       expect(pr.opts.yes).toBe("1");
+      expect(pr.opts.sync).toBe("1");
     }
   });
 
-  test("install omits --mcp option when mcpServer unset", () => {
-    const noMcp: CliProgram = { key: "x", version: "0.0.0", description: "x", handler: () => {} };
-    const names = installBuiltinOptions(noMcp).map((o) => o.name);
-    expect(names).not.toContain("mcp");
-  });
-
-  test("install notes mention brew upgrade", () => {
-    const install = cliBuiltinInstallCommand(fixture);
-    expect(install.notes).toContain("brew upgrade");
-    expect(install.notes).toContain("install --configure");
-  });
-
   test("mcp builtin description is user-facing", () => {
     const withDocs: CliProgram = {
       ...fixture,
@@ -77,39 +88,31 @@ describe("builtins help copy", () => {
     };
     const mcp = cliBuiltinMcpCommand(withDocs);
     expect(mcp.description).toContain("MCP server");
-    expect(mcp.notes).toContain("install --mcp --yes");
+    expect(mcp.notes).toContain("configure");
     expect(mcp.notes).toContain("docs mcp");
   });
 });
 
 describe("presentation root", () => {
-  test("includes mcp and install when enabled", () => {
+  test("includes mcp and configure when enabled", () => {
     const root = cliPresentationRoot(fixture);
     const keys = root.commands?.map((c) => c.key) ?? [];
     expect(keys).toContain("mcp");
-    expect(keys).toContain("install");
-    expect(keys).toContain("uninstall");
+    expect(keys).toContain("configure");
+    expect(keys).not.toContain("completion");
+    expect(keys).not.toContain("install");
   });
 
-  test("omits install when install.enabled is false", () => {
-    const disabled: CliProgram = { ...fixture, install: { enabled: false } };
+  test("omits configure when configure.enabled is false", () => {
+    const disabled: CliProgram = { ...fixture, configure: { enabled: false } };
     const root = cliPresentationRoot(disabled);
-    expect(root.commands?.map((c) => c.key)).not.toContain("install");
+    expect(root.commands?.map((c) => c.key)).not.toContain("configure");
   });
+
   test("includes version builtin", () => {
     const root = cliPresentationRoot(fixture);
     expect(root.commands?.map((c) => c.key)).toContain("version");
   });
-
-  test("root notes include agent hint when docs enabled", () => {
-    const withDocs: CliProgram = {
-      ...fixture,
-      docs: { enabled: true, topics: { readme: { text: "# r\n" } } },
-    };
-    const root = cliPresentationRoot(withDocs);
-    expect(root.notes).toContain("For AI agents: `myapp docs skill`.");
-    expect(root.notes).not.toContain("install --skill");
-  });
 });
 
 describe("completion emitters", () => {
@@ -118,14 +121,14 @@ describe("completion emitters", () => {
     const fish = completionFishScript(schema);
     expect(fish).toContain("complete -c myapp");
     expect(fish).toContain("hello");
-    expect(fish).toContain("install");
+    expect(fish).toContain("configure");
   });
 
-  test("bash script includes install flags", () => {
+  test("bash script includes configure flags", () => {
     const schema = cliPresentationRoot(fixture);
     const bash = completionBashScript(schema);
-    expect(bash).toContain("--all");
-    expect(bash).toContain("install");
+    expect(bash).toContain("hello");
+    expect(bash).toContain("--sync");
   });
 
   test("zsh script registers compdef", () => {
@@ -153,11 +156,29 @@ describe("schema export builtins", () => {
     };
     const builtins = exportPresentationBuiltins(withConfig);
     expect(builtins.map((b) => b.key)).toContain("config");
+    expect(builtins.map((b) => b.key)).toContain("configure");
   });
 
-  test("exportPresentationBuiltins includes install options", () => {
+  test("exportPresentationBuiltins omits hidden completion", () => {
     const builtins = exportPresentationBuiltins(fixture);
-    const install = builtins.find((b) => b.key === "install");
-    expect(install?.options?.find((o) => o.name === "all")?.description).toContain("agent");
+    expect(builtins.map((b) => b.key)).not.toContain("completion");
+  });
+});
+
+describe("docs skill topic copy", () => {
+  test("mentions configure when configure is enabled", () => {
+    const withDocs: CliProgram = {
+      ...noMcp,
+      docs: { enabled: true, topics: { readme: { text: "# r\n" } } },
+    };
+    const skill = cliBuiltinDocsGroup(withDocs).commands.find((c) => c.key === "skill");
+    expect(skill?.description).toContain("configure");
+
+    const configureOff: CliProgram = {
+      ...withDocs,
+      configure: { enabled: false },
+    };
+    const skillOff = cliBuiltinDocsGroup(configureOff).commands.find((c) => c.key === "skill");
+    expect(skillOff?.description).not.toContain("configure");
   });
 });

package/src/builtins/completion-group.ts

@@ -1,4 +1,3 @@
-import { resolveCapabilities } from "../capabilities.ts";
 import type { CliProgram } from "../types.ts";
 
 /**
@@ -8,6 +7,7 @@ export function cliBuiltinCompletionGroup(program: CliProgram): import("../types
   const appName = program.key;
   const router: import("../types.ts").CliRouter = {
     key: "completion",
+    hidden: true,
     description: "Generate the autocompletion script for shells.",
     commands: [
       {
@@ -44,10 +44,8 @@ export function cliBuiltinCompletionGroup(program: CliProgram): import("../types
       },
     ],
   };
-  if (resolveCapabilities(program).install) {
-    router.notes =
-      "Completions are installed by Homebrew during formula install.\n\n" +
-      "See: https://docs.brew.sh/Shell-Completion";
-  }
+  router.notes =
+    "Completions are installed by Homebrew during formula install.\n\n" +
+    "See: https://docs.brew.sh/Shell-Completion";
   return router;
 }

package/src/builtins/configure-copy.ts

@@ -0,0 +1,86 @@
+/** Capability-aware labels for configure builtin and docs copy. */
+
+import type { CliCapabilities } from "../capabilities.ts";
+import type { CliProgram } from "../types.ts";
+
+type Kind = "skills" | "mcp" | "config";
+
+const LABEL: Record<Kind, { prose: string; short: string }> = {
+  skills: { prose: "agent skills", short: "skills" },
+  mcp: { prose: "MCP config", short: "MCP" },
+  config: { prose: "app config", short: "config" },
+};
+
+function enabledKinds(program: CliProgram, caps: CliCapabilities): Kind[] {
+  const kinds: Kind[] = ["skills"];
+  if (caps.mcp) kinds.push("mcp");
+  if (program.appConfig) kinds.push("config");
+  return kinds;
+}
+
+function joinEnglish(items: string[]): string {
+  if (items.length === 0) return "agent artifacts";
+  if (items.length === 1) return items[0]!;
+  if (items.length === 2) return `${items[0]} and ${items[1]}`;
+  return `${items.slice(0, -1).join(", ")}, and ${items[items.length - 1]}`;
+}
+
+function prose(program: CliProgram, caps: CliCapabilities): string {
+  return joinEnglish(enabledKinds(program, caps).map((k) => LABEL[k].prose));
+}
+
+function short(program: CliProgram, caps: CliCapabilities): string {
+  return joinEnglish(enabledKinds(program, caps).map((k) => LABEL[k].short));
+}
+
+export function configureCommandDescription(program: CliProgram, caps: CliCapabilities): string {
+  return `Set up ${prose(program, caps)} for this app (binary via Homebrew).`;
+}
+
+export function configureSyncOptionDescription(program: CliProgram, caps: CliCapabilities): string {
+  return `Refresh installed ${short(program, caps)}. Used by Homebrew post_install.`;
+}
+
+export function docsSkillTopicDescription(program: CliProgram, caps: CliCapabilities): string {
+  if (caps.configure) {
+    return "Print a reference agent SKILL; run `configure` to install an optimized copy.";
+  }
+  return "Print a reference agent SKILL for AI agents.";
+}
+
+export function configureCommandNotes(program: CliProgram, caps: CliCapabilities): string {
+  const app = program.key;
+  const lines = [
+    "Install the binary via Homebrew (tap-from-repo), then set up agent artifacts:",
+    `  brew tap <org>/<repo>`,
+    `  brew install <tap>/${app}`,
+    "",
+    "Homebrew post_install runs:",
+    `  ${app} configure --sync --yes`,
+    "",
+    "Interactive setup (per target):",
+    `  ${app} configure`,
+    "",
+    "Upgrade:",
+    `  brew upgrade ${app}`,
+    "",
+    "Shell completions are installed by Homebrew during brew install.",
+    "See: https://docs.brew.sh/Shell-Completion",
+    "",
+    "See what is installed:",
+    `  ${app} configure --status`,
+    "",
+    "Remove agent artifacts before brew uninstall:",
+    `  ${app} configure --remove-all --yes`,
+    `  brew uninstall <tap>/${app}`,
+    "",
+  ];
+  if (program.appConfig) {
+    lines.push("Remove app config only:", `  ${app} configure --remove-config --yes`, "");
+  }
+  lines.push(
+    "Use --dry to preview changes without writing files.",
+    "Use --json for machine-readable output.",
+  );
+  return lines.join("\n");
+}

package/src/builtins/configure.ts

@@ -0,0 +1,70 @@
+import { resolveCapabilities } from "../capabilities.ts";
+import { type CliLeaf, type CliOption, CliOptionKind, type CliProgram } from "../types.ts";
+import {
+  configureCommandDescription,
+  configureCommandNotes,
+  configureSyncOptionDescription,
+} from "./configure-copy.ts";
+
+/** Configure command options. */
+export function configureBuiltinOptions(root: CliProgram): CliOption[] {
+  const caps = resolveCapabilities(root);
+  const opts: CliOption[] = [
+    {
+      name: "sync",
+      description: configureSyncOptionDescription(root, caps),
+      kind: CliOptionKind.Presence,
+    },
+    {
+      name: "remove-all",
+      description: "Remove all detected agent artifacts (skills and MCP).",
+      kind: CliOptionKind.Presence,
+    },
+  ];
+
+  if (root.appConfig) {
+    opts.push({
+      name: "remove-config",
+      description: "Remove the app config file only.",
+      kind: CliOptionKind.Presence,
+    });
+  }
+
+  opts.push(
+    {
+      name: "status",
+      description: "Print what is currently installed (read-only).",
+      kind: CliOptionKind.Presence,
+    },
+    {
+      name: "yes",
+      description: "Skip confirmation (required for --sync, --remove-all, --remove-config).",
+      kind: CliOptionKind.Presence,
+      shortName: "y",
+    },
+    {
+      name: "dry",
+      description: "Show what would change without writing files.",
+      kind: CliOptionKind.Presence,
+    },
+    {
+      name: "json",
+      description: "Print changed paths or status JSON on stdout.",
+      kind: CliOptionKind.Presence,
+    },
+  );
+
+  return opts;
+}
+
+/** Builds the `configure` built-in command. */
+export function cliBuiltinConfigureCommand(root: CliProgram): CliLeaf {
+  const caps = resolveCapabilities(root);
+  return {
+    key: "configure",
+    description: configureCommandDescription(root, caps),
+    options: configureBuiltinOptions(root),
+    notes: configureCommandNotes(root, caps),
+    handler: () => {},
+  };
+}

package/src/builtins/dispatch.ts

@@ -1,7 +1,7 @@
 import { capabilityDeniedMessage, resolveCapabilities } from "../capabilities.ts";
 import { Cli } from "../cli.ts";
+import { cliConfigure } from "../configure/index.ts";
 import { cliBuiltinDocsGroupIfEnabled } from "../docs/builtin.ts";
-import { cliInstall, cliUninstall } from "../install/index.ts";
 import { runMcpBundle } from "../mcp/bundle.ts";
 import type { ParseResult } from "../parse.ts";
 import { ParseKind } from "../parse.ts";
@@ -12,10 +12,9 @@ import { completionFishScript } from "./completion-fish.ts";
 import { cliBuiltinCompletionGroup as completionGroup } from "./completion-group.ts";
 import { completionZshScript } from "./completion-zsh.ts";
 import { cliBuiltinConfigGroupIfEnabled } from "./config.ts";
-import { cliBuiltinInstallCommand } from "./install.ts";
+import { cliBuiltinConfigureCommand } from "./configure.ts";
 import { cliBuiltinMcpCommand } from "./mcp.ts";
 import { cliPresentationRoot } from "./presentation.ts";
-import { cliBuiltinUninstallCommand } from "./uninstall.ts";
 import { cliBuiltinVersionCommand } from "./version.ts";
 
 export interface DispatchBuiltinOpts {
@@ -45,6 +44,10 @@ export async function dispatchBuiltin(
   const caps = resolveCapabilities(program);
 
   if (pr.path[0] === "completion") {
+    if (!caps.completion) {
+      process.stderr.write(capabilityDeniedMessage("completion"));
+      process.exit(1);
+    }
     const schemaForCompletion = completionSchema(program, opts);
     if (pr.path[1] === "bash") {
       process.stdout.write(completionBashScript(schemaForCompletion));
@@ -93,28 +96,16 @@ export async function dispatchBuiltin(
     process.exit(1);
   }
 
-  if (pr.path[0] === "install") {
-    if (!caps.install) {
-      process.stderr.write(capabilityDeniedMessage("install"));
-      process.exit(1);
-    }
-    if (pr.path.length !== 1) {
-      process.stderr.write(`Unknown subcommand: install ${pr.path.slice(1).join(" ")}\n`);
-      process.exit(1);
-    }
-    await cliInstall(program, pr.opts);
-  }
-
-  if (pr.path[0] === "uninstall") {
-    if (!caps.install) {
-      process.stderr.write(capabilityDeniedMessage("install"));
+  if (pr.path[0] === "configure") {
+    if (!caps.configure) {
+      process.stderr.write(capabilityDeniedMessage("configure"));
       process.exit(1);
     }
     if (pr.path.length !== 1) {
-      process.stderr.write(`Unknown subcommand: uninstall ${pr.path.slice(1).join(" ")}\n`);
+      process.stderr.write(`Unknown subcommand: configure ${pr.path.slice(1).join(" ")}\n`);
       process.exit(1);
     }
-    await cliUninstall(program, pr.opts);
+    await cliConfigure(program, pr.opts);
   }
 }
 
@@ -141,23 +132,12 @@ export function builtinInterceptRoot(
     };
   }
 
-  if (first === "install" && caps.install) {
-    return {
-      parseRoot: {
-        key: program.key,
-        description: program.description,
-        commands: [cliBuiltinInstallCommand(program)],
-      },
-      isLeafCompletionIntercept: false,
-    };
-  }
-
-  if (first === "uninstall" && caps.install) {
+  if (first === "configure" && caps.configure) {
     return {
       parseRoot: {
         key: program.key,
         description: program.description,
-        commands: [cliBuiltinUninstallCommand(program)],
+        commands: [cliBuiltinConfigureCommand(program)],
       },
       isLeafCompletionIntercept: false,
     };

package/src/builtins/index.ts

@@ -2,9 +2,9 @@ export { completionBashScript } from "./completion-bash.ts";
 export { completionFishScript } from "./completion-fish.ts";
 export { cliBuiltinCompletionGroup } from "./completion-group.ts";
 export { completionZshScript } from "./completion-zsh.ts";
+export { cliBuiltinConfigureCommand, configureBuiltinOptions } from "./configure.ts";
 export { builtinInterceptRoot, dispatchBuiltin } from "./dispatch.ts";
 export { type CliSchemaExport, exportPresentationBuiltins } from "./export.ts";
-export { cliBuiltinInstallCommand, installBuiltinOptions } from "./install.ts";
 export { cliBuiltinMcpCommand } from "./mcp.ts";
 export {
   cliParseRoot,

package/src/builtins/mcp.ts

@@ -12,8 +12,8 @@ export function cliBuiltinMcpCommand(program: CliProgram): CliRouter {
     "  args: mcp",
     "",
   ];
-  if (caps.install) {
-    lines.push("Or:", "", "  {argsbarg:program} install --mcp --yes", "");
+  if (caps.configure) {
+    lines.push("Or:", "", "  {argsbarg:program} configure", "");
   }
   if (docsEnabled(program)) {
     lines.push("Full setup guide: {argsbarg:program} docs mcp");