@thegitai/cli 1.0.0-beta.1

package/dist/src/tools/signature-help.js

@@ -0,0 +1,118 @@
+import { readProjectText, searchTextMatches } from './code-intel.js';
+const SIGNATURE_PATTERNS = [
+    /(?:pub\s+)?(?:async\s+)?fn\s+(\w+)\s*(?:<[^>]*>\s*)?\([^)]*\)/,
+    /func\s+(?:\([^)]+\)\s+)?(\w+)\s*\([^)]*\)/,
+    /(?:async\s+)?def\s+(\w+)\s*\([^)]*\)/,
+    /(?:export\s+)?(?:async\s+)?function\s*\*?\s+(\w+)\s*(?:<[^>]*>\s*)?\([^)]*\)/,
+    /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
+];
+function extractCalledFunction(content, line, column) {
+    const lines = content.split('\n');
+    if (line < 1 || line > lines.length)
+        return null;
+    const text = lines[line - 1];
+    const prefix = text.slice(0, column);
+    const m = prefix.match(/(\w+)\s*\(\s*[^)]*$/);
+    if (m)
+        return m[1];
+    if (line > 1) {
+        const prevLine = lines[line - 2];
+        const pm = prevLine.match(/(\w+)\s*\(\s*$/);
+        if (pm)
+            return pm[1];
+    }
+    return null;
+}
+async function findSignature(rootDir, funcName) {
+    const matches = await searchTextMatches(rootDir, funcName, { limit: 40 });
+    for (const match of matches) {
+        for (const pattern of SIGNATURE_PATTERNS) {
+            const sigMatch = match.content.match(pattern);
+            if (sigMatch && sigMatch[1] === funcName) {
+                return extractFullSignature(rootDir, match.filePath, match.line);
+            }
+        }
+    }
+    return null;
+}
+function extractFullSignature(rootDir, filePath, lineNum) {
+    let fileContent;
+    try {
+        fileContent = readProjectText(rootDir, filePath);
+    }
+    catch {
+        return null;
+    }
+    const lines = fileContent.split('\n');
+    const startIdx = lineNum - 1;
+    if (startIdx >= lines.length)
+        return null;
+    const signatureLines = [];
+    let openParens = 0;
+    let foundOpen = false;
+    for (let i = startIdx; i < Math.min(lines.length, startIdx + 20); i++) {
+        signatureLines.push(lines[i]);
+        for (const ch of lines[i]) {
+            if (ch === '(') {
+                openParens++;
+                foundOpen = true;
+            }
+            else if (ch === ')')
+                openParens--;
+        }
+        if (foundOpen && openParens <= 0)
+            break;
+    }
+    const signature = signatureLines.join('\n');
+    const bodyStart = signature.match(/\)\s*(?:->.*?)?\s*[{:]/) ??
+        signature.match(/\)\s*[{:]/) ??
+        signature.match(/\)\s*$/m);
+    const display = bodyStart
+        ? signature
+            .slice(0, bodyStart.index + bodyStart[0].length)
+            .replace(/\s*[{:]\s*$/, '')
+        : signature;
+    return `${filePath}:${lineNum}\n\`\`\`\n${display.trim()}\n\`\`\``;
+}
+export async function getSignatureHelp(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: 'signature_help requires filePath, line, and column.',
+        };
+    }
+    let content;
+    try {
+        content = readProjectText(context.rootDir, filePath);
+    }
+    catch {
+        return { ok: false, error: `Could not read ${filePath}.` };
+    }
+    const funcName = extractCalledFunction(content, line, column);
+    if (!funcName) {
+        return {
+            ok: false,
+            error: 'No function call found at the given position. Use hover_symbol or read_file.',
+        };
+    }
+    const signature = await findSignature(context.rootDir, funcName);
+    if (!signature) {
+        return {
+            ok: false,
+            error: `Could not find definition for "${funcName}". Use find_symbol or grep_code.`,
+        };
+    }
+    return {
+        ok: true,
+        provider: 'text_search',
+        available: true,
+        filePath,
+        line,
+        column,
+        functionName: funcName,
+        output: signature,
+    };
+}

package/dist/src/tools/str-replace.js

