adamantite 0.25.0 → 0.26.0

package/dist/index.js

@@ -1,19 +1,65 @@
 // src/index.ts
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
+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";
 
 // src/commands/analyze.ts
-import process3 from "node:process";
-import { log } from "@clack/prompts";
-import { Fault as Fault3 } from "faultier";
-import { ok as ok3, safeTry as safeTry3 } from "neverthrow";
-import { dlxCommand } from "nypm";
+import { Command, Options } from "@effect/cli";
+import { Command as ShellCommand2 } from "@effect/platform";
+import { Effect as Effect6 } from "effect";
 
 // src/helpers/packages/knip.ts
-import { readFile as readFile2, writeFile } from "node:fs/promises";
-import { join as join2 } from "node:path";
-import { Fault as Fault2 } from "faultier";
-import { err as err2, fromPromise as fromPromise2, ok as ok2, safeTry as safeTry2 } from "neverthrow";
+import { FileSystem as FileSystem2, Path as Path2 } from "@effect/platform";
+import { Effect as Effect3 } from "effect";
+
+// src/errors.ts
+import { Data } from "effect";
+
+class CliNotFound extends Data.TaggedError("CliNotFound") {
+}
+
+class FailedToCreateDirectory extends Data.TaggedError("FailedToCreateDirectory") {
+}
+
+class FailedToInstallDependency extends Data.TaggedError("FailedToInstallDependency") {
+}
+
+class FailedToInstallExtension extends Data.TaggedError("FailedToInstallExtension") {
+}
+
+class FailedToMergeConfig extends Data.TaggedError("FailedToMergeConfig") {
+}
+
+class FailedToParseFile extends Data.TaggedError("FailedToParseFile") {
+}
+
+class FailedToReadFile extends Data.TaggedError("FailedToReadFile") {
+}
+
+class FailedToWriteFile extends Data.TaggedError("FailedToWriteFile") {
+}
+
+class FileNotFound extends Data.TaggedError("FileNotFound") {
+}
+
+class InvalidConfigFormat extends Data.TaggedError("InvalidConfigFormat") {
+}
+
+class NoPackageManager extends Data.TaggedError("NoPackageManager") {
+}
+
+class MissingPackageVersion extends Data.TaggedError("MissingPackageVersion") {
+}
+
+class OperationCancelled extends Data.TaggedError("OperationCancelled") {
+}
+
+class UnknownScript extends Data.TaggedError("UnknownScript") {
+}
+
+class VscodeCliNotFound extends Data.TaggedError("VscodeCliNotFound") {
+}
 // presets/knip.json
 var knip_default = {
   $schema: "https://unpkg.com/knip@5/schema.json",
@@ -46,64 +92,69 @@ var knip_default = {
 };
 
 // src/utils.ts
-import { spawnSync } from "node:child_process";
-import { access, readFile } from "node:fs/promises";
-import { join } from "node:path";
-import process2 from "node:process";
+import process3 from "node:process";
+import { Command as ShellCommand, FileSystem, Path, Terminal } from "@effect/platform";
 import { defu } from "defu";
-import { Fault } from "faultier";
+import { Console, Effect as Effect2 } from "effect";
 import { parse } from "jsonc-parser";
-import { err, fromPromise, fromThrowable, ok, safeTry } from "neverthrow";
-import { detectPackageManager } from "nypm";
-function defineCommand(input) {
-  return input;
+
+// src/services/cwd.ts
+import process2 from "node:process";
+import { Context, Effect, Layer } from "effect";
+
+class Cwd extends Context.Tag("Cwd")() {
 }
-var runCommand = (command) => {
-  const result = spawnSync(command, {
-    maxBuffer: 100 * 1024 * 1024,
-    shell: true,
-    stdio: "inherit"
-  });
-  if (result.error || result.status !== 0) {
-    const message = result.error?.message ?? "An unknown error occurred while running the command";
-    return err(Fault.wrap(result.error ?? new Error(message)).withTag("FAILED_TO_RUN_COMMAND").withDebug(`Failed to run command: ${message}`));
-  }
-  return ok(result);
-};
-var getPackageManagerName = () => fromPromise(detectPackageManager(process2.cwd()), () => "Failed to detect package manager").andThen((result) => result ? ok(result.name) : err("Failed to resolve package manager")).mapErr((message) => Fault.create("NO_PACKAGE_MANAGER").withDescription(message, "We're unable to detect the package manager used in this project. Please ensure you have a package.json file in the current directory."));
-var checkIfExists = (path) => fromPromise(access(path), () => new Error("File not found")).match(() => true, () => false);
+var CwdLive = Layer.succeed(Cwd, {
+  get: Effect.sync(() => process2.cwd())
+});
+
+// src/utils.ts
 var checkCliExists = (command) => {
-  const result = spawnSync(process2.platform === "win32" ? "where" : "which", [command], {
-    stdio: "pipe"
-  });
-  if (result.status !== 0) {
-    return err(Fault.create("CLI_NOT_FOUND").withDescription(`CLI '${command}' not found`, `The '${command}' command is not available in your PATH.`).withContext({ command }));
-  }
-  return ok(true);
+  const executable = process3.platform === "win32" ? "where" : "which";
+  return ShellCommand.make(executable, command).pipe(ShellCommand.exitCode, Effect2.flatMap((exitCode) => exitCode === 0 ? Effect2.succeed(true) : Effect2.fail(new CliNotFound({ command }))));
 };
-var parseJson = (content) => {
+var parseJson = (content, path) => Effect2.sync(() => {
   const errors = [];
   const parsed = parse(content, errors);
-  if (errors.length > 0) {
-    return err(Fault.create("FAILED_TO_PARSE_FILE").withDescription("Failed to parse JSON", "We're unable to parse the provided JSON file.").withContext({ errors }));
-  }
-  return ok(parsed);
-};
+  return { errors, parsed };
+}).pipe(Effect2.flatMap(({ errors, parsed }) => errors.length > 0 ? Effect2.fail(new FailedToParseFile({ errors, path })) : Effect2.succeed(parsed)));
 var isJsonObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var WORKSPACE_PREFIX_REGEX = /^workspace:/;
 var RANGE_PREFIX_REGEX = /^[\^~]/;
 var normalizeDependencyVersion = (specifier) => specifier.trim().replace(WORKSPACE_PREFIX_REGEX, "").replace(RANGE_PREFIX_REGEX, "");
-var mergeConfig = fromThrowable(defu, (error) => Fault.wrap(error).withTag("FAILED_TO_MERGE_CONFIG").withDescription("Failed to merge configuration", "We're unable to merge the configuration files."));
-var readPackageJson = (cwd = process2.cwd()) => fromPromise(readFile(join(cwd, "package.json"), "utf8"), (error) => Fault.wrap(error).withTag("FAILED_TO_READ_FILE").withDescription("Failed to read package.json", "We're unable to read the package.json file in the current directory.").withContext({ path: join(cwd, "package.json") })).andThen((content) => parseJson(content)).andThen((parsed) => ok(parsed));
-var checkIsMonorepo = () => safeTry(async function* () {
-  const pnpmWorkspace = await checkIfExists(join(process2.cwd(), "pnpm-workspace.yaml"));
+var mergeConfig = (base, override) => Effect2.try({
+  catch: (cause) => new FailedToMergeConfig({ cause }),
+  try: () => defu(base, override)
+});
+var readPackageJson = (cwd) => Effect2.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const cwdService = yield* Cwd;
+  const workingDir = cwd ?? (yield* cwdService.get);
+  const packagePath = path.join(workingDir, "package.json");
+  const content = yield* fs.readFileString(packagePath).pipe(Effect2.mapError((cause) => new FailedToReadFile({ cause, path: packagePath })));
+  const parsed = yield* parseJson(content, packagePath);
+  return parsed;
+});
+var checkIsMonorepo = () => Effect2.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const cwd = yield* Cwd;
+  const currentDir = yield* cwd.get;
+  const pnpmWorkspace = yield* fs.exists(path.join(currentDir, "pnpm-workspace.yaml"));
   if (pnpmWorkspace) {
-    return ok(true);
+    return true;
   }
   const packageJson = yield* readPackageJson();
-  return ok(packageJson?.workspaces !== undefined);
+  return packageJson?.workspaces !== undefined;
+});
+var ensureDirectory = (path) => Effect2.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  yield* fs.makeDirectory(path, { recursive: true }).pipe(Effect2.mapError((cause) => new FailedToCreateDirectory({ cause, path })));
 });
