@danieljvdm/dev-kit 0.16.0 → 0.18.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);

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> = [];

package/src/skill-manager.ts

@@ -19,6 +19,11 @@ type ManagerOptions = {
   readonly apply?: boolean;
 };
 
+type ManagerSyncOptions = {
+  projectDir?: string;
+  manifestPath?: string;
+};
+
 const packageRoot = Effect.fn("skillManagerPackageRoot")(function* () {
   const path = yield* Path.Path;
 
@@ -150,6 +155,11 @@ const readManifest = Effect.fn("readManagedSkillManifest")(function* (
   return { ...paths, manifest, raw };
 });
 
+const ManifestSelectionSchema = Schema.Struct({
+  include: Schema.optional(Schema.Array(Schema.String)),
+  exclude: Schema.optional(Schema.Array(Schema.String)),
+});
+
 const writeArray = Effect.fn("writeManifestArray")(function* (
   manifestPath: string,
   raw: string,
@@ -157,12 +167,10 @@ const writeArray = Effect.fn("writeManifestArray")(function* (
   values: ReadonlyArray<string>,
 ) {
   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",
-      )
-    : undefined;
+  const parsed = yield* Schema.decodeUnknownEffect(ManifestSelectionSchema)(parseJsonc(raw)).pipe(
+    Effect.mapError((error) => SkillManagerError.make({ message: error.message })),
+  );
+  const current = parsed[property];
 
   if (current === undefined) {
     if (values.length === 0) return;
@@ -239,13 +247,17 @@ const summary = (description: string, defaultDescription: string): string => {
   return firstSentence.length > 96 ? `${firstSentence.slice(0, 93).trimEnd()}…` : firstSentence;
 };
 
-const applyIfRequested = (options: ManagerOptions) =>
-  options.apply === false
-    ? printStatus("success", "Manifest updated", "run dev-kit sync to apply")
-    : runProjectSkillPlan({
-        ...(options.projectDir === undefined ? {} : { projectDir: options.projectDir }),
-        ...(options.manifestPath === undefined ? {} : { manifestPath: options.manifestPath }),
-      });
+const applyIfRequested = (options: ManagerOptions) => {
+  if (options.apply === false) {
+    return printStatus("success", "Manifest updated", "run dev-kit sync to apply");
+  }
+  const syncOptions: ManagerSyncOptions = {};
+
+  if (options.projectDir !== undefined) syncOptions.projectDir = options.projectDir;
+  if (options.manifestPath !== undefined) syncOptions.manifestPath = options.manifestPath;
+
+  return runProjectSkillPlan(syncOptions);
+};
 
 export const initProject = Effect.fn("initDevKitProject")(function* (options: ManagerOptions) {
   const fs = yield* FileSystem.FileSystem;

package/src/sync.ts

@@ -267,7 +267,7 @@ const encodeOutputOwnershipIdentityJson = Schema.encodeSync(
 const encodePlanSnapshotJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
 const encodeAppliedStatePrettyJson = Schema.encodeSync(fromJsonString(AppliedStateSchema, 2));
 
-const SKILL_FAMILIES: SkillCatalog = {
+const SKILL_FAMILIES = {
   effect: [
     "effect-ts",
     "effect-architecture-audit",
@@ -275,7 +275,7 @@ const SKILL_FAMILIES: SkillCatalog = {
     "effect-atom-state",
     "build-effect-clis",
   ],
-};
+} satisfies SkillCatalog;
 
 export const DEFAULT_MANIFEST = "dev-kit.jsonc";
 const DEFAULT_LOCKFILE = "dev-kit.lock.json";
@@ -356,12 +356,12 @@ const inspectManagedInstructionSections = (content: string): ManagedInstructionI
     }
   }
 
+  if (ranges.length === 0) return { kind: "valid", ranges };
+
   return {
     kind: "valid",
     ranges,
-    ...(ranges.length === 0
-      ? {}
-      : { content: `${ranges.map((range) => range.content.trim()).join("\n\n")}\n` }),
+    content: `${ranges.map((range) => range.content.trim()).join("\n\n")}\n`,
   };
 };
 
@@ -460,6 +460,8 @@ const renderPackageScriptCommandPolicy = (
   const additionalCommands = Object.keys(scripts)
     .filter(
       (script) =>
+        // SAFETY: `script` is only asserted to the set's string-literal union for a
+        // runtime membership check; the assertion does not narrow any returned value.
         !knownScripts.has(script as (typeof entries)[number][0]) &&
         /^(?:check|validate|fmt|format|lint|test|type-?check)(?::|$)/.test(script),
     )
@@ -955,7 +957,7 @@ const buildDesiredOutputs = Effect.fn("buildDesiredSkillOutputs")(function* (
       const managed = yield* resolveManagedPath(projectDir, path.join(target.path, skill.name));
 
       if (target.mode === "copy") {
-        outputs.push({
+        const output: DesiredSkillOutput = {
           resourceId: `skill:${skill.selector}@${targetName}`,
           path: managed.relative,
           skill: skill.name,
@@ -963,10 +965,12 @@ const buildDesiredOutputs = Effect.fn("buildDesiredSkillOutputs")(function* (
           mode: "copy",
           kind: "directory",
           digest: sourceObservation.digest,
-          ...(resolvedSource.catalog ? { catalog: resolvedSource.catalog } : {}),
           source,
           destination: managed.absolute,
-        });
+        };
+
+        if (resolvedSource.catalog) Object.assign(output, { catalog: resolvedSource.catalog });
+        outputs.push(output);
         continue;
       }
       const linkSource =
@@ -977,7 +981,7 @@ const buildDesiredOutputs = Effect.fn("buildDesiredSkillOutputs")(function* (
       const linkTarget = path.relative(path.dirname(managed.absolute), linkSource);
       const linkDigest = yield* digestSymlinkTarget(linkTarget);
 
-      outputs.push({
+      const output: DesiredSkillOutput = {
         resourceId: `skill:${skill.selector}@${targetName}`,
         path: managed.relative,
         skill: skill.name,
@@ -985,11 +989,13 @@ const buildDesiredOutputs = Effect.fn("buildDesiredSkillOutputs")(function* (
         mode: "symlink",
         kind: "symlink",
         digest: linkDigest,
-        ...(resolvedSource.catalog ? { catalog: resolvedSource.catalog } : {}),
         source,
         destination: managed.absolute,
         linkTarget,
-      });
+      };
+
+      if (resolvedSource.catalog) Object.assign(output, { catalog: resolvedSource.catalog });
+      outputs.push(output);
     }
   }
   yield* validateInventory(projectDir, outputs, "desired outputs");
@@ -1175,14 +1181,15 @@ const planDesiredOutputs = Effect.fn("planDesiredSkillOutputs")(function* (
 
       if (managedDigest === receipt.digest || observed.digest === receipt.digest) {
         const remaining = removeManagedInstructionSections(existingContent, inspection.ranges);
-
-        actions.push({
+        const action: SkillPlanAction = {
           action: "remove",
           previous: receipt,
           destination: managed.absolute,
           observed,
-          ...(remaining.trim().length === 0 ? {} : { stagedContent: remaining }),
-        });
+        };
+
+        if (remaining.trim().length > 0) Object.assign(action, { stagedContent: remaining });
+        actions.push(action);
       } else {
         actions.push({
           action: "conflict",
@@ -1363,35 +1370,36 @@ export const planProjectSkills = Effect.fn("planProjectSkills")(function* (optio
     manifest.setup,
     manifest.targets,
   );
+  const nextSetup: NonNullable<DevKitLock["setup"]> = {};
+
+  if (effectSource !== undefined) {
+    Object.assign(nextSetup, {
+      effectSource: {
+        packageName: effectSource.packageName,
+        packageVersion: effectSource.packageVersion,
+        path: effectSource.path,
+        repository: effectSource.repository,
+        tag: effectSource.tag,
+      },
+    });
+  }
+  if (effectTsgo !== undefined) {
+    Object.assign(nextSetup, {
+      effectTsgo: {
+        effectTsgoVersion: effectTsgo.effectTsgoVersion,
+        typescriptPackage: effectTsgo.typescriptPackage,
+        typescriptVersion: effectTsgo.typescriptVersion,
+      },
+    });
+  }
   const nextLock: DevKitLock = {
     version: 1,
     toolVersion: DEV_KIT_VERSION,
     manifestDigest: yield* digestText(encodeManifestJson(manifest)),
-    setup: {
-      ...(effectSource === undefined
-        ? {}
-        : {
-            effectSource: {
-              packageName: effectSource.packageName,
-              packageVersion: effectSource.packageVersion,
-              path: effectSource.path,
-              repository: effectSource.repository,
-              tag: effectSource.tag,
-            },
-          }),
-      ...(effectTsgo === undefined
-        ? {}
-        : {
-            effectTsgo: {
-              effectTsgoVersion: effectTsgo.effectTsgoVersion,
-              typescriptPackage: effectTsgo.typescriptPackage,
-              typescriptVersion: effectTsgo.typescriptVersion,
-            },
-          }),
-    },
+    setup: nextSetup,
     outputs: desired.map((output): ManagedOutput => {
       if ("skill" in output) {
-        return {
+        const managedOutput: ManagedSkillOutput = {
           resourceId: output.resourceId,
           path: output.path,
           skill: output.skill,
@@ -1399,8 +1407,11 @@ export const planProjectSkills = Effect.fn("planProjectSkills")(function* (optio
           mode: output.mode,
           kind: output.kind,
           digest: output.digest,
-          ...(output.catalog ? { catalog: output.catalog } : {}),
         };
+
+        if (output.catalog) Object.assign(managedOutput, { catalog: output.catalog });
+
+        return managedOutput;
       }
       if (output.resourceId === "setup:agent-instructions") {
         return {
@@ -1488,16 +1499,11 @@ export const planProjectSkills = Effect.fn("planProjectSkills")(function* (optio
     });
   }
 
-  return {
+  const plan: SkillPlan = {
     projectDir,
     lockfilePath: lockManaged.absolute,
     statePath: stateManaged.absolute,
     actions: planned.actions,
-    ...(effectSource === undefined ? {} : { effectSource }),
-    ...(effectTsgo === undefined ? {} : { effectTsgo }),
-    ...(vitePlusHooks === undefined ? {} : { vitePlusHooks }),
-    ...(vitePlusWorkflow === undefined ? {} : { vitePlusWorkflow }),
-    ...(worktrunkConfig === undefined ? {} : { worktrunkConfig }),
     nextLock,
     nextState: planned.nextState,
     metadataChanged:
@@ -1505,7 +1511,15 @@ export const planProjectSkills = Effect.fn("planProjectSkills")(function* (optio
       encodeDevKitLockJson(currentLock) !== encodeDevKitLockJson(nextLock) ||
       currentState === undefined ||
       encodeAppliedStateJson(currentState) !== encodeAppliedStateJson(planned.nextState),
-  } satisfies SkillPlan;
+  };
+
+  if (effectSource !== undefined) Object.assign(plan, { effectSource });
+  if (effectTsgo !== undefined) Object.assign(plan, { effectTsgo });
+  if (vitePlusHooks !== undefined) Object.assign(plan, { vitePlusHooks });
+  if (vitePlusWorkflow !== undefined) Object.assign(plan, { vitePlusWorkflow });
+  if (worktrunkConfig !== undefined) Object.assign(plan, { worktrunkConfig });
+
+  return plan;
 });
 
 const formatAction = (action: SkillPlanAction): string => {
@@ -1761,13 +1775,15 @@ const applyPlannedSkillChanges = Effect.fn("applyPlannedSkillChanges")(function*
         }`,
       });
     }
-    replacements.push({
+    const replacement: Replacement = {
       destination: action.action === "remove" ? action.destination : action.desired.destination,
       backup: path.join(backupDir, String(replacementIndex++)),
       expected: action.observed,
       path: action.action === "remove" ? action.previous.path : action.desired.path,
-      ...(staged === undefined ? {} : { staged }),
-    });
+    };
+
+    if (staged !== undefined) Object.assign(replacement, { staged });
+    replacements.push(replacement);
   }
   replacements.push(
     {

package/src/vendor.ts

@@ -158,11 +158,13 @@ const normalizeRepositoryLocator = (
     const normalized = `https://github.com/${owner}/${name}.git`;
 
     if (segments[2] === "tree" && segments[3]) {
-      return Effect.succeed({
-        repository: normalized,
-        ref: segments[3],
-        ...(segments.length > 4 ? { skillsPath: segments.slice(4).join("/") } : {}),
-      });
+      const locator = { repository: normalized, ref: segments[3] };
+
+      if (segments.length > 4) {
+        Object.assign(locator, { skillsPath: segments.slice(4).join("/") });
+      }
+
+      return Effect.succeed(locator);
     }
 
     return Effect.succeed({ repository: normalized });
@@ -493,13 +495,16 @@ const prepareSource = Effect.fn("prepareSkillSource")(function* (
     }
   }
 
-  return {
+  const prepared = {
     checkoutDir,
     resolved,
     skills,
     source,
-    ...(licenseSource ? { licenseSource } : {}),
-  } satisfies PreparedSource;
+  };
+
+  if (licenseSource) Object.assign(prepared, { licenseSource });
+
+  return prepared satisfies PreparedSource;
 });
 
 const readCurrentLock = Effect.fn("readCurrentSkillSourcesLock")(function* (lockfilePath: string) {
@@ -713,20 +718,31 @@ const buildLock = Effect.fn("buildSkillCatalogLock")(function* (
       }
       digests[skill] = observation.digest;
     }
-    sources.push({
+    const lockedSource = {
       id: source.id,
       repository: source.repository,
       ref: source.ref,
       resolved,
       skillsPath: source.skillsPath,
       include: source.include,
-      ...(source.exclude ? { exclude: source.exclude } : {}),
+    };
+
+    if (source.exclude) Object.assign(lockedSource, { exclude: source.exclude });
+
+    const completeLockedSource = Object.assign(lockedSource, {
       skills,
       descriptions,
       digests,
-      ...(source.licensePath ? { licensePath: source.licensePath } : {}),
-      ...(source.stripFrontmatter ? { stripFrontmatter: source.stripFrontmatter } : {}),
-    });
+    }) satisfies LockedSkillSource;
+
+    if (source.licensePath) {
+      Object.assign(completeLockedSource, { licensePath: source.licensePath });
+    }
+    if (source.stripFrontmatter) {
+      Object.assign(completeLockedSource, { stripFrontmatter: source.stripFrontmatter });
+    }
+
+    sources.push(completeLockedSource);
   }
 
   return { version: 1, sources } satisfies SkillSourcesLock;
@@ -807,15 +823,18 @@ export const inspectCatalogRepository = Effect.fn("inspectCatalogRepository")(fu
     }
   }
 
-  return {
+  const inspection: CatalogInspection = {
     id,
     repository,
     ref,
     resolved: prepared.resolved,
     skillsPath: source.skillsPath,
     skills,
-    ...(licensePath ? { licensePath } : {}),
-  } satisfies CatalogInspection;
+  };
+
+  if (licensePath) Object.assign(inspection, { licensePath });
+
+  return inspection;
 });
 
 export const refreshSkillCatalog = Effect.fn("refreshSkillCatalog")(function* (