shortcutxl 0.2.0

package/dist/core/timings.js

@@ -0,0 +1,26 @@
+/**
+ * Central timing instrumentation for startup profiling.
+ * Enable with SHORTCUT_TIMING=1 environment variable.
+ */
+// SHORTCUT PATCH: renamed from PI_TIMING
+const ENABLED = process.env.SHORTCUT_TIMING === '1';
+const timings = [];
+let lastTime = Date.now();
+export function time(label) {
+    if (!ENABLED)
+        return;
+    const now = Date.now();
+    timings.push({ label, ms: now - lastTime });
+    lastTime = now;
+}
+export function printTimings() {
+    if (!ENABLED || timings.length === 0)
+        return;
+    console.error('\n--- Startup Timings ---');
+    for (const t of timings) {
+        console.error(`  ${t.label}: ${t.ms}ms`);
+    }
+    console.error(`  TOTAL: ${timings.reduce((a, b) => a + b.ms, 0)}ms`);
+    console.error('------------------------\n');
+}
+//# sourceMappingURL=timings.js.map

package/dist/core/tools/bash.js

@@ -0,0 +1,258 @@
+import { Type } from '@sinclair/typebox';
+import { spawn } from 'child_process';
+import { randomBytes } from 'node:crypto';
+import { createWriteStream, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { BASH } from '../../tool-names.js';
+import { getShellConfig, getShellEnv, killProcessTree } from '../../utils/shell.js';
+import { ABORT_AGENT_MESSAGE } from '../abort.js';
+import { SettingsManager } from '../settings-manager.js';
+import { DEFAULT_MAX_CHARS, truncateHead, truncateOutput } from './truncate.js';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const TOOL_NAME = BASH;
+const TOOL_LABEL = BASH;
+const TOOL_DESCRIPTION = `\
+Execute a bash command in the current working directory. Returns stdout and stderr. \
+Output is truncated to ${DEFAULT_MAX_CHARS} characters. If truncated, full output is saved to a temp file. \
+Default timeout is 30 seconds. Override with the timeout parameter for long-running commands.
+
+Python 3 and pip are available for data processing, scripting, and package installation.
+- ALWAYS use bash to execute python and other commands instead of through the 
+
+On Windows, this tool runs Git Bash (MSYS2), not a native shell. Two consequences:
+1. Forward-slash flags get auto-converted to paths — use double slashes for literal flags (e.g., reg query //v).
+2. This tool holds stdout/stderr pipes open until all child processes exit. To launch a process without blocking, use Git Bash's built-in \`start\` with the program name (e.g., \`start excel\`).
+
+**Conventions:**
+- When creating files, tell users the file path.
+- Stop retrying after 1-2 unexplained failures.`;
+// ---------------------------------------------------------------------------
+/**
+ * Generate a unique temp file path for bash output
+ */
+function getTempFilePath() {
+    const id = randomBytes(8).toString('hex');
+    return join(tmpdir(), `pi-bash-${id}.log`);
+}
+// SHORTCUT PATCH: added description field for task agent display
+const bashSchema = Type.Object({
+    description: Type.String({
+        description: 'A short description of what the command does for non-technical users.'
+    }),
+    command: Type.String({ description: 'Bash command to execute' }),
+    timeout: Type.Optional(Type.Number({ description: 'Timeout in seconds (default: 30). Increase for long-running commands.' }))
+});
+/**
+ * Default bash operations using local shell
+ */
+const defaultBashOperations = {
+    exec: (command, cwd, { onData, signal, timeout, env }) => {
+        return new Promise((resolve, reject) => {
+            const { shell, args } = getShellConfig(SettingsManager.create().getShellPath());
+            if (!existsSync(cwd)) {
+                reject(new Error(`Working directory does not exist: ${cwd}\nCannot execute bash commands.`));
+                return;
+            }
+            const child = spawn(shell, [...args, command], {
+                cwd,
+                // On Unix, detached creates a process group so killProcessTree can use -pid.
+                // On Windows, detached creates a new console which breaks stdout pipes for
+                // grandchild processes (external executables). Windows uses taskkill /T instead.
+                detached: process.platform !== 'win32',
+                env: env ?? getShellEnv(),
+                stdio: ['ignore', 'pipe', 'pipe']
+            });
+            let timedOut = false;
+            let settled = false;
+            // Set timeout if provided
+            let timeoutHandle;
+            if (timeout !== undefined && timeout > 0) {
+                timeoutHandle = setTimeout(() => {
+                    timedOut = true;
+                    if (child.pid) {
+                        killProcessTree(child.pid);
+                    }
+                    // Force-close pipes — on Windows, grandchild processes (e.g. spawned
+                    // by `start`) can hold pipe handles open even after the shell is killed.
+                    child.stdout?.destroy();
+                    child.stderr?.destroy();
+                }, timeout * 1000);
+            }
+            // Stream stdout and stderr
+            if (child.stdout) {
+                child.stdout.on('data', onData);
+            }
+            if (child.stderr) {
+                child.stderr.on('data', onData);
+            }
+            // Handle shell spawn errors
+            child.on('error', (err) => {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                if (signal)
+                    signal.removeEventListener('abort', onAbort);
+                if (!settled) {
+                    settled = true;
+                    reject(err);
+                }
+            });
+            // Handle abort signal - kill entire process tree and force-close pipes.
+            // On Windows, `start`-spawned processes can hold pipe handles open even
+            // after taskkill kills the shell, preventing the 'close' event from firing.
+            const onAbort = () => {
+                if (child.pid) {
+                    killProcessTree(child.pid);
+                }
+                child.stdout?.destroy();
+                child.stderr?.destroy();
+                // Safety net: if 'close' still doesn't fire (orphaned pipe handles),
+                // force-settle after 2 seconds so the tool call doesn't hang forever.
+                setTimeout(() => {
+                    if (!settled) {
+                        settled = true;
+                        if (timeoutHandle)
+                            clearTimeout(timeoutHandle);
+                        if (signal)
+                            signal.removeEventListener('abort', onAbort);
+                        reject(new Error('aborted'));
+                    }
+                }, 2000);
+            };
+            if (signal) {
+                if (signal.aborted) {
+                    onAbort();
+                }
+                else {
+                    signal.addEventListener('abort', onAbort, { once: true });
+                }
+            }
+            // Handle process exit
+            child.on('close', (code) => {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                if (signal)
+                    signal.removeEventListener('abort', onAbort);
+                if (settled)
+                    return;
+                settled = true;
+                if (signal?.aborted) {
+                    reject(new Error('aborted'));
+                    return;
+                }
+                if (timedOut) {
+                    reject(new Error(`timeout:${timeout}`));
+                    return;
+                }
+                resolve({ exitCode: code });
+            });
+        });
+    }
+};
+export function createBashTool(cwd, options) {
+    const ops = options?.operations ?? defaultBashOperations;
+    const commandPrefix = options?.commandPrefix;
+    return {
+        name: TOOL_NAME,
+        label: TOOL_LABEL,
+        description: TOOL_DESCRIPTION,
+        parameters: bashSchema,
+        execute: async (_toolCallId, { command, timeout: explicitTimeout }, signal, onUpdate) => {
+            const timeout = explicitTimeout ?? 30;
+            const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
+            return new Promise((resolve, reject) => {
+                // We'll stream to a temp file if output gets large
+                let tempFilePath;
+                let tempFileStream;
+                // Accumulate output chunks — only used for head truncation at the end
+                const chunks = [];
+                let totalChars = 0;
+                const handleData = (data) => {
+                    const text = data.toString('utf-8');
+                    totalChars += text.length;
+                    // Start writing to temp file once we exceed the threshold
+                    if (totalChars > DEFAULT_MAX_CHARS && !tempFilePath) {
+                        tempFilePath = getTempFilePath();
+                        tempFileStream = createWriteStream(tempFilePath);
+                        for (const chunk of chunks) {
+                            tempFileStream.write(chunk);
+                        }
+                    }
+                    if (tempFileStream) {
+                        tempFileStream.write(text);
+                    }
+                    chunks.push(text);
+                    // Stream partial output to callback
+                    if (onUpdate) {
+                        const truncation = truncateHead(chunks.join(''));
+                        onUpdate({
+                            content: [{ type: 'text', text: truncation.content || '' }],
+                            details: {
+                                truncation: truncation.truncated ? truncation : undefined,
+                                fullOutputPath: tempFilePath
+                            }
+                        });
+                    }
+                };
+                ops
+                    .exec(resolvedCommand, cwd, {
+                    onData: handleData,
+                    signal,
+                    timeout
+                })
+                    .then(({ exitCode }) => {
+                    if (tempFileStream) {
+                        tempFileStream.end();
+                    }
+                    const fullOutput = chunks.join('');
+                    const truncation = truncateHead(fullOutput);
+                    let outputText = truncateOutput(fullOutput) || '(no output)';
+                    let details;
+                    if (truncation.truncated) {
+                        details = {
+                            truncation,
+                            fullOutputPath: tempFilePath
+                        };
+                        if (tempFilePath) {
+                            outputText += `\nFull output: ${tempFilePath}`;
+                        }
+                    }
+                    if (exitCode !== 0 && exitCode !== null) {
+                        outputText += `\n\nCommand exited with code ${exitCode}`;
+                        reject(new Error(outputText));
+                    }
+                    else {
+                        resolve({ content: [{ type: 'text', text: outputText }], details });
+                    }
+                })
+                    .catch((err) => {
+                    if (tempFileStream) {
+                        tempFileStream.end();
+                    }
+                    let output = truncateOutput(chunks.join(''));
+                    if (err.message === 'aborted') {
+                        if (output)
+                            output += '\n\n';
+                        output += ABORT_AGENT_MESSAGE;
+                        reject(new Error(output));
+                    }
+                    else if (err.message.startsWith('timeout:')) {
+                        const timeoutSecs = err.message.split(':')[1];
+                        if (output)
+                            output += '\n\n';
+                        output += `Command timed out after ${timeoutSecs} seconds`;
+                        reject(new Error(output));
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+            });
+        }
+    };
+}
+/** Default bash tool using process.cwd() - for backwards compatibility */
+export const bashTool = createBashTool(process.cwd());
+//# sourceMappingURL=bash.js.map

package/dist/core/tools/edit-diff.js

@@ -0,0 +1,245 @@
+/**
+ * Shared diff computation utilities for the edit tool.
+ * Used by both edit.ts (for execution) and tool-execution.ts (for preview rendering).
+ */
+import * as Diff from 'diff';
+import { constants } from 'fs';
+import { access, readFile } from 'fs/promises';
+import { resolveToCwd } from './path-utils.js';
+export function detectLineEnding(content) {
+    const crlfIdx = content.indexOf('\r\n');
+    const lfIdx = content.indexOf('\n');
+    if (lfIdx === -1)
+        return '\n';
+    if (crlfIdx === -1)
+        return '\n';
+    return crlfIdx < lfIdx ? '\r\n' : '\n';
+}
+export function normalizeToLF(text) {
+    return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+export function restoreLineEndings(text, ending) {
+    return ending === '\r\n' ? text.replace(/\n/g, '\r\n') : text;
+}
+/**
+ * Normalize text for fuzzy matching. Applies progressive transformations:
+ * - Strip trailing whitespace from each line
+ * - Normalize smart quotes to ASCII equivalents
+ * - Normalize Unicode dashes/hyphens to ASCII hyphen
+ * - Normalize special Unicode spaces to regular space
+ */
+export function normalizeForFuzzyMatch(text) {
+    return (text
+        // Strip trailing whitespace per line
+        .split('\n')
+        .map((line) => line.trimEnd())
+        .join('\n')
+        // Smart single quotes → '
+        .replace(/[\u2018\u2019\u201A\u201B]/g, "'")
+        // Smart double quotes → "
+        .replace(/[\u201C\u201D\u201E\u201F]/g, '"')
+        // Various dashes/hyphens → -
+        // U+2010 hyphen, U+2011 non-breaking hyphen, U+2012 figure dash,
+        // U+2013 en-dash, U+2014 em-dash, U+2015 horizontal bar, U+2212 minus
+        .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, '-')
+        // Special spaces → regular space
+        // U+00A0 NBSP, U+2002-U+200A various spaces, U+202F narrow NBSP,
+        // U+205F medium math space, U+3000 ideographic space
+        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, ' '));
+}
+/**
+ * Find oldText in content, trying exact match first, then fuzzy match.
+ * When fuzzy matching is used, the returned contentForReplacement is the
+ * fuzzy-normalized version of the content (trailing whitespace stripped,
+ * Unicode quotes/dashes normalized to ASCII).
+ */
+export function fuzzyFindText(content, oldText) {
+    // Try exact match first
+    const exactIndex = content.indexOf(oldText);
+    if (exactIndex !== -1) {
+        return {
+            found: true,
+            index: exactIndex,
+            matchLength: oldText.length,
+            usedFuzzyMatch: false,
+            contentForReplacement: content
+        };
+    }
+    // Try fuzzy match - work entirely in normalized space
+    const fuzzyContent = normalizeForFuzzyMatch(content);
+    const fuzzyOldText = normalizeForFuzzyMatch(oldText);
+    const fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);
+    if (fuzzyIndex === -1) {
+        return {
+            found: false,
+            index: -1,
+            matchLength: 0,
+            usedFuzzyMatch: false,
+            contentForReplacement: content
+        };
+    }
+    // When fuzzy matching, we work in the normalized space for replacement.
+    // This means the output will have normalized whitespace/quotes/dashes,
+    // which is acceptable since we're fixing minor formatting differences anyway.
+    return {
+        found: true,
+        index: fuzzyIndex,
+        matchLength: fuzzyOldText.length,
+        usedFuzzyMatch: true,
+        contentForReplacement: fuzzyContent
+    };
+}
+/** Strip UTF-8 BOM if present, return both the BOM (if any) and the text without it */
+export function stripBom(content) {
+    return content.startsWith('\uFEFF')
+        ? { bom: '\uFEFF', text: content.slice(1) }
+        : { bom: '', text: content };
+}
+/**
+ * Generate a unified diff string with line numbers and context.
+ * Returns both the diff string and the first changed line number (in the new file).
+ */
+export function generateDiffString(oldContent, newContent, contextLines = 4) {
+    const parts = Diff.diffLines(oldContent, newContent);
+    const output = [];
+    const oldLines = oldContent.split('\n');
+    const newLines = newContent.split('\n');
+    const maxLineNum = Math.max(oldLines.length, newLines.length);
+    const lineNumWidth = String(maxLineNum).length;
+    let oldLineNum = 1;
+    let newLineNum = 1;
+    let lastWasChange = false;
+    let firstChangedLine;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const raw = part.value.split('\n');
+        if (raw[raw.length - 1] === '') {
+            raw.pop();
+        }
+        if (part.added || part.removed) {
+            // Capture the first changed line (in the new file)
+            if (firstChangedLine === undefined) {
+                firstChangedLine = newLineNum;
+            }
+            // Show the change
+            for (const line of raw) {
+                if (part.added) {
+                    const lineNum = String(newLineNum).padStart(lineNumWidth, ' ');
+                    output.push(`+${lineNum} ${line}`);
+                    newLineNum++;
+                }
+                else {
+                    // removed
+                    const lineNum = String(oldLineNum).padStart(lineNumWidth, ' ');
+                    output.push(`-${lineNum} ${line}`);
+                    oldLineNum++;
+                }
+            }
+            lastWasChange = true;
+        }
+        else {
+            // Context lines - only show a few before/after changes
+            const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
+            if (lastWasChange || nextPartIsChange) {
+                // Show context
+                let linesToShow = raw;
+                let skipStart = 0;
+                let skipEnd = 0;
+                if (!lastWasChange) {
+                    // Show only last N lines as leading context
+                    skipStart = Math.max(0, raw.length - contextLines);
+                    linesToShow = raw.slice(skipStart);
+                }
+                if (!nextPartIsChange && linesToShow.length > contextLines) {
+                    // Show only first N lines as trailing context
+                    skipEnd = linesToShow.length - contextLines;
+                    linesToShow = linesToShow.slice(0, contextLines);
+                }
+                // Add ellipsis if we skipped lines at start
+                if (skipStart > 0) {
+                    output.push(` ${''.padStart(lineNumWidth, ' ')} ...`);
+                    // Update line numbers for the skipped leading context
+                    oldLineNum += skipStart;
+                    newLineNum += skipStart;
+                }
+                for (const line of linesToShow) {
+                    const lineNum = String(oldLineNum).padStart(lineNumWidth, ' ');
+                    output.push(` ${lineNum} ${line}`);
+                    oldLineNum++;
+                    newLineNum++;
+                }
+                // Add ellipsis if we skipped lines at end
+                if (skipEnd > 0) {
+                    output.push(` ${''.padStart(lineNumWidth, ' ')} ...`);
+                    // Update line numbers for the skipped trailing context
+                    oldLineNum += skipEnd;
+                    newLineNum += skipEnd;
+                }
+            }
+            else {
+                // Skip these context lines entirely
+                oldLineNum += raw.length;
+                newLineNum += raw.length;
+            }
+            lastWasChange = false;
+        }
+    }
+    return { diff: output.join('\n'), firstChangedLine };
+}
+/**
+ * Compute the diff for an edit operation without applying it.
+ * Used for preview rendering in the TUI before the tool executes.
+ */
+export async function computeEditDiff(path, oldText, newText, cwd) {
+    const absolutePath = resolveToCwd(path, cwd);
+    try {
+        // Check if file exists and is readable
+        try {
+            await access(absolutePath, constants.R_OK);
+        }
+        catch {
+            return { error: `File not found: ${path}` };
+        }
+        // Read the file
+        const rawContent = await readFile(absolutePath, 'utf-8');
+        // Strip BOM before matching (LLM won't include invisible BOM in oldText)
+        const { text: content } = stripBom(rawContent);
+        const normalizedContent = normalizeToLF(content);
+        const normalizedOldText = normalizeToLF(oldText);
+        const normalizedNewText = normalizeToLF(newText);
+        // Find the old text using fuzzy matching (tries exact match first, then fuzzy)
+        const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
+        if (!matchResult.found) {
+            return {
+                error: `Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`
+            };
+        }
+        // Count occurrences using fuzzy-normalized content for consistency
+        const fuzzyContent = normalizeForFuzzyMatch(normalizedContent);
+        const fuzzyOldText = normalizeForFuzzyMatch(normalizedOldText);
+        const occurrences = fuzzyContent.split(fuzzyOldText).length - 1;
+        if (occurrences > 1) {
+            return {
+                error: `Found ${occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`
+            };
+        }
+        // Compute the new content using the matched position
+        // When fuzzy matching was used, contentForReplacement is the normalized version
+        const baseContent = matchResult.contentForReplacement;
+        const newContent = baseContent.substring(0, matchResult.index) +
+            normalizedNewText +
+            baseContent.substring(matchResult.index + matchResult.matchLength);
+        // Check if it would actually change anything
+        if (baseContent === newContent) {
+            return {
+                error: `No changes would be made to ${path}. The replacement produces identical content.`
+            };
+        }
+        // Generate the diff
+        return generateDiffString(baseContent, newContent);
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+//# sourceMappingURL=edit-diff.js.map

package/dist/core/tools/edit.js

@@ -0,0 +1,148 @@
+import { Type } from '@sinclair/typebox';
+import { constants } from 'fs';
+import { access as fsAccess, readFile as fsReadFile, writeFile as fsWriteFile } from 'fs/promises';
+import { ABORT_AGENT_MESSAGE } from '../abort.js';
+import { EDIT } from '../../tool-names.js';
+import { detectLineEnding, fuzzyFindText, generateDiffString, normalizeForFuzzyMatch, normalizeToLF, restoreLineEndings, stripBom } from './edit-diff.js';
+import { resolveToCwd } from './path-utils.js';
+const editSchema = Type.Object({
+    path: Type.String({ description: 'Path to the file to edit (relative or absolute)' }),
+    oldText: Type.String({ description: 'Exact text to find and replace (must match exactly)' }),
+    newText: Type.String({ description: 'New text to replace the old text with' })
+});
+const defaultEditOperations = {
+    readFile: (path) => fsReadFile(path),
+    writeFile: (path, content) => fsWriteFile(path, content, 'utf-8'),
+    access: (path) => fsAccess(path, constants.R_OK | constants.W_OK)
+};
+export function createEditTool(cwd, options) {
+    const ops = options?.operations ?? defaultEditOperations;
+    return {
+        name: EDIT,
+        label: EDIT,
+        description: 'Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits.',
+        parameters: editSchema,
+        execute: async (_toolCallId, { path, oldText, newText }, signal) => {
+            const absolutePath = resolveToCwd(path, cwd);
+            return new Promise((resolve, reject) => {
+                // Check if already aborted
+                if (signal?.aborted) {
+                    reject(new Error(ABORT_AGENT_MESSAGE));
+                    return;
+                }
+                let aborted = false;
+                // Set up abort handler
+                const onAbort = () => {
+                    aborted = true;
+                    reject(new Error(ABORT_AGENT_MESSAGE));
+                };
+                if (signal) {
+                    signal.addEventListener('abort', onAbort, { once: true });
+                }
+                // Perform the edit operation
+                (async () => {
+                    try {
+                        // Check if file exists
+                        try {
+                            await ops.access(absolutePath);
+                        }
+                        catch {
+                            if (signal) {
+                                signal.removeEventListener('abort', onAbort);
+                            }
+                            reject(new Error(`File not found: ${path}`));
+                            return;
+                        }
+                        // Check if aborted before reading
+                        if (aborted) {
+                            return;
+                        }
+                        // Read the file
+                        const buffer = await ops.readFile(absolutePath);
+                        const rawContent = buffer.toString('utf-8');
+                        // Check if aborted after reading
+                        if (aborted) {
+                            return;
+                        }
+                        // Strip BOM before matching (LLM won't include invisible BOM in oldText)
+                        const { bom, text: content } = stripBom(rawContent);
+                        const originalEnding = detectLineEnding(content);
+                        const normalizedContent = normalizeToLF(content);
+                        const normalizedOldText = normalizeToLF(oldText);
+                        const normalizedNewText = normalizeToLF(newText);
+                        // Find the old text using fuzzy matching (tries exact match first, then fuzzy)
+                        const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
+                        if (!matchResult.found) {
+                            if (signal) {
+                                signal.removeEventListener('abort', onAbort);
+                            }
+                            reject(new Error(`Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`));
+                            return;
+                        }
+                        // Count occurrences using fuzzy-normalized content for consistency
+                        const fuzzyContent = normalizeForFuzzyMatch(normalizedContent);
+                        const fuzzyOldText = normalizeForFuzzyMatch(normalizedOldText);
+                        const occurrences = fuzzyContent.split(fuzzyOldText).length - 1;
+                        if (occurrences > 1) {
+                            if (signal) {
+                                signal.removeEventListener('abort', onAbort);
+                            }
+                            reject(new Error(`Found ${occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`));
+                            return;
+                        }
+                        // Check if aborted before writing
+                        if (aborted) {
+                            return;
+                        }
+                        // Perform replacement using the matched text position
+                        // When fuzzy matching was used, contentForReplacement is the normalized version
+                        const baseContent = matchResult.contentForReplacement;
+                        const newContent = baseContent.substring(0, matchResult.index) +
+                            normalizedNewText +
+                            baseContent.substring(matchResult.index + matchResult.matchLength);
+                        // Verify the replacement actually changed something
+                        if (baseContent === newContent) {
+                            if (signal) {
+                                signal.removeEventListener('abort', onAbort);
+                            }
+                            reject(new Error(`No changes made to ${path}. The replacement produced identical content. This might indicate an issue with special characters or the text not existing as expected.`));
+                            return;
+                        }
+                        const finalContent = bom + restoreLineEndings(newContent, originalEnding);
+                        await ops.writeFile(absolutePath, finalContent);
+                        // Check if aborted after writing
+                        if (aborted) {
+                            return;
+                        }
+                        // Clean up abort handler
+                        if (signal) {
+                            signal.removeEventListener('abort', onAbort);
+                        }
+                        const diffResult = generateDiffString(baseContent, newContent);
+                        resolve({
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Successfully replaced text in ${path}.`
+                                }
+                            ],
+                            details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine }
+                        });
+                    }
+                    catch (error) {
+                        // Clean up abort handler
+                        if (signal) {
+                            signal.removeEventListener('abort', onAbort);
+                        }
+                        if (!aborted) {
+                            reject(error);
+                        }
+                    }
+                })();
+            });
+        }
+    };
+}
+/** Default edit tool using process.cwd() - for backwards compatibility */
+export const editTool = createEditTool(process.cwd());
+//# sourceMappingURL=edit.js.map