@opencode/util 2.0.21 → 2.0.22

package/dist/artifact.d.ts

@@ -0,0 +1,4 @@
+/** How the app shows a file, from its extension. */
+export type ArtifactKind = "image" | "svg" | "audio" | "video" | "pdf" | "html" | "markdown" | "mermaid" | "table" | "font" | "text";
+export declare function artifactMime(path: string): string | undefined;
+export declare function artifactKind(path: string): ArtifactKind;

package/dist/artifact.js

@@ -0,0 +1,77 @@
+const mimes = new Map([
+    ["png", "image/png"],
+    ["jpg", "image/jpeg"],
+    ["jpeg", "image/jpeg"],
+    ["gif", "image/gif"],
+    ["webp", "image/webp"],
+    ["avif", "image/avif"],
+    ["bmp", "image/bmp"],
+    ["ico", "image/x-icon"],
+    ["tif", "image/tiff"],
+    ["tiff", "image/tiff"],
+    ["heic", "image/heic"],
+    ["svg", "image/svg+xml"],
+    ["mp3", "audio/mpeg"],
+    ["wav", "audio/wav"],
+    ["ogg", "audio/ogg"],
+    ["oga", "audio/ogg"],
+    ["m4a", "audio/mp4"],
+    ["aac", "audio/aac"],
+    ["flac", "audio/flac"],
+    ["opus", "audio/ogg"],
+    ["weba", "audio/webm"],
+    ["mp4", "video/mp4"],
+    ["m4v", "video/mp4"],
+    ["webm", "video/webm"],
+    ["mov", "video/quicktime"],
+    ["ogv", "video/ogg"],
+    ["mkv", "video/x-matroska"],
+    ["pdf", "application/pdf"],
+    ["html", "text/html"],
+    ["htm", "text/html"],
+    ["md", "text/markdown"],
+    ["markdown", "text/markdown"],
+    ["mdx", "text/markdown"],
+    ["mmd", "text/vnd.mermaid"],
+    ["mermaid", "text/vnd.mermaid"],
+    ["csv", "text/csv"],
+    ["tsv", "text/tab-separated-values"],
+    ["ttf", "font/ttf"],
+    ["otf", "font/otf"],
+    ["woff", "font/woff"],
+    ["woff2", "font/woff2"],
+]);
+function artifactExtension(path) {
+    const name = path.split(/[\\/]/).pop() ?? "";
+    const index = name.lastIndexOf(".");
+    if (index <= 0)
+        return "";
+    return name.slice(index + 1).toLowerCase();
+}
+export function artifactMime(path) {
+    return mimes.get(artifactExtension(path));
+}
+export function artifactKind(path) {
+    const mime = artifactMime(path);
+    if (!mime)
+        return "text";
+    if (mime === "image/svg+xml")
+        return "svg";
+    if (mime === "application/pdf")
+        return "pdf";
+    if (mime === "text/html")
+        return "html";
+    if (mime === "text/markdown")
+        return "markdown";
+    if (mime === "text/vnd.mermaid")
+        return "mermaid";
+    if (mime === "text/csv" || mime === "text/tab-separated-values")
+        return "table";
+    if (mime.startsWith("image/"))
+        return "image";
+    if (mime.startsWith("audio/"))
+        return "audio";
+    if (mime.startsWith("font/"))
+        return "font";
+    return "video";
+}

package/dist/artifact.test.d.ts

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

package/dist/artifact.test.js

