@vertaaux/cli 0.4.0 → 0.5.1

package/dist/commands/fix-all.js

@@ -0,0 +1,206 @@
+/**
+ * Legacy fix-all command handler.
+ * Generates fix patches for all issues in an audit.
+ */
+import { renderError, createRenderer, runSteps } from "@vertaaux/tui";
+import { ExitCode } from "../utils/exit-codes.js";
+import { resolveApiBase, resolveFormat, getString, getBool, createClient, } from "../utils/api-client.js";
+import { normalizeIssues, isAutoFixable, formatBatchMarkdown, } from "../utils/formatters.js";
+import { writeDataOutput, writeJsonOutput, writeOutput } from "../output/envelope.js";
+import { strings } from "../ui/strings.js";
+const BATCH_LIMIT = 10;
+export async function handleFixAll(opts) {
+    const { jobId } = opts;
+    const autoFixOnly = opts.autoFixOnly || false;
+    const format = opts.format || "md";
+    if (!opts.fileContent) {
+        throw new Error(strings.fixAll.errors.missingArgs);
+    }
+    const renderer = createRenderer("auto");
+    const baseState = {
+        phase: "fix-all",
+        phaseIndex: 1,
+        phaseTotal: 2,
+        url: "",
+        mode: "fix-all",
+        progress: {},
+        totals: {},
+        issueCount: 0,
+        scorePreview: null,
+        verbose: false,
+        elapsed: 0,
+    };
+    const startTime = Date.now();
+    const client = createClient({ base: opts.base });
+    const ctx = { results: null };
+    const steps = [
+        {
+            id: "analyze",
+            actionText: "Analyzing fixable issues...",
+            summaryText: "Issues identified",
+            run: async () => {
+                const audit = await client.audits.retrieve(jobId);
+                if (audit.status !== "completed") {
+                    throw new Error(`Audit ${jobId} is not completed (status: ${audit.status})`);
+                }
+                // Normalize and filter issues
+                let issues = normalizeIssues(audit.issues);
+                const totalRequested = issues.length;
+                if (autoFixOnly) {
+                    issues = issues.filter((issue) => {
+                        const typeId = issue.id || "";
+                        return isAutoFixable(typeId);
+                    });
+                }
+                // Respect batch limit
+                const totalSkipped = Math.max(0, issues.length - BATCH_LIMIT);
+                ctx.results = {
+                    successes: [],
+                    failures: [],
+                    totalRequested,
+                    totalSkipped,
+                };
+                // --dry-run: show what would be processed and exit
+                if (opts.dryRun) {
+                    const issuesToShow = issues.slice(0, BATCH_LIMIT);
+                    const lines = [];
+                    lines.push(`[dry-run] Would generate patches for ${issuesToShow.length} issues:`);
+                    for (const issue of issuesToShow) {
+                        lines.push(`  - ${issue.id || "unknown"}: ${issue.title || issue.description || "(no title)"}`);
+                    }
+                    if (totalSkipped > 0) {
+                        lines.push(`  (${totalSkipped} additional issues skipped — batch limit ${BATCH_LIMIT})`);
+                    }
+                    lines.push("\nNo patches generated. Remove --dry-run to execute.");
+                    writeOutput(lines.join("\n"));
+                }
+            },
+        },
+        {
+            id: "fix",
+            actionText: "Applying fixes...",
+            summaryText: "Fixes applied",
+            run: async () => {
+                if (opts.dryRun || !ctx.results)
+                    return;
+                const audit = await client.audits.retrieve(jobId);
+                let issues = normalizeIssues(audit.issues);
+                if (autoFixOnly) {
+                    issues = issues.filter((issue) => {
+                        const typeId = issue.id || "";
+                        return isAutoFixable(typeId);
+                    });
+                }
+                const issuesToProcess = issues.slice(0, BATCH_LIMIT);
+                for (let i = 0; i < issuesToProcess.length; i++) {
+                    const issue = issuesToProcess[i];
+                    const curIssueId = issue.id || `issue-${i}`;
+                    try {
+                        const patchResult = await client.patches.generate({
+                            job_id: jobId,
+                            issue_id: curIssueId,
+                            file_content: opts.fileContent,
+                        });
+                        if (patchResult.success && patchResult.patch) {
+                            ctx.results.successes.push({
+                                issueId: curIssueId,
+                                patch: patchResult.patch,
+                            });
+                        }
+                        else {
+                            ctx.results.failures.push({
+                                issueId: curIssueId,
+                                reason: patchResult.error?.code || "PATCH_FAILED",
+                                details: patchResult.error?.message,
+                            });
+                        }
+                    }
+                    catch (err) {
+                        ctx.results.failures.push({
+                            issueId: curIssueId,
+                            reason: "REQUEST_ERROR",
+                            details: err instanceof Error ? err.message : String(err),
+                        });
+                    }
+                }
+            },
+        },
+    ];
+    const { success, states } = await runSteps(steps, {
+        onStateChange: (stepStates) => {
+            renderer.update({ ...baseState, stepStates, elapsed: Date.now() - startTime });
+        },
+    });
+    renderer.finish({
+        url: "",
+        mode: "fix-all",
+        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;
+    }
+    const finalResults = ctx.results;
+    if (!opts.dryRun && finalResults !== null) {
+        // Exit code 1 if any failures
+        if (finalResults.failures.length > 0) {
+            process.exitCode = 1;
+        }
+        if (format === "json") {
+            writeJsonOutput(finalResults, "fix-all");
+        }
+        else {
+            writeDataOutput(formatBatchMarkdown(finalResults));
+        }
+    }
+}
+/**
+ * Shared fix-all runner used by the fix-all command (legacy wrapper for backward compat).
+ */
+export async function runFixAllCommand(base, jobId, flags, globalFlags = {}) {
+    const fileContent = getString(flags, "file-content");
+    const autoFixOnly = getBool(flags, "auto-fix-only");
+    const format = resolveFormat(flags);
+    if (!fileContent) {
+        throw new Error(strings.fixAll.errors.missingArgs);
+    }
+    await handleFixAll({
+        base,
+        jobId,
+        fileContent,
+        autoFixOnly,
+        format,
+        dryRun: globalFlags.dryRun,
+        yes: globalFlags.yes,
+    });
+}
+export function registerFixAllCommand(program) {
+    program
+        .command("fix-all <jobId>")
+        .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, command) => {
+        try {
+            const globalOpts = command.optsWithGlobals();
+            const base = resolveApiBase(cmdOptions);
+            await runFixAllCommand(base, jobId, cmdOptions, { dryRun: !!globalOpts.dryRun, yes: !!globalOpts.yes });
+        }
+        catch (error) {
+            process.stderr.write(renderError({
+                message: error instanceof Error ? error.message : String(error),
+                suggestion: "vertaa explain <id>",
+                exitCode: ExitCode.ERROR,
+            }) + "\n");
+            process.exit(ExitCode.ERROR);
+        }
+    });
+}

