@pugi/cli 0.1.0-beta.99 → 1.0.0-alpha.1

package/dist/tui/tool-stream-pane.js

@@ -1,140 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-import { RESULT_PREVIEW_MAX_CHARS, STREAMING_DELTA_MAX_CHARS, } from '../core/repl/session.js';
-const DEFAULT_COLLAPSE_THRESHOLD = 5;
-const DEFAULT_MAX_ROWS = 8;
-export function ToolStreamPane(props) {
-    const calls = props.calls;
-    const collapseThreshold = props.collapseThreshold ?? DEFAULT_COLLAPSE_THRESHOLD;
-    const maxRows = props.maxRows ?? DEFAULT_MAX_ROWS;
-    if (calls.length === 0) {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(PaneHeader, { count: 0, collapsed: props.collapsed }), _jsx(Text, { dimColor: true, children: "No tool calls yet. Dispatch a brief and watch tools land here." })] }));
-    }
-    if (props.collapsed === true) {
-        return (_jsx(Box, { flexDirection: "column", children: _jsx(PaneHeader, { count: calls.length, collapsed: true }) }));
-    }
-    // Tail-window the rows so a long-running session does not overflow
-    // the bottom half of the frame. Older rows stay in the session state
-    // for /jobs and /diff inspection.
-    const visible = calls.slice(-maxRows);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(PaneHeader, { count: calls.length, collapsed: false }), visible.map((call) => (_jsx(ToolCallRow, { call: call, collapseThreshold: collapseThreshold }, call.id)))] }));
-}
-function PaneHeader({ count, collapsed }) {
-    const verb = collapsed ? 'Ctrl+T to expand' : 'Ctrl+T to collapse';
-    return (_jsxs(Box, { children: [_jsx(Text, { bold: true, dimColor: true, children: '─ tools ' }), _jsx(Text, { dimColor: true, children: `(${count}) ` }), _jsx(Text, { dimColor: true, children: verb })] }));
-}
-function ToolCallRow({ call, collapseThreshold, }) {
-    const glyph = statusGlyph(call.status);
-    const color = statusColor(call.status);
-    const label = formatToolLabel(call.tool, call.args);
-    const summary = formatSummary(call);
-    const showHint = (call.resultLines ?? 0) > collapseThreshold;
-    // small-CC-parity batch : on a `running` row,
-    // surface the rolling streaming delta as a dim inline preview after
-    // the label. On a completed row, the same slot carries the
-    // `resultPreview` quoted head. Either way the row stays single-line —
-    // both fields are clamped к their respective char ceilings upstream.
-    const inlineTail = call.status === 'running'
-        ? call.streamingDelta
-        : call.resultPreview;
-    // Error rows: render the label too in red so the eye lands on the
-    // failure even при peripheral attention. The other states keep the
-    // glyph as the only color signal.
-    const labelColor = call.status === 'error' ? 'red' : undefined;
-    return (_jsxs(Box, { children: [_jsx(Text, { color: color, children: glyph }), _jsx(Text, { children: ' ' }), _jsx(Text, { bold: true, color: labelColor, children: label }), _jsx(Text, { dimColor: true, children: ` ${summary}` }), inlineTail ? (_jsx(Text, { dimColor: true, children: ` ${formatInlineTail(call.status, inlineTail)}` })) : null, showHint ? (_jsx(Text, { dimColor: true, children: ` · ${call.resultLines} lines, Ctrl+O to expand` })) : null] }));
-}
-/**
- * small-CC-parity batch : render the inline tail
- * slot for either the live `streamingDelta` (during `running`) or the
- * collapsed `resultPreview` (after completion). Pure helper so the
- * spec can assert the exact shape.
- *
- *  running       → `… npm WARN deprecated…`
- *  ok / error    → `"<preview head>"`
- */
-export function formatInlineTail(status, tail) {
-    if (status === 'running') {
-        return tail;
-    }
-    // Wrap the completed preview in quotes so the operator's eye groups
-    // the preview block visually distinct from the canonical detail
-    // (`OK`, `+12 -0`). Mirrors the the upstream tool TUI's quoted-preview
-    // pattern.
-    return `"${tail}"`;
-}
-function statusGlyph(status) {
-    switch (status) {
-        case 'running':
-            return '→';
-        case 'ok':
-            return '✓';
-        case 'error':
-            return '✗';
-    }
-}
-function statusColor(status) {
-    switch (status) {
-        case 'running':
-            return 'cyan';
-        case 'ok':
-            return 'green';
-        case 'error':
-            return 'red';
-    }
-}
-/**
- * Render the canonical `Tool(args)` form. Tool names are capitalised
- * the way the upstream tool shows them; args are truncated to keep the row
- * single-line even on 80-col terminals. Cap = 60 chars (chosen empirically
- * to leave room for the glyph + 1-space gap + summary + optional
- * inline tail without overflow on narrow shells).
- */
-function formatToolLabel(tool, args) {
-    const name = toolDisplayName(tool);
-    const trimmedArgs = args.length > 60 ? `${args.slice(0, 57)}…` : args;
-    return `${name}(${trimmedArgs})`;
-}
-/**
- * Re-export the upstream char caps so the operator-facing constants
- * have one source of truth. The session module owns the canonical
- * values (used both during ingest и during the pane's render lookup);
- * tests assert against these names rather than literal numbers so a
- * future tuning сtays diff-friendly.
- */
-export { RESULT_PREVIEW_MAX_CHARS, STREAMING_DELTA_MAX_CHARS };
-function toolDisplayName(tool) {
-    switch (tool) {
-        case 'read':
-            return 'Read';
-        case 'write':
-            // — Write is the most operator-visible tool for the
-            // codegen-dispatch surface (Hiroshi writing index.html / style.css
-            // / script.js for a tic-tac-toe brief). Add the display name so
-            // the tool stream pane renders ✓ Write(index.html) instead of an
-            // unlabeled placeholder. Mirrors the the upstream tool Write rendering.
-            return 'Write';
-        case 'edit':
-            return 'Edit';
-        case 'bash':
-            return 'Bash';
-        case 'grep':
-            return 'Grep';
-        case 'glob':
-            return 'Glob';
-        case 'web_fetch':
-            return 'WebFetch';
-    }
-}
-function formatSummary(call) {
-    if (call.status === 'running') {
-        return call.detail ?? 'running...';
-    }
-    if (call.status === 'error') {
-        return call.detail ?? 'error';
-    }
-    // ok
-    const duration = typeof call.durationMs === 'number' ? `${call.durationMs}ms` : '';
-    const detail = call.detail ?? 'OK';
-    return duration.length > 0 ? `${detail} ${duration}` : detail;
-}
-//# sourceMappingURL=tool-stream-pane.js.map

