@opencode-ai/util 0.0.0-dev-17545 → 0.0.0-dev-17603

package/dist/binary.d.ts

@@ -0,0 +1,7 @@
+export declare namespace Binary {
+    function search<T>(array: T[], id: string, compare: (item: T) => string): {
+        found: boolean;
+        index: number;
+    };
+    function insert<T>(array: T[], item: T, compare: (item: T) => string): T[];
+}

package/dist/binary.js

@@ -0,0 +1,34 @@
+export var Binary;
+(function (Binary) {
+    function search(array, id, compare) {
+        let left = 0;
+        let right = array.length - 1;
+        while (left <= right) {
+            const middle = Math.floor((left + right) / 2);
+            const value = compare(array[middle]);
+            if (value === id)
+                return { found: true, index: middle };
+            if (value < id)
+                left = middle + 1;
+            else
+                right = middle - 1;
+        }
+        return { found: false, index: left };
+    }
+    Binary.search = search;
+    function insert(array, item, compare) {
+        const id = compare(item);
+        let left = 0;
+        let right = array.length;
+        while (left < right) {
+            const middle = Math.floor((left + right) / 2);
+            if (compare(array[middle]) < id)
+                left = middle + 1;
+            else
+                right = middle;
+        }
+        array.splice(left, 0, item);
+        return array;
+    }
+    Binary.insert = insert;
+})(Binary || (Binary = {}));

package/dist/binary.test.d.ts

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

package/dist/binary.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test";
+import { Binary } from "./binary.js";
+describe("binary search", () => {
+    test("finds sorted values and their insertion points", () => {
+        const values = [{ id: "a" }, { id: "c" }, { id: "e" }];
+        expect(Binary.search(values, "c", (item) => item.id)).toEqual({ found: true, index: 1 });
+        expect(Binary.search(values, "d", (item) => item.id)).toEqual({ found: false, index: 2 });
+        expect(Binary.search(values, "0", (item) => item.id)).toEqual({ found: false, index: 0 });
+    });
+    test("inserts before the first matching sorted value", () => {
+        const values = [{ id: "a" }, { id: "c" }, { id: "c" }, { id: "e" }];
+        const item = { id: "c" };
+        expect(Binary.insert(values, item, (value) => value.id)).toBe(values);
+        expect(values).toEqual([{ id: "a" }, item, { id: "c" }, { id: "c" }, { id: "e" }]);
+    });
+});

package/dist/effect-flock.js

@@ -11,17 +11,17 @@ export var EffectFlock;
     // ---------------------------------------------------------------------------
     // Errors
     // ---------------------------------------------------------------------------
