@anvpx/motion-cli 0.0.0-stage → 0.1.1

package/dist/template/fork.js

@@ -0,0 +1,156 @@
+import { createHash } from "node:crypto";
+import { dirname, join, resolve } from "node:path";
+import { instantiate } from "@anvpx/motion-build";
+import { MK_DIR, mkDir, storyboardStem } from "../approval/hash.js";
+import { parseFlags, requirePositional, textFlag, usageError } from "../args.js";
+import { EXIT } from "../exit-codes.js";
+import { defaultEnv, findTemplate, formatErrors, platformsFor } from "./env.js";
+import { TEMPLATE_PROVENANCE } from "./new.js";
+export const FORK_USAGE = `mk template fork <template>/<blueprint> --as <name> [--out <storyboard.json>] [--json]
+
+Forks a blueprint example into a user-owned storyboard you can reshape with mk scene/patch.
+Writes the storyboard, vendors the theme(s) it uses into <out dir>/themes/ and records
+provenance (including forkedFrom <template>@<version>) in <out dir>/.mk/<name>/template.json.
+Built-ins are never modified; the fork is yours.
+  --as <name>   fork folder/name (required): letters, numbers, - and _; no slashes
+  --out f       storyboard path (default <as>/storyboard.json)
+See \`mk template show <template>/<blueprint>\` for slots and limits.
+`;
+const FLAGS = {
+    as: { type: "string" },
+    out: { type: "string" },
+    json: { type: "boolean" },
+};
+const AS_RE = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+const MAX_WARNING_LINES = 5;
+const sha256 = (text) => createHash("sha256").update(text).digest("hex");
+/** Resolves `<template>/<blueprint>`; a miss prints the known ids and yields an exit code. */
+function resolveTarget(target, env, io) {
+    const [templateId = "", blueprintId = "", ...extra] = target.split("/");
+    if (blueprintId === "" || extra.length > 0) {
+        return usageError("template fork", FORK_USAGE, "target must be <template>/<blueprint>", io)
+            .code;
+    }
+    const found = findTemplate(env, io, templateId);
+    if (!found.ok) {
+        io.stderr(`mk template fork: ${found.message}\n`);
+        return EXIT.USAGE;
+    }
+    const blueprint = found.template.blueprints.get(blueprintId);
+    if (blueprint === undefined) {
+        const known = [...found.template.blueprints.keys()].join("|");
+        io.stderr(`mk template fork: unknown blueprint "${blueprintId}"; use one of: ${known}\n`);
+        return EXIT.USAGE;
+    }
+    return { template: found.template, blueprintId, blueprint };
+}
+const asNameOf = (flags, io) => {
+    const name = textFlag(flags, "as");
+    if (name === undefined) {
+        return usageError("template fork", FORK_USAGE, "missing --as <name>", io).code;
+    }
+    if (!AS_RE.test(name)) {
+        return usageError("template fork", FORK_USAGE, `--as "${name}" must match [A-Za-z0-9_-]+ with no slashes`, io).code;
+    }
+    return name;
+};
+/** Writes the storyboard, the vendored theme(s) and the fork provenance; returns the storyboard path. */
+async function writeFork(made, asName, outFlag, io) {
+    const out = resolve(outFlag ?? join(asName, "storyboard.json"));
+    const dir = dirname(out);
+    const text = `${made.text}\n`;
+    await io.host.writeText(out, text);
+    for (const theme of made.themes)
+        await io.host.writeText(join(dir, theme.file), theme.text);
+    const record = {
+        ...made.provenance,
+        storyboardSha256: sha256(text),
+        forkedFrom: made.provenance.template,
+        forkName: asName,
+    };
+    await io.host.writeText(join(mkDir(out), TEMPLATE_PROVENANCE), `${JSON.stringify(record, null, 2)}\n`);
+    return out;
+}
+function report(made, asName, out, json, io) {
+    const { meta } = made.storyboard;
+    const overlays = made.storyboard.scenes.filter((s) => s.layer === "overlay").length;
+    const scenes = made.sceneCount - overlays;
+    const frame = { width: meta.width, height: meta.height, fps: meta.fps };
+    const files = made.themes.map((t) => t.file);
+    if (json) {
+        const { provenance, totalSec } = made;
+        io.stdout(`${JSON.stringify({
+            ok: true,
+            fork: asName,
+            storyboard: out,
+            forkedFrom: provenance.template,
+            ...provenance,
+            scenes,
+            overlays,
+            totalSec,
+            frame,
+            themes: files,
+            warnings: made.warnings.length,
+        })}\n`);
+        return;
+    }
+    const { provenance } = made;
+    const label = `${provenance.template.split("@")[0]}/${provenance.blueprint}`;
+    io.stdout(`fork ok | ${label} -> ${asName} | ${scenes} scenes + ${overlays} overlays ${made.totalSec}s ${frame.width}x${frame.height}@${frame.fps}\n` +
+        `wrote ${out} (+ ${files.join(", ")}, ${MK_DIR}/${storyboardStem(out)}/${TEMPLATE_PROVENANCE})\n` +
+        `next: mk validate ${out} && mk preview ${out}\n`);
+}
+/** Everything `instantiate` needs, from flags and the template example; an exit code on bad input. */
+async function plan(args, env, io) {
+    const parsed = parseFlags("template fork", FORK_USAGE, args, FLAGS, io);
+    if (parsed.kind === "exit")
+        return parsed.code;
+    const name = requirePositional("template fork", FORK_USAGE, parsed.positionals, "<template>/<blueprint>", io);
+    if (typeof name !== "string")
+        return name.code;
+    const asName = asNameOf(parsed.flags, io);
+    if (typeof asName === "number")
+        return asName;
+    const target = resolveTarget(name, env, io);
+    if (typeof target === "number")
+        return target;
+    return {
+        target,
+        asName,
+        out: textFlag(parsed.flags, "out"),
+        json: parsed.flags.json === true,
+    };
+}
+const formatWarnings = (made) => {
+    const rows = made.warnings.slice(0, MAX_WARNING_LINES);
+    return rows.map((w) => `W ${w.path}: ${w.message}\n`).join("");
+};
+/** `mk template fork <template>/<blueprint> --as <name>`; `env` is injectable for tests. */
+export async function runFork(args, env, io) {
+    const planned = await plan(args, env, io);
+    if (typeof planned === "number")
+        return planned;
+    const slots = { ...planned.target.blueprint.example };
+    const result = instantiate(planned.target.template, planned.target.blueprintId, slots, {
+        platforms: await platformsFor(io),
+    });
+    if (!result.ok) {
+        io.stderr(`mk template fork: ${formatErrors(result.errors)}\n`);
+        return EXIT.USAGE;
+    }
+    const out = await writeFork(result.value, planned.asName, planned.out, io);
+    report(result.value, planned.asName, out, planned.json, io);
+    const warnings = formatWarnings(result.value);
+    if (warnings !== "")
+        io.stderr(warnings);
+    return EXIT.OK;
+}
+/** `mk template fork` as a standalone command (wired as a `mk template` subcommand too). */
+export const makeForkCommand = (env = defaultEnv) => ({
+    name: "fork",
+    summary: "fork a template blueprint example into a user-owned storyboard",
+    async run(args, io) {
+        return runFork(args, env(), io);
+    },
+});
+export const forkCommand = makeForkCommand();

