223 lines
9.4 KiB
TypeScript
223 lines
9.4 KiB
TypeScript
/**
|
|
* Model-facing V2 exact-edit leaf. Relative paths resolve within the active
|
|
* Location. Absolute paths inside that Location are accepted, while explicit
|
|
* absolute external paths retain mutation capability through a separate
|
|
* external_directory approval before edit approval.
|
|
*/
|
|
export * as EditTool from "./edit"
|
|
|
|
import { ToolFailure } from "@opencode-ai/llm"
|
|
import { FileDiff } from "@opencode-ai/schema/file-diff"
|
|
import { createTwoFilesPatch, diffLines } from "diff"
|
|
import { Effect, Layer, Schema } from "effect"
|
|
import { makeLocationNode } from "../effect/app-node"
|
|
import { FileMutation } from "../file-mutation"
|
|
import { FSUtil } from "../fs-util"
|
|
import { LocationMutation } from "../location-mutation"
|
|
import { PermissionV2 } from "../permission"
|
|
import { ToolRegistry } from "./registry"
|
|
import { Tool } from "./tool"
|
|
import { Tools } from "./tools"
|
|
|
|
export const name = "edit"
|
|
|
|
export const Input = Schema.Struct({
|
|
path: Schema.String.annotate({
|
|
description:
|
|
"File path to edit. Relative paths resolve within the active Location. Absolute paths inside that Location are accepted; external absolute paths require external_directory approval.",
|
|
}),
|
|
oldString: Schema.String.annotate({ description: "Exact text to replace" }),
|
|
newString: Schema.String.annotate({ description: "Replacement text, which must differ from oldString" }),
|
|
replaceAll: Schema.Boolean.pipe(Schema.optional).annotate({
|
|
description: "Replace all exact occurrences of oldString (default false)",
|
|
}),
|
|
})
|
|
|
|
export const Output = Schema.Struct({
|
|
files: Schema.Array(FileDiff.Info),
|
|
replacements: Schema.Number,
|
|
})
|
|
export type Output = typeof Output.Type
|
|
|
|
const normalizeLineEndings = (text: string) => text.replaceAll("\r\n", "\n")
|
|
const detectLineEnding = (text: string): "\n" | "\r\n" => (text.includes("\r\n") ? "\r\n" : "\n")
|
|
const convertToLineEnding = (text: string, ending: "\n" | "\r\n") =>
|
|
ending === "\n" ? normalizeLineEndings(text) : normalizeLineEndings(text).replaceAll("\n", "\r\n")
|
|
|
|
const splitBom = (text: string) =>
|
|
text.startsWith("\uFEFF") ? { bom: true, text: text.slice(1) } : { bom: false, text }
|
|
const joinBom = (text: string, bom: boolean) => (bom ? `\uFEFF${text}` : text)
|
|
const decodeUtf8 = (content: Uint8Array) => {
|
|
const bom = content[0] === 0xef && content[1] === 0xbb && content[2] === 0xbf
|
|
return { bom, content, text: new TextDecoder().decode(bom ? content.slice(3) : content) }
|
|
}
|
|
|
|
const countOccurrences = (content: string, search: string) => {
|
|
if (search === "") return content.length + 1
|
|
let count = 0
|
|
let offset = 0
|
|
while ((offset = content.indexOf(search, offset)) !== -1) {
|
|
count++
|
|
offset += search.length
|
|
}
|
|
return count
|
|
}
|
|
|
|
const previewLines = (value: string, prefix: "+" | "-") => {
|
|
const lines = normalizeLineEndings(value).split("\n")
|
|
const shown = lines.slice(0, 6).map((line) => `${prefix}${line.length > 240 ? `${line.slice(0, 240)}...` : line}`)
|
|
if (lines.length > shown.length) shown.push(`${prefix}...`)
|
|
return shown
|
|
}
|
|
|
|
export const toModelOutput = (output: Output, oldString: string, newString: string) =>
|
|
[
|
|
`Edited file successfully: ${output.files[0]?.file}`,
|
|
`Replacements: ${output.replacements}`,
|
|
"```diff",
|
|
...previewLines(oldString, "-"),
|
|
...previewLines(newString, "+"),
|
|
"```",
|
|
].join("\n")
|
|
|
|
/** Deferred V2 edit behavior and UX integrations remain visible at the model-facing seam. */
|
|
// TODO: Port V1 fuzzy correction strategies only after exact-edit behavior is established: line-trimmed matching, block-anchor fallback, indentation correction, and similarity-threshold review.
|
|
// TODO: Add formatter integration after V2 formatter runtime exists.
|
|
// TODO: Publish watcher/file-edit events after V2 watcher integration exists.
|
|
// TODO: Add snapshots / undo after design exists.
|
|
// TODO: Add LSP notification and diagnostics after V2 LSP runtime exists.
|
|
|
|
const layer = Layer.effectDiscard(
|
|
Effect.gen(function* () {
|
|
const tools = yield* Tools.Service
|
|
const mutation = yield* LocationMutation.Service
|
|
const files = yield* FileMutation.Service
|
|
const fs = yield* FSUtil.Service
|
|
const permission = yield* PermissionV2.Service
|
|
|
|
yield* tools
|
|
.register({
|
|
[name]: Tool.withPermission(
|
|
Tool.make({
|
|
description:
|
|
"Replace exact text in one file. Relative paths resolve within the active Location. Absolute paths inside the Location are accepted. Explicit external absolute paths require external_directory approval before edit approval.",
|
|
input: Input,
|
|
output: Output,
|
|
toModelOutput: ({ input, output }) => [
|
|
{ type: "text", text: toModelOutput(output, input.oldString, input.newString) },
|
|
],
|
|
execute: (input, context) => {
|
|
const unableToEdit = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
|
|
effect.pipe(
|
|
Effect.mapError((error) =>
|
|
error instanceof FileMutation.StaleContentError
|
|
? new ToolFailure({
|
|
message: "File changed after permission approval. Read it again before editing.",
|
|
})
|
|
: new ToolFailure({ message: `Unable to edit ${input.path}` }),
|
|
),
|
|
)
|
|
|
|
return Effect.gen(function* () {
|
|
const permissionSource = {
|
|
type: "tool" as const,
|
|
messageID: context.assistantMessageID,
|
|
callID: context.toolCallID,
|
|
}
|
|
if (input.oldString === input.newString) {
|
|
return yield* new ToolFailure({
|
|
message: "No changes to apply: oldString and newString are identical.",
|
|
})
|
|
}
|
|
if (input.oldString === "") {
|
|
return yield* new ToolFailure({
|
|
message: "oldString must not be empty. Use write to create or overwrite a file.",
|
|
})
|
|
}
|
|
|
|
const target = yield* unableToEdit(mutation.resolve({ path: input.path, kind: "file" }))
|
|
const external = target.externalDirectory
|
|
if (external) {
|
|
yield* unableToEdit(
|
|
permission.assert({
|
|
...LocationMutation.externalDirectoryPermission(external),
|
|
sessionID: context.sessionID,
|
|
agent: context.agent,
|
|
source: permissionSource,
|
|
}),
|
|
)
|
|
}
|
|
|
|
yield* unableToEdit(
|
|
permission.assert({
|
|
action: "edit",
|
|
resources: [target.resource],
|
|
save: ["*"],
|
|
sessionID: context.sessionID,
|
|
agent: context.agent,
|
|
source: permissionSource,
|
|
}),
|
|
)
|
|
const source = decodeUtf8(yield* unableToEdit(fs.readFile(target.canonical)))
|
|
const ending = detectLineEnding(source.text)
|
|
const oldString = convertToLineEnding(input.oldString, ending)
|
|
const newString = convertToLineEnding(input.newString, ending)
|
|
const replacements = countOccurrences(source.text, oldString)
|
|
if (replacements === 0) {
|
|
return yield* new ToolFailure({
|
|
message:
|
|
"Could not find oldString in the file. It must match exactly, including whitespace and indentation.",
|
|
})
|
|
}
|
|
if (replacements > 1 && input.replaceAll !== true) {
|
|
return yield* new ToolFailure({
|
|
message:
|
|
"Found multiple exact matches for oldString. Provide more surrounding context or set replaceAll to true.",
|
|
})
|
|
}
|
|
|
|
const replaced =
|
|
input.replaceAll === true
|
|
? source.text.replaceAll(oldString, newString)
|
|
: source.text.replace(oldString, newString)
|
|
const counts = diffLines(source.text, replaced).reduce(
|
|
(result, item) => ({
|
|
additions: result.additions + (item.added ? (item.count ?? 0) : 0),
|
|
deletions: result.deletions + (item.removed ? (item.count ?? 0) : 0),
|
|
}),
|
|
{ additions: 0, deletions: 0 },
|
|
)
|
|
const next = splitBom(replaced)
|
|
const result = yield* unableToEdit(
|
|
files.writeIfUnchanged({
|
|
target,
|
|
expected: source.content,
|
|
content: joinBom(next.text, source.bom || next.bom),
|
|
}),
|
|
)
|
|
return {
|
|
files: [
|
|
{
|
|
file: result.resource,
|
|
patch: createTwoFilesPatch(result.resource, result.resource, source.text, replaced),
|
|
status: "modified" as const,
|
|
...counts,
|
|
},
|
|
],
|
|
replacements,
|
|
} satisfies Output
|
|
})
|
|
},
|
|
}),
|
|
"edit",
|
|
),
|
|
})
|
|
.pipe(Effect.orDie)
|
|
}),
|
|
)
|
|
|
|
export const node = makeLocationNode({
|
|
name: "tool/edit",
|
|
layer,
|
|
deps: [ToolRegistry.node, LocationMutation.node, FileMutation.node, FSUtil.node, PermissionV2.node],
|
|
})
|