@danieljvdm/dev-kit 0.11.1 → 0.12.0

package/src/package-skill-source.ts

@@ -5,7 +5,7 @@ import { readDirectDependencyNames } from "./project-package.ts";
 import { isSkillName, parseSkillSelector } from "./skill-selector.ts";
 import { isTypeScriptPackageName } from "./typescript-package-name.ts";
 
-export class PackageSkillSourceError extends Schema.TaggedErrorClass<PackageSkillSourceError>()(
+export class PackageSkillSourceError extends Schema.TaggedError<PackageSkillSourceError>()(
   "PackageSkillSourceError",
   { message: Schema.String },
 ) {}
@@ -121,26 +121,24 @@ const rejectNestedSymlinks = Effect.fn("rejectPackageSkillSymlinks")(function* (
 
     if (current === undefined) continue;
     if ((yield* observeSymbolicLink(current)).kind === "symlink") {
-      return yield* new PackageSkillSourceError({
+      return yield* PackageSkillSourceError.make({
         message: `package skill contains a symlink: ${current}`,
       });
     }
-    const info = yield* fs
-      .stat(current)
-      .pipe(
-        Effect.mapError(
-          () =>
-            new PackageSkillSourceError({ message: `could not inspect package skill: ${current}` }),
-        ),
-      );
+    const info = yield* fs.stat(current).pipe(
+      Effect.mapError(() =>
+        PackageSkillSourceError.make({
+          message: `could not inspect package skill: ${current}`,
+        }),
+      ),
+    );
 
     if (info.type !== "Directory") continue;
     for (const entry of yield* fs
       .readDirectory(current)
       .pipe(
-        Effect.mapError(
-          () =>
-            new PackageSkillSourceError({ message: `could not read package skill: ${current}` }),
+        Effect.mapError(() =>
+          PackageSkillSourceError.make({ message: `could not read package skill: ${current}` }),
         ),
       ))
       pending.push(path.join(current, entry));
@@ -163,80 +161,75 @@ const loadInstalledPackageSkills = Effect.fn("loadInstalledPackageSkills")(funct
   const path = yield* Path.Path;
   const packageLink = path.join(projectDir, "node_modules", ...packageName.split("/"));
   const packageRoot = yield* fs.realPath(packageLink).pipe(
-    Effect.mapError(
-      () =>
-        new PackageSkillSourceError({
-          message: `package skill package is not installed: ${packageName}`,
-        }),
+    Effect.mapError(() =>
+      PackageSkillSourceError.make({
+        message: `package skill package is not installed: ${packageName}`,
+      }),
     ),
   );
   const packageInfo = yield* fs.stat(packageRoot).pipe(
-    Effect.mapError(
-      () =>
-        new PackageSkillSourceError({
-          message: `could not inspect package skill package: ${packageName}`,
-        }),
+    Effect.mapError(() =>
+      PackageSkillSourceError.make({
+        message: `could not inspect package skill package: ${packageName}`,
+      }),
     ),
   );
 
   if (packageInfo.type !== "Directory")
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skill package is not a directory: ${packageName}`,
     });
   const metadata = yield* fs.readFileString(path.join(packageRoot, "package.json")).pipe(
     Effect.flatMap(Schema.decodeUnknownEffect(PackageMetadataSchema)),
-    Effect.mapError(
-      () =>
-        new PackageSkillSourceError({
-          message: `invalid package.json for package skill package: ${packageName}`,
-        }),
+    Effect.mapError(() =>
+      PackageSkillSourceError.make({
+        message: `invalid package.json for package skill package: ${packageName}`,
+      }),
     ),
   );
 
   if (metadata.name !== packageName)
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package.json name does not match package skill package: ${packageName}`,
     });
   if (!isSafePackageVersion(metadata.version))
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package.json has an invalid version for package skill package: ${packageName}`,
     });
   if (!hasIntentDiscoveryMetadata(metadata))
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package does not declare Intent-compatible discovery metadata: ${packageName}`,
     });
   const skillsPath = "skills";
   const skillsLink = path.join(packageLink, skillsPath);
 
   if ((yield* observeSymbolicLink(skillsLink)).kind === "symlink")
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skills path is a symlink: ${packageName}/${skillsPath}`,
     });
   const skillsRoot = yield* fs.realPath(skillsLink).pipe(
-    Effect.mapError(
-      () =>
-        new PackageSkillSourceError({
-          message: `package skill package has no skills directory: ${packageName}`,
-        }),
+    Effect.mapError(() =>
+      PackageSkillSourceError.make({
+        message: `package skill package has no skills directory: ${packageName}`,
+      }),
     ),
   );
 
   if (!isContained(path, packageRoot, skillsRoot))
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skills path resolves outside package root: ${packageName}/${skillsPath}`,
     });
   const skillsInfo = yield* fs.stat(skillsRoot);
 
   if (skillsInfo.type !== "Directory")
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skills path is not a directory: ${packageName}/${skillsPath}`,
     });
   const names = (yield* fs.readDirectory(skillsRoot).pipe(
-    Effect.mapError(
-      () =>
-        new PackageSkillSourceError({
-          message: `package skill package has no readable skills directory: ${packageName}`,
-        }),
+    Effect.mapError(() =>
+      PackageSkillSourceError.make({
+        message: `package skill package has no readable skills directory: ${packageName}`,
+      }),
     ),
   ))
     .filter(isSkillName)
@@ -259,21 +252,21 @@ const inspectPackageSkill = Effect.fn("inspectInstalledPackageSkill")(function*
   const path = yield* Path.Path;
 
   if (!isSkillName(name)) {
-    return yield* new PackageSkillSourceError({ message: `invalid package skill name: ${name}` });
+    return yield* PackageSkillSourceError.make({ message: `invalid package skill name: ${name}` });
   }
   const selector = `${installed.package}#${name}`;
   const linkPath = path.join(installed.packageLink, "skills", name);
 
   if ((yield* observeSymbolicLink(linkPath)).kind === "symlink") {
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skill contains a symlink: ${selector}`,
     });
   }
   const skillRoot = yield* fs
     .realPath(linkPath)
     .pipe(
-      Effect.mapError(
-        () => new PackageSkillSourceError({ message: `package skill does not exist: ${selector}` }),
+      Effect.mapError(() =>
+        PackageSkillSourceError.make({ message: `package skill does not exist: ${selector}` }),
       ),
     );
 
@@ -281,29 +274,28 @@ const inspectPackageSkill = Effect.fn("inspectInstalledPackageSkill")(function*
     !isContained(path, installed.skillsRoot, skillRoot) ||
     (yield* fs.stat(skillRoot)).type !== "Directory"
   ) {
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skill is not a contained directory: ${selector}`,
     });
   }
   yield* rejectNestedSymlinks(skillRoot);
   const document = yield* fs.readFileString(path.join(skillRoot, "SKILL.md")).pipe(
-    Effect.mapError(
-      () =>
-        new PackageSkillSourceError({
-          message: `package skill is missing SKILL.md: ${selector}`,
-        }),
+    Effect.mapError(() =>
+      PackageSkillSourceError.make({
+        message: `package skill is missing SKILL.md: ${selector}`,
+      }),
     ),
   );
 
   if (skillName(document) !== name) {
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skill SKILL.md name must match directory: ${selector}`,
     });
   }
   const description = skillDescription(document);
 
   if (description === undefined) {
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skill SKILL.md must declare a description: ${selector}`,
     });
   }
