@danieljvdm/dev-kit 0.17.0 → 1.0.0

package/src/package-skill-source.ts

@@ -1,4 +1,4 @@
-import { Effect, FileSystem, Path, Result, Schema } from "effect";
+import { Effect, FileSystem, Option, Path, Result, Schema } from "effect";
 
 import { observeSymbolicLink } from "./node-symbolic-link.ts";
 import { readDirectDependencyNames } from "./project-package.ts";
@@ -34,33 +34,25 @@ const PackageMetadataSchema = Schema.fromJsonString(
   }),
 );
 
-const nonEmptyString = (value: unknown): value is string =>
-  typeof value === "string" && value.trim().length > 0;
+const DiscoveryLocationSchema = Schema.String.check(Schema.isPattern(/\S/));
+const IntentDiscoveryMetadataSchema = Schema.Struct({
+  version: Schema.Literal(1),
+  repo: DiscoveryLocationSchema,
+  docs: DiscoveryLocationSchema,
+});
+const RepositoryDiscoveryMetadataSchema = Schema.Union([
+  DiscoveryLocationSchema,
+  Schema.Struct({ url: DiscoveryLocationSchema }),
+]);
+const decodeIntentDiscoveryMetadata = Schema.decodeUnknownOption(IntentDiscoveryMetadataSchema);
+const decodeRepositoryDiscoveryMetadata = Schema.decodeUnknownOption(
+  RepositoryDiscoveryMetadataSchema,
+);
 
 const hasIntentDiscoveryMetadata = (metadata: typeof PackageMetadataSchema.Type): boolean => {
-  const intent = metadata.intent;
+  if (Option.isSome(decodeIntentDiscoveryMetadata(metadata.intent))) return true;
 
-  if (
-    typeof intent === "object" &&
-    intent !== null &&
-    "version" in intent &&
-    intent.version === 1 &&
-    "repo" in intent &&
-    nonEmptyString(intent.repo) &&
-    "docs" in intent &&
-    nonEmptyString(intent.docs)
-  ) {
-    return true;
-  }
-  const repository = metadata.repository;
-
-  return (
-    nonEmptyString(repository) ||
-    (typeof repository === "object" &&
-      repository !== null &&
-      "url" in repository &&
-      nonEmptyString(repository.url))
-  );
+  return Option.isSome(decodeRepositoryDiscoveryMetadata(metadata.repository));
 };
 
 const isSafePackageVersion = (value: string): boolean =>

package/src/path-digest.ts

@@ -23,13 +23,14 @@ export class PathInspectionError extends Schema.TaggedError<PathInspectionError>
 }
 
 const textEncoder = new TextEncoder();
+const isString = Schema.is(Schema.String);
 
 // Git preserves only the executable distinction for regular files. Canonicalizing
 // the remaining bits keeps digests stable across checkout and copy umasks.
 const canonicalFileMode = (mode: number): number => ((mode & 0o111) === 0 ? 0o644 : 0o755);
 
 const frame = (value: string | Uint8Array): Uint8Array => {
-  const bytes = typeof value === "string" ? textEncoder.encode(value) : value;
+  const bytes = isString(value) ? textEncoder.encode(value) : value;
   const framed = new Uint8Array(4 + bytes.length);
 
   new DataView(framed.buffer).setUint32(0, bytes.length);
@@ -152,6 +153,66 @@ export const observePath = Effect.fn("observeManagedPath")(function* (absolutePa
   );
 });
 
