openAgent

1import fs from "fs/promises"
2import path from "path"
3import { fileURLToPath } from "url"
4import { describe, expect, test } from "bun:test"
5import { Effect, Layer } from "effect"
6import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
7import { LayerNode } from "@opencode-ai/core/effect/layer-node"
8import { FileMutation } from "@opencode-ai/core/file-mutation"
9import { FSUtil } from "@opencode-ai/core/fs-util"
10import { Location } from "@opencode-ai/core/location"
11import { LocationMutation } from "@opencode-ai/core/location-mutation"
12import { PermissionV2 } from "@opencode-ai/core/permission"
13import { AbsolutePath } from "@opencode-ai/core/schema"
14import { SessionV2 } from "@opencode-ai/core/session"
15import { ToolRegistry } from "@opencode-ai/core/tool/registry"
16import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
17import { EditTool } from "@opencode-ai/core/tool/edit"
18import { location } from "./fixture/location"
19import { tmpdir } from "./fixture/tmpdir"
20import { testEffect } from "./lib/effect"
21import { toolIdentity, executeTool, settleTool, toolDefinitions } from "./lib/tool"
22 
23const sessionID = SessionV2.ID.make("ses_edit_tool_test")
24const assertions: PermissionV2.AssertInput[] = []
25const writes: string[] = []
26let reads = 0
27let denyAction: string | undefined
28let afterRead = (_target: string, _content: Uint8Array): Effect.Effect<void> => Effect.void
29 
30const permission = Layer.succeed(
31  PermissionV2.Service,
32  PermissionV2.Service.of({
33    assert: (input) =>
34      Effect.sync(() => assertions.push(input)).pipe(
35        Effect.andThen(
36          input.action === denyAction ? Effect.fail(new PermissionV2.BlockedError({ rules: [] })) : Effect.void,
37        ),
38      ),
39    ask: () => Effect.die("unused"),
40    reply: () => Effect.die("unused"),
41    get: () => Effect.die("unused"),
42    forSession: () => Effect.die("unused"),
43    list: () => Effect.die("unused"),
44  }),
45)
46 
47const reset = () => {
48  assertions.length = 0
49  writes.length = 0
50  reads = 0
51  denyAction = undefined
52  afterRead = () => Effect.void
53}
54 
55const filesystem = Layer.effect(
56  FSUtil.Service,
57  Effect.gen(function* () {
58    const fs = yield* FSUtil.Service
59    return FSUtil.Service.of({
60      ...fs,
61      readFile: (target) =>
62        fs
63          .readFile(target)
64          .pipe(
65            Effect.tap((content) =>
66              Effect.sync(() => reads++).pipe(Effect.andThen(Effect.suspend(() => afterRead(target, content)))),
67            ),
68          ),
69      writeWithDirs: (target, content, mode) =>
70        Effect.sync(() => writes.push(target)).pipe(Effect.andThen(fs.writeWithDirs(target, content, mode))),
71      writeFile: (target, content, options) =>
72        Effect.sync(() => writes.push(target)).pipe(Effect.andThen(fs.writeFile(target, content, options))),
73      writeFileString: (target, content, options) =>
74        Effect.sync(() => writes.push(target)).pipe(Effect.andThen(fs.writeFileString(target, content, options))),
75    })
76  }),
77).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
78 
79const withTool = <A, E, R>(directory: string, body: (registry: ToolRegistry.Interface) => Effect.Effect<A, E, R>) => {
80  const activeLocation = Layer.succeed(
81    Location.Service,
82    Location.Service.of(location({ directory: AbsolutePath.make(directory) })),
83  )
84  return Effect.gen(function* () {
85    return yield* body(yield* ToolRegistry.Service)
86  }).pipe(
87    Effect.provide(
88      AppNodeBuilder.build(
89        LayerNode.group([
90          ToolRegistry.node,
91          ToolRegistry.toolsNode,
92          LocationMutation.node,
93          FileMutation.node,
94          EditTool.node,
95        ]),
96        [
97          [FSUtil.node, filesystem],
98          [Location.node, activeLocation],
99          [PermissionV2.node, permission],
100          [ToolOutputStore.node, ToolOutputStore.nodeWithoutConfig],
101        ],
102      ),
103    ),
104  )
105}
106 
107const call = (input: typeof EditTool.Input.Type, id = "call-edit") => ({
108  sessionID,
109  ...toolIdentity,
110  call: { type: "tool-call" as const, id, name: "edit", input },
111})
112 
113const it = testEffect(Layer.empty)
114 
115describe("EditTool", () => {
116  it.live("registers and replaces relative exact text through FileMutation once", () =>
117    Effect.acquireUseRelease(
118      Effect.promise(() => tmpdir()),
119      (tmp) => {
120        reset()
121        const target = path.join(tmp.path, "hello.txt")
122        return Effect.promise(() => fs.writeFile(target, "before\nrest\n")).pipe(
123          Effect.andThen(
124            withTool(tmp.path, (registry) =>
125              Effect.gen(function* () {
126                expect((yield* toolDefinitions(registry)).map((tool) => tool.name)).toEqual(["edit"])
127                expect(yield* toolDefinitions(registry, [{ action: "edit", resource: "*", effect: "deny" }])).toEqual(
128                  [],
129                )
130                const settled = yield* settleTool(
131                  registry,
132                  call({ path: "hello.txt", oldString: "before", newString: "after" }),
133                )
134                expect(settled.result).toEqual({
135                  type: "text",
136                  value: "Edited file successfully: hello.txt\nReplacements: 1\n```diff\n-before\n+after\n```",
137                })
138                expect(settled.output?.structured).toEqual({
139                  replacements: 1,
140                  files: [
141                    {
142                      file: "hello.txt",
143                      status: "modified",
144                      additions: 1,
145                      deletions: 1,
146                      patch: expect.stringContaining("-before\n+after"),
147                    },
148                  ],
149                })
150                expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("after\nrest\n")
151                expect(assertions).toMatchObject([{ sessionID, action: "edit", resources: ["hello.txt"], save: ["*"] }])
152                expect(writes).toEqual([yield* Effect.promise(() => fs.realpath(target))])
153              }),
154            ),
155          ),
156        )
157      },
158      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
159    ),
160  )
161 
162  it.live("accepts an absolute file path inside the active Location", () =>
163    Effect.acquireUseRelease(
164      Effect.promise(() => tmpdir()),
165      (tmp) => {
166        reset()
167        const target = path.join(tmp.path, "absolute.txt")
168        return Effect.promise(() => fs.writeFile(target, "before")).pipe(
169          Effect.andThen(
170            withTool(tmp.path, (registry) =>
171              executeTool(registry, call({ path: target, oldString: "before", newString: "after" })),
172            ),
173          ),
174          Effect.andThen((result) =>
175            Effect.gen(function* () {
176              expect(result.type).toBe("text")
177              expect(assertions.map((input) => input.action)).toEqual(["edit"])
178              expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("after")
179            }),
180          ),
181        )
182      },
183      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
184    ),
185  )
186 
187  it.live("approves an explicit external absolute path before edit", () =>
188    Effect.acquireUseRelease(
189      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
190      ([active, outside]) => {
191        reset()
192        const target = path.join(outside.path, "external.txt")
193        return Effect.promise(() => fs.writeFile(target, "before")).pipe(
194          Effect.andThen(
195            withTool(active.path, (registry) =>
196              executeTool(registry, call({ path: target, oldString: "before", newString: "after" })),
197            ),
198          ),
199          Effect.andThen((result) =>
200            Effect.gen(function* () {
201              expect(result.type).toBe("text")
202              expect(assertions.map((input) => input.action)).toEqual(["external_directory", "edit"])
203              expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("after")
204              expect(writes).toHaveLength(1)
205            }),
206          ),
207        )
208      },
209      ([active, outside]) =>
210        Effect.promise(() =>
211          Promise.all([active[Symbol.asyncDispose](), outside[Symbol.asyncDispose]()]).then(() => undefined),
212        ),
213    ),
214  )
215 
216  it.live("does not write when external_directory or edit approval is denied", () =>
217    Effect.acquireUseRelease(
218      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
219      ([active, outside]) =>
220        Effect.gen(function* () {
221          const external = path.join(outside.path, "denied.txt")
222          yield* Effect.promise(() => fs.writeFile(external, "before"))
223          reset()
224          denyAction = "external_directory"
225          expect(
226            yield* withTool(active.path, (registry) =>
227              executeTool(registry, call({ path: external, oldString: "before", newString: "after" })),
228            ),
229          ).toEqual({
230            type: "error",
231            value: `Unable to edit ${external}`,
232          })
233          expect(assertions.map((input) => input.action)).toEqual(["external_directory"])
234          expect(reads).toBe(0)
235          expect(writes).toEqual([])
236 
237          reset()
238          denyAction = "edit"
239          expect(
240            yield* withTool(active.path, (registry) =>
241              executeTool(registry, call({ path: external, oldString: "before", newString: "after" })),
242            ),
243          ).toEqual({
244            type: "error",
245            value: `Unable to edit ${external}`,
246          })
247          expect(assertions.map((input) => input.action)).toEqual(["external_directory", "edit"])
248          expect(reads).toBe(0)
249          expect(writes).toEqual([])
250          expect(yield* Effect.promise(() => fs.readFile(external, "utf8"))).toBe("before")
251        }),
252      ([active, outside]) =>
253        Effect.promise(() =>
254          Promise.all([active[Symbol.asyncDispose](), outside[Symbol.asyncDispose]()]).then(() => undefined),
255        ),
256    ),
257  )
258 
259  it.live("denied edit reads no target content and does not disclose whether oldString matches", () =>
260    Effect.acquireUseRelease(
261      Effect.promise(() => tmpdir()),
262      (tmp) => {
263        reset()
264        denyAction = "edit"
265        const target = path.join(tmp.path, "secret.txt")
266        return Effect.promise(() => fs.writeFile(target, "secret content")).pipe(
267          Effect.andThen(
268            withTool(tmp.path, (registry) =>
269              Effect.gen(function* () {
270                const matching = yield* executeTool(
271                  registry,
272                  call({ path: "secret.txt", oldString: "secret content", newString: "replacement" }),
273                )
274                const missing = yield* executeTool(
275                  registry,
276                  call({ path: "secret.txt", oldString: "not present", newString: "replacement" }),
277                )
278 
279                expect(matching).toEqual({ type: "error", value: "Unable to edit secret.txt" })
280                expect(missing).toEqual(matching)
281                expect(assertions.map((input) => input.action)).toEqual(["edit", "edit"])
282                expect(reads).toBe(0)
283                expect(writes).toEqual([])
284              }),
285            ),
286          ),
287        )
288      },
289      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
290    ),
291  )
292 
293  it.live("rejects no-op, empty, missing, and ambiguous exact replacements", () =>
294    Effect.acquireUseRelease(
295      Effect.promise(() => tmpdir()),
296      (tmp) => {
297        reset()
298        const target = path.join(tmp.path, "matches.txt")
299        return Effect.promise(() => fs.writeFile(target, "same same")).pipe(
300          Effect.andThen(
301            withTool(tmp.path, (registry) =>
302              Effect.gen(function* () {
303                expect(
304                  yield* executeTool(registry, call({ path: "matches.txt", oldString: "same", newString: "same" })),
305                ).toEqual({
306                  type: "error",
307                  value: "No changes to apply: oldString and newString are identical.",
308                })
309                expect(
310                  yield* executeTool(registry, call({ path: "matches.txt", oldString: "", newString: "after" })),
311                ).toEqual({
312                  type: "error",
313                  value: "oldString must not be empty. Use write to create or overwrite a file.",
314                })
315                expect(
316                  yield* executeTool(registry, call({ path: "matches.txt", oldString: "missing", newString: "after" })),
317                ).toEqual({
318                  type: "error",
319                  value:
320                    "Could not find oldString in the file. It must match exactly, including whitespace and indentation.",
321                })
322                expect(
323                  yield* executeTool(registry, call({ path: "matches.txt", oldString: "same", newString: "after" })),
324                ).toEqual({
325                  type: "error",
326                  value:
327                    "Found multiple exact matches for oldString. Provide more surrounding context or set replaceAll to true.",
328                })
329                expect(writes).toEqual([])
330              }),
331            ),
332          ),
333        )
334      },
335      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
336    ),
337  )
338 
339  it.live("replaces every exact occurrence when replaceAll is true", () =>
340    Effect.acquireUseRelease(
341      Effect.promise(() => tmpdir()),
342      (tmp) => {
343        reset()
344        const target = path.join(tmp.path, "all.txt")
345        return Effect.promise(() => fs.writeFile(target, "same same same")).pipe(
346          Effect.andThen(
347            withTool(tmp.path, (registry) =>
348              settleTool(registry, call({ path: "all.txt", oldString: "same", newString: "after", replaceAll: true })),
349            ),
350          ),
351          Effect.andThen((settled) =>
352            Effect.gen(function* () {
353              expect(settled.output?.structured).toMatchObject({ replacements: 3 })
354              expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("after after after")
355              expect(writes).toHaveLength(1)
356            }),
357          ),
358        )
359      },
360      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
361    ),
362  )
363 
364  it.live("preserves BOM and CRLF line endings", () =>
365    Effect.acquireUseRelease(
366      Effect.promise(() => tmpdir()),
367      (tmp) => {
368        reset()
369        const target = path.join(tmp.path, "windows.txt")
370        return Effect.promise(() => fs.writeFile(target, "\uFEFFbefore\r\nrest\r\n")).pipe(
371          Effect.andThen(
372            withTool(tmp.path, (registry) =>
373              executeTool(registry, call({ path: "windows.txt", oldString: "before\nrest", newString: "after\nrest" })),
374            ),
375          ),
376          Effect.andThen(() => Effect.promise(() => fs.readFile(target, "utf8"))),
377          Effect.tap((content) => Effect.sync(() => expect(content).toBe("\uFEFFafter\r\nrest\r\n"))),
378        )
379      },
380      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
381    ),
382  )
383 
384  it.live("rejects an in-place content change after matching but before conditional commit", () =>
385    Effect.acquireUseRelease(
386      Effect.promise(() => tmpdir()),
387      (tmp) => {
388        reset()
389        const target = path.join(tmp.path, "concurrent.txt")
390        afterRead = () => (reads === 1 ? Effect.promise(() => fs.writeFile(target, "newer\n")) : Effect.void)
391        return Effect.promise(() => fs.writeFile(target, "before\n")).pipe(
392          Effect.andThen(
393            withTool(tmp.path, (registry) =>
394              executeTool(registry, call({ path: "concurrent.txt", oldString: "before", newString: "after" })),
395            ),
396          ),
397          Effect.andThen((result) =>
398            Effect.gen(function* () {
399              expect(result).toEqual({
400                type: "error",
401                value: "File changed after permission approval. Read it again before editing.",
402              })
403              expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("newer\n")
404              expect(writes).toEqual([])
405            }),
406          ),
407        )
408      },
409      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
410    ),
411  )
412})
413 
414test("keeps the locked edit schema, semantics docstring, and deferred TODOs visible", async () => {
415  const source = (await fs.readFile(new URL("../src/tool/edit.ts", import.meta.url), "utf8")).replaceAll("\r\n", "\n")
416  const definition = await Effect.runPromise(
417    withTool(path.dirname(fileURLToPath(import.meta.url)), (registry) => toolDefinitions(registry)),
418  )
419  const schema = definition[0]?.inputSchema as { readonly properties?: Record<string, unknown> }
420 
421  expect(Object.keys(schema.properties ?? {}).sort()).toEqual(["newString", "oldString", "path", "replaceAll"])
422  expect(source).toContain(
423    "absolute external paths retain mutation capability through a separate\n * external_directory approval before edit approval.",
424  )
425  for (const todo of [
426    "Port V1 fuzzy correction strategies only after exact-edit behavior is established: line-trimmed matching, block-anchor fallback, indentation correction, and similarity-threshold review.",
427    "Add formatter integration after V2 formatter runtime exists.",
428    "Publish watcher/file-edit events after V2 watcher integration exists.",
429    "Add snapshots / undo after design exists.",
430    "Add LSP notification and diagnostics after V2 LSP runtime exists.",
431  ]) {
432    expect(source).toContain(`TODO: ${todo}`)
433  }
434})
435