adamantite 0.13.2 → 0.14.0

package/README.md

@@ -165,7 +165,7 @@ Adamantite's Biome preset includes:
   - React/JSX patterns
 - **File Patterns**: Pre-configured for TypeScript, JavaScript, JSON, and more
 
-### TypeScript Configuration ([presets/tsconfig.json](./src/presets/tsconfig.json))
+### TypeScript Configuration ([presets/tsconfig.json](./presets/tsconfig.json))
 
 The TypeScript preset includes strict settings for maximum type safety:
 

package/bin/adamantite

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-import("../dist/index.js")
+import("../dist/index.mjs")

package/dist/index.mjs

@@ -1,12 +1,14 @@
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { execSync } from "child_process";
+import process$1 from "process";
+import { err, fromPromise, fromSafePromise, fromThrowable, ok, safeTry } from "neverthrow";
 import { addDevDependency, detectPackageManager, dlxCommand } from "nypm";
 import { access, mkdir, readFile, writeFile } from "fs/promises";
 import { join } from "path";
+import { Fault } from "faultier";
+import { execSync } from "child_process";
 import defu from "defu";
 import { parse } from "jsonc-parser";
-import process$1 from "process";
 import { cancel, confirm, intro, isCancel, log, multiselect, outro, spinner } from "@clack/prompts";
 import { readFileSync } from "fs";
 
@@ -14,51 +16,20 @@ import { readFileSync } from "fs";
 function defineCommand(input) {
 	return input;
 }
