@lotagate/cli 0.1.21 → 0.1.22

package/dist/presentation/tui/ink/components/transcript.d.ts

@@ -0,0 +1,39 @@
+import type { JSX } from 'react';
+import type { Attachment } from '../../../../domain/session/attachment.js';
+import type { TuiMessage } from '../tui-bridge.js';
+import type { TuiWelcome } from '../tui-bridge.js';
+import { type ActivityStatusProps } from './activity-status.js';
+export interface TuiStatusEntry {
+    id: string;
+    kind: 'status';
+    content: '';
+    status: ActivityStatusProps;
+}
+export interface TuiWelcomeEntry {
+    id: string;
+    kind: 'welcome';
+    content: '';
+    welcome: TuiWelcome;
+    visible?: boolean;
+}
+export type TuiTranscriptEntry = TuiMessage | TuiStatusEntry | TuiWelcomeEntry;
+export interface TranscriptProps {
+    messages: readonly TuiTranscriptEntry[];
+    showActionDetails?: boolean;
+    fill?: boolean;
+    height?: number;
+}
+export declare function Transcript({ messages, showActionDetails, fill, height }: TranscriptProps): JSX.Element;
+export interface TranscriptViewport {
+    messages: readonly TuiTranscriptEntry[];
+    firstMessage: number;
+    lastMessage: number;
+}
+/** Returns a stable message window, measured from the newest transcript entry. */
+export declare function transcriptViewport(messages: readonly TuiTranscriptEntry[], offset: number, maximumMessages: number): TranscriptViewport;
+/** Returns a viewport measured in terminal rows so wrapped messages scroll predictably. */
+export declare function transcriptViewportByRows(messages: readonly TuiTranscriptEntry[], offsetRows: number, maximumRows: number, columns: number): TranscriptViewport;
+export declare function transcriptTotalRows(messages: readonly TuiTranscriptEntry[], columns: number): number;
+export declare function AttachmentChip({ attachment }: {
+    attachment: Attachment;
+}): JSX.Element;

package/dist/presentation/tui/ink/components/transcript.js

