@thegitai/cli 1.0.0-beta.1

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

@@ -0,0 +1,488 @@
+import { readClipboardImage, readClipboardText } from '../../core/clipboard.js';
+import { applySlashCommandSuggestion, buildModelPickerOptions, deleteAtCursor, deleteBeforeCursor, getApprovalChoiceForCursor, getInputCommandToken, getNextApprovalCursor, getNextModelPickerIndex, getSlashCommandSuggestions, insertAtCursor, isExactSlashCommandToken, navigatePromptHistory, resolveApprovalChoiceFromInput, shouldRemountLiveFrameForComposerInputChange, } from '../repl.js';
+import { buildPastePlaceholder, shouldCollapsePaste, } from '../paste-collapse.js';
+function shouldShowCommandPalette(state) {
+    if (state.busy ||
+        state.exiting ||
+        state.modelPickerOpen ||
+        state.resumePickerOpen) {
+        return false;
+    }
+    const token = getInputCommandToken(state.input);
+    return token.startsWith('/') && !token.includes(' ');
+}
+function insertPastedText(store, handlers, text) {
+    const current = store.getState();
+    if (current.exiting || !text)
+        return;
+    if (shouldCollapsePaste(text)) {
+        store.update((state) => {
+            const id = state.pastedChunks.length + 1;
+            const placeholder = buildPastePlaceholder(text, id);
+            const chunk = { placeholder, text };
+            const nextInput = insertAtCursor(state, placeholder);
+            if (shouldRemountLiveFrameForComposerInputChange(state, nextInput.input)) {
+                handlers.onLiveFrameShapeChange();
+            }
+            return {
+                ...state,
+                commandCursor: 0,
+                pastedChunks: [...state.pastedChunks, chunk],
+                ...nextInput,
+            };
+        });
+        return;
+    }
+    store.update((state) => {
+        const nextInput = insertAtCursor(state, text);
+        if (shouldRemountLiveFrameForComposerInputChange(state, nextInput.input)) {
+            handlers.onLiveFrameShapeChange();
+        }
+        return {
+            ...state,
+            commandCursor: 0,
+            ...nextInput,
+        };
+    });
+}
+function pasteTextFromClipboard(store, handlers) {
+    const current = store.getState();
+    if (current.exiting ||
+        current.approvalPrompt ||
+        current.modelPickerOpen ||
+        current.resumePickerOpen ||
+        current.sudoPrompt) {
+        return;
+    }
+    const text = (handlers.readClipboardText ?? readClipboardText)();
+    if (!text) {
+        store.update((state) => ({
+            ...state,
+            status: 'Clipboard has no text to paste',
+        }));
+        return;
+    }
+    insertPastedText(store, handlers, text);
+}
+function filterResumeSessionsLocal(sessions, filter, serverModels) {
+    const q = filter.trim().toLowerCase();
+    if (!q)
+        return sessions;
+    return sessions.filter((session) => {
+        const branch = (session.branch ?? '').toLowerCase();
+        const model = serverModels.find((entry) => entry.id === session.modelId)?.label.toLowerCase() ??
+            '';
+        const conv = session.lastUserMessage.toLowerCase();
+        return branch.includes(q) || model.includes(q) || conv.includes(q);
+    });
+}
+export function handleShellKeyEvent(store, handlers, event) {
+    if (event.kind === 'paste') {
+        insertPastedText(store, handlers, event.text);
+        return;
+    }
+    if (event.kind === 'selectionCopy') {
+        if (event.text.trim()) {
+            void handlers.onSelectionCopy?.(event.text);
+        }
+        return;
+    }
+    if (event.kind === 'linkCopy') {
+        if (event.url.trim()) {
+            void handlers.onLinkCopy?.(event.url);
+        }
+        return;
+    }
+    if (event.kind === 'linkOpen') {
+        if (event.url.trim()) {
+            void handlers.onLinkOpen?.(event.url);
+        }
+        return;
+    }
+    if (event.kind === 'contextMenu') {
+        pasteTextFromClipboard(store, handlers);
+        return;
+    }
+    if (event.kind === 'transcriptScroll') {
+        const delta = Math.trunc(event.deltaLines);
+        if (delta !== 0) {
+            store.update((current) => {
+                const limit = handlers.getTranscriptScrollLimit?.() ??
+                    current.transcript.reduce((total, entry) => total + 2 + (entry.body ? entry.body.split('\n').length : 0), 0);
+                const next = current.transcriptScrollOffset + delta;
+                return {
+                    ...current,
+                    transcriptScrollOffset: Math.max(0, Math.min(next, limit)),
+                };
+            });
+        }
+        return;
+    }
+    if (event.kind !== 'key')
+        return;
+    const key = event;
+    const state = store.getState();
+    if (key.ctrl && key.input === 'c') {
+        if (state.sudoPrompt) {
+            handlers.onSudoPasswordInput({ kind: 'cancel' });
+            return;
+        }
+        if (handlers.onCtrlC) {
+            handlers.onCtrlC();
+            return;
+        }
+        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' });
+            return;
+        }
+        if (key.returnKey) {
+            handlers.onSudoPasswordInput({ kind: 'submit' });
+            return;
+        }
+        if (key.backspace || key.delete) {
+            handlers.onSudoPasswordInput({ kind: 'backspace' });
+            return;
+        }
+        if (!key.ctrl &&
+            !key.meta &&
+            key.input &&
+            key.input.length === 1 &&
+            key.input >= ' ') {
+            handlers.onSudoPasswordInput({ kind: 'char', char: key.input });
+        }
+        return;
+    }
+    if (state.approvalPrompt) {
+        const directChoice = resolveApprovalChoiceFromInput(key.input);
+        if (directChoice) {
+            void handlers.onResolveApproval(directChoice);
+            return;
+        }
+        if (key.escape) {
+            void handlers.onResolveApproval('n');
+            return;
+        }
+        if (key.upArrow || key.downArrow) {
+            store.update((current) => ({
+                ...current,
+                approvalCursor: getNextApprovalCursor(current.approvalCursor, key.upArrow ? -1 : 1),
+            }));
+            return;
+        }
+        if (key.returnKey) {
+            void handlers.onResolveApproval(getApprovalChoiceForCursor(state.approvalCursor));
+        }
+        return;
+    }
+    if (state.exiting) {
+        return;
+    }
+    if (key.pageUp || key.pageDown) {
+        store.update((current) => {
+            const transcriptLines = handlers.getTranscriptScrollLimit?.() ??
+                current.transcript.reduce((total, entry) => total + 2 + (entry.body ? entry.body.split('\n').length : 0), 0);
+            const next = current.transcriptScrollOffset + (key.pageUp ? 8 : -8);
+            return {
+                ...current,
+                transcriptScrollOffset: Math.max(0, Math.min(next, transcriptLines)),
+            };
+        });
+        return;
+    }
+    if (state.modelPickerOpen) {
+        if (key.escape) {
+            store.update((current) => ({ ...current, modelPickerOpen: false }));
+            return;
+        }
+        if (key.upArrow || key.downArrow) {
+            store.update((current) => {
+                const options = buildModelPickerOptions(Number(current.currentModelId ?? 0), current.serverModels ?? []);
+                return {
+                    ...current,
+                    modelPickerIndex: getNextModelPickerIndex(options, current.modelPickerIndex, key.upArrow ? -1 : 1),
+                };
+            });
+            return;
+        }
+        if (key.returnKey) {
+            void handlers.onSelectModel();
+        }
+        return;
+    }
+    if (state.resumePickerOpen) {
+        if (key.escape) {
+            store.update((current) => ({
+                ...current,
+                resumePickerFilter: '',
+                resumePickerIndex: 0,
+                resumePickerOpen: false,
+                status: 'Ready',
+            }));
+            return;
+        }
+        if (key.upArrow || key.downArrow) {
+            store.update((current) => {
+                const count = filterResumeSessionsLocal(current.resumePickerSessions, current.resumePickerFilter, current.serverModels ?? []).length;
+                const next = current.resumePickerIndex + (key.upArrow ? -1 : 1);
+                return {
+                    ...current,
+                    resumePickerIndex: Math.max(0, Math.min(next, count - 1)),
+                };
+            });
+            return;
+        }
+        if (key.returnKey) {
+            void handlers.onResumeSession();
+            return;
+        }
+        if (key.backspace || key.delete) {
+            store.update((current) => ({
+                ...current,
+                resumePickerFilter: current.resumePickerFilter.slice(0, -1),
+                resumePickerIndex: 0,
+            }));
+            return;
+        }
+        if (!key.ctrl && !key.meta && key.input && key.input.length === 1 && key.input >= ' ') {
+            store.update((current) => ({
+                ...current,
+                resumePickerFilter: current.resumePickerFilter + key.input,
+                resumePickerIndex: 0,
+            }));
+        }
+        return;
+    }
+    if (key.escape) {
+        if (state.busy) {
+            // With a queued message, Esc clears the queue only (turn keeps running).
+            // With nothing queued, Esc cancels the turn (Ctrl+C also cancels).
+            if (state.queuedMessage) {
+                handlers.onLiveFrameShapeChange();
+                store.update((current) => ({ ...current, queuedMessage: null }));
+                return;
+            }
+            handlers.onCancelTurn();
+            return;
+        }
+        store.update((current) => {
+            if (!current.input &&
+                current.cursor === 0 &&
+                current.pastedChunks.length === 0 &&
+                current.promptHistoryCursor === null) {
+                return current;
+            }
+            prepareForComposerInputChange(current, '');
+            return {
+                ...current,
+                commandCursor: 0,
+                cursor: 0,
+                input: '',
+                pastedChunks: [],
+                promptHistoryCursor: null,
+                promptHistoryDraft: '',
+            };
+        });
+        return;
+    }
+    if (key.tab && key.shift) {
+        handlers.onCycleAgentMode();
+        return;
+    }
+    if (commandPaletteActive && (key.upArrow || key.downArrow)) {
+        store.update((current) => ({
+            ...current,
+            commandCursor: Math.min(Math.max(current.commandCursor + (key.upArrow ? -1 : 1), 0), Math.max(commandSuggestions.length - 1, 0)),
+        }));
+        return;
+    }
+    if (key.upArrow) {
+        // While busy with an empty composer, Up recalls and dequeues the queued
+        // message for editing; otherwise it walks prompt history as usual.
+        if (state.busy && state.input.trim() === '' && state.queuedMessage) {
+            handlers.onLiveFrameShapeChange();
+            store.update((current) => {
+                const queued = current.queuedMessage;
+                if (!queued)
+                    return current;
+                return {
+                    ...current,
+                    cursor: queued.body.length,
+                    imageAttachments: queued.imageAttachments,
+                    input: queued.body,
+                    pastedChunks: queued.pastedChunks,
+                    promptHistoryCursor: null,
+                    promptHistoryDraft: '',
+                    queuedMessage: null,
+                };
+            });
+            return;
+        }
+        if (state.busy)
+            return;
+        store.update((current) => {
+            const next = navigatePromptHistory(current, 'previous');
+            prepareForComposerInputChange(current, next.input);
+            return next;
+        });
+        return;
+    }
+    if (key.downArrow) {
+        if (state.busy)
+            return;
+        store.update((current) => {
+            const next = navigatePromptHistory(current, 'next');
+            prepareForComposerInputChange(current, next.input);
+            return next;
+        });
+        return;
+    }
+    if (commandPaletteActive && key.tab) {
+        const suggestion = commandSuggestions[Math.min(state.commandCursor, commandSuggestions.length - 1)];
+        if (!suggestion)
+            return;
+        store.update((current) => {
+            const nextInput = applySlashCommandSuggestion(current.input, suggestion);
+            prepareForComposerInputChange(current, nextInput.input);
+            return { ...current, commandCursor: 0, ...nextInput };
+        });
+        return;
+    }
+    if (key.returnKey) {
+        const token = getInputCommandToken(state.input);
+        if (commandPaletteActive && !isExactSlashCommandToken(token)) {
+            const suggestion = commandSuggestions[Math.min(state.commandCursor, commandSuggestions.length - 1)];
+            if (!suggestion)
+                return;
+            store.update((current) => {
+                const nextInput = applySlashCommandSuggestion(current.input, suggestion);
+                prepareForComposerInputChange(current, nextInput.input);
+                return { ...current, commandCursor: 0, ...nextInput };
+            });
+            return;
+        }
+        void handlers.onSubmit(state.input);
+        return;
+    }
+    if (key.leftArrow) {
+        store.update((current) => ({
+            ...current,
+            cursor: Math.max(current.cursor - 1, 0),
+        }));
+        return;
+    }
+    if (key.rightArrow) {
+        store.update((current) => ({
+            ...current,
+            cursor: Math.min(current.cursor + 1, current.input.length),
+        }));
+        return;
+    }
+    if (key.home) {
+        store.update((current) => ({ ...current, commandCursor: 0, cursor: 0 }));
+        return;
+    }
+    if (key.end) {
+        store.update((current) => ({
+            ...current,
+            commandCursor: 0,
+            cursor: current.input.length,
+        }));
+        return;
+    }
+    if (key.backspace) {
+        store.update((current) => {
+            const next = deleteBeforeCursor(current);
+            if (next)
+                prepareForComposerInputChange(current, next.input);
+            return next ? { ...current, commandCursor: 0, ...next } : current;
+        });
+        return;
+    }
+    if (key.delete) {
+        store.update((current) => {
+            const next = deleteAtCursor(current);
+            if (next)
+                prepareForComposerInputChange(current, next.input);
+            return next ? { ...current, commandCursor: 0, ...next } : current;
+        });
+        return;
+    }
+    if (key.tab) {
+        store.update((current) => {
+            const nextInput = insertAtCursor(current, '  ');
+            prepareForComposerInputChange(current, nextInput.input);
+            return { ...current, commandCursor: 0, ...nextInput };
+        });
+        return;
+    }
+    if (key.ctrl && key.input === 'v') {
+        const current = store.getState();
+        if (current.busy)
+            return;
+        const liveAttachments = current.imageAttachments.filter((attachment) => current.input.includes(`[Image #${attachment.index}]`));
+        if (liveAttachments.length >= 2) {
+            store.appendEntry({
+                body: 'Maximum of 2 images per message. Send the current message first.',
+                kind: 'error',
+                title: 'Image',
+            });
+            return;
+        }
+        try {
+            const clipResult = readClipboardImage();
+            const idx = liveAttachments.length === 0
+                ? 1
+                : Math.max(...liveAttachments.map((attachment) => attachment.index)) + 1;
+            store.update((shellState) => ({
+                ...shellState,
+                imageAttachments: [
+                    ...liveAttachments,
+                    {
+                        index: idx,
+                        mimeType: clipResult.mimeType,
+                        base64Data: clipResult.base64Data,
+                        source: 'clipboard',
+                    },
+                ],
+                ...insertAtCursor(shellState, `[Image #${idx}] `),
+            }));
+        }
+        catch (error) {
+            if (error?.code === 'NO_IMAGE') {
+                store.appendEntry({
+                    body: 'No image found on clipboard. Use Ctrl+Shift+V to paste text.',
+                    kind: 'error',
+                    title: 'Image',
+                });
+            }
+            else if (error?.code === 'NO_TOOL' || error?.code === 'READ_FAILED') {
+                store.appendEntry({
+                    body: error.message,
+                    kind: 'error',
+                    title: 'Image Error',
+                });
+            }
+        }
+        return;
+    }
+    if (!key.ctrl && !key.meta && key.input) {
+        store.update((current) => {
+            const nextInput = insertAtCursor(current, key.input);
+            prepareForComposerInputChange(current, nextInput.input);
+            return { ...current, commandCursor: 0, ...nextInput };
+        });
+    }
+}

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