-function printTitle() {
+var printTitle = () => Effect2.gen(function* () {
+  const terminal = yield* Terminal.Terminal;
+  const terminalColumns = yield* terminal.columns;
   const title = `
                 .o8                                                        .    o8o      .            
                "888                                                      .o8    \`"'    .o8            
@@ -111,127 +162,202 @@ function printTitle() {
 \`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
-\`Y888""8o \`Y8bod88P" \`Y888""8o o888o o888o o888o \`Y888""8o o888o o888o   "888" o888o   "888" \`Y8bod8P'                                                     
-    `;
+\`Y888""8o \`Y8bod88P" \`Y888""8o o888o o888o o888o \`Y888""8o o888o o888o   "888" o888o   "888" \`Y8bod8P'
+`;
   const columns = title.split(`
 `).reduce((max, line) => Math.max(max, line.trim().length), 0);
-  if (process2.stdout.columns && process2.stdout.columns >= columns) {
-    console.info(title);
+  if (!terminalColumns || terminalColumns < columns) {
+    return;
   }
-}
+  yield* Console.info(title);
+});
+var getPackageVersion = () => readPackageJson().pipe(Effect2.flatMap((packageJson) => packageJson.version ? Effect2.succeed(packageJson.version) : Effect2.fail(new MissingPackageVersion({ path: "package.json" }))));
 
 // src/helpers/packages/knip.ts
+var CONFIG_FILE_JSON = "knip.json";
+var CONFIG_FILE_JSONC = "knip.jsonc";
 var knip = {
   config: knip_default,
-  create: () => fromPromise2(writeFile(join2(process.cwd(), "knip.json"), JSON.stringify(knip.config, null, 2)), (error) => Fault2.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write knip configuration", "We're unable to write the knip configuration to the current directory.")),
-  exists: async () => {
-    if (await checkIfExists(join2(process.cwd(), "knip.json"))) {
-      return { path: join2(process.cwd(), "knip.json") };
+  create: () => Effect3.gen(function* () {
+    const fs = yield* FileSystem2.FileSystem;
+    const path = yield* Path2.Path;
+    const configPath = path.join(process.cwd(), CONFIG_FILE_JSON);
+    const payload = JSON.stringify(knip.config, null, 2);
+    yield* fs.writeFileString(configPath, `${payload}
+`).pipe(Effect3.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
+  }),
+  exists: () => Effect3.gen(function* () {
+    const fs = yield* FileSystem2.FileSystem;
+    const path = yield* Path2.Path;
+    const jsonPath = path.join(process.cwd(), CONFIG_FILE_JSON);
+    const jsoncPath = path.join(process.cwd(), CONFIG_FILE_JSONC);
+    if (yield* fs.exists(jsonPath)) {
+      return { path: jsonPath };
     }
-    if (await checkIfExists(join2(process.cwd(), "knip.jsonc"))) {
-      return { path: join2(process.cwd(), "knip.jsonc") };
+    if (yield* fs.exists(jsoncPath)) {
+      return { path: jsoncPath };
     }
     return { path: null };
-  },
+  }),
   name: "knip",
-  update: () => safeTry2(async function* () {
-    const exists = await knip.exists();
-    if (!exists.path) {
-      return err2(Fault2.create("FILE_NOT_FOUND").withDescription("No `knip.json` or `knip.jsonc` found", "We're unable to find a knip configuration in the current directory."));
-    }
-    const knipFile = yield* fromPromise2(readFile2(exists.path, "utf8"), (error) => Fault2.wrap(error).withTag("FAILED_TO_READ_FILE").withDescription("Failed to read knip configuration", "We're unable to read the knip configuration from the current directory."));
-    const existingConfig = yield* parseJson(knipFile);
+  update: () => Effect3.gen(function* () {
+    const fs = yield* FileSystem2.FileSystem;
+    const { path: configPath } = yield* knip.exists();
+    if (!configPath) {
+      return yield* Effect3.fail(new FileNotFound({ path: CONFIG_FILE_JSON }));
+    }
+    const knipFile = yield* fs.readFileString(configPath).pipe(Effect3.mapError((cause) => new FailedToReadFile({ cause, path: configPath })));
+    const existingConfig = yield* parseJson(knipFile, configPath);
     if (!isJsonObject(existingConfig)) {
-      return err2(Fault2.create("INVALID_CONFIG_FORMAT").withDescription("Invalid knip configuration format", "The knip configuration must be a JSON object."));
+      return yield* Effect3.fail(new InvalidConfigFormat({ path: configPath }));
     }
     const mergedConfig = yield* mergeConfig(existingConfig, knip.config);
-    const isJsonc = exists.path.endsWith(".jsonc");
+    const isJsonc = configPath.endsWith(".jsonc");
     mergedConfig.$schema = isJsonc ? "https://unpkg.com/knip@5/schema-jsonc.json" : "https://unpkg.com/knip@5/schema.json";
-    yield* fromPromise2(writeFile(exists.path, JSON.stringify(mergedConfig, null, 2)), (error) => Fault2.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write knip configuration", "We're unable to write the knip configuration to the current directory.").withContext({ path: exists.path }));
-    return ok2();
+    yield* fs.writeFileString(configPath, `${JSON.stringify(mergedConfig, null, 2)}
+`).pipe(Effect3.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
   }),
   version: "5.80.1"
 };
 
-// src/commands/analyze.ts
-var analyze_default = defineCommand({
-  builder: (yargs) => yargs.positional("files", {
-    array: true,
-    describe: "Specific files to analyze (optional)",
-    type: "string"
-  }).option("fix", {
-    description: "Automatically fix issues",
-    type: "boolean"
-  }).option("strict", {
-    description: "Enable strict mode",
-    type: "boolean"
+// 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);
   }),
-  command: "analyze [files..]",
-  describe: "Find unused dependencies, exports, and files using knip",
-  handler: (argv) => safeTry3(async function* () {
-    const packageManager = yield* getPackageManagerName();
-    const args = [];
-    if (argv.fix) {
-      args.push("--fix", "--allow-remove-files");
-    }
-    if (argv.strict) {
-      args.push("--production", "--strict");
-    }
-    if (argv.files && argv.files.length > 0) {
-      args.push(...argv.files);
-    }
-    const command = dlxCommand(packageManager, knip.name, { args });
-    yield* runCommand(command);
-    return ok3();
-  }).match(() => {
-    process3.exit(0);
-  }, (error) => {
-    if (Fault3.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
-      log.error(error.flatten());
-    }
-    process3.exit(1);
-  })
+  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 && result.warnings.length > 0) {
+    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;
+  const args = [];
+  if (fix2) {
+    args.push("--fix", "--allow-remove-files");
+  }
+  if (strict2) {
+    args.push("--production", "--strict");
+  }
+  return yield* ShellCommand2.make(command, ...commandArgs, knip.name, ...args).pipe(ShellCommand2.stdout("inherit"), ShellCommand2.stderr("inherit"), ShellCommand2.exitCode);
+})));
+
 // src/commands/check.ts
-import process4 from "node:process";
-import { log as log2 } from "@clack/prompts";
-import { Fault as Fault5 } from "faultier";
-import { ok as ok5, safeTry as safeTry5 } from "neverthrow";
-import { dlxCommand as dlxCommand2 } from "nypm";
+import { Args, Command as Command2 } from "@effect/cli";
+import { Command as ShellCommand3 } from "@effect/platform";
+import { Effect as Effect8, Option } from "effect";
 
 // src/helpers/packages/oxlint.ts
-import { readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join3 } from "node:path";
-import { Fault as Fault4 } from "faultier";
-import { err as err3, fromPromise as fromPromise3, ok as ok4, safeTry as safeTry4 } from "neverthrow";
+import { FileSystem as FileSystem3, Path as Path3 } from "@effect/platform";
+import { Effect as Effect7 } from "effect";
+var CONFIG_FILE = ".oxlintrc.json";
 var oxlint = {
   config: {
     $schema: "./node_modules/oxlint/configuration_schema.json"
   },
-  create: (presets = []) => {
+  create: (presets = []) => Effect7.gen(function* () {
+    const fs = yield* FileSystem3.FileSystem;
+    const path = yield* Path3.Path;
     const extendsArray = ["./node_modules/adamantite/presets/lint/core.json"];
     for (const preset of presets) {
       extendsArray.push(`./node_modules/adamantite/presets/lint/${preset}.json`);
     }
-    return fromPromise3(writeFile2(join3(process.cwd(), ".oxlintrc.json"), JSON.stringify({ ...oxlint.config, extends: extendsArray }, null, 2)), (error) => Fault4.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write oxlint configuration", "We're unable to write the oxlint configuration to the current directory."));
-  },
-  exists: async () => {
-    if (await checkIfExists(join3(process.cwd(), ".oxlintrc.json"))) {
-      return { path: join3(process.cwd(), ".oxlintrc.json") };
-    }
-    return { path: null };
-  },
+    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 })));
+  }),
+  exists: () => Effect7.gen(function* () {
+    const fs = yield* FileSystem3.FileSystem;
+    const path = yield* Path3.Path;
+    const configPath = path.join(process.cwd(), CONFIG_FILE);
+    const exists = yield* fs.exists(configPath);
+    return { path: exists ? configPath : null };
+  }),
   name: "oxlint",
-  update: (presets = []) => safeTry4(async function* () {
-    const exists = await oxlint.exists();
-    if (!exists.path) {
-      return err3(Fault4.create("FILE_NOT_FOUND").withDescription("No `.oxlintrc.json` found", "We're unable to find an oxlint configuration in the current directory."));
-    }
-    const oxlintFile = yield* fromPromise3(readFile3(exists.path, "utf8"), (error) => Fault4.wrap(error).withTag("FAILED_TO_READ_FILE").withDescription("Failed to read oxlint configuration", "We're unable to read the oxlint configuration from the current directory."));
-    const existingConfig = yield* parseJson(oxlintFile);
+  update: (presets = []) => Effect7.gen(function* () {
+    const fs = yield* FileSystem3.FileSystem;
+    const { path: configPath } = yield* oxlint.exists();
+    if (!configPath) {
+      return yield* Effect7.fail(new FileNotFound({ path: CONFIG_FILE }));
+    }
+    const oxlintFile = yield* fs.readFileString(configPath).pipe(Effect7.mapError((cause) => new FailedToReadFile({ cause, path: configPath })));
+    const existingConfig = yield* parseJson(oxlintFile, configPath);
     if (!isJsonObject(existingConfig)) {
-      return err3(Fault4.create("INVALID_CONFIG_FORMAT").withDescription("Invalid oxlint configuration format", "The oxlint configuration must be a JSON object."));
+      return yield* Effect7.fail(new InvalidConfigFormat({ path: configPath }));
     }
     const newConfig = { ...existingConfig };
     const extendsArray = Array.isArray(newConfig.extends) ? newConfig.extends : typeof newConfig.extends === "string" ? [newConfig.extends] : [];
@@ -248,8 +374,8 @@ var oxlint = {
     newConfig.extends = extendsArray;
     const mergedConfig = yield* mergeConfig(newConfig, oxlint.config);
     mergedConfig.$schema = oxlint.config.$schema;
-    yield* fromPromise3(writeFile2(exists.path, JSON.stringify(mergedConfig, null, 2)), (error) => Fault4.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write oxlint configuration", "We're unable to write the oxlint configuration to the current directory.").withContext({ path: exists.path }));
-    return ok4();
+    yield* fs.writeFileString(configPath, `${JSON.stringify(mergedConfig, null, 2)}
+`).pipe(Effect7.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
   }),
   version: "1.38.0"
 };
@@ -259,102 +385,51 @@ var tsgolint = {
 };
 
 // src/commands/check.ts
-var check_default = defineCommand({
-  builder: (yargs) => yargs.positional("files", {
-    array: true,
-    describe: "Specific files to lint (optional)",
-    type: "string"
-  }),
-  command: "check [files..]",
-  describe: "Find issues in code using oxlint",
-  handler: (argv) => safeTry5(async function* () {
-    const packageManager = yield* getPackageManagerName();
-    const args = ["--type-aware"];
-    if (argv.files && argv.files.length > 0) {
-      args.push(...argv.files);
-    }
-    const command = dlxCommand2(packageManager, oxlint.name, { args });
-    const result = yield* runCommand(command);
-    return ok5(result);
-  }).match(() => {
-    process4.exit(0);
-  }, (error) => {
-    if (Fault5.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
-      log2.error(error.flatten());
-    }
-    process4.exit(1);
-  })
-});
+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;
+  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);
+})));
 
 // src/commands/fix.ts
-import process5 from "node:process";
-import { log as log3 } from "@clack/prompts";
-import { Fault as Fault6 } from "faultier";
-import { ok as ok6, safeTry as safeTry6 } from "neverthrow";
-import { dlxCommand as dlxCommand3 } from "nypm";
-var fix_default = defineCommand({
-  builder: (yargs) => yargs.positional("files", {
-    array: true,
-    describe: "Specific files to fix (optional)",
-    type: "string"
-  }).option("suggested", {
-    default: false,
-    description: "Apply suggested fixes",
-    type: "boolean"
-  }).option("dangerous", {
-    default: false,
-    description: "Apply dangerous fixes",
-    type: "boolean"
-  }).option("all", {
-    default: false,
-    description: "Apply all fixes, including suggested and dangerous fixes",
-    type: "boolean"
-  }),
-  command: "fix [files..]",
-  describe: "Fix issues in code using oxlint",
-  handler: (argv) => safeTry6(async function* () {
-    const packageManager = yield* getPackageManagerName();
-    const args = new Set(["--type-aware", "--fix"]);
-    if (argv.suggested) {
-      args.add("--fix-suggestions");
-    }
-    if (argv.dangerous) {
-      args.add("--fix-dangerously");
-    }
-    if (argv.all) {
-      args.add("--fix-suggestions");
-      args.add("--fix-dangerously");
-    }
-    if (argv.files && argv.files.length > 0) {
-      for (const file of argv.files) {
-        args.add(file);
-      }
-    }
-    const command = dlxCommand3(packageManager, oxlint.name, { args: Array.from(args) });
-    yield* runCommand(command);
-    return ok6();
-  }).match(() => {
-    process5.exit(0);
-  }, (error) => {
-    if (Fault6.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
-      log3.error(error.flatten());
+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";
+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;
+  const args = new Set(["--type-aware", "--fix"]);
+  if (suggested2 || all2) {
+    args.add("--fix-suggestions");
+  }
+  if (dangerous2 || all2) {
+    args.add("--fix-dangerously");
+  }
+  if (Option2.isSome(files3)) {
+    for (const file of files3.value) {
+      args.add(file);
     }
-    process5.exit(1);
-  })
-});
+  }
+  return yield* ShellCommand4.make(command, ...commandArgs, oxlint.name, ...args).pipe(ShellCommand4.stdout("inherit"), ShellCommand4.stderr("inherit"), ShellCommand4.exitCode);
+})));
 
 // src/commands/format.ts
-import process6 from "node:process";
-import { log as log4 } from "@clack/prompts";
-import { Fault as Fault8 } from "faultier";
-import { ok as ok8, safeTry as safeTry8 } from "neverthrow";
-import { dlxCommand as dlxCommand4 } from "nypm";
+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";
 
 // src/helpers/packages/oxfmt.ts
-import { readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join4 } from "node:path";
-import { Fault as Fault7 } from "faultier";
-import { err as err4, fromPromise as fromPromise4, ok as ok7, safeTry as safeTry7 } from "neverthrow";
+import { FileSystem as FileSystem4, Path as Path4 } from "@effect/platform";
+import { Effect as Effect10 } from "effect";
 // presets/format.json
 var format_default = {
   $schema: "../node_modules/oxfmt/configuration_schema.json",
@@ -402,89 +477,80 @@ var format_default = {
 };
 
 // src/helpers/packages/oxfmt.ts
+var CONFIG_FILE_JSONC2 = ".oxfmtrc.jsonc";
+var CONFIG_FILE_JSON2 = ".oxfmtrc.json";
 var oxfmt = {
   config: {
     ...format_default,
     $schema: "./node_modules/oxfmt/configuration_schema.json"
   },
-  create: () => fromPromise4(writeFile3(join4(process.cwd(), ".oxfmtrc.jsonc"), JSON.stringify(oxfmt.config, null, 2)), (error) => Fault7.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write oxfmt configuration", "We're unable to write the oxfmt configuration to the current directory.")),
-  exists: async () => {
-    if (await checkIfExists(join4(process.cwd(), ".oxfmtrc.jsonc"))) {
-      return { path: join4(process.cwd(), ".oxfmtrc.jsonc") };
+  create: () => Effect10.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 })));
+  }),
+  exists: () => Effect10.gen(function* () {
+    const fs = yield* FileSystem4.FileSystem;
+    const path = yield* Path4.Path;
+    const jsoncPath = path.join(process.cwd(), CONFIG_FILE_JSONC2);
+    const jsonPath = path.join(process.cwd(), CONFIG_FILE_JSON2);
+    if (yield* fs.exists(jsoncPath)) {
+      return { path: jsoncPath };
     }
-    if (await checkIfExists(join4(process.cwd(), ".oxfmtrc.json"))) {
-      return { path: join4(process.cwd(), ".oxfmtrc.json") };
+    if (yield* fs.exists(jsonPath)) {
+      return { path: jsonPath };
     }
     return { path: null };
-  },
+  }),
   name: "oxfmt",