+export const observeDirectoryWithoutEntry = Effect.fn("observeDirectoryWithoutEntry")(function* (
+  absolutePath: string,
+  excludedEntry: string,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+
+  if (
+    excludedEntry.length === 0 ||
+    excludedEntry === "." ||
+    excludedEntry === ".." ||
+    excludedEntry.includes("/") ||
+    excludedEntry.includes("\\")
+  ) {
+    return yield* PathInspectionError.make({
+      path: absolutePath,
+      operation: "exclude a direct directory entry",
+      cause: excludedEntry,
+    });
+  }
+  const observed = yield* observeSymbolicLink(absolutePath);
+
+  if (observed.kind === "missing") return { kind: "missing" } as const;
+  if (observed.kind === "symlink") {
+    return yield* PathInspectionError.make({
+      path: absolutePath,
+      operation: "inspect a regular directory",
+      cause: "path is a symlink",
+    });
+  }
+  const info = yield* fs.stat(absolutePath);
+
+  if (info.type !== "Directory") {
+    return yield* PathInspectionError.make({
+      path: absolutePath,
+      operation: "inspect a regular directory",
+      cause: info.type,
+    });
+  }
+  const entries = (yield* fs.readDirectory(absolutePath))
+    .filter((entry) => entry !== excludedEntry)
+    .sort(compareUtf8);
+  const frames: Array<string | Uint8Array> = ["directory-v1"];
+
+  for (const entry of entries) {
+    const child = yield* digestFileSystemPath(path.join(absolutePath, entry), canonicalFileMode);
+
+    if (child.kind === "missing") {
+      return yield* PathInspectionError.make({
+        path: path.join(absolutePath, entry),
+        operation: "inspect a stable directory tree",
+        cause: "path disappeared during inspection",
+      });
+    }
+    frames.push(entry, child.kind, child.digest);
+  }
+
+  return { kind: "directory", digest: yield* digestFrames(frames) } as const;
+});
+
 export const digestText = Effect.fn("digestText")(function* (value: string) {
   return yield* digestFrames(["text-v1", value]);
 });

package/src/project-package.ts

@@ -47,14 +47,16 @@ export const PACKAGE_MANAGER_COMMANDS = {
   yarn: { install: "yarn install", label: "Yarn" },
 } as const;
 
-export type PackageManagerName = keyof typeof PACKAGE_MANAGER_COMMANDS;
+const PackageManagerNameSchema = Schema.Literals(["bun", "npm", "pnpm", "yarn"]);
+
+export type PackageManagerName = typeof PackageManagerNameSchema.Type;
+
+const decodePackageManagerName = Schema.decodeUnknownOption(PackageManagerNameSchema);
 
 const packageManagerName = (declaration: string | undefined): PackageManagerName | undefined => {
   const name = declaration?.split("@", 1)[0];
 
-  return name !== undefined && name in PACKAGE_MANAGER_COMMANDS
-    ? (name as PackageManagerName)
-    : undefined;
+  return name === undefined ? undefined : Option.getOrUndefined(decodePackageManagerName(name));
 };
 
 export const detectPackageManager = Effect.fn("detectPackageManager")(function* (
@@ -129,13 +131,9 @@ const WorkspacePatternsSchema = Schema.Union([
 // this is a genuinely untyped boundary.
 const decodeWorkspacePatterns = Schema.decodeUnknownOption(WorkspacePatternsSchema);
 
-const workspacePatterns = (workspaces: unknown): ReadonlyArray<string> => {
-  const decoded = decodeWorkspacePatterns(workspaces);
-
-  if (Option.isNone(decoded)) return [];
-
-  return "packages" in decoded.value ? decoded.value.packages : decoded.value;
-};
+const workspacePatterns = (
+  workspaces: typeof WorkspacePatternsSchema.Type,
+): ReadonlyArray<string> => ("packages" in workspaces ? workspaces.packages : workspaces);
 
 /**
  * Direct dependency names of the project package plus every workspace member
@@ -149,8 +147,12 @@ export const readWorkspaceDependencyNames = Effect.fn("readWorkspaceDependencyNa
   const path = yield* Path.Path;
   const manifest = yield* readOptionalProjectPackage(projectDir);
   const names = new Set(manifestDependencyNames(manifest));
+  const decodedWorkspaces = decodeWorkspacePatterns(manifest?.workspaces);
+  const patterns = Option.isSome(decodedWorkspaces)
+    ? workspacePatterns(decodedWorkspaces.value)
+    : [];
 
-  for (const pattern of workspacePatterns(manifest?.workspaces)) {
+  for (const pattern of patterns) {
     if (pattern.startsWith("!")) continue;
     const star = pattern.indexOf("*");
     let memberDirs: ReadonlyArray<string> = [];