adamantite 0.16.0 → 0.18.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,81 @@ 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.")),
+  create: () => fromPromise2(writeFile(join2(process.cwd(), ".oxlintrc.json"), JSON.stringify({ ...oxlint.config, extends: ["adamantite/lint"] }, 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: () => safeTry2(async function* () {
-    const exists = await biome.exists();
+    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 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 }));
+    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");
+    }
+    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(() => {
@@ -153,18 +151,75 @@ var check_default = defineCommand({
   })
 });
 
-// src/commands/ci.ts
+// src/commands/fix.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 { Fault as Fault4 } from "faultier";
+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 oxlint",
+  builder: (yargs) => yargs.positional("files", {
+    describe: "Specific files to fix (optional)",
+    type: "string",
+    array: true
+  }).option("suggested", {
+    type: "boolean",
+    description: "Apply suggested fixes",
+    default: false
+  }).option("dangerous", {
+    type: "boolean",
+    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 = 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 = dlxCommand2(packageManager, oxlint.name, { args: Array.from(args) });
+    yield* runCommand(command);
+    return ok4();
+  }).match(() => {
+    process4.exit(0);
+  }, (error) => {
+    if (Fault4.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
+      log2.error(error.flatten());
+    }
+    process4.exit(1);
+  })
+});
+
+// src/commands/format.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";
 
 // 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";
+import { Fault as Fault5 } from "faultier";
+import { err as err3, fromPromise as fromPromise3, ok as ok5, safeTry as safeTry5 } from "neverthrow";
 // presets/oxfmt.json
 var oxfmt_default = {
   arrowParens: "always",
@@ -221,121 +276,25 @@ var oxfmt = {
     }
     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* () {
+  create: () => fromPromise3(writeFile2(join3(process.cwd(), ".oxfmtrc.jsonc"), JSON.stringify(oxfmt.config, null, 2)), (error) => Fault5.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: () => safeTry5(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."));
+      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) => 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 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(Fault4.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;
-    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",
-  version: "1.9.0"
-};
-
-// src/commands/ci.ts
-var ci_default = defineCommand({
-  command: "ci",
-  describe: "Run Adamantite in a CI environment",
-  builder: (yargs) => yargs.option("monorepo", {
-    type: "boolean",
-    description: "Run additional monorepo-specific checks"
-  }).option("github", {
-    type: "boolean",
-    description: "Use GitHub reporter"
-  }),
-  handler: (argv) => safeTry5(async function* () {
-    const packageManager = yield* getPackageManagerName();
-    const tools = [
-      {
-        package: biome.name,
-        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: [] });
-    }
-    for (const tool of tools) {
-      const command = dlxCommand2(packageManager, tool.package, {
-        args: tool.args
-      });
-      yield* runCommand(command);
-    }
+    yield* fromPromise3(writeFile2(exists.path, JSON.stringify(mergedConfig, null, 2)), (error) => Fault5.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 ok5();
-  }).match(() => {
-    process4.exit(0);
-  }, (error) => {
-    if (Fault5.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
-      log2.error(error.flatten());
-    }
-    process4.exit(1);
   })
-});
-
-// 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({
-  command: "fix [files..]",
-  describe: "Fix issues in code using Biome",
-  builder: (yargs) => yargs.positional("files", {
-    describe: "Specific files to fix (optional)",
-    type: "string",
-    array: true
-  }).option("unsafe", {
-    type: "boolean",
-    description: "Apply unsafe fixes"
-  }),
-  handler: (argv) => safeTry6(async function* () {
-    const packageManager = yield* getPackageManagerName();
-    const args = ["check", "--write"];
-    if (argv.unsafe) {
-      args.push("--unsafe");
-    }
-    if (argv.files && argv.files.length > 0) {
-      args.push(...argv.files);
-    }
-    const command = dlxCommand3(packageManager, biome.name, { args });
-    yield* runCommand(command);
-    return ok6();
-  }).match(() => {
-    process5.exit(0);
-  }, (error) => {
-    if (Fault6.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
-      log3.error(error.flatten());
-    }
-    process5.exit(1);
-  })
-});
+};
 
 // src/commands/format.ts
-import process6 from "node:process";
-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",
@@ -347,7 +306,7 @@ var format_default = defineCommand({
     type: "boolean",
     description: "Check if files are formatted without writing"
   }),
