@danieljvdm/dev-kit 0.6.0 → 0.7.1

package/src/effect-source.ts

@@ -1,9 +1,9 @@
 import { Config, Effect, FileSystem, Path, Schema, Stream } from "effect";
 import { ChildProcess } from "effect/unstable/process";
 
-import { acquireProjectProcessLock } from "./project-process-lock.ts";
 import { printStatus, withSpinner } from "./cli-ui.ts";
 import { observeSymbolicLink } from "./node-symbolic-link.ts";
+import { acquireProjectProcessLock } from "./project-process-lock.ts";
 import { isTypeScriptPackageName } from "./typescript-package-name.ts";
 
 export const DEFAULT_EFFECT_REPOSITORY = "https://github.com/Effect-TS/effect.git";
@@ -55,9 +55,7 @@ class EffectSourceCommandError extends Schema.TaggedErrorClass<EffectSourceComma
 
 const PackageVersionSchema = Schema.fromJsonString(
   Schema.Struct({
-    version: Schema.String.check(
-      Schema.isPattern(/^[0-9A-Za-z][0-9A-Za-z.+-]*$/),
-    ),
+    version: Schema.String.check(Schema.isPattern(/^[0-9A-Za-z][0-9A-Za-z.+-]*$/)),
   }),
 );
 
@@ -76,6 +74,7 @@ const runCommand = Effect.fn("runEffectSourceCommand")(function* (
     child.exitCode,
   ]);
   const trimmed = output.trim();
+
   if (exitCode !== 0) {
     return yield* new EffectSourceCommandError({
       command: [command, ...args].join(" "),
@@ -83,11 +82,11 @@ const runCommand = Effect.fn("runEffectSourceCommand")(function* (
       output: trimmed,
     });
   }
+
   return trimmed;
 });
 
