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

package/README.md

@@ -1,6 +1,6 @@
 # TheGitAI — AI coding agent for your terminal
 
-TheGitAI is an AI coding agent for your terminal. It indexes your repository,
+TheGitAI is an AI coding agent for your terminal. It reads and searches your repository,
 writes and edits files, runs commands, and builds features with you.
 
 Talk to your repo in plain English. TheGitAI can keep long-running processes
@@ -12,14 +12,26 @@ going while you work, all with your approval.
 npm i -g @thegitai/cli
 ```
 
-Requires Node.js 24 or newer.
+Supports Node.js 22 and newer. Node.js 24 is recommended.
+
+This installs the `ai` command. If `ai` is already taken by another command on
+your machine, `thegitai` starts the same CLI.
+
+## Updates
+
+`ai` checks for a newer release each time it starts, and offers to install it
+for you. TheGitAI works best on the latest version, and an older CLI may not
+work optimally. **Update now** is already selected, so Enter takes it — the CLI
+installs the update and asks you to start `ai` again, so the whole session runs
+one version — while ↑/↓ moves to **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
-ai                  start an interactive session in the current repo
+ai                  sign in if needed, then start a session in the current repo
 ai "<request>"      start a session with <request> as the first message
-ai login            sign in via your browser (--no-browser for SSH/headless)
+ai login            the same as `ai`; kept for muscle memory
 ai whoami           show the signed-in account
 ai --usage          show account usage and reset times
 ai logout           sign out
@@ -34,6 +46,83 @@ always be viewed or resumed from that computer. Continuing it through the
 service requires the TheGitAI account used for that session. Local sessions can
 also be listed while signed out or offline.
 
+Signing in opens your browser. The same screen also prints a URL you can open on
+any other device and a box for an authorization code, so SSH and headless
+machines need no separate command: open the URL wherever you have a browser,
+choose "On another computer" on that page, and paste the code it shows.
+
+CLI login tokens use a rolling 48-hour inactivity timeout. If one expires during
+any server request, the CLI removes the expired credential and signs you in
+again on the next run.
+
+## When the connection drops
+
+A dropped connection does not end your turn. The CLI shows
+`Connection interrupted · retrying in 10s · retry 1/3` under the working timer,
+waits ten seconds, and reconnects to the same turn — it never starts the request
+over, and a command, edit or browser action that already ran is not run again.
+It tries three times. Once it is back, the turn simply continues and a short
+`Connection restored` note stays in the transcript.
+
+The same applies when you start `ai` while TheGitAI is briefly unavailable:
+startup shows `Couldn't reach TheGitAI (…) · retrying in 10s · retry 1/3` and
+waits up to three times before giving up.
+
+If TheGitAI itself restarted while it was working, the turn cannot resume
+where it was. It continues instead: the CLI sends your request once more with
+the steps that already finished on your machine and everything you told it
+during the turn, and the work picks up from there — a command that already ran
+is not run again, and a correction you made still stands — with a short
+`Server restarted` note in the transcript.
+
+Press Esc at any point to stop the turn instead. If all three retries fail, the
+turn ends with an error that names what was interrupted, notes that some actions
+may already have completed, and leaves anything you had queued in the composer
+rather than sending it on top of a turn whose outcome is unknown.
+
+## Chrome browser control
+
+The TheGitAI Chrome extension is separately installed. After installing it,
+start `ai` normally and ask about your current tab or a website task. It uses
+your existing Chrome profile, website sessions, and terminal login. Connection
+is automatic; no setup/start command, second sign-in, or manual tab attachment
+is required. Tabs used by the agent join a TheGitAI tab group in an existing
+window. The conversation stays in your terminal.
+
+Default mode asks before using a website and can remember that site for the
+session. Bypass all permissions allows browser actions; Plan mode reads pages
+without clicking, typing, or navigating. Use Stop/Resume in the extension popup to
+pause browser control, or Disable to disconnect it. Chrome's protected pages,
+including browser settings and extension management, cannot be controlled.
+
+The extension is currently a development download and is not yet listed in the
+Chrome Web Store. Its version and distribution are independent of this npm
+package. Ubuntu with Chrome is the initial validation target.
+
+## Structured questions
+
+
+The agent can pause its current turn to ask up to four related questions in one
+form. Use **↑ / ↓**, the displayed option number, or **Enter** to choose, and
+**← / →** to move between questions. **Something else / add details** is the
+numbered final option; focus it and type, paste, or press **Enter** to add a
+single-line note; **Enter** commits it and moves on the way any other choice
+does — to the next question, or to **Submit answers** on the last one — without
+submitting the form. On single-select questions it is mutually exclusive with
+the listed choices, and **↑ / ↓** leaves its editor when the note is empty.
+Multi-select questions toggle choices. The last question has an explicit
+**Submit answers** row. **Esc** closes an open note first and otherwise cancels
+the form; **Ctrl+C** cancels the whole turn.
+
+Only the option you are on shows its description, so the whole form — every
+option, the note row, **Submit answers**, and the key hints — stays on screen
+without scrolling. Move between options to read the others.
+
+Answers return to the same turn, and completed question/answer records remain
+readable when the session is resumed. Default, Bypass all permissions, and Plan
+modes all support the form; Bypass all permissions does not choose answers for
+you.
+
 ## Visible to-do list
 
 For larger multi-step tasks, the agent keeps a compact to-do list on screen so

