@xortex/xcode 3.0.0

package/tools/FileEditTool/FileEditTool.ts

@@ -0,0 +1,625 @@
+import { dirname, isAbsolute, sep } from 'path'
+import { logEvent } from 'src/services/analytics/index.js'
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js'
+import { diagnosticTracker } from '../../services/diagnosticTracking.js'
+import { clearDeliveredDiagnosticsForFile } from '../../services/lsp/LSPDiagnosticRegistry.js'
+import { getLspServerManager } from '../../services/lsp/manager.js'
+import { notifyVscodeFileUpdated } from '../../services/mcp/vscodeSdkMcp.js'
+import { checkTeamMemSecrets } from '../../services/teamMemorySync/teamMemSecretGuard.js'
+import {
+  activateConditionalSkillsForPaths,
+  addSkillDirectories,
+  discoverSkillDirsForPaths,
+} from '../../skills/loadSkillsDir.js'
+import type { ToolUseContext } from '../../Tool.js'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import { getCwd } from '../../utils/cwd.js'
+import { logForDebugging } from '../../utils/debug.js'
+import { countLinesChanged } from '../../utils/diff.js'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+import { isENOENT } from '../../utils/errors.js'
+import {
+  FILE_NOT_FOUND_CWD_NOTE,
+  findSimilarFile,
+  getFileModificationTime,
+  suggestPathUnderCwd,
+  writeTextContent,
+} from '../../utils/file.js'
+import {
+  fileHistoryEnabled,
+  fileHistoryTrackEdit,
+} from '../../utils/fileHistory.js'
+import { logFileOperation } from '../../utils/fileOperationAnalytics.js'
+import {
+  type LineEndingType,
+  readFileSyncWithMetadata,
+} from '../../utils/fileRead.js'
+import { formatFileSize } from '../../utils/format.js'
+import { getFsImplementation } from '../../utils/fsOperations.js'
+import {
+  fetchSingleFileGitDiff,
+  type ToolUseDiff,
+} from '../../utils/gitDiff.js'
+import { logError } from '../../utils/log.js'
+import { expandPath } from '../../utils/path.js'
+import {
+  checkWritePermissionForTool,
+  matchingRuleForInput,
+} from '../../utils/permissions/filesystem.js'
+import type { PermissionDecision } from '../../utils/permissions/PermissionResult.js'
+import { matchWildcardPattern } from '../../utils/permissions/shellRuleMatching.js'
+import { validateInputForSettingsFileEdit } from '../../utils/settings/validateEditTool.js'
+import { NOTEBOOK_EDIT_TOOL_NAME } from '../NotebookEditTool/constants.js'
+import {
+  FILE_EDIT_TOOL_NAME,
+  FILE_UNEXPECTEDLY_MODIFIED_ERROR,
+} from './constants.js'
+import { getEditToolDescription } from './prompt.js'
+import {
+  type FileEditInput,
+  type FileEditOutput,
+  inputSchema,
+  outputSchema,
+} from './types.js'
+import {
+  getToolUseSummary,
+  renderToolResultMessage,
+  renderToolUseErrorMessage,
+  renderToolUseMessage,
+  renderToolUseRejectedMessage,
+  userFacingName,
+} from './UI.js'
+import {
+  areFileEditsInputsEquivalent,
+  findActualString,
+  getPatchForEdit,
+  preserveQuoteStyle,
+} from './utils.js'
+
+// V8/Bun string length limit is ~2^30 characters (~1 billion). For typical
+// ASCII/Latin-1 files, 1 byte on disk = 1 character, so 1 GiB in stat bytes
+// ≈ 1 billion characters ≈ the runtime string limit. Multi-byte UTF-8 files
+// can be larger on disk per character, but 1 GiB is a safe byte-level guard
+// that prevents OOM without being unnecessarily restrictive.
+const MAX_EDIT_FILE_SIZE = 1024 * 1024 * 1024 // 1 GiB (stat bytes)
+
+export const FileEditTool = buildTool({
+  name: FILE_EDIT_TOOL_NAME,
+  searchHint: 'modify file contents in place',
+  maxResultSizeChars: 100_000,
+  strict: true,
+  async description() {
+    return 'A tool for editing files'
+  },
+  async prompt() {
+    return getEditToolDescription()
+  },
+  userFacingName,
+  getToolUseSummary,
+  getActivityDescription(input) {
+    const summary = getToolUseSummary(input)
+    return summary ? `Editing ${summary}` : 'Editing file'
+  },
+  get inputSchema() {
+    return inputSchema()
+  },
+  get outputSchema() {
+    return outputSchema()
+  },
+  toAutoClassifierInput(input) {
+    return `${input.file_path}: ${input.new_string}`
+  },
+  getPath(input): string {
+    return input.file_path
+  },
+  backfillObservableInput(input) {
+    // hooks.mdx documents file_path as absolute; expand so hook allowlists
+    // can't be bypassed via ~ or relative paths.
+    if (typeof input.file_path === 'string') {
+      input.file_path = expandPath(input.file_path)
+    }
+  },
+  async preparePermissionMatcher({ file_path }) {
+    return pattern => matchWildcardPattern(pattern, file_path)
+  },
+  async checkPermissions(input, context): Promise<PermissionDecision> {
+    const appState = context.getAppState()
+    return checkWritePermissionForTool(
+      FileEditTool,
+      input,
+      appState.toolPermissionContext,
+    )
+  },
+  renderToolUseMessage,
+  renderToolResultMessage,
+  renderToolUseRejectedMessage,
+  renderToolUseErrorMessage,
+  async validateInput(input: FileEditInput, toolUseContext: ToolUseContext) {
+    const { file_path, old_string, new_string, replace_all = false } = input
+    // Use expandPath for consistent path normalization (especially on Windows
+    // where "/" vs "\" can cause readFileState lookup mismatches)
+    const fullFilePath = expandPath(file_path)
+
+    // Reject edits to team memory files that introduce secrets
+    const secretError = checkTeamMemSecrets(fullFilePath, new_string)
+    if (secretError) {
+      return { result: false, message: secretError, errorCode: 0 }
+    }
+    if (old_string === new_string) {
+      return {
+        result: false,
+        behavior: 'ask',
+        message:
+          'No changes to make: old_string and new_string are exactly the same.',
+        errorCode: 1,
+      }
+    }
+
+    // Check if path should be ignored based on permission settings
+    const appState = toolUseContext.getAppState()
+    const denyRule = matchingRuleForInput(
+      fullFilePath,
+      appState.toolPermissionContext,
+      'edit',
+      'deny',
+    )
+    if (denyRule !== null) {
+      return {
+        result: false,
+        behavior: 'ask',
+        message:
+          'File is in a directory that is denied by your permission settings.',
+        errorCode: 2,
+      }
+    }
+
+    // SECURITY: Skip filesystem operations for UNC paths to prevent NTLM credential leaks.
+    // On Windows, fs.existsSync() on UNC paths triggers SMB authentication which could
+    // leak credentials to malicious servers. Let the permission check handle UNC paths.
+    if (fullFilePath.startsWith('\\\\') || fullFilePath.startsWith('//')) {
+      return { result: true }
+    }
+
+    const fs = getFsImplementation()
+
+    // Prevent OOM on multi-GB files.
+    try {
+      const { size } = await fs.stat(fullFilePath)
+      if (size > MAX_EDIT_FILE_SIZE) {
+        return {
+          result: false,
+          behavior: 'ask',
+          message: `File is too large to edit (${formatFileSize(size)}). Maximum editable file size is ${formatFileSize(MAX_EDIT_FILE_SIZE)}.`,
+          errorCode: 10,
+        }
+      }
+    } catch (e) {
+      if (!isENOENT(e)) {
+        throw e
+      }
+    }
+
+    // Read the file as bytes first so we can detect encoding from the buffer
+    // instead of calling detectFileEncoding (which does its own sync readSync
+    // and would fail with a wasted ENOENT when the file doesn't exist).
+    let fileContent: string | null
+    try {
+      const fileBuffer = await fs.readFileBytes(fullFilePath)
+      const encoding: BufferEncoding =
+        fileBuffer.length >= 2 &&
+        fileBuffer[0] === 0xff &&
+        fileBuffer[1] === 0xfe
+          ? 'utf16le'
+          : 'utf8'
+      fileContent = fileBuffer.toString(encoding).replaceAll('\r\n', '\n')
+    } catch (e) {
+      if (isENOENT(e)) {
+        fileContent = null
+      } else {
+        throw e
+      }
+    }
+
+    // File doesn't exist
+    if (fileContent === null) {
+      // Empty old_string on nonexistent file means new file creation — valid
+      if (old_string === '') {
+        return { result: true }
+      }
+      // Try to find a similar file with a different extension
+      const similarFilename = findSimilarFile(fullFilePath)
+      const cwdSuggestion = await suggestPathUnderCwd(fullFilePath)
+      let message = `File does not exist. ${FILE_NOT_FOUND_CWD_NOTE} ${getCwd()}.`
+
+      if (cwdSuggestion) {
+        message += ` Did you mean ${cwdSuggestion}?`
+      } else if (similarFilename) {
+        message += ` Did you mean ${similarFilename}?`
+      }
+
+      return {
+        result: false,
+        behavior: 'ask',
+        message,
+        errorCode: 4,
+      }
+    }
+
+    // File exists with empty old_string — only valid if file is empty
+    if (old_string === '') {
+      // Only reject if the file has content (for file creation attempt)
+      if (fileContent.trim() !== '') {
+        return {
+          result: false,
+          behavior: 'ask',
+          message: 'Cannot create new file - file already exists.',
+          errorCode: 3,
+        }
+      }
+
+      // Empty file with empty old_string is valid - we're replacing empty with content
+      return {
+        result: true,
+      }
+    }
+
+    if (fullFilePath.endsWith('.ipynb')) {
+      return {
+        result: false,
+        behavior: 'ask',
+        message: `File is a Jupyter Notebook. Use the ${NOTEBOOK_EDIT_TOOL_NAME} to edit this file.`,
+        errorCode: 5,
+      }
+    }
+
+    const readTimestamp = toolUseContext.readFileState.get(fullFilePath)
+    if (!readTimestamp || readTimestamp.isPartialView) {
+      return {
+        result: false,
+        behavior: 'ask',
+        message:
+          'File has not been read yet. Read it first before writing to it.',
+        meta: {
+          isFilePathAbsolute: String(isAbsolute(file_path)),
+        },
+        errorCode: 6,
+      }
+    }
+
+    // Check if file exists and get its last modified time
+    if (readTimestamp) {
+      const lastWriteTime = getFileModificationTime(fullFilePath)
+      if (lastWriteTime > readTimestamp.timestamp) {
+        // Timestamp indicates modification, but on Windows timestamps can change
+        // without content changes (cloud sync, antivirus, etc.). For full reads,
+        // compare content as a fallback to avoid false positives.
+        const isFullRead =
+          readTimestamp.offset === undefined &&
+          readTimestamp.limit === undefined
+        if (isFullRead && fileContent === readTimestamp.content) {
+          // Content unchanged, safe to proceed
+        } else {
+          return {
+            result: false,
+            behavior: 'ask',
+            message:
+              'File has been modified since read, either by the user or by a linter. Read it again before attempting to write it.',
+            errorCode: 7,
+          }
+        }
+      }
+    }
+
+    const file = fileContent
+
+    // Use findActualString to handle quote normalization
+    const actualOldString = findActualString(file, old_string)
+    if (!actualOldString) {
+      return {
+        result: false,
+        behavior: 'ask',
+        message: `String to replace not found in file.\nString: ${old_string}`,
+        meta: {
+          isFilePathAbsolute: String(isAbsolute(file_path)),
+        },
+        errorCode: 8,
+      }
+    }
+
+    const matches = file.split(actualOldString).length - 1
+
+    // Check if we have multiple matches but replace_all is false
+    if (matches > 1 && !replace_all) {
+      return {
+        result: false,
+        behavior: 'ask',
+        message: `Found ${matches} matches of the string to replace, but replace_all is false. To replace all occurrences, set replace_all to true. To replace only one occurrence, please provide more context to uniquely identify the instance.\nString: ${old_string}`,
+        meta: {
+          isFilePathAbsolute: String(isAbsolute(file_path)),
+          actualOldString,
+        },
+        errorCode: 9,
+      }
+    }
+
+    // Additional validation for Claude settings files
+    const settingsValidationResult = validateInputForSettingsFileEdit(
+      fullFilePath,
+      file,
+      () => {
+        // Simulate the edit to get the final content using the exact same logic as the tool
+        return replace_all
+          ? file.replaceAll(actualOldString, new_string)
+          : file.replace(actualOldString, new_string)
+      },
+    )
+
+    if (settingsValidationResult !== null) {
+      return settingsValidationResult
+    }
+
+    return { result: true, meta: { actualOldString } }
+  },
+  inputsEquivalent(input1, input2) {
+    return areFileEditsInputsEquivalent(
+      {
+        file_path: input1.file_path,
+        edits: [
+          {
+            old_string: input1.old_string,
+            new_string: input1.new_string,
+            replace_all: input1.replace_all ?? false,
+          },
+        ],
+      },
+      {
+        file_path: input2.file_path,
+        edits: [
+          {
+            old_string: input2.old_string,
+            new_string: input2.new_string,
+            replace_all: input2.replace_all ?? false,
+          },
+        ],
+      },
+    )
+  },
+  async call(
+    input: FileEditInput,
+    {
+      readFileState,
+      userModified,
+      updateFileHistoryState,
+      dynamicSkillDirTriggers,
+    },
+    _,
+    parentMessage,
+  ) {
+    const { file_path, old_string, new_string, replace_all = false } = input
+
+    // 1. Get current state
+    const fs = getFsImplementation()
+    const absoluteFilePath = expandPath(file_path)
+
+    // Discover skills from this file's path (fire-and-forget, non-blocking)
+    // Skip in simple mode - no skills available
+    const cwd = getCwd()
+    if (!isEnvTruthy(process.env.CLAUDE_CODE_SIMPLE)) {
+      const newSkillDirs = await discoverSkillDirsForPaths(
+        [absoluteFilePath],
+        cwd,
+      )
+      if (newSkillDirs.length > 0) {
+        // Store discovered dirs for attachment display
+        for (const dir of newSkillDirs) {
+          dynamicSkillDirTriggers?.add(dir)
+        }
+        // Don't await - let skill loading happen in the background
+        addSkillDirectories(newSkillDirs).catch(() => {})
+      }
+
+      // Activate conditional skills whose path patterns match this file
+      activateConditionalSkillsForPaths([absoluteFilePath], cwd)
+    }
+
+    await diagnosticTracker.beforeFileEdited(absoluteFilePath)
+
+    // Ensure parent directory exists before the atomic read-modify-write section.
+    // These awaits must stay OUTSIDE the critical section below — a yield between
+    // the staleness check and writeTextContent lets concurrent edits interleave.
+    await fs.mkdir(dirname(absoluteFilePath))
+    if (fileHistoryEnabled()) {
+      // Backup captures pre-edit content — safe to call before the staleness
+      // check (idempotent v1 backup keyed on content hash; if staleness fails
+      // later we just have an unused backup, not corrupt state).
+      await fileHistoryTrackEdit(
+        updateFileHistoryState,
+        absoluteFilePath,
+        parentMessage.uuid,
+      )
+    }
+
+    // 2. Load current state and confirm no changes since last read
+    // Please avoid async operations between here and writing to disk to preserve atomicity
+    const {
+      content: originalFileContents,
+      fileExists,
+      encoding,
+      lineEndings: endings,
+    } = readFileForEdit(absoluteFilePath)
+
+    if (fileExists) {
+      const lastWriteTime = getFileModificationTime(absoluteFilePath)
+      const lastRead = readFileState.get(absoluteFilePath)
+      if (!lastRead || lastWriteTime > lastRead.timestamp) {
+        // Timestamp indicates modification, but on Windows timestamps can change
+        // without content changes (cloud sync, antivirus, etc.). For full reads,
+        // compare content as a fallback to avoid false positives.
+        const isFullRead =
+          lastRead &&
+          lastRead.offset === undefined &&
+          lastRead.limit === undefined
+        const contentUnchanged =
+          isFullRead && originalFileContents === lastRead.content
+        if (!contentUnchanged) {
+          throw new Error(FILE_UNEXPECTEDLY_MODIFIED_ERROR)
+        }
+      }
+    }
+
+    // 3. Use findActualString to handle quote normalization
+    const actualOldString =
+      findActualString(originalFileContents, old_string) || old_string
+
+    // Preserve curly quotes in new_string when the file uses them
+    const actualNewString = preserveQuoteStyle(
+      old_string,
+      actualOldString,
+      new_string,
+    )
+
+    // 4. Generate patch
+    const { patch, updatedFile } = getPatchForEdit({
+      filePath: absoluteFilePath,
+      fileContents: originalFileContents,
+      oldString: actualOldString,
+      newString: actualNewString,
+      replaceAll: replace_all,
+    })
+
+    // 5. Write to disk
+    writeTextContent(absoluteFilePath, updatedFile, encoding, endings)
+
+    // Notify LSP servers about file modification (didChange) and save (didSave)
+    const lspManager = getLspServerManager()
+    if (lspManager) {
+      // Clear previously delivered diagnostics so new ones will be shown
+      clearDeliveredDiagnosticsForFile(`file://${absoluteFilePath}`)
+      // didChange: Content has been modified
+      lspManager
+        .changeFile(absoluteFilePath, updatedFile)
+        .catch((err: Error) => {
+          logForDebugging(
+            `LSP: Failed to notify server of file change for ${absoluteFilePath}: ${err.message}`,
+          )
+          logError(err)
+        })
+      // didSave: File has been saved to disk (triggers diagnostics in TypeScript server)
+      lspManager.saveFile(absoluteFilePath).catch((err: Error) => {
+        logForDebugging(
+          `LSP: Failed to notify server of file save for ${absoluteFilePath}: ${err.message}`,
+        )
+        logError(err)
+      })
+    }
+
+    // Notify VSCode about the file change for diff view
+    notifyVscodeFileUpdated(absoluteFilePath, originalFileContents, updatedFile)
+
+    // 6. Update read timestamp, to invalidate stale writes
+    readFileState.set(absoluteFilePath, {
+      content: updatedFile,
+      timestamp: getFileModificationTime(absoluteFilePath),
+      offset: undefined,
+      limit: undefined,
+    })
+
+    // 7. Log events
+    if (absoluteFilePath.endsWith(`${sep}CLAUDE.md`)) {
+      logEvent('tengu_write_claudemd', {})
+    }
+    countLinesChanged(patch)
+
+    logFileOperation({
+      operation: 'edit',
+      tool: 'FileEditTool',
+      filePath: absoluteFilePath,
+    })
+
+    logEvent('tengu_edit_string_lengths', {
+      oldStringBytes: Buffer.byteLength(old_string, 'utf8'),
+      newStringBytes: Buffer.byteLength(new_string, 'utf8'),
+      replaceAll: replace_all,
+    })
+
+    let gitDiff: ToolUseDiff | undefined
+    if (
+      isEnvTruthy(process.env.CLAUDE_CODE_REMOTE) &&
+      getFeatureValue_CACHED_MAY_BE_STALE('tengu_quartz_lantern', false)
+    ) {
+      const startTime = Date.now()
+      const diff = await fetchSingleFileGitDiff(absoluteFilePath)
+      if (diff) gitDiff = diff
+      logEvent('tengu_tool_use_diff_computed', {
+        isEditTool: true,
+        durationMs: Date.now() - startTime,
+        hasDiff: !!diff,
+      })
+    }
+
+    // 8. Yield result
+    const data = {
+      filePath: file_path,
+      oldString: actualOldString,
+      newString: new_string,
+      originalFile: originalFileContents,
+      structuredPatch: patch,
+      userModified: userModified ?? false,
+      replaceAll: replace_all,
+      ...(gitDiff && { gitDiff }),
+    }
+    return {
+      data,
+    }
+  },
+  mapToolResultToToolResultBlockParam(data: FileEditOutput, toolUseID) {
+    const { filePath, userModified, replaceAll } = data
+    const modifiedNote = userModified
+      ? '.  The user modified your proposed changes before accepting them. '
+      : ''
+
+    if (replaceAll) {
+      return {
+        tool_use_id: toolUseID,
+        type: 'tool_result',
+        content: `The file ${filePath} has been updated${modifiedNote}. All occurrences were successfully replaced.`,
+      }
+    }
+
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: `The file ${filePath} has been updated successfully${modifiedNote}.`,
+    }
+  },
+} satisfies ToolDef<ReturnType<typeof inputSchema>, FileEditOutput>)
+
+// --
+
+function readFileForEdit(absoluteFilePath: string): {
+  content: string
+  fileExists: boolean
+  encoding: BufferEncoding
+  lineEndings: LineEndingType
+} {
+  try {
+    // eslint-disable-next-line custom-rules/no-sync-fs
+    const meta = readFileSyncWithMetadata(absoluteFilePath)
+    return {
+      content: meta.content,
+      fileExists: true,
+      encoding: meta.encoding,
+      lineEndings: meta.lineEndings,
+    }
+  } catch (e) {
+    if (isENOENT(e)) {
+      return {
+        content: '',
+        fileExists: false,
+        encoding: 'utf8',
+        lineEndings: 'LF',
+      }
+    }
+    throw e
+  }
+}