package/dist/commands/fix-plan.d.ts

@@ -11,5 +11,14 @@
  *   vertaa fix-plan --file audit.json --json
  */
 import { Command } from "commander";
+export interface FixPlanCommandOptions {
+    job?: string;
+    file?: string;
+    format?: string;
+    base?: string;
+    machine?: boolean;
+    apiKey?: string;
+}
+export declare function handleFixPlan(opts: FixPlanCommandOptions): Promise<void>;
 export declare function registerFixPlanCommand(program: Command): void;
 //# sourceMappingURL=fix-plan.d.ts.map

package/dist/commands/fix-plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fix-plan.d.ts","sourceRoot":"","sources":["../../src/commands/fix-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAuIpC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA6G7D"}
+{"version":3,"file":"fix-plan.d.ts","sourceRoot":"","sources":["../../src/commands/fix-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA8IpC,MAAM,WAAW,qBAAqB;IACpC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,aAAa,CAAC,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiI9E;AAMD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA2C7D"}

package/dist/commands/fix-plan.js

@@ -10,15 +10,15 @@
  *   vertaa fix-plan --job abc123
  *   vertaa fix-plan --file audit.json --json
  */
-import chalk from "chalk";
+import { bold, dim, colorize, boldColor, brand, severity as severityPalette, renderError, createRenderer, runSteps } from "@vertaaux/tui";
 import { ExitCode } from "../utils/exit-codes.js";
-import { resolveApiBase, getApiKey, apiRequest } from "../utils/client.js";
+import { resolveApiBase, getApiKey, apiRequest, createClient } from "../utils/client.js";
 import { resolveConfig } from "../config/loader.js";
-import { writeJsonOutput, writeOutput } from "../output/envelope.js";
+import { writeDataOutput, writeJsonOutput } 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";
+import { AI_TIMEOUT_MS } from "../utils/ai-error.js";
+import { strings } from "../ui/strings.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -50,46 +50,158 @@ function normalizeIssues(issues) {
 // ---------------------------------------------------------------------------
 // Formatters
 // ---------------------------------------------------------------------------
-const SEVERITY_COLORS = {
-    critical: chalk.red.bold,
-    high: chalk.red,
-    medium: chalk.yellow,
-    low: chalk.cyan,
-};
+function severityColor(sev, text) {
+    switch (sev) {
+        case "critical":
+            return boldColor(text, severityPalette.critical);
+        case "high":
+            return colorize(text, severityPalette.error);
+        case "medium":
+            return colorize(text, severityPalette.warning);
+        case "low":
+            return colorize(text, brand.cyan);
+        default:
+            return dim(text);
+    }
+}
 const EFFORT_LABELS = {
-    trivial: chalk.green("trivial"),
-    small: chalk.green("small"),
-    medium: chalk.yellow("medium"),
-    large: chalk.red("large"),
+    trivial: colorize("trivial", brand.lime),
+    small: colorize("small", brand.lime),
+    medium: colorize("medium", severityPalette.warning),
+    large: colorize("large", severityPalette.error),
 };
 const FIX_TYPE_LABELS = {
-    code: chalk.blue("code"),
-    config: chalk.magenta("config"),
-    content: chalk.cyan("content"),
-    design: chalk.yellow("design"),
+    code: colorize("code", brand.teal),
+    config: colorize("config", brand.tealLight),
+    content: colorize("content", brand.cyan),
+    design: colorize("design", severityPalette.warning),
 };
 function formatFixPlanHuman(data) {
     const lines = [];
-    lines.push(chalk.bold(`Remediation Plan (${data.items.length} items)`));
-    lines.push(chalk.dim(`Estimated total effort: ${data.estimated_total_effort}`));
+    lines.push(bold(`Remediation Plan (${data.items.length} items)`));
+    lines.push(dim(`Estimated total effort: ${data.estimated_total_effort}`));
     lines.push("");
     for (let idx = 0; idx < data.items.length; idx++) {
         const item = data.items[idx];
-        const severityFn = SEVERITY_COLORS[item.severity] || chalk.dim;
-        const effort = EFFORT_LABELS[item.effort] || chalk.dim(item.effort);
-        const fixType = FIX_TYPE_LABELS[item.fix_type] || chalk.dim(item.fix_type);
-        lines.push(`${chalk.bold(`${idx + 1}.`)} ${severityFn(`[${item.severity}]`)} ${chalk.bold(item.title)}`);
-        lines.push(`   Effort: ${effort}  Type: ${fixType}${item.id ? chalk.dim(`  (${item.id})`) : ""}`);
+        const effort = EFFORT_LABELS[item.effort] || dim(item.effort);
+        const fixType = FIX_TYPE_LABELS[item.fix_type] || dim(item.fix_type);
+        lines.push(`${bold(`${idx + 1}.`)} ${severityColor(item.severity, `[${item.severity}]`)} ${bold(item.title)}`);
+        lines.push(`   Effort: ${effort}  Type: ${fixType}${item.id ? dim(`  (${item.id})`) : ""}`);
         for (let s = 0; s < item.steps.length; s++) {
-            lines.push(`   ${chalk.dim(`${s + 1})`)} ${item.steps[s]}`);
+            lines.push(`   ${dim(`${s + 1})`)} ${item.steps[s]}`);
         }
         if (item.code_hint) {
-            lines.push(`   ${chalk.dim("Hint:")} ${chalk.italic(item.code_hint)}`);
+            lines.push(`   ${dim("Hint:")} ${item.code_hint}`);
         }
         lines.push("");
     }
     return lines.join("\n");
 }