package/dist/tui/update-banner.js

@@ -1,33 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-import { compareVersions, upgradeCommand, } from '../runtime/update-check.js';
-import { getCachedServerRecommendation } from '../core/transport/version-interceptor.js';
-/**
- * Resolve the `latest` value the banner should show. Exported so the
- * spec can lock the merge logic without rendering Ink.
- */
-export function resolveDisplayedLatest(npmLatest, serverRecommended) {
-    if (!serverRecommended)
-        return npmLatest;
-    return compareVersions(serverRecommended, npmLatest) > 0
-        ? serverRecommended
-        : npmLatest;
-}
-/**
- * peer-CLI-style corner banner: single line, dim orange, right
- * aligned. Renders to the bottom of the REPL frame so it never
- * displaces conversation content. Only mounts when an update is
- * actually available; identical to no-op when the registry poll
- * reports current. Suppress with `PUGI_SKIP_UPDATE_BANNER=1`.
- */
-export function UpdateBanner({ result }) {
-    const command = upgradeCommand(result.method);
-    // Read the cache lazily inside the render so a server response that
-    // landed AFTER the banner was constructed still shows up on the next
-    // re-render. The cache lookup is a single map read — cheap enough to
-    // do per render.
-    const serverRecommended = getCachedServerRecommendation();
-    const displayedLatest = resolveDisplayedLatest(result.latest, serverRecommended);
-    return (_jsx(Box, { justifyContent: "flex-end", children: _jsxs(Text, { color: "#d97706", children: [_jsx(Text, { dimColor: true, children: 'Update available! ' }), _jsx(Text, { dimColor: true, children: `v${displayedLatest} — Run: ` }), _jsx(Text, { bold: true, children: command })] }) }));
-}
-//# sourceMappingURL=update-banner.js.map

