adamantite 0.19.0 → 0.22.0

package/dist/index.js

@@ -2,18 +2,48 @@
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 
-// src/commands/check.ts
+// src/commands/analyze.ts
 import process3 from "node:process";
 import { log } from "@clack/prompts";
 import { Fault as Fault3 } from "faultier";
 import { ok as ok3, safeTry as safeTry3 } from "neverthrow";
 import { dlxCommand } from "nypm";
 
-// src/helpers/packages/oxlint.ts
+// src/helpers/packages/knip.ts
 import { readFile as readFile2, writeFile } from "node:fs/promises";
 import { join as join2 } from "node:path";
 import { Fault as Fault2 } from "faultier";
 import { err as err2, fromPromise as fromPromise2, ok as ok2, safeTry as safeTry2 } from "neverthrow";
+// presets/knip.json
+var knip_default = {
+  $schema: "https://unpkg.com/knip@5/schema.json",
+  rules: {
+    files: "error",
+    dependencies: "error",
+    devDependencies: "error",
+    optionalPeerDependencies: "warn",
+    unlisted: "error",
+    binaries: "error",
+    unresolved: "error",
+    exports: "warn",
+    nsExports: "warn",
+    types: "warn",
+    nsTypes: "warn",
+    enumMembers: "off",
+    classMembers: "off",
+    duplicates: "warn"
+  },
+  ignoreExportsUsedInFile: true,
+  ignoreFiles: [
+    "**/dist/**",
+    "**/build/**",
+    "**/coverage/**",
+    "**/.next/**",
+    "**/.vercel/**",
+    "**/.turbo/**"
+  ],
+  ignore: ["**/*.d.ts"]
+};
 
 // src/utils.ts
 import { spawnSync } from "node:child_process";