+export async function handleFixPlan(opts) {
+    const config = { apiKey: opts.apiKey };
+    const format = resolveCommandFormat("fix-plan", opts.format, opts.machine || false);
+    const renderer = createRenderer("auto");
+    const baseState = {
+        phase: "fix-plan",
+        phaseIndex: 1,
+        phaseTotal: 2,
+        url: "",
+        mode: "fix-plan",
+        progress: {},
+        totals: {},
+        issueCount: 0,
+        scorePreview: null,
+        verbose: false,
+        elapsed: 0,
+    };
+    const startTime = Date.now();
+    let responseData = null;
+    const steps = [
+        {
+            id: "analyze",
+            actionText: strings.fixPlan.generate.action,
+            summaryText: "Issues analyzed",
+            run: async () => {
+                let auditPayload;
+                if (opts.job) {
+                    const sdkClient = createClient({ base: opts.base, apiKey: config.apiKey });
+                    const result = await sdkClient.audits.retrieve(opts.job);
+                    const issues = normalizeIssues(result.issues);
+                    auditPayload = {
+                        job_id: result.job_id || opts.job,
+                        url: result.url || null,
+                        scores: result.scores || null,
+                        issues,
+                    };
+                }
+                else {
+                    const input = await readJsonInput(opts.file);
+                    if (!input) {
+                        throw new Error("No audit data provided.\nUsage:\n  vertaa audit https://example.com --json | vertaa fix-plan\n  vertaa fix-plan --job <job-id>\n  vertaa fix-plan --file audit.json");
+                    }
+                    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) {
+                    throw new Error("No issues found in audit data.");
+                }
+                const base = resolveApiBase(opts.base);
+                const apiKey = getApiKey(config.apiKey);
+                const response = await Promise.race([
+                    apiRequest(base, "/cli/ai/fix-plan", { method: "POST", body: { audit: auditPayload } }, apiKey),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("LLM request timed out")), AI_TIMEOUT_MS)),
+                ]);
+                responseData = response.data;
+            },
+        },
+        {
+            id: "plan",
+            actionText: "Generating fix plan...",
+            summaryText: responseData ? strings.fixPlan.generate.done(responseData.items.length) : "Fix plan generated",
+            run: async () => {
+                // Fix plan generated in analyze step via API call
+            },
+        },
+    ];
+    const { success, states } = await runSteps(steps, {
+        onStateChange: (stepStates) => {
+            renderer.update({ ...baseState, stepStates, elapsed: Date.now() - startTime });
+        },
+    });
+    renderer.finish({
+        url: "",
+        mode: "fix-plan",
+        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, "fix-plan");
+        }
+        else {
+            writeDataOutput(formatFixPlanHuman(responseData));
+        }
+    }
+}
 // ---------------------------------------------------------------------------
 // Command Registration
 // ---------------------------------------------------------------------------
