@opencode-ai/util 0.0.0-dev-18253 → 0.0.0-dev-18257

package/dist/npm.d.ts

@@ -27,6 +27,8 @@ export declare class Service extends Service_base {
 }
 export declare function sanitize(pkg: string): string;
 export declare function isRegistryPackage(pkg: string): Promise<boolean>;
+export declare function isInstallablePackage(pkg: string): Promise<boolean>;
+export declare function cacheKey(pkg: string): Promise<string>;
 export declare const node: LayerNode.Node<Service, never, LayerNode.Tag<"global">>;
 export declare function add(...args: Parameters<Interface["add"]>): Promise<EntryPoint>;
 export declare function resolve(...args: Parameters<Interface["resolve"]>): Promise<EntryPoint>;

package/dist/npm.js

@@ -1,7 +1,7 @@
 export * as Npm from "./npm.js";
 import path from "path";
+import { createHash } from "node:crypto";
 import { Effect, Schema, Context, Layer, Option, FileSystem } from "effect";
-import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
 import { FSUtil } from "./fs-util.js";
 import { Global } from "./global.js";
 import { EffectFlock } from "./effect-flock.js";
@@ -35,6 +35,27 @@ export async function isRegistryPackage(pkg) {
         return false;
     }
 }
+export async function isInstallablePackage(pkg) {
+    const { default: npa } = await import("npm-package-arg");
+    try {
+        const result = npa(pkg);
+        return result.type === "git" || (result.name !== undefined && ["version", "range", "tag"].includes(result.type));
+    }
+    catch {
+        return false;
+    }
+}
+export async function cacheKey(pkg) {
+    const { default: npa } = await import("npm-package-arg");
+    try {
+        if (npa(pkg).type === "git")
+            return `git-${createHash("sha256").update(pkg).digest("hex")}`;
+    }
+    catch {
+        // Preserve the existing fallback for invalid and non-registry package strings.
+    }
+    return sanitize(pkg);
+}
 const resolveEntryPoint = (name, dir, subpaths = [""]) => {
     const entrypoint = subpaths
         .map((subpath) => {
@@ -51,12 +72,28 @@ const resolveEntryPoint = (name, dir, subpaths = [""]) => {
         entrypoint,
     };
 };
+const PackageJson = Schema.Struct({
+    dependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+});
 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 directory = (pkg) => Effect.map(Effect.promise(() => cacheKey(pkg)), (key) => path.join(global.cache, "packages", key));
+    const installedName = Effect.fnUntraced(function* (pkg, dir, parsedName) {
+        if (parsedName)
+            return parsedName;
+        const manifest = yield* afs
+            .readJson(path.join(dir, "package.json"))
+            .pipe(Effect.flatMap(Schema.decodeUnknownEffect(PackageJson)), Effect.option);
+        if (Option.isSome(manifest)) {
+            const name = Object.keys(manifest.value.dependencies ?? {})[0];
+            if (name)
+                return name;
+        }
+        return pkg;
+    });
     const reify = (input) => Effect.gen(function* () {
         yield* flock.acquire(`npm-install:${input.dir}`);
         const { Arborist } = yield* Effect.promise(() => import("@npmcli/arborist"));
@@ -88,22 +125,24 @@ const layer = Layer.effect(Service, Effect.gen(function* () {
     }));
     const add = Effect.fn("Npm.add")(function* (pkg, options) {
         const { default: npa } = yield* Effect.promise(() => import("npm-package-arg"));
-        const dir = directory(pkg);
-        const name = (() => {
+        const parsedName = (() => {
             try {
-                return npa(pkg).name ?? pkg;
+                return npa(pkg).name ?? undefined;
             }
             catch {
-                return pkg;
+                return undefined;
             }
         })();
+        const dir = yield* directory(pkg);
+        const name = yield* installedName(pkg, dir, parsedName);
         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);
+            const installed = yield* installedName(pkg, dir, parsedName);
+            const result = resolveEntryPoint(installed, path.join(dir, "node_modules", installed), options?.subpaths);
             if (result.entrypoint)
                 return result;
             return yield* new InstallFailedError({ add: [pkg], dir });
@@ -112,21 +151,23 @@ const layer = Layer.effect(Service, Effect.gen(function* () {
     }, Effect.scoped);
     const resolve = Effect.fn("Npm.resolve")(function* (pkg, options) {
         const { default: npa } = yield* Effect.promise(() => import("npm-package-arg"));
-        const name = (() => {
+        const parsedName = (() => {
             try {
-                return npa(pkg).name ?? pkg;
+                return npa(pkg).name ?? undefined;
             }
             catch {
-                return pkg;
+                return undefined;
             }
         })();
-        const dir = path.join(directory(pkg), "node_modules", name);
+        const root = yield* directory(pkg);
+        const name = yield* installedName(pkg, root, parsedName);
+        const dir = path.join(root, "node_modules", name);
         if (!(yield* afs.existsSafe(dir)))
             return { directory: dir };
         return resolveEntryPoint(name, dir, options?.subpaths);
     });
     const which = Effect.fn("Npm.which")(function* (pkg, bin) {
-        const dir = directory(pkg);
+        const dir = yield* directory(pkg);
         const binDir = path.join(dir, "node_modules", ".bin");
         const pick = Effect.fnUntraced(function* () {
             const files = yield* fs.readDirectory(binDir).pipe(Effect.orElseSucceed(() => []));

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/util",
-  "version": "0.0.0-dev-18253",
+  "version": "0.0.0-dev-18257",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -45,6 +45,7 @@
   "dependencies": {
     "@effect/opentelemetry": "4.0.0-rc.111",
     "@effect/platform-node": "4.0.0-rc.111",
+    "@effect/platform-node-shared": "4.0.0-rc.111",
     "@npmcli/arborist": "9.4.0",
     "@npmcli/config": "10.8.1",
     "@opentelemetry/api": "1.9.0",