openAgent

1import { describe, expect } from "bun:test"
2import fs from "fs/promises"
3import path from "path"
4import { pathToFileURL } from "url"
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 { Global } from "@opencode-ai/core/global"
9import { Repository } from "@opencode-ai/core/repository"
10import { RepositoryCache } from "@opencode-ai/core/repository-cache"
11import { branch, git, gitRemote } from "./fixture/git"
12import { tmpdir } from "./fixture/tmpdir"
13import { testEffect } from "./lib/effect"
14 
15const it = testEffect(Layer.empty)
16 
17describe("RepositoryCache", () => {
18  it.live("replaces a stale cache directory before cloning", () =>
19    withRemote((fixture) =>
20      Effect.gen(function* () {
21        const localPath = Repository.cachePath(path.join(fixture.root, "repos"), fixture.reference)
22        yield* Effect.promise(async () => {
23          await fs.mkdir(localPath, { recursive: true })
24          await fs.writeFile(path.join(localPath, "stale.txt"), "stale")
25        })
26 
27        const result = yield* (yield* RepositoryCache.Service).ensure({ reference: fixture.reference })
28 
29        expect(result.status).toBe("cloned")
30        expect(yield* exists(path.join(localPath, "stale.txt"))).toBe(false)
31        expect(yield* read(path.join(localPath, "README.md"))).toBe("one\n")
32      }).pipe(Effect.provide(cacheLayer(fixture.root))),
33    ),
34  )
35 
36  it.live("serializes concurrent materialization for the same checkout", () =>
37    withRemote((fixture) =>
38      Effect.gen(function* () {
39        const cache = yield* RepositoryCache.Service
40        const results = yield* Effect.all(
41          [cache.ensure({ reference: fixture.reference }), cache.ensure({ reference: fixture.reference })],
42          { concurrency: "unbounded" },
43        )
44 
45        expect(results.map((result) => result.status).toSorted()).toEqual(["cached", "cloned"])
46        expect(results[0].localPath).toBe(results[1].localPath)
47      }).pipe(Effect.provide(cacheLayer(fixture.root))),
48    ),
49  )
50 
51  it.live("replaces an existing checkout whose origin does not match", () =>
52    withRemote((fixture) =>
53      Effect.gen(function* () {
54        const cache = yield* RepositoryCache.Service
55        const initial = yield* cache.ensure({ reference: fixture.reference })
56        yield* Effect.promise(async () => {
57          await git(initial.localPath, "config", "remote.origin.url", "https://github.com/other/repo.git")
58          await fs.writeFile(path.join(initial.localPath, "stale.txt"), "stale")
59        })
60 
61        const replaced = yield* cache.ensure({ reference: fixture.reference })
62 
63        expect(replaced.status).toBe("cloned")
64        expect(yield* exists(path.join(replaced.localPath, "stale.txt"))).toBe(false)
65      }).pipe(Effect.provide(cacheLayer(fixture.root))),
66    ),
67  )
68 
69  it.live("keeps branch checkouts isolated from branchless refreshes", () =>
70    withRemote((fixture) =>
71      Effect.gen(function* () {
72        yield* Effect.promise(() => branch(fixture.source, "feature", "two\n"))
73        const cache = yield* RepositoryCache.Service
74 
75        const featured = yield* cache.ensure({ reference: fixture.reference, branch: "feature" })
76        expect(featured.branch).toBe("feature")
77        expect(featured.localPath.endsWith("repo@feature")).toBe(true)
78        expect(yield* read(path.join(featured.localPath, "README.md"))).toBe("two\n")
79 
80        const refreshed = yield* cache.ensure({ reference: fixture.reference, refresh: true })
81        expect(refreshed.localPath).not.toBe(featured.localPath)
82        expect(yield* read(path.join(refreshed.localPath, "README.md"))).toBe("one\n")
83 
84        const cached = yield* cache.ensure({ reference: fixture.reference, branch: "feature" })
85        expect(cached.status).toBe("cached")
86        expect(yield* read(path.join(cached.localPath, "README.md"))).toBe("two\n")
87      }).pipe(Effect.provide(cacheLayer(fixture.root))),
88    ),
89  )
90 
91  it.live("does not mistake an enclosing repository for the cache checkout", () =>
92    withRemote((fixture) =>
93      Effect.gen(function* () {
94        yield* Effect.promise(() => git(fixture.root, "clone", fixture.remote, path.join(fixture.root, "repos")))
95 
96        const result = yield* (yield* RepositoryCache.Service).ensure({ reference: fixture.reference })
97 
98        expect(result.status).toBe("cloned")
99        expect(yield* read(path.join(result.localPath, "README.md"))).toBe("one\n")
100      }).pipe(Effect.provide(cacheLayer(fixture.root))),
101    ),
102  )
103 
104  it.live("returns typed validation and clone failures", () =>
105    withRemote((fixture) =>
106      Effect.gen(function* () {
107        const cache = yield* RepositoryCache.Service
108        const invalidRepository = yield* Effect.flip(RepositoryCache.parseRemote("not-a-repo"))
109        expect(invalidRepository).toBeInstanceOf(RepositoryCache.InvalidRepositoryError)
110 
111        const invalidBranch = yield* Effect.flip(cache.ensure({ reference: fixture.reference, branch: "../unsafe" }))
112        expect(invalidBranch).toBeInstanceOf(RepositoryCache.InvalidBranchError)
113 
114        const cloneFailure = yield* Effect.flip(
115          cache.ensure({
116            reference: { ...fixture.reference, remote: pathToFileURL(path.join(fixture.root, "missing.git")).href },
117          }),
118        )
119        expect(cloneFailure).toBeInstanceOf(RepositoryCache.CloneFailedError)
120      }).pipe(Effect.provide(cacheLayer(fixture.root))),
121    ),
122  )
123})
124 
125function cacheLayer(root: string) {
126  return AppNodeBuilder.build(RepositoryCache.node, [
127    [Global.node, Global.layerWith({ state: path.join(root, "state"), repos: path.join(root, "repos") })],
128  ])
129}
130 
131function withRemote<A, E, R>(body: (fixture: Awaited<ReturnType<typeof gitRemote>>) => Effect.Effect<A, E, R>) {
132  return Effect.acquireUseRelease(
133    Effect.promise(async () => {
134      const root = await tmpdir()
135      return { root, fixture: await gitRemote(root.path) }
136    }),
137    (input) => body(input.fixture),
138    (input) => Effect.promise(() => input.root[Symbol.asyncDispose]()),
139  )
140}
141 
142function read(file: string) {
143  return Effect.promise(() => fs.readFile(file, "utf8")).pipe(Effect.map((content) => content.replace(/\r\n/g, "\n")))
144}
145 
146function exists(file: string) {
147  return Effect.promise(() =>
148    fs.stat(file).then(
149      () => true,
150      () => false,
151    ),
152  )
153}
154