@ethlete/cli 3.0.0-next.21 → 3.0.0-next.23

package/src/lib/design/sketch-command.js

@@ -0,0 +1,618 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.designSketch = exports.verdictLinesOf = exports.sketchFlagHelpOf = exports.SKETCH_USAGE = void 0;
+const path_1 = require("path");
+const assets_1 = require("./system/assets");
+const comment_1 = require("./system/comments/comment");
+const product_1 = require("./system/product");
+const resolve_product_1 = require("./system/resolve-product");
+const check_format_1 = require("./system/sketch/check-format");
+const check_sketches_1 = require("./system/sketch/check-sketches");
+const cli_args_1 = require("./system/sketch/cli-args");
+const ready_shots_1 = require("./ready-shots");
+const merge_1 = require("./system/sketch/merge");
+const merged_parts_1 = require("./system/sketch/merged-parts");
+const render_check_1 = require("./system/render-check");
+const merge_preview_1 = require("./system/sketch/merge-preview");
+const sketch_1 = require("./system/sketch/sketch");
+exports.SKETCH_USAGE = [
+    'sketch new <layer>/<name> --variants a,b --by <model id> [--like <layer>/<name>[:<variant>]] [--round <title>] [--note <text>] [--variant-note <variant>=<text>]… [--product <name>]',
+    'sketch variant <layer>/<name> <variant>[,<variant>…] --from <variant> --by <model id> [--round <title> --note <why the running round lost> [--round-note <what the new round shows>]] [--product <name>]',
+    'sketch round <layer>/<name> <round> [--title <text>] [--note <text>] [--drops <state,state>] --by <model id> [--product <name>]',
+    'sketch list [--product <name>] [--json]',
+    'sketch report <layer>/<name> --variant <key> --by <model id> (<text> | --done) [--product <name>]',
+    'sketch ready <layer>/<name> --by <model id> [--product <name>]',
+    'sketch check [<layer>/<name>] [--fix] [--product <name>]',
+    'sketch preview <layer>/<name> <variant> [--product <name>] [--json]',
+    'sketch rebase <layer>/<name> --by <model id> [--product <name>]',
+    'sketch merge <layer>/<name> [--note <reason>] --by <model id> [--product <name>]',
+    'sketch discard <layer>/<name> --by <model id> [--product <name>]',
+    'sketch reject <layer>/<name> --variant <key> [--reason <text>] --by <model id | designer> [--product <name>]',
+    'sketch reopen <layer>/<name> --variant <key> [--reason <text>] --by <model id | designer> [--product <name>]',
+];
+const FLAG_HELP = {
+    '--variants': 'the variant folders to open, a comma list: a,b,c',
+    '--variant-note': "the note of one variant, kept in sketch.json apart from the part's merged note; repeat it per variant: a=<text>",
+    '--by': 'the exact model id the coordinator gave you, e.g. claude-opus-5-5',
+    '--like': 'start each variant from another part, or from a variant of the open sketch on it',
+    '--round': 'the title of a new round',
+    '--round-note': 'what the new round shows',
+    '--from': 'the variant to copy',
+    '--title': 'the new title of the round',
+    '--drops': 'the states the round drops on purpose, a comma list',
+    '--variant': 'the variant the command is about',
+    '--reason': 'why; on reject of a variant that is rejected already it sets the reason of that rejection; stored with who wrote it',
+    '--done': 'end the live report of the variant',
+    '--product': 'the product; needed only when config.json declares more than one and no other product has the sketch',
+    '--json': 'print JSON',
+    '--fix': "write the variants in the checkout's Prettier format first",
+};
+const VERDICT_BY_HELP = "a model id records the verdict as the agent's; --by designer records it as the designer's - only when the designer said it at this terminal";
+const NOTE_HELP = {
+    new: 'what the first round shows',
+    variant: 'why the running round lost; needed with --round',
+    round: 'what the round shows',
+    merge: 'why this variant',
+};
+/** One line per flag the usage line names, for `sketch <command> --help`. */
+const sketchFlagHelpOf = (usage) => {
+    var _a, _b;
+    const command = (_a = usage.split(' ')[1]) !== null && _a !== void 0 ? _a : '';
+    const help = Object.assign(Object.assign(Object.assign({}, FLAG_HELP), { '--note': NOTE_HELP[command] }), (VERDICTS.has(command) ? { '--by': VERDICT_BY_HELP } : {}));
+    return [...new Set((_b = usage.match(/--[a-z-]+/gu)) !== null && _b !== void 0 ? _b : [])].flatMap((flag) => help[flag] === undefined ? [] : [`  ${flag.padEnd(16)}${help[flag]}`]);
+};
+exports.sketchFlagHelpOf = sketchFlagHelpOf;
+const VERDICTS = new Set(['reject', 'reopen']);
+const WRITES = new Set(['new', 'variant', 'round', 'report', 'ready', 'rebase', 'merge', 'discard', ...VERDICTS]);
+const fail = (message) => {
+    console.error(message);
+    return 1;
+};
+const productsWithSketchOf = (context, has) => {
+    var _a;
+    return Object.keys((_a = context.config.products) !== null && _a !== void 0 ? _a : {}).filter((name) => has((0, product_1.productDirOf)({ target: context.target, product: name }), name));
+};
+/**
+ * The product a sketch command works on: the one `--product` names or the only one the config declares, else the
+ * only product with an open sketch on the target - or with any open sketch when the command names no target.
+ */
+const sketchProductOf = (context) => {
+    var _a;
+    const { target, config, args } = context;
+    const asked = args.values['--product'];
+    const declared = Object.keys((_a = config.products) !== null && _a !== void 0 ? _a : {});
+    if (asked !== undefined || declared.length < 2)
+        return (0, cli_args_1.oneProductOf)({ target, config, asked });
+    const parsed = (0, sketch_1.parseTarget)(args.positional[0]);
+    const holders = args.positional[0] === undefined
+        ? productsWithSketchOf(context, (productDir, product) => (0, sketch_1.listSketches)({ productDir, product }).some((sketch) => typeof sketch !== 'string'))
+        : typeof parsed === 'string'
+            ? []
+            : productsWithSketchOf(context, (productDir, product) => (0, sketch_1.findSketch)({ productDir, product, sketch: parsed }) !== null);
+    return (0, cli_args_1.oneProductOf)({ target, config, asked: holders.length === 1 ? holders[0] : undefined });
+};
+const productAndSketchOf = (context) => {
+    var _a;
+    const { args } = context;
+    const product = sketchProductOf(context);
+    if (typeof product === 'string')
+        return product;
+    const parsed = (0, sketch_1.parseTarget)(args.positional[0]);
+    if (typeof parsed === 'string')
+        return parsed;
+    const sketch = (0, sketch_1.findSketch)({ productDir: product.dir, product: product.name, sketch: parsed });
+    if (sketch === null)
+        return `NO SKETCH on ${(0, resolve_product_1.partKeyOf)(parsed)} in ${product.name}${(_a = context.noSketchHint) !== null && _a !== void 0 ? _a : ''}`;
+    if (typeof sketch === 'string')
+        return sketch;
+    return { product, sketch };
+};
+const withSketch = (context, run) => {
+    const found = productAndSketchOf(context);
+    return typeof found === 'string' ? fail(found) : run(found);
+};
+const partFileOf = (options) => {
+    var _a;
+    const { root, sketch, variant } = options;
+    const name = (_a = sketch.target.split('/').pop()) !== null && _a !== void 0 ? _a : '';
+    return (0, path_1.relative)(root, (0, path_1.resolve)(sketch.dir, variant, sketch.target, `${name}.ts`));
+};
+const variantLineOf = (options) => {
+    const { root, sketch, variant } = options;
+    return `  ${variant}: ${partFileOf(options)}  assets: ${(0, path_1.relative)(root, (0, path_1.resolve)(sketch.dir, variant, assets_1.ASSETS_FOLDER))}/`;
+};
+const created = (context) => {
+    var _a, _b, _c, _d;
+    const { target, config, args } = context;
+    const product = (0, cli_args_1.oneProductOf)({ target, config, asked: args.values['--product'] });
+    if (typeof product === 'string')
+        return fail(product);
+    const parsed = (0, sketch_1.parseTarget)(args.positional[0]);
+    if (typeof parsed === 'string')
+        return fail(parsed);
+    const variants = ((_a = args.values['--variants']) !== null && _a !== void 0 ? _a : '').split(',').filter((variant) => variant !== '');
+    const notes = variantNotesOf((_b = args.repeated['--variant-note']) !== null && _b !== void 0 ? _b : [], variants);
+    if (typeof notes === 'string')
+        return fail(notes);
+    if (args.values['--round'] !== undefined && ((_c = args.values['--note']) !== null && _c !== void 0 ? _c : '').trim() === '')
+        return fail(`--round needs --note "<what the round shows>" - sketch ready refuses a round without a note`);
+    const asked = args.values['--like'];
+    const like = asked === undefined ? undefined : (0, sketch_1.sketchSourceOf)({ product, like: asked });
+    if (typeof like === 'string')
+        return fail(like);
+    const sketch = (0, sketch_1.createSketch)({
+        product,
+        sketch: parsed,
+        variants,
+        roundTitle: args.values['--round'],
+        roundNote: args.values['--note'],
+        author: (_d = (0, cli_args_1.authorOf)(args)) !== null && _d !== void 0 ? _d : undefined,
+        like,
+        variantNotes: notes,
+    });
+    if (typeof sketch === 'string')
+        return fail(sketch);
+    (0, check_format_1.formatSketch)({ target, sketch, variants: sketch.variants });
+    console.log(`${sketch.target} in progress: ${(0, path_1.relative)(target, sketch.dir)} with ${sketch.variants.join(', ')}`);
+    for (const variant of sketch.variants)
+        console.log(variantLineOf({ root: target, sketch, variant }));
+    const shared = (0, sketch_1.sourceFilesIn)((0, sketch_1.sharedDirOf)(sketch));
+    if (shared.length > 0) {
+        console.log(`  shared by every variant, imported as @shared/<path>; edit it here, not in a copy:`);
+        shared.forEach((file) => console.log(`    ${(0, path_1.relative)(target, file)}`));
+    }
+    nextStepsOf(sketch, product.name).forEach((line) => console.log(line));
+    return 0;
+};
+const nextStepsOf = (sketch, product) => {
+    var _a;
+    const at = `${sketch.target} --product ${product}`;
+    const first = (_a = sketch.variants[0]) !== null && _a !== void 0 ? _a : '<key>';
+    const running = (0, sketch_1.runningRoundOf)(sketch);
+    return [
+        'Next:',
+        `  sketch report ${at} --variant ${first} --by <model id> "<what you draw>"   while you draw a variant`,
+        `  sketch report ${at} --variant ${first} --by <model id> --done              when you stop drawing it; no report runs yet, so none is needed now`,
+        ...(running.note.trim() === ''
+            ? [
+                `  sketch round ${sketch.target} ${running.key} --product ${product} --note "<what the round shows>" --by <model id>`,
+            ]
+            : []),
+        `  sketch check ${at}`,
+        `  sketch ready ${at} --by <model id>`,
+    ];
+};
+const variantNotesOf = (pairs, variants) => {
+    const notes = new Map();
+    for (const pair of pairs) {
+        const split = pair.indexOf('=');
+        const variant = pair.slice(0, split);
+        if (split < 1 || !variants.includes(variant))
+            return `--variant-note needs <variant>=<text> with one of ${variants.join(', ') || 'the --variants'}; got "${pair}"`;
+        notes.set(variant, pair.slice(split + 1).trim());
+    }
+    return notes;
+};
+const VARIANT_USAGE = 'usage: sketch variant <layer>/<name> <variant>[,<variant>…] --from <variant> [--round <title> --note <why the running round lost> [--round-note <what the new round shows>]]';
+const varied = (context) => {
+    var _a;
+    return withSketch(Object.assign(Object.assign({}, context), { noSketchHint: ` - start one with: sketch new ${(_a = context.args.positional[0]) !== null && _a !== void 0 ? _a : '<layer>/<name>'} --variants a,b,c --round "<title>"` }), ({ sketch }) => {
+        var _a, _b, _c, _d, _e;
+        const { positional, values } = context.args;
+        const variant = positional[1];
+        const from = values['--from'];
+        const title = values['--round'];
+        const lostNote = values['--note'];
+        const roundNote = values['--round-note'];
+        if (positional.length !== 2 ||
+            !variant ||
+            !from ||
+            (title === undefined) !== (lostNote === undefined) ||
+            (title === undefined && roundNote !== undefined))
+            return fail(VARIANT_USAGE);
+        const open = title === undefined
+            ? (0, comment_1.commentsOnSketch)({ productDir: (0, path_1.resolve)(sketch.dir, '..', '..'), product: sketch.product, sketch })
+            : [];
+        if (open.length > 0)
+            return fail([
+                `${sketch.target} has ${open.length} open comment(s) - a variant that answers them starts a new round:`,
+                ...open.map((comment) => { var _a, _b; return `  ${comment.id} on ${(_b = (_a = comment.sketch) === null || _a === void 0 ? void 0 : _a.variant) !== null && _b !== void 0 ? _b : ''}: ${comment.text}`; }),
+                `sketch variant ${sketch.target} ${variant} --from <variant> --round "<title>" --note "<why the running round lost>" --round-note "<what the new round shows>"`,
+                `if the variant answers none of them, close each first with: inbox done <id> --note <text>`,
+            ].join('\n'));
+        const variants = variant.split(',').filter((name) => name !== '');
+        const taken = variants.find((name, index) => sketch.variants.includes(name) || variants.indexOf(name) !== index);
+        const invalid = variants.find((name) => !(0, sketch_1.isVariantName)(name));
+        if (invalid !== undefined)
+            return fail(`"${invalid}" is no variant name - use lower case letters, digits and dashes, and not "shared"`);
+        if (taken !== undefined)
+            return fail(`${sketch.target} already has a variant "${taken}"`);
+        let added = sketch;
+        for (const [index, name] of variants.entries()) {
+            const next = (0, sketch_1.addVariant)(Object.assign({ sketch: added, variant: name, from, author: (_a = (0, cli_args_1.authorOf)(context.args)) !== null && _a !== void 0 ? _a : undefined }, (index === 0 && title !== undefined && lostNote !== undefined
+                ? { round: { title, lostNote, note: roundNote } }
+                : {})));
+            if (typeof next === 'string')
+                return fail(next);
+            added = next;
+        }
+        const round = added.rounds.find((entry) => { var _a, _b; return entry.key === ((_b = added.variantInfo[(_a = variants[0]) !== null && _a !== void 0 ? _a : '']) === null || _b === void 0 ? void 0 : _b.round); });
+        const previous = title === undefined ? undefined : added.rounds[added.rounds.length - 2];
+        if (previous)
+            console.log(`why round ${previous.key} ${previous.title} lost: ${(_b = previous.lost) !== null && _b !== void 0 ? _b : ''}`);
+        (0, check_format_1.formatSketch)({ target: context.target, sketch: added, variants });
+        for (const name of variants) {
+            console.log(`${added.target} in progress: variant ${name} from ${from} in round ${(_c = round === null || round === void 0 ? void 0 : round.key) !== null && _c !== void 0 ? _c : ''}`);
+            console.log(variantLineOf({ root: context.target, sketch: added, variant: name }));
+        }
+        if (title !== undefined && (round === null || round === void 0 ? void 0 : round.note) === '')
+            console.log(`round ${round.key} has no note yet - sketch ready needs one: sketch round ${added.target} ${round.key} --note "<what the round shows>" --by <model id>`);
+        if (title === undefined)
+            return 0;
+        const addressed = (0, comment_1.addressSketchComments)({
+            sketch,
+            variant: from,
+            reason: 'round',
+            author: (_d = (0, cli_args_1.authorOf)(context.args)) !== null && _d !== void 0 ? _d : undefined,
+            note: lostNote,
+            round: round === null || round === void 0 ? void 0 : round.key,
+        });
+        if (addressed.length > 0)
+            console.log(`addressed ${addressed.length} comment(s) on variant ${from} in round ${(_e = round === null || round === void 0 ? void 0 : round.key) !== null && _e !== void 0 ? _e : ''}: ${addressed.map(({ id }) => id).join(', ')}`);
+        return 0;
+    });
+};
+const listed = (context) => {
+    const names = (0, cli_args_1.productNamesOf)({ config: context.config, asked: context.args.values['--product'] });
+    if (typeof names === 'string')
+        return fail(names);
+    const sketches = names.flatMap((name) => (0, sketch_1.listSketches)({ productDir: (0, product_1.productDirOf)({ target: context.target, product: name }), product: name }));
+    const unreadable = sketches.filter((sketch) => typeof sketch === 'string');
+    const open = sketches.filter((sketch) => typeof sketch !== 'string');
+    unreadable.forEach((problem) => console.error(problem));
+    if (context.args.flags.has('--json')) {
+        console.log(JSON.stringify(open.map((_a) => {
+            var { dir } = _a, sketch = __rest(_a, ["dir"]);
+            return (Object.assign(Object.assign({}, sketch), { dir: (0, path_1.relative)(context.target, dir) }));
+        }), null, 2));
+    }
+    else {
+        for (const sketch of open) {
+            const decided = sketch.decision
+                ? sketch.decision.kind === 'pick'
+                    ? `, picked ${sketch.decision.variant}`
+                    : ', discard asked'
+                : '';
+            const rejected = sketch.variants.filter((variant) => (0, sketch_1.rejectionOf)(sketch, variant));
+            console.log(`${sketch.product}  ${sketch.target}  ${sketch.status}  ${sketch.variants.join(', ')}${decided}${rejected.length > 0 ? `, rejected ${rejected.join(', ')}` : ''}`);
+            for (const round of sketch.rounds) {
+                const variants = sketch.variants.filter((variant) => { var _a; return ((_a = sketch.variantInfo[variant]) === null || _a === void 0 ? void 0 : _a.round) === round.key; });
+                console.log(`  ${round.key}  ${round.title}  ${variants.join(', ')}${round.note === '' ? '' : `  - ${round.note}`}${round.lost ? `  - lost: ${round.lost}` : ''}`);
+            }
+        }
+        if (open.length === 0)
+            console.log('no open sketch');
+    }
+    return unreadable.length > 0 ? 1 : 0;
+};
+const reported = (context) => withSketch(context, ({ sketch }) => {
+    const message = context.args.positional.slice(1).join(' ');
+    const variant = context.args.values['--variant'];
+    const author = (0, cli_args_1.authorOf)(context.args);
+    const done = context.args.flags.has('--done');
+    if ((message === '' && !done) || !variant || !author)
+        return fail(`usage: sketch report <layer>/<name> --variant <key> --by <model id> (<text> | --done) [--product <name>] - --product is needed when config.json declares more than one product`);
+    if (done) {
+        (0, sketch_1.finishSketchReport)({ checkout: context.target, sketch, variant });
+        console.log(`${sketch.target} variant ${variant} marked done`);
+        return 0;
+    }
+    const reported = (0, sketch_1.reportSketch)({ checkout: context.target, sketch, variant, author, message });
+    if (typeof reported === 'string')
+        return fail(reported);
+    console.log(`reported on ${sketch.target} variant ${variant}: ${message}`);
+    return 0;
+});
+const ROUND_USAGE = 'usage: sketch round <layer>/<name> <round> [--title <text>] [--note <text>] [--drops <state,state>] --by <model id>';
+const roundEdited = (context) => withSketch(context, ({ sketch }) => {
+    var _a, _b;
+    const { positional, values } = context.args;
+    const round = positional[1];
+    if (positional.length !== 2 || !round)
+        return fail(ROUND_USAGE);
+    const edited = (0, sketch_1.editRound)({
+        sketch,
+        round,
+        title: values['--title'],
+        note: values['--note'],
+        drops: (_a = values['--drops']) === null || _a === void 0 ? void 0 : _a.split(',').map((state) => state.trim()).filter((state) => state !== ''),
+    });
+    if (typeof edited === 'string')
+        return fail(edited);
+    const entry = edited.rounds.find((candidate) => candidate.key === round);
+    console.log(`${edited.target} round ${round}: ${(_b = entry === null || entry === void 0 ? void 0 : entry.title) !== null && _b !== void 0 ? _b : ''}${(entry === null || entry === void 0 ? void 0 : entry.note) ? ` - ${entry.note}` : ''}${(entry === null || entry === void 0 ? void 0 : entry.lost) ? ` - lost: ${entry.lost}` : ''}${(entry === null || entry === void 0 ? void 0 : entry.drops) ? ` - drops ${entry.drops.join(', ')}` : ''}`);
+    return 0;
+});
+const readied = (context) => {
+    const found = productAndSketchOf(context);
+    if (typeof found === 'string')
+        return fail(found);
+    const status = markedReady(context, found);
+    if (typeof status === 'number')
+        return status;
+    return autoMerged(Object.assign(Object.assign({ context }, found), { sketch: status.ready, again: found.sketch.status === 'ready' }));
+};
+const autoMerged = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const { context, product, sketch, again } = options;
+    if (!again)
+        console.log(`${sketch.target} is ready`);
+    if (!product.parts.some((part) => (0, resolve_product_1.partKeyOf)(part) === sketch.target)) {
+        console.log('auto-merge skipped: new part, the user merges');
+        return again ? fail(`${sketch.target} is ready, not in progress`) : 0;
+    }
+    const noChange = yield (0, ready_shots_1.shotsShowNoChange)({ target: context.target, config: context.config, product, sketch });
+    if (noChange !== true) {
+        console.log(`auto-merge skipped: ${noChange}`);
+        return again ? fail(`${sketch.target} is ready, not in progress`) : 0;
+    }
+    const author = (_a = (0, cli_args_1.authorOf)(context.args)) !== null && _a !== void 0 ? _a : undefined;
+    const variant = (_b = sketch.variants.find((candidate) => !(0, sketch_1.rejectionOf)(sketch, candidate))) !== null && _b !== void 0 ? _b : '';
+    const decided = (0, sketch_1.decideSketch)({ sketch, decision: { kind: 'pick', variant } });
+    if (typeof decided === 'string')
+        return fail(decided);
+    const result = (0, merge_1.mergeSketch)({ target: context.target, config: context.config, product, sketch: decided, author });
+    if (!Array.isArray(result)) {
+        console.warn(`${sketch.target} shows no visible change but did not merge: ${result.reason}`);
+        return 0;
+    }
+    (0, merged_parts_1.recordAutoMerge)({ product, part: sketch.target, by: author !== null && author !== void 0 ? author : 'user' });
+    console.log(`No visible change in any state: merged ${sketch.target} automatically.`);
+    return 0;
+});
+const markedReady = (context, { product, sketch }) => {
+    var _a;
+    const lineOf = (variant, problem) => `${sketch.target} ${variant}: ${problem.rule} ${(0, path_1.relative)(context.target, problem.file)}: ${problem.message}`;
+    const found = (0, check_sketches_1.variantProblemsOf)({ product, sketch });
+    found.forEach(({ variant, before }) => before.forEach((problem) => console.warn(`NOTE (was there before) ${lineOf(variant, problem)}`)));
+    const problems = found.flatMap(({ variant, problems }) => [...problems, ...(0, check_format_1.formatProblemsOf)({ target: context.target, sketch, variant })].map((problem) => lineOf(variant, problem)));
+    sketch.variants.forEach((variant) => (0, check_sketches_1.variantWarningsOf)({ target: context.target, product, sketch, variant }).forEach((warning) => console.warn(`${sketch.target} ${variant}: ${warning}`)));
+    if (problems.length > 0)
+        return fail(`${problems.join('\n')}\n${sketch.target} has problems - fix them before ready`);
+    const running = (0, sketch_1.runningRoundOf)(sketch);
+    if (running.note.trim() === '')
+        return fail(`${sketch.target} round ${running.key} has no note - set it with: sketch round ${sketch.target} ${running.key} --note "<what the round shows>" --by <model id>`);
+    if (sketch.status === 'ready')
+        return { ready: sketch };
+    const ready = (0, sketch_1.markSketchReady)({ checkout: context.target, sketch, author: (_a = (0, cli_args_1.authorOf)(context.args)) !== null && _a !== void 0 ? _a : undefined });
+    if (typeof ready === 'string')
+        return fail(ready);
+    return { ready };
+};
+const rebased = (context) => withSketch(context, ({ product, sketch }) => {
+    (0, sketch_1.rebaseSketch)({ product, sketch });
+    console.log(`${sketch.target} now compares with the product as it is`);
+    return 0;
+});
+const checked = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const { target, config, args } = context;
+    const product = sketchProductOf(context);
+    if (typeof product === 'string')
+        return fail(product);
+    const asked = args.positional[0];
+    const { unreadable, variants } = (0, check_sketches_1.openSketchProblemsOf)(product);
+    const chosen = asked === undefined ? variants : variants.filter((entry) => entry.sketch.target === asked);
+    if (asked !== undefined && chosen.length === 0)
+        return fail(`NO SKETCH on ${asked} in ${product.name}`);
+    if (args.flags.has('--fix'))
+        new Set(chosen.map((entry) => entry.sketch)).forEach((sketch) => (0, check_format_1.formatSketch)({ target, sketch, variants: sketch.variants }));
+    let failed = asked === undefined && unreadable.length > 0;
+    if (asked === undefined)
+        unreadable.forEach((problem) => console.error(`${problem.rule} ${(0, path_1.relative)(target, problem.file)}: ${problem.message}`));
+    for (const { sketch, variant, problems, before } of chosen) {
+        const typed = (0, check_sketches_1.typecheckVariant)({ target, product, sketch, variant });
+        before.forEach((problem) => console.warn(`NOTE (was there before) ${sketch.target} ${variant}: ${problem.rule} ${(0, path_1.relative)(target, problem.file)}: ${problem.message}`));
+        (0, check_sketches_1.variantWarningsOf)({ target, product, sketch, variant }).forEach((warning) => console.warn(`${sketch.target} ${variant}: ${warning}`));
+        const all = [
+            ...problems,
+            ...(0, check_format_1.formatProblemsOf)({ target, sketch, variant }),
+            ...(typed.kind === 'failed' ? [{ rule: 'TYPE-ERROR', file: sketch.dir, message: `\n${typed.output}` }] : []),
+            ...(typed.kind === 'unavailable' ? [{ rule: 'NO-TYPE-CHECKER', file: sketch.dir, message: typed.message }] : []),
+        ];
+        for (const problem of all) {
+            console.error(`${sketch.target} ${variant}: ${problem.rule} ${(0, path_1.relative)(target, problem.file)}: ${problem.message}`);
+        }
+        failed || (failed = all.length > 0);
+    }
+    if (failed)
+        return 1;
+    const rendered = yield (0, render_check_1.renderIssuesOf)({
+        target,
+        config,
+        jobs: chosen.map(({ sketch, variant }) => {
+            const preview = (0, merge_preview_1.mergePreviewOf)({ product, sketch, variant });
+            return {
+                product: product.name,
+                sketch: { target: sketch.target, variant },
+                parts: [...preview.changed, ...preview.affected],
+            };
+        }),
+    });
+    if ('unavailable' in rendered)
+        console.log(`RENDER CHECK SKIPPED - ${rendered.unavailable}`);
+    else {
+        for (const { sketch, part, state, size } of rendered.drawn) {
+            const rules = [
+                ...new Set(rendered.issues
+                    .filter((issue) => {
+                    var _a, _b;
+                    return ((_a = issue.sketch) === null || _a === void 0 ? void 0 : _a.target) === (sketch === null || sketch === void 0 ? void 0 : sketch.target) &&
+                        ((_b = issue.sketch) === null || _b === void 0 ? void 0 : _b.variant) === (sketch === null || sketch === void 0 ? void 0 : sketch.variant) &&
+                        issue.part === part &&
+                        issue.state === state &&
+                        issue.size === size;
+                })
+                    .map((issue) => issue.rule)),
+            ];
+            console.log(`${(_a = sketch === null || sketch === void 0 ? void 0 : sketch.target) !== null && _a !== void 0 ? _a : ''} ${(_b = sketch === null || sketch === void 0 ? void 0 : sketch.variant) !== null && _b !== void 0 ? _b : ''}: ${part} ${state} at ${size} ${rules.join(' ') || 'ok'}`);
+        }
+        rendered.grids.forEach(({ sketch, part, line }) => { var _a, _b; return console.log(`${(_a = sketch === null || sketch === void 0 ? void 0 : sketch.target) !== null && _a !== void 0 ? _a : ''} ${(_b = sketch === null || sketch === void 0 ? void 0 : sketch.variant) !== null && _b !== void 0 ? _b : ''}: ${part} ${line}`); });
+        rendered.warnings.forEach((issue) => { var _a, _b, _c, _d; return console.warn(`${(_b = (_a = issue.sketch) === null || _a === void 0 ? void 0 : _a.target) !== null && _b !== void 0 ? _b : ''} ${(_d = (_c = issue.sketch) === null || _c === void 0 ? void 0 : _c.variant) !== null && _d !== void 0 ? _d : ''}: WARNING ${(0, render_check_1.renderIssueLineOf)(issue)}`); });
+        rendered.issues.forEach((issue) => { var _a, _b, _c, _d; return console.error(`${(_b = (_a = issue.sketch) === null || _a === void 0 ? void 0 : _a.target) !== null && _b !== void 0 ? _b : ''} ${(_d = (_c = issue.sketch) === null || _c === void 0 ? void 0 : _c.variant) !== null && _d !== void 0 ? _d : ''}: ${(0, render_check_1.renderIssueLineOf)(issue)}`); });
+    }
+    if ('issues' in rendered && rendered.issues.length > 0)
+        return 1;
+    console.log('ok');
+    return 0;
+});
+const previewed = (context) => withSketch(context, ({ product, sketch }) => {
+    const variant = context.args.positional[1];
+    if (!variant || !sketch.variants.includes(variant))
+        return fail(`${sketch.target} has no variant "${variant !== null && variant !== void 0 ? variant : ''}" - it has ${sketch.variants.join(', ')}`);
+    const preview = (0, merge_preview_1.mergePreviewOf)({ product, sketch, variant });
+    if (context.args.flags.has('--json')) {
+        console.log(JSON.stringify(preview, null, 2));
+    }
+    else {
+        console.log(`changes: ${preview.changed.join(', ')}`);
+        console.log(`shows: ${preview.affected.join(', ') || 'no other element or page'}`);
+    }
+    return 0;
+});
+const merged = (context) => withSketch(context, ({ product, sketch }) => {
+    var _a, _b;
+    const note = context.args.values['--note'];
+    if (context.args.positional.length > 1)
+        return fail(`usage: sketch merge <layer>/<name> [--note <reason>] - it merges the variant the user picked`);
+    const result = (0, merge_1.mergeSketch)({
+        target: context.target,
+        config: context.config,
+        product,
+        sketch,
+        note,
+        author: (_a = (0, cli_args_1.authorOf)(context.args)) !== null && _a !== void 0 ? _a : undefined,
+    });
+    if (!Array.isArray(result))
+        return fail(result.reason);
+    const variant = ((_b = sketch.decision) === null || _b === void 0 ? void 0 : _b.kind) === 'pick' ? sketch.decision.variant : '';
+    console.log(`merged ${sketch.target} variant ${variant} into ${product.name}: ${result.join(', ')}`);
+    return 0;
+});
+const discarded = (context) => withSketch(context, ({ sketch }) => {
+    var _a;
+    const problem = (0, merge_1.discardSketch)({ target: context.target, sketch, author: (_a = (0, cli_args_1.authorOf)(context.args)) !== null && _a !== void 0 ? _a : undefined });
+    if (problem)
+        return fail(problem);
+    console.log(`discarded the sketch on ${sketch.target}`);
+    return 0;
+});
+const verdictOriginOf = (by, of) => of && of !== by ? ` (reason by the ${of})` : '';
+/** The verdicts a variant had, oldest first, and whether it is rejected now. */
+const verdictLinesOf = (sketch, variant) => {
+    var _a, _b;
+    const history = (_b = (_a = sketch.rejections) === null || _a === void 0 ? void 0 : _a[variant]) !== null && _b !== void 0 ? _b : [];
+    const lines = history.flatMap((rejection) => [
+        `  rejected by the ${rejection.by} at ${rejection.decidedAt}${verdictOriginOf(rejection.by, rejection.reasonBy)}${rejection.reason ? `: ${rejection.reason}` : ''}`,
+        ...(rejection.reopened
+            ? [
+                `  reopened by the ${rejection.reopened.by} at ${rejection.reopened.decidedAt}${rejection.reopened.reason ? `: ${rejection.reopened.reason}` : ''}`,
+            ]
+            : []),
+    ]);
+    return [`${sketch.target} variant ${variant}: ${(0, sketch_1.rejectionOf)(sketch, variant) ? 'rejected' : 'live'}`, ...lines];
+};
+exports.verdictLinesOf = verdictLinesOf;
+const judged = (kind) => (context) => withSketch(context, ({ sketch }) => {
+    var _a;
+    const { positional, values } = context.args;
+    const variant = values['--variant'];
+    const reason = ((_a = values['--reason']) === null || _a === void 0 ? void 0 : _a.trim()) || undefined;
+    const by = (0, cli_args_1.authorOf)(context.args) === 'designer' ? 'designer' : 'agent';
+    if (positional.length !== 1 || !variant)
+        return fail(`usage: sketch ${kind} <layer>/<name> --variant <key> [--reason <text>] --by <model id | designer> [--product <name>]`);
+    const decision = kind === 'reject' && reason && (0, sketch_1.rejectionOf)(sketch, variant)
+        ? { kind: 'reason', variant, reason, by }
+        : Object.assign(Object.assign({ kind, variant }, (reason ? { reason } : {})), { by });
+    const decided = (0, sketch_1.decideSketch)({ sketch, decision });
+    if (typeof decided === 'string')
+        return fail(decided);
+    (0, exports.verdictLinesOf)(decided, variant).forEach((line) => console.log(line));
+    return 0;
+});
+const COMMANDS = {
+    new: created,
+    variant: varied,
+    round: roundEdited,
+    list: listed,
+    report: reported,
+    ready: readied,
+    check: checked,
+    preview: previewed,
+    rebase: rebased,
+    merge: merged,
+    discard: discarded,
+    reject: judged('reject'),
+    reopen: judged('reopen'),
+};
+/**
+ * `et design sketch <command> …` opens, adds variants to, reports on, readies, checks, previews, rebases, merges and
+ * discards sketches, and rejects and reopens their variants.
+ */
+const designSketch = (options) => {
+    const { target, argv, invocation } = options;
+    const [command = '', ...rest] = argv;
+    const run = COMMANDS[command];
+    const args = (0, cli_args_1.argsOf)(rest, [
+        '--product',
+        '--variants',
+        '--note',
+        '--variant',
+        '--by',
+        '--from',
+        '--round',
+        '--round-note',
+        '--title',
+        '--like',
+        '--drops',
+        '--variant-note',
+        '--reason',
+    ]);
+    const unauthored = typeof args !== 'string' && WRITES.has(command) && (0, cli_args_1.authorOf)(args) === null;
+    if (!run || typeof args === 'string' || unauthored) {
+        if (typeof args === 'string')
+            console.error(args);
+        if (!run)
+            console.error(`unknown sketch command "${command}"`);
+        if (unauthored)
+            console.error(`sketch ${command} ${cli_args_1.NEEDS_AUTHOR}`);
+        console.error(exports.SKETCH_USAGE.map((line) => `usage: ${invocation} ${line}`).join('\n'));
+        return 2;
+    }
+    const config = (0, cli_args_1.configOf)(target);
+    if (typeof config === 'string')
+        return fail(config);
+    return run({ target, config, args });
+};
+exports.designSketch = designSketch;
+//# sourceMappingURL=sketch-command.js.map