pirl-framework-cli 0.0.0-stage → 1.0.0

package/dist/ui/lines.js

@@ -0,0 +1,15 @@
+import { width, wrapText } from './text.js';
+export const lineWidth = (line) => line.reduce((sum, span) => sum + width(span.text), 0);
+/**
+ * Wraps `text` after a prefix (an icon or prompt). Continuation lines are indented by the prefix width,
+ * so the text keeps one left edge.
+ */
+export function hanging(prefix, text, columns, style = {}) {
+    const indent = prefix.reduce((sum, span) => sum + width(span.text), 0);
+    const body = wrapText(text, Math.max(1, columns - indent));
+    return body.map((part, index) => [
+        ...(index === 0 ? prefix : [{ text: ' '.repeat(indent) }]),
+        { text: part, ...style },
+    ]);
+}
+export const blank = [];

package/dist/ui/listOverlay.js

@@ -0,0 +1,97 @@
+import { useRef, useState } from 'react';
+import { blank, hanging } from './lines.js';
+export function useListOverlay() {
+    const [selected, setSelected] = useState(0);
+    const [detail, setDetailState] = useState(null);
+    const [scroll, setScroll] = useState(0);
+    const detailRef = useRef(null);
+    const maxTopRef = useRef(0);
+    const setDetail = (next) => {
+        detailRef.current = next;
+        setDetailState(next);
+        setScroll(0);
+    };
+    const reset = () => {
+        setSelected(0);
+        setDetail(null);
+    };
+    const choosable = (entries) => entries.map((entry, index) => (entry.open || entry.act ? index : -1)).filter(index => index >= 0);
+    /** The panel's lines for a frame whose content is `height` rows, and the first line to show. */
+    const view = (entries, header, columns, height, theme) => {
+        const rows = Math.max(1, height - 2);
+        if (detail) {
+            const lines = [...hanging([], detail.title, columns, { bold: true, color: 'accent' }), blank, ...detail.lines(columns)];
+            maxTopRef.current = Math.max(0, lines.length - rows);
+            return { lines, top: Math.min(scroll, maxTopRef.current) };
+        }
+        const indexes = choosable(entries);
+        const current = indexes[Math.min(selected, indexes.length - 1)] ?? -1;
+        const lines = [...header];
+        let focus = 0;
+        entries.forEach((entry, index) => {
+            if (index === current)
+                focus = lines.length;
+            lines.push(...entry.render(index === current, columns));
+        });
+        void theme;
+        maxTopRef.current = Math.max(0, lines.length - rows);
+        // Keep the chosen entry in view, with the lines above it when they fit.
+        return { lines, top: Math.min(maxTopRef.current, Math.max(0, focus - rows + 3)) };
+    };
+    /** Keys while the panel is open; returns false when Esc on the list closes it. */
+    const handleKey = (input, key, page, entries) => {
+        const clamp = (top) => Math.max(0, Math.min(maxTopRef.current, top));
+        if (detailRef.current) {
+            if (key.escape)
+                setDetail(null);
+            else if (key.upArrow)
+                setScroll(top => clamp(top - 1));
+            else if (key.downArrow)
+                setScroll(top => clamp(top + 1));
+            else if (key.pageUp)
+                setScroll(top => clamp(top - page));
+            else if (key.pageDown)
+                setScroll(top => clamp(top + page));
+            return true;
+        }
+        if (key.escape)
+            return false;
+        const indexes = choosable(entries);
+        if (indexes.length === 0)
+            return true;
+        const at = Math.min(selected, indexes.length - 1);
+        if (key.upArrow)
+            setSelected((at - 1 + indexes.length) % indexes.length);
+        else if (key.downArrow)
+            setSelected((at + 1) % indexes.length);
+        else if (key.pageUp)
+            setSelected(Math.max(0, at - 5));
+        else if (key.pageDown)
+            setSelected(Math.min(indexes.length - 1, at + 5));
+        else if (key.return) {
+            const entry = entries[indexes[at]];
+            if (entry.act)
+                entry.act();
+            else {
+                const opened = entry.open?.();
+                if (opened)
+                    setDetail(opened);
+            }
+        }
+        void input;
+        return true;
+    };
+    /** Mouse wheel: scrolls the details, or moves the choice on the list. */
+    const wheel = (lines, entries) => {
+        if (detailRef.current) {
+            setScroll(top => Math.max(0, Math.min(maxTopRef.current, top - lines)));
+            return;
+        }
+        const count = choosable(entries).length;
+        if (count === 0)
+            return;
+        setSelected(current => Math.max(0, Math.min(count - 1, Math.min(current, count - 1) - Math.sign(lines))));
+    };
+    const hints = (theme, action = 'xem') => detail ? [`${theme.glyphs.upDown} PgUp/PgDn cuộn`, 'Esc quay lại'] : [`${theme.glyphs.upDown} chọn`, `Enter ${action}`, 'Esc đóng'];
+    return { reset, view, handleKey, wheel, hints, inDetail: detail !== null };
+}