-async function getPackageManagerName() {
-	const result = await detectPackageManager(process$1.cwd());
-	if (!result) throw new Error("No package manager found");
-	const { warnings, ...packageManager } = result;
-	if (warnings && warnings.length > 0) console.warn(warnings.join("\n"));
-	return packageManager.name;
-}
-function handleCommandError(error) {
-	const message = error instanceof Error ? error.message : "An unknown error occurred";
-	console.error(message);
-	cancel("Failed to run Adamantite");
-	process$1.exit(1);
-}
-async function checkIfExists(path) {
-	try {
-		await access(path);
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Reads and parses package.json with proper typing
-*/
-async function readPackageJson(cwd = process$1.cwd()) {
-	const currentPath = join(cwd, "package.json");
-	if (!await checkIfExists(currentPath)) throw new Error("package.json not found in the current directory");
-	try {
-		const content = await readFile(currentPath, "utf-8");
-		return JSON.parse(content);
-	} catch (error) {
-		throw new Error(`Failed to parse package.json: ${error instanceof Error ? error.message : "Unknown error"}`);
-	}
-}
-/**
-* Writes package.json with proper formatting
-*/
-async function writePackageJson(packageJson, cwd = process$1.cwd()) {
-	const currentPath = join(cwd, "package.json");
-	try {
-		await writeFile(currentPath, JSON.stringify(packageJson, null, 2));
-	} catch (error) {
-		throw new Error(`Failed to write package.json: ${error instanceof Error ? error.message : "Unknown error"}`);
-	}
-}
+const runCommand = fromThrowable(execSync, (error) => Fault.wrap(error).withTag("FAILED_TO_RUN_COMMAND"));
+const getPackageManagerName = () => fromPromise(detectPackageManager(process$1.cwd()), () => Fault.create("NO_PACKAGE_MANAGER").withDescription("Error while detecting the package manager.", "We're unable to detect the package manager used in this project.")).andThen((result) => {
+	if (!result) return err(Fault.create("NO_PACKAGE_MANAGER").withDescription("No package manager detected.", "We're unable to detect the package manager used in this project."));
+	return ok(result.name);
+});
+const checkIfExists = (path) => fromPromise(access(path), () => /* @__PURE__ */ new Error("File not found")).match(() => true, () => false);
+const parseJson = (content) => {
+	const errors = [];
+	const parsed = parse(content, errors);
+	if (errors.length > 0) return err(Fault.create("FAILED_TO_PARSE_FILE").withDescription("Failed to parse JSON", "We're unable to parse the provided JSON file.").withContext({ errors }));
+	return ok(parsed);
+};
+const 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."));
+const readPackageJson = (cwd = process$1.cwd()) => fromPromise(readFile(join(cwd, "package.json"), "utf-8"), (error) => Fault.wrap(error).withTag("FAILED_TO_READ_FILE").withDescription("Failed to read package.json", "We're unable to read the package.json file in the current directory.").withContext({ path: join(cwd, "package.json") })).andThen((content) => parseJson(content)).andThen((parsed) => ok(parsed));
 function getTitle() {
 	if ((process$1.stdout.columns || 80) >= 120) return `
                █████                                                 █████     ███   █████            
@@ -78,96 +49,68 @@ function getTitle() {
 }
 
 //#endregion
-//#region src/commands/helpers.ts
-const tsconfig = {
-	name: "tsconfig",
-	config: { extends: "adamantite/tsconfig" },
-	async exists() {
-		return await checkIfExists(join(process.cwd(), "tsconfig.json"));
-	},
-	async create() {
-		await writeFile(join(process.cwd(), "tsconfig.json"), JSON.stringify(this.config, null, 2));
-	},
-	async update() {
-		const existingConfig = parse(await readFile(join(process.cwd(), "tsconfig.json"), "utf-8"));
-		const newConfig = defu(this.config, existingConfig);
-		await writeFile(join(process.cwd(), "tsconfig.json"), JSON.stringify(newConfig, null, 2));
-	}
-};
+//#region src/helpers/packages/biome.ts
 const biome = {
 	name: "@biomejs/biome",
 	version: "2.3.10",
 	config: { $schema: "./node_modules/@biomejs/biome/configuration_schema.json" },
-	async exists() {
-		return await checkIfExists(join(process.cwd(), "biome.jsonc"));
+	exists: async () => {
+		if (await checkIfExists(join(process.cwd(), "biome.jsonc"))) return { path: join(process.cwd(), "biome.jsonc") };
+		if (await checkIfExists(join(process.cwd(), "biome.json"))) return { path: join(process.cwd(), "biome.json") };
+		return { path: null };
 	},
-	async create() {
-		await writeFile(join(process.cwd(), "biome.jsonc"), JSON.stringify({
-			...this.config,
-			extends: ["adamantite"]
-		}, null, 2));
-	},
-	async update() {
-		const newConfig = { ...parse(await readFile(await checkIfExists(join(process.cwd(), "biome.jsonc")) ? join(process.cwd(), "biome.jsonc") : join(process.cwd(), "biome.json"), "utf-8")) };
+	create: () => fromPromise(writeFile(join(process.cwd(), "biome.jsonc"), JSON.stringify({
+		...biome.config,
+		extends: ["adamantite"]
+	}, null, 2)), (error) => Fault.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write Biome configuration", "We're unable to write the Biome configuration to the current directory.")),
+	update: () => safeTry(async function* () {
+		const exists = await biome.exists();
+		if (!exists.path) return err(Fault.create("FILE_NOT_FOUND").withDescription("No `biome.jsonc` or `biome.json` found", "We're unable to find a Biome configuration in the current directory."));
+		const existingConfig = yield* parseJson(yield* fromPromise(readFile(exists.path, "utf-8"), (error) => Fault.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.")));
+		if (!existingConfig || Object.keys(existingConfig).length === 0) return err(Fault.create("INVALID_BIOME_CONFIG").withDescription("Invalid Biome configuration", "The Biome configuration file is empty or invalid.").withContext({ path: exists.path }));
+		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 = defu(this.config, newConfig);
-		await writeFile(join(process.cwd(), "biome.jsonc"), JSON.stringify(mergedConfig, null, 2));
-	}
+		const mergedConfig = yield* mergeConfig(newConfig, biome.config);
+		mergedConfig.$schema = biome.config.$schema;
+		yield* fromPromise(writeFile(exists.path, JSON.stringify(mergedConfig, null, 2)), (error) => Fault.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 }));
+		return ok();
+	})
 };
-const vscode = {
-	name: ".vscode",
-	config: {
-		"typescript.tsdk": "node_modules/typescript/lib",
-		"editor.formatOnSave": true,
-		"editor.formatOnPaste": true,
-		"editor.codeActionsOnSave": {
-			"source.organizeImports.biome": "explicit",
-			"source.fixAll.biome": "explicit"
-		},
-		"[javascript][typescript][javascriptreact][typescriptreact][json][jsonc][css][graphql]": { "editor.defaultFormatter": "biomejs.biome" }
-	},
-	async exists() {
-		return await checkIfExists(join(process.cwd(), ".vscode", "settings.json"));
-	},
-	async create() {
-		const vscodePath = join(process.cwd(), ".vscode");
-		await mkdir(vscodePath, { recursive: true });
-		await writeFile(join(vscodePath, "settings.json"), JSON.stringify(this.config, null, 2));
-	},
-	async update() {
-		const existingConfig = parse(await readFile(join(process.cwd(), ".vscode", "settings.json"), "utf-8"));
-		const newConfig = defu(this.config, existingConfig);
-		await writeFile(join(process.cwd(), ".vscode", "settings.json"), JSON.stringify(newConfig, null, 2));
-	}
-};
-const sherif = { version: "1.9.0" };
 
 //#endregion
 //#region src/commands/check.ts
 var check_default = defineCommand({
-	command: "check",
+	command: "check [files..]",
 	describe: "Run Biome linter and check files for issues",
 	builder: (yargs$1) => yargs$1.positional("files", {
 		describe: "Specific files to lint (optional)",
-		type: "string"
+		type: "string",
+		array: true
 	}).option("summary", {
 		type: "boolean",
 		description: "Show summary of lint results"
 	}),
 	handler: async (argv) => {
-		try {
-			const packageManager = await getPackageManagerName();
+		if ((await safeTry(async function* () {
+			const packageManager = yield* getPackageManagerName();
 			const args = ["check"];
 			if (argv.summary) args.push("--reporter", "summary");
 			if (argv.files && argv.files.length > 0) args.push(...argv.files);
-			execSync(dlxCommand(packageManager, biome.name, { args }), { stdio: "inherit" });
-		} catch (error) {
-			handleCommandError(error);
-		}
+			yield* runCommand(dlxCommand(packageManager, biome.name, { args }), { stdio: "inherit" });
+			return ok(void 0);
+		})).isOk()) return;
+		process$1.exit(1);
 	}
 });
 
+//#endregion
+//#region src/helpers/packages/sherif.ts
+const sherif = {
+	name: "sherif",
+	version: "1.9.0"
+};
+
 //#endregion
 //#region src/commands/ci.ts
 var ci_default = defineCommand({
@@ -181,174 +124,192 @@ var ci_default = defineCommand({
 		description: "Use GitHub reporter"
 	}),
 	handler: async (argv) => {
-		try {
-			const packageManager = await getPackageManagerName();
+		if ((await safeTry(async function* () {
+			const packageManager = yield* getPackageManagerName();
 			const tools = [{
-				package: "@biomejs/biome",
+				package: biome.name,
 				args: ["ci", ...argv.github ? ["--reporter", "github"] : []]
-			}, ...argv.monorepo ? [{
-				package: "sherif",
+			}];
+			if (argv.monorepo) tools.push({
+				package: sherif.name,
 				args: []
-			}] : []];
-			for (const tool of tools) execSync(dlxCommand(packageManager, tool.package, { args: tool.args }), { stdio: "inherit" });
-		} catch (error) {
-			handleCommandError(error);
-		}
+			});
+			for (const tool of tools) yield* runCommand(dlxCommand(packageManager, tool.package, { args: tool.args }), { stdio: "inherit" });
+			return ok(void 0);
+		})).isOk()) return;
+		process$1.exit(1);
 	}
 });
 
 //#endregion
 //#region src/commands/fix.ts
 var fix_default = defineCommand({
-	command: "fix",
+	command: "fix [files..]",
 	describe: "Run Biome linter and fix issues in files",
 	builder: (yargs$1) => yargs$1.positional("files", {
 		describe: "Specific files to fix (optional)",
-		type: "string"
+		type: "string",
+		array: true
 	}).option("unsafe", {
 		type: "boolean",
 		description: "Apply unsafe fixes"
 	}),
 	handler: async (argv) => {
-		try {
-			const packageManager = await getPackageManagerName();
+		if ((await safeTry(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);
-			execSync(dlxCommand(packageManager, biome.name, { args }), { stdio: "inherit" });
-		} catch (error) {
-			handleCommandError(error);
-		}
+			yield* runCommand(dlxCommand(packageManager, biome.name, { args }), { stdio: "inherit" });
+			return ok(void 0);
+		})).isOk()) return;
+		process$1.exit(1);
 	}
 });
 
+//#endregion
+//#region src/helpers/editors/vscode.ts
+const vscode = {
+	config: {
+		"typescript.tsdk": "node_modules/typescript/lib",
+		"editor.formatOnSave": true,
+		"editor.formatOnPaste": true,
+		"editor.codeActionsOnSave": {
+			"source.organizeImports.biome": "explicit",
+			"source.fixAll.biome": "explicit"
+		},
+		"[javascript][typescript][javascriptreact][typescriptreact][json][jsonc][css][graphql]": { "editor.defaultFormatter": "biomejs.biome" }
+	},
+	exists: () => checkIfExists(join(process.cwd(), ".vscode", "settings.json")),
+	create: () => safeTry(async function* () {
+		const vscodePath = join(process.cwd(), ".vscode");
+		yield* fromPromise(mkdir(vscodePath, { recursive: true }), (error) => Fault.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* fromPromise(writeFile(join(vscodePath, "settings.json"), JSON.stringify(vscode.config, null, 2)), (error) => Fault.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 ok();
+	}),
+	update: () => safeTry(async function* () {
+		const vscodePath = join(process.cwd(), ".vscode", "settings.json");
+		const existingConfig = yield* parseJson(yield* fromPromise(readFile(vscodePath, "utf-8"), (error) => Fault.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 newConfig = yield* mergeConfig(vscode.config, existingConfig);
+		yield* fromPromise(writeFile(join(process.cwd(), ".vscode", "settings.json"), JSON.stringify(newConfig, null, 2)), (error) => Fault.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 ok();
+	})
+};
+
+//#endregion
+//#region src/helpers/tsconfig.ts
+const tsconfig = {
+	config: { extends: "adamantite/tsconfig" },
+	exists: () => checkIfExists(join(process.cwd(), "tsconfig.json")),
+	create: () => fromPromise(writeFile(join(process.cwd(), "tsconfig.json"), JSON.stringify(tsconfig.config, null, 2)), (error) => Fault.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: () => safeTry(async function* () {
+		const existingConfig = yield* parseJson(yield* fromPromise(readFile(join(process.cwd(), "tsconfig.json"), "utf-8"), (error) => Fault.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 newConfig = yield* mergeConfig(tsconfig.config, existingConfig);
+		yield* fromPromise(writeFile(join(process.cwd(), "tsconfig.json"), JSON.stringify(newConfig, null, 2)), (error) => Fault.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 ok();
+	})
+};
+
 //#endregion
 //#region src/commands/init.ts
-async function checkIsMonorepo() {
-	if (await checkIfExists(join(process$1.cwd(), "pnpm-workspace.yaml"))) return true;
-	try {
-		return (await readPackageJson()).workspaces !== void 0;
-	} catch {
-		return false;
-	}
-}
-async function setupBiomeConfig() {
-	const s = spinner();
-	if (await biome.exists()) {
-		s.start("Biome config found, updating...");
-		await biome.update();
-		s.stop("Biome config updated with Adamantite preset");
-	} else {
-		s.start("Biome config not found, creating...");
-		await biome.create();
-		s.stop("Biome config created with Adamantite preset");
-	}
-}
-async function setupScripts({ check, fix, monorepo }) {
-	const s = spinner();
-	s.start("Adding scripts to your `package.json`...");
-	try {
-		const packageJson = await readPackageJson();
-		if (!packageJson.scripts) packageJson.scripts = {};
-		if (check) packageJson.scripts["check"] = "adamantite check";
-		if (fix) packageJson.scripts["fix"] = "adamantite fix";
-		if (monorepo) packageJson.scripts["lint:monorepo"] = "adamantite monorepo";
-		await writePackageJson(packageJson);
-		s.stop("Scripts added to your `package.json`");
-	} catch (error) {
-		s.stop("Failed to add scripts");
-		throw new Error(`Failed to modify package.json: ${error instanceof Error ? error.message : "Unknown error"}`);
-	}
-}
-async function setupTsConfig() {
-	const s = spinner();
-	if (await tsconfig.exists()) {
-		s.start("`tsconfig.json` found, updating...");
-		await tsconfig.update();
-		s.stop("Updated `tsconfig.json` with preset");
-	} else {
-		s.start("`tsconfig.json` not found, creating...");
-		await tsconfig.create();
-		s.stop("Created `tsconfig.json` with preset");
-	}
-}
-async function selectEditorConfig() {
-	const selected = await multiselect({
-		message: "Which editors do you want to configure (recommended)?",
-		options: [{
-			label: "VSCode / Cursor / Windsurf",
-			value: "vscode"
-		}, {
-			label: "Zed (coming soon)",
-			value: "zed"
-		}],
-		required: false
-	});
-	if (isCancel(selected)) throw new Error("Operation cancelled");
-	return selected;
-}
-async function setupEditorConfig(selectedEditors) {
-	if (!selectedEditors || selectedEditors.length === 0) return;
-	const s = spinner();
-	if (selectedEditors.includes("vscode")) if (await vscode.exists()) {
-		s.start("VSCode settings found, updating...");
-		await vscode.update();
-		s.stop("VSCode settings updated with Adamantite preset");
-	} else {
-		s.start("VSCode settings not found, creating...");
-		await vscode.create();
-		s.stop("VSCode settings created with Adamantite preset");
-	}
-	if (selectedEditors.includes("zed")) {
-		s.start("Zed configuration coming soon...");
-		s.stop("Zed configuration coming soon...");
-	}
-}
-async function confirmAction(message) {
-	const result = await confirm({ message });
-	if (isCancel(result)) throw new Error("Operation cancelled");
-	return result;
-}
-async function installDependencies(options) {
-	const s = spinner();
-	s.start("Installing dependencies...");
-	try {
-		await addDevDependency("adamantite");
-		const biomeVersion = biome.version;
-		await addDevDependency(`@biomejs/biome@${biomeVersion}`);
-		if (options?.monorepo) await addDevDependency(`sherif@${sherif.version}`);
-		s.stop("Dependencies installed successfully");
-	} catch (error) {
-		s.stop("Failed to install dependencies");
-		throw new Error(`Failed to install dependencies: ${error instanceof Error ? error.message : "Unknown error"}`);
-	}
-}
 var init_default = defineCommand({
 	command: "init",
 	describe: "Initialize Adamantite in the current directory",
 	builder: (yargs$1) => yargs$1,
 	handler: async () => {
 		intro(getTitle());
-		try {
-			const isMonorepo = await checkIsMonorepo();
-			const installScripts = await confirmAction("Do you want to add the `check` and `fix` scripts to your `package.json`?");
-			const installMonorepoScript = isMonorepo ? await confirmAction("We've detected a monorepo setup in your project. Would you like to install monorepo linting scripts?") : false;
-			const installTypeScript = await confirmAction("Adamantite provides a TypeScript preset to enforce strict type-safety. Would you like to install it?");
-			const selectedEditors = await selectEditorConfig();
-			await installDependencies({ monorepo: installMonorepoScript });
-			await setupBiomeConfig();
-			if (installScripts || installMonorepoScript) await setupScripts({
-				check: installScripts,
-				fix: installScripts,
-				monorepo: installMonorepoScript
-			});
-			if (installTypeScript) await setupTsConfig();
-			await setupEditorConfig(selectedEditors);
+		const cwd = process$1.cwd();
+		const result = await safeTry(async function* () {
+			let packageJson = yield* readPackageJson();
+			const hasPnpmWorkspace = await checkIfExists(join(process$1.cwd(), "pnpm-workspace.yaml"));
+			const isMonorepo = packageJson.workspaces !== void 0 || hasPnpmWorkspace;
+			const shouldInstallScripts = yield* fromSafePromise(confirm({ message: "Do you want to add the `check` and `fix` scripts to your `package.json`?" })).andThen((r) => isCancel(r) ? err(Fault.create("OPERATION_CANCELLED")) : ok(r));
+			const shouldInstallMonorepoScripts = isMonorepo ? yield* fromSafePromise(confirm({ message: "We've detected a monorepo setup in your project. Would you like to install monorepo linting scripts?" })).andThen((r) => isCancel(r) ? err(Fault.create("OPERATION_CANCELLED")) : ok(r)) : false;
+			const shouldInstallTypeScriptPreset = yield* fromSafePromise(confirm({ message: "Adamantite provides a TypeScript preset to enforce strict type-safety. Would you like to install it?" })).andThen((r) => isCancel(r) ? err(Fault.create("OPERATION_CANCELLED")) : ok(r));
+			const selectedEditors = yield* fromSafePromise(multiselect({
+				message: "Which editors do you want to configure (recommended)?",
+				options: [{
+					label: "VSCode / Cursor / Windsurf",
+					value: "vscode"
+				}, {
+					label: "Zed (coming soon)",
+					value: "zed"
+				}],
+				required: false
+			})).andThen((r) => isCancel(r) ? err(Fault.create("OPERATION_CANCELLED")) : ok(r));
+			const installingDependencies = spinner();
+			installingDependencies.start("Installing dependencies...");
+			yield* fromPromise(addDevDependency("adamantite"), (error) => Fault.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage("Failed to install Adamantite"));
+			yield* fromPromise(addDevDependency(`${biome.name}@${biome.version}`), (error) => Fault.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage("Failed to install Biome"));
+			if (shouldInstallMonorepoScripts) yield* fromPromise(addDevDependency(`${sherif.name}@${sherif.version}`), (error) => Fault.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage("Failed to install Sherif"));
+			installingDependencies.stop("Dependencies installed successfully");
+			const settingUpBiomeConfig = spinner();
+			settingUpBiomeConfig.start("Setting up Biome config...");
+			if ((await biome.exists()).path) {
+				settingUpBiomeConfig.message("Biome config found, updating...");
+				yield* biome.update();
+				settingUpBiomeConfig.stop("Biome config updated successfully");
+			} else {
+				settingUpBiomeConfig.message("Biome config not found, creating...");
+				yield* biome.create();
+				settingUpBiomeConfig.stop("Biome config created successfully");
+			}
+			if (shouldInstallScripts) {
+				const addingScripts = spinner();
+				packageJson = yield* readPackageJson();
+				addingScripts.start("Adding scripts to your `package.json`...");
+				if (!packageJson.scripts) packageJson.scripts = {};
+				packageJson.scripts.check = "adamantite check";
+				packageJson.scripts.fix = "adamantite fix";
+				if (shouldInstallMonorepoScripts) packageJson.scripts["lint:monorepo"] = "adamantite monorepo";
+				yield* fromPromise(writeFile(join(cwd, "package.json"), JSON.stringify(packageJson, null, 2)), (error) => Fault.wrap(error).withTag("FAILED_TO_WRITE_FILE").withDescription("Failed to write package.json", "We're unable to update the package.json file.").withContext({ path: join(cwd, "package.json") }));
+				addingScripts.stop("Scripts added to your `package.json`");
+			}
+			if (shouldInstallTypeScriptPreset) {
+				const settingUpTypeScriptConfig = spinner();
+				settingUpTypeScriptConfig.start("Setting up TypeScript config...");
+				if (await tsconfig.exists()) {
+					settingUpTypeScriptConfig.message("`tsconfig.json` found, updating...");
+					yield* tsconfig.update();
+					settingUpTypeScriptConfig.stop("`tsconfig.json` updated successfully");
+				} else {
+					settingUpTypeScriptConfig.message("`tsconfig.json` not found, creating...");
+					yield* tsconfig.create();
+					settingUpTypeScriptConfig.stop("`tsconfig.json` created successfully");
+				}
+			}
+			if (selectedEditors.length > 0) {
+				const settingUpEditorConfig = spinner();
+				settingUpEditorConfig.start("Setting up editor config...");
+				if (selectedEditors.includes("vscode")) {
+					const settingUpVSCodeConfig = spinner();
+					settingUpVSCodeConfig.start("Setting up VSCode config...");
+					if (await vscode.exists()) {
+						settingUpVSCodeConfig.message("VSCode settings found, updating...");
+						yield* vscode.update();
+						settingUpVSCodeConfig.stop("VSCode settings updated with Adamantite preset");
+					} else {
+						settingUpVSCodeConfig.message("VSCode settings not found, creating...");
+						yield* vscode.create();
+						settingUpVSCodeConfig.stop("VSCode settings created with Adamantite preset");
+					}
+				}
+				if (selectedEditors.includes("zed")) log.warning("Zed configuration coming soon...");
+				settingUpEditorConfig.stop("Editor config set up successfully");
+			}
+			return ok();
+		});
+		if (result.isOk()) {
 			outro("💠 Adamantite initialized successfully!");
-		} catch (error) {
-			log.error(`${error instanceof Error ? error.message : "Unknown error"}`);
-			cancel("Failed to initialize Adamantite");
+			return;
 		}
+		if (result.error.tag === "OPERATION_CANCELLED") {
+			cancel("You've cancelled the initialization process.");
+			return;
+		}
+		log.error(result.error.message);
+		cancel("Failed to initialize Adamantite");
+		process$1.exit(1);
 	}
 });
 
@@ -359,100 +320,62 @@ var monorepo_default = defineCommand({
 	describe: "Lint and automatically fix monorepo-specific issues using Sherif",
 	builder: (yargs$1) => yargs$1,
 	handler: async () => {
-		try {
-			execSync(dlxCommand(await getPackageManagerName(), "sherif", { args: ["--fix"] }), { stdio: "inherit" });
-		} catch (error) {
-			handleCommandError(error);
-		}
+		if ((await safeTry(async function* () {
+			yield* runCommand(dlxCommand(yield* getPackageManagerName(), sherif.name, { args: ["--fix"] }), { stdio: "inherit" });
+			return ok(void 0);
+		})).isOk()) return;
+		process$1.exit(1);
 	}
 });
 
 //#endregion
 //#region src/commands/update.ts
-async function detectUpdatesNeeded() {
-	const updates = [];
-	try {
-		const packageJson = await readPackageJson();
-		const biomeDep = packageJson.devDependencies?.["@biomejs/biome"];
-		if (biomeDep && biomeDep !== biome.version) updates.push({
-			name: "@biomejs/biome",
-			currentVersion: biomeDep,
-			targetVersion: biome.version,
-			isDevDependency: true
-		});
-		const sherifDep = packageJson.devDependencies?.sherif;
-		if (sherifDep && sherifDep !== sherif.version) updates.push({
-			name: "sherif",
-			currentVersion: sherifDep,
-			targetVersion: sherif.version,
-			isDevDependency: true
-		});
-		return updates;
-	} catch (error) {
-		throw new Error(`Failed to read package.json: ${error instanceof Error ? error.message : "Unknown error"}`);
-	}
-}
-async function updateDependencies(updates) {
-	const s = spinner();
-	s.start("Updating dependencies...");
-	try {
-		const tasks = updates.map((dep) => addDevDependency(`${dep.name}@${dep.targetVersion}`));
-		const results = await Promise.allSettled(tasks);
-		const failures = [];
-		const successes = [];
-		for (const [index, result] of results.entries()) {
-			const dep = updates[index];
-			if (!dep) continue;
-			const depName = dep.name;
-			if (result.status === "fulfilled") successes.push(depName);
-			else failures.push(`${depName}: ${result.reason?.message || "Unknown error"}`);
-		}
-		if (failures.length === 0) s.stop("Dependencies updated successfully");
-		else if (successes.length === 0) {
-			s.stop("Failed to update dependencies");
-			throw new Error(`All dependency updates failed:\n${failures.join("\n")}`);
-		} else {
-			s.stop("Partial update completed");
-			log.warn("Some dependencies failed to update:");
-			for (const failure of failures) log.warn(`  ${failure}`);
-			log.success(`Successfully updated: ${successes.join(", ")}`);
-		}
-	} catch (error) {
-		s.stop("Failed to update dependencies");
-		throw error;
-	}
-}
-async function confirmUpdate(updates) {
-	log.message("The following dependencies will be updated:");
-	log.message("");
-	for (const dep of updates) log.message(`  ${dep.name}: ${dep.currentVersion} → ${dep.targetVersion}`);
-	log.message("");
-	const result = await confirm({ message: "Do you want to proceed with these updates?" });
-	if (isCancel(result)) throw new Error("Operation cancelled");
-	return result;
-}
 var update_default = defineCommand({
 	command: "update",
 	describe: "Update adamantite dependencies to latest compatible versions",
 	builder: (yargs$1) => yargs$1,
 	handler: async () => {
 		intro(getTitle());
-		try {
-			const updates = await detectUpdatesNeeded();
+		const result = await safeTry(async function* () {
+			const packageJson = yield* readPackageJson();
+			const updates = [];
+			for (const pkg of [biome, sherif]) {
+				const dependency = packageJson.devDependencies?.[pkg.name];
+				if (dependency && dependency !== pkg.version) updates.push({
+					name: pkg.name,
+					currentVersion: dependency,
+					targetVersion: pkg.version,
+					isDevDependency: true
+				});
+			}
 			if (updates.length === 0) {
 				log.success("All adamantite dependencies are already up to date!");
-				outro("💠 No updates needed");
-				return;
+				return ok("no-updates");
 			}
-			if (!await confirmUpdate(updates)) {
-				outro("💠 Update cancelled");
-				return;
-			}
-			await updateDependencies(updates);
-			outro("💠 Dependencies updated successfully!");
-		} catch (error) {
-			handleCommandError(error);
+			log.message("The following dependencies will be updated:");
+			log.message("");
+			for (const dep of updates) log.message(`  ${dep.name}: ${dep.currentVersion} → ${dep.targetVersion}`);
+			log.message("");
+			if (!(yield* fromSafePromise(confirm({ message: "Do you want to proceed with these updates?" })).andThen((r) => isCancel(r) ? err(Fault.create("OPERATION_CANCELLED")) : ok(r)))) return ok("cancelled");
+			const s = spinner();
+			s.start("Updating dependencies...");
+			for (const dep of updates) yield* fromPromise(addDevDependency(`${dep.name}@${dep.targetVersion}`), (error) => Fault.wrap(error).withTag("FAILED_TO_INSTALL_DEPENDENCY").withMessage(`Failed to update ${dep.name}`));
+			s.stop("Dependencies updated successfully");
+			return ok("updated");
+		});
+		if (result.isOk()) {
+			if (result.value === "no-updates") outro("💠 No updates needed");
+			else if (result.value === "cancelled") outro("💠 Update cancelled");
+			else if (result.value === "updated") outro("💠 Dependencies updated successfully!");
+			return;
+		}
+		if (result.error.tag === "OPERATION_CANCELLED") {
+			cancel("You've cancelled the update process.");
+			return;
 		}
+		log.error(result.error.message);
+		cancel("Failed to update dependencies");
+		process$1.exit(1);
 	}
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adamantite",
-  "version": "0.13.2",
+  "version": "0.14.0",
   "description": "An strict and opinionated set of presets for modern TypeScript applications",
   "keywords": [
     "adamantite",
@@ -21,7 +21,7 @@
   "license": "MIT",
   "author": "Adel Rodriguez <hello@adelrodriguez.com>",
   "type": "module",
-  "main": "src/presets/biome.jsonc",
+  "main": "presets/biome.jsonc",
   "bin": {
     "adamantite": "bin/adamantite"
   },
@@ -29,15 +29,15 @@
     "#*": "./src/*"
   },
   "exports": {
-    ".": "./src/presets/biome.jsonc",
-    "./biome": "./src/presets/biome.jsonc",
-    "./tsconfig": "./src/presets/tsconfig.json",
-    "./presets/*": "./src/presets/*"
+    ".": "./presets/biome.jsonc",
+    "./biome": "./presets/biome.jsonc",
+    "./tsconfig": "./presets/tsconfig.json",
+    "./presets/*": "./presets/*"
   },
   "files": [
     "bin",
     "dist",
-    "src/presets"
+    "presets"
   ],
   "scripts": {
     "build": "tsdown",
@@ -54,7 +54,9 @@
   "dependencies": {
     "@clack/prompts": "0.11.0",
     "defu": "6.1.4",
+    "faultier": "^1.0.3",
     "jsonc-parser": "3.3.1",
+    "neverthrow": "8.2.0",
     "nypm": "0.6.2",
     "yargs": "18.0.0"
   },

package/{src/presets → presets}/biome.jsonc

@@ -1,5 +1,5 @@
 {
-  "$schema": "../../node_modules/@biomejs/biome/configuration_schema.json",
+  "$schema": "../node_modules/@biomejs/biome/configuration_schema.json",
   "root": false,
   // ---------------------------- FORMATTER -----------------------------
   // These are the generic settings that apply to all files in the project.
@@ -15,7 +15,7 @@
     // Use the system line ending.
     "lineEnding": "auto",
     // The expected line width for most editors.
-    "lineWidth": 80,
+    "lineWidth": 100,
     // Don't force attributes to be on the same line as the element.
     "attributePosition": "auto",
     "bracketSpacing": true
@@ -103,9 +103,9 @@
         "noEmptyTypeParameters": "error",
         "noExtraBooleanCast": "error",
         "noExcessiveCognitiveComplexity": {
-          "level": "error",
+          "level": "warn",
           "options": {
-            "maxAllowedComplexity": 20
+            "maxAllowedComplexity": 40
           }
         },
         "noExcessiveNestedTestSuites": "error",