@vybestack/llxprt-code-tools 0.10.0-nightly.260613.1adad3b34

package/dist/src/tools/edit.js

@@ -0,0 +1,816 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/* @plan PLAN-20250212-LSP.P31 */
+/* @requirement REQ-DIAG-010, REQ-GRACE-050, REQ-GRACE-055 */
+import fs from 'node:fs/promises';
+import * as path from 'path';
+import * as Diff from 'diff';
+import process from 'node:process';
+import { BaseDeclarativeTool, BaseToolInvocation, Kind, ToolConfirmationOutcome, } from './tools.js';
+import { ToolErrorType } from '../types/tool-error.js';
+import { makeRelative, shortenPath } from '../utils/paths.js';
+import { isNodeError } from '../utils/errors.js';
+import { DEFAULT_CREATE_PATCH_OPTIONS, getDiffStat, } from '../utils/diffOptions.js';
+import { ReadFileTool } from './read-file.js';
+import { fuzzyReplace } from '../utils/fuzzy-replacer.js';
+import { EDIT_TOOL_NAME } from '../types/tool-names.js';
+import { collectLspDiagnosticsBlock } from '../utils/lsp-diagnostics-helper.js';
+import { debugLogger } from '../utils/debugLogger.js';
+import { ensureParentDirectoriesExist } from '../utils/ensure-dirs.js';
+import { validatePathWithinWorkspace } from '../utils/pathValidation.js';
+import { getEmojiFilter, validateEditState, applyReplacement, countLineGuardedOccurrences, applyLineGuardedReplacement, } from './edit-utils.js';
+function createDefaultToolHost() {
+    return {
+        getTargetDir: () => process.cwd(),
+        getWorkspaceRoots: () => [path.parse(process.cwd()).root],
+        getApprovalMode: () => 'auto',
+        setApprovalMode: () => { },
+        isInteractive: () => false,
+        hasFeatureFlag: () => false,
+        getFileService: () => ({
+            shouldGitIgnoreFile: () => false,
+            shouldLlxprtIgnoreFile: () => false,
+            filterFiles: (paths) => paths,
+        }),
+        getFileFilteringOptions: () => ({
+            respectGitIgnore: true,
+            respectLlxprtIgnore: true,
+        }),
+        getFileExclusions: () => [],
+        getReadManyFilesExclusions: () => [],
+        getFileFilteringRespectLlxprtIgnore: () => true,
+        getLlxprtIgnoreFilePath: () => null,
+        recordFileRead: () => { },
+        getLlxprtIgnorePatterns: () => [],
+        getEphemeralSettings: () => ({}),
+        getDebugMode: () => false,
+    };
+}
+function getTargetDirCompat(host) {
+    return host.getTargetDir?.() ?? process.cwd();
+}
+function getWorkspaceRootsCompat(host) {
+    const maybeHost = host;
+    return (maybeHost.getWorkspaceContext?.().getDirectories?.() ??
+        maybeHost.getWorkspaceRoots?.() ?? [
+        maybeHost.getTargetDir?.() ?? process.cwd(),
+    ]);
+}
+function toIdeConnectionStatus(status) {
+    if (typeof status === 'string') {
+        return status === 'connected' || status === 'connecting'
+            ? status
+            : 'disconnected';
+    }
+    if (typeof status === 'object' && status !== null && 'status' in status) {
+        return toIdeConnectionStatus(status.status);
+    }
+    return 'disconnected';
+}
+function hasMessageBusShape(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        ('requestConfirmation' in value ||
+            'publishPolicyUpdate' in value ||
+            'publish' in value ||
+            'subscribe' in value));
+}
+function hasIdeServiceShape(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        ('applyDiff' in value ||
+            'openDiff' in value ||
+            'getConnectionStatus' in value));
+}
+function hasLspServiceShape(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        ('waitForDiagnostics' in value ||
+            'getDiagnostics' in value ||
+            'getLspConfig' in value));
+}
+function getLegacyIdeService(host) {
+    const maybeHost = host;
+    if (typeof maybeHost.getIdeMode !== 'function' ||
+        typeof maybeHost.getIdeClient !== 'function') {
+        return undefined;
+    }
+    const getLegacyIdeClient = () => {
+        if (maybeHost.getIdeMode?.() !== true) {
+            return undefined;
+        }
+        const ideClient = maybeHost.getIdeClient?.();
+        if (typeof ideClient !== 'object' ||
+            ideClient === null ||
+            !('openDiff' in ideClient)) {
+            return undefined;
+        }
+        return ideClient;
+    };
+    return {
+        applyDiff: async ({ filePath, diff }) => {
+            const legacyIdeClient = getLegacyIdeClient();
+            if (legacyIdeClient?.openDiff === undefined) {
+                return { status: 'rejected', content: undefined };
+            }
+            const result = await legacyIdeClient.openDiff(filePath, diff);
+            return result.status === 'accepted'
+                ? { status: 'accepted', content: result.content }
+                : { status: 'rejected', content: undefined };
+        },
+        getConnectionStatus: () => toIdeConnectionStatus(getLegacyIdeClient()?.getConnectionStatus?.()),
+        openDiff: async ({ filePath, newContent }) => {
+            await getLegacyIdeClient()?.openDiff?.(filePath, newContent);
+        },
+    };
+}
+function getLegacyLspService(host) {
+    const maybeHost = host;
+    const lspClient = maybeHost.getLspServiceClient?.();
+    if (typeof lspClient !== 'object' || lspClient === null) {
+        return undefined;
+    }
+    return {
+        getDiagnostics: () => [],
+        waitForDiagnostics: async (filePath, _timeout) => {
+            const isAlive = lspClient.isAlive?.();
+            if (isAlive !== true) {
+                return [];
+            }
+            const checkFile = lspClient.checkFile;
+            if (typeof checkFile !== 'function') {
+                return [];
+            }
+            const diagnostics = await checkFile.call(lspClient, filePath);
+            return Array.isArray(diagnostics) ? diagnostics : [];
+        },
+        getLspConfig: () => maybeHost.getLspConfig?.(),
+    };
+}
+export { applyReplacement, countLineGuardedOccurrences, applyLineGuardedReplacement, } from './edit-utils.js';
+class EditToolInvocation extends BaseToolInvocation {
+    host;
+    ideService;
+    lspService;
+    constructor(host, ideService, lspService, params, messageBus, toolName, displayName) {
+        super(params, messageBus, toolName, displayName);
+        this.host = host;
+        this.ideService = ideService;
+        this.lspService = lspService;
+    }
+    getToolName() {
+        return EditTool.Name;
+    }
+    getFilePath() {
+        // Use absolute_path if provided, otherwise fall back to file_path
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- intentional falsy coalescing: empty string paths are invalid, fall back to file_path
+        return this.params.absolute_path || this.params.file_path || '';
+    }
+    toolLocations() {
+        return [{ path: this.getFilePath() }];
+    }
+    /**
+     * Counts occurrences of oldString in content, trying fuzzy then strict.
+     */
+    countOccurrences(currentContent, finalOldString, finalNewString, expectedReplacements, replaceLine, filePath) {
+        if (finalOldString === '') {
+            return { occurrences: 0, error: undefined };
+        }
+        if (replaceLine !== undefined && replaceLine > 0) {
+            const lines = currentContent.split('\n');
+            if (replaceLine > lines.length) {
+                return {
+                    occurrences: 0,
+                    error: {
+                        display: `Failed to edit: replaceBeginLineNumber is out of range.`,
+                        raw: `Failed to edit: replaceBeginLineNumber=${replaceLine} is out of range for ${filePath} (total lines: ${lines.length}). No edits made.`,
+                        type: ToolErrorType.INVALID_TOOL_PARAMS,
+                    },
+                };
+            }
+            const count = countLineGuardedOccurrences(currentContent, finalOldString, replaceLine);
+            return { occurrences: count, error: undefined };
+        }
+        const fuzzyResult = fuzzyReplace(currentContent, finalOldString, finalNewString, expectedReplacements > 1);
+        if (fuzzyResult) {
+            return { occurrences: fuzzyResult.occurrences, error: undefined };
+        }
+        let count = 0;
+        let pos = currentContent.indexOf(finalOldString);
+        while (pos !== -1) {
+            count++;
+            pos = currentContent.indexOf(finalOldString, pos + finalOldString.length);
+        }
+        return { occurrences: count, error: undefined };
+    }
+    /**
+     * Validates the edit parameters after reading file content and builds the
+     * appropriate error object if any validation fails.
+     */
+    validateEditState(filteredParams, currentContent, fileExists, filePath, occurrences, expectedReplacements, finalOldString, finalNewString) {
+        return validateEditState(filteredParams, currentContent, fileExists, filePath, occurrences, expectedReplacements, finalOldString, finalNewString);
+    }
+    /**
+     * Applies the replacement to produce newContent, handling replaceLine.
+     */
+    computeNewContent(currentContent, fileExists, isNewFile, filteredParams, finalOldString, finalNewString, expectedReplacements, filePath) {
+        const replaceLine = filteredParams.replaceBeginLineNumber;
+        if (fileExists &&
+            replaceLine !== undefined &&
+            replaceLine > 0 &&
+            currentContent !== null) {
+            const lines = currentContent.split('\n');
+            if (replaceLine > lines.length) {
+                return {
+                    newContent: currentContent,
+                    error: {
+                        display: `Failed to edit: replaceBeginLineNumber is out of range.`,
+                        raw: `Failed to edit: replaceBeginLineNumber=${replaceLine} is out of range for ${filePath} (total lines: ${lines.length}). No edits made.`,
+                        type: ToolErrorType.INVALID_TOOL_PARAMS,
+                    },
+                };
+            }
+            const result = applyLineGuardedReplacement(currentContent, finalOldString, finalNewString, expectedReplacements, replaceLine);
+            return {
+                newContent: result,
+                error: undefined,
+            };
+        }
+        const newContent = applyReplacement(currentContent, finalOldString, finalNewString, isNewFile, expectedReplacements);
+        return { newContent, error: undefined };
+    }
+    async readTextFile(filePath) {
+        const fileSystemService = this.host.getFileSystemService?.();
+        if (fileSystemService !== undefined) {
+            return fileSystemService.readTextFile(filePath);
+        }
+        return fs.readFile(filePath, 'utf8');
+    }
+    async writeTextFile(filePath, content) {
+        const fileSystemService = this.host.getFileSystemService?.();
+        if (fileSystemService !== undefined) {
+            await fileSystemService.writeTextFile(filePath, content);
+            return;
+        }
+        await fs.writeFile(filePath, content, 'utf8');
+    }
+    /**
+     * Reads the current file content, handling ENOENT for new files.
+     */
+    async readFileState(filePath) {
+        try {
+            let currentContent = await this.readTextFile(filePath);
+            currentContent = currentContent.replace(/\r\n/g, '\n');
+            return { currentContent, fileExists: true };
+        }
+        catch (err) {
+            if (!isNodeError(err) || err.code !== 'ENOENT') {
+                throw err;
+            }
+            return { currentContent: null, fileExists: false };
+        }
+    }
+    /**
+     * Reads file state and validates the edit, returning resolved values.
+     */
+    async resolveFileEditState(filteredParams, filePath, expectedReplacements) {
+        const { currentContent, fileExists } = await this.readFileState(filePath);
+        let isNewFile = false;
+        const finalOldString = filteredParams.old_string;
+        const finalNewString = filteredParams.new_string;
+        let occurrences = 0;
+        let error = undefined;
+        if (filteredParams.old_string === '' && !fileExists) {
+            isNewFile = true;
+        }
+        else if (!fileExists) {
+            error = {
+                display: `File not found. Cannot apply edit. Use an empty old_string to create a new file.`,
+                raw: `File not found: ${filePath}`,
+                type: ToolErrorType.FILE_NOT_FOUND,
+            };
+        }
+        else if (currentContent !== null) {
+            const countResult = this.countOccurrences(currentContent, finalOldString, finalNewString, expectedReplacements, filteredParams.replaceBeginLineNumber, filePath);
+            occurrences = countResult.occurrences;
+            error = countResult.error;
+            error ??= this.validateEditState(filteredParams, currentContent, fileExists, filePath, occurrences, expectedReplacements, finalOldString, finalNewString);
+        }
+        else {
+            error = {
+                display: `Failed to read content of file.`,
+                raw: `Failed to read content of existing file: ${filePath}`,
+                type: ToolErrorType.READ_CONTENT_FAILURE,
+            };
+        }
+        return {
+            currentContent,
+            fileExists,
+            isNewFile,
+            finalOldString,
+            finalNewString,
+            occurrences,
+            error,
+        };
+    }
+    /**
+     * Calculates the potential outcome of an edit operation.
+     * @param params Parameters for the edit operation
+     * @returns An object describing the potential edit outcome
+     * @throws File system errors if reading the file fails unexpectedly (e.g., permissions)
+     */
+    async calculateEdit(params, _abortSignal) {
+        // Apply emoji filtering to edit content
+        // NOTE: old_string is NOT filtered because it needs to match existing content exactly
+        // Only new_string is filtered to remove emojis from the replacement text
+        const filter = getEmojiFilter(this.host);
+        const newStringResult = filter.filterFileContent(params.new_string, 'edit');
+        // Handle blocking in error mode (only check new_string, not old_string)
+        if (newStringResult.blocked) {
+            return {
+                currentContent: null,
+                newContent: '',
+                occurrences: 0,
+                error: {
+                    display: 'Cannot edit files with emojis in content',
+                    raw: 'Emoji filtering blocked the edit operation',
+                    type: ToolErrorType.INVALID_TOOL_PARAMS,
+                },
+                isNewFile: false,
+                filterResult: newStringResult,
+            };
+        }
+        // Use filtered content for the edit (only filter new_string)
+        const filteredParams = {
+            ...params,
+            new_string: newStringResult.filtered,
+        };
+        const expectedReplacements = filteredParams.expected_replacements ?? 1;
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- intentional falsy coalescing: empty string paths are invalid, fall back to file_path
+        const filePath = params.absolute_path || params.file_path || '';
+        const { currentContent, fileExists, isNewFile, finalOldString, finalNewString, occurrences, error, } = await this.resolveFileEditState(filteredParams, filePath, expectedReplacements);
+        let newContent;
+        let resolvedError = error;
+        if (!resolvedError) {
+            const contentResult = this.computeNewContent(currentContent, fileExists, isNewFile, filteredParams, finalOldString, finalNewString, expectedReplacements, filePath);
+            newContent = contentResult.newContent;
+            resolvedError = contentResult.error;
+        }
+        else {
+            newContent = currentContent ?? '';
+        }
+        if (!resolvedError && fileExists && currentContent === newContent) {
+            // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- intentional falsy coalescing: empty string paths are invalid, fall back to file_path
+            const fp = params.absolute_path || params.file_path || '';
+            resolvedError = {
+                display: 'No changes to apply. The new content is identical to the current content.',
+                raw: `No changes to apply. The new content is identical to the current content in file: ${fp}`,
+                type: ToolErrorType.EDIT_NO_CHANGE,
+            };
+        }
+        return {
+            currentContent,
+            newContent,
+            occurrences,
+            error: resolvedError,
+            isNewFile,
+            filterResult: newStringResult,
+        };
+    }
+    /**
+     * Returns confirmation details for this edit operation.
+     * Called by getMessageBusDecision before surfacing operations to the policy engine/message bus.
+     */
+    getConfirmationDetails() {
+        // This is a synchronous method, so we can't calculate the edit here
+        // Instead, we'll need to handle confirmation in shouldConfirmExecute, which
+        // is invoked when the scheduler needs the diff payload for ASK_USER flows.
+        return null;
+    }
+    /**
+     * Handles the confirmation prompt for the Edit tool in the CLI.
+     * It needs to calculate the diff to show the user.
+     */
+    async shouldConfirmExecute(abortSignal) {
+        const approvalMode = this.host.getApprovalMode();
+        if (approvalMode === 'auto' || approvalMode === 'yolo') {
+            return false;
+        }
+        let editData;
+        try {
+            editData = await this.calculateEdit(this.params, abortSignal);
+        }
+        catch (error) {
+            if (abortSignal.aborted) {
+                throw error;
+            }
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            debugLogger.log(`Error preparing edit: ${errorMsg}`);
+            return false;
+        }
+        if (editData.error) {
+            return false;
+        }
+        // NOTE: Emoji filtering was already applied to new_string in calculateEdit()
+        // We should NOT filter the entire file content here
+        const filteredNewContent = editData.newContent;
+        // Also filter the original new_string parameter for use in onConfirm
+        const filter = getEmojiFilter(this.host);
+        const filteredNewStringParam = filter.filterFileContent(this.params.new_string, 'edit');
+        const filteredNewString = typeof filteredNewStringParam.filtered === 'string'
+            ? filteredNewStringParam.filtered
+            : this.params.new_string;
+        const filePath = this.getFilePath();
+        const fileName = path.basename(filePath);
+        const fileDiff = Diff.createPatch(fileName, editData.currentContent ?? '', filteredNewContent, 'Current', 'Proposed', DEFAULT_CREATE_PATCH_OPTIONS);
+        const ideConfirmation = this.ideService !== undefined &&
+            toIdeConnectionStatus(this.ideService.getConnectionStatus()) ===
+                'connected'
+            ? this.ideService.applyDiff({ filePath, diff: filteredNewContent })
+            : undefined;
+        const confirmationDetails = {
+            type: 'edit',
+            title: `Confirm Edit: ${shortenPath(makeRelative(filePath, getTargetDirCompat(this.host)))}`,
+            fileName,
+            filePath,
+            fileDiff,
+            originalContent: editData.currentContent,
+            newContent: filteredNewContent,
+            onConfirm: async (outcome) => {
+                if (outcome === ToolConfirmationOutcome.ProceedAlways) {
+                    // No need to publish a policy update as the default policy for
+                    // AUTO_EDIT already reflects always approving edit.
+                    const legacyAutoEdit = this.host
+                        .constructor?.name !== 'CoreToolHostAdapter';
+                    this.host.setApprovalMode(legacyAutoEdit ? 'autoEdit' : 'auto');
+                }
+                else {
+                    await this.publishPolicyUpdate(outcome);
+                }
+                if (ideConfirmation) {
+                    const result = await ideConfirmation;
+                    if (result.status === 'accepted' && result.content) {
+                        // Task(chrstn): See https://github.com/google-gemini/gemini-cli/pull/5618#discussion_r2255413084
+                        // for info on a possible race condition where the file is modified on disk while being edited.
+                        // FIX: IDE confirmation is for visual review only
+                        // The IDE returns the entire file content, not just the replacement text
+                        // We should use our original calculated replacement, not the IDE's full file content
+                        // Otherwise we'd replace a small string with the entire file, causing duplication
+                        // Use the filtered version of the original new_string parameter
+                        this.params.new_string = filteredNewString;
+                    }
+                }
+                else {
+                    // DON'T modify params - they need to stay as the original strings
+                    // The filtering has already been applied in calculateEdit()
+                }
+            },
+            ideConfirmation,
+        };
+        return confirmationDetails;
+    }
+    getDescription() {
+        const filePath = this.getFilePath();
+        const relativePath = makeRelative(filePath, getTargetDirCompat(this.host));
+        if (this.params.old_string === '') {
+            return `Create ${shortenPath(relativePath)}`;
+        }
+        const oldStringSnippet = this.params.old_string.split('\n')[0].substring(0, 30) +
+            (this.params.old_string.length > 30 ? '...' : '');
+        const newStringSnippet = this.params.new_string.split('\n')[0].substring(0, 30) +
+            (this.params.new_string.length > 30 ? '...' : '');
+        if (this.params.old_string === this.params.new_string) {
+            return `No file changes to ${shortenPath(relativePath)}`;
+        }
+        return `${shortenPath(relativePath)}: ${oldStringSnippet} => ${newStringSnippet}`;
+    }
+    /**
+     * Tracks git stats for the edit if logging is enabled.
+     */
+    async trackGitStats(filePath, currentContent, newContent) {
+        if (this.host.getConversationLoggingEnabled?.() !== true)
+            return null;
+        const gitStatsService = this.host.getGitStatsService?.();
+        if (!gitStatsService)
+            return null;
+        try {
+            return await gitStatsService.trackFileEdit(filePath, 
+            // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- intentional falsy coalescing: undefined currentContent should default to empty
+            currentContent || '', newContent);
+        }
+        catch (error) {
+            debugLogger.warn('Failed to track git stats:', error);
+            return null;
+        }
+    }
+    /**
+     * Builds the LLM success message parts for a successful edit.
+     */
+    buildSuccessMessage(editData, filePath) {
+        const parts = [
+            editData.isNewFile
+                ? `Created new file: ${filePath} with provided content.`
+                : `Successfully modified file: ${filePath} (${editData.occurrences} replacements).`,
+        ];
+        if (this.params.modified_by_user === true) {
+            parts.push(`User modified the \`new_string\` content to be: ${this.params.new_string}.`);
+        }
+        if (editData.filterResult?.systemFeedback) {
+            parts.push(`\n\n<system-reminder>\n${editData.filterResult.systemFeedback}\n</system-reminder>`);
+        }
+        return parts;
+    }
+    /**
+     * Appends LSP diagnostics to the message parts.
+     */
+    async appendDiagnostics(llmParts, filePath) {
+        try {
+            const diagBlock = this.lspService === undefined
+                ? null
+                : await collectLspDiagnosticsBlock(this.lspService, this.host, filePath);
+            if (diagBlock) {
+                llmParts.push(diagBlock);
+            }
+        }
+        catch {
+            // LSP failure must never fail the edit (REQ-GRACE-050, REQ-GRACE-055)
+        }
+    }
+    /**
+     * Builds the ToolResult for a successful write, including diff, diagnostics,
+     * and optional git-stats metadata.
+     */
+    async buildWriteResult(editData, filePath) {
+        const gitStats = await this.trackGitStats(filePath, editData.currentContent, editData.newContent);
+        const fileName = path.basename(filePath);
+        const originallyProposedContent = this.params.ai_proposed_content ?? editData.newContent;
+        const diffStat = getDiffStat(fileName, editData.currentContent ?? '', originallyProposedContent, editData.newContent);
+        const fileDiff = Diff.createPatch(fileName, editData.currentContent ?? '', editData.newContent, 'Current', 'Proposed', DEFAULT_CREATE_PATCH_OPTIONS);
+        const displayResult = {
+            fileDiff,
+            fileName,
+            filePath: this.params.file_path,
+            originalContent: editData.currentContent,
+            newContent: editData.newContent,
+            diffStat,
+            isNewFile: editData.isNewFile,
+        };
+        const llmSuccessMessageParts = this.buildSuccessMessage(editData, filePath);
+        // @plan PLAN-20250212-LSP.P31
+        // @requirement REQ-DIAG-010
+        await this.appendDiagnostics(llmSuccessMessageParts, filePath);
+        const result = {
+            llmContent: llmSuccessMessageParts.join('\n\n'),
+            returnDisplay: displayResult,
+        };
+        if (gitStats != null) {
+            result.metadata = {
+                ...result.metadata,
+                gitStats,
+            };
+        }
+        return result;
+    }
+    /**
+     * Executes the edit operation with the given parameters.
+     * @param params Parameters for the edit operation
+     * @returns Result of the edit operation
+     */
+    async execute(signal) {
+        let editData;
+        try {
+            editData = await this.calculateEdit(this.params, signal);
+        }
+        catch (error) {
+            if (signal.aborted) {
+                throw error;
+            }
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            return {
+                llmContent: `Error preparing edit: ${errorMsg}`,
+                returnDisplay: `Error preparing edit: ${errorMsg}`,
+                error: {
+                    message: errorMsg,
+                    type: ToolErrorType.EDIT_PREPARATION_FAILURE,
+                },
+            };
+        }
+        if (editData.error) {
+            return {
+                llmContent: editData.error.raw,
+                returnDisplay: `Error: ${editData.error.display}`,
+                error: {
+                    message: editData.error.raw,
+                    type: editData.error.type,
+                },
+            };
+        }
+        const filePath = this.getFilePath();
+        try {
+            await ensureParentDirectoriesExist(filePath);
+            await this.writeTextFile(filePath, editData.newContent);
+            return await this.buildWriteResult(editData, filePath);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            return {
+                llmContent: `Error executing edit: ${errorMsg}`,
+                returnDisplay: `Error writing file: ${errorMsg}`,
+                error: {
+                    message: errorMsg,
+                    type: ToolErrorType.FILE_WRITE_FAILURE,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the Edit tool logic
+ */
+export class EditTool extends BaseDeclarativeTool {
+    host;
+    static Name = EDIT_TOOL_NAME;
+    ideService;
+    lspService;
+    constructor(host = createDefaultToolHost(), messageBusOrIdeService, ideServiceOrLspService, lspService) {
+        const secondArgumentIsMessageBus = hasMessageBusShape(messageBusOrIdeService);
+        const explicitIdeService = secondArgumentIsMessageBus
+            ? ideServiceOrLspService
+            : messageBusOrIdeService;
+        const ideService = hasIdeServiceShape(explicitIdeService)
+            ? explicitIdeService
+            : getLegacyIdeService(host);
+        const messageBus = secondArgumentIsMessageBus
+            ? messageBusOrIdeService
+            : undefined;
+        const explicitLspService = secondArgumentIsMessageBus
+            ? lspService
+            : ideServiceOrLspService;
+        const resolvedLspService = hasLspServiceShape(explicitLspService)
+            ? explicitLspService
+            : getLegacyLspService(host);
+        super(EditTool.Name, 'Edit', `Replaces text within a file. By default, replaces a single occurrence, but can replace multiple occurrences when \`expected_replacements\` is specified. This tool requires providing significant context around the change to ensure precise targeting. Always use the ${ReadFileTool.Name} tool to examine the file's current content before attempting a text replacement.
+
+      The user has the ability to modify the \`new_string\` content. If modified, this will be stated in the response.
+
+Expectation for required parameters:
+1. \`file_path\` MUST be an absolute path; otherwise an error will be thrown.
+2. \`old_string\` MUST be the exact literal text to replace (including all whitespace, indentation, newlines, and surrounding code etc.).
+3. \`new_string\` MUST be the exact literal text to replace \`old_string\` with (also including all whitespace, indentation, newlines, and surrounding code etc.). Ensure the resulting code is correct and idiomatic.
+4. NEVER escape \`old_string\` or \`new_string\`, that would break the exact literal text requirement.
+5. If you do not provide \`replaceBeginLineNumber\` and the same text appears multiple times in the file, the tool will return an error instead of applying an ambiguous change.
+**Multiple replacements:** Set \`expected_replacements\` to the number of occurrences you want to replace. The tool will replace ALL occurrences that match \`old_string\` exactly. Ensure the number of replacements matches your expectation.`, Kind.Edit, {
+            properties: {
+                absolute_path: {
+                    description: process.platform === 'win32'
+                        ? "The absolute path to the file to modify (e.g., 'C:\\Users\\project\\file.txt'). Must be an absolute path."
+                        : "The absolute path to the file to modify (e.g., '/home/user/project/file.txt'). Must start with '/'.",
+                    type: 'string',
+                },
+                file_path: {
+                    description: 'Alternative parameter name for absolute_path (for backward compatibility). The absolute path to the file to modify.',
+                    type: 'string',
+                },
+                old_string: {
+                    description: 'The exact literal text to replace, preferably unescaped. For single replacements (default), include at least 3 lines of context BEFORE and AFTER the target text, matching whitespace and indentation precisely. For multiple replacements, specify expected_replacements parameter. If this string is not the exact literal text (i.e. you escaped it) or does not match exactly, the tool will fail.',
+                    type: 'string',
+                },
+                new_string: {
+                    description: 'The exact literal text to replace `old_string` with, preferably unescaped. Provide the EXACT text. Ensure the resulting code is correct and idiomatic.',
+                    type: 'string',
+                },
+                expected_replacements: {
+                    type: 'number',
+                    description: 'Number of replacements expected. Defaults to 1 if not specified. Use when you want to replace multiple occurrences.',
+                    minimum: 1,
+                },
+                replaceBeginLineNumber: {
+                    type: 'number',
+                    description: 'Optional 1-based line number where the replacement should begin. Strongly recommended to always set this to guard against misinterpreting the file structure, especially when similar text appears multiple times.',
+                    minimum: 1,
+                },
+            },
+            required: ['old_string', 'new_string'],
+            type: 'object',
+        }, false, false, messageBus);
+        this.host = host;
+        this.ideService = ideService;
+        this.lspService = resolvedLspService;
+    }
+    /**
+     * Validates the parameters for the Edit tool
+     * @param params Parameters to validate
+     * @returns Error message string or null if valid
+     */
+    validateToolParamValues(params) {
+        // Accept either absolute_path or file_path
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- intentional falsy coalescing: empty string paths are invalid
+        const filePath = params.absolute_path || params.file_path || '';
+        if (filePath.trim() === '') {
+            return "Either 'absolute_path' or 'file_path' parameter must be provided and non-empty.";
+        }
+        if (!path.isAbsolute(filePath)) {
+            return `File path must be absolute: ${filePath}`;
+        }
+        const pathError = validatePathWithinWorkspace(getWorkspaceRootsCompat(this.host), filePath);
+        if (pathError) {
+            return pathError;
+        }
+        // Validate that empty old_string with multiple replacements is not allowed
+        const expectedReplacements = params.expected_replacements ?? 1;
+        if (params.old_string === '' && expectedReplacements > 1) {
+            return `Cannot perform multiple replacements with empty old_string (would cause infinite loop)`;
+        }
+        const replaceLine = params.replaceBeginLineNumber;
+        if (replaceLine !== undefined &&
+            (!Number.isFinite(replaceLine) ||
+                !Number.isInteger(replaceLine) ||
+                replaceLine <= 0)) {
+            return `replaceBeginLineNumber must be a positive integer (1-based)`;
+        }
+        return null;
+    }
+    createInvocation(params, messageBus, toolName, displayName) {
+        // Normalize parameters: if file_path is provided but not absolute_path, copy it over
+        const normalizedParams = { ...params };
+        if (!normalizedParams.absolute_path && normalizedParams.file_path) {
+            normalizedParams.absolute_path = normalizedParams.file_path;
+        }
+        return new EditToolInvocation(this.host, this.ideService, this.lspService, normalizedParams, messageBus, toolName ?? this.name, displayName ?? this.displayName);
+    }
+    async readTextFile(filePath) {
+        const fileSystemService = this.host.getFileSystemService?.();
+        if (fileSystemService !== undefined) {
+            return fileSystemService.readTextFile(filePath);
+        }
+        return fs.readFile(filePath, 'utf8');
+    }
+    async execute(params, signal = new AbortController().signal) {
+        return this.build(params).execute(signal);
+    }
+    getModifyContext(_) {
+        return {
+            getFilePath: (params) => 
+            // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- intentional falsy coalescing: empty string paths are invalid, fall back to file_path
+            params.absolute_path || params.file_path || '',
+            getCurrentContent: async (params) => {
+                // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- intentional falsy coalescing: empty string paths are invalid, fall back to file_path
+                const filePath = params.absolute_path || params.file_path || '';
+                try {
+                    return await this.readTextFile(filePath);
+                }
+                catch (err) {
+                    if (!isNodeError(err) || err.code !== 'ENOENT')
+                        throw err;
+                    return '';
+                }
+            },
+            getProposedContent: async (params) => {
+                // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- intentional falsy coalescing: empty string paths are invalid, fall back to file_path
+                const filePath = params.absolute_path || params.file_path || '';
+                try {
+                    const raw = await this.readTextFile(filePath);
+                    const currentContent = raw.replace(/\r\n/g, '\n');
+                    const replaceLine = params.replaceBeginLineNumber;
+                    if (replaceLine !== undefined &&
+                        replaceLine > 0 &&
+                        params.old_string !== '') {
+                        // When replaceBeginLineNumber is set, only replace occurrences
+                        // whose start falls on the specified line.
+                        const expectedReplacements = params.expected_replacements ?? 1;
+                        const eligibleCount = countLineGuardedOccurrences(currentContent, params.old_string, replaceLine);
+                        // If eligible count doesn't match expected_replacements, execute()
+                        // would reject with a mismatch error. Return unchanged content to
+                        // avoid presenting a partial proposal that would never be written.
+                        if (eligibleCount !== expectedReplacements) {
+                            return currentContent;
+                        }
+                        return applyLineGuardedReplacement(currentContent, params.old_string, params.new_string, expectedReplacements, replaceLine);
+                    }
+                    const isNewFile = params.old_string === '' && currentContent === '';
+                    return applyReplacement(currentContent, params.old_string, params.new_string, isNewFile, params.expected_replacements ?? 1);
+                }
+                catch (err) {
+                    if (!isNodeError(err) || err.code !== 'ENOENT')
+                        throw err;
+                    // File does not exist: if old_string is empty, this is a new-file creation.
+                    if (params.old_string === '') {
+                        return params.new_string;
+                    }
+                    return '';
+                }
+            },
+            createUpdatedParams: (oldContent, modifiedProposedContent, originalParams) => ({
+                ...originalParams,
+                ai_proposed_content: oldContent,
+                old_string: oldContent,
+                new_string: modifiedProposedContent,
+                modified_by_user: true,
+            }),
+        };
+    }
+}
+//# sourceMappingURL=edit.js.map