@vertaaux/cli 0.4.0 → 0.5.1

package/dist/commands/suggest.js

@@ -10,28 +10,53 @@
  *   vertaa suggest "compare two pages"
  *   vertaa suggest "set up CI quality gate"
  */
-import chalk from "chalk";
+import { bold, dim, colorize, boldColor, brand, severity as severityPalette, runSteps, createRenderer, renderWarning, renderError, isCI, isTTY } from "@vertaaux/tui";
 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 { writeDataOutput, 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";
+import { strings } from "../ui/strings.js";
+function tokenizeCommand(command) {
+    return command.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+}
+function stripQuotes(token) {
+    if ((token.startsWith("\"") && token.endsWith("\"")) ||
+        (token.startsWith("'") && token.endsWith("'"))) {
+        return token.slice(1, -1);
+    }
+    return token;
+}
+function toSuggestionStages(command) {
+    return command
+        .split("|")
+        .map((segment) => segment.trim())
+        .filter(Boolean)
+        .map((segment) => {
+        const tokens = tokenizeCommand(segment).map(stripQuotes);
+        const [executable = "vertaa", ...argv] = tokens;
+        return {
+            executable,
+            argv,
+            placeholders: argv.filter((token) => /^<.+>$/.test(token)),
+        };
+    });
+}
 /**
  * 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(`  ${boldColor("$", brand.cyan)} ${bold(result.command)}`);
+        lines.push(`  ${dim(result.explanation)}`);
         lines.push("");
     }
     if (results.length === 0) {
-        lines.push(chalk.yellow("No matching commands found."));
-        lines.push(chalk.dim("Try: vertaa --help"));
+        lines.push(colorize("No matching commands found.", severityPalette.warning));
+        lines.push(dim("Try: vertaa --help"));
     }
     return lines.join("\n");
 }
@@ -42,12 +67,144 @@ function formatSuggestJson(results) {
     return {
         suggestions: results.map((r) => ({
             command: r.command,
+            stages: toSuggestionStages(r.command),
             explanation: r.explanation,
             source: r.source,
             confidence: r.confidence,
         })),
     };
 }
+export async function handleSuggest(opts) {
+    const format = resolveCommandFormat("suggest", opts.format, opts.machine || false);
+    const config = { apiKey: opts.apiKey };
+    const intent = opts.intent;
+    // Resolve fail-fast mode: --strict > --continue-on-error > auto-detect
+    let failFast;
+    if (opts.strict && opts.continueOnError) {
+        writeOutput(renderWarning({ message: "--strict and --continue-on-error both set — --strict takes precedence" }));
+        failFast = true;
+    }
+    else if (opts.strict) {
+        failFast = true;
+    }
+    else if (opts.continueOnError) {
+        failFast = false;
+    }
+    else {
+        failFast = isCI() || !isTTY();
+    }
+    let results = [];
+    const renderer = createRenderer("auto");
+    const baseState = {
+        phase: "suggest",
+        phaseIndex: 1,
+        phaseTotal: 1,
+        url: "",
+        mode: "suggest",
+        progress: {},
+        totals: {},
+        issueCount: 0,
+        scorePreview: null,
+        verbose: false,
+        elapsed: 0,
+    };
+    const steps = [
+        {
+            id: "search",
+            actionText: strings.suggest.search.action,
+            summaryText: strings.suggest.search.done(0),
+            run: async () => {
+                // Step 1: Local fuzzy match against command catalog
+                const localMatches = findMatches(intent);
+                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 base = resolveApiBase(opts.base);
+                    const apiKey = getApiKey(config.apiKey);
+                    try {
+                        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)),
+                        ]);
+                        if (response.data?.suggestions?.length) {
+                            results = response.data.suggestions.map((s) => ({
+                                command: s.command,
+                                explanation: s.explanation,
+                                source: "api",
+                                confidence: 80,
+                            }));
+                        }
+                        else {
+                            results = localMatches.map((m) => ({
+                                command: m.entry.command,
+                                explanation: m.entry.description,
+                                source: "local",
+                                confidence: Math.round(m.score * 100),
+                            }));
+                        }
+                    }
+                    catch {
+                        // API failed — suggest degrades gracefully to local catalog
+                        writeOutput(strings.suggest.errors.apiUnavailable + "\n");
+                        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),
+                    }));
+                }
+            },
+        },
+    ];
+    const { success, states } = await runSteps(steps, {
+        failFast,
+        onStateChange: (stepStates) => {
+            renderer.update({ ...baseState, stepStates });
+        },
+    });
+    renderer.finish({
+        url: "",
+        mode: "suggest",
+        overallScore: success ? 100 : 0,
+        scores: {},
+        issueCount: 0,
+        passed: success,
+        elapsed: 0,
+    });
+    if (!success) {
+        const failedStep = states.find((s) => s.status === "failed");
+        process.stderr.write(renderError({
+            message: strings.suggest.errors.searchFailed(failedStep?.failReason ?? "unknown error"),
+            suggestion: "vertaa --help",
+        }) + "\n");
+        process.exit(ExitCode.ERROR);
+    }
+    // Output
+    if (format === "json") {
+        writeJsonOutput(formatSuggestJson(results), "suggest");
+    }
+    else {
+        writeDataOutput(formatSuggestHuman(results));
+    }
+}
 /**
  * Register the suggest command with the Commander program.
  */
@@ -56,6 +213,8 @@ export function registerSuggestCommand(program) {
         .command("suggest <intent...>")
         .description("Convert natural language to exact CLI command(s)")
         .option("-f, --format <format>", "Output format: json | human")
+        .option("--strict", "Fail immediately on first step error")
+        .option("--continue-on-error", "Continue on step errors even in CI")
         .addHelpText("after", `
 Examples:
   vertaa suggest "check accessibility"
@@ -68,84 +227,22 @@ Examples:
             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));
-            }
+            await handleSuggest({
+                intent: intentParts.join(" "),
+                format: options.format,
+                strict: options.strict,
+                continueOnError: options.continueOnError,
+                machine: machineMode,
+                base: globalOpts.base,
+                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 --help",
+                exitCode: ExitCode.ERROR,
+            }) + "\n");
             process.exit(ExitCode.ERROR);
         }
     });

package/dist/commands/triage.d.ts

@@ -13,5 +13,40 @@
  *   vertaa triage --file audit.json --verbose
  */
 import { Command } from "commander";
+import { type ViewportItem } from "@vertaaux/tui";
+interface TriageItem {
+    id: string | null;
+    title: string;
+    reason: string;
+    effort: "trivial" | "small" | "medium" | "large";
+}
+interface TriageApiResponse {
+    data: {
+        p0_critical: TriageItem[];
+        p1_important: TriageItem[];
+        p2_nice_to_have: TriageItem[];
+        quick_wins: string[];
+    };
+}
+/**
+ * Flatten triage p0/p1/p2 buckets into a ViewportItem array.
+ *
+ * Order: p0_critical → p1_important → p2_nice_to_have (preserves API order within buckets).
+ * Severity mapping: p0 → "critical", p1 → "warning", p2 → "moderate".
+ */
+export declare function buildViewportItems(data: TriageApiResponse["data"]): ViewportItem[];
+export interface TriageCommandOptions {
+    job?: string;
+    file?: string;
+    format?: string;
+    strict?: boolean;
+    continueOnError?: boolean;
+    machine?: boolean;
+    verbose?: boolean;
+    base?: string;
+    apiKey?: string;
+}
+export declare function handleTriage(opts: TriageCommandOptions): Promise<void>;
 export declare function registerTriageCommand(program: Command): void;
+export {};
 //# sourceMappingURL=triage.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"triage.d.ts","sourceRoot":"","sources":["../../src/commands/triage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAwK,KAAK,YAAY,EAAqC,MAAM,eAAe,CAAC;AAc3P,UAAU,UAAU;IAClB,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;CAClD;AAED,UAAU,iBAAiB;IACzB,IAAI,EAAE;QACJ,WAAW,EAAE,UAAU,EAAE,CAAC;QAC1B,YAAY,EAAE,UAAU,EAAE,CAAC;QAC3B,eAAe,EAAE,UAAU,EAAE,CAAC;QAC9B,UAAU,EAAE,MAAM,EAAE,CAAC;KACtB,CAAC;CACH;AA0HD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,iBAAiB,CAAC,MAAM,CAAC,GAAG,YAAY,EAAE,CAkClF;AAMD,MAAM,WAAW,oBAAoB;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAwJ5E;AAMD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA+C5D"}