Aiden Cline
223 lines
10 KiB
TypeScript
223 lines
10 KiB
TypeScript
import { describe, expect, test } from "bun:test"
|
|
import { Effect, Layer, Option } from "effect"
|
|
import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
|
|
import { CodeMode } from "../src/index.js"
|
|
import { OpenAPI, type Document } from "../src/adapters/openapi/index.js"
|
|
|
|
const baseUrl = "http://localhost:4096"
|
|
const methods = new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace"])
|
|
|
|
type Recorded = {
|
|
readonly method: string
|
|
readonly url: string
|
|
readonly headers: Record<string, string>
|
|
readonly body: unknown
|
|
}
|
|
|
|
const opencodeSpec = async (): Promise<Document> => {
|
|
return Bun.file(new URL("./fixtures/opencode-v2-openapi.json", import.meta.url)).json() as Promise<Document>
|
|
}
|
|
|
|
const isRecord = (value: unknown): value is Record<string, unknown> =>
|
|
typeof value === "object" && value !== null && !Array.isArray(value)
|
|
|
|
const operations = (spec: Document) =>
|
|
Object.entries(isRecord(spec.paths) ? spec.paths : {}).flatMap(([path, pathValue]) =>
|
|
isRecord(pathValue)
|
|
? Object.entries(pathValue).flatMap(([method, operation]) =>
|
|
methods.has(method) && isRecord(operation) ? [{ path, method, operation }] : [],
|
|
)
|
|
: [],
|
|
)
|
|
|
|
const nonEmptyString = (value: unknown): string | undefined =>
|
|
typeof value === "string" && value !== "" ? value : undefined
|
|
|
|
const toolPathEntries = (spec: Document) => {
|
|
const used = new Set<string>()
|
|
const namespaces = new Set<string>()
|
|
return operations(spec).map((item) => {
|
|
const { path, method, operation } = item
|
|
const raw = nonEmptyString(operation.operationId)
|
|
const segments = (raw === undefined ? [`${method}_${path.replaceAll(/[{}]/g, "")}`] : raw.split("."))
|
|
.map((segment) => segment.replaceAll(/[^A-Za-z0-9_$]+/g, "_").replace(/^_+|_+$/g, "").replace(/^([0-9])/, "_$1") || "operation")
|
|
.map((segment) => (["__proto__", "constructor", "prototype"].includes(segment) ? `${segment}_2` : segment))
|
|
const key = segments.join(".")
|
|
const prefixUsed = segments.slice(0, -1).some((_, index) => used.has(segments.slice(0, index + 1).join(".")))
|
|
const name = used.has(key) || namespaces.has(key) || prefixUsed ? `${segments.join("_")}_2` : key
|
|
used.add(name)
|
|
for (const index of name.split(".").slice(0, -1).keys()) namespaces.add(name.split(".").slice(0, index + 1).join("."))
|
|
return { ...item, name }
|
|
})
|
|
}
|
|
|
|
const toolAt = (tools: unknown, name: string) =>
|
|
name.split(".").reduce<unknown>((current, segment) => (isRecord(current) ? current[segment] : undefined), tools)
|
|
|
|
const jsonContentSchema = (content: unknown) =>
|
|
isRecord(content)
|
|
? Object.entries(content).find(([mediaType]) => {
|
|
const normalized = mediaType.split(";")[0]?.trim().toLowerCase() ?? ""
|
|
return normalized === "application/json" || normalized.endsWith("+json")
|
|
})?.[1]
|
|
: undefined
|
|
|
|
const recordingClient = (respond: (request: HttpClientRequest.HttpClientRequest) => Response) => {
|
|
const requests: Array<Recorded> = []
|
|
const layer = Layer.succeed(HttpClient.HttpClient)(
|
|
HttpClient.make((request) =>
|
|
Effect.gen(function* () {
|
|
const body =
|
|
request.body._tag === "Uint8Array" ? JSON.parse(new TextDecoder().decode(request.body.body)) : undefined
|
|
const url = Option.map(HttpClientRequest.toUrl(request), (resolved) => resolved.toString())
|
|
requests.push({
|
|
method: request.method,
|
|
url: Option.getOrElse(url, () => request.url),
|
|
headers: { ...request.headers },
|
|
body,
|
|
})
|
|
return HttpClientResponse.fromWeb(request, respond(request))
|
|
}),
|
|
),
|
|
)
|
|
return { requests, layer }
|
|
}
|
|
|
|
const json = (value: unknown, status = 200) =>
|
|
new Response(JSON.stringify(value), { status, headers: { "content-type": "application/json" } })
|
|
|
|
describe("OpenAPI.fromSpec", () => {
|
|
test("converts every opencode operation into the expected tool shape", async () => {
|
|
const spec = await opencodeSpec()
|
|
const result = OpenAPI.fromSpec({ spec, baseUrl })
|
|
|
|
const entries = toolPathEntries(spec)
|
|
expect(entries.every((entry) => toolAt(result.tools, entry.name) !== undefined)).toBe(true)
|
|
expect(result.skipped).toStrictEqual([])
|
|
expect(toolAt(result.tools, "global.health")).not.toBeUndefined()
|
|
expect(toolAt(result.tools, "file.read")).not.toBeUndefined()
|
|
expect(toolAt(result.tools, "session.create")).not.toBeUndefined()
|
|
|
|
for (const item of entries) {
|
|
const tool = toolAt(result.tools, item.name)
|
|
expect(tool).toMatchObject({
|
|
_tag: "CodeModeTool",
|
|
description:
|
|
nonEmptyString(item.operation.description) ?? nonEmptyString(item.operation.summary) ?? `${item.method.toUpperCase()} ${item.path}`,
|
|
})
|
|
|
|
const toolRecord = isRecord(tool) ? tool : {}
|
|
const input = isRecord(toolRecord.input) ? toolRecord.input : {}
|
|
expect(input.type).toBe("object")
|
|
const properties = isRecord(input.properties) ? input.properties : {}
|
|
const parameters = Array.isArray(item.operation.parameters) ? item.operation.parameters.filter(isRecord) : []
|
|
for (const group of [
|
|
{ name: "path", location: "path" },
|
|
{ name: "query", location: "query" },
|
|
{ name: "headers", location: "header" },
|
|
]) {
|
|
const names = parameters
|
|
.filter((parameter) => parameter.in === group.location)
|
|
.map((parameter) => parameter.name)
|
|
.filter((name): name is string => typeof name === "string")
|
|
if (names.length === 0) continue
|
|
const groupSchema = isRecord(properties[group.name]) ? properties[group.name] : {}
|
|
const groupProperties = isRecord(groupSchema) && isRecord(groupSchema.properties) ? groupSchema.properties : {}
|
|
expect(Object.keys(groupProperties).sort()).toStrictEqual(names.sort())
|
|
}
|
|
|
|
const requestBody = isRecord(item.operation.requestBody) ? item.operation.requestBody : undefined
|
|
if (requestBody !== undefined && jsonContentSchema(requestBody.content) !== undefined) {
|
|
expect(properties).toHaveProperty("body")
|
|
}
|
|
|
|
const successes = Object.entries(isRecord(item.operation.responses) ? item.operation.responses : {})
|
|
.filter(([status]) => /^2\d\d$/.test(status) || status.toUpperCase() === "2XX")
|
|
.map(([, response]) => (isRecord(response) ? response : {}))
|
|
if (successes.some((response) => jsonContentSchema(response.content) !== undefined)) {
|
|
expect(toolRecord.output).not.toBeUndefined()
|
|
}
|
|
}
|
|
})
|
|
|
|
test("documents that the opencode fixture is unauthenticated", async () => {
|
|
const spec = await opencodeSpec()
|
|
const components = isRecord(spec.components) ? spec.components : {}
|
|
const result = OpenAPI.fromSpec({ spec, baseUrl })
|
|
|
|
expect(spec.security).toStrictEqual([])
|
|
expect(isRecord(components.securitySchemes) ? Object.keys(components.securitySchemes) : []).toStrictEqual([])
|
|
const health = toolAt(result.tools, "global.health")
|
|
const healthInput = isRecord(health) ? health.input : undefined
|
|
expect(healthInput).toMatchObject({ type: "object", properties: {} })
|
|
const input = isRecord(healthInput) ? healthInput : {}
|
|
expect(Object.keys(isRecord(input.properties) ? input.properties : {})).toStrictEqual([])
|
|
})
|
|
|
|
test("exposes real opencode operations through CodeMode discovery", async () => {
|
|
const { layer } = recordingClient(() => json({}))
|
|
const runtime = CodeMode.make({ tools: { opencode: OpenAPI.fromSpec({ spec: await opencodeSpec(), baseUrl }).tools } })
|
|
const result = await Effect.runPromise(
|
|
runtime.execute(`
|
|
return await tools.$codemode.search({ query: "global health", namespace: "opencode", limit: 1 })
|
|
`).pipe(Effect.provide(layer)),
|
|
)
|
|
|
|
expect(result).toMatchObject({ ok: true })
|
|
if (!result.ok) return
|
|
expect(result.value).toMatchObject({
|
|
items: [
|
|
{
|
|
path: "tools.opencode.global.health",
|
|
description: "Get health information about the OpenCode server.",
|
|
},
|
|
],
|
|
})
|
|
expect(JSON.stringify(result.value)).toContain("healthy: true")
|
|
expect(JSON.stringify(result.value)).toContain("version: string")
|
|
})
|
|
|
|
test("invokes real opencode paths, query parameters, and JSON request bodies", async () => {
|
|
const { requests, layer } = recordingClient((request) => {
|
|
if (request.method === "GET") return json({ type: "raw", content: "hello" })
|
|
return json({ id: "ses_123", version: "v2", time: { created: 0, updated: 0 }, title: "hello" })
|
|
})
|
|
const runtime = CodeMode.make({ tools: { opencode: OpenAPI.fromSpec({ spec: await opencodeSpec(), baseUrl }).tools } })
|
|
|
|
const result = await Effect.runPromise(
|
|
runtime
|
|
.execute(`
|
|
const file = await tools.opencode.file.read({ query: { path: "README.md", directory: "/repo" } })
|
|
const session = await tools.opencode.session.create({ body: { title: "hello" } })
|
|
return { file, session }
|
|
`)
|
|
.pipe(Effect.provide(layer)),
|
|
)
|
|
|
|
expect(result).toMatchObject({ ok: true })
|
|
expect(requests).toHaveLength(2)
|
|
expect(requests[0]).toMatchObject({ method: "GET", body: undefined })
|
|
expect(new URL(requests[0]!.url).pathname).toBe("/file/content")
|
|
expect(new URL(requests[0]!.url).searchParams.get("path")).toBe("README.md")
|
|
expect(new URL(requests[0]!.url).searchParams.get("directory")).toBe("/repo")
|
|
expect(requests[1]).toMatchObject({
|
|
method: "POST",
|
|
url: "http://localhost:4096/session",
|
|
body: { title: "hello" },
|
|
})
|
|
})
|
|
|
|
test("fails missing required parameters before auth and network", async () => {
|
|
const { requests, layer } = recordingClient(() => json({}))
|
|
const runtime = CodeMode.make({ tools: { opencode: OpenAPI.fromSpec({ spec: await opencodeSpec(), baseUrl }).tools } })
|
|
|
|
const result = await Effect.runPromise(
|
|
runtime.execute("return await tools.opencode.file.read({})").pipe(Effect.provide(layer)),
|
|
)
|
|
|
|
expect(result).toMatchObject({ ok: false })
|
|
expect(JSON.stringify(result)).toContain("Missing required query parameter 'path'")
|
|
expect(requests).toHaveLength(0)
|
|
})
|
|
})
|