openAgent

1import { describe, expect } from "bun:test"
2import { $ } from "bun"
3import fs from "fs/promises"
4import path from "path"
5import { Effect } from "effect"
6import { LayerNode } from "@opencode-ai/core/effect/layer-node"
7import { Git } from "@opencode-ai/core/git"
8import { AbsolutePath, RelativePath } from "@opencode-ai/core/schema"
9import { branch, commit, gitRemote } from "./fixture/git"
10import { tmpdir } from "./fixture/tmpdir"
11import { testEffect } from "./lib/effect"
12 
13const it = testEffect(LayerNode.compile(Git.node))
14 
15describe("Git", () => {
16  it.live("clones a remote and reads checkout metadata", () =>
17    withRemote((fixture) =>
18      Effect.gen(function* () {
19        const git = yield* Git.Service
20        const target = AbsolutePath.make(path.join(fixture.root, "checkout"))
21        const repository = yield* git.repo.clone({ remote: fixture.remote, directory: target })
22 
23        expect(yield* git.remote.get(repository)).toBe(fixture.remote)
24        expect(yield* git.history.head(repository)).toBeString()
25        expect(yield* git.history.branch(repository)).toBe("main")
26        expect(yield* git.history.defaultRemoteBranch(repository)).toBe("main")
27        expect(repository.worktree).toBe(target)
28        expect(repository.gitDirectory).toBe(AbsolutePath.make(path.join(target, ".git")))
29        expect(repository.commonDirectory).toBe(repository.gitDirectory)
30        expect(yield* read(path.join(target, "README.md"))).toBe("one\n")
31      }),
32    ),
33  )
34 
35  it.live("fetches, checks out, and resets remote changes", () =>
36    withRemote((fixture) =>
37      Effect.gen(function* () {
38        const git = yield* Git.Service
39        const target = AbsolutePath.make(path.join(fixture.root, "checkout"))
40        const repository = yield* git.repo.clone({ remote: fixture.remote, directory: target })
41 
42        yield* Effect.promise(() => commit(fixture.source, "two\n", "second"))
43        yield* git.sync.fetchRemotes(repository)
44        yield* git.sync.resetHard(repository, "origin/main")
45        expect(yield* read(path.join(target, "README.md"))).toBe("two\n")
46 
47        yield* Effect.promise(() => branch(fixture.source, "feature/docs", "feature\n"))
48        yield* git.sync.fetchBranch(repository, { branch: "feature/docs" })
49        yield* git.sync.checkoutRemoteBranch(repository, { branch: "feature/docs" })
50        yield* git.sync.resetHard(repository, "origin/feature/docs")
51        expect(yield* git.history.branch(repository)).toBe("feature/docs")
52        expect(yield* read(path.join(target, "README.md"))).toBe("feature\n")
53      }),
54    ),
55  )
56})
57 
58function withRemote<A, E, R>(body: (fixture: Awaited<ReturnType<typeof gitRemote>>) => Effect.Effect<A, E, R>) {
59  return Effect.acquireUseRelease(
60    Effect.promise(async () => {
61      const root = await tmpdir()
62      return { root, fixture: await gitRemote(root.path) }
63    }),
64    (input) => body(input.fixture),
65    (input) => Effect.promise(() => input.root[Symbol.asyncDispose]()),
66  )
67}
68 
69function read(file: string) {
70  return Effect.promise(() => fs.readFile(file, "utf8")).pipe(Effect.map((content) => content.replace(/\r\n/g, "\n")))
71}
72 
73async function initRepo(directory: string) {
74  await $`git init`.cwd(directory).quiet()
75  await $`git config core.fsmonitor false`.cwd(directory).quiet()
76  await $`git config commit.gpgsign false`.cwd(directory).quiet()
77  await $`git config user.email test@opencode.test`.cwd(directory).quiet()
78  await $`git config user.name Test`.cwd(directory).quiet()
79  await $`git commit --allow-empty -m root`.cwd(directory).quiet()
80}
81 
82describe("Git worktrees", () => {
83  it.live("creates, lists, and removes linked worktrees", () =>
84    Effect.gen(function* () {
85      const root = yield* Effect.acquireRelease(
86        Effect.promise(() => tmpdir()),
87        (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
88      )
89      yield* Effect.promise(() => initRepo(root.path))
90      const directory = AbsolutePath.make(yield* Effect.promise(() => fs.realpath(root.path)))
91      const worktree = AbsolutePath.make(`${root.path}-git-worktree`)
92      yield* Effect.addFinalizer(() =>
93        Effect.promise(() => fs.rm(worktree, { recursive: true, force: true })).pipe(Effect.ignore),
94      )
95      const git = yield* Git.Service
96      const repo = yield* git.repo.discover(directory)
97      if (!repo) throw new Error("Repository not found")
98 
99      yield* git.worktree.create({ repository: repo, directory: worktree })
100 
101      expect((yield* git.worktree.list(repo)).some((entry) => entry.directory.endsWith("-git-worktree"))).toBe(true)
102      const linked = yield* git.repo.discover(worktree)
103      expect(linked?.worktree).toBe(AbsolutePath.make(yield* Effect.promise(() => fs.realpath(worktree))))
104      expect(linked?.commonDirectory).toBe(repo.commonDirectory)
105      expect(linked?.gitDirectory).not.toBe(repo.gitDirectory)
106      if (!linked) throw new Error("Linked worktree not found")
107      yield* git.worktree.remove({ repository: linked, directory: worktree, force: false })
108      expect((yield* git.worktree.list(repo)).some((entry) => entry.directory.endsWith("-git-worktree"))).toBe(false)
109    }),
110  )
111})
112 
113describe("Git trees", () => {
114  it.live("captures, compares, previews, and restores scoped trees", () =>
115    Effect.gen(function* () {
116      const root = yield* Effect.acquireRelease(
117        Effect.promise(() => tmpdir()),
118        (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
119      )
120      yield* Effect.promise(async () => {
121        await initRepo(root.path)
122        await fs.mkdir(path.join(root.path, "scope"))
123        await fs.writeFile(path.join(root.path, "scope", "tracked.txt"), "one\n")
124        await fs.writeFile(path.join(root.path, "outside.txt"), "outside\n")
125        await $`git add .`.cwd(root.path).quiet()
126        await $`git commit -m initial`.cwd(root.path).quiet()
127      })
128      const git = yield* Git.Service
129      const source = yield* git.repo.discover(AbsolutePath.make(root.path))
130      if (!source) throw new Error("Repository not found")
131      const storage = AbsolutePath.make(path.join(root.path, ".snapshot"))
132      const repository = yield* git.repo.create({ worktree: source.worktree, gitDirectory: storage, seed: source })
133      yield* git.index.refresh({ repository, scope: RelativePath.make("scope") })
134      const before = yield* git.tree.write(repository)
135 
136      yield* Effect.promise(async () => {
137        await fs.writeFile(path.join(root.path, "scope", "tracked.txt"), "two\n")
138        await fs.writeFile(path.join(root.path, "scope", "added.txt"), "added\n")
139        await fs.writeFile(path.join(root.path, "outside.txt"), "changed outside\n")
140      })
141      yield* git.index.refresh({ repository, scope: RelativePath.make("scope") })
142      const after = yield* git.tree.write(repository)
143 
144      expect(yield* git.tree.files({ repository, from: before, to: after })).toEqual([
145        RelativePath.make("scope/added.txt"),
146        RelativePath.make("scope/tracked.txt"),
147      ])
148      const diffs = yield* git.tree.diff({ repository, from: before, to: after, context: 1 })
149      expect(diffs.map((item) => [item.path, item.status])).toEqual([
150        [RelativePath.make("scope/added.txt"), "added"],
151        [RelativePath.make("scope/tracked.txt"), "modified"],
152      ])
153 
154      const files = new Map([[RelativePath.make("scope/tracked.txt"), before]])
155      const preview = yield* git.tree.preview({ repository, current: after, files, context: 1 })
156      expect(preview).toHaveLength(1)
157      expect(preview[0]?.path).toBe(RelativePath.make("scope/tracked.txt"))
158      yield* git.tree.restore({ repository, files })
159      expect(yield* read(path.join(root.path, "scope", "tracked.txt"))).toBe("one\n")
160      expect(yield* read(path.join(root.path, "scope", "added.txt"))).toBe("added\n")
161      expect(yield* read(path.join(root.path, "outside.txt"))).toBe("changed outside\n")
162    }),
163  )
164})
165