-const runGit = (cwd: string, args: ReadonlyArray<string>) =>
-  runCommand(cwd, "git", args);
+const runGit = (cwd: string, args: ReadonlyArray<string>) => runCommand(cwd, "git", args);
 
 const readPackageVersion = Effect.fn("readEffectSourcePackageVersion")(function* (
   projectDir: string,
@@ -101,11 +100,14 @@ const readPackageVersion = Effect.fn("readEffectSourcePackageVersion")(function*
     ...packageName.split("/"),
     "package.json",
   );
-  const contents = yield* fs.readFileString(manifestPath).pipe(
-    Effect.catchReason("PlatformError", "NotFound", () =>
-      Effect.fail(new EffectSourceDependencyError({ packageName })),
-    ),
-  );
+  const contents = yield* fs
+    .readFileString(manifestPath)
+    .pipe(
+      Effect.catchReason("PlatformError", "NotFound", () =>
+        Effect.fail(new EffectSourceDependencyError({ packageName })),
+      ),
+    );
+
   return yield* Schema.decodeUnknownEffect(PackageVersionSchema)(contents).pipe(
     Effect.mapError(() => new EffectSourceDependencyError({ packageName })),
     Effect.map((manifest) => manifest.version),
@@ -117,6 +119,7 @@ const resolveCheckoutPath = Effect.fn("resolveEffectSourceCheckoutPath")(functio
   candidate: string,
 ) {
   const path = yield* Path.Path;
+
   if (candidate.length === 0 || path.isAbsolute(candidate)) {
     return yield* new EffectSourceCheckoutError({
       message: `Effect source path must be a non-empty project-relative path: ${candidate}`,
@@ -124,6 +127,7 @@ const resolveCheckoutPath = Effect.fn("resolveEffectSourceCheckoutPath")(functio
   }
   const checkoutDir = path.resolve(projectDir, candidate);
   const relative = path.relative(projectDir, checkoutDir);
+
   if (
     relative.length === 0 ||
     relative === ".." ||
@@ -135,6 +139,7 @@ const resolveCheckoutPath = Effect.fn("resolveEffectSourceCheckoutPath")(functio
     });
   }
   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") {
@@ -143,6 +148,7 @@ const resolveCheckoutPath = Effect.fn("resolveEffectSourceCheckoutPath")(functio
       });
     }
   }
+
   return {
     checkoutDir,
     path: path.sep === "/" ? relative : relative.split(path.sep).join("/"),
@@ -155,6 +161,7 @@ const inspectExistingCheckout = Effect.fn("inspectExistingEffectSource")(functio
   tag: string,
 ) {
   const fs = yield* FileSystem.FileSystem;
+
   if ((yield* observeSymbolicLink(checkoutDir)).kind === "symlink") {
     return yield* new EffectSourceCheckoutError({
       message: `Effect source destination is a symlink: ${checkoutDir}`,
@@ -163,19 +170,22 @@ const inspectExistingCheckout = Effect.fn("inspectExistingEffectSource")(functio
   if (!(yield* fs.exists(checkoutDir))) return "sync" as const;
 
   const actualRoot = yield* runGit(checkoutDir, ["rev-parse", "--show-toplevel"]).pipe(
-    Effect.mapError(() =>
-      new EffectSourceCheckoutError({
-        message: `Effect source destination exists but is not a Git checkout: ${checkoutDir}`,
-      }),
+    Effect.mapError(
+      () =>
+        new EffectSourceCheckoutError({
+          message: `Effect source destination exists but is not a Git checkout: ${checkoutDir}`,
+        }),
     ),
   );
   const expectedRoot = yield* fs.realPath(checkoutDir);
+
   if ((yield* fs.realPath(actualRoot)) !== expectedRoot) {
     return yield* new EffectSourceCheckoutError({
       message: `Effect source destination is nested inside another Git checkout: ${checkoutDir}`,
     });
   }
   const remote = yield* runGit(checkoutDir, ["remote", "get-url", "origin"]);
+
   if (remote !== repository) {
     return yield* new EffectSourceCheckoutError({
       message: `Effect source origin is ${remote}; expected ${repository}`,
@@ -188,17 +198,21 @@ const inspectExistingCheckout = Effect.fn("inspectExistingEffectSource")(functio
     "--verify",
     `${tag}^{commit}`,
   ]).pipe(Effect.catchTag("EffectSourceCommandError", () => Effect.void));
+
   if (target !== undefined) {
     const current = yield* runGit(checkoutDir, ["rev-parse", "HEAD"]);
+
     if (current === target) return "unchanged" as const;
   }
 
   const dirty = yield* runGit(checkoutDir, ["status", "--porcelain", "--untracked-files=all"]);
+
   if (dirty.length > 0) {
     return yield* new EffectSourceCheckoutError({
       message: `Effect source checkout has local changes; refusing to switch ${checkoutDir} to ${tag}`,
     });
   }
+
   return "sync" as const;
 });
 
@@ -209,14 +223,18 @@ export const planEffectSource = Effect.fn("planEffectSource")(function* (
   const path = yield* Path.Path;
   const projectDir = yield* fs.realPath(path.resolve(options.projectDir ?? "."));
   const packageName = options.packageName ?? "effect";
+
   if (!isTypeScriptPackageName(packageName)) {
     return yield* new EffectSourceCheckoutError({
       message: `invalid Effect source package name: ${packageName}`,
     });
   }
   const repository = options.repository ?? DEFAULT_EFFECT_REPOSITORY;
+
   if (repository.length === 0) {
-    return yield* new EffectSourceCheckoutError({ message: "Effect source repository cannot be empty" });
+    return yield* new EffectSourceCheckoutError({
+      message: "Effect source repository cannot be empty",
+    });
   }
   const resolved = yield* resolveCheckoutPath(
     projectDir,
@@ -225,9 +243,11 @@ export const planEffectSource = Effect.fn("planEffectSource")(function* (
   const packageVersion = yield* readPackageVersion(projectDir, packageName);
   const tag = `effect@${packageVersion}`;
   const ci = yield* Config.string("CI").pipe(Config.withDefault(""));
-  const action = ci === "true" || ci === "1"
-    ? "skipped" as const
-    : yield* inspectExistingCheckout(resolved.checkoutDir, repository, tag);
+  const action =
+    ci === "true" || ci === "1"
+      ? ("skipped" as const)
+      : yield* inspectExistingCheckout(resolved.checkoutDir, repository, tag);
+
   return {
     action,
     checkoutDir: resolved.checkoutDir,
@@ -246,14 +266,17 @@ export const applyEffectSourcePlan = Effect.fn("applyEffectSourcePlan")(function
   if (plan.action !== "sync") return;
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
+
   if (!(yield* fs.exists(plan.checkoutDir))) {
     const parent = path.dirname(plan.checkoutDir);
+
     yield* fs.makeDirectory(parent, { recursive: true });
     const tempDir = yield* fs.makeTempDirectoryScoped({
       directory: parent,
       prefix: ".dev-kit-effect-source-",
     });
     const staged = path.join(tempDir, "checkout");
+
     yield* runGit(plan.projectDir, [
       "clone",
       "--depth",
@@ -271,6 +294,7 @@ export const applyEffectSourcePlan = Effect.fn("applyEffectSourcePlan")(function
       });
     }
     yield* fs.rename(staged, plan.checkoutDir);
+
     return;
   }
 
@@ -289,6 +313,7 @@ export const applyEffectSourcePlan = Effect.fn("applyEffectSourcePlan")(function
     "--verify",
     `${plan.tag}^{commit}`,
   ]);
+
   yield* runGit(plan.checkoutDir, ["checkout", "--detach", target]);
 });
 
@@ -297,8 +322,10 @@ export const syncEffectSource = Effect.fn("syncEffectSource")(function* (
 ) {
   const plan = yield* planEffectSource(options);
   const detail = `${plan.tag} → ${plan.path}`;
+
   if (plan.action === "skipped") {
     yield* printStatus("plan", "Effect source skipped", "CI");
+
     return;
   }
   if (options.dryRun) {
@@ -307,14 +334,17 @@ export const syncEffectSource = Effect.fn("syncEffectSource")(function* (
       plan.action === "sync" ? "Would sync Effect source" : "Effect source up to date",
       detail,
     );
+
     return;
   }
   if (plan.action === "unchanged") {
     yield* printStatus("success", "Effect source up to date", detail);
+
     return;
   }
   yield* acquireProjectProcessLock(plan.projectDir);
   const replanned = yield* planEffectSource(options);
+
   if (JSON.stringify(plan) !== JSON.stringify(replanned)) {
     return yield* new EffectSourceCheckoutError({
       message: "Effect source checkout changed after planning; rerun the command",

package/src/effect-tsgo.ts

@@ -1,8 +1,8 @@
 import { Crypto, Effect, Encoding, FileSystem, Path, Schema, Stream } from "effect";
 import { ChildProcess } from "effect/unstable/process";
 
-import { acquireProjectProcessLock } from "./project-process-lock.ts";
 import { printStatus, withSpinner } from "./cli-ui.ts";
+import { acquireProjectProcessLock } from "./project-process-lock.ts";
 import { isTypeScriptPackageName } from "./typescript-package-name.ts";
 
 export const EFFECT_TSGO_VERSION = "0.24.3";
@@ -65,9 +65,7 @@ export class InvalidEffectTsgoPackageNameError extends Schema.TaggedErrorClass<I
   }
 }
 
-const PackageVersionSchema = Schema.fromJsonString(
-  Schema.Struct({ version: Schema.String }),
-);
+const PackageVersionSchema = Schema.fromJsonString(Schema.Struct({ version: Schema.String }));
 
 const packagePath = (path: Path.Path, projectDir: string, packageName: string): string =>
   path.join(projectDir, "node_modules", ...packageName.split("/"), "package.json");
@@ -80,18 +78,17 @@ const readExactPackageVersion = Effect.fn("readExactEffectTsgoPackageVersion")(f
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const manifestPath = packagePath(path, projectDir, packageName);
-  const contents = yield* fs.readFileString(manifestPath).pipe(
-    Effect.catchReason(
-      "PlatformError",
-      "NotFound",
-      () => Effect.fail(new EffectTsgoDependencyError({ packageName, expectedVersion })),
-    ),
-  );
+  const contents = yield* fs
+    .readFileString(manifestPath)
+    .pipe(
+      Effect.catchReason("PlatformError", "NotFound", () =>
+        Effect.fail(new EffectTsgoDependencyError({ packageName, expectedVersion })),
+      ),
+    );
   const manifest = yield* Schema.decodeUnknownEffect(PackageVersionSchema)(contents).pipe(
-    Effect.mapError(() =>
-      new EffectTsgoDependencyError({ packageName, expectedVersion }),
-    ),
+    Effect.mapError(() => new EffectTsgoDependencyError({ packageName, expectedVersion })),
   );
+
   if (manifest.version !== expectedVersion) {
     return yield* new EffectTsgoDependencyError({
       packageName,
@@ -99,6 +96,7 @@ const readExactPackageVersion = Effect.fn("readExactEffectTsgoPackageVersion")(f
       actualVersion: manifest.version,
     });
   }
+
   return manifest.version;
 });
 
@@ -108,53 +106,80 @@ const resolveEffectTsgoExecutable = Effect.fn("resolveEffectTsgoExecutable")(fun
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const binDir = path.join(projectDir, "node_modules", ".bin");
-  const candidates = path.sep === "\\"
-    ? [path.join(binDir, "effect-tsgo.cmd"), path.join(binDir, "effect-tsgo")]
-    : [path.join(binDir, "effect-tsgo"), path.join(binDir, "effect-tsgo.cmd")];
+  const candidates =
+    path.sep === "\\"
+      ? [path.join(binDir, "effect-tsgo.cmd"), path.join(binDir, "effect-tsgo")]
+      : [path.join(binDir, "effect-tsgo"), path.join(binDir, "effect-tsgo.cmd")];
+
   for (const candidate of candidates) {
     if (yield* fs.exists(candidate)) return candidate;
   }
+
   return yield* new EffectTsgoDependencyError({
     packageName: "@effect/tsgo",
     expectedVersion: EFFECT_TSGO_VERSION,
   });
 });
 
-const digestFileContents = Effect.fn("digestEffectTsgoFileContents")(function* (
-  filePath: string,
-) {
+const digestFileContents = Effect.fn("digestEffectTsgoFileContents")(function* (filePath: string) {
   const crypto = yield* Crypto.Crypto;
   const fs = yield* FileSystem.FileSystem;
+
   return Encoding.encodeHex(yield* crypto.digest("SHA-256", yield* fs.readFile(filePath)));
 });
 
+const findNodeModulesRoot = (path: Path.Path, packageJsonPath: string): string | undefined => {
+  let current = path.dirname(packageJsonPath);
+
+  while (true) {
+    if (path.basename(current) === "node_modules") return current;
+    const parent = path.dirname(current);
+
+    if (parent === current) return undefined;
+    current = parent;
+  }
+};
+
 const isEffectTsgoPatched = Effect.fn("isEffectTsgoPatched")(function* (
   projectDir: string,
+  typescriptPackage: string,
 ) {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
-  const scopeDir = path.join(projectDir, "node_modules", "@typescript");
-  if (!(yield* fs.exists(scopeDir))) return false;
-  const entries = yield* fs.readDirectory(scopeDir);
+  const typescriptPackageJson = yield* fs.realPath(
+    packagePath(path, projectDir, typescriptPackage),
+  );
+  const effectTsgoPackageJson = yield* fs.realPath(packagePath(path, projectDir, "@effect/tsgo"));
+  const typescriptNodeModules = findNodeModulesRoot(path, typescriptPackageJson);
+  const effectNodeModules = findNodeModulesRoot(path, effectTsgoPackageJson);
+
+  if (typescriptNodeModules === undefined || effectNodeModules === undefined) return false;
+
+  const typescriptScope = path.join(typescriptNodeModules, "@typescript");
+  const effectScope = path.join(effectNodeModules, "@effect");
+
+  if (!(yield* fs.exists(typescriptScope)) || !(yield* fs.exists(effectScope))) return false;
+
   const executableName = path.sep === "\\" ? "tsc.exe" : "tsc";
-  const effectExecutableNames = path.sep === "\\"
-    ? ["tsc.exe", "tsc-next.exe"]
-    : ["tsc", "tsc-next"];
-  for (const entry of entries) {
+  const effectExecutableNames =
+    path.sep === "\\" ? ["tsc.exe", "tsc-next.exe"] : ["tsc", "tsc-next"];
+
+  for (const entry of yield* fs.readDirectory(typescriptScope)) {
     if (!entry.startsWith("typescript-")) continue;
     const platform = entry.slice("typescript-".length);
-    const installedPath = path.join(scopeDir, entry, "lib", executableName);
+    const installedPath = path.join(typescriptScope, entry, "lib", executableName);
+
     if (!(yield* fs.exists(installedPath))) continue;
     const installedDigest = yield* digestFileContents(installedPath);
+
     for (const effectExecutableName of effectExecutableNames) {
       const effectBinaryPath = path.join(
-        projectDir,
-        "node_modules",
-        "@effect",
+        effectScope,
         `tsgo-${platform}`,
         "lib",
         effectExecutableName,
       );
+
       if (
         (yield* fs.exists(effectBinaryPath)) &&
         installedDigest === (yield* digestFileContents(effectBinaryPath))
@@ -163,6 +188,7 @@ const isEffectTsgoPatched = Effect.fn("isEffectTsgoPatched")(function* (
       }
     }
   }
+
   return false;
 });
 
@@ -173,6 +199,7 @@ export const planEffectTsgoPatch = Effect.fn("planEffectTsgoPatch")(function* (
   const path = yield* Path.Path;
   const projectDir = yield* fs.realPath(path.resolve(options.projectDir ?? "."));
   const typescriptPackage = options.typescriptPackage ?? "typescript";
+
   if (!isTypeScriptPackageName(typescriptPackage)) {
     return yield* new InvalidEffectTsgoPackageNameError({ packageName: typescriptPackage });
   }
@@ -187,16 +214,15 @@ export const planEffectTsgoPatch = Effect.fn("planEffectTsgoPatch")(function* (
     EFFECT_TSGO_TYPESCRIPT_VERSION,
   );
   const executable = yield* resolveEffectTsgoExecutable(projectDir);
+
   return {
-    alreadyPatched: yield* isEffectTsgoPatched(projectDir),
+    alreadyPatched: yield* isEffectTsgoPatched(projectDir, typescriptPackage),
     projectDir,
     executable,
     args: [
       "patch",
       ...(options.force ? ["--force"] : []),
-      ...(typescriptPackage === "typescript"
-        ? []
-        : ["--typescript-package", typescriptPackage]),
+      ...(typescriptPackage === "typescript" ? [] : ["--typescript-package", typescriptPackage]),
     ],
     effectTsgoVersion,
     typescriptPackage,
@@ -218,6 +244,7 @@ export const applyEffectTsgoPatchPlan = Effect.fn("applyEffectTsgoPatchPlan")(fu
     child.exitCode,
   ]);
   const trimmed = output.trim();
+
   if (exitCode !== 0) {
     return yield* new EffectTsgoPatchCommandError({
       command: [plan.executable, ...plan.args].join(" "),
@@ -232,12 +259,14 @@ export const patchEffectTsgo = Effect.fn("patchEffectTsgo")(function* (
 ) {
   const plan = yield* planEffectTsgoPatch(options);
   const detail = `@effect/tsgo@${plan.effectTsgoVersion} → ${plan.typescriptPackage}@${plan.typescriptVersion}`;
+
   if (options.dryRun) {
     yield* printStatus(
       plan.alreadyPatched ? "success" : "plan",
       plan.alreadyPatched ? "TypeScript patch up to date" : "Would patch TypeScript",
       detail,
     );
+
     return plan;
   }
 
@@ -246,10 +275,12 @@ export const patchEffectTsgo = Effect.fn("patchEffectTsgo")(function* (
       yield* acquireProjectProcessLock(plan.projectDir);
       if (plan.alreadyPatched) {
         yield* printStatus("success", "TypeScript patch up to date", detail);
+
         return plan;
       }
       yield* withSpinner("Patching TypeScript", applyEffectTsgoPatchPlan(plan));
       yield* printStatus("success", "TypeScript patched", detail);
+
       return plan;
     }),
   );

package/src/gitignore.ts

@@ -61,17 +61,20 @@ export const patchGitignoreContents = (
 ): { readonly contents: string; readonly added: ReadonlyArray<string> } => {
   const lines = current.split(/\r?\n/);
   const added = DEV_KIT_GITIGNORE_ENTRIES.filter((entry) => !lines.includes(entry));
+
   if (added.length === 0) return { contents: current, added };
 
   const newline = current.includes("\r\n") ? "\r\n" : "\n";
-  const separator = current.length === 0
-    ? ""
-    : current.endsWith(`${newline}${newline}`)
+  const separator =
+    current.length === 0
       ? ""
-      : current.endsWith(newline)
-        ? newline
-        : `${newline}${newline}`;
+      : current.endsWith(`${newline}${newline}`)
+        ? ""
+        : current.endsWith(newline)
+          ? newline
+          : `${newline}${newline}`;
   const block = ["# dev-kit managed paths", ...added].join(newline);
+
   return {
     contents: `${current}${separator}${block}${newline}`,
     added,
@@ -89,6 +92,7 @@ const planGitignorePatch = Effect.fn("planGitignorePatch")(function* (
   const path = yield* Path.Path;
   const gitignorePath = path.join(projectDir, ".gitignore");
   const observation = yield* observeSymbolicLink(gitignorePath);
+
   if (observation.kind === "symlink") {
     return yield* new UnsafeGitignorePathError({
       path: gitignorePath,
@@ -98,8 +102,10 @@ const planGitignorePatch = Effect.fn("planGitignorePatch")(function* (
 
   let current = "";
   let mode: number | undefined;
+
   if (observation.kind !== "missing") {
     const info = yield* fs.stat(gitignorePath);
+
     if (info.type !== "File") {
       return yield* new UnsafeGitignorePathError({
         path: gitignorePath,
@@ -111,6 +117,7 @@ const planGitignorePatch = Effect.fn("planGitignorePatch")(function* (
   }
 
   const patch = patchGitignoreContents(current);
+
   return {
     path: gitignorePath,
     changed: patch.added.length > 0,
@@ -135,6 +142,7 @@ const applyGitignorePatch = Effect.fn("applyGitignorePatch")(function* (
   });
   const staged = path.join(tempDir, "next.gitignore");
   const backup = path.join(tempDir, "previous.gitignore");
+
   yield* fs.writeFileString(staged, patch.contents, { mode: patch.mode ?? 0o666 });
 
   const currentObservation = yield* observeSymbolicLink(patch.path);
@@ -142,6 +150,7 @@ const applyGitignorePatch = Effect.fn("applyGitignorePatch")(function* (
     ? currentObservation.kind !== "not-symlink" ||
       (yield* fs.readFileString(patch.path)) !== patch.previousContents
     : currentObservation.kind !== "missing";
+
   if (changed) {
     return yield* new GitignoreConflictError({ path: patch.path });
   }
@@ -188,11 +197,13 @@ export const patchProjectGitignore = Effect.fn("patchProjectGitignore")(function
 
   if (options.dryRun) {
     const patch = yield* planGitignorePatch(projectDir);
+
     yield* printStatus(
       patch.changed ? "plan" : "success",
       patch.changed ? "Would update .gitignore" : ".gitignore up to date",
       patch.changed ? `add ${patch.added.join(", ")}` : undefined,
     );
+
     return publicPatch(patch);
   }
 
@@ -200,12 +211,14 @@ export const patchProjectGitignore = Effect.fn("patchProjectGitignore")(function
     Effect.gen(function* () {
       yield* acquireProjectProcessLock(projectDir);
       const patch = yield* planGitignorePatch(projectDir);
+
       yield* applyGitignorePatch(projectDir, patch);
       yield* printStatus(
         "success",
         patch.changed ? "Updated .gitignore" : ".gitignore up to date",
         patch.changed ? `added ${patch.added.join(", ")}` : undefined,
       );
+
       return publicPatch(patch);
     }),
   );

package/src/index.ts

@@ -11,6 +11,10 @@ export {
   EffectTsgoSetupSchema,
   type HarnessTarget,
   TargetConfigSchema,
+  type VitePlusQualitySetup,
+  VitePlusQualitySetupSchema,
+  type VitePlusSetup,
+  VitePlusSetupSchema,
 } from "./manifest.ts";
 export {
   applyEffectSourcePlan,
@@ -68,6 +72,7 @@ export {
   EffectTsgoLockSchema,
   ManagedAgentInstructionsOutputSchema,
   ManagedClaudeInstructionsOutputSchema,
+  ManagedGeneratedFileOutputSchema,
   ManagedInstructionOutputSchema,
   ManagedOutputSchema,
   ManagedSkillOutputSchema,
@@ -79,6 +84,7 @@ export {
   type EffectTsgoLock,
   type ManagedAgentInstructionsOutput,
   type ManagedClaudeInstructionsOutput,
+  type ManagedGeneratedFileOutput,
   type ManagedInstructionOutput,
   type ManagedOutput,
   type ManagedSkillOutput,

package/src/manifest.ts

@@ -49,16 +49,35 @@ export const ClaudeInstructionsSetupSchema = Schema.Struct({
 
 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(
@@ -99,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>>;
 };
@@ -122,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,
@@ -146,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,
   };