@danieljvdm/dev-kit 0.5.0 → 0.7.0

package/src/manifest.ts

@@ -37,21 +37,47 @@ export const EffectSourceSetupSchema = Schema.Struct({
 
 export type EffectSourceSetup = typeof EffectSourceSetupSchema.Type;
 
+export const AgentInstructionsSetupSchema = Schema.Struct({
+  enabled: Schema.optional(Schema.Boolean),
+});
+
+export type AgentInstructionsSetup = typeof AgentInstructionsSetupSchema.Type;
+
 export const ClaudeInstructionsSetupSchema = Schema.Struct({
   enabled: Schema.optional(Schema.Boolean),
 });
 
 export type ClaudeInstructionsSetup = typeof ClaudeInstructionsSetupSchema.Type;
 
+export const VitePlusHooksSetupSchema = Schema.Struct({
+  enabled: Schema.optional(Schema.Boolean),
+});
+
+export const VitePlusQualitySetupSchema = Schema.Struct({
+  enabled: Schema.optional(Schema.Boolean),
+});
+export type VitePlusQualitySetup = typeof VitePlusQualitySetupSchema.Type;
+
+export const VitePlusSetupSchema = Schema.Struct({
+  hooks: Schema.optional(VitePlusHooksSetupSchema),
+  quality: Schema.optional(VitePlusQualitySetupSchema),
+});
+
+export type VitePlusSetup = typeof VitePlusSetupSchema.Type;
+
 export const DevKitManifestSchema = Schema.Struct({
   $schema: Schema.optional(Schema.String),
   include: Schema.Array(Schema.String.check(Schema.isPattern(SKILL_SELECTOR_PATTERN))),
-  exclude: Schema.optional(Schema.Array(Schema.String.check(Schema.isPattern(SKILL_SELECTOR_PATTERN)))),
+  exclude: Schema.optional(
+    Schema.Array(Schema.String.check(Schema.isPattern(SKILL_SELECTOR_PATTERN))),
+  ),
   setup: Schema.optional(
     Schema.Struct({
+      agentInstructions: Schema.optional(AgentInstructionsSetupSchema),
       claudeInstructions: Schema.optional(ClaudeInstructionsSetupSchema),
       effectSource: Schema.optional(EffectSourceSetupSchema),
       effectTsgo: Schema.optional(EffectTsgoSetupSchema),
+      vitePlus: Schema.optional(VitePlusSetupSchema),
     }),
   ),
   targets: Schema.optional(
@@ -75,6 +101,9 @@ export type NormalizedManifest = {
   readonly include: ReadonlyArray<string>;
   readonly exclude: ReadonlyArray<string>;
   readonly setup: {
+    readonly agentInstructions: {
+      readonly enabled: boolean;
+    };
     readonly claudeInstructions: {
       readonly enabled: boolean;
     };
@@ -89,6 +118,14 @@ export type NormalizedManifest = {
       readonly force: boolean;
       readonly typescriptPackage: string;
     };
+    readonly vitePlus: {
+      readonly hooks: {
+        readonly enabled: boolean;
+      };
+      readonly quality: {
+        readonly enabled: boolean;
+      };
+    };
   };
   readonly targets: Readonly<Record<HarnessTarget, NormalizedTargetConfig>>;
 };
@@ -112,6 +149,7 @@ export const normalizeManifest = (manifest: DevKitManifest): NormalizedManifest
 
   for (const key of ["agents", "claude", "opencode"] as const) {
     const override = manifest.targets?.[key];
+
     if (override) {
       targets[key] = {
         enabled: override.enabled ?? DEFAULT_TARGETS[key].enabled,
@@ -125,6 +163,9 @@ export const normalizeManifest = (manifest: DevKitManifest): NormalizedManifest
     exclude: manifest.exclude ?? [],
     include: manifest.include,
     setup: {
+      agentInstructions: {
+        enabled: manifest.setup?.agentInstructions?.enabled ?? false,
+      },
       claudeInstructions: {
         enabled: manifest.setup?.claudeInstructions?.enabled ?? false,
       },
@@ -133,14 +174,21 @@ export const normalizeManifest = (manifest: DevKitManifest): NormalizedManifest
         packageName: manifest.setup?.effectSource?.packageName ?? "effect",
         path: manifest.setup?.effectSource?.path ?? ".repos/effect",
         repository:
-          manifest.setup?.effectSource?.repository ??
-          "https://github.com/Effect-TS/effect.git",
+          manifest.setup?.effectSource?.repository ?? "https://github.com/Effect-TS/effect.git",
       },
       effectTsgo: {
         enabled: manifest.setup?.effectTsgo?.enabled ?? false,
         force: manifest.setup?.effectTsgo?.force ?? false,
         typescriptPackage: manifest.setup?.effectTsgo?.typescriptPackage ?? "typescript",
       },
+      vitePlus: {
+        hooks: {
+          enabled: manifest.setup?.vitePlus?.hooks?.enabled ?? false,
+        },
+        quality: {
+          enabled: manifest.setup?.vitePlus?.quality?.enabled ?? false,
+        },
+      },
     },
     targets,
   };

package/src/node-symbolic-link.ts

@@ -9,6 +9,7 @@ export type SymbolicLinkObservation =
 const isNotSymbolicLink = (error: PlatformError.PlatformError): boolean => {
   if (error.reason._tag !== "Unknown") return false;
   const cause = error.reason.cause;
+
   return cause instanceof Error && "code" in cause && cause.code === "EINVAL";
 };
 
@@ -16,6 +17,7 @@ export const observeSymbolicLink = Effect.fn("observeSymbolicLink")(function* (
   absolutePath: string,
 ) {
   const fs = yield* FileSystem.FileSystem;
+
   return yield* fs.readLink(absolutePath).pipe(
     Effect.map((target): SymbolicLinkObservation => ({ kind: "symlink", target })),
     Effect.catch((error) => {
@@ -25,6 +27,7 @@ export const observeSymbolicLink = Effect.fn("observeSymbolicLink")(function* (
       if (isNotSymbolicLink(error)) {
         return Effect.succeed<SymbolicLinkObservation>({ kind: "not-symlink" });
       }
+
       return Effect.fail(error);
     }),
   );

package/src/oxlint-plugin-effect.js

@@ -33,6 +33,7 @@ const noPromiseAtomMode = {
         const isMode =
           (key.type === "Identifier" && key.name === "mode") ||
           (key.type === "Literal" && key.value === "mode");
+
         if (isMode && value.type === "Literal" && value.value === "promise") {
           context.report({ node, messageId: "noPromiseAtomMode" });
         }
@@ -117,8 +118,10 @@ const noAsyncWorkflow = {
         parent?.type === "Property" &&
         ((parent.key.type === "Identifier" && parent.key.name === "try") ||
           (parent.key.type === "Literal" && parent.key.value === "try"));
+
       if (!isCapturedTryThunk) context.report({ node, messageId: "noAsyncWorkflow" });
     };
+
     return {
       ArrowFunctionExpression: check,
       FunctionDeclaration: check,

package/src/oxlint-plugin-style.d.ts

@@ -0,0 +1,8 @@
+declare const styleOxlintPlugin: {
+  readonly meta: { readonly name: "dev-kit-style" };
+  readonly rules: {
+    readonly "padding-line-between-statements": unknown;
+  };
+};
+
+export default styleOxlintPlugin;

package/src/oxlint-plugin-style.js

@@ -0,0 +1,8 @@
+import stylisticPlugin from "@stylistic/eslint-plugin";
+
+export default {
+  meta: { name: "dev-kit-style" },
+  rules: {
+    "padding-line-between-statements": stylisticPlugin.rules["padding-line-between-statements"],
+  },
+};

package/src/oxlint.js

@@ -13,6 +13,10 @@ export const recommendedOxlintConfig = {
       name: "effect",
       specifier: "@danieljvdm/dev-kit/oxlint-plugin-effect",
     },
+    {
+      name: "stylistic",
+      specifier: "@danieljvdm/dev-kit/oxlint-plugin-style",
+    },
   ],
   plugins: ["import", "react", "vitest"],
   rules: {
@@ -24,6 +28,16 @@ export const recommendedOxlintConfig = {
     "import/no-self-import": "error",
     "react/exhaustive-deps": "error",
     "react/rules-of-hooks": "error",
+    "stylistic/padding-line-between-statements": [
+      "error",
+      { blankLine: "always", prev: ["const", "let", "var"], next: "*" },
+      {
+        blankLine: "any",
+        prev: ["const", "let", "var"],
+        next: ["const", "let", "var"],
+      },
+      { blankLine: "always", prev: "*", next: "return" },
+    ],
     "typescript/consistent-type-imports": "error",
     "typescript/no-floating-promises": "off",
     "typescript/no-explicit-any": "error",

package/src/oxlint.ts

@@ -16,6 +16,10 @@ export const recommendedOxlintConfig = {
       name: "effect",
       specifier: "@danieljvdm/dev-kit/oxlint-plugin-effect",
     },
+    {
+      name: "stylistic",
+      specifier: "@danieljvdm/dev-kit/oxlint-plugin-style",
+    },
   ],
   plugins: ["import", "react", "vitest"],
   rules: {
@@ -27,6 +31,16 @@ export const recommendedOxlintConfig = {
     "import/no-self-import": "error",
     "react/exhaustive-deps": "error",
     "react/rules-of-hooks": "error",
+    "stylistic/padding-line-between-statements": [
+      "error",
+      { blankLine: "always", prev: ["const", "let", "var"], next: "*" },
+      {
+        blankLine: "any",
+        prev: ["const", "let", "var"],
+        next: ["const", "let", "var"],
+      },
+      { blankLine: "always", prev: "*", next: "return" },
+    ],
     "typescript/consistent-type-imports": "error",
     "typescript/no-floating-promises": "off",
     "typescript/no-explicit-any": "error",

package/src/package-skill-source.ts

@@ -1,6 +1,7 @@
 import { Effect, FileSystem, Path, Result, Schema } from "effect";
 
 import { observeSymbolicLink } from "./node-symbolic-link.ts";
+import { readDirectDependencyNames } from "./project-package.ts";
 import { isSkillName, parseSkillSelector } from "./skill-selector.ts";
 import { isTypeScriptPackageName } from "./typescript-package-name.ts";
 
@@ -24,72 +25,88 @@ export type DiscoveredPackageSkill = {
   readonly linkPath: string;
 };
 
-const ProjectPackageSchema = Schema.fromJsonString(Schema.Struct({
-  dependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  devDependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  optionalDependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  peerDependencies: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-}));
-
-const PackageMetadataSchema = Schema.fromJsonString(Schema.Struct({
-  name: Schema.String,
-  version: Schema.String,
-  intent: Schema.optional(Schema.Unknown),
-  repository: Schema.optional(Schema.Unknown),
-}));
+const PackageMetadataSchema = Schema.fromJsonString(
+  Schema.Struct({
+    name: Schema.String,
+    version: Schema.String,
+    intent: Schema.optional(Schema.Unknown),
+    repository: Schema.optional(Schema.Unknown),
+  }),
+);
 
 const nonEmptyString = (value: unknown): value is string =>
   typeof value === "string" && value.trim().length > 0;
 
 const hasIntentDiscoveryMetadata = (metadata: typeof PackageMetadataSchema.Type): boolean => {
   const intent = metadata.intent;
-  if (typeof intent === "object" && intent !== null &&
-    "version" in intent && intent.version === 1 &&
-    "repo" in intent && nonEmptyString(intent.repo) &&
-    "docs" in intent && nonEmptyString(intent.docs)) {
+
+  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 (
+    nonEmptyString(repository) ||
+    (typeof repository === "object" &&
+      repository !== null &&
+      "url" in repository &&
+      nonEmptyString(repository.url))
+  );
 };
 
 const isSafePackageVersion = (value: string): boolean =>
-  value.length > 0 && value.trim() === value && ![...value].some((character) => {
+  value.length > 0 &&
+  value.trim() === value &&
+  ![...value].some((character) => {
     const code = character.charCodeAt(0);
+
     return code <= 32 || (code >= 127 && code <= 159);
   });
 
 const isContained = (path: Path.Path, root: string, candidate: string): boolean => {
   const relative = path.relative(root, candidate);
+
   return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
 };
 
 const frontmatterScalar = (document: string, key: string): string | undefined => {
   const body = document.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/)?.[1];
+
   if (body === undefined) return undefined;
   const lines = body.split(/\r?\n/);
   const index = lines.findIndex((line) => line.startsWith(`${key}:`));
+
   if (index < 0) return undefined;
   const raw = lines[index]?.slice(key.length + 1).trim() ?? "";
   const block = raw.match(/^([|>])(?:[1-9][+-]?|[+-][1-9]?)?$/)?.[1];
+
   if (block !== undefined) {
     const values: Array<string> = [];
+
     for (const line of lines.slice(index + 1)) {
       if (line.length > 0 && !/^\s/.test(line)) break;
       values.push(line.trim());
     }
     const value = block === "|" ? values.join("\n").trim() : values.join(" ").trim();
+
     return value.length > 0 ? value : undefined;
   }
   const quoted = raw.match(/^(['"])([\s\S]*?)\1(?:\s+#.*)?$/)?.[2];
   const value = (quoted ?? raw.replace(/\s+#.*$/, "")).trim();
+
   return value.length > 0 ? value : undefined;
 };
 
-const skillName = (document: string): string | undefined =>
-  frontmatterScalar(document, "name");
+const skillName = (document: string): string | undefined => frontmatterScalar(document, "name");
 
 const skillDescription = (document: string): string | undefined =>
   frontmatterScalar(document, "description");
@@ -98,38 +115,38 @@ const rejectNestedSymlinks = Effect.fn("rejectPackageSkillSymlinks")(function* (
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const pending = [skillRoot];
+
   while (pending.length > 0) {
     const current = pending.pop();
+
     if (current === undefined) continue;
     if ((yield* observeSymbolicLink(current)).kind === "symlink") {
-      return yield* new PackageSkillSourceError({ message: `package skill contains a symlink: ${current}` });
+      return yield* new PackageSkillSourceError({
+        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(
+          () =>
+            new PackageSkillSourceError({ 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}` })),
-    )) pending.push(path.join(current, entry));
+    for (const entry of yield* fs
+      .readDirectory(current)
+      .pipe(
+        Effect.mapError(
+          () =>
+            new PackageSkillSourceError({ message: `could not read package skill: ${current}` }),
+        ),
+      ))
+      pending.push(path.join(current, entry));
   }
 });
 
-const readDirectDependencyNames = Effect.fn("readDirectPackageSkillDependencyNames")(function* (projectDir: string) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const manifestPath = path.join(projectDir, "package.json");
-  const manifest = yield* fs.readFileString(manifestPath).pipe(
-    Effect.flatMap(Schema.decodeUnknownEffect(ProjectPackageSchema)),
-    Effect.mapError(() => new PackageSkillSourceError({ message: `invalid project package.json: ${manifestPath}` })),
-  );
-  return [...new Set([
-    ...Object.keys(manifest.dependencies ?? {}),
-    ...Object.keys(manifest.devDependencies ?? {}),
-    ...Object.keys(manifest.optionalDependencies ?? {}),
-    ...Object.keys(manifest.peerDependencies ?? {}),
-  ])].sort();
-});
-
 type InstalledPackageSkills = {
   readonly package: string;
   readonly version: string;
@@ -146,33 +163,85 @@ 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(
+      () =>
+        new PackageSkillSourceError({
+          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(
+      () =>
+        new PackageSkillSourceError({
+          message: `could not inspect package skill package: ${packageName}`,
+        }),
+    ),
   );
-  if (packageInfo.type !== "Directory") return yield* new PackageSkillSourceError({ message: `package skill package is not a directory: ${packageName}` });
+
+  if (packageInfo.type !== "Directory")
+    return yield* new PackageSkillSourceError({
+      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(
+      () =>
+        new PackageSkillSourceError({
+          message: `invalid package.json for package skill package: ${packageName}`,
+        }),
+    ),
   );
-  if (metadata.name !== packageName) return yield* new PackageSkillSourceError({ message: `package.json name does not match package skill package: ${packageName}` });
-  if (!isSafePackageVersion(metadata.version)) return yield* new PackageSkillSourceError({ message: `package.json has an invalid version for package skill package: ${packageName}` });
-  if (!hasIntentDiscoveryMetadata(metadata)) return yield* new PackageSkillSourceError({ message: `package does not declare Intent-compatible discovery metadata: ${packageName}` });
+
+  if (metadata.name !== packageName)
+    return yield* new PackageSkillSourceError({
+      message: `package.json name does not match package skill package: ${packageName}`,
+    });
+  if (!isSafePackageVersion(metadata.version))
+    return yield* new PackageSkillSourceError({
+      message: `package.json has an invalid version for package skill package: ${packageName}`,
+    });
+  if (!hasIntentDiscoveryMetadata(metadata))
+    return yield* new PackageSkillSourceError({
+      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({ message: `package skills path is a symlink: ${packageName}/${skillsPath}` });
+
+  if ((yield* observeSymbolicLink(skillsLink)).kind === "symlink")
+    return yield* new PackageSkillSourceError({
+      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(
+      () =>
+        new PackageSkillSourceError({
+          message: `package skill package has no skills directory: ${packageName}`,
+        }),
+    ),
   );
-  if (!isContained(path, packageRoot, skillsRoot)) return yield* new PackageSkillSourceError({ message: `package skills path resolves outside package root: ${packageName}/${skillsPath}` });
+
+  if (!isContained(path, packageRoot, skillsRoot))
+    return yield* new PackageSkillSourceError({
+      message: `package skills path resolves outside package root: ${packageName}/${skillsPath}`,
+    });
   const skillsInfo = yield* fs.stat(skillsRoot);
-  if (skillsInfo.type !== "Directory") return yield* new PackageSkillSourceError({ message: `package skills path is not a directory: ${packageName}/${skillsPath}` });
+
+  if (skillsInfo.type !== "Directory")
+    return yield* new PackageSkillSourceError({
+      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}`,
-    })),
-  )).filter(isSkillName).sort();
+    Effect.mapError(
+      () =>
+        new PackageSkillSourceError({
+          message: `package skill package has no readable skills directory: ${packageName}`,
+        }),
+    ),
+  ))
+    .filter(isSkillName)
+    .sort();
+
   return {
     package: packageName,
     version: metadata.version,
@@ -188,36 +257,57 @@ const inspectPackageSkill = Effect.fn("inspectInstalledPackageSkill")(function*
 ) {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
+
   if (!isSkillName(name)) {
     return yield* new PackageSkillSourceError({ 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({ message: `package skill contains a symlink: ${selector}` });
+    return yield* new PackageSkillSourceError({
+      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}` })),
-  );
-  if (!isContained(path, installed.skillsRoot, skillRoot) ||
-    (yield* fs.stat(skillRoot)).type !== "Directory") {
-    return yield* new PackageSkillSourceError({ message: `package skill is not a contained directory: ${selector}` });
+  const skillRoot = yield* fs
+    .realPath(linkPath)
+    .pipe(
+      Effect.mapError(
+        () => new PackageSkillSourceError({ message: `package skill does not exist: ${selector}` }),
+      ),
+    );
+
+  if (
+    !isContained(path, installed.skillsRoot, skillRoot) ||
+    (yield* fs.stat(skillRoot)).type !== "Directory"
+  ) {
+    return yield* new PackageSkillSourceError({
+      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(
+      () =>
+        new PackageSkillSourceError({
+          message: `package skill is missing SKILL.md: ${selector}`,
+        }),
+    ),
   );
+
   if (skillName(document) !== name) {
     return yield* new PackageSkillSourceError({
       message: `package skill SKILL.md name must match directory: ${selector}`,
     });
   }
   const description = skillDescription(document);
+
   if (description === undefined) {
     return yield* new PackageSkillSourceError({
       message: `package skill SKILL.md must declare a description: ${selector}`,
     });
   }
+
   return {
     selector,
     name,
@@ -230,41 +320,66 @@ const inspectPackageSkill = Effect.fn("inspectInstalledPackageSkill")(function*
 });
 
 /** Read direct project dependencies only; malformed packages are returned as diagnostics, never executed. */
-export const discoverPackageSkills = Effect.fn("discoverInstalledPackageSkills")(function* (projectDir: string) {
+export const discoverPackageSkills = Effect.fn("discoverInstalledPackageSkills")(function* (
+  projectDir: string,
+) {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const candidates: Array<DiscoveredPackageSkill> = [];
   const diagnostics: Array<PackageSkillDiagnostic> = [];
+
   if (!(yield* fs.exists(path.join(projectDir, "package.json")))) {
     return { candidates, diagnostics };
   }
   for (const packageName of yield* readDirectDependencyNames(projectDir)) {
     if (!isTypeScriptPackageName(packageName)) {
-      diagnostics.push({ package: packageName, message: `invalid direct dependency package name: ${packageName}` });
+      diagnostics.push({
+        package: packageName,
+        message: `invalid direct dependency package name: ${packageName}`,
+      });
       continue;
     }
     const skillsLink = path.join(projectDir, "node_modules", ...packageName.split("/"), "skills");
+
     if (!(yield* fs.exists(skillsLink))) continue;
     const installed = yield* Effect.result(loadInstalledPackageSkills(projectDir, packageName));
+
     if (Result.isFailure(installed)) {
       diagnostics.push({ package: packageName, message: installed.failure.message });
       continue;
     }
     for (const name of installed.success.names) {
       const inspected = yield* Effect.result(inspectPackageSkill(installed.success, name));
+
       if (Result.isSuccess(inspected)) candidates.push(inspected.success);
       else diagnostics.push({ package: packageName, message: inspected.failure.message });
     }
   }
-  return { candidates: candidates.sort((left, right) => left.selector.localeCompare(right.selector)), diagnostics };
+
+  return {
+    candidates: candidates.sort((left, right) => left.selector.localeCompare(right.selector)),
+    diagnostics,
+  };
 });
 
 /** Resolve one explicitly selected package skill. Unlike browsing, every malformed or missing part is an error. */
-export const resolvePackageSkillSelector = Effect.fn("resolvePackageSkillSelector")(function* (projectDir: string, selector: string) {
+export const resolvePackageSkillSelector = Effect.fn("resolvePackageSkillSelector")(function* (
+  projectDir: string,
+  selector: string,
+) {
   const parsed = parseSkillSelector(selector);
-  if (parsed?.type !== "package") return yield* new PackageSkillSourceError({ message: `invalid package skill selector: ${selector}` });
+
+  if (parsed?.type !== "package")
+    return yield* new PackageSkillSourceError({
+      message: `invalid package skill selector: ${selector}`,
+    });
   const directDependencies = yield* readDirectDependencyNames(projectDir);
-  if (!directDependencies.includes(parsed.package)) return yield* new PackageSkillSourceError({ message: `package skill package is not a direct dependency: ${parsed.package}` });
+
+  if (!directDependencies.includes(parsed.package))
+    return yield* new PackageSkillSourceError({
+      message: `package skill package is not a direct dependency: ${parsed.package}`,
+    });
+
   return yield* inspectPackageSkill(
     yield* loadInstalledPackageSkills(projectDir, parsed.package),
     parsed.skill,