apex-auditor 0.3.0 → 0.3.3

package/dist/shell-cli.js

@@ -0,0 +1,566 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { exec } from "node:child_process";
+import readline from "node:readline";
+import { runAuditCli } from "./cli.js";
+import { runMeasureCli } from "./measure-cli.js";
+import { runWizardCli } from "./wizard-cli.js";
+import { pathExists } from "./fs-utils.js";
+import { renderPanel } from "./ui/render-panel.js";
+import { startSpinner, stopSpinner } from "./spinner.js";
+import { UiTheme } from "./ui/ui-theme.js";
+const SESSION_DIR_NAME = ".apex-auditor";
+const SESSION_FILE_NAME = "session.json";
+const DEFAULT_CONFIG_PATH = "apex.config.json";
+const DEFAULT_PROMPT = "> ";
+const NO_COLOR = Boolean(process.env.NO_COLOR) || process.env.CI === "true";
+const theme = new UiTheme({ noColor: NO_COLOR });
+async function readJsonFile(absolutePath) {
+    try {
+        const raw = await readFile(absolutePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function writeJsonFile(absolutePath, value) {
+    await writeFile(absolutePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+function getSessionPaths(projectRoot) {
+    const dir = resolve(projectRoot, SESSION_DIR_NAME);
+    const file = join(dir, SESSION_FILE_NAME);
+    return { dir, file };
+}
+async function loadSession(projectRoot) {
+    const { dir, file } = getSessionPaths(projectRoot);
+    if (!(await pathExists(dir))) {
+        return {
+            configPath: DEFAULT_CONFIG_PATH,
+            preset: "default",
+            incremental: false,
+            buildIdStrategy: "auto",
+            buildIdManual: undefined,
+            lastReportPath: undefined,
+        };
+    }
+    const existing = await readJsonFile(file);
+    if (existing === undefined) {
+        return {
+            configPath: DEFAULT_CONFIG_PATH,
+            preset: "default",
+            incremental: false,
+            buildIdStrategy: "auto",
+            buildIdManual: undefined,
+            lastReportPath: undefined,
+        };
+    }
+    return existing;
+}
+async function saveSession(projectRoot, session) {
+    const { dir, file } = getSessionPaths(projectRoot);
+    await mkdir(dir, { recursive: true });
+    await writeJsonFile(file, session);
+}
+function parseShellCommand(line) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+        return { id: "", args: [] };
+    }
+    const parts = trimmed.split(/\s+/g);
+    const id = parts[0] ?? "";
+    const args = parts.slice(1);
+    return { id, args };
+}
+function buildPrompt(session) {
+    const incText = session.incremental ? "on" : "off";
+    const presetText = session.preset;
+    const configText = session.configPath;
+    const header = [
+        theme.cyan("ApexAuditor"),
+        theme.dim("config:"),
+        configText,
+        theme.dim("| preset:"),
+        presetText,
+        theme.dim("| incremental:"),
+        incText,
+    ].join(" ");
+    return `${header}\n${theme.dim(DEFAULT_PROMPT)}`;
+}
+function openInBrowser(filePath) {
+    const platform = process.platform;
+    const command = platform === "win32" ? `start "" "${filePath}"` : platform === "darwin" ? `open "${filePath}"` : `xdg-open "${filePath}"`;
+    exec(command, (error) => {
+        if (error) {
+            // eslint-disable-next-line no-console
+            console.error(`Could not open report: ${error.message}`);
+        }
+    });
+}
+async function snapshotPreviousSummary(projectRoot) {
+    const currentPath = resolve(projectRoot, SESSION_DIR_NAME, "summary.json");
+    const prevPath = resolve(projectRoot, SESSION_DIR_NAME, "summary.prev.json");
+    if (!(await pathExists(currentPath))) {
+        return;
+    }
+    try {
+        const raw = await readFile(currentPath, "utf8");
+        await mkdir(resolve(projectRoot, SESSION_DIR_NAME), { recursive: true });
+        await writeFile(prevPath, raw, "utf8");
+    }
+    catch {
+        return;
+    }
+}
+function computeAvgScores(results) {
+    const sums = results.reduce((acc, r) => {
+        return {
+            performance: acc.performance + (r.scores.performance ?? 0),
+            accessibility: acc.accessibility + (r.scores.accessibility ?? 0),
+            bestPractices: acc.bestPractices + (r.scores.bestPractices ?? 0),
+            seo: acc.seo + (r.scores.seo ?? 0),
+            count: acc.count + 1,
+        };
+    }, { performance: 0, accessibility: 0, bestPractices: 0, seo: 0, count: 0 });
+    const count = Math.max(1, sums.count);
+    return {
+        performance: Math.round(sums.performance / count),
+        accessibility: Math.round(sums.accessibility / count),
+        bestPractices: Math.round(sums.bestPractices / count),
+        seo: Math.round(sums.seo / count),
+    };
+}
+function formatChanges(previous, current) {
+    const prevAvg = computeAvgScores(previous.results);
+    const currAvg = computeAvgScores(current.results);
+    const avgDelta = {
+        performance: currAvg.performance - prevAvg.performance,
+        accessibility: currAvg.accessibility - prevAvg.accessibility,
+        bestPractices: currAvg.bestPractices - prevAvg.bestPractices,
+        seo: currAvg.seo - prevAvg.seo,
+    };
+    const prevMap = new Map(previous.results.map((r) => [`${r.label}:::${r.path}:::${r.device}`, r]));
+    const currMap = new Map(current.results.map((r) => [`${r.label}:::${r.path}:::${r.device}`, r]));
+    const allKeys = new Set([...prevMap.keys(), ...currMap.keys()]);
+    const deltas = [];
+    let added = 0;
+    let removed = 0;
+    for (const key of allKeys) {
+        const prev = prevMap.get(key);
+        const curr = currMap.get(key);
+        if (!prev && curr) {
+            added += 1;
+            continue;
+        }
+        if (prev && !curr) {
+            removed += 1;
+            continue;
+        }
+        if (!prev || !curr) {
+            continue;
+        }
+        const deltaP = (curr.scores.performance ?? 0) - (prev.scores.performance ?? 0);
+        deltas.push({ key, label: curr.label, path: curr.path, device: curr.device, deltaP });
+    }
+    deltas.sort((a, b) => a.deltaP - b.deltaP);
+    const regressions = deltas.slice(0, 5);
+    const improvements = [...deltas].reverse().slice(0, 5);
+    const lines = [];
+    lines.push(`Avg deltas: P ${avgDelta.performance} | A ${avgDelta.accessibility} | BP ${avgDelta.bestPractices} | SEO ${avgDelta.seo}`);
+    lines.push(`Combos: +${added} added, -${removed} removed`);
+    lines.push("Top regressions (Performance):");
+    for (const r of regressions) {
+        lines.push(`- ${r.label} ${r.path} [${r.device}] ΔP:${r.deltaP}`);
+    }
+    lines.push("Top improvements (Performance):");
+    for (const r of improvements) {
+        lines.push(`- ${r.label} ${r.path} [${r.device}] ΔP:${r.deltaP}`);
+    }
+    return lines.join("\n");
+}
+async function runDiff(projectRoot) {
+    const prevPath = resolve(projectRoot, SESSION_DIR_NAME, "summary.prev.json");
+    const currPath = resolve(projectRoot, SESSION_DIR_NAME, "summary.json");
+    const prev = await readJsonFile(prevPath);
+    const curr = await readJsonFile(currPath);
+    if (!prev || !curr) {
+        // eslint-disable-next-line no-console
+        console.log("No diff available. Run 'audit' at least twice in this shell session.");
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.log(formatChanges(prev, curr));
+}
+function buildAuditArgvFromSession(session) {
+    const args = ["node", "apex-auditor"];
+    if (session.configPath.length > 0) {
+        args.push("--config", session.configPath);
+    }
+    if (session.preset === "overview") {
+        args.push("--overview");
+    }
+    if (session.preset === "fast") {
+        args.push("--fast");
+    }
+    if (session.preset === "quick") {
+        args.push("--quick");
+    }
+    if (session.preset === "accurate") {
+        args.push("--accurate");
+    }
+    if (session.incremental) {
+        args.push("--incremental");
+    }
+    if (session.buildIdStrategy === "manual" && session.buildIdManual) {
+        args.push("--build-id", session.buildIdManual);
+    }
+    return args;
+}
+function buildAuditArgv(session, passthroughArgs) {
+    const baseArgv = buildAuditArgvFromSession(session);
+    if (passthroughArgs.length === 0) {
+        return baseArgv;
+    }
+    return [...baseArgv, ...passthroughArgs];
+}
+function resolvePresetFromArgs(args) {
+    const preset = args[0];
+    if (preset === "default" || preset === "overview" || preset === "quick" || preset === "accurate" || preset === "fast") {
+        return preset;
+    }
+    return undefined;
+}
+function resolveBoolFromArgs(args) {
+    const raw = args[0];
+    if (raw === "on") {
+        return true;
+    }
+    if (raw === "off") {
+        return false;
+    }
+    return undefined;
+}
+function resolveBuildIdStrategy(args) {
+    const raw = args[0];
+    if (raw === "auto") {
+        return { strategy: "auto", manual: undefined };
+    }
+    if (raw === "manual") {
+        const id = args[1];
+        if (!id || id.trim().length === 0) {
+            return undefined;
+        }
+        return { strategy: "manual", manual: id.trim() };
+    }
+    return undefined;
+}
+function printHelp() {
+    const lines = [];
+    lines.push(`${theme.cyan("measure")} Run fast metrics (CDP-based) for the current config`);
+    lines.push("");
+    lines.push(theme.bold("Commands"));
+    lines.push(`${theme.cyan("audit")} Run audits using the current session settings`);
+    lines.push(`${theme.cyan("measure")} Run fast metrics (CDP-based) for the current config`);
+    lines.push(`${theme.cyan("open")} Open the last HTML report (or .apex-auditor/report.html)`);
+    lines.push(`${theme.cyan("diff")} Compare last run vs previous run (from this shell session)`);
+    lines.push(`${theme.cyan("preset <id>")} Set preset: default|overview|quick|accurate|fast`);
+    lines.push(`${theme.cyan("incremental on|off")} Toggle incremental caching`);
+    lines.push(`${theme.cyan("build-id auto")} Use auto buildId detection`);
+    lines.push(`${theme.cyan("build-id manual <id>")} Use a fixed buildId`);
+    lines.push(`${theme.cyan("config <path>")} Set config path used by audit`);
+    lines.push("");
+    lines.push(theme.dim("Note: runs-per-combo is always 1. For baselines/comparison, rerun the same command."));
+    lines.push("");
+    lines.push(`${theme.cyan("help")} Show this help`);
+    lines.push(`${theme.cyan("exit")} Exit the shell`);
+    // eslint-disable-next-line no-console
+    console.log(renderPanel({ title: theme.bold("Help"), lines }));
+}
+async function readCliVersion(projectRoot) {
+    try {
+        const raw = await readFile(resolve(projectRoot, "package.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+            return "unknown";
+        }
+        const record = parsed;
+        return typeof record.version === "string" ? record.version : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+function printHomeScreen(params) {
+    const { version, session } = params;
+    const padCmd = (cmd) => cmd.padEnd(14, " ");
+    const lines = [];
+    lines.push(theme.dim("Performance + metrics assistant (measure-first, Lighthouse optional)"));
+    lines.push("");
+    lines.push(theme.bold("Audit commands"));
+    lines.push(`${theme.cyan(padCmd("measure"))}Fast batch metrics (LCP/CLS/INP + screenshot + console errors)`);
+    lines.push(`${theme.cyan(padCmd("audit"))}Deep Lighthouse audit (slower)`);
+    lines.push("");
+    lines.push(theme.bold("Common commands"));
+    lines.push(`${theme.cyan(padCmd("init"))}Launch config wizard to create/edit apex.config.json`);
+    lines.push(`${theme.cyan(padCmd("config <path>"))}Change config file (current: ${session.configPath})`);
+    lines.push(`${theme.cyan(padCmd("help"))}Show all commands`);
+    lines.push("");
+    lines.push(theme.bold("Tips"));
+    lines.push(theme.dim("- Press Tab for auto-completion"));
+    lines.push(theme.dim("- Press Ctrl+C or type exit to quit"));
+    // eslint-disable-next-line no-console
+    console.log(renderPanel({ title: theme.magenta(theme.bold(`ApexAuditor v${version}`)), lines }));
+}
+function createCompleter() {
+    const commands = [
+        "audit",
+        "measure",
+        "open",
+        "diff",
+        "preset",
+        "incremental",
+        "build-id",
+        "config",
+        "help",
+        "exit",
+        "quit",
+    ];
+    const presets = ["default", "overview", "quick", "accurate", "fast"];
+    const onOff = ["on", "off"];
+    const buildIdModes = ["auto", "manual"];
+    const measureFlags = ["--desktop-only", "--mobile-only", "--parallel", "--timeout-ms", "--json"];
+    const filterStartsWith = (candidates, fragment) => {
+        const hits = candidates.filter((c) => c.startsWith(fragment));
+        return hits.length > 0 ? hits : candidates;
+    };
+    const completeFirstWord = (trimmed, rawLine) => {
+        const hits = commands.filter((c) => c.startsWith(trimmed));
+        return [hits.length > 0 ? hits : commands, rawLine];
+    };
+    const completeSecondWord = (command, fragment, rawLine) => {
+        if (command === "preset") {
+            return [filterStartsWith(presets, fragment), rawLine];
+        }
+        if (command === "incremental") {
+            return [filterStartsWith(onOff, fragment), rawLine];
+        }
+        if (command === "build-id") {
+            return [filterStartsWith(buildIdModes, fragment), rawLine];
+        }
+        if (command === "measure") {
+            return [filterStartsWith(measureFlags, fragment), rawLine];
+        }
+        return [[], rawLine];
+    };
+    return (line) => {
+        const rawLine = line;
+        const trimmedStart = rawLine.trimStart();
+        const parts = trimmedStart.split(/\s+/g);
+        const hasTrailingSpace = rawLine.endsWith(" ");
+        const command = parts[0] ?? "";
+        if (parts.length <= 1) {
+            const fragment = command;
+            return completeFirstWord(fragment, rawLine);
+        }
+        const secondFragment = hasTrailingSpace ? "" : (parts[1] ?? "");
+        return completeSecondWord(command, secondFragment, rawLine);
+    };
+}
+async function runAudit(projectRoot, session, passthroughArgs) {
+    await snapshotPreviousSummary(projectRoot);
+    const argv = buildAuditArgv(session, passthroughArgs);
+    // eslint-disable-next-line no-console
+    console.log("Starting audit. Tip: large runs may prompt for confirmation; pass --yes to skip the prompt.");
+    await runAuditCli(argv);
+}
+async function runMeasure(session, passthroughArgs) {
+    const argv = ["node", "apex-auditor", "--config", session.configPath, ...passthroughArgs];
+    startSpinner("Running measure (fast metrics)");
+    try {
+        // eslint-disable-next-line no-console
+        console.log("Starting measure (fast metrics). Tip: use --desktop-only/--mobile-only and --parallel to tune speed.");
+        await runMeasureCli(argv);
+    }
+    finally {
+        stopSpinner();
+    }
+}
+async function runWithEscAbort(task) {
+    const controller = new AbortController();
+    const input = process.stdin;
+    const handleKeypress = (buffer) => {
+        if (buffer.length === 1 && buffer[0] === 0x1b) {
+            controller.abort();
+        }
+    };
+    const previousRaw = input.isTTY ? input.isRaw : undefined;
+    if (input.isTTY) {
+        input.setRawMode(true);
+    }
+    input.on("data", handleKeypress);
+    try {
+        const result = await task(controller.signal);
+        if (controller.signal.aborted) {
+            return "aborted";
+        }
+        return result;
+    }
+    finally {
+        input.off("data", handleKeypress);
+        if (input.isTTY && previousRaw !== undefined) {
+            input.setRawMode(previousRaw);
+        }
+    }
+}
+async function runAuditFromShell(projectRoot, session, args) {
+    const escResult = await runWithEscAbort(async (signal) => {
+        await runAuditCli(buildAuditArgv(session, args), { signal });
+    });
+    if (escResult === "aborted") {
+        // eslint-disable-next-line no-console
+        console.log("Audit cancelled via Esc. Back to shell.");
+        process.exitCode = 0;
+        return session;
+    }
+    try {
+        if (process.exitCode === 130) {
+            process.exitCode = 0;
+            // eslint-disable-next-line no-console
+            console.log("Audit cancelled. Back to shell.");
+            return session;
+        }
+        const reportPath = resolve(projectRoot, SESSION_DIR_NAME, "report.html");
+        // eslint-disable-next-line no-console
+        console.log(`Tip: type ${theme.cyan("open")} to view the latest HTML report.`);
+        const updated = { ...session, lastReportPath: reportPath };
+        await saveSession(projectRoot, updated);
+        return updated;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("ENOENT") && message.includes(session.configPath)) {
+            // eslint-disable-next-line no-console
+            console.log(`Config not found at ${session.configPath}. Run 'init' to create a new config for this project, or use 'config <path>' to point to an existing one.`);
+            return session;
+        }
+        throw error;
+    }
+}
+async function handleShellCommand(projectRoot, session, command) {
+    if (command.id === "" || command.id === "status") {
+        // eslint-disable-next-line no-console
+        console.log(buildPrompt(session).replace(`\n${DEFAULT_PROMPT}`, ""));
+        return { session, shouldExit: false };
+    }
+    if (command.id === "help") {
+        printHelp();
+        return { session, shouldExit: false };
+    }
+    if (command.id === "exit" || command.id === "quit") {
+        return { session, shouldExit: true };
+    }
+    if (command.id === "audit") {
+        const nextSession = await runAuditFromShell(projectRoot, session, command.args);
+        return { session: nextSession, shouldExit: false };
+    }
+    if (command.id === "measure") {
+        await runMeasure(session, command.args);
+        return { session, shouldExit: false };
+    }
+    if (command.id === "init") {
+        // eslint-disable-next-line no-console
+        console.log("Starting config wizard...");
+        await runWizardCli(["node", "apex-auditor"]);
+        return { session, shouldExit: false };
+    }
+    if (command.id === "open") {
+        const path = session.lastReportPath ?? resolve(projectRoot, SESSION_DIR_NAME, "report.html");
+        openInBrowser(path);
+        return { session, shouldExit: false };
+    }
+    if (command.id === "diff") {
+        await runDiff(projectRoot);
+        return { session, shouldExit: false };
+    }
+    if (command.id === "preset") {
+        const preset = resolvePresetFromArgs(command.args);
+        if (!preset) {
+            // eslint-disable-next-line no-console
+            console.log("Usage: preset default|quick|accurate|fast");
+            return { session, shouldExit: false };
+        }
+        const updated = { ...session, preset };
+        await saveSession(projectRoot, updated);
+        return { session: updated, shouldExit: false };
+    }
+    if (command.id === "incremental") {
+        const value = resolveBoolFromArgs(command.args);
+        if (value === undefined) {
+            // eslint-disable-next-line no-console
+            console.log("Usage: incremental on|off");
+            return { session, shouldExit: false };
+        }
+        const updated = { ...session, incremental: value };
+        await saveSession(projectRoot, updated);
+        return { session: updated, shouldExit: false };
+    }
+    if (command.id === "build-id") {
+        const resolved = resolveBuildIdStrategy(command.args);
+        if (!resolved) {
+            // eslint-disable-next-line no-console
+            console.log("Usage: build-id auto | build-id manual <id>");
+            return { session, shouldExit: false };
+        }
+        const updated = { ...session, buildIdStrategy: resolved.strategy, buildIdManual: resolved.manual };
+        await saveSession(projectRoot, updated);
+        return { session: updated, shouldExit: false };
+    }
+    if (command.id === "config") {
+        const configPath = command.args[0];
+        if (!configPath || configPath.trim().length === 0) {
+            // eslint-disable-next-line no-console
+            console.log("Usage: config <path-to-config.json>");
+            return { session, shouldExit: false };
+        }
+        const updated = { ...session, configPath: configPath.trim() };
+        await saveSession(projectRoot, updated);
+        return { session: updated, shouldExit: false };
+    }
+    // eslint-disable-next-line no-console
+    console.log(`Unknown command: ${command.id}. Type 'help' to see commands.`);
+    return { session, shouldExit: false };
+}
+/**
+ * Starts ApexAuditor in interactive shell mode.
+ */
+export async function runShellCli(argv) {
+    void argv;
+    const projectRoot = process.cwd();
+    let session = await loadSession(projectRoot);
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, completer: createCompleter() });
+    rl.on("SIGINT", () => {
+        rl.close();
+    });
+    const version = await readCliVersion(projectRoot);
+    printHomeScreen({ version, session });
+    rl.setPrompt(buildPrompt(session));
+    rl.prompt();
+    rl.on("line", async (line) => {
+        const command = parseShellCommand(line);
+        const result = await handleShellCommand(projectRoot, session, command);
+        session = result.session;
+        if (result.shouldExit) {
+            rl.close();
+            return;
+        }
+        rl.setPrompt(buildPrompt(session));
+        rl.prompt();
+    });
+    await new Promise((resolvePromise) => {
+        rl.on("close", () => resolvePromise());
+    });
+}

package/dist/spinner.js

@@ -0,0 +1,37 @@
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const SPINNER_INTERVAL_MS = 80;
+const ANSI_BLUE = "\u001B[34m";
+const ANSI_RESET = "\u001B[0m";
+let spinnerInterval;
+let spinnerIndex = 0;
+let spinnerMessage = "";
+export function startSpinner(message) {
+    if (!process.stdout.isTTY) {
+        return;
+    }
+    stopSpinner();
+    spinnerMessage = message;
+    spinnerIndex = 0;
+    process.stdout.write("\u001B[?25l"); // hide cursor
+    spinnerInterval = setInterval(() => {
+        process.stdout.write(`\r${ANSI_BLUE}${SPINNER_FRAMES[spinnerIndex]} ${spinnerMessage}${ANSI_RESET}`);
+        spinnerIndex = (spinnerIndex + 1) % SPINNER_FRAMES.length;
+    }, SPINNER_INTERVAL_MS);
+}
+export function updateSpinnerMessage(message) {
+    if (!process.stdout.isTTY || spinnerInterval === undefined) {
+        return;
+    }
+    spinnerMessage = message;
+}
+export function stopSpinner() {
+    if (spinnerInterval === undefined) {
+        return;
+    }
+    clearInterval(spinnerInterval);
+    spinnerInterval = undefined;
+    if (process.stdout.isTTY) {
+        process.stdout.write("\r\u001B[K"); // clear line
+        process.stdout.write("\u001B[?25h"); // show cursor
+    }
+}

package/dist/ui/render-panel.js

@@ -0,0 +1,46 @@
+const BOX = {
+    topLeft: "┌",
+    topRight: "┐",
+    bottomLeft: "└",
+    bottomRight: "┘",
+    horizontal: "─",
+    vertical: "│",
+};
+function repeatChar(char, count) {
+    return new Array(Math.max(0, count)).fill(char).join("");
+}
+function lineLength(value) {
+    return value.replace(/\u001b\[[0-9;]*m/g, "").length;
+}
+function padRight(value, total) {
+    const rawLen = lineLength(value);
+    if (rawLen >= total) {
+        return value;
+    }
+    return `${value}${repeatChar(" ", total - rawLen)}`;
+}
+function renderHeader(params) {
+    const titleLine = params.subtitle ? `${params.title} — ${params.subtitle}` : params.title;
+    const padded = padRight(titleLine, params.contentWidth);
+    return [`${BOX.vertical} ${padded} ${BOX.vertical}`];
+}
+function renderBody(lines, contentWidth) {
+    return lines.map((line) => {
+        const padded = padRight(line, contentWidth);
+        return `${BOX.vertical} ${padded} ${BOX.vertical}`;
+    });
+}
+function computeContentWidth(params) {
+    const headerLine = params.subtitle ? `${params.title} — ${params.subtitle}` : params.title;
+    const lengths = [lineLength(headerLine), ...params.lines.map((l) => lineLength(l))];
+    return Math.max(10, ...lengths);
+}
+export function renderPanel(params) {
+    const contentWidth = computeContentWidth(params);
+    const top = `${BOX.topLeft}${repeatChar(BOX.horizontal, contentWidth + 2)}${BOX.topRight}`;
+    const bottom = `${BOX.bottomLeft}${repeatChar(BOX.horizontal, contentWidth + 2)}${BOX.bottomRight}`;
+    const header = renderHeader({ title: params.title, subtitle: params.subtitle, contentWidth });
+    const separator = `${BOX.vertical} ${repeatChar(BOX.horizontal, contentWidth)} ${BOX.vertical}`;
+    const body = renderBody(params.lines, contentWidth);
+    return [top, ...header, separator, ...body, bottom].join("\n");
+}