@@ -0,0 +1,121 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { DARK_THEME as palette } from '../../../themes/theme.js';
+import { MarkdownMessage } from '../markdown-message.js';
+import { FileDiff, fileDiffRowCount } from './file-diff.js';
+import { terminalTextWidth, wrapTerminalText } from '../../formatters.js';
+import { ActivityEntry } from './activity-entry.js';
+import { SubagentCreatedEntry } from './subagent-activity.js';
+import { ActivityStatus } from './activity-status.js';
+import { WelcomePanel, WELCOME_PANEL_ROWS } from './welcome-panel.js';
+export function Transcript({ messages, showActionDetails = false, fill = false, height }) {
+    return _jsx(Box, { flexDirection: "column", ...(fill ? { flexGrow: 1, overflow: 'hidden' } : {}), ...(height === undefined ? {} : { height }), children: messages.map((message) => _jsx(TranscriptMessage, { message: message, showActionDetails: showActionDetails }, message.id)) });
+}
+/** Returns a stable message window, measured from the newest transcript entry. */
+export function transcriptViewport(messages, offset, maximumMessages) {
+    const normalizedOffset = Math.max(0, Math.min(offset, Math.max(0, messages.length - maximumMessages)));
+    const end = messages.length - normalizedOffset;
+    const start = Math.max(0, end - maximumMessages);
+    return { messages: messages.slice(start, end), firstMessage: start + 1, lastMessage: end };
+}
+/** Returns a viewport measured in terminal rows so wrapped messages scroll predictably. */
+export function transcriptViewportByRows(messages, offsetRows, maximumRows, columns) {
+    const rowCounts = messages.map((message) => messageRowCount(message, columns));
+    const rowOffsets = [];
+    const totalRows = rowCounts.reduce((sum, rows) => sum + rows, 0);
+    const viewportRows = Math.max(1, Math.floor(maximumRows));
+    const clampedOffset = Math.max(0, Math.min(Math.floor(offsetRows), Math.max(0, totalRows - viewportRows)));
+    const targetEnd = totalRows - clampedOffset;
+    const targetStart = Math.max(0, targetEnd - viewportRows);
+    let row = 0;
+    let start = messages.length;
+    let end = 0;
+    for (let index = 0; index < messages.length; index += 1) {
+        const messageStart = row;
+        rowOffsets[index] = messageStart;
+        const messageRows = rowCounts[index] ?? 1;
+        row += messageRows;
+        if (row > targetStart && messageStart < targetEnd) {
+            start = Math.min(start, index);
+            end = index + 1;
+        }
+    }
+    if (start === messages.length)
+        return { messages: [], firstMessage: 0, lastMessage: 0 };
+    const visibleMessages = messages.slice(start, end).flatMap((message, index) => {
+        const messageIndex = start + index;
+        const messageStart = rowOffsets[messageIndex] ?? 0;
+        const messageEnd = messageStart + (rowCounts[messageIndex] ?? 1);
+        const visibleStart = Math.max(targetStart, messageStart);
+        const visibleEnd = Math.min(targetEnd, messageEnd);
+        if (visibleEnd <= visibleStart)
+            return [];
+        return [clipMessageToRows(message, visibleStart - messageStart, visibleEnd - visibleStart, columns)];
+    });
+    return { messages: visibleMessages, firstMessage: start + 1, lastMessage: end };
+}
+export function transcriptTotalRows(messages, columns) {
+    return messages.reduce((sum, message) => sum + messageRowCount(message, columns), 0);
+}
+function messageRowCount(message, columns) {
+    if (message.kind === 'welcome')
+        return WELCOME_PANEL_ROWS;
+    if (message.kind === 'status')
+        return 2;
+    const width = Math.max(1, columns - 4);
+    const contentRows = message.content.split('\n').reduce((sum, line) => sum + Math.max(1, Math.ceil(terminalTextWidth(line) / width)), 0);
+    const attachmentRows = (message.attachments?.length ?? 0) * 2;
+    const diffRows = message.fileChange === undefined ? 0 : fileDiffRowCount(message.fileChange, columns);
+    const subagentRows = message.subagent === undefined ? 0 : 2;
+    return Math.max(1, contentRows + attachmentRows + diffRows + subagentRows + 1);
+}
+function clipMessageToRows(message, skipRows, takeRows, columns) {
+    if (message.kind === 'welcome') {
+        return skipRows <= 0 && takeRows >= WELCOME_PANEL_ROWS ? message : { ...message, visible: false };
+    }
+    if (message.kind === 'status' || !isTextMessage(message) || (skipRows <= 0 && takeRows >= messageRowCount(message, columns)))
+        return message;
+    const width = Math.max(1, columns - 4);
+    const contentRows = message.content.split('\n').reduce((sum, line) => sum + Math.max(1, Math.ceil(terminalTextWidth(line) / width)), 0);
+    const contentStart = Math.max(0, skipRows);
+    const contentEnd = Math.min(contentRows, contentStart + Math.max(0, takeRows));
+    if (contentEnd <= contentStart)
+        return { ...message, content: sliceTextByRows(message.content, Math.max(0, contentRows - 1), 1, width) };
+    return { ...message, content: sliceTextByRows(message.content, contentStart, contentEnd - contentStart, width) };
+}
+function isTextMessage(message) {
+    return message.kind === 'assistant' || message.kind === 'user' || message.kind === 'notice' || message.kind === 'error' || message.kind === 'command';
+}
+function sliceTextByRows(content, startRow, rowCount, width) {
+    const rows = [];
+    for (const line of content.split('\n')) {
+        const wrapped = wrapTerminalText(line, width);
+        rows.push(...wrapped);
+    }
+    return rows.slice(startRow, startRow + rowCount).join('\n');
+}
+function TranscriptMessage({ message, showActionDetails }) {
+    if (message.kind === 'welcome')
+        return message.visible === false ? null : _jsx(WelcomePanel, { welcome: message.welcome });
+    if (message.kind === 'status')
+        return _jsx(ActivityStatus, { ...message.status });
+    if (message.kind === 'assistant')
+        return _jsxs(Box, { flexDirection: "row", alignItems: "flex-start", marginBottom: 1, children: [_jsx(MessageMarker, {}), _jsx(Box, { flexGrow: 1, children: _jsx(MarkdownMessage, { content: message.content || ' ' }) })] });
+    if (message.kind === 'diff' && message.fileChange !== undefined)
+        return _jsx(FileDiff, { change: message.fileChange });
+    if (message.kind === 'activity' && message.activity !== undefined)
+        return _jsx(ActivityEntry, { activity: message.activity, showDetails: showActionDetails });
+    if (message.kind === 'subagent' && message.subagent !== undefined)
+        return _jsx(SubagentCreatedEntry, { subagent: message.subagent });
+    if (message.kind === 'user')
+        return _jsxs(Box, { backgroundColor: palette.user, flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { flexDirection: "row", alignItems: "flex-start", children: [_jsx(MessageMarker, {}), _jsx(Box, { flexGrow: 1, children: _jsx(MarkdownMessage, { content: message.content }) })] }), message.attachments?.map((attachment) => _jsx(AttachmentChip, { attachment: attachment }, attachment.id))] });
+    const tone = message.kind === 'error' ? palette.error : message.kind === 'command' ? palette.accent : palette.muted;
+    const marker = message.kind === 'error' ? '!' : message.kind === 'command' ? '›' : '·';
+    return _jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { color: tone, children: [marker, " "] }), _jsx(Text, { color: tone, wrap: "wrap", children: message.content })] });
+}
+function MessageMarker() {
+    return _jsx(Text, { color: palette.text, children: "\u25CF " });
+}
+export function AttachmentChip({ attachment }) {
+    return _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: palette.muted, children: ["\u25A3 ", attachment.name] }) });
+}

