argsbarg 4.1.0 → 5.0.1

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 } from "../install/index.ts";
 import { runMcpBundle } from "../mcp/bundle.ts";
 import type { ParseResult } from "../parse.ts";
 import { ParseKind } from "../parse.ts";
@@ -12,7 +12,7 @@ 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 { cliBuiltinVersionCommand } from "./version.ts";
@@ -44,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));
@@ -92,16 +96,16 @@ export async function dispatchBuiltin(
     process.exit(1);
   }
 
-  if (pr.path[0] === "install") {
-    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: install ${pr.path.slice(1).join(" ")}\n`);
+      process.stderr.write(`Unknown subcommand: configure ${pr.path.slice(1).join(" ")}\n`);
       process.exit(1);
     }
-    await cliInstall(program, pr.opts);
+    await cliConfigure(program, pr.opts);
   }
 }
 
@@ -128,12 +132,12 @@ export function builtinInterceptRoot(
     };
   }
 
-  if (first === "install" && caps.install) {
+  if (first === "configure" && caps.configure) {
     return {
       parseRoot: {
         key: program.key,
         description: program.description,
-        commands: [cliBuiltinInstallCommand(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");

package/src/builtins/registry.ts

@@ -3,7 +3,7 @@ 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 { cliBuiltinInstallCommand } from "./install.ts";
+import { cliBuiltinConfigureCommand } from "./configure.ts";
 import { cliBuiltinMcpCommand } from "./mcp.ts";
 import { cliBuiltinVersionCommand } from "./version.ts";
 
@@ -26,10 +26,12 @@ function pushBuiltin(
 /** Capability-gated built-in command nodes in stable order (parse, help, export). */
 export function resolveBuiltins(program: CliProgram, caps: CliCapabilities): CliNode[] {
   const builtins: CliNode[] = [];
-  pushBuiltin(builtins, program, (p) => cliBuiltinCompletionGroup(p));
+  if (caps.completion) {
+    pushBuiltin(builtins, program, (p) => cliBuiltinCompletionGroup(p));
+  }
   pushBuiltin(builtins, program, () => cliBuiltinVersionCommand());
-  if (caps.install) {
-    pushBuiltin(builtins, program, (p) => cliBuiltinInstallCommand(p));
+  if (caps.configure) {
+    pushBuiltin(builtins, program, (p) => cliBuiltinConfigureCommand(p));
   }
   pushBuiltin(builtins, program, (p) => cliBuiltinDocsGroupIfEnabled(p) ?? null);
   if (caps.mcp) {

package/src/capabilities.ts

@@ -8,32 +8,33 @@ import type { CliProgram } from "./types.ts";
 
 /** Platform builtins derived from program config and runtime. */
 export interface CliCapabilities {
-  completion: true;
+  completion: boolean;
   mcp: boolean;
-  install: boolean;
+  configure: boolean;
   docs: boolean;
-  update: boolean;
   configCommands: boolean;
 }
 
 /** Resolves which capabilities are enabled for a program. */
 export function resolveCapabilities(program: CliProgram): CliCapabilities {
-  const install = program.install?.enabled !== false;
+  const configure = program.configure?.enabled !== false;
   return {
-    completion: true,
+    completion: program.completion?.enabled !== false,
     mcp: program.mcpServer?.enabled === true,
-    install,
+    configure,
     docs: program.docs?.enabled === true,
-    update: install && typeof program.install?.updateGetLatest === "function",
     configCommands: configCommandsEnabled(program),
   };
 }
 
 /** Reserved top-level command names for the given capabilities. */
 export function reservedCommandNames(caps: CliCapabilities): string[] {
-  const names = ["completion", "version"];
-  if (caps.install) {
-    names.push("install");
+  const names = ["version"];
+  if (caps.completion) {
+    names.unshift("completion");
+  }
+  if (caps.configure) {
+    names.push("configure");
   }
   if (caps.docs) {
     names.push("docs");
@@ -59,15 +60,17 @@ export function skipsRequiredAppConfigExit(path: string[], caps: CliCapabilities
   return false;
 }
 
-export type CapabilityFeature = "mcp" | "install" | "docs" | "config";
+export type CapabilityFeature = "mcp" | "configure" | "docs" | "config" | "completion";
 
 /** Stderr message when a disabled built-in is invoked from the CLI. */
 export function capabilityDeniedMessage(feature: CapabilityFeature): string {
   switch (feature) {
+    case "completion":
+      return "Shell completion is not available for this app.\n";
     case "mcp":
       return "MCP is not available for this app.\n";
-    case "install":
-      return "Install is not available for this app.\n";
+    case "configure":
+      return "Configure is not available for this app.\n";
     case "docs":
       return "Documentation commands are not available for this app.\n";
     case "config":
@@ -81,12 +84,16 @@ export function assertBuiltinAllowed(argv: string[], caps: CliCapabilities): voi
     return;
   }
   const first = argv[0];
+  if (first === "completion" && !caps.completion) {
+    process.stderr.write(capabilityDeniedMessage("completion"));
+    process.exit(1);
+  }
   if (first === "mcp" && !caps.mcp) {
     process.stderr.write(capabilityDeniedMessage("mcp"));
     process.exit(1);
   }
-  if (first === "install" && !caps.install) {
-    process.stderr.write(capabilityDeniedMessage("install"));
+  if (first === "configure" && !caps.configure) {
+    process.stderr.write(capabilityDeniedMessage("configure"));
     process.exit(1);
   }
   if (first === "docs" && !caps.docs) {

package/src/cli-tool/cli-smoke.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { join } from "node:path";
+
+const main = join(import.meta.dir, "main.ts");
+
+describe("argsbarg cli-tool", () => {
+  test("version subcommand prints version", () => {
+    const proc = spawnSync("bun", [main, "version"], { encoding: "utf8" });
+    expect(proc.status).toBe(0);
+    expect(proc.stdout.trim().length).toBeGreaterThan(0);
+  });
+
+  test("help lists create and version only (no install, completion, mcp)", () => {
+    const proc = spawnSync("bun", [main, "--help"], { encoding: "utf8" });
+    expect(proc.status).toBe(0);
+    expect(proc.stdout).toContain("create");
+    expect(proc.stdout).toContain("version");
+    expect(proc.stdout).not.toContain("configure");
+    expect(proc.stdout).not.toContain("completion");
+    expect(proc.stdout).not.toContain("mcp");
+  });
+
+  test("completion subcommand is disabled", () => {
+    const proc = spawnSync("bun", [main, "completion", "bash"], { encoding: "utf8" });
+    expect(proc.status).toBe(1);
+    expect(proc.stderr).toContain("Shell completion is not available");
+  });
+});

package/src/cli-tool/create.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  applyCreate,
+  classNameFromKey,
+  diffCreate,
+  diffCreateDetails,
+  renderCreateTree,
+  resolveCreateOptions,
+  substituteTemplateContent,
+} from "./create.ts";
+
+describe("argsbarg create", () => {
+  test("substitutes {key} tokens", () => {
+    const out = substituteTemplateContent(
+      "key={key} class={className} env={envPrefix}_API_TOKEN tap={tap} org={tapOrg}",
+      {
+        key: "my-cli",
+        className: "MyCli",
+        tap: "org/my-cli",
+        homepage: "https://github.com/org/my-cli",
+        releaseRepo: "org/my-cli",
+        desc: "My CLI",
+        force: false,
+        dryRun: false,
+        check: false,
+        diff: false,
+        yes: false,
+        devTemplate: false,
+      },
+    );
+    expect(out).toContain("my-cli");
+    expect(out).toContain("MyCli");
+    expect(out).toContain("MY_CLI_API_TOKEN");
+    expect(out).toContain("org/my-cli");
+    expect(out).not.toContain("{key}");
+  });
+
+  test("classNameFromKey", () => {
+    expect(classNameFromKey("sqsp-i18n")).toBe("SqspI18n");
+    expect(classNameFromKey("at1")).toBe("At1");
+    expect(classNameFromKey("1password")).toBe("App1password");
+  });
+
+  test("resolveCreateOptions derives identity defaults from key", () => {
+    expect(resolveCreateOptions({ key: "1password", releaseRepo: "org/1password" }).className).toBe(
+      "App1password",
+    );
+    expect(
+      resolveCreateOptions({ key: "my-cli", className: "Custom", releaseRepo: "org/my-cli" })
+        .className,
+    ).toBe("Custom");
+    const opts = resolveCreateOptions({ key: "at1", releaseRepo: "bdombro/at1" });
+    expect(opts.tap).toBe("bdombro/at1");
+    expect(opts.releaseRepo).toBe("bdombro/at1");
+    expect(opts.homepage).toBe("https://github.com/bdombro/at1");
+    expect(opts.desc).toBe("At1 CLI");
+  });
+
+  test("resolveCreateOptions requires release repo", () => {
+    expect(() => resolveCreateOptions({ key: "at1" })).toThrow(/release repo/i);
+  });
+
+  test("renderCreateTree includes justfile and create-identity", () => {
+    const tree = renderCreateTree({
+      key: "testapp",
+      className: "Testapp",
+      tap: "local/testapp",
+      homepage: "https://example.com",
+      releaseRepo: "example/testapp",
+      desc: "Test",
+      force: false,
+      dryRun: false,
+      check: false,
+      diff: false,
+      yes: false,
+      devTemplate: false,
+    });
+    expect(tree.has("justfile")).toBe(true);
+    expect(tree.has("biome.json")).toBe(true);
+    expect(tree.has(".cursor/rules/code.mdc")).toBe(true);
+    expect(tree.has("scripts/create-identity.ts")).toBe(true);
+    const identity = tree.get("scripts/create-identity.ts");
+    expect(identity).toContain('key: "testapp"');
+    const formula = tree.get("scripts/formula-shared.ts");
+    expect(formula).toContain("create-identity.ts");
+  });
+
+  test("--check detects drift", () => {
+    const dir = mkdtempSync(join(tmpdir(), "argsbarg-create-"));
+    try {
+      applyCreate(dir, {
+        key: "testapp",
+        className: "Testapp",
+        tap: "local/testapp",
+        homepage: "https://example.com",
+        releaseRepo: "example/testapp",
+        desc: "Test",
+        force: true,
+        dryRun: false,
+        check: false,
+        diff: false,
+        yes: false,
+        devTemplate: false,
+      });
+      expect(diffCreate(dir, { key: "testapp", className: "Testapp" })).toEqual([]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("--check infers options from create-identity.ts", () => {
+    const dir = mkdtempSync(join(tmpdir(), "argsbarg-create-"));
+    try {
+      applyCreate(dir, {
+        key: "testapp",
+        className: "Testapp",
+        tap: "local/testapp",
+        homepage: "https://example.com",
+        releaseRepo: "example/testapp",
+        desc: "Test",
+        force: true,
+        dryRun: false,
+        check: false,
+        diff: false,
+        yes: false,
+        devTemplate: false,
+      });
+      expect(diffCreate(dir, { check: true })).toEqual([]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("--diff captures drift details", () => {
+    const drifts = diffCreateDetails("/nonexistent", { key: "x", releaseRepo: "org/x" });
+    expect(drifts.length).toBeGreaterThan(0);
+  });
+});