vibecodedshit 0.0.0-stage → 0.2.0

package/dist/commands/common.js

@@ -0,0 +1 @@
+export const EXIT = { ok: 0, usage: 1, methodology: 2, noLogic: 3, tool: 4, diffRefused: 5, sendFailed: 6 };

package/dist/commands/diff.js

@@ -0,0 +1,54 @@
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { compareRuns, DiffInputError } from '../diff/compare.js';
+import { conditionRefusals } from '../diff/conditions.js';
+import { formatDiff, formatRefusal } from '../diff/format.js';
+import { loadMethodology, MethodologyError } from '../methodology/load.js';
+import { readRun, RunReadError } from '../run/read.js';
+import { EXIT } from './common.js';
+const DIFF_USAGE = 'Usage: vibecodedshit diff <before.json> <after.json> [--json]\n';
+export function runDiff(argv, io) {
+    let parsed;
+    try {
+        parsed = parseArgs({ args: argv, allowPositionals: true, options: { json: { type: 'boolean' } } });
+    }
+    catch (err) {
+        io.stderr(`${err instanceof Error ? err.message : String(err)}\n${DIFF_USAGE}`);
+        return EXIT.usage;
+    }
+    const [beforeFile, afterFile] = parsed.positionals;
+    if (!beforeFile || !afterFile || parsed.positionals.length > 2) {
+        io.stderr(DIFF_USAGE);
+        return EXIT.usage;
+    }
+    const files = [path.resolve(io.cwd, beforeFile), path.resolve(io.cwd, afterFile)];
+    try {
+        const before = { run: readRun(files[0]), file: files[0] };
+        const after = { run: readRun(files[1]), file: files[1] };
+        // Mismatched runs are refused before any methodology is loaded, so a version this CLI lacks does not hide the refusal.
+        const early = conditionRefusals(before.run, after.run);
+        const result = early.length > 0
+            ? { schemaVersion: 1, compared: false, refusals: early }
+            : compareRuns(before, after, loadMethodology(before.run.methodology.version));
+        if (!result.compared) {
+            if (parsed.values.json)
+                io.stdout(`${JSON.stringify(result)}\n`);
+            else
+                io.stderr(formatRefusal(result));
+            return EXIT.diffRefused;
+        }
+        io.stdout(parsed.values.json ? `${JSON.stringify(result)}\n` : formatDiff(result));
+        return EXIT.ok;
+    }
+    catch (err) {
+        if (err instanceof RunReadError || err instanceof DiffInputError) {
+            io.stderr(`${err.message}\n`);
+            return EXIT.usage;
+        }
+        if (err instanceof MethodologyError) {
+            io.stderr(`Methodology error: ${err.message}\n`);
+            return EXIT.methodology;
+        }
+        throw err;
+    }
+}

package/dist/commands/footer.js

@@ -0,0 +1,25 @@
+import path from 'node:path';
+const PRIVACY = "Your code stayed on this machine. The scan only looked up your dependencies' names and versions on the public npm and PyPI registries (and OSV, if osv-scanner is installed).";
+/** The Docker command a user of an npx install runs to get the full-run image, with the package root resolved. */
+export function imageBuildCommand(packageRoot, tag) {
+    const docker = path.join(packageRoot, 'docker');
+    return `docker build -t ${tag} -f ${path.join(docker, 'Dockerfile')} ${docker}`;
+}
+/** Lines printed after the scan summary: what a preview skipped, that nothing was uploaded, and how to submit. */
+export function footer(run, outFile) {
+    const lines = [];
+    if (run.mode === 'preview') {
+        const skipped = run.parameters.filter((p) => p.status === 'not_measured' && p.reason?.startsWith('execution layer')).map((p) => p.id);
+        if (skipped.length > 0)
+            lines.push(`Skipped (needs Docker): ${skipped.join(', ')}. Run a full scan with Docker to measure them.`);
+    }
+    lines.push(PRIVACY);
+    if (run.valid && run.comparable && run.mode === 'full') {
+        lines.push(`To compare your result on app.vibecodedshit.com, run: npx vibecodedshit submit ${outFile} --email <you@example.com>`);
+        lines.push('It prints the payload first and sends nothing unless you add --confirm.');
+    }
+    else {
+        lines.push('Only full, comparable runs (Docker needed) can be submitted. Nothing is submitted unless you run the submit command yourself.');
+    }
+    return `${lines.join('\n')}\n`;
+}