package/dist/template/format.d.ts

@@ -0,0 +1,21 @@
+import { type LoadedTemplate } from "@anvpx/motion-build";
+import type { BlueprintDoc, SlotDef } from "@anvpx/motion-schema";
+/** One-line slot signature: `points* text[][3..5]<=70`; `*` required, `?` optional. */
+export declare const slotSignature: (name: string, def: SlotDef) => string;
+/** One line cut to `max` characters with an ellipsis. */
+export declare const clip: (text: string, max: number) => string;
+/** Approximate tokens of a text (4 characters each, as in the copy-guide limit). */
+export declare const tokensOf: (text: string) => number;
+/** Lengths as `30-60s`; `-` when unknown. */
+export declare const lengthLabel: (lengths: {
+    min: number;
+    max: number;
+} | undefined) => string;
+/** The 3D honesty line, repeated wherever a storyboard may contain `scene3d`. */
+export declare const SCENE3D_NOTE = "scene3d requires WebGL and falls back to a flat 2D canvas without it.";
+/** `mk template show <template>`; at most 60 lines and about 600 tokens. */
+export declare function formatTemplate(template: LoadedTemplate, source: string): string;
+/** A ready `mk new` line built from the blueprint `example`; object slots need `--slots`. */
+export declare const useLine: (id: string, blueprint: BlueprintDoc) => string;
+/** `mk template show <template>/<blueprint>`; at most 40 lines and about 450 tokens (the example is the first to go, the ready `mk new` line stays). */
+export declare function formatBlueprint(template: LoadedTemplate, blueprint: BlueprintDoc, preview?: string): string;

