@nemo-cli/shared 0.1.3 → 0.1.5

package/dist/index.js

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import path, { dirname as dirname$1, resolve } from "node:path";
+import path, { basename, dirname as dirname$1, join, parse, resolve } from "node:path";
 import fse from "fs-extra";
 import { glob as glob$1 } from "glob";
 import { cancel, confirm, group, groupMultiselect, intro, isCancel, log as log$1, multiselect, note, outro, progress, select, spinner, stream, taskLog, tasks, text } from "@clack/prompts";
@@ -7,20 +7,19 @@ import ansiEscapes, { clearScreen as clearScreen$1, clearTerminal as clearTermin
 import chalk, { default as colors } from "chalk";
 import winston from "winston";
 import { fileURLToPath } from "node:url";
-import { loadConfig } from "unconfig";
-import open, { apps, openApp } from "open";
+import fs, { existsSync } from "node:fs";
 import process$1 from "node:process";
+import fs$1 from "node:fs/promises";
 import { Command } from "commander";
 import { x as x$1 } from "tinyexec";
 import { $ } from "zx";
 import { ErrorMessage } from "@nemo-cli/ui";
-import { existsSync } from "node:fs";
-import { homedir } from "node:os";
-import Configstore from "configstore";
 import { search } from "@inquirer/prompts";
 import Fuse from "fuse.js";
+import open, { apps, openApp } from "open";
+import { homedir } from "node:os";
+import Configstore from "configstore";
 import instance, { spinners } from "ora";
-import fs from "node:fs/promises";
 import yaml from "yaml";
 
 //#region \0rolldown/runtime.js
@@ -201,9 +200,520 @@ const log = {
 const filename = (importMate) => fileURLToPath(importMate.url);
 const dirname = (importMate) => dirname$1(filename(importMate));
 const cwdPathname = (dirname) => resolve(process.cwd(), dirname);
+/**
+* Join path segments and resolve to absolute path from current working directory
+* @param segments - Path segments to join
+* @returns Absolute path
+*
+* @example
+* joinPath('packages', 'workspace', 'package.json')
+* // Returns: /Users/user/project/packages/workspace/package.json
+*/
+const joinPath = (...segments) => resolve(process.cwd(), join(...segments));
 const REGEXP_SPLIT_NAMES = /\W+/gm;
 const parseNames = (names) => names.split(REGEXP_SPLIT_NAMES);
 
+//#endregion
+//#region ../../node_modules/.pnpm/unconfig@7.4.2/node_modules/unconfig/dist/dist-A9poGcY_.mjs
+function toArray(array) {
+	array = array ?? [];
+	return Array.isArray(array) ? array : [array];
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/quansync@1.0.0/node_modules/quansync/dist/src-C2Pm6gXo.js
+const GET_IS_ASYNC = Symbol.for("quansync.getIsAsync");
+var QuansyncError = class extends Error {
+	constructor(message = "Unexpected promise in sync context") {
+		super(message);
+		this.name = "QuansyncError";
+	}
+};
+function isThenable(value) {
+	return value && typeof value === "object" && typeof value.then === "function";
+}
+function isQuansyncGenerator(value) {
+	return value && typeof value === "object" && typeof value[Symbol.iterator] === "function" && "__quansync" in value;
+}
+function fromObject(options) {
+	const generator = function* (...args) {
+		if (yield GET_IS_ASYNC) return yield options.async.apply(this, args);
+		return options.sync.apply(this, args);
+	};
+	function fn(...args) {
+		const iter = generator.apply(this, args);
+		iter.then = (...thenArgs) => options.async.apply(this, args).then(...thenArgs);
+		iter.__quansync = true;
+		return iter;
+	}
+	fn.sync = options.sync;
+	fn.async = options.async;
+	return fn;
+}
+function fromPromise(promise) {
+	return fromObject({
+		async: () => Promise.resolve(promise),
+		sync: () => {
+			if (isThenable(promise)) throw new QuansyncError();
+			return promise;
+		}
+	});
+}
+function unwrapYield(value, isAsync) {
+	if (value === GET_IS_ASYNC) return isAsync;
+	if (isQuansyncGenerator(value)) return isAsync ? iterateAsync(value) : iterateSync(value);
+	if (!isAsync && isThenable(value)) throw new QuansyncError();
+	return value;
+}
+const DEFAULT_ON_YIELD = (value) => value;
+function iterateSync(generator, onYield = DEFAULT_ON_YIELD) {
+	let current = generator.next();
+	while (!current.done) try {
+		current = generator.next(unwrapYield(onYield(current.value, false)));
+	} catch (err) {
+		current = generator.throw(err);
+	}
+	return unwrapYield(current.value);
+}
+async function iterateAsync(generator, onYield = DEFAULT_ON_YIELD) {
+	let current = generator.next();
+	while (!current.done) try {
+		current = generator.next(await unwrapYield(onYield(current.value, true), true));
+	} catch (err) {
+		current = generator.throw(err);
+	}
+	return current.value;
+}
+function fromGeneratorFn(generatorFn, options) {
+	return fromObject({
+		name: generatorFn.name,
+		async(...args) {
+			return iterateAsync(generatorFn.apply(this, args), options?.onYield);
+		},
+		sync(...args) {
+			return iterateSync(generatorFn.apply(this, args), options?.onYield);
+		}
+	});
+}
+function quansync$1(input, options) {
+	if (isThenable(input)) return fromPromise(input);
+	if (typeof input === "function") return fromGeneratorFn(input, options);
+	else return fromObject(input);
+}
+/**
+* @returns `true` if the current context is async, `false` otherwise.
+*/
+const getIsAsync = quansync$1({
+	async: () => Promise.resolve(true),
+	sync: () => false
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@quansync+fs@1.0.0/node_modules/@quansync/fs/dist/index.mjs
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesreadfilepath-options
+*/
+const readFile$1 = quansync$1({
+	sync: fs.readFileSync,
+	async: fs.promises.readFile
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromiseswritefilefile-data-options
+*/
+const writeFile = quansync$1({
+	sync: fs.writeFileSync,
+	async: fs.promises.writeFile
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesunlinkpath
+*/
+const unlink = quansync$1({
+	sync: fs.unlinkSync,
+	async: fs.promises.unlink
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesaccesspath-mode
+*/
+const access = quansync$1({
+	sync: fs.accessSync,
+	async: fs.promises.access
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesstatpath-options
+*/
+const stat = quansync$1({
+	sync: fs.statSync,
+	async: fs.promises.stat
+});
+const lstat = quansync$1({
+	sync: fs.lstatSync,
+	async: fs.promises.lstat
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisescpsrc-dest-options
+*/
+const cp = quansync$1({
+	sync: fs.copyFileSync,
+	async: fs.promises.copyFile
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesrmpath-options
+*/
+const rm = quansync$1({
+	sync: fs.rmSync,
+	async: fs.promises.rm
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesmkdirpath-options
+*/
+const mkdir = quansync$1({
+	sync: fs.mkdirSync,
+	async: fs.promises.mkdir
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesrenameoldpath-newpath
+*/
+const rename = quansync$1({
+	sync: fs.renameSync,
+	async: fs.promises.rename
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesreaddirpath-options
+*/
+const readdir = quansync$1({
+	sync: fs.readdirSync,
+	async: fs.promises.readdir
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesrealpathpath-options
+*/
+const realpath = quansync$1({
+	sync: fs.realpathSync,
+	async: fs.promises.realpath
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesreadlinkpath-options
+*/
+const readlink = quansync$1({
+	sync: fs.readlinkSync,
+	async: fs.promises.readlink
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisessymlinktarget-path-type
+*/
+const symlink = quansync$1({
+	sync: fs.symlinkSync,
+	async: fs.promises.symlink
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromiseschownpath-uid-gid
+*/
+const chown = quansync$1({
+	sync: fs.chownSync,
+	async: fs.promises.chown
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromiseslchownpath-uid-gid
+*/
+const lchown = quansync$1({
+	sync: fs.lchownSync,
+	async: fs.promises.lchown
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromiseschmodpath-mode
+*/
+const chmod = quansync$1({
+	sync: fs.chmodSync,
+	async: fs.promises.chmod
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesutimespath-atime-mtime
+*/
+const utimes = quansync$1({
+	sync: fs.utimesSync,
+	async: fs.promises.utimes
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromiseslutimespath-atime-mtime
+*/
+const lutimes = quansync$1({
+	sync: fs.lutimesSync,
+	async: fs.promises.lutimes
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesmkdtempprefix-options
+*/
+const mkdtemp = quansync$1({
+	sync: fs.mkdtempSync,
+	async: fs.promises.mkdtemp
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/defu@6.1.4/node_modules/defu/dist/defu.mjs
+function isPlainObject$2(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) return false;
+	if (Symbol.iterator in value) return false;
+	if (Symbol.toStringTag in value) return Object.prototype.toString.call(value) === "[object Module]";
+	return true;
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+	if (!isPlainObject$2(defaults)) return _defu(baseObject, {}, namespace, merger);
+	const object = Object.assign({}, defaults);
+	for (const key in baseObject) {
+		if (key === "__proto__" || key === "constructor") continue;
+		const value = baseObject[key];
+		if (value === null || value === void 0) continue;
+		if (merger && merger(object, key, value, namespace)) continue;
+		if (Array.isArray(value) && Array.isArray(object[key])) object[key] = [...value, ...object[key]];
+		else if (isPlainObject$2(value) && isPlainObject$2(object[key])) object[key] = _defu(value, object[key], (namespace ? `${namespace}.` : "") + key.toString(), merger);
+		else object[key] = value;
+	}
+	return object;
+}
+function createDefu(merger) {
+	return (...arguments_) => arguments_.reduce((p, c) => _defu(p, c, "", merger), {});
+}
+const defu = createDefu();
+const defuFn = createDefu((object, key, currentValue) => {
+	if (object[key] !== void 0 && typeof currentValue === "function") {
+		object[key] = currentValue(object[key]);
+		return true;
+	}
+});
+const defuArrayFn = createDefu((object, key, currentValue) => {
+	if (Array.isArray(object[key]) && typeof currentValue === "function") {
+		object[key] = currentValue(object[key]);
+		return true;
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/quansync@1.0.0/node_modules/quansync/dist/macro.js
+/**
+* This function is equivalent to `quansync` from main entry
+* but accepts a fake argument type of async functions.
+*
+* This requires to be used with the macro transformer `unplugin-quansync`.
+* Do NOT use it directly.
+*
+* @internal
+*/
+const quansync = quansync$1;
+
+//#endregion
+//#region ../../node_modules/.pnpm/unconfig-core@7.4.2/node_modules/unconfig-core/dist/index.mjs
+const isFile = quansync(function* (path, allowSymlinks) {
+	try {
+		return (yield (allowSymlinks ? stat : lstat)(path)).isFile();
+	} catch {
+		return false;
+	}
+});
+const findUp = quansync(function* (paths, options = {}) {
+	const { cwd = process$1.cwd(), stopAt = parse(cwd).root, multiple = false, allowSymlinks = true } = options;
+	let current = cwd;
+	const files = [];
+	while (current && current !== stopAt) {
+		for (const path of paths) {
+			const filepath = resolve(current, path);
+			if (yield isFile(filepath, allowSymlinks)) {
+				files.push(filepath);
+				if (!multiple) return files;
+			}
+		}
+		const parent = dirname$1(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return files;
+});
+const loadConfigFile$1 = quansync(function* (filepath, source) {
+	try {
+		const config = yield source.parser(filepath);
+		if (!config) return;
+		return {
+			config,
+			source: filepath
+		};
+	} catch (e) {
+		if (source.skipOnError) return;
+		throw e;
+	}
+});
+function createConfigCoreLoader(options) {
+	const { cwd = process$1.cwd(), multiple, sources } = options;
+	const results = [];
+	let matchedFiles;
+	const findConfigs = quansync(function* () {
+		if (matchedFiles == null) matchedFiles = [];
+		matchedFiles.length = 0;
+		for (const source of sources) {
+			const { extensions } = source;
+			const files = yield findUp(source.files.flatMap((file) => !extensions?.length ? [file] : extensions.map((ext) => ext ? `${file}.${ext}` : file)), {
+				cwd,
+				stopAt: options.stopAt,
+				multiple
+			});
+			matchedFiles.push([source, files]);
+		}
+		return matchedFiles.flatMap((i) => i[1]);
+	});
+	return {
+		load: quansync(function* (force = false) {
+			if (matchedFiles == null || force) yield findConfigs();
+			for (const [source, files] of matchedFiles) {
+				if (!files.length) continue;
+				if (!multiple) {
+					const result = yield loadConfigFile$1(files[0], source);
+					if (result) return [result];
+				} else for (const file of files) {
+					const result = yield loadConfigFile$1(file, source);
+					if (result) results.push(result);
+				}
+			}
+			return results;
+		}),
+		findConfigs
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/unconfig@7.4.2/node_modules/unconfig/dist/index.mjs
+function interopDefault(mod) {
+	if (mod == null || typeof mod !== "object" || !("default" in mod) || mod.default == null) return mod;
+	const defaultValue = mod.default;
+	if (typeof defaultValue !== "object") return defaultValue;
+	for (const key in mod) try {
+		if (key in defaultValue || key === "default" || mod[key] === defaultValue) continue;
+		Object.defineProperty(defaultValue, key, {
+			configurable: true,
+			enumerable: true,
+			get() {
+				return mod[key];
+			}
+		});
+	} catch {}
+	return defaultValue;
+}
+const defaultExtensions = [
+	"mts",
+	"cts",
+	"ts",
+	"mjs",
+	"cjs",
+	"js",
+	"json",
+	""
+];
+const require$2 = createRequire(import.meta.url);
+const loadConfigFile = quansync(function* (filepath, source) {
+	let config;
+	let parser = source.parser || "auto";
+	let bundleFilepath = filepath;
+	let code;
+	let dependencies;
+	const read = quansync(function* () {
+		if (code == null) code = yield readFile$1(filepath, "utf8");
+		return code;
+	});
+	const importModule = quansync({
+		sync: () => {
+			const { createJiti } = require$2("jiti");
+			const jiti = createJiti(import.meta.url, {
+				fsCache: false,
+				moduleCache: false,
+				interopDefault: true
+			});
+			config = interopDefault(jiti(bundleFilepath));
+			dependencies = Object.values(jiti.cache).map((i) => i.filename).filter(Boolean);
+		},
+		async: async () => {
+			const { createJiti } = await import("jiti");
+			const jiti = createJiti(import.meta.url, {
+				fsCache: false,
+				moduleCache: false,
+				interopDefault: true
+			});
+			config = interopDefault(await jiti.import(bundleFilepath, { default: true }));
+			dependencies = Object.values(jiti.cache).map((i) => i.filename).filter(Boolean);
+		}
+	});
+	if (source.transform) {
+		const transformed = yield source.transform(yield read(), filepath);
+		if (transformed) {
+			bundleFilepath = join(dirname$1(filepath), `__unconfig_${basename(filepath)}`);
+			yield writeFile(bundleFilepath, transformed, "utf8");
+			code = transformed;
+		}
+	}
+	if (parser === "auto") try {
+		config = JSON.parse(yield read());
+		parser = "json";
+	} catch {
+		parser = "import";
+	}
+	try {
+		if (!config) {
+			if (typeof parser === "function") config = yield parser(filepath);
+			else if (parser === "import") yield importModule();
+			else if (parser === "json") config = JSON.parse(yield read());
+		}
+		if (!config) return;
+		const rewritten = source.rewrite ? yield source.rewrite(config, filepath) : config;
+		if (!rewritten) return void 0;
+		return [rewritten, dependencies];
+	} finally {
+		if (bundleFilepath !== filepath) try {
+			yield unlink(bundleFilepath);
+		} catch {}
+	}
+});
+function createConfigLoader(options) {
+	const { merge, defaults, sources, ...coreOptions } = options;
+	const coreSources = toArray(sources || []).map((source) => {
+		return {
+			...source,
+			files: toArray(source.files),
+			extensions: source.extensions || defaultExtensions,
+			parser: (filepath) => loadConfigFile(filepath, source)
+		};
+	});
+	const core = createConfigCoreLoader({
+		...coreOptions,
+		multiple: merge,
+		sources: coreSources
+	});
+	return {
+		load: quansync(function* (force = false) {
+			const results = yield core.load(force);
+			if (!results.length) return {
+				config: defaults,
+				sources: []
+			};
+			if (!merge) return {
+				config: results[0].config[0],
+				sources: [results[0].source],
+				dependencies: results[0].config[1]
+			};
+			return {
+				config: applyDefaults(...results.map((i) => i.config[0]), defaults),
+				sources: results.map((i) => i.source),
+				dependencies: results.flatMap((i) => i.config[1] || [])
+			};
+		}),
+		findConfigs: core.findConfigs
+	};
+}
+function applyDefaults(...args) {
+	return defu(...args.map((i) => ({ config: i }))).config;
+}
+const loadConfig = quansync(function* (options) {
+	return createConfigLoader(options).load();
+});
+const loadConfigSync = loadConfig.sync;
+
 //#endregion
 //#region src/utils/file.ts
 const readPackage = (importMeta, ...paths) => {
@@ -271,20 +781,698 @@ const readGitignore = (cwd = process.cwd()) => {
 		log.verbose("gitignore", `未找到 .gitignore 文件: ${gitignorePath}`);
 		return [];
 	}
-	try {
-		const content = fse.readFileSync(gitignorePath, "utf-8");
-		log.verbose("gitignore", `成功读取 .gitignore 文件: ${gitignorePath}`);
-		return content.split("\n");
-	} catch (err) {
-		log.error("gitignore", `读取 .gitignore 文件失败: ${err.message}`);
-		return [];
+	try {
+		const content = fse.readFileSync(gitignorePath, "utf-8");
+		log.verbose("gitignore", `成功读取 .gitignore 文件: ${gitignorePath}`);
+		return content.split("\n");
+	} catch (err) {
+		log.error("gitignore", `读取 .gitignore 文件失败: ${err.message}`);
+		return [];
+	}
+};
+
+//#endregion
+//#region src/constants.ts
+const LOWEST_NODE_VERSION = "18.0.0";
+const CONFIG_NAME = ".nemoclirc";
+
+//#endregion
+//#region src/package-manager/adapters/bun.ts
+/**
+* Bun adapter - translates operations to bun-specific commands
+*/
+var BunAdapter = class {
+	name = "bun";
+	supportsWorkspaces = true;
+	command = "bun";
+	buildAddCommand(packages, options) {
+		const args = ["add"];
+		args.push(...packages);
+		if (options.saveDev) args.push("--development");
+		if (options.exact) args.push("--exact");
+		if (options.root) args.push("--workspace");
+		else if (options.workspaces && options.workspaces.length > 0) options.workspaces.forEach((ws) => {
+			args.push("--workspace", ws);
+		});
+		return args;
+	}
+	buildRemoveCommand(packages, options) {
+		const args = ["remove", ...packages];
+		if (options.root) args.push("--workspace");
+		else if (options.workspaces && options.workspaces.length > 0) options.workspaces.forEach((ws) => {
+			args.push("--workspace", ws);
+		});
+		return args;
+	}
+	buildUpgradeCommand(packages, options) {
+		const target = options.target || "latest";
+		const packagesWithTarget = packages.map((pkg) => `${pkg}@${target}`);
+		return this.buildAddCommand(packagesWithTarget, {});
+	}
+	parsePackageSpec(packageSpec) {
+		const match = packageSpec.match(/^(@?[^@]+)(?:@(.+))?$/);
+		if (!match) return { name: packageSpec };
+		return {
+			name: match[1] ?? packageSpec,
+			version: match[2]
+		};
+	}
+};
+
+//#endregion
+//#region src/package-manager/adapters/deno.ts
+/**
+* Deno adapter - translates operations to deno-specific commands
+*
+* Note: Deno has a different model (URL-based imports) so some operations
+* are limited or not applicable.
+*/
+var DenoAdapter = class {
+	name = "deno";
+	supportsWorkspaces = false;
+	command = "deno";
+	buildAddCommand(packages, options) {
+		const args = ["add", ...packages];
+		if (options.saveDev) args.push("--dev");
+		return args;
+	}
+	buildRemoveCommand(packages, options) {
+		return ["remove", ...packages];
+	}
+	buildUpgradeCommand(packages, options) {
+		return this.buildAddCommand(packages, {});
+	}
+	parsePackageSpec(packageSpec) {
+		const match = packageSpec.match(/^(@?[^@]+)(?:@(.+))?$/);
+		if (!match) return { name: packageSpec };
+		return {
+			name: match[1] ?? packageSpec,
+			version: match[2]
+		};
+	}
+};
+
+//#endregion
+//#region src/package-manager/adapters/npm.ts
+/**
+* NPM adapter - translates operations to npm-specific commands
+*/
+var NpmAdapter = class {
+	name = "npm";
+	supportsWorkspaces = true;
+	command = "npm";
+	buildAddCommand(packages, options) {
+		const args = ["install"];
+		args.push(...packages);
+		if (options.saveDev) args.push("--save-dev");
+		if (options.exact) args.push("--save-exact");
+		if (options.savePeer) args.push("--save-peer");
+		if (options.saveOptional) args.push("--save-optional");
+		if (options.root) args.push("-w");
+		else if (options.workspaces && options.workspaces.length > 0) if (options.workspaces.length === 1) args.push("--workspace", options.workspaces[0] ?? "");
+		else options.workspaces.forEach((ws) => {
+			args.push("--workspace", ws);
+		});
+		return args;
+	}
+	buildRemoveCommand(packages, options) {
+		const args = ["uninstall", ...packages];
+		if (options.root) args.push("-w");
+		else if (options.workspaces && options.workspaces.length > 0) if (options.workspaces.length === 1) args.push("--workspace", options.workspaces[0] ?? "");
+		else options.workspaces.forEach((ws) => {
+			args.push("--workspace", ws);
+		});
+		return args;
+	}
+	buildUpgradeCommand(packages, options) {
+		const target = options.target || "latest";
+		const packagesWithTarget = packages.map((pkg) => `${pkg}@${target}`);
+		return this.buildAddCommand(packagesWithTarget, {});
+	}
+	parsePackageSpec(packageSpec) {
+		const match = packageSpec.match(/^(@?[^@]+)(?:@(.+))?$/);
+		if (!match) return { name: packageSpec };
+		return {
+			name: match[1] ?? packageSpec,
+			version: match[2]
+		};
+	}
+};
+
+//#endregion
+//#region src/package-manager/adapters/pnpm.ts
+/**
+* pnpm adapter - translates operations to pnpm-specific commands
+*/
+var PnpmAdapter = class {
+	name = "pnpm";
+	supportsWorkspaces = true;
+	command = "pnpm";
+	buildAddCommand(packages, options) {
+		const args = ["add"];
+		args.push(...packages);
+		if (options.saveDev) args.push("--save-dev");
+		if (options.exact) args.push("--save-exact");
+		if (options.savePeer) args.push("--save-peer");
+		if (options.saveOptional) args.push("--save-optional");
+		if (options.root) args.push("-w");
+		else if (options.workspaces && options.workspaces.length > 0) options.workspaces.forEach((ws) => {
+			args.push("--filter", ws);
+		});
+		return args;
+	}
+	buildRemoveCommand(packages, options) {
+		const args = ["remove", ...packages];
+		if (options.root) args.push("-w");
+		else if (options.workspaces && options.workspaces.length > 0) options.workspaces.forEach((ws) => {
+			args.push("--filter", ws);
+		});
+		return args;
+	}
+	buildUpgradeCommand(packages, options) {
+		const target = options.target || "latest";
+		const packagesWithTarget = packages.map((pkg) => `${pkg}@${target}`);
+		return this.buildAddCommand(packagesWithTarget, {});
+	}
+	parsePackageSpec(packageSpec) {
+		const match = packageSpec.match(/^(@?[^@]+)(?:@(.+))?$/);
+		if (!match) return { name: packageSpec };
+		return {
+			name: match[1] ?? packageSpec,
+			version: match[2]
+		};
+	}
+};
+
+//#endregion
+//#region src/package-manager/adapters/yarn.ts
+/**
+* Yarn adapter - translates operations to yarn-specific commands
+*/
+var YarnAdapter = class {
+	name = "yarn";
+	supportsWorkspaces = true;
+	command = "yarn";
+	buildAddCommand(packages, options) {
+		const args = ["add"];
+		args.push(...packages);
+		if (options.saveDev) args.push("--dev");
+		if (options.exact) args.push("--exact");
+		if (options.savePeer) args.push("--peer");
+		if (options.saveOptional) args.push("--optional");
+		if (options.root) args.push("-W");
+		else if (options.workspaces && options.workspaces.length > 0) {
+			if (options.workspaces.length === 1) args.unshift("-c", "--", `workspace:${options.workspaces[0]}`);
+		}
+		return args;
+	}
+	buildRemoveCommand(packages, options) {
+		const args = ["remove", ...packages];
+		if (options.root) args.push("-W");
+		else if (options.workspaces && options.workspaces.length > 0) {
+			if (options.workspaces.length === 1) args.unshift("-c", "--", `workspace:${options.workspaces[0]}`);
+		}
+		return args;
+	}
+	buildUpgradeCommand(packages, options) {
+		const target = options.target || "latest";
+		const packagesWithTarget = packages.map((pkg) => `${pkg}@${target}`);
+		return this.buildAddCommand(packagesWithTarget, {});
+	}
+	parsePackageSpec(packageSpec) {
+		const match = packageSpec.match(/^(@?[^@]+)(?:@(.+))?$/);
+		if (!match) return { name: packageSpec };
+		return {
+			name: match[1] ?? packageSpec,
+			version: match[2]
+		};
+	}
+};
+
+//#endregion
+//#region src/package-manager/adapters/index.ts
+/**
+* Adapter registry
+*/
+const adapters = {
+	npm: new NpmAdapter(),
+	pnpm: new PnpmAdapter(),
+	yarn: new YarnAdapter(),
+	bun: new BunAdapter(),
+	deno: new DenoAdapter()
+};
+/**
+* Get adapter for a specific package manager
+*/
+function getAdapter(packageManager) {
+	return adapters[packageManager];
+}
+/**
+* Get all available adapters
+*/
+function getAllAdapters() {
+	return { ...adapters };
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+function isPlainObject$1(value) {
+	if (!value || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	if (!(proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null)) return false;
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/_internal/isUnsafeProperty.mjs
+function isUnsafeProperty(key) {
+	return key === "__proto__";
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/object/merge.mjs
+function merge(target, source) {
+	const sourceKeys = Object.keys(source);
+	for (let i = 0; i < sourceKeys.length; i++) {
+		const key = sourceKeys[i];
+		if (isUnsafeProperty(key)) continue;
+		const sourceValue = source[key];
+		const targetValue = target[key];
+		if (isMergeableValue(sourceValue) && isMergeableValue(targetValue)) target[key] = merge(targetValue, sourceValue);
+		else if (Array.isArray(sourceValue)) target[key] = merge([], sourceValue);
+		else if (isPlainObject$1(sourceValue)) target[key] = merge({}, sourceValue);
+		else if (targetValue === void 0 || sourceValue !== void 0) target[key] = sourceValue;
+	}
+	return target;
+}
+function isMergeableValue(value) {
+	return isPlainObject$1(value) || Array.isArray(value);
+}
+
+//#endregion
+//#region src/utils/error.ts
+const handleError = (err, message) => {
+	if (isError(err)) ErrorMessage({ text: `${message}: ${err.message}` });
+	else if (isString(err)) ErrorMessage({ text: `${message}: ${err}` });
+	else log.error(message, err);
+};
+
+//#endregion
+//#region src/utils/command.ts
+const exit = (code) => process$1.exit(code);
+const createHelpExample = (...commands) => {
+	return `
+Example:
+${commands.map((command) => `  $ ${command}`).join("\n")}
+`;
+};
+const createCommand = (name) => {
+	const command = new Command(name);
+	command.allowExcessArguments();
+	command.allowUnknownOption();
+	return command;
+};
+const buildCommand = (command, dynamicParts = []) => {
+	return {
+		command,
+		parts: dynamicParts.filter((part) => !isEmpty(part)).map((part) => part?.toString())
+	};
+};
+const x = (command, args, options = {}) => {
+	return x$1(command, args, merge({
+		nodeOptions: {
+			cwd: process$1.cwd(),
+			FORCE_COLOR: "1"
+		},
+		throwOnError: true
+	}, options));
+};
+const zx = (baseCommand, dynamicParts = [], options = {}) => {
+	const { command, parts } = buildCommand(baseCommand, dynamicParts);
+	const { signal } = new AbortController();
+	try {
+		return (isEmpty(options) ? $ : $({
+			...options,
+			signal
+		}))`${command} ${parts}`;
+	} catch (error) {
+		handleError(error, `Failed to execute dynamic command: ${command}`);
+		throw error;
+	}
+};
+const xASync = async (command, args, options) => {
+	try {
+		const { timeout, quiet, ...execOptions } = options ?? {};
+		const execPromise = x$1(command, args, merge({
+			nodeOptions: {
+				cwd: process$1.cwd(),
+				FORCE_COLOR: "1"
+			},
+			throwOnError: true
+		}, execOptions));
+		let result;
+		if (timeout) {
+			let timer;
+			const timeoutPromise = new Promise((_, reject) => {
+				timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Command timeout after ${timeout}ms`)), timeout);
+			});
+			try {
+				result = await Promise.race([execPromise, timeoutPromise]);
+			} finally {
+				timer && clearTimeout(timer);
+			}
+		} else result = await execPromise;
+		if (result.exitCode) {
+			if (!quiet) {
+				log.show(`Failed to execute command ${command}. Command exited with code ${result.exitCode}.`, { type: "error" });
+				log.show(result.stderr, { type: "error" });
+			}
+			return [new Error(result.stderr), null];
+		}
+		return [null, result];
+	} catch (error) {
+		handleError(error, `Failed to execute command ${command}.`);
+		return [isError(error) ? error : new Error(error), null];
+	}
+};
+
+//#endregion
+//#region src/utils/prompts.ts
+const createOptions = (options) => options.map((option) => ({
+	label: option.toString(),
+	value: option
+}));
+const createPrompt = (fn) => {
+	return async (options) => {
+		const result = await fn(options);
+		if (isCancel(result)) {
+			cancel("User cancelled");
+			exit(0);
+		}
+		return result;
+	};
+};
+const createShowList = createPrompt((options) => {
+	options.map((option) => {
+		return isString(option) ? option : option.label;
+	}).forEach((item) => {
+		log.show(item, { type: "step" });
+	});
+});
+const createSearch = ({ message, options }) => {
+	const fuse = new Fuse(options, { keys: ["label"] });
+	return search({
+		message,
+		source: (term) => {
+			if (!term) return options;
+			return fuse.search(term).map(({ item }) => item);
+		}
+	});
+};
+process.on("uncaughtException", (error) => {
+	if (error instanceof Error && error.name === "ExitPromptError") log.show("User cancelled", { type: "error" });
+	else throw error;
+});
+const createCheckbox = async (opts) => {
+	const result = await multiselect(opts);
+	if (isCancel(result)) {
+		cancel("User cancelled");
+		exit(0);
+	}
+	return result;
+};
+const createNote = ({ message = "", title = "", opts }) => note(message, title, opts);
+const createConfirm = createPrompt(confirm);
+const createTasks = createPrompt(tasks);
+const createSelect = async (opts) => {
+	const result = await select(opts);
+	if (isCancel(result)) {
+		cancel("User cancelled");
+		exit(0);
+	}
+	return result;
+};
+const createInput = async (opts) => {
+	const result = await text(opts);
+	if (isCancel(result)) {
+		cancel("User cancelled");
+		exit(0);
+	}
+	return result;
+};
+const createGroupMultiSelect = async (opts) => {
+	const result = await groupMultiselect(opts);
+	if (isCancel(result)) {
+		cancel("User cancelled");
+		process.exit(0);
+	}
+	return result;
+};
+const createGroup = async (opts) => {
+	const result = await group(opts);
+	if (isCancel(result)) {
+		cancel("User cancelled");
+		exit(0);
+	}
+	return result;
+};
+const createSpinner = (message, options) => {
+	const s = spinner(options);
+	s.start(message);
+	return s;
+};
+const createTaskLog = (title, options) => taskLog({
+	title,
+	...options
+});
+
+//#endregion
+//#region src/package-manager/types.ts
+/**
+* Lock file patterns for detection
+*/
+const LOCK_FILE_PATTERNS = {
+	npm: ["package-lock.json"],
+	pnpm: ["pnpm-lock.yaml"],
+	yarn: ["yarn.lock"],
+	bun: ["bun.lockb", "bun.lock"],
+	deno: ["deno.json", "deno.jsonc"]
+};
+/**
+* Package manager display names
+*/
+const PACKAGE_MANAGER_NAMES = {
+	npm: "npm",
+	pnpm: "pnpm",
+	yarn: "yarn",
+	bun: "Bun",
+	deno: "Deno"
+};
+
+//#endregion
+//#region src/package-manager/detector.ts
+/**
+* Cache file location
+*/
+const CACHE_FILE = ".nemo/package-manager.json";
+const CACHE_DURATION = 10080 * 60 * 1e3;
+/**
+* PackageManagerDetector - Detects the package manager used by a project
+*
+* Detection priority:
+* 1. Lock file analysis (package-lock.json, pnpm-lock.yaml, yarn.lock, bun.lockb)
+* 2. package.json packageManager field
+* 3. Interactive user selection
+*/
+var PackageManagerDetector = class {
+	projectRoot;
+	cachePath;
+	constructor(projectRoot = process.cwd()) {
+		console.log("🚀 : PackageManagerDetector : constructor : projectRoot:", projectRoot);
+		this.projectRoot = projectRoot;
+		this.cachePath = path.join(projectRoot, CACHE_FILE);
+	}
+	/**
+	* Detect the package manager for the project
+	*/
+	async detect(forceRefresh = false) {
+		if (!forceRefresh) {
+			const cached = await this.loadCache();
+			if (cached && !this.isCacheExpired(cached)) {
+				log.info(`Using cached package manager: ${cached.result.packageManager}`);
+				return cached.result;
+			}
+		}
+		const lockFileResult = await this.detectByLockFile();
+		if (lockFileResult) {
+			const result = await this.createDetectionResult(lockFileResult, "lock-file");
+			await this.saveCache(result);
+			return result;
+		}
+		const packageJsonResult = await this.detectByPackageJson();
+		if (packageJsonResult) {
+			const result = await this.createDetectionResult(packageJsonResult, "package-json");
+			await this.saveCache(result);
+			return result;
+		}
+		log.warn("Could not auto-detect package manager");
+		const userSelection = await this.promptUser();
+		const result = await this.createDetectionResult(userSelection, "user-selection");
+		await this.saveCache(result);
+		return result;
+	}
+	/**
+	* Detect package manager from lock files
+	*/
+	async detectByLockFile() {
+		for (const pm of [
+			"pnpm",
+			"yarn",
+			"npm",
+			"bun",
+			"deno"
+		]) {
+			const patterns = LOCK_FILE_PATTERNS[pm];
+			for (const pattern of patterns) {
+				const lockFilePath = path.join(this.projectRoot, pattern);
+				console.log("🚀 : PackageManagerDetector : detectByLockFile : lockFilePath:", lockFilePath);
+				if (existsSync(lockFilePath)) {
+					log.info(`Detected ${pm} from lock file: ${pattern}`);
+					return pm;
+				}
+			}
+		}
+		return null;
+	}
+	/**
+	* Detect package manager from package.json packageManager field
+	*/
+	async detectByPackageJson() {
+		const packageJsonPath = path.join(this.projectRoot, "package.json");
+		try {
+			const content = await fs$1.readFile(packageJsonPath, "utf-8");
+			const packageManagerField = JSON.parse(content).packageManager;
+			if (!packageManagerField) return null;
+			const match = packageManagerField.match(/^([a-z]+)@/);
+			if (match) {
+				const pm = match[1];
+				if (this.isValidPackageManager(pm)) {
+					log.info(`Detected ${pm} from package.json packageManager field`);
+					return pm;
+				}
+			}
+			return null;
+		} catch (error) {
+			log.error(`Could not read package.json: ${error}`);
+			return null;
+		}
+	}
+	/**
+	* Prompt user to select package manager interactively
+	*/
+	async promptUser() {
+		const selected = await createSelect({
+			message: "Could not detect package manager. Please select one:",
+			options: Object.entries(PACKAGE_MANAGER_NAMES).map(([value, label]) => ({
+				value,
+				label
+			}))
+		});
+		if (!selected || !this.isValidPackageManager(selected)) {
+			log.error("Invalid selection. Defaulting to npm.");
+			return "npm";
+		}
+		return selected;
+	}
+	/**
+	* Check if a package manager is installed and available
+	*/
+	async checkAvailability(pm) {
+		try {
+			return (await x(pm, ["--version"])).exitCode === 0;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a detection result with metadata
+	*/
+	async createDetectionResult(packageManager, method) {
+		const isAvailable = await this.checkAvailability(packageManager);
+		return {
+			packageManager,
+			method,
+			detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			isAvailable
+		};
+	}
+	/**
+	* Load cached detection result
+	*/
+	async loadCache() {
+		try {
+			if (!existsSync(this.cachePath)) return null;
+			const content = await fs$1.readFile(this.cachePath, "utf-8");
+			return JSON.parse(content);
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Save detection result to cache
+	*/
+	async saveCache(result) {
+		try {
+			const cacheDir = path.dirname(this.cachePath);
+			await fs$1.mkdir(cacheDir, { recursive: true });
+			const cache = {
+				result,
+				expiresAt: new Date(Date.now() + CACHE_DURATION).toISOString()
+			};
+			await fs$1.writeFile(this.cachePath, JSON.stringify(cache, null, 2));
+		} catch (error) {
+			log.error(`Could not save cache: ${error}`);
+		}
+	}
+	/**
+	* Check if cache has expired
+	*/
+	isCacheExpired(cache) {
+		return new Date(cache.expiresAt) < /* @__PURE__ */ new Date();
+	}
+	/**
+	* Validate package manager enum
+	*/
+	isValidPackageManager(pm) {
+		return [
+			"npm",
+			"pnpm",
+			"yarn",
+			"bun",
+			"deno"
+		].includes(pm);
+	}
+	/**
+	* Clear the cache (useful for testing or force re-detection)
+	*/
+	async clearCache() {
+		try {
+			if (existsSync(this.cachePath)) {
+				await fs$1.unlink(this.cachePath);
+				log.info("Package manager cache cleared");
+			}
+		} catch (error) {
+			log.error(`Could not clear cache: ${error}`);
+		}
 	}
 };
-
-//#endregion
-//#region src/constants.ts
-const LOWEST_NODE_VERSION = "18.0.0";
-const CONFIG_NAME = ".nemoclirc";
+/**
+* Get adapter for detected or specified package manager
+*/
+async function getPackageManagerAdapter(packageManager) {
+	const detector = new PackageManagerDetector();
+	return getAdapter(packageManager || (await detector.detect()).packageManager);
+}
 
 //#endregion
 //#region src/utils/browser.ts
@@ -303,113 +1491,6 @@ const getBrowserApps = () => {
 const clearScreen = () => console.log(clearScreen$1);
 const clearTerminal = () => console.log(clearTerminal$1);
 
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
-function isPlainObject$1(value) {
-	if (!value || typeof value !== "object") return false;
-	const proto = Object.getPrototypeOf(value);
-	if (!(proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null)) return false;
-	return Object.prototype.toString.call(value) === "[object Object]";
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/_internal/isUnsafeProperty.mjs
-function isUnsafeProperty(key) {
-	return key === "__proto__";
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/object/merge.mjs
-function merge(target, source) {
-	const sourceKeys = Object.keys(source);
-	for (let i = 0; i < sourceKeys.length; i++) {
-		const key = sourceKeys[i];
-		if (isUnsafeProperty(key)) continue;
-		const sourceValue = source[key];
-		const targetValue = target[key];
-		if (isMergeableValue(sourceValue) && isMergeableValue(targetValue)) target[key] = merge(targetValue, sourceValue);
-		else if (Array.isArray(sourceValue)) target[key] = merge([], sourceValue);
-		else if (isPlainObject$1(sourceValue)) target[key] = merge({}, sourceValue);
-		else if (targetValue === void 0 || sourceValue !== void 0) target[key] = sourceValue;
-	}
-	return target;
-}
-function isMergeableValue(value) {
-	return isPlainObject$1(value) || Array.isArray(value);
-}
-
-//#endregion
-//#region src/utils/error.ts
-const handleError = (err, message) => {
-	if (isError(err)) ErrorMessage({ text: `${message}: ${err.message}` });
-	else if (isString(err)) ErrorMessage({ text: `${message}: ${err}` });
-	else log.error(message, err);
-};
-
-//#endregion
-//#region src/utils/command.ts
-const exit = (code) => process$1.exit(code);
-const createHelpExample = (...commands) => {
-	return `
-Example:
-${commands.map((command) => `  $ ${command}`).join("\n")}
-`;
-};
-const createCommand = (name) => {
-	const command = new Command(name);
-	command.allowExcessArguments();
-	command.allowUnknownOption();
-	return command;
-};
-const buildCommand = (command, dynamicParts = []) => {
-	return {
-		command,
-		parts: dynamicParts.filter((part) => !isEmpty(part)).map((part) => part?.toString())
-	};
-};
-const x = (command, args, options = {}) => {
-	return x$1(command, args, merge({
-		nodeOptions: {
-			cwd: process$1.cwd(),
-			FORCE_COLOR: "1"
-		},
-		throwOnError: true
-	}, options));
-};
-const zx = (baseCommand, dynamicParts = [], options = {}) => {
-	const { command, parts } = buildCommand(baseCommand, dynamicParts);
-	const { signal } = new AbortController();
-	try {
-		return (isEmpty(options) ? $ : $({
-			...options,
-			signal
-		}))`${command} ${parts}`;
-	} catch (error) {
-		handleError(error, `Failed to execute dynamic command: ${command}`);
-		throw error;
-	}
-};
-const xASync = async (command, args, options) => {
-	try {
-		const result = await x$1(command, args, merge({
-			nodeOptions: {
-				cwd: process$1.cwd(),
-				FORCE_COLOR: "1"
-			},
-			throwOnError: true
-		}, options ?? {}));
-		if (result.exitCode) {
-			!options?.quiet && log.show(`Failed to execute command ${command}. Command exited with code ${result.exitCode}.`, { type: "error" });
-			!options?.quiet && log.show(result.stderr, { type: "error" });
-			return [new Error(result.stderr), null];
-		}
-		return [null, result];
-	} catch (error) {
-		handleError(error, `Failed to execute command ${command}.`);
-		return [isError(error) ? error : new Error(error), null];
-	}
-};
-
 //#endregion
 //#region src/utils/common.ts
 const cached = (fn) => {
@@ -429,11 +1510,11 @@ const sleep = (millisecond, controller) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/package.json
+//#region ../../node_modules/.pnpm/dotenv@17.2.4/node_modules/dotenv/package.json
 var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = {
 		"name": "dotenv",
-		"version": "17.2.3",
+		"version": "17.2.4",
 		"description": "Loads environment variables from .env file",
 		"main": "lib/main.js",
 		"types": "lib/main.d.ts",
@@ -492,9 +1573,9 @@ var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/lib/main.js
+//#region ../../node_modules/.pnpm/dotenv@17.2.4/node_modules/dotenv/lib/main.js
 var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const fs$2 = __require("fs");
+	const fs$3 = __require("fs");
 	const path$13 = __require("path");
 	const os = __require("os");
 	const crypto = __require("crypto");
@@ -631,10 +1712,10 @@ var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	function _vaultPath(options) {
 		let possibleVaultPath = null;
 		if (options && options.path && options.path.length > 0) if (Array.isArray(options.path)) {
-			for (const filepath of options.path) if (fs$2.existsSync(filepath)) possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+			for (const filepath of options.path) if (fs$3.existsSync(filepath)) possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
 		} else possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
 		else possibleVaultPath = path$13.resolve(process.cwd(), ".env.vault");
-		if (fs$2.existsSync(possibleVaultPath)) return possibleVaultPath;
+		if (fs$3.existsSync(possibleVaultPath)) return possibleVaultPath;
 		return null;
 	}
 	function _resolveHome(envPath) {
@@ -668,7 +1749,7 @@ var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		let lastError;
 		const parsedAll = {};
 		for (const path of optionPaths) try {
-			const parsed = DotenvModule.parse(fs$2.readFileSync(path, { encoding }));
+			const parsed = DotenvModule.parse(fs$3.readFileSync(path, { encoding }));
 			DotenvModule.populate(parsedAll, parsed, options);
 		} catch (e) {
 			if (debug) _debug(`Failed to load ${path} ${e.message}`);
@@ -783,7 +1864,14 @@ const loadEnv = (importMeta, ...paths) => {
 		});
 		return;
 	}
-	throw new Error(`Environment file not found at ${providedPath}`);
+	const examplePath = providedPath + ".example";
+	if (existsSync(examplePath)) {
+		(0, import_main.config)({
+			path: examplePath,
+			quiet: true
+		});
+		return;
+	}
 };
 const createStore = (name, options) => {
 	if (!options.path) throw Error("Store subpath is necessary!");
@@ -1241,7 +2329,7 @@ var require_clone = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var fs$1 = __require("fs");
+	var fs$2 = __require("fs");
 	var polyfills = require_polyfills();
 	var legacy = require_legacy_streams();
 	var clone = require_clone();
@@ -1270,36 +2358,36 @@ var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
 		console.error(m);
 	};
-	if (!fs$1[gracefulQueue]) {
-		publishQueue(fs$1, global[gracefulQueue] || []);
-		fs$1.close = (function(fs$close) {
+	if (!fs$2[gracefulQueue]) {
+		publishQueue(fs$2, global[gracefulQueue] || []);
+		fs$2.close = (function(fs$close) {
 			function close(fd, cb) {
-				return fs$close.call(fs$1, fd, function(err) {
+				return fs$close.call(fs$2, fd, function(err) {
 					if (!err) resetQueue();
 					if (typeof cb === "function") cb.apply(this, arguments);
 				});
 			}
 			Object.defineProperty(close, previousSymbol, { value: fs$close });
 			return close;
-		})(fs$1.close);
-		fs$1.closeSync = (function(fs$closeSync) {
+		})(fs$2.close);
+		fs$2.closeSync = (function(fs$closeSync) {
 			function closeSync(fd) {
-				fs$closeSync.apply(fs$1, arguments);
+				fs$closeSync.apply(fs$2, arguments);
 				resetQueue();
 			}
 			Object.defineProperty(closeSync, previousSymbol, { value: fs$closeSync });
 			return closeSync;
-		})(fs$1.closeSync);
+		})(fs$2.closeSync);
 		if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) process.on("exit", function() {
-			debug(fs$1[gracefulQueue]);
-			__require("assert").equal(fs$1[gracefulQueue].length, 0);
+			debug(fs$2[gracefulQueue]);
+			__require("assert").equal(fs$2[gracefulQueue].length, 0);
 		});
 	}
-	if (!global[gracefulQueue]) publishQueue(global, fs$1[gracefulQueue]);
-	module.exports = patch(clone(fs$1));
-	if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs$1.__patched) {
-		module.exports = patch(fs$1);
-		fs$1.__patched = true;
+	if (!global[gracefulQueue]) publishQueue(global, fs$2[gracefulQueue]);
+	module.exports = patch(clone(fs$2));
+	if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs$2.__patched) {
+		module.exports = patch(fs$2);
+		fs$2.__patched = true;
 	}
 	function patch(fs) {
 		polyfills(fs);
@@ -1554,23 +2642,23 @@ var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	}
 	function enqueue(elem) {
 		debug("ENQUEUE", elem[0].name, elem[1]);
-		fs$1[gracefulQueue].push(elem);
+		fs$2[gracefulQueue].push(elem);
 		retry();
 	}
 	var retryTimer;
 	function resetQueue() {
 		var now = Date.now();
-		for (var i = 0; i < fs$1[gracefulQueue].length; ++i) if (fs$1[gracefulQueue][i].length > 2) {
-			fs$1[gracefulQueue][i][3] = now;
-			fs$1[gracefulQueue][i][4] = now;
+		for (var i = 0; i < fs$2[gracefulQueue].length; ++i) if (fs$2[gracefulQueue][i].length > 2) {
+			fs$2[gracefulQueue][i][3] = now;
+			fs$2[gracefulQueue][i][4] = now;
 		}
 		retry();
 	}
 	function retry() {
 		clearTimeout(retryTimer);
 		retryTimer = void 0;
-		if (fs$1[gracefulQueue].length === 0) return;
-		var elem = fs$1[gracefulQueue].shift();
+		if (fs$2[gracefulQueue].length === 0) return;
+		var elem = fs$2[gracefulQueue].shift();
 		var fn = elem[0];
 		var args = elem[1];
 		var err = elem[2];
@@ -1589,7 +2677,7 @@ var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			if (sinceAttempt >= Math.min(sinceStart * 1.2, 100)) {
 				debug("RETRY", fn.name, args);
 				fn.apply(null, args.concat([startTime]));
-			} else fs$1[gracefulQueue].push(elem);
+			} else fs$2[gracefulQueue].push(elem);
 		}
 		if (retryTimer === void 0) retryTimer = setTimeout(retry, 0);
 	}
@@ -2881,96 +3969,6 @@ const safeAwait = async (promise) => {
 	}
 };
 
-//#endregion
-//#region src/utils/prompts.ts
-const createOptions = (options) => options.map((option) => ({
-	label: option.toString(),
-	value: option
-}));
-const createPrompt = (fn) => {
-	return async (options) => {
-		const result = await fn(options);
-		if (isCancel(result)) {
-			cancel("User cancelled");
-			exit(0);
-		}
-		return result;
-	};
-};
-const createShowList = createPrompt((options) => {
-	options.map((option) => {
-		return isString(option) ? option : option.label;
-	}).forEach((item) => {
-		log.show(item, { type: "step" });
-	});
-});
-const createSearch = ({ message, options }) => {
-	const fuse = new Fuse(options, { keys: ["label"] });
-	return search({
-		message,
-		source: (term) => {
-			if (!term) return options;
-			return fuse.search(term).map(({ item }) => item);
-		}
-	});
-};
-process.on("uncaughtException", (error) => {
-	if (error instanceof Error && error.name === "ExitPromptError") log.show("User cancelled", { type: "error" });
-	else throw error;
-});
-const createCheckbox = async (opts) => {
-	const result = await multiselect(opts);
-	if (isCancel(result)) {
-		cancel("User cancelled");
-		exit(0);
-	}
-	return result;
-};
-const createNote = ({ message = "", title = "", opts }) => note(message, title, opts);
-const createConfirm = createPrompt(confirm);
-const createTasks = createPrompt(tasks);
-const createSelect = async (opts) => {
-	const result = await select(opts);
-	if (isCancel(result)) {
-		cancel("User cancelled");
-		exit(0);
-	}
-	return result;
-};
-const createInput = async (opts) => {
-	const result = await text(opts);
-	if (isCancel(result)) {
-		cancel("User cancelled");
-		exit(0);
-	}
-	return result;
-};
-const createGroupMultiSelect = async (opts) => {
-	const result = await groupMultiselect(opts);
-	if (isCancel(result)) {
-		cancel("User cancelled");
-		process.exit(0);
-	}
-	return result;
-};
-const createGroup = async (opts) => {
-	const result = await group(opts);
-	if (isCancel(result)) {
-		cancel("User cancelled");
-		exit(0);
-	}
-	return result;
-};
-const createSpinner = (message, options) => {
-	const s = spinner(options);
-	s.start(message);
-	return s;
-};
-const createTaskLog = (title, options) => taskLog({
-	title,
-	...options
-});
-
 //#endregion
 //#region src/utils/spinner.ts
 const BASE_OPTIONS = { timeout: 1e4 };
@@ -2984,34 +3982,103 @@ const ora = (options) => {
 
 //#endregion
 //#region src/utils/workspace.ts
+/**
+* Workspace configuration files and their detection patterns
+*/
+const WORKSPACE_CONFIGS = {
+	pnpm: { file: "pnpm-workspace.yaml" },
+	yarn: {
+		file: "package.json",
+		checkField: "workspaces"
+	},
+	npm: {
+		file: "package.json",
+		checkField: "workspaces"
+	},
+	bun: {
+		file: "package.json",
+		checkField: "workspaces"
+	},
+	deno: {
+		file: "package.json",
+		checkField: "workspaces"
+	}
+};
+/**
+* Priority order for workspace detection (matches package manager detector)
+*/
+const WORKSPACE_PRIORITY = [
+	"pnpm",
+	"yarn",
+	"npm",
+	"bun"
+];
+/**
+* Find workspace root by detecting workspace configuration files
+* Supports pnpm, yarn, npm, and bun workspace configurations
+*/
 async function findWorkspaceRoot(startDir = process.cwd()) {
 	let currentDir = startDir;
-	while (true) try {
-		await fs.access(path.join(currentDir, "pnpm-workspace.yaml"));
-		return currentDir;
-	} catch {
+	while (true) {
+		for (const pm of WORKSPACE_PRIORITY) {
+			const config = WORKSPACE_CONFIGS[pm];
+			const configPath = path.join(currentDir, config.file);
+			try {
+				await fs$1.access(configPath);
+				if (config.checkField === "workspaces") {
+					if (readJSON(configPath)?.workspaces) {
+						log.info(`Found ${pm} workspace at: ${currentDir}`);
+						return {
+							root: currentDir,
+							packageManager: pm
+						};
+					}
+				} else {
+					log.info(`Found ${pm} workspace at: ${currentDir}`);
+					return {
+						root: currentDir,
+						packageManager: pm
+					};
+				}
+			} catch {}
+		}
 		const parentDir = path.dirname(currentDir);
-		if (parentDir === currentDir) throw new Error("pnpm-workspace.yaml not found in any parent directory.");
+		if (parentDir === currentDir) throw new Error("Workspace configuration not found. Supported: pnpm-workspace.yaml or package.json with workspaces field");
 		currentDir = parentDir;
 	}
 }
+/**
+* Get workspace directories based on detected package manager
+* Supports pnpm-workspace.yaml and package.json workspaces field
+*/
 async function getWorkspaceDirs() {
-	const workspaceRoot = await findWorkspaceRoot();
+	const { root: workspaceRoot, packageManager } = await findWorkspaceRoot();
 	try {
-		log.info(`Found workspace root at: ${workspaceRoot}`);
-		const workspaceConfigPath = path.join(workspaceRoot, "pnpm-workspace.yaml");
-		const configFileContent = await fs.readFile(workspaceConfigPath, "utf8");
-		const workspaceConfig = yaml.parse(configFileContent);
-		if (!workspaceConfig?.packages?.length) {
-			log.warn("No packages defined in pnpm-workspace.yaml or file is empty.");
+		let packagePatterns = [];
+		if (packageManager === "pnpm") {
+			const workspaceConfigPath = path.join(workspaceRoot, "pnpm-workspace.yaml");
+			const configFileContent = await fs$1.readFile(workspaceConfigPath, "utf8");
+			const workspaceConfig = yaml.parse(configFileContent);
+			if (workspaceConfig?.packages?.length) packagePatterns = workspaceConfig.packages;
+		} else {
+			const packageJsonPath = path.join(workspaceRoot, "package.json");
+			const packageJson = JSON.parse(await fs$1.readFile(packageJsonPath, "utf8"));
+			if (packageJson?.workspaces) {
+				if (Array.isArray(packageJson.workspaces)) packagePatterns = packageJson.workspaces;
+				else if (packageJson.workspaces?.packages && Array.isArray(packageJson.workspaces.packages)) packagePatterns = packageJson.workspaces.packages;
+			}
+		}
+		if (!packagePatterns.length) {
+			log.warn("No packages defined in workspace configuration or file is empty.");
 			return {
 				root: workspaceRoot,
-				packages: []
+				packages: [],
+				packageManager
 			};
 		}
-		log.info(`Workspace package patterns: ${workspaceConfig.packages.join(", ")}`);
+		log.info(`Workspace package patterns: ${packagePatterns.join(", ")}`);
 		const dirs = [];
-		for (const pattern of workspaceConfig.packages) {
+		for (const pattern of packagePatterns) {
 			const packagePaths = await glob(pattern, {
 				cwd: workspaceRoot,
 				absolute: true
@@ -3020,13 +4087,15 @@ async function getWorkspaceDirs() {
 		}
 		return {
 			root: workspaceRoot,
-			packages: filterDirList(dirs)
+			packages: filterDirList(dirs),
+			packageManager
 		};
 	} catch (err) {
 		handleError(err, "Failed to get workspace dirs: ");
 		return {
 			root: workspaceRoot,
-			packages: []
+			packages: [],
+			packageManager
 		};
 	}
 }
@@ -3034,6 +4103,7 @@ async function getWorkspaceNames() {
 	const workspacePackages = [];
 	try {
 		const { root, packages } = await getWorkspaceDirs();
+		console.log("🚀 : getWorkspaceNames : root, packages:", root, packages);
 		for (const packageDir of packages) {
 			const packageJson = readJSON(`${packageDir}/package.json`);
 			if (packageJson) workspacePackages.push({
@@ -3055,5 +4125,5 @@ async function getWorkspaceNames() {
 const pkg = readPackage(import.meta, "..");
 
 //#endregion
-export { $, BASE_OPTIONS, CONFIG_NAME, Configstore, LOWEST_NODE_VERSION, addFiles, buildCommand, cached, checkFile, clearScreen, clearTerminal, colors, copyFile, createCheckbox, createCommand, createConfirm, createGroup, createGroupMultiSelect, createHelpExample, createInput, createNote, createOptions, createSearch, createSelect, createShowList, createSpinner, createStore, createTaskLog, createTasks, cwdPathname, deleteFile, deleteFiles, dirList, dirname, emptyDir, emptyDirs, exit, fileList, filename, filterDirList, getBrowserApps, getCurrentBranch, getDiffFiles, getGitStatus, getLocalBranches, getPackageDependencies, getWorkspaceDirs, getWorkspaceNames, glob, handleError, has, hasOwn, intro, isArray, isBoolean, isChinese, isDate, isDebug, isEmpty, isEmptyDir, isError, isFormData, isFunction, isMap, isNull, isNumber, isPlainObject, isPromise, isSet, isString, isSymbol, isURLSearchParams, isUndefined, loadConfig, loadEnv, log, logger, openBrowser, openBrowserApp, ora, outro, parseNames, pkg, progress, readFile, readGitignore, readJSON, readPackage, require$1 as require, safeAwait, sleep, stream, writeJSON, x, xASync, zx };
+export { $, BASE_OPTIONS, CONFIG_NAME, Configstore, LOCK_FILE_PATTERNS, LOWEST_NODE_VERSION, PACKAGE_MANAGER_NAMES, PackageManagerDetector, addFiles, buildCommand, cached, checkFile, clearScreen, clearTerminal, colors, copyFile, createCheckbox, createCommand, createConfirm, createGroup, createGroupMultiSelect, createHelpExample, createInput, createNote, createOptions, createSearch, createSelect, createShowList, createSpinner, createStore, createTaskLog, createTasks, cwdPathname, deleteFile, deleteFiles, dirList, dirname, emptyDir, emptyDirs, exit, fileList, filename, filterDirList, getAdapter, getAllAdapters, getBrowserApps, getCurrentBranch, getDiffFiles, getGitStatus, getLocalBranches, getPackageDependencies, getPackageManagerAdapter, getWorkspaceDirs, getWorkspaceNames, glob, handleError, has, hasOwn, intro, isArray, isBoolean, isChinese, isDate, isDebug, isEmpty, isEmptyDir, isError, isFormData, isFunction, isMap, isNull, isNumber, isPlainObject, isPromise, isSet, isString, isSymbol, isURLSearchParams, isUndefined, joinPath, loadConfig, loadEnv, log, logger, openBrowser, openBrowserApp, ora, outro, parseNames, pkg, progress, readFile, readGitignore, readJSON, readPackage, require$1 as require, safeAwait, sleep, stream, writeJSON, x, xASync, zx };
 //# sourceMappingURL=index.js.map