@pugi/cli 0.1.0-beta.21 → 0.1.0-beta.23

package/dist/tui/onboarding-wizard.js

@@ -0,0 +1,240 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Leak L25 (2026-05-27) — Onboarding Ink wizard.
+ *
+ * Six-screen interactive walk:
+ *
+ *   1. Welcome + auth status         (single Enter to continue)
+ *   2. Default permission mode       (4-row picker)
+ *   3. Output style preset           (5-row picker)
+ *   4. MCP server pointer            (informational, Enter to continue)
+ *   5. Telemetry consent             (3-row picker)
+ *   6. Recap card                    (Enter to commit + exit)
+ *
+ * Driven entirely by Ink's `useInput`. The component does NOT perform
+ * any fs writes — it resolves the verdict back to the caller
+ * (`runOnboardingCommand`), which translates verdicts into L6 / L18 /
+ * telemetry-state mutations. Single source of truth: the runner.
+ *
+ * Each picker step pre-selects the CURRENT persisted value (from the
+ * snapshot passed in props) so pressing Enter on Step 2/3/5 keeps the
+ * current value — that is the idempotency contract.
+ *
+ * Cancellation:
+ *   - Esc / Ctrl-C at any step → verdict.cancelled = true, the runner
+ *     skips ALL writes (including the marker touch) so the next bare
+ *     `pugi` invocation still surfaces the first-run hint.
+ *
+ * Keystrokes:
+ *   - ↑/↓ or j/k — move selection in pickers.
+ *   - Enter      — confirm step (keep current = pass through; new pick
+ *                  = update verdict for that tier).
+ *   - 's'        — skip current step explicitly (verdict slot stays null).
+ *   - Esc / 'q'  — cancel the wizard.
+ */
+import { useState } from 'react';
+import { Box, Text, render, useApp, useInput } from 'ink';
+import { PERMISSION_MODES, PERMISSION_MODE_GLOSS, } from '../core/permissions/index.js';
+import { OUTPUT_STYLES, OUTPUT_STYLE_SLUGS, } from '../core/output-style/presets.js';
+import { TELEMETRY_CHOICES, } from '../core/onboarding/telemetry-state.js';
+const EMPTY_DRAFT = {
+    permissionMode: null,
+    outputStyle: null,
+    telemetry: null,
+};
+/**
+ * Lookup the snapshot value's index within the picker rows so the
+ * initial cursor sits on the current value. Returns 0 (safe default)
+ * when the snapshot value is outside the closed list — should never
+ * happen given the type guards in the state modules, but the index
+ * fallback keeps Ink from crashing on a malformed config.
+ */
+function indexOf(rows, value) {
+    const idx = rows.indexOf(value);
+    return idx === -1 ? 0 : idx;
+}
+/**
+ * The wizard component. Pure: no fs, no env, no network. Verdicts
+ * flow up via `onComplete`; the caller owns the writes.
+ */
+export function OnboardingWizard(props) {
+    const { snapshot, onComplete } = props;
+    const [step, setStep] = useState(1);
+    const [permissionIdx, setPermissionIdx] = useState(indexOf(PERMISSION_MODES, snapshot.permissionMode));
+    const [styleIdx, setStyleIdx] = useState(indexOf(OUTPUT_STYLE_SLUGS, snapshot.outputStyle));
+    const [telemetryIdx, setTelemetryIdx] = useState(indexOf(TELEMETRY_CHOICES, snapshot.telemetry));
+    const [draft, setDraft] = useState(EMPTY_DRAFT);
+    const finish = (final, cancelled) => {
+        onComplete({
+            permissionMode: final.permissionMode,
+            outputStyle: final.outputStyle,
+            telemetry: final.telemetry,
+            cancelled,
+        });
+    };
+    useInput((input, key) => {
+        // Universal cancel.
+        if (key.escape || (key.ctrl && input === 'c')) {
+            finish(EMPTY_DRAFT, true);
+            return;
+        }
+        // Universal skip — Enter on a picker means "keep current"; explicit
+        // 's' makes the skip intent obvious in the recap.
+        const isAdvance = key.return;
+        const moveUp = key.upArrow || input === 'k';
+        const moveDown = key.downArrow || input === 'j';
+        const explicitSkip = input === 's';
+        switch (step) {
+            case 1: {
+                if (isAdvance)
+                    setStep(2);
+                return;
+            }
+            case 2: {
+                if (moveUp) {
+                    setPermissionIdx((i) => (i === 0 ? PERMISSION_MODES.length - 1 : i - 1));
+                    return;
+                }
+                if (moveDown) {
+                    setPermissionIdx((i) => (i === PERMISSION_MODES.length - 1 ? 0 : i + 1));
+                    return;
+                }
+                if (isAdvance || explicitSkip) {
+                    const picked = PERMISSION_MODES[permissionIdx];
+                    const verdict = explicitSkip || picked === snapshot.permissionMode ? null : picked ?? null;
+                    setDraft((d) => ({ ...d, permissionMode: verdict }));
+                    setStep(3);
+                    return;
+                }
+                return;
+            }
+            case 3: {
+                if (moveUp) {
+                    setStyleIdx((i) => (i === 0 ? OUTPUT_STYLE_SLUGS.length - 1 : i - 1));
+                    return;
+                }
+                if (moveDown) {
+                    setStyleIdx((i) => (i === OUTPUT_STYLE_SLUGS.length - 1 ? 0 : i + 1));
+                    return;
+                }
+                if (isAdvance || explicitSkip) {
+                    const picked = OUTPUT_STYLE_SLUGS[styleIdx];
+                    const verdict = explicitSkip || picked === snapshot.outputStyle ? null : picked ?? null;
+                    setDraft((d) => ({ ...d, outputStyle: verdict }));
+                    setStep(4);
+                    return;
+                }
+                return;
+            }
+            case 4: {
+                if (isAdvance)
+                    setStep(5);
+                return;
+            }
+            case 5: {
+                if (moveUp) {
+                    setTelemetryIdx((i) => (i === 0 ? TELEMETRY_CHOICES.length - 1 : i - 1));
+                    return;
+                }
+                if (moveDown) {
+                    setTelemetryIdx((i) => (i === TELEMETRY_CHOICES.length - 1 ? 0 : i + 1));
+                    return;
+                }
+                if (isAdvance || explicitSkip) {
+                    const picked = TELEMETRY_CHOICES[telemetryIdx];
+                    const verdict = explicitSkip || picked === snapshot.telemetry ? null : picked ?? null;
+                    setDraft((d) => ({ ...d, telemetry: verdict }));
+                    setStep(6);
+                    return;
+                }
+                return;
+            }
+            case 6: {
+                if (isAdvance)
+                    finish(draft, false);
+                return;
+            }
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsx(StepHeader, { step: step }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [step === 1 && _jsx(WelcomeStep, { snapshot: snapshot }), step === 2 && (_jsx(ModeStep, { current: snapshot.permissionMode, selectedIdx: permissionIdx })), step === 3 && (_jsx(StyleStep, { current: snapshot.outputStyle, currentSource: snapshot.outputStyleSource, selectedIdx: styleIdx })), step === 4 && _jsx(McpStep, {}), step === 5 && (_jsx(TelemetryStep, { current: snapshot.telemetry, selectedIdx: telemetryIdx })), step === 6 && _jsx(RecapStep, { snapshot: snapshot, draft: draft })] }), _jsx(FooterHints, { step: step })] }));
+}
+function StepHeader({ step }) {
+    const titles = {
+        1: 'Welcome to Pugi',
+        2: 'Step 2 / 5 — Default permission mode',
+        3: 'Step 3 / 5 — Output style',
+        4: 'Step 4 / 5 — MCP servers',
+        5: 'Step 5 / 5 — Telemetry consent',
+        6: 'Setup complete',
+    };
+    return (_jsx(Text, { bold: true, color: "cyan", children: titles[step] }));
+}
+function WelcomeStep({ snapshot }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Brief it. It ships." }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: snapshot.authPresent
+                        ? 'You are signed in. The wizard configures local defaults; values persist to ~/.pugi/config.json.'
+                        : 'You are NOT signed in. The wizard still configures local defaults, but you should run `pugi login` after.' }) })] }));
+}
+function ModeStep({ current, selectedIdx, }) {
+    return (_jsx(Box, { flexDirection: "column", children: PERMISSION_MODES.map((mode, idx) => (_jsx(PickerRow, { isSelected: idx === selectedIdx, isCurrent: mode === current, title: mode, gloss: PERMISSION_MODE_GLOSS[mode] }, mode))) }));
+}
+function StyleStep({ current, currentSource, selectedIdx, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [OUTPUT_STYLE_SLUGS.map((slug, idx) => (_jsx(PickerRow, { isSelected: idx === selectedIdx, isCurrent: slug === current, title: slug, gloss: OUTPUT_STYLES[slug].gloss }, slug))), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: currentSource === 'workspace'
+                        ? 'Active style is currently a workspace override. The wizard writes the user-tier default.'
+                        : `Active source: ${currentSource}.` }) })] }));
+}
+function McpStep() {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "MCP servers extend Pugi with extra tools (filesystem, browser, custom APIs)." }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Add one with:" }) }), _jsx(Text, { children: '  pugi mcp add <name> <command>' }), _jsx(Text, { children: '  pugi mcp list' }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "You can skip for now and add servers later." }) })] }));
+}
+function TelemetryStep({ current, selectedIdx, }) {
+    const gloss = {
+        off: 'No telemetry of any kind.',
+        anonymous: 'Counts + error categories only; no payloads.',
+        community: 'Anonymous + opt-in usage panels.',
+    };
+    return (_jsx(Box, { flexDirection: "column", children: TELEMETRY_CHOICES.map((choice, idx) => (_jsx(PickerRow, { isSelected: idx === selectedIdx, isCurrent: choice === current, title: choice, gloss: gloss[choice] }, choice))) }));
+}
+function RecapStep({ snapshot, draft, }) {
+    const finalMode = draft.permissionMode ?? snapshot.permissionMode;
+    const finalStyle = draft.outputStyle ?? snapshot.outputStyle;
+    const finalTelemetry = draft.telemetry ?? snapshot.telemetry;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: `  Permission mode: ${finalMode}${draft.permissionMode === null ? ' (unchanged)' : ''}` }), _jsx(Text, { children: `  Output style:    ${finalStyle}${draft.outputStyle === null ? ' (unchanged)' : ''}` }), _jsx(Text, { children: `  Telemetry:       ${finalTelemetry}${draft.telemetry === null ? ' (unchanged)' : ''}` }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter to write defaults + exit. Esc to cancel without saving." }) })] }));
+}
+function PickerRow({ isSelected, isCurrent, title, gloss, }) {
+    const indicator = isSelected ? '▸ ' : '  ';
+    const currentTag = isCurrent ? ' [current]' : '';
+    return (_jsxs(Text, { children: [_jsxs(Text, { color: isSelected ? 'cyan' : undefined, bold: isSelected, children: [indicator, title.padEnd(18, ' ')] }), _jsx(Text, { dimColor: true, children: `${gloss}${currentTag}` })] }));
+}
+function FooterHints({ step }) {
+    const hint = step === 1 || step === 4
+        ? 'Enter continue   Esc cancel'
+        : step === 6
+            ? 'Enter commit + exit   Esc cancel'
+            : '↑/↓ select   Enter confirm   s skip   Esc cancel';
+    return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: hint }) }));
+}
+/**
+ * Mount the wizard, await the operator's verdict, unmount Ink, return
+ * the verdict to the runner. Wrapped in a `useApp` consumer so we can
+ * call `exit()` and let `waitUntilExit()` resolve cleanly.
+ */
+export async function renderOnboardingWizard(opts) {
+    return new Promise((resolvePromise) => {
+        let resolved = false;
+        const handleComplete = (verdict) => {
+            if (resolved)
+                return;
+            resolved = true;
+            app.unmount();
+            resolvePromise(verdict);
+        };
+        const Wrapper = () => {
+            const { exit } = useApp();
+            return (_jsx(OnboardingWizard, { snapshot: opts.snapshot, onComplete: (verdict) => {
+                    handleComplete(verdict);
+                    exit();
+                } }));
+        };
+        const app = render(_jsx(Wrapper, {}));
+    });
+}
+//# sourceMappingURL=onboarding-wizard.js.map