-  update: () => safeTry7(async function* () {
-    const exists = await oxfmt.exists();
-    if (!exists.path) {
-      return err4(Fault7.create("FILE_NOT_FOUND").withDescription("No `.oxfmtrc.jsonc` or `.oxfmtrc.json` found", "We're unable to find an oxfmt configuration in the current directory."));
-    }
-    const oxfmtFile = yield* fromPromise4(readFile4(exists.path, "utf8"), (error) => Fault7.wrap(error).withTag("FAILED_TO_READ_FILE").withDescription("Failed to read oxfmt configuration", "We're unable to read the oxfmt configuration from the current directory."));
-    const existingConfig = yield* parseJson(oxfmtFile);
+  update: () => Effect10.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 }));
+    }
+    const oxfmtFile = yield* fs.readFileString(configPath).pipe(Effect10.mapError((cause) => new FailedToReadFile({ cause, path: configPath })));
+    const existingConfig = yield* parseJson(oxfmtFile, configPath);
     if (!isJsonObject(existingConfig)) {
-      return err4(Fault7.create("INVALID_CONFIG_FORMAT").withDescription("Invalid oxfmt configuration format", "The oxfmt configuration must be a JSON object."));
+      return yield* Effect10.fail(new InvalidConfigFormat({ path: configPath }));
     }
     const mergedConfig = yield* mergeConfig(existingConfig, oxfmt.config);
     mergedConfig.$schema = oxfmt.config.$schema;
