@opencode-ai/util 0.0.0-beta-18219 → 0.0.0-beta-18269

package/dist/npm.d.ts

@@ -16,6 +16,7 @@ export interface EntryPoint {
 export interface Interface {
     readonly add: (pkg: string, options?: {
         readonly subpaths?: readonly string[];
+        readonly refresh?: boolean;
     }) => Effect.Effect<EntryPoint, InstallFailedError | EffectFlock.LockError>;
     readonly resolve: (pkg: string, options?: {
         readonly subpaths?: readonly string[];
@@ -27,6 +28,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,19 +72,37 @@ 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 refreshed = new Set();
     const reify = (input) => Effect.gen(function* () {
         yield* flock.acquire(`npm-install:${input.dir}`);
         const { Arborist } = yield* Effect.promise(() => import("@npmcli/arborist"));
         const add = input.add ?? [];
         const npmOptions = yield* NpmConfig.load(input.dir);
+        const options = input.update ? { ...npmOptions, preferOnline: true, noGitRevCache: true } : npmOptions;
         const arborist = new Arborist({
-            ...npmOptions,
+            ...options,
             path: input.dir,
             binLinks: true,
             progress: false,
@@ -72,8 +111,9 @@ const layer = Layer.effect(Service, Effect.gen(function* () {
         });
         return yield* Effect.tryPromise({
             try: () => arborist.reify({
-                ...npmOptions,
+                ...options,
                 add,
+                update: input.update,
                 save: true,
                 saveType: "prod",
             }),
@@ -88,22 +128,32 @@ 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 parsed = (() => {
             try {
-                return npa(pkg).name ?? pkg;
+                return npa(pkg);
             }
             catch {
-                return pkg;
+                return undefined;
             }
         })();
-        if (yield* afs.existsSafe(path.join(dir, "node_modules", name))) {
+        const parsedName = parsed?.name ?? undefined;
+        const dir = yield* directory(pkg);
+        const name = yield* installedName(pkg, dir, parsedName);
+        const cached = yield* afs.existsSafe(path.join(dir, "node_modules", name));
+        const refresh = options?.refresh && isMutable(parsed) && !refreshed.has(pkg);
+        if (refresh) {
+            refreshed.add(pkg);
+            if (cached)
+                yield* reify({ dir, add: [pkg], update: true }).pipe(Effect.catchCause(() => Effect.logWarning("failed to refresh cached package; using installed version")));
+        }
+        if (cached) {
             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 +162,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(() => []));
@@ -188,3 +240,12 @@ export async function resolve(...args) {
 export async function which(...args) {
     return runPromise((svc) => svc.which(...args));
 }
+function isMutable(parsed) {
+    if (!parsed)
+        return false;
+    if (["tag", "range"].includes(parsed.type))
+        return true;
+    if (parsed.type !== "git")
+        return false;
+    return !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/i.test(parsed.gitCommittish ?? "");
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/util",
-  "version": "0.0.0-beta-18219",
+  "version": "0.0.0-beta-18269",
   "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",