@vertaaux/cli 0.4.0 → 0.5.0

package/dist/commands/compare.d.ts

@@ -16,5 +16,22 @@
  *   vertaa compare --before baseline.json --after current.json --verbose
  */
 import { Command } from "commander";
+export interface CompareCommandOptions {
+    urlA?: string;
+    urlB?: string;
+    before?: string;
+    after?: string;
+    mode?: string;
+    wait?: boolean;
+    timeout?: string;
+    interval?: string;
+    failOnScore?: string;
+    format?: string;
+    base?: string;
+    verbose?: boolean;
+    machine?: boolean;
+    apiKey?: string;
+}
+export declare function handleCompare(opts: CompareCommandOptions): Promise<void>;
 export declare function registerCompareCommand(program: Command): void;
 //# sourceMappingURL=compare.d.ts.map

package/dist/commands/compare.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../src/commands/compare.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkNpC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAmE7D"}
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../src/commands/compare.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA6MpC,MAAM,WAAW,qBAAqB;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,aAAa,CAAC,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmR9E;AAMD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAuE7D"}

package/dist/commands/compare.js

@@ -15,15 +15,15 @@
  *   vertaa compare --before baseline.json --after current.json
  *   vertaa compare --before baseline.json --after current.json --verbose
  */
-import chalk from "chalk";
+import { bold, dim, colorize, boldColor, scoreColor, brand, severity as severityPalette, renderError, createRenderer, runSteps } from "@vertaaux/tui";
 import { ExitCode } from "../utils/exit-codes.js";
-import { resolveApiBase, getApiKey, apiRequest, waitForAudit, } from "../utils/client.js";
+import { resolveApiBase, getApiKey, apiRequest, waitForAudit, createClient, } from "../utils/client.js";
 import { resolveConfig } from "../config/loader.js";
 import { writeJsonOutput, writeOutput } from "../output/envelope.js";
 import { resolveCommandFormat } from "../output/formats.js";
-import { createSpinner, succeedSpinner, failSpinner } from "../ui/spinner.js";
 import { readJsonInput } from "../utils/stdin.js";
