chore: initialize recovered claude workspace
This commit is contained in:
625
src/tools/FileEditTool/FileEditTool.ts
Normal file
625
src/tools/FileEditTool/FileEditTool.ts
Normal file
@@ -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
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user