package/dist/presentation/tui/ink/components/welcome-panel.d.ts

@@ -0,0 +1,6 @@
+import type { JSX } from 'react';
+import type { TuiWelcome } from '../tui-bridge.js';
+export declare const WELCOME_PANEL_ROWS = 10;
+export declare function WelcomePanel({ welcome }: {
+    welcome: TuiWelcome;
+}): JSX.Element;

package/dist/presentation/tui/ink/components/welcome-panel.js

@@ -0,0 +1,20 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { DARK_THEME as palette } from '../../../themes/theme.js';
+import { COMMAND_REGISTRY } from '../../../../application/commands/command-runtime.js';
+import { formatCommandReference } from '../../../../application/commands/command-presentation.js';
+const HELP_COMMAND = commandReference('help');
+const MODEL_COMMAND = commandReference('model.current');
+export const WELCOME_PANEL_ROWS = 10;
+export function WelcomePanel({ welcome }) {
+    const model = welcome.model ?? 'Select a model to begin';
+    const trustLabel = welcome.trusted ? 'Trusted workspace' : 'Restricted workspace';
+    const trustColor = welcome.trusted ? palette.success : palette.warning;
+    return _jsxs(Box, { borderStyle: "round", borderColor: palette.accent, flexDirection: "row", marginBottom: 1, paddingX: 1, paddingY: 1, children: [_jsxs(Box, { flexDirection: "column", width: "38%", children: [_jsxs(Text, { color: palette.accent, children: ["LotaGate CLI v", welcome.version] }), _jsx(Text, { bold: true, color: palette.text, children: "Welcome back!" }), _jsx(Text, { color: palette.muted, wrap: "truncate", children: model }), _jsxs(Text, { color: trustColor, children: ["\u25CF ", trustLabel] }), _jsx(Text, { color: palette.muted, wrap: "truncate", children: welcome.cwd })] }), _jsxs(Box, { borderLeft: true, borderColor: palette.border, flexDirection: "column", paddingLeft: 1, width: "62%", children: [_jsx(Text, { bold: true, color: palette.accent, children: "Tips for getting started" }), _jsxs(Text, { color: palette.muted, wrap: "truncate", children: [HELP_COMMAND, "  Browse interactive commands"] }), _jsxs(Text, { color: palette.muted, wrap: "truncate", children: [MODEL_COMMAND, "  Show the active model"] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: true, color: palette.accent, children: "Recent activity" }) }), _jsx(Text, { color: palette.muted, children: "No recent activity" })] })] });
+}
+function commandReference(actionId) {
+    const action = COMMAND_REGISTRY.get(actionId);
+    if (action === undefined)
+        throw new Error(`Missing command contract: ${actionId}`);
+    return formatCommandReference(action, 'tui');
+}

package/dist/presentation/tui/ink/lotagate-tui.d.ts

@@ -0,0 +1,6 @@
+import type { JSX } from 'react';
+import type { InkTuiBridge } from './tui-bridge.js';
+export interface LotaGateTuiProps {
+    bridge: InkTuiBridge;
+}
+export declare function LotaGateTui({ bridge }: LotaGateTuiProps): JSX.Element;

package/dist/presentation/tui/ink/lotagate-tui.js