-    yield* fromPromise4(writeFile3(exists.path, JSON.stringify(mergedConfig, null, 2)), (error) => Fault7.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write oxfmt configuration", "We're unable to write the oxfmt configuration to the current directory.").withContext({ path: exists.path }));
-    return ok7();
+    yield* fs.writeFileString(configPath, `${JSON.stringify(mergedConfig, null, 2)}
+`).pipe(Effect10.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
   }),
   version: "0.23.0"
 };
 
 // src/commands/format.ts
-var format_default2 = defineCommand({
-  builder: (yargs) => yargs.positional("files", {
-    array: true,
-    describe: "Specific files to format (optional)",
-    type: "string"
-  }).option("check", {
-    description: "Check if files are formatted without writing",
-    type: "boolean"
-  }),
-  command: "format [files..]",
-  describe: "Format files using oxfmt",
-  handler: (argv) => safeTry8(async function* () {
-    const packageManager = yield* getPackageManagerName();
-    const args = [];
-    if (argv.check) {
-      args.push("--check");
-    }
-    if (argv.files && argv.files.length > 0) {
-      args.push(...argv.files);
-    }
-    const command = dlxCommand4(packageManager, oxfmt.name, { args });
-    const result = yield* runCommand(command);
-    return ok8(result);
-  }).match(() => {
-    process6.exit(0);
-  }, (error) => {
-    if (Fault8.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
-      log4.error(error.flatten());
-    }
-    process6.exit(1);
-  })
-});
+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;
+  const args = [];
+  if (check2) {
+    args.push("--check");
+  }
+  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);
+})));
 
 // src/commands/init.ts
-import { writeFile as writeFile7 } from "node:fs/promises";
-import { join as join8 } from "node:path";
-import process8 from "node:process";
-import * as p from "@clack/prompts";
-import { Fault as Fault12 } from "faultier";
-import { err as err7, fromPromise as fromPromise8, fromSafePromise, ok as ok12, safeTry as safeTry12 } from "neverthrow";
+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";
 
 // src/helpers/ci/github.ts