-import { handleAiCommandError, AI_TIMEOUT_MS } from "../utils/ai-error.js";
+import { AI_TIMEOUT_MS } from "../utils/ai-error.js";
+import { strings } from "../ui/strings.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -60,10 +60,11 @@ function toNumber(value) {
 function getOverallScore(scores) {
     if (!scores)
         return null;
-    const direct = toNumber(scores.overall ?? scores.ux ?? scores.total);
+    const s = scores;
+    const direct = toNumber(s.overall ?? s.ux ?? s.total);
     if (direct !== null)
         return direct;
-    const numeric = Object.values(scores)
+    const numeric = Object.values(s)
         .map((v) => toNumber(v))
         .filter((v) => v !== null);
     if (numeric.length === 0)
@@ -71,45 +72,38 @@ function getOverallScore(scores) {
     const avg = numeric.reduce((sum, v) => sum + v, 0) / numeric.length;
     return Math.round(avg);
 }
-function buildAuditPayload(result, fallbackJobId) {
-    const issues = normalizeIssues(result.issues);
-    return {
-        job_id: result.job_id || fallbackJobId || null,
-        url: result.url || null,
-        scores: result.scores || null,
-        issues,
-    };
-}
 // ---------------------------------------------------------------------------
 // Formatters — Legacy URL comparison
 // ---------------------------------------------------------------------------
 function formatLegacyCompareHuman(data) {
     const lines = [];
-    lines.push(chalk.bold("Audit Comparison"));
-    lines.push(`  URL A: ${chalk.cyan(data.urlA)}`);
-    lines.push(`  URL B: ${chalk.cyan(data.urlB)}`);
+    lines.push(bold("Audit Comparison"));
+    lines.push(`  URL A: ${colorize(data.urlA, brand.cyan)}`);
+    lines.push(`  URL B: ${colorize(data.urlB, brand.cyan)}`);
     lines.push("");
     // Overall scores
     const deltaStr = data.delta !== null
-        ? (data.delta >= 0 ? chalk.green(`+${data.delta}`) : chalk.red(`${data.delta}`))
-        : chalk.dim("n/a");
-    lines.push(chalk.bold("Overall Scores"));
-    lines.push(`  A: ${data.overallA ?? "n/a"}  B: ${data.overallB ?? "n/a"}  Delta: ${deltaStr}`);
+        ? (data.delta >= 0 ? colorize(`+${data.delta}`, brand.lime) : colorize(`${data.delta}`, severityPalette.error))
+        : dim("n/a");
+    lines.push(bold("Overall Scores"));
+    const scoreA = data.overallA !== null ? boldColor(String(data.overallA), scoreColor(data.overallA)) : dim("n/a");
+    const scoreB = data.overallB !== null ? boldColor(String(data.overallB), scoreColor(data.overallB)) : dim("n/a");
+    lines.push(`  A: ${scoreA}  B: ${scoreB}  Delta: ${deltaStr}`);
     lines.push("");
     // Category deltas
     const entries = Object.entries(data.categoryDeltas);
     if (entries.length > 0) {
-        lines.push(chalk.bold("Category Scores"));
+        lines.push(bold("Category Scores"));
         for (const [key, vals] of entries) {
             const d = vals.delta !== null
-                ? (vals.delta >= 0 ? chalk.green(`+${vals.delta}`) : chalk.red(`${vals.delta}`))
-                : chalk.dim("n/a");
+                ? (vals.delta >= 0 ? colorize(`+${vals.delta}`, brand.lime) : colorize(`${vals.delta}`, severityPalette.error))
+                : dim("n/a");
             lines.push(`  ${key}: ${vals.a ?? "n/a"} → ${vals.b ?? "n/a"} (${d})`);
         }
         lines.push("");
     }
     // Issue counts
-    lines.push(chalk.bold("Issue Counts"));
+    lines.push(bold("Issue Counts"));
     lines.push(`  A: ${data.issuesA}  B: ${data.issuesB}`);
     return lines.join("\n");
 }
@@ -118,43 +112,280 @@ function formatLegacyCompareHuman(data) {
 // ---------------------------------------------------------------------------
 function formatLlmCompareHuman(data, verbose) {
     const lines = [];
-    lines.push(chalk.bold(data.headline));
+    lines.push(bold(data.headline));
     lines.push("");
     // Score delta
     const d = data.score_delta.overall;
-    const deltaStr = d >= 0 ? chalk.green(`+${d}`) : chalk.red(`${d}`);
+    const deltaStr = d >= 0 ? colorize(`+${d}`, brand.lime) : colorize(`${d}`, severityPalette.error);
     lines.push(`Overall delta: ${deltaStr}`);
     if (data.score_delta.categories && verbose) {
         for (const [cat, val] of Object.entries(data.score_delta.categories)) {
-            const catDelta = val >= 0 ? chalk.green(`+${val}`) : chalk.red(`${val}`);
+            const catDelta = val >= 0 ? colorize(`+${val}`, brand.lime) : colorize(`${val}`, severityPalette.error);
             lines.push(`  ${cat}: ${catDelta}`);
         }
     }
     lines.push("");
     // Improvements
     if (data.improvements.length > 0) {
-        lines.push(chalk.green.bold(`Improvements (${data.improvements.length})`));
+        lines.push(boldColor(`Improvements (${data.improvements.length})`, brand.lime));
         for (const item of data.improvements) {
-            lines.push(`  ${chalk.green("+")} ${item}`);
+            lines.push(`  ${colorize("+", brand.lime)} ${item}`);
         }
         lines.push("");
     }
     // Regressions
     if (data.regressions.length > 0) {
-        lines.push(chalk.red.bold(`Regressions (${data.regressions.length})`));
+        lines.push(boldColor(`Regressions (${data.regressions.length})`, severityPalette.error));
         for (const item of data.regressions) {
-            lines.push(`  ${chalk.red("-")} ${item}`);
+            lines.push(`  ${colorize("-", severityPalette.error)} ${item}`);
         }
         lines.push("");
     }
-    lines.push(chalk.dim(`Unchanged: ${data.unchanged}`));
+    lines.push(dim(`Unchanged: ${data.unchanged}`));
     if (verbose) {
         lines.push("");
-        lines.push(chalk.bold("Analysis"));
+        lines.push(bold("Analysis"));
         lines.push(data.narrative);
     }
     return lines.join("\n");
 }
+export async function handleCompare(opts) {
+    const config = { apiKey: opts.apiKey };
+    const format = resolveCommandFormat("compare", opts.format, opts.machine || false);
+    const verbose = opts.verbose || false;
+    const isFileMode = opts.before || opts.after;
+    const renderer = createRenderer("auto");
+    const baseState = {
+        phase: "compare",
+        phaseIndex: 1,
+        phaseTotal: isFileMode ? 1 : 3,
+        url: opts.urlA || "",
+        mode: "compare",
+        progress: {},
+        totals: {},
+        issueCount: 0,
+        scorePreview: null,
+        verbose: false,
+        elapsed: 0,
+    };
+    const startTime = Date.now();
+    if (isFileMode) {
+        // File-based LLM comparison
+        let responseData = null;
+        const steps = [
+            {
+                id: "fetch-a",
+                actionText: "Loading audit files...",
+                summaryText: "Audit files loaded",
+                run: async () => {
+                    if (!opts.before || !opts.after) {
+                        throw new Error(strings.compare.errors.beforeAfterRequired);
+                    }
+                    const beforeInput = await readJsonInput(opts.before);
+                    const afterInput = await readJsonInput(opts.after);
+                    if (!beforeInput || !afterInput) {
+                        throw new Error(strings.compare.errors.readFailed);
+                    }
+                    function extractPayload(input) {
+                        const data = input;
+                        const inner = (data.data && typeof data.data === "object" ? data.data : data);
+                        const issues = normalizeIssues(inner.issues);
+                        return {
+                            job_id: inner.job_id || null,
+                            url: inner.url || null,
+                            scores: inner.scores || null,
+                            issues,
+                        };
+                    }
+                    const beforePayload = extractPayload(beforeInput);
+                    const afterPayload = extractPayload(afterInput);
+                    const base = resolveApiBase(opts.base);
+                    const apiKey = getApiKey(config.apiKey);
+                    const response = await Promise.race([
+                        apiRequest(base, "/cli/ai/compare", { method: "POST", body: { before: beforePayload, after: afterPayload } }, apiKey),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error("LLM request timed out")), AI_TIMEOUT_MS)),
+                    ]);
+                    responseData = response.data;
+                },
+            },
+            {
+                id: "compare",
+                actionText: strings.compare.analyze.action,
+                summaryText: strings.compare.analyze.done(),
+                run: async () => {
+                    // Analysis was performed in fetch-a step; this step finalizes output
+                },
+            },
+        ];
+        const { success, states } = await runSteps(steps, {
+            onStateChange: (stepStates) => {
+                renderer.update({ ...baseState, stepStates, elapsed: Date.now() - startTime });
+            },
+        });
+        renderer.finish({
+            url: opts.urlA || "",
+            mode: "compare",
+            overallScore: success ? 100 : 0,
+            scores: {},
+            issueCount: 0,
+            passed: success,
+            elapsed: Date.now() - startTime,
+        });
+        if (!success) {
+            const failed = states.find(s => s.status === "failed");
+            process.stderr.write(renderError({
+                message: failed?.failReason || "Command failed",
+                suggestion: "vertaa doctor",
+            }) + "\n");
+            process.exitCode = ExitCode.ERROR;
+        }
+        if (success && responseData) {
+            if (format === "json") {
+                writeJsonOutput(responseData, "compare");
+            }
+            else {
+                writeOutput(formatLlmCompareHuman(responseData, verbose));
+            }
+        }
+    }
+    else if (opts.urlA && opts.urlB) {
+        const urlA = opts.urlA;
+        const urlB = opts.urlB;
+        let compareOutput = null;
+        let compareJsonPayload = null;
+        let jobARef = null;
+        let jobBRef = null;
+        const steps = [
+            {
+                id: "fetch-a",
+                actionText: strings.compare.auditA.action,
+                summaryText: strings.compare.auditA.done(),
+                run: async () => {
+                    const sdkClient = createClient({ base: opts.base, apiKey: config.apiKey });
+                    const mode = opts.mode || "basic";
+                    jobARef = await sdkClient.audits.create({ url: urlA, mode: mode });
+                },
+            },
+            {
+                id: "fetch-b",
+                actionText: strings.compare.auditB.action,
+                summaryText: strings.compare.auditB.done(),
+                run: async () => {
+                    const sdkClient = createClient({ base: opts.base, apiKey: config.apiKey });
+                    const mode = opts.mode || "basic";
+                    jobBRef = await sdkClient.audits.create({ url: urlB, mode: mode });
+                },
+            },
+            {
+                id: "compare",
+                actionText: strings.compare.analyze.action,
+                summaryText: strings.compare.analyze.done(),
+                run: async () => {
+                    if (!jobARef || !jobBRef) {
+                        throw new Error(strings.compare.errors.missingJobIds);
+                    }
+                    const jobA = jobARef;
+                    const jobB = jobBRef;
+                    if (!opts.wait) {
+                        const payload = { job_a: jobA, job_b: jobB };
+                        if (format === "json") {
+                            compareJsonPayload = payload;
+                        }
+                        else {
+                            compareOutput = `Audit comparison queued:\n  Job A: ${jobA.job_id}\n  Job B: ${jobB.job_id}`;
+                        }
+                        return;
+                    }
+                    if (!jobA.job_id || !jobB.job_id) {
+                        throw new Error(strings.compare.errors.missingJobIds);
+                    }
+                    const timeout = parseInt(opts.timeout || "60000", 10);
+                    const interval = parseInt(opts.interval || "5000", 10);
+                    const sdkClientWait = createClient({ base: opts.base, apiKey: config.apiKey });
+                    const [resultA, resultB] = await Promise.all([
+                        waitForAudit(sdkClientWait, jobA.job_id, timeout, interval),
+                        waitForAudit(sdkClientWait, jobB.job_id, timeout, interval),
+                    ]);
+                    const overallA = getOverallScore(resultA.scores);
+                    const overallB = getOverallScore(resultB.scores);
+                    const delta = overallA !== null && overallB !== null ? overallB - overallA : null;
+                    const scoresA = (resultA.scores || {});
+                    const scoresB = (resultB.scores || {});
+                    const keys = new Set([...Object.keys(scoresA), ...Object.keys(scoresB)]);
+                    const categoryDeltas = {};
+                    for (const key of keys) {
+                        const a = toNumber(scoresA[key]);
+                        const b = toNumber(scoresB[key]);
+                        categoryDeltas[key] = {
+                            a,
+                            b,
+                            delta: a !== null && b !== null ? b - a : null,
+                        };
+                    }
+                    const issuesA = normalizeIssues(resultA.issues).length;
+                    const issuesB = normalizeIssues(resultB.issues).length;
+                    const data = {
+                        urlA,
+                        urlB,
+                        jobA: resultA.job_id || "",
+                        jobB: resultB.job_id || "",
+                        overallA,
+                        overallB,
+                        delta,
+                        categoryDeltas,
+                        issuesA,
+                        issuesB,
+                    };
+                    const failOnScore = opts.failOnScore ? parseInt(opts.failOnScore, 10) : undefined;
+                    if (failOnScore !== undefined &&
+                        ((overallA !== null && overallA < failOnScore) ||
+                            (overallB !== null && overallB < failOnScore))) {
+                        process.exitCode = 1;
+                    }
+                    if (format === "json") {
+                        compareJsonPayload = data;
+                    }
+                    else {
+                        compareOutput = formatLegacyCompareHuman(data);
+                    }
+                },
+            },
+        ];
+        const { success: urlSuccess, states: urlStates } = await runSteps(steps, {
+            onStateChange: (stepStates) => {
+                renderer.update({ ...baseState, stepStates, elapsed: Date.now() - startTime });
+            },
+        });
+        renderer.finish({
+            url: urlA,
+            mode: "compare",
+            overallScore: urlSuccess ? 100 : 0,
+            scores: {},
+            issueCount: 0,
+            passed: urlSuccess,
+            elapsed: Date.now() - startTime,
+        });
+        if (!urlSuccess) {
+            const failed = urlStates.find(s => s.status === "failed");
+            process.stderr.write(renderError({
+                message: failed?.failReason || "Command failed",
+                suggestion: "vertaa doctor",
+            }) + "\n");
+            process.exitCode = ExitCode.ERROR;
+        }
+        if (urlSuccess) {
+            if (format === "json" && compareJsonPayload !== null) {
+                writeJsonOutput(compareJsonPayload, "compare");
+            }
+            else if (compareOutput !== null) {
+                writeOutput(compareOutput);
+            }
+        }
+    }
+    else {
+        throw new Error(strings.compare.errors.urlsOrFilesRequired);
+    }
+}
 // ---------------------------------------------------------------------------
 // Command Registration
 // ---------------------------------------------------------------------------
