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

package/dist/src/update-check.js

@@ -0,0 +1,205 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { stdin as input, stdout as output } from 'node:process';
+import { emitKeypressEvents } from 'node:readline';
+import readline from 'node:readline/promises';
+import { fileURLToPath } from 'node:url';
+import chalk from './colors.js';
+import { isAbortError } from './utils.js';
+import { compareCliVersions, UNKNOWN_CLI_VERSION } from './version.js';
+const PACKAGE_NAME = '@thegitai/cli';
+export function resolveInstallCommand(version, moduleDir = path.dirname(fileURLToPath(import.meta.url))) {
+    const spec = `${PACKAGE_NAME}@${version}`;
+    const location = moduleDir.replace(/\\/g, '/').toLowerCase();
+    if (location.includes('/pnpm/global/')) {
+        return { program: 'pnpm', args: ['add', '-g', spec] };
+    }
+    if (location.includes('/.bun/install/global/')) {
+        return { program: 'bun', args: ['add', '-g', spec] };
+    }
+    return { program: 'npm', args: ['install', '-g', spec] };
+}
+export function buildUpdateOffer({ currentVersion, latestVersion, moduleDir, }) {
+    if (!latestVersion)
+        return null;
+    if (currentVersion === UNKNOWN_CLI_VERSION)
+        return null;
+    const ordering = compareCliVersions(currentVersion, latestVersion);
+    if (ordering === null || ordering >= 0)
+        return null;
+    const { program, args } = resolveInstallCommand(latestVersion, moduleDir);
+    return {
+        currentVersion,
+        latestVersion,
+        program,
+        args,
+        display: [program, ...args].join(' '),
+    };
+}
+export const UPDATE_OPTIONS = ['update', 'skip'];
+const UPDATE_KEY_HINT = '↑/↓ choose  •  Enter accepts  •  Ctrl+C quits';
+function formatUpdateHeader(offer) {
+    return [
+        '',
+        `  ${chalk.yellow('✨ Update available')} — ${chalk.dim(offer.currentVersion)} → ${chalk.bold(offer.latestVersion)}`,
+        '',
+        '  TheGitAI works best with the latest version. TheGitAI may not work',
+        '  optimally if not updated.',
+        '',
+    ].join('\n');
+}
+export function formatUpdateOptions(offer, selectedIndex = 0) {
+    const rows = [
+        { note: `(runs \`${offer.display}\`)`, text: 'Update now' },
+        { note: '(Agent may not work optimally)', text: 'Skip' },
+    ];
+    return [
+        ...rows.map(({ note, text }, index) => index === selectedIndex
+            ? `  ${chalk.cyan(`› ${index + 1}. ${text}`)} ${chalk.dim(note)}`
+            : `    ${chalk.dim(`${index + 1}.`)} ${text} ${chalk.dim(note)}`),
+        '',
+        `  ${chalk.dim(UPDATE_KEY_HINT)}`,
+        '',
+    ].join('\n');
+}
+export function formatUpdateScreen(offer, selectedIndex = 0) {
+    return `${formatUpdateHeader(offer)}\n${formatUpdateOptions(offer, selectedIndex)}`;
+}
+export function readUpdateKey(key, selectedIndex) {
+    const name = key.name ?? '';
+    if (key.ctrl && (name === 'c' || name === 'd')) {
+        return { kind: 'answer', answer: 'cancel' };
+    }
+    if (name === 'return' || name === 'enter') {
+        return { kind: 'answer', answer: UPDATE_OPTIONS[selectedIndex] ?? 'update' };
+    }
+    if (name === 'up' || (name === 'tab' && key.sequence === '\u001b[Z')) {
+        return { kind: 'select', index: Math.max(selectedIndex - 1, 0) };
+    }
+    if (name === 'down' || name === 'tab') {
+        return { kind: 'select', index: Math.min(selectedIndex + 1, UPDATE_OPTIONS.length - 1) };
+    }
+    const digit = Number.parseInt(key.sequence ?? '', 10);
+    if (Number.isInteger(digit) && digit >= 1 && digit <= UPDATE_OPTIONS.length) {
+        return { kind: 'answer', answer: UPDATE_OPTIONS[digit - 1] };
+    }
+    return { kind: 'ignore' };
+}
+export function readUpdateChoice(answer) {
+    const value = answer.trim().toLowerCase();
+    if (value === '' || value === '1' || value === 'y' || value === 'yes') {
+        return 'update';
+    }
+    return 'skip';
+}
+export async function resolveUpdateAnswer(question) {
+    try {
+        return readUpdateChoice(await question());
+    }
+    catch (error) {
+        if (isAbortError(error))
+            return 'cancel';
+        throw error;
+    }
+}
+export function renderedRowCount(text, columns) {
+    const width = Math.max(1, columns);
+    const lines = text.split('\n');
+    if (lines[lines.length - 1] === '')
+        lines.pop();
+    return lines.reduce((rows, line) => {
+        const visible = [...line.replace(/\x1b\[[0-9;]*m/g, '')].length;
+        return rows + Math.max(1, Math.ceil(visible / width));
+    }, 0);
+}
+async function askUpdateChoiceWithKeys(offer) {
+    let selected = 0;
+    const show = (index) => {
+        const rows = renderedRowCount(`${formatUpdateOptions(offer, selected)}\n`, output.columns ?? 80);
+        selected = index;
+        output.write(`\u001b[${rows}A\u001b[0J${formatUpdateOptions(offer, selected)}\n`);
+    };
+    emitKeypressEvents(input);
+    const wasRaw = input.isRaw === true;
+    input.setRawMode(true);
+    input.resume();
+    try {
+        return await new Promise((resolve) => {
+            const onKeypress = (_text, key) => {
+                const action = readUpdateKey(key ?? {}, selected);
+                if (action.kind === 'ignore')
+                    return;
+                if (action.kind === 'select') {
+                    if (action.index !== selected)
+                        show(action.index);
+                    return;
+                }
+                const chosen = UPDATE_OPTIONS.indexOf(action.answer);
+                if (chosen >= 0 && chosen !== selected)
+                    show(chosen);
+                input.off('keypress', onKeypress);
+                resolve(action.answer);
+            };
+            input.on('keypress', onKeypress);
+        });
+    }
+    finally {
+        if (!wasRaw)
+            input.setRawMode(false);
+        input.pause();
+    }
+}
+async function askUpdateChoice(offer) {
+    if (input.isTTY && output.isTTY)
+        return await askUpdateChoiceWithKeys(offer);
+    const rl = readline.createInterface({ input, output });
+    try {
+        return await resolveUpdateAnswer(() => rl.question('  ▸ '));
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runUpdate(offer) {
+    return await new Promise((resolve) => {
+        const child = spawn(offer.program, offer.args, {
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+        child.on('error', () => resolve(false));
+        child.on('close', (code) => resolve(code === 0));
+    });
+}
+export async function offerUpdateAtStartup({ currentVersion, latestVersion, ask = askUpdateChoice, install = runUpdate, write = (text) => {
+    process.stdout.write(text);
+}, }) {
+    const offer = buildUpdateOffer({ currentVersion, latestVersion });
+    if (!offer)
+        return 'none';
+    write(`${formatUpdateScreen(offer)}\n`);
+    const answer = await ask(offer);
+    if (answer === 'cancel') {
+        write(`\n  ${chalk.dim('Cancelled. Nothing was installed.')}\n\n`);
+        return 'cancelled';
+    }
+    if (answer === 'skip') {
+        write(`\n  ${chalk.yellow(`Continuing on ${offer.currentVersion} — you'll be asked again next time.`)}\n\n`);
+        return 'skipped';
+    }
+    write(`\n  ${chalk.dim(`$ ${offer.display}`)}\n\n`);
+    if (await install(offer)) {
+        write(`\n  ${chalk.green(`✓ Updated to ${offer.latestVersion}.`)} Run ${chalk.bold('ai')} again to start.\n\n`);
+        return 'updated';
+    }
+    write([
+        '',
+        `  ${chalk.red('✖ The update did not complete.')} Run this yourself, then start ${chalk.bold('ai')} again:`,
+        '',
+        `    ${chalk.bold(offer.display)}`,
+        '',
+        `  ${chalk.dim(`Starting on ${offer.currentVersion} for now.`)}`,
+        '',
+        '',
+    ].join('\n'));
+    return 'failed';
+}

package/dist/src/usage.js

@@ -1,9 +1,12 @@
-const USAGE_WINDOWS = [
+export const USAGE_WINDOWS = [
     ['5-hour', '5-hourly'],
     ['Weekly', 'weekly'],
     ['Monthly', 'monthly'],
 ];
-function formatUtcMinute(value) {
+export function usageWindowLabel(key) {
+    return USAGE_WINDOWS.find(([, id]) => id === key)?.[0] ?? '';
+}
+export function formatUtcMinute(value) {
     if (!value)
         return 'no active usage';
     const date = new Date(value);

package/dist/src/utils.js

@@ -1,3 +1,7 @@
+export function isAbortError(error) {
+    const err = error;
+    return err?.name === 'AbortError' || err?.code === 'ABORT_ERR';
+}
 export function cosineSimilarity(a, b) {
     let dot = 0;
     let magA = 0;
@@ -17,6 +21,15 @@ export function truncate(text, maxChars = 4000) {
         return text;
     return `${text.slice(0, maxChars)}\n... (truncated)`;
 }
+export function singleLinePreview(text, maxChars) {
+    const collapsed = String(text ?? '')
+        .replace(/\n\.\.\. \(truncated\)\s*$/, '…')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (collapsed.length <= maxChars)
+        return collapsed;
+    return `${collapsed.slice(0, Math.max(0, maxChars - 1)).trimEnd()}…`;
+}
 export function clampInteger(value, fallback, max) {
     const numeric = Number(value);
     if (!Number.isFinite(numeric) || numeric <= 0) {

package/dist/src/version.js

@@ -2,7 +2,7 @@ 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';
+export const UNKNOWN_CLI_VERSION = '0.0.0';
 export function getCliVersion() {
     let dir = path.dirname(fileURLToPath(import.meta.url));
     for (let depth = 0; depth < 6; depth++) {
@@ -19,7 +19,7 @@ export function getCliVersion() {
             break;
         dir = parent;
     }
-    return UNKNOWN_VERSION;
+    return UNKNOWN_CLI_VERSION;
 }
 export function getPlatformTag() {
     return `${process.platform}-${process.arch}`;
@@ -27,3 +27,53 @@ export function getPlatformTag() {
 export function formatVersionLine() {
     return `ai ${getCliVersion()} (${getPlatformTag()}, node ${process.version})`;
 }
+const VERSION_PATTERN = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parseVersion(value) {
+    const match = VERSION_PATTERN.exec(String(value ?? '').trim());
+    if (!match)
+        return null;
+    return {
+        core: [Number(match[1]), Number(match[2]), Number(match[3])],
+        prerelease: match[4] ? match[4].split('.') : [],
+    };
+}
+function comparePrereleaseIdentifier(left, right) {
+    const leftNumeric = /^\d+$/.test(left);
+    const rightNumeric = /^\d+$/.test(right);
+    if (leftNumeric && rightNumeric) {
+        const a = Number(left);
+        const b = Number(right);
+        return a === b ? 0 : a < b ? -1 : 1;
+    }
+    if (leftNumeric !== rightNumeric)
+        return leftNumeric ? -1 : 1;
+    return left === right ? 0 : left < right ? -1 : 1;
+}
+export function isReadableCliVersion(value) {
+    return parseVersion(value) !== null;
+}
+export function compareCliVersions(left, right) {
+    const a = parseVersion(left);
+    const b = parseVersion(right);
+    if (!a || !b)
+        return null;
+    for (let index = 0; index < 3; index++) {
+        if (a.core[index] !== b.core[index]) {
+            return a.core[index] < b.core[index] ? -1 : 1;
+        }
+    }
+    if (!a.prerelease.length || !b.prerelease.length) {
+        if (a.prerelease.length === b.prerelease.length)
+            return 0;
+        return a.prerelease.length ? -1 : 1;
+    }
+    const shared = Math.min(a.prerelease.length, b.prerelease.length);
+    for (let index = 0; index < shared; index++) {
+        const ordering = comparePrereleaseIdentifier(a.prerelease[index], b.prerelease[index]);
+        if (ordering !== 0)
+            return ordering;
+    }
+    if (a.prerelease.length === b.prerelease.length)
+        return 0;
+    return a.prerelease.length < b.prerelease.length ? -1 : 1;
+}

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@thegitai/cli",
-  "version": "1.0.0-preview.5",
-  "description": "TheGitAI is an AI coding agent for your terminal. It indexes your repository, writes and edits files, runs commands, and builds features with you.",
+  "version": "1.0.0-preview.51",
+  "description": "TheGitAI is an agentic AI coding tool for your terminal. It reads and searches your repository, writes and edits files, runs your tests, and verifies the change before handing it back.",
   "keywords": [
-    "ai",
+    "agentic-ai",
     "ai-coding-agent",
     "coding-agent",
+    "ai-agent",
+    "agentic-coding",
+    "autonomous-agent",
+    "ai-pair-programming",
     "coding-assistant",
+    "code-assistant",
+    "ai",
     "terminal",
     "cli",
     "developer-tools"
@@ -14,14 +20,16 @@
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://thegit.ai",
   "bugs": {
+    "url": "https://github.com/thegitai/thegitai-cli/issues",
     "email": "support@thegit.ai"
   },
   "type": "module",
   "engines": {
-    "node": ">=24"
+    "node": ">=22"
   },
   "bin": {
-    "ai": "./dist/bin/ai.js"
+    "ai": "./dist/bin/ai.js",
+    "thegitai": "./dist/bin/ai.js"
   },
   "files": [
     "dist",
@@ -37,12 +45,17 @@
     "@lydell/node-pty-linux-x64": "1.1.0",
     "@lydell/node-pty-win32-arm64": "1.1.0",
     "@lydell/node-pty-win32-x64": "1.1.0",
-    "@thegitai/tui-darwin-arm64": "1.0.0-preview.5",
-    "@thegitai/tui-darwin-x64": "1.0.0-preview.5",
-    "@thegitai/tui-linux-x64": "1.0.0-preview.5",
-    "@thegitai/tui-win32-x64": "1.0.0-preview.5",
+    "@thegitai/tui-darwin-arm64": "1.0.0-preview.51",
+    "@thegitai/tui-darwin-x64": "1.0.0-preview.51",
+    "@thegitai/tui-linux-arm64": "1.0.0-preview.51",
+    "@thegitai/tui-linux-x64": "1.0.0-preview.51",
+    "@thegitai/tui-win32-x64": "1.0.0-preview.51",
     "@vscode/ripgrep": "1.18.0"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thegitai/thegitai-cli.git"
+  },
   "publishConfig": {
     "access": "public"
   }

package/dist/src/project-index.js

@@ -1,233 +0,0 @@
-import { existsSync, statSync } from 'node:fs';
-import path from 'node:path';
-import { listProjectFiles, scanFiles, shouldIgnorePath, } from './scanner.js';
-import { truncate } from './utils.js';
-function normalizeProjectFilePath(rootDir, filePath) {
-    const resolvedRoot = path.resolve(rootDir);
-    const resolvedFile = path.resolve(resolvedRoot, filePath);
-    const relative = path.relative(resolvedRoot, resolvedFile);
-    if (relative.startsWith('..') || path.isAbsolute(relative)) {
-        return null;
-    }
-    return relative.replace(/\\/g, '/');
-}
-function getFileSignature(rootDir, relPath) {
-    try {
-        const stat = statSync(path.join(rootDir, relPath));
-        if (!stat.isFile()) {
-            return null;
-        }
-        return `${stat.size}:${stat.mtimeMs}`;
-    }
-    catch {
-        return null;
-    }
-}
-function setChunksForFile(index, relPath, chunks) {
-    if (chunks.length === 0) {
-        index.chunksByFile.delete(relPath);
-        index.fileSignatures.delete(relPath);
-        return;
-    }
-    index.chunksByFile.set(relPath, chunks);
-    const signature = getFileSignature(index.rootDir, relPath);
-    if (signature) {
-        index.fileSignatures.set(relPath, signature);
-    }
-}
-function removeFile(index, relPath) {
-    index.chunksByFile.delete(relPath);
-    index.fileSignatures.delete(relPath);
-}
-function countIndexedChunks(index) {
-    return Array.from(index.chunksByFile.values()).reduce((sum, chunks) => sum + chunks.length, 0);
-}
-async function initializeIndex(index) {
-    if (index.initialized) {
-        return countIndexedChunks(index);
-    }
-    if (!index._initializing) {
-        index._initializing = scanProjectIntoIndex(index).finally(() => {
-            index._initializing = null;
-        });
-    }
-    return index._initializing;
-}
-async function scanProjectIntoIndex(index) {
-    const files = listProjectFiles(index.rootDir);
-    const chunks = await scanFiles(index.rootDir, files);
-    index.fileSignatures.clear();
-    index.chunksByFile.clear();
-    for (const filePath of files) {
-        const signature = getFileSignature(index.rootDir, filePath);
-        if (signature) {
-            index.fileSignatures.set(filePath, signature);
-        }
-    }
-    for (const chunk of chunks) {
-        const current = index.chunksByFile.get(chunk.filePath) ?? [];
-        current.push(chunk);
-        index.chunksByFile.set(chunk.filePath, current);
-    }
-    index.initialized = true;
-    index.onStatus?.(`Local code index ready: ${index.fileSignatures.size.toLocaleString()} files.`);
-    return chunks.length;
-}
-function queryTerms(query) {
-    const parts = query
-        .toLowerCase()
-        .split(/[^a-z0-9_./-]+/i)
-        .map((part) => part.trim())
-        .filter(Boolean);
-    return [...new Set(parts)];
-}
-function countOccurrences(haystack, needle) {
-    if (!needle)
-        return 0;
-    let count = 0;
-    let cursor = 0;
-    while (cursor < haystack.length) {
-        const index = haystack.indexOf(needle, cursor);
-        if (index === -1)
-            break;
-        count += 1;
-        cursor = index + needle.length;
-    }
-    return count;
-}
-function scoreChunk(terms, chunk) {
-    const filePath = chunk.filePath.toLowerCase();
-    const content = chunk.content.toLowerCase();
-    let score = 0;
-    for (const term of terms) {
-        if (term.length < 2)
-            continue;
-        score += countOccurrences(filePath, term) * 3;
-        score += countOccurrences(content, term);
-        if (chunk.label?.toLowerCase().includes(term)) {
-            score += 2;
-        }
-    }
-    return score;
-}
-function flattenChunks(index) {
-    return Array.from(index.chunksByFile.values()).flat();
-}
-export function createIndex({ rootDir, onStatus = null, onContextLog = null, }) {
-    return {
-        rootDir: path.resolve(rootDir),
-        initialized: false,
-        _initializing: null,
-        fileSignatures: new Map(),
-        chunksByFile: new Map(),
-        onStatus,
-        onContextLog,
-    };
-}
-export async function searchIndex(index, query, limit = 10) {
-    await initializeIndex(index);
-    const terms = queryTerms(query);
-    if (terms.length === 0) {
-        return { results: [], retrievalTokensUsed: 0 };
-    }
-    const scored = flattenChunks(index)
-        .map((chunk) => ({
-        ...chunk,
-        score: scoreChunk(terms, chunk),
-    }))
-        .filter((chunk) => chunk.score > 0)
-        .sort((a, b) => b.score - a.score || a.filePath.localeCompare(b.filePath))
-        .slice(0, Math.max(1, Math.min(limit, 20)));
-    if (scored.length) {
-        const visible = scored
-            .slice(0, 6)
-            .map((chunk) => `${chunk.filePath}:${chunk.startLine}-${chunk.endLine}`)
-            .join(', ');
-        index.onContextLog?.(`Local search hit: ${visible}`);
-    }
-    return {
-        results: scored,
-        retrievalTokensUsed: 0,
-    };
-}
-export function formatIndexResults(results) {
-    return results.map((chunk) => ({
-        ...chunk,
-        content: truncate(chunk.content, 1200),
-    }));
-}
-export function listIndexFiles(index) {
-    return [...index.fileSignatures.keys()].sort();
-}
-export async function upsertIndexFile(index, filePath) {
-    if (!index.initialized) {
-        return { indexedChunks: 0, retrievalTokensUsed: 0 };
-    }
-    const relPath = normalizeProjectFilePath(index.rootDir, filePath);
-    if (!relPath || shouldIgnorePath(relPath)) {
-        return { indexedChunks: 0, retrievalTokensUsed: 0 };
-    }
-    const chunks = existsSync(path.join(index.rootDir, relPath))
-        ? await scanFiles(index.rootDir, [relPath])
-        : [];
-    setChunksForFile(index, relPath, chunks);
-    return {
-        indexedChunks: chunks.length,
-        retrievalTokensUsed: 0,
-    };
-}
-export async function removeIndexFile(index, filePath) {
-    const relPath = normalizeProjectFilePath(index.rootDir, filePath);
-    if (!relPath)
-        return;
-    removeFile(index, relPath);
-}
-export async function syncIndexFromDisk(index) {
-    if (!index.initialized) {
-        const indexedChunks = await initializeIndex(index);
-        return {
-            added: index.fileSignatures.size,
-            modified: 0,
-            removed: 0,
-            indexedChunks,
-            retrievalTokensUsed: 0,
-        };
-    }
-    const currentFiles = new Set(listProjectFiles(index.rootDir));
-    let added = 0;
-    let modified = 0;
-    let removed = 0;
-    let indexedChunks = 0;
-    for (const existing of [...index.fileSignatures.keys()]) {
-        if (!currentFiles.has(existing)) {
-            removeFile(index, existing);
-            removed += 1;
-        }
-    }
-    for (const relPath of currentFiles) {
-        const nextSignature = getFileSignature(index.rootDir, relPath);
-        if (!nextSignature)
-            continue;
-        const previousSignature = index.fileSignatures.get(relPath);
-        if (!previousSignature) {
-            const chunks = await scanFiles(index.rootDir, [relPath]);
-            setChunksForFile(index, relPath, chunks);
-            added += 1;
-            indexedChunks += chunks.length;
-            continue;
-        }
-        if (previousSignature !== nextSignature) {
-            const chunks = await scanFiles(index.rootDir, [relPath]);
-            setChunksForFile(index, relPath, chunks);
-            modified += 1;
-            indexedChunks += chunks.length;
-        }
-    }
-    return {
-        added,
-        modified,
-        removed,
-        indexedChunks,
-        retrievalTokensUsed: 0,
-    };
-}