centaurus-cli 3.0.1 → 3.1.1

package/dist/tools/file-ops.js

@@ -1,602 +1,631 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import * as fileUtils from '../utils/file.js';
-import * as Diff from 'diff';
-import { ToolValidator } from './validation.js';
-import { checkSyntax, formatSyntaxCheckResult } from '../utils/syntax-checker.js';
-import { logWarning } from '../utils/logger.js';
-/**
- * Helper: back up a file before the AI modifies it (for checkpoint revert).
- * Non-critical — if backup fails, the file operation proceeds anyway.
- */
+import * as path from "path";
+import * as fs from "fs";
+import * as fileUtils from "../utils/file.js";
+import * as Diff from "diff";
+import { ToolValidator } from "./validation.js";
+import { checkSyntax, formatSyntaxCheckResult } from "../utils/syntax-checker.js";
+import { logWarning } from "../utils/logger.js";
 async function backupBeforeChange(context, absoluteFilePath) {
-    if (!context.checkpointManager || !context.currentCheckpointId)
-        return;
-    try {
-        // Determine remote handler if in remote context
-        let remoteHandler;
-        if (context.contextManager) {
-            const currentCtx = context.contextManager.getCurrentContext();
-            if (currentCtx.type !== 'local' && currentCtx.handler) {
-                const h = currentCtx.handler;
-                if (typeof h.readFile === 'function' && typeof h.writeFile === 'function' &&
-                    typeof h.executeCommand === 'function' && typeof h.isConnected === 'function') {
-                    remoteHandler = h;
-                }
-            }
+  if (!context.checkpointManager || !context.currentCheckpointId) return;
+  try {
+    let remoteHandler;
+    if (context.contextManager) {
+      const currentCtx = context.contextManager.getCurrentContext();
+      if (currentCtx.type !== "local" && currentCtx.handler) {
+        const h = currentCtx.handler;
+        if (typeof h.readFile === "function" && typeof h.writeFile === "function" && typeof h.executeCommand === "function" && typeof h.isConnected === "function") {
+          remoteHandler = h;
         }
-        await context.checkpointManager.backupFileBeforeChange(context.currentCheckpointId, absoluteFilePath, context.cwd, remoteHandler);
-    }
-    catch (err) {
-        logWarning(`Checkpoint backup before change failed (non-critical): ${err.message}`);
+      }
     }
+    await context.checkpointManager.backupFileBeforeChange(
+      context.currentCheckpointId,
+      absoluteFilePath,
+      context.cwd,
+      remoteHandler
+    );
+  } catch (err) {
+    logWarning(`Checkpoint backup before change failed (non-critical): ${err.message}`);
+  }
 }
-export const viewFileTool = {
-    schema: {
-        name: 'view_file',
-        description: `View the contents of a file from the local filesystem. This tool supports some binary files such as images and videos.
-Text file usage:
-- The lines of the file are 1-indexed
-- If you do not provide StartLine/EndLine, the tool will read the ENTIRE file.
-  - WARNING: If the file is >500 lines, output will be TRUNCATED to the first 500 lines.
-  - You will be told the total line count and must use targeted reads (StartLine/EndLine) for the rest.
-- PREFER TARGETED READS: Use 'grep_search' to find line numbers, then read specific ranges.
-- You can view at most 500 lines at a time to prevent context explosion.
-Binary file usage:
-- Do not provide StartLine or EndLine arguments, this tool always returns the entire file
+const viewFileTool = {
+  schema: {
+    name: "view_file",
+    description: `View the contents of a file from the local filesystem. This tool supports some binary files such as images and videos.
+Text file usage:
+- The lines of the file are 1-indexed
+- If you do not provide StartLine/EndLine, the tool will read the ENTIRE file.
+  - WARNING: If the file is >500 lines, output will be TRUNCATED to the first 500 lines.
+  - You will be told the total line count and must use targeted reads (StartLine/EndLine) for the rest.
+- PREFER TARGETED READS: Use 'grep_search' to find line numbers, then read specific ranges.
+- You can view at most 500 lines at a time to prevent context explosion.
+Binary file usage:
+- Do not provide StartLine or EndLine arguments, this tool always returns the entire file
 - The output includes line numbers (e.g., "1: code") for reference. DO NOT include these line numbers in your search_pattern when editing.`,
-        parameters: {
-            type: 'object',
-            properties: {
-                reason_text: {
-                    type: 'string',
-                    description: 'REQUIRED: A brief explanation of why you are reading this file and what you are looking for. This will be shown to the user. Example: "Reading package.json to check the current version number"',
-                },
-                AbsolutePath: {
-                    type: 'string',
-                    description: 'Path to file to view. Must be an absolute path.',
-                },
-                StartLine: {
-                    type: 'integer',
-                    description: 'Optional. Startline to view, 1-indexed as usual, inclusive. This value must be less than or equal to EndLine.',
-                },
-                EndLine: {
-                    type: 'integer',
-                    description: 'Optional. Endline to view, 1-indexed as usual, inclusive. This value must be greater than or equal to StartLine.',
-                },
-            },
-            required: ['reason_text', 'AbsolutePath'],
+    parameters: {
+      type: "object",
+      properties: {
+        reason_text: {
+          type: "string",
+          description: 'REQUIRED: A brief explanation of why you are reading this file and what you are looking for. This will be shown to the user. Example: "Reading package.json to check the current version number"'
         },
-    },
-    async execute(args, context) {
-        const { AbsolutePath, StartLine, EndLine } = args;
-        const file_path = AbsolutePath; // Map to internal variable
-        const contextManager = context.contextManager;
-        const currentContext = contextManager.getCurrentContext();
-        // Use Context Manager for file operations
-        let content;
-        let fullPath;
-        if (currentContext.type === 'local') {
-            // Since AbsolutePath is required to be absolute, we might need to handle relative paths gracefully or enforce absolute
-            // The tool description says "Must be an absolute path", but for usability we can resolve it
-            fullPath = path.isAbsolute(file_path) ? file_path : path.resolve(context.cwd, file_path);
-            if (!fs.existsSync(fullPath)) {
-                throw new Error(`File not found: ${file_path}\n\nAction: Verify the file path using 'list_directory'.`);
-            }
-            // If user specifically requested lines, respect that lookup
-            // Otherwise read whole file first to check length
-            if (StartLine !== undefined || EndLine !== undefined) {
-                content = fileUtils.readFile(fullPath, StartLine, EndLine);
-            }
-            else {
-                // Read full file to check length
-                content = fs.readFileSync(fullPath, 'utf-8');
-            }
-        }
-        else {
-            // Read from subshell
-            content = await contextManager.readFile(file_path);
-            // Apply line range if logic requires it (for explicit range requests)
-            if (StartLine !== undefined || EndLine !== undefined) {
-                const lines = content.split('\n');
-                const start = StartLine ? StartLine - 1 : 0;
-                const end = EndLine ? EndLine : lines.length;
-                content = lines.slice(start, end).join('\n');
-            }
-        }
-        // Process content (add line numbers, handle truncation)
-        const lines = content.split('\n');
-        let displayedLines = lines;
-        let truncationMsg = '';
-        const startNum = StartLine || 1;
-        // TRUNCATION LOGIC:
-        // Only apply if NO range was specified (viewing "whole" file) AND file is too long
-        if (StartLine === undefined && EndLine === undefined && lines.length > 500) {
-            displayedLines = lines.slice(0, 500);
-            truncationMsg = `\n\n... [File truncated. Total lines: ${lines.length}. Showing first 500 lines only.]\n[Action: Use StartLine/EndLine parameters to view specific sections of the rest of the file.]`;
+        AbsolutePath: {
+          type: "string",
+          description: "Path to file to view. Must be an absolute path."
+        },
+        StartLine: {
+          type: "integer",
+          description: "Optional. Startline to view, 1-indexed as usual, inclusive. This value must be less than or equal to EndLine."
+        },
+        EndLine: {
+          type: "integer",
+          description: "Optional. Endline to view, 1-indexed as usual, inclusive. This value must be greater than or equal to StartLine."
         }
-        const numberedContent = displayedLines.map((line, idx) => `${startNum + idx}: ${line}`).join('\n');
-        return `File: ${file_path}\nLines: ${StartLine === undefined && EndLine === undefined ? lines.length : displayedLines.length} ${truncationMsg ? '(Truncated)' : ''}\n\n${numberedContent}${truncationMsg}`;
-    },
+      },
+      required: ["reason_text", "AbsolutePath"]
+    }
+  },
+  async execute(args, context) {
+    const { AbsolutePath, StartLine, EndLine } = args;
+    const file_path = AbsolutePath;
+    const contextManager = context.contextManager;
+    const currentContext = contextManager.getCurrentContext();
+    let content;
+    let fullPath;
+    if (currentContext.type === "local") {
+      fullPath = path.isAbsolute(file_path) ? file_path : path.resolve(context.cwd, file_path);
+      if (!fs.existsSync(fullPath)) {
+        throw new Error(`File not found: ${file_path}
+
+Action: Verify the file path using 'list_directory'.`);
+      }
+      if (StartLine !== void 0 || EndLine !== void 0) {
+        content = fileUtils.readFile(fullPath, StartLine, EndLine);
+      } else {
+        content = fs.readFileSync(fullPath, "utf-8");
+      }
+    } else {
+      content = await contextManager.readFile(file_path);
+      if (StartLine !== void 0 || EndLine !== void 0) {
+        const lines2 = content.split("\n");
+        const start = StartLine ? StartLine - 1 : 0;
+        const end = EndLine ? EndLine : lines2.length;
+        content = lines2.slice(start, end).join("\n");
+      }
+    }
+    const lines = content.split("\n");
+    let displayedLines = lines;
+    let truncationMsg = "";
+    const startNum = StartLine || 1;
+    if (StartLine === void 0 && EndLine === void 0 && lines.length > 500) {
+      displayedLines = lines.slice(0, 500);
+      truncationMsg = `
+
+... [File truncated. Total lines: ${lines.length}. Showing first 500 lines only.]
+[Action: Use StartLine/EndLine parameters to view specific sections of the rest of the file.]`;
+    }
+    const numberedContent = displayedLines.map((line, idx) => `${startNum + idx}: ${line}`).join("\n");
+    return `File: ${file_path}
+Lines: ${StartLine === void 0 && EndLine === void 0 ? lines.length : displayedLines.length} ${truncationMsg ? "(Truncated)" : ""}
+
+${numberedContent}${truncationMsg}`;
+  }
 };
-export const writeToFileTool = {
-    schema: {
-        name: 'write_to_file',
-        description: `Use this tool to create new files. The file and any parent directories will be created for you if they do not already exist.
-Follow these instructions:
-1. By default this tool will error if TargetFile already exists. To overwrite an existing file, set Overwrite to true.
-2. You MUST specify TargetFile as the FIRST argument. Please specify the full TargetFile before any of the code contents.
+const writeToFileTool = {
+  schema: {
+    name: "write_to_file",
+    description: `Use this tool to create new files. The file and any parent directories will be created for you if they do not already exist.
+Follow these instructions:
+1. By default this tool will error if TargetFile already exists. To overwrite an existing file, set Overwrite to true.
+2. You MUST specify TargetFile as the FIRST argument. Please specify the full TargetFile before any of the code contents.
 IMPORTANT: You must generate the following arguments first, before any others: [TargetFile, Overwrite]`,
-        parameters: {
-            type: 'object',
-            properties: {
-                reason_text: {
-                    type: 'string',
-                    description: 'REQUIRED: A brief explanation of why you are creating/writing this file. This will be shown to the user. Example: "Creating a new configuration file for the database connection"',
-                },
-                TargetFile: {
-                    type: 'string',
-                    description: 'The target file to create and write code to.',
-                },
-                CodeContent: {
-                    type: 'string',
-                    description: 'The code contents to write to the file.',
-                },
-                Overwrite: {
-                    type: 'boolean',
-                    description: 'Set this to true to overwrite an existing file. WARNING: This will replace the entire file contents. Only use when you explicitly intend to overwrite. Otherwise, use a code edit tool to modify existing files.',
-                },
-                EmptyFile: {
-                    type: 'boolean',
-                    description: 'Set this to true to create an empty file.',
-                },
-                Description: {
-                    type: 'string',
-                    description: 'Brief, user-facing explanation of what this change did. Focus on non-obvious rationale, design decisions, or important context. Don\'t just restate what the code does.',
-                },
-                Complexity: {
-                    type: 'integer',
-                    description: 'A 1-10 rating of how important it is for the user to review this change. Rate based on: 1-3 (routine/obvious), 4-6 (worth noting), 7-10 (critical or subtle and warrants explanation).',
-                },
-            },
-            required: ['reason_text', 'TargetFile', 'Overwrite', 'CodeContent', 'EmptyFile', 'Description', 'Complexity'],
+    parameters: {
+      type: "object",
+      properties: {
+        reason_text: {
+          type: "string",
+          description: 'REQUIRED: A brief explanation of why you are creating/writing this file. This will be shown to the user. Example: "Creating a new configuration file for the database connection"'
         },
-    },
-    async execute(args, context) {
-        const { TargetFile, CodeContent, Overwrite, EmptyFile } = args;
-        const file_path = TargetFile; // Map to internal variable
-        const content = EmptyFile ? '' : CodeContent;
-        const contextManager = context.contextManager;
-        const currentContext = contextManager.getCurrentContext();
-        if (currentContext.type === 'local') {
-            const fullPath = path.resolve(context.cwd, file_path);
-            // Ask for approval if file exists
-            if (fs.existsSync(fullPath)) {
-                if (!Overwrite) {
-                    throw new Error(`File ${file_path} already exists. Set Overwrite to true if you intend to replace it.`);
-                }
-                // Show preview of new content for overwrite
-                const language = file_path.split('.').pop() || 'text';
-                const result = await context.requireApproval(`File ${fullPath} already exists. Overwrite it?`, true, {
-                    type: 'code',
-                    content,
-                    language
-                }, 'write_to_file', { file_path: fullPath, operation: 'overwrite' });
-                if (typeof result === 'object' && 'feedback' in result) {
-                    // User provided feedback - throw special error with feedback
-                    throw new Error(`USER_FEEDBACK: ${result.feedback}`);
-                }
-                if (!result) {
-                    throw new Error('Operation cancelled by user.');
-                }
-            }
-            else {
-                // Ask for approval to create new file with code preview
-                const language = file_path.split('.').pop() || 'text';
-                const result = await context.requireApproval(`Create new file ${fullPath}?`, false, {
-                    type: 'code',
-                    content: content,
-                    language
-                }, 'write_to_file', { file_path: fullPath, operation: 'create' });
-                if (typeof result === 'object' && 'feedback' in result) {
-                    // User provided feedback - throw special error with feedback
-                    throw new Error(`USER_FEEDBACK: ${result.feedback}`);
-                }
-                if (!result) {
-                    throw new Error('Operation cancelled by user.');
-                }
-            }
-            // Backup file before modification (for checkpoint revert)
-            await backupBeforeChange(context, fullPath);
-            fileUtils.writeFile(fullPath, content);
-            // Run syntax check on the written file
-            const syntaxResult = await checkSyntax(fullPath, content);
-            const syntaxFeedback = formatSyntaxCheckResult(syntaxResult);
-            return `Successfully wrote ${content.length} characters to ${file_path}\n${syntaxFeedback}`;
-        }
-        else {
-            // Write to subshell - always ask for approval
-            const language = file_path.split('.').pop() || 'text';
-            const result = await context.requireApproval(`Write file ${file_path} in ${currentContext.type} environment?`, true, {
-                type: 'code',
-                content,
-                language
-            }, 'write_to_file', { file_path, operation: 'write_remote' });
-            if (typeof result === 'object' && 'feedback' in result) {
-                throw new Error(`USER_FEEDBACK: ${result.feedback}`);
-            }
-            if (!result) {
-                throw new Error('Operation cancelled by user.');
-            }
-            // Backup remote file before modification (for checkpoint revert)
-            await backupBeforeChange(context, file_path);
-            await contextManager.writeFile(file_path, content);
-            // Note: Syntax check skipped for remote files (would need to read back)
-            return `Successfully wrote ${content.length} characters to ${file_path} in ${currentContext.type} environment\n(Syntax check skipped for remote files)`;
-        }
-    },
-};
-export const editFileTool = {
-    schema: {
-        name: 'edit_file',
-        description: `Search for a specific pattern in a file and replace it with new content. Shows a diff preview before applying.
-
-IMPORTANT: You MUST provide a reason_text parameter explaining what change you are making and why. This will be shown to the user before the edit is applied.
-
-CRITICAL REQUIREMENTS:
-- 'search_pattern' must match the file content's meaningful tokens exactly.
-- Leading and trailing whitespace/indentation around the pattern will be ignored for the match.
-- You must still provide the full code block, but do not worry about exact indentation.
-- The pattern must be UNIQUE in the file (appear exactly once).
-- You MUST have read the file in a previous turn to know the exact content.
-- Include surrounding context (2-3 lines) to ensure uniqueness.
-
-COMMON MISTAKES TO AVOID:
-- Using patterns that appear multiple times
-- Not including enough context for uniqueness
-- Modifying the internal tokens of the code (variable names, strings, etc.)
-- Including the line numbers (e.g., "1: ") in the search_pattern. Copy ONLY the code.`,
-        parameters: {
-            type: 'object',
-            properties: {
-                reason_text: {
-                    type: 'string',
-                    description: 'REQUIRED: A brief explanation of what change you are making and why. This will be shown to the user. Example: "Updating the port number from 3000 to 8080 to match the production configuration"',
-                },
-                file_path: {
-                    type: 'string',
-                    description: 'The path to the file to edit (relative to current working directory)',
-                },
-                search_pattern: {
-                    type: 'string',
-                    description: `The EXACT block of text to replace. Must match character-for-character (ignoring whitespace differences).
-Copy this directly from a recent view_file output.`,
-                },
-                replacement: {
-                    type: 'string',
-                    description: 'The new text to insert in place of search_pattern. Use the same indentation style as the surrounding code.',
-                },
-            },
-            required: ['reason_text', 'file_path', 'search_pattern', 'replacement'],
+        TargetFile: {
+          type: "string",
+          description: "The target file to create and write code to."
         },
-    },
-    async execute(args, context) {
-        const { file_path, search_pattern, replacement } = args;
-        const contextManager = context.contextManager;
-        const currentContext = contextManager.getCurrentContext();
-        // Validate edit operation for local files
-        if (currentContext.type === 'local') {
-            const validator = new ToolValidator();
-            const validationResult = await validator.validateEditFile(file_path, search_pattern, replacement, context.cwd);
-            if (!validationResult.valid) {
-                const errorMessage = [
-                    validationResult.error,
-                    validationResult.suggestion ? `\nSuggestion: ${validationResult.suggestion}` : '',
-                ].join('');
-                throw new Error(errorMessage);
-            }
-        }
-        // Read the current content
-        let oldContent;
-        // Compute the full path for local files
-        const fullPath = currentContext.type === 'local' ? path.resolve(context.cwd, file_path) : file_path;
-        if (currentContext.type === 'local') {
-            if (!fs.existsSync(fullPath)) {
-                throw new Error(`File not found: ${file_path}\n\nAction: Verify the file path using 'list_directory'.`);
-            }
-            oldContent = fs.readFileSync(fullPath, 'utf-8');
+        CodeContent: {
+          type: "string",
+          description: "The code contents to write to the file."
+        },
+        Overwrite: {
+          type: "boolean",
+          description: "Set this to true to overwrite an existing file. WARNING: This will replace the entire file contents. Only use when you explicitly intend to overwrite. Otherwise, use a code edit tool to modify existing files."
+        },
+        EmptyFile: {
+          type: "boolean",
+          description: "Set this to true to create an empty file."
+        },
+        Description: {
+          type: "string",
+          description: "Brief, user-facing explanation of what this change did. Focus on non-obvious rationale, design decisions, or important context. Don't just restate what the code does."
+        },
+        Complexity: {
+          type: "integer",
+          description: "A 1-10 rating of how important it is for the user to review this change. Rate based on: 1-3 (routine/obvious), 4-6 (worth noting), 7-10 (critical or subtle and warrants explanation)."
         }
-        else {
-            oldContent = await contextManager.readFile(file_path);
+      },
+      required: ["reason_text", "TargetFile", "Overwrite", "CodeContent", "EmptyFile", "Description", "Complexity"]
+    }
+  },
+  async execute(args, context) {
+    const { TargetFile, CodeContent, Overwrite, EmptyFile } = args;
+    const file_path = TargetFile;
+    const content = EmptyFile ? "" : CodeContent;
+    const contextManager = context.contextManager;
+    const currentContext = contextManager.getCurrentContext();
+    if (currentContext.type === "local") {
+      const fullPath = path.resolve(context.cwd, file_path);
+      if (fs.existsSync(fullPath)) {
+        if (!Overwrite) {
+          throw new Error(`File ${file_path} already exists. Set Overwrite to true if you intend to replace it.`);
         }
-        // Create flexible regex for matching and replacement
-        const { createFlexibleRegex } = await import('./validation.js');
-        const regex = createFlexibleRegex(search_pattern);
-        // SAFETY CHECK: Ensure we don't accidentally match 0 times or >1 times 
-        // (In case file changed between validation and execution)
-        const matches = oldContent.match(regex);
-        if (!matches || matches.length === 0) {
-            throw new Error(`Pattern not found in file (even with flexible whitespace).`);
+        const language = file_path.split(".").pop() || "text";
+        const result = await context.requireApproval(
+          `File ${fullPath} already exists. Overwrite it?`,
+          true,
+          {
+            type: "code",
+            content,
+            language
+          },
+          "write_to_file",
+          { file_path: fullPath, operation: "overwrite" }
+        );
+        if (typeof result === "object" && "feedback" in result) {
+          throw new Error(`USER_FEEDBACK: ${result.feedback}`);
         }
-        if (matches.length > 1) {
-            throw new Error(`Pattern matches ${matches.length} times. Search pattern must be unique.`);
+        if (!result) {
+          throw new Error("Operation cancelled by user.");
         }
-        // APPLY REPLACEMENT
-        // We use the regex to replace. 
-        // Since we validated count === 1, the global 'g' flag is safe/necessary.
-        const newContent = oldContent.replace(regex, replacement);
-        // Build unified diff text for preview
-        const patch = Diff.createTwoFilesPatch(file_path, file_path, oldContent, newContent, '', '');
-        // Generate full diff with infinite context for "Full File" view
-        const fullDiff = Diff.createTwoFilesPatch(file_path, file_path, oldContent, newContent, '', '', { context: Number.MAX_SAFE_INTEGER });
-        // Ask for approval with diff preview
-        const approved = await context.requireApproval(`Apply these changes to ${fullPath}${currentContext.type !== 'local' ? ` in ${currentContext.type} environment` : ''}?`, false, {
-            type: 'diff',
-            content: patch,
-            fullDiff: fullDiff
-        }, 'edit_file', { file_path: fullPath });
-        if (!approved) {
-            throw new Error('Operation cancelled by user.');
+      } else {
+        const language = file_path.split(".").pop() || "text";
+        const result = await context.requireApproval(
+          `Create new file ${fullPath}?`,
+          false,
+          {
+            type: "code",
+            content,
+            language
+          },
+          "write_to_file",
+          { file_path: fullPath, operation: "create" }
+        );
+        if (typeof result === "object" && "feedback" in result) {
+          throw new Error(`USER_FEEDBACK: ${result.feedback}`);
         }
-        // Apply the changes
-        if (currentContext.type === 'local') {
-            // Backup file before modification (for checkpoint revert)
-            await backupBeforeChange(context, fullPath);
-            fs.writeFileSync(fullPath, newContent, 'utf-8');
-            // Run syntax check on the edited file
-            const syntaxResult = await checkSyntax(fullPath, newContent);
-            const syntaxFeedback = formatSyntaxCheckResult(syntaxResult);
-            return `Successfully replaced pattern in ${file_path}\n${syntaxFeedback}`;
+        if (!result) {
+          throw new Error("Operation cancelled by user.");
         }
-        else {
-            // Backup remote file before modification (for checkpoint revert)
-            await backupBeforeChange(context, fullPath);
-            await contextManager.writeFile(file_path, newContent);
-            // Note: Syntax check skipped for remote files
-            return `Successfully replaced pattern in ${file_path} (${currentContext.type} environment)\n(Syntax check skipped for remote files)`;
+      }
+      await backupBeforeChange(context, fullPath);
+      fileUtils.writeFile(fullPath, content);
+      const syntaxResult = await checkSyntax(fullPath, content);
+      const syntaxFeedback = formatSyntaxCheckResult(syntaxResult);
+      return `Successfully wrote ${content.length} characters to ${file_path}
+${syntaxFeedback}`;
+    } else {
+      const language = file_path.split(".").pop() || "text";
+      const result = await context.requireApproval(
+        `Write file ${file_path} in ${currentContext.type} environment?`,
+        true,
+        {
+          type: "code",
+          content,
+          language
+        },
+        "write_to_file",
+        { file_path, operation: "write_remote" }
+      );
+      if (typeof result === "object" && "feedback" in result) {
+        throw new Error(`USER_FEEDBACK: ${result.feedback}`);
+      }
+      if (!result) {
+        throw new Error("Operation cancelled by user.");
+      }
+      await backupBeforeChange(context, file_path);
+      await contextManager.writeFile(file_path, content);
+      return `Successfully wrote ${content.length} characters to ${file_path} in ${currentContext.type} environment
+(Syntax check skipped for remote files)`;
+    }
+  }
+};
+const editFileTool = {
+  schema: {
+    name: "edit_file",
+    description: `Search for a specific pattern in a file and replace it with new content. Shows a diff preview before applying.
+
+IMPORTANT: You MUST provide a reason_text parameter explaining what change you are making and why. This will be shown to the user before the edit is applied.
+
+CRITICAL REQUIREMENTS:
+- 'search_pattern' must match the file content's meaningful tokens exactly.
+- Leading and trailing whitespace/indentation around the pattern will be ignored for the match.
+- You must still provide the full code block, but do not worry about exact indentation.
+- The pattern must be UNIQUE in the file (appear exactly once).
+- You MUST have read the file in a previous turn to know the exact content.
+- Include surrounding context (2-3 lines) to ensure uniqueness.
+
+COMMON MISTAKES TO AVOID:
+- Using patterns that appear multiple times
+- Not including enough context for uniqueness
+- Modifying the internal tokens of the code (variable names, strings, etc.)
+- Including the line numbers (e.g., "1: ") in the search_pattern. Copy ONLY the code.`,
+    parameters: {
+      type: "object",
+      properties: {
+        reason_text: {
+          type: "string",
+          description: 'REQUIRED: A brief explanation of what change you are making and why. This will be shown to the user. Example: "Updating the port number from 3000 to 8080 to match the production configuration"'
+        },
+        file_path: {
+          type: "string",
+          description: "The path to the file to edit (relative to current working directory)"
+        },
+        search_pattern: {
+          type: "string",
+          description: `The EXACT block of text to replace. Must match character-for-character (ignoring whitespace differences).
+Copy this directly from a recent view_file output.`
+        },
+        replacement: {
+          type: "string",
+          description: "The new text to insert in place of search_pattern. Use the same indentation style as the surrounding code."
         }
-    },
+      },
+      required: ["reason_text", "file_path", "search_pattern", "replacement"]
+    }
+  },
+  async execute(args, context) {
+    const { file_path, search_pattern, replacement } = args;
+    const contextManager = context.contextManager;
+    const currentContext = contextManager.getCurrentContext();
+    if (currentContext.type === "local") {
+      const validator = new ToolValidator();
+      const validationResult = await validator.validateEditFile(
+        file_path,
+        search_pattern,
+        replacement,
+        context.cwd
+      );
+      if (!validationResult.valid) {
+        const errorMessage = [
+          validationResult.error,
+          validationResult.suggestion ? `
+Suggestion: ${validationResult.suggestion}` : ""
+        ].join("");
+        throw new Error(errorMessage);
+      }
+    }
+    let oldContent;
+    const fullPath = currentContext.type === "local" ? path.resolve(context.cwd, file_path) : file_path;
+    if (currentContext.type === "local") {
+      if (!fs.existsSync(fullPath)) {
+        throw new Error(`File not found: ${file_path}
+
+Action: Verify the file path using 'list_directory'.`);
+      }
+      oldContent = fs.readFileSync(fullPath, "utf-8");
+    } else {
+      oldContent = await contextManager.readFile(file_path);
+    }
+    const { createFlexibleRegex } = await import("./validation.js");
+    const regex = createFlexibleRegex(search_pattern);
+    const matches = oldContent.match(regex);
+    if (!matches || matches.length === 0) {
+      throw new Error(`Pattern not found in file (even with flexible whitespace).`);
+    }
+    if (matches.length > 1) {
+      throw new Error(`Pattern matches ${matches.length} times. Search pattern must be unique.`);
+    }
+    const newContent = oldContent.replace(regex, replacement);
+    const patch = Diff.createTwoFilesPatch(
+      file_path,
+      file_path,
+      oldContent,
+      newContent,
+      "",
+      ""
+    );
+    const fullDiff = Diff.createTwoFilesPatch(
+      file_path,
+      file_path,
+      oldContent,
+      newContent,
+      "",
+      "",
+      { context: Number.MAX_SAFE_INTEGER }
+    );
+    const approved = await context.requireApproval(
+      `Apply these changes to ${fullPath}${currentContext.type !== "local" ? ` in ${currentContext.type} environment` : ""}?`,
+      false,
+      {
+        type: "diff",
+        content: patch,
+        fullDiff
+      },
+      "edit_file",
+      { file_path: fullPath }
+    );
+    if (!approved) {
+      throw new Error("Operation cancelled by user.");
+    }
+    if (currentContext.type === "local") {
+      await backupBeforeChange(context, fullPath);
+      fs.writeFileSync(fullPath, newContent, "utf-8");
+      const syntaxResult = await checkSyntax(fullPath, newContent);
+      const syntaxFeedback = formatSyntaxCheckResult(syntaxResult);
+      return `Successfully replaced pattern in ${file_path}
+${syntaxFeedback}`;
+    } else {
+      await backupBeforeChange(context, fullPath);
+      await contextManager.writeFile(file_path, newContent);
+      return `Successfully replaced pattern in ${file_path} (${currentContext.type} environment)
+(Syntax check skipped for remote files)`;
+    }
+  }
 };
-export const multiEditFileTool = {
-    schema: {
-        name: 'multi_edit_file',
-        description: `Apply MULTIPLE search-and-replace edits to a SINGLE file in ONE tool call.
-    
-Use this instead of calling edit_file multiple times on the same file. This is more efficient and ensures all edits are applied atomically.
-
-WHEN TO USE:
-- You need to make 2+ edits to the same file
-- You want to batch changes to avoid multiple tool calls
-- The edits are independent (don't overlap)
-
-CRITICAL REQUIREMENTS:
-- Each edit's 'search_pattern' must be UNIQUE in the file
-- Edits are applied in order - earlier edits can affect line positions
-- All patterns must exist in the file or the entire operation fails
+const multiEditFileTool = {
+  schema: {
+    name: "multi_edit_file",
+    description: `Apply MULTIPLE search-and-replace edits to a SINGLE file in ONE tool call.
+    
+Use this instead of calling edit_file multiple times on the same file. This is more efficient and ensures all edits are applied atomically.
+
+WHEN TO USE:
+- You need to make 2+ edits to the same file
+- You want to batch changes to avoid multiple tool calls
+- The edits are independent (don't overlap)
+
+CRITICAL REQUIREMENTS:
+- Each edit's 'search_pattern' must be UNIQUE in the file
+- Edits are applied in order - earlier edits can affect line positions
+- All patterns must exist in the file or the entire operation fails
 - You MUST have read the file first to know exact content`,
-        parameters: {
-            type: 'object',
+    parameters: {
+      type: "object",
+      properties: {
+        reason_text: {
+          type: "string",
+          description: "REQUIRED: A brief explanation of what changes you are making and why."
+        },
+        file_path: {
+          type: "string",
+          description: "The path to the file to edit"
+        },
+        edits: {
+          type: "array",
+          description: "Array of edit operations to apply, in order",
+          items: {
+            type: "object",
             properties: {
-                reason_text: {
-                    type: 'string',
-                    description: 'REQUIRED: A brief explanation of what changes you are making and why.',
-                },
-                file_path: {
-                    type: 'string',
-                    description: 'The path to the file to edit',
-                },
-                edits: {
-                    type: 'array',
-                    description: 'Array of edit operations to apply, in order',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            search_pattern: {
-                                type: 'string',
-                                description: 'The EXACT block of text to replace. Must be unique in the file.',
-                            },
-                            replacement: {
-                                type: 'string',
-                                description: 'The new text to insert in place of search_pattern.',
-                            },
-                            description: {
-                                type: 'string',
-                                description: 'Brief description of this specific edit',
-                            },
-                        },
-                        required: ['search_pattern', 'replacement'],
-                    },
-                },
+              search_pattern: {
+                type: "string",
+                description: "The EXACT block of text to replace. Must be unique in the file."
+              },
+              replacement: {
+                type: "string",
+                description: "The new text to insert in place of search_pattern."
+              },
+              description: {
+                type: "string",
+                description: "Brief description of this specific edit"
+              }
             },
-            required: ['reason_text', 'file_path', 'edits'],
-        },
-    },
-    async execute(args, context) {
-        const { file_path, edits } = args;
-        const contextManager = context.contextManager;
-        const currentContext = contextManager.getCurrentContext();
-        if (!edits || !Array.isArray(edits) || edits.length === 0) {
-            throw new Error('No edits provided. The edits array must contain at least one edit operation.');
-        }
-        // Read the current content
-        let content;
-        // Compute the full path for local files
-        const fullPath = currentContext.type === 'local' ? path.resolve(context.cwd, file_path) : file_path;
-        if (currentContext.type === 'local') {
-            if (!fs.existsSync(fullPath)) {
-                throw new Error(`File not found: ${file_path}`);
-            }
-            content = fs.readFileSync(fullPath, 'utf-8');
+            required: ["search_pattern", "replacement"]
+          }
         }
-        else {
-            content = await contextManager.readFile(file_path);
-        }
-        const originalContent = content;
-        const { createFlexibleRegex } = await import('./validation.js');
-        const appliedEdits = [];
-        const errors = [];
-        // Validate all patterns exist before applying any
-        for (let i = 0; i < edits.length; i++) {
-            const edit = edits[i];
-            const regex = createFlexibleRegex(edit.search_pattern);
-            const matches = content.match(regex);
-            if (!matches || matches.length === 0) {
-                errors.push(`Edit ${i + 1}: Pattern not found in file`);
-            }
-            else if (matches.length > 1) {
-                errors.push(`Edit ${i + 1}: Pattern matches ${matches.length} times (must be unique)`);
-            }
-        }
-        if (errors.length > 0) {
-            throw new Error(`Validation failed:\n${errors.join('\n')}\n\nNo changes were made.`);
-        }
-        // Apply edits in order
-        for (let i = 0; i < edits.length; i++) {
-            const edit = edits[i];
-            const regex = createFlexibleRegex(edit.search_pattern);
-            // Re-check match after previous edits
-            const matches = content.match(regex);
-            if (!matches || matches.length === 0) {
-                errors.push(`Edit ${i + 1}: Pattern no longer found after previous edits`);
-                continue;
-            }
-            content = content.replace(regex, edit.replacement);
-            appliedEdits.push(edit.description || `Edit ${i + 1}`);
-        }
-        // Generate combined diff
-        const patch = Diff.createTwoFilesPatch(file_path, file_path, originalContent, content, '', '');
-        const fullDiff = Diff.createTwoFilesPatch(file_path, file_path, originalContent, content, '', '', { context: Number.MAX_SAFE_INTEGER });
-        // Ask for approval
-        const approved = await context.requireApproval(`Apply ${edits.length} edits to ${fullPath}?`, false, {
-            type: 'diff',
-            content: patch,
-            fullDiff: fullDiff
-        }, 'multi_edit_file', { file_path: fullPath, editCount: edits.length });
-        if (!approved) {
-            throw new Error('Operation cancelled by user.');
-        }
-        // Write changes
-        if (currentContext.type === 'local') {
-            // Backup file before modification (for checkpoint revert)
-            await backupBeforeChange(context, fullPath);
-            fs.writeFileSync(fullPath, content, 'utf-8');
-            const syntaxResult = await checkSyntax(fullPath, content);
-            const syntaxFeedback = formatSyntaxCheckResult(syntaxResult);
-            return `Successfully applied ${appliedEdits.length} edits to ${file_path}:\n${appliedEdits.map((e, i) => `  ${i + 1}. ${e}`).join('\n')}\n${syntaxFeedback}`;
-        }
-        else {
-            // Backup remote file before modification (for checkpoint revert)
-            await backupBeforeChange(context, fullPath);
-            await contextManager.writeFile(file_path, content);
-            return `Successfully applied ${appliedEdits.length} edits to ${file_path} (${currentContext.type} environment)`;
-        }
-    },
+      },
+      required: ["reason_text", "file_path", "edits"]
+    }
+  },
+  async execute(args, context) {
+    const { file_path, edits } = args;
+    const contextManager = context.contextManager;
+    const currentContext = contextManager.getCurrentContext();
+    if (!edits || !Array.isArray(edits) || edits.length === 0) {
+      throw new Error("No edits provided. The edits array must contain at least one edit operation.");
+    }
+    let content;
+    const fullPath = currentContext.type === "local" ? path.resolve(context.cwd, file_path) : file_path;
+    if (currentContext.type === "local") {
+      if (!fs.existsSync(fullPath)) {
+        throw new Error(`File not found: ${file_path}`);
+      }
+      content = fs.readFileSync(fullPath, "utf-8");
+    } else {
+      content = await contextManager.readFile(file_path);
+    }
+    const originalContent = content;
+    const { createFlexibleRegex } = await import("./validation.js");
+    const appliedEdits = [];
+    const errors = [];
+    for (let i = 0; i < edits.length; i++) {
+      const edit = edits[i];
+      const regex = createFlexibleRegex(edit.search_pattern);
+      const matches = content.match(regex);
+      if (!matches || matches.length === 0) {
+        errors.push(`Edit ${i + 1}: Pattern not found in file`);
+      } else if (matches.length > 1) {
+        errors.push(`Edit ${i + 1}: Pattern matches ${matches.length} times (must be unique)`);
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(`Validation failed:
+${errors.join("\n")}
+
+No changes were made.`);
+    }
+    for (let i = 0; i < edits.length; i++) {
+      const edit = edits[i];
+      const regex = createFlexibleRegex(edit.search_pattern);
+      const matches = content.match(regex);
+      if (!matches || matches.length === 0) {
+        errors.push(`Edit ${i + 1}: Pattern no longer found after previous edits`);
+        continue;
+      }
+      content = content.replace(regex, edit.replacement);
+      appliedEdits.push(edit.description || `Edit ${i + 1}`);
+    }
+    const patch = Diff.createTwoFilesPatch(
+      file_path,
+      file_path,
+      originalContent,
+      content,
+      "",
+      ""
+    );
+    const fullDiff = Diff.createTwoFilesPatch(
+      file_path,
+      file_path,
+      originalContent,
+      content,
+      "",
+      "",
+      { context: Number.MAX_SAFE_INTEGER }
+    );
+    const approved = await context.requireApproval(
+      `Apply ${edits.length} edits to ${fullPath}?`,
+      false,
+      {
+        type: "diff",
+        content: patch,
+        fullDiff
+      },
+      "multi_edit_file",
+      { file_path: fullPath, editCount: edits.length }
+    );
+    if (!approved) {
+      throw new Error("Operation cancelled by user.");
+    }
+    if (currentContext.type === "local") {
+      await backupBeforeChange(context, fullPath);
+      fs.writeFileSync(fullPath, content, "utf-8");
+      const syntaxResult = await checkSyntax(fullPath, content);
+      const syntaxFeedback = formatSyntaxCheckResult(syntaxResult);
+      return `Successfully applied ${appliedEdits.length} edits to ${file_path}:
+${appliedEdits.map((e, i) => `  ${i + 1}. ${e}`).join("\n")}
+${syntaxFeedback}`;
+    } else {
+      await backupBeforeChange(context, fullPath);
+      await contextManager.writeFile(file_path, content);
+      return `Successfully applied ${appliedEdits.length} edits to ${file_path} (${currentContext.type} environment)`;
+    }
+  }
 };
-export const listDirTool = {
-    schema: {
-        name: 'list_dir',
-        description: `List the contents of a directory with statistics and smart limiting.
-
-For each directory child, output includes:
-- Directories: name and item count (sorted by size, largest first)
-- Files: name and size in KB (limited to 100 by default)
-
-SMART LIMITING:
-- Shows all directories (up to 50) - navigation is critical
-- Limits files to 100 - prevents context explosion
-- Always shows complete statistics (total dirs, files, items)
-- Highlights large directories (>100 items) for awareness
-
+const listDirTool = {
+  schema: {
+    name: "list_dir",
+    description: `List the contents of a directory with statistics and smart limiting.
+
+For each directory child, output includes:
+- Directories: name and item count (sorted by size, largest first)
+- Files: name and size in KB (limited to 100 by default)
+
+SMART LIMITING:
+- Shows all directories (up to 50) - navigation is critical
+- Limits files to 100 - prevents context explosion
+- Always shows complete statistics (total dirs, files, items)
+- Highlights large directories (>100 items) for awareness
+
 IMPORTANT: You MUST provide a reason_text parameter explaining why you are listing this directory.`,
-        parameters: {
-            type: 'object',
-            properties: {
-                reason_text: {
-                    type: 'string',
-                    description: 'REQUIRED: A brief explanation of why you are listing this directory.',
-                },
-                DirectoryPath: {
-                    type: 'string',
-                    description: 'Path to list contents of, should be absolute path to a directory',
-                },
-                fileLimit: {
-                    type: 'integer',
-                    description: 'Optional: Maximum number of files to show (default: 100)',
-                },
-                showHidden: {
-                    type: 'boolean',
-                    description: 'Optional: Whether to show hidden files (dotfiles). Defaults to true.',
-                },
-            },
-            required: ['reason_text', 'DirectoryPath'],
+    parameters: {
+      type: "object",
+      properties: {
+        reason_text: {
+          type: "string",
+          description: "REQUIRED: A brief explanation of why you are listing this directory."
+        },
+        DirectoryPath: {
+          type: "string",
+          description: "Path to list contents of, should be absolute path to a directory"
         },
-    },
-    async execute(args, context) {
-        const { DirectoryPath, fileLimit = 100, showHidden = true } = args;
-        const directory_path = DirectoryPath;
-        const contextManager = context.contextManager;
-        const currentContext = contextManager.getCurrentContext();
-        if (currentContext.type === 'local') {
-            const fullPath = path.isAbsolute(directory_path) ? directory_path : path.resolve(context.cwd, directory_path);
-            if (!fs.existsSync(fullPath)) {
-                throw new Error(`Directory not found: ${directory_path}\n\nAction: Check the path or use 'find_files' to locate the directory.`);
-            }
-            if (!fs.statSync(fullPath).isDirectory()) {
-                throw new Error(`Path is not a directory: ${directory_path}\n\nAction: Verify the path points to a directory, not a file.`);
-            }
-            // Use enhanced listing
-            const listing = fileUtils.listDirectoryEnhanced(fullPath, {
-                fileLimit: fileLimit,
-                dirLimit: 50,
-                showHidden: showHidden,
-                largeThreshold: 100
-            });
-            return fileUtils.formatDirectoryListing(directory_path, listing);
+        fileLimit: {
+          type: "integer",
+          description: "Optional: Maximum number of files to show (default: 100)"
+        },
+        showHidden: {
+          type: "boolean",
+          description: "Optional: Whether to show hidden files (dotfiles). Defaults to true."
+        }
+      },
+      required: ["reason_text", "DirectoryPath"]
+    }
+  },
+  async execute(args, context) {
+    const { DirectoryPath, fileLimit = 100, showHidden = true } = args;
+    const directory_path = DirectoryPath;
+    const contextManager = context.contextManager;
+    const currentContext = contextManager.getCurrentContext();
+    if (currentContext.type === "local") {
+      const fullPath = path.isAbsolute(directory_path) ? directory_path : path.resolve(context.cwd, directory_path);
+      if (!fs.existsSync(fullPath)) {
+        throw new Error(`Directory not found: ${directory_path}
+
+Action: Check the path or use 'find_files' to locate the directory.`);
+      }
+      if (!fs.statSync(fullPath).isDirectory()) {
+        throw new Error(`Path is not a directory: ${directory_path}
+
+Action: Verify the path points to a directory, not a file.`);
+      }
+      const listing = fileUtils.listDirectoryEnhanced(fullPath, {
+        fileLimit,
+        dirLimit: 50,
+        showHidden,
+        largeThreshold: 100
+      });
+      return fileUtils.formatDirectoryListing(directory_path, listing);
+    } else {
+      const entries = await contextManager.listDirectory(directory_path);
+      const directories = [];
+      const files = [];
+      for (const entry of entries) {
+        if (entry.type === "directory") {
+          directories.push(`  ${entry.name}/`);
+        } else {
+          files.push(`  ${entry.name}`);
+        }
+      }
+      const lines = [
+        `\u{1F4C1} Directory: ${directory_path} (${currentContext.type} environment)`,
+        "\u2550".repeat(50),
+        `Total: ${directories.length} directories, ${files.length} files, ${entries.length} items`,
+        ""
+      ];
+      if (directories.length > 0) {
+        lines.push("\u{1F4C2} Directories:");
+        lines.push(...directories.slice(0, 50));
+        if (directories.length > 50) {
+          lines.push(`  ... and ${directories.length - 50} more directories`);
         }
-        else {
-            // For subshell contexts, use existing simple format
-            // (enhanced format would require additional subshell handler changes)
-            const entries = await contextManager.listDirectory(directory_path);
-            const directories = [];
-            const files = [];
-            for (const entry of entries) {
-                if (entry.type === 'directory') {
-                    directories.push(`  ${entry.name}/`);
-                }
-                else {
-                    files.push(`  ${entry.name}`);
-                }
-            }
-            const lines = [
-                `📁 Directory: ${directory_path} (${currentContext.type} environment)`,
-                '═'.repeat(50),
-                `Total: ${directories.length} directories, ${files.length} files, ${entries.length} items`,
-                ''
-            ];
-            if (directories.length > 0) {
-                lines.push('📂 Directories:');
-                lines.push(...directories.slice(0, 50));
-                if (directories.length > 50) {
-                    lines.push(`  ... and ${directories.length - 50} more directories`);
-                }
-                lines.push('');
-            }
-            if (files.length > 0) {
-                const fileLimit = 100;
-                const shownFiles = files.slice(0, fileLimit);
-                const hiddenCount = Math.max(0, files.length - fileLimit);
-                lines.push(hiddenCount > 0
-                    ? `📄 Files (${shownFiles.length} of ${files.length} shown):`
-                    : '📄 Files:');
-                lines.push(...shownFiles);
-                if (hiddenCount > 0) {
-                    lines.push(`  ... and ${hiddenCount} more files`);
-                    lines.push('');
-                    lines.push('💡 To see more: List subdirectories individually or use find_files to search');
-                }
-            }
-            return lines.join('\n');
+        lines.push("");
+      }
+      if (files.length > 0) {
+        const fileLimit2 = 100;
+        const shownFiles = files.slice(0, fileLimit2);
+        const hiddenCount = Math.max(0, files.length - fileLimit2);
+        lines.push(hiddenCount > 0 ? `\u{1F4C4} Files (${shownFiles.length} of ${files.length} shown):` : "\u{1F4C4} Files:");
+        lines.push(...shownFiles);
+        if (hiddenCount > 0) {
+          lines.push(`  ... and ${hiddenCount} more files`);
+          lines.push("");
+          lines.push("\u{1F4A1} To see more: List subdirectories individually or use find_files to search");
         }
-    },
+      }
+      return lines.join("\n");
+    }
+  }
+};
+export {
+  editFileTool,
+  listDirTool,
+  multiEditFileTool,
+  viewFileTool,
+  writeToFileTool
 };
 //# sourceMappingURL=file-ops.js.map