-    class LockTimeoutError extends Schema.TaggedErrorClass()("LockTimeoutError", {
+    class LockTimeoutError extends Schema.TaggedError()("LockTimeoutError", {
         key: Schema.String,
     }) {
     }
     EffectFlock.LockTimeoutError = LockTimeoutError;
-    class LockCompromisedError extends Schema.TaggedErrorClass()("LockCompromisedError", {
+    class LockCompromisedError extends Schema.TaggedError()("LockCompromisedError", {
         detail: Schema.String,
     }) {
     }
     EffectFlock.LockCompromisedError = LockCompromisedError;
-    class ReleaseError extends Schema.TaggedErrorClass()("ReleaseError", {
+    class ReleaseError extends Schema.TaggedError()("ReleaseError", {
         detail: Schema.String,
         cause: Schema.optional(Schema.Defect()),
     }) {
@@ -30,7 +30,7 @@ export var EffectFlock;
         }
     }
     /** Internal: signals "lock is held, retry later". Never leaks to callers. */
-    class NotAcquired extends Schema.TaggedErrorClass()("NotAcquired", {}) {
+    class NotAcquired extends Schema.TaggedError()("NotAcquired", {}) {
     }
     // ---------------------------------------------------------------------------
     // Timing defaults

package/dist/encode.d.ts

@@ -0,0 +1,4 @@
+export declare function base64Encode(value: string): string;
+export declare function base64Decode(value: string): string;
+export declare function checksum(content: string): string | undefined;
+export declare function sampledChecksum(content: string, limit?: number): string | undefined;

package/dist/encode.js

@@ -0,0 +1,38 @@
+export function base64Encode(value) {
+    const bytes = new TextEncoder().encode(value);
+    const binary = Array.from(bytes, (byte) => String.fromCharCode(byte)).join("");
+    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+export function base64Decode(value) {
+    const binary = atob(value.replace(/-/g, "+").replace(/_/g, "/"));
+    return new TextDecoder().decode(Uint8Array.from(binary, (character) => character.charCodeAt(0)));
+}
+export function checksum(content) {
+    if (!content)
+        return;
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < content.length; index++) {
+        hash ^= content.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(36);
+}
+export function sampledChecksum(content, limit = 500_000) {
+    if (!content)
+        return;
+    if (content.length <= limit)
+        return checksum(content);
+    const size = 4096;
+    return `${content.length}:${[
+        0,
+        Math.floor(content.length * 0.25),
+        Math.floor(content.length * 0.5),
+        Math.floor(content.length * 0.75),
+        content.length - size,
+    ]
+        .map((point) => {
+        const start = Math.max(0, Math.min(content.length - size, point - Math.floor(size / 2)));
+        return checksum(content.slice(start, start + size)) ?? "";
+    })
+        .join(":")}`;
+}

package/dist/encode.test.d.ts

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

package/dist/encode.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, test } from "bun:test";
+import { base64Decode, base64Encode, checksum, sampledChecksum } from "./encode.js";
+describe("frontend encoding", () => {
+    test("uses unpadded URL-safe UTF-8 base64", () => {
+        expect(base64Encode("hello")).toBe("aGVsbG8");
+        expect(base64Encode("✓ à la mode")).toBe("4pyTIMOgIGxhIG1vZGU");
+        expect(base64Decode("4pyTIMOgIGxhIG1vZGU")).toBe("✓ à la mode");
+        expect(base64Decode("dXNlcjpwYXNz")).toBe("user:pass");
+    });
+    test("rejects invalid base64", () => {
+        expect(() => base64Decode("%%%")).toThrow();
+    });
+    test("keeps stable FNV checksums", () => {
+        expect(checksum("")).toBeUndefined();
+        expect(checksum("hello")).toBe("m3bicr");
+        expect(checksum("✓ à la mode")).toBe("jmczk0");
+    });
+    test("samples large values without changing the size boundary", () => {
+        const value = "abcdef".repeat(100);
+        expect(sampledChecksum(value, value.length)).toBe(checksum(value));
+        expect(sampledChecksum(value, value.length - 1)).toBe("600:1isj1k5:1isj1k5:1isj1k5:1isj1k5:1isj1k5");
+    });
+});

package/dist/fs-util.js

@@ -10,7 +10,7 @@ import { makeGlobalNode } from "./effect/app-node.js";
 import { filesystem } from "./effect/app-node-platform.js";
 export var FSUtil;
 (function (FSUtil) {
-    class FileSystemError extends Schema.TaggedErrorClass()("FileSystemError", {
+    class FileSystemError extends Schema.TaggedError()("FileSystemError", {
         method: Schema.String,
         cause: Schema.optional(Schema.Defect()),
     }) {

package/dist/npm.js

@@ -11,7 +11,7 @@ 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", {
+export class InstallFailedError extends Schema.TaggedError()("NpmInstallFailedError", {
     add: Schema.Array(Schema.String).pipe(Schema.optional),
     dir: Schema.String,
     cause: Schema.optional(Schema.Defect()),

package/dist/observability/otlp.d.ts

@@ -13,6 +13,6 @@ export declare function resource(app?: App): {
     serviceVersion: string;
     attributes: Record<string, string>;
 };
-export declare function loggers(options: Options | undefined, app: App): Effect.Effect<import("effect/Logger").Logger<unknown, void>, never, import("effect/unstable/http/HttpClient").HttpClient | Scope.Scope | import("effect/unstable/observability/OtlpSerialization").OtlpSerialization>[];
+export declare function loggers(options: Options | undefined, app: App): Effect.Effect<import("effect/Logger").Logger<unknown, void>, never, import("effect/unstable/http/HttpClient").HttpClient | Scope.Scope | import("effect/unstable/observability/OtlpExporter").Flusher | import("effect/unstable/observability/OtlpSerialization").OtlpSerialization>[];
 export declare const tracingLayer: (options: Options | undefined, app: App) => Effect.Effect<Layer.Layer<never, never, never>, never, never>;
 export * as Otlp from "./otlp.js";

package/dist/observability.js

@@ -3,7 +3,7 @@ import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
 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 { OtlpExporter, OtlpSerialization } from "effect/unstable/observability";
 import { Logging } from "./observability/logging.js";
 import { Otlp } from "./observability/otlp.js";
 export const Options = Schema.Struct({
@@ -24,7 +24,7 @@ export function layer(options = {
     };
     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())));
+        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.provide(OtlpExporter.layerFlusher), Layer.orDie, Layer.merge(Layer.succeed(References.MinimumLogLevel, Logging.minimumLogLevel())));
         return Layer.merge(logs, yield* Otlp.tracingLayer(options, app));
     })).pipe(Layer.catchCause(() => local));
 }

package/dist/patch.js

@@ -1,14 +1,14 @@
 export * as Patch from "./patch.js";
 import { Result, Schema } from "effect";
 import { Bom } from "./bom.js";
-export class BoundaryError extends Schema.TaggedErrorClass()("Patch.BoundaryError", {
+export class BoundaryError extends Schema.TaggedError()("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", {
+export class InvalidHunkError extends Schema.TaggedError()("Patch.InvalidHunkError", {
     line: Schema.String,
     lineNumber: Schema.Number,
     reason: Schema.optional(Schema.String),

package/dist/path.d.ts

@@ -0,0 +1,4 @@
+export declare function getFilename(path: string | undefined): string;
+export declare function getDirectory(path: string | undefined): string;
+export declare function getFilenameTruncated(path: string | undefined, maxLength?: number): string;
+export declare function truncateMiddle(text: string, maxLength?: number): string;

package/dist/path.js

@@ -0,0 +1,33 @@
+export function getFilename(path) {
+    if (!path)
+        return "";
+    const trimmed = path.replace(/[/\\]+$/, "");
+    const parts = trimmed.split(/[/\\]/);
+    return parts[parts.length - 1] ?? "";
+}
+export function getDirectory(path) {
+    if (!path)
+        return "";
+    const trimmed = path.replace(/[/\\]+$/, "");
+    const parts = trimmed.split(/[/\\]/);
+    return parts.slice(0, parts.length - 1).join("/") + "/";
+}
+export function getFilenameTruncated(path, maxLength = 20) {
+    const filename = getFilename(path);
+    if (filename.length <= maxLength)
+        return filename;
+    const lastDot = filename.lastIndexOf(".");
+    const extension = lastDot <= 0 ? "" : filename.slice(lastDot);
+    const available = maxLength - extension.length - 1;
+    if (available <= 0)
+        return filename.slice(0, maxLength - 1) + "…";
+    return filename.slice(0, available) + "…" + extension;
+}
+export function truncateMiddle(text, maxLength = 20) {
+    if (text.length <= maxLength)
+        return text;
+    const available = maxLength - 1;
+    const start = Math.ceil(available / 2);
+    const end = Math.floor(available / 2);
+    return text.slice(0, start) + "…" + text.slice(-end);
+}

package/dist/path.test.d.ts

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

package/dist/path.test.js

@@ -0,0 +1,22 @@
+import { describe, expect, test } from "bun:test";
+import { getDirectory, getFilename, getFilenameTruncated, truncateMiddle } from "./path.js";
+describe("client paths", () => {
+    test("reads POSIX and Windows paths with the same rules", () => {
+        expect(getFilename("/repo/src/index.ts")).toBe("index.ts");
+        expect(getFilename("C:\\repo\\src\\index.ts\\")).toBe("index.ts");
+        expect(getDirectory("/repo/src/index.ts")).toBe("/repo/src/");
+        expect(getDirectory("C:\\repo\\src\\index.ts")).toBe("C:/repo/src/");
+    });
+    test("preserves root, UNC, mixed, and single-segment behavior", () => {
+        expect(getFilename("\\\\server\\share\\file")).toBe("file");
+        expect(getDirectory("\\\\server\\share\\file")).toBe("//server/share/");
+        expect(getDirectory("C:\\repo/src\\file")).toBe("C:/repo/src/");
+        expect(getDirectory("file")).toBe("/");
+        expect(getFilename(undefined)).toBe("");
+        expect(getDirectory("")).toBe("");
+    });
+    test("keeps filename truncation stable", () => {
+        expect(getFilenameTruncated("/repo/long-component-name.tsx", 16)).toBe("long-compon….tsx");
+        expect(truncateMiddle("abcdefghijklmnop", 9)).toBe("abcd…mnop");
+    });
+});

package/dist/process.js

@@ -3,7 +3,7 @@ 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", {
+export class AppProcessError extends Schema.TaggedError()("AppProcessError", {
     command: Schema.String,
     exitCode: Schema.optional(Schema.Number),
     stderr: Schema.optional(Schema.String),

package/dist/retry.d.ts

@@ -0,0 +1,8 @@
+export interface RetryOptions {
+    attempts?: number;
+    delay?: number;
+    factor?: number;
+    maxDelay?: number;
+    retryIf?: (error: unknown) => boolean;
+}
+export declare function retry<T>(operation: () => Promise<T>, options?: RetryOptions): Promise<T>;

package/dist/retry.js

@@ -0,0 +1,37 @@
+const transientMessages = [
+    "load failed",
+    "network connection was lost",
+    "network request failed",
+    "failed to fetch",
+    "econnreset",
+    "econnrefused",
+    "etimedout",
+    "socket hang up",
+];
+function isTransientError(error) {
+    if (!error)
+        return false;
+    // oxlint-disable-next-line no-base-to-string -- Error input is intentionally normalized for message matching.
+    const message = String(error instanceof Error ? error.message : error).toLowerCase();
+    return transientMessages.some((item) => message.includes(item));
+}
+export async function retry(operation, options = {}) {
+    const attempts = options.attempts ?? 3;
+    const delay = options.delay ?? 500;
+    const factor = options.factor ?? 2;
+    const maxDelay = options.maxDelay ?? 10_000;
+    const retryIf = options.retryIf ?? isTransientError;
+    let lastError;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === attempts - 1 || !retryIf(error))
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, Math.min(delay * Math.pow(factor, attempt), maxDelay)));
+        }
+    }
+    throw lastError;
+}

package/dist/retry.test.d.ts

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

package/dist/retry.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import { retry } from "./retry.js";
+describe("client retry", () => {
+    test("retries transient failures up to the configured attempt count", async () => {
+        const failures = [];
+        const value = await retry(async () => {
+            failures.push("attempt");
+            if (failures.length < 3)
+                throw new Error("Failed to fetch");
+            return "ready";
+        }, { delay: 0 });
+        expect(value).toBe("ready");
+        expect(failures).toHaveLength(3);
+    });
+    test("does not retry other failures", async () => {
+        const failures = [];
+        await expect(retry(async () => {
+            failures.push("attempt");
+            throw new Error("invalid response");
+        })).rejects.toThrow("invalid response");
+        expect(failures).toHaveLength(1);
+    });
+    test("uses a caller-owned retry condition", async () => {
+        const failures = [];
+        await expect(retry(async () => {
+            failures.push("attempt");
+            throw new Error("retry me");
+        }, { attempts: 2, delay: 0, retryIf: () => true })).rejects.toThrow("retry me");
+        expect(failures).toHaveLength(2);
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/util",
-  "version": "0.0.0-dev-17545",
+  "version": "0.0.0-dev-17603",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -43,8 +43,8 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@effect/opentelemetry": "4.0.0-beta.101",
-    "@effect/platform-node": "4.0.0-beta.101",
+    "@effect/opentelemetry": "4.0.0-beta.107",
+    "@effect/platform-node": "4.0.0-beta.107",
     "@npmcli/arborist": "9.4.0",
     "@npmcli/config": "10.8.1",
     "@opentelemetry/api": "1.9.0",
@@ -53,7 +53,7 @@
     "@opentelemetry/sdk-trace-base": "2.6.1",
     "@opentelemetry/sdk-trace-node": "2.6.1",
     "cross-spawn": "7.0.6",
-    "effect": "4.0.0-beta.101",
+    "effect": "4.0.0-beta.107",
     "glob": "13.0.5",
     "mime-types": "3.0.2",
     "minimatch": "10.2.5",