@thegitai/cli 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,20 @@
+TheGitAI Client — Source-Visible Proprietary License
+
+Copyright (c) 2026 TheGitAI
+
+This source code is made available for inspection and trust verification only.
+The following rights are NOT granted:
+
+  - Copying or redistribution of this code, in whole or in part
+  - Commercial use or resale
+  - Derivative works or modifications for distribution
+  - Sublicensing
+
+SECURITY NOTICE: This client is untrusted for enforcement purposes. All
+authentication, authorization, and security-sensitive decisions are enforced
+server-side. The server's enforcement is authoritative regardless of any
+client-side values.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY ARISING FROM THE USE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# TheGitAI
+
+Interactive terminal coding agent. Talk to your repo in plain English — it
+reads code, edits files, and runs commands with your approval.
+
+## Install
+
+```bash
+npm i -g @thegitai/cli
+```
+
+Requires Node.js 24.
+
+## Usage
+
+```text
+ai                  start an interactive 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 whoami           show the signed-in account
+ai --usage          show account usage and reset times
+ai logout           sign out
+```
+
+Run `ai --help` for sessions, modes, keys, and chat commands.
+
+## License
+
+Proprietary — see [LICENSE](./LICENSE). Source is visible for inspection;
+copying and redistribution are not permitted.

package/dist/bin/ai.js

