whale-igniter 1.1.0

package/dist/commands/selene.js

@@ -0,0 +1,516 @@
+import path from "node:path";
+import fs from "fs-extra";
+import ora from "ora";
+import prompts from "prompts";
+import { resolveTarget } from "../utils/paths.js";
+import { loadConfig } from "../utils/config.js";
+import { loadDecisions, appendDecision } from "../utils/decisions.js";
+import { loadRefinements, appendRefinement } from "../utils/refinements.js";
+import { loadComponents, upsertComponent } from "../utils/components.js";
+import { generateWiki } from "../generators/wikiGenerator.js";
+import { buildDescribePrompt, buildAuditPrompt, buildSuggestPrompt } from "../selene/promptBuilder.js";
+import { parseJsonResponse, isDescribeResponse, isAuditResponse, isSuggestResponse } from "../selene/responseParser.js";
+import { copyToClipboard } from "../selene/clipboard.js";
+import { resolveProvider, describeProviderState } from "../selene/providers.js";
+import { callProvider, estimateTokens, estimateCostUsd } from "../selene/apiClient.js";
+import { readCache, writeCache, clearCache } from "../selene/cache.js";
+import { randomUUID } from "node:crypto";
+import { ui } from "../ui/index.js";
+const PENDING_DIR = ".whale/selene";
+// ---------------------------------------------------------------------------
+// Shared helpers
+// ---------------------------------------------------------------------------
+async function loadContext(target) {
+    const [config, decisions, refinements, components] = await Promise.all([
+        loadConfig(target),
+        loadDecisions(target),
+        loadRefinements(target),
+        loadComponents(target)
+    ]);
+    return { config, decisions, refinements, components };
+}
+async function emitPrompt(target, prompt, kind, options) {
+    if (options.stdout) {
+        process.stdout.write(prompt);
+        return;
+    }
+    if (options.out) {
+        const outPath = path.resolve(target, options.out);
+        await fs.ensureDir(path.dirname(outPath));
+        await fs.writeFile(outPath, prompt, "utf8");
+        console.log(ui.ok(`Prompt written to ${path.relative(target, outPath)}`));
+        console.log(ui.muted("  Paste it into your AI agent of choice."));
+        return;
+    }
+    // Default: copy to clipboard + save a copy in .whale/selene for `apply` round-trip.
+    const stashDir = path.join(target, PENDING_DIR);
+    await fs.ensureDir(stashDir);
+    const stashPath = path.join(stashDir, `${kind}-${Date.now()}.prompt.md`);
+    await fs.writeFile(stashPath, prompt, "utf8");
+    const copied = await copyToClipboard(prompt);
+    if (copied) {
+        console.log(ui.ok("Prompt copied to clipboard"));
+        console.log(ui.muted(`  Length: ${prompt.length} chars`));
+        console.log(ui.muted(`  Stash:  ${path.relative(target, stashPath)}`));
+        console.log();
+        console.log(ui.accent("Next:"));
+        console.log(ui.muted("  1. Paste the prompt into Claude / ChatGPT / Cursor."));
+        console.log(ui.muted("  2. Copy the response."));
+        console.log(ui.muted(`  3. Run: whale selene apply ${kind}  (paste, then Ctrl+D)`));
+    }
+    else {
+        console.log(ui.warn("Could not access the clipboard — printing prompt below."));
+        console.log(ui.muted(`  Stash: ${path.relative(target, stashPath)}`));
+        console.log();
+        console.log(ui.rule());
+        console.log(prompt);
+        console.log(ui.rule());
+    }
+}
+/**
+ * The orchestration shared by describe/audit/suggest.
+ *
+ * Decides between API mode and prompt mode based on:
+ *   1. --prompt-only forces prompt mode.
+ *   2. --api-only forces API mode (errors if no key).
+ *   3. Otherwise: API if a key is resolvable, prompt otherwise.
+ *   4. config.selene.autoCall = false flips the default to prompt mode.
+ *
+ * Returns the raw response text on API success, or null on prompt mode
+ * (the caller stops there — the user runs `whale selene apply` later).
+ *
+ * Why a single helper instead of inline logic per command: the three
+ * commands all need cache lookup, cost confirmation, error fallback to
+ * prompt mode, etc. Centralising keeps the policy consistent.
+ */
+async function runSelene(target, kind, prompt, options) {
+    const config = await loadConfig(target);
+    const sel = config.selene ?? {};
+    // Step 1: figure out the mode.
+    let wantApi = !options.promptOnly;
+    if (options.apiOnly)
+        wantApi = true;
+    if (sel.autoCall === false && !options.apiOnly)
+        wantApi = false;
+    // Step 2: try to resolve a provider if we want API.
+    const force = options.provider ?? undefined;
+    const resolved = wantApi
+        ? resolveProvider(config, { force, modelOverride: options.model })
+        : null;
+    if (!resolved) {
+        if (options.apiOnly) {
+            console.log(ui.fail("--api-only was set but no API key is configured."));
+            console.log(ui.muted("  Set ANTHROPIC_API_KEY or OPENAI_API_KEY in your environment."));
+            process.exitCode = 1;
+            return { rawResponse: null };
+        }
+        await emitPrompt(target, prompt, kind, options);
+        return { rawResponse: null };
+    }
+    // ---- API mode --------------------------------------------------------------
+    console.log(ui.accent(`Selene • ${resolved.provider} • ${resolved.model}`) + ui.muted(` (key from ${resolved.source})`));
+    // Cache lookup, unless the user opted out.
+    const cacheEnabled = !options.noCache && !sel.noCache;
+    if (cacheEnabled) {
+        const cached = await readCache(target, resolved.model, prompt);
+        if (cached) {
+            console.log(ui.muted("  cache hit — no API call needed"));
+            // Still stash the response so `apply` from disk works if the user wants.
+            await stashResponse(target, kind, cached);
+            return { rawResponse: cached };
+        }
+    }
+    // Cost confirmation.
+    const confirm = options.confirmCost || sel.confirmCost;
+    if (confirm) {
+        const inputTokens = estimateTokens(prompt);
+        const expectedOutput = sel.maxTokens ?? 1500;
+        const cost = estimateCostUsd(resolved.model, inputTokens, expectedOutput);
+        const costStr = cost === null ? "unknown" : `≈ $${cost.toFixed(4)}`;
+        console.log(ui.muted(`  estimated cost: ${costStr} (${inputTokens} input + up to ${expectedOutput} output tokens)`));
+        const { ok } = await prompts({
+            type: "confirm",
+            name: "ok",
+            message: "Proceed with the call?",
+            initial: true
+        });
+        if (!ok) {
+            console.log(ui.warning("Aborted — falling back to prompt mode."));
+            await emitPrompt(target, prompt, kind, options);
+            return { rawResponse: null };
+        }
+    }
+    const spin = ora({ text: "Calling provider", stream: process.stderr }).start();
+    const result = await callProvider(resolved, {
+        prompt,
+        maxTokens: sel.maxTokens ?? 1500,
+        temperature: sel.temperature ?? 0.2
+    });
+    if (!result.ok) {
+        spin.fail(`API call failed: ${result.error}`);
+        if (result.retryable) {
+            console.log(ui.muted("  (retryable — try again later or pass --prompt-only)"));
+        }
+        // Graceful fallback: still emit the prompt so the user isn't stuck.
+        console.log(ui.warning("\nFalling back to prompt mode so you can run this manually:"));
+        await emitPrompt(target, prompt, kind, options);
+        return { rawResponse: null };
+    }
+    const usage = result.inputTokens !== null && result.outputTokens !== null
+        ? ` ${ui.muted(`(${result.inputTokens} in / ${result.outputTokens} out)`)}`
+        : "";
+    spin.succeed(`Response received${usage}`);
+    if (cacheEnabled) {
+        await writeCache(target, resolved.model, prompt, result.text);
+    }
+    await stashResponse(target, kind, result.text);
+    return { rawResponse: result.text };
+}
+async function stashResponse(target, kind, text) {
+    const stashDir = path.join(target, PENDING_DIR);
+    await fs.ensureDir(stashDir);
+    const stashPath = path.join(stashDir, `${kind}-${Date.now()}.response.md`);
+    await fs.writeFile(stashPath, text, "utf8");
+}
+async function readResponse(target, options) {
+    if (options.from) {
+        const p = path.resolve(target, options.from);
+        return await fs.readFile(p, "utf8");
+    }
+    // Read from stdin until EOF.
+    return await new Promise((resolve, reject) => {
+        if (process.stdin.isTTY) {
+            console.log(ui.muted("Paste the LLM response, then press Ctrl+D (or Ctrl+Z, Enter on Windows):"));
+        }
+        let buf = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            buf += chunk;
+        });
+        process.stdin.on("end", () => resolve(buf));
+        process.stdin.on("error", (err) => reject(err));
+    });
+}
+export async function seleneDescribeCommand(componentName, options = {}) {
+    const target = resolveTarget();
+    const ctx = await loadContext(target);
+    // Find the component file. Priority: --file flag, then catalog entry.
+    let filePath = options.file;
+    let existingEntry = ctx.components.find((c) => c.name === componentName);
+    if (!filePath && existingEntry?.files && existingEntry.files.length > 0) {
+        filePath = existingEntry.files[0];
+    }
+    if (!filePath) {
+        console.log(ui.fail(`Component "${componentName}" not found in the catalog and no --file given.`));
+        console.log(ui.muted("  Pass --file <path> or register the component first."));
+        process.exitCode = 1;
+        return;
+    }
+    const absFile = path.resolve(target, filePath);
+    if (!(await fs.pathExists(absFile))) {
+        console.log(ui.fail(`File not found: ${filePath}`));
+        process.exitCode = 1;
+        return;
+    }
+    const fileContents = await fs.readFile(absFile, "utf8");
+    const prompt = buildDescribePrompt(ctx, {
+        componentName,
+        filePath,
+        fileContents,
+        existingEntry
+    });
+    const { rawResponse } = await runSelene(target, "describe", prompt, options);
+    if (!rawResponse)
+        return; // Prompt-mode path — user will run `apply` later.
+    // API-mode path: auto-apply (with confirmation unless --yes is passed).
+    if (options.autoApply === false) {
+        console.log(ui.muted("\nResponse received but --no-auto-apply was set. Run `whale selene apply describe`."));
+        return;
+    }
+    await applyDescribe(target, rawResponse, {});
+}
+// ---------------------------------------------------------------------------
+// audit
+// ---------------------------------------------------------------------------
+export async function seleneAuditCommand(filePath, options = {}) {
+    const target = resolveTarget();
+    const ctx = await loadContext(target);
+    const absFile = path.resolve(target, filePath);
+    if (!(await fs.pathExists(absFile))) {
+        console.log(ui.fail(`File not found: ${filePath}`));
+        process.exitCode = 1;
+        return;
+    }
+    const fileContents = await fs.readFile(absFile, "utf8");
+    const prompt = buildAuditPrompt(ctx, { filePath, fileContents });
+    const { rawResponse } = await runSelene(target, "audit", prompt, options);
+    if (!rawResponse)
+        return;
+    if (options.autoApply === false) {
+        console.log(ui.muted("\nResponse received but --no-auto-apply was set. Run `whale selene apply audit`."));
+        return;
+    }
+    await applyAudit(target, rawResponse, {});
+}
+export async function seleneSuggestCommand(options = {}) {
+    const target = resolveTarget();
+    const ctx = await loadContext(target);
+    const validFocus = ["decisions", "refinements", "components", "all"];
+    const focus = options.focus && validFocus.includes(options.focus)
+        ? options.focus
+        : undefined;
+    const prompt = buildSuggestPrompt(ctx, { focus });
+    const { rawResponse } = await runSelene(target, "suggest", prompt, options);
+    if (!rawResponse)
+        return;
+    if (options.autoApply === false) {
+        console.log(ui.muted("\nResponse received but --no-auto-apply was set. Run `whale selene apply suggest`."));
+        return;
+    }
+    await applySuggest(target, rawResponse, { yes: options.yes });
+}
+export async function seleneApplyCommand(kind, options = {}) {
+    const target = resolveTarget();
+    const raw = await readResponse(target, options);
+    if (!raw.trim()) {
+        console.log(ui.fail("Empty input. Nothing to apply."));
+        process.exitCode = 1;
+        return;
+    }
+    if (kind === "describe")
+        return applyDescribe(target, raw, options);
+    if (kind === "audit")
+        return applyAudit(target, raw, options);
+    if (kind === "suggest")
+        return applySuggest(target, raw, options);
+    console.log(ui.fail(`Unknown apply kind: ${kind}`));
+    process.exitCode = 1;
+}
+async function applyDescribe(target, raw, options) {
+    const parsed = parseJsonResponse(raw, isDescribeResponse);
+    if (!parsed.ok) {
+        console.log(ui.fail(`${parsed.reason}`));
+        console.log(ui.muted("  Expected a fenced JSON block with `name` and `description`."));
+        process.exitCode = 1;
+        return;
+    }
+    const v = parsed.value;
+    console.log(ui.emphasis(`\nProposed catalog update for ${v.name}\n`));
+    console.log(`  description: ${ui.accent(v.description)}`);
+    if (v.category)
+        console.log(`  category:    ${v.category}`);
+    if (v.variants?.length)
+        console.log(`  variants:    ${v.variants.join(", ")}`);
+    if (v.states?.length)
+        console.log(`  states:      ${v.states.join(", ")}`);
+    if (v.tokens?.length)
+        console.log(`  tokens:      ${v.tokens.slice(0, 8).join(", ")}`);
+    if (!options.yes) {
+        const { ok } = await prompts({
+            type: "confirm",
+            name: "ok",
+            message: "Apply to intelligence/components.json?",
+            initial: true
+        });
+        if (!ok) {
+            console.log(ui.warning("Aborted."));
+            return;
+        }
+    }
+    await upsertComponent(target, {
+        name: v.name,
+        description: v.description,
+        category: v.category,
+        variants: v.variants,
+        states: v.states,
+        tokens: v.tokens
+    });
+    await generateWiki(target);
+    console.log(ui.ok("Catalog updated and AI context regenerated."));
+}
+async function applyAudit(target, raw, options) {
+    const parsed = parseJsonResponse(raw, isAuditResponse);
+    if (!parsed.ok) {
+        console.log(ui.fail(`${parsed.reason}`));
+        process.exitCode = 1;
+        return;
+    }
+    const v = parsed.value;
+    if (v.issues.length === 0) {
+        console.log(ui.ok(`${v.file} — no issues reported.`));
+        return;
+    }
+    // Audit results are surfaced, not auto-applied. We write a markdown
+    // report into docs/selene/ that the user (or a CI step) can act on.
+    const reportDir = path.join(target, "docs", "selene");
+    await fs.ensureDir(reportDir);
+    const slug = v.file.replace(/[\\/]/g, "_").replace(/\.[^.]+$/, "");
+    const reportPath = path.join(reportDir, `audit-${slug}-${Date.now()}.md`);
+    const lines = [`# Selene audit — ${v.file}`, "", `Generated: ${new Date().toISOString()}`, ""];
+    for (const i of v.issues) {
+        lines.push(`## ${i.severity.toUpperCase()} — ${i.rule}${i.line ? ` (line ${i.line})` : ""}`);
+        lines.push("");
+        lines.push(i.message);
+        if (i.suggestion) {
+            lines.push("");
+            lines.push(`**Suggestion:** ${i.suggestion}`);
+        }
+        lines.push("");
+    }
+    await fs.writeFile(reportPath, lines.join("\n"), "utf8");
+    // Console summary.
+    console.log(ui.emphasis(`\nSelene audit — ${v.file}`));
+    console.log(ui.muted(`${v.issues.length} issue(s) reported. Full report:`));
+    console.log(ui.accent(`  ${path.relative(target, reportPath)}`));
+    console.log();
+    for (const i of v.issues) {
+        const sev = i.severity === "critical" ? ui.emphasis(ui.danger("CRITICAL"))
+            : i.severity === "warning" ? ui.emphasis(ui.warning("WARNING"))
+                : ui.emphasis(ui.accent("INFO"));
+        console.log(`  ${sev} ${ui.muted(`[${i.rule}${i.line ? `:${i.line}` : ""}]`)} ${i.message}`);
+        if (i.suggestion)
+            console.log(ui.muted(`    → ${i.suggestion}`));
+    }
+}
+async function applySuggest(target, raw, options) {
+    const parsed = parseJsonResponse(raw, isSuggestResponse);
+    if (!parsed.ok) {
+        console.log(ui.fail(`${parsed.reason}`));
+        process.exitCode = 1;
+        return;
+    }
+    const v = parsed.value;
+    if (v.suggestions.length === 0) {
+        console.log(ui.muted("No suggestions in the response."));
+        return;
+    }
+    console.log(ui.emphasis(`\n${v.suggestions.length} suggestion(s) from Selene\n`));
+    let applied = 0;
+    let skipped = 0;
+    for (const s of v.suggestions) {
+        console.log(ui.emphasis(s.title));
+        console.log(ui.muted(`  kind: ${s.kind} (${s.category})`));
+        console.log(ui.muted(`  ${s.rationale}`));
+        console.log();
+        console.log("  Proposed:");
+        console.log("  " + ui.accent(s.proposed_text.split("\n").join("\n  ")));
+        console.log();
+        let action = "accept";
+        if (!options.yes) {
+            const { choice } = await prompts({
+                type: "select",
+                name: "choice",
+                message: "Action:",
+                choices: [
+                    { title: "Accept (record it)", value: "accept" },
+                    { title: "Skip", value: "skip" },
+                    { title: "Reject permanently", value: "reject" }
+                ]
+            });
+            action = choice ?? "skip";
+        }
+        if (action === "accept") {
+            if (s.kind === "decision" || s.kind === "foundation") {
+                await appendDecision(target, {
+                    title: s.title,
+                    category: s.category,
+                    context: s.rationale,
+                    decision: s.proposed_text
+                });
+                console.log(ui.success("  ✓ Recorded as decision."));
+            }
+            else if (s.kind === "refinement") {
+                await appendRefinement(target, {
+                    id: randomUUID(),
+                    timestamp: new Date().toISOString(),
+                    note: s.proposed_text
+                });
+                console.log(ui.success("  ✓ Recorded as refinement."));
+            }
+            else {
+                // cleanup — surfaced but not auto-applied.
+                console.log(ui.muted("  (cleanup suggestion — surfaced, not auto-applied)"));
+            }
+            applied += 1;
+        }
+        else {
+            skipped += 1;
+        }
+        console.log();
+    }
+    if (applied > 0) {
+        await generateWiki(target);
+        console.log(ui.muted("✓ AI context regenerated."));
+    }
+    console.log();
+    console.log(`Applied ${applied}, skipped ${skipped}.`);
+}
+// ---------------------------------------------------------------------------
+// Utility commands: status and cache
+// ---------------------------------------------------------------------------
+export async function seleneStatusCommand() {
+    const target = resolveTarget();
+    const config = await loadConfig(target);
+    const sel = config.selene ?? {};
+    console.log();
+    console.log(ui.header("Whale Igniter", "selene status"));
+    console.log();
+    console.log(ui.section("Providers"));
+    for (const p of describeProviderState()) {
+        const mark = p.available ? ui.glyph.check : ui.muted("·");
+        const envNote = p.available ? ui.muted(`(${p.envName} set)`) : ui.muted(`(${p.envName} not set)`);
+        console.log(ui.indent(`${mark} ${p.provider} ${envNote}`));
+    }
+    console.log();
+    console.log(ui.section("Configuration"));
+    if (Object.keys(sel).length === 0) {
+        console.log(ui.indent(ui.muted("(empty — using defaults)")));
+    }
+    else {
+        const cfgLines = [];
+        if (sel.provider)
+            cfgLines.push(ui.kv("provider", sel.provider, { keyWidth: 12 }));
+        if (sel.model)
+            cfgLines.push(ui.kv("model", ui.code(sel.model), { keyWidth: 12 }));
+        if (sel.temperature !== undefined)
+            cfgLines.push(ui.kv("temperature", String(sel.temperature), { keyWidth: 12 }));
+        if (sel.maxTokens !== undefined)
+            cfgLines.push(ui.kv("maxTokens", String(sel.maxTokens), { keyWidth: 12 }));
+        if (sel.autoCall !== undefined)
+            cfgLines.push(ui.kv("autoCall", String(sel.autoCall), { keyWidth: 12 }));
+        if (sel.confirmCost !== undefined)
+            cfgLines.push(ui.kv("confirmCost", String(sel.confirmCost), { keyWidth: 12 }));
+        if (sel.noCache !== undefined)
+            cfgLines.push(ui.kv("noCache", String(sel.noCache), { keyWidth: 12 }));
+        console.log(ui.indent(cfgLines.join("\n")));
+    }
+    // What would actually happen on a Selene call right now?
+    const resolved = resolveProvider(config);
+    console.log();
+    console.log(ui.section("Active mode"));
+    if (resolved) {
+        console.log(ui.indent(`${ui.glyph.check} ${ui.success("API")} ${ui.muted(`(${resolved.provider} • ${resolved.model})`)}`));
+    }
+    else {
+        console.log(ui.indent(`${ui.glyph.info} ${ui.warning("prompt-only")} ${ui.muted("(no API key found)")}`));
+        console.log(ui.indent(ui.muted("Set ANTHROPIC_API_KEY or OPENAI_API_KEY to enable API mode.")));
+    }
+    console.log();
+    console.log(ui.section("Cache"));
+    const cacheDir = path.join(target, ".whale/selene/cache");
+    if (await fs.pathExists(cacheDir)) {
+        const entries = (await fs.readdir(cacheDir)).filter((f) => f.endsWith(".json")).length;
+        console.log(ui.indent(`${entries} ${ui.muted("entry/entries at .whale/selene/cache")}`));
+    }
+    else {
+        console.log(ui.indent(ui.muted("empty")));
+    }
+    console.log();
+}
+export async function seleneCacheClearCommand() {
+    const target = resolveTarget();
+    const removed = await clearCache(target);
+    console.log();
+    console.log(ui.ok(`Cleared ${removed} cache entry/entries.`));
+    console.log();
+}