package/dist/template/format.js

@@ -0,0 +1,161 @@
+import { templateLengths } from "@anvpx/motion-build";
+const flagOf = (def) => def.required ? "*" : def.optional ? "?" : "";
+const range = (min, max) => min === undefined && max === undefined ? "" : `[${min ?? 0}..${max ?? "n"}]`;
+const upTo = (max) => (max === undefined ? "" : `<=${max}`);
+const fieldsOf = (fields) => Object.entries(fields)
+    .map(([key, type]) => `${key}:${type}`)
+    .join(",");
+const SIGNATURES = {
+    text: (name, def) => `${name}${flagOf(def)} text${upTo(def.max)}`,
+    "text[]": (name, def) => `${name}${flagOf(def)} text${range(def.min, def.max) || "[]"}${upTo(def.itemMax)}`,
+    number: (name, def) => `${name}${flagOf(def)} number${range(def.min, def.max)}`,
+    enum: (name, def) => `${name} ${def.values.join("|")}${def.default === undefined ? "" : ` (default ${def.default})`}`,
+    object: (name, def) => `${name}${flagOf(def)} ${def.list ? `{${fieldsOf(def.fields)}}[]${range(def.min, def.max)}` : `{${fieldsOf(def.fields)}}`}`,
+};
+/** One-line slot signature: `points* text[][3..5]<=70`; `*` required, `?` optional. */
+export const slotSignature = (name, def) => SIGNATURES[def.type](name, def);
+const frameOf = (template, styleId) => {
+    const frame = template.styles.get(styleId)?.frame;
+    if (frame === undefined)
+        return "";
+    return "platform" in frame
+        ? `, ${frame.platform}`
+        : `, ${frame.width}x${frame.height}@${frame.fps}`;
+};
+const CHARS_PER_TOKEN = 4;
+/** Keeps the first `maxLines` lines; the rest collapses into one `(+N more lines)` line. */
+const cap = (lines, max) => lines.length <= max
+    ? lines
+    : [...lines.slice(0, max - 1), `(+${lines.length - max + 1} more lines)`];
+/** One line cut to `max` characters with an ellipsis. */
+export const clip = (text, max) => text.length <= max ? text : `${text.slice(0, max - 1).trimEnd()}…`;
+/** Approximate tokens of a text (4 characters each, as in the copy-guide limit). */
+export const tokensOf = (text) => Math.ceil(text.length / CHARS_PER_TOKEN);
+/** Lengths as `30-60s`; `-` when unknown. */
+export const lengthLabel = (lengths) => lengths === undefined ? "-" : `${lengths.min}-${lengths.max}s`;
+/** Slot signature without the `length`/`style` enums every blueprint repeats. */
+const signatureLine = (blueprint) => {
+    const own = Object.entries(blueprint.slots).filter(([name]) => name !== "length" && name !== "style");
+    return own.map(([name, def]) => slotSignature(name, def)).join("; ");
+};
+const copyLinesWithin = (copy, budgetChars) => {
+    const lines = [];
+    let used = 0;
+    for (const line of copy
+        .split(/\r?\n/)
+        .filter((l) => l.trim() !== "")
+        .slice(0, 14)) {
+        used += line.length + 3;
+        if (used > budgetChars)
+            break;
+        lines.push(`  ${line}`);
+    }
+    return lines;
+};
+const TEMPLATE_MAX_LINES = 60;
+const TEMPLATE_MAX_TOKENS = 600;
+const BLUEPRINT_MAX_LINES = 40;
+const BLUEPRINT_MAX_TOKENS = 450;
+/** The 3D honesty line, repeated wherever a storyboard may contain `scene3d`. */
+export const SCENE3D_NOTE = "scene3d requires WebGL and falls back to a flat 2D canvas without it.";
+/** Drops trailing lines until the text fits the token budget; always keeps the first. */
+const withinTokens = (lines, maxTokens) => {
+    const out = [...lines];
+    while (out.length > 1 && tokensOf(out.join("\n")) > maxTokens)
+        out.pop();
+    return out;
+};
+const discoverLines = (discover, lengths) => {
+    if (discover === undefined)
+        return [];
+    const facts = [
+        `tags: ${discover.tags.join(", ")}`,
+        ...(discover.audience === undefined ? [] : [`audience: ${discover.audience.join(", ")}`]),
+        ...(discover.tone === undefined ? [] : [`tone: ${discover.tone.join(", ")}`]),
+        ...(discover.aspects === undefined ? [] : [`aspects: ${discover.aspects.join(", ")}`]),
+        ...(lengths === undefined ? [] : [`length: ${lengthLabel(lengths)}`]),
+    ];
+    return [
+        `good for: ${discover.goodFor}`,
+        ...(discover.notFor === undefined ? [] : [`not for: ${discover.notFor}`]),
+        "use cases:",
+        ...discover.useCases.map((useCase) => `  - ${useCase}`),
+        facts.join("; "),
+    ];
+};
+/** `mk template show <template>`; at most 60 lines and about 600 tokens. */
+export function formatTemplate(template, source) {
+    const { manifest } = template;
+    const lines = [
+        `${manifest.id}@${manifest.version} (${source}): ${manifest.title}`,
+        manifest.summary,
+        ...discoverLines(manifest.discover, templateLengths(template)),
+        `domains: ${manifest.domains.join(", ")}`,
+        `styles: ${[...template.styles.values()].map((s) => `${s.id} (theme ${s.theme}${frameOf(template, s.id)})`).join("; ")}`,
+        `themes: ${manifest.themes.map((t) => `${t.id} (${t.mode}${t.pair === undefined ? "" : `, pair ${t.pair}`})`).join("; ")}`,
+        "blueprints (mk template show <template>/<blueprint> for slots; every one also takes length, style):",
+    ];
+    for (const blueprint of template.blueprints.values()) {
+        const pick = clip(blueprint.discover?.goodFor ?? blueprint.purpose, 70);
+        lines.push(`  ${blueprint.id}: ${signatureLine(blueprint)} | ${lengthLabel(blueprint.discover?.lengths)} | ${pick}`);
+    }
+    if (uses3d(template))
+        lines.push(`note: ${SCENE3D_NOTE}`);
+    const { pacing } = template;
+    const ranges = Object.entries(pacing.lengths)
+        .map(([name, r]) => `${name} ${r.scenes[0]}-${r.scenes[1]} scenes, ${r.totalSec[0]}-${r.totalSec[1]}s`)
+        .join("; ");
+    lines.push(`pacing: ${pacing.wordsPerSecond} words/s; ${ranges}`);
+    const spent = tokensOf(lines.join("\n")) * CHARS_PER_TOKEN;
+    const room = TEMPLATE_MAX_TOKENS * CHARS_PER_TOKEN - spent - 16;
+    const copy = copyLinesWithin(template.copy, room);
+    const all = copy.length === 0 ? lines : [...lines, "copy guide:", ...copy];
+    return `${cap(withinTokens(all, TEMPLATE_MAX_TOKENS), TEMPLATE_MAX_LINES).join("\n")}
+`;
+}
+const shellQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+const setOf = (name, def, value) => {
+    if (def.type === "object" || value === undefined)
+        return undefined;
+    const text = Array.isArray(value)
+        ? value.map((item) => String(item).replaceAll("|", "\\|")).join("|")
+        : String(value);
+    return `--set ${shellQuote(`${name}=${text}`)}`;
+};
+/** A ready `mk new` line built from the blueprint `example`; object slots need `--slots`. */
+export const useLine = (id, blueprint) => {
+    const example = blueprint.example;
+    const sets = Object.entries(blueprint.slots).flatMap(([name, def]) => {
+        const set = setOf(name, def, example[name]);
+        return set === undefined ? [] : [set];
+    });
+    const objects = Object.values(blueprint.slots).some((def) => def.type === "object");
+    const tail = objects ? "  (object slots: --slots file.json)" : "";
+    return `use: mk new ${id} ${sets.join(" ")} --out storyboard.json${tail}`;
+};
+const sceneTypes = (blueprint) => [
+    ...new Set(blueprint.scenes.map((entry) => ("$repeat" in entry ? entry.scene.type : entry.type))),
+];
+/** True when any blueprint can emit `scene3d` (the template view then repeats the honesty line). */
+const uses3d = (template) => [...template.blueprints.values()].some((blueprint) => sceneTypes(blueprint).includes("scene3d"));
+/** `mk template show <template>/<blueprint>`; at most 40 lines and about 450 tokens (the example is the first to go, the ready `mk new` line stays). */
+export function formatBlueprint(template, blueprint, preview) {
+    const id = `${template.manifest.id}/${blueprint.id}`;
+    const types = sceneTypes(blueprint);
+    const lines = [
+        `${id}: ${blueprint.purpose}`,
+        ...(preview === undefined ? [] : [`preview: ${preview}`]),
+        ...discoverLines(blueprint.discover, blueprint.discover?.lengths),
+        "slots (* required, ? optional):",
+    ];
+    for (const [name, def] of Object.entries(blueprint.slots))
+        lines.push(`  ${slotSignature(name, def)}`);
+    lines.push(`styles: ${[...template.styles.keys()].join("|")}; lengths: short|standard|long`);
+    lines.push(`scenes: ${types.join(", ")}`);
+    if (types.includes("scene3d"))
+        lines.push(`note: ${SCENE3D_NOTE}`);
+    lines.push(useLine(id, blueprint));
+    lines.push(`example: ${JSON.stringify(blueprint.example)}`);
+    return `${cap(withinTokens(lines, BLUEPRINT_MAX_TOKENS), BLUEPRINT_MAX_LINES).join("\n")}
+`;
+}