@@ -182,154 +413,30 @@ Examples:
             const config = await resolveConfig(globalOpts.config);
             const machineMode = globalOpts.machine || false;
             const verbose = globalOpts.verbose || false;
-            const format = resolveCommandFormat("compare", options.format, machineMode);
-            // Decide mode: file-based LLM or URL-based legacy
-            const isFileMode = options.before || options.after;
-            if (isFileMode) {
-                await runLlmCompare(options, globalOpts, config, format, verbose);
-            }
-            else if (urlA && urlB) {
-                await runUrlCompare(urlA, urlB, options, globalOpts, config, format);
-            }
-            else {
-                console.error("Error: Provide either two URLs or --before/--after files.");
-                console.error("Usage:");
-                console.error("  vertaa compare https://a.com https://b.com --wait");
-                console.error("  vertaa compare --before baseline.json --after current.json");
-                process.exit(ExitCode.ERROR);
-            }
+            await handleCompare({
+                urlA,
+                urlB,
+                before: options.before,
+                after: options.after,
+                mode: options.mode,
+                wait: options.wait,
+                timeout: options.timeout,
+                interval: options.interval,
+                failOnScore: options.failOnScore,
+                format: options.format,
+                base: globalOpts.base,
+                verbose,
+                machine: machineMode,
+                apiKey: config.apiKey,
+            });
         }
         catch (error) {
-            console.error("Error:", error instanceof Error ? error.message : String(error));
+            process.stderr.write(renderError({
+                message: error instanceof Error ? error.message : String(error),
+                suggestion: "vertaa audit <url>",
+                exitCode: ExitCode.ERROR,
+            }) + "\n");
             process.exit(ExitCode.ERROR);
         }
     });
 }
