@copado/agentia-cli 0.108.0-alpha.0 → 0.110.0-alpha.0

package/dist/lib/ai-session-tui.js

@@ -0,0 +1,859 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, render, Text, useApp, useStdin, useStdout } from 'ink';
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { v4 as uuidv4 } from 'uuid';
+import { AiGateway, isAiRequestAborted } from './ai-gateway.js';
+import { bootstrapAiDialogue } from './ai-operations.js';
+import { copyTextToClipboard, lastMarkdownCodeFence } from './ai-session-tui-clipboard.js';
+import { COMPOSER_MAX_ROWS, composerBackspace, composerDelete, composerEnd, composerHome, composerRowCount, createComposer, createPromptRecall, insertComposerText, moveComposerCursor, recallNewer, recallOlder, recordPrompt, visibleComposerRows, } from './ai-session-tui-composer.js';
+import { SessionInputAssembler } from './ai-session-tui-keys.js';
+import { detectMermaidImageProtocol, installStdoutImageBridge } from './ai-session-tui-mermaid-image.js';
+import { chatViewportHeight, clampScrollOffset, flattenTranscript, visibleTranscriptRows } from './ai-session-tui-scroll.js';
+import { clampSlashIndex, filterSlashCommands, selectedSlashCommand, sessionHelpLines, slashPaletteWindow, } from './ai-session-tui-slash.js';
+import { WELCOME_ACTIONS, WelcomeScreen } from './ai-session-tui-welcome.js';
+import { filterAiSessions, formatSessionOverlayLine, listAiSessions, pickSessionFromList } from './ai-sessions.js';
+import { agentForAssistantId, AI_CHAT_AGENTS, AI_SESSION_LIST_DEFAULT_PAGE_SIZE, assistantIdForAgent, dialogueAssistantId, dialogueMessageText, enrichAiPrompt, } from './ai-types.js';
+const LAUNCH_ENTER_GUARD_MS = 400;
+function discardPendingStdinBytes(stdin) {
+    const stream = stdin;
+    if (typeof stream.read !== 'function')
+        return;
+    const pending = stream.readableLength;
+    if (pending === undefined || pending === 0)
+        return;
+    stream.read(pending);
+}
+const TOKEN_FLUSH_MS = 32;
+const MAX_FOLLOWUPS = 5;
+const SPINNER = '|/-\\';
+function helpText() {
+    return `Commands: /help, /session, /${AI_CHAT_AGENTS.join(', /')}, /copy, /clear, /new, /exit`;
+}
+function normalizeAgent(value) {
+    if (AI_CHAT_AGENTS.includes(value))
+        return value;
+    return undefined;
+}
+function slashAgent(line) {
+    if (!line.startsWith('/'))
+        return undefined;
+    return normalizeAgent(line.slice(1));
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function historyLines(dialogue) {
+    return (dialogue.messages ?? []).map((message, index) => ({
+        id: `history-${dialogue.id}-${index}`,
+        kind: message.role === 'human' ? 'you' : 'agent',
+        text: dialogueMessageText(message),
+    }));
+}
+function followupContent(value) {
+    if (typeof value === 'string' && value.trim().length > 0)
+        return value.trim();
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const record = value;
+    for (const candidate of [record.content, record.question, record.text]) {
+        if (typeof candidate === 'string' && candidate.trim().length > 0)
+            return candidate.trim();
+    }
+    return undefined;
+}
+function appendLinkLine(append, content) {
+    if (content === null || typeof content !== 'object' || Array.isArray(content))
+        return;
+    const record = content;
+    const title = typeof record.title === 'string' ? record.title : typeof record.summary === 'string' ? record.summary : undefined;
+    const url = typeof record.url === 'string' ? record.url : undefined;
+    const label = [title, url].filter((part) => part !== undefined && part.length > 0).join(' — ');
+    if (label.length > 0)
+        append({ kind: 'system', text: `Link: ${label}` });
+}
+function applyTurnStreamChunk(chunk, state) {
+    if (chunk.type === 'token' && typeof chunk.content === 'string') {
+        state.streamText.current += chunk.content;
+        state.scheduleFlush();
+        return;
+    }
+    if (chunk.type === 'status' && typeof chunk.content === 'string') {
+        state.setStatus(chunk.content);
+        return;
+    }
+    if (chunk.type === 'warning' && typeof chunk.content === 'string') {
+        state.append({ kind: 'system', text: chunk.content });
+        return;
+    }
+    if (chunk.type === 'followup') {
+        const text = followupContent(chunk.content);
+        if (text !== undefined && state.followups.length < MAX_FOLLOWUPS)
+            state.followups.push(text);
+        return;
+    }
+    if (chunk.type === 'link') {
+        appendLinkLine(state.append, chunk.content);
+    }
+}
+function lastFollowupItems(lines) {
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const line = lines[index];
+        if (line?.kind === 'followups')
+            return line.items ?? [];
+    }
+    return [];
+}
+function sessionChatHint(state) {
+    if (state.slashOpen)
+        return 'Tab complete · Enter run · Esc dismiss';
+    if (state.scrollOffset > 0)
+        return 'Reading history  ·  ↓ to return to latest';
+    if (state.busy)
+        return 'Pinned to latest  ·  Esc cancels this turn';
+    if (state.followupCount > 0 && state.inputLength === 0) {
+        return `Follow-ups: press 1–${state.followupCount} to send that suggestion`;
+    }
+    return '↑/↓ to scroll · ←/→ move the cursor · PgUp/PgDn (Fn+↑/Fn+↓) reuse a sent prompt';
+}
+function ignoreFailure(work) {
+    work.catch(() => {
+        // Errors are reported by the async command handlers themselves.
+    });
+}
+function sessionKeyAsInk(key) {
+    return {
+        key: {
+            backspace: key.type === 'backspace',
+            delete: key.type === 'delete',
+            downArrow: key.type === 'down',
+            escape: key.type === 'escape',
+            return: key.type === 'enter',
+            tab: key.type === 'tab',
+            upArrow: key.type === 'up',
+        },
+        value: key.type === 'text' ? key.value : '',
+    };
+}
+function handleSessionOverlayInput(event, handlers) {
+    const { key, live, value } = event;
+    const filtered = filterAiSessions(live.sessions, live.sessionFilter);
+    if (key.escape || value === '/cancel' || value === 'cancel') {
+        handlers.setOverlay('none');
+        return;
+    }
+    if (key.upArrow) {
+        handlers.setSessionIndex((index) => Math.max(0, index - 1));
+        return;
+    }
+    if (key.downArrow) {
+        handlers.setSessionIndex((index) => Math.min(Math.max(0, filtered.length - 1), index + 1));
+        return;
+    }
+    if (key.backspace || key.delete) {
+        const next = live.sessionFilter.slice(0, -1);
+        live.sessionFilter = next;
+        handlers.setSessionFilter(next);
+        handlers.setSessionIndex(() => 0);
+        return;
+    }
+    if (value.length > 1 && !/^\d+$/u.test(value)) {
+        const picked = pickSessionFromList(value, filtered);
+        if (picked !== undefined) {
+            ignoreFailure(handlers.resumeDialogue(picked.id));
+            return;
+        }
+    }
+    if (key.return && filtered[live.sessionIndex] !== undefined) {
+        ignoreFailure(handlers.resumeDialogue(filtered[live.sessionIndex].id));
+        return;
+    }
+    if (value.length > 0 && !key.return) {
+        const next = live.sessionFilter + value;
+        live.sessionFilter = next;
+        handlers.setSessionFilter(next);
+        handlers.setSessionIndex(() => 0);
+    }
+}
+function handleWelcomeInput(event, handlers) {
+    const { key, live, value } = event;
+    if (key.upArrow) {
+        handlers.setWelcomeIndex((index) => Math.max(0, index - 1));
+        return;
+    }
+    if (key.downArrow) {
+        const next = Math.min(WELCOME_ACTIONS.length - 1, live.welcomeIndex + 1);
+        live.welcomeIndex = next;
+        handlers.setWelcomeIndex(next);
+        return;
+    }
+    if (value === '1') {
+        ignoreFailure(handlers.startNew());
+        return;
+    }
+    if (value === '2') {
+        ignoreFailure(handlers.openSessionOverlay());
+        return;
+    }
+    if (key.return) {
+        ignoreFailure(WELCOME_ACTIONS[live.welcomeIndex]?.id === 'resume' ? handlers.openSessionOverlay() : handlers.startNew());
+    }
+}
+function handleSlashPaletteInput(event, matches, handlers) {
+    if (matches.length === 0)
+        return false;
+    const { key, live } = event;
+    if (key.upArrow) {
+        handlers.setSlashIndex((index) => Math.max(0, index - 1));
+        return true;
+    }
+    if (key.downArrow) {
+        handlers.setSlashIndex((index) => Math.min(matches.length - 1, index + 1));
+        return true;
+    }
+    if (key.tab) {
+        const selected = selectedSlashCommand(matches, live.slashIndex);
+        if (selected !== undefined) {
+            handlers.setComposer(createComposer(selected.command));
+        }
+        return true;
+    }
+    if (key.escape) {
+        handlers.setSlashDismissed(true);
+        return true;
+    }
+    if (key.return) {
+        const selected = selectedSlashCommand(matches, live.slashIndex);
+        if (selected !== undefined) {
+            handlers.setComposer(createComposer());
+            handlers.runCommand(selected.command);
+        }
+        return true;
+    }
+    return false;
+}
+function handleIdleChatInput(key, live, handlers) {
+    const matches = live.slashDismissed ? [] : filterSlashCommands(live.input);
+    const ink = sessionKeyAsInk(key);
+    if (handleSlashPaletteInput({ key: ink.key, live }, matches, {
+        runCommand: (command) => ignoreFailure(handlers.handleChatLine(command)),
+        setComposer: handlers.setComposer,
+        setSlashDismissed: handlers.setSlashDismissed,
+        setSlashIndex: handlers.setSlashIndex,
+    })) {
+        return;
+    }
+    handlePromptInput(key, live, handlers);
+}
+function handlePromptInput(key, live, handlers) {
+    const current = { cursor: live.cursor, text: live.input };
+    if (key.type === 'tab')
+        return;
+    if (key.type === 'escape') {
+        live.input = '';
+        live.cursor = 0;
+        handlers.setComposer(createComposer());
+        return;
+    }
+    if (key.type === 'enter') {
+        const line = live.input.trim();
+        live.input = '';
+        live.cursor = 0;
+        handlers.setComposer(createComposer());
+        if (line.length > 0)
+            ignoreFailure(handlers.handleChatLine(line));
+        return;
+    }
+    if (key.type === 'left') {
+        handlers.setComposer(moveComposerCursor(current, -1));
+        return;
+    }
+    if (key.type === 'right') {
+        handlers.setComposer(moveComposerCursor(current, 1));
+        return;
+    }
+    if (key.type === 'home') {
+        handlers.setComposer(composerHome(current));
+        return;
+    }
+    if (key.type === 'end') {
+        handlers.setComposer(composerEnd(current));
+        return;
+    }
+    if (key.type === 'backspace') {
+        handlers.setComposer(composerBackspace(current));
+        return;
+    }
+    if (key.type === 'delete') {
+        handlers.setComposer(composerDelete(current));
+        return;
+    }
+    if (key.type === 'text' && key.value.length > 0) {
+        handlers.setComposer(insertComposerText(current, key.value));
+    }
+}
+// eslint-disable-next-line complexity -- one dispatcher for welcome, overlays, composer, and slash
+function handleSessionAppKey(key, live, actions) {
+    const ink = sessionKeyAsInk(key);
+    const { value } = ink;
+    if (live.busy) {
+        if (key.type === 'escape')
+            actions.abortTurn();
+        return;
+    }
+    if (live.overlay === 'help') {
+        if (key.type === 'escape' || key.type === 'enter')
+            actions.setOverlay('none');
+        return;
+    }
+    if (live.overlay === 'confirm-new') {
+        if (key.type === 'escape') {
+            actions.setOverlay('none');
+            return;
+        }
+        if (key.type === 'enter') {
+            actions.setOverlay('none');
+            ignoreFailure(actions.startNew());
+        }
+        return;
+    }
+    if (live.overlay === 'session') {
+        handleSessionOverlayInput({ key: ink.key, live, value }, {
+            resumeDialogue: actions.resumeDialogue,
+            setOverlay: actions.setOverlay,
+            setSessionFilter: actions.setSessionFilter,
+            setSessionIndex: actions.setSessionIndex,
+        });
+        return;
+    }
+    if (live.screen === 'welcome') {
+        if (key.type === 'enter' && !actions.welcomeArmed)
+            return;
+        if (key.type === 'up' || key.type === 'down' || value.length > 0)
+            actions.armWelcome();
+        handleWelcomeInput({ key: ink.key, live, value }, { openSessionOverlay: actions.openSessionOverlay, setWelcomeIndex: actions.setWelcomeIndex, startNew: actions.startNew });
+        return;
+    }
+    const composerHandlers = {
+        handleChatLine: actions.handleChatLine,
+        setComposer: actions.applyComposer,
+        setSlashDismissed(dismissed) {
+            live.slashDismissed = dismissed;
+            actions.setSlashDismissed(dismissed);
+        },
+        setSlashIndex(updater) {
+            actions.setSlashIndex((index) => {
+                const next = updater(index);
+                live.slashIndex = next;
+                return next;
+            });
+        },
+    };
+    const slashOpen = !live.slashDismissed && filterSlashCommands(live.input).length > 0;
+    if (slashOpen) {
+        handleIdleChatInput(key, live, composerHandlers);
+        return;
+    }
+    if (live.screen === 'chat' && live.overlay === 'none') {
+        if (key.type === 'up') {
+            actions.setScrollOffset((offset) => clampScrollOffset(actions.displayRowsLength, actions.viewport, offset + 1));
+            return;
+        }
+        if (key.type === 'down') {
+            actions.setScrollOffset((offset) => clampScrollOffset(actions.displayRowsLength, actions.viewport, offset - 1));
+            return;
+        }
+    }
+    if (key.type === 'text' && live.input.length === 0 && /^\d$/u.test(key.value)) {
+        const picked = actions.followupItems[Number.parseInt(key.value, 10) - 1];
+        if (picked !== undefined) {
+            ignoreFailure(actions.handleChatLine(picked));
+            return;
+        }
+    }
+    if (key.type === 'page-up' || key.type === 'page-down') {
+        const recalled = key.type === 'page-up' ? recallOlder(actions.recall, live.input) : recallNewer(actions.recall, live.input);
+        actions.setRecall(recalled.recall);
+        actions.applyComposer(createComposer(recalled.text));
+        return;
+    }
+    handleIdleChatInput(key, live, composerHandlers);
+}
+function TranscriptRow(props) {
+    const { row } = props;
+    if (row.imageSlot !== undefined) {
+        return (_jsx(Text, { color: row.imageColor, wrap: "truncate", children: row.text.length === 0 ? ' ' : row.text }));
+    }
+    if (row.spans !== undefined && row.spans.length > 0) {
+        return (_jsx(Text, { wrap: "truncate", children: row.spans.map((span, index) => (_jsx(Text, { backgroundColor: span.backgroundColor, color: span.color, dimColor: span.dim === true, children: span.text.length === 0 ? ' ' : span.text }, `${row.id}-${index}`))) }));
+    }
+    return (_jsx(Text, { bold: row.bold, color: row.color, dimColor: row.dim, wrap: "truncate", children: row.text.length === 0 ? ' ' : row.text }));
+}
+function ChatLivePane(props) {
+    return (_jsxs(Box, { flexDirection: "column", height: props.height, children: [_jsx(Box, { flexShrink: 0, children: _jsxs(Text, { bold: true, wrap: "truncate", children: [props.agent, "  ", props.dialogueId] }) }), _jsx(Box, { flexShrink: 0, children: _jsx(Text, { dimColor: true, wrap: "truncate", children: helpText() }) }), _jsx(Box, { flexShrink: 0, children: _jsx(Text, { dimColor: true, wrap: "truncate", children: props.hint }) }), _jsx(Box, { flexDirection: "column", height: props.viewport, overflow: "hidden", children: props.rows.map((row) => (_jsx(TranscriptRow, { row: row }, row.id))) }), props.status.length > 0 || props.busy ? (_jsx(Box, { flexShrink: 0, children: _jsx(Text, { color: "yellow", dimColor: true, wrap: "truncate", children: props.busy
+                        ? `${SPINNER[props.elapsedSeconds % SPINNER.length]} ${props.status.length > 0 ? props.status : 'Waiting…'}  ${props.elapsedSeconds}s`
+                        : props.status }) })) : null, props.suggestions.map((item, index) => (_jsx(Box, { flexShrink: 0, children: _jsxs(Text, { color: index === props.selectedSlash ? 'green' : undefined, wrap: "truncate", children: [index === props.selectedSlash ? '●' : ' ', " ", item.command, "  ", item.description] }) }, item.command))), props.composerRows.map((row, index) => (_jsxs(Box, { flexShrink: 0, children: [_jsx(Text, { children: index === 0 ? '> ' : '  ' }), row.hasCaret && !props.busy ? (_jsxs(Box, { children: [_jsx(Text, { wrap: "truncate", children: row.text.slice(0, Math.max(0, row.caretColumn)) }), _jsx(Text, { color: "cyan", children: "\u2588" }), _jsx(Text, { wrap: "truncate", children: row.text.slice(Math.max(0, row.caretColumn)) })] })) : (_jsx(Text, { wrap: "truncate", children: row.text.length === 0 ? ' ' : row.text }))] }, `prompt-${index}`)))] }));
+}
+// eslint-disable-next-line complexity -- session screens, overlays, and stdin wiring
+export function SessionApp(props) {
+    const { onFinished, options } = props;
+    const { exit } = useApp();
+    const stdinApi = useStdin();
+    const { stdout } = useStdout();
+    const frameHeight = stdout.rows === undefined || stdout.rows < 10 ? undefined : stdout.rows;
+    const chatRows = frameHeight ?? 80;
+    const columns = Math.max(20, stdout.columns ?? 80);
+    const promptWidth = Math.max(10, columns - 2);
+    const skipWelcome = Boolean(options.dialogue);
+    const confirmArmedRef = useRef(skipWelcome);
+    const [screen, setScreen] = useState(skipWelcome ? 'chat' : 'welcome');
+    const [overlay, setOverlay] = useState('none');
+    const [agent, setAgent] = useState(options.agent);
+    const [dialogue, setDialogue] = useState();
+    const [committed, setCommitted] = useState([]);
+    const [liveAgent, setLiveAgent] = useState();
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const [input, setInput] = useState('');
+    const [cursor, setCursor] = useState(0);
+    const [welcomeIndex, setWelcomeIndex] = useState(0);
+    const [sessions, setSessions] = useState([]);
+    const [sessionIndex, setSessionIndex] = useState(0);
+    const [sessionFilter, setSessionFilter] = useState('');
+    const [busy, setBusy] = useState(false);
+    const [status, setStatus] = useState('');
+    const [slashIndex, setSlashIndex] = useState(0);
+    const [slashDismissed, setSlashDismissed] = useState(false);
+    const [elapsedTick, setElapsedTick] = useState(0);
+    const turnsRef = useRef(0);
+    const dialogueRef = useRef(undefined);
+    const streamTextRef = useRef('');
+    const rowCountRef = useRef(0);
+    const abortRef = useRef(undefined);
+    const turnStartedAtRef = useRef(undefined);
+    const recallRef = useRef(createPromptRecall());
+    const liveRef = useRef({
+        agent,
+        busy,
+        cursor,
+        dialogue,
+        input,
+        overlay,
+        screen,
+        sessionFilter,
+        sessionIndex,
+        sessions,
+        slashDismissed,
+        slashIndex,
+        welcomeIndex,
+    });
+    liveRef.current = {
+        agent,
+        busy,
+        cursor,
+        dialogue,
+        input,
+        overlay,
+        screen,
+        sessionFilter,
+        sessionIndex,
+        sessions,
+        slashDismissed,
+        slashIndex,
+        welcomeIndex,
+    };
+    const append = useCallback((line) => {
+        setCommitted((current) => [...current, { id: uuidv4(), ...line }]);
+    }, []);
+    const finish = useCallback((dialogueId) => {
+        onFinished?.({ dialogueId, turns: turnsRef.current });
+        exit();
+    }, [exit, onFinished]);
+    const applyDialogue = useCallback((next, nextAgent, notice) => {
+        setDialogue(next);
+        dialogueRef.current = next;
+        setAgent(nextAgent);
+        setScreen('chat');
+        setOverlay('none');
+        const lines = options.loadHistory === true ? historyLines(next) : [];
+        if (notice !== undefined)
+            lines.push({ id: uuidv4(), kind: 'system', text: notice });
+        setCommitted(lines);
+        setLiveAgent(undefined);
+        setScrollOffset(0);
+        setSlashDismissed(false);
+        setSlashIndex(0);
+        setInput('');
+        setCursor(0);
+        recallRef.current = createPromptRecall();
+        setStatus('');
+    }, [options.loadHistory]);
+    const startNew = useCallback(async () => {
+        setBusy(true);
+        setStatus('Starting session…');
+        try {
+            const bootstrap = await bootstrapAiDialogue({ ...options, agent, dialogue: undefined, kind: 'chat' });
+            applyDialogue(bootstrap.dialogue, agent);
+        }
+        catch (error) {
+            setStatus(errorMessage(error));
+        }
+        finally {
+            setBusy(false);
+        }
+    }, [agent, applyDialogue, options]);
+    const resumeDialogue = useCallback(async (id) => {
+        setBusy(true);
+        setStatus('Loading session…');
+        try {
+            const next = await AiGateway.getDialogue(id, options);
+            const nextAgent = agentForAssistantId(dialogueAssistantId(next)) ?? agent;
+            applyDialogue(next, nextAgent, `Resumed ${next.id}`);
+        }
+        catch (error) {
+            setStatus(errorMessage(error));
+        }
+        finally {
+            setBusy(false);
+        }
+    }, [agent, applyDialogue, options]);
+    const openSessionOverlay = useCallback(async () => {
+        setBusy(true);
+        setStatus('Loading sessions…');
+        try {
+            const page = await listAiSessions({ ...options, pageSize: AI_SESSION_LIST_DEFAULT_PAGE_SIZE });
+            setSessions(page.data);
+            setSessionIndex(0);
+            setSessionFilter('');
+            setOverlay('session');
+            setStatus(page.data.length === 0 ? 'No AI sessions found.' : '');
+        }
+        catch (error) {
+            setStatus(errorMessage(error));
+        }
+        finally {
+            setBusy(false);
+        }
+    }, [options]);
+    const sendTurn = useCallback(async (line, current, currentAgent) => {
+        setBusy(true);
+        streamTextRef.current = '';
+        append({ kind: 'you', text: line });
+        setLiveAgent('');
+        setScrollOffset(0);
+        const requestId = uuidv4();
+        const followups = [];
+        let completed = false;
+        let flushTimer;
+        const controller = new AbortController();
+        abortRef.current = controller;
+        turnStartedAtRef.current = Date.now();
+        const prompt = enrichAiPrompt(line, {
+            component: options.component,
+            sfOrg: options.sfOrg,
+            userStory: options.userStory,
+            workItem: options.workItem,
+        });
+        const flushAgentText = () => {
+            flushTimer = undefined;
+            setLiveAgent(streamTextRef.current);
+        };
+        try {
+            await AiGateway.sendMessage(current.id, {
+                assistantId: assistantIdForAgent(currentAgent),
+                'dev_context': null,
+                integrations: null,
+                prompt,
+                'request_id': requestId,
+                'system_prompt': null,
+            }, { ...options, signal: controller.signal }, (chunk) => {
+                if (chunk.type === 'error' && typeof chunk.content === 'string') {
+                    throw new Error(chunk.content);
+                }
+                if (chunk.type === 'done' || chunk.type === 'performance' || chunk.type === 'stream_complete') {
+                    completed = true;
+                    return;
+                }
+                applyTurnStreamChunk(chunk, {
+                    append,
+                    followups,
+                    scheduleFlush() {
+                        if (flushTimer === undefined)
+                            flushTimer = setTimeout(flushAgentText, TOKEN_FLUSH_MS);
+                    },
+                    setStatus,
+                    streamText: streamTextRef,
+                });
+            });
+            if (flushTimer !== undefined)
+                clearTimeout(flushTimer);
+            flushAgentText();
+            if (!completed)
+                throw new Error('AI stream ended before stream_complete. Response may be incomplete.');
+            append({ kind: 'agent', text: streamTextRef.current });
+            if (followups.length > 0)
+                append({ items: followups, kind: 'followups', text: followups.join('\n') });
+            setLiveAgent(undefined);
+            turnsRef.current += 1;
+            setStatus('');
+        }
+        catch (error) {
+            if (flushTimer !== undefined)
+                clearTimeout(flushTimer);
+            flushAgentText();
+            if (streamTextRef.current.length > 0) {
+                append({ kind: 'agent', text: streamTextRef.current });
+                setLiveAgent(undefined);
+            }
+            if (isAiRequestAborted(error)) {
+                append({ kind: 'system', text: 'Turn cancelled.' });
+            }
+            else {
+                append({ kind: 'system', text: `AI turn failed: ${errorMessage(error)}` });
+            }
+        }
+        finally {
+            abortRef.current = undefined;
+            turnStartedAtRef.current = undefined;
+            setBusy(false);
+        }
+    }, [append, options]);
+    const handleChatLine = useCallback(
+    // eslint-disable-next-line complexity -- slash routing mirrors the readline chat session
+    async (line) => {
+        if (line === '/exit' || line === 'exit' || line === 'quit') {
+            finish(dialogueRef.current?.id ?? '');
+            return;
+        }
+        if (line === '/help') {
+            setOverlay('help');
+            return;
+        }
+        if (line === '/cancel' || line === 'cancel') {
+            setOverlay('none');
+            return;
+        }
+        if (line === '/session') {
+            await openSessionOverlay();
+            return;
+        }
+        if (line.startsWith('/session ')) {
+            const page = sessions.length > 0 ? sessions : (await listAiSessions({ ...options, pageSize: AI_SESSION_LIST_DEFAULT_PAGE_SIZE })).data;
+            setSessions(page);
+            const picked = pickSessionFromList(line.slice('/session '.length).trim(), page);
+            if (picked === undefined) {
+                append({ kind: 'system', text: 'Unknown session. Use a list number or a dialogue UUID.' });
+                return;
+            }
+            await resumeDialogue(picked.id);
+            return;
+        }
+        if (line === '/clear') {
+            setCommitted([{ id: uuidv4(), kind: 'system', text: 'Transcript cleared. Same session.' }]);
+            setLiveAgent(undefined);
+            setScrollOffset(0);
+            return;
+        }
+        if (line === '/copy') {
+            const fence = lastMarkdownCodeFence([
+                ...committed,
+                ...(liveAgent === undefined ? [] : [{ kind: 'agent', text: liveAgent }]),
+            ]);
+            if (fence === undefined) {
+                append({ kind: 'system', text: 'No code block to copy.' });
+                return;
+            }
+            await copyTextToClipboard(fence.code);
+            const language = fence.language.trim().length > 0 ? fence.language : 'code';
+            append({ kind: 'system', text: `Copied ${language} to clipboard` });
+            return;
+        }
+        if (line === '/new') {
+            setOverlay('confirm-new');
+            return;
+        }
+        const shortcut = slashAgent(line);
+        if (shortcut !== undefined) {
+            setAgent(shortcut);
+            append({ kind: 'system', text: `Using ${shortcut} agent on session ${dialogue?.id ?? ''}` });
+            return;
+        }
+        if (line.startsWith('/agent ')) {
+            const nextAgent = normalizeAgent(line.slice('/agent '.length).trim());
+            if (nextAgent === undefined) {
+                append({ kind: 'system', text: `Unknown agent. Use ${AI_CHAT_AGENTS.join(', ')}.` });
+                return;
+            }
+            setAgent(nextAgent);
+            append({ kind: 'system', text: `Using ${nextAgent} agent on session ${dialogue?.id ?? ''}` });
+            return;
+        }
+        if (dialogue === undefined) {
+            append({ kind: 'system', text: 'Session is not ready yet.' });
+            return;
+        }
+        recallRef.current = recordPrompt(recallRef.current, line);
+        await sendTurn(line, dialogue, agent);
+    }, [agent, append, committed, dialogue, finish, liveAgent, openSessionOverlay, options, resumeDialogue, sendTurn, sessions, startNew]);
+    const applyComposer = useCallback((next) => {
+        liveRef.current.input = next.text;
+        liveRef.current.cursor = next.cursor;
+        setInput(next.text);
+        setCursor(next.cursor);
+        setSlashDismissed(false);
+    }, []);
+    const displayRows = useMemo(() => {
+        const items = [...committed];
+        if (liveAgent !== undefined)
+            items.push({ id: 'live', kind: 'agent', text: liveAgent });
+        return flattenTranscript(items, columns);
+    }, [columns, committed, liveAgent]);
+    const slashMatches = slashDismissed ? [] : filterSlashCommands(input);
+    const slashWindow = slashPaletteWindow(slashMatches, slashIndex);
+    const promptRows = composerRowCount(input, promptWidth, COMPOSER_MAX_ROWS);
+    const extraRows = slashWindow.window.length + Math.max(0, promptRows - 1);
+    const hasStatus = busy || status.length > 0;
+    const viewport = chatViewportHeight(chatRows, hasStatus, extraRows);
+    const visibleRows = visibleTranscriptRows(displayRows, viewport, scrollOffset);
+    const composerRows = visibleComposerRows(input, cursor, promptWidth, COMPOSER_MAX_ROWS);
+    const filteredSessions = filterAiSessions(sessions, sessionFilter);
+    const elapsedSeconds = busy ? elapsedTick : 0;
+    const followupCount = lastFollowupItems(committed).length;
+    const hint = sessionChatHint({
+        busy,
+        followupCount,
+        inputLength: input.length,
+        scrollOffset,
+        slashOpen: slashWindow.window.length > 0,
+    });
+    useEffect(() => {
+        setSlashIndex((index) => clampSlashIndex(slashMatches.length, index));
+    }, [input, slashDismissed, slashMatches.length]);
+    useEffect(() => {
+        if (!busy) {
+            setElapsedTick(0);
+            return;
+        }
+        const timer = setInterval(() => {
+            setElapsedTick((tick) => tick + 1);
+        }, 1000);
+        return () => {
+            clearInterval(timer);
+        };
+    }, [busy]);
+    useEffect(() => {
+        const previous = rowCountRef.current;
+        const next = displayRows.length;
+        const grown = next - previous;
+        rowCountRef.current = next;
+        setScrollOffset((offset) => clampScrollOffset(next, viewport, offset > 0 && grown > 0 ? offset + grown : offset));
+    }, [displayRows.length, viewport]);
+    useEffect(() => {
+        if (skipWelcome)
+            return;
+        const timer = setTimeout(() => {
+            confirmArmedRef.current = true;
+        }, LAUNCH_ENTER_GUARD_MS);
+        return () => {
+            clearTimeout(timer);
+        };
+    }, [skipWelcome]);
+    useEffect(() => {
+        if (!skipWelcome)
+            return;
+        let cancelled = false;
+        setBusy(true);
+        bootstrapAiDialogue({ ...options, agent: options.agent, kind: 'chat' })
+            .then((bootstrap) => {
+            if (!cancelled)
+                applyDialogue(bootstrap.dialogue, options.agent);
+        })
+            .catch((error) => {
+            if (!cancelled)
+                setStatus(errorMessage(error));
+        })
+            .finally(() => {
+            if (!cancelled)
+                setBusy(false);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [skipWelcome]);
+    const dispatchRef = useRef(() => { });
+    dispatchRef.current = (key) => {
+        handleSessionAppKey(key, liveRef.current, {
+            abortTurn() {
+                abortRef.current?.abort();
+            },
+            applyComposer,
+            armWelcome() {
+                confirmArmedRef.current = true;
+            },
+            displayRowsLength: displayRows.length,
+            followupItems: lastFollowupItems(committed),
+            handleChatLine,
+            openSessionOverlay,
+            recall: recallRef.current,
+            resumeDialogue,
+            setOverlay,
+            setRecall(next) {
+                recallRef.current = next;
+            },
+            setScrollOffset,
+            setSessionFilter,
+            setSessionIndex,
+            setSlashDismissed,
+            setSlashIndex,
+            setWelcomeIndex,
+            startNew,
+            viewport,
+            welcomeArmed: confirmArmedRef.current,
+        });
+    };
+    const { setRawMode } = stdinApi;
+    const stdinEvents = stdinApi.internal_eventEmitter;
+    useLayoutEffect(() => {
+        setRawMode(true);
+        const assembler = new SessionInputAssembler();
+        let wait;
+        const onChunk = (chunk) => {
+            if (wait !== undefined) {
+                clearTimeout(wait);
+                wait = undefined;
+            }
+            const { keys, pending } = assembler.push(String(chunk));
+            for (const key of keys)
+                dispatchRef.current(key);
+            if (!pending)
+                return;
+            wait = setTimeout(() => {
+                wait = undefined;
+                for (const key of assembler.flush())
+                    dispatchRef.current(key);
+            }, 30);
+        };
+        stdinEvents.on('input', onChunk);
+        return () => {
+            if (wait !== undefined)
+                clearTimeout(wait);
+            stdinEvents.off('input', onChunk);
+            setRawMode(false);
+        };
+    }, [setRawMode, stdinEvents]);
+    return (_jsx(_Fragment, { children: _jsxs(Box, { flexDirection: "column", height: screen === 'welcome' ? frameHeight : undefined, children: [screen === 'welcome' && overlay !== 'session' ? (_jsx(Box, { flexDirection: "column", flexGrow: 1, children: _jsx(WelcomeScreen, { agent: agent, selectedIndex: welcomeIndex }) })) : null, screen === 'chat' ? (_jsx(ChatLivePane, { agent: agent, busy: busy, composerRows: composerRows, dialogueId: dialogue?.id ?? '…', elapsedSeconds: elapsedSeconds, height: chatRows, hint: hint, rows: visibleRows, selectedSlash: slashWindow.selectedInWindow, status: status, suggestions: slashWindow.window, viewport: viewport })) : null, overlay === 'session' ? (_jsxs(Box, { borderStyle: "single", flexDirection: "column", marginTop: 1, paddingX: 1, children: [_jsx(Text, { bold: true, children: "Sessions" }), _jsxs(Text, { dimColor: true, wrap: "truncate", children: ["Filter: ", sessionFilter.length > 0 ? sessionFilter : '(type to filter)'] }), filteredSessions.length === 0 ? _jsx(Text, { dimColor: true, children: "No AI sessions found." }) : null, filteredSessions.map((session, index) => (_jsxs(Text, { color: index === sessionIndex ? 'green' : undefined, wrap: "truncate", children: [index === sessionIndex ? '●' : ' ', " ", formatSessionOverlayLine(session)] }, session.id))), _jsx(Text, { dimColor: true, children: "Enter to open \u00B7 type to filter \u00B7 Esc or /cancel to dismiss" })] })) : null, overlay === 'help' ? (_jsxs(Box, { borderStyle: "single", flexDirection: "column", marginTop: 1, paddingX: 1, children: [_jsx(Text, { bold: true, children: "Help" }), sessionHelpLines().map((line) => (_jsx(Text, { children: line }, line))), _jsx(Text, { dimColor: true, children: "Esc or Enter to close" })] })) : null, overlay === 'confirm-new' ? (_jsxs(Box, { borderStyle: "single", flexDirection: "column", marginTop: 1, paddingX: 1, children: [_jsx(Text, { bold: true, children: "Start a new session?" }), _jsx(Text, { children: "This creates a new Context Hub dialogue. The current one stays in the list." }), _jsx(Text, { dimColor: true, children: "Enter confirm \u00B7 Esc cancel" })] })) : null, screen !== 'chat' && status.length > 0 ? _jsx(Text, { color: "yellow", children: status }) : null] }) }));
+}
+export async function runAiSessionTui(options) {
+    discardPendingStdinBytes(process.stdin);
+    let result = { dialogueId: '', turns: 0 };
+    const restoreStdout = installStdoutImageBridge(process.stdout, detectMermaidImageProtocol());
+    try {
+        const instance = render(_jsx(SessionApp, { onFinished: (value) => {
+                result = value;
+            }, options: options }), { exitOnCtrlC: true });
+        await instance.waitUntilExit();
+        return result;
+    }
+    finally {
+        restoreStdout();
+    }
+}
+//# sourceMappingURL=ai-session-tui.js.map