@@ -0,0 +1,438 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+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 { formatCliHelpText, formatInteractiveHelpText, } from '../src/help-text.js';
+import { renderMarkdownForTerminal } from '../src/markdown-renderer.js';
+import { createIndex } from '../src/project-index.js';
+import { createSession, clearConversation } from '../src/session.js';
+import { applySessionSnapshot, listSessionMetadata, loadSessionSnapshot, saveSessionState, } from '../src/session-store.js';
+import { runClientInteractive, shouldUseClientRatatuiShell, } from '../src/ui/repl.js';
+import { appendPromptToFile } from '../src/ui/prompt-history-store.js';
+import { formatSessionExitNotice } from '../src/session-exit.js';
+import { formatUsageText } from '../src/usage.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 {
+        const suffix = fallback ? ` (${fallback})` : '';
+        const answer = await rl.question(`${question}${suffix}: `);
+        return answer.trim() || fallback || '';
+    }
+    finally {
+        rl.close();
+    }
+}
+function appendPromptHistory(prompt, env = process.env) {
+    appendPromptToFile(prompt, 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 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:'));
+                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;
+    }
+    const config = auth.readCliAuthConfig();
+    if (!config) {
+        throw new Error('Not logged in. Run `ai login` first.');
+    }
+    if (command === 'whoami') {
+        const customer = await auth.fetchWhoami({ config });
+        console.log(chalk.green(customer.email));
+        return;
+    }
+    if (command === 'logout') {
+        await auth.logoutFromServer({ config });
+        auth.clearCliAuthConfig();
+        console.log(chalk.green('Logged out.'));
+        return;
+    }
+    throw new Error(`Unknown auth command: ${command}`);
+}
+function requireCliAuthConfig() {
+    const config = auth.readCliAuthConfig();
+    if (!config) {
+        throw new Error('Not logged in. Run `ai login` first.');
+    }
+    return config;
+}
+function formatSessionName(name) {
+    return name ? `"${name}"` : '(unnamed)';
+}
+function printSessionList(rootDir, sessions, serverModels) {
+    console.log(chalk.bold(`Saved sessions for ${rootDir}`));
+    if (!sessions.length) {
+        console.log(chalk.dim('  No saved sessions for this repo.'));
+        return;
+    }
+    for (const session of sessions) {
+        const updated = new Date(session.updatedAt).toLocaleString();
+        const label = `${formatSessionName(session.name)} ${chalk.dim(session.id)}`;
+        const detail = [
+            modelLabel(serverModels, session.modelId),
+            `${session.messageCount} messages`,
+            `updated ${updated}`,
+        ].join(' · ');
+        console.log(`  ${label}`);
+        console.log(chalk.dim(`    ${detail}`));
+        if (session.lastUserMessage) {
+            console.log(chalk.dim(`    ${session.lastUserMessage}`));
+        }
+    }
+}
+function printStartupBanner(rootDir, modelLabel, autoYes) {
+    console.log(chalk.dim(`Project: ${rootDir}`));
+    console.log(chalk.dim(`Model: ${modelLabel}`));
+    if (autoYes) {
+        console.log(chalk.dim('Auto-confirm: enabled'));
+    }
+}
+function printSessionStartup(session) {
+    console.log(chalk.dim(`Session: ${session.sessionName ? `${session.sessionName} ` : ''}${session.sessionId}`));
+}
+function printSessionExit(session) {
+    console.log(chalk.dim(`\n${formatSessionExitNotice(session.sessionId)}\n`));
+}
+function modelLabel(serverModels, modelId) {
+    return (serverModels.models.find((model) => model.id === modelId)?.label ??
+        'Unknown model');
+}
+function makeConfirmCommand(session) {
+    return async (command) => {
+        console.log(chalk.bold(`\nCommand approval needed:\n${command}\n`));
+        const answer = (await promptText('Approve? [y]es/[a]ll/[n]o', 'n')).toLowerCase();
+        if (answer === 'a' || answer === 'all') {
+            session.autoYes = true;
+            return true;
+        }
+        return answer === 'y' || answer === 'yes';
+    };
+}
+function makeConfirmPatch(session) {
+    return async (filePath) => {
+        const answer = (await promptText(`Apply patch to ${filePath}? [y]es/[a]ll/[n]o`, 'n')).toLowerCase();
+        if (answer === 'a' || answer === 'all') {
+            session.autoYes = true;
+            return true;
+        }
+        return answer === 'y' || answer === 'yes';
+    };
+}
+async function saveSessionBoth({ session, serverSessionClient, }) {
+    saveSessionState(session);
+    try {
+        await serverSessionClient.save(session);
+    }
+    catch (error) {
+        console.error(chalk.yellow(`Warning: session save failed: ${error.message}`));
+    }
+}
+async function promptForModelSelection(currentModelId, authConfig) {
+    const serverModels = await models.fetchServerModels({ config: authConfig });
+    console.log(chalk.bold('\nAvailable models'));
+    for (const model of serverModels.models) {
+        const marker = model.id === currentModelId ? '*' : ' ';
+        console.log(`${marker} ${model.id}  ${model.label}`);
+    }
+    console.log();
+    const selected = (await promptText('Model id', '')).trim() || null;
+    if (!selected) {
+        return { selected: null, serverModels };
+    }
+    return {
+        selected: models.validateServerModel(selected, serverModels),
+        serverModels,
+    };
+}
+async function promptForResumeSession(rootDir, serverModels) {
+    const sessions = listSessionMetadata(rootDir);
+    if (!sessions.length) {
+        console.log(chalk.dim('No saved sessions for this repo.\n'));
+        return null;
+    }
+    printSessionList(rootDir, sessions, serverModels);
+    console.log();
+    const identifier = (await promptText('Session id or name', '')).trim();
+    if (!identifier) {
+        return null;
+    }
+    return loadSessionSnapshot(rootDir, identifier);
+}
+async function runTurn({ authConfig, projectIndex, serverSessionClient, session, inputText, }) {
+    const prompt = String(inputText ?? '').trim();
+    if (!prompt)
+        return;
+    appendPromptHistory(prompt, session.env);
+    const result = await chat.sendServerUserMessage({
+        config: authConfig,
+        projectIndex,
+        session,
+        input: prompt,
+    });
+    if (result.text) {
+        console.log(`\n${chalk.green('TheGitAI>')}`);
+        console.log(renderMarkdownForTerminal(result.text));
+        console.log();
+    }
+    await saveSessionBoth({ session, serverSessionClient });
+}
+async function mainInteractive({ authConfig, projectIndex, serverModels, serverSessionClient, session, usageText, initialPrompt, }) {
+    if (initialPrompt) {
+        console.log(chalk.dim(`Prompt: "${initialPrompt}"`));
+        await runTurn({
+            authConfig,
+            projectIndex,
+            serverSessionClient,
+            session,
+            inputText: initialPrompt,
+        });
+    }
+    while (true) {
+        const inputText = await promptText('you');
+        const trimmed = inputText.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed === '/exit')
+            return;
+        if (trimmed === '/help') {
+            console.log(renderMarkdownForTerminal(formatInteractiveHelpText()));
+            continue;
+        }
+        if (trimmed === '/usage') {
+            console.log(await usageText());
+            continue;
+        }
+        if (trimmed === '/clear') {
+            clearConversation(session);
+            await saveSessionBoth({ session, serverSessionClient });
+            console.log(chalk.dim('Conversation cleared.\n'));
+            continue;
+        }
+        if (trimmed === '/resume') {
+            const snapshot = await promptForResumeSession(session.rootDir, serverModels);
+            if (!snapshot) {
+                console.log(chalk.dim('Resume cancelled.\n'));
+                continue;
+            }
+            applySessionSnapshot(session, snapshot);
+            await saveSessionBoth({ session, serverSessionClient });
+            console.log(chalk.dim(`Resumed session${session.sessionName ? ` "${session.sessionName}"` : ''} (${session.sessionId})\n`));
+            continue;
+        }
+        if (trimmed === '/model' || trimmed.startsWith('/model ')) {
+            const inline = trimmed.slice('/model'.length).trim();
+            let serverModels;
+            let selected = null;
+            if (inline) {
+                serverModels = await models.fetchServerModels({ config: authConfig });
+                selected = models.validateServerModel(inline, serverModels);
+            }
+            else {
+                const response = await promptForModelSelection(session.modelId, authConfig);
+                serverModels = response.serverModels;
+                selected = response.selected;
+            }
+            if (!selected) {
+                console.log(chalk.dim('Model selection cancelled.\n'));
+                continue;
+            }
+            session.modelId = selected;
+            models.updateSelectedModelCache({
+                config: authConfig,
+                selectedModelId: selected,
+                serverModels,
+            });
+            await saveSessionBoth({ session, serverSessionClient });
+            console.log(chalk.dim(`Switched to ${modelLabel(serverModels, selected)}.\n`));
+            continue;
+        }
+        await runTurn({
+            authConfig,
+            projectIndex,
+            serverSessionClient,
+            session,
+            inputText: trimmed,
+        });
+    }
+}
+export async function main() {
+    const { autoYes, help, usage, command, commandArgs, session: sessionIdentifier, listSessions, prompt, } = parseArgs(process.argv);
+    if (help) {
+        printUsage();
+        return;
+    }
+    if (command) {
+        await runAuthCommand(command, commandArgs);
+        return;
+    }
+    if (usage) {
+        const authConfig = requireCliAuthConfig();
+        console.log(formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })));
+        return;
+    }
+    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 });
+    if (listSessions) {
+        printSessionList(rootDir, listSessionMetadata(rootDir), serverModels);
+        return;
+    }
+    const sourceSnapshot = sessionIdentifier
+        ? loadSessionSnapshot(rootDir, sessionIdentifier)
+        : null;
+    const selectedModelId = models.selectServerModel({
+        requestedModelId: sourceSnapshot?.modelId ?? null,
+        cached: cachedModels,
+        serverModels,
+    });
+    models.updateSelectedModelCache({
+        config: authConfig,
+        selectedModelId,
+        serverModels,
+    });
+    const session = createSession({
+        rootDir,
+        autoYes,
+        modelId: selectedModelId,
+    });
+    session.confirmCommand = makeConfirmCommand(session);
+    session.confirmPatch = makeConfirmPatch(session);
+    if (sourceSnapshot) {
+        applySessionSnapshot(session, sourceSnapshot);
+        await saveSessionBoth({ session, serverSessionClient });
+    }
+    const projectIndex = createIndex({
+        rootDir,
+        onStatus: (message) => {
+            if (message.trim()) {
+                console.log(chalk.dim(`  ${message}`));
+            }
+        },
+        onContextLog: (message) => {
+            if (message.trim()) {
+                console.log(chalk.cyan(`  ${message}`));
+            }
+        },
+    });
+    const initialPrompt = prompt || undefined;
+    if (shouldUseClientRatatuiShell()) {
+        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);
+        return;
+    }
+    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);
+}
+main().catch((error) => {
+    console.error(chalk.red(`\n✖ Error: ${error.message}\n`));
+    process.exit(1);
+});