@@ -0,0 +1,30 @@
+export function span(text, style = {}) {
+    return { text, ...style };
+}
+export function line(...spans) {
+    return { spans };
+}
+export function plainLine(text, style = {}) {
+    return line(span(text, style));
+}
+export function wrapText(text, width) {
+    const safeWidth = Math.max(1, width);
+    if (!text)
+        return [''];
+    const lines = [];
+    for (const rawLine of text.split('\n')) {
+        let remaining = rawLine;
+        while (remaining.length > safeWidth) {
+            let breakAt = remaining.lastIndexOf(' ', safeWidth);
+            if (breakAt <= 0)
+                breakAt = safeWidth;
+            lines.push(remaining.slice(0, breakAt).trimEnd());
+            remaining = remaining.slice(breakAt).trimStart();
+        }
+        lines.push(remaining);
+    }
+    return lines;
+}
+export function joinLines(blocks) {
+    return blocks.flat();
+}

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

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

package/dist/src/usage.js

@@ -0,0 +1,47 @@
+const USAGE_WINDOWS = [
+    ['5-hour', '5-hourly'],
+    ['Weekly', 'weekly'],
+    ['Monthly', 'monthly'],
+];
+function formatUtcMinute(value) {
+    if (!value)
+        return 'no active usage';
+    const date = new Date(value);
+    if (!Number.isFinite(date.getTime()))
+        return 'unknown';
+    const pad = (part) => String(part).padStart(2, '0');
+    return [
+        date.getUTCFullYear(),
+        '-',
+        pad(date.getUTCMonth() + 1),
+        '-',
+        pad(date.getUTCDate()),
+        ' ',
+        pad(date.getUTCHours()),
+        ':',
+        pad(date.getUTCMinutes()),
+        ' UTC',
+    ].join('');
+}
+function formatPercentLeft(value) {
+    const percent = Number.isFinite(value)
+        ? Math.max(0, Math.min(100, value))
+        : 0;
+    return `${new Intl.NumberFormat('en-US', {
+        maximumFractionDigits: 1,
+    }).format(percent)}% left`;
+}
+export function formatUsageText(response) {
+    const { customer, usage } = response;
+    const lines = [`Usage for ${customer.email}`, ''];
+    if (!usage) {
+        lines.push('Usage is not available for this account yet.');
+        return lines.join('\n');
+    }
+    lines.push('Window     Left        Resets');
+    for (const [label, key] of USAGE_WINDOWS) {
+        const value = formatPercentLeft(Number(usage.percentLeft[key] ?? 0));
+        lines.push(`${label.padEnd(10)} ${value.padEnd(11)} ${formatUtcMinute(usage.resetsAt[key])}`);
+    }
+    return lines.join('\n');
+}