@@ -0,0 +1,136 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useState, useSyncExternalStore } from 'react';
+import { Box, useInput, useStdout } from 'ink';
+import { Transcript, transcriptTotalRows, transcriptViewportByRows } from './components/transcript.js';
+import { Composer } from './components/composer.js';
+import { estimateModalRows, Modal } from './components/modal.js';
+import { SubagentActivity, visibleSubagents } from './components/subagent-activity.js';
+import { parseMouseWheel } from '../terminal-mouse.js';
+const SMOOTH_SCROLL_ROWS = 3;
+export function LotaGateTui({ bridge }) {
+    const state = useSyncExternalStore((listener) => bridge.subscribe(listener), () => bridge.snapshot(), () => bridge.snapshot());
+    const { stdout } = useStdout();
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const [selectedSubagentId, setSelectedSubagentId] = useState();
+    const [composerRows, setComposerRows] = useState();
+    const [modalLayout, setModalLayout] = useState();
+    const modal = state.modal;
+    const inlineModal = isInlineModal(modal) ? modal : undefined;
+    const canCancelActiveRun = state.runActive && state.modal === undefined;
+    const terminalRows = stdout.rows ?? 24;
+    const estimatedComposerRows = 6 + state.pendingAttachments.length * 2;
+    const currentComposerRows = composerRows ?? estimatedComposerRows;
+    const currentModalRows = inlineModal === undefined
+        ? 0
+        : modalLayout?.modal === inlineModal ? modalLayout.rows : estimateModalRows(inlineModal);
+    const reservedRows = reservedLayoutRows(state, selectableSubagentCount(state.subagents), currentComposerRows, currentModalRows);
+    const columns = Math.max(40, stdout.columns ?? 80);
+    const timeline = buildTranscriptTimeline(state);
+    const totalRows = transcriptTotalRows(timeline, columns);
+    const availableTranscriptRows = Math.max(0, terminalRows - reservedRows);
+    const minimumTranscriptRows = currentComposerRows > estimatedComposerRows ? 0 : 1;
+    const transcriptRows = Math.max(minimumTranscriptRows, availableTranscriptRows);
+    const maximumScrollOffset = Math.max(0, totalRows - transcriptRows);
+    const viewport = transcriptViewportByRows(timeline, scrollOffset, Math.max(1, transcriptRows), columns);
+    const fillTranscript = transcriptRows > 0 && totalRows >= transcriptRows;
+    const selectableSubagents = visibleSubagents(state.subagents);
+    const handleComposerRowsChange = useCallback((rows) => {
+        setComposerRows((current) => current === rows ? current : rows);
+    }, []);
+    const handleModalRowsChange = useCallback((rows) => {
+        if (inlineModal === undefined)
+            return;
+        setModalLayout((current) => current?.modal === inlineModal && current.rows === rows ? current : { modal: inlineModal, rows });
+    }, [inlineModal]);
+    useEffect(() => {
+        if (selectedSubagentId !== undefined && selectableSubagents.some((subagent) => subagent.id === selectedSubagentId))
+            return;
+        setSelectedSubagentId(selectableSubagents[0]?.id);
+    }, [selectableSubagents, selectedSubagentId]);
+    useInput((input, key) => {
+        const subagentDirection = state.modal === undefined
+            ? subagentNavigationDirection(input, key, state.runActive)
+            : undefined;
+        if (key.ctrl && input.toLowerCase() === 'c')
+            bridge.interrupt();
+        else if ((key.escape || input === '\u001b') && canCancelActiveRun)
+            bridge.cancel();
+        else if (subagentDirection !== undefined) {
+            if (selectableSubagents.length === 0)
+                return;
+            const current = selectableSubagents.findIndex((subagent) => subagent.id === selectedSubagentId);
+            const next = selectableSubagents[(current + subagentDirection + selectableSubagents.length) % selectableSubagents.length];
+            setSelectedSubagentId(next?.id);
+        }
+        else if (state.modal === undefined && key.ctrl && input.toLowerCase() === 'o' && selectedSubagentId !== undefined) {
+            bridge.openSubagentDetails(selectedSubagentId);
+        }
+        else {
+            const wheel = parseMouseWheel(input);
+            if (wheel === 'up')
+                setScrollOffset((current) => Math.min(maximumScrollOffset, current + 3));
+            else if (wheel === 'down')
+                setScrollOffset((current) => Math.max(0, current - 3));
+            else if (key.pageUp || key.home)
+                setScrollOffset(key.home ? maximumScrollOffset : (current) => Math.min(maximumScrollOffset, current + transcriptRows));
+            else if (isCtrlArrow(input, key, 'up'))
+                setScrollOffset((current) => Math.min(maximumScrollOffset, current + SMOOTH_SCROLL_ROWS));
+            else if (key.pageDown || key.end)
+                setScrollOffset(key.end ? 0 : (current) => Math.max(0, current - transcriptRows));
+            else if (isCtrlArrow(input, key, 'down'))
+                setScrollOffset((current) => Math.max(0, current - SMOOTH_SCROLL_ROWS));
+        }
+    });
+    return _jsx(Box, { flexDirection: "column", paddingX: 1, ...(stdout.rows === undefined ? {} : { height: stdout.rows, overflow: 'hidden' }), children: modal !== undefined && inlineModal === undefined
+            ? _jsx(Modal, { bridge: bridge, modal: modal })
+            : _jsxs(_Fragment, { children: [transcriptRows > 0 && _jsx(Transcript, { messages: viewport.messages, showActionDetails: state.actionDetails, fill: fillTranscript, ...(fillTranscript ? { height: transcriptRows } : {}) }), _jsx(SubagentActivity, { subagents: state.subagents, paused: false, ...(selectedSubagentId === undefined ? {} : { selectedId: selectedSubagentId }) }), _jsx(Composer, { bridge: bridge, enabled: state.ready && !state.runActive && inlineModal === undefined, activeRun: canCancelActiveRun, onLayoutRowsChange: handleComposerRowsChange, ...(state.clearBlockedUntil === undefined ? {} : { clearBlockedUntil: state.clearBlockedUntil }), ...(state.footerNotice === undefined ? {} : { footerNotice: state.footerNotice }), ...(state.contextUsage === undefined ? {} : { contextUsage: state.contextUsage }), attachments: state.pendingAttachments, fileChoices: state.fileSuggestions }), inlineModal !== undefined && _jsx(Modal, { bridge: bridge, modal: inlineModal, onLayoutRowsChange: handleModalRowsChange })] }) });
+}
+function isInlineModal(modal) {
+    return modal?.kind === 'choice' || modal?.kind === 'approval' || modal?.kind === 'plan';
+}
+function reservedLayoutRows(state, activeSubagents, composerRows, modalRows) {
+    const subagentRows = activeSubagents === 0 ? 0 : 4 + activeSubagents * 4;
+    return subagentRows + Math.max(composerRows, 6 + state.pendingAttachments.length * 2) + modalRows;
+}
+function buildTranscriptTimeline(state) {
+    const welcome = state.welcome === undefined ? [] : [{ id: 'tui-welcome', kind: 'welcome', content: '', welcome: state.welcome }];
+    if (state.status === undefined)
+        return [...welcome, ...state.messages];
+    return [...welcome, ...state.messages, {
+            id: 'tui-live-turn-status',
+            kind: 'status',
+            content: '',
+            status: {
+                status: state.status,
+                ...(state.activityStartedAt === undefined ? {} : { activityStartedAt: state.activityStartedAt }),
+                ...(state.elapsedMs === undefined ? {} : { elapsedMs: state.elapsedMs }),
+                ...(state.usage === undefined ? {} : { usage: state.usage }),
+                paused: state.modal !== undefined,
+            },
+        }];
+}
+function selectableSubagentCount(subagents) {
+    return subagents.filter((subagent) => subagent.status === 'queued' || subagent.status === 'running').length;
+}
+function isCtrlArrow(input, key, direction) {
+    if (key.ctrl && (direction === 'up' ? key.upArrow : key.downArrow))
+        return true;
+    return input === (direction === 'up' ? '\u001b[1;5A' : '\u001b[1;5B');
+}
+function subagentNavigationDirection(input, key, runActive) {
+    const value = input.toLowerCase();
+    if (key.ctrl && value === 'j')
+        return 1;
+    if (key.ctrl && value === 'k')
+        return -1;
+    // Windows terminals commonly encode Ctrl+J/K as LF/VT and omit `key.ctrl`.
+    // Only use that fallback while the composer is disabled by an active run so
+    // Enter can still submit a normal prompt whenever the composer is available.
+    if (!runActive)
+        return undefined;
+    if (input === '\n')
+        return 1;
+    if (input === '\v')
+        return -1;
+    return undefined;
+}

