@vertaaux/cli 0.2.2 → 0.3.0

package/dist/commands/report.js

@@ -0,0 +1,214 @@
+/**
+ * Report generation command for VertaaUX CLI.
+ *
+ * Generates consolidated multi-client reports by delegating
+ * data aggregation to the server-side consolidated report API.
+ * The CLI handles formatting only -- no data computation.
+ *
+ * Implements 46-06: CLI report command.
+ */
+import chalk from "chalk";
+import fs from "fs";
+import { resolveApiBase, getApiKey, apiRequest } from "../utils/client.js";
+/**
+ * Resolve API connection settings.
+ */
+function resolveConnection() {
+    return {
+        base: resolveApiBase(),
+        apiKey: getApiKey(),
+    };
+}
+/**
+ * Get a traffic-light status indicator for a client based on scores and policy.
+ */
+function getStatusIndicator(client) {
+    // Red: any URL with score < 50 or policy violations
+    const hasLowScore = client.urls.some((u) => u.overall !== null && u.overall < 50);
+    if (hasLowScore || client.policyViolations > 0) {
+        return chalk.red("\u25cf");
+    }
+    // Yellow: some URLs below threshold (< 70)
+    const hasMediumScore = client.urls.some((u) => u.overall !== null && u.overall < 70);
+    if (hasMediumScore) {
+        return chalk.yellow("\u25cf");
+    }
+    // Green: all URLs passing or above 70
+    return chalk.green("\u25cf");
+}
+/**
+ * Get trend arrow for display.
+ */
+function getTrendArrow(trend) {
+    switch (trend) {
+        case "improving":
+            return chalk.green("\u2191");
+        case "declining":
+            return chalk.red("\u2193");
+        case "stable":
+            return chalk.dim("-");
+        default:
+            return chalk.dim("?");
+    }
+}
+/**
+ * Pad a string to the right to a given width.
+ */
+function padRight(str, width) {
+    if (str.length >= width)
+        return str;
+    return str + " ".repeat(width - str.length);
+}
+/**
+ * Truncate a string to a maximum length with ellipsis.
+ */
+function truncate(str, maxLen) {
+    if (str.length <= maxLen)
+        return str;
+    return str.slice(0, maxLen - 1) + "\u2026";
+}
+/**
+ * Format the consolidated report as human-readable output.
+ */
+function formatHumanReport(report) {
+    const lines = [];
+    // Header
+    lines.push("");
+    lines.push(chalk.bold(`Consolidated Report: ${report.orgName}`));
+    lines.push(chalk.dim(`Generated: ${new Date(report.generatedAt).toISOString().split("T")[0]}`));
+    lines.push("");
+    // Per-client sections
+    for (const client of report.clients) {
+        const indicator = getStatusIndicator(client);
+        const avgStr = client.averageScore !== null
+            ? String(client.averageScore)
+            : "n/a";
+        lines.push(`${indicator} ${chalk.bold(client.name)} (avg: ${avgStr})`);
+        // URL table
+        const urlWidth = 40;
+        const scoreWidth = 8;
+        const policyWidth = 10;
+        const trendWidth = 6;
+        const header = "  " +
+            padRight("URL", urlWidth) +
+            padRight("Score", scoreWidth) +
+            padRight("Policy", policyWidth) +
+            padRight("Trend", trendWidth);
+        lines.push(chalk.dim(header));
+        lines.push(chalk.dim("  " + "-".repeat(urlWidth + scoreWidth + policyWidth + trendWidth)));
+        for (const u of client.urls) {
+            const scoreStr = u.overall !== null ? String(u.overall) : "n/a";
+            const policyStr = u.policyStatus === "passing"
+                ? chalk.green("pass")
+                : u.policyStatus === "failing"
+                    ? chalk.red("fail")
+                    : chalk.dim("none");
+            const trendStr = getTrendArrow(u.trend);
+            const row = "  " +
+                padRight(truncate(u.url, urlWidth - 2), urlWidth) +
+                padRight(scoreStr, scoreWidth) +
+                padRight(policyStr, policyWidth) +
+                trendStr;
+            lines.push(row);
+        }
+        lines.push("");
+    }
+    // Summary
+    lines.push(chalk.bold("Summary"));
+    lines.push(`  Clients: ${report.summary.totalClients}  |  URLs: ${report.summary.totalUrls}  |  Avg Score: ${report.summary.averageScore ?? "n/a"}`);
+    lines.push(`  Policies: ${chalk.green(String(report.summary.passingPolicies) + " passing")}  ${chalk.red(String(report.summary.failingPolicies) + " failing")}`);
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Format the consolidated report as CSV.
+ */
+function formatCsvReport(report) {
+    const lines = [];
+    // Header
+    lines.push("Client,URL,Overall,Accessibility,Performance,UX,Policy,Trend");
+    // Data rows
+    for (const client of report.clients) {
+        for (const u of client.urls) {
+            const overall = u.overall !== null ? String(u.overall) : "";
+            const accessibility = u.scores.accessibility !== undefined
+                ? String(u.scores.accessibility)
+                : "";
+            const performance = u.scores.performance !== undefined
+                ? String(u.scores.performance)
+                : "";
+            const ux = u.scores.ux !== undefined ? String(u.scores.ux) : "";
+            const policy = u.policyStatus;
+            const trend = u.trend;
+            // Escape client name and URL for CSV (wrap in quotes if contains comma)
+            const escapeCsv = (s) => s.includes(",") || s.includes('"')
+                ? `"${s.replace(/"/g, '""')}"`
+                : s;
+            lines.push([
+                escapeCsv(client.name),
+                escapeCsv(u.url),
+                overall,
+                accessibility,
+                performance,
+                ux,
+                policy,
+                trend,
+            ].join(","));
+        }
+    }
+    return lines.join("\n") + "\n";
+}
+/**
+ * Register the report command with the Commander program.
+ */
+export function registerReportCommand(program) {
+    program
+        .command("report")
+        .description("Generate consolidated reports")
+        .option("--clients", "Generate multi-client consolidated report")
+        .option("--client <names>", "Comma-separated client names/slugs (default: all)")
+        .option("--format <format>", "Output format: human|json|csv", "human")
+        .option("--output <path>", "Write report to file instead of stdout")
+        .action(async (options) => {
+        try {
+            // Currently only consolidated client reports are supported
+            if (!options.clients) {
+                process.stderr.write(chalk.yellow("The report command requires --clients flag.\n"));
+                process.stderr.write(chalk.dim("Usage: vertaa report --clients [--client <names>] [--format human|json|csv]\n"));
+                process.exit(1);
+                return;
+            }
+            const { base, apiKey } = resolveConnection();
+            // Build API URL with optional client filter
+            let apiPath = "/reports/consolidated";
+            if (options.client) {
+                const encoded = encodeURIComponent(options.client);
+                apiPath += `?clients=${encoded}`;
+            }
+            const report = await apiRequest(base, apiPath, { method: "GET" }, apiKey);
+            // Format output
+            let output;
+            if (options.format === "json") {
+                output = JSON.stringify(report, null, 2) + "\n";
+            }
+            else if (options.format === "csv") {
+                output = formatCsvReport(report);
+            }
+            else {
+                output = formatHumanReport(report);
+            }
+            // Write to file or stdout
+            if (options.output) {
+                fs.writeFileSync(options.output, output, "utf-8");
+                process.stderr.write(chalk.green(`Report written to ${options.output}\n`));
+            }
+            else {
+                process.stdout.write(output);
+            }
+        }
+        catch (error) {
+            process.stderr.write(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}\n`));
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/suggest.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Suggest command for VertaaUX CLI.
+ *
+ * Converts natural language intent into exact CLI command(s).
+ * Uses local command catalog matching first, with API fallback
+ * for complex intents.
+ *
+ * Examples:
+ *   vertaa suggest "check contrast issues"
+ *   vertaa suggest "compare two pages"
+ *   vertaa suggest "set up CI quality gate"
+ */
+import { Command } from "commander";
+/**
+ * Register the suggest command with the Commander program.
+ */
+export declare function registerSuggestCommand(program: Command): void;
+//# sourceMappingURL=suggest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"suggest.d.ts","sourceRoot":"","sources":["../../src/commands/suggest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoDpC;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAqH7D"}

package/dist/commands/suggest.js

@@ -0,0 +1,152 @@
+/**
+ * Suggest command for VertaaUX CLI.
+ *
+ * Converts natural language intent into exact CLI command(s).
+ * Uses local command catalog matching first, with API fallback
+ * for complex intents.
+ *
+ * Examples:
+ *   vertaa suggest "check contrast issues"
+ *   vertaa suggest "compare two pages"
+ *   vertaa suggest "set up CI quality gate"
+ */
+import chalk from "chalk";
+import { ExitCode } from "../utils/exit-codes.js";
+import { resolveApiBase, getApiKey, hasApiKey, apiRequest } 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 { findMatches } from "../prompts/command-catalog.js";
+import { AI_TIMEOUT_MS } from "../utils/ai-error.js";
+/**
+ * Format suggestion for human-readable output.
+ */
+function formatSuggestHuman(results) {
+    const lines = [];
+    for (const result of results) {
+        lines.push(`  ${chalk.cyan.bold("$")} ${chalk.bold(result.command)}`);
+        lines.push(`  ${chalk.dim(result.explanation)}`);
+        lines.push("");
+    }
+    if (results.length === 0) {
+        lines.push(chalk.yellow("No matching commands found."));
+        lines.push(chalk.dim("Try: vertaa --help"));
+    }
+    return lines.join("\n");
+}
+/**
+ * Format suggestion for JSON output.
+ */
+function formatSuggestJson(results) {
+    return {
+        suggestions: results.map((r) => ({
+            command: r.command,
+            explanation: r.explanation,
+            source: r.source,
+            confidence: r.confidence,
+        })),
+    };
+}
+/**
+ * Register the suggest command with the Commander program.
+ */
+export function registerSuggestCommand(program) {
+    program
+        .command("suggest <intent...>")
+        .description("Convert natural language to exact CLI command(s)")
+        .option("-f, --format <format>", "Output format: json | human")
+        .addHelpText("after", `
+Examples:
+  vertaa suggest "check accessibility"
+  vertaa suggest "audit my site for CI"
+  vertaa suggest "compare two pages"
+  vertaa suggest "what failed in my audit"
+`)
+        .action(async (intentParts, options, command) => {
+        try {
+            const globalOpts = command.optsWithGlobals();
+            const config = await resolveConfig(globalOpts.config);
+            const machineMode = globalOpts.machine || false;
+            const format = resolveCommandFormat("suggest", options.format, machineMode);
+            const intent = intentParts.join(" ");
+            // Step 1: Local fuzzy match against command catalog
+            const localMatches = findMatches(intent);
+            let results;
+            if (localMatches.length > 0 && localMatches[0].score >= 0.2) {
+                // Good local matches — use them
+                results = localMatches.map((m) => ({
+                    command: m.entry.command,
+                    explanation: m.entry.description,
+                    source: "local",
+                    confidence: Math.round(m.score * 100),
+                }));
+            }
+            else if (hasApiKey(config)) {
+                // No strong local match — try API
+                const spinner = createSpinner("Thinking...");
+                try {
+                    const base = resolveApiBase(globalOpts.base);
+                    const apiKey = getApiKey(config.apiKey);
+                    const response = await Promise.race([
+                        apiRequest(base, "/cli/ai/suggest", {
+                            method: "POST",
+                            body: { intent },
+                        }, apiKey),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error("LLM request timed out")), AI_TIMEOUT_MS)),
+                    ]);
+                    succeedSpinner(spinner, "Done");
+                    if (response.data?.suggestions?.length) {
+                        results = response.data.suggestions.map((s) => ({
+                            command: s.command,
+                            explanation: s.explanation,
+                            source: "api",
+                            confidence: 80,
+                        }));
+                    }
+                    else {
+                        // API returned nothing — fall back to partial local matches
+                        results = localMatches.map((m) => ({
+                            command: m.entry.command,
+                            explanation: m.entry.description,
+                            source: "local",
+                            confidence: Math.round(m.score * 100),
+                        }));
+                    }
+                }
+                catch (error) {
+                    // Suggest degrades gracefully — fall back to local catalog
+                    // instead of hard exit via handleAiCommandError
+                    failSpinner(spinner, "API unavailable — using local catalog");
+                    // API failed — use whatever local matches we have
+                    results = localMatches.map((m) => ({
+                        command: m.entry.command,
+                        explanation: m.entry.description,
+                        source: "local",
+                        confidence: Math.round(m.score * 100),
+                    }));
+                }
+            }
+            else {
+                // No API key — use partial local matches
+                results = localMatches.map((m) => ({
+                    command: m.entry.command,
+                    explanation: m.entry.description,
+                    source: "local",
+                    confidence: Math.round(m.score * 100),
+                }));
+            }
+            // Output
+            if (format === "json") {
+                writeJsonOutput(formatSuggestJson(results), "suggest");
+            }
+            else {
+                writeOutput(formatSuggestHuman(results));
+            }
+        }
+        catch (error) {
+            console.error("Error:", error instanceof Error ? error.message : String(error));
+            process.exit(ExitCode.ERROR);
+        }
+    });
+}

package/dist/commands/triage.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Triage command for VertaaUX CLI.
+ *
+ * Accepts full audit JSON (via stdin, --file, or --job) and calls the
+ * LLM triage endpoint to produce P0/P1/P2 priority buckets with effort
+ * estimates and a quick-wins list.
+ *
+ * Default output shows bucket counts; --verbose expands each bucket.
+ *
+ * Examples:
+ *   vertaa audit https://example.com --json | vertaa triage
+ *   vertaa triage --job abc123
+ *   vertaa triage --file audit.json --verbose
+ */
+import { Command } from "commander";
+export declare function registerTriageCommand(program: Command): void;
+//# sourceMappingURL=triage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"triage.d.ts","sourceRoot":"","sources":["../../src/commands/triage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAuJpC,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA+G5D"}

package/dist/commands/triage.js

@@ -0,0 +1,205 @@
+/**
+ * Triage command for VertaaUX CLI.
+ *
+ * Accepts full audit JSON (via stdin, --file, or --job) and calls the
+ * LLM triage endpoint to produce P0/P1/P2 priority buckets with effort
+ * estimates and a quick-wins list.
+ *
+ * Default output shows bucket counts; --verbose expands each bucket.
+ *
+ * Examples:
+ *   vertaa audit https://example.com --json | vertaa triage
+ *   vertaa triage --job abc123
+ *   vertaa triage --file audit.json --verbose
+ */
+import chalk from "chalk";
+import { ExitCode } from "../utils/exit-codes.js";
+import { resolveApiBase, getApiKey, apiRequest } 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 } from "../ui/spinner.js";
+import { readJsonInput } from "../utils/stdin.js";
+import { handleAiCommandError, AI_TIMEOUT_MS } from "../utils/ai-error.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function normalizeIssues(issues) {
+    let list;
+    if (Array.isArray(issues)) {
+        list = issues;
+    }
+    else if (issues && typeof issues === "object") {
+        list = Object.values(issues).flatMap((v) => Array.isArray(v) ? v : []);
+    }
+    else {
+        return [];
+    }
+    return list.map((raw) => {
+        const i = raw;
+        return {
+            id: i.id || i.ruleId || i.rule_id || null,
+            title: i.title || i.description || null,
+            description: i.description || null,
+            severity: i.severity || null,
+            category: i.category || null,
+            selector: i.selector || null,
+            wcag_reference: i.wcag_reference || null,
+            recommendation: i.recommendation || i.recommended_fix || null,
+        };
+    });
+}
+// ---------------------------------------------------------------------------
+// Formatters
+// ---------------------------------------------------------------------------
+const EFFORT_LABELS = {
+    trivial: chalk.green("trivial"),
+    small: chalk.green("small"),
+    medium: chalk.yellow("medium"),
+    large: chalk.red("large"),
+};
+function formatEffort(effort) {
+    return EFFORT_LABELS[effort] || chalk.dim(effort);
+}
+function formatTriageHuman(data, verbose) {
+    const lines = [];
+    // P0
+    lines.push(chalk.red.bold(`P0 Critical (${data.p0_critical.length})`));
+    if (verbose) {
+        for (const item of data.p0_critical) {
+            lines.push(`  ${chalk.red(">")} ${chalk.bold(item.title)}${item.id ? chalk.dim(` (${item.id})`) : ""}`);
+            lines.push(`    ${item.reason}`);
+            lines.push(`    Effort: ${formatEffort(item.effort)}`);
+        }
+    }
+    else if (data.p0_critical.length > 0) {
+        lines.push(`  ${data.p0_critical.map((i) => i.title).join(", ")}`);
+    }
+    lines.push("");
+    // P1
+    lines.push(chalk.yellow.bold(`P1 Important (${data.p1_important.length})`));
+    if (verbose) {
+        for (const item of data.p1_important) {
+            lines.push(`  ${chalk.yellow(">")} ${chalk.bold(item.title)}${item.id ? chalk.dim(` (${item.id})`) : ""}`);
+            lines.push(`    ${item.reason}`);
+            lines.push(`    Effort: ${formatEffort(item.effort)}`);
+        }
+    }
+    else if (data.p1_important.length > 0) {
+        lines.push(`  ${data.p1_important.map((i) => i.title).join(", ")}`);
+    }
+    lines.push("");
+    // P2
+    lines.push(chalk.cyan.bold(`P2 Nice to Have (${data.p2_nice_to_have.length})`));
+    if (verbose) {
+        for (const item of data.p2_nice_to_have) {
+            lines.push(`  ${chalk.cyan(">")} ${chalk.bold(item.title)}${item.id ? chalk.dim(` (${item.id})`) : ""}`);
+            lines.push(`    ${item.reason}`);
+            lines.push(`    Effort: ${formatEffort(item.effort)}`);
+        }
+    }
+    else if (data.p2_nice_to_have.length > 0) {
+        lines.push(`  ${data.p2_nice_to_have.map((i) => i.title).join(", ")}`);
+    }
+    lines.push("");
+    // Quick wins
+    if (data.quick_wins.length > 0) {
+        lines.push(chalk.green.bold("Quick Wins (< 5 min each)"));
+        for (const win of data.quick_wins) {
+            lines.push(`  ${chalk.green("*")} ${win}`);
+        }
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Command Registration
+// ---------------------------------------------------------------------------
+export function registerTriageCommand(program) {
+    program
+        .command("triage")
+        .description("Prioritize audit findings into P0/P1/P2 buckets with effort estimates")
+        .option("--job <job-id>", "Fetch audit data from a job ID")
+        .option("--file <path>", "Load audit JSON from file")
+        .option("-f, --format <format>", "Output format: json | human")
+        .addHelpText("after", `
+Examples:
+  vertaa audit https://example.com --json | vertaa triage
+  vertaa triage --job abc123
+  vertaa triage --file audit.json --verbose
+`)
+        .action(async (options, command) => {
+        try {
+            const globalOpts = command.optsWithGlobals();
+            const config = await resolveConfig(globalOpts.config);
+            const machineMode = globalOpts.machine || false;
+            const verbose = globalOpts.verbose || false;
+            const format = resolveCommandFormat("triage", options.format, machineMode);
+            // Resolve audit data
+            let auditPayload;
+            if (options.job) {
+                // Fetch from API
+                const base = resolveApiBase(globalOpts.base);
+                const apiKey = getApiKey(config.apiKey);
+                const result = await apiRequest(base, `/audit/${options.job}`, { method: "GET" }, apiKey);
+                const issues = normalizeIssues(result.issues);
+                auditPayload = {
+                    job_id: result.job_id || options.job,
+                    url: result.url || null,
+                    scores: result.scores || null,
+                    issues,
+                };
+            }
+            else {
+                // Read from stdin or --file
+                const input = await readJsonInput(options.file);
+                if (!input) {
+                    console.error("Error: No audit data provided.");
+                    console.error("Usage:");
+                    console.error("  vertaa audit https://example.com --json | vertaa triage");
+                    console.error("  vertaa triage --job <job-id>");
+                    console.error("  vertaa triage --file audit.json");
+                    process.exit(ExitCode.ERROR);
+                }
+                const data = input;
+                const innerData = (data.data && typeof data.data === "object" ? data.data : data);
+                const issues = normalizeIssues(innerData.issues);
+                auditPayload = {
+                    job_id: innerData.job_id || null,
+                    url: innerData.url || null,
+                    scores: innerData.scores || null,
+                    issues,
+                };
+            }
+            if (!Array.isArray(auditPayload.issues) ||
+                auditPayload.issues.length === 0) {
+                console.error("Error: No issues found in audit data.");
+                process.exit(ExitCode.ERROR);
+            }
+            // Auth check
+            const base = resolveApiBase(globalOpts.base);
+            const apiKey = getApiKey(config.apiKey);
+            // Call LLM triage API
+            const spinner = createSpinner("Triaging findings...");
+            try {
+                const response = await Promise.race([
+                    apiRequest(base, "/cli/ai/triage", { method: "POST", body: { audit: auditPayload } }, apiKey),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("LLM request timed out")), AI_TIMEOUT_MS)),
+                ]);
+                succeedSpinner(spinner, "Triage complete");
+                if (format === "json") {
+                    writeJsonOutput(response.data, "triage");
+                }
+                else {
+                    writeOutput(formatTriageHuman(response.data, verbose));
+                }
+            }
+            catch (error) {
+                handleAiCommandError(error, "triage", spinner);
+            }
+        }
+        catch (error) {
+            console.error("Error:", error instanceof Error ? error.message : String(error));
+            process.exit(ExitCode.ERROR);
+        }
+    });
+}

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

@@ -1 +1 @@
-{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../src/commands/upload.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyLpC;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiB5D"}
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../src/commands/upload.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA0LpC;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiB5D"}

package/dist/commands/upload.js

@@ -7,7 +7,7 @@
 import fs from "fs";
 import path from "path";
 import chalk from "chalk";
-import ora from "ora";
+import { createSpinner, succeedSpinner, failSpinner } from "../ui/spinner.js";
 import { loadToken } from "../auth/token-store.js";
 import { getCIToken } from "../auth/ci-token.js";
 import { resolveApiBase } from "../utils/client.js";
@@ -45,7 +45,8 @@ async function handleUpload(jobId, options) {
     const config = await resolveConfig(options.configPath);
     const apiBase = resolveApiBase(options.base);
     // Determine what to upload
-    const spinner = ora("Preparing upload...").start();
+    const spinner = createSpinner("Preparing upload...");
+    spinner.start();
     try {
         // If no job ID, find the most recent local result
         let targetJobId = jobId;
@@ -71,12 +72,12 @@ async function handleUpload(jobId, options) {
                 }
             }
             if (!targetJobId) {
-                spinner.fail("No job ID provided and no local results found.");
+                failSpinner(spinner, "No job ID provided and no local results found.");
                 console.error("Run `vertaa audit --save-trace` to save local results first.");
                 process.exit(ExitCode.ERROR);
             }
         }
-        spinner.text = `Uploading audit ${targetJobId}...`;
+        spinner.setText(`Uploading audit ${targetJobId}...`);
         // Prepare upload payload
         const payload = {
             job_id: targetJobId,
@@ -108,7 +109,7 @@ async function handleUpload(jobId, options) {
             const baseline = await loadBaseline(DEFAULT_BASELINE_PATH);
             if (baseline) {
                 payload.baseline = baseline;
-                spinner.text = `Uploading audit ${targetJobId} with baseline...`;
+                spinner.setText(`Uploading audit ${targetJobId} with baseline...`);
             }
         }
         // Make API request
@@ -128,7 +129,7 @@ async function handleUpload(jobId, options) {
         if (!result.success) {
             throw new Error(result.error?.message || "Upload failed");
         }
-        spinner.succeed("Upload complete!");
+        succeedSpinner(spinner, "Upload complete!");
         console.error("");
         console.error(`  Job ID: ${result.job_id}`);
         console.error(`  URL:    ${chalk.cyan(result.url)}`);
@@ -136,7 +137,7 @@ async function handleUpload(jobId, options) {
         console.error("Share this URL with your team to view the results.");
     }
     catch (error) {
-        spinner.fail("Upload failed");
+        failSpinner(spinner, "Upload failed");
         console.error(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
         process.exit(ExitCode.ERROR);
     }