-import { mkdir, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join5 } from "node:path";
-import process7 from "node:process";
-import { Fault as Fault9 } from "faultier";
-import { fromPromise as fromPromise5, ok as ok9, safeTry as safeTry9 } from "neverthrow";
+import { FileSystem as FileSystem5, Path as Path5 } from "@effect/platform";
+import { Effect as Effect12 } from "effect";
 import { runScriptCommand } from "nypm";
 var setupSteps = {
   bun: `      - name: Setup Bun
@@ -621,36 +687,42 @@ var CI_COMPATIBLE_SCRIPTS = new Set([
 ]);
 var hasCICompatibleScripts = (scripts) => scripts.some((script) => CI_COMPATIBLE_SCRIPTS.has(script));
 var github = {
-  create: (options) => safeTry9(async function* () {
-    const workflowDir = join5(process7.cwd(), ".github", "workflows");
-    yield* fromPromise5(mkdir(workflowDir, { recursive: true }), (error) => Fault9.wrap(error).withTag("FAILED_TO_CREATE_DIRECTORY").withDescription("Failed to create .github/workflows directory", "We're unable to create the .github/workflows directory in the current directory.").withContext({ path: workflowDir }));
+  create: (options) => Effect12.gen(function* () {
+    const fs = yield* FileSystem5.FileSystem;
+    const path = yield* Path5.Path;
+    const workflowDir = path.join(process.cwd(), ".github", "workflows");
+    yield* ensureDirectory(workflowDir);
     const workflowContent = generateWorkflow(options);
     if (!workflowContent) {
-      return ok9();
+      return;
     }
-    yield* fromPromise5(writeFile4(join5(workflowDir, "adamantite.yml"), workflowContent), (error) => Fault9.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write GitHub Actions workflow", "We're unable to write the GitHub Actions workflow file.").withContext({ path: join5(workflowDir, "adamantite.yml") }));
-    return ok9();
+    const workflowPath = path.join(workflowDir, "adamantite.yml");
+    yield* fs.writeFileString(workflowPath, workflowContent).pipe(Effect12.mapError((cause) => new FailedToWriteFile({ cause, path: workflowPath })));
+  }),
+  exists: () => Effect12.gen(function* () {
+    const fs = yield* FileSystem5.FileSystem;
+    const path = yield* Path5.Path;
+    return yield* fs.exists(path.join(process.cwd(), ".github", "workflows", "adamantite.yml"));
   }),
-  exists: () => checkIfExists(join5(process7.cwd(), ".github", "workflows", "adamantite.yml")),
-  update: (options) => safeTry9(async function* () {
-    const workflowPath = join5(process7.cwd(), ".github", "workflows", "adamantite.yml");
+  update: (options) => Effect12.gen(function* () {
+    const fs = yield* FileSystem5.FileSystem;
+    const path = yield* Path5.Path;
+    const workflowPath = path.join(process.cwd(), ".github", "workflows", "adamantite.yml");
     const workflowContent = generateWorkflow(options);
     if (!workflowContent) {
-      return ok9();
+      return;
     }
-    yield* fromPromise5(writeFile4(workflowPath, workflowContent), (error) => Fault9.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write GitHub Actions workflow", "We're unable to update the GitHub Actions workflow file.").withContext({ path: workflowPath }));
-    return ok9();
+    yield* fs.writeFileString(workflowPath, workflowContent).pipe(Effect12.mapError((cause) => new FailedToWriteFile({ cause, path: workflowPath })));
   }),
   workflowPath: ".github/workflows/adamantite.yml"
 };
 
 // src/helpers/editors/vscode.ts
-import { mkdir as mkdir2, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
-import { join as join6 } from "node:path";
-import { Fault as Fault10 } from "faultier";
-import { err as err5, fromPromise as fromPromise6, ok as ok10, safeTry as safeTry10 } from "neverthrow";
+import { FileSystem as FileSystem6, Path as Path6, Command as ShellCommand6 } from "@effect/platform";
+import { Effect as Effect13 } from "effect";
+var SETTINGS_FILE = "settings.json";
 var vscode = {
-  cliExists: () => checkCliExists("code").mapErr((error) => Fault10.wrap(error).withTag("VSCODE_CLI_NOT_FOUND").withDescription("VS Code CLI not found", "The 'code' CLI command is not available. Please install the VS Code command-line tools by opening VS Code and running 'Shell Command: Install code command in PATH' from the command palette (Cmd+Shift+P).")),
+  cliExists: () => checkCliExists("code").pipe(Effect13.mapError((cause) => new VscodeCliNotFound({ cause }))),
   config: {
     "[css]": {
       "editor.defaultFormatter": "oxc.oxc-vscode"
@@ -685,36 +757,46 @@ var vscode = {
     "oxc.typeAware": true,
     "typescript.tsdk": "node_modules/typescript/lib"
   },
-  create: () => safeTry10(async function* () {
-    const vscodePath = join6(process.cwd(), ".vscode");
-    yield* fromPromise6(mkdir2(vscodePath, { recursive: true }), (error) => Fault10.wrap(error).withTag("FAILED_TO_CREATE_DIRECTORY").withDescription("Failed to create .vscode directory", "We're unable to create the .vscode directory in the current directory.").withContext({ path: vscodePath }));
-    yield* fromPromise6(writeFile5(join6(vscodePath, "settings.json"), JSON.stringify(vscode.config, null, 2)), (error) => Fault10.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write .vscode/settings.json", "We're unable to write the .vscode/settings.json file in the current directory."));
-    return ok10();
+  create: () => Effect13.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.writeFileString(settingsPath, `${JSON.stringify(vscode.config, null, 2)}
+`).pipe(Effect13.mapError((cause) => new FailedToWriteFile({ cause, path: settingsPath })));
+  }),
+  exists: () => Effect13.gen(function* () {
+    const fs = yield* FileSystem6.FileSystem;
+    const path = yield* Path6.Path;
+    return yield* fs.exists(path.join(process.cwd(), ".vscode", SETTINGS_FILE));
   }),
-  exists: () => checkIfExists(join6(process.cwd(), ".vscode", "settings.json")),
-  extension: (scripts = []) => safeTry10(function* () {
+  extension: (scripts = []) => Effect13.gen(function* () {
     yield* vscode.cliExists();
-    if (scripts.includes("check") || scripts.includes("fix") || scripts.includes("format")) {
-      yield* runCommand("code --install-extension oxc.oxc-vscode").mapErr((error) => Fault10.wrap(error).withTag("FAILED_TO_INSTALL_EXTENSION").withDescription("Failed to install VS Code extension", "An error occurred while installing the VS Code extension."));
+    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 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
+    ];
+    const results = yield* Effect13.all(extensions, { mode: "either" });
+    const firstFailure = results.find((r) => r._tag === "Left");
+    if (firstFailure) {
+      yield* Effect13.fail(firstFailure.left);
     }
-    if (scripts.includes("analyze")) {
-      yield* runCommand("code --install-extension webpro.vscode-knip").mapErr((error) => Fault10.wrap(error).withTag("FAILED_TO_INSTALL_EXTENSION").withDescription("Failed to install VS Code extension", "An error occurred while installing the VS Code extension."));
-    }
-    if (scripts.includes("typecheck")) {
-      yield* runCommand("code --install-extension TypeScriptTeam.native-preview").mapErr((error) => Fault10.wrap(error).withTag("FAILED_TO_INSTALL_EXTENSION").withDescription("Failed to install VS Code extension", "An error occurred while installing the VS Code extension."));
-    }
-    return ok10();
   }),
-  update: () => safeTry10(async function* () {
-    const vscodePath = join6(process.cwd(), ".vscode", "settings.json");
-    const vscodeFile = yield* fromPromise6(readFile5(vscodePath, "utf8"), (error) => Fault10.wrap(error).withTag("FAILED_TO_READ_FILE").withDescription("Failed to read .vscode/settings.json", "We're unable to read the .vscode/settings.json file in the current directory.").withContext({ path: vscodePath }));
-    const existingConfig = yield* parseJson(vscodeFile);
+  update: () => Effect13.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 existingConfig = yield* parseJson(vscodeFile, vscodePath);
     if (!isJsonObject(existingConfig)) {
-      return err5(Fault10.create("INVALID_CONFIG_FORMAT").withDescription("Invalid .vscode/settings.json format", "The VS Code settings file must be a JSON object."));
+      return yield* Effect13.fail(new InvalidConfigFormat({ path: vscodePath }));
     }
     const newConfig = yield* mergeConfig(vscode.config, existingConfig);
-    yield* fromPromise6(writeFile5(join6(process.cwd(), ".vscode", "settings.json"), JSON.stringify(newConfig, null, 2)), (error) => Fault10.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write .vscode/settings.json", "We're unable to write the .vscode/settings.json file in the current directory.").withContext({ path: vscodePath }));
-    return ok10();
+    yield* fs.writeFileString(vscodePath, `${JSON.stringify(newConfig, null, 2)}
+`).pipe(Effect13.mapError((cause) => new FailedToWriteFile({ cause, path: vscodePath })));
   })
 };
 
@@ -725,42 +807,61 @@ var sherif = {
 };
 
 // src/helpers/packages/typescript.ts
-import { readFile as readFile6, writeFile as writeFile6 } from "node:fs/promises";
-import { join as join7 } from "node:path";
-import { Fault as Fault11 } from "faultier";
-import { err as err6, fromPromise as fromPromise7, ok as ok11, safeTry as safeTry11 } from "neverthrow";
+import { FileSystem as FileSystem7, Path as Path7 } from "@effect/platform";
+import { Effect as Effect14 } from "effect";
+var CONFIG_FILE2 = "tsconfig.json";
 var typescript = {
   command: "tsgo",
   config: { extends: "adamantite/typescript" },
-  create: () => fromPromise7(writeFile6(join7(process.cwd(), "tsconfig.json"), JSON.stringify(typescript.config, null, 2)), (error) => Fault11.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write tsconfig.json", "We're unable to write the tsconfig.json file in the current directory.")),
-  exists: () => checkIfExists(join7(process.cwd(), "tsconfig.json")),
+  create: () => Effect14.gen(function* () {
+    const fs = yield* FileSystem7.FileSystem;
+    const path = yield* Path7.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 })));
+  }),
+  exists: () => Effect14.gen(function* () {
+    const fs = yield* FileSystem7.FileSystem;
+    const path = yield* Path7.Path;
+    return yield* fs.exists(path.join(process.cwd(), CONFIG_FILE2));
+  }),
   name: "@typescript/native-preview",
-  update: () => safeTry11(async function* () {
-    const tsconfigFile = yield* fromPromise7(readFile6(join7(process.cwd(), "tsconfig.json"), "utf8"), (error) => Fault11.wrap(error).withTag("FAILED_TO_READ_FILE").withDescription("Failed to read tsconfig.json", "We're unable to read the tsconfig.json file in the current directory."));
-    const existingConfig = yield* parseJson(tsconfigFile);
+  update: () => Effect14.gen(function* () {
+    const fs = yield* FileSystem7.FileSystem;
+    const path = yield* Path7.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 existingConfig = yield* parseJson(tsconfigFile, configPath);
     if (!isJsonObject(existingConfig)) {
-      return err6(Fault11.create("INVALID_CONFIG_FORMAT").withDescription("Invalid tsconfig.json format", "The tsconfig.json file must be a JSON object."));
+      return yield* Effect14.fail(new InvalidConfigFormat({ path: configPath }));
     }
     const newConfig = yield* mergeConfig(typescript.config, existingConfig);
-    yield* fromPromise7(writeFile6(join7(process.cwd(), "tsconfig.json"), JSON.stringify(newConfig, null, 2)), (error) => Fault11.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write tsconfig.json", "We're unable to write the tsconfig.json file in the current directory."));
-    return ok11();
+    yield* fs.writeFileString(configPath, `${JSON.stringify(newConfig, null, 2)}
+`).pipe(Effect14.mapError((cause) => new FailedToWriteFile({ cause, path: configPath })));
   }),
   version: "7.0.0-dev.20260108.1"
 };
 
 // src/commands/init.ts
-var installDependencies = (packages) => safeTry12(async function* () {
-  const s = p.spinner();
-  s.start("Installing dependencies...");
+var installDependencies = (packages) => Effect15.gen(function* () {
+  const prompter = yield* Prompter;
+  const spinner2 = prompter.spinner();
+  spinner2.start("Installing dependencies...");
   const isMonorepo = yield* checkIsMonorepo();
-  yield* fromPromise8(addDevDependency(packages, { silent: true, workspace: isMonorepo }), (error) => Fault12.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage(`Failed to install dependencies: ${packages.join(", ")}`));
-  s.stop("Dependencies installed.");
-  return ok12();
+  yield* Effect15.tryPromise({
+    catch: (cause) => new FailedToInstallDependency({ cause, packages }),
+    try: () => addDevDependency(packages, { silent: true, workspace: isMonorepo })
+  }).pipe(Effect15.tapError(() => Effect15.sync(() => {
+    spinner2.stop("Failed to install dependencies.");
+  })));
+  spinner2.stop("Dependencies installed.");
 });
-var setupOxlintConfig = (presets) => safeTry12(async function* () {
-  const spinner2 = p.spinner();
+var setupOxlintConfig = (presets) => Effect15.gen(function* () {
+  const prompter = yield* Prompter;
+  const spinner2 = prompter.spinner();
   spinner2.start("Setting up oxlint config...");
-  const oxlintPath = await oxlint.exists();
+  const oxlintPath = yield* oxlint.exists();
   if (oxlintPath.path) {
     spinner2.message(`Found \`${oxlintPath.path}\`, updating...`);
     yield* oxlint.update(presets);
@@ -770,12 +871,12 @@ var setupOxlintConfig = (presets) => safeTry12(async function* () {
     yield* oxlint.create(presets);
     spinner2.stop("oxlint config created successfully.");
   }
-  return ok12();
 });