package/dist/ui/runView.js

@@ -0,0 +1,305 @@
+import { basename } from 'node:path';
+import { formatElapsed } from '../engine/run.js';
+import { displayPath } from '../core/paths.js';
+import { LAYER_LABELS, totalTokens } from '../engine/types.js';
+import { blank, hanging } from './lines.js';
+import { padEnd, truncateEnd, width } from './text.js';
+import { ROLE_IDS } from './theme.js';
+export const IMPROVEMENT_CHOICES = [
+    { id: 'commit', label: 'Commit vào Hub' },
+    { id: 'keep', label: 'Giữ, chưa commit' },
+    { id: 'discard', label: 'Bỏ cải tiến' },
+];
+export const STATUS_LABELS = {
+    running: 'đang chạy',
+    waiting: 'cần quyết định',
+    checking: 'đang kiểm tra kết quả',
+    improvements: 'chờ quyết định về cải tiến',
+    done: 'xong',
+    failed: 'lỗi',
+    stopped: 'đã dừng',
+};
+const isRole = (id) => ROLE_IDS.includes(id);
+/** A light Markdown layout for replies: headings, bullets, numbered lists and code blocks. */
+export function markdownLines(text, columns, indent = 0) {
+    const pad = { text: ' '.repeat(indent) };
+    const lines = [];
+    let code = false;
+    for (const raw of text.split('\n')) {
+        if (/^\s*```/.test(raw)) {
+            code = !code;
+            continue;
+        }
+        if (code) {
+            lines.push(...hanging([pad, { text: '  ' }], raw || ' ', columns, { dim: true }));
+            continue;
+        }
+        const line = raw.replace(/\*\*(.+?)\*\*/g, '$1');
+        const heading = /^#{1,6}\s+(.*)$/.exec(line);
+        const bullet = /^(\s*)[-*]\s+(.*)$/.exec(line);
+        const numbered = /^(\s*)(\d+[.)])\s+(.*)$/.exec(line);
+        if (heading)
+            lines.push(...hanging([pad], heading[1], columns, { bold: true }));
+        else if (bullet)
+            lines.push(...hanging([pad, { text: `${bullet[1]}• ` }], bullet[2], columns));
+        else if (numbered)
+            lines.push(...hanging([pad, { text: `${numbered[1]}${numbered[2]} ` }], numbered[3], columns));
+        else if (line.trim() === '')
+            lines.push(blank);
+        else
+            lines.push(...hanging([pad], line, columns));
+    }
+    return lines;
+}
+function choiceLines(options, selected, recommended, columns, theme) {
+    return options.flatMap((option, index) => {
+        const active = index === selected;
+        const prefix = [{ text: '    ' }, { text: active ? `${theme.glyphs.pointer} ` : '  ', color: 'accent' }, { text: `${index + 1}. `, color: active ? 'accent' : undefined, bold: active }];
+        const label = index === recommended ? `${option} (khuyến nghị)` : option;
+        return hanging(prefix, label, columns, active ? { color: 'accent', bold: true } : {});
+    });
+}
+/** The next layer, as a command for the user to type; PIRL never opens it by itself. */
+export function nextStep(run) {
+    if (run.status !== 'done')
+        return null;
+    if (run.kind === 'plan' && run.outputs.planSet)
+        return `/pirl-implement T01 của ${basename(run.outputs.planSet)}`;
+    if (run.kind === 'implement' && run.outputs.planFile)
+        return `/pirl-review ${basename(run.outputs.planFile)}`;
+    if (run.kind === 'review' && run.outputs.report)
+        return `/pirl-implement Sửa theo report ${basename(run.outputs.report)} (nếu Review là FAIL)`;
+    return null;
+}
+/** The spinner cell: turning with motion on, a still glyph with motion off. */
+export const spinnerSpan = (theme, motion, extra = {}) => motion ? { text: theme.glyphs.spinner[0], live: { kind: 'spinner', frames: theme.glyphs.spinner }, ...extra } : { text: theme.glyphs.running, ...extra };
+/** Time since `since`, kept current by the ticker. */
+export const clockSpan = (since) => ({ text: '00:00', dim: true, live: { kind: 'clock', since } });
+export const isActive = (run) => run.status === 'running' || run.status === 'checking';
+export function runLines(run, columns, theme, interaction, live) {
+    const g = theme.glyphs;
+    const lines = [];
+    const active = isActive(run);
+    const motion = live?.motion ?? false;
+    const statusTone = run.status === 'failed' ? 'danger' : run.status === 'done' ? 'success' : run.status === 'stopped' ? 'muted' : active ? 'accent' : 'warning';
+    const statusGlyph = run.status === 'done' ? g.ok : run.status === 'failed' ? g.fail : run.status === 'stopped' ? g.pending : run.status === 'waiting' || run.status === 'improvements' ? g.warn : null;
+    const glyph = [statusGlyph ? { text: statusGlyph, color: statusTone } : spinnerSpan(theme, motion, { color: statusTone }), { text: ' ' }];
+    const clock = active ? [{ text: ` ${g.sep} `, dim: true }, clockSpan(run.startedAt)] : [];
+    if (run.kind !== 'chat') {
+        lines.push([
+            ...glyph,
+            { text: LAYER_LABELS[run.kind], bold: true, color: 'accent' },
+            { text: ` ${g.sep} ${STATUS_LABELS[run.status]}`, color: statusTone },
+            ...clock,
+        ]);
+    }
+    else if (run.status !== 'done') {
+        lines.push([...glyph, { text: `PIRL ${g.sep} ${STATUS_LABELS[run.status]}`, color: statusTone }, ...clock]);
+    }
+    for (const role of run.roles) {
+        const tone = role.state === 'failed' ? 'danger' : role.state === 'done' ? 'success' : 'accent';
+        const mark = role.state === 'running' ? spinnerSpan(theme, motion, { color: tone }) : { text: role.state === 'done' ? g.ok : g.fail, color: tone };
+        const roleSpan = isRole(role.role) ? { text: role.role, role: role.role, bold: true } : { text: role.role, bold: true };
+        lines.push(...hanging([{ text: '  ' }, mark, { text: ' ' }, roleSpan, { text: '  ' }], role.description, columns, { dim: true }));
+        if (role.state === 'running' && role.activity)
+            lines.push(...hanging([{ text: '      ' }], role.activity, columns, { dim: true }));
+    }
+    if (active && run.activity) {
+        lines.push(...hanging([{ text: '  ' }, spinnerSpan(theme, motion, { color: 'accent' }), { text: ' ' }, { text: 'coordinator  ', dim: true }], run.activity, columns, { dim: true }));
+    }
+    if (run.reply && (run.status !== 'running' || run.kind === 'chat')) {
+        if (lines.length > 0)
+            lines.push(blank);
+        lines.push(...markdownLines(run.reply, columns, run.kind === 'chat' ? 0 : 2));
+    }
+    if (interaction?.kind === 'question' && interaction.runId === run.id) {
+        const q = interaction.question;
+        lines.push(blank);
+        lines.push(...hanging([{ text: '  ' }, { text: `? `, color: 'warning', bold: true }, { text: `Cần quyết định (${interaction.index + 1}/${interaction.total}): `, color: 'warning' }], q.question, columns, { bold: true }));
+        lines.push(...choiceLines(q.options, interaction.selected, q.recommended, columns, theme));
+        const how = q.options.length > 0 ? `Chọn bằng ${g.upDown} rồi Enter, gõ số rồi Enter, hoặc nhập câu trả lời khác.` : 'Nhập câu trả lời rồi Enter.';
+        lines.push(...hanging([{ text: '    ' }], how, columns, { dim: true }));
+    }
+    const checks = [
+        run.checks.validator && { label: 'Validator', ...run.checks.validator },
+        run.checks.record && { label: 'Record tự đánh giá', ...run.checks.record },
+        run.checks.paths && { label: 'Allowed paths', ...run.checks.paths },
+    ].filter(Boolean);
+    if (checks.length > 0) {
+        lines.push(blank);
+        for (const check of checks) {
+            const glyph = check.state === 'pass' ? g.ok : check.state === 'fail' ? g.fail : g.pending;
+            const tone = check.state === 'pass' ? 'success' : check.state === 'fail' ? 'danger' : 'muted';
+            lines.push(...hanging([{ text: '  ' }, { text: `${glyph} `, color: tone }, { text: `${check.label}: `, bold: true }], check.detail ?? '', columns, { dim: check.state !== 'fail' }));
+        }
+    }
+    if (run.denials.length > 0) {
+        // Refusals are the run's permissions working; the run goes on, and the coordinator reports what it could not do.
+        const shown = run.denials.slice(0, 3).join('; ');
+        const more = run.denials.length > 3 ? ` (và ${run.denials.length - 3} lệnh khác, xem nhật ký)` : '';
+        lines.push(...hanging([{ text: '  ' }, { text: `${g.info} `, color: 'muted' }], `Đã chặn ${run.denials.length} lệnh ngoài quyền của run, run vẫn tiếp tục: ${shown}${more}`, columns, { dim: true }));
+    }
+    const improvements = run.improvements;
+    if (improvements) {
+        lines.push(blank);
+        const title = improvements.state === 'pending'
+            ? `Tự cải tiến: ${improvements.files.length} file framework đã sửa`
+            : improvements.state === 'committed'
+                ? `Đã commit ${improvements.files.length} file cải tiến vào Hub`
+                : improvements.state === 'kept'
+                    ? `Giữ ${improvements.files.length} file cải tiến, chưa commit`
+                    : `Đã bỏ ${improvements.files.length} file cải tiến`;
+        lines.push(...hanging([{ text: '  ' }, { text: `${improvements.state === 'pending' ? g.warn : g.ok} `, color: improvements.state === 'pending' ? 'warning' : 'success' }], title, columns, { bold: true }));
+        if (improvements.state === 'pending') {
+            for (const file of improvements.files)
+                lines.push(...hanging([{ text: '    ' }], file, columns, { dim: true }));
+            const tests = improvements.tests;
+            if (tests?.state === 'pass')
+                lines.push(...hanging([{ text: '    ' }, { text: `${g.ok} `, color: 'success' }], 'Test của framework: PASS', columns));
+            if (tests?.state === 'skipped')
+                lines.push(...hanging([{ text: '    ' }, { text: `${g.warn} `, color: 'warning' }], `Test của framework: bỏ qua (${tests.detail ?? ''})`, columns));
+            if (tests?.state === 'fail') {
+                lines.push(...hanging([{ text: '    ' }, { text: `${g.fail} `, color: 'danger' }], 'Test của framework: FAIL. Cải tiến này làm hỏng framework nên không được commit; nên bỏ.', columns, { color: 'danger' }));
+                for (const line of (tests.detail ?? '').split('\n').slice(0, 5))
+                    lines.push(...hanging([{ text: '      ' }], line, columns, { dim: true }));
+            }
+            if (improvements.error)
+                lines.push(...hanging([{ text: '    ' }], `Lỗi: ${improvements.error}`, columns, { color: 'danger' }));
+            if (interaction?.kind === 'improvements' && interaction.runId === run.id) {
+                lines.push(...hanging([{ text: '    ' }], 'Commit cải tiến này vào Hub?', columns));
+                const labels = IMPROVEMENT_CHOICES.map(choice => (choice.id === 'commit' && tests?.state === 'fail' ? `${choice.label} (bị chặn: test lỗi)` : choice.label));
+                lines.push(...choiceLines(labels, interaction.selected, tests?.state === 'fail' ? 2 : 0, columns, theme));
+            }
+        }
+    }
+    if (run.error) {
+        lines.push(blank);
+        lines.push(...hanging([{ text: '  ' }, { text: `${g.fail} `, color: 'danger' }], run.error, columns, { color: 'danger' }));
+        lines.push(...hanging([{ text: '    ' }], 'Gõ /resume để chạy tiếp từ chỗ dừng.', columns, { dim: true }));
+    }
+    if (run.status === 'stopped') {
+        // Stopped before the provider started: there is no provider session to continue.
+        const next = run.sessionId ? 'Đã dừng. Gõ /resume để chạy tiếp.' : 'Đã dừng trước khi provider bắt đầu. Gõ lại lệnh để chạy.';
+        lines.push(...hanging([{ text: '    ' }], next, columns, { dim: true }));
+    }
+    if (run.suggestion) {
+        lines.push(blank);
+        lines.push(...hanging([{ text: '  ' }, { text: `${g.info} `, color: 'accent' }], `Yêu cầu này là một layer. Lệnh đã được điền sẵn vào ô nhập: ${run.suggestion}`, columns));
+    }
+    const next = nextStep(run);
+    if (next) {
+        lines.push(blank);
+        lines.push(...hanging([{ text: '  ' }, { text: 'Bước tiếp theo, khi bạn muốn: ', dim: true }], next, columns, { color: 'accent' }));
+    }
+    if (run.usage.calls > 0 && !active) {
+        const took = run.log.length > 0 ? ` ${g.sep} ${formatElapsed(run.log.at(-1).at)}` : '';
+        lines.push([{ text: `  ${run.usage.calls} lượt gọi${took}`, dim: true }]);
+        for (const text of usageDetail(run.usage, g.sep))
+            lines.push(...hanging([{ text: '  ' }], text, columns, { dim: true }));
+        const quota = quotaText(run.quota, g.sep, g.arrow);
+        if (quota)
+            lines.push(...hanging([{ text: '  ' }], quota, columns, { dim: true }));
+    }
+    if (run.logFile && !active)
+        lines.push(...hanging([{ text: '  ' }], `Nhật ký đầy đủ: ${displayPath(run.logFile)}`, columns, { dim: true }));
+    return lines;
+}
+/** 950 → "950", 12_345 → "12k", 1_209_213 → "1,21M": token counts at a glance. */
+export function compactTokens(count) {
+    const format = (value, digits) => value.toLocaleString('vi-VN', { maximumFractionDigits: digits });
+    if (count < 1000)
+        return String(count);
+    if (count < 1_000_000)
+        return `${format(count / 1000, count < 10_000 ? 1 : 0)}k`;
+    return `${format(count / 1_000_000, 2)}M`;
+}
+export const costText = (usd) => (usd === null ? null : `≈ $${usd < 0.1 ? usd.toFixed(3) : usd.toFixed(2)}`);
+/** The tokens of a run by kind, then what they come to at the Claude API list price, with the models used. */
+export function usageDetail(usage, sep) {
+    const total = totalTokens(usage);
+    if (total === 0)
+        return [];
+    const parts = [
+        `${compactTokens(usage.cacheReadTokens)} đọc cache`,
+        `${compactTokens(usage.cacheWriteTokens)} ghi cache`,
+        `${compactTokens(usage.outputTokens)} ra`,
+        `${compactTokens(usage.inputTokens)} vào mới`,
+    ];
+    const cost = costText(usage.costUsd);
+    const models = usage.models.map(model => model.replace(/^claude-/, '')).join(', ');
+    return [`${compactTokens(total)} token: ${parts.join(` ${sep} `)}`, [cost && `${cost} theo giá API`, models].filter(Boolean).join(` ${sep} `)].filter(Boolean);
+}
+/**
+ * How much of each plan limit the run took: "Hạn mức: 5 giờ 12% → 19% (+7)". The meters count the whole
+ * account, so other sessions at the same time are in the difference too.
+ */
+export function quotaText(quota, sep, arrow) {
+    const { before, after } = quota;
+    if (!after)
+        return null;
+    const rows = after.map(row => {
+        const start = before?.find(item => item.label === row.label);
+        if (!start)
+            return `${row.label} ${Math.round(row.percent)}%`;
+        const added = Math.round(row.percent - start.percent);
+        return `${row.label} ${Math.round(start.percent)}% ${arrow} ${Math.round(row.percent)}% (${added >= 0 ? '+' : ''}${added})`;
+    });
+    return rows.length ? `Hạn mức${before ? '' : ' hiện tại'}: ${rows.join(` ${sep} `)}` : null;
+}
+/** The side panel's Run section: the run and its roles. */
+export function runPanelLines(run, columns, theme, live) {
+    const g = theme.glyphs;
+    if (!run)
+        return hanging([{ text: `${g.pending} `, dim: true }], 'Chưa có run nào. Gõ /pirl-plan <request> để bắt đầu.', columns, { dim: true });
+    const active = isActive(run);
+    const motion = live?.motion ?? false;
+    const lines = [
+        [
+            { text: `${LAYER_LABELS[run.kind]} `, bold: true, color: 'accent' },
+            { text: STATUS_LABELS[run.status], dim: true },
+            ...(active ? [{ text: ` ${g.sep} `, dim: true }, clockSpan(run.startedAt)] : []),
+        ],
+    ];
+    if (run.roles.length === 0)
+        lines.push(...hanging([{ text: '  ' }], active ? 'Coordinator đang chuẩn bị…' : 'Không có role nào chạy.', columns, { dim: true }));
+    for (const role of run.roles) {
+        const tone = role.state === 'failed' ? 'danger' : role.state === 'done' ? 'success' : 'accent';
+        const mark = role.state === 'running' ? spinnerSpan(theme, motion, { color: tone }) : { text: role.state === 'done' ? g.ok : g.fail, color: tone };
+        const name = isRole(role.role) ? { text: role.role, role: role.role } : { text: role.role };
+        lines.push([mark, { text: ' ' }, name]);
+    }
+    return lines;
+}
+/** When a usage window resets: the time today, otherwise the day and time. */
+export function resetText(iso, now = new Date()) {
+    if (!iso)
+        return null;
+    const at = new Date(iso);
+    if (Number.isNaN(at.getTime()))
+        return null;
+    const two = (value) => String(value).padStart(2, '0');
+    const time = `${two(at.getHours())}:${two(at.getMinutes())}`;
+    return at.toDateString() === now.toDateString() ? time : `${two(at.getDate())}/${two(at.getMonth() + 1)} ${time}`;
+}
+/**
+ * The side panel's Hạn mức section: each usage window of the plan as a bar, its percentage and when it resets.
+ * The numbers come from Claude Code: `/usage` when the TUI opens, and the windows each run reports.
+ */
+export function quotaPanelLines(rows, columns, theme) {
+    if (!rows || rows.length === 0)
+        return hanging([], 'Chưa có số liệu. Claude Code báo hạn mức khi chạy run.', columns, { dim: true });
+    const labelWidth = Math.min(14, Math.max(...rows.map(row => width(row.label))) + 2);
+    const barWidth = Math.max(4, Math.min(12, columns - labelWidth - 6));
+    const lines = [];
+    for (const row of rows) {
+        const percent = Math.max(0, Math.min(100, Math.round(row.percent)));
+        const filled = Math.round((percent / 100) * barWidth);
+        const tone = percent >= 90 ? 'danger' : percent >= 70 ? 'warning' : 'success';
+        const bar = theme.unicode ? `${'█'.repeat(filled)}${'░'.repeat(barWidth - filled)}` : `${'#'.repeat(filled)}${'-'.repeat(barWidth - filled)}`;
+        lines.push([{ text: padEnd(truncateEnd(row.label, labelWidth - 1, theme.glyphs.ellipsis), labelWidth), dim: true }, { text: bar, color: tone }, { text: ` ${percent}%`, color: tone }]);
+        const reset = resetText(row.resetsAt);
+        if (reset)
+            lines.push([{ text: ' '.repeat(labelWidth) }, { text: `đặt lại ${reset}`, dim: true }]);
+    }
+    return lines;
+}

package/dist/ui/session.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/terminalInput.js

@@ -0,0 +1,45 @@
+/**
+ * Sequences the terminal sends that are not typed text. Ink passes some of them on as text with the leading ESC
+ * removed, so they would land in the input box:
+ * - replies to queries: the kitty keyboard protocol flags (`[?0u`, which a terminal can send after Ink stopped
+ *   waiting for it) and device attributes (`[?1;2c`);
+ * - mouse reports in SGR form (`[<64;10;5M`), sent while mouse reporting is on (src/bin/main.tsx).
+ */
+const REPLY = /\x1b?\[\?[\d;]*[uc]/g;
+const MOUSE = /\x1b?\[<(\d+);\d+;\d+[Mm]/g;
+/** Wheel buttons in an SGR mouse report; the low bits say up (64) or down (65), the rest are modifier keys. */
+const WHEEL_UP = 64;
+const WHEEL_DOWN = 65;
+export function parseTerminalInput(input) {
+    let wheel = 0;
+    let filtered = false;
+    const text = input
+        .replace(REPLY, () => {
+        filtered = true;
+        return '';
+    })
+        .replace(MOUSE, (_match, button) => {
+        filtered = true;
+        const code = Number(button) & ~(4 | 8 | 16); // without Shift, Alt and Ctrl
+        if (code === WHEEL_UP)
+            wheel += 1;
+        else if (code === WHEEL_DOWN)
+            wheel -= 1;
+        return '';
+    });
+    return { text, wheel, filtered };
+}
+/** Turns every mouse mode PIRL uses off: SGR mouse reporting and alternate scroll. */
+export const MOUSE_OFF = '\x1b[?1000l\x1b[?1006l\x1b[?1007l';
+/**
+ * What to send the terminal for a mouse setting (src/core/config.ts). `wheel` turns on SGR reporting of button
+ * presses and the wheel, not plain movement. `select` turns on alternate scroll: on the alternate screen the
+ * terminal sends the wheel as ↑/↓ and keeps dragging for its own selection.
+ */
+export function mouseSequence(mode) {
+    if (mode === 'wheel')
+        return `${MOUSE_OFF}\x1b[?1000h\x1b[?1006h`;
+    if (mode === 'select')
+        return `${MOUSE_OFF}\x1b[?1007h`;
+    return MOUSE_OFF;
+}

package/dist/ui/text.js

@@ -0,0 +1,58 @@
+import stringWidth from 'string-width';
+import wrapAnsi from 'wrap-ansi';
+/** Display width in terminal cells: Vietnamese combining marks take 0, CJK and emoji take 2. */
+export const width = (text) => stringWidth(text);
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+export const graphemes = (text) => Array.from(segmenter.segment(text), part => part.segment);
+/** Cuts text to at most `max` cells, ending with the ellipsis when anything was cut. */
+export function truncateEnd(text, max, ellipsis = '…') {
+    if (width(text) <= max)
+        return text;
+    if (max <= width(ellipsis))
+        return graphemesWithin(text, max);
+    return graphemesWithin(text, max - width(ellipsis)) + ellipsis;
+}
+/** Keeps both ends of a long path: `src/orders/cancel.ts` → `src/…/cancel.ts`. */
+export function truncateMiddle(text, max, ellipsis = '…') {
+    if (width(text) <= max)
+        return text;
+    const room = max - width(ellipsis);
+    if (room <= 1)
+        return truncateEnd(text, max, ellipsis);
+    const tailRoom = Math.ceil(room / 2);
+    const tail = graphemesFromEnd(text, tailRoom);
+    const head = graphemesWithin(text, room - width(tail));
+    return head + ellipsis + tail;
+}
+function graphemesWithin(text, max) {
+    let out = '';
+    let used = 0;
+    for (const g of graphemes(text)) {
+        const w = width(g);
+        if (used + w > max)
+            break;
+        out += g;
+        used += w;
+    }
+    return out;
+}
+function graphemesFromEnd(text, max) {
+    const parts = graphemes(text);
+    let out = '';
+    let used = 0;
+    for (let i = parts.length - 1; i >= 0; i--) {
+        const w = width(parts[i]);
+        if (used + w > max)
+            break;
+        out = parts[i] + out;
+        used += w;
+    }
+    return out;
+}
+/** Wraps plain text to `columns` cells: at spaces when possible, inside a word only when it is longer than a line. */
+export function wrapText(text, columns) {
+    if (columns <= 0)
+        return [];
+    return text.split('\n').flatMap(paragraph => paragraph === '' ? [''] : wrapAnsi(paragraph, columns, { hard: true, trim: true, wordWrap: true }).split('\n'));
+}
+export const padEnd = (text, columns) => text + ' '.repeat(Math.max(0, columns - width(text)));

package/dist/ui/theme.js

@@ -0,0 +1,139 @@
+export const ROLE_IDS = [
+    'business-analyst',
+    'solution-architect',
+    'code-analyst',
+    'ux-designer',
+    'backend-developer',
+    'frontend-developer',
+    'technical-writer',
+    'code-reviewer',
+    'process-auditor',
+];
+const DARK = {
+    accent: '#7aa2f7',
+    success: '#9ece6a',
+    warning: '#e0af68',
+    danger: '#f7768e',
+    muted: '#7f849c',
+    border: '#565f89',
+    user: '#bb9af7',
+    roles: {
+        'business-analyst': '#e0af68',
+        'solution-architect': '#7dcfff',
+        'code-analyst': '#7aa2f7',
+        'ux-designer': '#ff9e64',
+        'backend-developer': '#9ece6a',
+        'frontend-developer': '#73daca',
+        'technical-writer': '#c0caf5',
+        'code-reviewer': '#f7768e',
+        'process-auditor': '#bb9af7',
+    },
+};
+const LIGHT = {
+    accent: '#2e5bd8',
+    success: '#2f7d32',
+    warning: '#9a6700',
+    danger: '#c62828',
+    muted: '#6b7280',
+    border: '#9ca3af',
+    user: '#7c3aed',
+    roles: {
+        'business-analyst': '#9a6700',
+        'solution-architect': '#0e7490',
+        'code-analyst': '#2e5bd8',
+        'ux-designer': '#c2410c',
+        'backend-developer': '#2f7d32',
+        'frontend-developer': '#0f766e',
+        'technical-writer': '#4b5563',
+        'code-reviewer': '#c62828',
+        'process-auditor': '#7c3aed',
+    },
+};
+export const COLOR_SCHEMES = {
+    pirl: { label: 'PIRL (mặc định)', dark: { accent: '#7aa2f7', user: '#bb9af7', border: '#565f89' }, light: { accent: '#2e5bd8', user: '#7c3aed', border: '#9ca3af' } },
+    ocean: { label: 'Đại dương', dark: { accent: '#4fd6be', user: '#7dcfff', border: '#3b6e78' }, light: { accent: '#0f766e', user: '#0369a1', border: '#94b8bd' } },
+    forest: { label: 'Rừng', dark: { accent: '#9ece6a', user: '#e0af68', border: '#4f6b3a' }, light: { accent: '#3f7d20', user: '#9a6700', border: '#a3b899' } },
+    sunset: { label: 'Hoàng hôn', dark: { accent: '#ff9e64', user: '#f7768e', border: '#7a5040' }, light: { accent: '#c2410c', user: '#be185d', border: '#c4a79a' } },
+    grape: { label: 'Tím', dark: { accent: '#c099ff', user: '#ff79c6', border: '#5d4a7a' }, light: { accent: '#7c3aed', user: '#c026d3', border: '#b3a3c9' } },
+    mono: { label: 'Đơn sắc', dark: { accent: '#d4d4d4', user: '#ffffff', border: '#5c5c5c' }, light: { accent: '#262626', user: '#000000', border: '#a3a3a3' } },
+};
+/**
+ * Every glyph is one cell wide in every terminal: none has an emoji form. ✔ ✖ ℹ do, and a terminal that draws
+ * them from an emoji font makes them two cells wide and colored, over the space after them.
+ */
+const UNICODE_GLYPHS = {
+    ok: '✓',
+    warn: '▲',
+    fail: '✗',
+    info: '●',
+    running: '▸',
+    pending: '○',
+    prompt: '›',
+    bullet: '•',
+    sep: '·',
+    ellipsis: '…',
+    pointer: '❯',
+    up: '↑',
+    down: '↓',
+    arrow: '→',
+    upDown: '↑↓',
+    leftRight: '←→',
+    spinner: ['⠋', '⠙', '⠸', '⠴', '⠦', '⠇'],
+};
+const ASCII_GLYPHS = {
+    ok: 'v',
+    warn: '!',
+    fail: 'x',
+    info: 'i',
+    running: '>',
+    pending: 'o',
+    prompt: '>',
+    bullet: '-',
+    sep: '|',
+    ellipsis: '...',
+    pointer: '>',
+    up: '^',
+    down: 'v',
+    arrow: '->',
+    upDown: 'Up/Down',
+    leftRight: 'Left/Right',
+    spinner: ['|', '/', '-', '\\'],
+};
+/** COLORFGBG is "foreground;background" with ANSI color numbers; backgrounds 7 and 9–15 are light. */
+export function detectMode(env) {
+    const background = Number(env['COLORFGBG']?.split(';').pop());
+    if (!Number.isInteger(background))
+        return 'dark';
+    return background === 7 || (background >= 9 && background <= 15) ? 'light' : 'dark';
+}
+/** Same decisions as the widely used is-unicode-supported: legacy Windows consoles get ASCII. */
+export function detectUnicode(env, platform) {
+    if (platform !== 'win32')
+        return env['TERM'] !== 'linux';
+    return (Boolean(env['WT_SESSION']) ||
+        Boolean(env['TERMINUS_SUBLIME']) ||
+        env['ConEmuTask'] === '{cmd::Cmder}' ||
+        env['TERM_PROGRAM'] === 'Terminus-Sublime' ||
+        env['TERM_PROGRAM'] === 'vscode' ||
+        env['TERM'] === 'xterm-256color' ||
+        env['TERM'] === 'alacritty' ||
+        env['TERM'] === 'rxvt-unicode' ||
+        env['TERM'] === 'rxvt-unicode-256color' ||
+        env['TERMINAL_EMULATOR'] === 'JetBrains-JediTerm');
+}
+export function createTheme(settings, env = process.env, platform = process.platform) {
+    const mode = settings.theme === 'auto' ? detectMode(env) : settings.theme;
+    const color = !env['NO_COLOR'];
+    const unicode = settings.glyphs === 'auto' ? detectUnicode(env, platform) : settings.glyphs === 'unicode';
+    const scheme = COLOR_SCHEMES[settings.colors ?? 'pirl'] ?? COLOR_SCHEMES.pirl;
+    const palette = { ...(mode === 'light' ? LIGHT : DARK), ...(mode === 'light' ? scheme.light : scheme.dark) };
+    return {
+        mode,
+        color,
+        unicode,
+        glyphs: unicode ? UNICODE_GLYPHS : ASCII_GLYPHS,
+        border: unicode ? 'round' : 'classic',
+        fg: token => (color ? palette[token] : undefined),
+        role: id => (color ? palette.roles[id] : undefined),
+    };
+}