package/dist/src/agent-mode.js

@@ -0,0 +1,142 @@
+export const AGENT_MODES = ['default', 'auto-accept', 'plan'];
+const PLAN_MODE_TOOL_NAMES = new Set([
+    'search_code',
+    'list_files',
+    'list_directories',
+    'read_file',
+    'grep_code',
+    'find_symbol',
+    'list_symbols',
+    'hover_symbol',
+    'signature_help',
+    'read_document',
+    'analyze_image',
+    'run_command',
+]);
+const PLAN_MODE_RUN_COMMAND_NAMES = new Set([
+    'pwd',
+    'ls',
+    'find',
+    'fd',
+    'rg',
+    'grep',
+    'cat',
+    'sed',
+    'nl',
+    'head',
+    'tail',
+    'wc',
+    'jq',
+]);
+const PLAN_MODE_RUN_COMMAND_ACTION = 'Plan mode is read-only inspection only. Use read_file, read_document, grep_code, list_files, list_directories, symbol tools, or a bounded file/directory reading command. Switch to Default mode for tests, builds, diagnostics, installs, project execution, network probes, or edits.';
+export function normalizeAgentMode(value) {
+    return AGENT_MODES.includes(value)
+        ? value
+        : 'default';
+}
+export function nextAgentMode(mode) {
+    if (mode === 'default')
+        return 'auto-accept';
+    if (mode === 'auto-accept')
+        return 'plan';
+    return 'default';
+}
+export function agentModeAllowsTool(mode, toolName) {
+    return mode !== 'plan' || PLAN_MODE_TOOL_NAMES.has(toolName);
+}
+function getUnquotedShellText(command) {
+    let quote = null;
+    let escaped = false;
+    let text = '';
+    for (const char of String(command)) {
+        if (escaped) {
+            escaped = false;
+            text += ' ';
+            continue;
+        }
+        if (char === '\\' && quote !== "'") {
+            escaped = true;
+            text += ' ';
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            text += ' ';
+            continue;
+        }
+        if (char === "'" || char === '"' || char === '`') {
+            quote = char;
+            text += ' ';
+            continue;
+        }
+        text += char;
+    }
+    return text;
+}
+function planModeRunCommandBlockReason(command) {
+    const raw = String(command);
+    const text = getUnquotedShellText(command).trim();
+    if (!text)
+        return 'Plan mode run_command requires a command.';
+    if (/[<>]/.test(text) ||
+        /\$\(/.test(text) ||
+        /\bfind\b[\s\S]*(?:\s-delete\b|\s-exec\b)/.test(text) ||
+        /\bsed\b[\s\S]*(?:^|\s|["'])-i(?:\b|[A-Za-z])/.test(raw)) {
+        return PLAN_MODE_RUN_COMMAND_ACTION;
+    }
+    const segments = text
+        .split(/\s*(?:&&|\|\||;|\|)\s*/g)
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+    if (segments.length === 0)
+        return 'Plan mode run_command requires a command.';
+    for (const segment of segments) {
+        const tokens = segment.match(/\S+/g) ?? [];
+        let commandName = '';
+        for (const token of tokens) {
+            if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(token))
+                continue;
+            if (token === 'command')
+                continue;
+            commandName = token;
+            break;
+        }
+        commandName = commandName.split('/').pop() ?? commandName;
+        if (!PLAN_MODE_RUN_COMMAND_NAMES.has(commandName)) {
+            return PLAN_MODE_RUN_COMMAND_ACTION;
+        }
+    }
+    return null;
+}
+export function buildAgentModeToolBlockedResult(mode, call) {
+    if (mode !== 'plan')
+        return null;
+    if (!PLAN_MODE_TOOL_NAMES.has(call.name)) {
+        return buildPlanModeToolBlockedResult(call.name);
+    }
+    if (call.name !== 'run_command')
+        return null;
+    const command = String(call.args?.command ?? call.args?.cmd ?? '');
+    const reason = planModeRunCommandBlockReason(command);
+    return reason ? buildPlanModeToolBlockedResult(call.name, reason) : null;
+}
+export function buildPlanModeToolBlockedResult(toolName, action = 'Plan mode is read-only inspection only. Ask any needed question, use allowed inspection tools, or tell the user to switch modes before execution.') {
+    return {
+        ok: false,
+        failureCategory: 'policy_blocked',
+        failureDetails: {
+            category: 'policy_blocked',
+            tool: toolName,
+            action,
+        },
+        error: `Plan mode blocked ${toolName}. ${action}`,
+    };
+}
+export function agentModeLabel(mode) {
+    if (mode === 'auto-accept')
+        return 'Auto-Accept';
+    if (mode === 'plan')
+        return 'Plan · read-only';
+    return 'Default';
+}