package/dist/presentation/tui/ink/markdown-inline-renderer.d.ts

@@ -0,0 +1,4 @@
+import type { JSX } from 'react';
+export declare function MarkdownInline({ value }: {
+    value: string;
+}): JSX.Element;

package/dist/presentation/tui/ink/markdown-inline-renderer.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Text } from 'ink';
+import { DARK_THEME as palette } from '../../themes/theme.js';
+import { tokenizeMarkdownInline } from './markdown-inline.js';
+export function MarkdownInline({ value }) {
+    return _jsx(_Fragment, { children: tokenizeMarkdownInline(value).map((token, index) => _jsx(InlineToken, { token: token }, index)) });
+}
+function InlineToken({ token }) {
+    if (token.kind === 'link')
+        return _jsx(Text, { color: palette.link, underline: true, children: token.label });
+    if (token.kind === 'code')
+        return _jsx(Text, { color: palette.code, backgroundColor: palette.surfaceRaised, children: token.value });
+    if (token.kind === 'bold')
+        return _jsx(Text, { bold: true, children: token.value });
+    if (token.kind === 'italic')
+        return _jsx(Text, { italic: true, children: token.value });
+    if (token.kind === 'strike')
+        return _jsx(Text, { strikethrough: true, children: token.value });
+    return _jsx(Text, { children: token.value });
+}

