@thegitai/cli 1.0.0-beta.1

package/dist/src/api/models.js

@@ -0,0 +1,110 @@
+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';
+function sanitizeModelInfo(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return null;
+    }
+    const value = raw;
+    const id = Number(value.id);
+    const label = String(value.label ?? '').trim();
+    if (!Number.isInteger(id) || id <= 0 || !label) {
+        return null;
+    }
+    return { id, label };
+}
+export function getModelsCachePath(env = process.env) {
+    return path.join(getClientStateDir(env), 'models.json');
+}
+export function readCachedServerModels(env = process.env) {
+    const filePath = getModelsCachePath(env);
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+        const serverUrl = String(parsed.serverUrl ?? '').trim();
+        const selectedModelId = Number(parsed.selectedModelId);
+        const models = Array.isArray(parsed.models)
+            ? parsed.models.map(sanitizeModelInfo).filter(Boolean)
+            : [];
+        if (!serverUrl ||
+            !Number.isInteger(selectedModelId) ||
+            selectedModelId <= 0 ||
+            models.length === 0) {
+            return null;
+        }
+        return {
+            serverUrl,
+            selectedModelId,
+            models,
+            updatedAt: String(parsed.updatedAt ?? ''),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function writeCachedServerModels(cache, env = process.env) {
+    const filePath = getModelsCachePath(env);
+    mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    writeFileSync(filePath, `${JSON.stringify(cache, null, 2)}\n`, {
+        encoding: 'utf8',
+        mode: 0o600,
+    });
+}
+export async function fetchServerModels({ config, fetchImpl = globalThis.fetch, }) {
+    const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/models`, {
+        headers: {
+            authorization: `Bearer ${config.token}`,
+        },
+    });
+    const data = (await readJsonResponse(response));
+    if (!response.ok) {
+        throw new Error(failureMessage(data, response.status));
+    }
+    const models = Array.isArray(data?.models)
+        ? data.models.map(sanitizeModelInfo).filter(Boolean)
+        : [];
+    if (models.length === 0) {
+        throw new Error('Server returned an invalid model list.');
+    }
+    return {
+        models,
+    };
+}
+export function selectServerModel({ requestedModelId, cached, serverModels, }) {
+    const supportedIds = new Set(serverModels.models.map((model) => model.id));
+    const requested = requestedModelId == null ? null : Number(requestedModelId);
+    if (requested != null) {
+        if (supportedIds.has(requested)) {
+            return requested;
+        }
+        throw new Error(`Server does not support model "${requested}".`);
+    }
+    for (const candidate of [cached?.selectedModelId, serverModels.models[0]?.id]) {
+        const id = Number(candidate);
+        if (Number.isInteger(id) && supportedIds.has(id)) {
+            return id;
+        }
+    }
+    throw new Error('Server did not advertise a usable model.');
+}
+export function validateServerModel(modelId, serverModels) {
+    const requested = Number(modelId);
+    if (!Number.isInteger(requested) || requested <= 0) {
+        throw new Error('Model id is required.');
+    }
+    if (!serverModels.models.some((model) => model.id === requested)) {
+        throw new Error(`Server does not support model "${requested}".`);
+    }
+    return requested;
+}
+export function updateSelectedModelCache({ config, selectedModelId, serverModels, env = process.env, }) {
+    writeCachedServerModels({
+        serverUrl: normalizeServerUrl(config.serverUrl),
+        selectedModelId,
+        models: serverModels.models,
+        updatedAt: new Date().toISOString(),
+    }, env);
+}

package/dist/src/api/sessions.js

@@ -0,0 +1,72 @@
+import { createSessionSafetyState } from '../session-safety.js';
+import { getSessionProjectKey, snapshotFromSession, } from '../session-store.js';
+import { authorizedJson } from './http.js';
+function sessionListPath(rootDir) {
+    const query = new URLSearchParams({
+        projectKey: getSessionProjectKey(rootDir),
+    });
+    return `/v1/sessions?${query}`;
+}
+function sessionPath(rootDir, identifier) {
+    const query = new URLSearchParams({
+        projectKey: getSessionProjectKey(rootDir),
+    });
+    return `/v1/sessions/${encodeURIComponent(identifier)}?${query}`;
+}
+function metadataOnlySnapshot(snapshot) {
+    const providerSelection = snapshot.serverState?.providerSelection &&
+        typeof snapshot.serverState.providerSelection === 'object' &&
+        !Array.isArray(snapshot.serverState.providerSelection)
+        ? { providerSelection: snapshot.serverState.providerSelection }
+        : {};
+    return {
+        ...snapshot,
+        history: [],
+        clientState: {
+            editCounter: 0,
+            editJournal: [],
+            stickyFilePaths: [],
+            safety: createSessionSafetyState(),
+        },
+        serverState: providerSelection,
+    };
+}
+export function createServerSessionClient({ config, fetchImpl = globalThis.fetch, }) {
+    return {
+        async list(rootDir) {
+            const data = (await authorizedJson({
+                config,
+                path: sessionListPath(rootDir),
+                fetchImpl,
+            }));
+            return Array.isArray(data?.sessions) ? data.sessions : [];
+        },
+        async load(rootDir, identifier) {
+            const data = (await authorizedJson({
+                config,
+                path: sessionPath(rootDir, identifier),
+                fetchImpl,
+            }));
+            const snapshot = data?.session;
+            if (!snapshot?.id) {
+                throw new Error('Server returned an invalid session.');
+            }
+            return snapshot;
+        },
+        async save(session) {
+            const snapshot = snapshotFromSession(session);
+            const body = {
+                messageCount: snapshot.history.length,
+                session: metadataOnlySnapshot(snapshot),
+            };
+            await authorizedJson({
+                config,
+                path: sessionPath(snapshot.rootDir, snapshot.id),
+                method: 'PUT',
+                body,
+                fetchImpl,
+            });
+            return snapshot;
+        },
+    };
+}

package/dist/src/artifact-policy.js

@@ -0,0 +1,207 @@
+import path from 'node:path';
+function createArtifactNameSet(values) {
+    const lookup = Object.fromEntries(values.map((value) => [value, true]));
+    return {
+        has: (value) => lookup[value] === true,
+        *[Symbol.iterator]() {
+            yield* values;
+        },
+    };
+}
+export const ARTIFACT_IGNORE_FILES = createArtifactNameSet([
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+    'bun.lockb',
+    'Cargo.lock.bak',
+]);
+export const BINARY_ARTIFACT_EXTENSIONS = createArtifactNameSet([
+    '.png',
+    '.jpg',
+    '.jpeg',
+    '.gif',
+    '.ico',
+    '.webp',
+    '.avif',
+    '.woff',
+    '.woff2',
+    '.ttf',
+    '.eot',
+    '.mp4',
+    '.mp3',
+    '.wav',
+    '.ogg',
+    '.zip',
+    '.tar',
+    '.gz',
+    '.bz2',
+    '.7z',
+    '.pdf',
+    '.exe',
+    '.dll',
+    '.so',
+    '.dylib',
+    '.bin',
+    '.dat',
+    '.db',
+    '.sqlite',
+    '.map',
+    '.min.js',
+    '.min.css',
+]);
+const REPO_METADATA_DIRS = [
+    '.git',
+    '.thegitai',
+    '.thegitai-debug',
+];
+const EDITOR_METADATA_DIRS = [
+    '.idea',
+    '.vscode',
+    '.fleet',
+    '.zed',
+    '.history',
+    '.vs',
+];
+const PACKAGE_DEPENDENCY_DIRS = [
+    'node_modules',
+    'vendor',
+    '.venv',
+    'venv',
+    'env',
+];
+const GENERATED_OUTPUT_DIRS = [
+    '.next',
+    '.nuxt',
+    '.output',
+    '.vercel',
+    '.vite',
+    '.svelte-kit',
+    '.angular',
+    '.astro',
+    '.expo',
+    '.parcel-cache',
+    '.serverless',
+    '.build',
+    'DerivedData',
+    'dist',
+    'build',
+    'out',
+    'target',
+    'coverage',
+    'tmp',
+    'temp',
+    'obj',
+];
+const TOOL_CACHE_DIRS = [
+    '.turbo',
+    '.yarn',
+    '.pnpm-store',
+    '.npm',
+    '.gradle',
+    '.terraform',
+    '.mypy_cache',
+    '.pytest_cache',
+    '.ruff_cache',
+    '.sass-cache',
+    '.cache',
+    '.tox',
+    '.nox',
+    '.dart_tool',
+    '__pycache__',
+];
+export const ARTIFACT_IGNORE_DIRS = createArtifactNameSet([
+    ...REPO_METADATA_DIRS,
+    ...EDITOR_METADATA_DIRS,
+    ...PACKAGE_DEPENDENCY_DIRS,
+    ...GENERATED_OUTPUT_DIRS,
+    ...TOOL_CACHE_DIRS,
+]);
+export const ARTIFACT_INSPECT_BLOCK_DIRS = ARTIFACT_IGNORE_DIRS;
+export const ARTIFACT_IGNORE_PATH_PREFIXES = [
+    'storage/framework/cache',
+    'storage/framework/sessions',
+    'storage/framework/views',
+    'storage/logs',
+    'bootstrap/cache',
+    'var/cache',
+    'var/log',
+];
+export const ARTIFACT_FALLBACK_IGNORE_GLOBS = [
+    ...[...ARTIFACT_IGNORE_DIRS].flatMap((dir) => [
+        `${dir}/**`,
+        `**/${dir}/**`,
+    ]),
+    '.env',
+    '.env.*',
+    '**/*.lock',
+    '**/package-lock.json',
+    '**/yarn.lock',
+    '**/pnpm-lock.yaml',
+    ...ARTIFACT_IGNORE_PATH_PREFIXES.map((prefix) => `${prefix}/**`),
+];
+const SENSITIVE_BASENAME_PATTERNS = [
+    /^\.env(?:\..+)?$/i,
+    /^\.?npmrc$/i,
+    /^\.?pypirc$/i,
+    /^credentials(?:\..*)?$/i,
+    /^secrets?(?:\..*)?$/i,
+];
+const SENSITIVE_PATH_PATTERNS = [
+    /(^|[/\\])\.aws[/\\]credentials$/i,
+    /(^|[/\\])\.config[/\\]gcloud[/\\]/i,
+    /(^|[/\\])credentials?([._-]|$)/i,
+    /(^|[/\\])secrets?([._-]|$)/i,
+    /(^|[/\\])private[-_]?key([._-]|$)/i,
+    /\.(?:pem|key|p12|pfx)$/i,
+];
+export function normalizeArtifactPath(relPath) {
+    return String(relPath ?? '')
+        .split(/[\\/]+/)
+        .filter(Boolean)
+        .join('/');
+}
+export function getIgnoredArtifactDir(relPath) {
+    const parts = normalizeArtifactPath(relPath).split('/').filter(Boolean);
+    return parts.find((part) => ARTIFACT_IGNORE_DIRS.has(part)) ?? null;
+}
+export function getBlockedArtifactInspectDir(relPath) {
+    const parts = normalizeArtifactPath(relPath).split('/').filter(Boolean);
+    return parts.find((part) => ARTIFACT_INSPECT_BLOCK_DIRS.has(part)) ?? null;
+}
+export function matchesArtifactIgnorePrefix(relPath) {
+    const normalized = normalizeArtifactPath(relPath);
+    for (const prefix of ARTIFACT_IGNORE_PATH_PREFIXES) {
+        if (normalized === prefix || normalized.startsWith(`${prefix}/`)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function shouldIgnoreArtifactPath(relPath) {
+    return (getIgnoredArtifactDir(relPath) !== null ||
+        matchesArtifactIgnorePrefix(relPath));
+}
+export function isSensitiveProjectPath(value) {
+    const normalized = normalizeArtifactPath(String(value ?? '').trim());
+    if (!normalized)
+        return false;
+    const base = path.posix.basename(normalized);
+    return (SENSITIVE_BASENAME_PATTERNS.some((pattern) => pattern.test(base)) ||
+        SENSITIVE_PATH_PATTERNS.some((pattern) => pattern.test(normalized)));
+}
+export function relativeProjectPath(rootDir, absPath) {
+    const relPath = path.relative(path.resolve(rootDir), path.resolve(absPath));
+    if (!relPath ||
+        relPath === '.' ||
+        relPath.startsWith('..') ||
+        path.isAbsolute(relPath)) {
+        return null;
+    }
+    return relPath;
+}
+export function normalizeProjectRelativePath(rootDir, targetPath) {
+    const absPath = path.isAbsolute(targetPath)
+        ? targetPath
+        : path.join(rootDir, targetPath);
+    return relativeProjectPath(rootDir, absPath);
+}

package/dist/src/client-state.js

@@ -0,0 +1,14 @@
+import os from 'node:os';
+import path from 'node:path';
+const STORE_DIR = 'thegitai';
+export function getClientStateDir(env = process.env) {
+    const configured = String(env.THEGITAI_STATE_DIR ?? env.THEGITAI_SESSION_DIR ?? '').trim();
+    if (configured) {
+        return path.resolve(configured);
+    }
+    if (process.platform === 'win32') {
+        return path.join(env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), STORE_DIR);
+    }
+    const stateHome = String(env.XDG_STATE_HOME ?? '').trim();
+    return path.join(stateHome || path.join(os.homedir(), '.local', 'state'), STORE_DIR);
+}

package/dist/src/core/clipboard.js

@@ -0,0 +1,208 @@
+import { execFileSync } from 'node:child_process';
+const MAX_IMAGE_SIZE_BYTES = 10 * 1024 * 1024;
+const MIME_BY_EXT = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+};
+const SUPPORTED_MIME_TYPES = new Set(Object.values(MIME_BY_EXT));
+export class ClipboardError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'ClipboardError';
+    }
+}
+export function isSupportedImageMimeType(mime) {
+    return SUPPORTED_MIME_TYPES.has(mime);
+}
+function whichSync(cmd) {
+    try {
+        execFileSync('which', [cmd], { stdio: 'ignore', timeout: 2000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isWayland() {
+    return Boolean(process.env.WAYLAND_DISPLAY ||
+        process.env.XDG_SESSION_TYPE === 'wayland');
+}
+function isMaxBufferError(err) {
+    return (err?.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER' ||
+        /maxBuffer/.test(String(err?.message ?? '')));
+}
+function tryReadWithXclip() {
+    if (!whichSync('xclip'))
+        return null;
+    try {
+        const buf = execFileSync('xclip', ['-selection', 'clipboard', '-t', 'image/png', '-o'], {
+            timeout: 5000,
+            maxBuffer: MAX_IMAGE_SIZE_BYTES,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        if (buf.length) {
+            return { base64Data: buf.toString('base64'), mimeType: 'image/png' };
+        }
+    }
+    catch (err) {
+        if (isMaxBufferError(err)) {
+            throw new ClipboardError('Clipboard image exceeds 10MB size limit.', 'READ_FAILED');
+        }
+    }
+    return null;
+}
+function tryReadWithWlPaste() {
+    if (!whichSync('wl-paste'))
+        return null;
+    try {
+        const buf = execFileSync('wl-paste', ['--type', 'image/png'], {
+            timeout: 5000,
+            maxBuffer: MAX_IMAGE_SIZE_BYTES,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        if (buf.length) {
+            return { base64Data: buf.toString('base64'), mimeType: 'image/png' };
+        }
+    }
+    catch (err) {
+        if (isMaxBufferError(err)) {
+            throw new ClipboardError('Clipboard image exceeds 10MB size limit.', 'READ_FAILED');
+        }
+    }
+    return null;
+}
+function readClipboardLinux() {
+    if (isWayland()) {
+        const wlResult = tryReadWithWlPaste();
+        if (wlResult)
+            return wlResult;
+    }
+    const xclipResult = tryReadWithXclip();
+    if (xclipResult)
+        return xclipResult;
+    if (!isWayland() && !whichSync('xclip')) {
+        throw new ClipboardError('xclip is required for clipboard image paste on X11. Install xclip.', 'NO_TOOL');
+    }
+    if (isWayland() && !whichSync('wl-paste') && !whichSync('xclip')) {
+        throw new ClipboardError('wl-paste or xclip is required for clipboard image paste. Install wl-clipboard or xclip.', 'NO_TOOL');
+    }
+    throw new ClipboardError('Clipboard contains no image data.', 'NO_IMAGE');
+}
+function readClipboardDarwin() {
+    if (whichSync('pngpaste')) {
+        try {
+            const buf = execFileSync('pngpaste', ['-'], {
+                timeout: 5000,
+                maxBuffer: MAX_IMAGE_SIZE_BYTES,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            if (!buf.length) {
+                throw new ClipboardError('Clipboard contains no image data.', 'NO_IMAGE');
+            }
+            return { base64Data: buf.toString('base64'), mimeType: 'image/png' };
+        }
+        catch (err) {
+            if (err instanceof ClipboardError)
+                throw err;
+            if (isMaxBufferError(err)) {
+                throw new ClipboardError('Clipboard image exceeds 10MB size limit.', 'READ_FAILED');
+            }
+            throw new ClipboardError('Clipboard contains no image data.', 'NO_IMAGE');
+        }
+    }
+    throw new ClipboardError('pngpaste is required for clipboard image paste on macOS. Install via: brew install pngpaste', 'NO_TOOL');
+}
+export function readClipboardImage(platform = process.platform) {
+    switch (platform) {
+        case 'linux':
+            return readClipboardLinux();
+        case 'darwin':
+            return readClipboardDarwin();
+        default:
+            throw new ClipboardError(`Clipboard image paste is not supported on ${platform}.`, 'NO_TOOL');
+    }
+}
+export function readClipboardText(platform = process.platform) {
+    try {
+        if (platform === 'darwin') {
+            return normalizeClipboardTextOutput(execFileSync('pbpaste', [], {
+                encoding: 'utf-8',
+                timeout: 2000,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            }));
+        }
+        if (platform === 'win32') {
+            return normalizeClipboardTextOutput(execFileSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', 'Get-Clipboard -Raw'], {
+                encoding: 'utf-8',
+                timeout: 2000,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            }));
+        }
+        if (platform === 'linux') {
+            if (isWayland() && whichSync('wl-paste')) {
+                return normalizeClipboardTextOutput(execFileSync('wl-paste', ['--type', 'text/plain'], {
+                    encoding: 'utf-8',
+                    timeout: 2000,
+                    stdio: ['ignore', 'pipe', 'ignore'],
+                }));
+            }
+            if (whichSync('xclip')) {
+                return normalizeClipboardTextOutput(execFileSync('xclip', ['-selection', 'clipboard', '-o'], {
+                    encoding: 'utf-8',
+                    timeout: 2000,
+                    stdio: ['ignore', 'pipe', 'ignore'],
+                }));
+            }
+        }
+    }
+    catch {
+        return '';
+    }
+    return '';
+}
+function normalizeClipboardTextOutput(text) {
+    return text.replace(/\r?\n$/, '');
+}
+function tryWriteClipboardCommand(cmd, args, text) {
+    if (!whichSync(cmd))
+        return false;
+    try {
+        execFileSync(cmd, args, {
+            input: text,
+            timeout: 2000,
+            stdio: ['pipe', 'ignore', 'ignore'],
+        });
+        return true;
+    }
+    catch (error) {
+        throw new ClipboardError(`Failed to write clipboard with ${cmd}: ${error.message}`, 'WRITE_FAILED');
+    }
+}
+export function writeClipboardText(text, platform = process.platform) {
+    const value = String(text ?? '');
+    if (platform === 'darwin') {
+        if (tryWriteClipboardCommand('pbcopy', [], value))
+            return;
+        throw new ClipboardError('pbcopy is required to copy text on macOS.', 'NO_TOOL');
+    }
+    if (platform === 'win32') {
+        if (tryWriteClipboardCommand('clip.exe', [], value))
+            return;
+        throw new ClipboardError('clip.exe is required to copy text on Windows.', 'NO_TOOL');
+    }
+    if (platform === 'linux') {
+        if (isWayland() && tryWriteClipboardCommand('wl-copy', [], value))
+            return;
+        if (tryWriteClipboardCommand('xclip', ['-selection', 'clipboard'], value))
+            return;
+        if (tryWriteClipboardCommand('xsel', ['--clipboard', '--input'], value))
+            return;
+        throw new ClipboardError('wl-copy, xclip, or xsel is required to copy text. Install wl-clipboard, xclip, or xsel.', 'NO_TOOL');
+    }
+    throw new ClipboardError(`Clipboard text copy is not supported on ${platform}.`, 'NO_TOOL');
+}

package/dist/src/core/open-url.js

@@ -0,0 +1,32 @@
+import { spawn } from 'node:child_process';
+export function resolveOpenUrlCommand(url, platform = process.platform) {
+    const parsed = new URL(url);
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        throw new Error('Only http:// and https:// links can be opened.');
+    }
+    const href = parsed.href;
+    if (platform === 'darwin') {
+        return { command: 'open', args: [href] };
+    }
+    if (platform === 'win32') {
+        return { command: 'rundll32', args: ['url.dll,FileProtocolHandler', href] };
+    }
+    return { command: 'xdg-open', args: [href] };
+}
+export async function openUrl(url, platform = process.platform) {
+    const { command, args } = resolveOpenUrlCommand(url, platform);
+    return await new Promise((resolve) => {
+        const child = spawn(command, args, {
+            stdio: 'ignore',
+        });
+        let settled = false;
+        const finish = (opened) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(opened);
+        };
+        child.once('error', () => finish(false));
+        child.once('exit', (code) => finish(code === 0));
+    });
+}