@thegitai/cli 1.0.0-preview.42 → 1.0.0-preview.44

package/README.md

@@ -14,6 +14,15 @@ npm i -g @thegitai/cli
 
 Supports Node.js 22 and newer. Node.js 24 is recommended.
 
+## Updates
+
+`ai` checks for a newer release each time it starts, and offers to install it
+for you. TheGitAI serves the current release only, so an older CLI can fail
+partway through a session. Press Enter to update — the CLI installs it and asks
+you to start `ai` again, so the whole session runs one version — or choose
+**Skip** to go on with the version you have. Skipping lasts for that session
+only; the next start asks again. Ctrl+C quits without installing anything.
+
 ## Usage
 
 ```text

package/dist/bin/ai.js

@@ -13,7 +13,8 @@ import { startBrowserDiscoveryInBackground } from '../src/browser/session-bridge
 import { appendPromptToFile } from '../src/ui/prompt-history-store.js';
 import { formatSessionExitNotice } from '../src/session-exit.js';
 import { formatUsageText } from '../src/usage.js';
-import { formatVersionLine } from '../src/version.js';
+import { getCliVersion, formatVersionLine } from '../src/version.js';
+import { offerUpdateAtStartup } from '../src/update-check.js';
 import { parseArgs } from '../src/cli-args.js';
 const { auth, chat, models, sessions } = ServerApi;
 function printUsage() {
@@ -220,6 +221,17 @@ export async function main() {
     if (offlineNotice) {
         console.error(chalk.yellow(`⚠ Couldn't reach TheGitAI (${offlineNotice}). Starting with cached settings — it will reconnect on your next message.`));
     }