package/dist/bin/ai.js

@@ -1,68 +1,52 @@
 #!/usr/bin/env node
 import chalk from '../src/colors.js';
-import { stdin as input, stdout as output } from 'node:process';
-import readline from 'node:readline/promises';
 import { ServerApi } from '../src/api/index.js';
-import { loginViaBrowser } from '../src/api/browser-login.js';
-import { isTransientNetworkError } from '../src/api/http.js';
+import { DEFAULT_THEGITAI_HOST } from '../src/api/default-host.js';
+import { isSignInCancelled } from '../src/api/browser-login.js';
+import { runSignIn } from '../src/signin.js';
+import { ServerApiError, authenticationErrorMessage, isAuthenticationError, isTransientNetworkError, } from '../src/api/http.js';
+import { loadStartupHandshake } from '../src/api/startup-handshake.js';
+import { TURN_RECOVERY_DELAY_MS, TURN_RECOVERY_RETRIES, } from '../src/api/turn-recovery.js';
 import { formatCliHelpText } from '../src/help-text.js';
-import { createIndex } from '../src/project-index.js';
-import { createSession } from '../src/session.js';
-import { applySessionSnapshot, listSessionMetadata, loadSessionSnapshot, saveSessionState, } from '../src/session-store.js';
+import { createSession, disposeSession } from '../src/session.js';
+import { applySessionSnapshot, listSessionMetadata, loadSessionSnapshot, saveSessionState, sessionHasUserMessage, } from '../src/session-store.js';
 import { runClientInteractive } from '../src/ui/repl.js';
+import { startBrowserDiscoveryInBackground } from '../src/browser/session-bridge.js';
 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 DEFAULT_SERVER_URL = 'https://thegit.ai';
 const { auth, chat, models, sessions } = ServerApi;
 function printUsage() {
     console.log(formatCliHelpText({ color: process.stdout.isTTY === true }));
 }