@@ -0,0 +1,193 @@
+import chalk from 'chalk';
+import { normalizeProjectRelativePath } from '../artifact-policy.js';
+import { readProjectFile, writeProjectFile } from '../patcher.js';
+import { upsertIndexFile } from '../project-index.js';
+import { isTuiMode } from '../runtime-mode.js';
+import { getCurrentFileHash, resolveRedactionTokens } from '../session-safety.js';
+import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';
+function countOccurrences(haystack, needle) {
+    if (needle.length === 0)
+        return 0;
+    let count = 0;
+    let pos = 0;
+    while (pos <= haystack.length) {
+        const i = haystack.indexOf(needle, pos);
+        if (i === -1)
+            break;
+        count++;
+        pos = i + needle.length;
+    }
+    return count;
+}
+function similarityScore(a, b) {
+    const ta = a.trim();
+    const tb = b.trim();
+    if (!ta || !tb)
+        return 0;
+    const shorter = ta.length < tb.length ? ta : tb;
+    const longer = ta.length < tb.length ? tb : ta;
+    let common = 0;
+    for (let i = 0; i < shorter.length; i++) {
+        if (shorter[i] === longer[i])
+            common++;
+    }
+    const prefixRatio = common / longer.length;
+    if (longer.includes(shorter) && shorter.length >= 4) {
+        return Math.max(prefixRatio, shorter.length / longer.length);
+    }
+    return prefixRatio;
+}
+function buildClosestMatchHint(content, oldString) {
+    const contentLines = content.split('\n');
+    const needleLines = oldString
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length >= 3);
+    if (needleLines.length === 0)
+        return '';
+    const target = needleLines[0];
+    const scored = [];
+    for (let i = 0; i < contentLines.length; i++) {
+        const line = contentLines[i];
+        if (!line.trim())
+            continue;
+        const score = similarityScore(target, line);
+        if (score >= 0.5) {
+            scored.push({ lineNum: i + 1, line, score });
+        }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    const top = scored.slice(0, 3);
+    if (!top.length)
+        return '';
+    const formatted = top
+        .map((hint) => `  line ${hint.lineNum}: ${hint.line}`)
+        .join('\n');
+    return `\nClosest lines in the file:\n${formatted}\n\nRe-read the file to get the exact text before retrying.`;
+}
+function buildStrReplacePreview(oldString, newString) {
+    const oldLines = oldString.split('\n');
+    const newLines = newString.split('\n');
+    const minus = oldLines.map((l) => `-${l}`).join('\n');
+    const plus = newLines.map((l) => `+${l}`).join('\n');
+    return `@@ str_replace @@\n${minus}\n${plus}`;
+}
+export async function strReplace(context, args) {
+    const { rootDir, projectIndex, autoYes, confirmPatch } = context;
+    const filePath = String(args.filePath ?? args.file_path ?? '').trim();
+    let oldString = typeof args.old_string === 'string'
+        ? args.old_string
+        : typeof args.oldString === 'string'
+            ? args.oldString
+            : '';
+    let newString = typeof args.new_string === 'string'
+        ? args.new_string
+        : typeof args.newString === 'string'
+            ? args.newString
+            : '';
+    const replaceAll = args.replace_all === true || args.replaceAll === true;
+    if (!filePath) {
+        return { ok: false, error: 'file_path is required' };
+    }
+    if (oldString.length === 0) {
+        return { ok: false, error: 'old_string is required and must be non-empty' };
+    }
+    let originalContent;
+    try {
+        originalContent = readProjectFile(rootDir, filePath);
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: `Cannot read file for str_replace: ${err.message}. Use write_file to create new files.`,
+        };
+    }
+    const currentHash = getCurrentFileHash(rootDir, filePath);
+    const coveragePath = normalizeProjectRelativePath(rootDir, filePath) ?? filePath;
+    oldString = resolveRedactionTokens(context.safety, oldString, coveragePath, currentHash);
+    newString = resolveRedactionTokens(context.safety, newString, coveragePath, currentHash);
+    const n = countOccurrences(originalContent, oldString);
+    if (n === 0) {
+        const hint = buildClosestMatchHint(originalContent, oldString);
+        return {
+            ok: false,
+            filePath,
+            error: `String not found in file.${hint}`,
+            failureCategory: 'conflict',
+            failureDetails: {
+                category: 'conflict',
+                tool: 'str_replace',
+                action: 'The oldString text does not exist in this file. Do not keep editing imagined code; retry with oldString copied exactly from read_file output or use patch_file with exact current context.',
+            },
+        };
+    }
+    if (n >= 2 && !replaceAll) {
+        return {
+            ok: false,
+            error: `old_string matches ${n} locations. Provide more surrounding context to make it unique, or set replace_all: true.`,
+        };
+    }
+    const preview = buildStrReplacePreview(oldString, newString);
+    if (!isTuiMode()) {
+        console.log(chalk.bold(`\n  📋 str_replace preview for ${filePath}:`));
+        for (const line of preview.split('\n')) {
+            if (line.startsWith('+')) {
+                console.log(chalk.green(line));
+            }
+            else if (line.startsWith('-')) {
+                console.log(chalk.red(line));
+            }
+            else if (line.startsWith('@@')) {
+                console.log(chalk.cyan(line));
+            }
+            else {
+                console.log(chalk.dim(line));
+            }
+        }
+        console.log();
+    }
+    if (!autoYes && confirmPatch) {
+        const confirmed = await confirmPatch(filePath, preview);
+        if (!confirmed) {
+            if (!isTuiMode())
+                console.log(chalk.dim(`  ⏭  str_replace skipped: ${filePath}`));
+            return {
+                ok: false,
+                skipped: true,
+                filePath,
+                error: 'User declined str_replace',
+            };
+        }
+    }
+    const nextContent = originalContent.split(oldString).join(newString);
+    const { changed } = writeProjectFile(rootDir, filePath, nextContent);
+    const replacements = changed ? (replaceAll ? n : 1) : 0;
+    let indexedChunks = 0;
+    let retrievalTokensUsed = 0;
+    if (changed) {
+        const indexResult = await upsertIndexFile(projectIndex, filePath);
+        indexedChunks = indexResult.indexedChunks;
+        retrievalTokensUsed = indexResult.retrievalTokensUsed ?? 0;
+    }
+    invalidateShellDiagnosticsCache(rootDir, filePath);
+    const diagnostics = runShellDiagnostics(rootDir, filePath);
+    const originalLines = originalContent.split('\n').length;
+    const nextLines = nextContent.split('\n').length;
+    if (!isTuiMode()) {
+        const actionLabel = changed ? 'str_replace' : 'str_replace (no change)';
+        const color = changed ? chalk.green : chalk.yellow;
+        console.log(color(`  ✏️  ${actionLabel}: ${filePath} (${originalLines} → ${nextLines} lines, ${replacements} replacement(s))`));
+    }
+    return {
+        ok: true,
+        filePath,
+        changed,
+        operation: 'str_replace',
+        replacements,
+        indexedChunks,
+        retrievalTokensUsed,
+        bytesWritten: Buffer.byteLength(nextContent, 'utf-8'),
+        diagnostics,
+        message: changed ? undefined : 'The provided replacement resulted in no changes to the file content.',
+    };
+}