package/dist/tui/repl-render.js

@@ -22,6 +22,8 @@ import React from 'react';
 import { render } from 'ink';
 import { Repl } from './repl.js';
 import { printPugMascotPreInk } from './repl-splash-mascot.js';
+import { ThemeProvider } from '../core/theme/context.js';
+import { resolveTheme } from '../core/theme/state.js';
 import { ReplSession, } from '../core/repl/session.js';
 import { resolveWorkspaceContext } from '../core/repl/workspace-context.js';
 import { SqliteSessionStore } from '../core/repl/store/index.js';
@@ -70,7 +72,15 @@ export async function renderRepl(options) {
     // the same auto-init UX as a Node operator. Already-bound `.pugi/`
     // dirs also opt back in so the scaffold can fill any missing
     // sub-artifacts the operator deleted.
-    if (process.env.PUGI_NO_AUTO_INIT !== '1' && isProjectRoot(process.cwd())) {
+    // Leak L22 (2026-05-27): `--bare` (PUGI_BARE=1) ALSO suppresses the
+    // auto-init scaffold. Bare mode is the deterministic "fresh install
+    // anywhere" path — no `.pugi/` writes, no PUGI.md scaffold, no
+    // settings.json seed. The pre-existing PUGI_NO_AUTO_INIT escape
+    // hatch stays — bare mode just unions with it.
+    const { isBareMode } = await import('../core/bare-mode/index.js');
+    if (process.env.PUGI_NO_AUTO_INIT !== '1' &&
+        !isBareMode() &&
+        isProjectRoot(process.cwd())) {
         try {
             const { scaffoldPugiWorkspace } = await import('../runtime/cli.js');
             await scaffoldPugiWorkspace({
@@ -173,13 +183,26 @@ export async function renderRepl(options) {
     // (operator opted out via --no-splash), we suppress the pre-print
     // too so the boot stays silent.
     const mascotPrePrinted = options.skipSplash === true ? false : printPugMascotPreInk(process.stdout);
-    const instance = render(React.createElement(Repl, {
+    // Leak L30 (2026-05-27): resolve the active theme ONCE at mount
+    // and wrap `<Repl />` in `<ThemeProvider>` so every Ink consumer
+    // (`<Header>`, `<DoctorTable>`, `<StyleTable>`, `<ThemeTable>`,
+    // …) picks up the same color tokens. The provider is stable for
+    // the lifetime of the REPL — operator `/theme <name>` writes to
+    // disk + appends a system line, and the next `pugi` launch re-
+    // mounts with the new slug. Re-mounting mid-session would race
+    // against Ink's raw-mode handler so we deliberately keep the
+    // session-lifetime contract instead of polling the config file.
+    const resolvedTheme = resolveTheme({
+        workspaceRoot: process.cwd(),
+        env: process.env,
+    });
+    const instance = render(React.createElement(ThemeProvider, { slug: resolvedTheme.slug }, React.createElement(Repl, {
         session,
         updateBanner: options.updateBanner ?? null,
         skipSplash: options.skipSplash === true,
         hideToolStream: options.hideToolStream === true,
         mascotPrePrinted,
-    }));
+    })));
     // Make sure we leave the alt screen on abrupt exits too. Without
     // this the operator's shell stays "frozen" on the Pugi splash.
     process.once('exit', bootstrap.restore);

package/dist/tui/repl.js

@@ -29,6 +29,7 @@ import { StatusBar } from './status-bar.js';
 import { ToolStreamPane } from './tool-stream-pane.js';
 import { UpdateBanner } from './update-banner.js';
 import { collectWorkspaceContext } from './workspace-context.js';
+import { useTheme } from '../core/theme/context.js';
 import { slugForCwd } from '../core/repl/history.js';
 import { SLASH_COMMAND_HELP, SLASH_COMMAND_GROUPS } from '../core/repl/slash-commands.js';
 const TICK_INTERVAL_MS = 200;
@@ -202,7 +203,14 @@ export function Repl(props) {
                         sessionTokensIn: state.sessionTokensIn, sessionTokensOut: state.sessionTokensOut, sessionCostUsd: state.sessionCostUsd, sessionStartedAtEpochMs: state.sessionStartedAtEpochMs, lastTurnDelta: state.lastTurnDelta })] })] }));
 }
 function Header({ state }) {
-    return (_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Pugi" }), _jsx(Text, { bold: true, color: "#3da9fc", children: ".io" }), _jsx(Text, { dimColor: true, children: `  ·  workspace: ${state.workspaceLabel}  ·  v${state.cliVersion}  ·  ` }), _jsx(Text, { color: "#3da9fc", children: state.connection === 'on_watch' ? 'on watch' : state.connection.replace('_', ' ') })] }));
+    // Leak L30 (2026-05-27): the header `.io` brand accent + connection
+    // pill route through `useTheme()` so the operator's `/theme` flip
+    // (default / dark / light / colorblind) re-tints the chrome on
+    // re-mount. The `useTheme` hook returns the `default` preset's
+    // colors when no provider is mounted, preserving the previous
+    // `#3da9fc` constants for tests that import `<Repl />` standalone.
+    const theme = useTheme();
+    return (_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Pugi" }), _jsx(Text, { bold: true, color: theme.accent, children: ".io" }), _jsx(Text, { dimColor: true, children: `  ·  workspace: ${state.workspaceLabel}  ·  v${state.cliVersion}  ·  ` }), _jsx(Text, { color: theme.accent, children: state.connection === 'on_watch' ? 'on watch' : state.connection.replace('_', ' ') })] }));
 }
 function MainArea({ state, personaNames, nowEpochMs, hideToolStream, toolStreamCollapsed, }) {
     // α6.12: three vertical panes stacked above the input box.

package/dist/tui/stickers-art.js

@@ -0,0 +1,136 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+/**
+ * Curated ASCII pug corpus. Five variants — wide enough that repeat
+ * invocations look fresh, narrow enough that every entry stays
+ * hand-vetted (no procedural slop). Each art block intentionally fits
+ * inside an 80-column terminal so the surrounding box border does not
+ * wrap on narrow shells.
+ *
+ * The trailing newline at the end of each `art` string is intentional —
+ * keeps the renderer's join logic uniform between the boxed and the
+ * `--ascii-only` paths.
+ */
+export const PUG_STICKERS = Object.freeze([
+    {
+        id: 'classic-face',
+        caption: 'classic pug face',
+        art: [
+            '   _._     _,-\'""`-._',
+            '  (,-.`._,\'(       |\\`-/|',
+            '      `-.-\' \\ )-`( , o o)',
+            '            `-    \\`_`"\'-',
+        ].join('\n'),
+    },
+    {
+        id: 'sit-pose',
+        caption: 'sit, stay, ship',
+        art: [
+            '    /\\___/\\',
+            '   ( o   o )',
+            '   (  =^=  )',
+            '    (______)',
+        ].join('\n'),
+    },
+    {
+        id: 'peek',
+        caption: 'peek-a-pug',
+        art: [
+            '       __',
+            '   ___/  \\___',
+            '  /  o    o  \\',
+            ' |   >  ^  <  |',
+            '  \\__________/',
+        ].join('\n'),
+    },
+    {
+        id: 'sleepy',
+        caption: 'sleepy pug, no Zzz today',
+        art: [
+            '     .--.',
+            '    / -  -\\',
+            '   ( ^    ^ )',
+            '    \\  ^^  /',
+            '     `----\'',
+        ].join('\n'),
+    },
+    {
+        id: 'shipping',
+        caption: 'shipping pug',
+        art: [
+            '   .---.   .---.',
+            '   |o_o|   |o_o|',
+            '   \\_^_/   \\_^_/',
+            '   /| |\\   /| |\\',
+            '  shipped • shipped',
+        ].join('\n'),
+    },
+]);
+/**
+ * Curated rotating-quote pool. Brand voice gate (brandbook §08):
+ * `brief / dispatch / stop / agents / quit / shipped` are the power
+ * words; quotes lean on those and на the operator-mode register.
+ * Adding lines: keep each ≤ 64 chars so the boxed renderer never wraps,
+ * stay в the operator's voice, no AI attribution, no hype.
+ */
+export const PUG_QUOTES = Object.freeze([
+    'Pugi: your engineering co-pilot.',
+    'Brief it. It ships.',
+    'Built for operators, not for benchmarks.',
+    'Pugi: твой инженерный напарник.',
+    'Dispatch agents, not promises.',
+    'Small CLI. Loud workforce.',
+    'Engineering at the speed of brief.',
+    'Pugi: shipping is the default mode.',
+]);
+/**
+ * Clamp a raw rng draw to a safe array index. Handles every hostile
+ * shape the spec exercises:
+ *   - rng returns NaN → fall back to 0
+ *   - rng returns 1.0 → clamp to length-1 (Math.floor would land at n)
+ *   - rng returns -ε → clamp to 0
+ * The caller hands в the corpus length; the helper never touches the
+ * corpus itself so it stays trivially testable.
+ */
+function safeIndex(raw, length) {
+    if (!Number.isFinite(raw))
+        return 0;
+    const floored = Math.floor(raw);
+    if (floored < 0)
+        return 0;
+    if (floored >= length)
+        return length - 1;
+    return floored;
+}
+/**
+ * Pick one art variant. Defaults to `Math.random` but the caller can
+ * inject a deterministic source — the spec uses a sequence-driven
+ * stub to assert the picker hits each entry в the corpus.
+ */
+export function pickArtVariant(rng = Math.random) {
+    const raw = rng() * PUG_STICKERS.length;
+    return PUG_STICKERS[safeIndex(raw, PUG_STICKERS.length)];
+}
+/**
+ * Pick one rotating brand quote. Same contract as `pickArtVariant` —
+ * test-injectable rng so the spec can pin the chosen index.
+ */
+export function pickQuote(rng = Math.random) {
+    const raw = rng() * PUG_QUOTES.length;
+    return PUG_QUOTES[safeIndex(raw, PUG_QUOTES.length)];
+}
+/**
+ * Plain-text renderer for the `--ascii-only` flag and the non-TTY shell
+ * path. Emits the art verbatim, then a blank line, then the quote.
+ * No box border — scripting use-case (`pugi stickers --ascii-only`
+ * piped to `figlet`, `lolcat`, or a regression-fixture file) gets a
+ * stable contract free of decorative ANSI noise.
+ */
+export function renderPugStickersText(art, quote) {
+    return `${art.art}\n\n${quote}`;
+}
+export function PugStickersArt({ art, quote }) {
+    const lines = art.art.split('\n');
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, children: "Pugi stickers" }), _jsxs(Text, { dimColor: true, children: ["  \u2014 ", art.caption] })] }), _jsx(Box, { flexDirection: "column", children: lines.map((line, i) => (_jsx(Text, { children: line }, `art-${i}`))) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["\"", quote, "\""] }) })] }));
+}
+//# sourceMappingURL=stickers-art.js.map

