@thegitai/cli 1.0.0-beta.4 → 1.0.0-beta.6

package/README.md

@@ -20,6 +20,7 @@ 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.

package/dist/bin/ai.js

@@ -13,59 +13,13 @@ 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';
 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)
@@ -340,11 +294,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;

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, } from './http.js';
 export function getAuthConfigPath(env = process.env) {
     const configured = String(env.THEGITAI_AUTH_CONFIG ?? '').trim();
     if (configured) {
@@ -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,7 +2,7 @@ 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';
@@ -73,14 +73,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;

package/dist/src/api/chat.js

@@ -1,7 +1,7 @@
 import { createPromptCheckpoint, sanitizeSessionSafetyForServer, } from '../session-safety.js';
 import { applySessionSnapshot, snapshotFromSession, } from '../session-store.js';
 import { executeLocalToolCall } from '../tool-executor.js';
-import { normalizeServerUrl, readErrorResponse, } from './http.js';
+import { createTraceContext, normalizeServerUrl, readErrorResponse, } from './http.js';
 export class TurnCancelledError extends Error {
     name = 'TurnCancelledError';
     constructor(message = 'Turn cancelled.') {
@@ -12,10 +12,12 @@ export class ChatTurnFailedError extends Error {
     name = 'ChatTurnFailedError';
     category;
     retryable;
-    constructor(message, category = 'unknown_error', retryable = false) {
-        super(message);
+    traceId;
+    constructor(message, category = 'unknown_error', retryable = false, traceId = '') {
+        super(traceId ? `${message}\nTrace ID: ${traceId}` : message);
         this.category = category;
         this.retryable = retryable;
+        this.traceId = traceId;
     }
 }
 export function isTurnCancelledError(error) {
@@ -139,17 +141,19 @@ function publicStatusMessage(data) {
         return `Running ${toolName} locally...`;
     return null;
 }
-async function postToolResult({ config, turnId, event, result, session, fetchImpl, }) {
+async function postToolResult({ config, turnId, event, result, session, fetchImpl, traceId, }) {
     const payload = {
         toolCallId: event.call.id,
         result,
         toolState: toolStateFromSession(session),
     };
+    const trace = createTraceContext(traceId);
     const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/chat/turn/${encodeURIComponent(turnId)}/tool-result`, {
         method: 'POST',
         headers: {
             authorization: `Bearer ${config.token}`,
             'content-type': 'application/json',
+            ...trace.headers,
         },
         body: JSON.stringify(payload),
     });
@@ -157,10 +161,10 @@ async function postToolResult({ config, turnId, event, result, session, fetchImp
         return;
     }
     if (!response.ok) {
-        throw await readErrorResponse(response);
+        throw await readErrorResponse(response, trace.traceId);
     }
 }
-async function executeAndPostToolResult({ config, projectIndex, session, event, input, fetchImpl, signal, }) {
+async function executeAndPostToolResult({ config, projectIndex, session, event, input, fetchImpl, signal, traceId, }) {
     const turnId = String(event?.turnId ?? '').trim();
     if (!turnId || !event?.call?.id || !event.call.name) {
         throw new Error('Server emitted an invalid tool-call event.');
@@ -189,13 +193,14 @@ async function executeAndPostToolResult({ config, projectIndex, session, event,
             result: rawResult,
             session,
             fetchImpl,
+            traceId,
         });
     }
     finally {
         session.turnState.id = previousTurnId;
     }
 }
-async function consumeTurnStream({ response, config, projectIndex, session, input, fetchImpl, signal, }) {
+async function consumeTurnStream({ response, config, projectIndex, session, input, fetchImpl, signal, traceId, }) {
     if (!response.body) {
         throw new Error('Server returned an empty chat stream.');
     }
@@ -224,6 +229,7 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
                 input,
                 fetchImpl,
                 signal,
+                traceId,
             });
             return;
         }
@@ -243,7 +249,7 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
             if (event.event === 'cancelled') {
                 throw new TurnCancelledError(message);
             }
-            throw new ChatTurnFailedError(message, typeof event.data?.category === 'string' ? event.data.category : 'unknown_error', Boolean(event.data?.retryable));
+            throw new ChatTurnFailedError(message, typeof event.data?.category === 'string' ? event.data.category : 'unknown_error', Boolean(event.data?.retryable), typeof event.data?.traceId === 'string' ? event.data.traceId : traceId);
         }
     }
     while (true) {
@@ -287,6 +293,7 @@ export async function sendServerUserMessage({ config, projectIndex, session, inp
         autoYes: session.autoYes,
         agentMode: session.agentMode,
     };
+    const trace = createTraceContext();
     const preTurnHistoryLength = session.history.length;
     const preserveOnAbort = () => preserveCancelledTurnInput(session, input);
     if (signal?.aborted) {
@@ -302,12 +309,13 @@ export async function sendServerUserMessage({ config, projectIndex, session, inp
                 accept: 'text/event-stream',
                 authorization: `Bearer ${config.token}`,
                 'content-type': 'application/json',
+                ...trace.headers,
             },
             body: JSON.stringify(request),
             signal,
         });
         if (!response.ok) {
-            throw await readErrorResponse(response);
+            throw await readErrorResponse(response, trace.traceId);
         }
         const result = await consumeTurnStream({
             response,
@@ -317,6 +325,7 @@ export async function sendServerUserMessage({ config, projectIndex, session, inp
             input,
             fetchImpl,
             signal,
+            traceId: trace.traceId,
         });
         applySessionSnapshot(session, result.snapshot, { preserveAgentMode: true });
         return {

package/dist/src/api/http.js

@@ -1,4 +1,31 @@
+import { randomUUID } from 'node:crypto';
 const DEFAULT_SERVER_URL = 'https://thegit.ai';
+export const TRACE_ID_HEADER = 'x-thegitai-trace-id';
+export const CLIENT_HEADER = 'x-thegitai-client';
+export const CLIENT_PLATFORM_HEADER = 'x-thegitai-client-platform';
+export class ServerApiError extends Error {
+    status;
+    traceId;
+    constructor(message, status, traceId) {
+        super(traceId ? `${message}\nTrace ID: ${traceId}` : message);
+        this.name = 'ServerApiError';
+        this.status = status;
+        this.traceId = traceId;
+    }
+}
+export function createTraceId() {
+    return `tr_${randomUUID().replace(/-/g, '')}`;
+}
+export function createTraceContext(traceId = createTraceId()) {
+    return {
+        traceId,
+        headers: {
+            [TRACE_ID_HEADER]: traceId,
+            [CLIENT_HEADER]: 'cli',
+            [CLIENT_PLATFORM_HEADER]: `${process.platform}/${process.arch}`,
+        },
+    };
+}
 export function normalizeServerUrl(serverUrl) {
     const normalized = String(serverUrl || DEFAULT_SERVER_URL)
         .trim()
@@ -22,15 +49,17 @@ export async function readJsonResponse(response) {
 export function failureMessage(data, status) {
     return String(data?.error?.message ?? data?.message ?? `Request failed with ${status}`);
 }
-export async function readErrorResponse(response) {
+export async function readErrorResponse(response, traceId = response.headers.get(TRACE_ID_HEADER) ?? '') {
     const data = await readJsonResponse(response);
-    return new Error(failureMessage(data, response.status));
+    return new ServerApiError(failureMessage(data, response.status), response.status, traceId);
 }
 export async function authorizedJson({ config, path, method = 'GET', body = null, headers = {}, fetchImpl = globalThis.fetch, }) {
+    const trace = createTraceContext();
     const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}${path}`, {
         method,
         headers: {
             authorization: `Bearer ${config.token}`,
+            ...trace.headers,
             ...headers,
             ...(body === null ? {} : { 'content-type': 'application/json' }),
         },
@@ -38,7 +67,7 @@ export async function authorizedJson({ config, path, method = 'GET', body = null
     });
     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);
     }
     return data;
 }

package/dist/src/api/models.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { getClientStateDir } from '../client-state.js';
-import { failureMessage, normalizeServerUrl, readJsonResponse, } from './http.js';
+import { ServerApiError, createTraceContext, failureMessage, normalizeServerUrl, readJsonResponse, } from './http.js';
 function sanitizeModelInfo(raw) {
     if (!raw || typeof raw !== 'object') {
         return null;
@@ -54,14 +54,16 @@ export function writeCachedServerModels(cache, env = process.env) {
     });
 }
 export async function fetchServerModels({ config, fetchImpl = globalThis.fetch, }) {
+    const trace = createTraceContext();
     const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/models`, {
         headers: {
             authorization: `Bearer ${config.token}`,
+            ...trace.headers,
         },
     });
     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 models = Array.isArray(data?.models)
         ? data.models.map(sanitizeModelInfo).filter(Boolean)

package/dist/src/cli-args.js

@@ -0,0 +1,65 @@
+export const AUTH_COMMANDS = new Set(['login', 'whoami', 'logout']);
+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 version = false;
+    let usage = false;
+    let session = null;
+    let listSessions = false;
+    let unknownOption = null;
+    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 === '--version' || arg === '-v') {
+            version = true;
+            continue;
+        }
+        if (arg === '--usage') {
+            usage = true;
+            continue;
+        }
+        // An unrecognized dashed token is a mistyped flag, not prompt text. Without
+        // an auth subcommand (whose flags are parsed separately) it would otherwise
+        // be swept into the prompt and silently start a billable session. Flag the
+        // first one so the caller can fail fast instead. Quoted prompts are a single
+        // argv entry with spaces, so they never look like a bare option here.
+        if (command === null && unknownOption === null && /^-/.test(arg)) {
+            unknownOption = arg;
+            continue;
+        }
+        promptParts.push(arg);
+    }
+    return {
+        command,
+        commandArgs,
+        autoYes,
+        help,
+        version,
+        usage,
+        session,
+        listSessions,
+        unknownOption,
+        prompt: promptParts.join(' ').trim(),
+    };
+}

package/dist/src/help-text.js

@@ -1,4 +1,5 @@
 import chalk from 'chalk';
+import { getCliVersion, getPlatformTag } from './version.js';
 // The bound keys (Enter/Esc/Ctrl+C/Tab/arrows) are identical across platforms in
 // a terminal. The one thing that genuinely differs is the terminal's paste
 // shortcut, so surface the one for the host OS (right-click paste works
@@ -45,6 +46,7 @@ const HELP_MARKDOWN = [
     '',
     '- `-y, --yes` — start in Auto-Accept mode',
     '- `-h, --help` — show this help',
+    '- `-v, --version` — print the version and exit',
     '',
     '## Modes',
     '',
@@ -70,6 +72,7 @@ const HELP_MARKDOWN = [
     '## Chat commands',
     '',
     '- `/help` — show this help',
+    '- `/about` — show version and platform info',
     '- `/usage` — show account usage percentage and reset times',
     '- `/model` — list supported models and pick one',
     '- `/model <id>` — switch the active model without clearing history',
@@ -100,6 +103,17 @@ const HELP_MARKDOWN = [
     '- For anything else, re-run the command and report the printed error',
     '  message — there is no client-side debug mode by design.',
 ].join('\n');
+export function formatAboutCard() {
+    // Fenced so the column alignment survives terminal markdown rendering.
+    return [
+        '```',
+        'TheGitAI',
+        `  Version   ${getCliVersion()}`,
+        `  Platform  ${getPlatformTag()}`,
+        `  Node      ${process.version}`,
+        '```',
+    ].join('\n');
+}
 export function formatHelpMarkdown() {
     return HELP_MARKDOWN;
 }

package/dist/src/ui/repl.js

@@ -11,7 +11,7 @@ import { applySessionSnapshot, listSessionMetadata, loadSessionSnapshot, saveSes
 import { truncate } from '../utils.js';
 import { writeClipboardText } from '../core/clipboard.js';
 import { openUrl } from '../core/open-url.js';
-import { formatInteractiveHelpText } from '../help-text.js';
+import { formatAboutCard, formatInteractiveHelpText } from '../help-text.js';
 import { expandPastedChunks, } from './paste-collapse.js';
 import { loadPromptHistory, MAX_PROMPT_HISTORY_ENTRIES, } from './prompt-history-store.js';
 const RESPONSE_STREAM_CHUNK_SIZE = 4;
@@ -86,6 +86,10 @@ export const 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',
@@ -1875,6 +1879,14 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 });
                 return;
             }
+            if (input === '/about') {
+                appendStaticEntry({
+                    body: formatAboutCard(),
+                    kind: 'system',
+                    title: 'About',
+                });
+                return;
+            }
             if (input === '/usage') {
                 store.update((current) => ({
                     ...current,

package/dist/src/version.js

@@ -0,0 +1,35 @@
+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';
+// Resolve the package version at runtime by walking up from this module to the
+// nearest package.json named @thegitai/cli. This works in both layouts: the
+// compiled binary (dist/bin/ai.js → ../../package.json) and the source tree run
+// under tsx in tests (src/version.ts → ../package.json). The name guard avoids
+// picking up an unrelated manifest if the file is ever nested elsewhere.
+export function getCliVersion() {
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    for (let depth = 0; depth < 6; depth++) {
+        try {
+            const pkg = JSON.parse(readFileSync(path.join(dir, 'package.json'), 'utf8'));
+            if (pkg.name === PACKAGE_NAME && typeof pkg.version === 'string') {
+                return pkg.version;
+            }
+        }
+        catch {
+            // No package.json at this level (or unreadable); keep walking up.
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return UNKNOWN_VERSION;
+}
+export function getPlatformTag() {
+    return `${process.platform}-${process.arch}`;
+}
+export function formatVersionLine() {
+    return `ai ${getCliVersion()} (${getPlatformTag()}, node ${process.version})`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thegitai/cli",
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.6",
   "description": "TheGitAI CLI client (source-visible, proprietary)",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://thegit.ai",
@@ -27,10 +27,10 @@
     "web-tree-sitter": "^0.26.6"
   },
   "optionalDependencies": {
-    "@thegitai/tui-darwin-arm64": "1.0.0-beta.4",
-    "@thegitai/tui-darwin-x64": "1.0.0-beta.4",
-    "@thegitai/tui-linux-x64": "1.0.0-beta.4",
-    "@thegitai/tui-win32-x64": "1.0.0-beta.4"
+    "@thegitai/tui-darwin-arm64": "1.0.0-beta.6",
+    "@thegitai/tui-darwin-x64": "1.0.0-beta.6",
+    "@thegitai/tui-linux-x64": "1.0.0-beta.6",
+    "@thegitai/tui-win32-x64": "1.0.0-beta.6"
   },
   "publishConfig": {
     "access": "public"