112 lines
3.8 KiB
TypeScript
112 lines
3.8 KiB
TypeScript
export * as InstructionDiscovery from "./instruction-discovery"
|
|
|
|
import { Array, Context, Effect, Layer, Schema } from "effect"
|
|
import { isAbsolute, join, relative, sep } from "path"
|
|
import { FSUtil } from "@opencode-ai/util/fs-util"
|
|
import { Global } from "@opencode-ai/util/global"
|
|
import { Location } from "./location"
|
|
import { AbsolutePath } from "./schema"
|
|
import { Instructions } from "./instructions/index"
|
|
import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
|
|
|
|
class File extends Schema.Class<File>("InstructionDiscovery.File")({
|
|
path: AbsolutePath,
|
|
content: Schema.String,
|
|
}) {}
|
|
|
|
const Files = Schema.Array(File)
|
|
const key = Instructions.Key.make("core/instructions")
|
|
|
|
export interface Interface {
|
|
readonly load: () => Effect.Effect<Instructions.Instructions>
|
|
}
|
|
|
|
export const Options = Schema.Struct({
|
|
project: Schema.optional(Schema.Boolean),
|
|
})
|
|
export type Options = typeof Options.Type
|
|
|
|
export class Service extends Context.Service<Service, Interface>()("@opencode/InstructionDiscovery") {}
|
|
|
|
export const layer = (options?: Options) => Layer.effect(
|
|
Service,
|
|
Effect.gen(function* () {
|
|
const fs = yield* FSUtil.Service
|
|
const global = yield* Global.Service
|
|
const location = yield* Location.Service
|
|
|
|
const source = (value: ReadonlyArray<File> | Instructions.Unavailable | Instructions.Removed) =>
|
|
Instructions.make<ReadonlyArray<File>>({
|
|
key,
|
|
codec: Schema.toCodecJson(Files),
|
|
read: Effect.succeed(value),
|
|
render: {
|
|
initial: render,
|
|
changed: (_previous, current) =>
|
|
`These instructions replace all previously loaded ambient instructions.\n\n${render(current)}`,
|
|
removed: () => "Previously loaded instructions no longer apply.",
|
|
},
|
|
})
|
|
|
|
const observe = Effect.fn("InstructionDiscovery.observe")(function* () {
|
|
const start = yield* fs.resolve(location.directory)
|
|
const stop = yield* fs.resolve(location.project.directory)
|
|
const fromProject = relative(stop, start)
|
|
const insideProject =
|
|
fromProject === "" || (fromProject !== ".." && !fromProject.startsWith(`..${sep}`) && !isAbsolute(fromProject))
|
|
const discovered = new Set(
|
|
yield* Effect.forEach(
|
|
options?.project === false || !insideProject
|
|
? []
|
|
: yield* fs.up({
|
|
targets: ["AGENTS.md"],
|
|
start,
|
|
stop,
|
|
}),
|
|
fs.resolve,
|
|
),
|
|
)
|
|
const paths = Array.dedupe([yield* fs.resolve(join(global.config, "AGENTS.md")), ...discovered])
|
|
const files = yield* Effect.forEach(
|
|
paths,
|
|
(path) =>
|
|
fs
|
|
.readFileStringSafe(path)
|
|
.pipe(
|
|
Effect.map((content) =>
|
|
content === undefined ? undefined : new File({ path: AbsolutePath.make(path), content }),
|
|
),
|
|
),
|
|
{ concurrency: "unbounded" },
|
|
)
|
|
if (files.some((file, index) => file === undefined && discovered.has(paths[index])))
|
|
return Instructions.unavailable
|
|
return files.filter((file): file is File => file !== undefined)
|
|
})
|
|
|
|
return Service.of({
|
|
load: () =>
|
|
observe().pipe(
|
|
Effect.map((files) =>
|
|
Array.isArray(files) && files.length === 0 ? source(Instructions.removed) : source(files),
|
|
),
|
|
Effect.catch(() => Effect.succeed(source(Instructions.unavailable))),
|
|
Effect.catchDefect(() => Effect.succeed(source(Instructions.unavailable))),
|
|
),
|
|
})
|
|
}),
|
|
)
|
|
|
|
export function configured(options?: Options) {
|
|
return makeLocationNode({
|
|
service: Service,
|
|
layer: layer(options),
|
|
deps: [FSUtil.node, Global.node, Location.node],
|
|
})
|
|
}
|
|
|
|
export const node = configured()
|
|
|
|
function render(files: ReadonlyArray<File>) {
|
|
return files.map((file) => `Instructions from: ${file.path}\n${file.content}`).join("\n\n")
|
|
}
|