package/dist/tui/style-table.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { OUTPUT_STYLES, OUTPUT_STYLE_SLUGS, } from '../core/output-style/presets.js';
+import { useTheme } from '../core/theme/context.js';
+/**
+ * Banner above the table. Plain text (not bold) so the prefix `*`
+ * remains the dominant active-row cue.
+ */
+function buildBanner(active, source) {
+    return `Active style: ${active} (${source})`;
+}
+export function StyleTable({ active, source }) {
+    // Leak L30 (2026-05-27): the active-row marker color flows through
+    // the theme so `colorblind` operators see cyan instead of green
+    // (which their palette re-maps to `success`). Falls back to the
+    // default theme's `success` token when no provider is mounted.
+    const theme = useTheme();
+    const slugWidth = Math.max('NAME'.length, ...OUTPUT_STYLE_SLUGS.map((slug) => slug.length));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Pugi output styles" }) }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `  ${'NAME'.padEnd(slugWidth)}  GLOSS` }) }), OUTPUT_STYLE_SLUGS.map((slug) => (_jsx(StyleRow, { slug: slug, active: active, slugWidth: slugWidth, activeColor: theme.success }, slug))), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: buildBanner(active, source) }) })] }));
+}
+function StyleRow({ slug, active, slugWidth, activeColor }) {
+    const isActive = slug === active;
+    const marker = isActive ? '*' : ' ';
+    const slugPart = slug.padEnd(slugWidth, ' ');
+    const gloss = OUTPUT_STYLES[slug].gloss;
+    return (_jsxs(Box, { children: [_jsx(Text, { color: isActive ? activeColor : undefined, bold: isActive, children: `${marker} ${slugPart}` }), _jsx(Text, { children: `  ${gloss}` })] }));
+}
+//# sourceMappingURL=style-table.js.map

