adamantite 0.27.3 → 0.28.0

package/README.md

@@ -20,7 +20,7 @@
 Adamantite is a collection of presets for
 [oxlint](https://oxc.rs/docs/guide/usage/linter.html),
 [oxfmt](https://oxc.rs/docs/guide/usage/formatter.html),
-[tsgo](https://github.com/microsoft/typescript-go) and
+[TypeScript](https://www.typescriptlang.org/) and
 [sherif](https://github.com/QuiiBz/sherif) that are designed to help humans and agents write
 maintainable and scalable type-safe code, both for individual projects and monorepos.
 
@@ -145,14 +145,14 @@ Automatically detects and fixes:
 
 ### `adamantite typecheck`
 
-Run TypeScript type checking using tsgo (TypeScript Go) and the strict preset:
+Run TypeScript type checking using tsc and the strict preset:
 
 ```shell
 # Type check all files
 adamantite typecheck
 
-# Type check specific files
-adamantite typecheck src/utils.ts
+# Type check a specific project
+adamantite typecheck --project tsconfig.json
 ```
 
 ### `adamantite update`

package/dist/index.js

@@ -2,12 +2,12 @@
 import process5 from "node:process";
 import { Command as Command9 } from "@effect/cli";
 import { NodeContext, NodeRuntime } from "@effect/platform-node";
-import { Effect as Effect19, Layer as Layer4 } from "effect";
+import { Effect as Effect19, Layer as Layer3 } from "effect";
 
 // src/commands/analyze.ts
 import { Command, Options } from "@effect/cli";
 import { Command as ShellCommand2 } from "@effect/platform";
-import { Effect as Effect6 } from "effect";
+import { Effect as Effect4 } from "effect";
 
 // src/helpers/packages/knip.ts
 import { FileSystem as FileSystem2, Path as Path2 } from "@effect/platform";
@@ -156,9 +156,9 @@ var printTitle = () => Effect2.gen(function* () {
   const terminal = yield* Terminal.Terminal;
   const terminalColumns = yield* terminal.columns;
   const title = `
-                .o8                                                        .    o8o      .            
-               "888                                                      .o8    \`"'    .o8            
- .oooo.    .oooo888   .oooo.   ooo. .oo.  .oo.    .oooo.   ooo. .oo.   .o888oo oooo  .o888oo  .ooooo. 
+                .o8                                                        .    o8o      .
+               "888                                                      .o8    \`"'    .o8
+ .oooo.    .oooo888   .oooo.   ooo. .oo.  .oo.    .oooo.   ooo. .oo.   .o888oo oooo  .o888oo  .ooooo.
 \`P  )88b  d88' \`888  \`P  )88b  \`888P"Y88bP"Y88b  \`P  )88b  \`888P"Y88b    888   \`888    888   d88' \`88b
  .oP"888  888   888   .oP"888   888   888   888   .oP"888   888   888    888    888    888   888ooo888
 d8(  888  888   888  d8(  888   888   888   888  d8(  888   888   888    888 .  888    888 . 888    .o
@@ -216,94 +216,13 @@ var knip = {
     yield* fs.writeFileString(configPath, `${JSON.stringify(mergedConfig, null, 2)}
 `).pipe(Effect3.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
   }),
-  version: "5.81.0"
+  version: "5.82.1"
 };
 
-// src/services/package-manager.ts
-import process4 from "node:process";
-import { Context as Context3, Effect as Effect5, Layer as Layer3 } from "effect";
-import { detectPackageManager } from "nypm";
-
-// src/services/prompter.ts
-import * as p from "@clack/prompts";
-import { Context as Context2, Effect as Effect4, Layer as Layer2 } from "effect";
-
-class Prompter extends Context2.Tag("Prompter")() {
-}
-var PrompterLive = Layer2.succeed(Prompter, {
-  cancel: (message) => Effect4.sync(() => {
-    p.cancel(message);
-  }),
-  confirm: (options) => Effect4.tryPromise(() => p.confirm(options)).pipe(Effect4.orDie),
-  intro: (message) => Effect4.sync(() => {
-    p.intro(message);
-  }),
-  log: {
-    error: (message) => Effect4.sync(() => {
-      p.log.error(message);
-    }),
-    info: (message) => Effect4.sync(() => {
-      p.log.info(message);
-    }),
-    success: (message) => Effect4.sync(() => {
-      p.log.success(message);
-    }),
-    warning: (message) => Effect4.sync(() => {
-      p.log.warning(message);
-    })
-  },
-  multiselect: (options) => Effect4.tryPromise(() => p.multiselect(options)).pipe(Effect4.orDie),
-  outro: (message) => Effect4.sync(() => {
-    p.outro(message);
-  }),
-  spinner: () => p.spinner()
-});
-
-// src/services/package-manager.ts
-class PackageManager extends Context3.Tag("PackageManager")() {
-}
-var PackageManagerLive = Layer3.effect(PackageManager, Effect5.gen(function* () {
-  const prompter = yield* Prompter;
-  const result = yield* Effect5.tryPromise({
-    catch: (cause) => new NoPackageManager({ cause }),
-    try: () => detectPackageManager(process4.cwd())
-  });
-  if (!result?.name) {
-    return yield* Effect5.fail(new NoPackageManager({}));
-  }
-  if (result.warnings?.length) {
-    for (const warning of result.warnings) {
-      yield* prompter.log.warning(warning);
-    }
-  }
-  const command = (() => {
-    switch (result.name) {
-      case "bun":
-        return ["bunx"];
-      case "pnpm":
-        return ["pnpm", "dlx"];
-      case "yarn":
-        return ["yarn", "dlx"];
-      case "npm":
-        return ["npx"];
-      case "deno":
-        return ["deno", "run", "-A"];
-      default:
-        return ["npx"];
-    }
-  })();
-  return {
-    command,
-    name: result.name
-  };
-})).pipe(Layer3.provide(PrompterLive));
-
 // src/commands/analyze.ts
 var fix = Options.boolean("fix").pipe(Options.withDescription("Automatically fix issues"));
 var strict = Options.boolean("strict").pipe(Options.withDescription("Enable strict mode"));
-var analyze_default = Command.make("analyze", { fix, strict }).pipe(Command.withDescription("Find unused dependencies, exports, and files using knip"), Command.withHandler(({ fix: fix2, strict: strict2 }) => Effect6.gen(function* () {
-  const pm = yield* PackageManager;
-  const [command, ...commandArgs] = pm.command;
+var analyze_default = Command.make("analyze", { fix, strict }).pipe(Command.withDescription("Find unused dependencies, exports, and files using knip"), Command.withHandler(({ fix: fix2, strict: strict2 }) => Effect4.gen(function* () {
   const args = [];
   if (fix2) {
     args.push("--fix", "--allow-remove-files");
@@ -311,23 +230,23 @@ var analyze_default = Command.make("analyze", { fix, strict }).pipe(Command.with
   if (strict2) {
     args.push("--production", "--strict");
   }
-  return yield* ShellCommand2.make(command, ...commandArgs, knip.name, ...args).pipe(ShellCommand2.stdout("inherit"), ShellCommand2.stderr("inherit"), ShellCommand2.exitCode);
+  return yield* ShellCommand2.make(knip.name, ...args).pipe(ShellCommand2.stdout("inherit"), ShellCommand2.stderr("inherit"), ShellCommand2.exitCode);
 })));
 
 // src/commands/check.ts
 import { Args, Command as Command2 } from "@effect/cli";
 import { Command as ShellCommand3 } from "@effect/platform";
-import { Effect as Effect8, Option } from "effect";
+import { Effect as Effect6, Option } from "effect";
 
 // src/helpers/packages/oxlint.ts
 import { FileSystem as FileSystem3, Path as Path3 } from "@effect/platform";
-import { Effect as Effect7 } from "effect";
+import { Effect as Effect5 } from "effect";
 var CONFIG_FILE = ".oxlintrc.json";
 var oxlint = {
   config: {
     $schema: "./node_modules/oxlint/configuration_schema.json"
   },
-  create: (presets = []) => Effect7.gen(function* () {
+  create: (presets = []) => Effect5.gen(function* () {
     const fs = yield* FileSystem3.FileSystem;
     const path = yield* Path3.Path;
     const extendsArray = ["./node_modules/adamantite/presets/lint/core.json"];
@@ -337,9 +256,9 @@ var oxlint = {
     const configPath = path.join(process.cwd(), CONFIG_FILE);
     const payload = JSON.stringify({ ...oxlint.config, extends: extendsArray }, null, 2);
     yield* fs.writeFileString(configPath, `${payload}
-`).pipe(Effect7.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
+`).pipe(Effect5.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
   }),
-  exists: () => Effect7.gen(function* () {
+  exists: () => Effect5.gen(function* () {
     const fs = yield* FileSystem3.FileSystem;
     const path = yield* Path3.Path;
     const configPath = path.join(process.cwd(), CONFIG_FILE);
@@ -347,16 +266,16 @@ var oxlint = {
     return { path: exists ? configPath : null };
   }),
   name: "oxlint",
-  update: (presets = []) => Effect7.gen(function* () {
+  update: (presets = []) => Effect5.gen(function* () {
     const fs = yield* FileSystem3.FileSystem;
     const { path: configPath } = yield* oxlint.exists();
     if (!configPath) {
-      return yield* Effect7.fail(new FileNotFound({ path: CONFIG_FILE }));
+      return yield* Effect5.fail(new FileNotFound({ path: CONFIG_FILE }));
     }
-    const oxlintFile = yield* fs.readFileString(configPath).pipe(Effect7.mapError((cause) => new FailedToReadFile({ cause, path: configPath })));
+    const oxlintFile = yield* fs.readFileString(configPath).pipe(Effect5.mapError((cause) => new FailedToReadFile({ cause, path: configPath })));
     const existingConfig = yield* parseJson(oxlintFile, configPath);
     if (!isJsonObject(existingConfig)) {
-      return yield* Effect7.fail(new InvalidConfigFormat({ path: configPath }));
+      return yield* Effect5.fail(new InvalidConfigFormat({ path: configPath }));
     }
     const newConfig = { ...existingConfig };
     const extendsArray = Array.isArray(newConfig.extends) ? newConfig.extends : typeof newConfig.extends === "string" ? [newConfig.extends] : [];
@@ -374,9 +293,9 @@ var oxlint = {
     const mergedConfig = yield* mergeConfig(newConfig, oxlint.config);
     mergedConfig.$schema = oxlint.config.$schema;
     yield* fs.writeFileString(configPath, `${JSON.stringify(mergedConfig, null, 2)}
-`).pipe(Effect7.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
+`).pipe(Effect5.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
   }),
-  version: "1.39.0"
+  version: "1.41.0"
 };
 var tsgolint = {
   name: "oxlint-tsgolint",
@@ -385,27 +304,23 @@ var tsgolint = {
 
 // src/commands/check.ts
 var files = Args.file({ exists: "yes" }).pipe(Args.withDescription("Specific files to lint (optional)"), Args.repeated, Args.optional);
-var check_default = Command2.make("check", { files }).pipe(Command2.withDescription("Find issues in code using oxlint"), Command2.withHandler(({ files: files2 }) => Effect8.gen(function* () {
-  const pm = yield* PackageManager;
-  const [command, ...commandArgs] = pm.command;
+var check_default = Command2.make("check", { files }).pipe(Command2.withDescription("Find issues in code using oxlint"), Command2.withHandler(({ files: files2 }) => Effect6.gen(function* () {
   const args = ["--type-aware"];
   if (Option.isSome(files2)) {
     args.push(...files2.value);
   }
-  return yield* ShellCommand3.make(command, ...commandArgs, oxlint.name, ...args).pipe(ShellCommand3.stdout("inherit"), ShellCommand3.stderr("inherit"), ShellCommand3.exitCode);
+  return yield* ShellCommand3.make(oxlint.name, ...args).pipe(ShellCommand3.stdout("inherit"), ShellCommand3.stderr("inherit"), ShellCommand3.exitCode);
 })));
 
 // src/commands/fix.ts
 import { Args as Args2, Command as Command3, Options as Options2 } from "@effect/cli";
 import { Command as ShellCommand4 } from "@effect/platform";
-import { Effect as Effect9, Option as Option2 } from "effect";
+import { Effect as Effect7, Option as Option2 } from "effect";
 var files2 = Args2.file({ exists: "yes" }).pipe(Args2.withDescription("Specific files to fix (optional)"), Args2.repeated, Args2.optional);
 var suggested = Options2.boolean("suggested").pipe(Options2.withDescription("Apply suggested fixes"));
 var dangerous = Options2.boolean("dangerous").pipe(Options2.withDescription("Apply dangerous fixes"));
 var all = Options2.boolean("all").pipe(Options2.withDescription("Apply all fixes, including suggested and dangerous fixes"));
-var fix_default = Command3.make("fix", { all, dangerous, files: files2, suggested }).pipe(Command3.withDescription("Fix issues in code using oxlint"), Command3.withHandler(({ all: all2, dangerous: dangerous2, files: files3, suggested: suggested2 }) => Effect9.gen(function* () {
-  const pm = yield* PackageManager;
-  const [command, ...commandArgs] = pm.command;
+var fix_default = Command3.make("fix", { all, dangerous, files: files2, suggested }).pipe(Command3.withDescription("Fix issues in code using oxlint"), Command3.withHandler(({ all: all2, dangerous: dangerous2, files: files3, suggested: suggested2 }) => Effect7.gen(function* () {
   const args = new Set(["--type-aware", "--fix"]);
   if (suggested2 || all2) {
     args.add("--fix-suggestions");
@@ -418,17 +333,17 @@ var fix_default = Command3.make("fix", { all, dangerous, files: files2, suggeste
       args.add(file);
     }
   }
-  return yield* ShellCommand4.make(command, ...commandArgs, oxlint.name, ...args).pipe(ShellCommand4.stdout("inherit"), ShellCommand4.stderr("inherit"), ShellCommand4.exitCode);
+  return yield* ShellCommand4.make(oxlint.name, ...args).pipe(ShellCommand4.stdout("inherit"), ShellCommand4.stderr("inherit"), ShellCommand4.exitCode);
 })));
 
 // src/commands/format.ts
 import { Args as Args3, Command as Command4, Options as Options3 } from "@effect/cli";
 import { Command as ShellCommand5 } from "@effect/platform";
-import { Effect as Effect11, Option as Option3 } from "effect";
+import { Effect as Effect9, Option as Option3 } from "effect";
 
 // src/helpers/packages/oxfmt.ts
 import { FileSystem as FileSystem4, Path as Path4 } from "@effect/platform";
-import { Effect as Effect10 } from "effect";
+import { Effect as Effect8 } from "effect";
 // presets/format.json
 var format_default = {
   $schema: "../node_modules/oxfmt/configuration_schema.json",
@@ -483,15 +398,15 @@ var oxfmt = {
     ...format_default,
     $schema: "./node_modules/oxfmt/configuration_schema.json"
   },
-  create: () => Effect10.gen(function* () {
+  create: () => Effect8.gen(function* () {
     const fs = yield* FileSystem4.FileSystem;
     const path = yield* Path4.Path;
     const configPath = path.join(process.cwd(), CONFIG_FILE_JSONC2);
     const payload = JSON.stringify(oxfmt.config, null, 2);
     yield* fs.writeFileString(configPath, `${payload}
-`).pipe(Effect10.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
+`).pipe(Effect8.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
   }),
-  exists: () => Effect10.gen(function* () {
+  exists: () => Effect8.gen(function* () {
     const fs = yield* FileSystem4.FileSystem;
     const path = yield* Path4.Path;
     const jsoncPath = path.join(process.cwd(), CONFIG_FILE_JSONC2);
@@ -505,31 +420,29 @@ var oxfmt = {
     return { path: null };
   }),
   name: "oxfmt",
-  update: () => Effect10.gen(function* () {
+  update: () => Effect8.gen(function* () {
     const fs = yield* FileSystem4.FileSystem;
     const { path: configPath } = yield* oxfmt.exists();
     if (!configPath) {
-      return yield* Effect10.fail(new FileNotFound({ path: CONFIG_FILE_JSONC2 }));
+      return yield* Effect8.fail(new FileNotFound({ path: CONFIG_FILE_JSONC2 }));
     }
-    const oxfmtFile = yield* fs.readFileString(configPath).pipe(Effect10.mapError((cause) => new FailedToReadFile({ cause, path: configPath })));
+    const oxfmtFile = yield* fs.readFileString(configPath).pipe(Effect8.mapError((cause) => new FailedToReadFile({ cause, path: configPath })));
     const existingConfig = yield* parseJson(oxfmtFile, configPath);
     if (!isJsonObject(existingConfig)) {
-      return yield* Effect10.fail(new InvalidConfigFormat({ path: configPath }));
+      return yield* Effect8.fail(new InvalidConfigFormat({ path: configPath }));
     }
     const mergedConfig = yield* mergeConfig(existingConfig, oxfmt.config);
     mergedConfig.$schema = oxfmt.config.$schema;
     yield* fs.writeFileString(configPath, `${JSON.stringify(mergedConfig, null, 2)}
-`).pipe(Effect10.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
+`).pipe(Effect8.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
   }),
-  version: "0.24.0"
+  version: "0.26.0"
 };
 
 // src/commands/format.ts
 var files3 = Args3.file({ exists: "yes" }).pipe(Args3.withDescription("Specific files to format (optional)"), Args3.repeated, Args3.optional);
 var check = Options3.boolean("check").pipe(Options3.withDescription("Check if files are formatted without writing"));
-var format_default2 = Command4.make("format", { check, files: files3 }).pipe(Command4.withDescription("Format files using oxfmt"), Command4.withHandler(({ check: check2, files: files4 }) => Effect11.gen(function* () {
-  const pm = yield* PackageManager;
-  const [command, ...commandArgs] = pm.command;
+var format_default2 = Command4.make("format", { check, files: files3 }).pipe(Command4.withDescription("Format files using oxfmt"), Command4.withHandler(({ check: check2, files: files4 }) => Effect9.gen(function* () {
   const args = [];
   if (check2) {
     args.push("--check");
@@ -537,19 +450,21 @@ var format_default2 = Command4.make("format", { check, files: files3 }).pipe(Com
   if (Option3.isSome(files4)) {
     args.push(...files4.value);
   }
-  return yield* ShellCommand5.make(command, ...commandArgs, oxfmt.name, ...args).pipe(ShellCommand5.stdout("inherit"), ShellCommand5.stderr("inherit"), ShellCommand5.exitCode);
+  return yield* ShellCommand5.make(oxfmt.name, ...args).pipe(ShellCommand5.stdout("inherit"), ShellCommand5.stderr("inherit"), ShellCommand5.exitCode);
 })));
 
 // src/commands/init.ts
+import process4 from "node:process";
 import { isCancel } from "@clack/prompts";
-import { Command as Command5 } from "@effect/cli";
-import { FileSystem as FileSystem8, Path as Path8 } from "@effect/platform";
-import { Effect as Effect15 } from "effect";
-import { addDevDependency } from "nypm";
+import * as Command5 from "@effect/cli/Command";
+import * as FileSystem9 from "@effect/platform/FileSystem";
+import * as Path9 from "@effect/platform/Path";
+import * as Effect15 from "effect/Effect";
+import { addDevDependency, detectPackageManager } from "nypm";
 
 // src/helpers/ci/github.ts
 import { FileSystem as FileSystem5, Path as Path5 } from "@effect/platform";
-import { Effect as Effect12 } from "effect";
+import { Effect as Effect10 } from "effect";
 import { runScriptCommand } from "nypm";
 var setupSteps = {
   bun: `      - name: Setup Bun
@@ -686,7 +601,7 @@ var CI_COMPATIBLE_SCRIPTS = new Set([
 ]);
 var hasCICompatibleScripts = (scripts) => scripts.some((script) => CI_COMPATIBLE_SCRIPTS.has(script));
 var github = {
-  create: (options) => Effect12.gen(function* () {
+  create: (options) => Effect10.gen(function* () {
     const fs = yield* FileSystem5.FileSystem;
     const path = yield* Path5.Path;
     const workflowDir = path.join(process.cwd(), ".github", "workflows");
@@ -696,14 +611,14 @@ var github = {
       return;
     }
     const workflowPath = path.join(workflowDir, "adamantite.yml");
-    yield* fs.writeFileString(workflowPath, workflowContent).pipe(Effect12.mapError((cause) => new FailedToWriteFile({ cause, path: workflowPath })));
+    yield* fs.writeFileString(workflowPath, workflowContent).pipe(Effect10.mapError((cause) => new FailedToWriteFile({ cause, path: workflowPath })));
   }),
-  exists: () => Effect12.gen(function* () {
+  exists: () => Effect10.gen(function* () {
     const fs = yield* FileSystem5.FileSystem;
     const path = yield* Path5.Path;
     return yield* fs.exists(path.join(process.cwd(), ".github", "workflows", "adamantite.yml"));
   }),
-  update: (options) => Effect12.gen(function* () {
+  update: (options) => Effect10.gen(function* () {
     const fs = yield* FileSystem5.FileSystem;
     const path = yield* Path5.Path;
     const workflowPath = path.join(process.cwd(), ".github", "workflows", "adamantite.yml");
@@ -711,17 +626,17 @@ var github = {
     if (!workflowContent) {
       return;
     }
-    yield* fs.writeFileString(workflowPath, workflowContent).pipe(Effect12.mapError((cause) => new FailedToWriteFile({ cause, path: workflowPath })));
+    yield* fs.writeFileString(workflowPath, workflowContent).pipe(Effect10.mapError((cause) => new FailedToWriteFile({ cause, path: workflowPath })));
   }),
   workflowPath: ".github/workflows/adamantite.yml"
 };
 
 // src/helpers/editors/vscode.ts
 import { FileSystem as FileSystem6, Path as Path6, Command as ShellCommand6 } from "@effect/platform";
-import { Effect as Effect13 } from "effect";
+import { Effect as Effect11 } from "effect";
 var SETTINGS_FILE = "settings.json";
 var vscode = {
-  cliExists: () => checkCliExists("code").pipe(Effect13.mapError((cause) => new VscodeCliNotFound({ cause }))),
+  cliExists: () => checkCliExists("code").pipe(Effect11.mapError((cause) => new VscodeCliNotFound({ cause }))),
   config: {
     "[css]": {
       "editor.defaultFormatter": "oxc.oxc-vscode"
@@ -756,92 +671,228 @@ var vscode = {
     "oxc.typeAware": true,
     "typescript.tsdk": "node_modules/typescript/lib"
   },
-  create: () => Effect13.gen(function* () {
+  create: () => Effect11.gen(function* () {
     const fs = yield* FileSystem6.FileSystem;
     const path = yield* Path6.Path;
     const vscodePath = path.join(process.cwd(), ".vscode");
     const settingsPath = path.join(vscodePath, SETTINGS_FILE);
-    yield* fs.makeDirectory(vscodePath, { recursive: true }).pipe(Effect13.mapError((cause) => new FailedToCreateDirectory({ cause, path: vscodePath })));
+    yield* fs.makeDirectory(vscodePath, { recursive: true }).pipe(Effect11.mapError((cause) => new FailedToCreateDirectory({ cause, path: vscodePath })));
     yield* fs.writeFileString(settingsPath, `${JSON.stringify(vscode.config, null, 2)}
-`).pipe(Effect13.mapError((cause) => new FailedToWriteFile({ cause, path: settingsPath })));
+`).pipe(Effect11.mapError((cause) => new FailedToWriteFile({ cause, path: settingsPath })));
   }),
-  exists: () => Effect13.gen(function* () {
+  exists: () => Effect11.gen(function* () {
     const fs = yield* FileSystem6.FileSystem;
     const path = yield* Path6.Path;
     return yield* fs.exists(path.join(process.cwd(), ".vscode", SETTINGS_FILE));
   }),
-  extension: (scripts = []) => Effect13.gen(function* () {
+  extension: (scripts = []) => Effect11.gen(function* () {
     yield* vscode.cliExists();
-    const installExtension = (extension) => ShellCommand6.make("code", "--install-extension", extension).pipe(ShellCommand6.stdout("inherit"), ShellCommand6.stderr("inherit"), ShellCommand6.exitCode, Effect13.mapError((cause) => new FailedToInstallExtension({ cause, extension })));
+    const installExtension = (extension) => ShellCommand6.make("code", "--install-extension", extension).pipe(ShellCommand6.stdout("inherit"), ShellCommand6.stderr("inherit"), ShellCommand6.exitCode, Effect11.mapError((cause) => new FailedToInstallExtension({ cause, extension })));
     const extensions = [
-      scripts.includes("check") || scripts.includes("fix") || scripts.includes("format") ? installExtension("oxc.oxc-vscode") : Effect13.void,
-      scripts.includes("analyze") ? installExtension("webpro.vscode-knip") : Effect13.void,
-      scripts.includes("typecheck") ? installExtension("TypeScriptTeam.native-preview") : Effect13.void
+      scripts.includes("check") || scripts.includes("fix") || scripts.includes("format") ? installExtension("oxc.oxc-vscode") : Effect11.void,
+      scripts.includes("analyze") ? installExtension("webpro.vscode-knip") : Effect11.void
     ];
-    const results = yield* Effect13.all(extensions, { mode: "either" });
+    const results = yield* Effect11.all(extensions, { mode: "either" });
     const firstFailure = results.find((r) => r._tag === "Left");
     if (firstFailure) {
-      yield* Effect13.fail(firstFailure.left);
+      yield* Effect11.fail(firstFailure.left);
     }
   }),
-  update: () => Effect13.gen(function* () {
+  update: () => Effect11.gen(function* () {
     const fs = yield* FileSystem6.FileSystem;
     const path = yield* Path6.Path;
     const vscodePath = path.join(process.cwd(), ".vscode", SETTINGS_FILE);
-    const vscodeFile = yield* fs.readFileString(vscodePath).pipe(Effect13.mapError((cause) => new FailedToReadFile({ cause, path: vscodePath })));
+    const vscodeFile = yield* fs.readFileString(vscodePath).pipe(Effect11.mapError((cause) => new FailedToReadFile({ cause, path: vscodePath })));
     const existingConfig = yield* parseJson(vscodeFile, vscodePath);
     if (!isJsonObject(existingConfig)) {
-      return yield* Effect13.fail(new InvalidConfigFormat({ path: vscodePath }));
+      return yield* Effect11.fail(new InvalidConfigFormat({ path: vscodePath }));
     }
     const newConfig = yield* mergeConfig(vscode.config, existingConfig);
     yield* fs.writeFileString(vscodePath, `${JSON.stringify(newConfig, null, 2)}
-`).pipe(Effect13.mapError((cause) => new FailedToWriteFile({ cause, path: vscodePath })));
+`).pipe(Effect11.mapError((cause) => new FailedToWriteFile({ cause, path: vscodePath })));
+  })
+};
+
+// src/helpers/editors/zed.ts
+import { FileSystem as FileSystem7, Path as Path7 } from "@effect/platform";
+import { Effect as Effect12 } from "effect";
+var SETTINGS_FILE2 = "settings.json";
+var zed = {
+  config: {
+    languages: {
+      CSS: {
+        format_on_save: "on",
+        formatter: [{ language_server: { name: "oxfmt" } }]
+      },
+      HTML: {
+        format_on_save: "on",
+        formatter: [{ language_server: { name: "oxfmt" } }]
+      },
+      JSON: {
+        format_on_save: "on",
+        formatter: [{ language_server: { name: "oxfmt" } }]
+      },
+      JSONC: {
+        format_on_save: "on",
+        formatter: [{ language_server: { name: "oxfmt" } }]
+      },
+      JavaScript: {
+        format_on_save: "on",
+        formatter: [{ language_server: { name: "oxfmt" } }, { code_action: "source.fixAll.oxc" }]
+      },
+      MDX: {
+        format_on_save: "on",
+        formatter: [{ language_server: { name: "oxfmt" } }]
+      },
+      Markdown: {
+        format_on_save: "on",
+        formatter: [{ language_server: { name: "oxfmt" } }]
+      },
+      TSX: {
+        format_on_save: "on",
+        formatter: [{ language_server: { name: "oxfmt" } }]
+      },
+      TypeScript: {
+        format_on_save: "on",
+        formatter: [{ language_server: { name: "oxfmt" } }]
+      },
+      YAML: {
+        format_on_save: "on",
+        formatter: [{ language_server: { name: "oxfmt" } }]
+      }
+    },
+    lsp: {
+      oxfmt: {
+        initialization_options: {
+          settings: {
+            configPath: null,
+            "fmt.experimental": true,
+            run: "onSave",
+            typeAware: false,
+            unusedDisableDirectives: false
+          }
+        }
+      },
+      oxlint: {
+        initialization_options: {
+          settings: {
+            configPath: null,
+            fixKind: "safe_fix",
+            run: "onType",
+            typeAware: true,
+            unusedDisableDirectives: "deny"
+          }
+        }
+      }
+    }
+  },
+  create: () => Effect12.gen(function* () {
+    const fs = yield* FileSystem7.FileSystem;
+    const path = yield* Path7.Path;
+    const zedPath = path.join(process.cwd(), ".zed");
+    const settingsPath = path.join(zedPath, SETTINGS_FILE2);
+    yield* fs.makeDirectory(zedPath, { recursive: true }).pipe(Effect12.mapError((cause) => new FailedToCreateDirectory({ cause, path: zedPath })));
+    yield* fs.writeFileString(settingsPath, `${JSON.stringify(zed.config, null, 2)}
+`).pipe(Effect12.mapError((cause) => new FailedToWriteFile({ cause, path: settingsPath })));
+  }),
+  exists: () => Effect12.gen(function* () {
+    const fs = yield* FileSystem7.FileSystem;
+    const path = yield* Path7.Path;
+    return yield* fs.exists(path.join(process.cwd(), ".zed", SETTINGS_FILE2));
+  }),
+  update: () => Effect12.gen(function* () {
+    const fs = yield* FileSystem7.FileSystem;
+    const path = yield* Path7.Path;
+    const zedPath = path.join(process.cwd(), ".zed", SETTINGS_FILE2);
+    const zedFile = yield* fs.readFileString(zedPath).pipe(Effect12.mapError((cause) => new FailedToReadFile({ cause, path: zedPath })));
+    const existingConfig = yield* parseJson(zedFile, zedPath);
+    if (!isJsonObject(existingConfig)) {
+      return yield* Effect12.fail(new InvalidConfigFormat({ path: zedPath }));
+    }
+    const newConfig = yield* mergeConfig(zed.config, existingConfig);
+    yield* fs.writeFileString(zedPath, `${JSON.stringify(newConfig, null, 2)}
+`).pipe(Effect12.mapError((cause) => new FailedToWriteFile({ cause, path: zedPath })));
   })
 };
 
 // src/helpers/packages/sherif.ts
 var sherif = {
   name: "sherif",
-  version: "1.9.0"
+  version: "1.10.0"
 };
 
 // src/helpers/packages/typescript.ts
-import { FileSystem as FileSystem7, Path as Path7 } from "@effect/platform";
-import { Effect as Effect14 } from "effect";
+import { FileSystem as FileSystem8, Path as Path8 } from "@effect/platform";
+import { Effect as Effect13 } from "effect";
 var CONFIG_FILE2 = "tsconfig.json";
 var typescript = {
-  command: "tsgo",
+  command: "tsc",
   config: { extends: "adamantite/typescript" },
-  create: () => Effect14.gen(function* () {
-    const fs = yield* FileSystem7.FileSystem;
-    const path = yield* Path7.Path;
+  create: () => Effect13.gen(function* () {
+    const fs = yield* FileSystem8.FileSystem;
+    const path = yield* Path8.Path;
     const configPath = path.join(process.cwd(), CONFIG_FILE2);
     const payload = JSON.stringify(typescript.config, null, 2);
     yield* fs.writeFileString(configPath, `${payload}
-`).pipe(Effect14.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
+`).pipe(Effect13.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
   }),
-  exists: () => Effect14.gen(function* () {
-    const fs = yield* FileSystem7.FileSystem;
-    const path = yield* Path7.Path;
+  exists: () => Effect13.gen(function* () {
+    const fs = yield* FileSystem8.FileSystem;
+    const path = yield* Path8.Path;
     return yield* fs.exists(path.join(process.cwd(), CONFIG_FILE2));
   }),
-  name: "@typescript/native-preview",
-  update: () => Effect14.gen(function* () {
-    const fs = yield* FileSystem7.FileSystem;
-    const path = yield* Path7.Path;
+  name: "typescript",
+  update: () => Effect13.gen(function* () {
+    const fs = yield* FileSystem8.FileSystem;
+    const path = yield* Path8.Path;
     const configPath = path.join(process.cwd(), CONFIG_FILE2);
-    const tsconfigFile = yield* fs.readFileString(configPath).pipe(Effect14.mapError((cause) => new FailedToReadFile({ cause, path: configPath })));
+    const tsconfigFile = yield* fs.readFileString(configPath).pipe(Effect13.mapError((cause) => new FailedToReadFile({ cause, path: configPath })));
     const existingConfig = yield* parseJson(tsconfigFile, configPath);
     if (!isJsonObject(existingConfig)) {
-      return yield* Effect14.fail(new InvalidConfigFormat({ path: configPath }));
+      return yield* Effect13.fail(new InvalidConfigFormat({ path: configPath }));
     }
     const newConfig = yield* mergeConfig(typescript.config, existingConfig);
     yield* fs.writeFileString(configPath, `${JSON.stringify(newConfig, null, 2)}
-`).pipe(Effect14.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
+`).pipe(Effect13.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
   }),
-  version: "7.0.0-dev.20260115.1"
+  version: "5.9.3"
 };
 
+// src/services/prompter.ts
+import * as p from "@clack/prompts";
+import { Context as Context2, Effect as Effect14, Layer as Layer2 } from "effect";
+
+class Prompter extends Context2.Tag("Prompter")() {
+}
+var PrompterLive = Layer2.succeed(Prompter, {
+  cancel: (message) => Effect14.sync(() => {
+    p.cancel(message);
+  }),
+  confirm: (options) => Effect14.tryPromise(() => p.confirm(options)).pipe(Effect14.orDie),
+  intro: (message) => Effect14.sync(() => {
+    p.intro(message);
+  }),
+  log: {
+    error: (message) => Effect14.sync(() => {
+      p.log.error(message);
+    }),
+    info: (message) => Effect14.sync(() => {
+      p.log.info(message);
+    }),
+    success: (message) => Effect14.sync(() => {
+      p.log.success(message);
+    }),
+    warning: (message) => Effect14.sync(() => {
+      p.log.warning(message);
+    })
+  },
+  multiselect: (options) => Effect14.tryPromise(() => p.multiselect(options)).pipe(Effect14.orDie),
+  outro: (message) => Effect14.sync(() => {
+    p.outro(message);
+  }),
+  spinner: () => p.spinner()
+});
+
 // src/commands/init.ts
 var installDependencies = (packages) => Effect15.gen(function* () {
   const prompter = yield* Prompter;
@@ -887,8 +938,8 @@ var setupOxfmtConfig = () => Effect15.gen(function* () {
   }
 });
 var addScripts = (scripts) => Effect15.gen(function* () {
-  const fs = yield* FileSystem8.FileSystem;
-  const path = yield* Path8.Path;
+  const fs = yield* FileSystem9.FileSystem;
+  const path = yield* Path9.Path;
   const cwd = yield* Cwd;
   const prompter = yield* Prompter;
   const packageJson = yield* readPackageJson();
@@ -974,18 +1025,32 @@ var setupEditors = (editors) => Effect15.gen(function* () {
       spinner2.stop("`.vscode/settings.json` created with Adamantite preset.");
     }
   }
-  if (editors.includes("zed")) {}
+  if (editors.includes("zed")) {
+    const spinner2 = prompter.spinner();
+    spinner2.start("Checking for `.zed/settings.json`...");
+    const hasZedSettings = yield* zed.exists();
+    if (hasZedSettings) {
+      spinner2.message("`.zed/settings.json` found, updating...");
+      yield* zed.update();
+      spinner2.stop("`.zed/settings.json` updated with Adamantite preset.");
+    } else {
+      spinner2.message("`.zed/settings.json` not found, creating...");
+      yield* zed.create();
+      spinner2.stop("`.zed/settings.json` created with Adamantite preset.");
+    }
+  }
 });
 var installEditorExtensions = (editors, scripts) => Effect15.gen(function* () {
   const prompter = yield* Prompter;
   const spinner2 = prompter.spinner();
   spinner2.start("Installing editor extensions...");
+  const hasZed = editors.includes("zed");
+  const hasVscode = editors.includes("vscode");
   const result = yield* Effect15.gen(function* () {
     if (editors.includes("vscode")) {
       spinner2.message("Installing VS Code extension...");
       yield* vscode.extension(scripts);
     }
-    if (editors.includes("zed")) {}
     return true;
   }).pipe(Effect15.tapError(() => Effect15.sync(() => {
     spinner2.stop();
@@ -1005,7 +1070,14 @@ var installEditorExtensions = (editors, scripts) => Effect15.gen(function* () {
     })
   }));
   if (result) {
-    spinner2.stop("Editor extensions installed successfully.");
+    if (hasZed && !hasVscode) {
+      spinner2.stop("Zed extensions require manual install.");
+    } else {
+      spinner2.stop("Editor extensions installed successfully.");
+    }
+  }
+  if (hasZed) {
+    yield* prompter.log.info("Install the Zed `oxc` extension: zed://extension/oxc");
   }
 });
 var setupGitHubActions = (packageManager, scripts) => Effect15.gen(function* () {
@@ -1024,11 +1096,22 @@ var setupGitHubActions = (packageManager, scripts) => Effect15.gen(function* ()
   }
 }).pipe(Effect15.option);
 var init_default = Command5.make("init").pipe(Command5.withDescription("Initialize Adamantite in the current directory"), Command5.withHandler(() => Effect15.gen(function* () {
-  const pm = yield* PackageManager;
   const prompter = yield* Prompter;
   yield* printTitle();
   yield* prompter.intro("\uD83D\uDCA0 adamantite init");
-  yield* prompter.log.info(`Detected package manager: ${pm.name}`);
+  const packageManager = yield* Effect15.tryPromise({
+    catch: (cause) => new NoPackageManager({ cause }),
+    try: () => detectPackageManager(process4.cwd())
+  });
+  if (!packageManager) {
+    return yield* Effect15.fail(new NoPackageManager({}));
+  }
+  if (packageManager.warnings?.length) {
+    for (const warning of packageManager.warnings) {
+      yield* prompter.log.warning(warning);
+    }
+  }
+  yield* prompter.log.info(`Detected package manager: ${packageManager.name}`);
   const isMonorepo = yield* checkIsMonorepo();
   if (isMonorepo) {
     yield* prompter.log.info("We've detected a monorepo setup in your project.");
@@ -1053,7 +1136,7 @@ var init_default = Command5.make("init").pipe(Command5.withDescription("Initiali
       },
       {
         hint: "extends the `adamantite/typescript` preset in your `tsconfig.json`",
-        label: "typecheck - type-check your code using tsgo",
+        label: "typecheck - type-check your code using tsc",
         value: "typecheck"
       },
       {
@@ -1101,7 +1184,7 @@ var init_default = Command5.make("init").pipe(Command5.withDescription("Initiali
     message: "Which editors do you want to configure? (optional)",
     options: [
       { label: "VSCode / Cursor / Windsurf", value: "vscode" },
-      { disabled: true, hint: "coming soon", label: "Zed", value: "zed" }
+      { label: "Zed", value: "zed" }
     ],
     required: false
   });
@@ -1170,7 +1253,7 @@ var init_default = Command5.make("init").pipe(Command5.withDescription("Initiali
     yield* installEditorExtensions(selectedEditors, selectedScripts);
   }
   if (enableGitHubActions) {
-    yield* setupGitHubActions(pm.name, selectedScripts);
+    yield* setupGitHubActions(packageManager.name, selectedScripts);
   }
   yield* prompter.log.success("Your project is now configured");
   yield* prompter.outro("\uD83D\uDCA0 Adamantite initialized successfully!");
@@ -1187,13 +1270,11 @@ import { Command as ShellCommand7 } from "@effect/platform";
 import { Effect as Effect16 } from "effect";
 var fix2 = Options4.boolean("fix").pipe(Options4.withDescription("Automatically fix issues"));
 var monorepo_default = Command6.make("monorepo", { fix: fix2 }).pipe(Command6.withDescription("Find and fix monorepo-specific issues using Sherif"), Command6.withHandler(({ fix: fix3 }) => Effect16.gen(function* () {
-  const pm = yield* PackageManager;
-  const [command, ...commandArgs] = pm.command;
   const args = [];
   if (fix3) {
     args.push("--fix");
   }
-  return yield* ShellCommand7.make(command, ...commandArgs, sherif.name, ...args).pipe(ShellCommand7.stdin("inherit"), ShellCommand7.stdout("inherit"), ShellCommand7.stderr("inherit"), ShellCommand7.exitCode);
+  return yield* ShellCommand7.make(sherif.name, ...args).pipe(ShellCommand7.stdin("inherit"), ShellCommand7.stdout("inherit"), ShellCommand7.stderr("inherit"), ShellCommand7.exitCode);
 })));
 
 // src/commands/typecheck.ts
@@ -1203,8 +1284,8 @@ import { Effect as Effect17, Option as Option4 } from "effect";
 var project = Options5.file("project").pipe(Options5.withAlias("p"), Options5.optional, Options5.withDescription("Path to tsconfig.json file"));
 var watch = Options5.boolean("watch").pipe(Options5.withAlias("w"), Options5.withDescription("Run in watch mode"));
 var typecheck_default = Command7.make("typecheck", { project, watch }).pipe(Command7.withDescription("Run TypeScript type checking"), Command7.withHandler(({ project: project2, watch: watch2 }) => Effect17.gen(function* () {
-  const pm = yield* PackageManager;
-  const [command, ...commandArgs] = pm.command;
+  const cwd = yield* Cwd;
+  const currentDir = yield* cwd.get;
   const args = ["--noEmit"];
   if (Option4.isSome(project2)) {
     args.push("--project", project2.value);
@@ -1212,7 +1293,7 @@ var typecheck_default = Command7.make("typecheck", { project, watch }).pipe(Comm
   if (watch2) {
     args.push("--watch");
   }
-  return yield* ShellCommand8.make(command, ...commandArgs, typescript.command, ...args).pipe(ShellCommand8.stdout("inherit"), ShellCommand8.stderr("inherit"), ShellCommand8.exitCode);
+  return yield* ShellCommand8.make(typescript.command, ...args).pipe(ShellCommand8.workingDirectory(currentDir), ShellCommand8.stdout("inherit"), ShellCommand8.stderr("inherit"), ShellCommand8.exitCode);
 })));
 
 // src/commands/update.ts
@@ -1291,6 +1372,6 @@ var update_default = Command8.make("update").pipe(Command8.withDescription("Upda
 
 // src/index.ts
 var main = Command9.make("adamantite").pipe(Command9.withDescription("Opinionated preset package for modern TypeScript applications"), Command9.withSubcommands([analyze_default, check_default, fix_default, format_default2, init_default, monorepo_default, typecheck_default, update_default]));
-var version = await "0.27.3";
+var version = await "0.28.0";
 var program = Command9.run(main, { name: "adamantite", version });
-program(process5.argv).pipe(Effect19.provide(Layer4.mergeAll(NodeContext.layer, PackageManagerLive, PrompterLive, CwdLive)), NodeRuntime.runMain);
+program(process5.argv).pipe(Effect19.provide(Layer3.mergeAll(NodeContext.layer, PrompterLive, CwdLive)), NodeRuntime.runMain);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adamantite",
-  "version": "0.27.3",
+  "version": "0.28.0",
   "description": "An strict and opinionated set of presets for modern TypeScript applications",
   "keywords": [
     "adamantite",
@@ -9,7 +9,6 @@
     "oxfmt",
     "oxlint",
     "preset",
-    "tsgo",
     "typescript"
   ],
   "homepage": "https://github.com/adelrodriguez/adamantite",
@@ -61,24 +60,23 @@
   },
   "dependencies": {
     "@clack/prompts": "1.0.0-alpha.9",
-    "@effect/cli": "0.73.0",
-    "@effect/platform": "0.94.1",
-    "@effect/platform-node": "0.104.0",
+    "@effect/cli": "0.73.1",
+    "@effect/platform": "0.94.2",
+    "@effect/platform-node": "0.104.1",
     "defu": "6.1.4",
-    "effect": "3.19.14",
+    "effect": "3.19.15",
     "jsonc-parser": "3.3.1",
-    "nypm": "0.6.2"
+    "nypm": "0.6.4"
   },
   "devDependencies": {
     "@changesets/cli": "2.29.8",
     "@types/bun": "1.3.6",
-    "@typescript/native-preview": "7.0.0-dev.20260115.1",
     "bunup": "0.16.20",
-    "knip": "5.81.0",
-    "oxfmt": "0.24.0",
-    "oxlint": "1.39.0",
+    "knip": "5.82.1",
+    "oxfmt": "0.26.0",
+    "oxlint": "1.41.0",
     "oxlint-tsgolint": "0.11.1",
-    "sherif": "1.9.0",
+    "sherif": "1.10.0",
     "type-fest": "5.4.1",
     "typescript": "5.9.3"
   },