-async function promptText(question, fallback = null) {
-    const rl = readline.createInterface({ input, output });
-    try {
-        const suffix = fallback ? ` (${fallback})` : '';
-        const answer = await rl.question(`${question}${suffix}: `);
-        return answer.trim() || fallback || '';
-    }
-    finally {
-        rl.close();
+function unreachableReason(error) {
+    const err = error;
+    const code = err?.code ?? err?.cause?.code;
+    if (err?.name === 'TimeoutError' || err?.name === 'AbortError') {
+        return 'network timeout';
     }
+    if (code === 'ENOTFOUND' || code === 'EAI_AGAIN')
+        return 'DNS lookup failed';
+    if (code === 'ECONNREFUSED')
+        return 'connection refused';
+    if (code === 'ECONNRESET' || code === 'EPIPE')
+        return 'connection reset';
+    return err?.message ? String(err.message) : 'network error';
 }
 function appendPromptHistory(prompt, env = process.env) {
     appendPromptToFile(prompt, env);
 }
-async function runAuthCommand(command, args) {
-    if (command === 'login') {
-        const serverUrl = DEFAULT_SERVER_URL;
-        const noBrowser = args.includes('--no-browser');
-        console.log(chalk.dim(noBrowser
-            ? 'Sign in on the website, then paste the authorization code here.'
-            : 'Opening your browser to sign in…'));
-        const result = await loginViaBrowser({
-            serverUrl,
-            noBrowser,
-            onUrl: (url) => {
-                console.log(chalk.dim(noBrowser ? 'Open this URL to sign in:' : 'If your browser did not open, visit:'));
-                console.log(`  ${url}`);
-            },
-            onWaiting: () => console.log(chalk.dim('Waiting for you to finish signing in…')),
-            promptCode: noBrowser
-                ? () => promptText('Paste the authorization code')
-                : undefined,
-            deviceName: process.env.THEGITAI_DEVICE_NAME?.trim() || undefined,
-        });
-        auth.writeCliAuthConfig(result);
-        console.log(chalk.green(`✓ Logged in as ${result.customer.email}`));
-        console.log(chalk.dim(`Server: ${result.serverUrl}`));
-        console.log(chalk.dim('You can close the browser tab. Run `ai` in a repo to start.'));
-        return;
-    }
+async function runAuthCommand(command) {
     const config = auth.readCliAuthConfig();
     if (!config) {
-        throw new Error('Not logged in. Run `ai login` first.');
+        if (command === 'logout') {
+            console.log(chalk.green('Already signed out.'));
+            return;
+        }
+        throw new Error('Not signed in. Run `ai` to sign in.');
     }
     if (command === 'whoami') {
         const customer = await auth.fetchWhoami({ config });
@@ -70,19 +54,25 @@ async function runAuthCommand(command, args) {
         return;
     }
     if (command === 'logout') {
-        await auth.logoutFromServer({ config });
+        try {
+            await auth.logoutFromServer({ config });
+        }
+        catch {
+        }
         auth.clearCliAuthConfig();
         console.log(chalk.green('Logged out.'));
         return;
     }
     throw new Error(`Unknown auth command: ${command}`);
 }
-function requireCliAuthConfig() {
+async function ensureCliAuthConfig() {
     const config = auth.readCliAuthConfig();
-    if (!config) {
-        throw new Error('Not logged in. Run `ai login` first.');
+    if (config)
+        return config;
+    if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+        throw new Error('Not signed in. Run `ai login` on a terminal to sign in.');
     }
-    return config;
+    return await runSignIn();
 }
 function formatSessionName(name) {
     return name ? `"${name}"` : '(unnamed)';
@@ -116,6 +106,8 @@ function modelLabel(serverModels, modelId) {
         `Model ${modelId}`);
 }
 async function saveSessionBoth({ session, serverSessionClient, }) {
+    if (!sessionHasUserMessage(session))
+        return;
     saveSessionState(session);
     try {
         await serverSessionClient.save(session);
@@ -138,7 +130,7 @@ function requireInteractiveTerminal() {
     return true;
 }
 export async function main() {
-    const { autoYes, help, version, usage, command, commandArgs, session: sessionIdentifier, listSessions, unknownOption, prompt, } = parseArgs(process.argv);
+    const { autoYes, help, version, usage, command, session: sessionIdentifier, listSessions, unknownOption, prompt, } = parseArgs(process.argv);
     if (version) {
         console.log(formatVersionLine());
         return;
@@ -153,18 +145,18 @@ export async function main() {
         process.exitCode = 2;
         return;
     }
-    if (command) {
-        await runAuthCommand(command, commandArgs);
+    if (command && command !== 'login') {
+        await runAuthCommand(command);
         return;
     }
     if (usage) {
-        const authConfig = requireCliAuthConfig();
+        const authConfig = await ensureCliAuthConfig();
         console.log(formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })));
         return;
     }
     const rootDir = process.cwd();
     if (listSessions) {
-        const activeServerUrl = auth.readCliAuthConfig()?.serverUrl ?? DEFAULT_SERVER_URL;
+        const activeServerUrl = auth.readCliAuthConfig()?.serverUrl ?? DEFAULT_THEGITAI_HOST;
         printSessionList(rootDir, listSessionMetadata(rootDir), models.selectCacheForServer(models.readCachedServerModels(), activeServerUrl));
         return;
     }
@@ -179,48 +171,77 @@ export async function main() {
     if (!requireInteractiveTerminal()) {
         return;
     }
-    const authConfig = requireCliAuthConfig();
+    const authConfig = await ensureCliAuthConfig();
     const serverSessionClient = sessions.createServerSessionClient({ config: authConfig });
     const cachedModels = models.selectCacheForServer(models.readCachedServerModels(), authConfig.serverUrl);
+    const { models: modelsOutcome, whoami: whoamiOutcome } = await loadStartupHandshake({
+        config: authConfig,
+        canStartOffline: Boolean(cachedModels?.models.length),
+        onStatus: (status, lastFailure) => {
+            if (status.phase === 'waiting') {
+                const reason = lastFailure instanceof ServerApiError
+                    ? `HTTP ${lastFailure.status}`
+                    : unreachableReason(lastFailure);
+                console.error(chalk.yellow(`⚠ Couldn't reach TheGitAI (${reason}) · retrying in ${TURN_RECOVERY_DELAY_MS / 1000}s · retry ${status.retry}/${TURN_RECOVERY_RETRIES}`));
+            }
+            else if (status.phase === 'reconnecting') {
+                console.error(chalk.dim(`  Reconnecting · retry ${status.retry}/${TURN_RECOVERY_RETRIES}`));
+            }
+            else if (status.phase === 'restored') {
+                console.error(chalk.green('✓ Reconnected to TheGitAI'));
+            }
+        },
+    });
     let offlineNotice = null;
     let serverModels;
-    try {
-        serverModels = await models.fetchServerModels({ config: authConfig });
+    if (modelsOutcome.status === 'fulfilled') {
+        serverModels = modelsOutcome.value;
     }
-    catch (error) {
-        if (isTransientNetworkError(error) && cachedModels?.models.length) {
-            serverModels = { models: cachedModels.models };
-            offlineNotice = error?.message ? String(error.message) : 'network error';
-        }
-        else {
-            throw error;
-        }
+    else if (isTransientNetworkError(modelsOutcome.reason) &&
+        cachedModels?.models.length) {
+        serverModels = { models: cachedModels.models };
+        offlineNotice = unreachableReason(modelsOutcome.reason);
+    }
+    else if (isTransientNetworkError(modelsOutcome.reason)) {
+        throw new Error(`Couldn't reach TheGitAI to load your models (${unreachableReason(modelsOutcome.reason)}).\nCheck your internet connection and run \`ai\` again.`);
+    }
+    else {
+        throw modelsOutcome.reason;
     }
     let whoami;
-    try {
-        whoami = await auth.fetchWhoamiResponse({ config: authConfig });
+    if (whoamiOutcome.status === 'fulfilled') {
+        whoami = whoamiOutcome.value;
     }
-    catch (error) {
-        if (isTransientNetworkError(error)) {
-            whoami = {
-                customer: {
-                    id: '',
-                    uuid: '',
-                    email: authConfig.email,
-                    customer_type: authConfig.customerType ?? 'USER',
-                    scopes: [],
-                },
-                debugUi: { showSessionId: false },
-            };
-            offlineNotice ??= error?.message ? String(error.message) : 'network error';
-        }
-        else {
-            throw error;
-        }
+    else if (isTransientNetworkError(whoamiOutcome.reason)) {
+        whoami = {
+            customer: {
+                id: '',
+                uuid: '',
+                email: authConfig.email,
+                customer_type: authConfig.customerType ?? 'USER',
+                scopes: [],
+            },
+            debugUi: { showSessionId: false },
+        };
+        offlineNotice ??= unreachableReason(whoamiOutcome.reason);
+    }
+    else {
+        throw whoamiOutcome.reason;
     }
     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,
@@ -239,35 +260,44 @@ export async function main() {
     if (sourceSnapshot) {
         applySessionSnapshot(session, sourceSnapshot);
     }
-    const projectIndex = createIndex({
-        rootDir,
-        onStatus: (message) => {
-            if (message.trim()) {
-                console.log(chalk.dim(`  ${message}`));
-            }
-        },
-        onContextLog: (message) => {
-            if (message.trim()) {
-                console.log(chalk.cyan(`  ${message}`));
-            }
-        },
-    });
+    startBrowserDiscoveryInBackground({ cwd: rootDir, env: session.env });
     const initialPrompt = prompt || undefined;
-    await runClientInteractive({
-        appendPromptHistory: (value) => appendPromptHistory(value, session.env),
-        authConfig,
-        debugUi: whoami.debugUi,
-        projectIndex,
-        serverModels,
-        serverSessionClient,
-        session,
-        initialPrompt,
-        usageText: async () => formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })),
-    });
-    await saveSessionBoth({ session, serverSessionClient });
-    printSessionExit(session);
+    try {
+        const outcome = await runClientInteractive({
+            appendPromptHistory: (value) => appendPromptHistory(value, session.env),
+            authConfig,
+            debugUi: whoami.debugUi,
+            serverModels,
+            serverSessionClient,
+            session,
+            initialPrompt,
+            usageText: async () => formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })),
+        });
+        if (outcome.signedOut) {
+            if (sessionHasUserMessage(session)) {
+                saveSessionState(session);
+            }
+            console.log(chalk.green('\n✓ Logged out.\n'));
+            return;
+        }
+        await saveSessionBoth({ session, serverSessionClient });
+        printSessionExit(session);
+    }
+    finally {
+        await disposeSession(session);
+    }
 }
 main().catch((error) => {
-    console.error(chalk.red(`\n✖ Error: ${error.message}\n`));
+    if (isSignInCancelled(error)) {
+        console.error(chalk.dim('\nSign-in cancelled. Nothing was saved.\n'));
+        process.exit(130);
+    }
+    if (isAuthenticationError(error)) {
+        auth.clearCliAuthConfig();
+        console.error(chalk.red(`\n✖ Error: ${authenticationErrorMessage(error)}\n`));
+    }
+    else {
+        console.error(chalk.red(`\n✖ Error: ${error.message}\n`));
+    }
     process.exit(1);
 });