package/dist/presentation/tui/ink/markdown-inline.d.ts

@@ -0,0 +1,13 @@
+export type MarkdownInlineToken = {
+    kind: 'text';
+    value: string;
+} | {
+    kind: 'code' | 'bold' | 'italic' | 'strike';
+    value: string;
+} | {
+    kind: 'link';
+    label: string;
+    href: string;
+};
+/** Tokenizes the safe Markdown subset rendered by the terminal UI. */
+export declare function tokenizeMarkdownInline(value: string): readonly MarkdownInlineToken[];

package/dist/presentation/tui/ink/markdown-inline.js

@@ -0,0 +1,91 @@
+const INLINE_MARKUP = /(`[^\n`]+`|\*\*[^*\n]+\*\*|__[^_\n]+__|~~[^~\n]+~~|\*[^*\n]+\*|_[^_\n]+_)/gu;
+/** Tokenizes the safe Markdown subset rendered by the terminal UI. */
+export function tokenizeMarkdownInline(value) {
+    const tokens = [];
+    let cursor = 0;
+    let textStart = 0;
+    while (cursor < value.length) {
+        const link = parseLinkAt(value, cursor);
+        if (link !== undefined) {
+            pushText(tokens, value, textStart, cursor);
+            tokens.push({ kind: 'link', label: link.label, href: link.href });
+            cursor = link.end;
+            textStart = cursor;
+            continue;
+        }
+        INLINE_MARKUP.lastIndex = 0;
+        const markup = INLINE_MARKUP.exec(value.slice(cursor));
+        if (markup?.index === 0) {
+            const raw = markup[0] ?? '';
+            pushText(tokens, value, textStart, cursor);
+            tokens.push(parseToken(raw));
+            cursor += raw.length;
+            textStart = cursor;
+            continue;
+        }
+        cursor += 1;
+    }
+    pushText(tokens, value, textStart, value.length);
+    return tokens;
+}
+function parseToken(value) {
+    if (value.startsWith('`'))
+        return { kind: 'code', value: value.slice(1, -1) };
+    if (value.startsWith('**') || value.startsWith('__'))
+        return { kind: 'bold', value: value.slice(2, -2) };
+    if (value.startsWith('~~'))
+        return { kind: 'strike', value: value.slice(2, -2) };
+    if (value.startsWith('*') || value.startsWith('_'))
+        return { kind: 'italic', value: value.slice(1, -1) };
+    return { kind: 'text', value };
+}
+function parseLinkAt(value, start) {
+    if (value[start] !== '[')
+        return undefined;
+    const labelEnd = findUnescaped(value, ']', start + 1);
+    if (labelEnd === -1 || value[labelEnd + 1] !== '(')
+        return undefined;
+    const destinationStart = labelEnd + 2;
+    if (value[destinationStart] === '<') {
+        const destinationEnd = findUnescaped(value, '>', destinationStart + 1);
+        if (destinationEnd === -1 || value[destinationEnd + 1] !== ')')
+            return undefined;
+        return { label: value.slice(start + 1, labelEnd), href: value.slice(destinationStart + 1, destinationEnd), end: destinationEnd + 2 };
+    }
+    let depth = 1;
+    for (let index = destinationStart; index < value.length; index += 1) {
+        const character = value[index] ?? '';
+        if (character === '\\') {
+            index += 1;
+            continue;
+        }
+        if (/\s/u.test(character))
+            return undefined;
+        if (character === '(') {
+            depth += 1;
+            continue;
+        }
+        if (character !== ')')
+            continue;
+        depth -= 1;
+        if (depth === 0) {
+            return { label: value.slice(start + 1, labelEnd), href: value.slice(destinationStart, index), end: index + 1 };
+        }
+    }
+    return undefined;
+}
+function findUnescaped(value, target, start) {
+    for (let index = start; index < value.length; index += 1) {
+        if (value[index] === '\\') {
+            index += 1;
+            continue;
+        }
+        if (value[index] === target)
+            return index;
+    }
+    return -1;
+}
+function pushText(tokens, value, start, end) {
+    if (end > start)
+        tokens.push({ kind: 'text', value: value.slice(start, end) });
+}