package/dist/src/utils.js

@@ -0,0 +1,38 @@
+export function cosineSimilarity(a, b) {
+    let dot = 0;
+    let magA = 0;
+    let magB = 0;
+    for (let i = 0; i < a.length; i++) {
+        const valA = a[i] ?? 0;
+        const valB = b[i] ?? 0;
+        dot += valA * valB;
+        magA += valA * valA;
+        magB += valB * valB;
+    }
+    const denom = Math.sqrt(magA) * Math.sqrt(magB);
+    return denom === 0 ? 0 : dot / denom;
+}
+export function truncate(text, maxChars = 4000) {
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, maxChars)}\n... (truncated)`;
+}
+export function clampInteger(value, fallback, max) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric <= 0) {
+        return fallback;
+    }
+    return Math.min(Math.floor(numeric), max);
+}
+export function readFileRange(content, startLine, endLine) {
+    const lines = content.split('\n');
+    const safeStart = startLine ? Math.max(1, startLine) : 1;
+    const safeEnd = endLine ? Math.max(safeStart, endLine) : lines.length;
+    const selected = lines.slice(safeStart - 1, safeEnd);
+    return {
+        totalLines: lines.length,
+        startLine: safeStart,
+        endLine: safeStart + selected.length - 1,
+        content: selected.join('\n'),
+    };
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@thegitai/cli",
+  "version": "1.0.0-beta.1",
+  "description": "TheGitAI CLI client (source-visible, proprietary)",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://thegit.ai",
+  "type": "module",
+  "engines": {
+    "node": ">=24.14.1 <25"
+  },
+  "bin": {
+    "ai": "./dist/bin/ai.js"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@homebridge/node-pty-prebuilt-multiarch": "^0.13.1",
+    "@mozilla/readability": "0.6.0",
+    "@vscode/ripgrep": "1.17.1",
+    "@vscode/tree-sitter-wasm": "^0.3.0",
+    "chalk": "^5.4.1",
+    "glob": "^11.0.1",
+    "jsdom": "29.1.1",
+    "web-tree-sitter": "^0.26.6"
+  },
+  "optionalDependencies": {
+    "@thegitai/tui-darwin-arm64": "1.0.0-beta.1",
+    "@thegitai/tui-darwin-x64": "1.0.0-beta.1",
+    "@thegitai/tui-linux-x64": "1.0.0-beta.1",
+    "@thegitai/tui-win32-x64": "1.0.0-beta.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}