@@ -370,13 +362,13 @@ export const resolvePackageSkillSelector = Effect.fn("resolvePackageSkillSelecto
   const parsed = parseSkillSelector(selector);
 
   if (parsed?.type !== "package")
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `invalid package skill selector: ${selector}`,
     });
   const directDependencies = yield* readDirectDependencyNames(projectDir);
 
   if (!directDependencies.includes(parsed.package))
-    return yield* new PackageSkillSourceError({
+    return yield* PackageSkillSourceError.make({
       message: `package skill package is not a direct dependency: ${parsed.package}`,
     });
 

package/src/path-digest.ts

@@ -9,7 +9,7 @@ export type ObservedPath =
   | { readonly kind: "missing" }
   | { readonly kind: "file" | "directory" | "symlink"; readonly digest: Digest };
 
-export class PathInspectionError extends Schema.TaggedErrorClass<PathInspectionError>()(
+export class PathInspectionError extends Schema.TaggedError<PathInspectionError>()(
   "PathInspectionError",
   {
     path: Schema.String,
@@ -124,7 +124,7 @@ const digestFileSystemPath = Effect.fn("digestFileSystemPath")(function* (
       const child = yield* digestFileSystemPath(childPath, fileMode);
 
       if (child.kind === "missing") {
-        return yield* new PathInspectionError({
+        return yield* PathInspectionError.make({
           path: childPath,
           operation: "inspect a stable directory tree",
           cause: "path disappeared during inspection",
@@ -136,7 +136,7 @@ const digestFileSystemPath = Effect.fn("digestFileSystemPath")(function* (
     return { kind: "directory", digest: yield* digestFrames(frames) };
   }
 
-  return yield* new PathInspectionError({
+  return yield* PathInspectionError.make({
     path: absolutePath,
     operation: "inspect unsupported filesystem entry",
     cause: info.type,
@@ -146,9 +146,9 @@ const digestFileSystemPath = Effect.fn("digestFileSystemPath")(function* (
 export const observePath = Effect.fn("observeManagedPath")(function* (absolutePath: string) {
   return yield* digestFileSystemPath(absolutePath, canonicalFileMode).pipe(
     Effect.mapError((cause) =>
-      cause instanceof PathInspectionError
+      Schema.is(PathInspectionError)(cause)
         ? cause
-        : new PathInspectionError({ path: absolutePath, operation: "inspect", cause }),
+        : PathInspectionError.make({ path: absolutePath, operation: "inspect", cause }),
     ),
   );
 });
@@ -158,9 +158,9 @@ export const observePathWithRawModes = Effect.fn("observeManagedPathWithRawModes
 ) {
   return yield* digestFileSystemPath(absolutePath, rawFileMode).pipe(
     Effect.mapError((cause) =>
-      cause instanceof PathInspectionError
+      Schema.is(PathInspectionError)(cause)
         ? cause
-        : new PathInspectionError({ path: absolutePath, operation: "inspect", cause }),
+        : PathInspectionError.make({ path: absolutePath, operation: "inspect", cause }),
     ),
   );
 });

package/src/project-package.ts

@@ -1,6 +1,6 @@
 import { Effect, FileSystem, Path, Schema } from "effect";
 
-export class ProjectPackageError extends Schema.TaggedErrorClass<ProjectPackageError>()(
+export class ProjectPackageError extends Schema.TaggedError<ProjectPackageError>()(
   "ProjectPackageError",
   { message: Schema.String },
 ) {}
@@ -24,15 +24,16 @@ export const readProjectPackage = Effect.fn("readProjectPackage")(function* (pro
   const manifestPath = path.join(projectDir, "package.json");
 
   if (!(yield* fs.exists(manifestPath))) {
-    return yield* new ProjectPackageError({ message: `package.json not found: ${manifestPath}` });
+    return yield* ProjectPackageError.make({
+      message: `package.json not found: ${manifestPath}`,
+    });
   }
   const manifest = yield* fs.readFileString(manifestPath).pipe(
     Effect.flatMap(Schema.decodeUnknownEffect(ProjectPackageSchema)),
-    Effect.mapError(
-      () =>
-        new ProjectPackageError({
-          message: `invalid project package.json: ${manifestPath}`,
-        }),
+    Effect.mapError(() =>
+      ProjectPackageError.make({
+        message: `invalid project package.json: ${manifestPath}`,
+      }),
     ),
   );
 

package/src/project-process-lock.ts

@@ -4,7 +4,7 @@ import { DEV_KIT_VERSION } from "./tool-metadata.ts";
 
 export const PROJECT_PROCESS_LOCK_PATH = ".dev-kit/apply.lock";
 
-export class ProjectAlreadyLockedError extends Schema.TaggedErrorClass<ProjectAlreadyLockedError>()(
+export class ProjectAlreadyLockedError extends Schema.TaggedError<ProjectAlreadyLockedError>()(
   "ProjectAlreadyLockedError",
   { path: Schema.String },
 ) {
@@ -13,6 +13,15 @@ export class ProjectAlreadyLockedError extends Schema.TaggedErrorClass<ProjectAl
   }
 }
 
+const ProjectProcessLockOwnerSchema = Schema.fromJsonString(
+  Schema.Struct({
+    version: Schema.Literal(1),
+    toolVersion: Schema.String,
+    token: Schema.String,
+    startedAt: Schema.String,
+  }),
+);
+
 export const acquireProjectProcessLock = Effect.fn("acquireProjectProcessLock")(function* (
   projectDir: string,
 ) {
@@ -24,16 +33,12 @@ export const acquireProjectProcessLock = Effect.fn("acquireProjectProcessLock")(
   const ownerPath = path.join(lockDir, "owner.json");
   const token = yield* crypto.randomUUIDv7;
   const startedAt = DateTime.formatIso(yield* DateTime.now);
-  const ownerContents = `${JSON.stringify(
-    {
-      version: 1,
-      toolVersion: DEV_KIT_VERSION,
-      token,
-      startedAt,
-    },
-    null,
-    2,
-  )}\n`;
+  const ownerContents = `${yield* Schema.encodeEffect(ProjectProcessLockOwnerSchema)({
+    version: 1,
+    toolVersion: DEV_KIT_VERSION,
+    token,
+    startedAt,
+  }).pipe(Effect.orDie)}\n`;
 
   return yield* Effect.acquireRelease(
     Effect.gen(function* () {
@@ -46,7 +51,7 @@ export const acquireProjectProcessLock = Effect.fn("acquireProjectProcessLock")(
             .pipe(
               Effect.mapError((error) =>
                 error.reason._tag === "AlreadyExists"
-                  ? new ProjectAlreadyLockedError({ path: lockDir })
+                  ? ProjectAlreadyLockedError.make({ path: lockDir })
                   : error,
               ),
             );

package/src/project-state.ts

@@ -50,7 +50,7 @@ export const ManagedClaudeInstructionsOutputSchema = Schema.Struct({
 export type ManagedClaudeInstructionsOutput = typeof ManagedClaudeInstructionsOutputSchema.Type;
 
 export const ManagedGeneratedFileOutputSchema = Schema.Struct({
-  resourceId: Schema.Literals(["setup:vite-plus-config", "setup:vite-plus-github-actions"]),
+  resourceId: Schema.Literal("setup:vite-plus-github-actions"),
   path: Schema.String,
   sourcePath: Schema.String,
   mode: Schema.Literal("copy"),

package/src/skill-manager.ts

@@ -9,7 +9,7 @@ import { DevKitManifestSchema } from "./manifest.ts";
 import { observeSymbolicLink } from "./node-symbolic-link.ts";
 import { runProjectSkillPlan } from "./sync.ts";
 
-class SkillManagerError extends Schema.TaggedErrorClass<SkillManagerError>()("SkillManagerError", {
+class SkillManagerError extends Schema.TaggedError<SkillManagerError>()("SkillManagerError", {
   message: Schema.String,
 }) {}
 
@@ -32,7 +32,7 @@ const resolvePaths = Effect.fn("resolveSkillManagerPaths")(function* (options: M
   const candidate = options.manifestPath ?? "dev-kit.jsonc";
 
   if (candidate.length === 0 || path.isAbsolute(candidate)) {
-    return yield* new SkillManagerError({
+    return yield* SkillManagerError.make({
       message: "--manifest must be a non-empty project-relative path",
     });
   }
@@ -40,7 +40,7 @@ const resolvePaths = Effect.fn("resolveSkillManagerPaths")(function* (options: M
   const relative = path.relative(projectDir, manifestPath);
 
   if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-    return yield* new SkillManagerError({
+    return yield* SkillManagerError.make({
       message: "--manifest must resolve inside the project",
     });
   }
@@ -49,7 +49,7 @@ const resolvePaths = Effect.fn("resolveSkillManagerPaths")(function* (options: M
   for (const segment of relative.split(path.sep).slice(0, -1)) {
     ancestor = path.join(ancestor, segment);
     if ((yield* observeSymbolicLink(ancestor)).kind === "symlink") {
-      return yield* new SkillManagerError({
+      return yield* SkillManagerError.make({
         message: `manifest ancestor is a symlink: ${path.relative(projectDir, ancestor)}`,
       });
     }
@@ -57,10 +57,12 @@ const resolvePaths = Effect.fn("resolveSkillManagerPaths")(function* (options: M
   const destination = yield* observeSymbolicLink(manifestPath);
 
   if (destination.kind === "symlink") {
-    return yield* new SkillManagerError({ message: `manifest is a symlink: ${relative}` });
+    return yield* SkillManagerError.make({ message: `manifest is a symlink: ${relative}` });
   }
   if (destination.kind === "not-symlink" && (yield* fs.stat(manifestPath)).type !== "File") {
-    return yield* new SkillManagerError({ message: `manifest is not a regular file: ${relative}` });
+    return yield* SkillManagerError.make({
+      message: `manifest is not a regular file: ${relative}`,
+    });
   }
 
   return {
@@ -128,7 +130,7 @@ const readManifest = Effect.fn("readManagedSkillManifest")(function* (
 
   if (!(yield* fs.exists(paths.manifestPath))) {
     if (!create) {
-      return yield* new SkillManagerError({
+      return yield* SkillManagerError.make({
         message: "dev-kit.jsonc not found. Run `dev-kit init` first.",
       });
     }
@@ -139,10 +141,10 @@ const readManifest = Effect.fn("readManagedSkillManifest")(function* (
   const parsed = parseJsonc(raw, errors, { allowTrailingComma: true });
 
   if (errors.length > 0) {
-    return yield* new SkillManagerError({ message: `could not parse ${paths.manifestPath}` });
+    return yield* SkillManagerError.make({ message: `could not parse ${paths.manifestPath}` });
   }
   const manifest = yield* Schema.decodeUnknownEffect(DevKitManifestSchema)(parsed).pipe(
-    Effect.mapError((error) => new SkillManagerError({ message: error.message })),
+    Effect.mapError((error) => SkillManagerError.make({ message: error.message })),
   );
 
   return { ...paths, manifest, raw };
@@ -272,7 +274,7 @@ export const addSkills = Effect.fn("addManagedSkills")(function* (
   const unknown = names.filter((name) => !known.has(name));
 
   if (unknown.length > 0) {
-    return yield* new SkillManagerError({
+    return yield* SkillManagerError.make({
       message: `unknown skill${unknown.length === 1 ? "" : "s"}: ${unknown.join(", ")}. Try \`dev-kit search ${unknown[0]}\`.`,
     });
   }
@@ -319,7 +321,7 @@ export const removeSkills = Effect.fn("removeManagedSkills")(function* (
   );
 
   if (absent.length > 0) {
-    return yield* new SkillManagerError({ message: `not selected: ${absent.join(", ")}` });
+    return yield* SkillManagerError.make({ message: `not selected: ${absent.join(", ")}` });
   }
   const include = current.manifest.include.filter((name) => !names.includes(name));
   const excluded = new Set(current.manifest.exclude ?? []);
@@ -399,7 +401,7 @@ export const showSkill = Effect.fn("showCatalogSkill")(function* (
   const catalog = yield* loadSkillCatalog(yield* packageRoot(), paths.projectDir);
   const skill = catalog.skills.find((candidate) => candidate.selector === name);
 
-  if (!skill) return yield* new SkillManagerError({ message: `unknown skill: ${name}` });
+  if (!skill) return yield* SkillManagerError.make({ message: `unknown skill: ${name}` });
   yield* printLine(skill.selector);
   if (skill.description) yield* printLine(displayValue(skill.description));
   if (skill.package) {
@@ -436,7 +438,7 @@ export const chooseSkillsToAdd = Effect.fn("chooseSkillsToAdd")(function* (
   options: ManagerOptions,
 ) {
   if (!(yield* isInteractiveTerminal)) {
-    return yield* new SkillManagerError({
+    return yield* SkillManagerError.make({
       message: "pass one or more skill names, or run this command in a terminal",
     });
   }
@@ -471,7 +473,7 @@ export const chooseSkillsToRemove = Effect.fn("chooseSkillsToRemove")(function*
   options: ManagerOptions,
 ) {
   if (!(yield* isInteractiveTerminal)) {
-    return yield* new SkillManagerError({
+    return yield* SkillManagerError.make({
       message: "pass one or more skill names, or run this command in a terminal",
     });
   }

package/src/skill-selector.ts

@@ -28,6 +28,18 @@ export const SKILL_SELECTOR_PATTERN =
 
 export const isSkillName = (value: string): boolean => SKILL_NAME_PATTERN.test(value);
 
+/**
+ * The package-qualified directory name for an installed package skill. The npm
+ * package name keeps its identity in the flattened output: `@` is dropped,
+ * every other non-alphanumeric run becomes one dash, and the bare skill name
+ * is appended. `@tanstack/table-core#core` installs as
+ * `tanstack-table-core-core`.
+ */
+export const packageSkillInstallName = (packageName: string, skillName: string): string =>
+  `${packageName.replaceAll("@", "")}-${skillName}`
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+
 /** Parse an exact, canonical manifest skill selector. */
 export const parseSkillSelector = (value: string): SkillSelector | undefined => {
   if (isSkillName(value)) return { type: "static", name: value };