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

package/dist/patch.js

@@ -0,0 +1,206 @@
+export * as Patch from "./patch.js";
+import { Result, Schema } from "effect";
+export class BoundaryError extends Schema.TaggedErrorClass()("Patch.BoundaryError", {
+    boundary: Schema.Literals(["first", "last"]),
+}) {
+    get message() {
+        return `The ${this.boundary} line of the patch must be '${this.boundary === "first" ? "*** Begin Patch" : "*** End Patch"}'`;
+    }
+}
+export class InvalidHunkError extends Schema.TaggedErrorClass()("Patch.InvalidHunkError", {
+    line: Schema.String,
+    lineNumber: Schema.Number,
+}) {
+    get message() {
+        return `Invalid hunk at line ${this.lineNumber}: '${this.line}' is not a valid hunk header. Valid hunk headers: '*** Add File: {path}', '*** Delete File: {path}', '*** Update File: {path}'`;
+    }
+}
+export function parse(patchText) {
+    const lines = stripHeredoc(patchText.trim())
+        .split("\n")
+        .map((line) => (line.endsWith("\r") ? line.slice(0, -1) : line));
+    const begin = lines[0]?.trim() === "*** Begin Patch" ? 0 : -1;
+    const end = lines.at(-1)?.trim() === "*** End Patch" ? lines.length - 1 : -1;
+    if (begin === -1)
+        return Result.fail(new BoundaryError({ boundary: "first" }));
+    if (end === -1 || begin >= end)
+        return Result.fail(new BoundaryError({ boundary: "last" }));
+    const hunks = [];
+    let index = begin + 1;
+    while (index < end) {
+        const line = lines[index];
+        const header = line.trim();
+        if (header.startsWith("*** Add File:")) {
+            const path = header.slice("*** Add File:".length).trim();
+            if (!path) {
+                index++;
+                continue;
+            }
+            const parsed = parseAdd(lines, index + 1, end);
+            hunks.push({ type: "add", path, contents: parsed.content });
+            index = parsed.next;
+            continue;
+        }
+        if (header.startsWith("*** Delete File:")) {
+            const path = header.slice("*** Delete File:".length).trim();
+            if (!path) {
+                index++;
+                continue;
+            }
+            hunks.push({ type: "delete", path });
+            index++;
+            continue;
+        }
+        if (header.startsWith("*** Update File:")) {
+            const path = header.slice("*** Update File:".length).trim();
+            if (!path) {
+                index++;
+                continue;
+            }
+            let next = index + 1;
+            let movePath;
+            if (lines[next]?.startsWith("*** Move to:")) {
+                movePath = lines[next].slice("*** Move to:".length).trim();
+                next++;
+            }
+            const parsed = parseUpdate(lines, next, end);
+            hunks.push({ type: "update", path, movePath, chunks: parsed.chunks });
+            index = parsed.next;
+            continue;
+        }
+        index++;
+    }
+    if (hunks.length === 0) {
+        const invalid = lines.findIndex((line, index) => index > begin && index < end && line.trim() !== "");
+        if (invalid !== -1) {
+            return Result.fail(new InvalidHunkError({ line: lines[invalid].trim(), lineNumber: invalid + 1 }));
+        }
+    }
+    return Result.succeed(hunks);
+}
+export function derive(path, chunks, original) {
+    const source = splitBom(original);
+    const lines = source.text.split("\n");
+    if (lines.at(-1) === "")
+        lines.pop();
+    const replacements = computeReplacements(lines, path, chunks);
+    const updated = [...lines];
+    for (const [start, remove, insert] of replacements.toReversed())
+        updated.splice(start, remove, ...insert);
+    if (updated.at(-1) !== "")
+        updated.push("");
+    const next = splitBom(updated.join("\n"));
+    return { content: next.text, bom: source.bom || next.bom };
+}
+export function joinBom(text, bom) {
+    const stripped = splitBom(text).text;
+    return bom ? `\uFEFF${stripped}` : stripped;
+}
+function parseAdd(lines, start, end) {
+    const content = [];
+    let index = start;
+    while (index < end && !lines[index].startsWith("***")) {
+        if (lines[index].startsWith("+"))
+            content.push(lines[index].slice(1));
+        index++;
+    }
+    return { content: content.join("\n"), next: index };
+}
+function parseUpdate(lines, start, end) {
+    const chunks = [];
+    let index = start;
+    while (index < end && !lines[index].startsWith("***")) {
+        if (!lines[index].startsWith("@@")) {
+            index++;
+            continue;
+        }
+        const changeContext = lines[index].slice(2).trim() || undefined;
+        const oldLines = [];
+        const newLines = [];
+        let endOfFile = false;
+        index++;
+        while (index < end && !lines[index].startsWith("@@") && !lines[index].startsWith("***")) {
+            const line = lines[index];
+            if (line.startsWith(" ")) {
+                oldLines.push(line.slice(1));
+                newLines.push(line.slice(1));
+            }
+            else if (line.startsWith("-"))
+                oldLines.push(line.slice(1));
+            else if (line.startsWith("+"))
+                newLines.push(line.slice(1));
+            index++;
+        }
+        if (lines[index]?.trim() === "*** End of File") {
+            endOfFile = true;
+            index++;
+        }
+        chunks.push({ oldLines, newLines, changeContext, endOfFile: endOfFile || undefined });
+    }
+    return { chunks, next: index };
+}
+function computeReplacements(lines, path, chunks) {
+    const replacements = [];
+    let lineIndex = 0;
+    for (const chunk of chunks) {
+        if (chunk.changeContext) {
+            const context = seek(lines, [chunk.changeContext], lineIndex);
+            if (context === -1)
+                throw new Error(`Failed to find context '${chunk.changeContext}' in ${path}`);
+            lineIndex = context + 1;
+        }
+        if (chunk.oldLines.length === 0) {
+            replacements.push([lines.length, 0, chunk.newLines]);
+            continue;
+        }
+        let oldLines = chunk.oldLines;
+        let newLines = chunk.newLines;
+        let found = seek(lines, oldLines, lineIndex, chunk.endOfFile);
+        if (found === -1 && oldLines.at(-1) === "") {
+            oldLines = oldLines.slice(0, -1);
+            if (newLines.at(-1) === "")
+                newLines = newLines.slice(0, -1);
+            found = seek(lines, oldLines, lineIndex, chunk.endOfFile);
+        }
+        if (found === -1)
+            throw new Error(`Failed to find expected lines in ${path}:\n${chunk.oldLines.join("\n")}`);
+        replacements.push([found, oldLines.length, newLines]);
+        lineIndex = found + oldLines.length;
+    }
+    return replacements.toSorted((left, right) => left[0] - right[0]);
+}
+function seek(lines, pattern, start, eof = false) {
+    if (pattern.length === 0)
+        return -1;
+    if (eof) {
+        const offset = lines.length - pattern.length;
+        if (offset < start)
+            return -1;
+        for (const compare of [exact, rstrip, trim, normalized]) {
+            if (matches(lines, pattern, offset, compare))
+                return offset;
+        }
+        return -1;
+    }
+    for (const compare of [exact, rstrip, trim, normalized]) {
+        for (let offset = start; offset <= lines.length - pattern.length; offset++) {
+            if (matches(lines, pattern, offset, compare))
+                return offset;
+        }
+    }
+    return -1;
+}
+function matches(lines, pattern, offset, compare) {
+    return pattern.every((line, index) => compare(lines[offset + index], line));
+}
+const exact = (left, right) => left === right;
+const rstrip = (left, right) => left.trimEnd() === right.trimEnd();
+const trim = (left, right) => left.trim() === right.trim();
+const normalized = (left, right) => normalize(left.trim()) === normalize(right.trim());
+const normalize = (value) => value
+    .replace(/[‘’‚‛]/g, "'")
+    .replace(/[“”„‟]/g, '"')
+    .replace(/[‐‑‒–—―−]/g, "-")
+    .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
+const splitBom = (text) => text.startsWith("\uFEFF") ? { bom: true, text: text.slice(1) } : { bom: false, text };
+const stripHeredoc = (input) => input.match(/^(?:cat\s+)?<<['"]?(\w+)['"]?\s*\n([\s\S]*?)\n\1\s*$/)?.[2] ?? input;

package/dist/process.d.ts

@@ -0,0 +1,54 @@
+import { Context, Duration, Effect, Schema, Stream } from "effect";
+import type { PlatformError } from "effect/PlatformError";
+import { ChildProcess } from "effect/unstable/process";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+declare const AppProcessError_base: Schema.Class<AppProcessError, Schema.TaggedStruct<"AppProcessError", {
+    readonly command: Schema.String;
+    readonly exitCode: Schema.optional<Schema.Number>;
+    readonly stderr: Schema.optional<Schema.String>;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class AppProcessError extends AppProcessError_base {
+    get message(): string;
+}
+export interface RunOptions {
+    readonly combineOutput?: boolean;
+    readonly maxOutputBytes?: number;
+    readonly maxErrorBytes?: number;
+    readonly signal?: AbortSignal;
+    readonly timeout?: Duration.Input;
+    readonly stdin?: string | Uint8Array | Stream.Stream<Uint8Array, PlatformError>;
+}
+export interface RunStreamOptions {
+    readonly signal?: AbortSignal;
+    readonly includeStderr?: boolean;
+    readonly okExitCodes?: ReadonlyArray<number>;
+    readonly maxErrorBytes?: number;
+}
+export interface RunResult {
+    readonly command: string;
+    readonly exitCode: number;
+    readonly output?: Buffer;
+    readonly stdout: Buffer;
+    readonly stderr: Buffer;
+    readonly outputTruncated?: boolean;
+    readonly stdoutTruncated: boolean;
+    readonly stderrTruncated: boolean;
+}
+export type Interface = ChildProcessSpawner["Service"] & {
+    readonly run: (command: ChildProcess.Command, options?: RunOptions) => Effect.Effect<RunResult, AppProcessError>;
+    readonly runStream: (command: ChildProcess.Command, options?: RunStreamOptions) => Stream.Stream<string, AppProcessError>;
+};
+declare const Service_base: Context.ServiceClass<Service, "@opencode/AppProcess", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const requireSuccess: (result: RunResult) => Effect.Effect<RunResult, AppProcessError>;
+export declare const requireExitIn: (codes: ReadonlyArray<number>) => (result: RunResult) => Effect.Effect<RunResult, AppProcessError>;
+export declare const abortError: (signal: AbortSignal) => Error;
+export declare const waitForAbort: (signal: AbortSignal) => Effect.Effect<never, Error, never>;
+export declare const collectStream: (stream: Stream.Stream<Uint8Array, PlatformError>, maxOutputBytes: number | undefined) => Effect.Effect<{
+    buffer: Buffer<ArrayBuffer>;
+    truncated: boolean;
+}, PlatformError, never>;
+export declare const node: import("./effect/layer-node.js").Node<Service, never, import("./effect/layer-node.js").Tag<"global">>;
+export * as AppProcess from "./process.js";

package/dist/process.js

@@ -0,0 +1,162 @@
+import { Context, Duration, Effect, Fiber, Layer, Schema, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import { CrossSpawnSpawner } from "./cross-spawn-spawner.js";
+import { makeGlobalNode } from "./effect/app-node.js";
+export class AppProcessError extends Schema.TaggedErrorClass()("AppProcessError", {
+    command: Schema.String,
+    exitCode: Schema.optional(Schema.Number),
+    stderr: Schema.optional(Schema.String),
+    cause: Schema.optional(Schema.Defect()),
+}) {
+    get message() {
+        const detail = this.stderr?.trim() || (this.cause instanceof Error ? this.cause.message : this.cause && String(this.cause));
+        const status = this.exitCode === undefined ? "" : ` (exit ${this.exitCode})`;
+        return `Command failed${status}: ${this.command}${detail ? `: ${detail}` : ""}`;
+    }
+}
+export class Service extends Context.Service()("@opencode/AppProcess") {
+}
+export const requireSuccess = (result) => result.exitCode === 0
+    ? Effect.succeed(result)
+    : Effect.fail(new AppProcessError({
+        command: result.command,
+        exitCode: result.exitCode,
+        stderr: result.stderr.toString("utf8"),
+    }));
+export const requireExitIn = (codes) => (result) => codes.includes(result.exitCode)
+    ? Effect.succeed(result)
+    : Effect.fail(new AppProcessError({
+        command: result.command,
+        exitCode: result.exitCode,
+        stderr: result.stderr.toString("utf8"),
+    }));
+const describeCommand = (command) => {
+    if (command._tag === "StandardCommand") {
+        return command.args.length ? `${command.command} ${command.args.join(" ")}` : command.command;
+    }
+    return `${describeCommand(command.left)} | ${describeCommand(command.right)}`;
+};
+const wrapError = (description, cause) => cause instanceof AppProcessError ? cause : new AppProcessError({ command: description, cause });
+export const abortError = (signal) => {
+    const reason = signal.reason;
+    if (reason instanceof Error)
+        return reason;
+    const err = new Error("Aborted");
+    err.name = "AbortError";
+    return err;
+};
+export const waitForAbort = (signal) => Effect.callback((resume) => {
+    if (signal.aborted) {
+        resume(Effect.fail(abortError(signal)));
+        return;
+    }
+    const onabort = () => resume(Effect.fail(abortError(signal)));
+    signal.addEventListener("abort", onabort, { once: true });
+    return Effect.sync(() => signal.removeEventListener("abort", onabort));
+});
+const normalizeStdin = (input) => typeof input === "string"
+    ? Stream.make(new TextEncoder().encode(input))
+    : input instanceof Uint8Array
+        ? Stream.make(input)
+        : input;
+export const collectStream = (stream, maxOutputBytes) => Stream.runFold(stream, () => ({ chunks: [], bytes: 0, truncated: false }), (acc, chunk) => {
+    if (maxOutputBytes === undefined) {
+        acc.chunks.push(chunk);
+        acc.bytes += chunk.length;
+        return acc;
+    }
+    const remaining = maxOutputBytes - acc.bytes;
+    if (remaining > 0)
+        acc.chunks.push(remaining >= chunk.length ? chunk : chunk.slice(0, remaining));
+    acc.bytes += chunk.length;
+    acc.truncated = acc.truncated || acc.bytes > maxOutputBytes;
+    return acc;
+}).pipe(Effect.map((x) => ({ buffer: Buffer.concat(x.chunks), truncated: x.truncated })));
+const layer = Layer.effect(Service, Effect.gen(function* () {
+    const spawner = yield* ChildProcessSpawner;
+    const runCommand = (command, options) => {
+        const description = describeCommand(command);
+        const collect = Effect.scoped(Effect.gen(function* () {
+            const handle = yield* spawner.spawn(command);
+            if (options?.combineOutput) {
+                const [output, exitCode] = yield* Effect.all([collectStream(handle.all, options.maxOutputBytes), handle.exitCode], { concurrency: "unbounded" });
+                return {
+                    command: description,
+                    exitCode,
+                    output: output.buffer,
+                    stdout: Buffer.alloc(0),
+                    stderr: Buffer.alloc(0),
+                    outputTruncated: output.truncated,
+                    stdoutTruncated: false,
+                    stderrTruncated: false,
+                };
+            }
+            const [stdout, stderr, exitCode] = yield* Effect.all([
+                collectStream(handle.stdout, options?.maxOutputBytes),
+                collectStream(handle.stderr, options?.maxErrorBytes),
+                handle.exitCode,
+            ], { concurrency: "unbounded" });
+            return {
+                command: description,
+                exitCode,
+                stdout: stdout.buffer,
+                stderr: stderr.buffer,
+                stdoutTruncated: stdout.truncated,
+                stderrTruncated: stderr.truncated,
+            };
+        }));
+        const timed = options?.timeout
+            ? Effect.timeoutOrElse(collect, {
+                duration: options.timeout,
+                orElse: () => Effect.fail(new AppProcessError({ command: description, cause: new Error("Timed out") })),
+            })
+            : collect;
+        const aborted = options?.signal
+            ? timed.pipe(Effect.raceFirst(waitForAbort(options.signal).pipe(Effect.mapError((cause) => wrapError(description, cause)))))
+            : timed;
+        return aborted.pipe(Effect.catch((cause) => Effect.fail(wrapError(description, cause))));
+    };
+    const run = Effect.fn("AppProcess.run")(function* (command, options) {
+        if (options?.stdin === undefined)
+            return yield* runCommand(command, options);
+        if (command._tag !== "StandardCommand") {
+            return yield* new AppProcessError({
+                command: describeCommand(command),
+                cause: new Error("stdin option only supports StandardCommand; received PipedCommand"),
+            });
+        }
+        const next = ChildProcess.make(command.command, command.args, {
+            ...command.options,
+            stdin: normalizeStdin(options.stdin),
+        });
+        return yield* runCommand(next, options);
+    });
+    const runStream = (command, options) => {
+        const description = describeCommand(command);
+        const okExitCodes = options?.okExitCodes;
+        const built = Stream.unwrap(Effect.gen(function* () {
+            const handle = yield* spawner.spawn(command);
+            const stderrFiber = yield* Effect.forkScoped(collectStream(handle.stderr, options?.maxErrorBytes).pipe(Effect.map((x) => x.buffer.toString("utf8"))));
+            const source = options?.includeStderr === true ? handle.all : handle.stdout;
+            const lines = source.pipe(Stream.decodeText, Stream.splitLines, Stream.filter((line) => line.length > 0));
+            const tail = Stream.unwrap(Effect.gen(function* () {
+                const code = yield* handle.exitCode;
+                if (okExitCodes && okExitCodes.length > 0 && !okExitCodes.includes(code)) {
+                    const stderr = yield* Fiber.join(stderrFiber);
+                    return Stream.fail(new AppProcessError({ command: description, exitCode: code, stderr }));
+                }
+                return Stream.empty;
+            }));
+            return Stream.concat(lines, tail);
+        }));
+        const mapped = built.pipe(Stream.catch((cause) => Stream.fail(wrapError(description, cause))));
+        if (!options?.signal)
+            return mapped;
+        const signal = options.signal;
+        return mapped.pipe(Stream.interruptWhen(waitForAbort(signal).pipe(Effect.mapError((cause) => wrapError(description, cause)))));
+    };
+    return Service.of({ ...spawner, run, runStream });
+}));
+export const node = makeGlobalNode({ service: Service, layer: layer, deps: [CrossSpawnSpawner.node] });
+export * as AppProcess from "./process.js";

package/dist/runtime/import.bun.d.ts

@@ -0,0 +1,2 @@
+export declare function importModule(specifier: string): Promise<unknown>;
+export declare function resolveModule(specifier: string, directory: string): string;

package/dist/runtime/import.bun.js

@@ -0,0 +1,6 @@
+export function importModule(specifier) {
+    return import(specifier);
+}
+export function resolveModule(specifier, directory) {
+    return import.meta.resolve(specifier, directory);
+}

package/dist/runtime/import.node.d.ts

@@ -0,0 +1,2 @@
+export declare function importModule(specifier: string): Promise<unknown>;
+export declare function resolveModule(specifier: string, directory: string): string;

package/dist/runtime/import.node.js

@@ -0,0 +1,36 @@
+import { Script, constants } from "node:vm";
+import { createRequire, registerHooks } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { resolve } from "resolve.exports";
+let conditions = [];
+const conditionHooks = registerHooks({
+    resolve(specifier, context, nextResolve) {
+        conditions = context.conditions;
+        return nextResolve(specifier, context);
+    },
+});
+await new Script('import("node:module")', {
+    importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER,
+}).runInThisContext();
+conditionHooks.deregister();
+export async function importModule(specifier) {
+    const imported = (await new Script(`import(${JSON.stringify(specifier)})`, {
+        importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER,
+    }).runInThisContext());
+    if (typeof imported !== "object" || imported === null)
+        return imported;
+    const module = imported;
+    const exports = module["module.exports"];
+    if (exports !== module.default || (typeof exports !== "object" && typeof exports !== "function") || exports === null)
+        return imported;
+    return Object.assign({}, module, exports);
+}
+export function resolveModule(specifier, directory) {
+    const pkg = createRequire(import.meta.url)(path.join(directory, "package.json"));
+    const target = resolve(pkg, specifier, { conditions, unsafe: true })?.[0];
+    if (target)
+        return pathToFileURL(path.resolve(directory, target)).href;
+    const legacyTarget = specifier === pkg.name ? directory : path.resolve(directory, specifier.slice(pkg.name.length + 1));
+    return pathToFileURL(createRequire(path.join(directory, "package.json")).resolve(legacyTarget)).href;
+}

package/dist/runtime-import.d.ts

@@ -0,0 +1 @@
+export { importModule, resolveModule } from "#runtime-import";

package/dist/runtime-import.js

@@ -0,0 +1 @@
+export { importModule, resolveModule } from "#runtime-import";

package/package.json

@@ -1,17 +1,66 @@
 {
+  "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/util",
-  "version": "0.0.0-bootstrap.0",
-  "description": "OpenCode package namespace bootstrap",
+  "version": "0.0.0-next-15994",
+  "type": "module",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/anomalyco/opencode.git"
+    "url": "git+https://github.com/anomalyco/opencode.git",
+    "directory": "packages/util"
   },
-  "files": [
-    "index.js"
-  ],
-  "exports": "./index.js",
   "publishConfig": {
     "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./effect/layer-node": {
+      "import": "./dist/effect/layer-node.js",
+      "types": "./dist/effect/layer-node.d.ts"
+    },
+    "./*": {
+      "import": "./dist/*.js",
+      "types": "./dist/*.d.ts"
+    }
+  },
+  "imports": {
+    "#runtime-import": {
+      "bun": "./dist/runtime/import.bun.js",
+      "node": "./dist/runtime/import.node.js",
+      "default": "./dist/runtime/import.bun.js"
+    }
+  },
+  "scripts": {
+    "build": "bun run script/build.ts",
+    "typecheck": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "@effect/opentelemetry": "4.0.0-beta.98",
+    "@effect/platform-node": "4.0.0-beta.98",
+    "@npmcli/arborist": "9.4.0",
+    "@npmcli/config": "10.8.1",
+    "@opentelemetry/api": "1.9.0",
+    "@opentelemetry/context-async-hooks": "2.6.1",
+    "@opentelemetry/exporter-trace-otlp-http": "0.214.0",
+    "@opentelemetry/sdk-trace-base": "2.6.1",
+    "cross-spawn": "7.0.6",
+    "effect": "4.0.0-beta.98",
+    "glob": "13.0.5",
+    "mime-types": "3.0.2",
+    "minimatch": "10.2.5",
+    "npm-package-arg": "13.0.2",
+    "resolve.exports": "2.0.3",
+    "xdg-basedir": "5.1.0"
+  },
+  "devDependencies": {
+    "@tsconfig/bun": "1.0.9",
+    "@types/bun": "1.3.13",
+    "@types/cross-spawn": "6.0.6",
+    "@types/node": "24.12.2",
+    "@types/npm-package-arg": "6.1.4",
+    "@types/npmcli__arborist": "6.3.3",
+    "@typescript/native-preview": "7.0.0-dev.20251207.1"
   }
 }

package/index.js

@@ -1 +0,0 @@
-export {}