argsbarg 5.0.3 → 5.1.1

package/src/builtins/config.ts

@@ -1,14 +1,19 @@
 /*
-Built-in `config get` / `config set` commands.
+Built-in `configure get` / `configure set` subcommands.
 */
 
 import { bootstrapAppConfig } from "../config/bootstrap.ts";
-import { configEntrySensitive, defaultConfigEntryTitle } from "../config/entry.ts";
+import {
+  configCommandsEnabled,
+  configEntrySensitive,
+  configMcpSetEnabled,
+  defaultConfigEntryTitle,
+} from "../config/entry.ts";
 import { writeAppConfigFile } from "../config/file.ts";
 import { captureMappedHostEnv, exportConfigToEnv, resolveAppConfig } from "../config/resolve.ts";
 import { configPropertySchema, effectiveJsonSchema } from "../config/schema.ts";
 import { parseConfigSetValue } from "../config/validate.ts";
-import type { CliLeaf, CliOption, CliProgram, CliRouter } from "../types.ts";
+import type { CliLeaf, CliOption, CliProgram } from "../types.ts";
 import { CliOptionKind } from "../types.ts";
 
 const JSON_OPTION: CliOption = {
@@ -182,16 +187,16 @@ function configSetLeaf(program: CliProgram, mcpSetEnabled: boolean): CliLeaf {
     handler: (ctx) => {
       const key = ctx.args[0];
       if (!key) {
-        process.stderr.write("config set requires a key.\n");
+        process.stderr.write("configure set requires a key.\n");
         process.exit(1);
       }
       const raw = ctx.args[1];
       if (raw === undefined || raw.length === 0) {
         if (!ctx.hasFlag("json")) {
-          process.stderr.write("config set requires a value (or --json).\n");
+          process.stderr.write("configure set requires a value (or --json).\n");
           process.exit(1);
         }
-        process.stderr.write("config set requires a value.\n");
+        process.stderr.write("configure set requires a value.\n");
         process.exit(1);
       }
       configSetRun(program, key, raw, ctx.hasFlag("json"));
@@ -199,23 +204,15 @@ function configSetLeaf(program: CliProgram, mcpSetEnabled: boolean): CliLeaf {
   };
 }
 
-import { configCommandsEnabled, configMcpSetEnabled } from "../config/entry.ts";
-
-/** Built-in `config` router when program.appConfig is set. */
-export function cliBuiltinConfigGroup(program: CliProgram): CliRouter {
+/** `configure get` / `configure set` leaves when app config commands are enabled. */
+export function configureConfigSubcommands(
+  program: CliProgram,
+  mcpSetEnabled = configMcpSetEnabled(program),
+): CliLeaf[] {
   if (!program.appConfig) {
-    throw new Error("config not enabled");
+    throw new Error("configure config subcommands require program.appConfig");
   }
-  return {
-    key: "config",
-    description: "Read or write app configuration.",
-    commands: [configGetLeaf(program), configSetLeaf(program, configMcpSetEnabled(program))],
-  };
+  return [configGetLeaf(program), configSetLeaf(program, mcpSetEnabled)];
 }
 
-export function cliBuiltinConfigGroupIfEnabled(program: CliProgram): CliRouter | undefined {
-  if (!configCommandsEnabled(program)) {
-    return undefined;
-  }
-  return cliBuiltinConfigGroup(program);
-}
+export { configCommandsEnabled };

package/src/builtins/configure.ts

@@ -1,11 +1,23 @@
 import { resolveCapabilities } from "../capabilities.ts";
-import { type CliLeaf, type CliOption, CliOptionKind, type CliProgram } from "../types.ts";
+import { configCommandsEnabled, configMcpSetEnabled } from "../config/entry.ts";
+import {
+  CliFallbackMode,
+  type CliLeaf,
+  type CliOption,
+  CliOptionKind,
+  type CliProgram,
+  type CliRouter,
+} from "../types.ts";
+import { configureConfigSubcommands } from "./config.ts";
 import {
   configureCommandDescription,
   configureCommandNotes,
   configureSyncOptionDescription,
 } from "./configure-copy.ts";
 
+/** Hidden fallback leaf for bare `configure` (interactive / flag modes). */
+export const CONFIGURE_RUN_KEY = "run";
+
 /** Configure command options. */
 export function configureBuiltinOptions(root: CliProgram): CliOption[] {
   const caps = resolveCapabilities(root);
@@ -57,14 +69,33 @@ export function configureBuiltinOptions(root: CliProgram): CliOption[] {
   return opts;
 }
 
-/** Builds the `configure` built-in command. */
-export function cliBuiltinConfigureCommand(root: CliProgram): CliLeaf {
+/** True when argv resolved to `configure get` or `configure set`. */
+export function isConfigureConfigPath(path: string[]): boolean {
+  return path.length >= 2 && (path[1] === "get" || path[1] === "set");
+}
+
+/** Builds the `configure` built-in router. */
+export function cliBuiltinConfigureCommand(root: CliProgram): CliRouter {
   const caps = resolveCapabilities(root);
+  const run: CliLeaf = {
+    key: CONFIGURE_RUN_KEY,
+    hidden: true,
+    description: "Interactive or flag-driven configure (skills, MCP, app config).",
+    handler: () => {},
+  };
+
+  const commands: CliLeaf[] = [run];
+  if (configCommandsEnabled(root)) {
+    commands.push(...configureConfigSubcommands(root, configMcpSetEnabled(root)));
+  }
+
   return {
     key: "configure",
     description: configureCommandDescription(root, caps),
     options: configureBuiltinOptions(root),
     notes: configureCommandNotes(root, caps),
-    handler: () => {},
+    fallbackCommand: CONFIGURE_RUN_KEY,
+    fallbackMode: CliFallbackMode.MissingOnly,
+    commands,
   };
 }

package/src/builtins/dispatch.ts

@@ -11,8 +11,11 @@ import { completionBashScript } from "./completion-bash.ts";
 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 { cliBuiltinConfigureCommand } from "./configure.ts";
+import {
+  CONFIGURE_RUN_KEY,
+  cliBuiltinConfigureCommand,
+  isConfigureConfigPath,
+} from "./configure.ts";
 import { cliBuiltinMcpCommand } from "./mcp.ts";
 import { cliPresentationRoot } from "./presentation.ts";
 import { cliBuiltinVersionCommand } from "./version.ts";
@@ -101,7 +104,11 @@ export async function dispatchBuiltin(
       process.stderr.write(capabilityDeniedMessage("configure"));
       process.exit(1);
     }
-    if (pr.path.length !== 1) {
+    if (isConfigureConfigPath(pr.path)) {
+      return;
+    }
+    const runSeg = pr.path[1];
+    if (pr.path.length > 2 || (pr.path.length === 2 && runSeg !== CONFIGURE_RUN_KEY)) {
       process.stderr.write(`Unknown subcommand: configure ${pr.path.slice(1).join(" ")}\n`);
       process.exit(1);
     }
@@ -177,17 +184,5 @@ export function builtinInterceptRoot(
     };
   }
 
-  const configGroup = cliBuiltinConfigGroupIfEnabled(program);
-  if (first === "config" && configGroup) {
-    return {
-      parseRoot: {
-        key: program.key,
-        description: program.description,
-        commands: [configGroup],
-      },
-      isLeafCompletionIntercept: false,
-    };
-  }
-
   return { parseRoot: program, isLeafCompletionIntercept: false };
 }

package/src/builtins/registry.ts

@@ -2,7 +2,6 @@ import type { CliCapabilities } from "../capabilities.ts";
 import { cliBuiltinDocsGroupIfEnabled } from "../docs/builtin.ts";
 import type { CliNode, CliProgram } from "../types.ts";
 import { cliBuiltinCompletionGroup } from "./completion-group.ts";
-import { cliBuiltinConfigGroupIfEnabled } from "./config.ts";
 import { cliBuiltinConfigureCommand } from "./configure.ts";
 import { cliBuiltinMcpCommand } from "./mcp.ts";
 import { cliBuiltinVersionCommand } from "./version.ts";
@@ -37,6 +36,5 @@ export function resolveBuiltins(program: CliProgram, caps: CliCapabilities): Cli
   if (caps.mcp) {
     pushBuiltin(builtins, program, (p) => cliBuiltinMcpCommand(p));
   }
-  pushBuiltin(builtins, program, (p) => cliBuiltinConfigGroupIfEnabled(p) ?? null);
   return builtins;
 }

package/src/capabilities.ts

@@ -42,17 +42,17 @@ export function reservedCommandNames(caps: CliCapabilities): string[] {
   if (caps.mcp) {
     names.push("mcp");
   }
-  if (caps.configCommands) {
-    names.push("config");
-  }
   return names;
 }
 
 /** Commands that may run without required appConfig values (read-only / config introspection). */
 export function skipsRequiredAppConfigExit(path: string[], caps: CliCapabilities): boolean {
   const root = path[0];
-  if (root === "config" && caps.configCommands) {
-    return true;
+  if (root === "configure" && caps.configCommands) {
+    const sub = path[1];
+    if (sub === "get" || sub === "set") {
+      return true;
+    }
   }
   if (root === "docs" && caps.docs) {
     return true;
@@ -60,7 +60,7 @@ export function skipsRequiredAppConfigExit(path: string[], caps: CliCapabilities
   return false;
 }
 
-export type CapabilityFeature = "mcp" | "configure" | "docs" | "config" | "completion";
+export type CapabilityFeature = "mcp" | "configure" | "docs" | "completion";
 
 /** Stderr message when a disabled built-in is invoked from the CLI. */
 export function capabilityDeniedMessage(feature: CapabilityFeature): string {
@@ -73,8 +73,6 @@ export function capabilityDeniedMessage(feature: CapabilityFeature): string {
       return "Configure is not available for this app.\n";
     case "docs":
       return "Documentation commands are not available for this app.\n";
-    case "config":
-      return "Configuration commands are not available for this app.\n";
   }
 }
 
@@ -100,8 +98,4 @@ export function assertBuiltinAllowed(argv: string[], caps: CliCapabilities): voi
     process.stderr.write(capabilityDeniedMessage("docs"));
     process.exit(1);
   }
-  if (first === "config" && !caps.configCommands) {
-    process.stderr.write(capabilityDeniedMessage("config"));
-    process.exit(1);
-  }
 }

package/src/config/entry.ts

@@ -29,7 +29,7 @@ export function configEntryRequired(
   return true;
 }
 
-/** Whether prompts and `config get` should redact this entry. */
+/** Whether prompts and `configure get` should redact this entry. */
 export function configEntrySensitive(key: string, entry: CliAppConfigEntry): boolean {
   return entry.sensitive ?? defaultConfigEntrySensitive(key);
 }
@@ -56,7 +56,7 @@ export function jsonSchemaRequiredKeys(
   return new Set(required.filter((k): k is string => typeof k === "string"));
 }
 
-/** Whether built-in config get/set commands are enabled. */
+/** Whether built-in `configure get` / `configure set` subcommands are enabled. */
 export function configCommandsEnabled(program: CliProgram): boolean {
   if (!program.appConfig) {
     return false;

package/src/config/resolve.ts

@@ -227,7 +227,7 @@ export function formatMissingConfigMessage(program: CliProgram, keys: string[]):
   return [
     `Missing required configuration: ${list}`,
     `Configure interactively:  ${program.key} configure`,
-    `Or set via:               ${program.key} config set <key> <value>`,
+    `Or set via:               ${program.key} configure set <key> <value>`,
     `Config file:              ${path}`,
     `See:                      ${program.key} docs mcp`,
   ].join("\n");
@@ -240,7 +240,7 @@ export function formatMcpMissingConfigMessage(program: CliProgram, keys: string[
   return [
     `Missing required configuration: ${list}`,
     `Configure: ${program.key} configure`,
-    `Or set via: ${program.key} config set`,
+    `Or set via: ${program.key} configure set`,
     `Config file: ${path}`,
   ].join("\n");
 }

package/src/configure/prompt.ts

@@ -2,8 +2,8 @@
 TTY prompts for per-target install, skip, or uninstall during interactive `configure`.
 */
 
-import { readSync } from "node:fs";
 import type { CliInstallArtifactKey } from "../install/target-types.ts";
+import { readPromptLine } from "../prompt.ts";
 
 /** Human-readable labels for each install artifact key in interactive prompts. */
 const LABELS: Record<CliInstallArtifactKey, string> = {
@@ -35,9 +35,7 @@ export type TargetPromptAction = "install" | "skip" | "uninstall";
 export function promptTargetAction(label: string, installed: boolean): TargetPromptAction | null {
   const hint = installed ? `${label} [y/N]: ` : `${label} [Y/n]: `;
   process.stderr.write(hint);
-  const buf = Buffer.alloc(256);
-  const n = readSync(0, buf, { length: 256 });
-  const ans = buf.toString("utf8", 0, n).trim().toLowerCase();
+  const ans = readPromptLine().trim().toLowerCase();
   if (installed) {
     if (ans === "n") return "uninstall";
     return "skip";

package/src/docs/docs.test.ts

@@ -167,7 +167,7 @@ test("skipsRequiredAppConfigExit includes docs and config builtins", () => {
   };
   const caps = resolveCapabilities(program);
   expect(skipsRequiredAppConfigExit(["docs", "api"], caps)).toBe(true);
-  expect(skipsRequiredAppConfigExit(["config", "get"], caps)).toBe(true);
+  expect(skipsRequiredAppConfigExit(["configure", "get"], caps)).toBe(true);
   expect(skipsRequiredAppConfigExit(["run"], caps)).toBe(false);
 });
 

package/src/install/install-validate.test.ts

@@ -63,4 +63,15 @@ describe("validateConfigureConfig", () => {
     };
     expect(() => cliValidateProgram(program)).not.toThrow();
   });
+
+  test("rejects explicit MCP target without mcpServer", () => {
+    const program: CliProgram = {
+      ...base,
+      configure: {
+        agentIntegration: "both",
+        targets: { cursorMcp: true },
+      },
+    };
+    expect(() => cliValidateProgram(program)).toThrow(/mcpServer\.enabled/);
+  });
 });

package/src/install/target-effective.ts

@@ -7,7 +7,12 @@ import type {
   InstallTargetSpec,
 } from "../types.ts";
 import type { InstallPaths } from "./paths.ts";
-import { AGENT_PAIRS, INSTALL_ARTIFACT_KEYS, installTargetForKey } from "./target-registry.ts";
+import {
+  AGENT_PAIRS,
+  INSTALL_ARTIFACT_KEYS,
+  installTargetForKey,
+  mcpServerRequiredForArtifact,
+} from "./target-registry.ts";
 import type { CliInstallArtifactKey, InstallPlanMode } from "./target-types.ts";
 
 export type { InstallTargetSpec, ResolvedInstallTarget } from "../types.ts";
@@ -44,9 +49,13 @@ export function resolveInstallTargetSpec(
 function artifactDefaults(
   key: CliInstallArtifactKey,
   integration: InstallAgentIntegration,
+  mcpServerEnabled: boolean,
 ): { enabled: boolean; includedInAll: boolean } {
   const target = installTargetForKey(key);
   const includedInAll = target?.defaultIncludedInAll(integration) ?? false;
+  if (!mcpServerRequiredForArtifact(key, mcpServerEnabled)) {
+    return { enabled: false, includedInAll: false };
+  }
   return { enabled: true, includedInAll };
 }
 
@@ -86,7 +95,10 @@ export function resolveEffectiveInstallTargets(
   const user = configure?.targets;
   const out = {} as Record<CliInstallArtifactKey, { enabled: boolean; includedInAll: boolean }>;
   for (const key of INSTALL_ARTIFACT_KEYS) {
-    out[key] = resolveInstallTargetSpec(user?.[key], artifactDefaults(key, integration));
+    out[key] = resolveInstallTargetSpec(
+      user?.[key],
+      artifactDefaults(key, integration, mcpEnabled),
+    );
   }
   applyAgentPairDedupe(out, user, integration);
   return out;

package/src/install/target-registry.ts

@@ -37,6 +37,23 @@ export function installTargetForKey(key: CliInstallArtifactKey): InstallTarget |
   return targetByKey.get(key);
 }
 
+/** True when the artifact key is an MCP install target (requires mcpServer.enabled). */
+export function isMcpArtifactKey(key: CliInstallArtifactKey): boolean {
+  return installTargetForKey(key)?.category === "mcp";
+}
+
+/**
+ * MCP install targets are inactive without mcpServer.enabled.
+ * Defaults: artifactDefaults in target-effective.ts.
+ * Explicit spec rejection: validateConfigureConfig in validate.ts.
+ */
+export function mcpServerRequiredForArtifact(
+  key: CliInstallArtifactKey,
+  mcpServerEnabled: boolean,
+): boolean {
+  return !isMcpArtifactKey(key) || mcpServerEnabled;
+}
+
 /** Lookup by plan action kind. */
 export function installTargetForActionKind(kind: InstallActionKind): InstallTarget | undefined {
   return INSTALL_TARGETS.find((t) => t.actionKind === kind);

package/src/install/targets.test.ts

@@ -50,7 +50,9 @@ describe("resolveEffectiveInstallTargets", () => {
     const program: Pick<CliProgram, "mcpServer"> = {};
     const t = resolveEffectiveInstallTargets(undefined, program);
     expect(t.cursorSkill.includedInAll).toBe(true);
+    expect(t.cursorSkill.enabled).toBe(true);
     expect(t.cursorMcp.includedInAll).toBe(false);
+    expect(t.cursorMcp.enabled).toBe(false);
   });
 
   test("mcp mode includes MCP in --all not paired skills", () => {