-  handler: (argv) => safeTry7(async function* () {
+  handler: (argv) => safeTry6(async function* () {
     const packageManager = yield* getPackageManagerName();
     const args = [];
     if (argv.check) {
@@ -356,76 +315,241 @@ var format_default = defineCommand({
     if (argv.files && argv.files.length > 0) {
       args.push(...argv.files);
     }
-    const command = dlxCommand4(packageManager, oxfmt.name, { args });
+    const command = dlxCommand3(packageManager, oxfmt.name, { args });
     const result = yield* runCommand(command);
-    return ok7(result);
+    return ok6(result);
   }).match(() => {
-    process6.exit(0);
+    process5.exit(0);
   }, (error) => {
-    if (Fault7.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
-      log4.error(error.flatten());
+    if (Fault6.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
+      log3.error(error.flatten());
     }
-    process6.exit(1);
+    process5.exit(1);
   })
 });
 
 // src/commands/init.ts
-import { writeFile as writeFile5 } from "node:fs/promises";
-import { join as join6 } from "node:path";
+import { writeFile as writeFile6 } from "node:fs/promises";
+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 fromPromise6, 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/editors/vscode.ts
-import { mkdir, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+// src/helpers/ci/github.ts
+import { mkdir, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join4 } from "node:path";
+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 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
+        uses: pnpm/action-setup@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: "22"
+          cache: "pnpm"
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile`,
+  yarn: `      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: "22"
+          cache: "yarn"
+
+      - name: Install dependencies
+        run: yarn install --frozen-lockfile`,
+  npm: `      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: "22"
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm ci`,
+  deno: `      - name: Setup Deno
+        uses: denoland/setup-deno@v2
+
+      - name: Install dependencies
+        run: deno install --frozen`
+};
+var buildCommand = (packageManager, script, args) => runScriptCommand(packageManager, script, { args });
+var generateWorkflow = ({ packageManager, scripts }) => {
+  const matrixEntries = [];
+  if (scripts.includes("check")) {
+    matrixEntries.push({
+      name: "lint",
+      command: buildCommand(packageManager, "check")
+    });
+  }
+  if (scripts.includes("format")) {
+    matrixEntries.push({
+      name: "format",
+      command: buildCommand(packageManager, "format", ["--check"])
+    });
+  }
+  if (scripts.includes("typecheck")) {
+    matrixEntries.push({
+      name: "types",
+      command: buildCommand(packageManager, "typecheck")
+    });
+  }
+  if (scripts.includes("check:monorepo")) {
+    matrixEntries.push({
+      name: "monorepo",
+      command: buildCommand(packageManager, "check:monorepo")
+    });
+  }
+  if (matrixEntries.length === 0) {
+    return null;
+  }
+  const matrixInclude = matrixEntries.map((entry) => `          - name: ${entry.name}
+            command: ${entry.command}`).join(`
+`);
+  const workflow = `name: adamantite
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: \${{ github.workflow }}-\${{ github.ref }}
+  cancel-in-progress: true
+
+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) => ["check", "format", "typecheck", "check:monorepo"].includes(script));
+var github = {
+  workflowPath: ".github/workflows/adamantite.yml",
+  exists: () => checkIfExists(join4(process6.cwd(), ".github", "workflows", "adamantite.yml")),
+  create: (options) => safeTry7(async function* () {
+    const workflowDir = join4(process6.cwd(), ".github", "workflows");
+    yield* fromPromise4(mkdir(workflowDir, { recursive: true }), (error) => Fault7.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 }));
+    const workflowContent = generateWorkflow(options);
+    if (!workflowContent) {
+      return ok7();
+    }
+    yield* fromPromise4(writeFile3(join4(workflowDir, "adamantite.yml"), workflowContent), (error) => Fault7.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: join4(workflowDir, "adamantite.yml") }));
+    return ok7();
+  }),
+  update: (options) => safeTry7(async function* () {
+    const workflowPath = join4(process6.cwd(), ".github", "workflows", "adamantite.yml");
+    const workflowContent = generateWorkflow(options);
+    if (!workflowContent) {
+      return ok7();
+    }
+    yield* fromPromise4(writeFile3(workflowPath, workflowContent), (error) => Fault7.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 ok7();
+  })
+};
+
+// src/helpers/editors/vscode.ts
+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 fromPromise4, 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"
     }
   },
-  exists: () => checkIfExists(join4(process.cwd(), ".vscode", "settings.json")),
+  exists: () => checkIfExists(join5(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."));
+    const vscodePath = join5(process.cwd(), ".vscode");
+    yield* fromPromise5(mkdir2(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* fromPromise5(writeFile4(join5(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: () => 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 vscodePath = join5(process.cwd(), ".vscode", "settings.json");
+    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* 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 }));
+    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();
   })
 };
 
-// src/helpers/tsconfig.ts
-import { readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join5 } from "node:path";
+// src/helpers/packages/sherif.ts
+var sherif = {
+  name: "sherif",
+  version: "1.9.0"
+};
+
+// 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 fromPromise5, 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: "tsc",
   config: { extends: "adamantite/typescript" },
-  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.")),
+  exists: () => checkIfExists(join6(process.cwd(), "tsconfig.json")),
+  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* 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 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);
-    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."));
+    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();
   })
 };