-// ---------------------------------------------------------------------------
-// LLM-based comparison (new)
-// ---------------------------------------------------------------------------
-async function runLlmCompare(options, globalOpts, config, format, verbose) {
-    if (!options.before || !options.after) {
-        console.error("Error: Both --before and --after are required for file-based comparison.");
-        process.exit(ExitCode.ERROR);
-    }
-    const beforeInput = await readJsonInput(options.before);
-    const afterInput = await readJsonInput(options.after);
-    if (!beforeInput || !afterInput) {
-        console.error("Error: Could not read audit files.");
-        process.exit(ExitCode.ERROR);
-    }
-    function extractPayload(input) {
-        const data = input;
-        const inner = (data.data && typeof data.data === "object" ? data.data : data);
-        const issues = normalizeIssues(inner.issues);
-        return {
-            job_id: inner.job_id || null,
-            url: inner.url || null,
-            scores: inner.scores || null,
-            issues,
-        };
-    }
-    const beforePayload = extractPayload(beforeInput);
-    const afterPayload = extractPayload(afterInput);
-    const base = resolveApiBase(globalOpts.base);
-    const apiKey = getApiKey(config.apiKey);
-    const spinner = createSpinner("Comparing audits...");
-    try {
-        const response = await Promise.race([
-            apiRequest(base, "/cli/ai/compare", { method: "POST", body: { before: beforePayload, after: afterPayload } }, apiKey),
-            new Promise((_, reject) => setTimeout(() => reject(new Error("LLM request timed out")), AI_TIMEOUT_MS)),
-        ]);
-        succeedSpinner(spinner, "Comparison complete");
-        if (format === "json") {
-            writeJsonOutput(response.data, "compare");
-        }
-        else {
-            writeOutput(formatLlmCompareHuman(response.data, verbose));
-        }
-    }
-    catch (error) {
-        handleAiCommandError(error, "compare", spinner);
-    }
-}
-// ---------------------------------------------------------------------------
-// URL-based comparison (legacy backward compat)
-// ---------------------------------------------------------------------------
-async function runUrlCompare(urlA, urlB, options, globalOpts, config, format) {
-    const base = resolveApiBase(globalOpts.base);
-    const apiKey = getApiKey(config.apiKey);
-    const mode = options.mode || "basic";
-    const spinner = createSpinner("Starting audits...");
-    const jobA = await apiRequest(base, "/audit", {
-        method: "POST",
-        body: { url: urlA, mode },
-    }, apiKey);
-    const jobB = await apiRequest(base, "/audit", {
-        method: "POST",
-        body: { url: urlB, mode },
-    }, apiKey);
-    if (!options.wait) {
-        succeedSpinner(spinner, "Audits queued");
-        const payload = { job_a: jobA, job_b: jobB };
-        if (format === "json") {
-            writeJsonOutput(payload, "compare");
-        }
-        else {
-            writeOutput(`Audit comparison queued:\n  Job A: ${jobA.job_id}\n  Job B: ${jobB.job_id}`);
-        }
-        return;
-    }
-    if (!jobA.job_id || !jobB.job_id) {
-        failSpinner(spinner, "Missing job IDs");
-        throw new Error("Compare response missing job_id");
-    }
-    const timeout = parseInt(options.timeout || "60000", 10);
-    const interval = parseInt(options.interval || "5000", 10);
-    const [resultA, resultB] = await Promise.all([
-        waitForAudit(base, jobA.job_id, timeout, interval, apiKey),
-        waitForAudit(base, jobB.job_id, timeout, interval, apiKey),
-    ]);
-    succeedSpinner(spinner, "Audits complete");
-    const overallA = getOverallScore(resultA.scores);
-    const overallB = getOverallScore(resultB.scores);
-    const delta = overallA !== null && overallB !== null ? overallB - overallA : null;
-    const scoresA = (resultA.scores || {});
-    const scoresB = (resultB.scores || {});
-    const keys = new Set([...Object.keys(scoresA), ...Object.keys(scoresB)]);
-    const categoryDeltas = {};
-    for (const key of keys) {
-        const a = toNumber(scoresA[key]);
-        const b = toNumber(scoresB[key]);
-        categoryDeltas[key] = {
-            a,
-            b,
-            delta: a !== null && b !== null ? b - a : null,
-        };
-    }
-    const issuesA = normalizeIssues(resultA.issues).length;
-    const issuesB = normalizeIssues(resultB.issues).length;
-    const compareData = {
-        urlA,
-        urlB,
-        jobA: resultA.job_id || "",
-        jobB: resultB.job_id || "",
-        overallA,
-        overallB,
-        delta,
-        categoryDeltas,
-        issuesA,
-        issuesB,
-    };
-    const failOnScore = options.failOnScore ? parseInt(options.failOnScore, 10) : undefined;
-    if (failOnScore !== undefined &&
-        ((overallA !== null && overallA < failOnScore) ||
-            (overallB !== null && overallB < failOnScore))) {
-        process.exitCode = 1;
-    }
-    if (format === "json") {
-        writeJsonOutput(compareData, "compare");
-    }
-    else {
-        writeOutput(formatLegacyCompareHuman(compareData));
-    }
-}

package/dist/commands/diff.d.ts

@@ -16,7 +16,12 @@ export interface DiffCommandOptions {
     format?: string;
     verbose?: boolean;
     fromFile?: string;
+    strict?: boolean;
+    continueOnError?: boolean;
+    machine?: boolean;
+    jobIdArg?: string;
 }
+export declare function handleDiff(opts: DiffCommandOptions): Promise<void>;
 /**
  * Register the diff command with the Commander program.
  */

package/dist/commands/diff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/commands/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiFzC,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA2I1D"}
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/commands/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkCzC,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAMD,wBAAsB,UAAU,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmKxE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA8B1D"}