@@ -100,6 +212,7 @@ export function registerFixPlanCommand(program) {
         .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")
+        .option("--json", "Alias for --format json")
         .addHelpText("after", `
 Examples:
   vertaa audit https://example.com --json | vertaa fix-plan
@@ -112,70 +225,21 @@ Examples:
             const globalOpts = command.optsWithGlobals();
             const config = await resolveConfig(globalOpts.config);
             const machineMode = globalOpts.machine || false;
-            const format = resolveCommandFormat("fix-plan", options.format, machineMode);
-            // Resolve audit data
-            let auditPayload;
-            if (options.job) {
-                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 {
-                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 fix-plan");
-                    console.error("  vertaa fix-plan --job <job-id>");
-                    console.error("  vertaa fix-plan --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 fix-plan API
-            const spinner = createSpinner("Generating remediation plan...");
-            try {
-                const response = await Promise.race([
-                    apiRequest(base, "/cli/ai/fix-plan", { method: "POST", body: { audit: auditPayload } }, apiKey),
-                    new Promise((_, reject) => setTimeout(() => reject(new Error("LLM request timed out")), AI_TIMEOUT_MS)),
-                ]);
-                succeedSpinner(spinner, "Plan ready");
-                if (format === "json") {
-                    writeJsonOutput(response.data, "fix-plan");
-                }
-                else {
-                    writeOutput(formatFixPlanHuman(response.data));
-                }
-            }
-            catch (error) {
-                handleAiCommandError(error, "fix-plan", spinner);
-            }
+            await handleFixPlan({
+                job: options.job,
+                file: options.file,
+                format: options.json ? "json" : options.format,
+                base: globalOpts.base,
+                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 explain <id>",
+                exitCode: ExitCode.ERROR,
+            }) + "\n");
             process.exit(ExitCode.ERROR);
         }
     });

package/dist/commands/fix.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Legacy fix command handler.
+ * Generates a fix patch for an issue.
+ */
+import type { Command } from "commander";
+import type { Flags } from "../types.js";
+/**
+ * Shared fix runner used by the fix command.
+ */
+export declare function runFixCommand(base: string, jobId: string, issueId: string, flags: Flags, globalFlags?: {
+    dryRun?: boolean;
+}): Promise<void>;
+export declare function handleFix(jobId: string, cmdOptions: Flags, globalFlags?: {
+    dryRun?: boolean;
+}): Promise<void>;
+export declare function registerFixCommand(program: Command): void;
+//# sourceMappingURL=fix.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fix.d.ts","sourceRoot":"","sources":["../../src/commands/fix.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAczC,OAAO,KAAK,EAAE,KAAK,EAAiB,MAAM,aAAa,CAAC;AAGxD;;GAEG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,KAAK,EACZ,WAAW,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,iBAiCvC;AAED,wBAAsB,SAAS,CAC7B,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,KAAK,EACjB,WAAW,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GACrC,OAAO,CAAC,IAAI,CAAC,CAiDf;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAqBzD"}

package/dist/commands/fix.js

@@ -0,0 +1,111 @@
+/**
+ * Legacy fix command handler.
+ * Generates a fix patch for an issue.
+ */
+import { renderError, runSteps, createRenderer } from "@vertaaux/tui";
+import { ExitCode } from "../utils/exit-codes.js";
+import { resolveApiBase, resolveFormat, getString, createClient, } from "../utils/api-client.js";
+import { formatPatchMarkdown, } from "../utils/formatters.js";
+import { writeDataOutput, writeJsonOutput } from "../output/envelope.js";
+import { strings } from "../ui/strings.js";
+/**
+ * Shared fix runner used by the fix command.
+ */
+export async function runFixCommand(base, jobId, issueId, flags, globalFlags = {}) {
+    const fileContent = getString(flags, "file-content");
+    const format = resolveFormat(flags);
+    if (!fileContent) {
+        throw new Error(strings.fix.errors.missingArgs);
+    }
+    const client = createClient({ base });
+    const result = await client.patches.generate({
+        job_id: jobId,
+        issue_id: issueId,
+        file_content: fileContent,
+    });
+    if (!result.success) {
+        process.exitCode = 1;
+    }
+    if (format === "json") {
+        const output = globalFlags.dryRun ? { ...result, dry_run: true } : result;
+        writeJsonOutput(output, "fix");
+    }
+    else {
+        if (globalFlags.dryRun) {
+            writeDataOutput(strings.fix.dryRun);
+        }
+        if (result.success && result.patch) {
+            writeDataOutput(formatPatchMarkdown(result.patch));
+        }
+        else {
+            writeDataOutput(`## Patch Generation Failed\n\n${result.error?.message || "Unknown error"}`);
+        }
+    }
+}
+export async function handleFix(jobId, cmdOptions, globalFlags = {}) {
+    const renderer = createRenderer("auto");
+    const baseState = {
+        phase: "fix",
+        phaseIndex: 1,
+        phaseTotal: 1,
+        url: "",
+        mode: "fix",
+        progress: {},
+        totals: {},
+        issueCount: 0,
+        scorePreview: null,
+        verbose: false,
+        elapsed: 0,
+    };
+    const startTime = Date.now();
+    const steps = [
+        {
+            id: "generate",
+            actionText: "Generating patch...",
+            summaryText: "Patch generated",
+            run: async () => {
+                const base = resolveApiBase(cmdOptions);
+                const issueId = getString(cmdOptions, "issue");
+                if (!issueId)
+                    throw new Error("--issue is required");
+                await runFixCommand(base, jobId, issueId, cmdOptions, globalFlags);
+            },
+        },
+    ];
+    const { success, states } = await runSteps(steps, {
+        failFast: true,
+        onStateChange: (stepStates) => {
+            renderer.update({ ...baseState, stepStates, elapsed: Date.now() - startTime });
+        },
+    });
+    renderer.finish({ url: "", mode: "fix", overallScore: 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;
+    }
+}
+export function registerFixCommand(program) {
+    program
+        .command("fix <jobId>")
+        .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, command) => {
+        try {
+            const globalOpts = command.optsWithGlobals();
+            await handleFix(jobId, cmdOptions, { dryRun: !!globalOpts.dryRun });
+        }
+        catch (error) {
+            process.stderr.write(renderError({
+                message: error instanceof Error ? error.message : String(error),
+                suggestion: "vertaa explain <id>",
+                exitCode: ExitCode.ERROR,
+            }) + "\n");
+            process.exit(ExitCode.ERROR);
+        }
+    });
+}

package/dist/commands/init.d.ts

@@ -5,6 +5,17 @@
  * Generates CI templates for popular platforms.
  */
 import type { Command } from "commander";
+import type { CITemplate, FailOnSeverity } from "../config/schema.js";
+/**
+ * Handle the init command.
+ */
+export declare function handleInit(options: {
+    yes?: boolean;
+    ci?: CITemplate;
+    failOn?: FailOnSeverity;
+    threshold?: number;
+    force?: boolean;
+}): Promise<void>;
 /**
  * Register the init command with the Commander program.
  */