@@ -436,23 +560,23 @@ var installDependencies = (packages) => safeTry10(async function* () {
   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}`));
+    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 = () => 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();
+    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();
+    spinner2.stop("oxlint config created successfully.");
   }
   return ok10();
 });
@@ -476,9 +600,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":
@@ -491,7 +613,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";
@@ -500,23 +622,23 @@ 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* 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") }));
+  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") }));
   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()) {
+  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();
@@ -538,6 +660,20 @@ var setupEditors = (editors) => safeTry10(async function* () {
   if (editors.includes("zed")) {}
   return ok10();
 });
+var setupGitHubActions = (packageManager, scripts) => safeTry10(async function* () {
+  const spinner2 = p.spinner();
+  spinner2.start("Setting up GitHub Actions workflow...");
+  if (await github.exists()) {
+    spinner2.message("`.github/workflows/adamantite.yml` found, updating...");
+    yield* github.update({ packageManager, scripts });
+    spinner2.stop("GitHub Actions workflow updated successfully.");
+  } else {
+    spinner2.message("Creating `.github/workflows/adamantite.yml`...");
+    yield* github.create({ packageManager, scripts });
+    spinner2.stop("GitHub Actions workflow created successfully.");
+  }
+  return ok10();
+});
 var init_default = defineCommand({
   command: "init",
   describe: "Initialize Adamantite in the current directory",
@@ -555,12 +691,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"
         },
@@ -589,7 +725,7 @@ var init_default = defineCommand({
       ]
     }));
     if (p.isCancel(scripts)) {
-      return err4(Fault10.create("OPERATION_CANCELLED"));
+      return err6(Fault10.create("OPERATION_CANCELLED"));
     }
     const editors = yield* fromSafePromise(p.multiselect({
       message: "Which editors do you want to configure? (optional)",
@@ -600,15 +736,28 @@ 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;
+    if (hasCIScripts) {
+      const response = yield* fromSafePromise(p.confirm({
+        message: "Do you want to add a GitHub Actions workflow to run checks in CI?",
+        initialValue: false
+      }));
+      if (p.isCancel(response)) {
+        return err6(Fault10.create("OPERATION_CANCELLED"));
+      }
+      enableGitHubActions = response;
     }
-    const hasBiome = scripts.includes("check") || scripts.includes("fix");
+    const hasOxlint = 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}`);
@@ -623,14 +772,17 @@ var init_default = defineCommand({
     if (hasOxfmt) {
       yield* setupOxfmtConfig();
     }
-    if (hasBiome) {
-      yield* setupBiomeConfig();
+    if (hasOxlint) {
+      yield* setupOxlintConfig();
     }
     yield* addScripts(scripts);
     if (hasTypecheck) {
       yield* setupTypescript();
     }
     yield* setupEditors(editors);
+    if (enableGitHubActions) {
+      yield* setupGitHubActions(packageManager, scripts);
+    }
     return ok10();
   }).match(() => {
     p.outro("\uD83D\uDCA0 Adamantite initialized successfully!");
@@ -653,10 +805,10 @@ var init_default = defineCommand({
 
 // src/commands/monorepo.ts
 import process8 from "node:process";
-import { log as log6 } from "@clack/prompts";
+import { log as log5 } from "@clack/prompts";
 import { Fault as Fault11 } from "faultier";
 import { ok as ok11, safeTry as safeTry11 } from "neverthrow";
-import { dlxCommand as dlxCommand5 } from "nypm";
+import { dlxCommand as dlxCommand4 } from "nypm";
 var monorepo_default = defineCommand({
   command: "monorepo",
   describe: "Find and fix monorepo-specific issues using Sherif",
@@ -670,35 +822,75 @@ var monorepo_default = defineCommand({
     if (argv.fix) {
       args.push("--fix");
     }
-    const command = dlxCommand5(packageManager, sherif.name, { args });
+    const command = dlxCommand4(packageManager, sherif.name, { args });
     yield* runCommand(command);
-    return ok11(undefined);
+    return ok11();
   }).match(() => {
     process8.exit(0);
   }, (error) => {
     if (Fault11.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
-      log6.error(error.flatten());
+      log5.error(error.flatten());
     }
     process8.exit(1);
   })
 });
 
-// src/commands/update.ts
+// src/commands/typecheck.ts
 import process9 from "node:process";
-import { cancel as cancel2, confirm, intro as intro2, isCancel as isCancel2, log as log7, 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 fromPromise7, 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.name, { 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({
@@ -711,7 +903,7 @@ var update_default = defineCommand({
     }
     if (updates.length === 0) {
       log7.success("All adamantite dependencies are already up to date!");
-      return ok12("no-updates");
+      return ok13("no-updates");
     }
     log7.message("The following dependencies will be updated:");
     log7.message("");
@@ -719,22 +911,22 @@ var update_default = defineCommand({
       log7.message(`  ${dep.name}: ${dep.currentVersion} → ${dep.targetVersion}`);
     }
     log7.message("");
-    const shouldUpdate = yield* fromSafePromise2(confirm({
+    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* fromPromise7(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");
@@ -743,21 +935,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)) {
+    if (Fault13.isFault(error)) {
       log7.error(error.flatten());
     } else {
       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.16.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();
+var version = await "0.18.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();