-var setupOxfmtConfig = () => safeTry12(async function* () {
-  const spinner2 = p.spinner();
+var setupOxfmtConfig = () => Effect15.gen(function* () {
+  const prompter = yield* Prompter;
+  const spinner2 = prompter.spinner();
   spinner2.start("Setting up oxfmt config...");
-  const oxfmtPath = await oxfmt.exists();
+  const oxfmtPath = yield* oxfmt.exists();
   if (oxfmtPath.path) {
     spinner2.message(`Found \`${oxfmtPath.path}\`, updating...`);
     yield* oxfmt.update();
@@ -785,12 +886,14 @@ var setupOxfmtConfig = () => safeTry12(async function* () {
     yield* oxfmt.create();
     spinner2.stop("oxfmt config created successfully.");
   }
-  return ok12();
 });
-var addScripts = (scripts) => safeTry12(async function* () {
-  const cwd = process8.cwd();
+var addScripts = (scripts) => Effect15.gen(function* () {
+  const fs = yield* FileSystem8.FileSystem;
+  const path = yield* Path8.Path;
+  const cwd = yield* Cwd;
+  const prompter = yield* Prompter;
   const packageJson = yield* readPackageJson();
-  const spinner2 = p.spinner();
+  const spinner2 = prompter.spinner();
   spinner2.start("Adding scripts to your `package.json`...");
   packageJson.scripts ??= {};
   for (const script of scripts) {
@@ -817,17 +920,20 @@ var addScripts = (scripts) => safeTry12(async function* () {
         packageJson.scripts.analyze = "adamantite analyze";
         break;
       default:
-        return err7(Fault12.create("UNKNOWN_SCRIPT").withContext({ script }));
+        return yield* Effect15.fail(new UnknownScript({ script }));
     }
   }
-  yield* fromPromise8(writeFile7(join8(cwd, "package.json"), JSON.stringify(packageJson, null, 2)), (error) => Fault12.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write package.json", "We're unable to update the package.json file.").withContext({ path: join8(cwd, "package.json") }));
+  const currentDir = yield* cwd.get;
+  const packagePath = path.join(currentDir, "package.json");
+  yield* fs.writeFileString(packagePath, `${JSON.stringify(packageJson, null, 2)}
+`).pipe(Effect15.mapError((cause) => new FailedToWriteFile({ cause, path: packagePath })));
   spinner2.stop("Scripts added to your `package.json`");
-  return ok12();
 });
-var setupKnipConfig = () => safeTry12(async function* () {
-  const spinner2 = p.spinner();
+var setupKnipConfig = () => Effect15.gen(function* () {
+  const prompter = yield* Prompter;
+  const spinner2 = prompter.spinner();
   spinner2.start("Setting up knip config...");
-  const knipPath = await knip.exists();
+  const knipPath = yield* knip.exists();
   if (knipPath.path) {
     spinner2.message(`Found \`${knipPath.path}\`, updating...`);
     yield* knip.update();
@@ -837,12 +943,13 @@ var setupKnipConfig = () => safeTry12(async function* () {
     yield* knip.create();
     spinner2.stop("knip config created successfully.");
   }
-  return ok12();
 });
-var setupTypescript = () => safeTry12(async function* () {
-  const spinner2 = p.spinner();
+var setupTypescript = () => Effect15.gen(function* () {
+  const prompter = yield* Prompter;
+  const spinner2 = prompter.spinner();
   spinner2.start("Setting up TypeScript config...");
-  if (await typescript.exists()) {
+  const typescriptExists = yield* typescript.exists();
+  if (typescriptExists) {
     spinner2.message("`tsconfig.json` found, updating...");
     yield* typescript.update();
     spinner2.stop("`tsconfig.json` updated successfully");
@@ -851,13 +958,14 @@ var setupTypescript = () => safeTry12(async function* () {
     yield* typescript.create();
     spinner2.stop("`tsconfig.json` created successfully");
   }
-  return ok12();
 });
-var setupEditors = (editors) => safeTry12(async function* () {
+var setupEditors = (editors) => Effect15.gen(function* () {
+  const prompter = yield* Prompter;
   if (editors.includes("vscode")) {
-    const spinner2 = p.spinner();
+    const spinner2 = prompter.spinner();
     spinner2.start("Checking for `.vscode/settings.json`...");
-    if (await vscode.exists()) {
+    const hasVscodeSettings = yield* vscode.exists();
+    if (hasVscodeSettings) {
       spinner2.message("`.vscode/settings.json` found, updating...");
       yield* vscode.update();
       spinner2.stop("`.vscode/settings.json` updated with Adamantite preset.");
@@ -868,23 +976,45 @@ var setupEditors = (editors) => safeTry12(async function* () {
     }
   }
   if (editors.includes("zed")) {}
-  return ok12();
 });
-var installEditorExtensions = (editors, scripts) => safeTry12(function* () {
-  const spinner2 = p.spinner();
+var installEditorExtensions = (editors, scripts) => Effect15.gen(function* () {
+  const prompter = yield* Prompter;
+  const spinner2 = prompter.spinner();
   spinner2.start("Installing editor extensions...");
-  if (editors.includes("vscode")) {
-    spinner2.message("Installing VS Code extension...");
-    yield* vscode.extension(scripts);
+  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();
+  })), Effect15.catchTags({
+    FailedToInstallExtension: (error) => Effect15.gen(function* () {
+      yield* prompter.log.warning(`⚠️ Failed to install the \`${error.extension}\` extension.`);
+      yield* prompter.log.warning("Please install it manually after setup completes.");
+      return false;
+    }),
+    VscodeCliNotFound: () => Effect15.gen(function* () {
+      yield* prompter.log.error("VSCode CLI ('code' command) not found.");
+      yield* prompter.log.info("To install it:");
+      yield* prompter.log.info("  1. Open VS Code");
+      yield* prompter.log.info("  2. Press Cmd+Shift+P (macOS) or Ctrl+Shift+P (Windows/Linux)");
+      yield* prompter.log.info(`  3. Run 'Shell Command: Install "code" command in PATH'`);
+      return false;
+    })
+  }));
+  if (result) {
+    spinner2.stop("Editor extensions installed successfully.");
   }
-  if (editors.includes("zed")) {}
-  spinner2.stop("Editor extensions installed successfully.");
-  return ok12();
 });
-var setupGitHubActions = (packageManager, scripts) => safeTry12(async function* () {
-  const spinner2 = p.spinner();
+var setupGitHubActions = (packageManager, scripts) => Effect15.gen(function* () {
+  const prompter = yield* Prompter;
+  const spinner2 = prompter.spinner();
   spinner2.start("Setting up GitHub Actions workflow...");
-  if (await github.exists()) {
+  const workflowExists = yield* github.exists();
+  if (workflowExists) {
     spinner2.message("`.github/workflows/adamantite.yml` found, updating...");
     yield* github.update({ packageManager, scripts });
     spinner2.stop("GitHub Actions workflow updated successfully.");
@@ -893,322 +1023,278 @@ var setupGitHubActions = (packageManager, scripts) => safeTry12(async function*
     yield* github.create({ packageManager, scripts });
     spinner2.stop("GitHub Actions workflow created successfully.");
   }
-  return ok12();
-});
-var init_default = defineCommand({
-  builder: (yargs) => yargs,
-  command: "init",
-  describe: "Initialize Adamantite in the current directory",
-  handler: () => safeTry12(async function* () {
-    const packageManager = yield* getPackageManagerName();
-    printTitle();
-    p.intro("\uD83D\uDCA0 adamantite init");
-    p.log.info(`Detected package manager: ${packageManager}`);
-    const isMonorepo = yield* checkIsMonorepo();
-    if (isMonorepo) {
-      p.log.info("We've detected a monorepo setup in your project.");
-    }
-    const scripts = yield* fromSafePromise(p.multiselect({
-      message: "Which scripts do you want to add to your `package.json`?",
-      options: [
-        {
-          hint: "recommended",
-          label: "check - find issues in code using oxlint",
-          value: "check"
-        },
-        {
-          hint: "recommended",
-          label: "fix - fix code issues using oxlint",
-          value: "fix"
-        },
-        {
-          hint: "recommended",
-          label: "format - code formatting using oxfmt",
-          value: "format"
-        },
-        {
-          hint: "extends the `adamantite/typescript` preset in your `tsconfig.json`",
-          label: "typecheck - type-check your code using tsgo",
-          value: "typecheck"
-        },
-        {
-          disabled: !isMonorepo,
-          hint: isMonorepo ? undefined : "available for monorepo projects",
-          label: "check:monorepo - check for monorepo-specific issues using Sherif",
-          value: "check:monorepo"
-        },
-        {
-          disabled: !isMonorepo,
-          hint: isMonorepo ? undefined : "available for monorepo projects",
-          label: "fix:monorepo - fix monorepo-specific issues using Sherif",
-          value: "fix:monorepo"
-        },
-        {
-          label: "analyze - find unused dependencies, exports, and files using knip",
-          value: "analyze"
-        }
-      ]
-    }));
-    if (p.isCancel(scripts)) {
-      return err7(Fault12.create("OPERATION_CANCELLED"));
-    }
-    const hasOxlint = scripts.includes("check") || scripts.includes("fix");
-    let presets = [];
-    if (hasOxlint) {
-      presets = yield* fromSafePromise(p.multiselect({
-        message: "Which presets do you want to install? (core is always included)",
-        options: [
-          { label: "React", value: "react" },
-          { label: "Next.js", value: "nextjs" },
-          { label: "Vue", value: "vue" },
-          { label: "Jest", value: "jest" },
-          { label: "Vitest", value: "vitest" },
-          { label: "Node", value: "node" }
-        ],
-        required: false
-      }));
-      if (p.isCancel(presets)) {
-        return err7(Fault12.create("OPERATION_CANCELLED"));
+}).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 isMonorepo = yield* checkIsMonorepo();
+  if (isMonorepo) {
+    yield* prompter.log.info("We've detected a monorepo setup in your project.");
+  }
+  const selectedScripts = yield* prompter.multiselect({
+    message: "Which scripts do you want to add to your `package.json`?",
+    options: [
+      {
+        hint: "recommended",
+        label: "check - find issues in code using oxlint",
+        value: "check"
+      },
+      {
+        hint: "recommended",
+        label: "fix - fix code issues using oxlint",
+        value: "fix"
+      },
+      {
+        hint: "recommended",
+        label: "format - code formatting using oxfmt",
+        value: "format"
+      },
+      {
+        hint: "extends the `adamantite/typescript` preset in your `tsconfig.json`",
+        label: "typecheck - type-check your code using tsgo",
+        value: "typecheck"
+      },
+      {
+        disabled: !isMonorepo,
+        hint: isMonorepo ? undefined : "available for monorepo projects",
+        label: "check:monorepo - check for monorepo-specific issues using Sherif",
+        value: "check:monorepo"
+      },
+      {
+        disabled: !isMonorepo,
+        hint: isMonorepo ? undefined : "available for monorepo projects",
+        label: "fix:monorepo - fix monorepo-specific issues using Sherif",
+        value: "fix:monorepo"
+      },
+      {
+        label: "analyze - find unused dependencies, exports, and files using knip",
+        value: "analyze"
       }
-    }
-    const editors = yield* fromSafePromise(p.multiselect({
-      message: "Which editors do you want to configure? (optional)",
+    ]
+  });
+  if (isCancel(selectedScripts)) {
+    return yield* Effect15.fail(new OperationCancelled({ reason: "init-cancelled" }));
+  }
+  const hasOxlint = selectedScripts.includes("check") || selectedScripts.includes("fix");
+  let presets = [];
+  if (hasOxlint) {
+    const selectedPresets = yield* prompter.multiselect({
+      message: "Which presets do you want to install? (core is always included)",
       options: [
-        { label: "VSCode / Cursor / Windsurf", value: "vscode" },
-        { disabled: true, hint: "coming soon", label: "Zed", value: "zed" }
+        { label: "React", value: "react" },
+        { label: "Next.js", value: "nextjs" },
+        { label: "Vue", value: "vue" },
+        { label: "Jest", value: "jest" },
+        { label: "Vitest", value: "vitest" },
+        { label: "Node", value: "node" }
       ],
       required: false
-    }));
-    if (p.isCancel(editors)) {
-      return err7(Fault12.create("OPERATION_CANCELLED"));
-    }
-    let installExtensions = false;
-    if (editors.length > 0) {
-      const installExtensionsResponse = yield* fromSafePromise(p.confirm({
-        initialValue: true,
-        message: "Do you want to install the recommended editor extensions?"
-      }));
-      if (p.isCancel(installExtensionsResponse)) {
-        return err7(Fault12.create("OPERATION_CANCELLED"));
-      }
-      installExtensions = installExtensionsResponse;
-    }
-    const hasCIScripts = hasCICompatibleScripts(scripts);
-    let enableGitHubActions = false;
-    if (hasCIScripts) {
-      enableGitHubActions = yield* fromSafePromise(p.confirm({
-        message: "Do you want to add a GitHub Actions workflow to run checks in CI?"
-      }));
-      if (p.isCancel(enableGitHubActions)) {
-        return err7(Fault12.create("OPERATION_CANCELLED"));
-      }
-    }
-    const hasOxfmt = scripts.includes("format");
-    const hasSherif = scripts.includes("check:monorepo") || scripts.includes("fix:monorepo");
-    const hasTypecheck = scripts.includes("typecheck");
-    const hasKnip = scripts.includes("analyze");
-    const dependencies = ["adamantite"];
-    if (hasOxlint) {
-      dependencies.push(`${oxlint.name}@${oxlint.version}`);
-      dependencies.push(`${tsgolint.name}@${tsgolint.version}`);
-    }
-    if (hasOxfmt) {
-      dependencies.push(`${oxfmt.name}@${oxfmt.version}`);
-    }
-    if (hasSherif) {
-      dependencies.push(`${sherif.name}@${sherif.version}`);
-    }
-    if (hasTypecheck) {
-      dependencies.push(`${typescript.name}@${typescript.version}`);
-    }
-    if (hasKnip) {
-      dependencies.push(`${knip.name}@${knip.version}`);
-    }
-    yield* installDependencies(dependencies);
-    if (hasOxfmt) {
-      yield* setupOxfmtConfig();
-    }
-    if (hasOxlint) {
-      yield* setupOxlintConfig(presets);
-    }
-    if (hasKnip) {
-      yield* setupKnipConfig();
-    }
-    yield* addScripts(scripts);
-    if (hasTypecheck) {
-      yield* setupTypescript();
-    }
-    yield* setupEditors(editors);
-    if (installExtensions) {
-      yield* installEditorExtensions(editors, scripts);
-    }
-    if (enableGitHubActions) {
-      yield* setupGitHubActions(packageManager, scripts);
+    });
+    if (isCancel(selectedPresets)) {
+      return yield* Effect15.fail(new OperationCancelled({ reason: "init-cancelled" }));
     }
-    return ok12();
-  }).match(() => {
-    p.outro("\uD83D\uDCA0 Adamantite initialized successfully!");
-    process8.exit(0);
-  }, (error) => {
-    if (Fault12.isFault(error) && error.tag === "OPERATION_CANCELLED") {
-      p.cancel("You've cancelled the initialization process.");
-      process8.exit(0);
+    presets = selectedPresets;
+  }
+  const selectedEditors = yield* prompter.multiselect({
+    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" }
+    ],
+    required: false
+  });
+  if (isCancel(selectedEditors)) {
+    return yield* Effect15.fail(new OperationCancelled({ reason: "init-cancelled" }));
+  }
+  let installExtensions = false;
+  if (selectedEditors.length > 0) {
+    const installExtensionsResponse = yield* prompter.confirm({
+      initialValue: true,
+      message: "Do you want to install the recommended editor extensions?"
+    });
+    if (isCancel(installExtensionsResponse)) {
+      return yield* Effect15.fail(new OperationCancelled({ reason: "init-cancelled" }));
     }
-    if (!Fault12.isFault(error)) {
-      p.log.error(`An unexpected error occurred: ${String(error)}`);
-      p.cancel("Failed to initialize Adamantite");
-      process8.exit(1);
+    installExtensions = installExtensionsResponse;
+  }
+  const hasCIScripts = hasCICompatibleScripts(selectedScripts);
+  let enableGitHubActions = false;
+  if (hasCIScripts) {
+    const enableGitHubActionsResponse = yield* prompter.confirm({
+      message: "Do you want to add a GitHub Actions workflow to run checks in CI?"
+    });
+    if (isCancel(enableGitHubActionsResponse)) {
+      return yield* Effect15.fail(new OperationCancelled({ reason: "init-cancelled" }));
     }
-    p.log.error(error.flatten());
-    p.cancel("Failed to initialize Adamantite");
-    process8.exit(1);
+    enableGitHubActions = enableGitHubActionsResponse;
+  }
+  const hasOxfmt = selectedScripts.includes("format");
+  const hasSherif = selectedScripts.includes("check:monorepo") || selectedScripts.includes("fix:monorepo");
+  const hasTypecheck = selectedScripts.includes("typecheck");
+  const hasKnip = selectedScripts.includes("analyze");
+  const dependencies = ["adamantite"];
+  if (hasOxlint) {
+    dependencies.push(`${oxlint.name}@${oxlint.version}`);
+    dependencies.push(`${tsgolint.name}@${tsgolint.version}`);
+  }
+  if (hasOxfmt) {
+    dependencies.push(`${oxfmt.name}@${oxfmt.version}`);
+  }
+  if (hasSherif) {
+    dependencies.push(`${sherif.name}@${sherif.version}`);
+  }
+  if (hasTypecheck) {
+    dependencies.push(`${typescript.name}@${typescript.version}`);
+  }
+  if (hasKnip) {
+    dependencies.push(`${knip.name}@${knip.version}`);
+  }
+  yield* installDependencies(dependencies);
+  if (hasOxfmt) {
+    yield* setupOxfmtConfig();
+  }
+  if (hasOxlint) {
+    yield* setupOxlintConfig(presets);
+  }
+  if (hasKnip) {
+    yield* setupKnipConfig();
+  }
+  yield* addScripts(selectedScripts);
+  if (hasTypecheck) {
+    yield* setupTypescript();
+  }
+  yield* setupEditors(selectedEditors);
+  if (installExtensions) {
+    yield* installEditorExtensions(selectedEditors, selectedScripts);
+  }
+  if (enableGitHubActions) {
+    yield* setupGitHubActions(pm.name, selectedScripts);
+  }
+  yield* prompter.log.success("Your project is now configured");
+  yield* prompter.outro("\uD83D\uDCA0 Adamantite initialized successfully!");
+}).pipe(Effect15.catchTags({
+  OperationCancelled: () => Effect15.gen(function* () {
+    const prompter = yield* Prompter;
+    yield* prompter.cancel("You've cancelled the initialization process.");
   })
-});
+}))));
 
 // src/commands/monorepo.ts
-import process9 from "node:process";
-import { log as log6 } from "@clack/prompts";
-import { Fault as Fault13 } from "faultier";
-import { ok as ok13, safeTry as safeTry13 } from "neverthrow";
-import { dlxCommand as dlxCommand5 } from "nypm";
-var monorepo_default = defineCommand({
-  builder: (yargs) => yargs.option("fix", {
-    description: "Automatically fix issues",
-    type: "boolean"
-  }),
-  command: "monorepo",
-  describe: "Find and fix monorepo-specific issues using Sherif",
-  handler: (argv) => safeTry13(async function* () {
-    const packageManager = yield* getPackageManagerName();
-    const args = [];
-    if (argv.fix) {
-      args.push("--fix");
-    }
-    const command = dlxCommand5(packageManager, sherif.name, { args });
-    yield* runCommand(command);
-    return ok13();
-  }).match(() => {
-    process9.exit(0);
-  }, (error) => {
-    if (Fault13.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
-      log6.error(error.flatten());
-    }
-    process9.exit(1);
-  })
-});
+import { Command as Command6, Options as Options4 } from "@effect/cli";
+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.stdout("inherit"), ShellCommand7.stderr("inherit"), ShellCommand7.exitCode);
+})));
 
 // src/commands/typecheck.ts
-import process10 from "node:process";
-import { log as log7 } from "@clack/prompts";
-import { Fault as Fault14 } from "faultier";
-import { ok as ok14, safeTry as safeTry14 } from "neverthrow";
-import { dlxCommand as dlxCommand6 } from "nypm";
-var typecheck_default = defineCommand({
-  builder: (yargs) => yargs.option("project", {
-    alias: "p",
-    description: "Path to tsconfig.json file",
-    type: "string"
-  }).option("watch", {
-    alias: "w",
-    description: "Run in watch mode",
-    type: "boolean"
-  }),
-  command: "typecheck",
-  describe: "Run TypeScript type checking",
-  handler: (argv) => safeTry14(async function* () {
-    const packageManager = yield* getPackageManagerName();
-    const args = ["--noEmit"];
-    if (argv.project) {
-      args.push("--project", argv.project);
-    }
-    if (argv.watch) {
-      args.push("--watch");
-    }
-    const command = dlxCommand6(packageManager, typescript.command, { args });
-    const result = yield* runCommand(command);
-    return ok14(result);
-  }).match(() => {
-    process10.exit(0);
-  }, (error) => {
-    if (Fault14.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
-      log7.error(error.flatten());
-    }
-    process10.exit(1);
-  })
-});
+import { Command as Command7, Options as Options5 } from "@effect/cli";
+import { Command as ShellCommand8 } from "@effect/platform";
+import { Effect as Effect17, Option as Option4 } from "effect";
+var project = Options5.text("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 args = ["--noEmit"];
+  if (Option4.isSome(project2)) {
+    args.push("--project", project2.value);
+  }
+  if (watch2) {
+    args.push("--watch");
+  }
+  return yield* ShellCommand8.make(command, ...commandArgs, typescript.command, ...args).pipe(ShellCommand8.stdout("inherit"), ShellCommand8.stderr("inherit"), ShellCommand8.exitCode);
+})));
 
 // src/commands/update.ts
-import process11 from "node:process";
-import { cancel as cancel2, confirm as confirm2, intro as intro2, isCancel as isCancel2, log as log8, outro as outro2, spinner as spinner2 } from "@clack/prompts";
-import { Fault as Fault15 } from "faultier";
-import { err as err8, fromPromise as fromPromise9, fromSafePromise as fromSafePromise2, ok as ok15, safeTry as safeTry15 } from "neverthrow";
+import { isCancel as isCancel2 } from "@clack/prompts";
+import { Command as Command8 } from "@effect/cli";
+import { Effect as Effect18 } from "effect";
 import { addDevDependency as addDevDependency2 } from "nypm";
-var update_default = defineCommand({
-  builder: (yargs) => yargs,
-  command: "update",
-  describe: "Update adamantite dependencies to latest compatible versions",
-  handler: () => safeTry15(async function* () {
-    const packageJson = yield* readPackageJson();
-    printTitle();
-    intro2("\uD83D\uDCA0 adamantite update");
-    const updates = [];
-    for (const pkg of [oxlint, oxfmt, sherif]) {
-      const dependency = packageJson.devDependencies?.[pkg.name];
-      if (dependency && normalizeDependencyVersion(dependency) !== pkg.version) {
-        updates.push({
-          currentVersion: dependency,
-          isDevDependency: true,
-          name: pkg.name,
-          targetVersion: pkg.version
-        });
-      }
-    }
-    if (updates.length === 0) {
-      log8.success("All adamantite dependencies are already up to date!");
-      return ok15("no-updates");
-    }
-    log8.message("The following dependencies will be updated:");
-    for (const dep of updates) {
-      log8.message(`  ${dep.name}: ${dep.currentVersion} → ${dep.targetVersion}`);
-    }
-    const shouldUpdate = yield* fromSafePromise2(confirm2({
-      message: "Do you want to proceed with these updates?"
-    }));
-    if (isCancel2(shouldUpdate)) {
-      return err8(Fault15.create("OPERATION_CANCELLED"));
-    }
-    if (!shouldUpdate) {
-      return ok15("cancelled");
-    }
-    const s = spinner2();
-    s.start("Updating dependencies...");
-    yield* fromPromise9(addDevDependency2(updates.map((dep) => `${dep.name}@${dep.targetVersion}`), { silent: true }), (error) => Fault15.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage(`Failed to update dependencies: ${updates.map((dep) => dep.name).join(", ")}`));
-    s.stop("Dependencies updated successfully");
-    return ok15("updated");
-  }).match((value) => {
-    if (value === "no-updates") {
-      outro2("✅ No updates needed");
-    } else if (value === "cancelled") {
-      outro2("⚠️ Update cancelled");
-    } else if (value === "updated") {
-      outro2("✅ Dependencies updated successfully!");
-    }
-    process11.exit(0);
-  }, (error) => {
-    if (Fault15.isFault(error) && error.tag === "OPERATION_CANCELLED") {
-      cancel2("You've cancelled the update process.");
-      process11.exit(0);
-    }
-    if (Fault15.isFault(error)) {
-      log8.error(error.flatten());
-    } else {
-      log8.error(String(error));
+var update_default = Command8.make("update").pipe(Command8.withDescription("Update adamantite dependencies to latest compatible versions"), Command8.withHandler(() => Effect18.gen(function* () {
+  const prompter = yield* Prompter;
+  const packageJson = yield* readPackageJson();
+  yield* printTitle();
+  yield* prompter.intro("\uD83D\uDCA0 adamantite update");
+  const updates = [];
+  for (const pkg of [oxlint, oxfmt, sherif]) {
+    const dependency = packageJson.devDependencies?.[pkg.name];
+    if (dependency && normalizeDependencyVersion(dependency) !== pkg.version) {
+      updates.push({
+        currentVersion: dependency,
+        isDevDependency: true,
+        name: pkg.name,
+        targetVersion: pkg.version
+      });
     }
-    cancel2("Failed to update dependencies");
-    process11.exit(1);
+  }
+  if (updates.length === 0) {
+    yield* prompter.log.success("All adamantite dependencies are already up to date!");
+    return "no-updates";
+  }
+  yield* prompter.log.info("The following dependencies will be updated:");
+  for (const dep of updates) {
+    yield* prompter.log.info(`  ${dep.name}: ${dep.currentVersion} → ${dep.targetVersion}`);
+  }
+  const shouldUpdate = yield* prompter.confirm({
+    message: "Do you want to proceed with these updates?"
+  });
+  if (isCancel2(shouldUpdate)) {
+    return yield* Effect18.fail(new OperationCancelled({ reason: "update-cancelled" }));
+  }
+  if (!shouldUpdate) {
+    return "cancelled";
+  }
+  const spinner2 = prompter.spinner();
+  spinner2.start("Updating dependencies...");
+  yield* Effect18.tryPromise({
+    catch: (cause) => new FailedToInstallDependency({
+      cause,
+      packages: updates.map((dep) => dep.name)
+    }),
+    try: () => addDevDependency2(updates.map((dep) => `${dep.name}@${dep.targetVersion}`), { silent: true })
+  }).pipe(Effect18.tapError(() => Effect18.sync(() => {
+    spinner2.stop("Failed to update dependencies");
+  })));
+  spinner2.stop("Dependencies updated successfully");
+  return "updated";
+}).pipe(Effect18.tap((value) => Effect18.gen(function* () {
+  const prompter = yield* Prompter;
+  switch (value) {
+    case "no-updates":
+      yield* prompter.outro("✅ No updates needed");
+      break;
+    case "cancelled":
+      yield* prompter.outro("⚠️ Update cancelled");
+      break;
+    case "updated":
+      yield* prompter.outro("✅ Dependencies updated successfully!");
+      break;
+    default:
+      break;
+  }
+})), Effect18.catchTags({
+  OperationCancelled: () => Effect18.gen(function* () {
+    const prompter = yield* Prompter;
+    yield* prompter.cancel("You've cancelled the update process.");
   })
-});
+}))));
 
 // src/index.ts
-var version = await "0.25.0";
-yargs(hideBin(process.argv)).scriptName("adamantite").version(version).command(analyze_default).command(check_default).command(fix_default).command(format_default2).command(init_default).command(monorepo_default).command(typecheck_default).command(update_default).demandCommand(1).strict().help().parse();
+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 program = Effect19.gen(function* () {
+  const version = yield* getPackageVersion();
+  const cli = Command9.run(main, { name: "adamantite", version });
+  yield* cli(process5.argv);
+});
+program.pipe(Effect19.provide(Layer4.mergeAll(NodeContext.layer, PackageManagerLive, PrompterLive, CwdLive)), NodeRuntime.runMain);