@thegitai/cli 1.0.0-beta.1

package/dist/src/patcher.js

@@ -0,0 +1,279 @@
+import chalk from 'chalk';
+import { existsSync, lstatSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
+import path from 'path';
+import { createInterface } from 'readline';
+import { runCommand } from './executor.js';
+import { isTuiMode } from './runtime-mode.js';
+import { truncate } from './utils.js';
+function parseUnifiedDiff(patchText) {
+    const lines = patchText.split('\n');
+    const hunks = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line === undefined)
+            break;
+        if (line.startsWith('diff ') ||
+            line.startsWith('--- ') ||
+            line.startsWith('+++ ')) {
+            i++;
+            continue;
+        }
+        break;
+    }
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line === undefined)
+            break;
+        const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+        if (!hunkMatch) {
+            i++;
+            continue;
+        }
+        const oldStart = parseInt(hunkMatch[1] || '0', 10);
+        const oldCount = hunkMatch[2] !== undefined ? parseInt(hunkMatch[2], 10) : 1;
+        const newStart = parseInt(hunkMatch[3] || '0', 10);
+        const newCount = hunkMatch[4] !== undefined ? parseInt(hunkMatch[4], 10) : 1;
+        i++;
+        const hunkLines = [];
+        while (i < lines.length) {
+            const nextLine = lines[i];
+            if (nextLine === undefined || nextLine.startsWith('@@'))
+                break;
+            hunkLines.push(nextLine);
+            i++;
+        }
+        hunks.push({ oldStart, oldCount, newStart, newCount, lines: hunkLines });
+    }
+    return hunks;
+}
+function formatActualFileSnippet(lines, lineIndex) {
+    const before = Math.max(0, lineIndex - 3);
+    const after = Math.min(lines.length, lineIndex + 4);
+    const width = String(after).length;
+    const rows = [];
+    for (let i = before; i < after; i++) {
+        const marker = i === lineIndex ? '→' : ' ';
+        const line = i < lines.length ? lines[i] : '';
+        rows.push(`${marker} ${String(i + 1).padStart(width)}: ${line}`);
+    }
+    return rows.join('\n');
+}
+export function applyUnifiedPatch(originalContent, patchText) {
+    const hunks = parseUnifiedDiff(patchText);
+    if (!hunks.length) {
+        throw new Error('No valid hunks found in patch. Ensure the patch uses standard unified diff format with @@ hunk headers.');
+    }
+    const endsWithNewline = originalContent.endsWith('\n');
+    const originalLines = endsWithNewline
+        ? originalContent.slice(0, -1).split('\n')
+        : originalContent.split('\n');
+    const result = [...originalLines];
+    let offset = 0;
+    for (const hunk of hunks) {
+        const startIdx = hunk.oldStart - 1 + offset;
+        let oldIdx = startIdx;
+        const newChunk = [];
+        if (hunk.oldCount === 0 && startIdx > result.length) {
+            throw new Error(`Patch hunk claims insertion at line ${hunk.oldStart} but the file only has ${result.length} line(s). ` +
+                'Re-read the file to get current line numbers before patching.');
+        }
+        for (const line of hunk.lines) {
+            if (line.length === 0)
+                continue;
+            if (line === '\')
+                continue;
+            const prefix = line[0];
+            const content = line.slice(1);
+            if (prefix === ' ') {
+                if (result[oldIdx] !== content) {
+                    throw new Error(`Patch context mismatch at line ${oldIdx + 1}:\n` +
+                        `  Expected: ${JSON.stringify(content)}\n` +
+                        `  Got:      ${JSON.stringify(result[oldIdx])}\n\n` +
+                        `Actual file around line ${oldIdx + 1}:\n${formatActualFileSnippet(result, oldIdx)}\n\n` +
+                        `Re-read the file to get the current lines and rebuild the hunk before retrying.`);
+                }
+                newChunk.push(content);
+                oldIdx++;
+            }
+            else if (prefix === '-') {
+                if (result[oldIdx] !== content) {
+                    throw new Error(`Patch removal mismatch at line ${oldIdx + 1}:\n` +
+                        `  Expected: ${JSON.stringify(content)}\n` +
+                        `  Got:      ${JSON.stringify(result[oldIdx])}\n\n` +
+                        `Actual file around line ${oldIdx + 1}:\n${formatActualFileSnippet(result, oldIdx)}\n\n` +
+                        `Re-read the file to get the current lines and rebuild the hunk before retrying.`);
+                }
+                oldIdx++;
+            }
+            else if (prefix === '+') {
+                newChunk.push(content);
+            }
+        }
+        const removedCount = oldIdx - startIdx;
+        result.splice(startIdx, removedCount, ...newChunk);
+        offset += newChunk.length - removedCount;
+    }
+    const joined = result.join('\n');
+    return endsWithNewline ? `${joined}\n` : joined;
+}
+export function renderDiffPreview(filePath, patchText) {
+    if (isTuiMode())
+        return;
+    console.log(chalk.bold(`\n  📋 Patch preview for ${filePath}:`));
+    for (const line of patchText.split('\n')) {
+        if (line.startsWith('+++ ') || line.startsWith('--- ')) {
+            console.log(chalk.bold(line));
+        }
+        else if (line.startsWith('@@')) {
+            console.log(chalk.cyan(line));
+        }
+        else if (line.startsWith('+')) {
+            console.log(chalk.green(line));
+        }
+        else if (line.startsWith('-')) {
+            console.log(chalk.red(line));
+        }
+        else {
+            console.log(chalk.dim(line));
+        }
+    }
+    console.log();
+}
+function normalizeRoot(rootDir) {
+    return path.resolve(rootDir);
+}
+export function resolveProjectPath(rootDir, filePath) {
+    const absRoot = normalizeRoot(rootDir);
+    const absPath = path.resolve(absRoot, filePath);
+    const relative = path.relative(absRoot, absPath);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error(`Refusing to access path outside the project root: ${filePath}`);
+    }
+    return absPath;
+}
+export function writeProjectFile(rootDir, filePath, content) {
+    const absPath = resolveProjectPath(rootDir, filePath);
+    if (existsSync(absPath)) {
+        try {
+            const existingContent = readFileSync(absPath, 'utf-8');
+            if (existingContent === content) {
+                return { absPath, changed: false };
+            }
+        }
+        catch {
+            // If we can't read it for some reason, proceed with write
+        }
+    }
+    mkdirSync(path.dirname(absPath), { recursive: true });
+    writeFileSync(absPath, content, 'utf-8');
+    return { absPath, changed: true };
+}
+export function deleteProjectFile(rootDir, filePath) {
+    const absPath = resolveProjectPath(rootDir, filePath);
+    if (!existsSync(absPath)) {
+        return { deleted: false, absPath };
+    }
+    let content;
+    try {
+        if (!lstatSync(absPath).isSymbolicLink()) {
+            content = readFileSync(absPath, 'utf-8');
+        }
+    }
+    catch {
+        content = undefined;
+    }
+    unlinkSync(absPath);
+    return { deleted: true, absPath, content };
+}
+export function readProjectFile(rootDir, filePath) {
+    const absPath = resolveProjectPath(rootDir, filePath);
+    if (!existsSync(absPath)) {
+        throw new Error(`File does not exist: ${filePath}`);
+    }
+    return readFileSync(absPath, 'utf-8');
+}
+function confirm(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase().startsWith('y'));
+        });
+    });
+}
+export async function applyChanges(operations, rootDir, { autoYes = false, } = {}) {
+    const silent = isTuiMode();
+    if (!operations.length) {
+        if (!silent)
+            console.log(chalk.yellow('\n⚠  No changes to apply.'));
+        return;
+    }
+    const fileOps = operations.filter((op) => op.action !== 'run');
+    const cmdOps = operations.filter((op) => op.action === 'run');
+    if (!silent)
+        console.log(chalk.bold(`\n📝 Applying ${fileOps.length} file change(s) and ${cmdOps.length} command(s):\n`));
+    for (const op of operations) {
+        switch (op.action) {
+            case 'create':
+            case 'update': {
+                if (op.filePath && op.content !== undefined) {
+                    writeProjectFile(rootDir, op.filePath, op.content);
+                    const icon = op.action === 'create' ? '✨' : '✏️ ';
+                    const label = op.action === 'create' ? 'Created' : 'Updated';
+                    if (!silent)
+                        console.log(chalk.green(`  ${icon} ${label}: ${op.filePath}`));
+                }
+                break;
+            }
+            case 'delete': {
+                if (op.filePath) {
+                    try {
+                        const result = deleteProjectFile(rootDir, op.filePath);
+                        if (result.deleted) {
+                            if (!silent)
+                                console.log(chalk.red(`  🗑️  Deleted: ${op.filePath}`));
+                        }
+                        else {
+                            if (!silent)
+                                console.log(chalk.yellow(`  ⚠  Could not delete ${op.filePath}: file not found`));
+                        }
+                    }
+                    catch (err) {
+                        if (!silent)
+                            console.log(chalk.yellow(`  ⚠  Could not delete ${op.filePath}: ${err.message}`));
+                    }
+                }
+                break;
+            }
+            case 'run': {
+                if (op.command) {
+                    if (!silent)
+                        console.log(chalk.bold.yellow(`\n  ⚡ Command: ${op.command}`));
+                    if (!autoYes) {
+                        const proceed = await confirm(chalk.yellow(`  ⚠  Run this command? [y/N] `));
+                        if (!proceed) {
+                            if (!silent)
+                                console.log(chalk.dim(`  ⏭  Skipped: ${op.command}`));
+                            break;
+                        }
+                    }
+                    const result = await runCommand(op.command, rootDir);
+                    if (result.exitCode !== 0) {
+                        if (!silent)
+                            console.log(chalk.red(`  ⚠  Command failed (exit ${result.exitCode}). Continuing…`));
+                        if (!silent && result.output) {
+                            console.log(chalk.dim(truncate(result.output, 1000)));
+                        }
+                    }
+                }
+                break;
+            }
+            default:
+                if (!silent)
+                    console.log(chalk.yellow(`  ⚠  Unknown action "${op.action}"`));
+        }
+    }
+    if (!silent)
+        console.log(chalk.bold.green('\n✅ All operations complete.\n'));
+}

