@thegitai/cli 1.0.0-preview.1 → 1.0.0-preview.11

package/dist/src/ui/tui/shell-input.js

@@ -9,6 +9,17 @@ function isClipboardImagePasteKey(key) {
     }
     return key.ctrl && key.input === 'v' && !key.shift && !key.meta;
 }
+function composerIsEmpty(state) {
+    return (!state.input &&
+        state.cursor === 0 &&
+        state.pastedChunks.length === 0 &&
+        state.promptHistoryCursor === null);
+}
+function composerHasDiscardableDraft(state) {
+    if (!composerIsEmpty(state))
+        return true;
+    return !state.busy && state.imageAttachments.length > 0;
+}
 function shouldShowCommandPalette(state) {
     if (state.busy ||
         state.exiting ||
@@ -132,11 +143,41 @@ export function handleShellKeyEvent(store, handlers, event) {
         return;
     const key = event;
     const state = store.getState();
+    const commandPaletteActive = shouldShowCommandPalette(state);
+    const commandSuggestions = commandPaletteActive
+        ? getSlashCommandSuggestions(state.input)
+        : [];
+    const prepareForComposerInputChange = (current, nextInput) => {
+        if (shouldRemountLiveFrameForComposerInputChange(current, nextInput)) {
+            handlers.onLiveFrameShapeChange();
+        }
+    };
     if (key.ctrl && key.input === 'c') {
         if (state.sudoPrompt) {
             handlers.onSudoPasswordInput({ kind: 'cancel' });
             return;
         }
+        if (state.queuedMessage) {
+            handlers.onLiveFrameShapeChange();
+            store.update((current) => ({ ...current, queuedMessage: null }));
+            return;
+        }
+        if (composerHasDiscardableDraft(state)) {
+            store.update((current) => {
+                prepareForComposerInputChange(current, '');
+                return {
+                    ...current,
+                    commandCursor: 0,
+                    cursor: 0,
+                    imageAttachments: current.busy ? current.imageAttachments : [],
+                    input: '',
+                    pastedChunks: [],
+                    promptHistoryCursor: null,
+                    promptHistoryDraft: '',
+                };
+            });
+            return;
+        }
         if (handlers.onCtrlC) {
             handlers.onCtrlC();
             return;
@@ -144,15 +185,6 @@ export function handleShellKeyEvent(store, handlers, event) {
         handlers.onRequestExit();
         return;
     }
-    const commandPaletteActive = shouldShowCommandPalette(state);
-    const commandSuggestions = commandPaletteActive
-        ? getSlashCommandSuggestions(state.input)
-        : [];
-    const prepareForComposerInputChange = (current, nextInput) => {
-        if (shouldRemountLiveFrameForComposerInputChange(current, nextInput)) {
-            handlers.onLiveFrameShapeChange();
-        }
-    };
     if (state.sudoPrompt) {
         if (key.escape) {
             handlers.onSudoPasswordInput({ kind: 'cancel' });
@@ -317,10 +349,7 @@ export function handleShellKeyEvent(store, handlers, event) {
             return;
         }
         store.update((current) => {
-            if (!current.input &&
-                current.cursor === 0 &&
-                current.pastedChunks.length === 0 &&
-                current.promptHistoryCursor === null) {
+            if (composerIsEmpty(current)) {
                 return current;
             }
             prepareForComposerInputChange(current, '');

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/dist/src/utils.js

@@ -17,6 +17,15 @@ export function truncate(text, maxChars = 4000) {
         return text;
     return `${text.slice(0, maxChars)}\n... (truncated)`;
 }
+export function singleLinePreview(text, maxChars) {
+    const collapsed = String(text ?? '')
+        .replace(/\n\.\.\. \(truncated\)\s*$/, '…')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (collapsed.length <= maxChars)
+        return collapsed;
+    return `${collapsed.slice(0, Math.max(0, maxChars - 1)).trimEnd()}…`;
+}
 export function clampInteger(value, fallback, max) {
     const numeric = Number(value);
     if (!Number.isFinite(numeric) || numeric <= 0) {

package/package.json

@@ -1,9 +1,21 @@
 {
   "name": "@thegitai/cli",
-  "version": "1.0.0-preview.1",
-  "description": "TheGitAI CLI client (source-visible, proprietary)",
+  "version": "1.0.0-preview.11",
+  "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",
+    "ai-coding-agent",
+    "coding-agent",
+    "coding-assistant",
+    "terminal",
+    "cli",
+    "developer-tools"
+  ],
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://thegit.ai",
+  "bugs": {
+    "email": "support@thegit.ai"
+  },
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -25,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.1",
-    "@thegitai/tui-darwin-x64": "1.0.0-preview.1",
-    "@thegitai/tui-linux-x64": "1.0.0-preview.1",
-    "@thegitai/tui-win32-x64": "1.0.0-preview.1",
+    "@thegitai/tui-darwin-arm64": "1.0.0-preview.11",
+    "@thegitai/tui-darwin-x64": "1.0.0-preview.11",
+    "@thegitai/tui-linux-x64": "1.0.0-preview.11",
+    "@thegitai/tui-win32-x64": "1.0.0-preview.11",
     "@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();
-}