@opencode-ai/util 0.0.0-bootstrap.0 → 0.0.0-next-15994

package/dist/global.d.ts

@@ -0,0 +1,30 @@
+import { Context, Layer } from "effect";
+export declare const Path: {
+    readonly home: string;
+    data: string;
+    bin: string;
+    log: string;
+    repos: string;
+    cache: string;
+    config: string;
+    state: string;
+    tmp: string;
+};
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Global", Interface>;
+export declare class Service extends Service_base {
+}
+export interface Interface {
+    readonly home: string;
+    readonly data: string;
+    readonly cache: string;
+    readonly config: string;
+    readonly state: string;
+    readonly tmp: string;
+    readonly bin: string;
+    readonly log: string;
+    readonly repos: string;
+}
+export declare function make(input?: Partial<Interface>): Interface;
+export declare const node: import("./effect/layer-node.js").Node<Service, never, import("./effect/layer-node.js").Tag<"global">>;
+export declare const layerWith: (input: Partial<Interface>) => Layer.Layer<Service, never, never>;
+export * as Global from "./global.js";

package/dist/global.js

@@ -0,0 +1,57 @@
+import path from "path";
+import fs from "fs/promises";
+import { xdgData, xdgCache, xdgConfig, xdgState } from "xdg-basedir";
+import os from "os";
+import { Context, Effect, Layer } from "effect";
+import { Flock } from "./flock.js";
+import { makeGlobalNode } from "./effect/app-node.js";
+const app = "opencode";
+const data = path.join(xdgData, app);
+const cache = path.join(xdgCache, app);
+const config = path.join(xdgConfig, app);
+const state = path.join(xdgState, app);
+const tmp = path.join(os.tmpdir(), app);
+const paths = {
+    get home() {
+        return process.env.OPENCODE_TEST_HOME ?? os.homedir();
+    },
+    data,
+    bin: path.join(cache, "bin"),
+    log: path.join(data, "log"),
+    repos: path.join(data, "repos"),
+    cache,
+    config,
+    state,
+    tmp,
+};
+export const Path = paths;
+Flock.setGlobal({ state });
+await Promise.all([
+    fs.mkdir(Path.data, { recursive: true }),
+    fs.mkdir(Path.config, { recursive: true }),
+    fs.mkdir(Path.state, { recursive: true }),
+    fs.mkdir(Path.tmp, { recursive: true }),
+    fs.mkdir(Path.log, { recursive: true }),
+    fs.mkdir(Path.bin, { recursive: true }),
+    fs.mkdir(Path.repos, { recursive: true }),
+]);
+export class Service extends Context.Service()("@opencode/Global") {
+}
+export function make(input = {}) {
+    return {
+        home: Path.home,
+        data: Path.data,
+        cache: Path.cache,
+        config: Path.config,
+        state: Path.state,
+        tmp: Path.tmp,
+        bin: Path.bin,
+        log: Path.log,
+        repos: Path.repos,
+        ...input,
+    };
+}
+const layer = Layer.effect(Service, Effect.sync(() => Service.of(make({ config: process.env.OPENCODE_CONFIG_DIR ?? Path.config }))));
+export const node = makeGlobalNode({ service: Service, layer: layer, deps: [] });
+export const layerWith = (input) => Layer.effect(Service, Effect.sync(() => Service.of(make(input))));
+export * as Global from "./global.js";

package/dist/hash.d.ts

@@ -0,0 +1,4 @@
+export declare namespace Hash {
+    function fast(input: string | Buffer): string;
+    function sha256(input: string | Buffer): string;
+}

package/dist/hash.js

@@ -0,0 +1,12 @@
+import { createHash } from "crypto";
+export var Hash;
+(function (Hash) {
+    function fast(input) {
+        return createHash("sha1").update(input).digest("hex");
+    }
+    Hash.fast = fast;
+    function sha256(input) {
+        return createHash("sha256").update(input).digest("hex");
+    }
+    Hash.sha256 = sha256;
+})(Hash || (Hash = {}));

package/dist/npm-config.d.ts

