@vertaaux/cli 0.2.3 → 0.3.0

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);
     }

package/dist/index.js

@@ -10,6 +10,7 @@ import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 import { Command } from "commander";
+import { setColorEnabled, shouldUseColor } from "@vertaaux/tui";
 import { showBanner, getVersion } from "./ui/banner.js";
 import { registerAuditCommand } from "./commands/audit.js";
 import { registerBaselineCommand } from "./commands/baseline.js";
@@ -22,6 +23,13 @@ import { registerUploadCommand } from "./commands/upload.js";
 import { registerDownloadCommand } from "./commands/download.js";
 import { registerPolicyCommand } from "./commands/policy.js";
 import { registerDoctorCommand } from "./commands/doctor.js";
+import { registerSuggestCommand } from "./commands/suggest.js";
+import { registerTriageCommand } from "./commands/triage.js";
+import { registerFixPlanCommand } from "./commands/fix-plan.js";
+import { registerPatchReviewCommand } from "./commands/patch-review.js";
+import { registerCompareCommand } from "./commands/compare.js";
+import { registerReleaseNotesCommand } from "./commands/release-notes.js";
+import { registerDocCommand } from "./commands/doc.js";
 import { ExitCode } from "./utils/exit-codes.js";
 import { formatCommanderError } from "./ui/diagnostics.js";
 import { parseMode, parseTimeout, parseInterval, parseScore } from "./utils/validators.js";
@@ -625,7 +633,7 @@ async function runCompareCommand(base, urls, flags) {
     }
     printOutput(format, compare, formatCompareMarkdown(compare));
 }
