argsbarg 6.1.10 → 6.2.0

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

@@ -8,6 +8,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
   applyCreate,
+  type CreateOptions,
   classNameFromKey,
   diffCreate,
   diffCreateDetails,
@@ -16,25 +17,39 @@ import {
   substituteTemplateContent,
 } from "./create.ts";
 
+function baseOpts(overrides: Partial<CreateOptions> = {}): CreateOptions {
+  return {
+    templateId: "cli",
+    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,
+    ...overrides,
+  };
+}
+
 /** Tests for argsbarg create. */
 describe("argsbarg create", () => {
-  /** Tests that substitutes {key} tokens. */
   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,
+        ...baseOpts({
+          key: "my-cli",
+          className: "MyCli",
+          tap: "org/my-cli",
+          homepage: "https://github.com/org/my-cli",
+          releaseRepo: "org/my-cli",
+          desc: "My CLI",
+        }),
       },
     );
     expect(out).toContain("my-cli");
@@ -50,7 +65,6 @@ describe("argsbarg create", () => {
     expect(classNameFromKey("1password")).toBe("App1password");
   });
 
-  /** ResolveCreateOptions derives identity defaults from key. */
   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(
@@ -58,83 +72,45 @@ describe("argsbarg create", () => {
     );
     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");
+    expect(opts.templateId).toBe("cli");
   });
 
   test("resolveCreateOptions requires release repo", () => {
     expect(() => resolveCreateOptions({ key: "at1" })).toThrow(/release repo/i);
   });
 
-  /** Tests that renderCreateTree includes justfile and create-identity. */
-  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,
-    });
+  test("renderCreateTree includes justfile and create-identity for cli template", () => {
+    const tree = renderCreateTree(baseOpts({ key: "testapp" }));
     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");
+    expect(identity).toContain('template: "cli"');
+    expect(tree.has("src/commands/render-json/command.ts")).toBe(false);
+  });
+
+  test("renderCreateTree json template includes schemagen commands", () => {
+    const tree = renderCreateTree(baseOpts({ templateId: "json", key: "testapp" }));
+    expect(tree.has("src/commands/render-json/command.ts")).toBe(true);
+    expect(tree.has("src/db/index.ts")).toBe(true);
+    const identity = tree.get("scripts/create-identity.ts");
+    expect(identity).toContain('template: "json"');
   });
 
-  /** Tests that --check detects drift. */
   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([]);
+      applyCreate(dir, baseOpts({ force: true }));
+      expect(diffCreate(dir, { key: "testapp", className: "Testapp", templateId: "cli" })).toEqual([]);
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
   });
 
-  /** Tests that --check infers options from create-identity.ts. */
   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,
