@danieljvdm/dev-kit 0.11.3 → 0.13.0

package/src/catalog.ts

@@ -2,8 +2,13 @@ import { Effect, FileSystem, Path, Schema, Stream } from "effect";
 import { ChildProcess } from "effect/unstable/process";
 import { parse as parseJsonc, type ParseError } from "jsonc-parser";
 
-import { discoverPackageSkills, resolvePackageSkillSelector } from "./package-skill-source.ts";
+import {
+  discoverPackageSkills,
+  resolvePackageSkillSelector,
+  type DiscoveredPackageSkill,
+} from "./package-skill-source.ts";
 import { observePath, type Digest } from "./path-digest.ts";
+import { packageSkillInstallName } from "./skill-selector.ts";
 import {
   SkillSourcesLockSchema,
   type LockedSkillSource,
@@ -45,7 +50,7 @@ export type ResolvedSkillSource = {
       };
 };
 
-class CatalogError extends Schema.TaggedErrorClass<CatalogError>()("CatalogError", {
+class CatalogError extends Schema.TaggedError<CatalogError>()("CatalogError", {
   message: Schema.String,
 }) {}
 
@@ -61,7 +66,7 @@ const runGit = Effect.fn("runCatalogGit")(function* (cwd: string, args: Readonly
   ]);
 
   if (exitCode !== 0) {
-    return yield* new CatalogError({
+    return yield* CatalogError.make({
       message: `git ${args.join(" ")} failed: ${output.trim()}`,
     });
   }
@@ -80,11 +85,11 @@ const readCatalogLock = Effect.fn("readCatalogLock")(function* (packageRoot: str
   const value = parseJsonc(raw, errors, { allowTrailingComma: true });
 
   if (errors.length > 0) {
-    return yield* new CatalogError({ message: `invalid skill catalog lock: ${lockPath}` });
+    return yield* CatalogError.make({ message: `invalid skill catalog lock: ${lockPath}` });
   }
 
   return yield* Schema.decodeUnknownEffect(SkillSourcesLockSchema)(value).pipe(
-    Effect.mapError((error) => new CatalogError({ message: error.message })),
+    Effect.mapError((error) => CatalogError.make({ message: error.message })),
   );
 });
 
@@ -145,7 +150,7 @@ export const loadSkillCatalog = Effect.fn("loadSkillCatalog")(function* (
 
   for (const candidate of discovery.candidates) {
     skills.push({
-      name: candidate.name,
+      name: packageSkillInstallName(candidate.package, candidate.name),
       selector: candidate.selector,
       description: candidate.description,
       source: candidate.package,
@@ -159,7 +164,7 @@ export const loadSkillCatalog = Effect.fn("loadSkillCatalog")(function* (
   );
 
   if (duplicates.length > 0) {
-    return yield* new CatalogError({
+    return yield* CatalogError.make({
       message: `duplicate catalog skill selector: ${duplicates[0]?.selector ?? "unknown"}`,
     });
   }
@@ -171,13 +176,12 @@ export const loadSkillCatalog = Effect.fn("loadSkillCatalog")(function* (
   );
 
   if (duplicateFamily !== undefined) {
-    return yield* new CatalogError({
+    return yield* CatalogError.make({
       message: `duplicate catalog family: ${duplicateFamily[0]}`,
     });
   }
   const families: Readonly<Record<string, ReadonlyArray<string>>> = {
-    effect: ["effect-ts"],
-    "effect-atom-data-fetching": ["effect-ts"],
+    effect: ["effect-ts", "effect-architecture-audit", "build-effect-apis", "build-effect-clis"],
     ...Object.fromEntries(externalFamilies),
   };
 
@@ -206,6 +210,57 @@ const stripFrontmatterKeys = (text: string, keys: ReadonlyArray<string>): string
   return `---\n${lines.join("\n")}\n---${frontmatter[2]}${text.slice(frontmatter[0].length)}`;
 };
 
+const rewriteFrontmatterName = (text: string, name: string): string => {
+  const frontmatter = text.match(/^---\r?\n([\s\S]*?)\r?\n---(\r?\n|$)/);
+
+  if (!frontmatter?.[1]) return text;
+  let replacing = false;
+  const lines = frontmatter[1].split(/\r?\n/).flatMap((line) => {
+    const key = line.match(/^([A-Za-z0-9_-]+):/)?.[1];
+
+    if (key !== undefined) replacing = key === "name";
+
+    return replacing ? (key === undefined ? [] : [`name: ${name}`]) : [line];
+  });
+
+  return `---\n${lines.join("\n")}\n---${frontmatter[2]}${text.slice(frontmatter[0].length)}`;
+};
+
+const materializePackageSkill = Effect.fn("materializePackageSkill")(function* (
+  projectDir: string,
+  skill: DiscoveredPackageSkill,
+  digest: Digest,
+  cache: boolean,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const installName = packageSkillInstallName(skill.package, skill.name);
+  const root = cache
+    ? path.join(projectDir, ".dev-kit", "cache", "package-skills", installName)
+    : path.join(
+        yield* fs.makeTempDirectoryScoped({ prefix: "dev-kit-package-plan-" }),
+        installName,
+      );
+  const staged = path.join(root, "skill");
+  const ready = path.join(root, ".ready");
+  const stamp = `${skill.version}\n${digest}\n`;
+
+  if (!(yield* fs.exists(ready)) || (yield* fs.readFileString(ready)) !== stamp) {
+    yield* fs.remove(root, { force: true, recursive: true });
+    yield* fs.makeDirectory(root, { recursive: true });
+    yield* fs.copy(skill.path, staged, { overwrite: true });
+    const document = path.join(staged, "SKILL.md");
+
+    yield* fs.writeFileString(
+      document,
+      rewriteFrontmatterName(yield* fs.readFileString(document), installName),
+    );
+    yield* fs.writeFileString(ready, stamp);
+  }
+
+  return staged;
+});
+
 const materializeSource = Effect.fn("materializeCatalogSource")(function* (
   projectDir: string,
   source: LockedSkillSource,
@@ -234,14 +289,14 @@ const materializeSource = Effect.fn("materializeCatalogSource")(function* (
     const actual = yield* runGit(checkout, ["rev-parse", "HEAD"]);
 
     if (actual !== source.resolved) {
-      return yield* new CatalogError({
+      return yield* CatalogError.make({
         message: `source ${source.id} resolved to ${actual}, expected ${source.resolved}`,
       });
     }
     const symlinks = yield* runGit(checkout, ["ls-files", "--stage", "--", source.skillsPath]);
 
     if (symlinks.split(/\r?\n/).some((line) => line.startsWith("120000 "))) {
-      return yield* new CatalogError({
+      return yield* CatalogError.make({
         message: `source ${source.id} contains symlinks; refusing to install it`,
       });
     }
@@ -251,7 +306,7 @@ const materializeSource = Effect.fn("materializeCatalogSource")(function* (
       const observation = yield* observePath(from);
 
       if (observation.kind !== "directory") {
-        return yield* new CatalogError({
+        return yield* CatalogError.make({
           message: `source ${source.id} is missing skill ${skill}`,
         });
       }
@@ -275,7 +330,7 @@ const materializeSource = Effect.fn("materializeCatalogSource")(function* (
       approvedDigest !== undefined &&
       (observation.kind !== "directory" || observation.digest !== approvedDigest)
     ) {
-      return yield* new CatalogError({
+      return yield* CatalogError.make({
         message: `cached skill ${skill} does not match the approved catalog; remove ${root} and retry`,
       });
     }
@@ -324,10 +379,10 @@ export const resolveSkillSources = Effect.fn("resolveSkillSources")(function* (
     const observation = yield* observePath(resolved.path);
 
     if (observation.kind !== "directory") {
-      return yield* new CatalogError({ message: `package skill is missing: ${selector}` });
+      return yield* CatalogError.make({ message: `package skill is missing: ${selector}` });
     }
     sources.set(selector, {
-      path: resolved.path,
+      path: yield* materializePackageSkill(projectDir, resolved, observation.digest, cache),
       linkPath: resolved.linkPath,
       catalog: {
         package: resolved.package,

package/src/effect-source.ts

@@ -28,7 +28,20 @@ export type EffectSourcePlan = {
   readonly tag: string;
 };
 
-export class EffectSourceDependencyError extends Schema.TaggedErrorClass<EffectSourceDependencyError>()(
+const EffectSourcePlanJsonSchema = Schema.fromJsonString(
+  Schema.Struct({
+    action: Schema.Literals(["sync", "unchanged", "skipped"]),
+    checkoutDir: Schema.String,
+    packageName: Schema.String,
+    packageVersion: Schema.String,
+    path: Schema.String,
+    projectDir: Schema.String,
+    repository: Schema.String,
+    tag: Schema.String,
+  }),
+);
+
+export class EffectSourceDependencyError extends Schema.TaggedError<EffectSourceDependencyError>()(
   "EffectSourceDependencyError",
   { packageName: Schema.String },
 ) {
@@ -37,12 +50,12 @@ export class EffectSourceDependencyError extends Schema.TaggedErrorClass<EffectS
   }
 }
 
-export class EffectSourceCheckoutError extends Schema.TaggedErrorClass<EffectSourceCheckoutError>()(
+export class EffectSourceCheckoutError extends Schema.TaggedError<EffectSourceCheckoutError>()(
   "EffectSourceCheckoutError",
   { message: Schema.String },
 ) {}
 
-class EffectSourceCommandError extends Schema.TaggedErrorClass<EffectSourceCommandError>()(
+class EffectSourceCommandError extends Schema.TaggedError<EffectSourceCommandError>()(
   "EffectSourceCommandError",
   { command: Schema.String, exitCode: Schema.Int, output: Schema.String },
 ) {
@@ -76,7 +89,7 @@ const runCommand = Effect.fn("runEffectSourceCommand")(function* (
   const trimmed = output.trim();
 
   if (exitCode !== 0) {
-    return yield* new EffectSourceCommandError({
+    return yield* EffectSourceCommandError.make({
       command: [command, ...args].join(" "),
       exitCode,
       output: trimmed,
@@ -104,12 +117,12 @@ const readPackageVersion = Effect.fn("readEffectSourcePackageVersion")(function*
     .readFileString(manifestPath)
     .pipe(
       Effect.catchReason("PlatformError", "NotFound", () =>
-        Effect.fail(new EffectSourceDependencyError({ packageName })),
+        Effect.fail(EffectSourceDependencyError.make({ packageName })),
       ),
     );
 
-  return yield* Schema.decodeUnknownEffect(PackageVersionSchema)(contents).pipe(
-    Effect.mapError(() => new EffectSourceDependencyError({ packageName })),
+  return yield* Schema.decodeEffect(PackageVersionSchema)(contents).pipe(
+    Effect.mapError(() => EffectSourceDependencyError.make({ packageName })),
     Effect.map((manifest) => manifest.version),
   );
 });
@@ -121,7 +134,7 @@ const resolveCheckoutPath = Effect.fn("resolveEffectSourceCheckoutPath")(functio
   const path = yield* Path.Path;
 
   if (candidate.length === 0 || path.isAbsolute(candidate)) {
-    return yield* new EffectSourceCheckoutError({
+    return yield* EffectSourceCheckoutError.make({
       message: `Effect source path must be a non-empty project-relative path: ${candidate}`,
     });
   }
@@ -134,7 +147,7 @@ const resolveCheckoutPath = Effect.fn("resolveEffectSourceCheckoutPath")(functio
     relative.startsWith(`..${path.sep}`) ||
     path.isAbsolute(relative)
   ) {
-    return yield* new EffectSourceCheckoutError({
+    return yield* EffectSourceCheckoutError.make({
       message: `Effect source path resolves outside the project: ${candidate}`,
     });
   }
@@ -143,7 +156,7 @@ const resolveCheckoutPath = Effect.fn("resolveEffectSourceCheckoutPath")(functio
   for (const segment of relative.split(path.sep).slice(0, -1)) {
     ancestor = path.join(ancestor, segment);
     if ((yield* observeSymbolicLink(ancestor)).kind === "symlink") {
-      return yield* new EffectSourceCheckoutError({
+      return yield* EffectSourceCheckoutError.make({
         message: `Effect source path has a symlink ancestor: ${ancestor}`,
       });
     }
@@ -163,31 +176,30 @@ const inspectExistingCheckout = Effect.fn("inspectExistingEffectSource")(functio
   const fs = yield* FileSystem.FileSystem;
 
   if ((yield* observeSymbolicLink(checkoutDir)).kind === "symlink") {
-    return yield* new EffectSourceCheckoutError({
+    return yield* EffectSourceCheckoutError.make({
       message: `Effect source destination is a symlink: ${checkoutDir}`,
     });
   }
   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(() =>
+      EffectSourceCheckoutError.make({
+        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({
+    return yield* EffectSourceCheckoutError.make({
       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({
+    return yield* EffectSourceCheckoutError.make({
       message: `Effect source origin is ${remote}; expected ${repository}`,
     });
   }
@@ -208,7 +220,7 @@ const inspectExistingCheckout = Effect.fn("inspectExistingEffectSource")(functio
   const dirty = yield* runGit(checkoutDir, ["status", "--porcelain", "--untracked-files=all"]);
 
   if (dirty.length > 0) {
-    return yield* new EffectSourceCheckoutError({
+    return yield* EffectSourceCheckoutError.make({
       message: `Effect source checkout has local changes; refusing to switch ${checkoutDir} to ${tag}`,
     });
   }
@@ -225,14 +237,14 @@ export const planEffectSource = Effect.fn("planEffectSource")(function* (
   const packageName = options.packageName ?? "effect";
 
   if (!isTypeScriptPackageName(packageName)) {
-    return yield* new EffectSourceCheckoutError({
+    return yield* EffectSourceCheckoutError.make({
       message: `invalid Effect source package name: ${packageName}`,
     });
   }
   const repository = options.repository ?? DEFAULT_EFFECT_REPOSITORY;
 
   if (repository.length === 0) {
-    return yield* new EffectSourceCheckoutError({
+    return yield* EffectSourceCheckoutError.make({
       message: "Effect source repository cannot be empty",
     });
   }
@@ -289,7 +301,7 @@ export const applyEffectSourcePlan = Effect.fn("applyEffectSourcePlan")(function
       staged,
     ]);
     if (yield* fs.exists(plan.checkoutDir)) {
-      return yield* new EffectSourceCheckoutError({
+      return yield* EffectSourceCheckoutError.make({
         message: `Effect source destination appeared while cloning: ${plan.checkoutDir}`,
       });
     }
@@ -344,9 +356,19 @@ export const syncEffectSource = Effect.fn("syncEffectSource")(function* (
   }
   yield* acquireProjectProcessLock(plan.projectDir);
   const replanned = yield* planEffectSource(options);
+  const [plannedSignature, replannedSignature] = yield* Effect.all([
+    Schema.encodeEffect(EffectSourcePlanJsonSchema)(plan),
+    Schema.encodeEffect(EffectSourcePlanJsonSchema)(replanned),
+  ]).pipe(
+    Effect.mapError((error) =>
+      EffectSourceCheckoutError.make({
+        message: `could not encode Effect source plan: ${error.message}`,
+      }),
+    ),
+  );
 
-  if (JSON.stringify(plan) !== JSON.stringify(replanned)) {
-    return yield* new EffectSourceCheckoutError({
+  if (plannedSignature !== replannedSignature) {
+    return yield* EffectSourceCheckoutError.make({
       message: "Effect source checkout changed after planning; rerun the command",
     });
   }

package/src/effect-tsgo.ts

@@ -5,10 +5,47 @@ 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";
+export const EFFECT_TSGO_VERSION = "0.33.0";
 export const EFFECT_TSGO_TYPESCRIPT_VERSION = "7.0.2";
 export const EFFECT_TSGO_PLUGIN_NAME = "@effect/language-service";
 
+export type EffectTsgoDiagnosticSeverity = "off" | "error" | "warning" | "message" | "suggestion";
+
+export type EffectTsgoPluginConfig = {
+  readonly name: typeof EFFECT_TSGO_PLUGIN_NAME;
+  readonly diagnosticSeverity: Readonly<Record<string, EffectTsgoDiagnosticSeverity>>;
+  readonly overrides: ReadonlyArray<{
+    readonly include: ReadonlyArray<string>;
+    readonly options: {
+      readonly diagnosticSeverity: Readonly<Record<string, EffectTsgoDiagnosticSeverity>>;
+    };
+  }>;
+};
+
+/** Recommended diagnostics for projects using the Effect TypeScript-Go plugin. */
+export const recommendedEffectTsgoPlugin = {
+  name: EFFECT_TSGO_PLUGIN_NAME,
+  diagnosticSeverity: {
+    anyUnknownInErrorContext: "warning",
+    instanceOfSchema: "suggestion",
+    nestedEffectGenYield: "suggestion",
+    newSchemaClass: "suggestion",
+    preferSchemaTypeProperty: "suggestion",
+    unsafeEffectTypeAssertion: "warning",
+  },
+  overrides: [
+    {
+      include: ["src/**/*.ts"],
+      options: {
+        diagnosticSeverity: {
+          nodeBuiltinImport: "warning",
+          preferSchemaOverJson: "suggestion",
+        },
+      },
+    },
+  ],
+} as const satisfies EffectTsgoPluginConfig;
+
 export type EffectTsgoPatchOptions = {
   readonly dryRun?: boolean;
   readonly force?: boolean;
@@ -18,6 +55,7 @@ export type EffectTsgoPatchOptions = {
 
 export type EffectTsgoPatchPlan = {
   readonly alreadyPatched: boolean;
+  readonly unpatchArgs?: ReadonlyArray<string>;
   readonly projectDir: string;
   readonly executable: string;
   readonly args: ReadonlyArray<string>;
@@ -26,7 +64,7 @@ export type EffectTsgoPatchPlan = {
   readonly typescriptVersion: string;
 };
 
-export class EffectTsgoDependencyError extends Schema.TaggedErrorClass<EffectTsgoDependencyError>()(
+export class EffectTsgoDependencyError extends Schema.TaggedError<EffectTsgoDependencyError>()(
   "EffectTsgoDependencyError",
   {
     packageName: Schema.String,
@@ -41,7 +79,7 @@ export class EffectTsgoDependencyError extends Schema.TaggedErrorClass<EffectTsg
   }
 }
 
-export class EffectTsgoPatchCommandError extends Schema.TaggedErrorClass<EffectTsgoPatchCommandError>()(
+export class EffectTsgoPatchCommandError extends Schema.TaggedError<EffectTsgoPatchCommandError>()(
   "EffectTsgoPatchCommandError",
   {
     command: Schema.String,
@@ -56,7 +94,7 @@ export class EffectTsgoPatchCommandError extends Schema.TaggedErrorClass<EffectT
   }
 }
 
-export class InvalidEffectTsgoPackageNameError extends Schema.TaggedErrorClass<InvalidEffectTsgoPackageNameError>()(
+export class InvalidEffectTsgoPackageNameError extends Schema.TaggedError<InvalidEffectTsgoPackageNameError>()(
   "InvalidEffectTsgoPackageNameError",
   { packageName: Schema.String },
 ) {
@@ -82,15 +120,15 @@ const readExactPackageVersion = Effect.fn("readExactEffectTsgoPackageVersion")(f
     .readFileString(manifestPath)
     .pipe(
       Effect.catchReason("PlatformError", "NotFound", () =>
-        Effect.fail(new EffectTsgoDependencyError({ packageName, expectedVersion })),
+        Effect.fail(EffectTsgoDependencyError.make({ packageName, expectedVersion })),
       ),
     );
-  const manifest = yield* Schema.decodeUnknownEffect(PackageVersionSchema)(contents).pipe(
-    Effect.mapError(() => new EffectTsgoDependencyError({ packageName, expectedVersion })),
+  const manifest = yield* Schema.decodeEffect(PackageVersionSchema)(contents).pipe(
+    Effect.mapError(() => EffectTsgoDependencyError.make({ packageName, expectedVersion })),
   );
 
   if (manifest.version !== expectedVersion) {
-    return yield* new EffectTsgoDependencyError({
+    return yield* EffectTsgoDependencyError.make({
       packageName,
       expectedVersion,
       actualVersion: manifest.version,
@@ -115,7 +153,7 @@ const resolveEffectTsgoExecutable = Effect.fn("resolveEffectTsgoExecutable")(fun
     if (yield* fs.exists(candidate)) return candidate;
   }
 
-  return yield* new EffectTsgoDependencyError({
+  return yield* EffectTsgoDependencyError.make({
     packageName: "@effect/tsgo",
     expectedVersion: EFFECT_TSGO_VERSION,
   });
@@ -140,7 +178,7 @@ const findNodeModulesRoot = (path: Path.Path, packageJsonPath: string): string |
   }
 };
 
-const isEffectTsgoPatched = Effect.fn("isEffectTsgoPatched")(function* (
+const inspectEffectTsgoPatch = Effect.fn("inspectEffectTsgoPatch")(function* (
   projectDir: string,
   typescriptPackage: string,
 ) {
@@ -153,22 +191,28 @@ const isEffectTsgoPatched = Effect.fn("isEffectTsgoPatched")(function* (
   const typescriptNodeModules = findNodeModulesRoot(path, typescriptPackageJson);
   const effectNodeModules = findNodeModulesRoot(path, effectTsgoPackageJson);
 
-  if (typescriptNodeModules === undefined || effectNodeModules === undefined) return false;
+  if (typescriptNodeModules === undefined || effectNodeModules === undefined) {
+    return { alreadyPatched: false, hasBackup: false };
+  }
 
   const typescriptScope = path.join(typescriptNodeModules, "@typescript");
   const effectScope = path.join(effectNodeModules, "@effect");
 
-  if (!(yield* fs.exists(typescriptScope)) || !(yield* fs.exists(effectScope))) return false;
+  if (!(yield* fs.exists(typescriptScope)) || !(yield* fs.exists(effectScope))) {
+    return { alreadyPatched: false, hasBackup: false };
+  }
 
   const executableName = path.sep === "\\" ? "tsc.exe" : "tsc";
   const effectExecutableNames =
     path.sep === "\\" ? ["tsc.exe", "tsc-next.exe"] : ["tsc", "tsc-next"];
+  let hasBackup = false;
 
   for (const entry of yield* fs.readDirectory(typescriptScope)) {
     if (!entry.startsWith("typescript-")) continue;
     const platform = entry.slice("typescript-".length);
     const installedPath = path.join(typescriptScope, entry, "lib", executableName);
 
+    if (yield* fs.exists(`${installedPath}.original`)) hasBackup = true;
     if (!(yield* fs.exists(installedPath))) continue;
     const installedDigest = yield* digestFileContents(installedPath);
 
@@ -184,12 +228,12 @@ const isEffectTsgoPatched = Effect.fn("isEffectTsgoPatched")(function* (
         (yield* fs.exists(effectBinaryPath)) &&
         installedDigest === (yield* digestFileContents(effectBinaryPath))
       ) {
-        return true;
+        return { alreadyPatched: true, hasBackup };
       }
     }
   }
 
-  return false;
+  return { alreadyPatched: false, hasBackup };
 });
 
 export const planEffectTsgoPatch = Effect.fn("planEffectTsgoPatch")(function* (
@@ -201,7 +245,7 @@ export const planEffectTsgoPatch = Effect.fn("planEffectTsgoPatch")(function* (
   const typescriptPackage = options.typescriptPackage ?? "typescript";
 
   if (!isTypeScriptPackageName(typescriptPackage)) {
-    return yield* new InvalidEffectTsgoPackageNameError({ packageName: typescriptPackage });
+    return yield* InvalidEffectTsgoPackageNameError.make({ packageName: typescriptPackage });
   }
   const effectTsgoVersion = yield* readExactPackageVersion(
     projectDir,
@@ -214,15 +258,22 @@ export const planEffectTsgoPatch = Effect.fn("planEffectTsgoPatch")(function* (
     EFFECT_TSGO_TYPESCRIPT_VERSION,
   );
   const executable = yield* resolveEffectTsgoExecutable(projectDir);
+  const patchState = yield* inspectEffectTsgoPatch(projectDir, typescriptPackage);
+  const typescriptPackageArgs =
+    typescriptPackage === "typescript" ? [] : ["--typescript-package", typescriptPackage];
 
   return {
-    alreadyPatched: yield* isEffectTsgoPatched(projectDir, typescriptPackage),
+    alreadyPatched: patchState.alreadyPatched,
+    ...(patchState.hasBackup && !patchState.alreadyPatched
+      ? { unpatchArgs: ["unpatch", "--typescript", ...typescriptPackageArgs] }
+      : {}),
     projectDir,
     executable,
     args: [
       "patch",
+      "--typescript",
       ...(options.force ? ["--force"] : []),
-      ...(typescriptPackage === "typescript" ? [] : ["--typescript-package", typescriptPackage]),
+      ...typescriptPackageArgs,
     ],
     effectTsgoVersion,
     typescriptPackage,
@@ -230,12 +281,13 @@ export const planEffectTsgoPatch = Effect.fn("planEffectTsgoPatch")(function* (
   } satisfies EffectTsgoPatchPlan;
 });
 
-export const applyEffectTsgoPatchPlan = Effect.fn("applyEffectTsgoPatchPlan")(function* (
-  plan: EffectTsgoPatchPlan,
+const runEffectTsgoCommand = Effect.fn("runEffectTsgoCommand")(function* (
+  executable: string,
+  args: ReadonlyArray<string>,
+  projectDir: string,
 ) {
-  if (plan.alreadyPatched) return;
-  const child = yield* ChildProcess.make(plan.executable, plan.args, {
-    cwd: plan.projectDir,
+  const child = yield* ChildProcess.make(executable, args, {
+    cwd: projectDir,
     stderr: "pipe",
     stdout: "pipe",
   });
@@ -246,14 +298,24 @@ export const applyEffectTsgoPatchPlan = Effect.fn("applyEffectTsgoPatchPlan")(fu
   const trimmed = output.trim();
 
   if (exitCode !== 0) {
-    return yield* new EffectTsgoPatchCommandError({
-      command: [plan.executable, ...plan.args].join(" "),
+    return yield* EffectTsgoPatchCommandError.make({
+      command: [executable, ...args].join(" "),
       exitCode,
       output: trimmed,
     });
   }
 });
 
+export const applyEffectTsgoPatchPlan = Effect.fn("applyEffectTsgoPatchPlan")(function* (
+  plan: EffectTsgoPatchPlan,
+) {
+  if (plan.alreadyPatched) return;
+  if (plan.unpatchArgs !== undefined) {
+    yield* runEffectTsgoCommand(plan.executable, plan.unpatchArgs, plan.projectDir);
+  }
+  yield* runEffectTsgoCommand(plan.executable, plan.args, plan.projectDir);
+});
+
 export const patchEffectTsgo = Effect.fn("patchEffectTsgo")(function* (
   options: EffectTsgoPatchOptions = {},
 ) {

package/src/gitignore.ts

@@ -22,7 +22,7 @@ export type GitignorePatch = {
   readonly added: ReadonlyArray<string>;
 };
 
-export class UnsafeGitignorePathError extends Schema.TaggedErrorClass<UnsafeGitignorePathError>()(
+export class UnsafeGitignorePathError extends Schema.TaggedError<UnsafeGitignorePathError>()(
   "UnsafeGitignorePathError",
   {
     path: Schema.String,
@@ -34,7 +34,7 @@ export class UnsafeGitignorePathError extends Schema.TaggedErrorClass<UnsafeGiti
   }
 }
 
-export class GitignoreConflictError extends Schema.TaggedErrorClass<GitignoreConflictError>()(
+export class GitignoreConflictError extends Schema.TaggedError<GitignoreConflictError>()(
   "GitignoreConflictError",
   { path: Schema.String },
 ) {
@@ -94,7 +94,7 @@ const planGitignorePatch = Effect.fn("planGitignorePatch")(function* (
   const observation = yield* observeSymbolicLink(gitignorePath);
 
   if (observation.kind === "symlink") {
-    return yield* new UnsafeGitignorePathError({
+    return yield* UnsafeGitignorePathError.make({
       path: gitignorePath,
       reason: "the file is a symlink",
     });
@@ -107,7 +107,7 @@ const planGitignorePatch = Effect.fn("planGitignorePatch")(function* (
     const info = yield* fs.stat(gitignorePath);
 
     if (info.type !== "File") {
-      return yield* new UnsafeGitignorePathError({
+      return yield* UnsafeGitignorePathError.make({
         path: gitignorePath,
         reason: "the path is not a regular file",
       });
@@ -152,7 +152,7 @@ const applyGitignorePatch = Effect.fn("applyGitignorePatch")(function* (
     : currentObservation.kind !== "missing";
 
   if (changed) {
-    return yield* new GitignoreConflictError({ path: patch.path });
+    return yield* GitignoreConflictError.make({ path: patch.path });
   }
 
   let backedUp = false;