package/dist/presentation/tui/ink/markdown-message.d.ts

@@ -0,0 +1,6 @@
+import type { JSX } from 'react';
+export interface MarkdownMessageProps {
+    content: string;
+}
+/** A deliberately small, safe Markdown subset for streamed terminal text. */
+export declare function MarkdownMessage({ content }: MarkdownMessageProps): JSX.Element;

package/dist/presentation/tui/ink/markdown-message.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { DARK_THEME as palette } from '../../themes/theme.js';
+import { MarkdownInline } from './markdown-inline-renderer.js';
+import { MarkdownTable, parseMarkdownTable } from './markdown-table.js';
+/** A deliberately small, safe Markdown subset for streamed terminal text. */
+export function MarkdownMessage({ content }) {
+    let inCodeBlock = false;
+    const lines = content.split('\n');
+    const rendered = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? '';
+        if (line.startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            rendered.push(_jsx(Text, { color: palette.muted, children: line.length > 3 ? `· ${line.slice(3).trim()}` : '' }, index));
+            continue;
+        }
+        if (inCodeBlock) {
+            rendered.push(_jsx(Text, { color: palette.code, wrap: "wrap", children: line }, index));
+            continue;
+        }
+        const table = parseMarkdownTable(lines, index);
+        if (table !== undefined) {
+            rendered.push(_jsx(MarkdownTable, { table: table.table }, index));
+            index = table.nextLine - 1;
+            continue;
+        }
+        const heading = /^(#{1,6})\s+(.+)$/u.exec(line);
+        if (heading !== null) {
+            rendered.push(_jsx(Text, { bold: true, color: palette.accent, wrap: "wrap", children: _jsx(MarkdownInline, { value: heading[2] ?? '' }) }, index));
+            continue;
+        }
+        const list = parseMarkdownListItem(line);
+        if (list !== undefined) {
+            rendered.push(_jsx(MarkdownListItem, { item: list }, index));
+            continue;
+        }
+        const quote = /^(\s*)(>+)\s?(.*)$/u.exec(line);
+        if (quote !== null) {
+            rendered.push(_jsxs(Text, { color: palette.muted, wrap: "wrap", children: [quote[1], '│ '.repeat(quote[2]?.length ?? 1), _jsx(MarkdownInline, { value: quote[3] ?? '' })] }, index));
+            continue;
+        }
+        if (/^([-*_])(?:\s*\1){2,}\s*$/u.test(line)) {
+            rendered.push(_jsx(Text, { color: palette.muted, children: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }, index));
+            continue;
+        }
+        rendered.push(_jsx(Text, { wrap: "wrap", children: _jsx(MarkdownInline, { value: line }) }, index));
+    }
+    return _jsx(Box, { flexDirection: "column", children: rendered });
+}
+function parseMarkdownListItem(line) {
+    const match = /^(\s*)([-*+]|\d+[.)])\s+(?:(\[(?: |x|X)\])\s+)?(.+)$/u.exec(line);
+    if (match === null)
+        return undefined;
+    const task = match[3];
+    return {
+        indent: match[1] ?? '',
+        marker: match[2] ?? '•',
+        content: match[4] ?? '',
+        ...(task === undefined ? {} : { checked: task.toLowerCase() === '[x]' }),
+    };
+}
+function MarkdownListItem({ item }) {
+    const marker = item.checked === undefined ? /^\d/u.test(item.marker) ? item.marker : '•' : item.checked ? '☑' : '☐';
+    return _jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: palette.accent, children: [item.indent, marker, " "] }), _jsx(Box, { flexGrow: 1, children: _jsx(Text, { wrap: "wrap", children: _jsx(MarkdownInline, { value: item.content }) }) })] });
+}

package/dist/presentation/tui/ink/markdown-table.d.ts

