@thegitai/cli 1.0.0-beta.1

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

@@ -0,0 +1,472 @@
+import { execFile } from 'node:child_process';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { ALWAYS_IGNORE_DIRS, listProjectFiles as listScannerProjectFiles, shouldIgnorePath, } from '../scanner.js';
+import { normalizeProjectRelativePath } from '../artifact-policy.js';
+import { getRipgrepPathCandidates, isRipgrepExecutionUnavailable, } from './ripgrep.js';
+import { getCommandExitCode } from './exec-utils.js';
+const MAX_RIPGREP_BUFFER = 2 * 1024 * 1024;
+const MAX_RIPGREP_TIMEOUT_MS = 10000;
+const DEFAULT_PROJECT_FILE_LIMIT = 400;
+const MAX_FALLBACK_FILES_TO_SCAN = 2000;
+const execFileAsync = promisify(execFile);
+const SOURCE_FILE_EXTENSIONS = new Set([
+    '.c',
+    '.cc',
+    '.cpp',
+    '.cs',
+    '.css',
+    '.cts',
+    '.cxx',
+    '.go',
+    '.h',
+    '.hpp',
+    '.html',
+    '.java',
+    '.js',
+    '.jsx',
+    '.kt',
+    '.kts',
+    '.m',
+    '.mjml',
+    '.mm',
+    '.mts',
+    '.php',
+    '.py',
+    '.rb',
+    '.rs',
+    '.swift',
+    '.ts',
+    '.tsx',
+    '.vue',
+]);
+const DEF_KEYWORDS = [
+    'def ',
+    'async def ',
+    'function ',
+    'async function ',
+    'class ',
+    'const ',
+    'let ',
+    'var ',
+    'interface ',
+    'type ',
+    'fn ',
+    'func ',
+    'pub fn ',
+    'pub async fn ',
+    'export function ',
+    'export async function ',
+    'export const ',
+    'export class ',
+    'export interface ',
+    'export type ',
+    'export default function ',
+    'export default class ',
+    'struct ',
+    'pub struct ',
+    'enum ',
+    'pub enum ',
+    'trait ',
+    'pub trait ',
+    'impl ',
+    'pub mod ',
+    'mod ',
+];
+const SYMBOL_PATTERNS = [
+    {
+        regex: /^\s*(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/,
+        kind: 'function',
+        nameGroup: 1,
+    },
+    { regex: /^\s*(?:pub\s+)?struct\s+(\w+)/, kind: 'struct', nameGroup: 1 },
+    { regex: /^\s*(?:pub\s+)?enum\s+(\w+)/, kind: 'enum', nameGroup: 1 },
+    { regex: /^\s*(?:pub\s+)?trait\s+(\w+)/, kind: 'interface', nameGroup: 1 },
+    { regex: /^\s*(?:pub\s+)?type\s+(\w+)/, kind: 'type', nameGroup: 1 },
+    {
+        regex: /^\s*(?:pub\s+)?(?:static|const)\s+(\w+)\s*:/,
+        kind: 'constant',
+        nameGroup: 1,
+    },
+    { regex: /^\s*impl(?:<[^>]*>)?\s+(\w+)/, kind: 'class', nameGroup: 1 },
+    { regex: /^\s*(?:pub\s+)?mod\s+(\w+)/, kind: 'module', nameGroup: 1 },
+    { regex: /^func\s+(?:\([^)]+\)\s+)?(\w+)/, kind: 'function', nameGroup: 1 },
+    { regex: /^type\s+(\w+)\s+struct\b/, kind: 'struct', nameGroup: 1 },
+    { regex: /^type\s+(\w+)\s+interface\b/, kind: 'interface', nameGroup: 1 },
+    { regex: /^type\s+(\w+)\b/, kind: 'type', nameGroup: 1 },
+    { regex: /^var\s+(\w+)\b/, kind: 'variable', nameGroup: 1 },
+    { regex: /^const\s+(\w+)\b/, kind: 'constant', nameGroup: 1 },
+    { regex: /^\s*(?:async\s+)?def\s+(\w+)/, kind: 'function', nameGroup: 1 },
+    { regex: /^\s*class\s+(\w+)/, kind: 'class', nameGroup: 1 },
+    {
+        regex: /^\s*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+(\w+)/,
+        kind: 'class',
+        nameGroup: 1,
+    },
+    {
+        regex: /^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*\*?\s+(\w+)/,
+        kind: 'function',
+        nameGroup: 1,
+    },
+    {
+        regex: /^\s*(?:export\s+)?interface\s+(\w+)/,
+        kind: 'interface',
+        nameGroup: 1,
+    },
+    {
+        regex: /^\s*(?:export\s+)?type\s+(\w+)\s*[<=]/,
+        kind: 'type',
+        nameGroup: 1,
+    },
+    {
+        regex: /^\s*(?:export\s+)?(?:const|let|var)\s+(\w+)\s*(?::\s*\S+\s*)?=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
+        kind: 'function',
+        nameGroup: 1,
+    },
+    {
+        regex: /^\s*(?:export\s+)?const\s+(\w+)\s*[=:]/,
+        kind: 'constant',
+        nameGroup: 1,
+    },
+    {
+        regex: /^\s*(?:export\s+)?(?:let|var)\s+(\w+)\b/,
+        kind: 'variable',
+        nameGroup: 1,
+    },
+    { regex: /^\s*(?:export\s+)?enum\s+(\w+)/, kind: 'enum', nameGroup: 1 },
+];
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function isLikelySourceFile(filePath) {
+    return SOURCE_FILE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+export function normalizeProjectFilePath(rootDir, filePath) {
+    if (!filePath)
+        return filePath;
+    const relativePath = normalizeProjectRelativePath(rootDir, filePath);
+    return relativePath ?? filePath.replace(/\\/g, '/').replace(/^\.\//, '');
+}
+export function readProjectText(rootDir, filePath) {
+    const normalizedPath = normalizeProjectRelativePath(rootDir, filePath);
+    if (!normalizedPath) {
+        throw Error(`Refusing to access path outside the project root: ${filePath}`);
+    }
+    if (shouldIgnorePath(normalizedPath)) {
+        throw Error(`Ignored artifact paths are off-limits: ${normalizedPath}`);
+    }
+    const fullPath = path.join(rootDir, normalizedPath);
+    return readFileSync(fullPath, 'utf8');
+}
+export function extractIdentifierAtPosition(content, line, column) {
+    const lines = content.split(/\r?\n/);
+    if (line < 1 || line > lines.length)
+        return null;
+    const text = (lines[line - 1] ?? '').replace(/\r$/, '');
+    if (column < 1 || column > text.length + 1)
+        return null;
+    const index = column - 1;
+    const identifierChar = /[\w$]/;
+    if (!identifierChar.test(text[index] ?? ''))
+        return null;
+    let start = index;
+    let end = index;
+    while (start > 0 && identifierChar.test(text[start - 1] ?? ''))
+        start--;
+    while (end < text.length - 1 && identifierChar.test(text[end + 1] ?? ''))
+        end++;
+    const symbol = text.slice(start, end + 1).trim();
+    return symbol || null;
+}
+export function isDefinitionLine(line, symbol) {
+    const trimmed = line.trim();
+    if (/^(\/\/|#|\/\*|\*)/.test(trimmed))
+        return false;
+    for (const keyword of DEF_KEYWORDS) {
+        const index = trimmed.indexOf(keyword);
+        if (index === -1)
+            continue;
+        const before = trimmed.slice(0, index);
+        if (before.length > 0 && !/^[a-zA-Z0-9_$\s]*$/.test(before))
+            continue;
+        const after = trimmed.slice(index + keyword.length).trimStart();
+        if (!after.startsWith(symbol))
+            continue;
+        const nextChar = after[symbol.length];
+        if (!nextChar || /[\s(<:{=[]/.test(nextChar)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function buildIgnoreArgs() {
+    const args = [];
+    for (const dir of ALWAYS_IGNORE_DIRS) {
+        args.push('--glob', `!${dir}`, '--glob', `!**/${dir}/**`);
+    }
+    return args;
+}
+async function runRipgrep(rootDir, args) {
+    let unavailableError = null;
+    for (const candidate of getRipgrepPathCandidates()) {
+        try {
+            const { stdout } = await execFileAsync(candidate, args, {
+                cwd: rootDir,
+                encoding: 'utf-8',
+                maxBuffer: MAX_RIPGREP_BUFFER,
+                timeout: MAX_RIPGREP_TIMEOUT_MS,
+            });
+            return String(stdout ?? '');
+        }
+        catch (error) {
+            if (getCommandExitCode(error) === 1) {
+                return '';
+            }
+            if (!isRipgrepExecutionUnavailable(error)) {
+                throw error;
+            }
+            unavailableError = error;
+        }
+    }
+    if (unavailableError) {
+        return null;
+    }
+    return null;
+}
+function collectRelativeFilesUnder(rootDir, dirRel, out, maxFiles) {
+    if (out.length >= maxFiles)
+        return;
+    const absDir = path.join(rootDir, dirRel);
+    let entries;
+    try {
+        entries = readdirSync(absDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const ent of entries) {
+        if (out.length >= maxFiles)
+            return;
+        const name = String(ent.name);
+        const rel = dirRel ? path.join(dirRel, name) : name;
+        const relPosix = rel.split(path.sep).join('/');
+        if (shouldIgnorePath(relPosix))
+            continue;
+        if (ent.isDirectory()) {
+            collectRelativeFilesUnder(rootDir, rel, out, maxFiles);
+        }
+        else if (ent.isFile()) {
+            out.push(relPosix);
+        }
+    }
+}
+function listRelativePathsForTextSearch(rootDir, targetRel) {
+    const absTarget = path.join(rootDir, targetRel);
+    let stat;
+    try {
+        stat = statSync(absTarget);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    if (stat.isFile()) {
+        if (!shouldIgnorePath(normalizeProjectFilePath(rootDir, targetRel))) {
+            out.push(normalizeProjectFilePath(rootDir, targetRel));
+        }
+        return out;
+    }
+    if (stat.isDirectory()) {
+        collectRelativeFilesUnder(rootDir, targetRel === '.' ? '' : targetRel, out, MAX_FALLBACK_FILES_TO_SCAN);
+    }
+    return out;
+}
+function searchTextMatchesWithoutRipgrep(rootDir, searchTerm, options = {}) {
+    const target = options.filePath
+        ? normalizeProjectFilePath(rootDir, options.filePath)
+        : '.';
+    const limit = Math.max(1, Math.min(Number(options.limit ?? 80), 200));
+    const wordPattern = new RegExp(`\\b${escapeRegExp(searchTerm)}\\b`);
+    const files = listRelativePathsForTextSearch(rootDir, target);
+    const results = [];
+    for (const rel of files) {
+        if (results.length >= limit)
+            break;
+        let content;
+        try {
+            content = readFileSync(path.join(rootDir, rel), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const lines = content.split(/\r?\n/);
+        for (let i = 0; i < lines.length; i++) {
+            if (results.length >= limit)
+                break;
+            const line = lines[i] ?? '';
+            if (wordPattern.test(line)) {
+                results.push({
+                    filePath: normalizeProjectFilePath(rootDir, rel),
+                    line: i + 1,
+                    content: line,
+                });
+            }
+        }
+    }
+    return results.slice(0, limit);
+}
+function parseTextSearchMatch(rootDir, line) {
+    const match = line.match(/^(.+?):(\d+):(.*)$/);
+    if (!match)
+        return null;
+    return {
+        filePath: normalizeProjectFilePath(rootDir, match[1] ?? ''),
+        line: parseInt(match[2] ?? '1', 10),
+        content: match[3] ?? '',
+    };
+}
+export async function searchTextMatches(rootDir, searchTerm, options = {}) {
+    const target = options.filePath
+        ? normalizeProjectFilePath(rootDir, options.filePath)
+        : '.';
+    const limit = Math.max(1, Math.min(Number(options.limit ?? 80), 200));
+    const raw = await runRipgrep(rootDir, [
+        '-n',
+        '--no-heading',
+        '--color',
+        'never',
+        '--word-regexp',
+        '--fixed-strings',
+        ...buildIgnoreArgs(),
+        '-m',
+        String(limit),
+        '--',
+        searchTerm,
+        target,
+    ]);
+    if (raw === null) {
+        return searchTextMatchesWithoutRipgrep(rootDir, searchTerm, options);
+    }
+    return raw
+        .trim()
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => parseTextSearchMatch(rootDir, line))
+        .filter((match) => match != null)
+        .slice(0, limit);
+}
+export async function searchSymbolOccurrences(rootDir, symbol, options = {}) {
+    const limit = Math.max(1, Math.min(Number(options.limit ?? 80), 200));
+    const matches = await searchTextMatches(rootDir, symbol, options);
+    const wordPattern = new RegExp(`\\b${escapeRegExp(symbol)}\\b`);
+    return matches
+        .map((match) => {
+        const filePath = match.filePath;
+        const startLine = match.line;
+        const content = match.content;
+        const columnMatch = content.match(wordPattern);
+        const startColumn = columnMatch?.index != null ? columnMatch.index + 1 : 1;
+        return {
+            filePath,
+            content,
+            startLine,
+            startColumn,
+            endLine: startLine,
+            endColumn: startColumn + symbol.length,
+        };
+    })
+        .slice(0, limit);
+}
+export function expandContext(rootDir, filePath, startLine, maxLines = 35) {
+    try {
+        const lines = readProjectText(rootDir, filePath).split('\n');
+        const start = Math.max(0, startLine - 1);
+        const end = Math.min(lines.length, start + maxLines);
+        return lines
+            .slice(start, end)
+            .map((line, index) => `${start + index + 1}: ${line}`)
+            .join('\n');
+    }
+    catch {
+        return '';
+    }
+}
+export function extractSymbolsFromFile(rootDir, filePath, query, limit = 40) {
+    let content;
+    try {
+        content = readProjectText(rootDir, filePath);
+    }
+    catch {
+        return [];
+    }
+    const lines = content.split('\n');
+    const symbols = [];
+    const seen = new Set();
+    const normalizedPath = normalizeProjectFilePath(rootDir, filePath);
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index] ?? '';
+        const trimmed = line.trim();
+        if (trimmed.startsWith('//') ||
+            trimmed.startsWith('#') ||
+            trimmed.startsWith('/*') ||
+            trimmed.startsWith('*')) {
+            continue;
+        }
+        for (const pattern of SYMBOL_PATTERNS) {
+            const match = line.match(pattern.regex);
+            if (!match)
+                continue;
+            const name = match[pattern.nameGroup];
+            if (!name || name === '_' || name === 'self')
+                continue;
+            if (query && !name.toLowerCase().includes(query.toLowerCase()))
+                continue;
+            const key = `${pattern.kind}:${name}:${index + 1}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const startColumn = line.indexOf(name) + 1;
+            symbols.push({
+                name,
+                kind: pattern.kind,
+                filePath: normalizedPath,
+                startLine: index + 1,
+                startColumn,
+                endLine: index + 1,
+                endColumn: startColumn + name.length,
+                selectionLine: index + 1,
+                selectionColumn: startColumn,
+                searchSource: 'regex',
+            });
+            if (symbols.length >= limit) {
+                return symbols;
+            }
+            break;
+        }
+    }
+    return symbols;
+}
+export async function listProjectFiles(rootDir, options = {}) {
+    const limit = Math.max(1, Math.min(Number(options.limit ?? DEFAULT_PROJECT_FILE_LIMIT), 2000));
+    try {
+        const raw = await runRipgrep(rootDir, ['--files', ...buildIgnoreArgs()]);
+        if (raw === null) {
+            const scanned = listScannerProjectFiles(rootDir, { limit });
+            return scanned
+                .map((filePath) => filePath.split(path.sep).join('/'))
+                .filter((filePath) => !options.sourceOnly || isLikelySourceFile(filePath))
+                .slice(0, limit);
+        }
+        const files = raw
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .filter((filePath) => !options.sourceOnly || isLikelySourceFile(filePath));
+        return files.slice(0, limit);
+    }
+    catch (error) {
+        console.warn(`[code-intel] Failed to list project files: ${error?.message ?? String(error)}`);
+        return [];
+    }
+}

package/dist/src/tools/delete-file.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import { deleteProjectFile } from '../patcher.js';
+import { isTuiMode } from '../runtime-mode.js';
+import { removeIndexFile } from '../project-index.js';
+import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';
+export async function deleteFile(context, args) {
+    const { rootDir, projectIndex } = context;
+    const filePath = String(args.filePath ?? '').trim();
+    if (!filePath) {
+        return { ok: false, error: 'filePath is required' };
+    }
+    const result = deleteProjectFile(rootDir, filePath);
+    if (result.deleted) {
+        await removeIndexFile(projectIndex, filePath);
+        invalidateShellDiagnosticsCache(rootDir, filePath);
+        if (!isTuiMode())
+            console.log(chalk.red(`  🗑️  Deleted: ${filePath}`));
+    }
+    return {
+        ok: true,
+        filePath,
+        changed: result.deleted,
+        deleted: result.deleted,
+        content: result.content,
+        diagnostics: result.deleted ? runShellDiagnostics(rootDir) : undefined,
+    };
+}

package/dist/src/tools/exec-utils.js

@@ -0,0 +1,17 @@
+export function getCommandExitCode(error) {
+    if (typeof error?.status === 'number')
+        return error.status;
+    if (typeof error?.code === 'number')
+        return error.code;
+    return null;
+}
+export function getCommandErrorText(error) {
+    return [
+        error?.message,
+        error?.stderr,
+        error?.stdout,
+    ]
+        .filter(Boolean)
+        .map(String)
+        .join('\n');
+}

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

@@ -0,0 +1,70 @@
+import { expandContext, extractIdentifierAtPosition, isDefinitionLine, readProjectText, searchSymbolOccurrences, } from './code-intel.js';
+const MAX_CONTEXT_LINES = 35;
+const MAX_REFS = 30;
+const MAX_OUTPUT_CHARS = 8000;
+async function fallbackFindSymbol(rootDir, args) {
+    const symbol = resolveRequestedSymbol(rootDir, args);
+    if (!symbol)
+        return {
+            ok: false,
+            error: 'symbol or filePath + line + column is required',
+        };
+    const all = await searchSymbolOccurrences(rootDir, symbol, { limit: 80 });
+    const defs = all.filter((hit) => isDefinitionLine(hit.content, symbol));
+    const defKeys = new Set(defs.map((definition) => `${definition.filePath}:${definition.startLine}`));
+    const refs = args.includeReferences !== false
+        ? all.filter((hit) => !defKeys.has(`${hit.filePath}:${hit.startLine}`))
+        : [];
+    const sections = [];
+    if (defs.length === 0) {
+        sections.push(`No definition found for "${symbol}". Showing all occurrences as references.`);
+        for (const r of all.slice(0, MAX_REFS)) {
+            sections.push(`- ${r.filePath}:${r.startLine}: ${r.content.trim()}`);
+        }
+    }
+    else {
+        sections.push(`## Definitions (${defs.length})`);
+        for (const def of defs) {
+            sections.push(`\n### ${def.filePath}:${def.startLine}\n\`\`\`\n${expandContext(rootDir, def.filePath, def.startLine, MAX_CONTEXT_LINES)}\n\`\`\``);
+        }
+    }
+    if (refs.length > 0) {
+        const shown = refs.slice(0, MAX_REFS);
+        sections.push(`\n## References (${refs.length} total, showing ${shown.length})`);
+        for (const r of shown)
+            sections.push(`- ${r.filePath}:${r.startLine}: ${r.content.trim()}`);
+    }
+    const output = sections.join('\n');
+    return {
+        ok: true,
+        provider: 'text_search',
+        symbol,
+        definitions: defs,
+        references: refs,
+        definitionCount: defs.length,
+        referenceCount: refs.length,
+        output: output.length > MAX_OUTPUT_CHARS
+            ? `${output.slice(0, MAX_OUTPUT_CHARS)}\n...(truncated)`
+            : output,
+    };
+}
+export async function findSymbol(context, args) {
+    return fallbackFindSymbol(context.rootDir, args);
+}
+function resolveRequestedSymbol(rootDir, args) {
+    const symbol = String(args.symbol ?? '').trim();
+    if (symbol)
+        return symbol;
+    const filePath = String(args.filePath ?? '').trim();
+    const line = Number(args.line ?? 0);
+    const column = Number(args.column ?? 0);
+    if (!filePath || !line || !column)
+        return '';
+    try {
+        const content = readProjectText(rootDir, filePath);
+        return extractIdentifierAtPosition(content, line, column) ?? '';
+    }
+    catch {
+        return '';
+    }
+}

package/dist/src/tools/get-diagnostics.js

@@ -0,0 +1,22 @@
+import { isSensitiveProjectPath, normalizeProjectRelativePath, shouldIgnoreArtifactPath, } from '../artifact-policy.js';
+import { runShellDiagnostics } from './shell-diagnostics.js';
+export async function getDiagnostics(context, args) {
+    const filePath = String(args.filePath ?? '').trim() || undefined;
+    const projectPath = filePath
+        ? normalizeProjectRelativePath(context.rootDir, filePath)
+        : undefined;
+    if (projectPath && shouldIgnoreArtifactPath(projectPath)) {
+        return {
+            ok: false,
+            error: 'This path is not permitted.',
+        };
+    }
+    if (projectPath && isSensitiveProjectPath(projectPath)) {
+        return {
+            ok: false,
+            error: 'This path is not permitted.',
+        };
+    }
+    const limit = args.limit ?? 50;
+    return runShellDiagnostics(context.rootDir, filePath, limit);
+}