lcagent-cli 0.1.6 → 0.1.7

package/dist/tools/editFile.js

@@ -1,61 +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).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: 'edit_file is blocked in manual approval mode. Switch config approvalMode to auto to enable file edits.',
+                content: 'Use either patch mode or oldText/newText mode, not both in the same call.',
             };
         }
-        const normalizedPath = input.path ?? input.filePath ?? input.file_path;
-        const oldText = input.oldText ?? input.old_text;
-        const newText = input.newText ?? input.new_text;
-        if (!normalizedPath || oldText === undefined || newText === undefined) {
+        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: 'Missing required fields: path, oldText, or newText',
+                content: 'oldText must not be empty.',
             };
         }
-        const absolutePath = resolvePath(context.cwd, normalizedPath);
-        const current = await readFile(absolutePath, 'utf8');
-        if (!current.includes(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(oldText, 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 ${normalizedPath}`,
+            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,25 +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 {
-        return await tool.execute(parsed.data, context);
+        const result = await tool.execute(parsed.data, context);
+        return finalizeResult(result, context, startedAt, approvalMeta);
     }
     catch (error) {
-        return {
+        return finalizeResult({
             isError: true,
             content: error instanceof Error ? error.message : String(error),
-        };
+        }, context, startedAt, approvalMeta, 'execution');
     }
 }

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;

package/dist/tools/permissions.js

@@ -0,0 +1,105 @@
+import { isAbsolute, normalize, relative, resolve, sep } from 'node:path';
+export const DANGEROUS_FILES = [
+    '.gitconfig',
+    '.gitmodules',
+    '.bashrc',
+    '.bash_profile',
+    '.zshrc',
+    '.zprofile',
+    '.profile',
+    '.mcp.json',
+    '.claude.json',
+];
+export const DANGEROUS_DIRECTORIES = ['.git', '.vscode', '.idea', '.claude'];
+function normalizeCaseForComparison(filePath) {
+    return filePath.toLowerCase();
+}
+function resolveTargetPath(cwd, targetPath) {
+    return isAbsolute(targetPath) ? normalize(targetPath) : normalize(resolve(cwd, targetPath));
+}
+function toDisplayPath(cwd, absolutePath) {
+    const relativePath = relative(cwd, absolutePath);
+    if (!relativePath || relativePath.startsWith(`..${sep}`) || relativePath === '..') {
+        return absolutePath;
+    }
+    return relativePath;
+}
+function isDangerousPath(absolutePath) {
+    const normalizedPath = normalizeCaseForComparison(absolutePath);
+    const pathSegments = normalizedPath.split(/[\\/]+/).filter(Boolean);
+    const fileName = pathSegments[pathSegments.length - 1];
+    if (fileName && DANGEROUS_FILES.includes(fileName)) {
+        return true;
+    }
+    return pathSegments.some(segment => DANGEROUS_DIRECTORIES.includes(segment));
+}
+function extractPatchTarget(patchText) {
+    const lines = patchText.split(/\r?\n/);
+    for (const line of lines) {
+        if (line.startsWith('+++ ') || line.startsWith('--- ')) {
+            const rawPath = line.slice(4).trim();
+            if (!rawPath || rawPath === '/dev/null') {
+                continue;
+            }
+            return rawPath.replace(/^(a|b)\//, '');
+        }
+    }
+    return null;
+}
+function extractCandidateTargets(toolName, input) {
+    if (!input || typeof input !== 'object') {
+        return [];
+    }
+    const record = input;
+    const directPath = [record.path, record.filePath, record.file_path]
+        .find(value => typeof value === 'string' && value.trim().length > 0);
+    if (toolName === 'grep') {
+        const searchPath = [record.path, record.directory]
+            .find(value => typeof value === 'string' && value.trim().length > 0);
+        return searchPath ? [String(searchPath)] : [];
+    }
+    if (toolName === 'run_shell') {
+        return [];
+    }
+    const patchText = [record.patch, record.diff, record.unifiedDiff, record.unified_diff]
+        .find(value => typeof value === 'string' && value.trim().length > 0);
+    const patchPath = typeof patchText === 'string' ? extractPatchTarget(patchText) : null;
+    return [directPath, patchPath].filter((value) => Boolean(value));
+}
+export function buildApprovalRequest(tool, input, context) {
+    if (context.approvalMode === 'auto') {
+        return null;
+    }
+    if (tool.isReadOnly) {
+        return null;
+    }
+    const candidateTargets = extractCandidateTargets(tool.name, input);
+    const absoluteTargets = candidateTargets.map(target => resolveTargetPath(context.cwd, target));
+    const displayTargets = absoluteTargets.map(target => toDisplayPath(context.cwd, target));
+    const hasDangerousTarget = absoluteTargets.some(isDangerousPath);
+    if (tool.name === 'run_shell') {
+        const command = input && typeof input === 'object'
+            ? input.command ?? input.cmd
+            : undefined;
+        return {
+            toolName: tool.name,
+            summary: `Shell execution requested${typeof command === 'string' ? `: ${command}` : '.'}`,
+            reason: 'run_shell can execute arbitrary commands and modify the filesystem or environment.',
+            targets: [],
+            risk: 'high',
+            input,
+        };
+    }
+    return {
+        toolName: tool.name,
+        summary: displayTargets.length > 0
+            ? `Write access requested for ${displayTargets.join(', ')}`
+            : 'Write access requested.',
+        reason: hasDangerousTarget
+            ? 'Target includes a protected configuration or metadata path from the Claude Code-style danger list.'
+            : 'This tool can modify files on disk.',
+        targets: displayTargets,
+        risk: hasDangerousTarget ? 'high' : 'medium',
+        input,
+    };
+}