@thegitai/cli 1.0.0-beta.2 → 1.0.0-beta.20

package/README.md

@@ -1,7 +1,8 @@
 # TheGitAI
 
-Interactive terminal coding agent. Talk to your repo in plain English — it
-reads code, edits files, and runs commands with your approval.
+Interactive terminal coding agent. Talk to your repo in plain English — it reads
+your code, makes edits, runs the commands a task needs, and keeps long-running
+processes going while you work, all with your approval.
 
 ## Install
 
@@ -20,10 +21,44 @@ ai login            sign in via your browser (--no-browser for SSH/headless)
 ai whoami           show the signed-in account
 ai --usage          show account usage and reset times
 ai logout           sign out
+ai --version        print the version and exit
 ```
 
 Run `ai --help` for sessions, modes, keys, and chat commands.
 
+## Visible to-do list
+
+For larger multi-step tasks, the agent keeps a compact to-do list on screen so
+you can see what it plans to do, what it is working on right now, and what is
+already done.
+
+- While the agent works, the list sits at the bottom of the live **Working**
+  area, right above where you type, and updates as steps start and finish —
+  one step in progress at a time — so it stays visible even when tool output
+  above it runs long.
+- When the turn ends, a final snapshot of the list stays readable in the
+  transcript, and the footer shows a small progress chip (e.g. `◐ 4/6 to-dos`)
+  while steps remain open.
+- The agent's current reasoning stays visible too, right below the list, in a
+  compact one-line form so it doesn't compete with the list for space.
+- The list is managed entirely by the agent; simple one-step requests skip it.
+
+## Background jobs
+
+Some commands are meant to keep running — a dev server, a file watcher, a local
+API. TheGitAI runs these as **background jobs**, so the agent can start a server,
+work against it live, and stop it when the task is done, all in one session.
+
+- Each job's block in the transcript updates on its own with a live tail of its
+  latest output, and a compact indicator keeps you aware of what's still running.
+- Type `/jobs` to open a picker: **↑ / ↓** to move, **Enter** to expand a job and
+  read its output inline, **k** to stop it, **Esc** to close.
+- `/jobs output <id>` prints a job's full output, and `/jobs kill <id>` stops one
+  by id.
+- When you end the session, TheGitAI stops its background jobs for you.
+
+Full documentation: <https://thegit.ai/docs>
+
 ## License
 
 Proprietary — see the LICENSE file included in this package. Source is

package/dist/bin/ai.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
-import chalk from 'chalk';
+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 { formatCliHelpText, formatInteractiveHelpText, } from '../src/help-text.js';
 import { renderMarkdownForTerminal } from '../src/markdown-renderer.js';
 import { createIndex } from '../src/project-index.js';
@@ -13,65 +14,15 @@ import { runClientInteractive, shouldUseClientRatatuiShell, } from '../src/ui/re
 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 { parseArgs } from '../src/cli-args.js';
+import { getJobBufferedOutput, killBackgroundJob, killAllBackgroundJobs, listBackgroundJobs, setBackgroundJobSession, } from '../src/background-jobs.js';
+import { collectBackgroundJobUiKillMutations, collectBackgroundJobUiOutputMutations, } from '../src/tool-executor.js';
 const DEFAULT_SERVER_URL = 'https://thegit.ai';
-const AUTH_COMMANDS = new Set(['login', 'whoami', 'logout']);
 const { auth, chat, models, sessions } = ServerApi;
 function printUsage() {
     console.log(formatCliHelpText({ color: process.stdout.isTTY === true }));
 }
-export function parseArgs(argv) {
-    const args = argv.slice(2);
-    const firstArg = args[0];
-    const command = firstArg && AUTH_COMMANDS.has(firstArg) ? firstArg : null;
-    const commandArgs = command ? args.slice(1) : [];
-    let autoYes = false;
-    let help = false;
-    let usage = false;
-    let session = null;
-    let listSessions = false;
-    const promptParts = [];
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === '--yes' || arg === '-y') {
-            autoYes = true;
-            continue;
-        }
-        if ((arg === '--session' || arg === '--resume') && i + 1 < args.length) {
-            session = args[i + 1] ?? null;
-            i += 1;
-            continue;
-        }
-        if (arg === '--list-sessions') {
-            listSessions = true;
-            continue;
-        }
-        if (arg === '--help' || arg === '-h') {
-            help = true;
-            continue;
-        }
-        if (arg === '--usage') {
-            usage = true;
-            continue;
-        }
-        promptParts.push(arg);
-    }
-    return {
-        command,
-        commandArgs,
-        autoYes,
-        help,
-        usage,
-        session,
-        listSessions,
-        prompt: promptParts.join(' ').trim(),
-    };
-}
-function commandFlagValue(args, name) {
-    const index = args.indexOf(name);
-    if (index === -1)
-        return null;
-    return args[index + 1] ?? null;
-}
 async function promptText(question, fallback = null) {
     const rl = readline.createInterface({ input, output });
     try {
@@ -88,17 +39,13 @@ function appendPromptHistory(prompt, env = process.env) {
 }
 async function runAuthCommand(command, args) {
     if (command === 'login') {
-        const serverUrl = commandFlagValue(args, '--server') ??
-            process.env.THEGITAI_SERVER_URL ??
-            DEFAULT_SERVER_URL;
-        const websiteUrl = commandFlagValue(args, '--website') ?? undefined;
+        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,
-            websiteUrl,
             noBrowser,
             onUrl: (url) => {
                 console.log(chalk.dim(noBrowser ? 'Open this URL to sign in:' : 'If your browser did not open, visit:'));
@@ -181,6 +128,15 @@ function modelLabel(serverModels, modelId) {
     return (serverModels.models.find((model) => model.id === modelId)?.label ??
         'Unknown model');
 }
+function formatJobElapsedMs(ms) {
+    const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+    if (totalSeconds < 60)
+        return `${totalSeconds}s`;
+    const minutes = Math.floor(totalSeconds / 60);
+    if (minutes < 60)
+        return `${minutes}m${String(totalSeconds % 60).padStart(2, '0')}s`;
+    return `${Math.floor(minutes / 60)}h${String(minutes % 60).padStart(2, '0')}m`;
+}
 function makeConfirmCommand(session) {
     return async (command) => {
         console.log(chalk.bold(`\nCommand approval needed:\n${command}\n`));
@@ -292,6 +248,68 @@ async function mainInteractive({ authConfig, projectIndex, serverModels, serverS
             console.log(chalk.dim('Conversation cleared.\n'));
             continue;
         }
+        if (trimmed === '/jobs' || trimmed.startsWith('/jobs ')) {
+            const jobsArgs = trimmed.slice('/jobs'.length).trim();
+            const killMatch = jobsArgs.match(/^kill\s+(\S+)$/);
+            if (killMatch) {
+                const jobId = killMatch[1];
+                const killed = await killBackgroundJob(jobId);
+                await collectBackgroundJobUiKillMutations({
+                    session,
+                    projectIndex,
+                    jobId,
+                    result: killed,
+                });
+                if (!killed.ok) {
+                    console.log(chalk.red(killed.error ?? 'Background job kill failed.'));
+                }
+                else if (killed.alreadyFinished) {
+                    console.log(chalk.dim(`${jobId} had already finished.`));
+                }
+                continue;
+            }
+            const outputMatch = jobsArgs.match(/^output\s+(\S+)$/);
+            if (outputMatch) {
+                const jobId = outputMatch[1];
+                await collectBackgroundJobUiOutputMutations({
+                    session,
+                    projectIndex,
+                    jobId,
+                });
+                const job = listBackgroundJobs().find((candidate) => candidate.id === jobId);
+                const buffered = getJobBufferedOutput(jobId);
+                if (!job || !buffered) {
+                    console.log(chalk.red(`Unknown background job id: ${jobId}`));
+                    continue;
+                }
+                if (buffered.droppedChars > 0) {
+                    console.log(chalk.dim(`... (${buffered.droppedChars} chars of older output dropped) ...`));
+                }
+                console.log(buffered.output || chalk.dim('(no output captured)'));
+                continue;
+            }
+            if (jobsArgs) {
+                console.log(chalk.dim('Usage: /jobs — list · /jobs output <id> — full output · /jobs kill <id> — kill'));
+                continue;
+            }
+            const jobsList = listBackgroundJobs();
+            if (!jobsList.length) {
+                console.log(chalk.dim('No background jobs in this session.'));
+                continue;
+            }
+            for (const job of jobsList) {
+                const elapsed = formatJobElapsedMs((job.endedAt ?? Date.now()) - job.startedAt);
+                const stateText = job.status === 'running'
+                    ? `running · ${elapsed}`
+                    : job.status === 'killed'
+                        ? `killed · ran ${elapsed}`
+                        : job.status === 'error'
+                            ? 'failed to start'
+                            : `exited (code ${job.exitCode ?? 1}) · ran ${elapsed}`;
+                console.log(`${job.id} · ${stateText}\n    $ ${job.command}`);
+            }
+            continue;
+        }
         if (trimmed === '/resume') {
             const snapshot = await promptForResumeSession(session.rootDir, serverModels);
             if (!snapshot) {
@@ -299,6 +317,7 @@ async function mainInteractive({ authConfig, projectIndex, serverModels, serverS
                 continue;
             }
             applySessionSnapshot(session, snapshot);
+            setBackgroundJobSession(session.sessionId);
             await saveSessionBoth({ session, serverSessionClient });
             console.log(chalk.dim(`Resumed session${session.sessionName ? ` "${session.sessionName}"` : ''} (${session.sessionId})\n`));
             continue;
@@ -340,11 +359,21 @@ async function mainInteractive({ authConfig, projectIndex, serverModels, serverS
     }
 }
 export async function main() {
-    const { autoYes, help, usage, command, commandArgs, session: sessionIdentifier, listSessions, prompt, } = parseArgs(process.argv);
+    const { autoYes, help, version, usage, command, commandArgs, session: sessionIdentifier, listSessions, unknownOption, prompt, } = parseArgs(process.argv);
+    if (version) {
+        console.log(formatVersionLine());
+        return;
+    }
     if (help) {
         printUsage();
         return;
     }
+    if (unknownOption) {
+        console.error(`Unknown option: ${unknownOption}`);
+        console.error("Run 'ai --help' to see available commands and options.");
+        process.exitCode = 2;
+        return;
+    }
     if (command) {
         await runAuthCommand(command, commandArgs);
         return;
@@ -357,9 +386,46 @@ export async function main() {
     const rootDir = process.cwd();
     const authConfig = requireCliAuthConfig();
     const serverSessionClient = sessions.createServerSessionClient({ config: authConfig });
-    const cachedModels = models.readCachedServerModels();
-    const serverModels = await models.fetchServerModels({ config: authConfig });
-    const whoami = await auth.fetchWhoamiResponse({ config: authConfig });
+    const cachedModels = models.selectCacheForServer(models.readCachedServerModels(), authConfig.serverUrl);
+    let offlineNotice = null;
+    let serverModels;
+    try {
+        serverModels = await models.fetchServerModels({ config: authConfig });
+    }
+    catch (error) {
+        if (isTransientNetworkError(error) && cachedModels?.models.length) {
+            serverModels = { models: cachedModels.models };
+            offlineNotice = error?.message ? String(error.message) : 'network error';
+        }
+        else {
+            throw error;
+        }
+    }
+    let whoami;
+    try {
+        whoami = await auth.fetchWhoamiResponse({ config: authConfig });
+    }
+    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;
+        }
+    }
+    if (offlineNotice) {
+        console.error(chalk.yellow(`⚠ Couldn't reach TheGitAI (${offlineNotice}). Starting with cached settings — it will reconnect on your next message.`));
+    }
     if (listSessions) {
         printSessionList(rootDir, listSessionMetadata(rootDir), serverModels);
         return;
@@ -420,17 +486,24 @@ export async function main() {
     }
     printStartupBanner(rootDir, modelLabel(serverModels, session.modelId), session.autoYes);
     printSessionStartup(session);
-    await mainInteractive({
-        authConfig,
-        projectIndex,
-        serverModels,
-        serverSessionClient,
-        session,
-        usageText: async () => formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })),
-        initialPrompt,
-    });
-    await saveSessionBoth({ session, serverSessionClient });
-    printSessionExit(session);
+    setBackgroundJobSession(session.sessionId);
+    try {
+        await mainInteractive({
+            authConfig,
+            projectIndex,
+            serverModels,
+            serverSessionClient,
+            session,
+            usageText: async () => formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })),
+            initialPrompt,
+        });
+        await saveSessionBoth({ session, serverSessionClient });
+        printSessionExit(session);
+    }
+    finally {
+        killAllBackgroundJobs({ sessionId: session.sessionId, remove: true });
+        setBackgroundJobSession(null);
+    }
 }
 main().catch((error) => {
     console.error(chalk.red(`\n✖ Error: ${error.message}\n`));

package/dist/parsers/NOTICE

@@ -0,0 +1,18 @@
+Tree-sitter grammar parsers
+===========================
+
+The `tree-sitter-*.wasm` files in this directory are precompiled tree-sitter
+grammar parsers, vendored so the published `@thegitai/cli` package ships local
+code intelligence without a runtime dependency. They are used unmodified, only
+as parsing inputs to the vendored web-tree-sitter runtime
+(see ../vendor/web-tree-sitter/NOTICE).
+
+Each grammar is the work of its respective tree-sitter grammar project and is
+distributed under that project's license (the tree-sitter grammars are
+MIT-licensed). Grammars included:
+
+  c, c-sharp, cpp, css, go, html, java, javascript, objc, php, python, ruby,
+  rust, tsx, typescript
+
+Upstream organization: https://github.com/tree-sitter
+Individual grammars:    https://github.com/tree-sitter/tree-sitter-<language>

package/dist/src/agent-mode.js

@@ -12,6 +12,8 @@ const PLAN_MODE_TOOL_NAMES = new Set([
     'read_document',
     'analyze_image',
     'run_command',
+    'shell_job_output',
+    'update_todos',
 ]);
 const PLAN_MODE_RUN_COMMAND_NAMES = new Set([
     'pwd',
@@ -117,6 +119,9 @@ export function buildAgentModeToolBlockedResult(mode, call) {
     }
     if (call.name !== 'run_command')
         return null;
+    if (call.args?.background === true) {
+        return buildPlanModeToolBlockedResult(call.name, PLAN_MODE_RUN_COMMAND_ACTION);
+    }
     const command = String(call.args?.command ?? call.args?.cmd ?? '');
     const reason = planModeRunCommandBlockReason(command);
     return reason ? buildPlanModeToolBlockedResult(call.name, reason) : null;

package/dist/src/api/auth.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { getClientStateDir } from '../client-state.js';
-import { authorizedJson, failureMessage, normalizeServerUrl, readJsonResponse, } from './http.js';
+import { ServerApiError, authorizedJson, createTraceContext, failureMessage, normalizeServerUrl, readJsonResponse, retryTransient, } from './http.js';
 export function getAuthConfigPath(env = process.env) {
     const configured = String(env.THEGITAI_AUTH_CONFIG ?? '').trim();
     if (configured) {
@@ -51,11 +51,11 @@ export async function fetchWhoami({ config, fetchImpl = globalThis.fetch, }) {
     return data.customer;
 }
 export async function fetchWhoamiResponse({ config, fetchImpl = globalThis.fetch, }) {
-    const data = (await authorizedJson({
+    const data = (await retryTransient(() => authorizedJson({
         config,
         path: '/v1/auth/whoami',
         fetchImpl,
-    }));
+    })));
     if (!data?.customer?.email) {
         throw new Error('Server returned an invalid whoami response.');
     }
@@ -68,14 +68,16 @@ export async function fetchWhoamiResponse({ config, fetchImpl = globalThis.fetch
     };
 }
 export async function logoutFromServer({ config, fetchImpl = globalThis.fetch, }) {
+    const trace = createTraceContext();
     const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/auth/logout`, {
         method: 'POST',
         headers: {
             authorization: `Bearer ${config.token}`,
+            ...trace.headers,
         },
     });
     if (!response.ok && response.status !== 401) {
         const data = (await readJsonResponse(response));
-        throw new Error(failureMessage(data, response.status));
+        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId);
     }
 }

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

@@ -2,40 +2,16 @@ import crypto from 'node:crypto';
 import http from 'node:http';
 import os from 'node:os';
 import { openUrl } from '../core/open-url.js';
-import { failureMessage, normalizeServerUrl, readJsonResponse, } from './http.js';
+import { ServerApiError, createTraceContext, failureMessage, normalizeServerUrl, readJsonResponse, } from './http.js';
 const DEFAULT_WEBSITE_URL = 'https://thegit.ai';
-const DEFAULT_DEV_WEBSITE_URL = 'http://localhost:3002';
 const DEFAULT_SERVER_URL = 'https://thegit.ai';
 const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
 function shutDownServer(server) {
-    // Drop any lingering (keep-alive) connections so the event loop empties and
-    // the CLI exits instead of hanging after a successful login.
     server.closeAllConnections?.();
     server.close();
 }
-function isLocalhostUrl(url) {
-    if (!url)
-        return false;
-    try {
-        const host = new URL(url).hostname;
-        return host === 'localhost' || host === '127.0.0.1' || host === '::1';
-    }
-    catch {
-        return false;
-    }
-}
-export function resolveWebsiteUrl(websiteUrl, env = process.env, serverUrl) {
-    const explicit = String(websiteUrl ?? '').trim() ||
-        String(env.THEGITAI_WEBSITE_URL ?? '').trim();
-    // With no explicit override, point at production — unless we're clearly in
-    // local dev (talking to a localhost server), in which case default to the
-    // local website so `ai login` works without any flags or env vars.
-    const value = explicit || (isLocalhostUrl(serverUrl) ? DEFAULT_DEV_WEBSITE_URL : DEFAULT_WEBSITE_URL);
-    const normalized = value.replace(/\/+$/, '');
-    if (!/^https?:\/\//i.test(normalized)) {
-        throw new Error('Website URL must start with http:// or https://.');
-    }
-    return normalized;
+export function resolveWebsiteUrl() {
+    return DEFAULT_WEBSITE_URL.replace(/\/+$/, '');
 }
 function defaultDeviceName() {
     try {
@@ -45,7 +21,6 @@ function defaultDeviceName() {
         return os.hostname();
     }
 }
-/** PKCE (RFC 7636, S256): a random verifier and its SHA-256 challenge. */
 export function generatePkce() {
     const verifier = crypto.randomBytes(32).toString('base64url');
     const challenge = crypto
@@ -73,14 +48,15 @@ const RESULT_PAGE = (heading, detail) => `<!doctype html><html><head><meta chars
     `p{color:#9aa0a6}</style></head><body><div class="card"><h1>${heading}</h1>` +
     `<p>${detail}</p></div></body></html>`;
 async function exchangeCodeForToken({ serverUrl, code, codeVerifier, fetchImpl, }) {
+    const trace = createTraceContext();
     const response = await fetchImpl(`${serverUrl}/v1/cli/auth/token`, {
         method: 'POST',
-        headers: { 'content-type': 'application/json' },
+        headers: { 'content-type': 'application/json', ...trace.headers },
         body: JSON.stringify({ code, code_verifier: codeVerifier }),
     });
     const data = (await readJsonResponse(response));
     if (!response.ok) {
-        throw new Error(failureMessage(data, response.status));
+        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId);
     }
     const token = String(data?.token ?? '').trim();
     const customer = data?.customer;
@@ -95,15 +71,9 @@ async function exchangeCodeForToken({ serverUrl, code, codeVerifier, fetchImpl,
         customer,
     };
 }
-/**
- * Browser-based login. Starts a loopback server so the website can redirect the
- * one-time code back automatically; the code is then exchanged for a token
- * using the PKCE verifier. With `noBrowser`, the user pastes the code instead.
- * The CLI never sees the user's credentials.
- */
 export async function loginViaBrowser(options) {
     const serverUrl = normalizeServerUrl(options.serverUrl ?? DEFAULT_SERVER_URL);
-    const websiteUrl = resolveWebsiteUrl(options.websiteUrl, process.env, serverUrl);
+    const websiteUrl = resolveWebsiteUrl();
     const fetchImpl = options.fetchImpl ?? globalThis.fetch;
     const openBrowser = options.openBrowser ?? openUrl;
     const onUrl = options.onUrl ?? (() => { });
@@ -115,8 +85,6 @@ export async function loginViaBrowser(options) {
             deviceName,
             paste: true,
         });
-        // Headless mode: only print the URL for the user to open on another device.
-        // Never launch a browser here — that is the whole point of --no-browser.
         onUrl(authUrl);
         if (!options.promptCode) {
             throw new Error('No way to read the authorization code in this context.');
@@ -143,8 +111,6 @@ export async function loginViaBrowser(options) {
             }
             const code = requestUrl.searchParams.get('code') ?? '';
             const returnedState = requestUrl.searchParams.get('state') ?? '';
-            // `Connection: close` plus closeAllConnections() ensures the browser's
-            // keep-alive socket is torn down so the process can exit after login.
             if (!code || returnedState !== state) {
                 res.writeHead(400, { 'content-type': 'text/html', connection: 'close' });
                 res.end(RESULT_PAGE('Login failed', 'The request could not be verified. Please run ai login again.'));