package/dist/commands/sync.js

@@ -0,0 +1,43 @@
+import path from "node:path";
+import ora from "ora";
+import { resolveTarget } from "../utils/paths.js";
+import { generateWiki } from "../generators/wikiGenerator.js";
+import { loadConfig } from "../utils/config.js";
+import { loadDecisions } from "../utils/decisions.js";
+import { loadComponents } from "../utils/components.js";
+import { loadRefinements } from "../utils/refinements.js";
+import { ui } from "../ui/index.js";
+/**
+ * `whale sync` regenerates everything an AI agent reads, from the
+ * intelligence JSON files (which are the source of truth).
+ *
+ * Run this:
+ *   - after manually editing intelligence/*.json
+ *   - before handing the project to an AI agent
+ *   - in CI to ensure CLAUDE.md stays in sync
+ */
+export async function syncCommand(targetArg) {
+    const target = resolveTarget(targetArg);
+    const spinner = ora("Reading intelligence stores").start();
+    const config = await loadConfig(target);
+    const decisions = await loadDecisions(target);
+    const components = await loadComponents(target);
+    const refinements = await loadRefinements(target);
+    spinner.succeed(`Loaded: ${decisions.length} decision(s), ${components.length} component(s), ${refinements.length} refinement(s)`);
+    const spin2 = ora("Regenerating AI context").start();
+    const { rootFiles, wikiFiles } = await generateWiki(target);
+    spin2.succeed("AI context regenerated");
+    console.log();
+    console.log(ui.section("Root entry points"));
+    for (const file of rootFiles) {
+        console.log(`  ${ui.ok(ui.path(path.relative(target, file)))}`);
+    }
+    console.log();
+    console.log(ui.section("Wiki"));
+    for (const file of wikiFiles) {
+        console.log(`  ${ui.ok(ui.path(path.relative(target, file)))}`);
+    }
+    console.log();
+    console.log(ui.accent("AI agents will now see the latest project state."));
+    console.log(ui.muted(`Targets configured: ${(config.aiTargets ?? []).join(", ") || "(none)"}`));
+}

