From d68031bc0d92e7c1bfb7a4ad1e7fa234b1cac756 Mon Sep 17 00:00:00 2001 From: Kit Langton Date: Wed, 26 Aug 2026 20:42:40 -0400 Subject: [PATCH] fix(core): preserve renamed files when undoing changes (#45383) --- .changeset/rename-undo.md | 5 + packages/core/src/git.ts | 2 + packages/core/test/git.test.ts | 31 ++++++ packages/core/test/session-revert.test.ts | 117 ++++++++++++++++++++++ 4 files changed, 155 insertions(+) create mode 100644 .changeset/rename-undo.md create mode 100644 packages/core/test/session-revert.test.ts diff --git a/.changeset/rename-undo.md b/.changeset/rename-undo.md new file mode 100644 index 00000000000..b88b7584f94 --- /dev/null +++ b/.changeset/rename-undo.md @@ -0,0 +1,5 @@ +--- +"@opencode-ai/core": patch +--- + +Include both paths of renamed files in new snapshot change lists so undo restores the original file instead of only deleting the renamed file. diff --git a/packages/core/src/git.ts b/packages/core/src/git.ts index 40950bfc6f3..7388045840d 100644 --- a/packages/core/src/git.ts +++ b/packages/core/src/git.ts @@ -507,9 +507,11 @@ const layer = Layer.effect( from: TreeID to: TreeID }) { + // Undo needs both paths of a rename, not only its destination. return (yield* repositoryOperation("list_files", input.repository, [ "diff", "--name-only", + "--no-renames", "-z", input.from, input.to, diff --git a/packages/core/test/git.test.ts b/packages/core/test/git.test.ts index 26aface5730..b930e614048 100644 --- a/packages/core/test/git.test.ts +++ b/packages/core/test/git.test.ts @@ -131,6 +131,37 @@ describe("Git worktrees", () => { }) describe("Git trees", () => { + it.live("lists both sides of a rename as separate file changes", () => + Effect.gen(function* () { + const root = yield* Effect.acquireRelease( + Effect.promise(() => tmpdir()), + (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()), + ) + yield* Effect.promise(async () => { + await initRepo(root.path) + await $`git config diff.renames true`.cwd(root.path).quiet() + await Bun.write(path.join(root.path, "old name.txt"), "Preserve this content.\n") + }) + const git = yield* Git.Service + const repository = yield* git.repo.discover(AbsolutePath.make(root.path)) + if (!repository) throw new Error("Repository not found") + const before = yield* git.tree.capture({ repository, scopes: [RelativePath.make(".")] }) + yield* Effect.promise(() => fs.rename(path.join(root.path, "old name.txt"), path.join(root.path, "new name.txt"))) + const after = yield* git.tree.capture({ repository, scopes: [RelativePath.make(".")] }) + + expect(yield* git.tree.files({ repository, from: before, to: after })).toEqual([ + RelativePath.make("new name.txt"), + RelativePath.make("old name.txt"), + ]) + expect( + (yield* git.tree.diff({ repository, from: before, to: after })).map((file) => [file.file, file.status]), + ).toEqual([ + ["new name.txt", "added"], + ["old name.txt", "deleted"], + ]) + }), + ) + it.live("captures, compares, previews, and restores scoped trees", () => Effect.gen(function* () { const root = yield* Effect.acquireRelease( diff --git a/packages/core/test/session-revert.test.ts b/packages/core/test/session-revert.test.ts new file mode 100644 index 00000000000..2a166e34d93 --- /dev/null +++ b/packages/core/test/session-revert.test.ts @@ -0,0 +1,117 @@ +import { $ } from "bun" +import { describe, expect } from "bun:test" +import fs from "fs/promises" +import path from "path" +import { Effect } from "effect" +import { Agent } from "@opencode-ai/core/agent" +import { Bus } from "@opencode-ai/core/bus" +import { Database } from "@opencode-ai/core/database/database" +import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder" +import { LocationServiceMap } from "@opencode-ai/core/location-service-map" +import { Model } from "@opencode-ai/core/model" +import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor" +import { Provider } from "@opencode-ai/core/provider" +import { AbsolutePath } from "@opencode-ai/core/schema" +import { Session } from "@opencode-ai/core/session" +import { SessionEvent } from "@opencode-ai/core/session/event" +import { SessionExecution } from "@opencode-ai/core/session/execution" +import { SessionInbox } from "@opencode-ai/core/session/inbox" +import { SessionMessage } from "@opencode-ai/core/session/message" +import { SessionProjector } from "@opencode-ai/core/session/projector" +import { Snapshot } from "@opencode-ai/core/snapshot" +import { Money } from "@opencode-ai/schema/money" +import { LayerNode } from "@opencode-ai/util/effect/layer-node" +import { Global } from "@opencode-ai/util/global" +import { tempGlobalLayer } from "./fixture/global" +import { tmpdir } from "./fixture/tmpdir" +import { testEffect } from "./lib/effect" + +const it = testEffect( + AppNodeBuilder.build( + LayerNode.group([Database.node, Bus.node, SessionProjector.node, Session.node, LocationServiceMap.node]), + [ + [Bus.node, Bus.configured({ persist: true })], + [Global.node, tempGlobalLayer], + [SessionExecution.node, SessionExecution.noopLayer], + ], + ), +) + +describe("Session.revert files", () => { + it.live("undoes and restores a file rename without losing either path", () => + Effect.gen(function* () { + const tmp = yield* Effect.acquireRelease( + Effect.promise(() => tmpdir()), + (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()), + ) + const directory = path.join(tmp.path, "project") + const original = path.join(directory, "old name.txt") + const renamed = path.join(directory, "new name.txt") + yield* Effect.promise(async () => { + await fs.mkdir(directory) + await Bun.write(original, "Preserve this content.\n") + await Bun.write(path.join(directory, "unrelated.txt"), "Unrelated content.\n") + await $`git init -q`.cwd(directory).quiet() + await $`git -c core.fsmonitor=false add .`.cwd(directory).quiet() + }) + + const session = yield* Session.Service + const database = yield* Database.Service + const bus = yield* Bus.Service + const created = yield* session.create({ location: { directory: AbsolutePath.make(directory) } }) + const prompt = yield* session.prompt({ sessionID: created.id, text: "Rename the file", resume: false }) + yield* SessionInbox.promote(database.db, bus, created.id, "steer") + + yield* Effect.gen(function* () { + const plugins = yield* PluginSupervisor.Service + yield* plugins.flush + const snapshot = yield* Snapshot.Service + const before = yield* snapshot.capture() + if (!before) throw new Error("Initial snapshot missing") + const assistantMessageID = SessionMessage.ID.create() + yield* bus.publish(SessionEvent.Step.Started, { + sessionID: created.id, + assistantMessageID, + agent: Agent.defaultID, + model: { id: Model.ID.make("test-model"), providerID: Provider.ID.make("test-provider") }, + snapshot: before, + }) + yield* Effect.promise(() => fs.rename(original, renamed)) + const after = yield* snapshot.capture() + if (!after) throw new Error("Renamed snapshot missing") + yield* bus.publish(SessionEvent.Step.Ended, { + sessionID: created.id, + assistantMessageID, + finish: "stop", + cost: Money.USD.zero, + tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, + snapshot: after, + files: yield* snapshot.files({ from: before, to: after }), + }) + + yield* Effect.promise(() => Bun.write(path.join(directory, "unrelated.txt"), "Keep this later edit.\n")) + const reverted = yield* session.revert.stage({ sessionID: created.id, messageID: prompt.id }) + expect({ + original: yield* Effect.promise(() => Bun.file(original).exists()), + renamed: yield* Effect.promise(() => Bun.file(renamed).exists()), + }).toEqual({ original: true, renamed: false }) + expect(yield* Effect.promise(() => Bun.file(original).text())).toBe("Preserve this content.\n") + expect(reverted.files?.map((file) => [file.file, file.status])).toEqual([ + ["new name.txt", "deleted"], + ["old name.txt", "added"], + ]) + expect(yield* Effect.promise(() => Bun.file(path.join(directory, "unrelated.txt")).text())).toBe( + "Keep this later edit.\n", + ) + + yield* session.revert.clear(created.id) + expect(yield* Effect.promise(() => Bun.file(original).exists())).toBe(false) + expect(yield* Effect.promise(() => Bun.file(renamed).text())).toBe("Preserve this content.\n") + expect(yield* Effect.promise(() => Bun.file(path.join(directory, "unrelated.txt")).text())).toBe( + "Keep this later edit.\n", + ) + expect((yield* session.get(created.id)).revert).toBeUndefined() + }).pipe(Effect.provide(LocationServiceMap.Service.get(created.location))) + }), + ) +})