@@ -0,0 +1,24 @@
+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"],
+        ["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/fs-util.d.ts

@@ -19,6 +19,8 @@ export declare namespace FSUtil {
         readonly start: string;
         readonly stop?: string;
         readonly mode?: "all" | "first";
+        /** Only match regular files or directories (following symlinks). By default any existing path matches. */
+        readonly type?: "file" | "directory";
     }
     export interface Interface extends FileSystem.FileSystem {
         readonly isDir: (path: string) => Effect.Effect<boolean>;

package/dist/fs-util.js

@@ -97,7 +97,12 @@ export var FSUtil;
             while (true) {
                 for (const target of options.targets) {
                     const search = join(current, target);
-                    if (yield* fs.exists(search)) {
+                    const found = options.type === "file"
+                        ? yield* isFile(search)
+                        : options.type === "directory"
+                            ? yield* isDir(search)
+                            : yield* fs.exists(search);
+                    if (found) {
                         result.push(search);
                         if (options.mode === "first")
                             return result;

package/dist/path.d.ts

@@ -2,3 +2,9 @@ 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;
+/** A comparable form of a directory path: forward slashes for Windows paths, no trailing slash except on roots. */
+export declare function comparablePath(path: string): string;
+/** `child` is `parent` or inside it. Windows drive and UNC paths compare case-insensitively. */
+export declare function containsDirectory(parent: string, child: string): boolean;
+export declare function sameDirectory(a: string, b: string): boolean;
+export declare function encodeFilePath(filepath: string): string;

package/dist/path.js

@@ -31,3 +31,57 @@ export function truncateMiddle(text, maxLength = 20) {
     const end = Math.floor(available / 2);
     return text.slice(0, start) + "…" + text.slice(-end);
 }
+const isDrive = (value) => {
+    if (value.length !== 2)
+        return false;
+    const code = value.charCodeAt(0);
+    return value[1] === ":" && ((code >= 65 && code <= 90) || (code >= 97 && code <= 122));
+};
+const trimTrailingSlashes = (value) => {
+    for (let i = value.length - 1; i >= 0; i--) {
+        if (value[i] !== "/")
+            return value.slice(0, i + 1);
+    }
+    return "";
+};
+const isWindowsPath = (value) => value[1] === ":" || value.startsWith("\\\\");
+/** A comparable form of a directory path: forward slashes for Windows paths, no trailing slash except on roots. */
+export function comparablePath(path) {
+    const value = isWindowsPath(path) ? path.replaceAll("\\", "/") : path;
+    const trimmed = trimTrailingSlashes(value);
+    if (!trimmed && value.startsWith("/"))
+        return "/";
+    if (isDrive(trimmed))
+        return `${trimmed}/`;
+    return trimmed;
+}
+/** `child` is `parent` or inside it. Windows drive and UNC paths compare case-insensitively. */
+export function containsDirectory(parent, child) {
+    const normalize = (value) => {
+        const key = comparablePath(value);
+        return /^[a-z]:\//i.test(key) || key.startsWith("//") ? key.toLowerCase() : key;
+    };
+    const root = normalize(parent);
+    const target = normalize(child);
+    return target === root || target.startsWith(root.endsWith("/") ? root : `${root}/`);
+}
+export function sameDirectory(a, b) {
+    return containsDirectory(a, b) && containsDirectory(b, a);
+}
+export function encodeFilePath(filepath) {
+    // Normalize Windows paths: convert backslashes to forward slashes
+    const normalized = filepath.replace(/\\/g, "/");
+    // Handle Windows absolute paths (D:/path -> /D:/path for proper file:// URLs)
+    const rooted = /^[A-Za-z]:/.test(normalized) ? "/" + normalized : normalized;
+    // Encode each path segment (preserving forward slashes as path separators)
+    // Keep the colon in Windows drive letters (`/C:/...`) so downstream file URL parsers
+    // can reliably detect drives.
+    return rooted
+        .split("/")
+        .map((segment, index) => {
+        if (index === 1 && /^[A-Za-z]:$/.test(segment))
+            return segment;
+        return encodeURIComponent(segment);
+    })
+        .join("/");
+}

package/dist/path.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { getDirectory, getFilename, getFilenameTruncated, truncateMiddle } from "./path.js";
+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");
@@ -34,3 +34,38 @@ describe("client paths", () => {
         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/package.json

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