@pugi/cli 0.1.0-beta.7 → 0.1.0-beta.87

package/dist/tui/vim-input.js

@@ -0,0 +1,267 @@
+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

@@ -0,0 +1,107 @@
+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

package/dist/tui/welcome-data.js

@@ -0,0 +1,293 @@
+/**
+ * Pure data layer for the `<WelcomeBanner />` component (CEO P0 #2,
+ *). Lives in its own module so it can be unit-tested without
+ * rendering Ink, and so the banner component itself contains zero IO.
+ *
+ * The banner is the 2-column boxed greeting that replaces the
+ * wave-3 `<ReplSplash />` on the bare REPL boot path. It mirrors
+ * the upstream tool's boot layout:
+ *
+ *    ╭────── Pugi v0.1.0-beta.46 ──────╮
+ *    │                                 │ Tips for getting started
+ *    │     Welcome back Yurii!        │ Run /init to create PUGI.md...
+ *    │                                 │ ───────────
+ *    │        ▗ ▗  ▖ ▖               │ What's new
+ *    │          ▘▘ ▝▝                 │ * 0.1.0-beta.26 — RAG ...
+ *    │ Sonnet 4.6 (1M context) · Founder
+ *    │ yuriy.bulah@gmail.com · pugi-io Org
+ *    │ <workspace>
+ *    ╰──────────────────────────────────╯
+ *
+ * Data sources, in priority order:
+ *
+ *  - Account email + tenant + plan: JWT principal decoded from the
+ *    active credential. Falls back to anonymous label when no
+ *    credential is on disk (operator boots `pugi` before login).
+ *  - Greeting first-name: best-effort split of the local part of the
+ *    email. Falls back к "operator" when unauthenticated.
+ *  - Model: env override `PUGI_ENGINE_MODEL_CODE`, then the operator's
+ *    workspace settings `defaultModel`, then "Sonnet 4.6 (1M context)"
+ *    as the locked default.
+ *  - Cwd: absolute path of `process.cwd()` — banner left column shows
+ *    the full path so the operator confirms они are в the right repo.
+ *  - What's new: top 3 release-note titles from `apps/pugi-cli/CHANGELOG.md`
+ *    newer than `~/.pugi/.last-seen-version`. Falls back к the top 3
+ *    overall when last-seen marker is missing. Each entry is a one-line
+ *    headline ("0.1.0-beta.26 — RAG consumer middleware") trimmed
+ *    к 60 chars so the right column does not wrap on a 100-col terminal.
+ *
+ * Every resolver swallows its IO error and returns the documented
+ * fallback so a partial environment (missing CHANGELOG, malformed JWT,
+ * unreadable settings) never blocks the banner.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, resolve as resolvePath } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DEFAULT_API_URL, normalizeApiUrl, readCredentialsFile, resolveActiveCredential, } from '../core/credentials.js';
+import { parseChangelog } from '../core/release-notes/parser.js';
+function decodeJwtPayload(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length < 2)
+            return null;
+        const payload = parts[1];
+        if (!payload)
+            return null;
+        const padded = payload
+            .replace(/-/g, '+')
+            .replace(/_/g, '/')
+            .padEnd(payload.length + ((4 - (payload.length % 4)) % 4), '=');
+        const json = Buffer.from(padded, 'base64').toString('utf8');
+        const obj = JSON.parse(json);
+        if (!obj || typeof obj !== 'object')
+            return null;
+        return {
+            ...(typeof obj.sub === 'string' && { sub: obj.sub }),
+            ...(typeof obj.email === 'string' && { email: obj.email }),
+            ...(typeof obj.customerId === 'string' && { customerId: obj.customerId }),
+            ...(typeof obj.plan === 'string' && { plan: obj.plan }),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/* ------------------------------------------------------------------ */
+/* Resolvers                                                         */
+/* ------------------------------------------------------------------ */
+/**
+ * Derive a greeting first-name from an email's local part. The split
+ * is intentionally aggressive: dot-separated, hyphen-separated, and
+ * digit-stripped so `yuriy.bulah@gmail.com` resolves к "Yuriy" instead
+ * of "yuriy.bulah". Title-cases the first segment. Falls back к
+ * "operator" when no email is available.
+ *
+ * Export so the spec can lock the heuristic against edge cases (numeric
+ * local part, plus-tag aliases, single-letter local part).
+ */
+export function deriveGreetingName(email) {
+    if (!email || typeof email !== 'string')
+        return 'operator';
+    const at = email.indexOf('@');
+    if (at <= 0)
+        return 'operator';
+    const local = email.slice(0, at);
+    // Strip plus-tag aliases (`name+tag@host` → `name`).
+    const noTag = local.split('+')[0] ?? local;
+    // First dot / hyphen / underscore segment wins; this is the
+    // colloquial "given name" surface for the vast majority of work
+    // emails ("first.last@..." / "first-last@...").
+    const firstSegment = noTag.split(/[._-]/)[0] ?? noTag;
+    // Strip trailing digits some signup flows append (`yurii2@`) so the
+    // greeting reads as a name, not a username.
+    const stripped = firstSegment.replace(/[0-9]+$/u, '');
+    if (stripped.length === 0)
+        return 'operator';
+    return stripped.charAt(0).toUpperCase() + stripped.slice(1);
+}
+/**
+ * Resolve the model display string. Priority:
+ *
+ *  1. `PUGI_ENGINE_MODEL_CODE` env override (operator-set in shell).
+ *  2. `.pugi/settings.json` → `defaultModel` field (per-workspace).
+ *  3. Locked default `"Sonnet 4.6 (1M context)"`.
+ *
+ * Returns the value verbatim — the banner is responsible for trimming
+ * if the string is too long for the column.
+ */
+export function resolveModelDisplay(env, settingsOverride) {
+    const envModel = env.PUGI_ENGINE_MODEL_CODE;
+    if (typeof envModel === 'string' && envModel.length > 0)
+        return envModel;
+    const settingsModel = settingsOverride?.defaultModel;
+    if (typeof settingsModel === 'string' && settingsModel.length > 0) {
+        return settingsModel;
+    }
+    return 'Sonnet 4.6 (1M context)';
+}
+/**
+ * Locate the bundled CHANGELOG.md. The CLI ships к
+ * `node_modules/@pugi/cli/dist/tui/welcome-data.js` so the changelog
+ * lives at `node_modules/@pugi/cli/CHANGELOG.md` — two directory hops
+ * up from this file. In a local pnpm dev checkout the structure is the
+ * same (`src/tui/` ⇒ `../../CHANGELOG.md`) because tsx re-resolves the
+ * same relative tree.
+ */
+function defaultChangelogPath() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    return resolvePath(here, '..', '..', 'CHANGELOG.md');
+}
+/**
+ * Read top-3 "what's new" headlines from the CLI CHANGELOG.md. Each
+ * headline is `<version> — <first non-empty section body line>` trimmed
+ * к 60 chars so the right column does not wrap on a 100-col terminal.
+ * Returns an empty array when the file is missing / unparseable.
+ *
+ * The body-line heuristic walks к the first non-empty, non-section-
+ * header line below the version header. For Keep-a-Changelog entries
+ * the second line is usually `### Added` / `### Fixed`; we skip those
+ * headers и land on the first bullet, which is the operator-visible
+ * one-liner ("- L30 `pugi theme` ...").
+ */
+export function readWhatsNew(changelogPath) {
+    const path = changelogPath ?? defaultChangelogPath();
+    try {
+        if (!existsSync(path))
+            return [];
+        const raw = readFileSync(path, 'utf8');
+        if (!raw || raw.length === 0)
+            return [];
+        const sections = parseChangelog(raw);
+        const headlines = [];
+        for (const section of sections) {
+            if (headlines.length >= 3)
+                break;
+            // Skip the "[Unreleased]" / "[Unreleased] - YYYY-MM-DD" section —
+            // the banner is meant к surface SHIPPED notes only. The parser
+            // captures Unreleased identically к а tagged version, so we
+            // filter here.
+            if (/^unreleased$/i.test(section.version))
+                continue;
+            const firstBullet = pickFirstBullet(section.body);
+            if (!firstBullet)
+                continue;
+            const headline = `${section.version} — ${firstBullet}`;
+            headlines.push(truncate(headline, 60));
+        }
+        return headlines;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Pull the first bullet text out of a Keep-a-Changelog section body.
+ * Skips `### <subsection>` headers, blank lines, и non-bullet prose
+ * (release-note footers like "### Notes"). Returns undefined when no
+ * bullet is present.
+ *
+ * Body lines arrive verbatim from the parser; bullets follow the
+ * `- ` / `* ` Markdown convention. We strip the leading bullet glyph
+ * + the first whitespace run so the rendered string is the bullet
+ * content only.
+ */
+function pickFirstBullet(body) {
+    const lines = body.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue;
+        if (trimmed.startsWith('### '))
+            continue;
+        if (trimmed.startsWith('- ') || trimmed.startsWith('* ')) {
+            // Strip leading bullet glyph + ws and collapse internal MD ticks.
+            return trimmed
+                .slice(2)
+                .replace(/`/g, '')
+                .replace(/\*\*/g, '')
+                .trim();
+        }
+    }
+    return undefined;
+}
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    // Reserve 1 char for the ellipsis so we land on EXACTLY `max`
+    // visible chars including the dot. Single Unicode ellipsis would be
+    // narrower but some terminals render it as а full-width glyph in
+    // CJK locales — ASCII three-dot stays predictable.
+    return `${text.slice(0, max - 1).trimEnd()}…`;
+}
+/**
+ * Resolve the active credential and decode the JWT principal. Returns
+ * the email / tenant / plan triple when authenticated, null fields when
+ * anonymous. Encapsulates the credential + JWT IO so the spec can drive
+ * the resolver via an env override.
+ */
+function resolvePrincipal(env, home) {
+    const credential = resolveActiveCredential(env, home);
+    if (!credential) {
+        const file = readCredentialsFile(home);
+        return {
+            apiUrl: normalizeApiUrl(env.PUGI_API_URL ?? file.activeApiUrl ?? DEFAULT_API_URL),
+        };
+    }
+    const principal = decodeJwtPayload(credential.apiKey);
+    return {
+        apiUrl: credential.apiUrl,
+        ...(principal?.email && { email: principal.email }),
+        ...(principal?.customerId && { tenant: principal.customerId }),
+        ...(principal?.plan && { plan: principal.plan }),
+    };
+}
+/**
+ * Best-effort read of `.pugi/settings.json`. Returns null when the file
+ * is missing / unreadable / malformed so the model resolver can fall
+ * back to the env override + locked default.
+ */
+function readSettingsBlob(cwd) {
+    try {
+        const path = resolvePath(cwd, '.pugi', 'settings.json');
+        if (!existsSync(path))
+            return null;
+        const raw = readFileSync(path, 'utf8');
+        if (!raw || raw.length === 0)
+            return null;
+        const obj = JSON.parse(raw);
+        if (typeof obj?.defaultModel === 'string') {
+            return { defaultModel: obj.defaultModel };
+        }
+        return {};
+    }
+    catch {
+        return null;
+    }
+}
+/* ------------------------------------------------------------------ */
+/* Entry point                                                       */
+/* ------------------------------------------------------------------ */
+export function collectWelcomeData(input) {
+    const env = input.env ?? process.env;
+    const home = input.home ?? homedir();
+    const cwd = input.cwd ?? process.cwd();
+    const principal = resolvePrincipal(env, home);
+    const settings = input.settingsOverride !== undefined
+        ? input.settingsOverride
+        : readSettingsBlob(cwd);
+    const greetingName = deriveGreetingName(principal.email);
+    const model = resolveModelDisplay(env, settings);
+    const whatsNew = readWhatsNew(input.changelogPath);
+    return {
+        greetingName,
+        ...(principal.email && { email: principal.email }),
+        ...(principal.tenant && { tenant: principal.tenant }),
+        ...(principal.plan && { plan: principal.plan }),
+        model,
+        cwd,
+        cliVersion: input.cliVersion,
+        whatsNew,
+    };
+}
+//# sourceMappingURL=welcome-data.js.map