@@ -0,0 +1,16 @@
+import type { JSX } from 'react';
+export type MarkdownTableAlignment = 'left' | 'center' | 'right';
+export interface MarkdownTableData {
+    headers: readonly string[];
+    rows: readonly (readonly string[])[];
+    alignments: readonly MarkdownTableAlignment[];
+}
+export interface MarkdownTableMatch {
+    table: MarkdownTableData;
+    nextLine: number;
+}
+/** Detects a pipe table beginning at the supplied Markdown line. */
+export declare function parseMarkdownTable(lines: readonly string[], startLine: number): MarkdownTableMatch | undefined;
+export declare function MarkdownTable({ table }: {
+    table: MarkdownTableData;
+}): JSX.Element;

package/dist/presentation/tui/ink/markdown-table.js

@@ -0,0 +1,77 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { DARK_THEME as palette } from '../../themes/theme.js';
+import { terminalTextWidth } from '../formatters.js';
+import { MarkdownInline } from './markdown-inline-renderer.js';
+import { tokenizeMarkdownInline } from './markdown-inline.js';
+/** Detects a pipe table beginning at the supplied Markdown line. */
+export function parseMarkdownTable(lines, startLine) {
+    const header = splitTableRow(lines[startLine] ?? '');
+    const separator = splitTableRow(lines[startLine + 1] ?? '');
+    if (header.length < 2 || separator.length < 2 || separator.some((cell) => !isSeparatorCell(cell)))
+        return undefined;
+    const columnCount = Math.max(header.length, separator.length);
+    const headers = normalizeRow(header, columnCount);
+    const alignments = normalizeAlignments(separator, columnCount);
+    const rows = [];
+    let nextLine = startLine + 2;
+    while (nextLine < lines.length) {
+        const row = splitTableRow(lines[nextLine] ?? '');
+        if (row.length < 2)
+            break;
+        rows.push(normalizeRow(row, columnCount));
+        nextLine += 1;
+    }
+    return { table: { headers, rows, alignments }, nextLine };
+}
+export function MarkdownTable({ table }) {
+    const widths = table.headers.map((header, column) => Math.max(terminalTextWidth(inlineText(header)), ...table.rows.map((row) => terminalTextWidth(inlineText(row[column] ?? '')))));
+    return _jsxs(Box, { flexDirection: "column", children: [renderTableRow(table.headers, widths, table.alignments, true), renderSeparator(widths), table.rows.map((row, index) => renderTableRow(row, widths, table.alignments, false, index))] });
+}
+function renderTableRow(cells, widths, alignments, header, key = 0) {
+    return _jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: palette.muted, children: "\u2502" }), cells.map((cell, column) => _jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: (widths[column] ?? 0) + 2, paddingX: 1, justifyContent: alignments[column] === 'right' ? 'flex-end' : alignments[column] === 'center' ? 'center' : 'flex-start', children: _jsx(Text, { bold: header, wrap: "truncate", children: _jsx(MarkdownInline, { value: cell }) }) }), _jsx(Text, { color: palette.muted, children: "\u2502" })] }, column))] }, key);
+}
+function renderSeparator(widths) {
+    return _jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: palette.muted, children: "\u251C" }), widths.map((width, index) => _jsxs(Text, { color: palette.muted, children: ['─'.repeat(width + 2), index === widths.length - 1 ? '┤' : '┼'] }, index))] });
+}
+function splitTableRow(line) {
+    const trimmed = line.trim();
+    if (!trimmed.includes('|'))
+        return [];
+    const content = trimmed.startsWith('|') ? trimmed.slice(1) : trimmed;
+    const withoutTrailingPipe = content.endsWith('|') && !content.endsWith('\\|') ? content.slice(0, -1) : content;
+    const cells = [];
+    let current = '';
+    let escaped = false;
+    for (const character of withoutTrailingPipe) {
+        if (character === '|' && !escaped) {
+            cells.push(current.trim());
+            current = '';
+            continue;
+        }
+        if (character === '\\' && !escaped) {
+            escaped = true;
+            current += character;
+            continue;
+        }
+        escaped = false;
+        current += character;
+    }
+    cells.push(current.trim());
+    return cells;
+}
+function isSeparatorCell(value) { return /^:?-{1,}:?$/u.test(value); }
+function normalizeRow(row, columnCount) {
+    return Array.from({ length: columnCount }, (_, index) => row[index] ?? '');
+}
+function normalizeAlignments(row, columnCount) {
+    return Array.from({ length: columnCount }, (_, index) => {
+        const cell = row[index] ?? '';
+        const left = cell.startsWith(':');
+        const right = cell.endsWith(':');
+        return left && right ? 'center' : right ? 'right' : 'left';
+    });
+}
+function inlineText(value) {
+    return tokenizeMarkdownInline(value).map((token) => token.kind === 'link' ? token.label : token.value).join('');
+}