package/dist/src/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/tools/undo-edit.js

@@ -0,0 +1,202 @@
+import chalk from 'chalk';
+import { hashContent, readFileEditSnapshot, } from '../edit-journal.js';
+import { deleteProjectFile, writeProjectFile, } from '../patcher.js';
+import { removeIndexFile, upsertIndexFile, } from '../project-index.js';
+import { isTuiMode } from '../runtime-mode.js';
+import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';
+function normalizeTarget(value) {
+    const text = String(value ?? '').trim();
+    if (text === 'last_turn' ||
+        text === 'file' ||
+        text === 'edit_id' ||
+        text === 'last_assistant_edit') {
+        return text;
+    }
+    return 'last_assistant_edit';
+}
+function activeRecords(records) {
+    return records.filter((record) => !record.revertedAt);
+}
+function latestRecord(records) {
+    return records.length ? records[records.length - 1] : null;
+}
+function selectRecords(records, target, editId, filePath) {
+    const active = activeRecords(records);
+    if (target === 'edit_id') {
+        return active.filter((record) => record.id === editId);
+    }
+    if (target === 'file') {
+        const latest = latestRecord(active.filter((record) => record.filePath === filePath));
+        return latest ? [latest] : [];
+    }
+    if (target === 'last_turn') {
+        const latest = latestRecord(active);
+        if (!latest)
+            return [];
+        if (!latest.turnId)
+            return [latest];
+        return active.filter((record) => record.turnId === latest.turnId).reverse();
+    }
+    const latest = latestRecord(active);
+    return latest ? [latest] : [];
+}
+function validateUndoPlan(rootDir, records) {
+    const simulatedHashes = new Map();
+    for (const record of records) {
+        let currentHash;
+        if (simulatedHashes.has(record.filePath)) {
+            currentHash = simulatedHashes.get(record.filePath) ?? null;
+        }
+        else {
+            const current = readFileEditSnapshot(rootDir, record.filePath);
+            if (current.error) {
+                return {
+                    ok: false,
+                    error: `Cannot inspect ${record.filePath} before undo: ${current.error}`,
+                    editId: record.id,
+                    filePath: record.filePath,
+                    expectedHash: record.afterHash,
+                    currentHash: current.hash,
+                };
+            }
+            currentHash = current.hash;
+        }
+        if (currentHash !== record.afterHash) {
+            return {
+                ok: false,
+                error: `Cannot undo ${record.id} for ${record.filePath}: ` +
+                    'the file changed after the assistant edit.',
+                editId: record.id,
+                filePath: record.filePath,
+                expectedHash: record.afterHash,
+                currentHash,
+            };
+        }
+        const needsPreimage = record.operation === 'update' || record.operation === 'delete';
+        if (needsPreimage) {
+            if (record.beforeContent === null || record.beforeHash === null) {
+                return {
+                    ok: false,
+                    error: `Cannot undo ${record.id}: the stored pre-edit snapshot is incomplete.`,
+                    editId: record.id,
+                    filePath: record.filePath,
+                    expectedHash: record.beforeHash,
+                    currentHash,
+                };
+            }
+            const beforeContentHash = hashContent(record.beforeContent);
+            if (beforeContentHash !== record.beforeHash) {
+                return {
+                    ok: false,
+                    error: `Cannot undo ${record.id}: stored before-content hash does not match the edit record.`,
+                    editId: record.id,
+                    filePath: record.filePath,
+                    expectedHash: record.beforeHash,
+                    currentHash: beforeContentHash,
+                };
+            }
+        }
+        simulatedHashes.set(record.filePath, record.operation === 'create' ? null : record.beforeHash);
+    }
+    return { ok: true };
+}
+async function applyUndo(context, record) {
+    const { rootDir, projectIndex } = context;
+    if (record.operation === 'create') {
+        deleteProjectFile(rootDir, record.filePath);
+        await removeIndexFile(projectIndex, record.filePath);
+        return { changed: true };
+    }
+    if (record.beforeContent === null) {
+        throw new Error(`Cannot undo ${record.id}: the stored pre-edit snapshot is incomplete.`);
+    }
+    const { changed } = writeProjectFile(rootDir, record.filePath, record.beforeContent);
+    if (changed) {
+        await upsertIndexFile(projectIndex, record.filePath);
+    }
+    return { changed };
+}
+function summarizeUndoRecord(record) {
+    return {
+        id: record.id,
+        filePath: record.filePath,
+        operation: record.operation,
+        toolName: record.toolName,
+        turnId: record.turnId,
+    };
+}
+export async function undoEdit(context, args) {
+    const records = context.editJournal ?? [];
+    const target = normalizeTarget(args.target);
+    const editId = String(args.editId ?? args.edit_id ?? '').trim();
+    const filePath = String(args.filePath ?? args.file_path ?? '').trim();
+    if (target === 'edit_id' && !editId) {
+        return {
+            ok: false,
+            failureCategory: 'missing_required_argument',
+            error: 'editId is required when target is edit_id',
+        };
+    }
+    if (target === 'file' && !filePath) {
+        return {
+            ok: false,
+            failureCategory: 'missing_required_argument',
+            error: 'filePath is required when target is file',
+        };
+    }
+    const selected = selectRecords(records, target, editId, filePath);
+    if (!selected.length) {
+        return {
+            ok: false,
+            failureCategory: 'not_found',
+            error: 'No active assistant edit matched the undo request.',
+            target,
+            editId: editId || undefined,
+            filePath: filePath || undefined,
+        };
+    }
+    const validation = validateUndoPlan(context.rootDir, selected);
+    if (!validation.ok) {
+        return {
+            ok: false,
+            failureCategory: 'conflict',
+            error: validation.error,
+            editId: validation.editId,
+            filePath: validation.filePath,
+            expectedHash: validation.expectedHash,
+            currentHash: validation.currentHash,
+        };
+    }
+    const dryRun = args.dryRun === true || args.dry_run === true;
+    let anyChanged = false;
+    if (!dryRun) {
+        for (const record of selected) {
+            const result = await applyUndo(context, record);
+            if (result.changed) {
+                anyChanged = true;
+            }
+            context.markEditReverted?.(record.id, context.currentToolCallId ?? 'undo_edit');
+        }
+        invalidateShellDiagnosticsCache(context.rootDir);
+    }
+    const previewed = dryRun ? selected.map(summarizeUndoRecord) : [];
+    const reverted = dryRun ? [] : selected.map(summarizeUndoRecord);
+    if (!isTuiMode()) {
+        const files = (dryRun ? previewed : reverted)
+            .map((record) => record.filePath)
+            .join(', ');
+        const actionLabel = anyChanged || dryRun ? 'Undo' : 'Undo (no change)';
+        console.log(chalk.green(`  ${actionLabel} ${dryRun ? 'preview' : 'edit'}: ${files}`));
+    }
+    return {
+        ok: true,
+        operation: 'undo_edit',
+        target,
+        changed: anyChanged,
+        dryRun,
+        previewed,
+        reverted,
+        gitWorkTree: selected.some((record) => record.gitWorkTree),
+        diagnostics: dryRun ? undefined : runShellDiagnostics(context.rootDir),
+    };
+}

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

