adamantite 0.14.2 → 0.15.0

package/dist/index.js

@@ -6,29 +6,40 @@ import { hideBin } from "yargs/helpers";
 import process3 from "node:process";
 import { log } from "@clack/prompts";
 import { Fault as Fault3 } from "faultier";
-import { ok as ok3, safeTry as safeTry2 } from "neverthrow";
+import { ok as ok3, safeTry as safeTry3 } from "neverthrow";
 import { dlxCommand } from "nypm";
 
 // src/helpers/packages/biome.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 } from "neverthrow";
+import { err as err2, fromPromise as fromPromise2, ok as ok2, safeTry as safeTry2 } from "neverthrow";
 
 // src/utils.ts
-import { execSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import { access, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import process2 from "node:process";
 import defu from "defu";
 import { Fault } from "faultier";
 import { parse } from "jsonc-parser";
-import { err, fromPromise, fromThrowable, ok } from "neverthrow";
+import { err, fromPromise, fromThrowable, ok, safeTry } from "neverthrow";
 import { detectPackageManager } from "nypm";
 function defineCommand(input) {
   return input;
 }
-var runCommand = fromThrowable(execSync, (error) => Fault.wrap(error).withTag("FAILED_TO_RUN_COMMAND"));
+var runCommand = (command) => {
+  const result = spawnSync(command, {
+    stdio: "inherit",
+    shell: true,
+    maxBuffer: 100 * 1024 * 1024
+  });
+  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 parseJson = (content) => {
@@ -39,27 +50,32 @@ var parseJson = (content) => {
   }
   return ok(parsed);
 };
+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"), "utf-8"), (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));
-function getTitle() {
-  const terminalWidth = process2.stdout.columns || 80;
-  if (terminalWidth >= 120) {
-    return `
-               █████                                                 █████     ███   █████            
-              ░░███                                                 ░░███     ░░░   ░░███             
-  ██████    ███████   ██████   █████████████    ██████   ████████   ███████   ████  ███████    ██████ 
- ░░░░░███  ███░░███  ░░░░░███ ░░███░░███░░███  ░░░░░███ ░░███░░███ ░░░███░   ░░███ ░░░███░    ███░░███
-  ███████ ░███ ░███   ███████  ░███ ░███ ░███   ███████  ░███ ░███   ░███     ░███   ░███    ░███████ 
- ███░░███ ░███ ░███  ███░░███  ░███ ░███ ░███  ███░░███  ░███ ░███   ░███ ███ ░███   ░███ ███░███░░░  
-░░████████░░████████░░████████ █████░███ █████░░████████ ████ █████  ░░█████  █████  ░░█████ ░░██████ 
- ░░░░░░░░  ░░░░░░░░  ░░░░░░░░ ░░░░░ ░░░ ░░░░░  ░░░░░░░░ ░░░░ ░░░░░    ░░░░░  ░░░░░    ░░░░░   ░░░░░░                   
-`;
+var checkIsMonorepo = () => safeTry(async function* () {
+  const pnpmWorkspace = await checkIfExists(join(process2.cwd(), "pnpm-workspace.yaml"));
+  if (pnpmWorkspace) {
+    return ok(true);
   }
-  return `
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
-┃                              ADAMANTITE                              ┃
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+  const packageJson = yield* readPackageJson();
+  return ok(packageJson?.workspaces !== undefined);
+});
+var TITLE = `
+     o      ooooooooo      o      oooo     oooo      o      oooo   oooo ooooooooooo ooooo ooooooooooo ooooooooooo
+    888      888    88o   888      8888o   888      888      8888o  88  88  888  88  888  88  888  88  888    88 
+   8  88     888    888  8  88     88 888o8 88     8  88     88 888o88      888      888      888      888ooo8   
+  8oooo88    888    888 8oooo88    88  888  88    8oooo88    88   8888      888      888      888      888    oo 
+o88o  o888o o888ooo88 o88o  o888o o88o  8  o88o o88o  o888o o88o    88     o888o    o888o    o888o    o888ooo8888                                                                       
 `;
+function printTitle() {
+  const columns = TITLE.split(`
+`).reduce((max, line) => Math.max(max, line.trim().length), 0);
+  if (process2.stdout.columns && process2.stdout.columns >= columns) {
+    console.log(TITLE);
+  }
 }
 
 // src/helpers/packages/biome.ts
@@ -79,7 +95,7 @@ var biome = {
     return { path: null };
   },
   create: () => fromPromise2(writeFile(join2(process.cwd(), "biome.jsonc"), JSON.stringify({ ...biome.config, extends: ["adamantite"] }, null, 2)), (error) => Fault2.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write Biome configuration", "We're unable to write the Biome configuration to the current directory.")),
-  update: () => safeTry(async function* () {
+  update: () => safeTry2(async function* () {
     const exists = await biome.exists();
     if (!exists.path) {
       return err2(Fault2.create("FILE_NOT_FOUND").withDescription("No `biome.jsonc` or `biome.json` found", "We're unable to find a Biome configuration in the current directory."));
@@ -106,7 +122,7 @@ var biome = {
 // src/commands/check.ts
 var check_default = defineCommand({
   command: "check [files..]",
-  describe: "Run Biome linter and check files for issues",
+  describe: "Find issues in code using Biome",
   builder: (yargs) => yargs.positional("files", {
     describe: "Specific files to lint (optional)",
     type: "string",
@@ -115,7 +131,7 @@ var check_default = defineCommand({
     type: "boolean",
     description: "Show summary of lint results"
   }),
-  handler: async (argv) => safeTry2(async function* () {
+  handler: (argv) => safeTry3(async function* () {
     const packageManager = yield* getPackageManagerName();
     const args = ["check"];
     if (argv.summary) {
@@ -125,8 +141,8 @@ var check_default = defineCommand({
       args.push(...argv.files);
     }
     const command = dlxCommand(packageManager, biome.name, { args });
-    yield* runCommand(command, { stdio: "inherit" });
-    return ok3(undefined);
+    const result = yield* runCommand(command);
+    return ok3(result);
   }).match(() => {
     process3.exit(0);
   }, (error) => {
@@ -140,10 +156,89 @@ var check_default = defineCommand({
 // src/commands/ci.ts
 import process4 from "node:process";
 import { log as log2 } from "@clack/prompts";
-import { Fault as Fault4 } from "faultier";
-import { ok as ok4, safeTry as safeTry3 } from "neverthrow";
+import { Fault as Fault5 } from "faultier";
+import { ok as ok5, safeTry as safeTry5 } from "neverthrow";
 import { dlxCommand as dlxCommand2 } from "nypm";
 
+// src/helpers/packages/oxfmt.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";
+// presets/oxfmt.json
+var oxfmt_default = {
+  arrowParens: "always",
+  bracketSameLine: false,
+  bracketSpacing: true,
+  embeddedLanguageFormatting: "auto",
+  endOfLine: "lf",
+  experimentalSortImports: {
+    groups: [
+      ["value-builtin", "type-import"],
+      ["value-external"],
+      ["type-internal"],
+      ["value-internal"],
+      ["type-subpath"],
+      ["value-subpath"],
+      ["type-parent", "type-sibling", "type-index"],
+      ["value-parent", "value-sibling", "value-index"],
+      ["unknown"]
+    ],
+    ignoreCase: true,
+    newlinesBetween: false,
+    partitionByNewline: true,
+    order: "asc",
+    partitionByComment: true,
+    sortSideEffects: false
+  },
+  insertFinalNewline: true,
+  jsxSingleQuote: false,
+  objectWrap: "preserve",
+  printWidth: 100,
+  quoteProps: "as-needed",
+  semi: false,
+  singleAttributePerLine: false,
+  singleQuote: false,
+  tabWidth: 2,
+  trailingComma: "es5",
+  useTabs: false
+};
+
+// src/helpers/packages/oxfmt.ts
+var oxfmt = {
+  name: "oxfmt",
+  version: "0.20.0",
+  config: {
+    $schema: "./node_modules/oxfmt/configuration_schema.json",
+    ...oxfmt_default
+  },
+  exists: async () => {
+    if (await checkIfExists(join3(process.cwd(), ".oxfmtrc.jsonc"))) {
+      return { path: join3(process.cwd(), ".oxfmtrc.jsonc") };
+    }
+    if (await checkIfExists(join3(process.cwd(), ".oxfmtrc.json"))) {
+      return { path: join3(process.cwd(), ".oxfmtrc.json") };
+    }
+    return { path: null };
+  },
+  create: () => fromPromise3(writeFile2(join3(process.cwd(), ".oxfmtrc.jsonc"), JSON.stringify(oxfmt.config, null, 2)), (error) => Fault4.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.")),
+  update: () => safeTry4(async function* () {
+    const exists = await oxfmt.exists();
+    if (!exists.path) {
+      return err3(Fault4.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* fromPromise3(readFile3(exists.path, "utf-8"), (error) => Fault4.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);
+    if (!existingConfig || Object.keys(existingConfig).length === 0) {
+      return err3(Fault4.create("INVALID_OXFMT_CONFIG").withDescription("Invalid oxfmt configuration", "The oxfmt configuration file is empty or invalid.").withContext({ path: exists.path }));
+    }
+    const mergedConfig = yield* mergeConfig(existingConfig, oxfmt.config);
+    mergedConfig.$schema = oxfmt.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 oxfmt configuration", "We're unable to write the oxfmt configuration to the current directory.").withContext({ path: exists.path }));
+    return ok4();
+  })
+};
+
 // src/helpers/packages/sherif.ts
 var sherif = {
   name: "sherif",
@@ -161,7 +256,7 @@ var ci_default = defineCommand({
     type: "boolean",
     description: "Use GitHub reporter"
   }),
-  handler: async (argv) => safeTry3(async function* () {
+  handler: (argv) => safeTry5(async function* () {
     const packageManager = yield* getPackageManagerName();
     const tools = [
       {
@@ -169,6 +264,13 @@ var ci_default = defineCommand({
         args: ["ci", ...argv.github ? ["--reporter", "github"] : []]
       }
     ];
+    const oxfmtConfig = await oxfmt.exists();
+    if (oxfmtConfig.path) {
+      tools.push({
+        package: oxfmt.name,
+        args: ["--check"]
+      });
+    }
     if (argv.monorepo) {
       tools.push({ package: sherif.name, args: [] });
     }
@@ -176,15 +278,13 @@ var ci_default = defineCommand({
       const command = dlxCommand2(packageManager, tool.package, {
         args: tool.args
       });
-      yield* runCommand(command, {
-        stdio: "inherit"
-      });
+      yield* runCommand(command);
     }
-    return ok4(undefined);
+    return ok5();
   }).match(() => {
     process4.exit(0);
   }, (error) => {
-    if (Fault4.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
+    if (Fault5.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
       log2.error(error.flatten());
     }
     process4.exit(1);
@@ -194,12 +294,12 @@ var ci_default = defineCommand({
 // src/commands/fix.ts
 import process5 from "node:process";
 import { log as log3 } from "@clack/prompts";
-import { Fault as Fault5 } from "faultier";
-import { ok as ok5, safeTry as safeTry4 } from "neverthrow";
+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({
   command: "fix [files..]",
-  describe: "Run Biome linter and fix issues in files",
+  describe: "Fix issues in code using Biome",
   builder: (yargs) => yargs.positional("files", {
     describe: "Specific files to fix (optional)",
     type: "string",
@@ -208,7 +308,7 @@ var fix_default = defineCommand({
     type: "boolean",
     description: "Apply unsafe fixes"
   }),
-  handler: async (argv) => safeTry4(async function* () {
+  handler: (argv) => safeTry6(async function* () {
     const packageManager = yield* getPackageManagerName();
     const args = ["check", "--write"];
     if (argv.unsafe) {
@@ -218,262 +318,383 @@ var fix_default = defineCommand({
       args.push(...argv.files);
     }
     const command = dlxCommand3(packageManager, biome.name, { args });
-    yield* runCommand(command, {
-      stdio: "inherit"
-    });
-    return ok5(undefined);
+    yield* runCommand(command);
+    return ok6();
   }).match(() => {
     process5.exit(0);
   }, (error) => {
-    if (Fault5.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
+    if (Fault6.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
       log3.error(error.flatten());
     }
     process5.exit(1);
   })
 });
 
-// src/commands/init.ts
-import { writeFile as writeFile4 } from "node:fs/promises";
-import { join as join5 } from "node:path";
+// src/commands/format.ts
 import process6 from "node:process";
-import { cancel, confirm, intro, isCancel, log as log4, multiselect, outro, spinner } from "@clack/prompts";
-import { Fault as Fault8 } from "faultier";
-import { err as err3, fromPromise as fromPromise5, fromSafePromise, ok as ok8, safeTry as safeTry7 } from "neverthrow";
+import { log as log4 } from "@clack/prompts";
+import { Fault as Fault7 } from "faultier";
+import { ok as ok7, safeTry as safeTry7 } from "neverthrow";
+import { dlxCommand as dlxCommand4 } from "nypm";
+var format_default = defineCommand({
+  command: "format [files..]",
+  describe: "Format files using oxfmt",
+  builder: (yargs) => yargs.positional("files", {
+    describe: "Specific files to format (optional)",
+    type: "string",
+    array: true
+  }).option("check", {
+    type: "boolean",
+    description: "Check if files are formatted without writing"
+  }),
+  handler: (argv) => safeTry7(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 ok7(result);
+  }).match(() => {
+    process6.exit(0);
+  }, (error) => {
+    if (Fault7.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
+      log4.error(error.flatten());
+    }
+    process6.exit(1);
+  })
+});
+
+// src/commands/init.ts
+import { writeFile as writeFile5 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+import process7 from "node:process";
+import * as p from "@clack/prompts";
+import { Fault as Fault10 } from "faultier";
+import { err as err4, fromPromise as fromPromise6, fromSafePromise, ok as ok10, safeTry as safeTry10 } from "neverthrow";
 import { addDevDependency } from "nypm";
 
 // src/helpers/editors/vscode.ts
-import { mkdir, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join3 } from "node:path";
-import { Fault as Fault6 } from "faultier";
-import { fromPromise as fromPromise3, ok as ok6, safeTry as safeTry5 } from "neverthrow";
+import { mkdir, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+import { Fault as Fault8 } from "faultier";
+import { fromPromise as fromPromise4, ok as ok8, safeTry as safeTry8 } from "neverthrow";
 var vscode = {
   config: {
     "typescript.tsdk": "node_modules/typescript/lib",
     "editor.formatOnSave": true,
     "editor.formatOnPaste": true,
     "editor.codeActionsOnSave": {
-      "source.organizeImports.biome": "explicit",
       "source.fixAll.biome": "explicit"
     },
     "[javascript][typescript][javascriptreact][typescriptreact][json][jsonc][css][graphql]": {
-      "editor.defaultFormatter": "biomejs.biome"
+      "editor.defaultFormatter": "oxc.oxc-vscode"
     }
   },
-  exists: () => checkIfExists(join3(process.cwd(), ".vscode", "settings.json")),
-  create: () => safeTry5(async function* () {
-    const vscodePath = join3(process.cwd(), ".vscode");
-    yield* fromPromise3(mkdir(vscodePath, { recursive: true }), (error) => Fault6.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* fromPromise3(writeFile2(join3(vscodePath, "settings.json"), JSON.stringify(vscode.config, null, 2)), (error) => Fault6.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 ok6();
+  exists: () => checkIfExists(join4(process.cwd(), ".vscode", "settings.json")),
+  create: () => safeTry8(async function* () {
+    const vscodePath = join4(process.cwd(), ".vscode");
+    yield* fromPromise4(mkdir(vscodePath, { recursive: true }), (error) => Fault8.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* fromPromise4(writeFile3(join4(vscodePath, "settings.json"), JSON.stringify(vscode.config, null, 2)), (error) => Fault8.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 ok8();
   }),
-  update: () => safeTry5(async function* () {
-    const vscodePath = join3(process.cwd(), ".vscode", "settings.json");
-    const vscodeFile = yield* fromPromise3(readFile3(vscodePath, "utf-8"), (error) => Fault6.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 }));
+  update: () => safeTry8(async function* () {
+    const vscodePath = join4(process.cwd(), ".vscode", "settings.json");
+    const vscodeFile = yield* fromPromise4(readFile4(vscodePath, "utf-8"), (error) => Fault8.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);
     const newConfig = yield* mergeConfig(vscode.config, existingConfig);
-    yield* fromPromise3(writeFile2(join3(process.cwd(), ".vscode", "settings.json"), JSON.stringify(newConfig, null, 2)), (error) => Fault6.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 ok6();
+    yield* fromPromise4(writeFile3(join4(process.cwd(), ".vscode", "settings.json"), JSON.stringify(newConfig, null, 2)), (error) => Fault8.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 ok8();
   })
 };
 
 // src/helpers/tsconfig.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 { fromPromise as fromPromise4, ok as ok7, safeTry as safeTry6 } from "neverthrow";
+import { readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+import { Fault as Fault9 } from "faultier";
+import { fromPromise as fromPromise5, ok as ok9, safeTry as safeTry9 } from "neverthrow";
 var tsconfig = {
   config: { extends: "adamantite/tsconfig" },
-  exists: () => checkIfExists(join4(process.cwd(), "tsconfig.json")),
-  create: () => fromPromise4(writeFile3(join4(process.cwd(), "tsconfig.json"), JSON.stringify(tsconfig.config, null, 2)), (error) => Fault7.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.")),
-  update: () => safeTry6(async function* () {
-    const tsconfigFile = yield* fromPromise4(readFile4(join4(process.cwd(), "tsconfig.json"), "utf-8"), (error) => Fault7.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."));
+  exists: () => checkIfExists(join5(process.cwd(), "tsconfig.json")),
+  create: () => fromPromise5(writeFile4(join5(process.cwd(), "tsconfig.json"), JSON.stringify(tsconfig.config, null, 2)), (error) => Fault9.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.")),
+  update: () => safeTry9(async function* () {
+    const tsconfigFile = yield* fromPromise5(readFile5(join5(process.cwd(), "tsconfig.json"), "utf-8"), (error) => Fault9.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);
     const newConfig = yield* mergeConfig(tsconfig.config, existingConfig);
-    yield* fromPromise4(writeFile3(join4(process.cwd(), "tsconfig.json"), JSON.stringify(newConfig, null, 2)), (error) => Fault7.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 ok7();
+    yield* fromPromise5(writeFile4(join5(process.cwd(), "tsconfig.json"), JSON.stringify(newConfig, null, 2)), (error) => Fault9.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 ok9();
   })
 };
 
 // src/commands/init.ts
+var installDependencies = (packages) => safeTry10(async function* () {
+  const s = p.spinner();
+  s.start("Installing dependencies...");
+  const isMonorepo = yield* checkIsMonorepo();
+  for (const pkg of packages) {
+    yield* fromPromise6(addDevDependency(pkg, { silent: true, workspace: isMonorepo }), (error) => Fault10.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage(`Failed to install ${pkg}`));
+  }
+  s.stop("Dependencies installed.");
+  return ok10();
+});
+var setupBiomeConfig = () => safeTry10(async function* () {
+  const spinner2 = p.spinner();
+  spinner2.start("Setting up Biome config...");
+  const biomePath = await biome.exists();
+  if (biomePath.path) {
+    spinner2.message(`Found \`${biomePath.path}\`, updating...`);
+    yield* biome.update();
+    spinner2.stop("Biome config updated successfully.");
+  } else {
+    spinner2.message("`.biome.jsonc` or `.biome.json` not found, creating...");
+    yield* biome.create();
+    spinner2.stop("Biome config created successfully.");
+  }
+  return ok10();
+});
+var setupOxfmtConfig = () => safeTry10(async function* () {
+  const spinner2 = p.spinner();
+  spinner2.start("Setting up oxfmt config...");
+  const oxfmtPath = await oxfmt.exists();
+  if (oxfmtPath.path) {
+    spinner2.message(`Found \`${oxfmtPath.path}\`, updating...`);
+    yield* oxfmt.update();
+    spinner2.stop("oxfmt config updated successfully.");
+  } else {
+    spinner2.message("`.oxfmtrc.jsonc` or `.oxfmtrc.json` not found, creating...");
+    yield* oxfmt.create();
+    spinner2.stop("oxfmt config created successfully.");
+  }
+  return ok10();
+});
+var addScripts = (scripts) => safeTry10(async function* () {
+  const cwd = process7.cwd();
+  const packageJson = yield* readPackageJson();
+  const spinner2 = p.spinner();
+  spinner2.start("Adding scripts to your `package.json`...");
+  if (!packageJson.scripts) {
+    packageJson.scripts = {};
+  }
+  for (const script of scripts) {
+    switch (script) {
+      case "check":
+        packageJson.scripts.check = "adamantite check";
+        break;
+      case "fix":
+        packageJson.scripts.fix = "adamantite fix";
+        break;
+      case "format":
+        packageJson.scripts.format = "adamantite format";
+        break;
+      case "check:monorepo":
+        packageJson.scripts["check:monorepo"] = "adamantite monorepo";
+        break;
+      case "fix:monorepo":
+        packageJson.scripts["fix:monorepo"] = "adamantite monorepo --fix";
+        break;
+      default:
+        return err4(Fault10.create("UNKNOWN_SCRIPT").withContext({ script }));
+    }
+  }
+  yield* fromPromise6(writeFile5(join6(cwd, "package.json"), JSON.stringify(packageJson, null, 2)), (error) => Fault10.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write package.json", "We're unable to update the package.json file.").withContext({ path: join6(cwd, "package.json") }));
+  spinner2.stop("Scripts added to your `package.json`");
+  return ok10();
+});
+var setupTypescript = () => safeTry10(async function* () {
+  const spinner2 = p.spinner();
+  spinner2.start("Setting up TypeScript config...");
+  if (await tsconfig.exists()) {
+    spinner2.message("`tsconfig.json` found, updating...");
+    yield* tsconfig.update();
+    spinner2.stop("`tsconfig.json` updated successfully");
+  } else {
+    spinner2.message("`tsconfig.json` not found, creating...");
+    yield* tsconfig.create();
+    spinner2.stop("`tsconfig.json` created successfully");
+  }
+  return ok10();
+});
+var setupEditors = (editors) => safeTry10(async function* () {
+  if (editors.includes("vscode")) {
+    const spinner2 = p.spinner();
+    spinner2.start("Checking for `.vscode/settings.json`...");
+    if (await vscode.exists()) {
+      spinner2.message("`.vscode/settings.json` found, updating...");
+      yield* vscode.update();
+      spinner2.stop("`.vscode/settings.json` updated with Adamantite preset.");
+    } else {
+      spinner2.message("`.vscode/settings.json` not found, creating...");
+      yield* vscode.create();
+      spinner2.stop("`.vscode/settings.json` created with Adamantite preset.");
+    }
+  }
+  if (editors.includes("zed")) {}
+  return ok10();
+});
 var init_default = defineCommand({
   command: "init",
   describe: "Initialize Adamantite in the current directory",
   builder: (yargs) => yargs,
-  handler: async () => {
-    const cwd = process6.cwd();
-    return safeTry7(async function* () {
-      let packageJson = yield* readPackageJson();
-      intro(getTitle());
-      const hasPnpmWorkspace = await checkIfExists(join5(process6.cwd(), "pnpm-workspace.yaml"));
-      const isMonorepo = packageJson.workspaces !== undefined || hasPnpmWorkspace;
-      const shouldInstallScripts = yield* fromSafePromise(confirm({
-        message: "Do you want to add the `check` and `fix` scripts to your `package.json`?"
-      }));
-      if (isCancel(shouldInstallScripts)) {
-        return err3(Fault8.create("OPERATION_CANCELLED"));
-      }
-      let shouldInstallMonorepoScripts = false;
-      if (isMonorepo) {
-        const shouldInstallMonorepoScriptsResponse = yield* fromSafePromise(confirm({
-          message: "We've detected a monorepo setup in your project. Would you like to install monorepo linting scripts?"
-        }));
-        if (isCancel(shouldInstallMonorepoScriptsResponse)) {
-          return err3(Fault8.create("OPERATION_CANCELLED"));
-        }
-        shouldInstallMonorepoScripts = shouldInstallMonorepoScriptsResponse;
-      }
-      const shouldInstallTypeScriptPreset = yield* fromSafePromise(confirm({
-        message: "Adamantite provides a TypeScript preset to enforce strict type-safety. Would you like to install it?"
-      }));
-      if (isCancel(shouldInstallTypeScriptPreset)) {
-        return err3(Fault8.create("OPERATION_CANCELLED"));
-      }
-      const selectedEditors = yield* fromSafePromise(multiselect({
-        message: "Which editors do you want to configure (recommended)?",
-        options: [
-          { label: "VSCode / Cursor / Windsurf", value: "vscode" },
-          { label: "Zed (coming soon)", value: "zed" }
-        ],
-        required: false
-      }));
-      if (isCancel(selectedEditors)) {
-        return err3(Fault8.create("OPERATION_CANCELLED"));
-      }
-      const installingDependencies = spinner();
-      installingDependencies.start("Installing dependencies...");
-      yield* fromPromise5(addDevDependency("adamantite"), (error) => Fault8.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage("Failed to install Adamantite"));
-      yield* fromPromise5(addDevDependency(`${biome.name}@${biome.version}`), (error) => Fault8.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage("Failed to install Biome"));
-      if (shouldInstallMonorepoScripts) {
-        yield* fromPromise5(addDevDependency(`${sherif.name}@${sherif.version}`), (error) => Fault8.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage("Failed to install Sherif"));
-      }
-      installingDependencies.stop("Dependencies installed successfully");
-      const settingUpBiomeConfig = spinner();
-      settingUpBiomeConfig.start("Setting up Biome config...");
-      const biomePath = await biome.exists();
-      if (biomePath.path) {
-        settingUpBiomeConfig.message("Biome config found, updating...");
-        yield* biome.update();
-        settingUpBiomeConfig.stop("Biome config updated successfully");
-      } else {
-        settingUpBiomeConfig.message("Biome config not found, creating...");
-        yield* biome.create();
-        settingUpBiomeConfig.stop("Biome config created successfully");
-      }
-      if (shouldInstallScripts) {
-        const addingScripts = spinner();
-        packageJson = yield* readPackageJson();
-        addingScripts.start("Adding scripts to your `package.json`...");
-        if (!packageJson.scripts) {
-          packageJson.scripts = {};
-        }
-        packageJson.scripts.check = "adamantite check";
-        packageJson.scripts.fix = "adamantite fix";
-        if (shouldInstallMonorepoScripts) {
-          packageJson.scripts["lint:monorepo"] = "adamantite monorepo";
-        }
-        yield* fromPromise5(writeFile4(join5(cwd, "package.json"), JSON.stringify(packageJson, null, 2)), (error) => Fault8.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write package.json", "We're unable to update the package.json file.").withContext({ path: join5(cwd, "package.json") }));
-        addingScripts.stop("Scripts added to your `package.json`");
-      }
-      if (shouldInstallTypeScriptPreset) {
-        const settingUpTypeScriptConfig = spinner();
-        settingUpTypeScriptConfig.start("Setting up TypeScript config...");
-        if (await tsconfig.exists()) {
-          settingUpTypeScriptConfig.message("`tsconfig.json` found, updating...");
-          yield* tsconfig.update();
-          settingUpTypeScriptConfig.stop("`tsconfig.json` updated successfully");
-        } else {
-          settingUpTypeScriptConfig.message("`tsconfig.json` not found, creating...");
-          yield* tsconfig.create();
-          settingUpTypeScriptConfig.stop("`tsconfig.json` created successfully");
-        }
-      }
-      if (selectedEditors.length > 0) {
-        const settingUpEditorConfig = spinner();
-        settingUpEditorConfig.start("Setting up editor config...");
-        if (selectedEditors.includes("vscode")) {
-          const settingUpVSCodeConfig = spinner();
-          settingUpVSCodeConfig.start("Setting up VSCode config...");
-          if (await vscode.exists()) {
-            settingUpVSCodeConfig.message("VSCode settings found, updating...");
-            yield* vscode.update();
-            settingUpVSCodeConfig.stop("VSCode settings updated with Adamantite preset");
-          } else {
-            settingUpVSCodeConfig.message("VSCode settings not found, creating...");
-            yield* vscode.create();
-            settingUpVSCodeConfig.stop("VSCode settings created with Adamantite preset");
-          }
-        }
-        if (selectedEditors.includes("zed")) {
-          log4.warning("Zed configuration coming soon...");
+  handler: () => safeTry10(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: [
+        {
+          label: "check - find issues in code using Biome",
+          value: "check",
+          hint: "recommended"
+        },
+        {
+          label: "fix - fix code issues using Biome",
+          value: "fix",
+          hint: "recommended"
+        },
+        {
+          label: "format - code formatting using oxfmt",
+          value: "format",
+          hint: "recommended"
+        },
+        {
+          label: "check:monorepo - check for monorepo-specific issues using Sherif",
+          value: "check:monorepo",
+          hint: isMonorepo ? undefined : "available for monorepo projects",
+          disabled: !isMonorepo
+        },
+        {
+          label: "fix:monorepo - fix monorepo-specific issues using Sherif",
+          value: "fix:monorepo",
+          hint: isMonorepo ? undefined : "available for monorepo projects",
+          disabled: !isMonorepo
         }
-        settingUpEditorConfig.stop("Editor config set up successfully");
-      }
-      return ok8();
-    }).match(() => {
-      outro("\uD83D\uDCA0 Adamantite initialized successfully!");
-      process6.exit(0);
-    }, (error) => {
-      if (Fault8.isFault(error) && error.tag === "OPERATION_CANCELLED") {
-        cancel("You've cancelled the initialization process.");
-        process6.exit(0);
-        return;
-      }
-      if (Fault8.isFault(error)) {
-        log4.error(error.flatten());
-      } else {
-        log4.error(String(error));
-      }
-      cancel("Failed to initialize Adamantite");
-      process6.exit(1);
-    });
-  }
+      ]
+    }));
+    if (p.isCancel(scripts)) {
+      return err4(Fault10.create("OPERATION_CANCELLED"));
+    }
+    const typescriptPreset = yield* fromSafePromise(p.confirm({
+      message: "Adamantite provides a TypeScript preset to enforce strict type-safety. Would you like to install it?"
+    }));
+    if (p.isCancel(typescriptPreset)) {
+      return err4(Fault10.create("OPERATION_CANCELLED"));
+    }
+    const editors = yield* fromSafePromise(p.multiselect({
+      message: "Which editors do you want to configure? (optional)",
+      options: [
+        { label: "VSCode / Cursor / Windsurf", value: "vscode" },
+        { label: "Zed", value: "zed", disabled: true, hint: "coming soon" }
+      ],
+      required: false
+    }));
+    if (p.isCancel(editors)) {
+      return err4(Fault10.create("OPERATION_CANCELLED"));
+    }
+    const hasBiome = scripts.includes("check") || scripts.includes("fix");
+    const hasOxfmt = scripts.includes("format");
+    const hasSherif = scripts.includes("check:monorepo") || scripts.includes("fix:monorepo");
+    const dependencies = ["adamantite"];
+    if (hasBiome) {
+      dependencies.push(`${biome.name}@${biome.version}`);
+    }
+    if (hasOxfmt) {
+      dependencies.push(`${oxfmt.name}@${oxfmt.version}`);
+    }
+    if (hasSherif) {
+      dependencies.push(`${sherif.name}@${sherif.version}`);
+    }
+    yield* installDependencies(dependencies);
+    if (hasOxfmt) {
+      yield* setupOxfmtConfig();
+    }
+    if (hasBiome) {
+      yield* setupBiomeConfig();
+    }
+    yield* addScripts(scripts);
+    if (typescriptPreset) {
+      yield* setupTypescript();
+    }
+    yield* setupEditors(editors);
+    return ok10();
+  }).match(() => {
+    p.outro("\uD83D\uDCA0 Adamantite initialized successfully!");
+    process7.exit(0);
+  }, (error) => {
+    if (Fault10.isFault(error) && error.tag === "OPERATION_CANCELLED") {
+      p.cancel("You've cancelled the initialization process.");
+      process7.exit(0);
+    }
+    if (!Fault10.isFault(error)) {
+      p.log.error(`An unexpected error occurred: ${String(error)}`);
+      p.cancel("Failed to initialize Adamantite");
+      process7.exit(1);
+    }
+    p.log.error(error.flatten());
+    p.cancel("Failed to initialize Adamantite");
+    process7.exit(1);
+  })
 });
 
 // src/commands/monorepo.ts
-import process7 from "node:process";
-import { log as log5 } from "@clack/prompts";
-import { Fault as Fault9 } from "faultier";
-import { ok as ok9, safeTry as safeTry8 } from "neverthrow";
-import { dlxCommand as dlxCommand4 } from "nypm";
+import process8 from "node:process";
+import { log as log6 } from "@clack/prompts";
+import { Fault as Fault11 } from "faultier";
+import { ok as ok11, safeTry as safeTry11 } from "neverthrow";
+import { dlxCommand as dlxCommand5 } from "nypm";
 var monorepo_default = defineCommand({
   command: "monorepo",
-  describe: "Lint and automatically fix monorepo-specific issues using Sherif",
-  builder: (yargs) => yargs,
-  handler: async () => safeTry8(async function* () {
+  describe: "Find and fix monorepo-specific issues using Sherif",
+  builder: (yargs) => yargs.option("fix", {
+    type: "boolean",
+    description: "Automatically fix issues"
+  }),
+  handler: (argv) => safeTry11(async function* () {
     const packageManager = yield* getPackageManagerName();
-    const args = ["--fix"];
-    const command = dlxCommand4(packageManager, sherif.name, { args });
-    yield* runCommand(command, {
-      stdio: "inherit"
-    });
-    return ok9(undefined);
+    const args = [];
+    if (argv.fix) {
+      args.push("--fix");
+    }
+    const command = dlxCommand5(packageManager, sherif.name, { args });
+    yield* runCommand(command);
+    return ok11(undefined);
   }).match(() => {
-    process7.exit(0);
+    process8.exit(0);
   }, (error) => {
-    if (Fault9.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
-      log5.error(error.flatten());
+    if (Fault11.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
+      log6.error(error.flatten());
     }
-    process7.exit(1);
+    process8.exit(1);
   })
 });
 
 // src/commands/update.ts
-import process8 from "node:process";
-import { cancel as cancel2, confirm as confirm2, intro as intro2, isCancel as isCancel2, log as log6, outro as outro2, spinner as spinner2 } from "@clack/prompts";
-import { Fault as Fault10 } from "faultier";
-import { err as err4, fromPromise as fromPromise6, fromSafePromise as fromSafePromise2, ok as ok10, safeTry as safeTry9 } from "neverthrow";
+import process9 from "node:process";
+import { cancel as cancel2, confirm as confirm2, intro as intro2, isCancel as isCancel2, log as log7, outro as outro2, spinner as spinner2 } from "@clack/prompts";
+import { Fault as Fault12 } from "faultier";
+import { err as err5, fromPromise as fromPromise7, fromSafePromise as fromSafePromise2, ok as ok12, safeTry as safeTry12 } from "neverthrow";
 import { addDevDependency as addDevDependency2 } from "nypm";
 var update_default = defineCommand({
   command: "update",
   describe: "Update adamantite dependencies to latest compatible versions",
   builder: (yargs) => yargs,
-  handler: async () => safeTry9(async function* () {
+  handler: async () => safeTry12(async function* () {
     const packageJson = yield* readPackageJson();
-    intro2(getTitle());
+    printTitle();
+    intro2("\uD83D\uDCA0 adamantite update");
     const updates = [];
-    for (const pkg of [biome, sherif]) {
+    for (const pkg of [biome, oxfmt, sherif]) {
       const dependency = packageJson.devDependencies?.[pkg.name];
-      if (dependency && dependency !== pkg.version) {
+      if (dependency && normalizeDependencyVersion(dependency) !== pkg.version) {
         updates.push({
           name: pkg.name,
           currentVersion: dependency,
@@ -483,55 +704,54 @@ var update_default = defineCommand({
       }
     }
     if (updates.length === 0) {
-      log6.success("All adamantite dependencies are already up to date!");
-      return ok10("no-updates");
+      log7.success("All adamantite dependencies are already up to date!");
+      return ok12("no-updates");
     }
-    log6.message("The following dependencies will be updated:");
-    log6.message("");
+    log7.message("The following dependencies will be updated:");
+    log7.message("");
     for (const dep of updates) {
-      log6.message(`  ${dep.name}: ${dep.currentVersion} → ${dep.targetVersion}`);
+      log7.message(`  ${dep.name}: ${dep.currentVersion} → ${dep.targetVersion}`);
     }
-    log6.message("");
+    log7.message("");
     const shouldUpdate = yield* fromSafePromise2(confirm2({
       message: "Do you want to proceed with these updates?"
     }));
     if (isCancel2(shouldUpdate)) {
-      return err4(Fault10.create("OPERATION_CANCELLED"));
+      return err5(Fault12.create("OPERATION_CANCELLED"));
     }
     if (!shouldUpdate) {
-      return ok10("cancelled");
+      return ok12("cancelled");
     }
     const s = spinner2();
     s.start("Updating dependencies...");
     for (const dep of updates) {
-      yield* fromPromise6(addDevDependency2(`${dep.name}@${dep.targetVersion}`), (error) => Fault10.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage(`Failed to update ${dep.name}`));
+      yield* fromPromise7(addDevDependency2(`${dep.name}@${dep.targetVersion}`), (error) => Fault12.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage(`Failed to update ${dep.name}`));
     }
     s.stop("Dependencies updated successfully");
-    return ok10("updated");
+    return ok12("updated");
   }).match((value) => {
     if (value === "no-updates") {
-      outro2("\uD83D\uDCA0 No updates needed");
+      outro2("✅ No updates needed");
     } else if (value === "cancelled") {
-      outro2("\uD83D\uDCA0 Update cancelled");
+      outro2("⚠️ Update cancelled");
     } else if (value === "updated") {
-      outro2("\uD83D\uDCA0 Dependencies updated successfully!");
+      outro2("✅ Dependencies updated successfully!");
     }
-    process8.exit(0);
+    process9.exit(0);
   }, (error) => {
-    if (Fault10.isFault(error) && error.tag === "OPERATION_CANCELLED") {
+    if (Fault12.isFault(error) && error.tag === "OPERATION_CANCELLED") {
       cancel2("You've cancelled the update process.");
-      process8.exit(0);
-      return;
+      process9.exit(0);
     }
-    if (Fault10.isFault(error)) {
-      log6.error(error.flatten());
+    if (Fault12.isFault(error)) {
+      log7.error(error.flatten());
     } else {
-      log6.error(String(error));
+      log7.error(String(error));
     }
     cancel2("Failed to update dependencies");
-    process8.exit(1);
+    process9.exit(1);
   })
 });
 
 // src/index.ts
-yargs(hideBin(process.argv)).scriptName("adamantite").version("0.14.2").command(check_default).command(ci_default).command(fix_default).command(init_default).command(monorepo_default).command(update_default).demandCommand(1).strict().help().parse();
+yargs(hideBin(process.argv)).scriptName("adamantite").version("0.15.0").command(check_default).command(ci_default).command(fix_default).command(format_default).command(init_default).command(monorepo_default).command(update_default).demandCommand(1).strict().help().parse();