package/dist/commands/validate.js

@@ -0,0 +1,48 @@
+import ora from "ora";
+import { resolveTarget } from "../utils/paths.js";
+import { validateCss, hasErrors } from "../validators/cssValidator.js";
+import { ui } from "../ui/index.js";
+export async function validateCommand(targetArg) {
+    const target = resolveTarget(targetArg);
+    const spinner = ora("Scanning workspace").start();
+    let issues;
+    try {
+        issues = await validateCss(target);
+    }
+    catch (err) {
+        spinner.fail(`Validation failed: ${err.message}`);
+        process.exitCode = 2;
+        return;
+    }
+    spinner.succeed("Workspace scanned");
+    const errorCount = issues.filter((i) => i.severity === "error").length;
+    const warningCount = issues.filter((i) => i.severity === "warning").length;
+    if (issues.length === 0) {
+        console.log();
+        console.log(ui.ok("No issues found."));
+        process.exitCode = 0;
+        return;
+    }
+    // Header with the counts as badges.
+    console.log();
+    console.log(ui.summary([
+        { label: "issues", value: issues.length },
+        { label: "errors", value: errorCount, tone: errorCount > 0 ? "danger" : "muted" },
+        { label: "warnings", value: warningCount, tone: warningCount > 0 ? "warn" : "muted" }
+    ]));
+    console.log();
+    for (const issue of issues) {
+        const head = issue.severity === "error"
+            ? `${ui.glyph.cross} ${ui.danger(issue.type)}`
+            : `${ui.glyph.warn} ${ui.warning(issue.type)}`;
+        console.log(`${head} ${ui.muted(`— ${issue.file}:${issue.line}:${issue.column}`)}`);
+        console.log(`  ${issue.message}`);
+        console.log(`  ${ui.next(issue.suggestion)}`);
+        if (issue.selector) {
+            console.log(`  ${ui.muted("selector: " + issue.selector)}`);
+        }
+        console.log();
+    }
+    // Exit code: errors fail the run, warnings don't.
+    process.exitCode = hasErrors(issues) ? 1 : 0;
+}