@danieljvdm/dev-kit 0.6.0 → 0.7.0

package/src/project-package.ts

@@ -5,30 +5,55 @@ export class ProjectPackageError extends Schema.TaggedErrorClass<ProjectPackageE
   { message: Schema.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 ProjectPackageSchema = Schema.fromJsonString(
+  Schema.Struct({
+    name: Schema.optional(Schema.String),
+    scripts: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    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)),
+  }),
+);
 
-export const readDirectDependencyNames = Effect.fn("readDirectDependencyNames")(function* (
-  projectDir: string,
-) {
+export const readProjectPackage = Effect.fn("readProjectPackage")(function* (projectDir: string) {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const manifestPath = path.join(projectDir, "package.json");
-  if (!(yield* fs.exists(manifestPath))) return [];
+
+  if (!(yield* fs.exists(manifestPath))) {
+    return yield* new ProjectPackageError({ 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(
+      () =>
+        new ProjectPackageError({
+          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();
+
+  return manifest;
+});
+
+export const readDirectDependencyNames = Effect.fn("readDirectDependencyNames")(function* (
+  projectDir: string,
+) {
+  const manifest = yield* readProjectPackage(projectDir).pipe(
+    Effect.catchTag("ProjectPackageError", (error) =>
+      error.message.startsWith("package.json not found:") ? Effect.void : Effect.fail(error),
+    ),
+  );
+
+  if (manifest === undefined) return [];
+
+  return [
+    ...new Set([
+      ...Object.keys(manifest.dependencies ?? {}),
+      ...Object.keys(manifest.devDependencies ?? {}),
+      ...Object.keys(manifest.optionalDependencies ?? {}),
+      ...Object.keys(manifest.peerDependencies ?? {}),
+    ]),
+  ].sort();
 });

package/src/project-process-lock.ts

@@ -38,15 +38,18 @@ export const acquireProjectProcessLock = Effect.fn("acquireProjectProcessLock")(
   return yield* Effect.acquireRelease(
     Effect.gen(function* () {
       yield* fs.makeDirectory(stateDir, { recursive: true });
+
       return yield* Effect.uninterruptible(
         Effect.gen(function* () {
-          yield* fs.makeDirectory(lockDir).pipe(
-            Effect.mapError((error) =>
-              error.reason._tag === "AlreadyExists"
-                ? new ProjectAlreadyLockedError({ path: lockDir })
-                : error,
-            ),
-          );
+          yield* fs
+            .makeDirectory(lockDir)
+            .pipe(
+              Effect.mapError((error) =>
+                error.reason._tag === "AlreadyExists"
+                  ? new ProjectAlreadyLockedError({ path: lockDir })
+                  : error,
+              ),
+            );
           yield* fs.writeFileString(ownerPath, ownerContents).pipe(
             Effect.catchCause((writeCause) =>
               fs.remove(lockDir, { recursive: true, force: true }).pipe(
@@ -57,17 +60,21 @@ export const acquireProjectProcessLock = Effect.fn("acquireProjectProcessLock")(
               ),
             ),
           );
+
           return { lockDir, ownerContents };
         }),
       );
     }),
     ({ lockDir: acquiredLockDir, ownerContents }) =>
       Effect.gen(function* () {
-        const currentOwner = yield* fs.readFileString(ownerPath).pipe(
-          Effect.catch((error) =>
-            error.reason._tag === "NotFound" ? Effect.void : Effect.fail(error),
-          ),
-        );
+        const currentOwner = yield* fs
+          .readFileString(ownerPath)
+          .pipe(
+            Effect.catch((error) =>
+              error.reason._tag === "NotFound" ? Effect.void : Effect.fail(error),
+            ),
+          );
+
         if (currentOwner === ownerContents) {
           yield* fs.remove(acquiredLockDir, { recursive: true, force: true });
         }

package/src/project-state.ts

@@ -49,6 +49,16 @@ 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"]),
+  path: Schema.String,
+  sourcePath: Schema.String,
+  mode: Schema.Literal("copy"),
+  kind: Schema.Literal("file"),
+  digest: DigestSchema,
+});
+export type ManagedGeneratedFileOutput = typeof ManagedGeneratedFileOutputSchema.Type;
+
 export const ManagedInstructionOutputSchema = Schema.Union([
   ManagedAgentInstructionsOutputSchema,
   ManagedClaudeInstructionsOutputSchema,
@@ -58,6 +68,7 @@ export type ManagedInstructionOutput = typeof ManagedInstructionOutputSchema.Typ
 export const ManagedOutputSchema = Schema.Union([
   ManagedSkillOutputSchema,
   ManagedInstructionOutputSchema,
+  ManagedGeneratedFileOutputSchema,
 ]);
 export type ManagedOutput = typeof ManagedOutputSchema.Type;
 

package/src/skill-manager.ts

@@ -1,18 +1,17 @@
-import { applyEdits, modify, parse as parseJsonc, type ParseError } from "jsonc-parser";
 import { Effect, FileSystem, Path, Schema } from "effect";
 import { Prompt } from "effect/unstable/cli";
+import { applyEdits, modify, parse as parseJsonc, type ParseError } from "jsonc-parser";
 
 import { loadSkillCatalog } from "./catalog.ts";
 import { isInteractiveTerminal, printDetail, printLine, printStatus } from "./cli-ui.ts";
+import { patchProjectGitignore } from "./gitignore.ts";
 import { DevKitManifestSchema } from "./manifest.ts";
 import { observeSymbolicLink } from "./node-symbolic-link.ts";
 import { runProjectSkillPlan } from "./sync.ts";
-import { patchProjectGitignore } from "./gitignore.ts";
 
-class SkillManagerError extends Schema.TaggedErrorClass<SkillManagerError>()(
-  "SkillManagerError",
-  { message: Schema.String },
-) {}
+class SkillManagerError extends Schema.TaggedErrorClass<SkillManagerError>()("SkillManagerError", {
+  message: Schema.String,
+}) {}
 
 type ManagerOptions = {
   readonly projectDir?: string;
@@ -22,16 +21,16 @@ type ManagerOptions = {
 
 const packageRoot = Effect.fn("skillManagerPackageRoot")(function* () {
   const path = yield* Path.Path;
+
   return path.resolve(path.dirname(yield* path.fromFileUrl(new URL(import.meta.url))), "..");
 });
 
-const resolvePaths = Effect.fn("resolveSkillManagerPaths")(function* (
-  options: ManagerOptions,
-) {
+const resolvePaths = Effect.fn("resolveSkillManagerPaths")(function* (options: ManagerOptions) {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const projectDir = path.resolve(options.projectDir ?? ".");
   const candidate = options.manifestPath ?? "dev-kit.jsonc";
+
   if (candidate.length === 0 || path.isAbsolute(candidate)) {
     return yield* new SkillManagerError({
       message: "--manifest must be a non-empty project-relative path",
@@ -39,16 +38,14 @@ const resolvePaths = Effect.fn("resolveSkillManagerPaths")(function* (
   }
   const manifestPath = path.resolve(projectDir, candidate);
   const relative = path.relative(projectDir, manifestPath);
-  if (
-    relative === ".." ||
-    relative.startsWith(`..${path.sep}`) ||
-    path.isAbsolute(relative)
-  ) {
+
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
     return yield* new SkillManagerError({
       message: "--manifest must resolve inside the project",
     });
   }
   let ancestor = projectDir;
+
   for (const segment of relative.split(path.sep).slice(0, -1)) {
     ancestor = path.join(ancestor, segment);
     if ((yield* observeSymbolicLink(ancestor)).kind === "symlink") {
@@ -58,12 +55,14 @@ const resolvePaths = Effect.fn("resolveSkillManagerPaths")(function* (
     }
   }
   const destination = yield* observeSymbolicLink(manifestPath);
+
   if (destination.kind === "symlink") {
     return yield* new SkillManagerError({ 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 {
     projectDir,
     manifestPath,
@@ -73,31 +72,45 @@ const resolvePaths = Effect.fn("resolveSkillManagerPaths")(function* (
 const renderDefaultManifest = (projectDir: string, manifestPath: string, path: Path.Path) => {
   const rawSchemaPath = path.relative(
     path.dirname(manifestPath),
-    path.join(projectDir, "node_modules", "@danieljvdm", "dev-kit", "schema", "dev-kit.schema.json"),
+    path.join(
+      projectDir,
+      "node_modules",
+      "@danieljvdm",
+      "dev-kit",
+      "schema",
+      "dev-kit.schema.json",
+    ),
   );
-  const portableSchemaPath = path.sep === "/"
-    ? rawSchemaPath
-    : rawSchemaPath.split(path.sep).join("/");
+  const portableSchemaPath =
+    path.sep === "/" ? rawSchemaPath : rawSchemaPath.split(path.sep).join("/");
   const schemaPath = portableSchemaPath.startsWith(".")
     ? portableSchemaPath
     : `./${portableSchemaPath}`;
-  return `${JSON.stringify({
-    $schema: schemaPath,
-    include: [],
-    targets: { agents: { enabled: true, mode: "copy" } },
-  }, null, 2)}\n`;
+
+  return `${JSON.stringify(
+    {
+      $schema: schemaPath,
+      include: [],
+      targets: { agents: { enabled: true, mode: "copy" } },
+    },
+    null,
+    2,
+  )}\n`;
 };
 
-const createDefaultManifest = Effect.fn("createDefaultSkillManifest")(function* (
-  paths: { readonly projectDir: string; readonly manifestPath: string },
-) {
+const createDefaultManifest = Effect.fn("createDefaultSkillManifest")(function* (paths: {
+  readonly projectDir: string;
+  readonly manifestPath: string;
+}) {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
+
   yield* fs.makeDirectory(path.dirname(paths.manifestPath), { recursive: true });
   const staged = yield* fs.makeTempFileScoped({
     directory: path.dirname(paths.manifestPath),
     prefix: ".dev-kit-init-",
   });
+
   yield* fs.writeFileString(
     staged,
     renderDefaultManifest(paths.projectDir, paths.manifestPath, path),
@@ -112,6 +125,7 @@ const readManifest = Effect.fn("readManagedSkillManifest")(function* (
 ) {
   const fs = yield* FileSystem.FileSystem;
   const paths = yield* resolvePaths(options);
+
   if (!(yield* fs.exists(paths.manifestPath))) {
     if (!create) {
       return yield* new SkillManagerError({
@@ -123,12 +137,14 @@ const readManifest = Effect.fn("readManagedSkillManifest")(function* (
   const raw = yield* fs.readFileString(paths.manifestPath);
   const errors: Array<ParseError> = [];
   const parsed = parseJsonc(raw, errors, { allowTrailingComma: true });
+
   if (errors.length > 0) {
     return yield* new SkillManagerError({ message: `could not parse ${paths.manifestPath}` });
   }
   const manifest = yield* Schema.decodeUnknownEffect(DevKitManifestSchema)(parsed).pipe(
     Effect.mapError((error) => new SkillManagerError({ message: error.message })),
   );
+
   return { ...paths, manifest, raw };
 });
 
@@ -141,33 +157,46 @@ const writeArray = Effect.fn("writeManifestArray")(function* (
   const fs = yield* FileSystem.FileSystem;
   const parsed = parseJsonc(raw) as Record<string, unknown>;
   const current = Array.isArray(parsed[property])
-    ? (parsed[property] as Array<unknown>).filter((value): value is string => typeof value === "string")
+    ? (parsed[property] as Array<unknown>).filter(
+        (value): value is string => typeof value === "string",
+      )
     : undefined;
+
   if (current === undefined) {
     if (values.length === 0) return;
     const edits = modify(raw, [property], [...values], {
       formattingOptions: { insertSpaces: true, tabSize: 2 },
     });
+
     yield* fs.writeFileString(manifestPath, applyEdits(raw, edits));
+
     return;
   }
   let next = raw;
   const retained = [...current];
+
   for (let index = current.length - 1; index >= 0; index -= 1) {
     const currentValue = current[index];
+
     if (currentValue !== undefined && !values.includes(currentValue)) {
-      next = applyEdits(next, modify(next, [property, index], undefined, {
-        formattingOptions: { insertSpaces: true, tabSize: 2 },
-      }));
+      next = applyEdits(
+        next,
+        modify(next, [property, index], undefined, {
+          formattingOptions: { insertSpaces: true, tabSize: 2 },
+        }),
+      );
       retained.splice(index, 1);
     }
   }
   for (const value of values) {
     if (retained.includes(value)) continue;
-    next = applyEdits(next, modify(next, [property, retained.length], value, {
-      formattingOptions: { insertSpaces: true, tabSize: 2 },
-      isArrayInsertion: true,
-    }));
+    next = applyEdits(
+      next,
+      modify(next, [property, retained.length], value, {
+        formattingOptions: { insertSpaces: true, tabSize: 2 },
+        isArrayInsertion: true,
+      }),
+    );
     retained.push(value);
   }
   if (next !== raw) yield* fs.writeFileString(manifestPath, next);
@@ -179,24 +208,32 @@ const selectedNames = (
   families: Readonly<Record<string, ReadonlyArray<string>>>,
 ) => {
   const selected = new Set<string>();
+
   for (const name of include) {
     for (const skill of families[name] ?? [name]) selected.add(skill);
   }
   for (const name of exclude) {
     for (const skill of families[name] ?? [name]) selected.delete(skill);
   }
+
   return selected;
 };
 
 const displayValue = (value: string): string =>
-  [...value].map((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || (code >= 127 && code <= 159) ? " " : character;
-  }).join("").replace(/\s+/g, " ").trim();
+  [...value]
+    .map((character) => {
+      const code = character.charCodeAt(0);
+
+      return code <= 31 || (code >= 127 && code <= 159) ? " " : character;
+    })
+    .join("")
+    .replace(/\s+/g, " ")
+    .trim();
 
 const summary = (description: string, defaultDescription: string): string => {
   const text = displayValue(description || defaultDescription);
   const firstSentence = text.match(/^.*?[.!?](?:\s|$)/)?.[0]?.trim() ?? text;
+
   return firstSentence.length > 96 ? `${firstSentence.slice(0, 93).trimEnd()}…` : firstSentence;
 };
 
@@ -211,8 +248,10 @@ const applyIfRequested = (options: ManagerOptions) =>
 export const initProject = Effect.fn("initDevKitProject")(function* (options: ManagerOptions) {
   const fs = yield* FileSystem.FileSystem;
   const paths = yield* resolvePaths(options);
+
   if (yield* fs.exists(paths.manifestPath)) {
     yield* printStatus("info", "Already initialized", paths.manifestPath);
+
     return;
   }
   yield* createDefaultManifest(paths);
@@ -226,14 +265,19 @@ export const addSkills = Effect.fn("addManagedSkills")(function* (
 ) {
   const current = yield* readManifest(options, true);
   const catalog = yield* loadSkillCatalog(yield* packageRoot(), current.projectDir);
-  const known = new Set([...catalog.skills.map((skill) => skill.selector), ...Object.keys(catalog.families)]);
+  const known = new Set([
+    ...catalog.skills.map((skill) => skill.selector),
+    ...Object.keys(catalog.families),
+  ]);
   const unknown = names.filter((name) => !known.has(name));
+
   if (unknown.length > 0) {
     return yield* new SkillManagerError({
       message: `unknown skill${unknown.length === 1 ? "" : "s"}: ${unknown.join(", ")}. Try \`dev-kit search ${unknown[0]}\`.`,
     });
   }
   const sourceFamilies = catalog.lock?.sources ?? [];
+
   for (const source of sourceFamilies) {
     if (!names.includes(source.id)) continue;
     yield* printStatus(
@@ -246,8 +290,10 @@ export const addSkills = Effect.fn("addManagedSkills")(function* (
   }
   const include = [...new Set([...current.manifest.include, ...names])];
   const exclude = (current.manifest.exclude ?? []).filter((name) => !names.includes(name));
+
   yield* writeArray(current.manifestPath, current.raw, "include", include);
   const reread = yield* FileSystem.FileSystem;
+
   yield* writeArray(
     current.manifestPath,
     yield* reread.readFileString(current.manifestPath),
@@ -268,18 +314,23 @@ export const removeSkills = Effect.fn("removeManagedSkills")(function* (
     current.manifest.exclude ?? [],
     catalog.families,
   );
-  const absent = names.filter((name) => !before.has(name) && !current.manifest.include.includes(name));
+  const absent = names.filter(
+    (name) => !before.has(name) && !current.manifest.include.includes(name),
+  );
+
   if (absent.length > 0) {
     return yield* new SkillManagerError({ message: `not selected: ${absent.join(", ")}` });
   }
   const include = current.manifest.include.filter((name) => !names.includes(name));
   const excluded = new Set(current.manifest.exclude ?? []);
+
   for (const name of names) {
     if (before.has(name) && !current.manifest.include.includes(name)) excluded.add(name);
     else excluded.delete(name);
   }
   yield* writeArray(current.manifestPath, current.raw, "include", include);
   const fs = yield* FileSystem.FileSystem;
+
   yield* writeArray(
     current.manifestPath,
     yield* fs.readFileString(current.manifestPath),
@@ -300,17 +351,22 @@ export const listSkills = Effect.fn("listManagedSkills")(function* (
     : { include: [], exclude: [] };
   const selected = selectedNames(manifest.include, manifest.exclude ?? [], catalog.families);
   const query = options.query?.toLowerCase();
-  const visible = catalog.skills.filter((skill) =>
-    (options.all || selected.has(skill.selector)) &&
-    (!query || `${skill.selector} ${skill.description} ${skill.source}`.toLowerCase().includes(query)),
+  const visible = catalog.skills.filter(
+    (skill) =>
+      (options.all || selected.has(skill.selector)) &&
+      (!query ||
+        `${skill.selector} ${skill.description} ${skill.source}`.toLowerCase().includes(query)),
   );
   const catalogSelectors = new Set(catalog.skills.map((skill) => skill.selector));
-  const unavailable = [...selected].filter((selector) =>
-    !catalogSelectors.has(selector) && (!query || selector.toLowerCase().includes(query))
+  const unavailable = [...selected].filter(
+    (selector) =>
+      !catalogSelectors.has(selector) && (!query || selector.toLowerCase().includes(query)),
   );
+
   if (visible.length === 0 && unavailable.length === 0) {
     yield* printStatus("info", query ? "No matching skills" : "No skills selected");
     if (!query && !options.all) yield* printDetail("Browse with: dev-kit list --all");
+
     return;
   }
   for (const skill of visible) {
@@ -318,11 +374,18 @@ export const listSkills = Effect.fn("listManagedSkills")(function* (
     const origin = skill.bundled ? "built in" : skill.source;
     const provenance = skill.package
       ? ` [installed ${displayValue(skill.package.version)}]`
-      : skill.bundled ? "" : ` [${skill.source}]`;
-    yield* printLine(`${marker} ${skill.selector}${provenance}  ${summary(skill.description, origin)}`);
+      : skill.bundled
+        ? ""
+        : ` [${skill.source}]`;
+
+    yield* printLine(
+      `${marker} ${skill.selector}${provenance}  ${summary(skill.description, origin)}`,
+    );
   }
   for (const selector of unavailable) {
-    yield* printLine(`! ${selector} [unavailable]  install or repair the selected direct dependency`);
+    yield* printLine(
+      `! ${selector} [unavailable]  install or repair the selected direct dependency`,
+    );
   }
   yield* printLine();
   yield* printLine(`${selected.size} selected · ${catalog.skills.length} available`);
@@ -335,6 +398,7 @@ export const showSkill = Effect.fn("showCatalogSkill")(function* (
   const paths = yield* resolvePaths(options);
   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}` });
   yield* printLine(skill.selector);
   if (skill.description) yield* printLine(displayValue(skill.description));
@@ -342,14 +406,17 @@ export const showSkill = Effect.fn("showCatalogSkill")(function* (
     yield* printLine(`Source: installed package`);
     yield* printLine(`Package: ${skill.package.name}`);
     yield* printLine(`Version: ${displayValue(skill.package.version)}`);
+
     return;
   }
   yield* printLine(`Source: ${skill.bundled ? "dev-kit (built in)" : skill.source}`);
   if (!skill.bundled) {
     const source = catalog.lock?.sources.find((candidate) => candidate.id === skill.source);
+
     if (source) {
       yield* printLine(`Repository: ${source.repository}`);
       yield* printLine(`Approved commit: ${source.resolved}`);
+
       return;
     }
   }
@@ -369,7 +436,9 @@ export const chooseSkillsToAdd = Effect.fn("chooseSkillsToAdd")(function* (
   options: ManagerOptions,
 ) {
   if (!(yield* isInteractiveTerminal)) {
-    return yield* new SkillManagerError({ message: "pass one or more skill names, or run this command in a terminal" });
+    return yield* new SkillManagerError({
+      message: "pass one or more skill names, or run this command in a terminal",
+    });
   }
   const current = yield* readManifest(options, true);
   const catalog = yield* loadSkillCatalog(yield* packageRoot(), current.projectDir);
@@ -379,8 +448,10 @@ export const chooseSkillsToAdd = Effect.fn("chooseSkillsToAdd")(function* (
     catalog.families,
   );
   const available = catalog.skills.filter((skill) => !selected.has(skill.selector));
+
   if (available.length === 0) {
     yield* printStatus("success", "All available skills are selected");
+
     return;
   }
   const names = yield* Prompt.multiSelect({
@@ -392,6 +463,7 @@ export const chooseSkillsToAdd = Effect.fn("chooseSkillsToAdd")(function* (
     })),
     min: 1,
   });
+
   yield* addSkills(names, options);
 });
 
@@ -399,7 +471,9 @@ export const chooseSkillsToRemove = Effect.fn("chooseSkillsToRemove")(function*
   options: ManagerOptions,
 ) {
   if (!(yield* isInteractiveTerminal)) {
-    return yield* new SkillManagerError({ message: "pass one or more skill names, or run this command in a terminal" });
+    return yield* new SkillManagerError({
+      message: "pass one or more skill names, or run this command in a terminal",
+    });
   }
   const current = yield* readManifest(options);
   const catalog = yield* loadSkillCatalog(yield* packageRoot(), current.projectDir);
@@ -408,18 +482,22 @@ export const chooseSkillsToRemove = Effect.fn("chooseSkillsToRemove")(function*
     current.manifest.exclude ?? [],
     catalog.families,
   );
+
   if (selected.size === 0) {
     yield* printStatus("info", "No skills selected");
+
     return;
   }
   const names = yield* Prompt.multiSelect({
     message: "Choose skills to remove",
     choices: [
-      ...catalog.skills.filter((skill) => selected.has(skill.selector)).map((skill) => ({
-        title: skill.selector,
-        value: skill.selector,
-        description: summary(skill.description, skill.source),
-      })),
+      ...catalog.skills
+        .filter((skill) => selected.has(skill.selector))
+        .map((skill) => ({
+          title: skill.selector,
+          value: skill.selector,
+          description: summary(skill.description, skill.source),
+        })),
       ...[...selected]
         .filter((selector) => !catalog.skills.some((skill) => skill.selector === selector))
         .map((selector) => ({
@@ -430,5 +508,6 @@ export const chooseSkillsToRemove = Effect.fn("chooseSkillsToRemove")(function*
     ],
     min: 1,
   });
+
   yield* removeSkills(names, options);
 });

package/src/skill-selector.ts

@@ -35,9 +35,15 @@ export const parseSkillSelector = (value: string): SkillSelector | undefined =>
   const match = PACKAGE_SKILL_SELECTOR_PATTERN.exec(value);
   const packageName = match?.groups?.package;
   const skill = match?.groups?.skill;
-  if (packageName === undefined || skill === undefined ||
-    !isTypeScriptPackageName(packageName) || !isSkillName(skill)) {
+
+  if (
+    packageName === undefined ||
+    skill === undefined ||
+    !isTypeScriptPackageName(packageName) ||
+    !isSkillName(skill)
+  ) {
     return undefined;
   }
+
   return { type: "package", package: packageName, skill };
 };

package/src/source-manifest.ts

@@ -31,12 +31,8 @@ export const LockedSkillSourceSchema = Schema.Struct({
   include: Schema.Array(Schema.String),
   exclude: Schema.optional(Schema.Array(Schema.String)),
   skills: Schema.Array(Schema.String),
-  descriptions: Schema.optional(
-    Schema.Record(Schema.String, Schema.String),
-  ),
-  digests: Schema.optional(
-    Schema.Record(Schema.String, DigestSchema),
-  ),
+  descriptions: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  digests: Schema.optional(Schema.Record(Schema.String, DigestSchema)),
   licensePath: Schema.optional(Schema.String),
   stripFrontmatter: Schema.optional(Schema.Array(Schema.String)),
 });