@opencode/util 0.0.0-dev-21018 → 0.0.0-dev-21022

package/dist/npm.js

@@ -160,6 +160,7 @@ const layer = Layer.effect(Service, Effect.gen(function* () {
             ...(input.update ? { preferOnline: true, noGitRevCache: true } : {}),
             // Audit reports are unused here, but Arborist waits for them before completing an install.
             audit: false,
+            windowsHide: true,
         };
         const arborist = new Arborist({
             ...options,
@@ -284,7 +285,14 @@ const layer = Layer.effect(Service, Effect.gen(function* () {
         if (!installed)
             return yield* new InstallFailedError({ dir: root, cause: new Error(`Package is not installed: ${pkg}`) });
         const { manifest, resolve } = yield* Effect.promise(() => import("pacote"));
-        const options = { ...(yield* NpmConfig.load(root)), preferOnline: true, noGitRevCache: true, ignoreScripts: true };
+        const options = {
+            ...(yield* NpmConfig.load(root)),
+            preferOnline: true,
+            noGitRevCache: true,
+            ignoreScripts: true,
+            // Pacote spawns Git directly rather than through AppProcess.
+            windowsHide: true,
+        };
         const available = yield* Effect.tryPromise({
             try: async () => target.type === "git" ? gitRevision(await resolve(pkg, options)) : (await manifest(pkg, options)).version,
             catch: (cause) => new InstallFailedError({ dir: root, cause }),

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/util",
-  "version": "0.0.0-dev-21018",
+  "version": "0.0.0-dev-21022",
   "type": "module",
   "license": "MIT",
   "repository": {

package/dist/activity-calendar.test.d.ts

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

package/dist/activity-calendar.test.js

@@ -1,119 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { activityCalendar } from "./activity-calendar.js";
-const input = {
-    from: new Date(2026, 0, 1).getTime(),
-    to: new Date(2026, 0, 8).getTime(),
-    maxWeeks: 53,
-    activity: [
-        { date: "2026-01-01", steps: 1 },
-        { date: "2026-01-02", steps: 50 },
-    ],
-};
-describe("activity calendar", () => {
-    test("aligns Monday-first weeks and excludes cells outside the end-exclusive range", () => {
-        const calendar = activityCalendar(input);
-        expect(calendar.clipped).toBe(false);
-        expect(calendar.weeks).toHaveLength(2);
-        expect(calendar.weeks[0][0]).toEqual({ date: "2025-12-29", steps: 0, level: -1 });
-        expect(calendar.weeks[0][3]).toEqual({ date: "2026-01-01", steps: 1, level: 2 });
-        expect(calendar.weeks[0][4]).toEqual({ date: "2026-01-02", steps: 50, level: 4 });
-        expect(calendar.weeks[1][2]).toEqual({ date: "2026-01-07", steps: 0, level: 0 });
-        expect(calendar.weeks[1][3].level).toBe(-1);
-        expect(calendar.months).toEqual([{ week: 0, label: "Jan", span: 2 }]);
-    });
-    test("clips to the latest weeks and keeps empty days distinct from out-of-range cells", () => {
-        const calendar = activityCalendar({ ...input, activity: [], maxWeeks: 1 });
-        expect(calendar.clipped).toBe(true);
-        expect(calendar.weeks).toHaveLength(1);
-        expect(calendar.weeks[0][0]).toEqual({ date: "2026-01-05", steps: 0, level: 0 });
-        expect(calendar.weeks[0][3].level).toBe(-1);
-    });
-    test("caps long histories at 53 weeks", () => {
-        const calendar = activityCalendar({ ...input, from: new Date(2020, 0, 1).getTime(), maxWeeks: 200 });
-        expect(calendar.clipped).toBe(true);
-        expect(calendar.weeks).toHaveLength(53);
-        expect(calendar.weeks.at(-1)?.[2].date).toBe("2026-01-07");
-        expect(calendar.months.reduce((sum, month) => sum + month.span, 0)).toBe(53);
-    });
-    test("returns month positions and spans for partial first and last months", () => {
-        const calendar = activityCalendar({
-            ...input,
-            from: new Date(2026, 3, 29).getTime(),
-            to: new Date(2026, 4, 20).getTime(),
-        });
-        expect(calendar.months).toEqual([
-            { week: 0, label: "Apr", span: 1 },
-            { week: 1, label: "May", span: 3 },
-        ]);
-        const partial = activityCalendar({
-            ...input,
-            from: new Date(2026, 3, 1).getTime(),
-            to: new Date(2026, 3, 2).getTime(),
-        });
-        expect(partial.months).toEqual([{ week: 0, label: "Apr", span: 1 }]);
-    });
-    test("places month labels across a year boundary", () => {
-        const calendar = activityCalendar({
-            ...input,
-            from: new Date(2025, 11, 22).getTime(),
-            to: new Date(2026, 0, 12).getTime(),
-        });
-        expect(calendar.months).toEqual([
-            { week: 0, label: "Dec", span: 1 },
-            { week: 1, label: "Jan", span: 2 },
-        ]);
-    });
-    test("keeps exactly seven distinct cells per week across DST and leap days", () => {
-        const calendar = activityCalendar({
-            from: new Date(2024, 1, 26).getTime(),
-            to: new Date(2024, 2, 12).getTime(),
-            maxWeeks: 53,
-            activity: [
-                { date: "2024-02-29", steps: 1 },
-                { date: "2024-03-10", steps: 1 },
-            ],
-        });
-        expect(calendar.weeks).toHaveLength(3);
-        expect(calendar.weeks
-            .flat()
-            .filter((day) => day.steps > 0)
-            .map((day) => day.date)).toEqual(["2024-02-29", "2024-03-10"]);
-        expect(new Set(calendar.weeks.flat().map((day) => day.date)).size).toBe(21);
-    });
-    test("uses the highest intensity for a single distinct positive count", () => {
-        const calendar = activityCalendar({ ...input, activity: input.activity.map((day) => ({ ...day, steps: 10 })) });
-        expect(calendar.weeks
-            .flat()
-            .filter((day) => day.steps > 0)
-            .map((day) => day.level)).toEqual([4, 4]);
-    });
-    test("ranks distinct activity counts in four levels", () => {
-        const calendar = activityCalendar({
-            ...input,
-            to: new Date(2026, 0, 10).getTime(),
-            activity: Array.from({ length: 8 }, (_, index) => ({ date: `2026-01-0${index + 1}`, steps: index + 1 })),
-        });
-        expect(calendar.weeks
-            .flat()
-            .filter((day) => day.steps > 0)
-            .map((day) => day.level)).toEqual([1, 1, 2, 2, 3, 3, 4, 4]);
-    });
-    test("keeps intensity relative to the requested range when older weeks are clipped", () => {
-        const calendar = activityCalendar({
-            ...input,
-            maxWeeks: 1,
-            activity: [
-                { date: "2026-01-01", steps: 50 },
-                { date: "2026-01-05", steps: 1 },
-            ],
-        });
-        expect(calendar.weeks[0][0].level).toBe(2);
-    });
-    test("returns an empty calendar for an empty range", () => {
-        expect(activityCalendar({ ...input, to: input.from, activity: [] })).toEqual({
-            weeks: [],
-            months: [],
-            clipped: false,
-        });
-    });
-});

package/dist/artifact.test.d.ts

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

package/dist/artifact.test.js

@@ -1,28 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { artifactKind } from "./artifact.js";
-describe("artifactKind", () => {
-    test.each([
-        ["shot.PNG", "image"],
-        ["logo.svg", "svg"],
-        ["song.mp3", "audio"],
-        ["demo.mp4", "video"],
-        ["clip.webm", "video"],
-        ["paper.pdf", "pdf"],
-        ["out/index.html", "html"],
-        ["README.md", "markdown"],
-        ["flow.mmd", "mermaid"],
-        ["data.csv", "table"],
-        ["data.tsv", "table"],
-        ["Inter.woff2", "font"],
-        ["report.docx", "document"],
-        ["budget.XLSX", "spreadsheet"],
-        ["deck.pptx", "presentation"],
-        ["legacy.doc", "text"],
-        ["src/app.ts", "text"],
-        ["Makefile", "text"],
-        [".env", "text"],
-        ["archive.tar.gz", "text"],
-    ])("classifies %s as %s", (path, kind) => {
-        expect(artifactKind(path)).toBe(kind);
-    });
-});

package/dist/base64.test.d.ts

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

package/dist/base64.test.js

@@ -1,10 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { base64ToBytes, bytesToBase64 } from "./base64.js";
-describe("base64", () => {
-    test("encodes as standard base64 and decodes back to the same bytes", () => {
-        const bytes = Uint8Array.from({ length: 70_000 }, (_, index) => index % 256);
-        const encoded = bytesToBase64(bytes);
-        expect(encoded).toBe(Buffer.from(bytes).toString("base64"));
-        expect(base64ToBytes(encoded)).toEqual(bytes);
-    });
-});

package/dist/binary.test.d.ts

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

package/dist/binary.test.js

@@ -1,16 +0,0 @@
-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/bom.test.d.ts

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

package/dist/bom.test.js

@@ -1,19 +0,0 @@
-import { expect, test } from "bun:test";
-import { Bom } from "./bom.js";
-test.each([
-    { prefix: "", bom: false, expected: undefined },
-    { prefix: "", bom: true, expected: "\uFEFF" },
-    { prefix: "\uFEFF", bom: false, expected: "" },
-    { prefix: "\uFEFF", bom: true, expected: undefined },
-    { prefix: "\uFEFF\uFEFF", bom: false, expected: "" },
-    { prefix: "\uFEFF\uFEFF", bom: true, expected: "\uFEFF" },
-])("syncBytes(%j)", (row) => {
-    const encoder = new TextEncoder();
-    const text = "a\uFEFF\u00e9";
-    const input = encoder.encode(row.prefix + text);
-    expect(Bom.syncBytes(input, row.bom)).toEqual({
-        text,
-        bytes: row.expected === undefined ? undefined : encoder.encode(row.expected + text),
-    });
-    expect(input).toEqual(encoder.encode(row.prefix + text));
-});

package/dist/encode.test.d.ts

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

package/dist/encode.test.js

@@ -1,23 +0,0 @@
-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/open.test.d.ts

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

package/dist/open.test.js

@@ -1,14 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { openUrl } from "./open.js";
-describe("openUrl", () => {
-    test("rejects values that are not URLs", async () => {
-        await expect(openUrl("not a url")).rejects.toThrow("Only http and https links");
-        await expect(openUrl("")).rejects.toThrow("Only http and https links");
-    });
-    test("rejects non-http schemes", async () => {
-        await expect(openUrl("file:///etc/hosts")).rejects.toThrow("Only http and https links");
-        await expect(openUrl("javascript:alert(1)")).rejects.toThrow("Only http and https links");
-        await expect(openUrl("ms-msdt:/id PCWDiagnostic")).rejects.toThrow("Only http and https links");
-        await expect(openUrl("\\\\server\\share\\file.html")).rejects.toThrow("Only http and https links");
-    });
-});

package/dist/path.test.d.ts

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

package/dist/path.test.js

@@ -1,71 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { encodeFilePath, 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.each([
-        ["/repo/src/index.ts///", "index.ts"],
-        ["C:\\repo\\src\\index.ts", "index.ts"],
-        ["C:\\repo/src\\file", "file"],
-        ["C:/repo\\src/file/\\", "file"],
-        ["/", ""],
-        ["\\", ""],
-        ["/\\/\\", ""],
-        ["C:\\", "C:"],
-        ["file", "file"],
-        ["", ""],
-    ])("reads the filename from %j", (path, filename) => {
-        expect(getFilename(path)).toBe(filename);
-    });
-    test("keeps filename truncation stable", () => {
-        expect(getFilenameTruncated("/repo/long-component-name.tsx", 16)).toBe("long-compon….tsx");
-        expect(truncateMiddle("abcdefghijklmnop", 9)).toBe("abcd…mnop");
-    });
-});
-describe("encodeFilePath", () => {
-    const rows = [
-        ["/home/user/project/README.md", "/home/user/project/README.md"],
-        ["/home/user/file#name with spaces.txt", "/home/user/file%23name%20with%20spaces.txt"],
-        ["/path/to/file#with?special%chars&more.txt", "/path/to/file%23with%3Fspecial%25chars%26more.txt"],
-        ["/path/to/file?name.txt", "/path/to/file%3Fname.txt"],
-        ["/path/to/file%name.txt", "/path/to/file%25name.txt"],
-        ["/home/user/文档/README.md", "/home/user/%E6%96%87%E6%A1%A3/README.md"],
-        ["/", "/"],
-        ["", ""],
-        ["//path//to///file.txt", "//path//to///file.txt"],
-        ["src/components/App.tsx", "src/components/App.tsx"],
-        ["src\\components\\App.tsx", "src/components/App.tsx"],
-        ["D:\\dev\\projects\\opencode\\README.bs.md", "/D:/dev/projects/opencode/README.bs.md"],
-        ["D:\\dev\\projects\\opencode/README.bs.md", "/D:/dev/projects/opencode/README.bs.md"],
-        ["C:\\Program Files\\MyApp\\file with spaces.txt", "/C:/Program%20Files/MyApp/file%20with%20spaces.txt"],
-        ["D:\\projects\\file#name with ?marks.txt", "/D:/projects/file%23name%20with%20%3Fmarks.txt"],
-        ["C:\\", "/C:/"],
-        ["c:\\users\\test\\file.txt", "/c:/users/test/file.txt"],
-        ["D:", "/D:"],
-        ["C:\\Users\\test\\", "/C:/Users/test/"],
-        ["C:\\Users\\..\\test\\.\\file.txt", "/C:/Users/../test/./file.txt"],
-        ["/D:/path/file.txt", "/D:/path/file.txt"],
-    ];
-    test.each(rows)("encodes %p as %p", (input, expected) => {
-        expect(encodeFilePath(input)).toBe(expected);
-    });
-    test("every encoded path forms a file URL that keeps its query", () => {
-        rows.forEach(([input]) => {
-            const url = new URL(`file://${encodeFilePath(input)}?start=10`);
-            expect(url.protocol).toBe("file:");
-            expect(url.searchParams.get("start")).toBe("10");
-        });
-    });
-});

package/dist/retry.test.d.ts

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

package/dist/retry.test.js

@@ -1,63 +0,0 @@
-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("retries a real network failure wrapped as the cause of a transport error", async () => {
-        const server = Bun.listen({
-            hostname: "127.0.0.1",
-            port: 0,
-            socket: {
-                open(socket) {
-                    socket.terminate();
-                },
-                data() { },
-            },
-        });
-        const failures = [];
-        try {
-            await expect(retry(() => fetch(`http://127.0.0.1:${server.port}/api/project`).catch((cause) => {
-                failures.push(cause);
-                throw new Error("Transport", { cause });
-            }), { delay: 0 })).rejects.toThrow("Transport");
-        }
-        finally {
-            server.stop(true);
-        }
-        expect(failures).toHaveLength(3);
-        expect(failures.every((cause) => cause instanceof TypeError)).toBe(true);
-    });
-    test("does not retry a transport error whose cause is not transient", async () => {
-        const failures = [];
-        await expect(retry(async () => {
-            failures.push("attempt");
-            throw new Error("Transport", { cause: new Error("invalid response") });
-        })).rejects.toThrow("Transport");
-        expect(failures).toHaveLength(1);
-    });
-    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);
-    });
-});