package/dist/src/project-index.js

@@ -0,0 +1,221 @@
+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);
+}
+async function initializeIndex(index) {
+    if (index.initialized) {
+        return Array.from(index.chunksByFile.values()).reduce((sum, chunks) => sum + chunks.length, 0);
+    }
+    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,
+        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,
+    };
+}

package/dist/src/repo-map-languages.js

@@ -0,0 +1,100 @@
+export const REPO_MAP_LANGUAGE_CONFIGS = [
+    {
+        id: 'javascript',
+        displayName: 'JavaScript',
+        wasmFile: 'tree-sitter-javascript.wasm',
+        extensions: ['.js', '.jsx', '.mjs', '.cjs'],
+    },
+    {
+        id: 'typescript',
+        displayName: 'TypeScript',
+        wasmFile: 'tree-sitter-typescript.wasm',
+        extensions: ['.ts', '.mts', '.cts'],
+    },
+    {
+        id: 'tsx',
+        displayName: 'TSX',
+        wasmFile: 'tree-sitter-tsx.wasm',
+        extensions: ['.tsx'],
+    },
+    {
+        id: 'python',
+        displayName: 'Python',
+        wasmFile: 'tree-sitter-python.wasm',
+        extensions: ['.py'],
+    },
+    {
+        id: 'go',
+        displayName: 'Go',
+        wasmFile: 'tree-sitter-go.wasm',
+        extensions: ['.go'],
+    },
+    {
+        id: 'rust',
+        displayName: 'Rust',
+        wasmFile: 'tree-sitter-rust.wasm',
+        extensions: ['.rs'],
+    },
+    {
+        id: 'php',
+        displayName: 'PHP',
+        wasmFile: 'tree-sitter-php.wasm',
+        extensions: ['.php'],
+    },
+    {
+        id: 'java',
+        displayName: 'Java',
+        wasmFile: 'tree-sitter-java.wasm',
+        extensions: ['.java'],
+    },
+    {
+        id: 'c',
+        displayName: 'C',
+        wasmFile: 'tree-sitter-c.wasm',
+        extensions: ['.c'],
+    },
+    {
+        id: 'cpp',
+        displayName: 'C++',
+        wasmFile: 'tree-sitter-cpp.wasm',
+        extensions: ['.cpp', '.hpp', '.cc', '.h'],
+    },
+    {
+        id: 'csharp',
+        displayName: 'C#',
+        wasmFile: 'tree-sitter-c-sharp.wasm',
+        extensions: ['.cs'],
+    },
+    {
+        id: 'objc',
+        displayName: 'Objective-C',
+        wasmFile: 'tree-sitter-objc.wasm',
+        extensions: ['.m'],
+    },
+    {
+        id: 'html',
+        displayName: 'HTML',
+        wasmFile: 'tree-sitter-html.wasm',
+        extensions: ['.html', '.htm'],
+    },
+    {
+        id: 'css',
+        displayName: 'CSS',
+        wasmFile: 'tree-sitter-css.wasm',
+        extensions: ['.css', '.scss'],
+    },
+    {
+        id: 'ruby',
+        displayName: 'Ruby',
+        wasmFile: 'tree-sitter-ruby.wasm',
+        extensions: ['.rb'],
+    },
+];
+export const REPO_MAP_LANGUAGE_BY_EXTENSION = new Map(REPO_MAP_LANGUAGE_CONFIGS.flatMap((config) => config.extensions.map((extension) => [extension, config])));
+export function getRepoMapLanguageForFile(filePath, pathModule) {
+    const extension = pathModule.extname(filePath).toLowerCase();
+    return REPO_MAP_LANGUAGE_BY_EXTENSION.get(extension) ?? null;
+}
+export function listRepoMapWasmFiles() {
+    return REPO_MAP_LANGUAGE_CONFIGS.map((config) => config.wasmFile);
+}

package/dist/src/runtime-mode.js

@@ -0,0 +1,35 @@
+export function isTuiMode(env = process.env) {
+    return env.THEGITAI_TUI === '1';
+}
+let _commandOutputHook = null;
+export function setCommandOutputHook(hook) {
+    _commandOutputHook = hook;
+}
+export function emitCommandOutput(chunk) {
+    _commandOutputHook?.(chunk);
+}
+const tuiEnvStacks = new WeakMap();
+export async function withTuiMode(run, env = process.env) {
+    let stack = tuiEnvStacks.get(env);
+    if (!stack) {
+        stack = { depth: 0, original: env.THEGITAI_TUI };
+        tuiEnvStacks.set(env, stack);
+    }
+    stack.depth += 1;
+    env.THEGITAI_TUI = '1';
+    try {
+        return await run();
+    }
+    finally {
+        stack.depth -= 1;
+        if (stack.depth <= 0) {
+            tuiEnvStacks.delete(env);
+            if (stack.original === undefined) {
+                delete env.THEGITAI_TUI;
+            }
+            else {
+                env.THEGITAI_TUI = stack.original;
+            }
+        }
+    }
+}