-async function runFixCommand(base, jobId, issueId, flags) {
+async function runFixCommand(base, jobId, issueId, flags, globalFlags = {}) {
     const fileContent = getString(flags, "file-content");
     const format = resolveFormat(flags);
     if (!fileContent) {
@@ -649,8 +657,12 @@ async function runFixCommand(base, jobId, issueId, flags) {
     if (!result.success) {
         process.exitCode = 1;
     }
+    if (globalFlags.dryRun && isTTYOutput) {
+        process.stderr.write("[dry-run] Showing patch preview — no changes applied.\n\n");
+    }
     if (format === "json") {
-        console.log(JSON.stringify(result, null, 2));
+        const output = globalFlags.dryRun ? { ...result, dry_run: true } : result;
+        console.log(JSON.stringify(output, null, 2));
     }
     else {
         if (result.success && result.patch) {
@@ -708,7 +720,7 @@ async function runVerifyCommand(base, flags) {
     }
 }
 const BATCH_LIMIT = 10;
-async function runFixAllCommand(base, jobId, flags) {
+async function runFixAllCommand(base, jobId, flags, globalFlags = {}) {
     const fileContent = getString(flags, "file-content");
     const autoFixOnly = getBool(flags, "auto-fix-only");
     const format = resolveFormat(flags);
@@ -741,6 +753,21 @@ async function runFixAllCommand(base, jobId, flags) {
     if (isTTYOutput) {
         process.stderr.write("                    \r");
     }
+    // --dry-run: show what would be processed and exit
+    if (globalFlags.dryRun) {
+        process.stderr.write(`[dry-run] Would generate patches for ${issuesToProcess.length} issues:\n`);
+        for (const issue of issuesToProcess) {
+            process.stderr.write(`  - ${issue.id || "unknown"}: ${issue.title || issue.description || "(no title)"}\n`);
+        }
+        if (totalSkipped > 0) {
+            process.stderr.write(`  (${totalSkipped} additional issues skipped — batch limit ${BATCH_LIMIT})\n`);
+        }
+        process.stderr.write("\nNo patches generated. Remove --dry-run to execute.\n");
+        return;
+    }
+    // --yes is available for future interactive confirmation steps
+    // Currently fix-all runs non-interactively, but --yes suppresses any
+    // confirmation prompts that may be added (e.g., "Apply all N patches?")
     const results = {
         successes: [],
         failures: [],
@@ -845,6 +872,13 @@ program
     .option("-q, --quiet", "Suppress banner and non-essential output")
     .option("--no-banner", "Hide the V-mark banner")
     .option("--machine", "Strict machine-readable output (JSON stdout, diagnostics stderr)")
+    .option("--color", "Force color output")
+    .option("--no-color", "Disable color output")
+    .option("--dashboard", "Force live dashboard during audit --wait")
+    .option("--no-dashboard", "Disable live dashboard (use spinner instead)")
+    .option("--dry-run", "Show what would happen without executing")
+    .option("-y, --yes", "Auto-confirm all interactive prompts")
+    .option("--verbose", "Expand output with additional details")
     .configureOutput({
     outputError: (str, _write) => {
         const formatted = formatCommanderError(str);
@@ -864,9 +898,20 @@ program
     .hook("preAction", (thisCommand) => {
     const opts = thisCommand.optsWithGlobals();
     const machineMode = opts.machine || false;
+    // Apply color settings from flags or environment
+    if (opts.color === false || process.env.NO_COLOR !== undefined) {
+        setColorEnabled(false);
+    }
+    else if (opts.color === true || process.env.FORCE_COLOR !== undefined) {
+        setColorEnabled(true);
+    }
+    else {
+        setColorEnabled(shouldUseColor());
+    }
     if (machineMode) {
         opts.quiet = true;
         opts.banner = false;
+        setColorEnabled(false);
     }
     showBanner({
         version,
@@ -886,6 +931,13 @@ registerUploadCommand(program);
 registerDownloadCommand(program);
 registerPolicyCommand(program);
 registerDoctorCommand(program);
+registerSuggestCommand(program);
+registerTriageCommand(program);
+registerFixPlanCommand(program);
+registerPatchReviewCommand(program);
+registerCompareCommand(program);
+registerReleaseNotesCommand(program);
+registerDocCommand(program);
 // Legacy commands using old argument parsing
 // These will be migrated in subsequent plans
 program
@@ -924,24 +976,7 @@ program
         process.exit(ExitCode.ERROR);
     }
 });
-program
-    .command("compare <urlA> <urlB>")
-    .description("Compare audits of two URLs")
-    .option("--mode <mode>", "Audit depth: basic|standard|deep", parseMode, "basic")
-    .option("--wait", "Wait for audits to complete")
-    .option("--timeout <ms>", "Wait timeout in milliseconds (1-300000)", parseTimeout, 60000)
-    .option("--interval <ms>", "Poll interval in milliseconds (1-300000)", parseInterval, 5000)
-    .option("--fail-on-score <n>", "Exit non-zero if score below n (0-100)", parseScore)
-    .action(async (urlA, urlB, cmdOptions) => {
-    try {
-        const base = resolveApiBase(cmdOptions);
-        await runCompareCommand(base, [urlA, urlB], cmdOptions);
-    }
-    catch (error) {
-        process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}\n`);
-        process.exit(ExitCode.ERROR);
-    }
-});
+// compare is now registered via registerCompareCommand (Phase 60)
 program
     .command("status <jobId>")
     .description("Get status of an audit job")
@@ -973,13 +1008,14 @@ program
     .description("Generate a fix patch for an issue")
     .requiredOption("--issue <id>", "Issue ID to fix")
     .requiredOption("--file-content <code>", "Source code content")
-    .action(async (jobId, cmdOptions) => {
+    .action(async (jobId, cmdOptions, command) => {
     try {
+        const globalOpts = command.optsWithGlobals();
         const base = resolveApiBase(cmdOptions);
         const issueId = getString(cmdOptions, "issue");
         if (!issueId)
             throw new Error("--issue is required");
-        await runFixCommand(base, jobId, issueId, cmdOptions);
+        await runFixCommand(base, jobId, issueId, cmdOptions, { dryRun: !!globalOpts.dryRun });
     }
     catch (error) {
         process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -991,10 +1027,11 @@ program
     .description("Generate fix patches for all issues in an audit")
     .requiredOption("--file-content <code>", "Source code content")
     .option("--auto-fix-only", "Only process auto-fixable issues")
-    .action(async (jobId, cmdOptions) => {
+    .action(async (jobId, cmdOptions, command) => {
     try {
+        const globalOpts = command.optsWithGlobals();
         const base = resolveApiBase(cmdOptions);
-        await runFixAllCommand(base, jobId, cmdOptions);
+        await runFixAllCommand(base, jobId, cmdOptions, { dryRun: !!globalOpts.dryRun, yes: !!globalOpts.yes });
     }
     catch (error) {
         process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}\n`);

package/dist/output/formats.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formats.d.ts","sourceRoot":"","sources":["../../src/output/formats.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAM7D,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAMzD,CAAC;AAEF,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAclF;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,WAAW,EAAE,OAAO,GACnB,MAAM,CASR"}
+{"version":3,"file":"formats.d.ts","sourceRoot":"","sources":["../../src/output/formats.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAa7D,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAazD,CAAC;AAEF,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAclF;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,WAAW,EAAE,OAAO,GACnB,MAAM,CASR"}

package/dist/output/formats.js

@@ -10,6 +10,13 @@ export const COMMAND_FORMATS = {
     explain: ["json", "human"],
     "policy-show": ["json", "yaml"],
     diff: ["json", "human"],
+    suggest: ["json", "human"],
+    triage: ["json", "human"],
+    "fix-plan": ["json", "human"],
+    "patch-review": ["json", "human"],
+    "release-notes": ["json", "human", "markdown"],
+    compare: ["json", "human"],
+    doc: ["json", "markdown"],
 };
 export const COMMAND_DEFAULT_FORMAT = {
     audit: "human",
@@ -17,6 +24,13 @@ export const COMMAND_DEFAULT_FORMAT = {
     explain: "human",
     "policy-show": "yaml",
     diff: "human",
+    suggest: "human",
+    triage: "human",
+    "fix-plan": "human",
+    "patch-review": "human",
+    "release-notes": "markdown",
+    compare: "human",
+    doc: "markdown",
 };
 export function validateFormat(command, format) {
     const allowed = COMMAND_FORMATS[command];