package/dist/commands/report.js

@@ -0,0 +1,49 @@
+import { writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { loadMethodology, MethodologyError } from '../methodology/load.js';
+import { renderReport } from '../report/render.js';
+import { roadmapLines } from '../report/roadmap.js';
+import { scareLines } from '../report/scares.js';
+import { readRun, RunReadError } from '../run/read.js';
+import { EXIT } from './common.js';
+const REPORT_USAGE = 'Usage: vibecodedshit report <run.json> [--out <file>]\n';
+export function runReport(argv, io) {
+    let parsed;
+    try {
+        parsed = parseArgs({ args: argv, allowPositionals: true, options: { out: { type: 'string' } } });
+    }
+    catch (err) {
+        io.stderr(`${err instanceof Error ? err.message : String(err)}\n${REPORT_USAGE}`);
+        return EXIT.usage;
+    }
+    const [input] = parsed.positionals;
+    if (!input || parsed.positionals.length > 1) {
+        io.stderr(REPORT_USAGE);
+        return EXIT.usage;
+    }
+    // The default is the current directory, never the scanned repository, the same rule as run.json.
+    const outFile = path.resolve(io.cwd, parsed.values.out ?? 'health-report.html');
+    try {
+        const run = readRun(path.resolve(io.cwd, input));
+        if (!run.valid) {
+            io.stderr(`run.json is invalid: ${run.invalidReason ?? 'no reason given'}\n`);
+            return EXIT.usage;
+        }
+        const methodology = loadMethodology(run.methodology.version);
+        writeFileSync(outFile, renderReport(run, methodology), 'utf8');
+        io.stdout(`${[outFile, ...roadmapLines(run, methodology), ...scareLines(run)].join('\n')}\n`);
+        return EXIT.ok;
+    }
+    catch (err) {
+        if (err instanceof RunReadError) {
+            io.stderr(`${err.message}\n`);
+            return EXIT.usage;
+        }
+        if (err instanceof MethodologyError) {
+            io.stderr(`Methodology error: ${err.message}\n`);
+            return EXIT.methodology;
+        }
+        throw err;
+    }
+}

package/dist/commands/route.js

@@ -0,0 +1,62 @@
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { loadMethodology, MethodologyError } from '../methodology/load.js';
+import { readRun, RunReadError } from '../run/read.js';
+import { checkRouteFiles } from '../route/check.js';
+import { buildRouteFiles } from '../route/files.js';
+import { buildRoute, routeLines } from '../route/select.js';
+import { writeRouteFiles } from '../route/write.js';
+import { EXIT } from './common.js';
+const ROUTE_USAGE = 'Usage: vibecodedshit route <run.json> --out <dir>\n       vibecodedshit route --check <dir> <run.json>\n';
+export function runRoute(argv, io) {
+    let parsed;
+    try {
+        parsed = parseArgs({ args: argv, allowPositionals: true, options: { out: { type: 'string' }, check: { type: 'string' } } });
+    }
+    catch (err) {
+        io.stderr(`${err instanceof Error ? err.message : String(err)}\n${ROUTE_USAGE}`);
+        return EXIT.usage;
+    }
+    const [input] = parsed.positionals;
+    const { out, check } = parsed.values;
+    if (!input || parsed.positionals.length > 1 || (out === undefined) === (check === undefined)) {
+        io.stderr(ROUTE_USAGE);
+        return EXIT.usage;
+    }
+    try {
+        const run = readRun(path.resolve(io.cwd, input));
+        if (!run.valid) {
+            io.stderr(`run.json is invalid: ${run.invalidReason ?? 'no reason given'}\n`);
+            return EXIT.usage;
+        }
+        const methodology = loadMethodology(run.methodology.version);
+        const plan = buildRoute(run, methodology);
+        const files = buildRouteFiles(run, methodology, plan);
+        if (check !== undefined) {
+            const problems = checkRouteFiles(path.resolve(io.cwd, check), files);
+            if (problems.length > 0) {
+                io.stderr(`${problems.join('\n')}\n`);
+                return EXIT.usage;
+            }
+            io.stdout('Route files match run.json\n');
+            return EXIT.ok;
+        }
+        const lines = routeLines(plan);
+        if (files.length > 0 && out !== undefined)
+            writeRouteFiles(path.resolve(io.cwd, out), files);
+        if (lines.length > 0)
+            io.stdout(`${lines.join('\n')}\n`);
+        return EXIT.ok;
+    }
+    catch (err) {
+        if (err instanceof RunReadError) {
+            io.stderr(`${err.message}\n`);
+            return EXIT.usage;
+        }
+        if (err instanceof MethodologyError) {
+            io.stderr(`Methodology error: ${err.message}\n`);
+            return EXIT.methodology;
+        }
+        throw err;
+    }
+}

package/dist/commands/submit.js

@@ -0,0 +1,125 @@
+import { execFile } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { readRun, RunReadError } from '../run/read.js';
+import { EMAIL_PATTERN, MAX_EMAIL_CHARS, MAX_PAYLOAD_BYTES, MAX_SUMMARY_CHARS } from '../submit/constants.js';
+import { buildPayload, PayloadError } from '../submit/payload.js';
+import { repoIdentity, RepoIdentityError } from '../submit/repo-identity.js';
+import { sendPayload } from '../submit/send.js';
+import { EXIT } from './common.js';
+export const SUBMIT_USAGE = 'Usage: vibecodedshit submit <run.json> --email <addr> [--confirm] [--newsletter] [--include-repo-name] [--summary-file <path>]\n';
+export const defaultGit = (repoPath, args) => new Promise((resolve) => {
+    execFile('git', ['-C', repoPath, ...args], { encoding: 'utf8' }, (err, stdout) => resolve(err ? null : stdout));
+});
+export async function runSubmit(argv, io, deps = {}) {
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args: argv,
+            allowPositionals: true,
+            options: {
+                confirm: { type: 'boolean' },
+                newsletter: { type: 'boolean' },
+                'include-repo-name': { type: 'boolean' },
+                email: { type: 'string' },
+                'summary-file': { type: 'string' },
+            },
+        });
+    }
+    catch (err) {
+        io.stderr(`${err instanceof Error ? err.message : String(err)}\n${SUBMIT_USAGE}`);
+        return EXIT.usage;
+    }
+    const [runFile] = parsed.positionals;
+    if (!runFile || parsed.positionals.length > 1) {
+        io.stderr(SUBMIT_USAGE);
+        return EXIT.usage;
+    }
+    const refuse = (message) => {
+        io.stderr(`${message}\n`);
+        return EXIT.usage;
+    };
+    const email = parsed.values.email;
+    if (email === undefined)
+        return refuse('--email is required.');
+    if (email.length > MAX_EMAIL_CHARS || !EMAIL_PATTERN.test(email))
+        return refuse('--email is not a valid address.');
+    let run;
+    try {
+        run = readRun(path.resolve(io.cwd, runFile));
+    }
+    catch (err) {
+        if (err instanceof RunReadError)
+            return refuse(err.message);
+        throw err;
+    }
+    if (run.mode !== 'full') {
+        return refuse('Preview runs are not comparable and cannot be submitted. Run a full scan (Docker required) and submit that run.');
+    }
+    if (!run.valid)
+        return refuse(`run.json is invalid: ${run.invalidReason ?? 'no reason given'}.`);
+    if (!run.comparable)
+        return refuse(`This run is not comparable: ${run.comparableReason ?? 'no reason given'}.`);
+    let summary;
+    const summaryFile = parsed.values['summary-file'];
+    if (summaryFile !== undefined) {
+        try {
+            summary = readFileSync(path.resolve(io.cwd, summaryFile), 'utf8').trim();
+        }
+        catch (err) {
+            return refuse(`Cannot read the summary file: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (summary === '')
+            return refuse('The summary file is empty.');
+        if (summary.length > MAX_SUMMARY_CHARS)
+            return refuse(`The summary is longer than ${MAX_SUMMARY_CHARS} characters, the server limit.`);
+        const paths = [run.repo.path, ...run.parameters.flatMap((p) => (p.units ?? []).map((u) => u.package))].filter((p) => p !== '' && p !== '.');
+        if (paths.some((p) => summary?.includes(p)))
+            return refuse('The summary contains a file path. Remove it and try again.');
+    }
+    let identity;
+    try {
+        identity = await repoIdentity(run.repo.path, deps.git ?? defaultGit);
+    }
+    catch (err) {
+        if (err instanceof RepoIdentityError)
+            return refuse(err.message);
+        throw err;
+    }
+    let payload;
+    try {
+        payload = buildPayload({
+            run,
+            repoHash: identity.hash,
+            repoName: parsed.values['include-repo-name'] ? identity.name : undefined,
+            summary,
+            email,
+            newsletter: parsed.values.newsletter,
+        });
+    }
+    catch (err) {
+        if (err instanceof PayloadError)
+            return refuse(err.message);
+        throw err;
+    }
+    const body = JSON.stringify(payload, null, 2);
+    if (Buffer.byteLength(JSON.stringify(payload), 'utf8') > MAX_PAYLOAD_BYTES)
+        return refuse('Payload is larger than 64 KB, the server limit.');
+    io.stdout(`${body}\n`);
+    if (!parsed.values.confirm) {
+        io.stdout('Not sent. Add --confirm to send.\n');
+        return EXIT.ok;
+    }
+    const result = await sendPayload(payload, deps.fetch ?? fetch);
+    if (!result.ok) {
+        io.stderr(`${result.message}\n`);
+        return EXIT.sendFailed;
+    }
+    io.stdout('Submitted. Thank you.\n');
+    if (result.rank) {
+        const { rank, total, top10Threshold } = result.rank;
+        io.stdout(`Rank ${rank} of ${total}.${top10Threshold === null ? '' : ` Top 10 starts at ${top10Threshold}.`}\n`);
+    }
+    return EXIT.ok;
+}

package/dist/commands/summary.js

@@ -0,0 +1,77 @@
+function round1(value) {
+    return (Math.round(value * 10) / 10).toFixed(1);
+}
+/** Whole numbers print bare (0 findings, 178 points), anything else with one decimal (3.1 seconds). */
+function formatNumber(value) {
+    return Number.isInteger(value) ? String(value) : round1(value);
+}
+/** One raw value as text: scale-100 ratios in %, scale-1000 ratios and numbers with the YAML unit. Null when it has no value. */
+export function formatRaw(raw, unit) {
+    switch (raw.kind) {
+        case 'ratio': {
+            if (raw.denominator === 0)
+                return null;
+            const value = round1((raw.numerator / raw.denominator) * raw.scale);
+            return raw.scale === 100 ? `${value}%` : `${value} ${unit}`;
+        }
+        case 'number':
+            return unit === 'count' ? formatNumber(raw.value) : `${formatNumber(raw.value)} ${unit}`;
+        case 'level':
+            return raw.level;
+        case 'failed':
+            return 'install failed';
+        case 'components':
+            return Object.entries(raw.components)
+                .map(([name, component]) => `${name}=${formatRaw(component, unit) ?? 'n/a'}`)
+                .join(', ');
+    }
+}
+/**
+ * The raw value printed for a measured parameter: the pooled value when there is one, otherwise the unit values
+ * (one unit alone, several as `package/group: value` joined with `; `). Levels list the distinct levels, as before.
+ */
+export function shownRaw(param, unit) {
+    if (param.raw) {
+        const pooled = formatRaw(param.raw, unit);
+        if (pooled !== null)
+            return pooled;
+    }
+    const units = param.units ?? [];
+    if (units.length > 0 && units.every((u) => u.raw.kind === 'level')) {
+        return [...new Set(units.map((u) => u.raw.level))].join(', ');
+    }
+    const shown = units.flatMap((u) => {
+        const value = formatRaw(u.raw, unit);
+        return value === null ? [] : [{ label: `${u.package}/${u.group}`, value }];
+    });
+    if (shown.length === 0)
+        return 'n/a';
+    if (shown.length === 1)
+        return shown[0]?.value ?? 'n/a';
+    return shown.map((s) => `${s.label}: ${s.value}`).join('; ');
+}
+export function summarize(run, methodology) {
+    const lines = [];
+    if (run.health) {
+        const band = methodology.bands.find((b) => b.key === run.health?.band);
+        lines.push(`Health ${run.health.displayed} ${band?.name ?? run.health.band} (${run.mode === 'preview' ? 'preview, ' : ''}${run.comparable ? 'comparable' : 'not comparable'})`);
+    }
+    for (const dimension of run.dimensions) {
+        if (dimension.score === null)
+            continue;
+        const def = methodology.dimensions.find((d) => d.id === dimension.id);
+        lines.push(`Dimension ${dimension.id} ${def?.name ?? dimension.key}: ${Math.floor(dimension.score + 0.5 + 1e-9)}`);
+    }
+    const defs = new Map(methodology.dimensions.flatMap((d) => d.parameters).map((p) => [p.id, p]));
+    for (const param of run.parameters) {
+        const def = defs.get(param.id);
+        if (param.status === 'not_measured' && param.reason && !/^(execution layer|not implemented)/.test(param.reason)) {
+            lines.push(`${param.id} ${def?.name ?? ''}: not measured (${param.reason})`);
+            continue;
+        }
+        if (param.status !== 'measured')
+            continue;
+        lines.push(`${param.id} ${def?.name ?? ''}: ${shownRaw(param, def?.raw.unit ?? '')} -> ${Math.floor((param.score ?? 0) + 0.5 + 1e-9)}`);
+    }
+    return `${lines.join('\n')}\n`;
+}

package/dist/diff/compare.js

@@ -0,0 +1,73 @@
+import { roundHalfUp } from '../scoring/aggregate.js';
+import { conditionRefusals, notComparableRefusals } from './conditions.js';
+/** methodology.yaml `regression.flag_when`: a dimension drops by this much or more, unrounded. */
+const REGRESSION_DROP = 3.0;
+const TOLERANCE = 1e-9;
+export class DiffInputError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DiffInputError';
+    }
+}
+function side(run, file, methodology) {
+    const health = run.health;
+    if (!health)
+        throw new DiffInputError(`${file}: run has no health score`);
+    const band = methodology.bands.find((b) => b.key === health.band);
+    if (!band)
+        throw new DiffInputError(`${file}: unknown band "${health.band}" for methodology ${methodology.version}`);
+    return {
+        path: run.repo.path,
+        headCommit: run.repo.headCommit,
+        treeHash: run.repo.treeHash,
+        health: { score: health.score, displayed: health.displayed, band: band.key, bandName: band.name },
+    };
+}
+function dimensionScore(run, id) {
+    return run.dimensions.find((d) => d.id === id)?.score ?? null;
+}
+/** Refuse when the five conditions differ or a run cannot be compared; otherwise compare the stored scores. */
+export function compareRuns(a, b, methodology) {
+    const refusals = conditionRefusals(a.run, b.run);
+    if (refusals.length === 0)
+        refusals.push(...notComparableRefusals(a.run, b.run));
+    if (refusals.length > 0)
+        return { schemaVersion: 1, compared: false, refusals };
+    const before = side(a.run, a.file, methodology);
+    const after = side(b.run, b.file, methodology);
+    const rank = (key) => methodology.bands.findIndex((band) => band.key === key);
+    const bandDrop = rank(after.health.band) < rank(before.health.band);
+    const dimensions = methodology.dimensions.map((def) => {
+        const from = dimensionScore(a.run, def.id);
+        const to = dimensionScore(b.run, def.id);
+        const both = from !== null && to !== null;
+        return {
+            id: def.id,
+            key: def.key,
+            name: def.name,
+            before: from === null ? null : roundHalfUp(from),
+            after: to === null ? null : roundHalfUp(to),
+            delta: both ? roundHalfUp(to - from) : null,
+            regressed: both && from - to >= REGRESSION_DROP - TOLERANCE,
+        };
+    });
+    const regressed = dimensions.filter((d) => d.regressed).map((d) => d.id);
+    return {
+        schemaVersion: 1,
+        compared: true,
+        methodologyVersion: methodology.version,
+        asOf: a.run.asOf,
+        before,
+        after,
+        healthDelta: roundHalfUp(after.health.score - before.health.score, 1),
+        bandChange: {
+            from: before.health.band,
+            to: after.health.band,
+            fromName: before.health.bandName,
+            toName: after.health.bandName,
+            dropped: bandDrop,
+        },
+        dimensions,
+        regression: { flag: regressed.length > 0 || bandDrop, dimensions: regressed, bandDrop },
+    };
+}

package/dist/diff/conditions.js

@@ -0,0 +1,87 @@
+const NONE = '(none)';
+/** Layers as written, for the message. */
+function layerText(run) {
+    return [...new Set(run.layers)].join('+') || NONE;
+}
+/** Layers as a set, for the comparison. */
+function layerKey(run) {
+    return [...new Set(run.layers)].sort().join('+');
+}
+/** Flatten nested objects to dotted keys, so a differing leaf is named exactly. */
+function flatten(value, prefix, out) {
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        for (const [key, inner] of Object.entries(value))
+            flatten(inner, `${prefix}.${key}`, out);
+        return;
+    }
+    out.set(prefix, JSON.stringify(value));
+}
+function shown(json) {
+    if (json === undefined)
+        return NONE;
+    try {
+        const value = JSON.parse(json);
+        return typeof value === 'string' ? value : json;
+    }
+    catch {
+        return json;
+    }
+}
+function toolDifferences(a, b) {
+    const left = new Map();
+    const right = new Map();
+    flatten(a.tools, 'tools', left);
+    flatten(b.tools, 'tools', right);
+    const keys = [...new Set([...left.keys(), ...right.keys()])].sort();
+    return keys.filter((k) => left.get(k) !== right.get(k)).map((k) => `${k} a=${shown(left.get(k))} b=${shown(right.get(k))}`);
+}
+function ignoreDifferences(a, b) {
+    const out = [];
+    if (a.ignoreSet.healthignoreSha256 !== b.ignoreSet.healthignoreSha256)
+        out.push('.healthignore hash');
+    if (a.ignoreSet.gitleaksignoreSha256 !== b.ignoreSet.gitleaksignoreSha256)
+        out.push('.gitleaksignore hash');
+    return out;
+}
+/** The five `delta.conditions` of methodology.yaml, in order. Every mismatch is reported. */
+export function conditionRefusals(a, b) {
+    const refusals = [];
+    if (layerKey(a) !== layerKey(b)) {
+        refusals.push({ condition: 'layers', message: `layers differ (a: ${layerText(a)}, b: ${layerText(b)})` });
+    }
+    const tools = toolDifferences(a, b);
+    if (tools.length > 0)
+        refusals.push({ condition: 'tool_versions', message: `tool versions differ: ${tools.join(', ')}` });
+    if (a.methodology.version !== b.methodology.version) {
+        refusals.push({
+            condition: 'methodology_version',
+            message: `methodology version differs (a: ${a.methodology.version}, b: ${b.methodology.version}); runs from different versions are never compared`,
+        });
+    }
+    if (a.asOf !== b.asOf) {
+        refusals.push({ condition: 'as_of_date', message: `as-of date differs (a: ${a.asOf}, b: ${b.asOf})` });
+    }
+    const ignore = ignoreDifferences(a, b);
+    if (ignore.length > 0)
+        refusals.push({ condition: 'ignore_set', message: `ignore set differs: ${ignore.join(', ')}` });
+    return refusals;
+}
+/** A run that cannot be compared at all: invalid, preview or without a health score. */
+export function notComparableRefusals(before, after) {
+    const refusals = [];
+    for (const [side, run] of [
+        ['before', before],
+        ['after', after],
+    ]) {
+        let reason = null;
+        if (!run.valid)
+            reason = run.invalidReason ?? 'run is invalid';
+        else if (!run.comparable)
+            reason = run.comparableReason ?? 'run is not comparable';
+        else if (run.health === null)
+            reason = 'run has no health score';
+        if (reason !== null)
+            refusals.push({ condition: 'run_not_comparable', message: `${side} run is not comparable: ${reason}` });
+    }
+    return refusals;
+}

package/dist/diff/format.js

@@ -0,0 +1,23 @@
+function signed(value, digits) {
+    const text = value.toFixed(digits);
+    return value >= 0 ? `+${text}` : text;
+}
+/** Human output: health line, one line per changed dimension, regression line. */
+export function formatDiff(result) {
+    const lines = [`Health ${result.after.health.displayed} ${result.after.health.bandName} (${signed(result.healthDelta, 1)})`];
+    for (const d of result.dimensions) {
+        if (d.delta === null || d.delta === 0)
+            continue;
+        lines.push(`Dimension ${d.id} ${d.name}: ${signed(d.delta, 0)}`);
+    }
+    const regressions = result.dimensions
+        .filter((d) => d.regressed)
+        .map((d) => `${d.name} ${signed(d.delta ?? 0, 0)}`);
+    if (result.regression.bandDrop)
+        regressions.push(`band ${result.bandChange.fromName} -> ${result.bandChange.toName}`);
+    lines.push(`Regression: ${regressions.length === 0 ? 'none' : regressions.join(', ')}`);
+    return `${lines.join('\n')}\n`;
+}
+export function formatRefusal(result) {
+    return `${result.refusals.map((r) => `Refused: ${r.message}`).join('\n')}\n`;
+}