@magland/mochi 0.3.1

package/dist/cli/parse.js

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandHelp = commandHelp;
+exports.groupHelp = groupHelp;
+exports.rootHelp = rootHelp;
+exports.registryJson = registryJson;
+exports.dispatch = dispatch;
+const exit_1 = require("./exit");
+function usageError(message) {
+    throw new exit_1.CliError(message, exit_1.EXIT_USAGE);
+}
+// ---- suggestions ----
+function editDistance(a, b) {
+    const prev = new Array(b.length + 1).fill(0).map((_, i) => i);
+    const cur = new Array(b.length + 1).fill(0);
+    for (let i = 1; i <= a.length; i++) {
+        cur[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        for (let j = 0; j <= b.length; j++)
+            prev[j] = cur[j];
+    }
+    return prev[b.length];
+}
+/** The closest of `among` to `word`, when something is within two edits of it. */
+function nearest(word, among) {
+    let best = null;
+    let bestD = 3;
+    for (const c of among) {
+        const d = editDistance(word, c);
+        if (d < bestD) {
+            bestD = d;
+            best = c;
+        }
+    }
+    return best;
+}
+// ---- option lookup ----
+function findOption(cmd, name) {
+    return (cmd.options ?? []).find((o) => o.name === name) ?? null;
+}
+function findShort(cmd, letter) {
+    return (cmd.options ?? []).find((o) => o.short === letter) ?? null;
+}
+// A field list is how a 'string?' option's value is recognised when it is not
+// attached with '='. Requiring a comma is what keeps `repo list --json mycoll`
+// from swallowing the collection: a single field must be written
+// `--json=title`, which the option's help says.
+function looksLikeFieldList(token) {
+    return /^[A-Za-z][A-Za-z0-9_]*(,[A-Za-z][A-Za-z0-9_]*)+$/.test(token);
+}
+function parseOptions(cmd, argv) {
+    const values = new Map();
+    const args = [];
+    const names = (cmd.options ?? []).filter((o) => !o.hidden).map((o) => o.name);
+    const take = (spec, inline, argv, i) => {
+        let value;
+        if (inline !== undefined)
+            value = inline;
+        else if (i + 1 < argv.length)
+            value = argv[++i];
+        else
+            usageError(`--${spec.name} needs a value${spec.value ? `: --${spec.name} ${spec.value}` : ''}`);
+        if (spec.type === 'string[]') {
+            const list = values.get(spec.name) ?? [];
+            list.push(value);
+            values.set(spec.name, list);
+        }
+        else if (spec.type === 'int') {
+            const n = Number(value);
+            if (!Number.isInteger(n))
+                usageError(`--${spec.name} takes a whole number, not '${value}'`);
+            values.set(spec.name, n);
+        }
+        else {
+            values.set(spec.name, value);
+        }
+        return i;
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--') {
+            args.push(...argv.slice(i + 1));
+            break;
+        }
+        if (a.startsWith('--')) {
+            const eq = a.indexOf('=');
+            const name = eq === -1 ? a.slice(2) : a.slice(2, eq);
+            const inline = eq === -1 ? undefined : a.slice(eq + 1);
+            const spec = findOption(cmd, name);
+            if (!spec) {
+                const near = nearest(name, names);
+                usageError(`unknown option --${name} for '${cmd.path.join(' ')}'` +
+                    (near ? `; did you mean --${near}?` : `. Run 'mochi ${cmd.path.join(' ')} --help'.`));
+            }
+            if (spec.type === 'boolean') {
+                if (inline !== undefined)
+                    usageError(`--${name} takes no value`);
+                values.set(name, true);
+            }
+            else if (spec.type === 'string?') {
+                if (inline !== undefined)
+                    values.set(name, inline);
+                else if (i + 1 < argv.length && !argv[i + 1].startsWith('-') && looksLikeFieldList(argv[i + 1])) {
+                    values.set(name, argv[++i]);
+                }
+                else
+                    values.set(name, true);
+            }
+            else {
+                i = take(spec, inline, argv, i);
+            }
+            continue;
+        }
+        // A lone '-' is a positional: several options take it to mean stdin.
+        if (a.startsWith('-') && a.length > 1) {
+            const spec = findShort(cmd, a.slice(1));
+            if (!spec)
+                usageError(`unknown option ${a} for '${cmd.path.join(' ')}'. Run 'mochi ${cmd.path.join(' ')} --help'.`);
+            if (spec.type === 'boolean')
+                values.set(spec.name, true);
+            else
+                i = take(spec, undefined, argv, i);
+            continue;
+        }
+        args.push(a);
+    }
+    return { values, args };
+}
+function checkArgs(cmd, args) {
+    const specs = cmd.args ?? [];
+    const required = specs.filter((s) => s.required).length;
+    if (args.length < required) {
+        usageError(`'mochi ${cmd.path.join(' ')}' needs ${usageLine(cmd)}`);
+    }
+    const variadic = specs.some((s) => s.variadic);
+    if (!variadic && args.length > specs.length) {
+        usageError(`unexpected argument '${args[specs.length]}' to 'mochi ${cmd.path.join(' ')}'`);
+    }
+}
+function invocationFor(cli, cmd, argv) {
+    const { values, args } = cmd.raw ? { values: new Map(), args: [] } : parseOptions(cmd, argv);
+    if (!cmd.raw)
+        checkArgs(cmd, args);
+    if (values.has('json'))
+        (0, exit_1.setJsonErrors)(true);
+    return {
+        args,
+        argv,
+        help: () => {
+            process.stdout.write(commandHelp(cli, cmd));
+            process.exit(0);
+        },
+        str: (name) => {
+            const v = values.get(name);
+            return typeof v === 'string' ? v : null;
+        },
+        int: (name) => {
+            const v = values.get(name);
+            return typeof v === 'number' ? v : null;
+        },
+        bool: (name) => values.get(name) === true,
+        list: (name) => {
+            const v = values.get(name);
+            return Array.isArray(v) ? v : [];
+        },
+        optional: (name) => {
+            const v = values.get(name);
+            if (typeof v === 'string')
+                return v;
+            return v === true;
+        },
+    };
+}
+// ---- help ----
+function usageLine(cmd) {
+    return (cmd.args ?? [])
+        .map((a) => (a.required ? `<${a.name}>` : `[<${a.name}>]`) + (a.variadic ? '...' : ''))
+        .join(' ');
+}
+function optionLine(o) {
+    const short = o.short ? `-${o.short}, ` : '';
+    const value = o.type === 'boolean' ? '' : ` ${o.value ?? '<value>'}`;
+    const repeat = o.type === 'string[]' ? '...' : '';
+    return `${short}--${o.name}${value}${repeat}`;
+}
+function pad(rows, indent = '  ') {
+    const width = rows.reduce((w, [left]) => Math.max(w, left.length), 0);
+    return rows.map(([left, right]) => `${indent}${left.padEnd(width)}  ${right}\n`).join('');
+}
+function commandHelp(cli, cmd) {
+    const args = usageLine(cmd);
+    let out = `Usage: ${cli.name} ${cmd.path.join(' ')}${args ? ' ' + args : ''}${cmd.options?.length ? ' [options]' : ''}\n`;
+    out += `\n${cmd.summary}\n`;
+    if (cmd.description)
+        out += `\n${cmd.description.trim()}\n`;
+    const shown = (cmd.options ?? []).filter((o) => !o.hidden);
+    if (shown.length) {
+        out += '\nOptions:\n';
+        out += pad(shown.map((o) => [optionLine(o), o.summary]));
+    }
+    return out;
+}
+function groupHelp(cli, group) {
+    const commands = cli.commands.filter((c) => c.path.length > 1 && c.path[0] === group);
+    const summary = cli.groups.find((g) => g.name === group)?.summary ?? '';
+    let out = `Usage: ${cli.name} ${group} <command>\n`;
+    if (summary)
+        out += `\n${summary}\n`;
+    out += '\nCommands:\n';
+    out += pad(commands.map((c) => [c.path.slice(1).join(' '), c.summary]));
+    out += `\nRun '${cli.name} ${group} <command> --help' for one command's options.\n`;
+    return out;
+}
+function rootHelp(cli) {
+    let out = `Usage: ${cli.name} <command> [options]\n`;
+    const groups = cli.groups.filter((g) => cli.commands.some((c) => c.path.length > 1 && c.path[0] === g.name));
+    const singles = cli.commands.filter((c) => c.path.length === 1);
+    if (singles.length) {
+        out += '\nCommands:\n';
+        out += pad(singles.map((c) => [c.path[0], c.summary]));
+    }
+    if (groups.length) {
+        out += '\nCommand groups:\n';
+        out += pad(groups.map((g) => [g.name, g.summary]));
+    }
+    out += `\nRun '${cli.name} <group> --help' for a group's commands, or '${cli.name} <command> --help'\n`;
+    out += `for one command's options. '${cli.name} commands --json' dumps the whole command set.\n`;
+    if (cli.footer)
+        out += `\n${cli.footer.trim()}\n`;
+    return out;
+}
+/** The registry as data, for a caller that would rather not read help text. */
+function registryJson(cli) {
+    return {
+        name: cli.name,
+        commands: cli.commands.map((c) => ({
+            path: c.path,
+            summary: c.summary,
+            args: (c.args ?? []).map((a) => ({ name: a.name, required: !!a.required, variadic: !!a.variadic })),
+            options: (c.options ?? [])
+                .filter((o) => !o.hidden)
+                .map((o) => ({ name: o.name, type: o.type, summary: o.summary, short: o.short ?? null })),
+            raw: !!c.raw,
+        })),
+    };
+}
+// ---- dispatch ----
+const HELP_FLAGS = new Set(['-h', '--help', 'help']);
+function wantsHelp(argv) {
+    for (const a of argv) {
+        if (a === '--')
+            return false;
+        if (a === '-h' || a === '--help')
+            return true;
+    }
+    return false;
+}
+/**
+ * Resolve argv against the registry and run what it names. Every failure is a
+ * CliError, so the caller decides how to report it; nothing here writes to
+ * stderr or exits, apart from the help paths.
+ */
+async function dispatch(cli, argv) {
+    if (argv.length === 0 || (argv.length === 1 && HELP_FLAGS.has(argv[0]))) {
+        process.stdout.write(rootHelp(cli));
+        return;
+    }
+    // The longest matching path wins, so a two-word command is found before the
+    // one-word command that shares its first word could shadow it.
+    let found = null;
+    let depth = 0;
+    for (const cmd of cli.commands) {
+        if (cmd.path.length > argv.length)
+            continue;
+        if (cmd.path.every((seg, i) => argv[i] === seg) && cmd.path.length > depth) {
+            found = cmd;
+            depth = cmd.path.length;
+        }
+    }
+    if (!found) {
+        const head = argv[0];
+        if (cli.groups.some((g) => g.name === head) || cli.commands.some((c) => c.path[0] === head)) {
+            // A known group with an unknown or missing subcommand. Listed by their
+            // whole path below the group, since a group may nest ('deploy fly show'),
+            // and deduplicated: several such commands share one second word.
+            const under = cli.commands.filter((c) => c.path[0] === head && c.path.length > 1);
+            const subs = [...new Set(under.map((c) => c.path.slice(1).join(' ')))];
+            const sub = argv[1];
+            if (sub === undefined || HELP_FLAGS.has(sub)) {
+                process.stdout.write(groupHelp(cli, head));
+                if (sub === undefined)
+                    throw new exit_1.CliError(`'mochi ${head}' needs a command: ${subs.join(', ')}`, exit_1.EXIT_USAGE);
+                return;
+            }
+            // A group may nest twice ('user token list'), so a second word that names
+            // one of those is a group in its own right rather than a misspelling.
+            const deeper = under.filter((c) => c.path.length > 2 && c.path[1] === sub);
+            if (deeper.length && argv[2] === undefined) {
+                throw new exit_1.CliError(`'mochi ${head} ${sub}' needs a command: ${[...new Set(deeper.map((c) => c.path[2]))].join(', ')}`, exit_1.EXIT_USAGE);
+            }
+            // What was typed is one word, so it is compared against single words.
+            const near = nearest(sub, [...new Set(under.map((c) => c.path[1]))]);
+            throw new exit_1.CliError(`unknown command 'mochi ${head} ${sub}'` + (near ? `; did you mean '${head} ${near}'?` : `. One of: ${subs.join(', ')}`), exit_1.EXIT_USAGE);
+        }
+        const tops = [...new Set([...cli.groups.map((g) => g.name), ...cli.commands.map((c) => c.path[0])])];
+        const near = nearest(head, tops);
+        throw new exit_1.CliError(`unknown command '${head}'` + (near ? `; did you mean '${near}'?` : ". Run 'mochi --help'."), exit_1.EXIT_USAGE);
+    }
+    const rest = argv.slice(depth);
+    if (wantsHelp(rest)) {
+        process.stdout.write(commandHelp(cli, found));
+        return;
+    }
+    await found.run(invocationFor(cli, found, rest));
+}

