icopilot 2.2.0

package/dist/tools/auto-check.js

@@ -0,0 +1,218 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { detectLinters } from '../commands/lint-cmd.js';
+import { detectTestFrameworks } from '../commands/test-cmd.js';
+import { config } from '../config.js';
+export const AUTO_FIX_MAX_RETRIES = 3;
+export function getAutoCheckConfig() {
+    return {
+        autoLint: config.autoLint,
+        autoTest: config.autoTest,
+        autoFix: config.autoFix,
+        lintCmd: config.lintCmd.trim() || undefined,
+        testCmd: config.testCmd.trim() || undefined,
+    };
+}
+export function detectAutoLintCommand(cwd = config.cwd) {
+    const configured = config.lintCmd.trim();
+    if (configured)
+        return configured;
+    const linters = detectLinters(cwd);
+    const preferred = linters.find((entry) => entry.name === 'eslint' || entry.name === 'eslint-config') ??
+        linters.find((entry) => entry.name === 'npm-lint') ??
+        linters[0];
+    return preferred?.command;
+}
+export function detectAutoTestCommand(cwd = config.cwd) {
+    const configured = config.testCmd.trim();
+    if (configured)
+        return configured;
+    const frameworks = detectTestFrameworks(cwd);
+    const preferred = frameworks.find((entry) => entry.name === 'npm-test') ??
+        frameworks.find((entry) => entry.name === 'vitest') ??
+        frameworks.find((entry) => entry.name === 'jest') ??
+        frameworks[0];
+    return preferred?.command;
+}
+export async function runAutoLint(changedFiles) {
+    const normalizedFiles = normalizeFiles(changedFiles);
+    if (!normalizedFiles.length) {
+        return { passed: true, output: 'No changed files to lint.', fixable: false };
+    }
+    const lintableFiles = normalizedFiles.filter((file) => /\.(?:[cm]?[jt]sx?|py|go|java|cs|php|rb)$/iu.test(file));
+    if (!lintableFiles.length) {
+        return { passed: true, output: 'No lintable changed files detected.', fixable: false };
+    }
+    const command = buildLintCommand(lintableFiles, config.cwd, getAutoCheckConfig());
+    if (!command) {
+        return {
+            passed: false,
+            output: 'No configured linter detected for auto-lint.',
+            fixable: false,
+        };
+    }
+    const result = await executeShellCommand(command, config.cwd);
+    return toAutoCheckResult(result, { missingCommand: false });
+}
+export async function runAutoTest() {
+    const command = buildTestCommand(config.cwd, getAutoCheckConfig());
+    if (!command) {
+        return {
+            passed: false,
+            output: 'No configured test runner detected for auto-test.',
+            fixable: false,
+        };
+    }
+    const result = await executeShellCommand(command, config.cwd);
+    return toAutoCheckResult(result, { missingCommand: false });
+}
+export function extractChangedFilesFromToolResult(toolName, args, output) {
+    const parsed = tryParseJson(output);
+    switch (toolName) {
+        case 'write_file':
+            return parsed?.wrote && typeof args.path === 'string' ? [args.path] : [];
+        case 'write_files':
+            return parsed?.wrote && Array.isArray(args.items)
+                ? args.items
+                    .map((item) => item && typeof item === 'object'
+                    ? String(item.path ?? '')
+                    : '')
+                    .filter(Boolean)
+                : [];
+        case 'edit_file':
+            return parsed?.ok && typeof args.path === 'string' ? [args.path] : [];
+        case 'multi_edit':
+            return Array.isArray(parsed?.applied)
+                ? parsed.applied.filter((entry) => typeof entry === 'string')
+                : [];
+        case 'apply_patch':
+            return Array.isArray(parsed?.applied)
+                ? parsed.applied
+                    .map((entry) => (typeof entry?.path === 'string' ? entry.path : ''))
+                    .filter(Boolean)
+                : [];
+        default:
+            return [];
+    }
+}
+export function extractAutoLintResult(output) {
+    const parsed = tryParseJson(output);
+    const candidate = parsed?.autoLint;
+    if (!candidate || typeof candidate !== 'object')
+        return undefined;
+    if (typeof candidate.passed !== 'boolean' || typeof candidate.output !== 'string')
+        return undefined;
+    return {
+        passed: candidate.passed,
+        output: candidate.output,
+        fixable: Boolean(candidate.fixable),
+    };
+}
+export function formatAutoCheckResult(kind, result, changedFiles = []) {
+    const header = kind === 'lint' ? 'AUTO LINT' : 'AUTO TEST';
+    const label = changedFiles.length ? ` ${changedFiles.join(', ')}` : '';
+    const summary = result.passed ? 'passed' : 'failed';
+    const detail = result.output.trim();
+    return [`${header}${label}: ${summary}`, detail].filter(Boolean).join('\n');
+}
+export function buildAutoFixPrompt(kind, result, attempt, changedFiles = []) {
+    const scope = changedFiles.length ? `Files: ${changedFiles.join(', ')}\n` : '';
+    return [
+        `Automatic ${kind} failed after your recent edits.`,
+        `Retry ${attempt}/${AUTO_FIX_MAX_RETRIES}.`,
+        scope.trimEnd(),
+        'Fix the reported problem using the available file-editing tools, then stop so the check can re-run.',
+        '',
+        result.output.trim(),
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+function buildLintCommand(lintableFiles, cwd, overrides) {
+    const configured = overrides.lintCmd?.trim();
+    if (configured)
+        return injectFiles(configured, lintableFiles);
+    const linters = detectLinters(cwd);
+    if (!linters.length)
+        return undefined;
+    const explicitEslint = linters.some((entry) => entry.name === 'eslint' || entry.name === 'eslint-config');
+    if (explicitEslint) {
+        return ['npx', 'eslint', ...lintableFiles].map(quoteArg).join(' ');
+    }
+    const preferred = linters.find((entry) => entry.name === 'npm-lint') ?? linters[0];
+    return injectFiles(preferred.command, lintableFiles);
+}
+function buildTestCommand(cwd, overrides) {
+    const configured = overrides.testCmd?.trim();
+    if (configured)
+        return configured;
+    const frameworks = detectTestFrameworks(cwd);
+    if (!frameworks.length)
+        return undefined;
+    const preferred = frameworks.find((entry) => entry.name === 'npm-test') ??
+        frameworks.find((entry) => entry.name === 'vitest') ??
+        frameworks.find((entry) => entry.name === 'jest') ??
+        frameworks[0];
+    return preferred?.command;
+}
+async function executeShellCommand(command, cwd) {
+    return new Promise((resolve) => {
+        const isWin = process.platform === 'win32';
+        const shell = isWin ? process.env.ComSpec || 'cmd.exe' : 'bash';
+        const args = isWin ? ['/d', '/s', '/c', command] : ['-lc', command];
+        const child = spawn(shell, args, {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        let output = '';
+        child.stdout.on('data', (chunk) => {
+            output += String(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            output += String(chunk);
+        });
+        child.on('close', (code) => {
+            resolve({ exitCode: code ?? -1, output });
+        });
+        child.on('error', (error) => {
+            resolve({ exitCode: -1, output: `${output}${error.message}` });
+        });
+    });
+}
+function toAutoCheckResult(result, options) {
+    const output = result.output.trim();
+    const commandMissing = options.missingCommand ||
+        /(?:is not recognized as|not found|No configured .* detected|could not find)/iu.test(output);
+    return {
+        passed: result.exitCode === 0,
+        output: output || (result.exitCode === 0 ? 'Check passed.' : 'Check failed with no output.'),
+        fixable: result.exitCode !== 0 && !commandMissing,
+    };
+}
+function injectFiles(command, files) {
+    if (!files.length)
+        return command;
+    const fileArgs = files.map(quoteArg).join(' ');
+    if (command.includes('{files}')) {
+        return command.replace(/\{files\}/gu, fileArgs);
+    }
+    if (/^(?:npm|pnpm|yarn)\s+/iu.test(command)) {
+        return `${command} -- ${fileArgs}`;
+    }
+    return `${command} ${fileArgs}`;
+}
+function normalizeFiles(files) {
+    return [...new Set(files.map((file) => path.normalize(file)).filter(Boolean))];
+}
+function quoteArg(value) {
+    return `"${value.replace(/(["\\$`])/gu, '\\$1')}"`;
+}
+function tryParseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/tools/diff-edit.js

@@ -0,0 +1,150 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { config } from '../config.js';
+const DIFF_BLOCK_PATTERN = /<<<<<<< SEARCH\r?\nfilepath:\s*(.+?)\r?\n([\s\S]*?)\r?\n=======\r?\n([\s\S]*?)\r?\n>>>>>>> REPLACE/g;
+export function parseDiffBlocks(content) {
+    const blocks = [];
+    for (const match of content.matchAll(DIFF_BLOCK_PATTERN)) {
+        const [, filePath = '', search = '', replace = ''] = match;
+        const normalizedPath = filePath.trim();
+        if (!normalizedPath)
+            continue;
+        blocks.push({
+            filePath: normalizedPath,
+            search: normalizeEol(search),
+            replace: normalizeEol(replace),
+        });
+    }
+    return blocks;
+}
+export function applyDiffBlocks(blocks) {
+    const results = [];
+    const states = new Map();
+    for (const block of blocks) {
+        try {
+            const state = getFileState(states, block.filePath);
+            state.content = applyBlock(state.content, block);
+            fs.writeFileSync(state.absPath, restoreEol(state.content, state.eol), 'utf8');
+            results.push({ filePath: block.filePath, success: true });
+        }
+        catch (error) {
+            results.push({
+                filePath: block.filePath,
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return results;
+}
+function getFileState(states, filePath) {
+    const cached = states.get(filePath);
+    if (cached)
+        return cached;
+    const absPath = path.resolve(config.cwd, filePath);
+    if (!fs.existsSync(absPath)) {
+        throw new Error(`file not found: ${filePath}`);
+    }
+    const raw = fs.readFileSync(absPath, 'utf8');
+    const state = {
+        absPath,
+        eol: raw.includes('\r\n') ? '\r\n' : '\n',
+        content: normalizeEol(raw),
+    };
+    states.set(filePath, state);
+    return state;
+}
+function applyBlock(content, block) {
+    if (!block.search.trim()) {
+        throw new Error(`search text must not be empty for ${block.filePath}`);
+    }
+    const exactMatches = findAllOccurrences(content, block.search);
+    if (exactMatches.length === 1) {
+        const index = exactMatches[0];
+        return content.slice(0, index) + block.replace + content.slice(index + block.search.length);
+    }
+    if (exactMatches.length > 1) {
+        throw new Error(`search text matched multiple locations in ${block.filePath}`);
+    }
+    const fuzzyMatch = findFuzzyMatch(content, block.search);
+    if (!fuzzyMatch) {
+        throw new Error(`search text not found in ${block.filePath}`);
+    }
+    if (fuzzyMatch.ambiguous) {
+        throw new Error(`search text matched multiple locations in ${block.filePath}`);
+    }
+    const lines = content.split('\n');
+    const replacementLines = splitReplacementLines(block.replace);
+    return [
+        ...lines.slice(0, fuzzyMatch.startLine),
+        ...replacementLines,
+        ...lines.slice(fuzzyMatch.endLine),
+    ].join('\n');
+}
+function findAllOccurrences(source, target) {
+    if (!target)
+        return [];
+    const matches = [];
+    let offset = 0;
+    while (offset <= source.length) {
+        const index = source.indexOf(target, offset);
+        if (index === -1)
+            break;
+        matches.push(index);
+        offset = index + target.length;
+    }
+    return matches;
+}
+function findFuzzyMatch(content, search) {
+    const fileLines = content.split('\n');
+    const searchLines = stripBlankEdges(search.split('\n'));
+    if (searchLines.length === 0)
+        return null;
+    const normalizedSearch = searchLines.map(normalizeComparableLine);
+    const maxExtraLines = Math.max(4, search.split('\n').length - searchLines.length + 4);
+    const matches = new Map();
+    for (let start = 0; start < fileLines.length; start += 1) {
+        const minEnd = start + searchLines.length;
+        const maxEnd = Math.min(fileLines.length, minEnd + maxExtraLines);
+        for (let end = minEnd; end <= maxEnd; end += 1) {
+            const candidate = stripBlankEdges(fileLines.slice(start, end));
+            if (candidate.length !== normalizedSearch.length)
+                continue;
+            const normalizedCandidate = candidate.map(normalizeComparableLine);
+            if (normalizedCandidate.every((line, index) => line === normalizedSearch[index])) {
+                matches.set(`${start}:${end}`, { startLine: start, endLine: end });
+            }
+        }
+    }
+    if (matches.size === 0)
+        return null;
+    if (matches.size > 1) {
+        const [first] = matches.values();
+        return first ? { ...first, ambiguous: true } : null;
+    }
+    const [match] = matches.values();
+    return match ? { ...match, ambiguous: false } : null;
+}
+function splitReplacementLines(replace) {
+    if (replace === '')
+        return [];
+    return replace.split('\n');
+}
+function stripBlankEdges(lines) {
+    let start = 0;
+    let end = lines.length;
+    while (start < end && lines[start]?.trim() === '')
+        start += 1;
+    while (end > start && lines[end - 1]?.trim() === '')
+        end -= 1;
+    return lines.slice(start, end);
+}
+function normalizeComparableLine(line) {
+    return line.replace(/\s+/g, '');
+}
+function normalizeEol(value) {
+    return value.replace(/\r\n/g, '\n');
+}
+function restoreEol(value, eol) {
+    return eol === '\n' ? value : value.replace(/\n/g, '\r\n');
+}

package/dist/tools/diff-prompt.js

@@ -0,0 +1,36 @@
+const BASE_SYSTEM_PROMPT = `You are iCopilot, a terminal-native coding assistant powered by GitHub Models.
+
+Operating principles:
+- Be concise. Default to short, direct answers; expand only when warranted.
+- Render code in fenced blocks with the correct language tag.
+- When you propose any change to the user's machine, use a tool call:
+  • run_shell  for shell commands
+  • write_file for creating/overwriting files
+  • read_file  for reading files
+- Never claim to have run a command or written a file unless a tool call returned success.
+- When the user references files with @path, those files are already injected; do not re-read them with read_file.
+- Prefer surgical edits. State assumptions explicitly.`;
+const DIFF_EDIT_SYSTEM_PROMPT = `${BASE_SYSTEM_PROMPT}
+
+When you need to propose direct code edits in plain text, prefer SEARCH/REPLACE blocks over whole-file rewrites:
+<<<<<<< SEARCH
+filepath: src/example.ts
+old code here that exists in file
+=======
+new replacement code
+>>>>>>> REPLACE
+
+Rules:
+- Use one SEARCH/REPLACE block per localized change. Multiple blocks per file are allowed.
+- The filepath line is required in every block.
+- SEARCH content should be copied from the current file and include enough nearby context to be unique.
+- Keep edits minimal; do not rewrite the whole file unless the user explicitly asks for that.`;
+export function getDiffEditSystemPrompt() {
+    return DIFF_EDIT_SYSTEM_PROMPT;
+}
+export function getWholeFileSystemPrompt() {
+    return BASE_SYSTEM_PROMPT;
+}
+export function getEditFormatPrompt(format) {
+    return format === 'whole' ? getWholeFileSystemPrompt() : getDiffEditSystemPrompt();
+}

package/dist/tools/edit-file.js

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { config } from '../config.js';
+import { proposeWrite } from './file-ops.js';
+export async function editFileTool(args) {
+    const startLine = Number(args.startLine);
+    const endLine = Number(args.endLine);
+    const newLines = args.newContent.split('\n');
+    const linesReplaced = Number.isInteger(startLine) && Number.isInteger(endLine) ? endLine - startLine + 1 : 0;
+    try {
+        if (!Number.isInteger(startLine)) {
+            return JSON.stringify(result(false, linesReplaced, newLines.length, 'startLine must be an integer'));
+        }
+        if (!Number.isInteger(endLine)) {
+            return JSON.stringify(result(false, linesReplaced, newLines.length, 'endLine must be an integer'));
+        }
+        if (startLine < 1) {
+            return JSON.stringify(result(false, linesReplaced, newLines.length, 'startLine must be >= 1'));
+        }
+        if (endLine < startLine) {
+            return JSON.stringify(result(false, linesReplaced, newLines.length, 'endLine must be >= startLine'));
+        }
+        const abs = path.resolve(config.cwd, args.path);
+        if (!fs.existsSync(abs)) {
+            return JSON.stringify(result(false, linesReplaced, newLines.length, `file not found: ${args.path}`));
+        }
+        const current = fs.readFileSync(abs, 'utf8');
+        const lines = current.split('\n');
+        if (endLine > lines.length) {
+            return JSON.stringify(result(false, linesReplaced, newLines.length, `line range ${startLine}-${endLine} is out of bounds for ${lines.length}-line file`));
+        }
+        const updated = [...lines.slice(0, startLine - 1), ...newLines, ...lines.slice(endLine)].join('\n');
+        const write = await proposeWrite(args.path, updated);
+        if (!write.wrote) {
+            return JSON.stringify(result(false, linesReplaced, newLines.length, write.error || 'edit rejected'));
+        }
+        return JSON.stringify(result(true, linesReplaced, newLines.length, undefined, write.autoLint));
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        return JSON.stringify(result(false, linesReplaced, newLines.length, message));
+    }
+}
+export const EDIT_FILE_SCHEMA = {
+    type: 'function',
+    function: {
+        name: 'edit_file',
+        description: 'Edit specific lines of a file. More efficient than rewriting the whole file.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string' },
+                startLine: { type: 'number' },
+                endLine: { type: 'number' },
+                newContent: { type: 'string' },
+            },
+            required: ['path', 'startLine', 'endLine', 'newContent'],
+        },
+    },
+};
+function result(ok, linesReplaced, newLineCount, error, autoLint) {
+    const base = error
+        ? { ok, linesReplaced, newLineCount, error }
+        : { ok, linesReplaced, newLineCount };
+    return autoLint ? { ...base, autoLint } : base;
+}

package/dist/tools/file-ops.js

@@ -0,0 +1,205 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createPatch } from 'diff';
+import { confirm } from '@inquirer/prompts';
+import { config } from '../config.js';
+import { theme } from '../ui/theme.js';
+import { formatAutoCheckResult, runAutoLint } from './auto-check.js';
+import { toolMemory } from './memory.js';
+import { loadPolicy, writePathAllowed } from './policy.js';
+import { assertSandbox } from './sandbox.js';
+import { isReadOnly } from '../context/read-only.js';
+import { hookManager } from '../hooks/lifecycle.js';
+/** Show a unified diff and ask the user before writing the file. */
+export async function proposeWrite(relPath, newContent) {
+    const abs = path.resolve(config.cwd, relPath);
+    const denied = ensureWriteAllowed(abs);
+    if (denied) {
+        process.stdout.write(theme.err(`  ${denied}\n`));
+        return { wrote: false, path: abs, bytes: 0, error: denied };
+    }
+    let old = '';
+    let exists = false;
+    try {
+        old = fs.readFileSync(abs, 'utf8');
+        exists = true;
+    }
+    catch {
+        /* new file */
+    }
+    const patch = createPatch(relPath, old, newContent, exists ? 'current' : 'empty', 'proposed');
+    if (!config.quiet && !config.jsonOutput) {
+        process.stdout.write('\n' + theme.badge('WRITE') + ` ${relPath}\n`);
+        process.stdout.write(colorizePatch(patch) + '\n');
+    }
+    const remembered = toolMemory.isWriteRemembered(abs);
+    const ok = config.autoApprove ||
+        remembered ||
+        (await confirm({
+            message: exists ? 'Apply this patch?' : 'Create this new file?',
+            default: false,
+        }).catch(() => false));
+    if (!ok) {
+        if (!config.jsonOutput)
+            process.stdout.write(theme.warn('  skipped.\n'));
+        return { wrote: false, path: abs, bytes: 0 };
+    }
+    if (!config.autoApprove && !remembered) {
+        const remember = await confirm({
+            message: 'Remember this write path for the session?',
+            default: false,
+        }).catch(() => false);
+        if (remember)
+            toolMemory.rememberWrite(abs);
+    }
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, newContent, 'utf8');
+    await hookManager.emit('fileChanged', {
+        cwd: config.cwd,
+        path: relPath,
+        absolutePath: abs,
+        bytes: Buffer.byteLength(newContent),
+    });
+    if (!config.jsonOutput)
+        process.stdout.write(theme.ok(`  ✔ wrote ${relPath}\n`));
+    const autoLint = await maybeRunAutoLint([relPath]);
+    return {
+        wrote: true,
+        path: abs,
+        bytes: Buffer.byteLength(newContent),
+        ...(autoLint ? { autoLint } : {}),
+    };
+}
+export async function proposeWriteBatch(items) {
+    const prepared = [];
+    for (const item of items) {
+        const abs = path.resolve(config.cwd, item.path);
+        const denied = ensureWriteAllowed(abs);
+        if (denied) {
+            process.stdout.write(theme.err(`  ${denied}\n`));
+            return { wrote: false, results: [{ wrote: false, path: abs, bytes: 0, error: denied }] };
+        }
+        let old = '';
+        let exists = false;
+        try {
+            old = fs.readFileSync(abs, 'utf8');
+            exists = true;
+        }
+        catch {
+            /* new file */
+        }
+        prepared.push({ relPath: item.path, abs, content: item.content, old, exists });
+    }
+    if (!config.quiet && !config.jsonOutput) {
+        process.stdout.write('\n' + theme.badge('WRITE BATCH') + ` ${prepared.length} files\n`);
+        for (const item of prepared) {
+            const patch = createPatch(item.relPath, item.old, item.content, item.exists ? 'current' : 'empty', 'proposed');
+            process.stdout.write(colorizePatch(patch) + '\n');
+        }
+    }
+    const remembered = prepared.every((item) => toolMemory.isWriteRemembered(item.abs));
+    const ok = config.autoApprove ||
+        remembered ||
+        (await confirm({
+            message: 'Apply all patches?',
+            default: false,
+        }).catch(() => false));
+    if (!ok) {
+        if (!config.jsonOutput)
+            process.stdout.write(theme.warn('  skipped.\n'));
+        return {
+            wrote: false,
+            results: prepared.map((item) => ({ wrote: false, path: item.abs, bytes: 0 })),
+        };
+    }
+    if (!config.autoApprove && !remembered) {
+        const remember = await confirm({
+            message: 'Remember these write paths for the session?',
+            default: false,
+        }).catch(() => false);
+        if (remember)
+            prepared.forEach((item) => toolMemory.rememberWrite(item.abs));
+    }
+    const results = [];
+    const written = [];
+    try {
+        for (const item of prepared) {
+            fs.mkdirSync(path.dirname(item.abs), { recursive: true });
+            fs.writeFileSync(item.abs, item.content, 'utf8');
+            await hookManager.emit('fileChanged', {
+                cwd: config.cwd,
+                path: item.relPath,
+                absolutePath: item.abs,
+                bytes: Buffer.byteLength(item.content),
+            });
+            written.push(item);
+            results.push({ wrote: true, path: item.abs, bytes: Buffer.byteLength(item.content) });
+        }
+        const autoLint = await maybeRunAutoLint(prepared.map((item) => item.relPath));
+        return { wrote: true, results, ...(autoLint ? { autoLint } : {}) };
+    }
+    catch (e) {
+        const error = e?.message || String(e);
+        for (const item of written.reverse()) {
+            try {
+                if (item.exists)
+                    fs.writeFileSync(item.abs, item.old, 'utf8');
+                else if (fs.existsSync(item.abs))
+                    fs.unlinkSync(item.abs);
+            }
+            catch {
+                /* best-effort rollback */
+            }
+        }
+        return {
+            wrote: false,
+            results: [
+                ...results.map((result) => ({ ...result, wrote: false })),
+                { wrote: false, path: '', bytes: 0, error },
+            ],
+        };
+    }
+}
+export function readFileSafe(relPath) {
+    const abs = path.resolve(config.cwd, relPath);
+    assertSandbox(abs, config.cwd);
+    return fs.readFileSync(abs, 'utf8');
+}
+export function ensureWriteAllowed(abs) {
+    try {
+        assertSandbox(abs, config.cwd);
+    }
+    catch (e) {
+        return e?.message || String(e);
+    }
+    if (isReadOnly(abs))
+        return 'read-only file';
+    if (!writePathAllowed(abs, loadPolicy(config.cwd), config.cwd))
+        return 'policy denied';
+    return undefined;
+}
+function colorizePatch(p) {
+    return p
+        .split('\n')
+        .map((l) => {
+        if (l.startsWith('+++') || l.startsWith('---'))
+            return theme.dim(l);
+        if (l.startsWith('+'))
+            return theme.ok(l);
+        if (l.startsWith('-'))
+            return theme.err(l);
+        if (l.startsWith('@@'))
+            return theme.hl(l);
+        return l;
+    })
+        .join('\n');
+}
+async function maybeRunAutoLint(changedFiles) {
+    if (!config.autoLint)
+        return undefined;
+    const result = await runAutoLint(changedFiles);
+    if (!config.quiet && !config.jsonOutput) {
+        process.stdout.write(`${theme.dim(formatAutoCheckResult('lint', result, changedFiles))}\n`);
+    }
+    return result;
+}

package/dist/tools/glob.js

@@ -0,0 +1,17 @@
+import path from 'node:path';
+import fg from 'fast-glob';
+import { config } from '../config.js';
+import { assertSandbox } from './sandbox.js';
+export async function globTool(args) {
+    const root = path.resolve(config.cwd, args.cwd || '.');
+    assertSandbox(root, config.cwd);
+    const files = await fg(args.pattern, {
+        cwd: root,
+        onlyFiles: true,
+        dot: true,
+        ignore: args.ignore || ['**/node_modules/**', '**/dist/**', '**/.git/**'],
+    });
+    return JSON.stringify({
+        files: files.map((file) => path.relative(config.cwd, path.join(root, file))),
+    });
+}