+    const updateOutcome = await offerUpdateAtStartup({
+        currentVersion: getCliVersion(),
+        latestVersion: whoami.release?.latestVersion ?? null,
+    });
+    if (updateOutcome === 'updated') {
+        return;
+    }
+    if (updateOutcome === 'cancelled') {
+        process.exitCode = 130;
+        return;
+    }
     const selectedModelId = models.selectServerModel({
         requestedModelId: sourceSnapshot?.modelId ?? null,
         cached: cachedModels,

package/dist/src/api/auth.js

@@ -61,11 +61,15 @@ export async function fetchWhoamiResponse({ config, fetchImpl = globalThis.fetch
     if (!data?.customer?.email) {
         throw new Error('Server returned an invalid whoami response.');
     }
+    const latestVersion = data.release?.latestVersion;
     return {
         customer: data.customer,
         debugUi: {
             showSessionId: data.debugUi?.showSessionId === true,
         },
+        ...(typeof latestVersion === 'string' && latestVersion
+            ? { release: { latestVersion } }
+            : {}),
         ...(data.usage ? { usage: data.usage } : {}),
     };
 }

package/dist/src/api/browser-login.js

@@ -6,6 +6,7 @@ import os from 'node:os';
 import { openUrl } from '../core/open-url.js';
 import { ServerApiError, createTraceContext, failureCode, failureMessage, normalizeServerUrl, readJsonResponse, } from './http.js';
 import { DEFAULT_THEGITAI_HOST } from './default-host.js';
+import { isAbortError } from '../utils.js';
 const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
 function shutDownServer(server) {
     server.closeAllConnections?.();
@@ -20,10 +21,6 @@ export class SignInCancelledError extends Error {
 export function isSignInCancelled(error) {
     return error instanceof SignInCancelledError;
 }
-function isAbortError(error) {
-    const err = error;
-    return err?.name === 'AbortError' || err?.code === 'ABORT_ERR';
-}
 export function resolveWebsiteUrl() {
     return DEFAULT_THEGITAI_HOST.replace(/\/+$/, '');
 }

package/dist/src/help-text.js

@@ -43,6 +43,19 @@ const HELP_MARKDOWN = [
     '- Sessions are stored locally and can be listed or resumed in the same repo.',
     '  Continuing one requires the TheGitAI account used for that session.',
     '',
+    '## Updates',
+    '',
+    '- On start, `ai` says when a newer release is published and offers to install',
+    '  it. TheGitAI serves the current release only, so an older CLI can fail',
+    '  partway through a session, in ways the transcript cannot explain.',
+    '- Enter takes the update; the CLI installs it and asks you to start `ai`',
+    '  again, so the whole session runs one version.',
+    '- Skipping starts the session on the version you have and asks again next',
+    '  time. A release cannot be silenced for good — that is what keeps a broken',
+    '  combination from lasting.',
+    '- **Ctrl+C** at the prompt quits without installing anything and without',
+    '  starting the session.',
+    '',
     '## Options',
     '',
     '- `-y, --yes` — start in Bypass all permissions mode',
@@ -77,6 +90,11 @@ const HELP_MARKDOWN = [
     '  back for editing and **Esc**/**Ctrl+C** discards it; both unlock the',
     '  composer for the next message. **Ctrl+V** pastes a screenshot onto the',
     '  queued message, and it is delivered into the running turn with the text.',
+    '- **Ctrl+G** turns desktop notifications on or off. One is raised when a turn',
+    '  ends and when a permission prompt or a question is waiting for you, but',
+    '  only while the terminal is in the background — if you are looking at the',
+    '  session you are told nothing. Coming back clears it. The choice is',
+    '  remembered between sessions.',
     `- **Paste** into the composer with your terminal's paste shortcut (\`${PASTE_SHORTCUT}\``,
     '  on this system) or by right-clicking the composer.',
     '- **Copy** from the transcript by dragging to select; double-click copies a',
@@ -101,6 +119,7 @@ const HELP_MARKDOWN = [
     '  is working; press it again or Esc to close without touching the turn',
     '- `/jobs output <id>` — print one job\'s full captured output',
     '- `/jobs kill <id>` — stop one background job',
+    '- `/notify` — turn desktop notifications on or off (same as Ctrl+G)',
     '- `/new` — start a new conversation; this session remains saved',
     '- `/logout` — sign out and quit',
     '- `/exit` — quit the session',

package/dist/src/preferences.js

@@ -0,0 +1,39 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { getClientStateDir } from './client-state.js';
+export const DEFAULT_PREFERENCES = {
+    notifications: true,
+};
+export function getPreferencesPath(env = process.env) {
+    return path.join(getClientStateDir(env), 'prefs.json');
+}
+export function readPreferences(env = process.env) {
+    const filePath = getPreferencesPath(env);
+    if (!existsSync(filePath))
+        return { ...DEFAULT_PREFERENCES };
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+        return {
+            notifications: parsed.notifications === false ? false : DEFAULT_PREFERENCES.notifications,
+        };
+    }
+    catch {
+        return { ...DEFAULT_PREFERENCES };
+    }
+}
+export function writePreferences(preferences, env = process.env) {
+    const filePath = getPreferencesPath(env);
+    mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    try {
+        writeFileSync(tempPath, `${JSON.stringify(preferences, null, 2)}\n`, {
+            encoding: 'utf8',
+            mode: 0o600,
+        });
+        renameSync(tempPath, filePath);
+    }
+    catch (error) {
+        rmSync(tempPath, { force: true });
+        throw error;
+    }
+}

package/dist/src/ui/repl.js

@@ -1,6 +1,10 @@
+import { basename } from 'node:path';
 import { createRatatuiBridge } from './tui/bridge.js';
 import { bucketActionLabel, } from '../permissions.js';
 import { AGENT_MODE_LOCKED_STATUS, approvalScrollLimit, buildTuiFrame, formatJobElapsed, formatTodoProgress, pickThinkingFallbackPhrase, renderTranscriptEntryLines, THINKING_FALLBACK_PHRASES, userInputViewportForFrame, } from './tui/build-frame.js';
+import { createAttentionController, INITIAL_TERMINAL_FOCUS, } from './tui/attention.js';
+import { backendFor, createNotificationQueue, } from './tui/desktop-notification.js';
+import { readPreferences, writePreferences } from '../preferences.js';
 import { createTerminalTitleController } from './tui/terminal-title.js';
 import { captureTerminalWrites, releaseTerminalWrites, } from './tui/terminal-writes.js';
 export { getSlashCommandSuggestions } from './tui/build-frame.js';
@@ -135,6 +139,10 @@ export const SLASH_COMMANDS = [
         command: '/jobs',
         description: 'Background jobs: pick to view output or kill',
     },
+    {
+        command: '/notify',
+        description: 'Toggle desktop notifications when a turn ends (Ctrl+G)',
+    },
     {
         command: '/new',
         description: 'start a new conversation; this session remains saved',
@@ -1100,6 +1108,8 @@ function createInitialShellState(session, serverModels, debugUi) {
         exiting: false,
         input: '',
         maxToolSteps: session.maxToolSteps,
+        notificationsEnabled: readPreferences(session.env).notifications,
+        terminalFocused: INITIAL_TERMINAL_FOCUS,
         jobsPickerExpandedId: null,
         jobsPickerIndex: 0,
         jobsPickerOpen: false,
@@ -1557,11 +1567,42 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 busy: state.busy,
             });
         };
+        const notifier = backendFor();
+        let notificationHandle = null;
+        const projectLabel = basename(session.rootDir) || 'TheGitAI';
+        const notifications = createNotificationQueue();
+        const attention = createAttentionController({
+            notify: (kind) => {
+                notifications.run(async () => {
+                    notificationHandle = await notifier.post({
+                        title: projectLabel,
+                        body: kind === 'blocked'
+                            ? 'Waiting for your answer'
+                            : 'Finished \u2014 your turn',
+                    }, notificationHandle);
+                });
+            },
+            withdraw: () => {
+                notifications.run(async () => {
+                    notifier.withdraw(notificationHandle);
+                    notificationHandle = null;
+                });
+            },
+        });
+        const syncAttention = () => {
+            const state = store.getState();
+            attention.sync({
+                awaitingAnswer: Boolean(state.approvalPrompt || state.sudoPrompt || state.userInputPrompt),
+                busy: state.busy,
+                focused: state.terminalFocused,
+            }, state.notificationsEnabled);
+        };
         const renderCurrentFrame = () => {
             if (!tuiReady)
                 return;
             const state = store.getState();
             syncTerminalTitle();
+            syncAttention();
             const elapsedSeconds = busyElapsedSeconds(state, Date.now());
             bridge.render(buildTuiFrame(state, terminalCols, terminalRows, spinnerFrame, elapsedSeconds, Date.now()));
         };
@@ -2107,6 +2148,16 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 title: 'Model',
             });
         };
+        const toggleNotifications = () => {
+            const enabled = !store.getState().notificationsEnabled;
+            store.update((current) => ({ ...current, notificationsEnabled: enabled }));
+            try {
+                writePreferences({ ...readPreferences(session.env), notifications: enabled }, session.env);
+            }
+            catch {
+            }
+            showTransientStatus(enabled ? 'Notifications on' : 'Notifications off');
+        };
         const openJobsPicker = () => {
             if (store.getState().jobsPickerOpen)
                 return;
@@ -2513,8 +2564,19 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                         openJobsPicker();
                         return;
                     }
+                    if (input === '/notify') {
+                        store.update((current) => ({
+                            ...current,
+                            cursor: 0,
+                            input: '',
+                            pastedChunks: [],
+                        }));
+                        toggleNotifications();
+                        return;
+                    }
                     appendTurnAwareEntry({
-                        body: "Slash commands can't be queued while a turn is running. Ctrl+B opens background jobs.",
+                        body: "Slash commands can't be queued while a turn is running. " +
+                            'Ctrl+B opens background jobs, Ctrl+G toggles notifications.',
                         kind: 'system',
                         title: 'Queued',
                     });
@@ -2599,6 +2661,10 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 appendStaticEntries(buildReportTranscriptEntries(opened));
                 return;
             }
+            if (input === '/notify') {
+                toggleNotifications();
+                return;
+            }
             if (input === '/jobs' || input.startsWith('/jobs ')) {
                 const jobsArgs = input.slice('/jobs'.length).trim();
                 if (!jobsArgs) {
@@ -3124,6 +3190,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             onSelectionCopy: handleAppSelectionCopy,
             onSelectModel: handleInlineModelSelection,
             onOpenJobsPicker: openJobsPicker,
+            onToggleNotifications: toggleNotifications,
             onJobsPickerOutput: handleJobsPickerOutput,
             onJobsPickerKill: handleJobsPickerKill,
             onSudoPasswordInput: handleSudoPasswordInput,
@@ -3167,6 +3234,13 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 return;
             }
             if (message.op === 'event') {
+                if (message.kind === 'focus') {
+                    store.update((current) => current.terminalFocused === message.focused
+                        ? current
+                        : { ...current, terminalFocused: message.focused });
+                    renderCurrentFrame();
+                    return;
+                }
                 if (message.kind === 'resize') {
                     terminalCols = message.cols;
                     terminalRows = message.rows;

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

@@ -0,0 +1,25 @@
+export const INITIAL_TERMINAL_FOCUS = true;
+export function createAttentionController(options) {
+    let previous = null;
+    let outstanding = false;
+    return {
+        sync(state, enabled) {
+            const last = previous;
+            previous = { ...state };
+            if (last && !last.focused && state.focused && outstanding) {
+                outstanding = false;
+                options.withdraw();
+            }
+            if (!last || !enabled)
+                return;
+            if (state.focused)
+                return;
+            const turnFinished = last.busy && !state.busy;
+            const nowBlocked = !last.awaitingAnswer && state.awaitingAnswer;
+            if (nowBlocked || turnFinished) {
+                outstanding = true;
+                options.notify(nowBlocked ? 'blocked' : 'finished');
+            }
+        },
+    };
+}

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

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
-import { existsSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -51,6 +51,9 @@ function normalizeChildMessage(raw) {
             url: String(raw.url ?? ''),
         };
     }
+    if (raw.kind === 'focus') {
+        return { op: 'event', kind: 'focus', focused: raw.focused === true };
+    }
     if (raw.kind === 'contextMenu') {
         return { op: 'event', kind: 'contextMenu' };
     }
@@ -95,13 +98,18 @@ function normalizeChildMessage(raw) {
         pageDown: bool(raw.pageDown ?? raw.page_down),
     };
 }
+function isRepoCheckout(moduleDir) {
+    return [
+        path.join(moduleDir, '../../../../thegitai-tui/Cargo.toml'),
+        path.join(moduleDir, '../../../../../thegitai-tui/Cargo.toml'),
+    ].some((candidate) => existsSync(candidate));
+}
 export function resolveTuiBinaryPath() {
     const binaryName = process.platform === 'win32' ? 'thegitai-tui.exe' : 'thegitai-tui';
     const platformPackage = `@thegitai/tui-${process.platform}-${process.arch}`;
-    try {
-        return requireFromHere.resolve(`${platformPackage}/${binaryName}`);
-    }
-    catch {
+    const override = String(process.env.THEGITAI_TUI_BINARY ?? '').trim();
+    if (override && existsSync(override)) {
+        return override;
     }
     const moduleDir = path.dirname(fileURLToPath(import.meta.url));
     const devCandidates = [
@@ -109,6 +117,24 @@ export function resolveTuiBinaryPath() {
         path.join(moduleDir, '../../../../bin', binaryName),
     ];
     const devBinary = devCandidates.find((candidate) => existsSync(candidate));
+    let publishedBinary = null;
+    try {
+        publishedBinary = requireFromHere.resolve(`${platformPackage}/${binaryName}`);
+    }
+    catch {
+    }
+    if (publishedBinary && devBinary && isRepoCheckout(moduleDir)) {
+        try {
+            if (statSync(devBinary).mtimeMs > statSync(publishedBinary).mtimeMs) {
+                return devBinary;
+            }
+        }
+        catch {
+        }
+    }
+    if (publishedBinary) {
+        return publishedBinary;
+    }
     if (devBinary) {
         return devBinary;
     }

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

@@ -32,6 +32,16 @@ const COMPOSER_INPUT_MAX_ROWS = 6;
 const FOOTER_HINT_MIN_GAP = 2;
 const FOOTER_HELP_HINT = '? for shortcuts';
 const FOOTER_CANCEL_HINT = 'esc cancels turn';
+const FOOTER_NOTIFICATIONS_ON = 'Notifications ON';
+const FOOTER_NOTIFICATIONS_OFF = 'Notifications OFF';
+export function footerNotificationHint(status) {
+    const text = String(status ?? '').trim();
+    if (text === 'Notifications on')
+        return FOOTER_NOTIFICATIONS_ON;
+    if (text === 'Notifications off')
+        return FOOTER_NOTIFICATIONS_OFF;
+    return '';
+}
 const FOOTER_CYCLE_HINT = ' (shift+tab to cycle)';
 const OVERLAY_PANEL_MAX_WIDTH = 86;
 const OVERLAY_PANEL_MARGIN_LINES = 2;
@@ -180,10 +190,12 @@ export function formatPromptSessionIdLabel(showSessionId, sessionId) {
 }
 const CLIENT_SLASH_COMMANDS = [
     { command: '/help', description: 'Show available chat commands' },
+    { command: '/about', description: 'Show version and platform info' },
     { command: '/usage', description: 'Show account usage percentage and reset times' },
     { command: '/model', description: 'Switch the active model' },
     { command: '/resume', description: 'Open the session picker to resume a previous session' },
     { command: '/jobs', description: 'Background jobs: pick to view output or kill' },
+    { command: '/notify', description: 'Toggle desktop notifications when a turn ends (Ctrl+G)' },
     { command: '/report', description: 'Report a bug privately on the TheGitAI website' },
     { command: '/new', description: 'start a new conversation; this session remains saved' },
     { command: '/logout', description: 'Sign out and quit' },
@@ -491,7 +503,15 @@ function composerFooterRightHints(state) {
         ? FOOTER_CANCEL_HINT
         : '';
     const helpHint = shortcutsPanelAvailable(state) ? FOOTER_HELP_HINT : '';
+    const notifyHint = footerNotificationHint(state.transientStatus);
+    const join = (...parts) => parts.filter(Boolean).join('  ·  ');
     const tiers = [];
+    if (notifyHint) {
+        tiers.push(join(cancelHint, notifyHint, helpHint));
+        tiers.push(join(notifyHint, helpHint));
+        tiers.push(join(cancelHint, notifyHint));
+        tiers.push(notifyHint);
+    }
     if (cancelHint && helpHint)
         tiers.push(`${cancelHint}  ·  ${helpHint}`);
     if (cancelHint)
@@ -499,7 +519,7 @@ function composerFooterRightHints(state) {
     if (helpHint)
         tiers.push(helpHint);
     tiers.push('');
-    return tiers;
+    return tiers.filter((tier, index) => tiers.indexOf(tier) === index);
 }
 export function fitComposerFooterRow({ modeLabels, modeLabelFallback, cycleHint, rightHints, leadWidth, tailWidth, contentWidth, }) {
     const candidates = rightHints.flatMap((rightHint) => (cycleHint ? [cycleHint, ''] : ['']).flatMap((cycle) => modeLabels.map((modeLabel) => ({ modeLabel, cycleHint: cycle, rightHint }))));

package/dist/src/ui/tui/desktop-notification.js

@@ -0,0 +1,118 @@
+import { spawn } from 'node:child_process';
+function run(command, args, { capture = false } = {}) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(command, args, {
+                stdio: ['ignore', capture ? 'pipe' : 'ignore', 'ignore'],
+            });
+        }
+        catch {
+            resolve('');
+            return;
+        }
+        let out = '';
+        child.stdout?.on('data', (chunk) => {
+            out += chunk.toString('utf8');
+        });
+        child.on('error', () => resolve(''));
+        child.on('close', () => resolve(out.trim()));
+    });
+}
+const linuxBackend = {
+    canWithdraw: true,
+    async post(request, previous) {
+        const args = [
+            '--print-id',
+            '--app-name=TheGitAI',
+            '--icon=utilities-terminal',
+            '--urgency=normal',
+        ];
+        if (previous)
+            args.push(`--replace-id=${previous}`);
+        args.push(request.title, request.body);
+        const id = await run('notify-send', args, { capture: true });
+        return /^\d+$/.test(id) ? id : null;
+    },
+    withdraw(handle) {
+        if (!handle)
+            return;
+        void run('gdbus', [
+            'call',
+            '--session',
+            '--dest',
+            'org.freedesktop.Notifications',
+            '--object-path',
+            '/org/freedesktop/Notifications',
+            '--method',
+            'org.freedesktop.Notifications.CloseNotification',
+            handle,
+        ]);
+    },
+};
+function appleScriptString(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+const macBackend = {
+    canWithdraw: false,
+    async post(request) {
+        await run('osascript', [
+            '-e',
+            `display notification "${appleScriptString(request.body)}" with title "${appleScriptString(request.title)}"`,
+        ]);
+        return null;
+    },
+    withdraw() {
+    },
+};
+function powerShellString(value) {
+    return value.replace(/'/g, "''");
+}
+const WINDOWS_AUMID = 'TheGitAI';
+const WINDOWS_TAG = 'thegitai-attention';
+const WINDOWS_GROUP = 'thegitai';
+const windowsBackend = {
+    canWithdraw: true,
+    async post(request) {
+        const script = [
+            '[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType=WindowsRuntime] > $null',
+            '[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom, ContentType=WindowsRuntime] > $null',
+            '$t = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)',
+            '$n = $t.GetElementsByTagName("text")',
+            `$n.Item(0).AppendChild($t.CreateTextNode('${powerShellString(request.title)}')) > $null`,
+            `$n.Item(1).AppendChild($t.CreateTextNode('${powerShellString(request.body)}')) > $null`,
+            '$toast = [Windows.UI.Notifications.ToastNotification]::new($t)',
+            `$toast.Tag = '${WINDOWS_TAG}'`,
+            `$toast.Group = '${WINDOWS_GROUP}'`,
+            `[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('${WINDOWS_AUMID}').Show($toast)`,
+        ].join('; ');
+        await run('powershell', ['-NoProfile', '-NonInteractive', '-Command', script]);
+        return WINDOWS_TAG;
+    },
+    withdraw(handle) {
+        if (!handle)
+            return;
+        const script = [
+            '[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType=WindowsRuntime] > $null',
+            `[Windows.UI.Notifications.ToastNotificationManager]::History.Remove('${powerShellString(handle)}', '${WINDOWS_GROUP}', '${WINDOWS_AUMID}')`,
+        ].join('; ');
+        void run('powershell', ['-NoProfile', '-NonInteractive', '-Command', script]);
+    },
+};
+export function createNotificationQueue() {
+    let tail = Promise.resolve();
+    return {
+        idle: () => tail,
+        run(step) {
+            tail = tail.then(step).catch(() => {
+            });
+        },
+    };
+}
+export function backendFor(platform = process.platform) {
+    if (platform === 'darwin')
+        return macBackend;
+    if (platform === 'win32')
+        return windowsBackend;
+    return linuxBackend;
+}

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

@@ -429,6 +429,10 @@ export function handleShellKeyEvent(store, handlers, event) {
         }
         return;
     }
+    if (key.ctrl && key.input === 'g' && !key.meta && !key.shift) {
+        handlers.onToggleNotifications?.();
+        return;
+    }
     if (key.input === '?' && !key.ctrl && !key.meta && shortcutsPanelAvailable(state)) {
         handlers.onLiveFrameShapeChange();
         store.update((current) => ({ ...current, shortcutsOpen: true }));

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

@@ -26,6 +26,7 @@ export function buildShortcutGroups(platform = process.platform) {
                 { keys: '↑ / ↓', description: 'Earlier prompts' },
                 { keys: 'Esc', description: 'Clear the composer' },
                 { keys: 'Ctrl+C', description: 'Clear the composer, or quit when empty' },
+                { keys: 'Ctrl+G', description: 'Desktop notifications — toggle on or off' },
             ],
         },
         {

package/dist/src/update-check.js

@@ -0,0 +1,121 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { stdin as input, stdout as output } from 'node:process';
+import readline from 'node:readline/promises';
+import { fileURLToPath } from 'node:url';
+import chalk from './colors.js';
+import { isAbortError } from './utils.js';
+import { compareCliVersions, UNKNOWN_CLI_VERSION } from './version.js';
+const PACKAGE_NAME = '@thegitai/cli';
+export function resolveInstallCommand(version, moduleDir = path.dirname(fileURLToPath(import.meta.url))) {
+    const spec = `${PACKAGE_NAME}@${version}`;
+    const location = moduleDir.replace(/\\/g, '/').toLowerCase();
+    if (location.includes('/pnpm/global/')) {
+        return { program: 'pnpm', args: ['add', '-g', spec] };
+    }
+    if (location.includes('/.bun/install/global/')) {
+        return { program: 'bun', args: ['add', '-g', spec] };
+    }
+    return { program: 'npm', args: ['install', '-g', spec] };
+}
+export function buildUpdateOffer({ currentVersion, latestVersion, moduleDir, }) {
+    if (!latestVersion)
+        return null;
+    if (currentVersion === UNKNOWN_CLI_VERSION)
+        return null;
+    const ordering = compareCliVersions(currentVersion, latestVersion);
+    if (ordering === null || ordering >= 0)
+        return null;
+    const { program, args } = resolveInstallCommand(latestVersion, moduleDir);
+    return {
+        currentVersion,
+        latestVersion,
+        program,
+        args,
+        display: [program, ...args].join(' '),
+    };
+}
+export function formatUpdateScreen(offer) {
+    return [
+        '',
+        `  ${chalk.yellow('✨ Update available')} — ${chalk.dim(offer.currentVersion)} → ${chalk.bold(offer.latestVersion)}`,
+        '',
+        '  TheGitAI supports the current release only. On an older CLI a session',
+        '  can fail partway through, in ways this terminal cannot explain.',
+        '',
+        `  ${chalk.cyan('1.')} Update now ${chalk.dim(`(runs \`${offer.display}\`)`)}`,
+        `  ${chalk.cyan('2.')} Skip ${chalk.dim('(Agent may not work optimally)')}`,
+        '',
+        `  ${chalk.dim('Press Enter to update, or 2 to skip.')}`,
+        '',
+    ].join('\n');
+}
+export function readUpdateChoice(answer) {
+    const value = answer.trim().toLowerCase();
+    if (value === '' || value === '1' || value === 'y' || value === 'yes') {
+        return 'update';
+    }
+    return 'skip';
+}
+export async function resolveUpdateAnswer(question) {
+    try {
+        return readUpdateChoice(await question());
+    }
+    catch (error) {
+        if (isAbortError(error))
+            return 'cancel';
+        throw error;
+    }
+}
+async function askUpdateChoice() {
+    const rl = readline.createInterface({ input, output });
+    try {
+        return await resolveUpdateAnswer(() => rl.question('  ▸ '));
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runUpdate(offer) {
+    return await new Promise((resolve) => {
+        const child = spawn(offer.program, offer.args, {
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+        child.on('error', () => resolve(false));
+        child.on('close', (code) => resolve(code === 0));
+    });
+}
+export async function offerUpdateAtStartup({ currentVersion, latestVersion, ask = askUpdateChoice, install = runUpdate, write = (text) => {
+    process.stdout.write(text);
+}, }) {
+    const offer = buildUpdateOffer({ currentVersion, latestVersion });
+    if (!offer)
+        return 'none';
+    write(`${formatUpdateScreen(offer)}\n`);
+    const answer = await ask();
+    if (answer === 'cancel') {
+        write(`\n  ${chalk.dim('Cancelled. Nothing was installed.')}\n\n`);
+        return 'cancelled';
+    }
+    if (answer === 'skip') {
+        write(`\n  ${chalk.yellow(`Continuing on ${offer.currentVersion} — you'll be asked again next time.`)}\n\n`);
+        return 'skipped';
+    }
+    write(`\n  ${chalk.dim(`$ ${offer.display}`)}\n\n`);
+    if (await install(offer)) {
+        write(`\n  ${chalk.green(`✓ Updated to ${offer.latestVersion}.`)} Run ${chalk.bold('ai')} again to start.\n\n`);
+        return 'updated';
+    }
+    write([
+        '',
+        `  ${chalk.red('✖ The update did not complete.')} Run this yourself, then start ${chalk.bold('ai')} again:`,
+        '',
+        `    ${chalk.bold(offer.display)}`,
+        '',
+        `  ${chalk.dim(`Starting on ${offer.currentVersion} for now.`)}`,
+        '',
+        '',
+    ].join('\n'));
+    return 'failed';
+}

package/dist/src/utils.js

@@ -1,3 +1,7 @@
+export function isAbortError(error) {
+    const err = error;
+    return err?.name === 'AbortError' || err?.code === 'ABORT_ERR';
+}
 export function cosineSimilarity(a, b) {
     let dot = 0;
     let magA = 0;

package/dist/src/version.js

@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 const PACKAGE_NAME = '@thegitai/cli';
-const UNKNOWN_VERSION = '0.0.0';
+export const UNKNOWN_CLI_VERSION = '0.0.0';
 export function getCliVersion() {
     let dir = path.dirname(fileURLToPath(import.meta.url));
     for (let depth = 0; depth < 6; depth++) {
@@ -19,7 +19,7 @@ export function getCliVersion() {
             break;
         dir = parent;
     }
-    return UNKNOWN_VERSION;
+    return UNKNOWN_CLI_VERSION;
 }
 export function getPlatformTag() {
     return `${process.platform}-${process.arch}`;
@@ -27,3 +27,53 @@ export function getPlatformTag() {
 export function formatVersionLine() {
     return `ai ${getCliVersion()} (${getPlatformTag()}, node ${process.version})`;
 }
+const VERSION_PATTERN = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parseVersion(value) {
+    const match = VERSION_PATTERN.exec(String(value ?? '').trim());
+    if (!match)
+        return null;
+    return {
+        core: [Number(match[1]), Number(match[2]), Number(match[3])],
+        prerelease: match[4] ? match[4].split('.') : [],
+    };
+}
+function comparePrereleaseIdentifier(left, right) {
+    const leftNumeric = /^\d+$/.test(left);
+    const rightNumeric = /^\d+$/.test(right);
+    if (leftNumeric && rightNumeric) {
+        const a = Number(left);
+        const b = Number(right);
+        return a === b ? 0 : a < b ? -1 : 1;
+    }
+    if (leftNumeric !== rightNumeric)
+        return leftNumeric ? -1 : 1;
+    return left === right ? 0 : left < right ? -1 : 1;
+}
+export function isReadableCliVersion(value) {
+    return parseVersion(value) !== null;
+}
+export function compareCliVersions(left, right) {
+    const a = parseVersion(left);
+    const b = parseVersion(right);
+    if (!a || !b)
+        return null;
+    for (let index = 0; index < 3; index++) {
+        if (a.core[index] !== b.core[index]) {
+            return a.core[index] < b.core[index] ? -1 : 1;
+        }
+    }
+    if (!a.prerelease.length || !b.prerelease.length) {
+        if (a.prerelease.length === b.prerelease.length)
+            return 0;
+        return a.prerelease.length ? -1 : 1;
+    }
+    const shared = Math.min(a.prerelease.length, b.prerelease.length);
+    for (let index = 0; index < shared; index++) {
+        const ordering = comparePrereleaseIdentifier(a.prerelease[index], b.prerelease[index]);
+        if (ordering !== 0)
+            return ordering;
+    }
+    if (a.prerelease.length === b.prerelease.length)
+        return 0;
+    return a.prerelease.length < b.prerelease.length ? -1 : 1;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thegitai/cli",
-  "version": "1.0.0-preview.42",
+  "version": "1.0.0-preview.44",
   "description": "TheGitAI is an agentic AI coding tool for your terminal. It reads and searches your repository, writes and edits files, runs your tests, and verifies the change before handing it back.",
   "keywords": [
     "agentic-ai",
@@ -44,11 +44,11 @@
     "@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.42",
-    "@thegitai/tui-darwin-x64": "1.0.0-preview.42",
-    "@thegitai/tui-linux-arm64": "1.0.0-preview.42",
-    "@thegitai/tui-linux-x64": "1.0.0-preview.42",
-    "@thegitai/tui-win32-x64": "1.0.0-preview.42",
+    "@thegitai/tui-darwin-arm64": "1.0.0-preview.44",
+    "@thegitai/tui-darwin-x64": "1.0.0-preview.44",
+    "@thegitai/tui-linux-arm64": "1.0.0-preview.44",
+    "@thegitai/tui-linux-x64": "1.0.0-preview.44",
+    "@thegitai/tui-win32-x64": "1.0.0-preview.44",
     "@vscode/ripgrep": "1.18.0"
   },
   "repository": {