package/dist/cli/pr-cmd.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prCommands = void 0;
+const cli_api_1 = require("../cli-api");
+const exit_1 = require("./exit");
+const input_1 = require("./input");
+const output_1 = require("./output");
+const repo_1 = require("./repo");
+const target_1 = require("./target");
+// The pull request commands. `pr merge` and `pr checks` are the two with
+// something to say beyond the shape of the API underneath.
+const COMMON = [repo_1.REPO_OPTION, ...target_1.TARGET_OPTIONS];
+const BODY_OPTIONS = [
+    { name: 'body', type: 'string', value: '<b>', summary: 'Body text' },
+    { name: 'body-file', type: 'string', value: '<f>', summary: "Read the body from a file, or '-' for stdin" },
+];
+async function bodyOf(inv, required = false) {
+    const inline = inv.str('body');
+    const file = inv.str('body-file');
+    if (inline !== null && file !== null)
+        throw new exit_1.CliError('Pass either --body or --body-file, not both.', exit_1.EXIT_USAGE);
+    if (file !== null)
+        return await (0, input_1.readFileArg)(file);
+    if (inline !== null)
+        return inline;
+    if (required)
+        throw new exit_1.CliError('A body is required: pass --body <text> or --body-file <path>.', exit_1.EXIT_USAGE);
+    return undefined;
+}
+function pullRef(inv) {
+    const raw = inv.args[0] ?? '';
+    if (!/^[1-9][0-9]*$/.test(raw))
+        throw new exit_1.CliError(`'${raw}' is not a pull request number`, exit_1.EXIT_USAGE);
+    return parseInt(raw, 10);
+}
+exports.prCommands = [
+    {
+        path: ['pr', 'list'],
+        summary: 'List pull requests',
+        options: [
+            { name: 'state', type: 'string', value: '<s>', summary: 'open (default), closed, merged, or all' },
+            { name: 'limit', type: 'int', value: '<n>', summary: 'At most this many' },
+            output_1.JSON_OPTION,
+            ...COMMON,
+        ],
+        async run(inv) {
+            const target = await (0, target_1.targetFrom)(inv);
+            const ref = await (0, repo_1.resolveRepo)(inv, target);
+            const query = new URLSearchParams();
+            const state = inv.str('state');
+            if (state !== null)
+                query.set('state', state);
+            const limit = inv.int('limit');
+            if (limit !== null)
+                query.set('limit', String(limit));
+            const data = await (0, cli_api_1.api)(target, 'GET', `${(0, repo_1.repoPath)(ref)}/pulls?${query.toString()}`);
+            const pulls = (data.pulls ?? []);
+            const json = (0, output_1.jsonMode)(inv);
+            if (json.enabled) {
+                (0, output_1.printJson)({ pulls: (0, output_1.pickFields)(pulls, json.fields) });
+                return;
+            }
+            if (pulls.length === 0) {
+                console.log(`No pull requests in ${ref.collection}/${ref.repo}`);
+                return;
+            }
+            (0, output_1.printTable)(pulls.map((p) => [
+                `#${p.number}`,
+                String(p.state),
+                String(p.title),
+                `${p.head} -> ${p.base}`,
+                String(p.author),
+                (0, output_1.shortDate)(p.updated),
+            ]));
+        },
+    },
+    {
+        path: ['pr', 'view'],
+        summary: 'Show one pull request, with its comments',
+        args: [{ name: 'number', required: true }],
+        options: [
+            { name: 'comments', type: 'boolean', summary: 'Print the comments in full (implied by --json)' },
+            output_1.JSON_OPTION,
+            ...COMMON,
+        ],
+        async run(inv) {
+            const target = await (0, target_1.targetFrom)(inv);
+            const ref = await (0, repo_1.resolveRepo)(inv, target);
+            const data = await (0, cli_api_1.api)(target, 'GET', `${(0, repo_1.repoPath)(ref)}/pulls/${pullRef(inv)}`);
+            const json = (0, output_1.jsonMode)(inv);
+            if (json.enabled) {
+                (0, output_1.printJson)((0, output_1.pickObject)(data, json.fields));
+                return;
+            }
+            console.log(`#${data.number} ${data.title}`);
+            console.log(`${data.state} - ${data.head} into ${data.base}, opened by ${data.author} on ${(0, output_1.shortDate)(data.created)}`);
+            if (data.mergeSha)
+                console.log(`merged by ${data.mergedBy} as ${String(data.mergeSha).slice(0, 10)}`);
+            console.log('');
+            console.log(String(data.body ?? '').trimEnd());
+            const comments = (data.commentList ?? []);
+            if (comments.length && inv.bool('comments')) {
+                for (const c of comments) {
+                    console.log('');
+                    console.log(`--- ${c.author} on ${(0, output_1.shortDate)(c.created)}`);
+                    console.log(String(c.body ?? '').trimEnd());
+                }
+            }
+            else if (comments.length) {
+                console.log('');
+                console.log(`(${comments.length} comment${comments.length === 1 ? '' : 's'}; --comments shows them)`);
+            }
+        },
+    },
+    {
+        path: ['pr', 'create'],
+        summary: 'Open a pull request',
+        options: [
+            { name: 'base', type: 'string', value: '<b>', summary: 'Branch to merge into' },
+            { name: 'head', type: 'string', value: '<h>', summary: 'Branch to merge from' },
+            { name: 'title', type: 'string', value: '<t>', summary: 'Title' },
+            ...BODY_OPTIONS,
+            output_1.JSON_OPTION,
+            ...COMMON,
+        ],
+        async run(inv) {
+            const base = inv.str('base');
+            const head = inv.str('head');
+            const title = inv.str('title');
+            if (base === null || head === null || title === null) {
+                throw new exit_1.CliError('--base, --head, and --title are all required', exit_1.EXIT_USAGE);
+            }
+            const target = await (0, target_1.targetFrom)(inv);
+            const ref = await (0, repo_1.resolveRepo)(inv, target);
+            const data = await (0, cli_api_1.api)(target, 'POST', `${(0, repo_1.repoPath)(ref)}/pulls`, {
+                base,
+                head,
+                title,
+                body: (await bodyOf(inv)) ?? '',
+            });
+            const json = (0, output_1.jsonMode)(inv);
+            if (json.enabled) {
+                (0, output_1.printJson)((0, output_1.pickObject)(data, json.fields));
+                return;
+            }
+            console.log(`${target.host}/${ref.collection}/${ref.repo}/pulls/${data.number}`);
+        },
+    },
+    {
+        path: ['pr', 'diff'],
+        summary: 'Print the diff a pull request proposes',
+        args: [{ name: 'number', required: true }],
+        options: [output_1.JSON_OPTION, ...COMMON],
+        async run(inv) {
+            const target = await (0, target_1.targetFrom)(inv);
+            const ref = await (0, repo_1.resolveRepo)(inv, target);
+            const data = await (0, cli_api_1.api)(target, 'GET', `${(0, repo_1.repoPath)(ref)}/pulls/${pullRef(inv)}/diff`);
+            const json = (0, output_1.jsonMode)(inv);
+            if (json.enabled) {
+                (0, output_1.printJson)((0, output_1.pickObject)(data, json.fields));
+                return;
+            }
+            process.stdout.write(String(data.patch ?? ''));
+        },
+    },
+    {
+        path: ['pr', 'comment'],
+        summary: 'Add a comment to a pull request',
+        args: [{ name: 'number', required: true }],
+        options: [...BODY_OPTIONS, output_1.JSON_OPTION, ...COMMON],
+        async run(inv) {
+            const target = await (0, target_1.targetFrom)(inv);
+            const ref = await (0, repo_1.resolveRepo)(inv, target);
+            const n = pullRef(inv);
+            const data = await (0, cli_api_1.api)(target, 'POST', `${(0, repo_1.repoPath)(ref)}/pulls/${n}/comments`, { body: await bodyOf(inv, true) });
+            const json = (0, output_1.jsonMode)(inv);
+            if (json.enabled) {
+                (0, output_1.printJson)((0, output_1.pickObject)(data, json.fields));
+                return;
+            }
+            console.log(`Commented on #${n}`);
+        },
+    },
+    {
+        path: ['pr', 'merge'],
+        summary: 'Merge a pull request',
+        description: `Without --squash the merge keeps both parents, which is the record of where the
+work came from. A conflict is reported with the conflicting paths and exits 5, so
+a caller can tell "it does not apply" from "it went wrong".
+
+Whether it would apply can be asked without merging anything, which is the read
+worth making first:
+
+  mochi api repos/<collection>/<repo>/pulls/<n>/merge`,
+        args: [{ name: 'number', required: true }],
+        options: [
+            { name: 'squash', type: 'boolean', summary: 'One commit on the base rather than a merge commit' },
+            { name: 'delete-branch', type: 'boolean', summary: 'Delete the head branch afterwards' },
+            { name: 'message', type: 'string', value: '<m>', summary: 'Commit message; a default is built if omitted' },
+            output_1.JSON_OPTION,
+            ...COMMON,
+        ],
+        async run(inv) {
+            const target = await (0, target_1.targetFrom)(inv);
+            const ref = await (0, repo_1.resolveRepo)(inv, target);
+            const n = pullRef(inv);
+            const path = `${(0, repo_1.repoPath)(ref)}/pulls/${n}/merge`;
+            const r = await (0, cli_api_1.apiTry)(target, 'POST', path, {
+                method: inv.bool('squash') ? 'squash' : 'merge',
+                message: inv.str('message') ?? undefined,
+                deleteBranch: inv.bool('delete-branch'),
+            });
+            const json = (0, output_1.jsonMode)(inv);
+            if (!r.ok) {
+                // The conflicting paths are the useful part of a refusal, so they are
+                // printed rather than swallowed by a one-line error.
+                if (json.enabled) {
+                    process.stderr.write(JSON.stringify(r.data) + '\n');
+                }
+                else {
+                    console.error(String(r.data.error ?? `HTTP ${r.status}`));
+                    for (const p of (r.data.conflicts ?? []))
+                        console.error(`  conflict: ${p}`);
+                }
+                process.exit(Array.isArray(r.data.conflicts) ? exit_1.EXIT_CONFLICT : (0, exit_1.exitCodeForStatus)(r.status));
+            }
+            if (json.enabled) {
+                (0, output_1.printJson)((0, output_1.pickObject)(r.data, json.fields));
+                return;
+            }
+            console.log(`Merged #${n} as ${String(r.data.sha).slice(0, 10)}`);
+            if (r.data.branchDeleted)
+                console.log('and deleted the head branch');
+        },
+    },
+    {
+        path: ['pr', 'checks'],
+        summary: 'Workflow runs whose commit is this pull request head',
+        description: `mochi has no equivalent of a check suite or a commit status, so there is
+nothing behind this but the runs whose sha matches the pull request's head
+commit. That is what this reports, and it is worth knowing that is what it means.`,
+        args: [{ name: 'number', required: true }],
+        options: [output_1.JSON_OPTION, ...COMMON],
+        async run(inv) {
+            const target = await (0, target_1.targetFrom)(inv);
+            const ref = await (0, repo_1.resolveRepo)(inv, target);
+            const n = pullRef(inv);
+            const commits = await (0, cli_api_1.api)(target, 'GET', `${(0, repo_1.repoPath)(ref)}/pulls/${n}/commits`);
+            const head = (commits.commits ?? [])[0];
+            const sha = head ? String(head.sha) : null;
+            const runs = await (0, cli_api_1.api)(target, 'GET', `${(0, repo_1.repoPath)(ref)}/runs?limit=100`);
+            const matching = (runs.runs ?? []).filter((r) => sha !== null && r.sha === sha);
+            const json = (0, output_1.jsonMode)(inv);
+            if (json.enabled) {
+                (0, output_1.printJson)({ sha, runs: (0, output_1.pickFields)(matching, json.fields) });
+                return;
+            }
+            if (!sha) {
+                console.log('This pull request has no commits, so there is nothing to have run.');
+                return;
+            }
+            if (matching.length === 0) {
+                console.log(`No workflow runs for ${sha.slice(0, 10)}`);
+                return;
+            }
+            (0, output_1.printTable)(matching.map((r) => [`#${r.number}`, String(r.status), String(r.conclusion ?? ''), String(r.workflowName ?? r.workflow ?? '')]));
+        },
+    },
+    ...['close', 'reopen'].map((verb) => ({
+        path: ['pr', verb],
+        summary: verb === 'close' ? 'Close a pull request without merging it' : 'Reopen a closed pull request',
+        args: [{ name: 'number', required: true }],
+        options: [output_1.JSON_OPTION, ...COMMON],
+        async run(inv) {
+            const target = await (0, target_1.targetFrom)(inv);
+            const ref = await (0, repo_1.resolveRepo)(inv, target);
+            const n = pullRef(inv);
+            const data = await (0, cli_api_1.api)(target, 'POST', `${(0, repo_1.repoPath)(ref)}/pulls/${n}/state`, {
+                state: verb === 'close' ? 'closed' : 'open',
+            });
+            const json = (0, output_1.jsonMode)(inv);
+            if (json.enabled) {
+                (0, output_1.printJson)((0, output_1.pickObject)(data, json.fields));
+                return;
+            }
+            console.log(`#${n} is now ${data.state}`);
+        },
+    })),
+];