@thegitai/cli 1.0.0-preview.4 → 1.0.0-preview.5

package/dist/src/api/chat.js

@@ -52,6 +52,7 @@ function parseSseBlock(block) {
         return { event, data: text };
     }
 }
+let toolStateSeqCounter = 0;
 function toolStateFromSession(session) {
     return {
         autoYes: session.autoYes,
@@ -185,6 +186,7 @@ async function postToolResult({ config, turnId, event, result, session, fetchImp
         toolCallId: event.call.id,
         result,
         toolState: toolStateFromSession(session),
+        toolStateSeq: ++toolStateSeqCounter,
     };
     const trace = createTraceContext(traceId);
     const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/chat/turn/${encodeURIComponent(turnId)}/tool-result`, {
@@ -203,6 +205,29 @@ async function postToolResult({ config, turnId, event, result, session, fetchImp
         throw await readErrorResponse(response, trace.traceId);
     }
 }
+const turnIdOverrides = new WeakMap();
+function enterServerTurnId(session, serverSessionTurnId) {
+    const active = turnIdOverrides.get(session);
+    if (active) {
+        active.depth += 1;
+        return;
+    }
+    turnIdOverrides.set(session, {
+        previousTurnId: session.turnState.id,
+        depth: 1,
+    });
+    session.turnState.id = serverSessionTurnId;
+}
+function exitServerTurnId(session) {
+    const active = turnIdOverrides.get(session);
+    if (!active)
+        return;
+    active.depth -= 1;
+    if (active.depth === 0) {
+        session.turnState.id = active.previousTurnId;
+        turnIdOverrides.delete(session);
+    }
+}
 async function executeAndPostToolResult({ config, projectIndex, session, event, input, fetchImpl, signal, traceId, }) {
     const turnId = String(event?.turnId ?? '').trim();
     if (!turnId || !event?.call?.id || !event.call.name) {
@@ -211,10 +236,9 @@ async function executeAndPostToolResult({ config, projectIndex, session, event,
     if (signal?.aborted) {
         throw new TurnCancelledError();
     }
-    const previousTurnId = session.turnState.id;
     const serverSessionTurnId = String(event.sessionTurnId ?? '').trim();
     if (serverSessionTurnId) {
-        session.turnState.id = serverSessionTurnId;
+        enterServerTurnId(session, serverSessionTurnId);
         if (!session.clientState.safety.checkpoints.some((checkpoint) => checkpoint.turnId === serverSessionTurnId)) {
             createPromptCheckpoint(session.clientState.safety, 'prompt boundary', serverSessionTurnId);
         }
@@ -237,7 +261,9 @@ async function executeAndPostToolResult({ config, projectIndex, session, event,
         });
     }
     finally {
-        session.turnState.id = previousTurnId;
+        if (serverSessionTurnId) {
+            exitServerTurnId(session);
+        }
     }
 }
 async function consumeTurnStream({ response, config, projectIndex, session, input, fetchImpl, signal, traceId, }) {
@@ -250,6 +276,31 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
     const finalResult = {
         current: null,
     };
+    const pendingParallelTools = [];
+    let firstParallelFailure = null;
+    let rejectOnParallelFailure = null;
+    const parallelToolFailure = new Promise((_, reject) => {
+        rejectOnParallelFailure = reject;
+    });
+    parallelToolFailure.catch(() => { });
+    function recordParallelFailure(error) {
+        const failure = error ?? new Error('Local tool execution failed.');
+        if (firstParallelFailure == null) {
+            firstParallelFailure = failure;
+            rejectOnParallelFailure?.(failure);
+        }
+        return failure;
+    }
+    async function drainParallelTools() {
+        if (!pendingParallelTools.length)
+            return;
+        const pending = pendingParallelTools.splice(0);
+        const outcomes = await Promise.all(pending);
+        for (const outcome of outcomes) {
+            if (outcome != null)
+                throw outcome;
+        }
+    }
     async function handleEvent(event) {
         if (event.event === 'status') {
             const message = publicStatusMessage(event.data);
@@ -261,11 +312,26 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
             return;
         }
         if (event.event === 'tool-call') {
+            const data = event.data;
+            if (data?.parallelSafe === true) {
+                pendingParallelTools.push(executeAndPostToolResult({
+                    config,
+                    projectIndex,
+                    session,
+                    event: data,
+                    input,
+                    fetchImpl,
+                    signal,
+                    traceId,
+                }).then(() => null, (error) => recordParallelFailure(error)));
+                return;
+            }
+            await drainParallelTools();
             await executeAndPostToolResult({
                 config,
                 projectIndex,
                 session,
-                event: event.data,
+                event: data,
                 input,
                 fetchImpl,
                 signal,
@@ -281,10 +347,12 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
             return;
         }
         if (event.event === 'result') {
+            await drainParallelTools();
             finalResult.current = event.data;
             return;
         }
         if (event.event === 'cancelled' || event.event === 'error') {
+            await drainParallelTools().catch(() => { });
             const message = String(event.data?.message ?? 'Server chat failed.');
             if (event.event === 'cancelled') {
                 throw new TurnCancelledError(message);
@@ -292,24 +360,34 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
             throw new ChatTurnFailedError(message, typeof event.data?.category === 'string' ? event.data.category : 'unknown_error', Boolean(event.data?.retryable), typeof event.data?.traceId === 'string' ? event.data.traceId : traceId);
         }
     }
-    while (true) {
-        if (signal?.aborted) {
-            await reader.cancel().catch(() => { });
-            throw new TurnCancelledError();
-        }
-        const read = await reader.read();
-        if (read.done)
-            break;
-        buffer += decoder.decode(read.value, { stream: true });
-        let separatorIndex = buffer.indexOf('\n\n');
-        while (separatorIndex !== -1) {
-            const block = buffer.slice(0, separatorIndex);
-            buffer = buffer.slice(separatorIndex + 2);
-            const event = parseSseBlock(block);
-            if (event)
-                await handleEvent(event);
-            separatorIndex = buffer.indexOf('\n\n');
+    try {
+        while (true) {
+            if (signal?.aborted) {
+                await reader.cancel().catch(() => { });
+                throw new TurnCancelledError();
+            }
+            const read = await Promise.race([reader.read(), parallelToolFailure]);
+            if (read.done)
+                break;
+            buffer += decoder.decode(read.value, { stream: true });
+            let separatorIndex = buffer.indexOf('\n\n');
+            while (separatorIndex !== -1) {
+                const block = buffer.slice(0, separatorIndex);
+                buffer = buffer.slice(separatorIndex + 2);
+                const event = parseSseBlock(block);
+                if (event)
+                    await handleEvent(event);
+                separatorIndex = buffer.indexOf('\n\n');
+            }
         }
+        await drainParallelTools();
+    }
+    catch (error) {
+        await reader.cancel().catch(() => { });
+        throw error;
+    }
+    finally {
+        await drainParallelTools().catch(() => { });
     }
     buffer += decoder.decode();
     const tail = buffer.trim();

package/dist/src/project-index.js

@@ -39,10 +39,21 @@ function removeFile(index, relPath) {
     index.chunksByFile.delete(relPath);
     index.fileSignatures.delete(relPath);
 }
+function countIndexedChunks(index) {
+    return Array.from(index.chunksByFile.values()).reduce((sum, chunks) => sum + chunks.length, 0);
+}
 async function initializeIndex(index) {
     if (index.initialized) {
-        return Array.from(index.chunksByFile.values()).reduce((sum, chunks) => sum + chunks.length, 0);
+        return countIndexedChunks(index);
+    }
+    if (!index._initializing) {
+        index._initializing = scanProjectIntoIndex(index).finally(() => {
+            index._initializing = null;
+        });
     }
+    return index._initializing;
+}
+async function scanProjectIntoIndex(index) {
     const files = listProjectFiles(index.rootDir);
     const chunks = await scanFiles(index.rootDir, files);
     index.fileSignatures.clear();
@@ -106,6 +117,7 @@ export function createIndex({ rootDir, onStatus = null, onContextLog = null, })
     return {
         rootDir: path.resolve(rootDir),
         initialized: false,
+        _initializing: null,
         fileSignatures: new Map(),
         chunksByFile: new Map(),
         onStatus,

package/dist/src/ui/repl.js

@@ -1,6 +1,7 @@
 import { createRatatuiBridge } from './tui/bridge.js';
 import { buildTuiFrame, formatJobElapsed, formatTodoProgress, renderTranscriptEntryLines, } from './tui/build-frame.js';
 import { createTerminalTitleController } from './tui/terminal-title.js';
+import { captureTerminalWrites, releaseTerminalWrites, } from './tui/terminal-writes.js';
 export { getSlashCommandSuggestions } from './tui/build-frame.js';
 import { agentModeLabel, nextAgentMode, } from '../agent-mode.js';
 import { chat, models } from '../api/index.js';
@@ -1303,6 +1304,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
         let cleanupSudoPasswordPrompt = null;
         let sudoPasswordBuffer = '';
         const bridge = createRatatuiBridge();
+        captureTerminalWrites();
         const { handleShellKeyEvent } = await import('./tui/shell-input.js');
         let terminalCols = 80;
         let terminalRows = 24;
@@ -1347,7 +1349,9 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 store.update((current) => current.status === status ? { ...current, status: 'Ready' } : current);
             }, 2500);
         };
-        const terminalTitle = createTerminalTitleController();
+        const terminalTitle = createTerminalTitleController({
+            write: (title) => bridge.setTitle(title),
+        });
         const syncTerminalTitle = () => {
             const state = store.getState();
             terminalTitle.sync({
@@ -1653,6 +1657,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 status: 'Exiting...',
             }));
             void bridge.close().then(() => {
+                releaseTerminalWrites();
                 resolveDone?.();
             });
         };
@@ -2231,6 +2236,8 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             activeTurnAbort = turnAbort;
             lastTurnStartedAt = turnStartedAt;
             todosTouchedThisTurn = false;
+            clearTodos();
+            syncTodosState();
             const userEntry = {
                 body: input,
                 kind: 'user',
@@ -2570,6 +2577,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             setTodoSession(null);
             setBackgroundJobUpdateHook(null);
             await bridge.close();
+            releaseTerminalWrites();
             setCommandOutputHook(null);
         }
     });

package/dist/src/ui/tui/bridge.js

@@ -155,6 +155,9 @@ export function createRatatuiBridge() {
         clear() {
             writeParent({ op: 'clear' });
         },
+        setTitle(title) {
+            writeParent({ op: 'title', text: title });
+        },
         async close() {
             if (closed)
                 return;

package/dist/src/ui/tui/build-frame.js

@@ -2,7 +2,7 @@ import { agentModeLabel } from '../../agent-mode.js';
 import { truncate } from '../../utils.js';
 import { formatClientTokenUsage } from '../repl.js';
 import { renderFormattedBodyLines, renderPreformattedBodyLines, } from './markdown-render.js';
-import { line, plainLine, span, wrapText } from './text.js';
+import { displayWidth, line, plainLine, sliceToWidth, span, wrapText, } from './text.js';
 const WORKING_CLOCK_ICON = '◷';
 const BRAILLE_SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴'];
 const TODO_PANEL_MAX_ROWS = 12;
@@ -133,14 +133,14 @@ function diffLinePrefix(kind) {
             return ' ';
     }
 }
-function fitLine(content, maxWidth) {
+export function fitLine(content, maxWidth) {
     if (maxWidth <= 0)
         return '';
-    if (content.length <= maxWidth)
+    if (displayWidth(content) <= maxWidth)
         return content;
     if (maxWidth === 1)
         return '…';
-    return `${content.slice(0, maxWidth - 1)}…`;
+    return `${sliceToWidth(content, maxWidth - 1)}…`;
 }
 export function formatPromptDirectoryLabel(projectRoot, homeDir = process.env.HOME ?? '') {
     const trimmed = String(projectRoot ?? '').trim();
@@ -573,7 +573,7 @@ function buildLiveLines(state, width, spinnerFrame, elapsedSeconds) {
     return lines;
 }
 function lineCharCount(row) {
-    return row.spans.reduce((total, item) => total + [...item.text].length, 0);
+    return row.spans.reduce((total, item) => total + displayWidth(item.text), 0);
 }
 function overlayPanelLine(row, width, color) {
     const padding = Math.max(0, width - lineCharCount(row));

package/dist/src/ui/tui/markdown-render.js

@@ -1,6 +1,8 @@
-import { line, plainLine, span, wrapText } from './text.js';
-const TABLE_BORDER_WIDTH = 2;
-const TABLE_CELL_OVERHEAD_WIDTH = 3;
+import { displayWidth, line, padToWidth, plainLine, sliceToWidth, span, wrapText, wrapToWidth, } from './text.js';
+const MIN_TABLE_COLUMN_WIDTH = 3;
+function tableRowOverhead(columnCount) {
+    return 3 * columnCount + 1;
+}
 function parseInlineSegments(text) {
     const source = String(text ?? '');
     const segments = [];
@@ -110,45 +112,37 @@ function stripInlineFormattingForWidth(text) {
         .replace(/\*\*([^*]+)\*\*/g, '$1');
 }
 function fitTableColumnWidths(columnWidths, maxWidth) {
-    const widths = columnWidths.map((width) => Math.max(3, Math.floor(width)));
-    if (widths.length === 0)
-        return widths;
-    const overhead = TABLE_BORDER_WIDTH + widths.length * TABLE_CELL_OVERHEAD_WIDTH;
-    const budget = Math.max(widths.length * 3, maxWidth - overhead);
-    const total = widths.reduce((sum, width) => sum + width, 0);
-    if (total <= budget)
-        return widths;
-    let remaining = budget;
-    const scaled = widths.map((width) => {
-        const next = Math.max(3, Math.floor((width / total) * budget));
-        remaining -= next;
-        return next;
-    });
-    while (remaining > 0) {
-        let targetIndex = 0;
-        for (let index = 1; index < widths.length; index++) {
-            if (widths[index] - scaled[index] > widths[targetIndex] - scaled[targetIndex]) {
-                targetIndex = index;
-            }
-        }
-        scaled[targetIndex]++;
-        remaining--;
+    const columnCount = columnWidths.length;
+    if (columnCount === 0)
+        return [];
+    const natural = columnWidths.map((width) => Math.max(1, Math.floor(width)));
+    const budget = Math.floor(maxWidth) - tableRowOverhead(columnCount);
+    const total = natural.reduce((sum, width) => sum + width, 0);
+    if (budget >= total)
+        return natural;
+    const floorWidth = Math.max(1, Math.min(MIN_TABLE_COLUMN_WIDTH, Math.floor(budget / columnCount)));
+    const widths = natural.map((width) => Math.min(width, floorWidth));
+    let used = widths.reduce((sum, width) => sum + width, 0);
+    if (used > budget) {
+        const share = Math.max(1, Math.floor(budget / columnCount));
+        for (let index = 0; index < columnCount; index++)
+            widths[index] = share;
+        used = share * columnCount;
     }
-    while (remaining < 0) {
-        let targetIndex = -1;
-        for (let index = 0; index < scaled.length; index++) {
-            if (scaled[index] <= 3)
+    let remaining = budget - used;
+    while (remaining > 0) {
+        let grew = false;
+        for (let index = 0; index < columnCount && remaining > 0; index++) {
+            if (widths[index] >= natural[index])
                 continue;
-            if (targetIndex === -1 || scaled[index] > scaled[targetIndex]) {
-                targetIndex = index;
-            }
+            widths[index]++;
+            remaining--;
+            grew = true;
         }
-        if (targetIndex === -1)
+        if (!grew)
             break;
-        scaled[targetIndex]--;
-        remaining++;
     }
-    return scaled;
+    return widths;
 }
 function normalizeMarkdownTableCells(cells, columnCount) {
     return Array.from({ length: columnCount }, (_, index) => cells[index] ?? '');
@@ -176,7 +170,7 @@ function parseMarkdownTableBlock(lines, startIndex) {
     const normalizedHeaders = normalizeMarkdownTableCells(headers, columnCount);
     const columnWidths = normalizedHeaders.map((header, columnIndex) => {
         const values = [header, ...rows.map((row) => row[columnIndex] ?? '')];
-        return Math.max(3, ...values.map((value) => stripInlineFormattingForWidth(value).length));
+        return Math.max(MIN_TABLE_COLUMN_WIDTH, ...values.map((value) => displayWidth(stripInlineFormattingForWidth(value))));
     });
     return {
         nextIndex,
@@ -280,24 +274,33 @@ function wrapInlineToLines(text, width, bodyColor, prefix = '') {
         rowWidth = 0;
     };
     const appendSpan = (part) => {
-        const current = rows[rows.length - 1];
-        const limit = safeWidth - (indent ? prefix.length : 0);
+        let current = rows[rows.length - 1];
+        const limit = safeWidth - (rows.length === 1 && indent ? displayWidth(prefix) : 0);
         let remaining = part.text;
         while (remaining.length > 0) {
             const room = limit - rowWidth;
             if (room <= 0) {
                 startRow();
+                current = rows[rows.length - 1];
                 continue;
             }
-            if (remaining.length <= room) {
+            const width = displayWidth(remaining);
+            if (width <= room) {
                 current.push(span(remaining, styleFromSpan(part)));
-                rowWidth += remaining.length;
+                rowWidth += width;
                 remaining = '';
                 break;
             }
-            current.push(span(remaining.slice(0, room), styleFromSpan(part)));
-            remaining = remaining.slice(room);
+            const head = sliceToWidth(remaining, room);
+            if (displayWidth(head) > room && current.length > 0) {
+                startRow();
+                current = rows[rows.length - 1];
+                continue;
+            }
+            current.push(span(head, styleFromSpan(part)));
+            remaining = remaining.slice(head.length);
             startRow();
+            current = rows[rows.length - 1];
         }
     };
     for (const segment of segments) {
@@ -316,36 +319,35 @@ function wrapInlineToLines(text, width, bodyColor, prefix = '') {
         return line(...bodySpans);
     });
 }
-function padCell(text, width) {
-    const plain = stripInlineFormattingForWidth(text);
-    if (plain.length >= width)
-        return plain.slice(0, width);
-    return plain + ' '.repeat(width - plain.length);
-}
 function renderTableLines(table, width) {
     const columnWidths = fitTableColumnWidths(table.columnWidths, width);
+    const border = (left, joint, right) => line(span(left +
+        columnWidths.map((colWidth) => '─'.repeat(colWidth + 2)).join(joint) +
+        right, { color: 'cyan', dim: true }));
     const renderRow = (cells, bold) => {
-        const parts = columnWidths.map((colWidth, index) => span(` ${padCell(cells[index] ?? '', colWidth)} `, {
-            color: 'cyan',
-            bold,
-        }));
-        return line(span('│', { color: 'cyan' }), ...parts, span('│', { color: 'cyan' }));
+        const wrapped = columnWidths.map((colWidth, index) => wrapToWidth(stripInlineFormattingForWidth(cells[index] ?? ''), colWidth));
+        const height = Math.max(1, ...wrapped.map((cellLines) => cellLines.length));
+        const rows = [];
+        for (let row = 0; row < height; row++) {
+            const spans = [span('│', { color: 'cyan' })];
+            for (let column = 0; column < columnWidths.length; column++) {
+                const text = wrapped[column]?.[row] ?? '';
+                spans.push(span(` ${padToWidth(text, columnWidths[column])} `, {
+                    color: 'cyan',
+                    bold,
+                }));
+                spans.push(span('│', { color: 'cyan' }));
+            }
+            rows.push(line(...spans));
+        }
+        return rows;
     };
-    const separator = line(span('├' +
-        columnWidths.map((colWidth) => '─'.repeat(colWidth + 2)).join('┼') +
-        '┤', { color: 'cyan', dim: true }));
-    const top = line(span('┌' +
-        columnWidths.map((colWidth) => '─'.repeat(colWidth + 2)).join('┬') +
-        '┐', { color: 'cyan', dim: true }));
-    const bottom = line(span('└' +
-        columnWidths.map((colWidth) => '─'.repeat(colWidth + 2)).join('┴') +
-        '┘', { color: 'cyan', dim: true }));
     return [
-        top,
-        renderRow(table.headers, true),
-        separator,
-        ...table.rows.map((row) => renderRow(row, false)),
-        bottom,
+        border('┌', '┬', '┐'),
+        ...renderRow(table.headers, true),
+        border('├', '┼', '┤'),
+        ...table.rows.flatMap((row) => renderRow(row, false)),
+        border('└', '┴', '┘'),
     ];
 }
 function getEntryColor(kind) {
@@ -410,10 +412,7 @@ export function renderFormattedBodyLines(body, width, kind) {
         }
         if (formattedLine.kind === 'table' && formattedLine.table) {
             output.push(...renderTableLines(formattedLine.table, bodyWidth).map((tableLine) => {
-                const spans = tableLine.spans.map((part) => ({
-                    ...part,
-                    text: `  ${part.text}`,
-                }));
+                const spans = tableLine.spans.map((part, index) => index === 0 ? { ...part, text: `  ${part.text}` } : part);
                 return { spans };
             }));
             continue;

package/dist/src/ui/tui/terminal-title.js

@@ -1,3 +1,4 @@
+import { isTuiMode } from '../../runtime-mode.js';
 const BRAILLE_SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴'];
 const TITLE_BRAND = 'TheGitAI';
 const TITLE_MARK_PREFIX = '❯_';
@@ -19,6 +20,8 @@ export function formatTerminalTitle(state, spinnerFrame = 0) {
     return `${TITLE_MARK_PREFIX}● ${TITLE_BRAND}`;
 }
 export function writeTerminalTitle(title, stream = process.stdout) {
+    if (isTuiMode())
+        return;
     if (!('isTTY' in stream) || !stream.isTTY)
         return;
     stream.write(`\x1b]0;${title}\x07`);

package/dist/src/ui/tui/terminal-writes.js

@@ -0,0 +1,48 @@
+const MAX_CAPTURED_CHARS = 1_000_000;
+let restore = null;
+let captured = [];
+let capturedChars = 0;
+function chunkToString(chunk, encoding) {
+    if (typeof chunk === 'string')
+        return chunk;
+    if (chunk instanceof Uint8Array) {
+        return Buffer.from(chunk).toString(typeof encoding === 'string' ? encoding : 'utf8');
+    }
+    return String(chunk ?? '');
+}
+export function captureTerminalWrites() {
+    if (restore)
+        return;
+    const streams = [process.stdout, process.stderr];
+    const originals = streams.map((stream) => stream.write.bind(stream));
+    for (const stream of streams) {
+        stream.write = (chunk, encoding, callback) => {
+            if (capturedChars < MAX_CAPTURED_CHARS) {
+                const text = chunkToString(chunk, encoding);
+                captured.push(text);
+                capturedChars += text.length;
+            }
+            const done = typeof encoding === 'function' ? encoding : callback;
+            if (typeof done === 'function')
+                done();
+            return true;
+        };
+    }
+    restore = () => {
+        streams.forEach((stream, index) => {
+            stream.write = originals[index];
+        });
+    };
+}
+export function releaseTerminalWrites() {
+    if (!restore)
+        return;
+    restore();
+    restore = null;
+    if (captured.length > 0) {
+        const text = captured.join('');
+        captured = [];
+        capturedChars = 0;
+        process.stderr.write(text);
+    }
+}

package/dist/src/ui/tui/text.js

@@ -1,5 +1,14 @@
+const CSI_PATTERN = /\u001B\[[0-9;?]*[ -\/]*[@-~]/g;
+const OSC_PATTERN = /\u001B\][^\u0007\u001B]*(?:\u0007|\u001B\\)?/g;
+const CONTROL_CHAR_PATTERN = /[\u0000-\u0008\u000B-\u001F\u007F]/g;
+export function stripControlCharacters(text) {
+    return String(text ?? '')
+        .replace(OSC_PATTERN, '')
+        .replace(CSI_PATTERN, '')
+        .replace(CONTROL_CHAR_PATTERN, '');
+}
 export function span(text, style = {}) {
-    return { text, ...style };
+    return { text: stripControlCharacters(text), ...style };
 }
 export function line(...spans) {
     return { spans };
@@ -14,10 +23,11 @@ export function wrapText(text, width) {
     const lines = [];
     for (const rawLine of text.split('\n')) {
         let remaining = rawLine;
-        while (remaining.length > safeWidth) {
-            let breakAt = remaining.lastIndexOf(' ', safeWidth);
+        while (displayWidth(remaining) > safeWidth) {
+            const head = sliceToWidth(remaining, safeWidth);
+            let breakAt = head.lastIndexOf(' ');
             if (breakAt <= 0)
-                breakAt = safeWidth;
+                breakAt = head.length;
             lines.push(remaining.slice(0, breakAt).trimEnd());
             remaining = remaining.slice(breakAt).trimStart();
         }
@@ -28,3 +38,147 @@ export function wrapText(text, width) {
 export function joinLines(blocks) {
     return blocks.flat();
 }
+function isZeroWidthCodePoint(codePoint) {
+    return (codePoint === 0x200d ||
+        (codePoint >= 0x0300 && codePoint <= 0x036f) ||
+        (codePoint >= 0x1ab0 && codePoint <= 0x1aff) ||
+        (codePoint >= 0x1dc0 && codePoint <= 0x1dff) ||
+        (codePoint >= 0x20d0 && codePoint <= 0x20ff) ||
+        (codePoint >= 0xfe00 && codePoint <= 0xfe0f) ||
+        (codePoint >= 0xfe20 && codePoint <= 0xfe2f));
+}
+function isWideCodePoint(codePoint) {
+    return ((codePoint >= 0x1100 && codePoint <= 0x115f) ||
+        codePoint === 0x231a ||
+        codePoint === 0x231b ||
+        (codePoint >= 0x23e9 && codePoint <= 0x23ec) ||
+        codePoint === 0x23f0 ||
+        codePoint === 0x23f3 ||
+        (codePoint >= 0x25fd && codePoint <= 0x25fe) ||
+        (codePoint >= 0x2614 && codePoint <= 0x2615) ||
+        (codePoint >= 0x2648 && codePoint <= 0x2653) ||
+        codePoint === 0x267f ||
+        codePoint === 0x2693 ||
+        codePoint === 0x26a1 ||
+        (codePoint >= 0x26aa && codePoint <= 0x26ab) ||
+        (codePoint >= 0x26bd && codePoint <= 0x26be) ||
+        (codePoint >= 0x26c4 && codePoint <= 0x26c5) ||
+        codePoint === 0x26ce ||
+        codePoint === 0x26d4 ||
+        codePoint === 0x26ea ||
+        (codePoint >= 0x26f2 && codePoint <= 0x26f3) ||
+        codePoint === 0x26f5 ||
+        codePoint === 0x26fa ||
+        codePoint === 0x26fd ||
+        codePoint === 0x2705 ||
+        (codePoint >= 0x270a && codePoint <= 0x270b) ||
+        codePoint === 0x2728 ||
+        codePoint === 0x274c ||
+        codePoint === 0x274e ||
+        (codePoint >= 0x2753 && codePoint <= 0x2755) ||
+        codePoint === 0x2757 ||
+        (codePoint >= 0x2795 && codePoint <= 0x2797) ||
+        codePoint === 0x27b0 ||
+        codePoint === 0x27bf ||
+        (codePoint >= 0x2b1b && codePoint <= 0x2b1c) ||
+        codePoint === 0x2b50 ||
+        codePoint === 0x2b55 ||
+        (codePoint >= 0x2e80 && codePoint <= 0x303e) ||
+        (codePoint >= 0x3041 && codePoint <= 0x33ff) ||
+        (codePoint >= 0x3400 && codePoint <= 0x4dbf) ||
+        (codePoint >= 0x4e00 && codePoint <= 0x9fff) ||
+        (codePoint >= 0xa000 && codePoint <= 0xa4cf) ||
+        (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+        (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+        (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+        (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+        (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+        (codePoint >= 0x1f300 && codePoint <= 0x1f64f) ||
+        (codePoint >= 0x1f680 && codePoint <= 0x1f6ff) ||
+        (codePoint >= 0x1f900 && codePoint <= 0x1f9ff) ||
+        (codePoint >= 0x1fa70 && codePoint <= 0x1faff) ||
+        (codePoint >= 0x20000 && codePoint <= 0x3fffd));
+}
+export function displayWidth(text) {
+    const chars = [...String(text ?? '')];
+    let width = 0;
+    for (let index = 0; index < chars.length; index++) {
+        const codePoint = chars[index].codePointAt(0);
+        if (isZeroWidthCodePoint(codePoint))
+            continue;
+        const next = chars[index + 1]?.codePointAt(0);
+        if (next === 0xfe0f) {
+            width += 2;
+            index++;
+            continue;
+        }
+        if (next === 0xfe0e) {
+            width += 1;
+            index++;
+            continue;
+        }
+        width += isWideCodePoint(codePoint) ? 2 : 1;
+    }
+    return width;
+}
+export function sliceToWidth(text, width) {
+    const limit = Math.max(1, Math.floor(width));
+    const chars = [...String(text ?? '')];
+    let out = '';
+    let used = 0;
+    for (let index = 0; index < chars.length; index++) {
+        const char = chars[index];
+        const next = chars[index + 1];
+        const selector = next === '️' || next === '︎';
+        const cluster = selector ? `${char}${next}` : char;
+        const clusterWidth = displayWidth(cluster);
+        if (used + clusterWidth > limit)
+            break;
+        out += cluster;
+        used += clusterWidth;
+        if (selector)
+            index++;
+    }
+    if (!out)
+        return chars[0] ?? '';
+    return out;
+}
+export function padToWidth(text, width) {
+    const current = displayWidth(text);
+    if (current >= width)
+        return text;
+    return text + ' '.repeat(width - current);
+}
+export function wrapToWidth(text, width) {
+    const limit = Math.max(1, Math.floor(width));
+    const out = [];
+    for (const rawLine of String(text ?? '').split('\n')) {
+        let current = '';
+        const flush = () => {
+            out.push(current);
+            current = '';
+        };
+        for (const token of rawLine.split(/\s+/).filter(Boolean)) {
+            let rest = token;
+            while (displayWidth(rest) > limit) {
+                if (current)
+                    flush();
+                const head = sliceToWidth(rest, limit);
+                out.push(head);
+                rest = rest.slice(head.length);
+            }
+            if (!rest)
+                continue;
+            const candidate = current ? `${current} ${rest}` : rest;
+            if (displayWidth(candidate) > limit) {
+                flush();
+                current = rest;
+            }
+            else {
+                current = candidate;
+            }
+        }
+        flush();
+    }
+    return out.length > 0 ? out : [''];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thegitai/cli",
-  "version": "1.0.0-preview.4",
+  "version": "1.0.0-preview.5",
   "description": "TheGitAI is an AI coding agent for your terminal. It indexes your repository, writes and edits files, runs commands, and builds features with you.",
   "keywords": [
     "ai",
@@ -37,10 +37,10 @@
     "@lydell/node-pty-linux-x64": "1.1.0",
     "@lydell/node-pty-win32-arm64": "1.1.0",
     "@lydell/node-pty-win32-x64": "1.1.0",
-    "@thegitai/tui-darwin-arm64": "1.0.0-preview.4",
-    "@thegitai/tui-darwin-x64": "1.0.0-preview.4",
-    "@thegitai/tui-linux-x64": "1.0.0-preview.4",
-    "@thegitai/tui-win32-x64": "1.0.0-preview.4",
+    "@thegitai/tui-darwin-arm64": "1.0.0-preview.5",
+    "@thegitai/tui-darwin-x64": "1.0.0-preview.5",
+    "@thegitai/tui-linux-x64": "1.0.0-preview.5",
+    "@thegitai/tui-win32-x64": "1.0.0-preview.5",
     "@vscode/ripgrep": "1.18.0"
   },
   "publishConfig": {

package/dist/src/markdown-renderer.js

@@ -1,112 +0,0 @@
-import chalk from './colors.js';
-function renderInline(text) {
-    const parts = String(text ?? '').split(/(`[^`]+`)/g);
-    return parts
-        .map((part) => part.startsWith('`') && part.endsWith('`') && part.length > 1
-        ? chalk.cyan(part.slice(1, -1))
-        : part)
-        .join('');
-}
-function isTableSeparator(line) {
-    const cells = splitTableRow(line);
-    return (cells.length > 1 &&
-        cells.every((cell) => /^:?-{3,}:?$/.test(cell.trim())));
-}
-function splitTableRow(line) {
-    const trimmed = String(line ?? '').trim();
-    if (!trimmed.includes('|'))
-        return [];
-    return trimmed
-        .replace(/^\|/, '')
-        .replace(/\|$/, '')
-        .split('|')
-        .map((cell) => cell.trim());
-}
-function tableWidth(text) {
-    return text.replace(/\x1b\[[0-9;]*m/g, '').length;
-}
-function padCell(text, width) {
-    return `${text}${' '.repeat(Math.max(0, width - tableWidth(text)))}`;
-}
-function renderTable(rows) {
-    if (rows.length < 2 || !isTableSeparator(rows[1].join('|')))
-        return [];
-    const headers = rows[0];
-    const body = rows.slice(2).filter((row) => row.length > 0);
-    const columnCount = Math.max(headers.length, ...body.map((row) => row.length));
-    const normalizedRows = [headers, ...body].map((row) => Array.from({ length: columnCount }, (_, index) => renderInline(row[index] ?? '')));
-    const widths = Array.from({ length: columnCount }, (_, index) => Math.max(...normalizedRows.map((row) => tableWidth(row[index] ?? '')), 3));
-    const border = `+${widths.map((width) => '-'.repeat(width + 2)).join('+')}+`;
-    const renderRow = (row) => `| ${row.map((cell, index) => padCell(cell, widths[index])).join(' | ')} |`;
-    return [
-        border,
-        renderRow(normalizedRows[0].map((cell) => chalk.bold(cell))),
-        border,
-        ...normalizedRows.slice(1).map(renderRow),
-        border,
-    ];
-}
-function readTableBlock(lines, startIndex) {
-    if (startIndex + 1 >= lines.length)
-        return null;
-    const header = splitTableRow(lines[startIndex]);
-    const separator = splitTableRow(lines[startIndex + 1]);
-    if (header.length < 2 || separator.length < 2 || !isTableSeparator(lines[startIndex + 1])) {
-        return null;
-    }
-    const rows = [header, separator];
-    let index = startIndex + 2;
-    while (index < lines.length) {
-        const row = splitTableRow(lines[index]);
-        if (row.length < 2)
-            break;
-        rows.push(row);
-        index += 1;
-    }
-    const rendered = renderTable(rows);
-    return rendered.length ? { rendered, nextIndex: index } : null;
-}
-export function renderMarkdownForTerminal(markdown) {
-    const lines = String(markdown ?? '').replace(/\r\n?/g, '\n').split('\n');
-    const output = [];
-    let inCodeBlock = false;
-    for (let index = 0; index < lines.length; index++) {
-        const line = lines[index];
-        if (/^\s*```/.test(line)) {
-            inCodeBlock = !inCodeBlock;
-            continue;
-        }
-        if (inCodeBlock) {
-            output.push(chalk.dim(`  ${line}`));
-            continue;
-        }
-        const table = readTableBlock(lines, index);
-        if (table) {
-            output.push(...table.rendered);
-            index = table.nextIndex - 1;
-            continue;
-        }
-        const heading = line.match(/^\s{0,3}#{1,6}\s+(.+)$/);
-        if (heading) {
-            output.push(chalk.bold(renderInline(heading[1].trim())));
-            continue;
-        }
-        const bullet = line.match(/^(\s*)[-*]\s+(.+)$/);
-        if (bullet) {
-            output.push(`${bullet[1]}- ${renderInline(bullet[2].trim())}`);
-            continue;
-        }
-        const numbered = line.match(/^(\s*)\d+[.)]\s+(.+)$/);
-        if (numbered) {
-            output.push(`${numbered[1]}- ${renderInline(numbered[2].trim())}`);
-            continue;
-        }
-        const quote = line.match(/^\s*>\s?(.+)$/);
-        if (quote) {
-            output.push(chalk.dim(`> ${renderInline(quote[1].trim())}`));
-            continue;
-        }
-        output.push(renderInline(line));
-    }
-    return output.join('\n').trimEnd();
-}