@qduc/term2 0.3.1 → 0.5.0

package/dist/tools/search-replace.js

@@ -5,6 +5,7 @@ import { resolveWorkspacePath } from './utils.js';
 import { getOutputText, safeJsonParse, normalizeToolArguments, createBaseMessage } from './format-helpers.js';
 import { healSearchReplaceParams } from './edit-healing.js';
 import { getApprovalPresentationCapability } from './tool-capabilities.js';
+import { withFileLock } from './file-locks.js';
 /**
  * Detect the predominant EOL style in file content.
  * Returns '\r\n' if CRLF is dominant, otherwise '\n'.
@@ -66,11 +67,11 @@ function detectSummarizationMarkers(content) {
     }
     return null;
 }
-const searchReplaceParametersSchema = z.object({
+const searchReplaceOperationSchema = z.object({
     path: z.string().describe('The absolute or relative path to the file'),
     search_content: z
         .string()
-        .describe('The exact content to search for. Use <...> on its own line to skip unchanged middle content (gap matching).'),
+        .describe('The exact content to search for. Put <...> on its own line to match (and replace) everything between a head anchor and a tail anchor — lets you edit or delete a large block without reproducing it. The whole span between anchors is replaced, so use distinctive multi-line anchors (never a single generic line) to avoid deleting the wrong region. Omit the anchors from replace_content to delete them too.'),
     replace_content: z.string().describe('The content to replace it with'),
     replace_all: z
         .boolean()
@@ -78,6 +79,52 @@ const searchReplaceParametersSchema = z.object({
         .default(false)
         .describe('Whether to replace all occurrences of the search content. If false, requires exactly one match.'),
 });
+const searchReplaceParametersSchema = z
+    .object({
+    path: z.string().describe('The absolute or relative path to the file').optional(),
+    search_content: z
+        .string()
+        .describe('The exact content to search for. Put <...> on its own line to match (and replace) everything between a head anchor and a tail anchor — lets you edit or delete a large block without reproducing it. The whole span between anchors is replaced, so use distinctive multi-line anchors (never a single generic line) to avoid deleting the wrong region. Omit the anchors from replace_content to delete them too.')
+        .optional(),
+    replace_content: z.string().describe('The content to replace it with').optional(),
+    replace_all: z
+        .boolean()
+        .optional()
+        .describe('Whether to replace all occurrences of the search content. If false, requires exactly one match.'),
+    replacements: z.array(searchReplaceOperationSchema).min(1).optional(),
+})
+    .superRefine((params, ctx) => {
+    const hasBatch = Array.isArray(params.replacements);
+    const hasSingle = params.path !== undefined || params.search_content !== undefined || params.replace_content !== undefined;
+    if (hasBatch && hasSingle) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Provide either replacements or a single path/search_content/replace_content edit, not both.',
+        });
+        return;
+    }
+    if (!hasBatch &&
+        (params.path === undefined || params.search_content === undefined || params.replace_content === undefined)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Provide replacements or all single edit fields: path, search_content, and replace_content.',
+        });
+    }
+});
+function getSearchReplaceOperations(params) {
+    if ('replacements' in params && params.replacements) {
+        return params.replacements;
+    }
+    const operation = params;
+    return [
+        {
+            path: operation.path,
+            search_content: operation.search_content,
+            replace_content: operation.replace_content,
+            replace_all: operation.replace_all ?? false,
+        },
+    ];
+}
 /**
  * Gap marker constant used to indicate omitted middle content in search strings.
  * When the model uses <...> in search_content, the search is split into segments
@@ -207,10 +254,15 @@ function findGapMatches(content, searchContent) {
         .filter((l) => l.length > 0));
     // Validate: all segments must have at least one non-empty line
     if (segmentLineSets.some((lines) => lines.length === 0)) {
-        return { type: 'none' };
+        return {
+            type: 'none',
+            diagnostic: 'Gap pattern has an empty segment — every part separated by <...> must contain at least one non-blank line.',
+        };
     }
     const lineInfos = parseFileLines(content);
     const allMatches = [];
+    let headEverMatched = false;
+    let maxSegmentsMatched = 0; // best run: count of leading segments matched consecutively
     // Try every possible starting position for the first segment
     let searchFrom = 0;
     while (searchFrom <= lineInfos.length - segmentLineSets[0].length) {
@@ -218,8 +270,10 @@ function findGapMatches(content, searchContent) {
         const firstMatch = findSegmentInLines(lineInfos, segmentLineSets[0], searchFrom);
         if (!firstMatch)
             break;
+        headEverMatched = true;
         // Try to match remaining segments sequentially after the first
         let valid = true;
+        let segmentsMatched = 1;
         let lastEndLineIdx = firstMatch.endLineIdx;
         for (let s = 1; s < segmentLineSets.length; s++) {
             const nextMatch = findSegmentInLines(lineInfos, segmentLineSets[s], lastEndLineIdx);
@@ -227,8 +281,10 @@ function findGapMatches(content, searchContent) {
                 valid = false;
                 break;
             }
+            segmentsMatched++;
             lastEndLineIdx = nextMatch.endLineIdx;
         }
+        maxSegmentsMatched = Math.max(maxSegmentsMatched, segmentsMatched);
         if (valid) {
             allMatches.push({
                 startIndex: lineInfos[firstMatch.startLineIdx].start,
@@ -241,7 +297,17 @@ function findGapMatches(content, searchContent) {
     if (allMatches.length > 0) {
         return { type: 'gap', count: allMatches.length, matches: allMatches };
     }
-    return { type: 'none' };
+    if (!headEverMatched) {
+        return {
+            type: 'none',
+            diagnostic: `Gap pattern did not match: the head anchor (starting ${JSON.stringify(segmentLineSets[0][0])}) was not found in the file. Recheck the first anchor's exact text.`,
+        };
+    }
+    const failedSegmentFirstLine = segmentLineSets[maxSegmentsMatched]?.[0] ?? '';
+    return {
+        type: 'none',
+        diagnostic: `Gap pattern did not match: the head anchor matched, but the next anchor (starting ${JSON.stringify(failedSegmentFirstLine)}) was not found after it. Recheck that anchor's text and that anchors appear in order.`,
+    };
 }
 /**
  * Find matches in content using exact matching first, then relaxed matching.
@@ -408,9 +474,10 @@ export const formatSearchReplaceCommandMessage = (item, index, _toolCallArgument
     for (const [replaceIndex, replaceResult] of replaceOutputItems.entries()) {
         const normalizedArgs = item?.rawItem?.arguments ?? item?.arguments;
         const args = normalizeToolArguments(normalizedArgs) ?? {};
-        const filePath = args?.path ?? replaceResult?.path ?? 'unknown';
-        const searchContent = args?.search_content ?? '';
-        const replaceContent = args?.replace_content ?? '';
+        const operationArgs = Array.isArray(args?.replacements) ? args.replacements[replaceIndex] : args;
+        const filePath = operationArgs?.path ?? replaceResult?.path ?? 'unknown';
+        const searchContent = operationArgs?.search_content ?? '';
+        const replaceContent = operationArgs?.replace_content ?? '';
         const command = `search_replace "${searchContent}" → "${replaceContent}" "${filePath}"`;
         const isHealed = replaceResult?.healed === true;
         let output = replaceResult?.message ?? replaceResult?.error ?? 'No output';
@@ -427,7 +494,7 @@ export const formatSearchReplaceCommandMessage = (item, index, _toolCallArgument
                 path: filePath,
                 search_content: searchContent,
                 replace_content: replaceContent,
-                replace_all: args?.replace_all ?? false,
+                replace_all: operationArgs?.replace_all ?? false,
             },
         }));
     }
@@ -440,15 +507,29 @@ export function createSearchReplaceToolDefinition(deps) {
         name: 'search_replace',
         description: 'Replace text in a file using exact or relaxed matching.\n' +
             'Set replace_all to true to replace all occurrences instead of requiring a unique match.\n' +
-            'Use <...> on its own line in search_content to skip unchanged middle content (gap matching) to save tokens.\n' +
+            'Gap matching: put <...> on its own line in search_content to match an unchanged region between a head anchor and a tail anchor. The entire span (both anchors plus everything between them) is what gets replaced, so a mis-placed anchor silently deletes a large region. Choose anchors that are distinctive and unambiguous — prefer a few lines of real, unique code; never anchor on a single generic line like "}", "return", or a blank line. Use this to edit or DELETE a large block without reproducing it. To delete the block including the anchors, omit them from replace_content; to delete only the middle, repeat the anchors in replace_content.\n' +
             'Use this tool for precise edits where you know the content to be replaced.',
         parameters: searchReplaceParametersSchema,
         approvalPresentation: getApprovalPresentationCapability('search_replace'),
         needsApproval: async (params) => {
             try {
                 const editMode = settingsService.get('app.editMode');
-                const { path: filePath, search_content, replace_all = false } = params;
+                const operations = getSearchReplaceOperations(params);
                 const cwd = executionContext?.getCwd() || process.cwd();
+                if (operations.length > 1) {
+                    const allInsideCwd = operations.every((operation) => {
+                        try {
+                            const targetPath = resolveWorkspacePath(operation.path, cwd);
+                            return targetPath.startsWith(cwd + path.sep);
+                        }
+                        catch {
+                            return false;
+                        }
+                    });
+                    return !(editMode && allInsideCwd);
+                }
+                const operation = operations[0];
+                const { path: filePath, search_content, replace_content, replace_all = false } = operation;
                 const targetPath = resolveWorkspacePath(filePath, cwd);
                 const workspaceRoot = cwd;
                 const insideCwd = targetPath.startsWith(workspaceRoot + path.sep);
@@ -486,6 +567,13 @@ export function createSearchReplaceToolDefinition(deps) {
                     });
                     return true;
                 }
+                if (search_content === replace_content) {
+                    loggingService.warn('search_replace validation: search_content and replace_content are identical', {
+                        path: filePath,
+                    });
+                    // Auto-approve - execute will handle the error gracefully
+                    return false;
+                }
                 // Check for summarization markers
                 const markerError = detectSummarizationMarkers(search_content);
                 if (markerError) {
@@ -502,7 +590,7 @@ export function createSearchReplaceToolDefinition(deps) {
                 // Find matches using shared logic with normalized content
                 const matchInfo = findMatchesInContent(content, normalizedSearchContent);
                 // Cache the result for execute phase
-                editCache.set(params, matchInfo, content, eol);
+                editCache.set(operation, matchInfo, content, eol);
                 if (matchInfo.type === 'exact') {
                     if (!replace_all && matchInfo.count > 1) {
                         loggingService.warn('search_replace validation: multiple exact matches, replace_all=false', {
@@ -586,77 +674,46 @@ export function createSearchReplaceToolDefinition(deps) {
         },
         execute: async (params) => {
             const enableFileLogging = settingsService.get('tools.logFileOperations');
-            try {
-                const { path: filePath, search_content, replace_content, replace_all = false } = params;
-                const cwd = executionContext?.getCwd() || process.cwd();
-                const targetPath = resolveWorkspacePath(filePath, cwd);
-                const sshService = executionContext?.getSSHService();
-                const isRemote = executionContext?.isRemote() && !!sshService;
-                const readFileFn = async (p) => {
-                    if (isRemote && sshService)
-                        return sshService.readFile(p);
-                    return readFile(p, 'utf8');
-                };
-                const writeFileFn = async (p, c) => {
-                    if (isRemote && sshService)
-                        return sshService.writeFile(p, c);
-                    return writeFile(p, c, 'utf8');
-                };
-                if (enableFileLogging) {
-                    loggingService.debug(`File operation started: search_replace`, {
-                        path: filePath,
-                        targetPath,
-                        replace_all,
-                    });
-                }
-                let content;
-                try {
-                    content = await readFileFn(targetPath);
-                }
-                catch (error) {
-                    if (search_content === '' && error?.code === 'ENOENT') {
-                        await writeFileFn(targetPath, replace_content);
-                        if (enableFileLogging) {
-                            loggingService.debug('File created (search_content empty)', {
-                                path: filePath,
-                            });
-                        }
-                        return JSON.stringify({
-                            output: [
-                                {
-                                    success: true,
-                                    operation: 'search_replace',
-                                    path: filePath,
-                                    message: `Created ${filePath} (new file)`,
-                                },
-                            ],
-                        });
-                    }
-                    throw error;
-                }
+            const cwd = executionContext?.getCwd() || process.cwd();
+            const sshService = executionContext?.getSSHService();
+            const isRemote = executionContext?.isRemote() && !!sshService;
+            const readFileFn = async (p) => {
+                if (isRemote && sshService)
+                    return sshService.readFile(p);
+                return readFile(p, 'utf8');
+            };
+            const writeFileFn = async (p, c) => {
+                if (isRemote && sshService)
+                    return sshService.writeFile(p, c);
+                return writeFile(p, c, 'utf8');
+            };
+            const applyToContent = async (operation, content) => {
+                const { path: filePath, search_content, replace_content, replace_all = false } = operation;
                 if (search_content === '') {
-                    return JSON.stringify({
-                        output: [
-                            {
-                                success: false,
-                                error: 'search_content must not be empty when editing an existing file. Provide search text or create a new file with an empty search.',
-                            },
-                        ],
-                    });
+                    return {
+                        output: {
+                            success: false,
+                            error: 'search_content must not be empty when editing an existing file. Provide search text or create a new file with an empty search.',
+                        },
+                    };
+                }
+                if (search_content === replace_content) {
+                    return {
+                        output: {
+                            success: false,
+                            error: 'search_content and replace_content are identical.',
+                        },
+                    };
                 }
-                // Check for summarization markers
                 const markerError = detectSummarizationMarkers(search_content);
                 if (markerError) {
-                    return JSON.stringify({
-                        output: [
-                            {
-                                success: false,
-                                error: markerError,
-                            },
-                        ],
-                    });
+                    return {
+                        output: {
+                            success: false,
+                            error: markerError,
+                        },
+                    };
                 }
-                // Check cache first
                 let matchInfo;
                 let eol;
                 let normalizedSearchContent;
@@ -665,30 +722,38 @@ export function createSearchReplaceToolDefinition(deps) {
                 let healingSucceeded = false;
                 let healedSearchLength = 0;
                 let matchTypeAfterHealing = 'none';
-                const cachedEdit = editCache.get(params, content);
+                let healingFailureReason;
+                const cachedEdit = editCache.get(operation, content);
                 if (cachedEdit) {
-                    // Use cached results
                     matchInfo = cachedEdit.matchInfo;
                     eol = cachedEdit.eol;
                     normalizedSearchContent = normalizeToEOL(removeLeadingFilepathComment(search_content, filePath), eol);
                 }
                 else {
-                    // Detect EOL and normalize content
                     eol = detectEOL(content);
                     normalizedSearchContent = normalizeToEOL(removeLeadingFilepathComment(search_content, filePath), eol);
-                    // Find matches using shared logic
                     matchInfo = findMatchesInContent(content, normalizedSearchContent);
                 }
                 if (matchInfo.type === 'none') {
+                    if (containsGapMarker(search_content)) {
+                        return {
+                            output: {
+                                success: false,
+                                error: (matchInfo.diagnostic ?? 'Gap pattern did not match. Recheck the head and tail anchor lines.') +
+                                    ' Gap (<...>) edits are not auto-healed — fix the anchors and retry.',
+                            },
+                        };
+                    }
                     const enableEditHealing = settingsService.get('tools.enableEditHealing') ?? true;
                     if (enableEditHealing) {
                         healingAttempted = true;
                         const healingModel = settingsService.get('tools.editHealingModel') ?? 'gpt-4o-mini';
-                        const healingResult = await editHealing(params, content, healingModel, process.env.OPENAI_API_KEY ?? '', {
+                        const healingResult = await editHealing(operation, content, healingModel, process.env.OPENAI_API_KEY ?? '', {
                             settingsService,
                             loggingService,
                         });
                         healedSearchLength = healingResult.params.search_content.length;
+                        healingFailureReason = healingResult.failureReason;
                         if (healingResult.wasModified) {
                             normalizedSearchContent = normalizeToEOL(removeLeadingFilepathComment(healingResult.params.search_content, filePath), eol);
                             matchInfo = findMatchesInContent(content, normalizedSearchContent);
@@ -706,17 +771,18 @@ export function createSearchReplaceToolDefinition(deps) {
                                 original_search_length: search_content.length,
                                 healed_search_length: healedSearchLength,
                                 match_type_after_healing: matchTypeAfterHealing,
+                                failure_reason: healingFailureReason,
                             });
                         }
                         if (!usedHealing) {
-                            return JSON.stringify({
-                                output: [
-                                    {
-                                        success: false,
-                                        error: 'Search content not found. Auto-healing attempted but no match found. Try splitting changes into smaller patterns.',
-                                    },
-                                ],
-                            });
+                            const reasonSuffix = healingFailureReason ? ` Reason: ${healingFailureReason}.` : '';
+                            return {
+                                output: {
+                                    success: false,
+                                    error: `Search content not found. Auto-healing attempted but no match found.${reasonSuffix} Try splitting changes into smaller patterns.`,
+                                    healing_failure_reason: healingFailureReason,
+                                },
+                            };
                         }
                     }
                 }
@@ -726,16 +792,13 @@ export function createSearchReplaceToolDefinition(deps) {
                     replaceAll: replace_all,
                 });
                 if (!replacementResult.success) {
-                    return JSON.stringify({
-                        output: [
-                            {
-                                success: false,
-                                error: replacementResult.error,
-                            },
-                        ],
-                    });
+                    return {
+                        output: {
+                            success: false,
+                            error: replacementResult.error,
+                        },
+                    };
                 }
-                await writeFileFn(targetPath, replacementResult.newContent);
                 if (enableFileLogging) {
                     loggingService.debug(`File updated (${replacementResult.matchType} match)`, {
                         path: filePath,
@@ -745,25 +808,100 @@ export function createSearchReplaceToolDefinition(deps) {
                     });
                 }
                 const successMessage = usedHealing
-                    ? `Updated ${filePath} (healed match - original search had minor differences)`
+                    ? `Updated ${filePath} (Search param has minor difference with actual file, auto healing was used. Reread the file to make sure the edit is correct)`
                     : `Updated ${filePath} (${replacementResult.replacedCount} ${replacementResult.matchType} match${replacementResult.replacedCount > 1 ? 'es' : ''})`;
+                return {
+                    newContent: replacementResult.newContent,
+                    output: {
+                        success: true,
+                        operation: 'search_replace',
+                        path: filePath,
+                        message: successMessage,
+                        healed: usedHealing,
+                    },
+                };
+            };
+            try {
+                const operations = getSearchReplaceOperations(params);
+                const indexedOperations = operations.map((operation, index) => ({
+                    operation,
+                    index,
+                    targetPath: resolveWorkspacePath(operation.path, cwd),
+                }));
+                const groups = new Map();
+                for (const indexedOperation of indexedOperations) {
+                    groups.set(indexedOperation.targetPath, [
+                        ...(groups.get(indexedOperation.targetPath) ?? []),
+                        indexedOperation,
+                    ]);
+                }
+                const output = new Array(operations.length);
+                for (const [targetPath, group] of groups) {
+                    await withFileLock(targetPath, async () => {
+                        let content = '';
+                        let fileExists = true;
+                        try {
+                            content = await readFileFn(targetPath);
+                        }
+                        catch (error) {
+                            if (error?.code === 'ENOENT') {
+                                fileExists = false;
+                            }
+                            else {
+                                throw error;
+                            }
+                        }
+                        if (enableFileLogging) {
+                            loggingService.debug(`File operation started: search_replace`, {
+                                path: group[0].operation.path,
+                                targetPath,
+                                operationCount: group.length,
+                            });
+                        }
+                        let nextContent = content;
+                        let changed = false;
+                        for (const { operation, index } of group) {
+                            if (!fileExists) {
+                                if (operation.search_content === '') {
+                                    nextContent = operation.replace_content;
+                                    fileExists = true;
+                                    changed = true;
+                                    output[index] = {
+                                        success: true,
+                                        operation: 'search_replace',
+                                        path: operation.path,
+                                        message: `Created ${operation.path} (new file)`,
+                                    };
+                                    continue;
+                                }
+                                output[index] = {
+                                    success: false,
+                                    error: `File not found: ${operation.path}`,
+                                };
+                                continue;
+                            }
+                            const result = await applyToContent(operation, nextContent);
+                            output[index] = result.output;
+                            if (!result.output.success) {
+                                continue;
+                            }
+                            nextContent = result.newContent;
+                            changed = true;
+                        }
+                        if (changed) {
+                            await writeFileFn(targetPath, nextContent);
+                        }
+                    });
+                }
                 return JSON.stringify({
-                    output: [
-                        {
-                            success: true,
-                            operation: 'search_replace',
-                            path: filePath,
-                            message: successMessage,
-                            healed: usedHealing,
-                        },
-                    ],
+                    output: output.filter(Boolean),
                 });
             }
             catch (error) {
                 if (enableFileLogging) {
                     loggingService.error('File operation failed', {
                         type: 'search_replace',
-                        path: params.path,
+                        path: 'replacements' in params ? 'multiple' : params.path,
                         error: error instanceof Error ? error.message : String(error),
                     });
                 }