lcagent-cli 0.1.5 → 0.1.7

package/dist/tools/editFile.js

@@ -1,48 +1,308 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import { isAbsolute, resolve } from 'node:path';
+import { applyPatch as applyUnifiedPatch, parsePatch } from 'diff';
 import { z } from 'zod';
+import { applyMatches, findEditMatches, stripTrailingWhitespace } from './editUtils.js';
 const inputSchema = z.object({
-    path: z.string().min(1),
-    oldText: z.string(),
-    newText: z.string(),
+    path: z.string().min(1).optional(),
+    filePath: z.string().min(1).optional(),
+    file_path: z.string().min(1).optional(),
+    patch: z.string().optional(),
+    diff: z.string().optional(),
+    unifiedDiff: z.string().optional(),
+    unified_diff: z.string().optional(),
+    oldText: z.string().optional(),
+    old_text: z.string().optional(),
+    newText: z.string().optional(),
+    new_text: z.string().optional(),
+    replaceAll: z.boolean().optional(),
+    replace_all: z.boolean().optional(),
+    occurrence: z.number().int().positive().optional(),
+    occurrence_index: z.number().int().positive().optional(),
 });
 function resolvePath(cwd, filePath) {
     return isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
 }
+function normalizePatchPath(filePath) {
+    if (!filePath) {
+        return null;
+    }
+    return filePath.replace(/^(a|b)\//, '');
+}
+function getPathBasename(filePath) {
+    const segments = filePath.replace(/\\/g, '/').split('/').filter(Boolean);
+    return segments[segments.length - 1] ?? filePath;
+}
+function extractSinglePatch(patchText) {
+    const parsed = parsePatch(patchText);
+    if (parsed.length === 0) {
+        return { error: 'Patch could not be parsed. Provide a valid unified diff.' };
+    }
+    if (parsed.length > 1) {
+        return {
+            error: 'Patch mode currently supports exactly one file diff. Split multi-file patches into separate edit_file calls.',
+        };
+    }
+    const patch = parsed[0];
+    const targetPath = normalizePatchPath(patch.newFileName) ?? normalizePatchPath(patch.oldFileName);
+    return { patch, targetPath };
+}
+function patchTouchedLines(patch) {
+    const lines = new Set();
+    for (const hunk of patch.hunks) {
+        const removedOnly = hunk.lines.every(line => line.startsWith('-'));
+        const start = removedOnly ? hunk.oldStart : hunk.newStart;
+        const length = removedOnly ? hunk.oldLines : hunk.newLines;
+        const safeLength = Math.max(length, 1);
+        for (let offset = 0; offset < safeLength; offset += 1) {
+            lines.add(start + offset);
+        }
+    }
+    return [...lines].sort((left, right) => left - right);
+}
+function buildPatchMismatchDiagnostic(inputPath, patchPath) {
+    return [
+        'Patch target path does not match the requested file path.',
+        `Input path: ${inputPath}`,
+        `Patch path: ${patchPath}`,
+        'Either omit path and let the patch header decide, or make them match exactly.',
+    ].join('\n');
+}
+function applySingleFilePatch(current, patchText) {
+    const parsed = extractSinglePatch(patchText);
+    if ('error' in parsed) {
+        return parsed;
+    }
+    const updated = applyUnifiedPatch(current, parsed.patch, {
+        fuzzFactor: 0,
+    });
+    if (updated === false) {
+        return {
+            error: [
+                'Patch could not be applied cleanly.',
+                'The file content may have changed, or the patch context does not match exactly.',
+                'Re-read the file and generate a fresh unified diff.',
+            ].join('\n'),
+        };
+    }
+    return {
+        updated,
+        touchedLines: patchTouchedLines(parsed.patch),
+        patchPath: parsed.targetPath,
+    };
+}
+function getLineNumberAtIndex(source, index) {
+    return source.slice(0, index).split(/\r?\n/).length;
+}
+function buildLinePreview(source, lineNumber) {
+    const lines = source.split(/\r?\n/);
+    const start = Math.max(lineNumber - 2, 0);
+    const end = Math.min(lineNumber + 1, lines.length);
+    return lines
+        .slice(start, end)
+        .map((line, offset) => `${start + offset + 1}: ${line}`)
+        .join('\n');
+}
+function buildNotFoundDiagnostic(source, oldText) {
+    const firstAnchor = oldText
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .find(Boolean);
+    if (!firstAnchor) {
+        return 'oldText was not found in the target file.';
+    }
+    const lines = source.split(/\r?\n/);
+    const anchorLower = firstAnchor.toLowerCase();
+    const matchingLines = lines
+        .map((line, index) => ({ line, lineNumber: index + 1 }))
+        .filter(item => item.line.toLowerCase().includes(anchorLower))
+        .slice(0, 3);
+    if (matchingLines.length === 0) {
+        const whitespaceNormalized = stripTrailingWhitespace(oldText);
+        const sourceWithoutTrailingWhitespace = stripTrailingWhitespace(source);
+        if (whitespaceNormalized !== oldText &&
+            sourceWithoutTrailingWhitespace.includes(whitespaceNormalized)) {
+            return [
+                'oldText was not found exactly in the target file.',
+                'A trailing-whitespace-normalized version appears to exist.',
+                'Try reading the file again and resend oldText without trailing spaces.',
+            ].join('\n');
+        }
+        return 'oldText was not found in the target file.';
+    }
+    return [
+        'oldText was not found exactly in the target file.',
+        'Closest anchor matches:',
+        ...matchingLines.map(item => `${item.lineNumber}: ${item.line}`),
+    ].join('\n');
+}
 export const editFileTool = {
     name: 'edit_file',
-    description: 'Replace the first occurrence of oldText with newText in a text file.',
+    description: 'Edit a file either by replacing text or by applying a single-file unified diff patch.',
     inputSchema,
     inputSchemaJson: {
         type: 'object',
         properties: {
             path: { type: 'string' },
+            patch: {
+                type: 'string',
+                description: 'Unified diff patch for a single file. When provided, oldText/newText are not required.',
+            },
             oldText: { type: 'string' },
             newText: { type: 'string' },
+            replaceAll: { type: 'boolean' },
+            occurrence: {
+                type: 'integer',
+                description: '1-based occurrence index to replace when multiple exact matches exist.',
+            },
         },
-        required: ['path', 'oldText', 'newText'],
         additionalProperties: false,
     },
     isReadOnly: false,
     async execute(input, context) {
-        if (context.approvalMode === 'manual') {
+        const normalizedPath = input.path ?? input.filePath ?? input.file_path;
+        const patchText = input.patch ?? input.diff ?? input.unifiedDiff ?? input.unified_diff;
+        const oldText = input.oldText ?? input.old_text;
+        const newText = input.newText ?? input.new_text;
+        const replaceAll = input.replaceAll ?? input.replace_all ?? false;
+        const occurrence = input.occurrence ?? input.occurrence_index;
+        if (patchText !== undefined && (oldText !== undefined || newText !== undefined)) {
+            return {
+                isError: true,
+                content: 'Use either patch mode or oldText/newText mode, not both in the same call.',
+            };
+        }
+        if (patchText === undefined && (!normalizedPath || oldText === undefined || newText === undefined)) {
+            return {
+                isError: true,
+                content: 'Missing required fields. Use path + oldText + newText, or provide patch (and optionally path).',
+            };
+        }
+        if (patchText === undefined && oldText !== undefined && oldText.length === 0) {
             return {
                 isError: true,
-                content: 'edit_file is blocked in manual approval mode. Switch config approvalMode to auto to enable file edits.',
+                content: 'oldText must not be empty.',
             };
         }
-        const absolutePath = resolvePath(context.cwd, input.path);
-        const current = await readFile(absolutePath, 'utf8');
-        if (!current.includes(input.oldText)) {
+        if (patchText !== undefined && (replaceAll || occurrence !== undefined)) {
             return {
                 isError: true,
-                content: 'oldText was not found in the target file.',
+                content: 'replaceAll and occurrence are only supported in oldText/newText mode.',
             };
         }
-        const next = current.replace(input.oldText, input.newText);
+        if (patchText === undefined && replaceAll && occurrence !== undefined) {
+            return {
+                isError: true,
+                content: 'Use either replaceAll or occurrence, not both.',
+            };
+        }
+        let resolvedPath = normalizedPath;
+        if (patchText !== undefined) {
+            const parsed = extractSinglePatch(patchText);
+            if ('error' in parsed) {
+                return {
+                    isError: true,
+                    content: parsed.error,
+                };
+            }
+            if (!resolvedPath && parsed.targetPath) {
+                resolvedPath = parsed.targetPath;
+            }
+            if (!resolvedPath) {
+                return {
+                    isError: true,
+                    content: 'Patch mode requires a path field or a patch header with a target file path.',
+                };
+            }
+            if (parsed.targetPath && normalizePatchPath(resolvedPath) !== normalizePatchPath(parsed.targetPath)) {
+                return {
+                    isError: true,
+                    content: buildPatchMismatchDiagnostic(resolvedPath, parsed.targetPath),
+                };
+            }
+        }
+        const absolutePath = resolvePath(context.cwd, resolvedPath);
+        let current;
+        try {
+            current = await readFile(absolutePath, 'utf8');
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: error instanceof Error ? error.message : String(error),
+            };
+        }
+        if (patchText !== undefined) {
+            const patchResult = applySingleFilePatch(current, patchText);
+            if ('error' in patchResult) {
+                return {
+                    isError: true,
+                    content: patchResult.error,
+                };
+            }
+            await writeFile(absolutePath, patchResult.updated, 'utf8');
+            return {
+                content: `Applied patch to ${resolvedPath} touching line${patchResult.touchedLines.length === 1 ? '' : 's'} ${patchResult.touchedLines.join(', ')}.`,
+            };
+        }
+        const requiredOldText = oldText;
+        const requiredNewText = newText;
+        const matches = findEditMatches(current, requiredOldText);
+        if (matches.length === 0) {
+            return {
+                isError: true,
+                content: buildNotFoundDiagnostic(current, requiredOldText),
+            };
+        }
+        let next;
+        let replacedCount;
+        let replacedLines;
+        let matchTypeLabel = matches[0]?.matchType === 'normalized_quotes'
+            ? 'normalized quote match'
+            : 'exact match';
+        if (replaceAll) {
+            next = applyMatches(current, requiredOldText, requiredNewText, matches);
+            replacedCount = matches.length;
+            replacedLines = matches.map(match => getLineNumberAtIndex(current, match.index));
+        }
+        else if (occurrence !== undefined) {
+            if (occurrence > matches.length) {
+                return {
+                    isError: true,
+                    content: `Requested occurrence ${occurrence}, but only found ${matches.length} exact match(es).`,
+                };
+            }
+            const selected = matches[occurrence - 1];
+            next = applyMatches(current, requiredOldText, requiredNewText, [selected]);
+            replacedCount = 1;
+            replacedLines = [getLineNumberAtIndex(current, selected.index)];
+            matchTypeLabel = selected.matchType === 'normalized_quotes'
+                ? 'normalized quote match'
+                : 'exact match';
+        }
+        else if (matches.length > 1) {
+            const previews = matches.slice(0, 3).map(match => {
+                const lineNumber = getLineNumberAtIndex(current, match.index);
+                return `${match.matchType === 'normalized_quotes' ? '[normalized-quotes]' : '[exact]'}\n${buildLinePreview(current, lineNumber)}`;
+            });
+            return {
+                isError: true,
+                content: [
+                    `Found ${matches.length} ${matches[0]?.matchType === 'normalized_quotes' ? 'normalized quote' : 'exact'} matches for oldText in ${resolvedPath}.`,
+                    'Specify occurrence (1-based) or set replaceAll=true.',
+                    'Example matching locations:',
+                    ...previews,
+                ].join('\n---\n'),
+            };
+        }
+        else {
+            next = applyMatches(current, requiredOldText, requiredNewText, [matches[0]]);
+            replacedCount = 1;
+            replacedLines = [getLineNumberAtIndex(current, matches[0].index)];
+        }
         await writeFile(absolutePath, next, 'utf8');
         return {
-            content: `Updated ${input.path}`,
+            content: `Updated ${resolvedPath} (${replacedCount} replacement${replacedCount === 1 ? '' : 's'}) using ${matchTypeLabel} at line${replacedLines.length === 1 ? '' : 's'} ${replacedLines.join(', ')}.`,
         };
     },
 };

package/dist/tools/editUtils.d.ts

@@ -0,0 +1,15 @@
+export declare const LEFT_SINGLE_CURLY_QUOTE = "\u2018";
+export declare const RIGHT_SINGLE_CURLY_QUOTE = "\u2019";
+export declare const LEFT_DOUBLE_CURLY_QUOTE = "\u201C";
+export declare const RIGHT_DOUBLE_CURLY_QUOTE = "\u201D";
+export type EditMatch = {
+    index: number;
+    actual: string;
+    matchType: 'exact' | 'normalized_quotes';
+};
+export declare function normalizeQuotes(value: string): string;
+export declare function stripTrailingWhitespace(value: string): string;
+export declare function findExactMatchIndices(source: string, target: string): number[];
+export declare function preserveQuoteStyle(requestedOldText: string, actualOldText: string, requestedNewText: string): string;
+export declare function findEditMatches(source: string, requestedOldText: string): EditMatch[];
+export declare function applyMatches(source: string, requestedOldText: string, requestedNewText: string, matches: EditMatch[]): string;

package/dist/tools/editUtils.js

@@ -0,0 +1,142 @@
+export const LEFT_SINGLE_CURLY_QUOTE = '‘';
+export const RIGHT_SINGLE_CURLY_QUOTE = '’';
+export const LEFT_DOUBLE_CURLY_QUOTE = '“';
+export const RIGHT_DOUBLE_CURLY_QUOTE = '”';
+export function normalizeQuotes(value) {
+    return value
+        .replaceAll(LEFT_SINGLE_CURLY_QUOTE, "'")
+        .replaceAll(RIGHT_SINGLE_CURLY_QUOTE, "'")
+        .replaceAll(LEFT_DOUBLE_CURLY_QUOTE, '"')
+        .replaceAll(RIGHT_DOUBLE_CURLY_QUOTE, '"');
+}
+export function stripTrailingWhitespace(value) {
+    const parts = value.split(/(\r\n|\n|\r)/);
+    let result = '';
+    for (let index = 0; index < parts.length; index += 1) {
+        const part = parts[index];
+        if (part === undefined) {
+            continue;
+        }
+        result += index % 2 === 0 ? part.replace(/\s+$/, '') : part;
+    }
+    return result;
+}
+export function findExactMatchIndices(source, target) {
+    const indices = [];
+    if (!target) {
+        return indices;
+    }
+    let searchStart = 0;
+    while (searchStart <= source.length) {
+        const index = source.indexOf(target, searchStart);
+        if (index === -1) {
+            break;
+        }
+        indices.push(index);
+        searchStart = index + Math.max(target.length, 1);
+    }
+    return indices;
+}
+function isOpeningContext(characters, index) {
+    if (index === 0) {
+        return true;
+    }
+    const previous = characters[index - 1];
+    return (previous === ' ' ||
+        previous === '\t' ||
+        previous === '\n' ||
+        previous === '\r' ||
+        previous === '(' ||
+        previous === '[' ||
+        previous === '{' ||
+        previous === '\u2014' ||
+        previous === '\u2013');
+}
+function applyCurlyDoubleQuotes(value) {
+    const characters = [...value];
+    const result = [];
+    for (let index = 0; index < characters.length; index += 1) {
+        const character = characters[index];
+        if (character === '"') {
+            result.push(isOpeningContext(characters, index)
+                ? LEFT_DOUBLE_CURLY_QUOTE
+                : RIGHT_DOUBLE_CURLY_QUOTE);
+            continue;
+        }
+        result.push(character ?? '');
+    }
+    return result.join('');
+}
+function applyCurlySingleQuotes(value) {
+    const characters = [...value];
+    const result = [];
+    for (let index = 0; index < characters.length; index += 1) {
+        const character = characters[index];
+        if (character === "'") {
+            const previous = index > 0 ? characters[index - 1] : undefined;
+            const next = index < characters.length - 1 ? characters[index + 1] : undefined;
+            const previousIsLetter = previous !== undefined && /\p{L}/u.test(previous);
+            const nextIsLetter = next !== undefined && /\p{L}/u.test(next);
+            if (previousIsLetter && nextIsLetter) {
+                result.push(RIGHT_SINGLE_CURLY_QUOTE);
+            }
+            else {
+                result.push(isOpeningContext(characters, index)
+                    ? LEFT_SINGLE_CURLY_QUOTE
+                    : RIGHT_SINGLE_CURLY_QUOTE);
+            }
+            continue;
+        }
+        result.push(character ?? '');
+    }
+    return result.join('');
+}
+export function preserveQuoteStyle(requestedOldText, actualOldText, requestedNewText) {
+    if (requestedOldText === actualOldText) {
+        return requestedNewText;
+    }
+    const hasDoubleCurlyQuotes = actualOldText.includes(LEFT_DOUBLE_CURLY_QUOTE) ||
+        actualOldText.includes(RIGHT_DOUBLE_CURLY_QUOTE);
+    const hasSingleCurlyQuotes = actualOldText.includes(LEFT_SINGLE_CURLY_QUOTE) ||
+        actualOldText.includes(RIGHT_SINGLE_CURLY_QUOTE);
+    if (!hasDoubleCurlyQuotes && !hasSingleCurlyQuotes) {
+        return requestedNewText;
+    }
+    let result = requestedNewText;
+    if (hasDoubleCurlyQuotes) {
+        result = applyCurlyDoubleQuotes(result);
+    }
+    if (hasSingleCurlyQuotes) {
+        result = applyCurlySingleQuotes(result);
+    }
+    return result;
+}
+export function findEditMatches(source, requestedOldText) {
+    const exactMatches = findExactMatchIndices(source, requestedOldText);
+    if (exactMatches.length > 0) {
+        return exactMatches.map(index => ({
+            index,
+            actual: requestedOldText,
+            matchType: 'exact',
+        }));
+    }
+    const normalizedOldText = normalizeQuotes(requestedOldText);
+    const normalizedSource = normalizeQuotes(source);
+    const normalizedIndices = findExactMatchIndices(normalizedSource, normalizedOldText);
+    return normalizedIndices.map(index => ({
+        index,
+        actual: source.slice(index, index + requestedOldText.length),
+        matchType: 'normalized_quotes',
+    }));
+}
+export function applyMatches(source, requestedOldText, requestedNewText, matches) {
+    let next = source;
+    for (const match of [...matches].sort((left, right) => right.index - left.index)) {
+        const replacement = preserveQuoteStyle(requestedOldText, match.actual, requestedNewText);
+        next =
+            next.slice(0, match.index) +
+                replacement +
+                next.slice(match.index + match.actual.length);
+    }
+    return next;
+}

package/dist/tools/execute.js

@@ -1,17 +1,74 @@
+import { buildApprovalRequest } from './permissions.js';
+function finalizeResult(result, context, startedAt, approval, failureStage) {
+    return {
+        ...result,
+        meta: {
+            cwd: context.cwd,
+            durationMs: Date.now() - startedAt,
+            approval,
+            failureStage,
+        },
+    };
+}
 export async function executeToolCall(toolUse, tools, context) {
+    const startedAt = Date.now();
     const tool = tools.find(item => item.name === toolUse.name);
     if (!tool) {
-        return {
+        return finalizeResult({
             isError: true,
             content: `Unknown tool: ${toolUse.name}`,
-        };
+        }, context, startedAt, {
+            mode: context.approvalMode,
+            required: false,
+        }, 'lookup');
     }
     const parsed = tool.inputSchema.safeParse(toolUse.input);
     if (!parsed.success) {
-        return {
+        return finalizeResult({
             isError: true,
             content: parsed.error.message,
-        };
+        }, context, startedAt, {
+            mode: context.approvalMode,
+            required: false,
+        }, 'validation');
+    }
+    const approvalRequest = buildApprovalRequest(tool, parsed.data, context);
+    const approvalMeta = {
+        mode: context.approvalMode,
+        required: Boolean(approvalRequest),
+        risk: approvalRequest?.risk,
+        targets: approvalRequest?.targets,
+    };
+    if (approvalRequest) {
+        if (!context.requestApproval) {
+            return finalizeResult({
+                isError: true,
+                content: 'This tool requires manual approval, but no approval handler is available in the current session.',
+            }, context, startedAt, {
+                ...approvalMeta,
+                approved: false,
+            }, 'approval');
+        }
+        const decision = await context.requestApproval(approvalRequest);
+        if (!decision.approved) {
+            return finalizeResult({
+                isError: true,
+                content: decision.reason ?? `User denied ${tool.name}.`,
+            }, context, startedAt, {
+                ...approvalMeta,
+                approved: false,
+            }, 'approval');
+        }
+        approvalMeta.approved = true;
+    }
+    try {
+        const result = await tool.execute(parsed.data, context);
+        return finalizeResult(result, context, startedAt, approvalMeta);
+    }
+    catch (error) {
+        return finalizeResult({
+            isError: true,
+            content: error instanceof Error ? error.message : String(error),
+        }, context, startedAt, approvalMeta, 'execution');
     }
-    return tool.execute(parsed.data, context);
 }

package/dist/tools/grep.d.ts

@@ -1,10 +1,14 @@
 import { z } from 'zod';
 import type { ToolDefinition } from './types.js';
 declare const inputSchema: z.ZodObject<{
-    pattern: z.ZodString;
+    pattern: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
     path: z.ZodOptional<z.ZodString>;
+    directory: z.ZodOptional<z.ZodString>;
     maxResults: z.ZodOptional<z.ZodNumber>;
+    max_results: z.ZodOptional<z.ZodNumber>;
     isRegex: z.ZodOptional<z.ZodBoolean>;
+    is_regex: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const grepTool: ToolDefinition<z.infer<typeof inputSchema>>;
 export {};

package/dist/tools/grep.js

@@ -2,10 +2,14 @@ import { readdir, readFile } from 'node:fs/promises';
 import { extname, isAbsolute, join, resolve } from 'node:path';
 import { z } from 'zod';
 const inputSchema = z.object({
-    pattern: z.string().min(1),
+    pattern: z.string().min(1).optional(),
+    query: z.string().min(1).optional(),
     path: z.string().optional(),
+    directory: z.string().optional(),
     maxResults: z.number().int().positive().max(200).optional(),
+    max_results: z.number().int().positive().max(200).optional(),
     isRegex: z.boolean().optional(),
+    is_regex: z.boolean().optional(),
 });
 const textExtensions = new Set([
     '.ts', '.tsx', '.js', '.jsx', '.json', '.md', '.txt', '.yml', '.yaml', '.css', '.html', '.mjs', '.cjs', '.sh', '.py', '.java', '.go', '.rs'
@@ -44,17 +48,26 @@ export const grepTool = {
     },
     isReadOnly: true,
     async execute(input, context) {
-        const root = input.path
-            ? isAbsolute(input.path)
-                ? input.path
-                : resolve(context.cwd, input.path)
+        const pattern = input.pattern ?? input.query;
+        if (!pattern) {
+            return {
+                isError: true,
+                content: 'Missing required field: pattern',
+            };
+        }
+        const searchPath = input.path ?? input.directory;
+        const root = searchPath
+            ? isAbsolute(searchPath)
+                ? searchPath
+                : resolve(context.cwd, searchPath)
             : context.cwd;
-        const matcher = input.isRegex
-            ? new RegExp(input.pattern, 'i')
+        const isRegex = input.isRegex ?? input.is_regex;
+        const matcher = isRegex
+            ? new RegExp(pattern, 'i')
             : null;
         const files = await walk(root);
         const results = [];
-        const maxResults = input.maxResults ?? 50;
+        const maxResults = input.maxResults ?? input.max_results ?? 50;
         for (const filePath of files) {
             if (!textExtensions.has(extname(filePath))) {
                 continue;
@@ -68,7 +81,7 @@ export const grepTool = {
                 const line = lines[index] ?? '';
                 const matched = matcher
                     ? matcher.test(line)
-                    : line.toLowerCase().includes(input.pattern.toLowerCase());
+                    : line.toLowerCase().includes(pattern.toLowerCase());
                 if (!matched) {
                     continue;
                 }

package/dist/tools/permissions.d.ts

@@ -0,0 +1,12 @@
+import type { ToolContext, ToolDefinition } from './types.js';
+export declare const DANGEROUS_FILES: readonly [".gitconfig", ".gitmodules", ".bashrc", ".bash_profile", ".zshrc", ".zprofile", ".profile", ".mcp.json", ".claude.json"];
+export declare const DANGEROUS_DIRECTORIES: readonly [".git", ".vscode", ".idea", ".claude"];
+export type ToolApprovalRequest = {
+    toolName: string;
+    summary: string;
+    reason: string;
+    targets: string[];
+    risk: 'low' | 'medium' | 'high';
+    input: unknown;
+};
+export declare function buildApprovalRequest(tool: ToolDefinition, input: unknown, context: ToolContext): ToolApprovalRequest | null;