@danieljvdm/dev-kit 0.11.3 → 0.13.0

package/src/index.ts

@@ -11,20 +11,14 @@ export {
   EffectTsgoSetupSchema,
   type HarnessTarget,
   TargetConfigSchema,
-  type VitePlusQualityConfigSetup,
-  VitePlusQualityConfigSetupSchema,
   type VitePlusQualitySetup,
   VitePlusQualitySetupSchema,
-  type VitePlusQualityTypecheckSetup,
-  VitePlusQualityTypecheckSetupSchema,
   type VitePlusQualityWorkflowSetup,
   VitePlusQualityWorkflowSetupSchema,
   type VitePlusQualityWorkflowStep,
   VitePlusQualityWorkflowStepSchema,
   type VitePlusSetup,
   VitePlusSetupSchema,
-  type VitePlusTypecheckStrategy,
-  VitePlusTypecheckStrategySchema,
 } from "./manifest.ts";
 export {
   applyEffectSourcePlan,
@@ -49,13 +43,16 @@ export {
   EFFECT_TSGO_PLUGIN_NAME,
   EFFECT_TSGO_TYPESCRIPT_VERSION,
   EFFECT_TSGO_VERSION,
+  type EffectTsgoDiagnosticSeverity,
   EffectTsgoDependencyError,
   InvalidEffectTsgoPackageNameError,
   type EffectTsgoPatchOptions,
   type EffectTsgoPatchPlan,
+  type EffectTsgoPluginConfig,
   EffectTsgoPatchCommandError,
   patchEffectTsgo,
   planEffectTsgoPatch,
+  recommendedEffectTsgoPlugin,
 } from "./effect-tsgo.ts";
 export {
   ExternalSkillSourceSchema,

package/src/manifest.ts

@@ -53,22 +53,6 @@ export const VitePlusHooksSetupSchema = Schema.Struct({
   enabled: Schema.optional(Schema.Boolean),
 });
 
-export const VitePlusTypecheckStrategySchema = Schema.Literals(["single-project", "workspace"]);
-export type VitePlusTypecheckStrategy = typeof VitePlusTypecheckStrategySchema.Type;
-
-export const VitePlusQualityTypecheckSetupSchema = Schema.Struct({
-  strategy: Schema.optional(VitePlusTypecheckStrategySchema),
-  concurrency: Schema.optional(Schema.Int),
-  packages: Schema.optional(Schema.Array(Schema.String)),
-});
-export type VitePlusQualityTypecheckSetup = typeof VitePlusQualityTypecheckSetupSchema.Type;
-
-export const VitePlusQualityConfigSetupSchema = Schema.Struct({
-  enabled: Schema.optional(Schema.Boolean),
-  typecheck: Schema.optional(VitePlusQualityTypecheckSetupSchema),
-});
-export type VitePlusQualityConfigSetup = typeof VitePlusQualityConfigSetupSchema.Type;
-
 export const VitePlusQualityWorkflowStepSchema = Schema.Struct({
   name: Schema.String,
   run: Schema.Array(Schema.String),
@@ -83,7 +67,6 @@ export const VitePlusQualityWorkflowSetupSchema = Schema.Struct({
 export type VitePlusQualityWorkflowSetup = typeof VitePlusQualityWorkflowSetupSchema.Type;
 
 export const VitePlusQualitySetupSchema = Schema.Struct({
-  config: Schema.optional(VitePlusQualityConfigSetupSchema),
   workflow: Schema.optional(VitePlusQualityWorkflowSetupSchema),
 });
 export type VitePlusQualitySetup = typeof VitePlusQualitySetupSchema.Type;
@@ -153,14 +136,6 @@ export type NormalizedManifest = {
         readonly enabled: boolean;
       };
       readonly quality: {
-        readonly config: {
-          readonly enabled: boolean;
-          readonly typecheck: {
-            readonly strategy: VitePlusTypecheckStrategy;
-            readonly concurrency: number;
-            readonly packages: ReadonlyArray<string>;
-          };
-        };
         readonly workflow: {
           readonly enabled: boolean;
           readonly beforeChecks: ReadonlyArray<VitePlusQualityWorkflowStep>;
@@ -201,7 +176,6 @@ export const normalizeManifest = (manifest: DevKitManifest): NormalizedManifest
     }
   }
   const quality = manifest.setup?.vitePlus?.quality;
-  const typecheck = quality?.config?.typecheck;
 
   return {
     exclude: manifest.exclude ?? [],
@@ -230,14 +204,6 @@ export const normalizeManifest = (manifest: DevKitManifest): NormalizedManifest
           enabled: manifest.setup?.vitePlus?.hooks?.enabled ?? false,
         },
         quality: {
-          config: {
-            enabled: quality?.config?.enabled ?? false,
-            typecheck: {
-              strategy: typecheck?.strategy ?? "single-project",
-              concurrency: typecheck?.concurrency ?? 4,
-              packages: typecheck?.packages ?? [],
-            },
-          },
           workflow: {
             enabled: quality?.workflow?.enabled ?? false,
             beforeChecks: quality?.workflow?.beforeChecks ?? [],

package/src/node-symbolic-link.ts

@@ -4,8 +4,8 @@ export type SymbolicLinkObservation =
   | { readonly kind: "missing" | "not-symlink" }
   | { readonly kind: "symlink"; readonly target: string };
 
-// Effect beta.102's Node FileSystem adapter maps readlink(2) EINVAL to Unknown.
-// Keep that runtime-specific normalization at this narrow adapter boundary.
+// Effect's Node FileSystem adapter maps readlink(2) EINVAL to Unknown. Keep
+// that runtime-specific normalization at this narrow adapter boundary.
 const isNotSymbolicLink = (error: PlatformError.PlatformError): boolean => {
   if (error.reason._tag !== "Unknown") return false;
   const cause = error.reason.cause;

package/src/oxfmt.js

@@ -4,9 +4,14 @@
  * This file is intentionally plain JavaScript because Node does not strip
  * TypeScript from packages in node_modules when tools load their config.
  */
+import { devKitToolIgnorePatterns } from "./tool-ignore-patterns.js";
+
+export { devKitToolIgnorePatterns } from "./tool-ignore-patterns.js";
+
 export const recommendedOxfmtConfig = {
   arrowParens: "always",
   endOfLine: "lf",
+  ignorePatterns: [...devKitToolIgnorePatterns],
   printWidth: 100,
   semi: true,
   singleQuote: false,

package/src/oxfmt.ts

@@ -1,5 +1,9 @@
 import type { OxfmtConfig } from "oxfmt";
 
+import { devKitToolIgnorePatterns } from "./tool-ignore-patterns.ts";
+
+export { devKitToolIgnorePatterns } from "./tool-ignore-patterns.ts";
+
 /**
  * Canonical formatting defaults for standalone Oxfmt and Vite+ projects.
  *
@@ -9,6 +13,7 @@ import type { OxfmtConfig } from "oxfmt";
 export const recommendedOxfmtConfig = {
   arrowParens: "always",
   endOfLine: "lf",
+  ignorePatterns: [...devKitToolIgnorePatterns],
   printWidth: 100,
   semi: true,
   singleQuote: false,

package/src/oxlint.js

@@ -4,7 +4,12 @@
  * This file is intentionally plain JavaScript because Node does not strip
  * TypeScript from packages in node_modules when Vite+ loads vite.config.ts.
  */
+import { devKitToolIgnorePatterns } from "./tool-ignore-patterns.js";
+
+export { devKitToolIgnorePatterns } from "./tool-ignore-patterns.js";
+
 export const recommendedOxlintConfig = {
+  ignorePatterns: [...devKitToolIgnorePatterns],
   options: {
     typeAware: true,
   },

package/src/oxlint.ts

@@ -1,5 +1,9 @@
 import type { OxlintConfig } from "oxlint";
 
+import { devKitToolIgnorePatterns } from "./tool-ignore-patterns.ts";
+
+export { devKitToolIgnorePatterns } from "./tool-ignore-patterns.ts";
+
 /**
  * High-signal Oxlint defaults for TypeScript projects.
  *
@@ -8,6 +12,7 @@ import type { OxlintConfig } from "oxlint";
  * without losing nested configuration.
  */
 export const recommendedOxlintConfig = {
+  ignorePatterns: [...devKitToolIgnorePatterns],
   options: {
     typeAware: true,
   },

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"),