@@ -0,0 +1,4 @@
+export * as NpmConfig from "./npm-config.js";
+import { Effect } from "effect";
+export declare const load: (dir: string) => Effect.Effect<Record<string, unknown>, never, never>;
+export declare const registry: (dir: string) => Effect.Effect<string, never, never>;

package/dist/npm-config.js

@@ -0,0 +1,32 @@
+export * as NpmConfig from "./npm-config.js";
+import { fileURLToPath } from "url";
+// @ts-expect-error npm does not publish types for this internal config API.
+import Config from "@npmcli/config";
+// @ts-expect-error npm does not publish types for this internal config API.
+import { definitions, flatten, nerfDarts, shorthands } from "@npmcli/config/lib/definitions/index.js";
+import { Effect } from "effect";
+const npmPath = fileURLToPath(new URL("..", import.meta.url));
+export const load = (dir) => Effect.tryPromise({
+    try: async () => {
+        const config = new Config({
+            npmPath,
+            cwd: dir,
+            env: { ...process.env },
+            argv: [process.execPath, process.execPath, "--prefix", dir],
+            execPath: process.execPath,
+            platform: process.platform,
+            definitions,
+            flatten,
+            nerfDarts,
+            shorthands,
+            warn: false,
+        });
+        await config.load();
+        return config.flat;
+    },
+    catch: (cause) => cause,
+}).pipe(Effect.orElseSucceed(() => ({})));
+export const registry = (dir) => load(dir).pipe(Effect.map((config) => {
+    const registry = typeof config.registry === "string" ? config.registry : "https://registry.npmjs.org";
+    return registry.endsWith("/") ? registry.slice(0, -1) : registry;
+}));

package/dist/npm.d.ts

