openAgent

1import { describe, expect } from "bun:test"
2import { $ } from "bun"
3import fs from "fs/promises"
4import path from "path"
5import { Effect, Schema } from "effect"
6import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
7import { ProjectV2 } from "@opencode-ai/core/project"
8import { AbsolutePath } from "@opencode-ai/core/schema"
9import { Hash } from "@opencode-ai/core/util/hash"
10import { tmpdir } from "./fixture/tmpdir"
11import { testEffect } from "./lib/effect"
12 
13const it = testEffect(AppNodeBuilder.build(ProjectV2.node))
14 
15function remoteID(remote: string) {
16  return ProjectV2.ID.make(Hash.fast(`git-remote:${remote}`))
17}
18 
19function abs(value: string) {
20  return AbsolutePath.make(value)
21}
22 
23function real(value: string) {
24  return Effect.promise(() => fs.realpath(value)).pipe(Effect.map((value) => AbsolutePath.make(value)))
25}
26 
27async function initRepo(dir: string, opts?: { commit?: boolean; remote?: string }) {
28  await $`git init`.cwd(dir).quiet()
29  await $`git config core.fsmonitor false`.cwd(dir).quiet()
30  await $`git config commit.gpgsign false`.cwd(dir).quiet()
31  await $`git config user.email test@opencode.test`.cwd(dir).quiet()
32  await $`git config user.name Test`.cwd(dir).quiet()
33  if (opts?.commit) await $`git commit --allow-empty -m root`.cwd(dir).quiet()
34  if (opts?.remote) await $`git remote add origin ${opts.remote}`.cwd(dir).quiet()
35}
36 
37async function rootCommit(dir: string) {
38  return (await $`git rev-list --max-parents=0 HEAD`.cwd(dir).text()).trim()
39}
40 
41describe("ProjectV2.resolve", () => {
42  it.live("returns global for non-git directory", () =>
43    Effect.gen(function* () {
44      const tmp = yield* Effect.acquireRelease(
45        Effect.promise(() => tmpdir()),
46        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
47      )
48      const project = yield* ProjectV2.Service
49 
50      const result = yield* project.resolve(abs(tmp.path))
51 
52      expect(result.id).toBe(ProjectV2.ID.make("global"))
53      expect(path.resolve(result.directory)).toBe(path.parse(tmp.path).root)
54      expect(result.previous).toBeUndefined()
55      expect(result.vcs).toBeUndefined()
56    }),
57  )
58 
59  it.live("returns git global for repo with no commits and no remote", () =>
60    Effect.gen(function* () {
61      const tmp = yield* Effect.acquireRelease(
62        Effect.promise(() => tmpdir()),
63        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
64      )
65      yield* Effect.promise(() => initRepo(tmp.path))
66      const project = yield* ProjectV2.Service
67 
68      const result = yield* project.resolve(abs(tmp.path))
69 
70      expect(result.id).toBe(ProjectV2.ID.make("global"))
71      expect(result.directory).toBe(yield* real(tmp.path))
72      expect(result.previous).toBeUndefined()
73      expect(result.vcs?.type).toBe("git")
74    }),
75  )
76 
77  it.live("falls back to root commit when origin is missing", () =>
78    Effect.gen(function* () {
79      const tmp = yield* Effect.acquireRelease(
80        Effect.promise(() => tmpdir()),
81        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
82      )
83      yield* Effect.promise(() => initRepo(tmp.path, { commit: true }))
84      const project = yield* ProjectV2.Service
85 
86      const result = yield* project.resolve(abs(tmp.path))
87 
88      expect(result.id).toBe(ProjectV2.ID.make(yield* Effect.promise(() => rootCommit(tmp.path))))
89      expect(result.directory).toBe(yield* real(tmp.path))
90      expect(result.previous).toBeUndefined()
91      expect(result.vcs?.type).toBe("git")
92    }),
93  )
94 
95  it.live("prefers normalized origin over root commit", () =>
96    Effect.gen(function* () {
97      const tmp = yield* Effect.acquireRelease(
98        Effect.promise(() => tmpdir()),
99        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
100      )
101      yield* Effect.promise(() => initRepo(tmp.path, { commit: true, remote: "git@github.com:Acme/App.git" }))
102      const project = yield* ProjectV2.Service
103 
104      const result = yield* project.resolve(abs(tmp.path))
105 
106      expect(result.id).toBe(remoteID("github.com/Acme/App"))
107      expect(result.id).not.toBe(ProjectV2.ID.make(yield* Effect.promise(() => rootCommit(tmp.path))))
108      expect(result.directory).toBe(yield* real(tmp.path))
109      expect(result.vcs?.type).toBe("git")
110    }),
111  )
112 
113  it.live("normalizes ssh and https remotes to the same id", () =>
114    Effect.gen(function* () {
115      const ssh = yield* Effect.acquireRelease(
116        Effect.promise(() => tmpdir()),
117        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
118      )
119      const https = yield* Effect.acquireRelease(
120        Effect.promise(() => tmpdir()),
121        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
122      )
123      yield* Effect.promise(() => initRepo(ssh.path, { commit: true, remote: "git@github.com:owner/repo.git" }))
124      yield* Effect.promise(() => initRepo(https.path, { commit: true, remote: "https://github.com/owner/repo.git" }))
125      const project = yield* ProjectV2.Service
126 
127      const a = yield* project.resolve(abs(ssh.path))
128      const b = yield* project.resolve(abs(https.path))
129 
130      expect(a.id).toBe(remoteID("github.com/owner/repo"))
131      expect(b.id).toBe(a.id)
132    }),
133  )
134 
135  it.live("ignores file remotes and falls back to root commit", () =>
136    Effect.gen(function* () {
137      const tmp = yield* Effect.acquireRelease(
138        Effect.promise(() => tmpdir()),
139        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
140      )
141      yield* Effect.promise(() => initRepo(tmp.path, { commit: true, remote: `file://${tmp.path}` }))
142      const project = yield* ProjectV2.Service
143 
144      const result = yield* project.resolve(abs(tmp.path))
145 
146      expect(result.id).toBe(ProjectV2.ID.make(yield* Effect.promise(() => rootCommit(tmp.path))))
147    }),
148  )
149 
150  it.live("returns previous cached id from common dir", () =>
151    Effect.gen(function* () {
152      const tmp = yield* Effect.acquireRelease(
153        Effect.promise(() => tmpdir()),
154        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
155      )
156      yield* Effect.promise(() => initRepo(tmp.path, { commit: true, remote: "git@github.com:owner/repo.git" }))
157      yield* Effect.promise(() => Bun.write(path.join(tmp.path, ".git", "opencode"), "old-id"))
158      const project = yield* ProjectV2.Service
159 
160      const result = yield* project.resolve(abs(tmp.path))
161 
162      expect(result.previous).toBe(ProjectV2.ID.make("old-id"))
163      expect(result.id).toBe(remoteID("github.com/owner/repo"))
164    }),
165  )
166 
167  it.live("does not write the cache while resolving", () =>
168    Effect.gen(function* () {
169      const tmp = yield* Effect.acquireRelease(
170        Effect.promise(() => tmpdir()),
171        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
172      )
173      yield* Effect.promise(() => initRepo(tmp.path, { commit: true, remote: "git@github.com:owner/repo.git" }))
174      const project = yield* ProjectV2.Service
175 
176      yield* project.resolve(abs(tmp.path))
177 
178      expect(yield* Effect.promise(() => Bun.file(path.join(tmp.path, ".git", "opencode")).exists())).toBe(false)
179    }),
180  )
181 
182  it.live("resolves from nested directories to repo root", () =>
183    Effect.gen(function* () {
184      const tmp = yield* Effect.acquireRelease(
185        Effect.promise(() => tmpdir()),
186        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
187      )
188      yield* Effect.promise(() => initRepo(tmp.path, { commit: true }))
189      yield* Effect.promise(() => fs.mkdir(path.join(tmp.path, "a", "b"), { recursive: true }))
190      const project = yield* ProjectV2.Service
191 
192      const result = yield* project.resolve(abs(path.join(tmp.path, "a", "b")))
193 
194      expect(result.directory).toBe(yield* real(tmp.path))
195    }),
196  )
197 
198  it.live("linked worktree returns opened worktree directory and previous from common dir", () =>
199    Effect.gen(function* () {
200      const tmp = yield* Effect.acquireRelease(
201        Effect.promise(() => tmpdir()),
202        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
203      )
204      const worktree = `${tmp.path}-worktree`
205      yield* Effect.addFinalizer(() =>
206        Effect.promise(() => $`rm -rf ${worktree}`.quiet().nothrow()).pipe(Effect.ignore),
207      )
208      yield* Effect.promise(() => initRepo(tmp.path, { commit: true, remote: "git@github.com:owner/repo.git" }))
209      yield* Effect.promise(() => Bun.write(path.join(tmp.path, ".git", "opencode"), "old-id"))
210      yield* Effect.promise(() => $`git worktree add ${worktree} -b test-${Date.now()}`.cwd(tmp.path).quiet())
211      const project = yield* ProjectV2.Service
212 
213      const result = yield* project.resolve(abs(worktree))
214 
215      expect(result.directory).toBe(yield* real(worktree))
216      expect(result.previous).toBe(ProjectV2.ID.make("old-id"))
217      expect(result.id).toBe(remoteID("github.com/owner/repo"))
218      expect(result.vcs?.type).toBe("git")
219    }),
220  )
221})
222