openAgent

1import { describe, expect, test } from "bun:test"
2import { SessionV1 } from "@opencode-ai/core/v1/session"
3import path from "path"
4import { Effect, FileSystem, Layer } from "effect"
5import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
6 
7import { Instruction } from "../../src/session/instruction"
8import type { MessageV2 } from "../../src/session/message-v2"
9import { MessageID, PartID, SessionID } from "../../src/session/schema"
10import { Global } from "@opencode-ai/core/global"
11import { RuntimeFlags } from "../../src/effect/runtime-flags"
12import { provideInstance, provideTmpdirInstance, tmpdirScoped } from "../fixture/fixture"
13import { testEffect } from "../lib/effect"
14import { TestConfig } from "../fixture/config"
15import { ProviderV2 } from "@opencode-ai/core/provider"
16import { ModelV2 } from "@opencode-ai/core/model"
17import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
18import { LayerNode } from "@opencode-ai/core/effect/layer-node"
19import { LayerNodePlatform } from "@opencode-ai/core/effect/app-node-platform"
20import { InstanceStore } from "@/project/instance-store"
21import { InstanceBootstrap } from "@/project/bootstrap"
22import { Config } from "@/config/config"
23 
24const it = testEffect(
25  AppNodeBuilder.build(LayerNode.group([CrossSpawnSpawner.node, LayerNodePlatform.filesystem, InstanceStore.node]), [
26    [
27      InstanceBootstrap.node,
28      Layer.succeed(InstanceBootstrap.Service, InstanceBootstrap.Service.of({ run: Effect.void })),
29    ],
30  ]),
31)
32 
33const configLayer = Layer.succeed(Config.Service, TestConfig.make())
34 
35const instructionLayer = (global: Partial<Global.Interface>, flags: Partial<RuntimeFlags.Info> = {}) =>
36  AppNodeBuilder.build(Instruction.node, [
37    [Config.node, configLayer],
38    [Global.node, Global.layerWith(global)],
39    [RuntimeFlags.node, RuntimeFlags.layer(flags)],
40  ])
41 
42const provideInstruction =
43  (global: Partial<Global.Interface>, flags?: Partial<RuntimeFlags.Info>) =>
44  <A, E, R>(self: Effect.Effect<A, E, R>) =>
45    self.pipe(Effect.provide(instructionLayer(global, flags)))
46 
47const write = (filepath: string, content: string) =>
48  Effect.gen(function* () {
49    const fs = yield* FileSystem.FileSystem
50    yield* fs.makeDirectory(path.dirname(filepath), { recursive: true })
51    yield* fs.writeFileString(filepath, content)
52  })
53 
54const writeFiles = (dir: string, files: Record<string, string>) =>
55  Effect.all(
56    Object.entries(files).map(([file, content]) => write(path.join(dir, file), content)),
57    { discard: true },
58  )
59 
60const withFiles = <A, E, R>(files: Record<string, string>, self: (dir: string) => Effect.Effect<A, E, R>) =>
61  provideTmpdirInstance((dir) =>
62    Effect.gen(function* () {
63      yield* writeFiles(dir, files)
64      return yield* self(dir).pipe(provideInstruction({ home: dir, config: dir }))
65    }),
66  )
67 
68const tmpWithFiles = (files: Record<string, string>) =>
69  Effect.gen(function* () {
70    const dir = yield* tmpdirScoped()
71    yield* writeFiles(dir, files)
72    return dir
73  })
74 
75function loaded(filepath: string): SessionV1.WithParts[] {
76  const sessionID = SessionID.make("session-loaded-1")
77  const messageID = MessageID.make("msg_message-loaded-1")
78 
79  return [
80    {
81      info: {
82        id: messageID,
83        sessionID,
84        role: "user",
85        time: { created: 0 },
86        agent: "build",
87        model: {
88          providerID: ProviderV2.ID.make("anthropic"),
89          modelID: ModelV2.ID.make("claude-sonnet-4-20250514"),
90        },
91      },
92      parts: [
93        {
94          id: PartID.make("prt_part-loaded-1"),
95          messageID,
96          sessionID,
97          type: "tool",
98          callID: "call-loaded-1",
99          tool: "read",
100          state: {
101            status: "completed",
102            input: {},
103            output: "done",
104            title: "Read",
105            metadata: { loaded: [filepath] },
106            time: { start: 0, end: 1 },
107          },
108        },
109      ],
110    },
111  ]
112}
113 
114describe("Instruction.resolve", () => {
115  it.live("returns empty when AGENTS.md is at project root (already in systemPaths)", () =>
116    withFiles({ "AGENTS.md": "# Root Instructions", "src/file.ts": "const x = 1" }, (dir) =>
117      Effect.gen(function* () {
118        const svc = yield* Instruction.Service
119        const system = yield* svc.systemPaths()
120        expect(system.has(path.join(dir, "AGENTS.md"))).toBe(true)
121 
122        const results = yield* svc.resolve([], path.join(dir, "src", "file.ts"), MessageID.make("msg_message-test-1"))
123        expect(results).toEqual([])
124      }),
125    ),
126  )
127 
128  it.live("returns AGENTS.md from subdirectory (not in systemPaths)", () =>
129    withFiles({ "subdir/AGENTS.md": "# Subdir Instructions", "subdir/nested/file.ts": "const x = 1" }, (dir) =>
130      Effect.gen(function* () {
131        const svc = yield* Instruction.Service
132        const system = yield* svc.systemPaths()
133        expect(system.has(path.join(dir, "subdir", "AGENTS.md"))).toBe(false)
134 
135        const results = yield* svc.resolve(
136          [],
137          path.join(dir, "subdir", "nested", "file.ts"),
138          MessageID.make("msg_message-test-2"),
139        )
140        expect(results.length).toBe(1)
141        expect(results[0].filepath).toBe(path.join(dir, "subdir", "AGENTS.md"))
142      }),
143    ),
144  )
145 
146  it.live("doesn't reload AGENTS.md when reading it directly", () =>
147    withFiles({ "subdir/AGENTS.md": "# Subdir Instructions", "subdir/nested/file.ts": "const x = 1" }, (dir) =>
148      Effect.gen(function* () {
149        const svc = yield* Instruction.Service
150        const filepath = path.join(dir, "subdir", "AGENTS.md")
151        const system = yield* svc.systemPaths()
152        expect(system.has(filepath)).toBe(false)
153 
154        const results = yield* svc.resolve([], filepath, MessageID.make("msg_message-test-3"))
155        expect(results).toEqual([])
156      }),
157    ),
158  )
159 
160  it.live("does not reattach the same nearby instructions twice for one message", () =>
161    withFiles({ "subdir/AGENTS.md": "# Subdir Instructions", "subdir/nested/file.ts": "const x = 1" }, (dir) =>
162      Effect.gen(function* () {
163        const svc = yield* Instruction.Service
164        const filepath = path.join(dir, "subdir", "nested", "file.ts")
165        const id = MessageID.make("msg_message-claim-1")
166 
167        const first = yield* svc.resolve([], filepath, id)
168        const second = yield* svc.resolve([], filepath, id)
169 
170        expect(first).toHaveLength(1)
171        expect(first[0].filepath).toBe(path.join(dir, "subdir", "AGENTS.md"))
172        expect(second).toEqual([])
173      }),
174    ),
175  )
176 
177  it.live("clear allows nearby instructions to be attached again for the same message", () =>
178    withFiles({ "subdir/AGENTS.md": "# Subdir Instructions", "subdir/nested/file.ts": "const x = 1" }, (dir) =>
179      Effect.gen(function* () {
180        const svc = yield* Instruction.Service
181        const filepath = path.join(dir, "subdir", "nested", "file.ts")
182        const id = MessageID.make("msg_message-claim-2")
183 
184        const first = yield* svc.resolve([], filepath, id)
185        yield* svc.clear(id)
186        const second = yield* svc.resolve([], filepath, id)
187 
188        expect(first).toHaveLength(1)
189        expect(second).toHaveLength(1)
190        expect(second[0].filepath).toBe(path.join(dir, "subdir", "AGENTS.md"))
191      }),
192    ),
193  )
194 
195  it.live("skips instructions already reported by prior read metadata", () =>
196    withFiles({ "subdir/AGENTS.md": "# Subdir Instructions", "subdir/nested/file.ts": "const x = 1" }, (dir) =>
197      Effect.gen(function* () {
198        const svc = yield* Instruction.Service
199        const agents = path.join(dir, "subdir", "AGENTS.md")
200        const filepath = path.join(dir, "subdir", "nested", "file.ts")
201        const id = MessageID.make("msg_message-claim-3")
202 
203        const results = yield* svc.resolve(loaded(agents), filepath, id)
204        expect(results).toEqual([])
205      }),
206    ),
207  )
208 
209  test.todo("fetches remote instructions from config URLs via HttpClient", () => {})
210})
211 
212describe("Instruction.system", () => {
213  it.live("loads both project and global AGENTS.md when both exist", () =>
214    Effect.gen(function* () {
215      const globalTmp = yield* tmpWithFiles({ "AGENTS.md": "# Global Instructions" })
216      const projectTmp = yield* tmpWithFiles({ "AGENTS.md": "# Project Instructions" })
217 
218      yield* Effect.gen(function* () {
219        const svc = yield* Instruction.Service
220        const paths = yield* svc.systemPaths()
221        expect(paths.has(path.join(projectTmp, "AGENTS.md"))).toBe(true)
222        expect(paths.has(path.join(globalTmp, "AGENTS.md"))).toBe(true)
223 
224        const rules = yield* svc.system()
225        expect(rules).toHaveLength(2)
226        expect(rules[0]).toBe(`Instructions from: ${path.join(globalTmp, "AGENTS.md")}\n# Global Instructions`)
227        expect(rules[1]).toBe(`Instructions from: ${path.join(projectTmp, "AGENTS.md")}\n# Project Instructions`)
228      }).pipe(provideInstance(projectTmp), provideInstruction({ home: globalTmp, config: globalTmp }))
229    }),
230  )
231 
232  it.live("skips project and global CLAUDE.md when Claude Code prompt is disabled", () =>
233    Effect.gen(function* () {
234      const globalTmp = yield* tmpWithFiles({ ".claude/CLAUDE.md": "# Global Claude" })
235      const projectTmp = yield* tmpWithFiles({ "CLAUDE.md": "# Project Claude" })
236 
237      yield* Effect.gen(function* () {
238        const svc = yield* Instruction.Service
239        const paths = yield* svc.systemPaths()
240        expect(paths.has(path.join(globalTmp, ".claude", "CLAUDE.md"))).toBe(false)
241        expect(paths.has(path.join(projectTmp, "CLAUDE.md"))).toBe(false)
242        expect(yield* svc.system()).toEqual([])
243      }).pipe(
244        provideInstance(projectTmp),
245        provideInstruction({ home: globalTmp, config: globalTmp }, { disableClaudeCodePrompt: true }),
246      )
247    }),
248  )
249})
250 
251describe("Instruction.systemPaths global config", () => {
252  it.live("uses Global.Service config AGENTS.md", () =>
253    Effect.gen(function* () {
254      const globalTmp = yield* tmpWithFiles({ "AGENTS.md": "# Global Instructions" })
255      const projectTmp = yield* tmpdirScoped()
256 
257      yield* Effect.gen(function* () {
258        const svc = yield* Instruction.Service
259        const paths = yield* svc.systemPaths()
260        expect(paths.has(path.join(globalTmp, "AGENTS.md"))).toBe(true)
261      }).pipe(provideInstance(projectTmp), provideInstruction({ home: globalTmp, config: globalTmp }))
262    }),
263  )
264})
265