-      });
+      applyCreate(dir, baseOpts({ force: true }));
       expect(diffCreate(dir, { check: true })).toEqual([]);
     } finally {
       rmSync(dir, { recursive: true, force: true });

package/src/cli-tool/create.ts

@@ -1,11 +1,48 @@
-/** `argsbarg create` — copy npm-shipped examples/full-example with substitutions. */
+/** `argsbarg create` — copy npm-shipped example templates with substitutions. */
 
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import pkg from "../../package.json" with { type: "json" };
 
+export type CreateTemplateId = "cli" | "json";
+
+export interface CreateTemplateSpec {
+  id: CreateTemplateId;
+  dirName: string;
+  displayName: string;
+  description: string;
+}
+
+export const CREATE_TEMPLATES: CreateTemplateSpec[] = [
+  {
+    id: "cli",
+    dirName: "full-example",
+    displayName: "full-example",
+    description: "Production CLI with MCP, HTTP, configure, and skills. Options and flags only; no schemagen.",
+  },
+  {
+    id: "json",
+    dirName: "full-example-json",
+    displayName: "full-example-json",
+    description: "Same shell plus @sg schemagen, input/outputSchema validation, JSON HTTP leaves, and REST CRUD demo.",
+  },
+];
+
+export function normalizeCreateTemplateId(value: string | undefined): CreateTemplateId {
+  return value === "json" ? "json" : "cli";
+}
+
+export function templateDirFor(templateId: CreateTemplateId): string {
+  const spec = CREATE_TEMPLATES.find((t) => t.id === templateId);
+  if (!spec) {
+    throw new Error(`Unknown create template: ${templateId}`);
+  }
+  return join(packageRoot(), "examples", spec.dirName);
+}
+
 export interface CreateOptions {
+  templateId: CreateTemplateId;
   key: string;
   className: string;
   tap: string;
@@ -29,12 +66,25 @@ export function packageRoot(): string {
   return resolve(dirname(fileURLToPath(import.meta.url)), "../..");
 }
 
-export function templateDir(): string {
-  return join(packageRoot(), "examples/full-example");
+export function templateDir(templateId: CreateTemplateId = "cli"): string {
+  return templateDirFor(templateId);
 }
 
-export function isDevTemplateDir(baseDir: string): boolean {
-  return resolve(baseDir) === resolve(templateDir());
+export function devTemplateIdForDir(baseDir: string): CreateTemplateId | undefined {
+  const resolved = resolve(baseDir);
+  for (const spec of CREATE_TEMPLATES) {
+    if (resolved === resolve(templateDirFor(spec.id))) {
+      return spec.id;
+    }
+  }
+  return undefined;
+}
+
+export function isDevTemplateDir(baseDir: string, templateId?: CreateTemplateId): boolean {
+  if (templateId) {
+    return resolve(baseDir) === resolve(templateDirFor(templateId));
+  }
+  return devTemplateIdForDir(baseDir) !== undefined;
 }
 
 export function keyToEnvPrefix(key: string): string {
@@ -70,10 +120,13 @@ function tapLibraryParts(tap: string): { org: string; repo: string } {
 }
 
 /** Parse `scripts/create-identity.ts` for inference and template defaults. */
-export function parseCreateIdentityFile(path: string): Partial<CreateOptions> & { envPrefix?: string } {
+export function parseCreateIdentityFile(
+  path: string,
+): Partial<CreateOptions> & { envPrefix?: string; template?: string } {
   if (!existsSync(path)) return {};
   const text = readFileSync(path, "utf8");
   const pick = (field: string) => text.match(new RegExp(`${field}:\\s*"([^"]*)"`))?.[1];
+  const templateRaw = text.match(/template:\s*"(cli|json)"/)?.[1];
   return {
     key: pick("key"),
     className: pick("className"),
@@ -82,10 +135,13 @@ export function parseCreateIdentityFile(path: string): Partial<CreateOptions> &
     releaseRepo: pick("releaseRepo"),
     desc: pick("desc"),
     envPrefix: pick("envPrefix"),
+    template: templateRaw,
+    templateId: templateRaw ? normalizeCreateTemplateId(templateRaw) : undefined,
   };
 }
 
-export function templateIdentity(): {
+export function templateIdentity(templateId: CreateTemplateId = "cli"): {
+  templateId: CreateTemplateId;
   key: string;
   className: string;
   tap: string;
@@ -94,15 +150,16 @@ export function templateIdentity(): {
   desc: string;
   envPrefix: string;
 } {
-  const parsed = parseCreateIdentityFile(join(templateDir(), CREATE_IDENTITY_REL));
-  const key = parsed.key ?? "full-example";
+  const parsed = parseCreateIdentityFile(join(templateDirFor(templateId), CREATE_IDENTITY_REL));
+  const key = parsed.key ?? CREATE_TEMPLATES.find((t) => t.id === templateId)?.displayName ?? "full-example";
   return {
+    templateId,
     key,
     className: parsed.className ?? classNameFromKey(key),
     tap: parsed.tap ?? `local/${key}`,
     homepage: parsed.homepage ?? "https://github.com/bdombro/bun-argsbarg",
     releaseRepo: parsed.releaseRepo ?? "bdombro/bun-argsbarg",
-    desc: parsed.desc ?? "Argsbarg full example reference app",
+    desc: parsed.desc ?? "Argsbarg copy template",
     envPrefix: parsed.envPrefix ?? keyToEnvPrefix(key),
   };
 }
@@ -113,6 +170,7 @@ export function inferCreateOptions(baseDir: string, partial: Partial<CreateOptio
   }
   const fromIdentity = parseCreateIdentityFile(join(baseDir, CREATE_IDENTITY_REL));
   return {
+    templateId: partial.templateId ?? fromIdentity.templateId,
     key: partial.key ?? fromIdentity.key,
     className: partial.className ?? fromIdentity.className,
     desc: partial.desc ?? fromIdentity.desc,
@@ -136,7 +194,10 @@ function assertReleaseRepoFormat(releaseRepo: string): void {
 
 export function resolveCreateOptions(partial: Partial<CreateOptions>, baseDir?: string): CreateOptions {
   const merged = baseDir ? inferCreateOptions(baseDir, partial) : partial;
-  const tmpl = templateIdentity();
+  const templateId = normalizeCreateTemplateId(
+    merged.templateId ?? (baseDir ? devTemplateIdForDir(baseDir) : undefined),
+  );
+  const tmpl = templateIdentity(templateId);
   const key = merged.key ?? tmpl.key ?? "full-example";
   const className = merged.className ?? classNameFromKey(key);
   const releaseRepo = merged.releaseRepo;
@@ -144,8 +205,9 @@ export function resolveCreateOptions(partial: Partial<CreateOptions>, baseDir?:
     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);
+  const devTemplate = merged.devTemplate ?? (baseDir ? isDevTemplateDir(baseDir, templateId) : false);
   return {
+    templateId,
     key,
     className,
     tap: merged.tap ?? releaseRepo,
@@ -173,6 +235,7 @@ export const createIdentity = {
   releaseRepo: "${opts.releaseRepo}",
   desc: "${opts.desc}",
   envPrefix: "${envPrefix}",
+  template: "${opts.templateId}",
 } as const;
 `;
 }
@@ -195,7 +258,7 @@ function tokenMap(opts: CreateOptions): Record<string, string> {
 
 /** Substitute \`{key}\`-style placeholders; also replace template identity literals. */
 export function substituteTemplateContent(content: string, opts: CreateOptions): string {
-  const tmpl = templateIdentity();
+  const tmpl = templateIdentity(opts.templateId);
   const tokens = tokenMap(opts);
   const argsbargVersion = pkg.version;
 
@@ -245,8 +308,8 @@ function shouldExcludeRel(rel: string): boolean {
   return EXCLUDE_REL.has(rel);
 }
 
-function listTemplateFiles(): string[] {
-  const root = templateDir();
+function listTemplateFiles(templateId: CreateTemplateId): string[] {
+  const root = templateDirFor(templateId);
   if (!existsSync(root)) return [];
   const out: string[] = [];
   const walk = (dir: string, prefix: string) => {
@@ -266,12 +329,12 @@ function listTemplateFiles(): string[] {
 
 export function renderCreateTree(opts: CreateOptions): Map<string, string> {
   const files = new Map<string, string>();
-  for (const rel of listTemplateFiles()) {
+  for (const rel of listTemplateFiles(opts.templateId)) {
     if (rel === CREATE_IDENTITY_REL) {
       files.set(rel, renderCreateIdentitySource(opts));
       continue;
     }
-    const src = join(templateDir(), rel);
+    const src = join(templateDirFor(opts.templateId), rel);
     const raw = readFileSync(src, "utf8");
     files.set(rel, substituteTemplateContent(raw, opts));
   }
@@ -374,6 +437,7 @@ export function parseCreateArgv(rest: string[]): ParsedCreateArgv {
     else if (a === "--homepage" && rest[i + 1]) opts.homepage = rest[++i];
     else if (a === "--release-repo" && rest[i + 1]) opts.releaseRepo = rest[++i];
     else if (a === "--desc" && rest[i + 1]) opts.desc = rest[++i];
+    else if (a === "--template" && rest[i + 1]) opts.templateId = normalizeCreateTemplateId(rest[++i]);
     else if (a?.startsWith("--")) {
       throw new Error(`Unknown option: ${a}`);
     } else if (a) {

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

@@ -8,14 +8,16 @@ import { join } from "node:path";
 import { CliOptionKind, type CliProgram } from "../core/types.ts";
 import { resolveCapabilities } from "../runtime/capabilities.ts";
 
-const exampleRoot = join(import.meta.dir, "../../examples/full-example");
-const programSource = readFileSync(join(exampleRoot, "src/program.ts"), "utf8");
+const cliExampleRoot = join(import.meta.dir, "../../examples/full-example");
+const jsonExampleRoot = join(import.meta.dir, "../../examples/full-example-json");
+const cliProgramSource = readFileSync(join(cliExampleRoot, "src/program.ts"), "utf8");
+const jsonProgramSource = readFileSync(join(jsonExampleRoot, "src/program.ts"), "utf8");
 
-/** Mirror of full-example/src/program.ts capability flags (in-repo types only). */
+/** Mirror capability flags for copy templates (in-repo types only). */
 const sinkProgram = {
   key: "full-example",
   version: "1.0.0",
-  description: "Full example reference.",
+  description: "Copy template reference.",
   docs: {
     topics: { readme: { text: "# readme\n" } },
   },
@@ -44,25 +46,22 @@ const sinkProgram = {
   ],
 } satisfies CliProgram;
 
-/** Tests for full-example template. */
-describe("full-example template", () => {
-  /** Tests that program source enables every builtin flag. */
+describe("full-example cli template", () => {
   test("program source enables every builtin flag", () => {
-    expect(programSource).toContain("mcpServer: {");
-    expect(programSource).toContain("httpServer: {");
-    expect(programSource).toContain("docs:");
-    expect(programSource).not.toMatch(/docs:\s*\{[^}]*enabled:\s*true/s);
-    expect(programSource).not.toContain("appConfig:");
+    expect(cliProgramSource).toContain("mcpServer: {");
+    expect(cliProgramSource).toContain("httpServer: {");
+    expect(cliProgramSource).toContain("docs:");
+    expect(cliProgramSource).not.toMatch(/docs:\s*\{[^}]*enabled:\s*true/s);
+    expect(cliProgramSource).not.toContain("appConfig:");
   });
 
-  test("status command defines outputSchema", () => {
-    const statusSource = readFileSync(join(exampleRoot, "src/commands/status/command.ts"), "utf8");
-    expect(statusSource).toMatch(/outputSchema[,:]/);
-    expect(statusSource).toContain("StatusJsonOutputSchema");
-    expect(statusSource).toContain('from "./__generated__"');
+  test("status command has no outputSchema", () => {
+    const statusSource = readFileSync(join(cliExampleRoot, "src/commands/status/command.ts"), "utf8");
+    expect(statusSource).not.toMatch(/outputSchema[,:]/);
+    expect(statusSource).not.toContain("__generated__");
   });
 
-  test("resolveCapabilities matches full sink shape", () => {
+  test("resolveCapabilities matches sink shape", () => {
     expect(resolveCapabilities(sinkProgram)).toEqual({
       http: true,
       completion: true,
@@ -73,3 +72,19 @@ describe("full-example template", () => {
     });
   });
 });
+
+describe("full-example-json template", () => {
+  test("program source enables every builtin flag", () => {
+    expect(jsonProgramSource).toContain("mcpServer: {");
+    expect(jsonProgramSource).toContain("httpServer: {");
+    expect(jsonProgramSource).toContain("docs:");
+    expect(jsonProgramSource).not.toContain("appConfig:");
+  });
+
+  test("status command defines outputSchema", () => {
+    const statusSource = readFileSync(join(jsonExampleRoot, "src/commands/status/command.ts"), "utf8");
+    expect(statusSource).toMatch(/outputSchema[,:]/);
+    expect(statusSource).toContain("StatusJsonOutputSchema");
+    expect(statusSource).toContain('from "./__generated__"');
+  });
+});

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

@@ -2,6 +2,7 @@
 
 import { existsSync } from "node:fs";
 import { join, resolve } from "node:path";
+import type { CreateTemplateId } from "./create.ts";
 
 export function isInsideGitWorkTree(dir: string): boolean {
   try {
@@ -25,7 +26,11 @@ export function shouldSkipGitBootstrap(targetDir: string): boolean {
   return false;
 }
 
-export async function runPostCreate(targetDir: string, dryRun: boolean): Promise<void> {
+export async function runPostCreate(
+  targetDir: string,
+  dryRun: boolean,
+  templateId: CreateTemplateId = "cli",
+): Promise<void> {
   const abs = resolve(targetDir);
   const steps: Array<{ label: string; run: () => Promise<void> | void }> = [
     {
@@ -40,18 +45,22 @@ export async function runPostCreate(targetDir: string, dryRun: boolean): Promise
         if (proc.exitCode !== 0) throw new Error("bun install failed");
       },
     },
-    {
-      label: "argsbarg schemagen",
-      run: () => {
-        if (dryRun) return;
-        const proc = Bun.spawnSync(["argsbarg", "schemagen"], {
-          cwd: abs,
-          stdout: "inherit",
-          stderr: "inherit",
-        });
-        if (proc.exitCode !== 0) throw new Error("schemagen failed");
-      },
-    },
+    ...(templateId === "json"
+      ? [
+          {
+            label: "argsbarg schemagen",
+            run: () => {
+              if (dryRun) return;
+              const proc = Bun.spawnSync(["argsbarg", "schemagen"], {
+                cwd: abs,
+                stdout: "inherit",
+                stderr: "inherit",
+              });
+              if (proc.exitCode !== 0) throw new Error("schemagen failed");
+            },
+          },
+        ]
+      : []),
     {
       label: "bun test",
       run: () => {
@@ -100,10 +109,15 @@ export async function runPostCreate(targetDir: string, dryRun: boolean): Promise
   }
 }
 
-export function printPostCreatePlan(): void {
+export function printPostCreatePlan(templateId: CreateTemplateId = "cli"): void {
   process.stderr.write("Post-create steps:\n");
   process.stderr.write("  1. bun install\n");
-  process.stderr.write("  2. just schemagen\n");
-  process.stderr.write("  3. bun test\n");
-  process.stderr.write("  4. git init + Initial commit (skipped inside existing git work tree)\n");
+  if (templateId === "json") {
+    process.stderr.write("  2. argsbarg schemagen\n");
+    process.stderr.write("  3. bun test\n");
+    process.stderr.write("  4. git init + Initial commit (skipped inside existing git work tree)\n");
+  } else {
+    process.stderr.write("  2. bun test\n");
+    process.stderr.write("  3. git init + Initial commit (skipped inside existing git work tree)\n");
+  }
 }

package/src/cli-tool/program.ts

@@ -4,21 +4,22 @@ Argsbarg developer tools — bootstrap consumer CLIs via `create`.
 
 import pkg from "../../package.json" with { type: "json" };
 import { CliOptionKind, type CliProgram } from "../index.ts";
+import { normalizeCreateTemplateId } from "./create.ts";
 import { runCreate } from "./run-create.ts";
 import { runSchemagenCli } from "./run-schemagen.ts";
 
 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 },
-  docs: { enabled: false },
   commands: [
     {
       key: "create",
-      description: "Copy the full-example template into a directory with substitutions.",
+      description: "Copy a CLI template into a directory with substitutions.",
       options: [
+        {
+          name: "template",
+          description: "Template: cli (default) or json (schema-first).",
+          kind: CliOptionKind.Enum,
+          choices: ["cli", "json"],
+        },
         { name: "key", description: "CLI binary name.", kind: CliOptionKind.String },
         {
           name: "class-name",
@@ -77,8 +78,10 @@ export const program = {
         },
       ],
       handler: async (ctx) => {
+        const templateRaw = ctx.stringOpt("template");
         const code = await runCreate({
           dir: ctx.args[0],
+          ...(templateRaw !== undefined ? { templateId: normalizeCreateTemplateId(templateRaw) } : {}),
           key: ctx.stringOpt("key"),
           className: ctx.stringOpt("class-name"),
           tap: ctx.stringOpt("tap"),
@@ -130,4 +133,10 @@ export const program = {
       },
     },
   ],
+  completion: { enabled: false },
+  configure: { enabled: false },
+  description: "Argsbarg developer tools — bootstrap CLIs from copy templates.",
+  docs: { enabled: false },
+  key: "argsbarg",
+  version: pkg.version,
 } satisfies CliProgram;

package/src/cli-tool/prompt.ts

@@ -1,6 +1,7 @@
 /** Interactive prompts for `argsbarg create`. */
 
 import { readPromptLine as readStdinLine } from "../prompt.ts";
+import { CREATE_TEMPLATES, type CreateTemplateId, normalizeCreateTemplateId } from "./create.ts";
 
 export function readPromptLine(prompt: string): string {
   process.stderr.write(prompt);
@@ -26,3 +27,29 @@ export function promptRequired(label: string, current?: string): string {
     process.stderr.write("  (required)\n");
   }
 }
+
+/** A/B picker for create template (returns cli or json). */
+export function promptTemplateChoice(): CreateTemplateId {
+  const cli = CREATE_TEMPLATES.find((t) => t.id === "cli");
+  const json = CREATE_TEMPLATES.find((t) => t.id === "json");
+  if (!cli || !json) {
+    throw new Error("CREATE_TEMPLATES must include cli and json entries");
+  }
+  process.stderr.write("\nSelect a template:\n\n");
+  process.stderr.write(`A) ${cli.displayName} — ${cli.description}\n`);
+  process.stderr.write(`B) ${json.displayName} — ${json.description}\n\n`);
+  while (true) {
+    const ans = readPromptLine("Choice: ").toLowerCase();
+    if (ans === "a") return "cli";
+    if (ans === "b") return "json";
+    process.stderr.write("  Enter A or B.\n");
+  }
+}
+
+export function parseTemplateChoiceInput(value: string | undefined): CreateTemplateId | undefined {
+  if (!value) return undefined;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "a" || normalized === "cli") return "cli";
+  if (normalized === "b" || normalized === "json") return "json";
+  return normalizeCreateTemplateId(value);
+}