package/dist/tui/vim-input.js

@@ -1,267 +0,0 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * — Vim-mode-aware REPL input.
- *
- * Thin wrapper that sits BETWEEN the REPL session and the legacy
- * `InputBox`. When vim mode is off it forwards every prop unchanged
- * so existing operators see zero behavioural delta. When vim mode is
- * on it intercepts keystrokes through `useInput` BEFORE Ink's normal
- * dispatch and either:
- *
- *  - in `insert` mode, lets the keystroke fall through to `InputBox`
- *    so the legacy buffer / cursor / history / palette code stays
- *    authoritative (we do NOT re-implement insert-mode editing);
- *  - in `normal` mode, routes the key through `core/vim/keymap.ts`
- *    and applies the result to a shadow buffer + cursor mirror that
- *    it then pushes back into `InputBox` via the existing `initial`
- *    prop on remount.
- *
- * Why a wrapper instead of inlining into `InputBox`?
- *
- *  - Keeps the legacy input surface untouched for non-vim operators
- *    (the L26 ship risks zero regression to ~year-old code).
- *  - The wrapper renders a thin status row ABOVE the input frame so
- *    the active mode + pending sequence + cheat sheet are visible.
- *  - Tests can exercise the wrapper without dragging in the full
- *    ink + clipboard stack of `InputBox` (the spec drives the
- *    keymap directly; the wrapper is exercised via the runtime
- *    command tests + manual smoke from the REPL).
- *
- * The component intentionally only models the SINGLE-LINE REPL prompt
- * buffer — that is the surface the upstream tool's `/vim` covers, and that
- * is what the upstream behavior validated. Multi-line + visual-mode +
- * counts are out of scope for this sprint.
- *
- * ─── Closure-staleness contract (post-L26 fix) ───
- *
- * Three-of-three reviewers flagged the original `setShadowLine`
- * functional updater for reading `shadowCursor` and `pending` from
- * the closure, which goes stale across consecutive keystrokes
- * (React batches dispatch, so the second `d` of `dd` saw the
- * `pending` value from the render that scheduled the first `d`,
- * not the post-first-d value). Same problem for cursor advancement
- * across chained `l`/`h`/`w`/`b` presses.
- *
- * Additionally, calling `props.onSubmit` inline inside a setState
- * updater is double-fired by React strict mode (updaters MUST be
- * pure — strict mode runs them twice to surface impurity).
- *
- * The fix moves shadow cursor + pending + mode into `useRef`
- * (refs survive across renders, are read synchronously, and are
- * not subject to closure capture), drives the keymap dispatch
- * OUTSIDE any setState callback, and defers `props.onSubmit` /
- * `props.onExit` invocations until AFTER the render via the
- * `useEffect` queued by toggling a transition ref.
- *
- * The `line` state is the only React state we mutate per keystroke
- * because the inner `InputBox` re-reads it via the `initial` prop
- * on remount — refs alone cannot trigger that remount. Cursor + mode
- * + pending are surfaced to the render path through the same
- * `line`/`tick` rerender, so the status bar stays in sync without
- * itself being captured by a stale closure.
- */
-import { useEffect, useRef, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
-import { handleNormalKey, PENDING_NONE, describePending, } from '../core/vim/keymap.js';
-import { InputBox } from './input-box.js';
-/**
- * Render the mode badge + pending sequence + cheat sheet above the
- * input frame. Two lines:
- *
- *  ─ NORMAL ─ d:               Esc=normal · i=insert · :w=submit · :q=cancel
- *  ─ INSERT ─                  (mode-specific tail dropped when there's nothing to show)
- *
- * Plain ASCII + dim accents to match the rest of the REPL's chrome.
- */
-function VimStatusBar(props) {
-    const modeLabel = props.mode === 'normal' ? '-- NORMAL --' : '-- INSERT --';
-    const pendingLabel = describePending(props.pending);
-    const hint = props.mode === 'normal'
-        ? 'h/j/k/l move · i/a insert · x del · dd line · :w submit · :q cancel'
-        : 'Esc → normal mode';
-    return (_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", bold: true, children: modeLabel }), pendingLabel.length > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: "yellow", children: `${pendingLabel}` })] })) : null, _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: hint })] }));
-}
-export function VimInput(props) {
-    const { vimEnabled, initialMode, ...inputBoxProps } = props;
-    // When vim mode is off we DO NOT mount the `useInput` overlay — the
-    // legacy `InputBox` keeps full ownership of the keystrokes and
-    // behaves byte-for-byte the way it always did. This is the same
-    // pattern `output-style` followed (off → pass through; on → activate
-    // the modal surface).
-    if (!vimEnabled) {
-        return _jsx(InputBox, { ...inputBoxProps });
-    }
-    // ─── Render-driving state ─────────────────────────────────────
-    //
-    // `line` + `tick` are the only pieces of state the render path
-    // reads — the inner `InputBox` is remounted on every `tick` bump
-    // so the `initial` prop is honoured. Cursor / pending / mode are
-    // held in refs (see below) and mirrored into render state via the
-    // same setLine/setTick burst at the end of each keystroke so the
-    // status bar stays in lockstep without ever being captured by a
-    // stale closure inside a setState updater.
-    const [line, setLine] = useState(props.initial ?? '');
-    const [mode, setMode] = useState(initialMode ?? 'normal');
-    const [pending, setPending] = useState(PENDING_NONE);
-    const [remountTick, setRemountTick] = useState(0);
-    // ─── Closure-safe scratch refs ────────────────────────────────
-    //
-    // These refs are written synchronously inside the `useInput`
-    // handler and read on the NEXT keystroke. They survive across
-    // renders, are not captured by stale closures, and are NEVER
-    // mutated inside a setState updater — so React strict-mode's
-    // double-invocation cannot corrupt them.
-    //
-    // Why not `useReducer`? A reducer would also see fresh state on
-    // every dispatch, but the keymap result is a tagged union whose
-    // side effects (mode flip, submit, cancel, remount) are easier
-    // to read as imperative steps after the pure `handleNormalKey`
-    // call. Refs keep the dispatcher linear and the diff vs the
-    // pre-fix file minimal.
-    const lineRef = useRef(props.initial ?? '');
-    const cursorRef = useRef(props.initial?.length ?? 0);
-    const pendingRef = useRef(PENDING_NONE);
-    const modeRef = useRef(initialMode ?? 'normal');
-    // Deferred side-effect queue — submit / exit must NOT run inline
-    // inside a setState updater (strict mode double-invokes them).
-    // We stash the payload here and flush it from a `useEffect` after
-    // the render commits.
-    const pendingSubmitRef = useRef(null);
-    const pendingExitRef = useRef(false);
-    const [sideEffectTick, setSideEffectTick] = useState(0);
-    useEffect(() => {
-        // Flush any deferred host callback exactly once per scheduled
-        // burst. The refs are nulled BEFORE the call so a re-entrant
-        // host onSubmit handler that re-renders us cannot re-fire the
-        // same payload.
-        const submit = pendingSubmitRef.current;
-        if (submit !== null) {
-            pendingSubmitRef.current = null;
-            props.onSubmit(submit);
-        }
-        if (pendingExitRef.current) {
-            pendingExitRef.current = false;
-            props.onExit();
-        }
-        // Intentionally only depends on `sideEffectTick`: we want this
-        // effect to fire ONLY when the keystroke handler asked for it
-        // (via setSideEffectTick), not on every prop change.
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [sideEffectTick]);
-    useInput((input, key) => {
-        // Esc always returns to normal mode (and clears any pending
-        // sequence). This binding wins over `InputBox`'s own Esc handling
-        // because we own the `useInput` hook earlier in the render tree.
-        if (key.escape) {
-            modeRef.current = 'normal';
-            pendingRef.current = PENDING_NONE;
-            setMode('normal');
-            setPending(PENDING_NONE);
-            return;
-        }
-        // In insert mode we relinquish dispatch entirely so the legacy
-        // input box owns typing / palette / history / clipboard / kill
-        // ring without interference. Returning `undefined` from a
-        // `useInput` callback is a no-op — InputBox's own `useInput` will
-        // receive the same event on the next frame.
-        if (modeRef.current === 'insert')
-            return;
-        // In normal mode we drive the buffer through the keymap.
-        //
-        // CRITICAL: all inputs to `handleNormalKey` are read from refs,
-        // not from the React state closure captured at render time.
-        // This is what makes consecutive keystrokes ("ll", "dd", ":w")
-        // observe the post-previous-keystroke state instead of the
-        // pre-batch render snapshot.
-        const ch = input ?? '';
-        const curLine = lineRef.current;
-        const curCursor = cursorRef.current;
-        const curPending = pendingRef.current;
-        const out = handleNormalKey({
-            line: curLine,
-            cursor: curCursor,
-            pending: curPending,
-            ch,
-            enter: key.return,
-            escape: false,
-            backspace: key.backspace || key.delete,
-        });
-        // Step 1: write the new pending state to BOTH the ref (read by
-        // the next keystroke synchronously) AND the React state (drives
-        // the status bar render).
-        pendingRef.current = out.pending;
-        setPending(out.pending);
-        // Step 2: apply the discriminated result. Each branch updates
-        // the refs first (synchronous, closure-safe) and then schedules
-        // any required React state update or deferred side effect.
-        switch (out.result.kind) {
-            case 'move': {
-                cursorRef.current = out.result.cursor;
-                // Cursor lives in the ref; the inner InputBox does not need
-                // a remount for a pure motion, so we skip the tick bump.
-                break;
-            }
-            case 'edit': {
-                cursorRef.current = out.result.cursor;
-                lineRef.current = out.result.line;
-                setLine(out.result.line);
-                setRemountTick((t) => t + 1);
-                break;
-            }
-            case 'mode': {
-                cursorRef.current = out.result.cursor;
-                modeRef.current = out.result.mode;
-                setMode(out.result.mode);
-                break;
-            }
-            case 'submit': {
-                // Forward to the host's onSubmit and clear the shadow buffer
-                // so the next prompt starts empty. We DO NOT re-route
-                // through InputBox's Enter handler — that path also writes
-                // history; submitting from `:w` should mirror that, so we
-                // call props.onSubmit indirectly via the deferred-effect
-                // queue. (The host's history append happens inside InputBox;
-                // for the modal path the host can observe via props.onSubmit
-                // and append manually if needed. The leak-parity surface for
-                // L26 documents `:w` as equivalent to Enter so this is fine.)
-                const payload = out.result.payload;
-                if (payload.trim().length > 0) {
-                    // Queue the host callback; useEffect flushes it after the
-                    // render commits. This avoids React strict-mode's
-                    // double-invocation of setState updaters double-firing
-                    // onSubmit (which would, e.g., submit the same prompt
-                    // twice to the agent on every `:w`).
-                    pendingSubmitRef.current = payload;
-                }
-                cursorRef.current = 0;
-                lineRef.current = '';
-                setLine('');
-                setRemountTick((t) => t + 1);
-                setSideEffectTick((t) => t + 1);
-                break;
-            }
-            case 'cancel': {
-                cursorRef.current = 0;
-                lineRef.current = '';
-                setLine('');
-                setRemountTick((t) => t + 1);
-                break;
-            }
-            case 'noop': {
-                // No-op result still may have advanced `pending` (e.g. the
-                // first `d` of `dd` arms the pending state). The pending ref
-                // and state were already updated above, so nothing else to
-                // do here.
-                break;
-            }
-        }
-    });
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(VimStatusBar, { mode: mode, pending: pending }), _jsx(InputBox, { ...inputBoxProps, 
-                // In normal mode we seed the (possibly mutated) shadow line +
-                // suppress the blink so the operator's caret is unambiguously
-                // controlled by h/l/0/$/w/b. In insert mode we hand the
-                // buffer back to InputBox as-is so the legacy typing path
-                // takes over.
-                initial: mode === 'normal' ? line : (props.initial ?? line), blinkCursor: mode === 'normal' ? false : (props.blinkCursor ?? true) }, `vim-${remountTick}`)] }));
-}
-//# sourceMappingURL=vim-input.js.map

