adamantite 0.17.0 → 0.19.0

package/dist/index.js

@@ -9,7 +9,7 @@ import { Fault as Fault3 } from "faultier";
 import { ok as ok3, safeTry as safeTry3 } from "neverthrow";
 import { dlxCommand } from "nypm";
 
-// src/helpers/packages/biome.ts
+// src/helpers/packages/oxlint.ts
 import { readFile as readFile2, writeFile } from "node:fs/promises";
 import { join as join2 } from "node:path";
 import { Fault as Fault2 } from "faultier";
@@ -20,7 +20,7 @@ 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 { defu } from "defu";
 import { Fault } from "faultier";
 import { parse } from "jsonc-parser";
 import { err, fromPromise, fromThrowable, ok, safeTry } from "neverthrow";
@@ -50,11 +50,12 @@ var parseJson = (content) => {
   }
   return ok(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"), "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));
+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"));
   if (pnpmWorkspace) {
@@ -63,84 +64,93 @@ var checkIsMonorepo = () => safeTry(async function* () {
   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(`
+  const title = `
+                .o8                                                        .    o8o      .            
+               "888                                                      .o8    \`"'    .o8            
+ .oooo.    .oooo888   .oooo.   ooo. .oo.  .oo.    .oooo.   ooo. .oo.   .o888oo oooo  .o888oo  .ooooo. 
+\`P  )88b  d88' \`888  \`P  )88b  \`888P"Y88bP"Y88b  \`P  )88b  \`888P"Y88b    888   \`888    888   d88' \`88b
+ .oP"888  888   888   .oP"888   888   888   888   .oP"888   888   888    888    888    888   888ooo888
+d8(  888  888   888  d8(  888   888   888   888  d8(  888   888   888    888 .  888    888 . 888    .o
+\`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.log(TITLE);
+    console.info(title);
   }
 }
 
-// src/helpers/packages/biome.ts
-var biome = {
-  name: "@biomejs/biome",
-  version: "2.3.10",
+// src/helpers/packages/oxlint.ts
+var oxlint = {
+  name: "oxlint",
+  version: "1.35.0",
   config: {
-    $schema: "./node_modules/@biomejs/biome/configuration_schema.json"
+    $schema: "./node_modules/oxlint/configuration_schema.json"
   },
   exists: async () => {
-    if (await checkIfExists(join2(process.cwd(), "biome.jsonc"))) {
-      return { path: join2(process.cwd(), "biome.jsonc") };
-    }
-    if (await checkIfExists(join2(process.cwd(), "biome.json"))) {
-      return { path: join2(process.cwd(), "biome.json") };
+    if (await checkIfExists(join2(process.cwd(), ".oxlintrc.json"))) {
+      return { path: join2(process.cwd(), ".oxlintrc.json") };
     }
     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: () => safeTry2(async function* () {
-    const exists = await biome.exists();
+  create: (presets = []) => {
+    const extendsArray = ["adamantite/lint"];
+    for (const preset of presets) {
+      extendsArray.push(`adamantite/lint/${preset}`);
+    }
+    return fromPromise2(writeFile(join2(process.cwd(), ".oxlintrc.json"), JSON.stringify({ ...oxlint.config, extends: extendsArray }, null, 2)), (error) => Fault2.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."));
+  },
+  update: (presets = []) => safeTry2(async function* () {
+    const exists = await oxlint.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."));
+      return err2(Fault2.create("FILE_NOT_FOUND").withDescription("No `.oxlintrc.json` found", "We're unable to find an oxlint configuration in the current directory."));
     }
-    const biomeFile = yield* fromPromise2(readFile2(exists.path, "utf-8"), (error) => Fault2.wrap(error).withTag("FAILED_TO_READ_FILE").withDescription("Failed to read Biome configuration", "We're unable to read the Biome configuration from the current directory."));
-    const existingConfig = yield* parseJson(biomeFile);
-    if (!existingConfig || Object.keys(existingConfig).length === 0) {
-      return err2(Fault2.create("INVALID_BIOME_CONFIG").withDescription("Invalid Biome configuration", "The Biome configuration file is empty or invalid.").withContext({ path: exists.path }));
+    const oxlintFile = yield* fromPromise2(readFile2(exists.path, "utf8"), (error) => Fault2.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);
+    if (!isJsonObject(existingConfig)) {
+      return err2(Fault2.create("INVALID_CONFIG_FORMAT").withDescription("Invalid oxlint configuration format", "The oxlint configuration must be a JSON object."));
     }
     const newConfig = { ...existingConfig };
-    if (!Array.isArray(newConfig.extends)) {
-      newConfig.extends = newConfig.extends ? [newConfig.extends] : [];
-    }
-    if (!newConfig.extends.includes("adamantite")) {
-      newConfig.extends.push("adamantite");
+    const extendsArray = Array.isArray(newConfig.extends) ? newConfig.extends : typeof newConfig.extends === "string" ? [newConfig.extends] : [];
+    const hasAdamantite = extendsArray.some((ext) => ext === "adamantite/lint" || ext === "adamantite/lint/core");
+    if (!hasAdamantite) {
+      extendsArray.push("adamantite/lint");
+    }
+    for (const preset of presets) {
+      const presetPath = `adamantite/lint/${preset}`;
+      if (!extendsArray.includes(presetPath)) {
+        extendsArray.push(presetPath);
+      }
     }
-    const mergedConfig = yield* mergeConfig(newConfig, biome.config);
-    mergedConfig.$schema = biome.config.$schema;
-    yield* fromPromise2(writeFile(exists.path, JSON.stringify(mergedConfig, 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.").withContext({ path: exists.path }));
+    newConfig.extends = extendsArray;
+    const mergedConfig = yield* mergeConfig(newConfig, oxlint.config);
+    mergedConfig.$schema = oxlint.config.$schema;
+    yield* fromPromise2(writeFile(exists.path, JSON.stringify(mergedConfig, null, 2)), (error) => Fault2.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 ok2();
   })
 };
+var tsgolint = {
+  name: "oxlint-tsgolint",
+  version: "0.10.0"
+};
 
 // src/commands/check.ts
 var check_default = defineCommand({
   command: "check [files..]",
-  describe: "Find issues in code using Biome",
+  describe: "Find issues in code using oxlint",
   builder: (yargs) => yargs.positional("files", {
     describe: "Specific files to lint (optional)",
     type: "string",
     array: true
-  }).option("summary", {
-    type: "boolean",
-    description: "Show summary of lint results"
   }),
   handler: (argv) => safeTry3(async function* () {
     const packageManager = yield* getPackageManagerName();
-    const args = ["check"];
-    if (argv.summary) {
-      args.push("--reporter", "summary");
-    }
+    const args = ["--type-aware"];
     if (argv.files && argv.files.length > 0) {
       args.push(...argv.files);
     }
-    const command = dlxCommand(packageManager, biome.name, { args });
+    const command = dlxCommand(packageManager, oxlint.name, { args });
     const result = yield* runCommand(command);
     return ok3(result);
   }).match(() => {
@@ -161,25 +171,43 @@ import { ok as ok4, safeTry as safeTry4 } from "neverthrow";
 import { dlxCommand as dlxCommand2 } from "nypm";
 var fix_default = defineCommand({
   command: "fix [files..]",
-  describe: "Fix issues in code using Biome",
+  describe: "Fix issues in code using oxlint",
   builder: (yargs) => yargs.positional("files", {
     describe: "Specific files to fix (optional)",
     type: "string",
     array: true
-  }).option("unsafe", {
+  }).option("suggested", {
+    type: "boolean",
+    description: "Apply suggested fixes",
+    default: false
+  }).option("dangerous", {
     type: "boolean",
-    description: "Apply unsafe fixes"
+    description: "Apply dangerous fixes",
+    default: false
+  }).option("all", {
+    type: "boolean",
+    description: "Apply all fixes, including suggested and dangerous fixes",
+    default: false
   }),
   handler: (argv) => safeTry4(async function* () {
     const packageManager = yield* getPackageManagerName();
-    const args = ["check", "--write"];
-    if (argv.unsafe) {
-      args.push("--unsafe");
+    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) {
-      args.push(...argv.files);
+      for (const file of argv.files) {
+        args.add(file);
+      }
     }
-    const command = dlxCommand2(packageManager, biome.name, { args });
+    const command = dlxCommand2(packageManager, oxlint.name, { args: Array.from(args) });
     yield* runCommand(command);
     return ok4();
   }).match(() => {
@@ -266,10 +294,10 @@ var oxfmt = {
     if (!exists.path) {
       return err3(Fault5.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) => Fault5.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 oxfmtFile = yield* fromPromise3(readFile3(exists.path, "utf8"), (error) => Fault5.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(Fault5.create("INVALID_OXFMT_CONFIG").withDescription("Invalid oxfmt configuration", "The oxfmt configuration file is empty or invalid.").withContext({ path: exists.path }));
+    if (!isJsonObject(existingConfig)) {
+      return err3(Fault5.create("INVALID_CONFIG_FORMAT").withDescription("Invalid oxfmt configuration format", "The oxfmt configuration must be a JSON object."));
     }
     const mergedConfig = yield* mergeConfig(existingConfig, oxfmt.config);
     mergedConfig.$schema = oxfmt.config.$schema;
@@ -318,7 +346,7 @@ import { join as join7 } 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 fromPromise7, fromSafePromise, ok as ok10, safeTry as safeTry10 } from "neverthrow";
+import { err as err6, fromPromise as fromPromise7, fromSafePromise, ok as ok10, safeTry as safeTry10 } from "neverthrow";
 import { addDevDependency } from "nypm";
 
 // src/helpers/ci/github.ts
@@ -328,11 +356,20 @@ import process6 from "node:process";
 import { Fault as Fault7 } from "faultier";
 import { fromPromise as fromPromise4, ok as ok7, safeTry as safeTry7 } from "neverthrow";
 import { runScriptCommand } from "nypm";
-var CI_COMPATIBLE_SCRIPTS = ["check", "format", "typecheck", "check:monorepo"];
 var setupSteps = {
   bun: `      - name: Setup Bun
         uses: oven-sh/setup-bun@v2
 
+      - name: Cache dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.bun/install/cache
+            node_modules
+          key: \${{ runner.os }}-bun-\${{ hashFiles('bun.lock') }}
+          restore-keys: |
+            \${{ runner.os }}-bun-
+
       - name: Install dependencies
         run: bun install --frozen-lockfile`,
   pnpm: `      - name: Setup pnpm
@@ -368,36 +405,40 @@ var setupSteps = {
       - name: Install dependencies
         run: deno install --frozen`
 };
-var generateJob = (jobName, stepName, script, packageManager) => `
-  ${jobName}:
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-${setupSteps[packageManager]}
-
-      - name: ${stepName}
-        run: ${runScriptCommand(packageManager, script)}`;
+var buildCommand = (packageManager, script, args) => runScriptCommand(packageManager, script, { args });
 var generateWorkflow = ({ packageManager, scripts }) => {
-  const jobs = [];
+  const matrixEntries = [];
   if (scripts.includes("check")) {
-    jobs.push(generateJob("lint", "Run linter", "check", packageManager));
+    matrixEntries.push({
+      name: "lint",
+      command: buildCommand(packageManager, "check")
+    });
   }
   if (scripts.includes("format")) {
-    jobs.push(generateJob("format", "Check formatting", "format --check", packageManager));
+    matrixEntries.push({
+      name: "format",
+      command: buildCommand(packageManager, "format", ["--check"])
+    });
   }
   if (scripts.includes("typecheck")) {
-    jobs.push(generateJob("typecheck", "Run type check", "typecheck", packageManager));
+    matrixEntries.push({
+      name: "types",
+      command: buildCommand(packageManager, "typecheck")
+    });
   }
   if (scripts.includes("check:monorepo")) {
-    jobs.push(generateJob("monorepo", "Check monorepo", "check:monorepo", packageManager));
+    matrixEntries.push({
+      name: "monorepo",
+      command: buildCommand(packageManager, "check:monorepo")
+    });
   }
-  if (jobs.length === 0) {
+  if (matrixEntries.length === 0) {
     return null;
   }
-  const workflow = `name: CI
+  const matrixInclude = matrixEntries.map((entry) => `          - name: ${entry.name}
+            command: ${entry.command}`).join(`
+`);
+  const workflow = `name: adamantite
 
 on:
   push:
@@ -406,16 +447,36 @@ on:
   pull_request:
     types: [opened, synchronize, reopened]
 
+permissions:
+  contents: read
+
 concurrency:
   group: \${{ github.workflow }}-\${{ github.ref }}
   cancel-in-progress: true
 
-jobs:${jobs.join(`
-`)}`;
+jobs:
+  verify:
+    name: \${{ matrix.name }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+${matrixInclude}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+${setupSteps[packageManager]}
+
+      - name: Run \${{ matrix.name }}
+        run: \${{ matrix.command }}`;
   return `${workflow}
 `;
 };
-var hasCICompatibleScripts = (scripts) => scripts.some((script) => CI_COMPATIBLE_SCRIPTS.includes(script));
+var hasCICompatibleScripts = (scripts) => scripts.some((script) => ["check", "format", "typecheck", "check:monorepo"].includes(script));
 var github = {
   workflowPath: ".github/workflows/adamantite.yml",
   exists: () => checkIfExists(join4(process6.cwd(), ".github", "workflows", "adamantite.yml")),
@@ -444,14 +505,14 @@ var github = {
 import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
 import { join as join5 } from "node:path";
 import { Fault as Fault8 } from "faultier";
-import { fromPromise as fromPromise5, ok as ok8, safeTry as safeTry8 } from "neverthrow";
+import { err as err4, fromPromise as fromPromise5, 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.fixAll.biome": "explicit"
+      "source.fixAll.oxc": "explicit"
     },
     "[javascript][typescript][javascriptreact][typescriptreact][json][jsonc][css][graphql]": {
       "editor.defaultFormatter": "oxc.oxc-vscode"
@@ -466,8 +527,11 @@ var vscode = {
   }),
   update: () => safeTry8(async function* () {
     const vscodePath = join5(process.cwd(), ".vscode", "settings.json");
-    const vscodeFile = yield* fromPromise5(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 vscodeFile = yield* fromPromise5(readFile4(vscodePath, "utf8"), (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);
+    if (!isJsonObject(existingConfig)) {
+      return err4(Fault8.create("INVALID_CONFIG_FORMAT").withDescription("Invalid .vscode/settings.json format", "The VS Code settings file must be a JSON object."));
+    }
     const newConfig = yield* mergeConfig(vscode.config, existingConfig);
     yield* fromPromise5(writeFile4(join5(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();
@@ -480,19 +544,25 @@ var sherif = {
   version: "1.9.0"
 };
 
-// src/helpers/tsconfig.ts
+// src/helpers/packages/typescript.ts
 import { readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
 import { join as join6 } from "node:path";
 import { Fault as Fault9 } from "faultier";
-import { fromPromise as fromPromise6, ok as ok9, safeTry as safeTry9 } from "neverthrow";
-var tsconfig = {
+import { err as err5, fromPromise as fromPromise6, ok as ok9, safeTry as safeTry9 } from "neverthrow";
+var typescript = {
+  name: "@typescript/native-preview",
+  version: "7.0.0-dev.20251227.1",
+  command: "tsgo",
   config: { extends: "adamantite/typescript" },
   exists: () => checkIfExists(join6(process.cwd(), "tsconfig.json")),
-  create: () => fromPromise6(writeFile5(join6(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.")),
+  create: () => fromPromise6(writeFile5(join6(process.cwd(), "tsconfig.json"), JSON.stringify(typescript.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* fromPromise6(readFile5(join6(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 tsconfigFile = yield* fromPromise6(readFile5(join6(process.cwd(), "tsconfig.json"), "utf8"), (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);
+    if (!isJsonObject(existingConfig)) {
+      return err5(Fault9.create("INVALID_CONFIG_FORMAT").withDescription("Invalid tsconfig.json format", "The tsconfig.json file must be a JSON object."));
+    }
+    const newConfig = yield* mergeConfig(typescript.config, existingConfig);
     yield* fromPromise6(writeFile5(join6(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();
   })
@@ -504,23 +574,24 @@ var installDependencies = (packages) => safeTry10(async function* () {
   s.start("Installing dependencies...");
   const isMonorepo = yield* checkIsMonorepo();
   for (const pkg of packages) {
+    s.message(`Installing dependency: ${pkg}...`);
     yield* fromPromise7(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* () {
+var setupOxlintConfig = (presets) => 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.");
+  spinner2.start("Setting up oxlint config...");
+  const oxlintPath = await oxlint.exists();
+  if (oxlintPath.path) {
+    spinner2.message(`Found \`${oxlintPath.path}\`, updating...`);
+    yield* oxlint.update(presets);
+    spinner2.stop("oxlint config updated successfully.");
   } else {
-    spinner2.message("`.biome.jsonc` or `.biome.json` not found, creating...");
-    yield* biome.create();
-    spinner2.stop("Biome config created successfully.");
+    spinner2.message("`.oxlintrc.json` not found, creating...");
+    yield* oxlint.create(presets);
+    spinner2.stop("oxlint config created successfully.");
   }
   return ok10();
 });
@@ -544,9 +615,7 @@ var addScripts = (scripts) => safeTry10(async function* () {
   const packageJson = yield* readPackageJson();
   const spinner2 = p.spinner();
   spinner2.start("Adding scripts to your `package.json`...");
-  if (!packageJson.scripts) {
-    packageJson.scripts = {};
-  }
+  packageJson.scripts ??= {};
   for (const script of scripts) {
     switch (script) {
       case "check":
@@ -559,7 +628,7 @@ var addScripts = (scripts) => safeTry10(async function* () {
         packageJson.scripts.format = "adamantite format";
         break;
       case "typecheck":
-        packageJson.scripts.typecheck = "tsc --noEmit";
+        packageJson.scripts.typecheck = "adamantite typecheck";
         break;
       case "check:monorepo":
         packageJson.scripts["check:monorepo"] = "adamantite monorepo";
@@ -568,7 +637,7 @@ var addScripts = (scripts) => safeTry10(async function* () {
         packageJson.scripts["fix:monorepo"] = "adamantite monorepo --fix";
         break;
       default:
-        return err4(Fault10.create("UNKNOWN_SCRIPT").withContext({ script }));
+        return err6(Fault10.create("UNKNOWN_SCRIPT").withContext({ script }));
     }
   }
   yield* fromPromise7(writeFile6(join7(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: join7(cwd, "package.json") }));
@@ -578,13 +647,13 @@ var addScripts = (scripts) => safeTry10(async function* () {
 var setupTypescript = () => safeTry10(async function* () {
   const spinner2 = p.spinner();
   spinner2.start("Setting up TypeScript config...");
-  if (await tsconfig.exists()) {
+  if (await typescript.exists()) {
     spinner2.message("`tsconfig.json` found, updating...");
-    yield* tsconfig.update();
+    yield* typescript.update();
     spinner2.stop("`tsconfig.json` updated successfully");
   } else {
     spinner2.message("`tsconfig.json` not found, creating...");
-    yield* tsconfig.create();
+    yield* typescript.create();
     spinner2.stop("`tsconfig.json` created successfully");
   }
   return ok10();
@@ -637,12 +706,12 @@ var init_default = defineCommand({
       message: "Which scripts do you want to add to your `package.json`?",
       options: [
         {
-          label: "check - find issues in code using Biome",
+          label: "check - find issues in code using oxlint",
           value: "check",
           hint: "recommended"
         },
         {
-          label: "fix - fix code issues using Biome",
+          label: "fix - fix code issues using oxlint",
           value: "fix",
           hint: "recommended"
         },
@@ -652,7 +721,7 @@ var init_default = defineCommand({
           hint: "recommended"
         },
         {
-          label: "typecheck - type-check your code using strict TypeScript preset",
+          label: "typecheck - type-check your code using tsgo",
           value: "typecheck",
           hint: "extends the `adamantite/typescript` preset in your `tsconfig.json`"
         },
@@ -671,7 +740,27 @@ var init_default = defineCommand({
       ]
     }));
     if (p.isCancel(scripts)) {
-      return err4(Fault10.create("OPERATION_CANCELLED"));
+      return err6(Fault10.create("OPERATION_CANCELLED"));
+    }
+    const hasOxlint = scripts.includes("check") || scripts.includes("fix");
+    let presets = [];
+    if (hasOxlint) {
+      const presetsResponse = 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(presetsResponse)) {
+        return err6(Fault10.create("OPERATION_CANCELLED"));
+      }
+      presets = presetsResponse;
     }
     const editors = yield* fromSafePromise(p.multiselect({
       message: "Which editors do you want to configure? (optional)",
@@ -682,7 +771,7 @@ var init_default = defineCommand({
       required: false
     }));
     if (p.isCancel(editors)) {
-      return err4(Fault10.create("OPERATION_CANCELLED"));
+      return err6(Fault10.create("OPERATION_CANCELLED"));
     }
     const hasCIScripts = hasCICompatibleScripts(scripts);
     let enableGitHubActions = false;
@@ -692,17 +781,17 @@ var init_default = defineCommand({
         initialValue: false
       }));
       if (p.isCancel(response)) {
-        return err4(Fault10.create("OPERATION_CANCELLED"));
+        return err6(Fault10.create("OPERATION_CANCELLED"));
       }
       enableGitHubActions = response;
     }
-    const hasBiome = scripts.includes("check") || scripts.includes("fix");
     const hasOxfmt = scripts.includes("format");
     const hasSherif = scripts.includes("check:monorepo") || scripts.includes("fix:monorepo");
     const hasTypecheck = scripts.includes("typecheck");
     const dependencies = ["adamantite"];
-    if (hasBiome) {
-      dependencies.push(`${biome.name}@${biome.version}`);
+    if (hasOxlint) {
+      dependencies.push(`${oxlint.name}@${oxlint.version}`);
+      dependencies.push(`${tsgolint.name}@${tsgolint.version}`);
     }
     if (hasOxfmt) {
       dependencies.push(`${oxfmt.name}@${oxfmt.version}`);
@@ -711,14 +800,14 @@ var init_default = defineCommand({
       dependencies.push(`${sherif.name}@${sherif.version}`);
     }
     if (hasTypecheck) {
-      dependencies.push("typescript");
+      dependencies.push(`${typescript.name}@${typescript.version}`);
     }
     yield* installDependencies(dependencies);
     if (hasOxfmt) {
       yield* setupOxfmtConfig();
     }
-    if (hasBiome) {
-      yield* setupBiomeConfig();
+    if (hasOxlint) {
+      yield* setupOxlintConfig(presets);
     }
     yield* addScripts(scripts);
     if (hasTypecheck) {
@@ -769,7 +858,7 @@ var monorepo_default = defineCommand({
     }
     const command = dlxCommand4(packageManager, sherif.name, { args });
     yield* runCommand(command);
-    return ok11(undefined);
+    return ok11();
   }).match(() => {
     process8.exit(0);
   }, (error) => {
@@ -780,22 +869,62 @@ var monorepo_default = defineCommand({
   })
 });
 
-// src/commands/update.ts
+// src/commands/typecheck.ts
 import process9 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 { log as log6 } from "@clack/prompts";
 import { Fault as Fault12 } from "faultier";
-import { err as err5, fromPromise as fromPromise8, fromSafePromise as fromSafePromise2, ok as ok12, safeTry as safeTry12 } from "neverthrow";
+import { ok as ok12, safeTry as safeTry12 } from "neverthrow";
+import { dlxCommand as dlxCommand5 } from "nypm";
+var typecheck_default = defineCommand({
+  command: "typecheck",
+  describe: "Run TypeScript type checking",
+  builder: (yargs) => yargs.option("project", {
+    alias: "p",
+    type: "string",
+    description: "Path to tsconfig.json file"
+  }).option("watch", {
+    alias: "w",
+    type: "boolean",
+    description: "Run in watch mode"
+  }),
+  handler: (argv) => safeTry12(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 = dlxCommand5(packageManager, typescript.command, { args });
+    const result = yield* runCommand(command);
+    return ok12(result);
+  }).match(() => {
+    process9.exit(0);
+  }, (error) => {
+    if (Fault12.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
+      log6.error(error.flatten());
+    }
+    process9.exit(1);
+  })
+});
+
+// src/commands/update.ts
+import process10 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 Fault13 } from "faultier";
+import { err as err7, fromPromise as fromPromise8, fromSafePromise as fromSafePromise2, ok as ok13, safeTry as safeTry13 } 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 () => safeTry12(async function* () {
+  handler: () => safeTry13(async function* () {
     const packageJson = yield* readPackageJson();
     printTitle();
     intro2("\uD83D\uDCA0 adamantite update");
     const updates = [];
-    for (const pkg of [biome, oxfmt, sherif]) {
+    for (const pkg of [oxlint, oxfmt, sherif]) {
       const dependency = packageJson.devDependencies?.[pkg.name];
       if (dependency && normalizeDependencyVersion(dependency) !== pkg.version) {
         updates.push({
@@ -807,31 +936,31 @@ var update_default = defineCommand({
       }
     }
     if (updates.length === 0) {
-      log6.success("All adamantite dependencies are already up to date!");
-      return ok12("no-updates");
+      log7.success("All adamantite dependencies are already up to date!");
+      return ok13("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 err5(Fault12.create("OPERATION_CANCELLED"));
+      return err7(Fault13.create("OPERATION_CANCELLED"));
     }
     if (!shouldUpdate) {
-      return ok12("cancelled");
+      return ok13("cancelled");
     }
     const s = spinner2();
     s.start("Updating dependencies...");
     for (const dep of updates) {
-      yield* fromPromise8(addDevDependency2(`${dep.name}@${dep.targetVersion}`), (error) => Fault12.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage(`Failed to update ${dep.name}`));
+      yield* fromPromise8(addDevDependency2(`${dep.name}@${dep.targetVersion}`), (error) => Fault13.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage(`Failed to update ${dep.name}`));
     }
     s.stop("Dependencies updated successfully");
-    return ok12("updated");
+    return ok13("updated");
   }).match((value) => {
     if (value === "no-updates") {
       outro2("✅ No updates needed");
@@ -840,21 +969,22 @@ var update_default = defineCommand({
     } else if (value === "updated") {
       outro2("✅ Dependencies updated successfully!");
     }
-    process9.exit(0);
+    process10.exit(0);
   }, (error) => {
-    if (Fault12.isFault(error) && error.tag === "OPERATION_CANCELLED") {
+    if (Fault13.isFault(error) && error.tag === "OPERATION_CANCELLED") {
       cancel2("You've cancelled the update process.");
-      process9.exit(0);
+      process10.exit(0);
     }
-    if (Fault12.isFault(error)) {
-      log6.error(error.flatten());
+    if (Fault13.isFault(error)) {
+      log7.error(error.flatten());
     } else {
-      log6.error(String(error));
+      log7.error(String(error));
     }
     cancel2("Failed to update dependencies");
-    process9.exit(1);
+    process10.exit(1);
   })
 });
 
 // src/index.ts
-yargs(hideBin(process.argv)).scriptName("adamantite").version("0.17.0").command(check_default).command(fix_default).command(format_default).command(init_default).command(monorepo_default).command(update_default).demandCommand(1).strict().help().parse();
+var version = await "0.19.0";
+yargs(hideBin(process.argv)).scriptName("adamantite").version(version).command(check_default).command(fix_default).command(format_default).command(init_default).command(monorepo_default).command(typecheck_default).command(update_default).demandCommand(1).strict().help().parse();