@opencode-ai/core 0.0.0-dev-17471

package/dist/types/filesystem.d.ts

@@ -0,0 +1,130 @@
+export * as FileSystem from "./filesystem.js";
+import { Context, Effect, Schema } from "effect";
+import { Entry, FindInput } from "@opencode-ai/schema/filesystem";
+export { Entry, Match, Submatch } from "@opencode-ai/schema/filesystem";
+export declare const ReadInput: Schema.Struct<{
+    readonly path: Schema.brand<Schema.String, "RelativePath">;
+}>;
+export type ReadInput = typeof ReadInput.Type;
+export declare const Content: Schema.Struct<{
+    readonly uri: Schema.String;
+    readonly name: Schema.optional<Schema.String>;
+    readonly content: Schema.String;
+    readonly encoding: Schema.Literals<readonly ["utf8", "base64"]>;
+    readonly mime: Schema.String;
+}>;
+export type Content = typeof Content.Type;
+export declare const ListInput: Schema.Struct<{
+    readonly path: Schema.optional<Schema.brand<Schema.String, "RelativePath">>;
+}>;
+export type ListInput = typeof ListInput.Type;
+export { FindInput };
+export declare const DEFAULT_SEARCH_LIMIT = 100;
+export declare const DEFAULT_SEARCH_TIMEOUT_MS = 30000;
+declare const GlobInput_base: Schema.Class<GlobInput, Schema.Struct<{
+    readonly pattern: Schema.String;
+    readonly path: Schema.optionalKey<Schema.brand<Schema.String, "RelativePath">>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>, {}>;
+export declare class GlobInput extends GlobInput_base {
+}
+declare const GrepInput_base: Schema.Class<GrepInput, Schema.Struct<{
+    readonly pattern: Schema.String;
+    readonly path: Schema.optionalKey<Schema.brand<Schema.String, "RelativePath">>;
+    readonly include: Schema.optionalKey<Schema.String>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>, {}>;
+export declare class GrepInput extends GrepInput_base {
+}
+export declare const Event: {
+    Changed: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly type: Schema.Literal<"filesystem.changed">;
+        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{
+            readonly file: Schema.String;
+            readonly event: Schema.Literals<readonly ["add", "change", "unlink"]>;
+        }>;
+    }> & {
+        type: "filesystem.changed";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{
+            readonly file: Schema.String;
+            readonly event: Schema.Literals<readonly ["add", "change", "unlink"]>;
+        }>;
+    };
+    Definitions: readonly [Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly type: Schema.Literal<"filesystem.changed">;
+        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{
+            readonly file: Schema.String;
+            readonly event: Schema.Literals<readonly ["add", "change", "unlink"]>;
+        }>;
+    }> & {
+        type: "filesystem.changed";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{
+            readonly file: Schema.String;
+            readonly event: Schema.Literals<readonly ["add", "change", "unlink"]>;
+        }>;
+    }];
+};
+export interface Interface {
+    readonly read: (input: ReadInput) => Effect.Effect<{
+        readonly content: Uint8Array;
+        readonly mime: string;
+    }>;
+    readonly list: (input?: ListInput) => Effect.Effect<Entry[]>;
+    readonly find: (input: FindInput) => Effect.Effect<Entry[]>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/FileSystem", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/form.d.ts

@@ -0,0 +1,449 @@
+export * as Form from "./form.js";
+import { Form } from "@opencode-ai/schema/form";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Bus } from "./bus.js";
+export declare const ID: Schema.brand<Schema.String, "Form.ID"> & {
+    create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
+};
+export type ID = typeof ID.Type;
+export declare const Info: Schema.Struct<{
+    readonly fields: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"string">;
+        readonly format: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>>, Schema.optionalKey<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>, never, never>;
+        readonly minLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly maxLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly pattern: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly options: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly value: Schema.String;
+            readonly label: Schema.String;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly value: Schema.String;
+            readonly label: Schema.String;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>>, never, never>;
+        readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly key: Schema.String;
+        readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"number">;
+        readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly key: Schema.String;
+        readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"integer">;
+        readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly key: Schema.String;
+        readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"boolean">;
+        readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly key: Schema.String;
+        readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"multiselect">;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly value: Schema.String;
+            readonly label: Schema.String;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>;
+        readonly minItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly maxItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+        readonly key: Schema.String;
+        readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>, never, never>;
+    }>, Schema.Struct<{
+        readonly key: Schema.String;
+        readonly type: Schema.Literal<"external">;
+        readonly url: Schema.String;
+        readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>]>>;
+    readonly id: Schema.brand<Schema.String, "Form.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
+    };
+    readonly sessionID: Schema.String;
+    readonly title: Schema.String;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>;
+export type Info = typeof Info.Type;
+export declare const Field: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"string">;
+    readonly format: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>>, Schema.optionalKey<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>, never, never>;
+    readonly minLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly maxLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly pattern: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly options: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly value: Schema.String;
+        readonly label: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly value: Schema.String;
+        readonly label: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, never, never>;
+    readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"number">;
+    readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"integer">;
+    readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"boolean">;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"multiselect">;
+    readonly options: Schema.$Array<Schema.Struct<{
+        readonly value: Schema.String;
+        readonly label: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>;
+    readonly minItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly maxItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly key: Schema.String;
+    readonly type: Schema.Literal<"external">;
+    readonly url: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>]>;
+export type Field = Form.Field;
+export declare const Fields: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"string">;
+    readonly format: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>>, Schema.optionalKey<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>, never, never>;
+    readonly minLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly maxLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly pattern: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly options: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly value: Schema.String;
+        readonly label: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly value: Schema.String;
+        readonly label: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, never, never>;
+    readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"number">;
+    readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"integer">;
+    readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"boolean">;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"multiselect">;
+    readonly options: Schema.$Array<Schema.Struct<{
+        readonly value: Schema.String;
+        readonly label: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>;
+    readonly minItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly maxItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly key: Schema.String;
+    readonly type: Schema.Literal<"external">;
+    readonly url: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>]>>;
+export type Fields = Form.Fields;
+export declare const When: Schema.Struct<{
+    readonly key: Schema.String;
+    readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+    readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+}>;
+export type When = Form.When;
+export declare const State: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"pending">;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"answered">;
+    readonly answer: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"cancelled">;
+}>]>;
+export type State = typeof State.Type;
+export type TerminalState = Exclude<State, {
+    readonly status: "pending";
+}>;
+export declare const Answer: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>;
+export type Answer = typeof Answer.Type;
+export declare const Reply: Schema.Struct<{
+    readonly answer: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>;
+}>;
+export type Reply = typeof Reply.Type;
+export { Event } from "@opencode-ai/schema/form";
+declare const NotFoundError_base: Schema.Class<NotFoundError, Schema.TaggedStruct<"Form.NotFoundError", {
+    readonly id: Schema.brand<Schema.String, "Form.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class NotFoundError extends NotFoundError_base {
+    get message(): string;
+}
+declare const AlreadySettledError_base: Schema.Class<AlreadySettledError, Schema.TaggedStruct<"Form.AlreadySettledError", {
+    readonly id: Schema.brand<Schema.String, "Form.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class AlreadySettledError extends AlreadySettledError_base {
+    get message(): string;
+}
+declare const AlreadyExistsError_base: Schema.Class<AlreadyExistsError, Schema.TaggedStruct<"Form.AlreadyExistsError", {
+    readonly id: Schema.brand<Schema.String, "Form.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class AlreadyExistsError extends AlreadyExistsError_base {
+    get message(): string;
+}
+declare const InvalidAnswerError_base: Schema.Class<InvalidAnswerError, Schema.TaggedStruct<"Form.InvalidAnswerError", {
+    readonly id: Schema.brand<Schema.String, "Form.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
+    };
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidAnswerError extends InvalidAnswerError_base {
+}
+declare const InvalidFormError_base: Schema.Class<InvalidFormError, Schema.TaggedStruct<"Form.InvalidFormError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidFormError extends InvalidFormError_base {
+}
+export type CreateInput = Omit<Form.Info, "id"> & {
+    readonly id?: ID;
+};
+export interface ReplyInput {
+    readonly id: ID;
+    readonly answer: Answer;
+}
+export interface ListInput {
+    readonly sessionID?: Form.Info["sessionID"];
+}
+export interface Interface {
+    readonly create: (input: CreateInput) => Effect.Effect<Info, AlreadyExistsError | InvalidFormError>;
+    readonly ask: (input: CreateInput) => Effect.Effect<TerminalState, AlreadyExistsError | InvalidFormError>;
+    readonly get: (id: ID) => Effect.Effect<Info, NotFoundError>;
+    readonly list: (input?: ListInput) => Effect.Effect<ReadonlyArray<Info>>;
+    readonly state: (id: ID) => Effect.Effect<State, NotFoundError>;
+    readonly reply: (input: ReplyInput) => Effect.Effect<void, AlreadySettledError | InvalidAnswerError | NotFoundError>;
+    readonly cancel: (id: ID) => Effect.Effect<void, AlreadySettledError | NotFoundError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Form", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Bus.Service>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;
+export declare function validateAnswer(form: ReadonlyArray<Form.Field>, answer: Answer): string | undefined;
+export declare function validateFields(fields: ReadonlyArray<Form.Field>): string | undefined;

package/dist/types/formatter/builtins.d.ts

@@ -0,0 +1,18 @@
+import { Effect } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Npm } from "@opencode-ai/util/npm";
+import { AppProcess } from "@opencode-ai/util/process";
+export interface Info {
+    readonly name: string;
+    readonly environment?: Record<string, string>;
+    readonly extensions: readonly string[];
+    readonly enabled: Effect.Effect<string[] | false>;
+}
+export declare function make(input: {
+    readonly directory: string;
+    readonly worktree: string;
+    readonly fs: FSUtil.Interface;
+    readonly npm: Npm.Interface;
+    readonly processes: AppProcess.Interface;
+    readonly bin: string;
+}): Info[];

package/dist/types/formatter.d.ts

@@ -0,0 +1,9 @@
+export * as Formatter from "./formatter.js";
+import { Context, Effect } from "effect";
+export interface Interface {
+    readonly file: (filepath: string) => Effect.Effect<boolean>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/v2/Formatter", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;