openAgent

1import { NodeFileSystem } from "@effect/platform-node"
2import { describe, expect } from "bun:test"
3import { LayerNode } from "@opencode-ai/core/effect/layer-node"
4import { Effect, Layer } from "effect"
5import { provideTmpdirInstance, testInstanceStoreLayer, TestInstance } from "../fixture/fixture"
6import { testEffect } from "../lib/effect"
7import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
8import { Format } from "../../src/format"
9import * as Formatter from "../../src/format/formatter"
10 
11const it = testEffect(
12  Layer.mergeAll(LayerNode.compile(LayerNode.group([Format.node, CrossSpawnSpawner.node])), NodeFileSystem.layer),
13)
14 
15describe("Format", () => {
16  it.instance("status() returns empty list when no formatters are configured", () =>
17    Format.Service.use((fmt) =>
18      Effect.gen(function* () {
19        expect(yield* fmt.status()).toEqual([])
20      }),
21    ),
22  )
23 
24  it.instance(
25    "status() returns built-in formatters when formatter is true",
26    () =>
27      Format.Service.use((fmt) =>
28        Effect.gen(function* () {
29          const statuses = yield* fmt.status()
30          const gofmt = statuses.find((item) => item.name === "gofmt")
31          expect(gofmt).toBeDefined()
32          expect(gofmt!.extensions).toContain(".go")
33        }),
34      ),
35    { config: { formatter: true } },
36  )
37 
38  it.instance(
39    "status() keeps built-in formatters when config object is provided",
40    () =>
41      Format.Service.use((fmt) =>
42        Effect.gen(function* () {
43          const statuses = yield* fmt.status()
44          const gofmt = statuses.find((item) => item.name === "gofmt")
45          const mix = statuses.find((item) => item.name === "mix")
46          expect(gofmt).toBeDefined()
47          expect(gofmt!.extensions).toContain(".go")
48          expect(mix).toBeDefined()
49        }),
50      ),
51    { config: { formatter: { gofmt: {} } } },
52  )
53 
54  it.instance(
55    "status() excludes formatters marked as disabled in config",
56    () =>
57      Format.Service.use((fmt) =>
58        Effect.gen(function* () {
59          const statuses = yield* fmt.status()
60          const gofmt = statuses.find((item) => item.name === "gofmt")
61          const mix = statuses.find((item) => item.name === "mix")
62          expect(gofmt).toBeUndefined()
63          expect(mix).toBeDefined()
64        }),
65      ),
66    { config: { formatter: { gofmt: { disabled: true } } } },
67  )
68 
69  it.instance(
70    "status() excludes uv when ruff is disabled",
71    () =>
72      Format.Service.use((fmt) =>
73        Effect.gen(function* () {
74          const statuses = yield* fmt.status()
75          expect(statuses.find((item) => item.name === "ruff")).toBeUndefined()
76          expect(statuses.find((item) => item.name === "uv")).toBeUndefined()
77        }),
78      ),
79    { config: { formatter: { ruff: { disabled: true } } } },
80  )
81 
82  it.instance(
83    "status() excludes ruff when uv is disabled",
84    () =>
85      Format.Service.use((fmt) =>
86        Effect.gen(function* () {
87          const statuses = yield* fmt.status()
88          expect(statuses.find((item) => item.name === "ruff")).toBeUndefined()
89          expect(statuses.find((item) => item.name === "uv")).toBeUndefined()
90        }),
91      ),
92    { config: { formatter: { uv: { disabled: true } } } },
93  )
94 
95  it.instance("service initializes without error", () => Format.Service.use(() => Effect.void))
96 
97  it.instance(
98    "file() returns false when no formatter runs",
99    () =>
100      Effect.gen(function* () {
101        const test = yield* TestInstance
102        const file = `${test.directory}/test.txt`
103        yield* Effect.promise(() => Bun.write(file, "x"))
104 
105        const formatted = yield* Format.use.file(file)
106        expect(formatted).toBe(false)
107      }),
108    { config: { formatter: false } },
109  )
110 
111  testEffect(
112    Layer.mergeAll(
113      LayerNode.compile(LayerNode.group([Format.node, CrossSpawnSpawner.node])),
114      NodeFileSystem.layer,
115      testInstanceStoreLayer,
116    ),
117  ).live("status() initializes formatter state per directory", () =>
118    Effect.gen(function* () {
119      const a = yield* provideTmpdirInstance(() => Format.use.status(), {
120        config: { formatter: false },
121      })
122      const b = yield* provideTmpdirInstance(() => Format.use.status(), {
123        config: {
124          formatter: true,
125        },
126      })
127 
128      expect(a).toEqual([])
129      expect(b.find((item) => item.name === "gofmt")).toBeDefined()
130    }),
131  )
132 
133  it.instance(
134    "runs enabled checks for matching formatters in parallel",
135    () =>
136      Effect.gen(function* () {
137        const test = yield* TestInstance
138        const file = `${test.directory}/test.parallel`
139        yield* Effect.promise(() => Bun.write(file, "x"))
140 
141        const one = {
142          extensions: Formatter.gofmt.extensions,
143          enabled: Formatter.gofmt.enabled,
144        }
145        const two = {
146          extensions: Formatter.mix.extensions,
147          enabled: Formatter.mix.enabled,
148        }
149 
150        let active = 0
151        let max = 0
152 
153        yield* Effect.acquireUseRelease(
154          Effect.sync(() => {
155            Formatter.gofmt.extensions = [".parallel"]
156            Formatter.mix.extensions = [".parallel"]
157            Formatter.gofmt.enabled = async () => {
158              active++
159              max = Math.max(max, active)
160              await Promise.resolve()
161              active--
162              return ["sh", "-c", "true"]
163            }
164            Formatter.mix.enabled = async () => {
165              active++
166              max = Math.max(max, active)
167              await Promise.resolve()
168              active--
169              return ["sh", "-c", "true"]
170            }
171          }),
172          () =>
173            Format.Service.use((fmt) =>
174              Effect.gen(function* () {
175                yield* fmt.init()
176                yield* fmt.file(file)
177              }),
178            ),
179          () =>
180            Effect.sync(() => {
181              Formatter.gofmt.extensions = one.extensions
182              Formatter.gofmt.enabled = one.enabled
183              Formatter.mix.extensions = two.extensions
184              Formatter.mix.enabled = two.enabled
185            }),
186        )
187 
188        expect(max).toBe(2)
189      }),
190    { config: { formatter: { gofmt: {}, mix: {} } } },
191  )
192 
193  it.instance(
194    "runs matching formatters sequentially for the same file",
195    () =>
196      Effect.gen(function* () {
197        const test = yield* TestInstance
198        const file = `${test.directory}/test.seq`
199        yield* Effect.promise(() => Bun.write(file, "x"))
200 
201        yield* Format.Service.use((fmt) =>
202          Effect.gen(function* () {
203            yield* fmt.init()
204            expect(yield* fmt.file(file)).toBe(true)
205          }),
206        )
207 
208        expect(yield* Effect.promise(() => Bun.file(file).text())).toBe("xAB")
209      }),
210    {
211      config: {
212        formatter: {
213          first: {
214            command: [
215              "node",
216              "-e",
217              "const fs = require('fs'); const file = process.argv[1]; fs.writeFileSync(file, fs.readFileSync(file, 'utf8') + 'A')",
218              "$FILE",
219            ],
220            extensions: [".seq"],
221          },
222          second: {
223            command: [
224              "node",
225              "-e",
226              "const fs = require('fs'); const file = process.argv[1]; fs.writeFileSync(file, fs.readFileSync(file, 'utf8') + 'B')",
227              "$FILE",
228            ],
229            extensions: [".seq"],
230          },
231        },
232      },
233    },
234  )
235})
236