@@ -0,0 +1,35 @@
+export * as Npm from "./npm.js";
+import { Effect, Schema, Context } from "effect";
+import { EffectFlock } from "./effect-flock.js";
+import { LayerNode } from "./effect/layer-node.js";
+declare const InstallFailedError_base: Schema.Class<InstallFailedError, Schema.TaggedStruct<"NpmInstallFailedError", {
+    readonly add: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly dir: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class InstallFailedError extends InstallFailedError_base {
+}
+export interface EntryPoint {
+    readonly directory: string;
+    readonly entrypoint?: string;
+}
+export interface Interface {
+    readonly add: (pkg: string, options?: {
+        readonly subpaths?: readonly string[];
+    }) => Effect.Effect<EntryPoint, InstallFailedError | EffectFlock.LockError>;
+    readonly install: (dir: string, input?: {
+        add: {
+            name: string;
+            version?: string;
+        }[];
+    }) => Effect.Effect<void, EffectFlock.LockError | InstallFailedError>;
+    readonly which: (pkg: string, bin?: string) => Effect.Effect<string | undefined>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Npm", Interface>;
+export declare class Service extends Service_base {
+}
+export declare function sanitize(pkg: string): string;
+export declare const node: LayerNode.Node<Service, never, LayerNode.Tag<"global">>;
+export declare function install(...args: Parameters<Interface["install"]>): Promise<void>;
+export declare function add(...args: Parameters<Interface["add"]>): Promise<EntryPoint>;
+export declare function which(...args: Parameters<Interface["which"]>): Promise<string | undefined>;

package/dist/npm.js

@@ -0,0 +1,207 @@
+export * as Npm from "./npm.js";
+import path from "path";
+import npa from "npm-package-arg";
+import { Effect, Schema, Context, Layer, Option, FileSystem } from "effect";
+import { NodeFileSystem } from "@effect/platform-node";
+import { FSUtil } from "./fs-util.js";
+import { Global } from "./global.js";
+import { EffectFlock } from "./effect-flock.js";
+import { makeGlobalNode } from "./effect/app-node.js";
+import { filesystem } from "./effect/app-node-platform.js";
+import { LayerNode } from "./effect/layer-node.js";
+import { makeRuntime } from "./effect/runtime.js";
+import { NpmConfig } from "./npm-config.js";
+import { resolveModule } from "#runtime-import";
+export class InstallFailedError extends Schema.TaggedErrorClass()("NpmInstallFailedError", {
+    add: Schema.Array(Schema.String).pipe(Schema.optional),
+    dir: Schema.String,
+    cause: Schema.optional(Schema.Defect()),
+}) {
+}
+export class Service extends Context.Service()("@opencode/Npm") {
+}
+const illegal = process.platform === "win32" ? new Set(["<", ">", ":", '"', "|", "?", "*"]) : undefined;
+export function sanitize(pkg) {
+    if (!illegal)
+        return pkg;
+    return Array.from(pkg, (char) => (illegal.has(char) || char.charCodeAt(0) < 32 ? "_" : char)).join("");
+}
+const resolveEntryPoint = (name, dir, subpaths = [""]) => {
+    const entrypoint = subpaths
+        .map((subpath) => {
+        try {
+            return resolveModule([name, subpath].filter(Boolean).join("/"), dir);
+        }
+        catch {
+            return undefined;
+        }
+    })
+        .find((entrypoint) => entrypoint !== undefined);
+    return {
+        directory: dir,
+        entrypoint,
+    };
+};
+const layer = Layer.effect(Service, Effect.gen(function* () {
+    const afs = yield* FSUtil.Service;
+    const global = yield* Global.Service;
+    const fs = yield* FileSystem.FileSystem;
+    const flock = yield* EffectFlock.Service;
+    const directory = (pkg) => path.join(global.cache, "packages", sanitize(pkg));
+    const reify = (input) => Effect.gen(function* () {
+        yield* flock.acquire(`npm-install:${input.dir}`);
+        const { Arborist } = yield* Effect.promise(() => import("@npmcli/arborist"));
+        const add = input.add ?? [];
+        const npmOptions = yield* NpmConfig.load(input.dir);
+        const arborist = new Arborist({
+            ...npmOptions,
+            path: input.dir,
+            binLinks: true,
+            progress: false,
+            savePrefix: "",
+            ignoreScripts: true,
+        });
+        return yield* Effect.tryPromise({
+            try: () => arborist.reify({
+                ...npmOptions,
+                add,
+                save: true,
+                saveType: "prod",
+            }),
+            catch: (cause) => new InstallFailedError({
+                cause,
+                add,
+                dir: input.dir,
+            }),
+        });
+    }).pipe(Effect.withSpan("Npm.reify", {
+        attributes: input,
+    }));
+    const add = Effect.fn("Npm.add")(function* (pkg, options) {
+        const dir = directory(pkg);
+        const name = (() => {
+            try {
+                return npa(pkg).name ?? pkg;
+            }
+            catch {
+                return pkg;
+            }
+        })();
+        if (yield* afs.existsSafe(path.join(dir, "node_modules", name))) {
+            return resolveEntryPoint(name, path.join(dir, "node_modules", name), options?.subpaths);
+        }
+        const tree = yield* reify({ dir, add: [pkg] });
+        const first = tree.edgesOut.values().next().value?.to;
+        if (!first) {
+            const result = resolveEntryPoint(name, path.join(dir, "node_modules", name), options?.subpaths);
+            if (result.entrypoint)
+                return result;
+            return yield* new InstallFailedError({ add: [pkg], dir });
+        }
+        return resolveEntryPoint(first.name, first.path, options?.subpaths);
+    }, Effect.scoped);
+    const install = Effect.fn("Npm.install")(function* (dir, input) {
+        const canWrite = yield* afs.access(dir, { writable: true }).pipe(Effect.as(true), Effect.orElseSucceed(() => false));
+        if (!canWrite)
+            return;
+        const add = input?.add.map((pkg) => [pkg.name, pkg.version].filter(Boolean).join("@")) ?? [];
+        if (yield* Effect.gen(function* () {
+            const nodeModulesExists = yield* afs.existsSafe(path.join(dir, "node_modules"));
+            if (!nodeModulesExists) {
+                yield* reify({ add, dir });
+                return true;
+            }
+            return false;
+        }).pipe(Effect.withSpan("Npm.checkNodeModules")))
+            return;
+        yield* Effect.gen(function* () {
+            const pkg = yield* afs.readJson(path.join(dir, "package.json")).pipe(Effect.orElseSucceed(() => ({})));
+            const lock = yield* afs.readJson(path.join(dir, "package-lock.json")).pipe(Effect.orElseSucceed(() => ({})));
+            const pkgAny = pkg;
+            const lockAny = lock;
+            const declared = new Set([
+                ...Object.keys(pkgAny?.dependencies || {}),
+                ...Object.keys(pkgAny?.devDependencies || {}),
+                ...Object.keys(pkgAny?.peerDependencies || {}),
+                ...Object.keys(pkgAny?.optionalDependencies || {}),
+                ...(input?.add || []).map((pkg) => pkg.name),
+            ]);
+            const root = lockAny?.packages?.[""] || {};
+            const locked = new Set([
+                ...Object.keys(root?.dependencies || {}),
+                ...Object.keys(root?.devDependencies || {}),
+                ...Object.keys(root?.peerDependencies || {}),
+                ...Object.keys(root?.optionalDependencies || {}),
+            ]);
+            for (const name of declared) {
+                if (!locked.has(name)) {
+                    yield* reify({ dir, add });
+                    return;
+                }
+            }
+        }).pipe(Effect.withSpan("Npm.checkDirty"));
+        return;
+    }, Effect.scoped);
+    const which = Effect.fn("Npm.which")(function* (pkg, bin) {
+        const dir = directory(pkg);
+        const binDir = path.join(dir, "node_modules", ".bin");
+        const pick = Effect.fnUntraced(function* () {
+            const files = yield* fs.readDirectory(binDir).pipe(Effect.catch(() => Effect.succeed([])));
+            if (files.length === 0)
+                return Option.none();
+            // Caller picked a specific bin (e.g. pyright exposes both `pyright` and
+            // `pyright-langserver`); trust the hint if the package provides it.
+            if (bin)
+                return files.includes(bin) ? Option.some(bin) : Option.none();
+            if (files.length === 1)
+                return Option.some(files[0]);
+            const pkgJson = yield* afs.readJson(path.join(dir, "node_modules", pkg, "package.json")).pipe(Effect.option);
+            if (Option.isSome(pkgJson)) {
+                const parsed = pkgJson.value;
+                if (parsed?.bin) {
+                    const unscoped = pkg.startsWith("@") ? pkg.split("/")[1] : pkg;
+                    const parsedBin = parsed.bin;
+                    if (typeof parsedBin === "string")
+                        return Option.some(unscoped);
+                    const keys = Object.keys(parsedBin);
+                    if (keys.length === 1)
+                        return Option.some(keys[0]);
+                    return parsedBin[unscoped] ? Option.some(unscoped) : Option.some(keys[0]);
+                }
+            }
+            return Option.some(files[0]);
+        });
+        return Option.getOrUndefined(yield* Effect.gen(function* () {
+            const bin = yield* pick();
+            if (Option.isSome(bin)) {
+                return Option.some(path.join(binDir, bin.value));
+            }
+            yield* fs.remove(path.join(dir, "package-lock.json")).pipe(Effect.orElseSucceed(() => { }));
+            yield* add(pkg);
+            const resolved = yield* pick();
+            if (Option.isNone(resolved))
+                return Option.none();
+            return Option.some(path.join(binDir, resolved.value));
+        }).pipe(Effect.scoped, Effect.orElseSucceed(() => Option.none())));
+    });
+    return Service.of({
+        add,
+        install,
+        which,
+    });
+}));
+export const node = makeGlobalNode({
+    service: Service,
+    layer: layer,
+    deps: [FSUtil.node, Global.node, filesystem, EffectFlock.node],
+});
+const { runPromise } = makeRuntime(Service, LayerNode.compile(node));
+export async function install(...args) {
+    return runPromise((svc) => svc.install(...args));
+}
+export async function add(...args) {
+    return runPromise((svc) => svc.add(...args));
+}
+export async function which(...args) {
+    return runPromise((svc) => svc.which(...args));
+}

package/dist/observability/logging.d.ts

@@ -0,0 +1,6 @@
+import { Logger } from "effect";
+export declare function file(local?: boolean, channel?: string): string;
+export declare function fileLogger(target?: string, id?: string): import("effect/Effect").Effect<Logger.Logger<unknown, void>, import("effect/PlatformError").PlatformError, import("effect/FileSystem").FileSystem | import("effect/Scope").Scope>;
+export declare function minimumLogLevel(): "Error" | "Warn" | "Info" | "Debug";
+export declare function loggers(local?: boolean, channel?: string): (import("effect/Effect").Effect<Logger.Logger<unknown, void>, import("effect/PlatformError").PlatformError, import("effect/FileSystem").FileSystem | import("effect/Scope").Scope> | Logger.Logger<unknown, boolean>)[];
+export * as Logging from "./logging.js";

package/dist/observability/logging.js

@@ -0,0 +1,67 @@
+import { Formatter, Logger } from "effect";
+import path from "path";
+import { Global } from "../global.js";
+import { runID } from "./shared.js";
+function formatter(id = runID) {
+    return Logger.map(Logger.formatStructured, (output) => {
+        const messages = Array.isArray(output.message) ? output.message : [output.message];
+        return [
+            ["timestamp", output.timestamp],
+            ["level", output.level],
+            ["run", id],
+            ...messages.flatMap((value) => (plain(value) ? flatten(value) : [["message", value]])),
+            ...(output.cause === undefined ? [] : [["cause", output.cause]]),
+            ...flatten(output.spans),
+            ...flatten(output.annotations),
+        ]
+            .map(([key, value]) => `${key}=${format(value)}`)
+            .join(" ");
+    });
+}
+function flatten(input, prefix = "", seen = new WeakSet()) {
+    if (seen.has(input))
+        return [[prefix, "[Circular]"]];
+    seen.add(input);
+    const entries = Object.entries(input);
+    if (entries.length === 0 && prefix)
+        return [[prefix, input]];
+    return entries.flatMap(([key, value]) => {
+        const path = prefix ? `${prefix}.${key}` : key;
+        return plain(value) ? flatten(value, path, seen) : [[path, value]];
+    });
+}
+function plain(input) {
+    if (input === null || typeof input !== "object" || Array.isArray(input))
+        return false;
+    const prototype = Object.getPrototypeOf(input);
+    return prototype === Object.prototype || prototype === null;
+}
+function format(input) {
+    const value = typeof input === "string" ? input : Formatter.format(input);
+    return /^[^\s="\\]+$/.test(value) ? value : JSON.stringify(value);
+}
+export function file(local = true, channel = "local") {
+    if (!local)
+        return path.join(Global.Path.log, "opencode.log");
+    return path.join(Global.Path.log, `opencode-${channel.replace(/[^a-zA-Z0-9._-]/g, "-")}.log`);
+}
+export function fileLogger(target = file(), id = runID) {
+    // Do not set batchWindow to 0; it causes high idle CPU usage.
+    return Logger.toFile(formatter(id), target, { flag: "a" });
+}
+const stderrLogger = Logger.make((options) => process.stderr.write(formatter().log(options) + "\n"));
+export function minimumLogLevel() {
+    const value = process.env.OPENCODE_LOG_LEVEL?.toUpperCase();
+    const levels = {
+        DEBUG: "Debug",
+        INFO: "Info",
+        WARN: "Warn",
+        ERROR: "Error",
+    };
+    return value && value in levels ? levels[value] : levels.INFO;
+}
+export function loggers(local = true, channel = "local") {
+    const logger = fileLogger(file(local, channel));
+    return process.env.OPENCODE_PRINT_LOGS === "1" ? [logger, stderrLogger] : [logger];
+}
+export * as Logging from "./logging.js";

package/dist/observability/otlp.d.ts

@@ -0,0 +1,18 @@
+import { Layer } from "effect";
+export interface Options {
+    readonly endpoint?: string;
+    readonly headers?: string;
+}
+export interface App {
+    readonly client: string;
+    readonly version: string;
+    readonly channel: string;
+}
+export declare function resource(app?: App): {
+    serviceName: string;
+    serviceVersion: string;
+    attributes: Record<string, string>;
+};
+export declare function loggers(options: Options | undefined, app: App): import("effect/Effect").Effect<import("effect/Logger").Logger<unknown, void>, never, import("effect/unstable/http/HttpClient").HttpClient | import("effect/Scope").Scope | import("effect/unstable/observability/OtlpSerialization").OtlpSerialization>[];
+export declare function tracingLayer(options: Options | undefined, app: App): Promise<Layer.Layer<never, never, never>>;
+export * as Otlp from "./otlp.js";

package/dist/observability/otlp.js

@@ -0,0 +1,73 @@
+import { Layer } from "effect";
+import { OtlpLogger } from "effect/unstable/observability";
+import { runID } from "./shared.js";
+function parseHeaders(value) {
+    return value
+        ? value.split(",").reduce((acc, entry) => {
+            const [key, ...value] = entry.split("=");
+            acc[key] = value.join("=");
+            return acc;
+        }, {})
+        : undefined;
+}
+function resourceAttributes() {
+    const value = process.env.OTEL_RESOURCE_ATTRIBUTES;
+    if (!value)
+        return {};
+    try {
+        return Object.fromEntries(value.split(",").map((entry) => {
+            const index = entry.indexOf("=");
+            if (index < 1)
+                throw new Error("Invalid OTEL_RESOURCE_ATTRIBUTES entry");
+            return [decodeURIComponent(entry.slice(0, index)), decodeURIComponent(entry.slice(index + 1))];
+        }));
+    }
+    catch {
+        return {};
+    }
+}
+export function resource(app = { client: "opencode", version: "unknown", channel: "local" }) {
+    return {
+        serviceName: "opencode",
+        serviceVersion: app.version,
+        attributes: {
+            ...resourceAttributes(),
+            "deployment.environment.name": app.channel,
+            "opencode.client": app.client,
+            "opencode.run": runID,
+            "service.instance.id": runID,
+        },
+    };
+}
+export function loggers(options, app) {
+    if (!options?.endpoint)
+        return [];
+    return [
+        OtlpLogger.make({
+            url: `${options.endpoint}/v1/logs`,
+            resource: resource(app),
+            headers: parseHeaders(options.headers),
+        }),
+    ];
+}
+export async function tracingLayer(options, app) {
+    if (!options?.endpoint)
+        return Layer.empty;
+    const NodeSdk = await import("@effect/opentelemetry/NodeSdk");
+    const OTLP = await import("@opentelemetry/exporter-trace-otlp-http");
+    const SdkBase = await import("@opentelemetry/sdk-trace-base");
+    const { AsyncLocalStorageContextManager } = await import("@opentelemetry/context-async-hooks");
+    const { context } = await import("@opentelemetry/api");
+    // The Effect Node SDK does not register a global context manager, but the AI SDK uses it to parent spans.
+    const manager = new AsyncLocalStorageContextManager();
+    manager.enable();
+    context.setGlobalContextManager(manager);
+    return NodeSdk.layer(() => ({
+        resource: resource(app),
+        spanProcessor: new SdkBase.BatchSpanProcessor(new OTLP.OTLPTraceExporter({
+            url: `${options.endpoint}/v1/traces`,
+            headers: parseHeaders(options.headers),
+        })),
+    }));
+}
+export * as Otlp from "./otlp.js";

package/dist/observability/shared.d.ts

@@ -0,0 +1 @@
+export declare const runID: string;

package/dist/observability/shared.js

@@ -0,0 +1 @@
+export const runID = crypto.randomUUID().slice(0, 8);

package/dist/observability.d.ts

@@ -0,0 +1,13 @@
+export * as Observability from "./observability.js";
+import { LayerNode } from "./effect/layer-node.js";
+import { Layer, Schema } from "effect";
+export declare const Options: Schema.Struct<{
+    readonly endpoint: Schema.optional<Schema.String>;
+    readonly headers: Schema.optional<Schema.String>;
+    readonly client: Schema.optional<Schema.String>;
+    readonly version: Schema.optional<Schema.String>;
+    readonly channel: Schema.optional<Schema.String>;
+}>;
+export type Options = typeof Options.Type;
+export declare function layer(options?: Options): Layer.Layer<never, never, never>;
+export declare const node: LayerNode.Node<never, never, undefined>;

package/dist/observability.js

@@ -0,0 +1,31 @@
+export * as Observability from "./observability.js";
+import { NodeFileSystem } from "@effect/platform-node";
+import { LayerNode } from "./effect/layer-node.js";
+import { Effect, Layer, Logger, References, Schema } from "effect";
+import { FetchHttpClient } from "effect/unstable/http";
+import { OtlpSerialization } from "effect/unstable/observability";
+import { Logging } from "./observability/logging.js";
+import { Otlp } from "./observability/otlp.js";
+export const Options = Schema.Struct({
+    endpoint: Schema.optional(Schema.String),
+    headers: Schema.optional(Schema.String),
+    client: Schema.optional(Schema.String),
+    version: Schema.optional(Schema.String),
+    channel: Schema.optional(Schema.String),
+});
+export function layer(options = {
+    endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+    headers: process.env.OTEL_EXPORTER_OTLP_HEADERS,
+}) {
+    const app = {
+        client: options.client ?? "opencode",
+        version: options.version ?? "unknown",
+        channel: options.channel ?? "local",
+    };
+    const local = Logger.layer(Logging.loggers(app.channel === "local", app.channel), { mergeWithExisting: false }).pipe(Layer.provide(NodeFileSystem.layer), Layer.orDie, Layer.merge(Layer.succeed(References.MinimumLogLevel, Logging.minimumLogLevel())));
+    return Layer.unwrap(Effect.gen(function* () {
+        const logs = Logger.layer([...Logging.loggers(app.channel === "local", app.channel), ...Otlp.loggers(options, app)], { mergeWithExisting: false }).pipe(Layer.provide(NodeFileSystem.layer), Layer.provide(OtlpSerialization.layerJson), Layer.provide(FetchHttpClient.layer), Layer.orDie, Layer.merge(Layer.succeed(References.MinimumLogLevel, Logging.minimumLogLevel())));
+        return Layer.merge(logs, yield* Effect.promise(() => Otlp.tracingLayer(options, app)));
+    })).pipe(Layer.catchCause(() => local));
+}
+export const node = LayerNode.make({ name: "observability", layer: layer(), deps: [] });

package/dist/patch.d.ts

@@ -0,0 +1,42 @@
+export * as Patch from "./patch.js";
+import { Result, Schema } from "effect";
+declare const BoundaryError_base: Schema.Class<BoundaryError, Schema.TaggedStruct<"Patch.BoundaryError", {
+    readonly boundary: Schema.Literals<readonly ["first", "last"]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class BoundaryError extends BoundaryError_base {
+    get message(): string;
+}
+declare const InvalidHunkError_base: Schema.Class<InvalidHunkError, Schema.TaggedStruct<"Patch.InvalidHunkError", {
+    readonly line: Schema.String;
+    readonly lineNumber: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidHunkError extends InvalidHunkError_base {
+    get message(): string;
+}
+export type ParseError = BoundaryError | InvalidHunkError;
+export type Hunk = {
+    readonly type: "add";
+    readonly path: string;
+    readonly contents: string;
+} | {
+    readonly type: "delete";
+    readonly path: string;
+} | {
+    readonly type: "update";
+    readonly path: string;
+    readonly movePath?: string;
+    readonly chunks: ReadonlyArray<UpdateFileChunk>;
+};
+export interface UpdateFileChunk {
+    readonly oldLines: ReadonlyArray<string>;
+    readonly newLines: ReadonlyArray<string>;
+    readonly changeContext?: string;
+    readonly endOfFile?: boolean;
+}
+export interface FileUpdate {
+    readonly content: string;
+    readonly bom: boolean;
+}
+export declare function parse(patchText: string): Result.Result<ReadonlyArray<Hunk>, ParseError>;
+export declare function derive(path: string, chunks: ReadonlyArray<UpdateFileChunk>, original: string): FileUpdate;
+export declare function joinBom(text: string, bom: boolean): string;