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

package/dist/src/ui/slash-commands.js

@@ -0,0 +1,121 @@
+export const SLASH_COMMANDS = [
+    { command: '/model', description: 'Switch the active model' },
+    { command: '/help', description: 'Show available chat commands' },
+    { command: '/usage', description: 'Show account usage percentage and reset times' },
+    {
+        command: '/resume',
+        description: 'Open the session picker to resume a previous session',
+    },
+    { command: '/new', description: 'start a new conversation; this session remains saved' },
+    { 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: '/about', description: 'Show version and platform info' },
+    { command: '/logout', description: 'Sign out and quit' },
+    { command: '/exit', description: 'Quit the current session', aliases: ['/quit'] },
+];
+export const SLASH_COMMAND_SUGGESTION_LIMIT = 5;
+export function getInputCommandToken(input) {
+    const trimmed = String(input ?? '').trimStart();
+    const match = trimmed.match(/^\/[^\s]*/);
+    const token = match?.[0] ?? '';
+    if (token.indexOf('/', 1) !== -1)
+        return '';
+    return token;
+}
+export function slashCommandMatchesToken(option, token) {
+    return option.command === token || (option.aliases?.includes(token) ?? false);
+}
+const MATCH_EXACT = 0;
+const MATCH_PREFIX = 100;
+const MATCH_OVERTYPED = 200;
+const MATCH_TYPO = 300;
+const MATCH_IN_NAME = 400;
+const MATCH_IN_DESCRIPTION = 500;
+const MATCH_NONE = 600;
+function typoBudget(body) {
+    if (body.length <= 3)
+        return 0;
+    if (body.length <= 5)
+        return 1;
+    return 2;
+}
+function editDistanceWithin(a, b, max) {
+    if (a === b)
+        return 0;
+    if (max <= 0)
+        return null;
+    if (Math.abs(a.length - b.length) > max)
+        return null;
+    const width = b.length + 1;
+    let beforePrevious = [];
+    let previous = Array.from({ length: width }, (_, index) => index);
+    for (let i = 1; i <= a.length; i += 1) {
+        const current = new Array(width);
+        current[0] = i;
+        let best = i;
+        for (let j = 1; j < width; j += 1) {
+            const substitution = a[i - 1] === b[j - 1] ? 0 : 1;
+            let cost = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + substitution);
+            if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+                cost = Math.min(cost, beforePrevious[j - 2] + 1);
+            }
+            current[j] = cost;
+            if (cost < best)
+                best = cost;
+        }
+        if (best > max)
+            return null;
+        beforePrevious = previous;
+        previous = current;
+    }
+    const distance = previous[b.length];
+    return distance <= max ? distance : null;
+}
+function scoreSlashCommand(option, token) {
+    const command = option.command;
+    const body = token.slice(1);
+    if (!body)
+        return MATCH_PREFIX;
+    const spellings = [command, ...(option.aliases ?? [])];
+    if (slashCommandMatchesToken(option, token))
+        return MATCH_EXACT;
+    if (spellings.some((spelling) => spelling.startsWith(token)))
+        return MATCH_PREFIX;
+    const overtyped = spellings.find((spelling) => token.startsWith(spelling));
+    if (overtyped) {
+        return MATCH_OVERTYPED + Math.min(token.length - overtyped.length, 99);
+    }
+    const distances = spellings
+        .map((spelling) => editDistanceWithin(body, spelling.slice(1), typoBudget(body)))
+        .filter((distance) => distance !== null);
+    if (distances.length)
+        return MATCH_TYPO + Math.min(...distances);
+    if (command.includes(body))
+        return MATCH_IN_NAME;
+    if (option.description.toLowerCase().includes(body))
+        return MATCH_IN_DESCRIPTION;
+    return MATCH_NONE;
+}
+function rankSlashCommands(input) {
+    const token = getInputCommandToken(input).toLowerCase();
+    if (!token)
+        return [];
+    return SLASH_COMMANDS.map((option, order) => ({
+        option,
+        order,
+        score: scoreSlashCommand(option, token),
+    }))
+        .filter((entry) => entry.score < MATCH_NONE)
+        .sort((a, b) => a.score - b.score || a.order - b.order)
+        .map((entry) => entry.option);
+}
+export function getSlashCommandSuggestions(input) {
+    return rankSlashCommands(input).slice(0, SLASH_COMMAND_SUGGESTION_LIMIT);
+}
+export function getHiddenSlashCommandCount(input) {
+    return Math.max(0, rankSlashCommands(input).length - SLASH_COMMAND_SUGGESTION_LIMIT);
+}

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' };
     }
@@ -61,6 +64,13 @@ function normalizeChildMessage(raw) {
             deltaLines: Number(raw.deltaLines ?? raw.delta_lines ?? 0),
         };
     }
+    if (raw.kind === 'transcriptScrollTo') {
+        return {
+            op: 'event',
+            kind: 'transcriptScrollTo',
+            offset: Number(raw.offset ?? 0),
+        };
+    }
     if (raw.kind !== 'key') {
         return null;
     }
@@ -88,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 = [
@@ -102,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;
     }