package/dist/tui/welcome-banner.js

@@ -1,107 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-import { PUG_MASCOT, PUG_MASCOT_CYAN_MASK, PUG_MASCOT_MAX_WIDTH, } from './repl-splash-art.js';
-/* ------------------------------------------------------------------ */
-/* Layout constants                                                  */
-/* ------------------------------------------------------------------ */
-/** Default left-column width when the parent box doesn't pin one. */
-const LEFT_COLUMN_WIDTH = 44;
-/** Default right-column width. */
-const RIGHT_COLUMN_WIDTH = 44;
-const ACCENT = '#3da9fc';
-const BULLET = '·';
-/* ------------------------------------------------------------------ */
-/* Component                                                         */
-/* ------------------------------------------------------------------ */
-export function WelcomeBanner(props) {
-    const { data } = props;
-    const showHandCraftedMascot = props.mascotPrePrinted !== true;
-    const initToast = props.autoInitStatus === 'initialized'
-        ? 'Pugi workspace initialised at .pugi/.'
-        : null;
-    const accountLine = formatAccountLine(data);
-    const modelLine = formatModelLine(data);
-    return (_jsx(Box, { flexDirection: "column", children: _jsxs(Box, { borderStyle: "round", borderColor: ACCENT, paddingX: 1, flexDirection: "row", children: [_jsx(LeftColumn, { greetingName: data.greetingName, cwd: data.cwd, modelLine: modelLine, accountLine: accountLine, cliVersion: data.cliVersion, showHandCraftedMascot: showHandCraftedMascot, initToast: initToast }), _jsx(Box, { width: 2 }), _jsx(RightColumn, { whatsNew: data.whatsNew })] }) }));
-}
-/* ------------------------------------------------------------------ */
-/* Left column — greeting + mascot + status                           */
-/* ------------------------------------------------------------------ */
-function LeftColumn({ greetingName, cwd, modelLine, accountLine, cliVersion, showHandCraftedMascot, initToast, }) {
-    return (_jsxs(Box, { flexDirection: "column", width: LEFT_COLUMN_WIDTH, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Pugi" }), _jsx(Text, { bold: true, color: ACCENT, children: ".io" }), _jsx(Text, { dimColor: true, children: ` v${cliVersion}` })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: `Welcome back ${greetingName}!` }) }), showHandCraftedMascot ? (_jsx(Box, { marginTop: 1, children: _jsx(MascotColumn, {}) })) : null, _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { children: modelLine }), _jsx(Text, { dimColor: true, children: accountLine }), _jsx(Text, { dimColor: true, children: truncatePath(cwd, LEFT_COLUMN_WIDTH - 2) })] }), initToast ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: ACCENT, children: initToast }) })) : null] }));
-}
-/* ------------------------------------------------------------------ */
-/* Right column — tips + what's new                                   */
-/* ------------------------------------------------------------------ */
-function RightColumn({ whatsNew, }) {
-    return (_jsxs(Box, { flexDirection: "column", width: RIGHT_COLUMN_WIDTH, children: [_jsx(Text, { dimColor: true, children: "Tips for getting started" }), _jsxs(Box, { flexDirection: "column", children: [_jsx(TipRow, { text: "Run /init to scaffold PUGI.md instructions" }), _jsx(TipRow, { text: "Brief Pugi \u2014 the workforce dispatches" }), _jsx(TipRow, { text: "Triple-review gate before push: /review --triple" }), _jsx(TipRow, { text: "/help for every slash command" })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: '─'.repeat(Math.min(RIGHT_COLUMN_WIDTH - 2, 18)) }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "What's new" }) }), _jsx(Box, { flexDirection: "column", children: whatsNew.length > 0 ? (whatsNew.map((line, index) => (_jsx(TipRow, { text: line }, `whatsnew-${index}`)))) : (_jsx(Text, { dimColor: true, children: ` ${BULLET} /release-notes for the full changelog` })) })] }));
-}
-function TipRow({ text }) {
-    return (_jsxs(Text, { children: [_jsx(Text, { color: ACCENT, children: ` ${BULLET} ` }), _jsx(Text, { children: text })] }));
-}
-/* ------------------------------------------------------------------ */
-/* Mascot column (hand-crafted ASCII fallback path)                   */
-/* ------------------------------------------------------------------ */
-function MascotColumn() {
-    return (_jsx(Box, { flexDirection: "column", minWidth: PUG_MASCOT_MAX_WIDTH, children: PUG_MASCOT.map((row, rowIndex) => (_jsx(MascotRow, { row: row, mask: PUG_MASCOT_CYAN_MASK[rowIndex] ?? [] }, `mascot-row-${rowIndex}`))) }));
-}
-function MascotRow({ row, mask, }) {
-    // Split into contiguous same-color runs so we emit one <Text> per
-    // run instead of one per character (keeps the Ink tree shallow и
-    // the snapshot diff readable).
-    const runs = [];
-    let buffer = '';
-    let bufferCyan = false;
-    for (let column = 0; column < row.length; column += 1) {
-        const ch = row.charAt(column);
-        const cyan = mask[column] === true;
-        if (buffer.length === 0) {
-            buffer = ch;
-            bufferCyan = cyan;
-            continue;
-        }
-        if (cyan === bufferCyan) {
-            buffer += ch;
-        }
-        else {
-            runs.push({ text: buffer, cyan: bufferCyan });
-            buffer = ch;
-            bufferCyan = cyan;
-        }
-    }
-    if (buffer.length > 0)
-        runs.push({ text: buffer, cyan: bufferCyan });
-    return (_jsx(Text, { children: runs.map((run, runIndex) => run.cyan ? (_jsx(Text, { color: ACCENT, children: run.text }, runIndex)) : (_jsx(Text, { color: "gray", children: run.text }, runIndex))) }));
-}
-/* ------------------------------------------------------------------ */
-/* Formatters                                                        */
-/* ------------------------------------------------------------------ */
-function formatModelLine(data) {
-    const tierLabel = data.plan ? ` ${BULLET} ${capitalize(data.plan)} Tier` : '';
-    return `${data.model}${tierLabel}`;
-}
-function formatAccountLine(data) {
-    if (!data.email) {
-        return 'Anonymous (run /login to authenticate)';
-    }
-    const tenant = data.tenant ? ` ${BULLET} ${data.tenant} Org` : '';
-    return `${data.email}${tenant}`;
-}
-function capitalize(value) {
-    if (value.length === 0)
-        return value;
-    return value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
-}
-/**
- * Trim the cwd from the LEFT (preserving the basename) so the operator
- * always sees which project they're in even when the column is narrow.
- * Mirrors the the upstream tool boot card convention: long paths get an
- * ellipsis on the head, never on the tail.
- */
-export function truncatePath(path, max) {
-    if (path.length <= max)
-        return path;
-    if (max <= 3)
-        return path.slice(-max);
-    return `…${path.slice(-(max - 1))}`;
-}
-//# sourceMappingURL=welcome-banner.js.map