package/dist/template/list.d.ts

@@ -0,0 +1,15 @@
+import { type SearchFilters } from "@anvpx/motion-build";
+import type { Io } from "../types.ts";
+import { type TemplateEnv } from "./env.ts";
+export declare const LIST_MAX_LINES = 15;
+/** Ranked or filtered blueprints shown (one header line on top: 9 lines in all). */
+export declare const BLUEPRINT_ROWS = 8;
+export interface ListRequest {
+    readonly domain: string | undefined;
+    /** `--for` free text. */
+    readonly query: string | undefined;
+    readonly filters: SearchFilters;
+    readonly json: boolean;
+}
+/** `mk template list`: templates, or (with `--for/--tag/--aspect/--sec`) ranked or filtered blueprints. */
+export declare function list(request: ListRequest, env: TemplateEnv, io: Io): Promise<number>;

package/dist/template/list.js

@@ -0,0 +1,116 @@
+import { entriesOf, filterEntries, loadTemplate, rankEntries, } from "@anvpx/motion-build";
+import { EXIT } from "../exit-codes.js";
+import { discover, loadOptions } from "./env.js";
+import { clip, lengthLabel } from "./format.js";
+export const LIST_MAX_LINES = 15;
+/** Ranked or filtered blueprints shown (one header line on top: 9 lines in all). */
+export const BLUEPRINT_ROWS = 8;
+const SUMMARY_MAX = 70;
+const GOOD_FOR_MAX = 70;
+const TOP_TAGS = 4;
+/** `--for`, `--tag`, `--aspect` or `--sec` switch the listing from templates to blueprints. */
+const wantsBlueprints = (request) => request.query !== undefined ||
+    (request.filters.tags?.length ?? 0) > 0 ||
+    request.filters.aspect !== undefined ||
+    request.filters.sec !== undefined;
+const capLines = (lines) => lines.length <= LIST_MAX_LINES
+    ? lines
+    : [...lines.slice(0, LIST_MAX_LINES - 1), `(+${lines.length - LIST_MAX_LINES + 1} more)`];
+const loadAll = (env, io) => {
+    const found = discover(env, io);
+    const loaded = found.templates.flatMap((candidate) => {
+        const result = loadTemplate(candidate.dir, loadOptions(env));
+        return result.ok ? [{ template: result.value, source: candidate.source }] : [];
+    });
+    return { found, loaded };
+};
+const templateRow = (template, source) => {
+    const { manifest } = template;
+    const tags = manifest.discover?.tags.slice(0, TOP_TAGS) ?? [];
+    return {
+        id: `${manifest.id}@${manifest.version}`,
+        summary: manifest.summary,
+        domains: manifest.domains,
+        tags,
+        aspects: manifest.discover?.aspects ?? [],
+        blueprints: manifest.blueprints.map((b) => b.id),
+        source,
+    };
+};
+const dash = (items) => (items.length === 0 ? "-" : items.join(","));
+function listTemplates(request, env, io) {
+    const { found, loaded } = loadAll(env, io);
+    const wanted = request.domain?.toLowerCase();
+    const rows = loaded
+        .filter(({ template }) => wanted === undefined || template.manifest.domains.some((d) => d.toLowerCase() === wanted))
+        .map(({ template, source }) => templateRow(template, source));
+    const shadowed = found.shadowed.map((s) => `! ${s.id}@${s.version} (${s.source}) shadowed by ${s.reason === "root" ? "higher-precedence root" : "newer version"}: ${s.by}`);
+    const problems = found.problems.map((p) => `! ${p.path}: ${p.message}`);
+    if (request.json) {
+        io.stdout(`${JSON.stringify({ templates: rows, shadowed, problems })}\n`);
+        return EXIT.OK;
+    }
+    const lines = [
+        ...rows.map((r) => `${r.id} | ${clip(r.summary, SUMMARY_MAX)} | ${dash(r.tags)} | ${dash(r.aspects)} | ${r.blueprints.join(",")} | ${r.source}`),
+        ...shadowed,
+        ...problems,
+    ];
+    if (lines.length === 0) {
+        lines.push(wanted === undefined ? "no templates found" : `no template for domain "${request.domain}"`);
+    }
+    io.stdout(`${capLines(lines).join("\n")}\n`);
+    return EXIT.OK;
+}
+const idOf = (entry) => `${entry.template}/${entry.blueprint}`;
+const pickText = (entry) => clip(entry.goodFor === "" ? entry.purpose : entry.goodFor, GOOD_FOR_MAX);
+const criteria = (request) => {
+    const { tags = [], aspect, sec } = request.filters;
+    return [
+        request.query === undefined ? "" : `for "${request.query}"`,
+        tags.length === 0 ? "" : `tag ${tags.join(",")}`,
+        aspect === undefined ? "" : `aspect ${aspect}`,
+        sec === undefined ? "" : `sec ${sec}`,
+    ]
+        .filter((part) => part !== "")
+        .join(" ");
+};
+const rowOf = (entry, hit) => {
+    const tail = `${pickText(entry)} | ${lengthLabel(entry.lengths)} | ${dash(entry.aspects)}`;
+    if (hit === undefined)
+        return `${idOf(entry)} | ${tail}`;
+    const mark = hit.notFor ? `${hit.score} NOT-FOR` : String(hit.score);
+    return `${idOf(entry)} | ${mark} | ${tail} | why: ${hit.why.join(",")}`;
+};
+function listBlueprints(request, env, io) {
+    const { loaded } = loadAll(env, io);
+    const filtered = filterEntries(entriesOf(loaded.map((item) => item.template)), request.filters);
+    const hits = request.query === undefined ? undefined : rankEntries(filtered, request.query, env.stopwords);
+    const shown = hits === undefined
+        ? filtered.map((entry) => ({ entry, hit: undefined }))
+        : hits.map((hit) => ({ entry: hit.entry, hit }));
+    const top = shown.slice(0, BLUEPRINT_ROWS);
+    if (request.json) {
+        const blueprints = top.map(({ entry, hit }) => ({
+            id: idOf(entry),
+            goodFor: entry.goodFor,
+            aspects: entry.aspects,
+            lengths: entry.lengths ?? null,
+            ...(hit === undefined ? {} : { score: hit.score, notFor: hit.notFor, why: hit.why }),
+        }));
+        io.stdout(`${JSON.stringify({ total: shown.length, blueprints })}\n`);
+        return EXIT.OK;
+    }
+    const count = shown.length > top.length ? `top ${top.length} of ${shown.length}` : `${shown.length}`;
+    const header = `blueprints ${criteria(request)}: ${count}`;
+    const lines = top.length === 0
+        ? [header, "no blueprint matches; relax a filter or reword --for"]
+        : [header, ...top.map(({ entry, hit }) => rowOf(entry, hit))];
+    io.stdout(`${lines.join("\n")}\n`);
+    return EXIT.OK;
+}
+/** `mk template list`: templates, or (with `--for/--tag/--aspect/--sec`) ranked or filtered blueprints. */
+export async function list(request, env, io) {
+    return wantsBlueprints(request)
+        ? listBlueprints(request, env, io)
+        : listTemplates(request, env, io);
+}

package/dist/template/new.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from "../types.ts";
+import { type TemplateEnv } from "./env.ts";
+export declare const TEMPLATE_PROVENANCE = "template.json";
+/** `mk new`; `env` is injectable for tests. */
+export declare const makeNewCommand: (env?: () => TemplateEnv) => Command;
+export declare const newCommand: Command;