@get-dx/cli 0.1.0

package/dist/commands/scorecards.js

@@ -0,0 +1,480 @@
+import fs from "fs";
+import { Command } from "commander";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { createExampleText, getContext, parsePositiveIntOption, wrapAction, } from "../commandHelpers.js";
+import { CliError, EXIT_CODES, HttpError } from "../errors.js";
+import { request } from "../http.js";
+import { renderJson, renderRichText } from "../renderers.js";
+import { buildRuntime } from "../runtime.js";
+import * as ui from "../ui.js";
+import { renderScorecard, renderScorecardList } from "./scorecardsRendering.js";
+export function scorecardsCommand() {
+    const scorecards = new Command()
+        .name("scorecards")
+        .description("Manage scorecards");
+    scorecards
+        .command("create")
+        .description("Create a new scorecard from a YAML file or stdin. The `init` command can be used to generate a starting template.")
+        .option("--from-file <path>", "Read a YAML file and create a scorecard from its contents")
+        .option("--from-stdin", "Read YAML from stdin and create a scorecard from its contents")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Generate a blank template first",
+            command: "dx scorecards init ./my-scorecard.yaml",
+        },
+        {
+            label: "Create a scorecard from a YAML file",
+            command: "dx scorecards create --from-file ./my-scorecard.yaml",
+        },
+        {
+            label: "Create a scorecard from stdin",
+            command: "cat ./my-scorecard.yaml | dx scorecards create --from-stdin",
+        },
+    ]))
+        .action(wrapAction(async (options, command) => {
+        const modeCount = [options.fromFile, options.fromStdin].filter(Boolean).length;
+        if (modeCount === 0) {
+            throw new CliError("One of --from-file or --from-stdin is required", EXIT_CODES.ARGUMENT_ERROR);
+        }
+        if (modeCount > 1) {
+            throw new CliError("--from-file and --from-stdin are mutually exclusive", EXIT_CODES.ARGUMENT_ERROR);
+        }
+        const runtime = buildRuntime(getContext(command));
+        let raw;
+        if (options.fromFile) {
+            raw = readYamlFile(options.fromFile);
+        }
+        else {
+            raw = await readYamlStdin();
+        }
+        const payload = buildCreatePayload(raw);
+        const response = await createScorecard(runtime, payload);
+        if (runtime.context.json) {
+            renderJson({ ok: true, scorecard: response.scorecard });
+        }
+        else {
+            renderScorecard(response.scorecard, null, `${ui.success(ui.GLYPHS.CHECK)} Scorecard created`);
+        }
+    }));
+    scorecards
+        .command("delete")
+        .description("Delete a scorecard")
+        .argument("<id>", "The unique ID of the scorecard")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Delete a scorecard",
+            command: "dx scorecards delete pht2wuldvjcb",
+        },
+        {
+            label: "Delete a scorecard and return JSON",
+            command: "dx scorecards delete pht2wuldvjcb --json",
+        },
+    ]))
+        .action(wrapAction(async (id, _options, command) => {
+        const runtime = buildRuntime(getContext(command));
+        await deleteScorecard(runtime, id);
+        if (runtime.context.json) {
+            renderJson({ ok: true });
+        }
+        else {
+            renderRichText([
+                ui.p(`${ui.success(ui.GLYPHS.CHECK)} Scorecard deleted`),
+            ]);
+        }
+    }));
+    scorecards
+        .command("info")
+        .description("Retrieve details about a specific scorecard, including its defined levels and checks")
+        .argument("<id>", "The unique ID of the scorecard")
+        .option("--include <include>", "Show only these comma-separated sections: core, owners, checks")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Fetch info for a scorecard",
+            command: "dx scorecards info qjfj1a6cmit4",
+        },
+        {
+            label: "Fetch scorecard info and return as JSON",
+            command: "dx scorecards info qjfj1a6cmit4 --json",
+        },
+        {
+            label: "Fetch only the core fields and checks",
+            command: "dx scorecards info qjfj1a6cmit4 --include core,checks",
+        },
+    ]))
+        .action(wrapAction(async (id, options, command) => {
+        const includeSections = parseScorecardIncludeSections(options.include);
+        const runtime = buildRuntime(getContext(command));
+        const response = await getScorecard(runtime, id);
+        if (runtime.context.json) {
+            const processedScorecard = processScorecardIncludes(response.scorecard, includeSections);
+            renderJson({ ok: true, scorecard: processedScorecard });
+        }
+        else {
+            renderScorecard(response.scorecard, includeSections);
+        }
+    }));
+    scorecards
+        .command("init")
+        .description("Write a scorecard YAML file, either from an existing scorecard or as a blank template")
+        .argument("<path>", "File path to write the YAML to")
+        .option("--id <id>", "Fetch an existing scorecard and use it as the template")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Write a blank scorecard template",
+            command: "dx scorecards init ./my-scorecard.yaml",
+        },
+        {
+            label: "Initialize from an existing scorecard",
+            command: "dx scorecards init ./my-scorecard.yaml --id qjfj1a6cmit4",
+        },
+    ]))
+        .action(wrapAction(async (path, options, command) => {
+        const runtime = buildRuntime(getContext(command));
+        if (options.id) {
+            const id = options.id;
+            let scorecardResponse;
+            try {
+                scorecardResponse = await getScorecard(runtime, id);
+            }
+            catch (err) {
+                const exitCode = err instanceof HttpError &&
+                    err.status !== undefined &&
+                    err.status < 500
+                    ? EXIT_CODES.ARGUMENT_ERROR
+                    : EXIT_CODES.RETRY_RECOMMENDED;
+                throw new CliError(`Failed to fetch scorecard "${id}": ${err instanceof Error ? err.message : String(err)}`, exitCode);
+            }
+            const yaml = scorecardToYaml(scorecardResponse.scorecard);
+            fs.writeFileSync(path, yaml, "utf8");
+            if (runtime.context.json) {
+                renderJson({ ok: true, id, path });
+            }
+            else {
+                renderRichText([
+                    ui.p(`${ui.success(ui.GLYPHS.CHECK)} Scorecard written to ${ui.code(path)}.`),
+                    ui.p(`Edit the file, then run: ${ui.code(`dx scorecards update ${id} --from-file ${path}`)}`),
+                ]);
+            }
+        }
+        else {
+            fs.writeFileSync(path, SCORECARD_BLANK_TEMPLATE_YAML, "utf8");
+            if (runtime.context.json) {
+                renderJson({ ok: true, path });
+            }
+            else {
+                renderRichText([
+                    ui.p(`${ui.success(ui.GLYPHS.CHECK)} Blank template written to ${ui.code(path)}.`),
+                    ui.p(`Edit the file, then run: ${ui.code(`dx scorecards create --from-file ${path}`)}`),
+                ]);
+            }
+        }
+    }));
+    scorecards
+        .command("list")
+        .description("List scorecards")
+        .option("--cursor <cursor>", "Cursor for the next page of results")
+        .option("--limit <n>", "Max scorecards per page (default is 50)", (value) => parsePositiveIntOption(value, "--limit"))
+        .option("--include-unpublished", "Include draft scorecards in addition to published ones")
+        .option("--include <include>", "Show only these comma-separated sections: core, owners, checks")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "List all published scorecards",
+            command: "dx scorecards list",
+        },
+        {
+            label: "List scorecards including drafts",
+            command: "dx scorecards list --include-unpublished",
+        },
+        {
+            label: "List with a limit and return JSON",
+            command: "dx scorecards list --limit 10 --json",
+        },
+        {
+            label: "Fetch the next page using a cursor from the prior response",
+            command: "dx scorecards list --cursor xuvkgfq9t0ty",
+        },
+        {
+            label: "List scorecards showing only core fields",
+            command: "dx scorecards list --include core",
+        },
+    ]))
+        .action(wrapAction(async (options, command) => {
+        const includeSections = parseScorecardIncludeSections(options.include);
+        const runtime = buildRuntime(getContext(command));
+        const response = await listScorecards(runtime, {
+            cursor: options.cursor,
+            limit: options.limit,
+            include_unpublished: options.includeUnpublished,
+        });
+        if (runtime.context.json) {
+            const processedScorecards = response.scorecards.map((sc) => processScorecardIncludes(sc, includeSections));
+            renderJson({ ...response, scorecards: processedScorecards });
+        }
+        else {
+            renderScorecardList(response.scorecards, response.response_metadata?.next_cursor ?? null, includeSections);
+        }
+    }));
+    scorecards
+        .command("update")
+        .description("Update an existing scorecard from a YAML file or stdin. The `init` command can be used to initialize the scorecard file.")
+        .argument("<id>", "The unique ID of the scorecard")
+        .option("--from-file <path>", "Read a YAML file and update the scorecard with its contents")
+        .option("--from-stdin", "Read YAML from stdin and update the scorecard with its contents")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Initialize a file first",
+            command: "dx scorecards init ./my-scorecard.yaml --id qjfj1a6cmit4",
+        },
+        {
+            label: "Update a scorecard from a YAML file",
+            command: "dx scorecards update qjfj1a6cmit4 --from-file ./my-scorecard.yaml",
+        },
+        {
+            label: "Update a scorecard from stdin",
+            command: "cat ./my-scorecard.yaml | dx scorecards update qjfj1a6cmit4 --from-stdin",
+        },
+    ]))
+        .action(wrapAction(async (id, options, command) => {
+        const modeCount = [options.fromFile, options.fromStdin].filter(Boolean).length;
+        if (modeCount === 0) {
+            throw new CliError("One of --from-file or --from-stdin is required", EXIT_CODES.ARGUMENT_ERROR);
+        }
+        if (modeCount > 1) {
+            throw new CliError("--from-file and --from-stdin are mutually exclusive", EXIT_CODES.ARGUMENT_ERROR);
+        }
+        const runtime = buildRuntime(getContext(command));
+        let raw;
+        if (options.fromFile) {
+            raw = readYamlFile(options.fromFile);
+        }
+        else {
+            raw = await readYamlStdin();
+        }
+        const payload = buildUpdatePayload(id, raw);
+        const response = await updateScorecard(runtime, payload);
+        if (runtime.context.json) {
+            renderJson({ ok: true, scorecard: response.scorecard });
+        }
+        else {
+            renderScorecard(response.scorecard, null, `${ui.success(ui.GLYPHS.CHECK)} Scorecard updated`);
+        }
+    }));
+    return scorecards;
+}
+export async function deleteScorecard(runtime, id) {
+    const response = await request(runtime, "/scorecards.delete", {
+        method: "POST",
+        query: { id },
+    });
+    return response.body;
+}
+export async function createScorecard(runtime, payload) {
+    const response = await request(runtime, "/scorecards.create", {
+        method: "POST",
+        body: payload,
+    });
+    return response.body;
+}
+function buildCreatePayload(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new CliError("YAML content must be an object", EXIT_CODES.ARGUMENT_ERROR);
+    }
+    const { id: _id, ...rest } = raw;
+    return rest;
+}
+export async function getScorecard(runtime, id) {
+    const response = await request(runtime, "/scorecards.info", {
+        method: "GET",
+        query: { id },
+    });
+    return response.body;
+}
+export async function listScorecards(runtime, params) {
+    const query = {};
+    if (params.cursor !== undefined)
+        query.cursor = params.cursor;
+    if (params.limit !== undefined)
+        query.limit = params.limit;
+    if (params.include_unpublished)
+        query.include_unpublished = true;
+    const response = await request(runtime, "/scorecards.list", {
+        method: "GET",
+        query,
+    });
+    return response.body;
+}
+export async function updateScorecard(runtime, payload) {
+    const response = await request(runtime, "/scorecards.update", {
+        method: "POST",
+        body: payload,
+    });
+    return response.body;
+}
+// --- YAML helpers ---
+const SCORECARD_BLANK_TEMPLATE_YAML = fs.readFileSync(new URL("./scorecard-blank-template.yaml", import.meta.url), "utf8");
+/**
+ * These keys are ignored when initializing a file to update
+ */
+const SCORECARD_IGNORED_KEYS = [
+    // Read-only: managed through other parts of the app, not the scorecards API
+    "admins",
+    // Deprecated fields
+    "evaluation_frequency_hours",
+    "entity_filter_type_ids",
+    // Reporting on state
+    "sql_errors",
+    "max_entity_points",
+];
+const SCORECARD_TRANSFORM_KEYS = {
+    editors: (value) => value.map((editor) => editor.id),
+    tags: (value) => value.map((tag) => ({ value: tag.value })),
+    levels: (value) => {
+        if (!Array.isArray(value)) {
+            return value;
+        }
+        else {
+            return value.map((level) => {
+                return {
+                    ...level,
+                    key: toSnakeCase(level.name),
+                };
+            });
+        }
+    },
+    check_groups: (value) => {
+        if (!Array.isArray(value)) {
+            return value;
+        }
+        else {
+            return value.map((checkGroup) => {
+                return {
+                    ...checkGroup,
+                    key: toSnakeCase(checkGroup.name),
+                };
+            });
+        }
+    },
+    checks: (value) => {
+        return value.map((check) => {
+            const { level, check_group, ...rest } = check;
+            const payload = rest;
+            if (level) {
+                payload.scorecard_level_key = toSnakeCase(level.name);
+            }
+            else if (check_group) {
+                payload.scorecard_check_group_key = toSnakeCase(check_group.name);
+            }
+            return payload;
+        });
+    },
+};
+function scorecardToYaml(scorecard) {
+    const obj = { ...scorecard };
+    for (const key of SCORECARD_IGNORED_KEYS) {
+        delete obj[key];
+    }
+    const objLoose = obj;
+    for (const key of Object.keys(SCORECARD_TRANSFORM_KEYS)) {
+        const transformFn = SCORECARD_TRANSFORM_KEYS[key];
+        if (transformFn) {
+            objLoose[key] = transformFn(objLoose[key]);
+        }
+    }
+    return stringifyYaml(obj, { blockQuote: "literal" });
+}
+function readYamlFile(filePath) {
+    let content;
+    try {
+        content = fs.readFileSync(filePath, "utf8");
+    }
+    catch (err) {
+        throw new CliError(`Could not read file "${filePath}": ${err.message}`, EXIT_CODES.ARGUMENT_ERROR);
+    }
+    return parseYaml(content);
+}
+async function readYamlStdin() {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        process.stdin.on("data", (chunk) => chunks.push(chunk));
+        process.stdin.on("end", () => {
+            const content = Buffer.concat(chunks).toString("utf8");
+            try {
+                resolve(parseYaml(content));
+            }
+            catch (err) {
+                reject(new CliError(`Failed to parse YAML from stdin: ${err.message}`, EXIT_CODES.ARGUMENT_ERROR));
+            }
+        });
+        process.stdin.on("error", (err) => {
+            reject(new CliError(`Failed to read from stdin: ${err.message}`, EXIT_CODES.ARGUMENT_ERROR));
+        });
+    });
+}
+function buildUpdatePayload(id, raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new CliError("YAML content must be an object", EXIT_CODES.ARGUMENT_ERROR);
+    }
+    return { ...raw, id };
+}
+function toSnakeCase(str) {
+    return (str
+        // First, handle camelCase/PascalCase transitions
+        .replace(/([a-z])([A-Z])/g, "$1_$2")
+        // Then convert to lowercase
+        .toLowerCase()
+        // Replace sequences of non-alphanumeric characters with single underscore
+        .replace(/[^a-z0-9]+/g, "_")
+        // Remove leading and trailing underscores
+        .replace(/^_+|_+$/g, ""));
+}
+// --- Include helpers ---
+const SCORECARD_INCLUDE_SECTIONS = ["core", "owners", "checks"];
+const SCORECARD_SECTION_KEYS = {
+    core: [
+        "id",
+        "name",
+        "description",
+        "type",
+        "published",
+        "entity_filter_type",
+        "entity_filter_sql",
+        "entity_filter_type_ids",
+        "tags",
+        "sql_errors",
+        "levels",
+        "empty_level_label",
+        "empty_level_color",
+        "check_groups",
+    ],
+    owners: ["admins", "editors"],
+    checks: ["checks"],
+};
+function assignScorecardKey(out, src, key) {
+    out[key] = src[key];
+}
+function processScorecardIncludes(scorecard, includeSections) {
+    if (includeSections === null) {
+        return scorecard;
+    }
+    const out = {};
+    for (const section of includeSections) {
+        for (const key of SCORECARD_SECTION_KEYS[section]) {
+            if (key in scorecard) {
+                assignScorecardKey(out, scorecard, key);
+            }
+        }
+    }
+    return out;
+}
+function parseScorecardIncludeSections(include) {
+    if (!include) {
+        return null;
+    }
+    const results = include.split(",");
+    for (const result of results) {
+        if (!SCORECARD_INCLUDE_SECTIONS.includes(result)) {
+            throw new CliError(`Invalid --include "${result}". Expected one of: ${SCORECARD_INCLUDE_SECTIONS.join(", ")}`, EXIT_CODES.ARGUMENT_ERROR);
+        }
+    }
+    return results;
+}