@@ -0,0 +1,59 @@
+import chalk from 'chalk';
+import { normalizeProjectRelativePath } from '../artifact-policy.js';
+import { writeProjectFile } from '../patcher.js';
+import { upsertIndexFile } from '../project-index.js';
+import { isTuiMode } from '../runtime-mode.js';
+import { getCurrentFileHash, hasFreshFullReadCoverage, resolveRedactionTokens, } from '../session-safety.js';
+import { invalidateShellDiagnosticsCache, runShellDiagnostics, } from './shell-diagnostics.js';
+export async function writeFile(context, args) {
+    const { rootDir, projectIndex } = context;
+    const filePath = String(args.filePath ?? '').trim();
+    let content = typeof args.content === 'string' ? args.content : '';
+    if (!filePath) {
+        return { ok: false, error: 'filePath is required' };
+    }
+    const coveragePath = normalizeProjectRelativePath(rootDir, filePath) ?? filePath;
+    const currentHash = getCurrentFileHash(rootDir, filePath);
+    if (currentHash !== null &&
+        context.safety &&
+        !hasFreshFullReadCoverage(context.safety, coveragePath, currentHash)) {
+        return {
+            ok: false,
+            filePath,
+            failureCategory: 'conflict',
+            error: `write_file refused to replace existing file ${filePath} without a fresh full-file read at the current hash.`,
+            failureDetails: {
+                category: 'conflict',
+                tool: 'write_file',
+                action: 'Call read_file for the full file first, then retry write_file only if a full replacement is still necessary. Prefer str_replace or patch_file for targeted edits.',
+            },
+            currentHash,
+        };
+    }
+    content = resolveRedactionTokens(context.safety, content, coveragePath, currentHash);
+    const { changed } = writeProjectFile(rootDir, filePath, content);
+    let indexedChunks = 0;
+    let retrievalTokensUsed = 0;
+    if (changed) {
+        const indexResult = await upsertIndexFile(projectIndex, filePath);
+        indexedChunks = indexResult.indexedChunks;
+        retrievalTokensUsed = indexResult.retrievalTokensUsed ?? 0;
+    }
+    invalidateShellDiagnosticsCache(rootDir, filePath);
+    const diagnostics = runShellDiagnostics(rootDir, filePath);
+    if (!isTuiMode()) {
+        const icon = changed ? '✨' : '📝';
+        const label = changed ? 'Created/Updated' : 'Created/Updated (no change)';
+        console.log(chalk.green(`  ${icon} ${label}: ${filePath}`));
+    }
+    return {
+        ok: true,
+        filePath,
+        changed,
+        operation: 'write',
+        indexedChunks,
+        retrievalTokensUsed,
+        bytesWritten: Buffer.byteLength(content, 'utf-8'),
+        diagnostics,
+    };
+}