@@ -42,6 +72,15 @@ var runCommand = (command) => {
 };
 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 checkCliExists = (command) => {
+  const result = spawnSync(process2.platform === "win32" ? "where" : "which", [command], {
+    stdio: "pipe"
+  });
+  if (result.status !== 0) {
+    return err(Fault.create("CLI_NOT_FOUND").withDescription(`CLI '${command}' not found`, `The '${command}' command is not available in your PATH.`).withContext({ command }));
+  }
+  return ok(true);
+};
 var parseJson = (content) => {
   const errors = [];
   const parsed = parse(content, errors);
@@ -81,16 +120,100 @@ d8(  888  888   888  d8(  888   888   888   888  d8(  888   888   888    888 .
   }
 }
 
+// src/helpers/packages/knip.ts
+var knip = {
+  name: "knip",
+  version: "5.79.0",
+  config: knip_default,
+  exists: async () => {
+    if (await checkIfExists(join2(process.cwd(), "knip.json"))) {
+      return { path: join2(process.cwd(), "knip.json") };
+    }
+    if (await checkIfExists(join2(process.cwd(), "knip.jsonc"))) {
+      return { path: join2(process.cwd(), "knip.jsonc") };
+    }
+    return { path: null };
+  },
+  create: () => fromPromise2(writeFile(join2(process.cwd(), "knip.json"), JSON.stringify(knip.config, null, 2)), (error) => Fault2.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write knip configuration", "We're unable to write the knip configuration to the current directory.")),
+  update: () => safeTry2(async function* () {
+    const exists = await knip.exists();
+    if (!exists.path) {
+      return err2(Fault2.create("FILE_NOT_FOUND").withDescription("No `knip.json` or `knip.jsonc` found", "We're unable to find a knip configuration in the current directory."));
+    }
+    const knipFile = yield* fromPromise2(readFile2(exists.path, "utf8"), (error) => Fault2.wrap(error).withTag("FAILED_TO_READ_FILE").withDescription("Failed to read knip configuration", "We're unable to read the knip configuration from the current directory."));
+    const existingConfig = yield* parseJson(knipFile);
+    if (!isJsonObject(existingConfig)) {
+      return err2(Fault2.create("INVALID_CONFIG_FORMAT").withDescription("Invalid knip configuration format", "The knip configuration must be a JSON object."));
+    }
+    const mergedConfig = yield* mergeConfig(existingConfig, knip.config);
+    const isJsonc = exists.path.endsWith(".jsonc");
+    mergedConfig.$schema = isJsonc ? "https://unpkg.com/knip@5/schema-jsonc.json" : "https://unpkg.com/knip@5/schema.json";
+    yield* fromPromise2(writeFile(exists.path, JSON.stringify(mergedConfig, null, 2)), (error) => Fault2.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write knip configuration", "We're unable to write the knip configuration to the current directory.").withContext({ path: exists.path }));
+    return ok2();
+  })
+};
+
+// src/commands/analyze.ts
+var analyze_default = defineCommand({
+  command: "analyze [files..]",
+  describe: "Find unused dependencies, exports, and files using knip",
+  builder: (yargs) => yargs.positional("files", {
+    describe: "Specific files to analyze (optional)",
+    type: "string",
+    array: true
+  }).option("fix", {
+    type: "boolean",
+    description: "Automatically fix issues"
+  }).option("strict", {
+    type: "boolean",
+    description: "Enable strict mode"
+  }),
+  handler: (argv) => safeTry3(async function* () {
+    const packageManager = yield* getPackageManagerName();
+    const args = [];
+    if (argv.fix) {
+      args.push("--fix", "--allow-remove-files");
+    }
+    if (argv.strict) {
+      args.push("--production", "--strict");
+    }
+    if (argv.files && argv.files.length > 0) {
+      args.push(...argv.files);
+    }
+    const command = dlxCommand(packageManager, knip.name, { args });
+    yield* runCommand(command);
+    return ok3();
+  }).match(() => {
+    process3.exit(0);
+  }, (error) => {
+    if (Fault3.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
+      log.error(error.flatten());
+    }
+    process3.exit(1);
+  })
+});
+
+// src/commands/check.ts
+import process4 from "node:process";
+import { log as log2 } from "@clack/prompts";
+import { Fault as Fault5 } from "faultier";
+import { ok as ok5, safeTry as safeTry5 } from "neverthrow";
+import { dlxCommand as dlxCommand2 } from "nypm";
+
 // src/helpers/packages/oxlint.ts
+import { readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+import { Fault as Fault4 } from "faultier";
+import { err as err3, fromPromise as fromPromise3, ok as ok4, safeTry as safeTry4 } from "neverthrow";
 var oxlint = {
   name: "oxlint",
-  version: "1.35.0",
+  version: "1.36.0",
   config: {
     $schema: "./node_modules/oxlint/configuration_schema.json"
   },
   exists: async () => {
-    if (await checkIfExists(join2(process.cwd(), ".oxlintrc.json"))) {
-      return { path: join2(process.cwd(), ".oxlintrc.json") };
+    if (await checkIfExists(join3(process.cwd(), ".oxlintrc.json"))) {
+      return { path: join3(process.cwd(), ".oxlintrc.json") };
     }
     return { path: null };
   },
@@ -99,17 +222,17 @@ var oxlint = {
     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."));
+    return fromPromise3(writeFile2(join3(process.cwd(), ".oxlintrc.json"), JSON.stringify({ ...oxlint.config, extends: extendsArray }, null, 2)), (error) => Fault4.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write oxlint configuration", "We're unable to write the oxlint configuration to the current directory."));
   },
-  update: (presets = []) => safeTry2(async function* () {
+  update: (presets = []) => safeTry4(async function* () {
     const exists = await oxlint.exists();
     if (!exists.path) {
-      return err2(Fault2.create("FILE_NOT_FOUND").withDescription("No `.oxlintrc.json` found", "We're unable to find an oxlint configuration in the current directory."));
+      return err3(Fault4.create("FILE_NOT_FOUND").withDescription("No `.oxlintrc.json` found", "We're unable to find an oxlint configuration in the current directory."));
     }
-    const oxlintFile = yield* 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 oxlintFile = yield* fromPromise3(readFile3(exists.path, "utf8"), (error) => Fault4.wrap(error).withTag("FAILED_TO_READ_FILE").withDescription("Failed to read oxlint configuration", "We're unable to read the oxlint configuration from the current directory."));
     const existingConfig = yield* parseJson(oxlintFile);
     if (!isJsonObject(existingConfig)) {
-      return err2(Fault2.create("INVALID_CONFIG_FORMAT").withDescription("Invalid oxlint configuration format", "The oxlint configuration must be a JSON object."));
+      return err3(Fault4.create("INVALID_CONFIG_FORMAT").withDescription("Invalid oxlint configuration format", "The oxlint configuration must be a JSON object."));
     }
     const newConfig = { ...existingConfig };
     const extendsArray = Array.isArray(newConfig.extends) ? newConfig.extends : typeof newConfig.extends === "string" ? [newConfig.extends] : [];
@@ -126,13 +249,13 @@ var oxlint = {
     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();
+    yield* fromPromise3(writeFile2(exists.path, JSON.stringify(mergedConfig, null, 2)), (error) => Fault4.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write oxlint configuration", "We're unable to write the oxlint configuration to the current directory.").withContext({ path: exists.path }));
+    return ok4();
   })
 };
 var tsgolint = {
   name: "oxlint-tsgolint",
-  version: "0.10.0"
+  version: "0.10.1"
 };
 
 // src/commands/check.ts
@@ -144,31 +267,31 @@ var check_default = defineCommand({
     type: "string",
     array: true
   }),
-  handler: (argv) => safeTry3(async function* () {
+  handler: (argv) => safeTry5(async function* () {
     const packageManager = yield* getPackageManagerName();
     const args = ["--type-aware"];
     if (argv.files && argv.files.length > 0) {
       args.push(...argv.files);
     }
-    const command = dlxCommand(packageManager, oxlint.name, { args });
+    const command = dlxCommand2(packageManager, oxlint.name, { args });
     const result = yield* runCommand(command);
-    return ok3(result);
+    return ok5(result);
   }).match(() => {
-    process3.exit(0);
+    process4.exit(0);
   }, (error) => {
-    if (Fault3.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
-      log.error(error.flatten());
+    if (Fault5.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
+      log2.error(error.flatten());
     }
-    process3.exit(1);
+    process4.exit(1);
   })
 });
 
 // src/commands/fix.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 safeTry4 } from "neverthrow";
-import { dlxCommand as dlxCommand2 } from "nypm";
+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 oxlint",
@@ -189,7 +312,7 @@ var fix_default = defineCommand({
     description: "Apply all fixes, including suggested and dangerous fixes",
     default: false
   }),
-  handler: (argv) => safeTry4(async function* () {
+  handler: (argv) => safeTry6(async function* () {
     const packageManager = yield* getPackageManagerName();
     const args = new Set(["--type-aware", "--fix"]);
     if (argv.suggested) {
@@ -207,31 +330,31 @@ var fix_default = defineCommand({
         args.add(file);
       }
     }
-    const command = dlxCommand2(packageManager, oxlint.name, { args: Array.from(args) });
+    const command = dlxCommand3(packageManager, oxlint.name, { args: Array.from(args) });
     yield* runCommand(command);
-    return ok4();
+    return ok6();
   }).match(() => {
-    process4.exit(0);
+    process5.exit(0);
   }, (error) => {
-    if (Fault4.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
-      log2.error(error.flatten());
+    if (Fault6.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
+      log3.error(error.flatten());
     }
-    process4.exit(1);
+    process5.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";
+import process6 from "node:process";
+import { log as log4 } from "@clack/prompts";
+import { Fault as Fault8 } from "faultier";
+import { ok as ok8, safeTry as safeTry8 } from "neverthrow";
+import { dlxCommand as dlxCommand4 } from "nypm";
 
 // 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 Fault5 } from "faultier";
-import { err as err3, fromPromise as fromPromise3, ok as ok5, safeTry as safeTry5 } from "neverthrow";
+import { readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+import { Fault as Fault7 } from "faultier";
+import { err as err4, fromPromise as fromPromise4, ok as ok7, safeTry as safeTry7 } from "neverthrow";
 // presets/oxfmt.json
 var oxfmt_default = {
   arrowParens: "always",
@@ -274,35 +397,35 @@ var oxfmt_default = {
 // src/helpers/packages/oxfmt.ts
 var oxfmt = {
   name: "oxfmt",
-  version: "0.20.0",
+  version: "0.21.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(join4(process.cwd(), ".oxfmtrc.jsonc"))) {
+      return { path: join4(process.cwd(), ".oxfmtrc.jsonc") };
     }
-    if (await checkIfExists(join3(process.cwd(), ".oxfmtrc.json"))) {
-      return { path: join3(process.cwd(), ".oxfmtrc.json") };
+    if (await checkIfExists(join4(process.cwd(), ".oxfmtrc.json"))) {
+      return { path: join4(process.cwd(), ".oxfmtrc.json") };
     }
     return { path: null };
   },
-  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* () {
+  create: () => fromPromise4(writeFile3(join4(process.cwd(), ".oxfmtrc.jsonc"), JSON.stringify(oxfmt.config, null, 2)), (error) => Fault7.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write oxfmt configuration", "We're unable to write the oxfmt configuration to the current directory.")),
+  update: () => safeTry7(async function* () {
     const exists = await oxfmt.exists();
     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."));
+      return err4(Fault7.create("FILE_NOT_FOUND").withDescription("No `.oxfmtrc.jsonc` or `.oxfmtrc.json` found", "We're unable to find an oxfmt configuration in the current directory."));
     }
-    const oxfmtFile = yield* 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 oxfmtFile = yield* fromPromise4(readFile4(exists.path, "utf8"), (error) => Fault7.wrap(error).withTag("FAILED_TO_READ_FILE").withDescription("Failed to read oxfmt configuration", "We're unable to read the oxfmt configuration from the current directory."));
     const existingConfig = yield* parseJson(oxfmtFile);
     if (!isJsonObject(existingConfig)) {
-      return err3(Fault5.create("INVALID_CONFIG_FORMAT").withDescription("Invalid oxfmt configuration format", "The oxfmt configuration must be a JSON object."));
+      return err4(Fault7.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) => 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();
+    yield* fromPromise4(writeFile3(exists.path, JSON.stringify(mergedConfig, null, 2)), (error) => Fault7.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write oxfmt configuration", "We're unable to write the oxfmt configuration to the current directory.").withContext({ path: exists.path }));
+    return ok7();
   })
 };
 
@@ -318,7 +441,7 @@ var format_default = defineCommand({
     type: "boolean",
     description: "Check if files are formatted without writing"
   }),
-  handler: (argv) => safeTry6(async function* () {
+  handler: (argv) => safeTry8(async function* () {
     const packageManager = yield* getPackageManagerName();
     const args = [];
     if (argv.check) {
@@ -327,34 +450,34 @@ var format_default = defineCommand({
     if (argv.files && argv.files.length > 0) {
       args.push(...argv.files);
     }
-    const command = dlxCommand3(packageManager, oxfmt.name, { args });
+    const command = dlxCommand4(packageManager, oxfmt.name, { args });
     const result = yield* runCommand(command);
-    return ok6(result);
+    return ok8(result);
   }).match(() => {
-    process5.exit(0);
+    process6.exit(0);
   }, (error) => {
-    if (Fault6.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
-      log3.error(error.flatten());
+    if (Fault8.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
+      log4.error(error.flatten());
     }
-    process5.exit(1);
+    process6.exit(1);
   })
 });
 
 // src/commands/init.ts
-import { writeFile as writeFile6 } from "node:fs/promises";
-import { join as join7 } from "node:path";
-import process7 from "node:process";
+import { writeFile as writeFile7 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+import process8 from "node:process";
 import * as p from "@clack/prompts";
-import { Fault as Fault10 } from "faultier";
-import { err as err6, fromPromise as fromPromise7, fromSafePromise, ok as ok10, safeTry as safeTry10 } from "neverthrow";
+import { Fault as Fault12 } from "faultier";
+import { err as err7, fromPromise as fromPromise8, fromSafePromise, ok as ok12, safeTry as safeTry12 } from "neverthrow";
 import { addDevDependency } from "nypm";
 
 // 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 { mkdir, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+import process7 from "node:process";
+import { Fault as Fault9 } from "faultier";
+import { fromPromise as fromPromise5, ok as ok9, safeTry as safeTry9 } from "neverthrow";
 import { runScriptCommand } from "nypm";
 var setupSteps = {
   bun: `      - name: Setup Bun
@@ -432,6 +555,12 @@ var generateWorkflow = ({ packageManager, scripts }) => {
       command: buildCommand(packageManager, "check:monorepo")
     });
   }
+  if (scripts.includes("analyze")) {
+    matrixEntries.push({
+      name: "analyze",
+      command: buildCommand(packageManager, "analyze")
+    });
+  }
   if (matrixEntries.length === 0) {
     return null;
   }
@@ -476,65 +605,108 @@ ${setupSteps[packageManager]}
   return `${workflow}
 `;
 };
-var hasCICompatibleScripts = (scripts) => scripts.some((script) => ["check", "format", "typecheck", "check:monorepo"].includes(script));
+var CI_COMPATIBLE_SCRIPTS = new Set([
+  "check",
+  "format",
+  "typecheck",
+  "check:monorepo",
+  "analyze"
+]);
+var hasCICompatibleScripts = (scripts) => scripts.some((script) => CI_COMPATIBLE_SCRIPTS.has(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 }));
+  exists: () => checkIfExists(join5(process7.cwd(), ".github", "workflows", "adamantite.yml")),
+  create: (options) => safeTry9(async function* () {
+    const workflowDir = join5(process7.cwd(), ".github", "workflows");
+    yield* fromPromise5(mkdir(workflowDir, { recursive: true }), (error) => Fault9.wrap(error).withTag("FAILED_TO_CREATE_DIRECTORY").withDescription("Failed to create .github/workflows directory", "We're unable to create the .github/workflows directory in the current directory.").withContext({ path: workflowDir }));
     const workflowContent = generateWorkflow(options);
     if (!workflowContent) {
-      return ok7();
+      return ok9();
     }
-    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();
+    yield* fromPromise5(writeFile4(join5(workflowDir, "adamantite.yml"), workflowContent), (error) => Fault9.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write GitHub Actions workflow", "We're unable to write the GitHub Actions workflow file.").withContext({ path: join5(workflowDir, "adamantite.yml") }));
+    return ok9();
   }),
-  update: (options) => safeTry7(async function* () {
-    const workflowPath = join4(process6.cwd(), ".github", "workflows", "adamantite.yml");
+  update: (options) => safeTry9(async function* () {
+    const workflowPath = join5(process7.cwd(), ".github", "workflows", "adamantite.yml");
     const workflowContent = generateWorkflow(options);
     if (!workflowContent) {
-      return ok7();
+      return ok9();
     }
-    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();
+    yield* fromPromise5(writeFile4(workflowPath, workflowContent), (error) => Fault9.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write GitHub Actions workflow", "We're unable to update the GitHub Actions workflow file.").withContext({ path: workflowPath }));
+    return ok9();
   })
 };
 
 // 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 { err as err4, fromPromise as fromPromise5, ok as ok8, safeTry as safeTry8 } from "neverthrow";
+import { mkdir as mkdir2, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+import { Fault as Fault10 } from "faultier";
+import { err as err5, fromPromise as fromPromise6, ok as ok10, safeTry as safeTry10 } from "neverthrow";
 var vscode = {
   config: {
     "typescript.tsdk": "node_modules/typescript/lib",
+    "editor.defaultFormatter": "oxc.oxc-vscode",
     "editor.formatOnSave": true,
     "editor.formatOnPaste": true,
     "editor.codeActionsOnSave": {
       "source.fixAll.oxc": "explicit"
     },
-    "[javascript][typescript][javascriptreact][typescriptreact][json][jsonc][css][graphql]": {
+    "[javascript]": {
+      "editor.defaultFormatter": "oxc.oxc-vscode"
+    },
+    "[typescript]": {
+      "editor.defaultFormatter": "oxc.oxc-vscode"
+    },
+    "[javascriptreact]": {
+      "editor.defaultFormatter": "oxc.oxc-vscode"
+    },
+    "[typescriptreact]": {
+      "editor.defaultFormatter": "oxc.oxc-vscode"
+    },
+    "[json]": {
+      "editor.defaultFormatter": "oxc.oxc-vscode"
+    },
+    "[jsonc]": {
+      "editor.defaultFormatter": "oxc.oxc-vscode"
+    },
+    "[css]": {
+      "editor.defaultFormatter": "oxc.oxc-vscode"
+    },
+    "[graphql]": {
       "editor.defaultFormatter": "oxc.oxc-vscode"
     }
   },
-  exists: () => checkIfExists(join5(process.cwd(), ".vscode", "settings.json")),
-  create: () => safeTry8(async function* () {
-    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();
+  exists: () => checkIfExists(join6(process.cwd(), ".vscode", "settings.json")),
+  cliExists: () => checkCliExists("code").mapErr((error) => Fault10.wrap(error).withTag("VSCODE_CLI_NOT_FOUND").withDescription("VS Code CLI not found", "The 'code' CLI command is not available. Please install the VS Code command-line tools by opening VS Code and running 'Shell Command: Install code command in PATH' from the command palette (Cmd+Shift+P).")),
+  create: () => safeTry10(async function* () {
+    const vscodePath = join6(process.cwd(), ".vscode");
+    yield* fromPromise6(mkdir2(vscodePath, { recursive: true }), (error) => Fault10.wrap(error).withTag("FAILED_TO_CREATE_DIRECTORY").withDescription("Failed to create .vscode directory", "We're unable to create the .vscode directory in the current directory.").withContext({ path: vscodePath }));
+    yield* fromPromise6(writeFile5(join6(vscodePath, "settings.json"), JSON.stringify(vscode.config, null, 2)), (error) => Fault10.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write .vscode/settings.json", "We're unable to write the .vscode/settings.json file in the current directory."));
+    return ok10();
   }),
-  update: () => safeTry8(async function* () {
-    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 }));
+  update: () => safeTry10(async function* () {
+    const vscodePath = join6(process.cwd(), ".vscode", "settings.json");
+    const vscodeFile = yield* fromPromise6(readFile5(vscodePath, "utf8"), (error) => Fault10.wrap(error).withTag("FAILED_TO_READ_FILE").withDescription("Failed to read .vscode/settings.json", "We're unable to read the .vscode/settings.json file in the current directory.").withContext({ path: vscodePath }));
     const existingConfig = yield* parseJson(vscodeFile);
     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."));
+      return err5(Fault10.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();
+    yield* fromPromise6(writeFile5(join6(process.cwd(), ".vscode", "settings.json"), JSON.stringify(newConfig, null, 2)), (error) => Fault10.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write .vscode/settings.json", "We're unable to write the .vscode/settings.json file in the current directory.").withContext({ path: vscodePath }));
+    return ok10();
+  }),
+  extension: (scripts = []) => safeTry10(function* () {
+    yield* vscode.cliExists();
+    if (scripts.includes("check") || scripts.includes("fix") || scripts.includes("format")) {
+      yield* runCommand("code --install-extension oxc.oxc-vscode").mapErr((error) => Fault10.wrap(error).withTag("FAILED_TO_INSTALL_EXTENSION").withDescription("Failed to install VS Code extension", "An error occurred while installing the VS Code extension."));
+    }
+    if (scripts.includes("analyze")) {
+      yield* runCommand("code --install-extension webpro.vscode-knip").mapErr((error) => Fault10.wrap(error).withTag("FAILED_TO_INSTALL_EXTENSION").withDescription("Failed to install VS Code extension", "An error occurred while installing the VS Code extension."));
+    }
+    if (scripts.includes("typecheck")) {
+      yield* runCommand("code --install-extension TypeScriptTeam.native-preview").mapErr((error) => Fault10.wrap(error).withTag("FAILED_TO_INSTALL_EXTENSION").withDescription("Failed to install VS Code extension", "An error occurred while installing the VS Code extension."));
+    }
+    return ok10();
   })
 };
 
@@ -545,42 +717,42 @@ var sherif = {
 };
 
 // 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 { err as err5, fromPromise as fromPromise6, ok as ok9, safeTry as safeTry9 } from "neverthrow";
+import { readFile as readFile6, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+import { Fault as Fault11 } from "faultier";
+import { err as err6, fromPromise as fromPromise7, ok as ok11, safeTry as safeTry11 } from "neverthrow";
 var typescript = {
   name: "@typescript/native-preview",
-  version: "7.0.0-dev.20251227.1",
+  version: "7.0.0-dev.20260103.1",
   command: "tsgo",
   config: { extends: "adamantite/typescript" },
-  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* 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."));
+  exists: () => checkIfExists(join7(process.cwd(), "tsconfig.json")),
+  create: () => fromPromise7(writeFile6(join7(process.cwd(), "tsconfig.json"), JSON.stringify(typescript.config, null, 2)), (error) => Fault11.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write tsconfig.json", "We're unable to write the tsconfig.json file in the current directory.")),
+  update: () => safeTry11(async function* () {
+    const tsconfigFile = yield* fromPromise7(readFile6(join7(process.cwd(), "tsconfig.json"), "utf8"), (error) => Fault11.wrap(error).withTag("FAILED_TO_READ_FILE").withDescription("Failed to read tsconfig.json", "We're unable to read the tsconfig.json file in the current directory."));
     const existingConfig = yield* parseJson(tsconfigFile);
     if (!isJsonObject(existingConfig)) {
-      return err5(Fault9.create("INVALID_CONFIG_FORMAT").withDescription("Invalid tsconfig.json format", "The tsconfig.json file must be a JSON object."));
+      return err6(Fault11.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();
+    yield* fromPromise7(writeFile6(join7(process.cwd(), "tsconfig.json"), JSON.stringify(newConfig, null, 2)), (error) => Fault11.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write tsconfig.json", "We're unable to write the tsconfig.json file in the current directory."));
+    return ok11();
   })
 };
 
 // src/commands/init.ts
-var installDependencies = (packages) => safeTry10(async function* () {
+var installDependencies = (packages) => safeTry12(async function* () {
   const s = p.spinner();
   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}`));
+    yield* fromPromise8(addDevDependency(pkg, { silent: true, workspace: isMonorepo }), (error) => Fault12.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage(`Failed to install ${pkg}`));
   }
   s.stop("Dependencies installed.");
-  return ok10();
+  return ok12();
 });
-var setupOxlintConfig = (presets) => safeTry10(async function* () {
+var setupOxlintConfig = (presets) => safeTry12(async function* () {
   const spinner2 = p.spinner();
   spinner2.start("Setting up oxlint config...");
   const oxlintPath = await oxlint.exists();
@@ -593,9 +765,9 @@ var setupOxlintConfig = (presets) => safeTry10(async function* () {
     yield* oxlint.create(presets);
     spinner2.stop("oxlint config created successfully.");
   }
-  return ok10();
+  return ok12();
 });
-var setupOxfmtConfig = () => safeTry10(async function* () {
+var setupOxfmtConfig = () => safeTry12(async function* () {
   const spinner2 = p.spinner();
   spinner2.start("Setting up oxfmt config...");
   const oxfmtPath = await oxfmt.exists();
@@ -608,10 +780,10 @@ var setupOxfmtConfig = () => safeTry10(async function* () {
     yield* oxfmt.create();
     spinner2.stop("oxfmt config created successfully.");
   }
-  return ok10();
+  return ok12();
 });
-var addScripts = (scripts) => safeTry10(async function* () {
-  const cwd = process7.cwd();
+var addScripts = (scripts) => safeTry12(async function* () {
+  const cwd = process8.cwd();
   const packageJson = yield* readPackageJson();
   const spinner2 = p.spinner();
   spinner2.start("Adding scripts to your `package.json`...");
@@ -636,15 +808,33 @@ var addScripts = (scripts) => safeTry10(async function* () {
       case "fix:monorepo":
         packageJson.scripts["fix:monorepo"] = "adamantite monorepo --fix";
         break;
+      case "analyze":
+        packageJson.scripts.analyze = "adamantite analyze";
+        break;
       default:
-        return err6(Fault10.create("UNKNOWN_SCRIPT").withContext({ script }));
+        return err7(Fault12.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") }));
+  yield* fromPromise8(writeFile7(join8(cwd, "package.json"), JSON.stringify(packageJson, null, 2)), (error) => Fault12.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write package.json", "We're unable to update the package.json file.").withContext({ path: join8(cwd, "package.json") }));
   spinner2.stop("Scripts added to your `package.json`");
-  return ok10();
+  return ok12();
 });
-var setupTypescript = () => safeTry10(async function* () {
+var setupKnipConfig = () => safeTry12(async function* () {
+  const spinner2 = p.spinner();
+  spinner2.start("Setting up knip config...");
+  const knipPath = await knip.exists();
+  if (knipPath.path) {
+    spinner2.message(`Found \`${knipPath.path}\`, updating...`);
+    yield* knip.update();
+    spinner2.stop("knip config updated successfully.");
+  } else {
+    spinner2.message("`knip.json` not found, creating...");
+    yield* knip.create();
+    spinner2.stop("knip config created successfully.");
+  }
+  return ok12();
+});
+var setupTypescript = () => safeTry12(async function* () {
   const spinner2 = p.spinner();
   spinner2.start("Setting up TypeScript config...");
   if (await typescript.exists()) {
@@ -656,9 +846,9 @@ var setupTypescript = () => safeTry10(async function* () {
     yield* typescript.create();
     spinner2.stop("`tsconfig.json` created successfully");
   }
-  return ok10();
+  return ok12();
 });
-var setupEditors = (editors) => safeTry10(async function* () {
+var setupEditors = (editors) => safeTry12(async function* () {
   if (editors.includes("vscode")) {
     const spinner2 = p.spinner();
     spinner2.start("Checking for `.vscode/settings.json`...");
@@ -673,9 +863,20 @@ var setupEditors = (editors) => safeTry10(async function* () {
     }
   }
   if (editors.includes("zed")) {}
-  return ok10();
+  return ok12();
 });
-var setupGitHubActions = (packageManager, scripts) => safeTry10(async function* () {
+var installEditorExtensions = (editors, scripts) => safeTry12(function* () {
+  const spinner2 = p.spinner();
+  spinner2.start("Installing editor extensions...");
+  if (editors.includes("vscode")) {
+    spinner2.message("Installing VS Code extension...");
+    yield* vscode.extension(scripts);
+  }
+  if (editors.includes("zed")) {}
+  spinner2.stop("Editor extensions installed successfully.");
+  return ok12();
+});
+var setupGitHubActions = (packageManager, scripts) => safeTry12(async function* () {
   const spinner2 = p.spinner();
   spinner2.start("Setting up GitHub Actions workflow...");
   if (await github.exists()) {
@@ -687,13 +888,13 @@ var setupGitHubActions = (packageManager, scripts) => safeTry10(async function*
     yield* github.create({ packageManager, scripts });
     spinner2.stop("GitHub Actions workflow created successfully.");
   }
-  return ok10();
+  return ok12();
 });
 var init_default = defineCommand({
   command: "init",
   describe: "Initialize Adamantite in the current directory",
   builder: (yargs) => yargs,
-  handler: () => safeTry10(async function* () {
+  handler: () => safeTry12(async function* () {
     const packageManager = yield* getPackageManagerName();
     printTitle();
     p.intro("\uD83D\uDCA0 adamantite init");
@@ -736,16 +937,20 @@ var init_default = defineCommand({
           value: "fix:monorepo",
           hint: isMonorepo ? undefined : "available for monorepo projects",
           disabled: !isMonorepo
+        },
+        {
+          label: "analyze - find unused dependencies, exports, and files using knip",
+          value: "analyze"
         }
       ]
     }));
     if (p.isCancel(scripts)) {
-      return err6(Fault10.create("OPERATION_CANCELLED"));
+      return err7(Fault12.create("OPERATION_CANCELLED"));
     }
     const hasOxlint = scripts.includes("check") || scripts.includes("fix");
     let presets = [];
     if (hasOxlint) {
-      const presetsResponse = yield* fromSafePromise(p.multiselect({
+      presets = yield* fromSafePromise(p.multiselect({
         message: "Which presets do you want to install? (core is always included)",
         options: [
           { label: "React", value: "react" },
@@ -757,10 +962,9 @@ var init_default = defineCommand({
         ],
         required: false
       }));
-      if (p.isCancel(presetsResponse)) {
-        return err6(Fault10.create("OPERATION_CANCELLED"));
+      if (p.isCancel(presets)) {
+        return err7(Fault12.create("OPERATION_CANCELLED"));
       }
-      presets = presetsResponse;
     }
     const editors = yield* fromSafePromise(p.multiselect({
       message: "Which editors do you want to configure? (optional)",
@@ -771,23 +975,33 @@ var init_default = defineCommand({
       required: false
     }));
     if (p.isCancel(editors)) {
-      return err6(Fault10.create("OPERATION_CANCELLED"));
+      return err7(Fault12.create("OPERATION_CANCELLED"));
+    }
+    let installExtensions = false;
+    if (editors.length > 0) {
+      const installExtensionsResponse = yield* fromSafePromise(p.confirm({
+        message: "Do you want to install the recommended editor extensions?",
+        initialValue: true
+      }));
+      if (p.isCancel(installExtensionsResponse)) {
+        return err7(Fault12.create("OPERATION_CANCELLED"));
+      }
+      installExtensions = installExtensionsResponse;
     }
     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
+      enableGitHubActions = yield* fromSafePromise(p.confirm({
+        message: "Do you want to add a GitHub Actions workflow to run checks in CI?"
       }));
-      if (p.isCancel(response)) {
-        return err6(Fault10.create("OPERATION_CANCELLED"));
+      if (p.isCancel(enableGitHubActions)) {
+        return err7(Fault12.create("OPERATION_CANCELLED"));
       }
-      enableGitHubActions = response;
     }
     const hasOxfmt = scripts.includes("format");
     const hasSherif = scripts.includes("check:monorepo") || scripts.includes("fix:monorepo");
     const hasTypecheck = scripts.includes("typecheck");
+    const hasKnip = scripts.includes("analyze");
     const dependencies = ["adamantite"];
     if (hasOxlint) {
       dependencies.push(`${oxlint.name}@${oxlint.version}`);
@@ -802,6 +1016,9 @@ var init_default = defineCommand({
     if (hasTypecheck) {
       dependencies.push(`${typescript.name}@${typescript.version}`);
     }
+    if (hasKnip) {
+      dependencies.push(`${knip.name}@${knip.version}`);
+    }
     yield* installDependencies(dependencies);
     if (hasOxfmt) {
       yield* setupOxfmtConfig();
@@ -809,40 +1026,46 @@ var init_default = defineCommand({
     if (hasOxlint) {
       yield* setupOxlintConfig(presets);
     }
+    if (hasKnip) {
+      yield* setupKnipConfig();
+    }
     yield* addScripts(scripts);
     if (hasTypecheck) {
       yield* setupTypescript();
     }
     yield* setupEditors(editors);
+    if (installExtensions) {
+      yield* installEditorExtensions(editors, scripts);
+    }
     if (enableGitHubActions) {
       yield* setupGitHubActions(packageManager, scripts);
     }
-    return ok10();
+    return ok12();
   }).match(() => {
     p.outro("\uD83D\uDCA0 Adamantite initialized successfully!");
-    process7.exit(0);
+    process8.exit(0);
   }, (error) => {
-    if (Fault10.isFault(error) && error.tag === "OPERATION_CANCELLED") {
+    if (Fault12.isFault(error) && error.tag === "OPERATION_CANCELLED") {
       p.cancel("You've cancelled the initialization process.");
-      process7.exit(0);
+      process8.exit(0);
     }
-    if (!Fault10.isFault(error)) {
+    if (!Fault12.isFault(error)) {
       p.log.error(`An unexpected error occurred: ${String(error)}`);
       p.cancel("Failed to initialize Adamantite");
-      process7.exit(1);
+      process8.exit(1);
     }
     p.log.error(error.flatten());
     p.cancel("Failed to initialize Adamantite");
-    process7.exit(1);
+    process8.exit(1);
   })
 });
 
 // src/commands/monorepo.ts
-import process8 from "node:process";
-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 dlxCommand4 } from "nypm";
+import process9 from "node:process";
+import { log as log6 } from "@clack/prompts";
+import { Fault as Fault13 } from "faultier";
+import { ok as ok13, safeTry as safeTry13 } from "neverthrow";
+import { dlxCommand as dlxCommand5 } from "nypm";
 var monorepo_default = defineCommand({
   command: "monorepo",
   describe: "Find and fix monorepo-specific issues using Sherif",
@@ -850,31 +1073,31 @@ var monorepo_default = defineCommand({
     type: "boolean",
     description: "Automatically fix issues"
   }),
-  handler: (argv) => safeTry11(async function* () {
+  handler: (argv) => safeTry13(async function* () {
     const packageManager = yield* getPackageManagerName();
     const args = [];
     if (argv.fix) {
       args.push("--fix");
     }
-    const command = dlxCommand4(packageManager, sherif.name, { args });
+    const command = dlxCommand5(packageManager, sherif.name, { args });
     yield* runCommand(command);
-    return ok11();
+    return ok13();
   }).match(() => {
-    process8.exit(0);
+    process9.exit(0);
   }, (error) => {
-    if (Fault11.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
-      log5.error(error.flatten());
+    if (Fault13.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
+      log6.error(error.flatten());
     }
-    process8.exit(1);
+    process9.exit(1);
   })
 });
 
 // src/commands/typecheck.ts
-import process9 from "node:process";
-import { log as log6 } from "@clack/prompts";
-import { Fault as Fault12 } from "faultier";
-import { ok as ok12, safeTry as safeTry12 } from "neverthrow";
-import { dlxCommand as dlxCommand5 } from "nypm";
+import process10 from "node:process";
+import { log as log7 } from "@clack/prompts";
+import { Fault as Fault14 } from "faultier";
+import { ok as ok14, safeTry as safeTry14 } from "neverthrow";
+import { dlxCommand as dlxCommand6 } from "nypm";
 var typecheck_default = defineCommand({
   command: "typecheck",
   describe: "Run TypeScript type checking",
@@ -887,7 +1110,7 @@ var typecheck_default = defineCommand({
     type: "boolean",
     description: "Run in watch mode"
   }),
-  handler: (argv) => safeTry12(async function* () {
+  handler: (argv) => safeTry14(async function* () {
     const packageManager = yield* getPackageManagerName();
     const args = ["--noEmit"];
     if (argv.project) {
@@ -896,30 +1119,30 @@ var typecheck_default = defineCommand({
     if (argv.watch) {
       args.push("--watch");
     }
-    const command = dlxCommand5(packageManager, typescript.command, { args });
+    const command = dlxCommand6(packageManager, typescript.command, { args });
     const result = yield* runCommand(command);
-    return ok12(result);
+    return ok14(result);
   }).match(() => {
-    process9.exit(0);
+    process10.exit(0);
   }, (error) => {
-    if (Fault12.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
-      log6.error(error.flatten());
+    if (Fault14.isFault(error) && error.tag === "NO_PACKAGE_MANAGER") {
+      log7.error(error.flatten());
     }
-    process9.exit(1);
+    process10.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 process11 from "node:process";
+import { cancel as cancel2, confirm as confirm2, intro as intro2, isCancel as isCancel2, log as log8, outro as outro2, spinner as spinner2 } from "@clack/prompts";
+import { Fault as Fault15 } from "faultier";
+import { err as err8, fromPromise as fromPromise9, fromSafePromise as fromSafePromise2, ok as ok15, safeTry as safeTry15 } from "neverthrow";
 import { addDevDependency as addDevDependency2 } from "nypm";
 var update_default = defineCommand({
   command: "update",
   describe: "Update adamantite dependencies to latest compatible versions",
   builder: (yargs) => yargs,
-  handler: () => safeTry13(async function* () {
+  handler: () => safeTry15(async function* () {
     const packageJson = yield* readPackageJson();
     printTitle();
     intro2("\uD83D\uDCA0 adamantite update");
@@ -936,31 +1159,31 @@ var update_default = defineCommand({
       }
     }
     if (updates.length === 0) {
-      log7.success("All adamantite dependencies are already up to date!");
-      return ok13("no-updates");
+      log8.success("All adamantite dependencies are already up to date!");
+      return ok15("no-updates");
     }
-    log7.message("The following dependencies will be updated:");
-    log7.message("");
+    log8.message("The following dependencies will be updated:");
+    log8.message("");
     for (const dep of updates) {
-      log7.message(`  ${dep.name}: ${dep.currentVersion} → ${dep.targetVersion}`);
+      log8.message(`  ${dep.name}: ${dep.currentVersion} → ${dep.targetVersion}`);
     }
-    log7.message("");
+    log8.message("");
     const shouldUpdate = yield* fromSafePromise2(confirm2({
       message: "Do you want to proceed with these updates?"
     }));
     if (isCancel2(shouldUpdate)) {
-      return err7(Fault13.create("OPERATION_CANCELLED"));
+      return err8(Fault15.create("OPERATION_CANCELLED"));
     }
     if (!shouldUpdate) {
-      return ok13("cancelled");
+      return ok15("cancelled");
     }
     const s = spinner2();
     s.start("Updating dependencies...");
     for (const dep of updates) {
-      yield* fromPromise8(addDevDependency2(`${dep.name}@${dep.targetVersion}`), (error) => Fault13.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage(`Failed to update ${dep.name}`));
+      yield* fromPromise9(addDevDependency2(`${dep.name}@${dep.targetVersion}`), (error) => Fault15.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage(`Failed to update ${dep.name}`));
     }
     s.stop("Dependencies updated successfully");
-    return ok13("updated");
+    return ok15("updated");
   }).match((value) => {
     if (value === "no-updates") {
       outro2("✅ No updates needed");
@@ -969,22 +1192,22 @@ var update_default = defineCommand({
     } else if (value === "updated") {
       outro2("✅ Dependencies updated successfully!");
     }
-    process10.exit(0);
+    process11.exit(0);
   }, (error) => {
-    if (Fault13.isFault(error) && error.tag === "OPERATION_CANCELLED") {
+    if (Fault15.isFault(error) && error.tag === "OPERATION_CANCELLED") {
       cancel2("You've cancelled the update process.");
-      process10.exit(0);
+      process11.exit(0);
     }
-    if (Fault13.isFault(error)) {
-      log7.error(error.flatten());
+    if (Fault15.isFault(error)) {
+      log8.error(error.flatten());
     } else {
-      log7.error(String(error));
+      log8.error(String(error));
     }
     cancel2("Failed to update dependencies");
-    process10.exit(1);
+    process11.exit(1);
   })
 });
 
 // src/index.ts
-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();
+var version = await "0.22.0";
+yargs(hideBin(process.argv)).scriptName("adamantite").version(version).command(analyze_default).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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adamantite",
-  "version": "0.19.0",
+  "version": "0.22.0",
   "description": "An strict and opinionated set of presets for modern TypeScript applications",
   "keywords": [
     "adamantite",
@@ -37,13 +37,15 @@
     "#presets/*": "./presets/*"
   },
   "exports": {
+    "./analyze": "./presets/knip.json",
+    "./format": "./presets/oxfmt.json",
     "./lint": "./presets/oxlint/core.json",
     "./lint/*": "./presets/oxlint/*.json",
-    "./format": "./presets/oxfmt.json",
     "./typescript": "./presets/tsconfig.json",
     "./presets/*": "./presets/*"
   },
   "scripts": {
+    "analyze": "bun run src/index.ts analyze",
     "build": "bunup",
     "bump:deps": "bun update --interactive",
     "check": "bun run src/index.ts check",
@@ -59,7 +61,6 @@
   },
   "dependencies": {
     "@clack/prompts": "1.0.0-alpha.9",
-    "consola": "3.4.2",
     "defu": "6.1.4",
     "faultier": "^1.1.0",
     "jsonc-parser": "3.3.1",
@@ -71,11 +72,12 @@
     "@changesets/cli": "2.29.8",
     "@types/bun": "1.3.5",
     "@types/yargs": "17.0.35",
-    "@typescript/native-preview": "7.0.0-dev.20251227.1",
-    "bunup": "0.16.11",
-    "oxfmt": "0.20.0",
-    "oxlint": "1.35.0",
-    "oxlint-tsgolint": "0.10.0",
+    "@typescript/native-preview": "7.0.0-dev.20260103.1",
+    "bunup": "0.16.17",
+    "knip": "5.79.0",
+    "oxfmt": "0.21.0",
+    "oxlint": "1.36.0",
+    "oxlint-tsgolint": "0.10.1",
     "sherif": "1.9.0",
     "type-fest": "5.3.1",
     "typescript": "5.9.3"

package/presets/knip.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "https://unpkg.com/knip@5/schema.json",
+  "rules": {
+    "files": "error",
+    "dependencies": "error",
+    "devDependencies": "error",
+    "optionalPeerDependencies": "warn",
+    "unlisted": "error",
+    "binaries": "error",
+    "unresolved": "error",
+    "exports": "warn",
+    "nsExports": "warn",
+    "types": "warn",
+    "nsTypes": "warn",
+    "enumMembers": "off",
+    "classMembers": "off",
+    "duplicates": "warn"
+  },
+  "ignoreExportsUsedInFile": true,
+  "ignoreFiles": [
+    "**/dist/**",
+    "**/build/**",
+    "**/coverage/**",
+    "**/.next/**",
+    "**/.vercel/**",
+    "**/.turbo/**"
+  ],
+  "ignore": ["**/*.d.ts"]
+}

package/presets/oxlint/core.json

@@ -44,7 +44,10 @@
     "no-unsafe-finally": "error",
     "no-unsafe-negation": "error",
     "no-unsafe-optional-chaining": "error",
-    "no-unused-expressions": "error",
+    "no-unused-expressions": [
+      "error",
+      { "allowTaggedTemplates": true, "allowTernary": true, "enforceForJSX": true }
+    ],
     "no-unused-labels": "error",
     "no-unused-private-class-members": "error",
     "no-unused-vars": "error",