package/dist/tui/theme-table.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { compileSampleRow, THEMES, THEME_SLUGS, } from '../core/theme/presets.js';
+/**
+ * Banner above the table. Plain text (not bold) so the prefix `*`
+ * remains the dominant active-row cue. Mirrors `<StyleTable>` so the
+ * Settings-group surfaces read identically.
+ */
+function buildBanner(active, source) {
+    return `Active theme: ${active} (${source})`;
+}
+export function ThemeTable({ active, source }) {
+    const slugWidth = Math.max('NAME'.length, ...THEME_SLUGS.map((slug) => slug.length));
+    // The gloss column gets sized to the widest gloss + 2 padding so
+    // the sample column lines up. Computed once per render so the
+    // layout stays stable when the catalogue grows.
+    const glossWidth = Math.max('GLOSS'.length, ...THEME_SLUGS.map((slug) => THEMES[slug].gloss.length));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Pugi themes" }) }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `  ${'NAME'.padEnd(slugWidth)}  ${'GLOSS'.padEnd(glossWidth)}  SAMPLE` }) }), THEME_SLUGS.map((slug) => (_jsx(ThemeRow, { slug: slug, active: active, slugWidth: slugWidth, glossWidth: glossWidth }, slug))), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: buildBanner(active, source) }) })] }));
+}
+function ThemeRow({ slug, active, slugWidth, glossWidth }) {
+    const isActive = slug === active;
+    const marker = isActive ? '*' : ' ';
+    const slugPart = slug.padEnd(slugWidth, ' ');
+    const preset = THEMES[slug];
+    const gloss = preset.gloss.padEnd(glossWidth, ' ');
+    const sample = compileSampleRow(slug);
+    return (_jsxs(Box, { children: [_jsx(Text, { color: isActive ? preset.colors.accent : undefined, bold: isActive, children: `${marker} ${slugPart}` }), _jsx(Text, { children: `  ${gloss}  ` }), _jsx(Text, { color: preset.colors.foreground, children: sample.foreground }), _jsx(Text, { children: ' ' }), _jsx(Text, { color: preset.colors.accent, children: sample.accent }), _jsx(Text, { children: ' ' }), _jsx(Text, { color: preset.colors.success, children: sample.success }), _jsx(Text, { children: ' ' }), _jsx(Text, { color: preset.colors.warning, children: sample.warning }), _jsx(Text, { children: ' ' }), _jsx(Text, { color: preset.colors.error, children: sample.error })] }));
+}
+//# sourceMappingURL=theme-table.js.map