package/dist/commands/scorecardsRendering.js

@@ -0,0 +1,219 @@
+import { renderRichText } from "../renderers.js";
+import * as ui from "../ui.js";
+export function renderScorecardList(scorecards, nextCursor, includeSections) {
+    const shouldIncludeAll = includeSections === null;
+    const blocks = [ui.h1("Scorecards")];
+    blocks.push(ui.p(`Displaying ${ui.bold(scorecards.length.toString())} scorecards.`));
+    if (nextCursor) {
+        blocks.push(ui.p(`Next cursor: ${ui.code(nextCursor)}`));
+    }
+    for (const scorecard of scorecards) {
+        blocks.push(ui.h2(`${scorecard.name} (${ui.code(scorecard.id)})`));
+        if (shouldIncludeAll || includeSections.includes("core")) {
+            blocks.push(ui.h3("Basic details"));
+            blocks.push(...basicDetailsContent(scorecard));
+            blocks.push(ui.h3("Entity filter"));
+            blocks.push(...entityFilterContent(scorecard));
+            if (scorecard.type === "LEVEL") {
+                blocks.push(ui.h3("Levels"));
+                blocks.push(...levelsContent(scorecard));
+            }
+            else {
+                blocks.push(ui.h3("Check groups"));
+                blocks.push(...checkGroupsContent(scorecard.check_groups));
+            }
+        }
+        if (shouldIncludeAll || includeSections.includes("owners")) {
+            blocks.push(ui.h3("Owners"));
+            blocks.push(...ownersContent(scorecard));
+        }
+        if (shouldIncludeAll || includeSections.includes("checks")) {
+            blocks.push(ui.h3("Checks"));
+            blocks.push(...checksContent(scorecard));
+        }
+    }
+    renderRichText(blocks);
+}
+export function renderScorecard(scorecard, includeSections, title = "Scorecard Information") {
+    const shouldIncludeAll = includeSections === null;
+    const blocks = [ui.h1(title)];
+    if (shouldIncludeAll || includeSections.includes("core")) {
+        blocks.push(ui.h2("Basic details"));
+        blocks.push(...basicDetailsContent(scorecard));
+        blocks.push(ui.h2("Entity filter"));
+        blocks.push(...entityFilterContent(scorecard));
+        if (scorecard.type === "LEVEL") {
+            blocks.push(ui.h2("Levels"));
+            blocks.push(...levelsContent(scorecard));
+        }
+        else {
+            blocks.push(ui.h2("Check groups"));
+            blocks.push(...checkGroupsContent(scorecard.check_groups));
+        }
+    }
+    if (shouldIncludeAll || includeSections.includes("owners")) {
+        blocks.push(ui.h2("Owners"));
+        blocks.push(...ownersContent(scorecard));
+    }
+    if (shouldIncludeAll || includeSections.includes("checks")) {
+        blocks.push(ui.h2(`Checks`));
+        blocks.push(...checksContent(scorecard));
+    }
+    renderRichText(blocks);
+}
+function basicDetailsContent(scorecard) {
+    const items = [
+        ui.dli("ID", [ui.p(ui.code(scorecard.id), false)]),
+        ui.dli("Name", [ui.p(scorecard.name, false)]),
+        ui.dli("Description", [
+            ui.p(scorecard.description || ui.dim("(None)"), false),
+        ]),
+        ui.dli("Type", [
+            ui.p(scorecard.type ? ui.code(scorecard.type) : ui.dim("(None)"), false),
+        ]),
+        ui.dli("Published", [
+            ui.p(scorecard.published ? ui.success("Yes") : ui.dim("No (draft)"), false),
+        ]),
+    ];
+    if (scorecard.tags && scorecard.tags.length > 0) {
+        items.push(ui.dli("Tags", [
+            ui.p(scorecard.tags.map((t) => t.value).join(", "), false),
+        ]));
+    }
+    return [ui.dl(items, { termWidth: 14 })];
+}
+function entityFilterContent(scorecard) {
+    const blocks = [];
+    if (scorecard.entity_filter_type === "entity_types") {
+        blocks.push(ui.p(`Filter: ${ui.code("entity_types")}`));
+        if (scorecard.entity_filter_type_ids &&
+            scorecard.entity_filter_type_ids.length > 0) {
+            blocks.push(ui.ul(scorecard.entity_filter_type_ids.map((id) => ui.li([ui.p(ui.code(id), false)]))));
+        }
+        else {
+            blocks.push(ui.p(ui.dim("(No entity types selected)")));
+        }
+    }
+    else if (scorecard.entity_filter_type === "sql") {
+        blocks.push(ui.p(`Filter: ${ui.code("sql")}`));
+        if (scorecard.entity_filter_sql) {
+            blocks.push(truncatedSqlBlock(scorecard.entity_filter_sql));
+        }
+        else {
+            blocks.push(ui.p(ui.dim("(No SQL provided)")));
+        }
+    }
+    else if (scorecard.entity_filter_type) {
+        blocks.push(ui.p(`Filter: ${ui.code(scorecard.entity_filter_type)}`));
+    }
+    return blocks;
+}
+function levelsContent(scorecard) {
+    const levels = scorecard.levels ?? [];
+    if (levels.length === 0) {
+        return [ui.p(ui.dim("(No levels defined)"))];
+    }
+    const blocks = [
+        ui.ul(levels.map((level) => ui.li([ui.p(`${ui.bold(level.name)}  ${ui.dim(level.color)}`, false)]))),
+    ];
+    if (scorecard.empty_level_label) {
+        const colorSuffix = scorecard.empty_level_color
+            ? `  ${ui.dim(scorecard.empty_level_color)}`
+            : "";
+        blocks.push(ui.p(`Empty level: ${ui.bold(scorecard.empty_level_label)}${colorSuffix}`));
+    }
+    return blocks;
+}
+function checkGroupsContent(checkGroups) {
+    if (checkGroups.length === 0) {
+        return [ui.p(ui.dim("(No check groups defined)"))];
+    }
+    return [ui.ul(checkGroups.map((g) => ui.li([ui.p(ui.bold(g.name), false)])))];
+}
+function ownersContent(scorecard) {
+    const blocks = [];
+    const adminCount = scorecard.admins?.length ?? 0;
+    const editorCount = scorecard.editors?.length ?? 0;
+    if (adminCount === 0 && editorCount === 0) {
+        return [ui.p(ui.dim("(No owners assigned)"))];
+    }
+    if (scorecard.admins && adminCount > 0) {
+        blocks.push(ui.p(ui.bold("Admins:")));
+        blocks.push(ui.ul(scorecard.admins.map((u) => ui.li([ui.p(`${u.name} (${ui.code(u.email)})`, false)]))));
+    }
+    if (scorecard.editors && editorCount > 0) {
+        blocks.push(ui.p(ui.bold("Editors:")));
+        blocks.push(ui.ul(scorecard.editors.map((u) => ui.li([ui.p(`${u.name} (${ui.code(u.email)})`, false)]))));
+    }
+    return blocks;
+}
+function checksContent(scorecard) {
+    const checks = scorecard.checks ?? [];
+    if (checks.length === 0) {
+        return [ui.p(ui.dim("(No checks defined)"))];
+    }
+    const blocks = [];
+    for (const check of checks) {
+        blocks.push(...checkContent(check, scorecard.type));
+    }
+    return blocks;
+}
+function checkContent(check, scorecardType) {
+    const statusBadge = check.published ? "" : `  ${ui.dim("[draft]")}`;
+    const blocks = [ui.h3(`${check.name}${statusBadge}`)];
+    // Core fields dl
+    const dlItems = [ui.dli("ID", [ui.p(ui.code(check.id), false)])];
+    if (scorecardType === "LEVEL" && check.level) {
+        dlItems.push(ui.dli("Level", [ui.p(check.level.name, false)]));
+    }
+    if (scorecardType === "POINTS") {
+        if (check.check_group) {
+            dlItems.push(ui.dli("Check group", [ui.p(check.check_group.name, false)]));
+        }
+        if (check.points !== undefined && check.points !== null) {
+            dlItems.push(ui.dli("Points", [ui.p(check.points.toString(), false)]));
+        }
+    }
+    dlItems.push(ui.dli("Doc URL", [
+        ui.p(check.external_url ? ui.link(check.external_url) : ui.dim("(none)"), false),
+    ]));
+    if (check.estimated_dev_days !== null) {
+        dlItems.push(ui.dli("Est. dev days", [
+            ui.p(check.estimated_dev_days?.toString() ?? ui.dim("(none)"), false),
+        ]));
+    }
+    blocks.push(ui.dl(dlItems, { termWidth: 14 }));
+    // Description
+    if (check.description) {
+        blocks.push(ui.p(ui.bold("Description:"), false));
+        blocks.push(ui.p(check.description));
+    }
+    // Query
+    blocks.push(ui.p(ui.bold("Query:")));
+    blocks.push(truncatedSqlBlock(check.sql));
+    // Output settings
+    if (check.output_enabled) {
+        const outputParts = [`Output: ${ui.code(check.output_type ?? "unknown")}`];
+        if (check.output_aggregation) {
+            outputParts.push(ui.dim(`(aggregation: ${check.output_aggregation})`));
+        }
+        blocks.push(ui.p(outputParts.join("  ")));
+    }
+    // Entity filter
+    if (check.filter_sql) {
+        blocks.push(ui.p(ui.bold("Entity filter:")));
+        blocks.push(truncatedSqlBlock(check.filter_sql));
+        if (check.filter_message) {
+            blocks.push(ui.p(`Excluded message: ${ui.dim(check.filter_message)}`, false));
+        }
+    }
+    return blocks;
+}
+function truncatedSqlBlock(sql) {
+    const lines = sql.split("\n");
+    const firstLine = lines[0];
+    const isLong = firstLine.length > 80 || lines.length > 1;
+    const truncated = firstLine.length > 80 ? firstLine.slice(0, 80) : firstLine;
+    const display = isLong ? truncated + ui.dim(" …") : truncated;
+    return ui.p(ui.code(display));
+}