@thegitai/cli 1.0.0-beta.1

package/dist/src/tools/grep-code.js

@@ -0,0 +1,331 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { ARTIFACT_IGNORE_FILES, BINARY_ARTIFACT_EXTENSIONS, } from '../artifact-policy.js';
+import { ALWAYS_IGNORE_DIRS, listProjectFiles, shouldIgnorePath, } from '../scanner.js';
+import { clampInteger } from '../utils.js';
+import { getRipgrepPathCandidates, isRipgrepExecutionUnavailable, } from './ripgrep.js';
+import { getCommandErrorText, getCommandExitCode, } from './exec-utils.js';
+const MAX_RESULTS = 200;
+const MAX_OUTPUT_CHARS = 8000;
+const MAX_FALLBACK_FILE_BYTES = 512 * 1024;
+const MAX_FALLBACK_FILES_TO_SCAN = 5000;
+function buildRgIgnoreArgs() {
+    const args = [];
+    for (const dir of ALWAYS_IGNORE_DIRS) {
+        args.push('--glob', `!${dir}`);
+        args.push('--glob', `!**/${dir}/**`);
+    }
+    args.push('--glob', '!*.min.js');
+    args.push('--glob', '!*.min.css');
+    args.push('--glob', '!*.map');
+    args.push('--glob', '!package-lock.json');
+    args.push('--glob', '!yarn.lock');
+    args.push('--glob', '!pnpm-lock.yaml');
+    return args;
+}
+function isRegexParseFailure(error) {
+    if (getCommandExitCode(error) !== 2)
+        return false;
+    return /regex parse error|repetition quantifier|unclosed group|invalid regex/i.test(getCommandErrorText(error));
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function uniqueNonEmptyStrings(values) {
+    const unique = [];
+    for (const value of values) {
+        const trimmed = value.trim();
+        if (trimmed && !unique.includes(trimmed)) {
+            unique.push(trimmed);
+        }
+    }
+    return unique;
+}
+function literalPatternCandidates(pattern) {
+    const trimmed = pattern.trim();
+    const candidates = [trimmed];
+    if (trimmed.startsWith('(?:')) {
+        const inner = trimmed.slice(3).trim();
+        candidates.push(inner.endsWith(')') ? inner.slice(0, -1).trim() : inner);
+    }
+    else if (trimmed.startsWith('(')) {
+        const inner = trimmed.slice(1).trim();
+        candidates.push(inner.endsWith(')') ? inner.slice(0, -1).trim() : inner);
+    }
+    return uniqueNonEmptyStrings(candidates);
+}
+function globToRegExp(glob) {
+    const normalized = glob.replace(/\\/g, '/');
+    let pattern = '^';
+    for (let index = 0; index < normalized.length;) {
+        const char = normalized[index] ?? '';
+        const next = normalized[index + 1] ?? '';
+        const afterNext = normalized[index + 2] ?? '';
+        if (char === '*' && next === '*' && afterNext === '/') {
+            pattern += '(?:.*/)?';
+            index += 3;
+        }
+        else if (char === '*' && next === '*') {
+            pattern += '.*';
+            index += 2;
+        }
+        else if (char === '*') {
+            pattern += '[^/]*';
+            index += 1;
+        }
+        else if (char === '?') {
+            pattern += '[^/]';
+            index += 1;
+        }
+        else {
+            pattern += escapeRegExp(char);
+            index += 1;
+        }
+    }
+    return RegExp(`${pattern}$`);
+}
+function matchesFilePattern(filePath, filePattern) {
+    if (!filePattern)
+        return true;
+    const normalized = filePath.replace(/\\/g, '/');
+    const pattern = filePattern.replace(/\\/g, '/');
+    const negated = pattern.startsWith('!');
+    const effectivePattern = negated ? pattern.slice(1) : pattern;
+    const regex = globToRegExp(effectivePattern);
+    const matches = regex.test(normalized) ||
+        (!effectivePattern.includes('/') && regex.test(path.basename(normalized)));
+    return negated ? !matches : matches;
+}
+function isBinaryText(content) {
+    return content.slice(0, 8192).includes('\0');
+}
+function shouldSkipFallbackFile(rootDir, filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    if (shouldIgnorePath(normalized))
+        return true;
+    if (ARTIFACT_IGNORE_FILES.has(path.basename(normalized)))
+        return true;
+    if (normalized.endsWith('.min.js') ||
+        normalized.endsWith('.min.css') ||
+        normalized.endsWith('.map')) {
+        return true;
+    }
+    if (BINARY_ARTIFACT_EXTENSIONS.has(path.extname(normalized).toLowerCase())) {
+        return true;
+    }
+    try {
+        const stat = statSync(path.join(rootDir, normalized));
+        return !stat.isFile() || stat.size > MAX_FALLBACK_FILE_BYTES;
+    }
+    catch {
+        return true;
+    }
+}
+function normalizeMatches(raw, limit) {
+    const limitedLines = raw.split('\n').filter(Boolean).slice(0, limit);
+    const limited = limitedLines.join('\n');
+    const matchCount = limitedLines.length;
+    const matches = limited.length > MAX_OUTPUT_CHARS
+        ? `${limited.slice(0, MAX_OUTPUT_CHARS)}\n... (truncated)`
+        : limited;
+    return { matchCount, matches };
+}
+function grepCodeWithoutRipgrep(rootDir, pattern, options) {
+    let regexes;
+    let literalMode = false;
+    try {
+        regexes = [RegExp(pattern, options.caseSensitive ? '' : 'i')];
+    }
+    catch {
+        literalMode = true;
+        regexes = literalPatternCandidates(pattern).map((candidate) => RegExp(escapeRegExp(candidate), options.caseSensitive ? '' : 'i'));
+    }
+    const allFiles = listProjectFiles(rootDir)
+        .filter((filePath) => matchesFilePattern(filePath, options.filePattern))
+        .filter((filePath) => !shouldSkipFallbackFile(rootDir, filePath));
+    const files = allFiles.slice(0, MAX_FALLBACK_FILES_TO_SCAN);
+    const matches = [];
+    for (const filePath of files) {
+        if (matches.length >= options.limit)
+            break;
+        let content;
+        try {
+            content = readFileSync(path.join(rootDir, filePath), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        if (isBinaryText(content))
+            continue;
+        const lines = content.split(/\r?\n/);
+        for (let index = 0; index < lines.length; index++) {
+            if (matches.length >= options.limit)
+                break;
+            const line = lines[index] ?? '';
+            if (regexes.some((regex) => regex.test(line))) {
+                matches.push(`${filePath}:${index + 1}:${line}`);
+            }
+        }
+    }
+    const normalized = normalizeMatches(matches.join('\n'), options.limit);
+    return {
+        ok: true,
+        pattern,
+        matchCount: normalized.matchCount,
+        matches: normalized.matches,
+        searchEngine: 'node_fallback',
+        searchMode: literalMode ? 'literal' : 'regex',
+        warning: allFiles.length > files.length
+            ? `ripgrep is unavailable; searched the first ${files.length} matching files with the built-in fallback.`
+            : 'ripgrep is unavailable; searched with the built-in fallback.',
+    };
+}
+function buildRipgrepArgs(options) {
+    const rgArgs = [
+        '-n',
+        '--no-heading',
+        '--color',
+        'never',
+        ...buildRgIgnoreArgs(),
+    ];
+    if (options.fixedStrings) {
+        rgArgs.push('--fixed-strings');
+    }
+    if (!options.caseSensitive) {
+        rgArgs.push('-i');
+    }
+    if (options.filePattern) {
+        rgArgs.push('--glob', options.filePattern);
+    }
+    rgArgs.push('-m', String(options.limit));
+    rgArgs.push('--', options.pattern, '.');
+    return rgArgs;
+}
+function runRipgrep(rootDir, options) {
+    const args = buildRipgrepArgs(options);
+    let unavailableError = null;
+    for (const candidate of getRipgrepPathCandidates()) {
+        try {
+            return execFileSync(candidate, args, {
+                cwd: rootDir,
+                encoding: 'utf-8',
+                maxBuffer: 2 * 1024 * 1024,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                timeout: 15000,
+            });
+        }
+        catch (error) {
+            if (!isRipgrepExecutionUnavailable(error)) {
+                throw error;
+            }
+            unavailableError = error;
+        }
+    }
+    throw unavailableError;
+}
+function runRipgrepLiteralSearch(rootDir, options) {
+    for (const literalPattern of literalPatternCandidates(options.pattern)) {
+        try {
+            return runRipgrep(rootDir, {
+                ...options,
+                fixedStrings: true,
+                pattern: literalPattern,
+            });
+        }
+        catch (literalErr) {
+            if (getCommandExitCode(literalErr) === 1) {
+                continue;
+            }
+            throw literalErr;
+        }
+    }
+    return null;
+}
+export function grepCode(rootDir, args) {
+    const pattern = String(args.pattern ?? '').trim();
+    if (!pattern) {
+        return { ok: false, error: 'pattern is required' };
+    }
+    const limit = clampInteger(args.limit, 50, MAX_RESULTS);
+    const filePattern = args.filePattern ? String(args.filePattern).trim() : '';
+    const caseSensitive = args.caseSensitive !== false;
+    try {
+        const raw = runRipgrep(rootDir, {
+            caseSensitive,
+            filePattern,
+            fixedStrings: false,
+            limit,
+            pattern,
+        });
+        const { matchCount, matches } = normalizeMatches(raw, limit);
+        return {
+            ok: true,
+            pattern,
+            matchCount,
+            matches,
+            searchEngine: 'ripgrep',
+            searchMode: 'regex',
+        };
+    }
+    catch (err) {
+        if (getCommandExitCode(err) === 1) {
+            return {
+                ok: true,
+                pattern,
+                matchCount: 0,
+                matches: '',
+                searchEngine: 'ripgrep',
+                searchMode: 'regex',
+            };
+        }
+        if (isRegexParseFailure(err)) {
+            try {
+                const raw = runRipgrepLiteralSearch(rootDir, {
+                    caseSensitive,
+                    filePattern,
+                    limit,
+                    pattern,
+                });
+                if (raw === null) {
+                    return {
+                        ok: true,
+                        pattern,
+                        matchCount: 0,
+                        matches: '',
+                        searchEngine: 'ripgrep',
+                        searchMode: 'literal',
+                    };
+                }
+                const { matchCount, matches } = normalizeMatches(raw, limit);
+                return {
+                    ok: true,
+                    pattern,
+                    matchCount,
+                    matches,
+                    searchEngine: 'ripgrep',
+                    searchMode: 'literal',
+                };
+            }
+            catch (literalErr) {
+                if (!isRipgrepExecutionUnavailable(literalErr)) {
+                    return {
+                        ok: false,
+                        error: 'ripgrep literal search failed.',
+                    };
+                }
+            }
+        }
+        if (isRipgrepExecutionUnavailable(err)) {
+            return grepCodeWithoutRipgrep(rootDir, pattern, {
+                limit,
+                filePattern,
+                caseSensitive,
+            });
+        }
+        return {
+            ok: false,
+            error: 'ripgrep search failed.',
+        };
+    }
+}

package/dist/src/tools/hover-symbol.js

@@ -0,0 +1,95 @@
+import { extractIdentifierAtPosition, isDefinitionLine, readProjectText, searchTextMatches, } from './code-intel.js';
+const MAX_CONTEXT_LINES = 15;
+const MAX_OUTPUT_CHARS = 4000;
+async function findDefinitionContext(rootDir, symbol) {
+    const matches = await searchTextMatches(rootDir, symbol, { limit: 40 });
+    for (const match of matches) {
+        if (!isDefinitionLine(match.content, symbol))
+            continue;
+        return extractDefinitionBlock(rootDir, match.filePath, match.line, symbol);
+    }
+    return null;
+}
+function extractDefinitionBlock(rootDir, filePath, lineNum, symbol) {
+    let fileContent;
+    try {
+        fileContent = readProjectText(rootDir, filePath);
+    }
+    catch {
+        return null;
+    }
+    const lines = fileContent.split('\n');
+    const defIdx = lineNum - 1;
+    let start = defIdx;
+    while (start > 0) {
+        const prev = lines[start - 1].trim();
+        if (prev.startsWith('///') ||
+            prev.startsWith('//!') ||
+            prev.startsWith('#[') ||
+            prev.startsWith('#![') ||
+            prev.startsWith('#') ||
+            prev.startsWith('@') ||
+            prev.startsWith('/**') ||
+            prev.startsWith('*') ||
+            prev.startsWith('//') ||
+            prev === '') {
+            if (prev === '' && start > 1) {
+                const prevPrev = lines[start - 2].trim();
+                if (!prevPrev.startsWith('//') &&
+                    !prevPrev.startsWith('*') &&
+                    !prevPrev.startsWith('#') &&
+                    !prevPrev.startsWith('@'))
+                    break;
+            }
+            start--;
+        }
+        else {
+            break;
+        }
+    }
+    const end = Math.min(lines.length, defIdx + MAX_CONTEXT_LINES);
+    const block = lines.slice(start, end);
+    return `${symbol} — ${filePath}:${lineNum}\n\`\`\`\n${block.join('\n')}\n\`\`\``;
+}
+export async function hoverSymbol(context, args) {
+    const filePath = String(args.filePath ?? '').trim();
+    const line = Number(args.line ?? 0);
+    const column = Number(args.column ?? 0);
+    if (!filePath || !line || !column) {
+        return {
+            ok: false,
+            error: 'hover_symbol requires filePath, line, and column.',
+        };
+    }
+    let content;
+    try {
+        content = readProjectText(context.rootDir, filePath);
+    }
+    catch {
+        return { ok: false, error: `Could not read ${filePath}.` };
+    }
+    const symbol = extractIdentifierAtPosition(content, line, column);
+    if (!symbol) {
+        return { ok: false, error: 'No identifier found at the given position.' };
+    }
+    const hoverContent = await findDefinitionContext(context.rootDir, symbol);
+    if (!hoverContent) {
+        return {
+            ok: false,
+            error: `Could not find definition for "${symbol}". Use find_symbol or grep_code.`,
+        };
+    }
+    const output = hoverContent.length > MAX_OUTPUT_CHARS
+        ? `${hoverContent.slice(0, MAX_OUTPUT_CHARS)}\n...(truncated)`
+        : hoverContent;
+    return {
+        ok: true,
+        provider: 'text_search',
+        available: true,
+        filePath,
+        line,
+        column,
+        contents: output,
+        output,
+    };
+}

package/dist/src/tools/index.js

@@ -0,0 +1,73 @@
+import { deleteFile } from './delete-file.js';
+import { findSymbol } from './find-symbol.js';
+import { getDiagnostics } from './get-diagnostics.js';
+import { grepCode } from './grep-code.js';
+import { hoverSymbol } from './hover-symbol.js';
+import { listDirectories } from './list-directories.js';
+import { listCheckpoints } from './list-checkpoints.js';
+import { listFiles } from './list-files.js';
+import { listSessionEdits } from './list-session-edits.js';
+import { listSymbols } from './list-symbols.js';
+import { patchFile } from './patch-file.js';
+import { readDocument } from './read-document.js';
+import { readFile } from './read-file.js';
+import { runShellCommand } from './run-command.js';
+import { runNodeScript } from './run-node-script.js';
+import { restoreFilesToCheckpoint, restoreToCheckpoint, } from './restore-checkpoint.js';
+import { searchCode } from './search-code.js';
+import { getSignatureHelp } from './signature-help.js';
+import { strReplace } from './str-replace.js';
+import { undoEdit } from './undo-edit.js';
+import { writeFile } from './write-file.js';
+export const TOOL_MAP = {
+    search_code: (context, args) => searchCode(context.projectIndex, args),
+    list_files: (context, args) => listFiles(context, args),
+    list_directories: (context, args) => listDirectories(context, args),
+    read_file: (context, args) => readFile(context, args),
+    read_document: (context, args) => readDocument(context.rootDir, args, context.env),
+    grep_code: (context, args) => grepCode(context.rootDir, args),
+    find_symbol: (context, args) => findSymbol(context, args),
+    list_symbols: (context, args) => listSymbols(context, args),
+    hover_symbol: (context, args) => hoverSymbol(context, args),
+    signature_help: (context, args) => getSignatureHelp(context, args),
+    get_diagnostics: (context, args) => getDiagnostics(context, args),
+    list_checkpoints: (context) => listCheckpoints(context),
+    list_session_edits: (context) => listSessionEdits(context),
+    restore_to_checkpoint: restoreToCheckpoint,
+    restore_files_to_checkpoint: restoreFilesToCheckpoint,
+    patch_file: patchFile,
+    str_replace: strReplace,
+    write_file: writeFile,
+    delete_file: deleteFile,
+    undo_edit: undoEdit,
+    run_command: runShellCommand,
+    run_node_script: runNodeScript,
+};
+function invalidToolCall(error) {
+    return {
+        ok: false,
+        error,
+        failureCategory: 'malformed_arguments',
+    };
+}
+function normalizeArgs(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+export async function dispatchTool(context, call) {
+    const toolName = String(call?.name ?? '').trim();
+    if (!toolName) {
+        return invalidToolCall('Tool call name is required.');
+    }
+    const toolFn = TOOL_MAP[toolName];
+    if (!toolFn) {
+        return {
+            ok: false,
+            error: `Unknown tool: ${toolName}`,
+            failureCategory: 'unknown_tool',
+        };
+    }
+    return await toolFn(context, normalizeArgs(call.args));
+}

package/dist/src/tools/list-checkpoints.js

@@ -0,0 +1,11 @@
+import { listCheckpointSummaries } from '../session-safety.js';
+export async function listCheckpoints(context) {
+    const checkpoints = context.safety
+        ? listCheckpointSummaries(context.safety)
+        : [];
+    return {
+        ok: true,
+        checkpoints,
+        total: checkpoints.length,
+    };
+}

package/dist/src/tools/list-directories.js

@@ -0,0 +1,16 @@
+import { clampInteger } from '../utils.js';
+import { listFilesystemDirectories } from './path-listing.js';
+export async function listDirectories(context, args) {
+    const pattern = String(args.pattern ?? '').trim();
+    const limit = clampInteger(args.limit, 200, 500);
+    const directories = listFilesystemDirectories(context.rootDir, {
+        pattern,
+        limit,
+    });
+    return {
+        ok: true,
+        pattern,
+        directories,
+        total: directories.length,
+    };
+}

package/dist/src/tools/list-files.js

@@ -0,0 +1,13 @@
+import { clampInteger } from '../utils.js';
+import { listFilesystemFiles } from './path-listing.js';
+export async function listFiles(context, args) {
+    const pattern = String(args.pattern ?? '').trim();
+    const limit = clampInteger(args.limit, 200, 500);
+    const files = listFilesystemFiles(context.rootDir, { pattern, limit });
+    return {
+        ok: true,
+        pattern,
+        files,
+        total: files.length,
+    };
+}

package/dist/src/tools/list-session-edits.js

@@ -0,0 +1,9 @@
+import { listSessionEditSummaries } from '../session-safety.js';
+export async function listSessionEdits(context) {
+    const edits = context.safety ? listSessionEditSummaries(context.safety) : [];
+    return {
+        ok: true,
+        edits,
+        total: edits.length,
+    };
+}

package/dist/src/tools/list-symbols.js

@@ -0,0 +1,55 @@
+import { shouldIgnoreArtifactPath } from '../artifact-policy.js';
+import { extractSymbolsFromFile, listProjectFiles, normalizeProjectFilePath, } from './code-intel.js';
+function formatRegexSymbolsOutput(symbols) {
+    if (!symbols.length)
+        return 'No symbols found.';
+    const lines = symbols.map((s) => `- ${s.kind} ${s.name} @ ${s.filePath}:${s.selectionLine}:${s.selectionColumn}`);
+    return lines.join('\n');
+}
+export async function listSymbols(context, args) {
+    const scope = args.scope === 'workspace' ? 'workspace' : 'document';
+    const filePath = String(args.filePath ?? '').trim();
+    if (scope === 'document' && !filePath) {
+        return {
+            ok: false,
+            error: 'filePath is required for document symbol queries.',
+        };
+    }
+    if (scope === 'document' &&
+        shouldIgnoreArtifactPath(normalizeProjectFilePath(context.rootDir, filePath))) {
+        return {
+            ok: false,
+            error: 'This path is not permitted.',
+        };
+    }
+    const limit = Math.max(1, Math.min(Number(args.limit ?? 40), 100));
+    const query = String(args.query ?? '').trim() || undefined;
+    const symbols = scope === 'workspace'
+        ? await listWorkspaceSymbols(context.rootDir, query, limit)
+        : extractSymbolsFromFile(context.rootDir, filePath, query, limit);
+    return {
+        ok: true,
+        provider: 'regex',
+        available: true,
+        scope,
+        filePath: scope === 'document' ? filePath : undefined,
+        total: symbols.length,
+        symbols,
+        output: formatRegexSymbolsOutput(symbols),
+    };
+}
+async function listWorkspaceSymbols(rootDir, query, limit) {
+    const files = await listProjectFiles(rootDir, {
+        limit: 400,
+        sourceOnly: true,
+    });
+    const symbols = [];
+    for (const projectFile of files) {
+        const remaining = limit - symbols.length;
+        if (remaining <= 0)
+            break;
+        const fileSymbols = extractSymbolsFromFile(rootDir, projectFile, query, remaining);
+        symbols.push(...fileSymbols);
+    }
+    return symbols;
+}