argsbarg 4.1.1 → 5.0.1

package/src/builtins/registry.ts

@@ -3,9 +3,8 @@ 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 { cliBuiltinUninstallCommand } from "./uninstall.ts";
 import { cliBuiltinVersionCommand } from "./version.ts";
 
 type BuiltinFactory = (program: CliProgram) => CliNode | null;
@@ -27,11 +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));
-    pushBuiltin(builtins, program, (p) => cliBuiltinUninstallCommand(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,20 +8,20 @@ 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;
   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,
     configCommands: configCommandsEnabled(program),
   };
@@ -29,9 +29,12 @@ export function resolveCapabilities(program: CliProgram): CliCapabilities {
 
 /** 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", "uninstall");
+  const names = ["version"];
+  if (caps.completion) {
+    names.unshift("completion");
+  }
+  if (caps.configure) {
+    names.push("configure");
   }
   if (caps.docs) {
     names.push("docs");
@@ -57,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":
@@ -79,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

@@ -11,9 +11,19 @@ describe("argsbarg cli-tool", () => {
     expect(proc.stdout.trim().length).toBeGreaterThan(0);
   });
 
-  test("completion subcommand emits bash script", () => {
-    const proc = spawnSync("bun", [main, "completion", "bash"], { encoding: "utf8" });
+  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("complete");
+    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

@@ -8,6 +8,7 @@ import {
   diffCreate,
   diffCreateDetails,
   renderCreateTree,
+  resolveCreateOptions,
   substituteTemplateContent,
 } from "./create.ts";
 
@@ -39,6 +40,27 @@ describe("argsbarg create", () => {
 
   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", () => {
@@ -113,7 +135,7 @@ describe("argsbarg create", () => {
   });
 
   test("--diff captures drift details", () => {
-    const drifts = diffCreateDetails("/nonexistent", { key: "x" });
+    const drifts = diffCreateDetails("/nonexistent", { key: "x", releaseRepo: "org/x" });
     expect(drifts.length).toBeGreaterThan(0);
   });
 });

package/src/cli-tool/create.ts

@@ -44,11 +44,20 @@ export function keyToEnvPrefix(key: string): string {
     .toUpperCase();
 }
 
+/** PascalCase Homebrew formula class from CLI key; prefix `App` when Ruby constant rules require it. */
 export function classNameFromKey(key: string): string {
-  return key
+  const name = key
     .split(/[-_]/)
+    .filter((s) => s.length > 0)
     .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
     .join("");
+  if (name.length === 0) {
+    throw new Error(`Invalid CLI key: ${key}`);
+  }
+  if (!/^[A-Z]/.test(name)) {
+    return `App${name}`;
+  }
+  return name;
 }
 
 function tapLibraryParts(tap: string): { org: string; repo: string } {
@@ -131,6 +140,12 @@ export function inferCreateOptions(
   };
 }
 
+function assertReleaseRepoFormat(releaseRepo: string): void {
+  if (!/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(releaseRepo)) {
+    throw new Error(`Invalid release repo (expected org/repo): ${releaseRepo}`);
+  }
+}
+
 export function resolveCreateOptions(
   partial: Partial<CreateOptions>,
   baseDir?: string,
@@ -139,13 +154,20 @@ export function resolveCreateOptions(
   const tmpl = templateIdentity();
   const key = merged.key ?? tmpl.key ?? "full-example";
   const className = merged.className ?? classNameFromKey(key);
+  const releaseRepo = merged.releaseRepo;
+  if (!releaseRepo) {
+    throw new Error(
+      "GitHub release repo (org/repo) is required. Pass --release-repo or use the interactive wizard.",
+    );
+  }
+  assertReleaseRepoFormat(releaseRepo);
   const devTemplate = merged.devTemplate ?? (baseDir ? isDevTemplateDir(baseDir) : false);
   return {
     key,
     className,
-    tap: merged.tap ?? `local/${key}`,
-    homepage: merged.homepage ?? `https://github.com/${merged.releaseRepo ?? `example/${key}`}`,
-    releaseRepo: merged.releaseRepo ?? `example/${key}`,
+    tap: merged.tap ?? releaseRepo,
+    homepage: merged.homepage ?? `https://github.com/${releaseRepo}`,
+    releaseRepo,
     desc: merged.desc ?? `${className} CLI`,
     force: merged.force ?? false,
     dryRun: merged.dryRun ?? false,

package/src/cli-tool/full-example-capabilities.test.ts

@@ -22,7 +22,7 @@ const sinkProgram = {
     topics: { readme: { text: "# readme\n" } },
   },
   mcpServer: { enabled: true },
-  install: {},
+  configure: {},
   commands: [
     {
       key: "status",
@@ -62,7 +62,7 @@ describe("full-example template", () => {
     expect(resolveCapabilities(sinkProgram)).toEqual({
       completion: true,
       mcp: true,
-      install: true,
+      configure: true,
       docs: true,
       configCommands: true,
     });

package/src/cli-tool/program.ts

@@ -10,6 +10,8 @@ export const program = {
   key: "argsbarg",
   version: pkg.version,
   description: "Argsbarg developer tools — bootstrap CLIs from the full-example template.",
+  completion: { enabled: false },
+  configure: { enabled: false },
   commands: [
     {
       key: "create",
@@ -18,17 +20,30 @@ export const program = {
         { name: "key", description: "CLI binary name.", kind: CliOptionKind.String },
         {
           name: "class-name",
-          description: "Homebrew formula class name.",
+          description: "Homebrew formula Ruby class (default: derived from --key).",
+          kind: CliOptionKind.String,
+        },
+        {
+          name: "tap",
+          description: "Homebrew tap (default: same as --release-repo).",
+          kind: CliOptionKind.String,
+        },
+        {
+          name: "homepage",
+          description: "Formula homepage (default: https://github.com/<release-repo>).",
           kind: CliOptionKind.String,
         },
-        { name: "tap", description: "Homebrew tap (org/repo).", kind: CliOptionKind.String },
-        { name: "homepage", description: "Formula homepage URL.", kind: CliOptionKind.String },
         {
           name: "release-repo",
-          description: "GitHub org/repo for release binary.",
+          description: "GitHub org/repo for releases (required in non-interactive mode).",
+          kind: CliOptionKind.String,
+        },
+        {
+          name: "desc",
+          description:
+            "App + formula description (default: <ClassName> CLI; stored in create-identity.ts).",
           kind: CliOptionKind.String,
         },
-        { name: "desc", description: "Formula description.", kind: CliOptionKind.String },
         { name: "force", description: "Overwrite existing files.", kind: CliOptionKind.Presence },
         {
           name: "dry-run",

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

@@ -5,7 +5,6 @@ import { relative, resolve } from "node:path";
 import {
   applyCreate,
   type CreateOptions,
-  classNameFromKey,
   diffCreateDetails,
   parseCreateArgv,
   printCreateDiffs,
@@ -27,36 +26,23 @@ function collectInteractiveOptions(
   const targetDir = promptOptional("Target directory", dir) ?? dir;
   const baseDir = resolve(process.cwd(), targetDir);
   const key = promptRequired("CLI key (binary name)", partial.key);
-  const className =
-    promptOptional("Formula class name", partial.className ?? classNameFromKey(key)) ??
-    classNameFromKey(key);
-  const releaseRepo =
-    promptOptional("GitHub release repo (org/repo)", partial.releaseRepo ?? `example/${key}`) ??
-    `example/${key}`;
-  const homepage =
-    promptOptional("Homepage URL", partial.homepage ?? `https://github.com/${releaseRepo}`) ??
-    `https://github.com/${releaseRepo}`;
-  const tap =
-    promptOptional("Homebrew tap (org/repo)", partial.tap ?? `local/${key}`) ?? `local/${key}`;
-  const desc =
-    promptOptional("Formula description", partial.desc ?? `${className} CLI`) ?? `${className} CLI`;
+  const releaseRepo = promptRequired("GitHub release repo (org/repo)", partial.releaseRepo);
 
   const opts = resolveCreateOptions(
     {
       ...partial,
       key,
-      className,
-      tap,
-      homepage,
       releaseRepo,
-      desc,
       force: partial.force ?? false,
     },
     baseDir,
   );
 
   process.stderr.write(`\nTarget: ${baseDir}\n`);
-  process.stderr.write(`Key: ${opts.key}  Class: ${opts.className}  Tap: ${opts.tap}\n\n`);
+  process.stderr.write(
+    `Key: ${opts.key}  Class: ${opts.className}  Tap: ${opts.tap}  Release: ${opts.releaseRepo}\n`,
+  );
+  process.stderr.write(`Homepage: ${opts.homepage}\n\n`);
   const tree = renderCreateTree(opts);
   process.stderr.write(`Files (${tree.size}):\n`);
   for (const rel of [...tree.keys()].sort()) {
@@ -104,6 +90,9 @@ export async function runCreate(input: Partial<CreateOptions> & { dir?: string }
     if (!partial.key) {
       throw new Error("--key is required in non-interactive mode.");
     }
+    if (!partial.releaseRepo) {
+      throw new Error("--release-repo is required in non-interactive mode.");
+    }
     opts = resolveCreateOptions(partial, baseDir);
     return runCreateApply(baseDir, opts, partial.dryRun ?? false);
   } catch (err) {

package/src/config/bootstrap.ts

@@ -176,10 +176,12 @@ function promptConfigKey(
   return { value: undefined, userTyped: false };
 }
 
-/** Options for the interactive `install --configure` wizard. */
+/** Options for the interactive configure wizard (app config target). */
 export interface RunInstallConfigureOpts {
   /** Where the wizard was started from (standalone command vs right after install). */
   context?: "standalone" | "after-install";
+  /** When false, omit the "Configuration Setup" banner (e.g. inside interactive `configure`). */
+  showHeading?: boolean;
 }
 
 /** Print the "Configuration Setup" heading before the configure prompts. */
@@ -225,13 +227,13 @@ function promptMissingRequired(program: CliProgram): Record<string, unknown> {
   return updates;
 }
 
-/** Run the full interactive configure wizard (`install --configure`). */
-export function runInstallConfigure(
+/** Run the full interactive app config wizard (`configure`). */
+export function runConfigure(
   program: CliProgram,
-  _opts: RunInstallConfigureOpts = {},
+  opts: RunInstallConfigureOpts = {},
 ): { path: string; changed: boolean } {
   if (!program.appConfig) {
-    throw new Error("install --configure requires program.appConfig on the program root.");
+    throw new Error("configure requires program.appConfig on the program root.");
   }
   if (!process.stdin.isTTY) {
     const { resolved } = bootstrapAppConfig(program, { validateFile: false });
@@ -239,7 +241,7 @@ export function runInstallConfigure(
     if (missing.length > 0) {
       process.stderr.write(`${formatMissingConfigMessage(program, missing)}\n`);
     } else {
-      process.stderr.write("install --configure requires an interactive terminal.\n");
+      process.stderr.write("configure requires an interactive terminal.\n");
     }
     process.exit(1);
   }
@@ -253,7 +255,7 @@ export function runInstallConfigure(
   const next: Record<string, unknown> = { ...existing };
   let changed = false;
 
-  if (shouldShowConfigureSetupHeading(program)) {
+  if (opts.showHeading !== false && shouldShowConfigureSetupHeading(program)) {
     writeConfigureSetupHeading();
   }
 
@@ -286,7 +288,7 @@ export function runInstallConfigure(
   return { path, changed: false };
 }
 
-/** Summary for `install --status`: config path, whether the file exists, and which required settings are set (never their values). */
+/** Summary for `configure --status`: config path, whether the file exists, and which required settings are set (never their values). */
 export function appConfigStatus(program: CliProgram):
   | {
       path: string;
@@ -343,7 +345,7 @@ export function ensureAppConfig(
 
   if (opts.interactive && process.stdin.isTTY) {
     if (opts.configure) {
-      runInstallConfigure(program, { context: "standalone" });
+      runConfigure(program, { context: "standalone" });
       fileData = readAppConfigFileRaw(resolveAppConfigPath(program));
       resolved = resolveAppConfig(program, fileData, hostEnv);
       exportConfigToEnv(program, resolved, hostEnv);

package/src/config/file.test.ts

@@ -85,7 +85,7 @@ describe("config/file", () => {
       expect(missing).toContain("apiToken");
       expect(missing).not.toContain("port");
       const msg = formatMissingConfigMessage(program, missing);
-      expect(msg).toContain("install --configure");
+      expect(msg).toContain("configure");
     } finally {
       if (prev !== undefined) process.env.API_TOKEN = prev;
     }

package/src/config/resolve.ts

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

package/src/configure/configure.test.ts

@@ -0,0 +1,148 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  appConfigHasEntries,
+  parseConfigureOpts,
+  validateConfigureOpts,
+} from "../configure/index.ts";
+import { detectInstalledArtifacts } from "../install/detect-installed.ts";
+import { parseInstallOpts } from "../install/opts.ts";
+import { resolveClaudeDesktopMcpPath, resolveInstallPaths } from "../install/paths.ts";
+import { buildInstallPlan, buildUpdatePlan } from "../install/plan.ts";
+import { buildUninstallPlan } from "../install/uninstall.ts";
+import type { CliProgram } from "../types.ts";
+
+const fixture: CliProgram = {
+  key: "testapp",
+  version: "0.0.0",
+  description: "Test",
+  mcpServer: { enabled: true },
+  handler: () => {},
+};
+
+let home: string;
+let prevHome: string | undefined;
+let prevXdg: string | undefined;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "argsbarg-configure-"));
+  prevHome = process.env.HOME;
+  prevXdg = process.env.XDG_CONFIG_HOME;
+  process.env.HOME = home;
+  delete process.env.XDG_CONFIG_HOME;
+});
+
+afterEach(() => {
+  if (prevHome === undefined) delete process.env.HOME;
+  else process.env.HOME = prevHome;
+  if (prevXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+  else process.env.XDG_CONFIG_HOME = prevXdg;
+  rmSync(home, { recursive: true, force: true });
+});
+
+describe("configure opts", () => {
+  test("validate rejects multiple modes", () => {
+    const opts = parseConfigureOpts({ sync: "1", status: "1" });
+    expect(validateConfigureOpts(opts)).toContain("only one");
+  });
+
+  test("sync requires --yes", () => {
+    const opts = parseConfigureOpts({ sync: "1" });
+    expect(validateConfigureOpts(opts)).toContain("--yes");
+  });
+
+  test("remove-all requires --yes", () => {
+    const opts = parseConfigureOpts({ "remove-all": "1" });
+    expect(validateConfigureOpts(opts)).toContain("--yes");
+  });
+});
+
+describe("install paths", () => {
+  test("resolveInstallPaths includes skill and mcp paths", () => {
+    const paths = resolveInstallPaths(fixture);
+    expect(paths.cursorSkillDir).toContain(".cursor/skills");
+    expect(paths.cursorMcpPath).toContain("mcp.json");
+  });
+
+  test("claude desktop mcp path on darwin", () => {
+    const prev = process.platform;
+    Object.defineProperty(process, "platform", { value: "darwin" });
+    try {
+      expect(resolveClaudeDesktopMcpPath(home)).toBe(
+        join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"),
+      );
+    } finally {
+      Object.defineProperty(process, "platform", { value: prev });
+    }
+  });
+});
+
+describe("detect installed", () => {
+  test("detects cursor mcp when configured", () => {
+    const paths = resolveInstallPaths(fixture);
+    mkdirSync(join(home, ".cursor"), { recursive: true });
+    writeFileSync(
+      paths.cursorMcpPath,
+      JSON.stringify({ mcpServers: { testapp: { command: "testapp", args: ["mcp"] } } }),
+      "utf8",
+    );
+
+    const detected = detectInstalledArtifacts(paths, fixture);
+    expect(detected.cursorMcp).toBe(true);
+    expect(detected.app).toBe(false);
+  });
+});
+
+describe("sync plan", () => {
+  test("buildUpdatePlan greenfield includes agent targets", () => {
+    const paths = resolveInstallPaths(fixture);
+    const plan = buildUpdatePlan(fixture, paths, parseInstallOpts({ reinstall: "1", yes: "1" }));
+    expect(plan.length).toBeGreaterThan(0);
+    expect(plan.some((a) => a.kind === "app")).toBe(false);
+  });
+
+  test("buildInstallPlan --all omits app self-install", () => {
+    const paths = resolveInstallPaths(fixture);
+    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ all: "1" }));
+    expect(plan.some((a) => a.kind === "app")).toBe(false);
+    expect(plan.some((a) => a.kind.endsWith("-mcp"))).toBe(true);
+  });
+
+  test("buildInstallPlan respects configure.agentIntegration skill", () => {
+    const skillApp: CliProgram = {
+      ...fixture,
+      configure: { agentIntegration: "skill" },
+    };
+    const paths = resolveInstallPaths(skillApp);
+    mkdirSync(join(home, ".claude"), { recursive: true });
+    mkdirSync(join(home, ".cursor"), { recursive: true });
+    const plan = buildInstallPlan(skillApp, paths, parseInstallOpts({ mcp: "1" }));
+    expect(plan.some((a) => a.kind.endsWith("-mcp"))).toBe(false);
+  });
+});
+
+describe("remove plan", () => {
+  test("buildUninstallPlan --all with nothing installed is empty", () => {
+    const paths = resolveInstallPaths(fixture);
+    const plan = buildUninstallPlan(fixture, paths, parseInstallOpts({ uninstall: "1", all: "1" }));
+    expect(plan.length).toBe(0);
+  });
+});
+
+describe("app config wizard", () => {
+  test("appConfigHasEntries when entries exist", () => {
+    expect(
+      appConfigHasEntries({
+        ...fixture,
+        appConfig: { entries: { token: { description: "API token." } } },
+      }),
+    ).toBe(true);
+  });
+
+  test("appConfigHasEntries false for empty entries or missing appConfig", () => {
+    expect(appConfigHasEntries({ ...fixture, appConfig: { entries: {} } })).toBe(false);
+    expect(appConfigHasEntries(fixture)).toBe(false);
+  });
+});