@udohjeremiah/moniq 0.1.0

package/dist/cli.js

@@ -0,0 +1,1295 @@
+#!/usr/bin/env node
+import { n as loadConfig } from "./dist-B1TNZsla.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { styleText } from "node:util";
+import { access } from "node:fs/promises";
+import { execFileSync } from "node:child_process";
+//#region ../../node_modules/.pnpm/cac@7.0.0/node_modules/cac/dist/index.js
+function toArr(any) {
+	return any == null ? [] : Array.isArray(any) ? any : [any];
+}
+function toVal(out, key, val, opts) {
+	var x, old = out[key], nxt = !!~opts.string.indexOf(key) ? val == null || val === true ? "" : String(val) : typeof val === "boolean" ? val : !!~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || (out._.push((x = +val, x * 0 === 0) ? x : val), !!val) : (x = +val, x * 0 === 0) ? x : val;
+	out[key] = old == null ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
+}
+function lib_default(args, opts) {
+	args = args || [];
+	opts = opts || {};
+	var k, arr, arg, name, val, out = { _: [] };
+	var i = 0, j = 0, idx = 0, len = args.length;
+	const alibi = opts.alias !== void 0;
+	const strict = opts.unknown !== void 0;
+	const defaults = opts.default !== void 0;
+	opts.alias = opts.alias || {};
+	opts.string = toArr(opts.string);
+	opts.boolean = toArr(opts.boolean);
+	if (alibi) for (k in opts.alias) {
+		arr = opts.alias[k] = toArr(opts.alias[k]);
+		for (i = 0; i < arr.length; i++) (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
+	}
+	for (i = opts.boolean.length; i-- > 0;) {
+		arr = opts.alias[opts.boolean[i]] || [];
+		for (j = arr.length; j-- > 0;) opts.boolean.push(arr[j]);
+	}
+	for (i = opts.string.length; i-- > 0;) {
+		arr = opts.alias[opts.string[i]] || [];
+		for (j = arr.length; j-- > 0;) opts.string.push(arr[j]);
+	}
+	if (defaults) for (k in opts.default) {
+		name = typeof opts.default[k];
+		arr = opts.alias[k] = opts.alias[k] || [];
+		if (opts[name] !== void 0) {
+			opts[name].push(k);
+			for (i = 0; i < arr.length; i++) opts[name].push(arr[i]);
+		}
+	}
+	const keys = strict ? Object.keys(opts.alias) : [];
+	for (i = 0; i < len; i++) {
+		arg = args[i];
+		if (arg === "--") {
+			out._ = out._.concat(args.slice(++i));
+			break;
+		}
+		for (j = 0; j < arg.length; j++) if (arg.charCodeAt(j) !== 45) break;
+		if (j === 0) out._.push(arg);
+		else if (arg.substring(j, j + 3) === "no-") {
+			name = arg.substring(j + 3);
+			if (strict && !~keys.indexOf(name)) return opts.unknown(arg);
+			out[name] = false;
+		} else {
+			for (idx = j + 1; idx < arg.length; idx++) if (arg.charCodeAt(idx) === 61) break;
+			name = arg.substring(j, idx);
+			val = arg.substring(++idx) || i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i];
+			arr = j === 2 ? [name] : name;
+			for (idx = 0; idx < arr.length; idx++) {
+				name = arr[idx];
+				if (strict && !~keys.indexOf(name)) return opts.unknown("-".repeat(j) + name);
+				toVal(out, name, idx + 1 < arr.length || val, opts);
+			}
+		}
+	}
+	if (defaults) {
+		for (k in opts.default) if (out[k] === void 0) out[k] = opts.default[k];
+	}
+	if (alibi) for (k in out) {
+		arr = opts.alias[k] || [];
+		while (arr.length > 0) out[arr.shift()] = out[k];
+	}
+	return out;
+}
+function removeBrackets(v) {
+	return v.replace(/[<[].+/, "").trim();
+}
+function findAllBrackets(v) {
+	const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
+	const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
+	const res = [];
+	const parse = (match) => {
+		let variadic = false;
+		let value = match[1];
+		if (value.startsWith("...")) {
+			value = value.slice(3);
+			variadic = true;
+		}
+		return {
+			required: match[0].startsWith("<"),
+			value,
+			variadic
+		};
+	};
+	let angledMatch;
+	while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v)) res.push(parse(angledMatch));
+	let squareMatch;
+	while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v)) res.push(parse(squareMatch));
+	return res;
+}
+function getMriOptions(options) {
+	const result = {
+		alias: {},
+		boolean: []
+	};
+	for (const [index, option] of options.entries()) {
+		if (option.names.length > 1) result.alias[option.names[0]] = option.names.slice(1);
+		if (option.isBoolean) if (option.negated) {
+			if (!options.some((o, i) => {
+				return i !== index && o.names.some((name) => option.names.includes(name)) && typeof o.required === "boolean";
+			})) result.boolean.push(option.names[0]);
+		} else result.boolean.push(option.names[0]);
+	}
+	return result;
+}
+function findLongest(arr) {
+	return arr.sort((a, b) => {
+		return a.length > b.length ? -1 : 1;
+	})[0];
+}
+function padRight(str, length) {
+	return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
+}
+function camelcase(input) {
+	return input.replaceAll(/([a-z])-([a-z])/g, (_, p1, p2) => {
+		return p1 + p2.toUpperCase();
+	});
+}
+function setDotProp(obj, keys, val) {
+	let current = obj;
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		if (i === keys.length - 1) {
+			current[key] = val;
+			return;
+		}
+		if (current[key] == null) {
+			const nextKeyIsArrayIndex = +keys[i + 1] > -1;
+			current[key] = nextKeyIsArrayIndex ? [] : {};
+		}
+		current = current[key];
+	}
+}
+function setByType(obj, transforms) {
+	for (const key of Object.keys(transforms)) {
+		const transform = transforms[key];
+		if (transform.shouldTransform) {
+			obj[key] = [obj[key]].flat();
+			if (typeof transform.transformFunction === "function") obj[key] = obj[key].map(transform.transformFunction);
+		}
+	}
+}
+function getFileName(input) {
+	const m = /([^\\/]+)$/.exec(input);
+	return m ? m[1] : "";
+}
+function camelcaseOptionName(name) {
+	return name.split(".").map((v, i) => {
+		return i === 0 ? camelcase(v) : v;
+	}).join(".");
+}
+var CACError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CACError";
+		if (typeof Error.captureStackTrace !== "function") this.stack = new Error(message).stack;
+	}
+};
+var Option = class {
+	rawName;
+	description;
+	/** Option name */
+	name;
+	/** Option name and aliases */
+	names;
+	isBoolean;
+	required;
+	config;
+	negated;
+	constructor(rawName, description, config) {
+		this.rawName = rawName;
+		this.description = description;
+		this.config = Object.assign({}, config);
+		rawName = rawName.replaceAll(".*", "");
+		this.negated = false;
+		this.names = removeBrackets(rawName).split(",").map((v) => {
+			let name = v.trim().replace(/^-{1,2}/, "");
+			if (name.startsWith("no-")) {
+				this.negated = true;
+				name = name.replace(/^no-/, "");
+			}
+			return camelcaseOptionName(name);
+		}).sort((a, b) => a.length > b.length ? 1 : -1);
+		this.name = this.names.at(-1);
+		if (this.negated && this.config.default == null) this.config.default = true;
+		if (rawName.includes("<")) this.required = true;
+		else if (rawName.includes("[")) this.required = false;
+		else this.isBoolean = true;
+	}
+};
+let runtimeProcessArgs;
+let runtimeInfo;
+if (typeof process !== "undefined") {
+	let runtimeName;
+	if (typeof Deno !== "undefined" && typeof Deno.version?.deno === "string") runtimeName = "deno";
+	else if (typeof Bun !== "undefined" && typeof Bun.version === "string") runtimeName = "bun";
+	else runtimeName = "node";
+	runtimeInfo = `${process.platform}-${process.arch} ${runtimeName}-${process.version}`;
+	runtimeProcessArgs = process.argv;
+} else if (typeof navigator === "undefined") runtimeInfo = `unknown`;
+else runtimeInfo = `${navigator.platform} ${navigator.userAgent}`;
+var Command = class {
+	rawName;
+	description;
+	config;
+	cli;
+	options;
+	aliasNames;
+	name;
+	args;
+	commandAction;
+	usageText;
+	versionNumber;
+	examples;
+	helpCallback;
+	globalCommand;
+	constructor(rawName, description, config = {}, cli) {
+		this.rawName = rawName;
+		this.description = description;
+		this.config = config;
+		this.cli = cli;
+		this.options = [];
+		this.aliasNames = [];
+		this.name = removeBrackets(rawName);
+		this.args = findAllBrackets(rawName);
+		this.examples = [];
+	}
+	usage(text) {
+		this.usageText = text;
+		return this;
+	}
+	allowUnknownOptions() {
+		this.config.allowUnknownOptions = true;
+		return this;
+	}
+	ignoreOptionDefaultValue() {
+		this.config.ignoreOptionDefaultValue = true;
+		return this;
+	}
+	version(version, customFlags = "-v, --version") {
+		this.versionNumber = version;
+		this.option(customFlags, "Display version number");
+		return this;
+	}
+	example(example) {
+		this.examples.push(example);
+		return this;
+	}
+	/**
+	* Add a option for this command
+	* @param rawName Raw option name(s)
+	* @param description Option description
+	* @param config Option config
+	*/
+	option(rawName, description, config) {
+		const option = new Option(rawName, description, config);
+		this.options.push(option);
+		return this;
+	}
+	alias(name) {
+		this.aliasNames.push(name);
+		return this;
+	}
+	action(callback) {
+		this.commandAction = callback;
+		return this;
+	}
+	/**
+	* Check if a command name is matched by this command
+	* @param name Command name
+	*/
+	isMatched(name) {
+		return this.name === name || this.aliasNames.includes(name);
+	}
+	get isDefaultCommand() {
+		return this.name === "" || this.aliasNames.includes("!");
+	}
+	get isGlobalCommand() {
+		return this instanceof GlobalCommand;
+	}
+	/**
+	* Check if an option is registered in this command
+	* @param name Option name
+	*/
+	hasOption(name) {
+		name = name.split(".")[0];
+		return this.options.find((option) => {
+			return option.names.includes(name);
+		});
+	}
+	outputHelp() {
+		const { name, commands } = this.cli;
+		const { versionNumber, options: globalOptions, helpCallback } = this.cli.globalCommand;
+		let sections = [{ body: `${name}${versionNumber ? `/${versionNumber}` : ""}` }];
+		sections.push({
+			title: "Usage",
+			body: `  $ ${name} ${this.usageText || this.rawName}`
+		});
+		if ((this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0) {
+			const longestCommandName = findLongest(commands.map((command) => command.rawName));
+			sections.push({
+				title: "Commands",
+				body: commands.map((command) => {
+					return `  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`;
+				}).join("\n")
+			}, {
+				title: `For more info, run any command with the \`--help\` flag`,
+				body: commands.map((command) => `  $ ${name}${command.name === "" ? "" : ` ${command.name}`} --help`).join("\n")
+			});
+		}
+		let options = this.isGlobalCommand ? globalOptions : [...this.options, ...globalOptions || []];
+		if (!this.isGlobalCommand && !this.isDefaultCommand) options = options.filter((option) => option.name !== "version");
+		if (options.length > 0) {
+			const longestOptionName = findLongest(options.map((option) => option.rawName));
+			sections.push({
+				title: "Options",
+				body: options.map((option) => {
+					return `  ${padRight(option.rawName, longestOptionName.length)}  ${option.description} ${option.config.default === void 0 ? "" : `(default: ${option.config.default})`}`;
+				}).join("\n")
+			});
+		}
+		if (this.examples.length > 0) sections.push({
+			title: "Examples",
+			body: this.examples.map((example) => {
+				if (typeof example === "function") return example(name);
+				return example;
+			}).join("\n")
+		});
+		if (helpCallback) sections = helpCallback(sections) || sections;
+		console.info(sections.map((section) => {
+			return section.title ? `${section.title}:\n${section.body}` : section.body;
+		}).join("\n\n"));
+	}
+	outputVersion() {
+		const { name } = this.cli;
+		const { versionNumber } = this.cli.globalCommand;
+		if (versionNumber) console.info(`${name}/${versionNumber} ${runtimeInfo}`);
+	}
+	checkRequiredArgs() {
+		const minimalArgsCount = this.args.filter((arg) => arg.required).length;
+		if (this.cli.args.length < minimalArgsCount) throw new CACError(`missing required args for command \`${this.rawName}\``);
+	}
+	/**
+	* Check if the parsed options contain any unknown options
+	*
+	* Exit and output error when true
+	*/
+	checkUnknownOptions() {
+		const { options, globalCommand } = this.cli;
+		if (!this.config.allowUnknownOptions) {
+			for (const name of Object.keys(options)) if (name !== "--" && !this.hasOption(name) && !globalCommand.hasOption(name)) throw new CACError(`Unknown option \`${name.length > 1 ? `--${name}` : `-${name}`}\``);
+		}
+	}
+	/**
+	* Check if the required string-type options exist
+	*/
+	checkOptionValue() {
+		const { options: parsedOptions, globalCommand } = this.cli;
+		const options = [...globalCommand.options, ...this.options];
+		for (const option of options) {
+			const value = parsedOptions[option.name.split(".")[0]];
+			if (option.required) {
+				const hasNegated = options.some((o) => o.negated && o.names.includes(option.name));
+				if (value === true || value === false && !hasNegated) throw new CACError(`option \`${option.rawName}\` value is missing`);
+			}
+		}
+	}
+	/**
+	* Check if the number of args is more than expected
+	*/
+	checkUnusedArgs() {
+		const maximumArgsCount = this.args.some((arg) => arg.variadic) ? Infinity : this.args.length;
+		if (maximumArgsCount < this.cli.args.length) throw new CACError(`Unused args: ${this.cli.args.slice(maximumArgsCount).map((arg) => `\`${arg}\``).join(", ")}`);
+	}
+};
+var GlobalCommand = class extends Command {
+	constructor(cli) {
+		super("@@global@@", "", {}, cli);
+	}
+};
+var CAC = class extends EventTarget {
+	/** The program name to display in help and version message */
+	name;
+	commands;
+	globalCommand;
+	matchedCommand;
+	matchedCommandName;
+	/**
+	* Raw CLI arguments
+	*/
+	rawArgs;
+	/**
+	* Parsed CLI arguments
+	*/
+	args;
+	/**
+	* Parsed CLI options, camelCased
+	*/
+	options;
+	showHelpOnExit;
+	showVersionOnExit;
+	/**
+	* @param name The program name to display in help and version message
+	*/
+	constructor(name = "") {
+		super();
+		this.name = name;
+		this.commands = [];
+		this.rawArgs = [];
+		this.args = [];
+		this.options = {};
+		this.globalCommand = new GlobalCommand(this);
+		this.globalCommand.usage("<command> [options]");
+	}
+	/**
+	* Add a global usage text.
+	*
+	* This is not used by sub-commands.
+	*/
+	usage(text) {
+		this.globalCommand.usage(text);
+		return this;
+	}
+	/**
+	* Add a sub-command
+	*/
+	command(rawName, description, config) {
+		const command = new Command(rawName, description || "", config, this);
+		command.globalCommand = this.globalCommand;
+		this.commands.push(command);
+		return command;
+	}
+	/**
+	* Add a global CLI option.
+	*
+	* Which is also applied to sub-commands.
+	*/
+	option(rawName, description, config) {
+		this.globalCommand.option(rawName, description, config);
+		return this;
+	}
+	/**
+	* Show help message when `-h, --help` flags appear.
+	*
+	*/
+	help(callback) {
+		this.globalCommand.option("-h, --help", "Display this message");
+		this.globalCommand.helpCallback = callback;
+		this.showHelpOnExit = true;
+		return this;
+	}
+	/**
+	* Show version number when `-v, --version` flags appear.
+	*
+	*/
+	version(version, customFlags = "-v, --version") {
+		this.globalCommand.version(version, customFlags);
+		this.showVersionOnExit = true;
+		return this;
+	}
+	/**
+	* Add a global example.
+	*
+	* This example added here will not be used by sub-commands.
+	*/
+	example(example) {
+		this.globalCommand.example(example);
+		return this;
+	}
+	/**
+	* Output the corresponding help message
+	* When a sub-command is matched, output the help message for the command
+	* Otherwise output the global one.
+	*
+	*/
+	outputHelp() {
+		if (this.matchedCommand) this.matchedCommand.outputHelp();
+		else this.globalCommand.outputHelp();
+	}
+	/**
+	* Output the version number.
+	*
+	*/
+	outputVersion() {
+		this.globalCommand.outputVersion();
+	}
+	setParsedInfo({ args, options }, matchedCommand, matchedCommandName) {
+		this.args = args;
+		this.options = options;
+		if (matchedCommand) this.matchedCommand = matchedCommand;
+		if (matchedCommandName) this.matchedCommandName = matchedCommandName;
+		return this;
+	}
+	unsetMatchedCommand() {
+		this.matchedCommand = void 0;
+		this.matchedCommandName = void 0;
+	}
+	/**
+	* Parse argv
+	*/
+	parse(argv, { run = true } = {}) {
+		if (!argv) {
+			if (!runtimeProcessArgs) throw new Error("No argv provided and runtime process argv is not available.");
+			argv = runtimeProcessArgs;
+		}
+		this.rawArgs = argv;
+		if (!this.name) this.name = argv[1] ? getFileName(argv[1]) : "cli";
+		let shouldParse = true;
+		for (const command of this.commands) {
+			const parsed = this.mri(argv.slice(2), command);
+			const commandName = parsed.args[0];
+			if (command.isMatched(commandName)) {
+				shouldParse = false;
+				const parsedInfo = {
+					...parsed,
+					args: parsed.args.slice(1)
+				};
+				this.setParsedInfo(parsedInfo, command, commandName);
+				this.dispatchEvent(new CustomEvent(`command:${commandName}`, { detail: command }));
+			}
+		}
+		if (shouldParse) {
+			for (const command of this.commands) if (command.isDefaultCommand) {
+				shouldParse = false;
+				const parsed = this.mri(argv.slice(2), command);
+				this.setParsedInfo(parsed, command);
+				this.dispatchEvent(new CustomEvent("command:!", { detail: command }));
+			}
+		}
+		if (shouldParse) {
+			const parsed = this.mri(argv.slice(2));
+			this.setParsedInfo(parsed);
+		}
+		if (this.options.help && this.showHelpOnExit) {
+			this.outputHelp();
+			run = false;
+			this.unsetMatchedCommand();
+		}
+		if (this.options.version && this.showVersionOnExit && this.matchedCommandName == null) {
+			this.outputVersion();
+			run = false;
+			this.unsetMatchedCommand();
+		}
+		const parsedArgv = {
+			args: this.args,
+			options: this.options
+		};
+		if (run) this.runMatchedCommand();
+		if (!this.matchedCommand && this.args[0]) this.dispatchEvent(new CustomEvent("command:*", { detail: this.args[0] }));
+		return parsedArgv;
+	}
+	mri(argv, command) {
+		const cliOptions = [...this.globalCommand.options, ...command ? command.options : []];
+		const mriOptions = getMriOptions(cliOptions);
+		let argsAfterDoubleDashes = [];
+		const doubleDashesIndex = argv.indexOf("--");
+		if (doubleDashesIndex !== -1) {
+			argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1);
+			argv = argv.slice(0, doubleDashesIndex);
+		}
+		let parsed = lib_default(argv, mriOptions);
+		parsed = Object.keys(parsed).reduce((res, name) => {
+			return {
+				...res,
+				[camelcaseOptionName(name)]: parsed[name]
+			};
+		}, { _: [] });
+		const args = parsed._;
+		const options = { "--": argsAfterDoubleDashes };
+		const ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue;
+		const transforms = Object.create(null);
+		for (const cliOption of cliOptions) {
+			if (!ignoreDefault && cliOption.config.default !== void 0) for (const name of cliOption.names) options[name] = cliOption.config.default;
+			if (Array.isArray(cliOption.config.type) && transforms[cliOption.name] === void 0) {
+				transforms[cliOption.name] = Object.create(null);
+				transforms[cliOption.name].shouldTransform = true;
+				transforms[cliOption.name].transformFunction = cliOption.config.type[0];
+			}
+		}
+		for (const key of Object.keys(parsed)) if (key !== "_") {
+			setDotProp(options, key.split("."), parsed[key]);
+			setByType(options, transforms);
+		}
+		return {
+			args,
+			options
+		};
+	}
+	runMatchedCommand() {
+		const { args, options, matchedCommand: command } = this;
+		if (!command || !command.commandAction) return;
+		command.checkUnknownOptions();
+		command.checkOptionValue();
+		command.checkRequiredArgs();
+		command.checkUnusedArgs();
+		const actionArgs = [];
+		command.args.forEach((arg, index) => {
+			if (arg.variadic) actionArgs.push(args.slice(index));
+			else actionArgs.push(args[index]);
+		});
+		actionArgs.push(options);
+		return command.commandAction.apply(this, actionArgs);
+	}
+};
+/**
+* @param name The program name to display in help and version message
+*/
+const cac = (name = "") => new CAC(name);
+//#endregion
+//#region ../workspace/dist/index.js
+async function readPackageJson(path) {
+	const { readFile } = await import("node:fs/promises");
+	const content = await readFile(path, "utf8");
+	return JSON.parse(content);
+}
+function getScript(packageJson, name) {
+	const scripts = packageJson["scripts"];
+	if (typeof scripts !== "object" || scripts === null) return;
+	const value = Object.entries(scripts).find(([k]) => k === name)?.[1];
+	return typeof value === "string" ? value : void 0;
+}
+const npmCommand = getNpmCommand();
+const pnpmCommand = getPnpmCommand();
+const yarnCommand = getYarnCommand();
+function discoverWorkspace(root) {
+	const pm = detectPackageManager(root);
+	let output;
+	switch (pm) {
+		case "npm": {
+			output = execFileSync(npmCommand, [
+				"ls",
+				"--workspaces",
+				"--all",
+				"--json",
+				"--depth",
+				"0"
+			], {
+				cwd: root,
+				encoding: "utf8"
+			});
+			const tree = JSON.parse(output);
+			return Object.values(tree.dependencies ?? {}).map((entry) => ({ path: entry.path }));
+		}
+		case "pnpm":
+			output = execFileSync(pnpmCommand, [
+				"ls",
+				"-r",
+				"--depth",
+				"-1",
+				"--json"
+			], {
+				cwd: root,
+				encoding: "utf8"
+			});
+			return JSON.parse(output).map((entry) => ({ path: entry.path }));
+		case "yarn":
+			output = execFileSync(yarnCommand, [
+				"workspaces",
+				"list",
+				"--json"
+			], {
+				cwd: root,
+				encoding: "utf8"
+			});
+			return output.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line)).map((entry) => ({ path: path.resolve(root, entry.location) }));
+	}
+}
+function detectPackageManager(root) {
+	const userAgent = process.env["npm_config_user_agent"] ?? "";
+	if (userAgent.startsWith("pnpm")) return "pnpm";
+	if (userAgent.startsWith("yarn")) return "yarn";
+	if (userAgent.startsWith("npm")) return "npm";
+	const request = createRequire(import.meta.url);
+	for (const [lockFile, pm] of Object.entries({
+		"package-lock.json": "npm",
+		"pnpm-lock.yaml": "pnpm",
+		"yarn.lock": "yarn"
+	})) try {
+		request.resolve(path.join(root, lockFile));
+		return pm;
+	} catch {}
+	try {
+		const rawPm = request(path.join(root, "package.json"))["packageManager"];
+		const pm = typeof rawPm === "string" ? rawPm.split("@", 2)[0] ?? "" : "";
+		if ([
+			"npm",
+			"pnpm",
+			"yarn"
+		].includes(pm)) return pm;
+	} catch {}
+	return "pnpm";
+}
+function getNpmCommand() {
+	return path.join(path.dirname(process.execPath), "npm");
+}
+function getPnpmCommand() {
+	try {
+		const request = createRequire(import.meta.url);
+		const specifier = ["pnpm", "package.json"].join("/");
+		const packagePath = request.resolve(specifier);
+		return path.resolve(path.dirname(packagePath), "bin", "pnpm.cjs");
+	} catch {
+		return "pnpm";
+	}
+}
+function getYarnCommand() {
+	try {
+		const request = createRequire(import.meta.url);
+		const specifier = [
+			"@yarnpkg",
+			"cli",
+			"package.json"
+		].join("/");
+		const packagePath = request.resolve(specifier);
+		return path.resolve(path.dirname(packagePath), "sources", "bin", "yarn.js");
+	} catch {
+		try {
+			const request = createRequire(import.meta.url);
+			const specifier = ["yarn", "package.json"].join("/");
+			const packagePath = request.resolve(specifier);
+			return path.resolve(path.dirname(packagePath), "bin", "yarn.js");
+		} catch {
+			return "yarn";
+		}
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/wildcard-match@5.1.4/node_modules/wildcard-match/build/index.es.mjs
+/**
+* Escapes a character if it has a special meaning in regular expressions
+* and returns the character as is if it doesn't
+*/
+function escapeRegExpChar(char) {
+	if (char === "-" || char === "^" || char === "$" || char === "+" || char === "." || char === "(" || char === ")" || char === "|" || char === "[" || char === "]" || char === "{" || char === "}" || char === "*" || char === "?" || char === "\\") return "\\".concat(char);
+	else return char;
+}
+/**
+* Escapes all characters in a given string that have a special meaning in regular expressions
+*/
+function escapeRegExpString(str) {
+	var result = "";
+	for (var i = 0; i < str.length; i++) result += escapeRegExpChar(str[i]);
+	return result;
+}
+/**
+* Transforms one or more glob patterns into a RegExp pattern
+*/
+function transform(pattern, separator) {
+	if (separator === void 0) separator = true;
+	if (Array.isArray(pattern)) {
+		var regExpPatterns = pattern.map(function(p) {
+			return "^".concat(transform(p, separator), "$");
+		});
+		return "(?:".concat(regExpPatterns.join("|"), ")");
+	}
+	var separatorSplitter = "";
+	var separatorMatcher = "";
+	var wildcard = ".";
+	if (separator === true) {
+		separatorSplitter = "/";
+		separatorMatcher = "[/\\\\]";
+		wildcard = "[^/\\\\]";
+	} else if (separator) {
+		separatorSplitter = separator;
+		separatorMatcher = escapeRegExpString(separatorSplitter);
+		if (separatorMatcher.length > 1) {
+			separatorMatcher = "(?:".concat(separatorMatcher, ")");
+			wildcard = "((?!".concat(separatorMatcher, ").)");
+		} else wildcard = "[^".concat(separatorMatcher, "]");
+	}
+	var requiredSeparator = separator ? "".concat(separatorMatcher, "+?") : "";
+	var optionalSeparator = separator ? "".concat(separatorMatcher, "*?") : "";
+	var segments = separator ? pattern.split(separatorSplitter) : [pattern];
+	var result = "";
+	for (var s = 0; s < segments.length; s++) {
+		var segment = segments[s];
+		var nextSegment = segments[s + 1];
+		var currentSeparator = "";
+		if (!segment && s > 0) continue;
+		if (separator) if (s === segments.length - 1) currentSeparator = optionalSeparator;
+		else if (nextSegment !== "**") currentSeparator = requiredSeparator;
+		else currentSeparator = "";
+		if (separator && segment === "**") {
+			if (currentSeparator) {
+				result += s === 0 ? "" : s === segments.length - 1 ? "(?:".concat(requiredSeparator, "|$)") : requiredSeparator;
+				result += "(?:".concat(wildcard, "*?").concat(currentSeparator, ")*?");
+			}
+			continue;
+		}
+		for (var c = 0; c < segment.length; c++) {
+			var char = segment[c];
+			if (char === "\\") {
+				if (c < segment.length - 1) {
+					result += escapeRegExpChar(segment[c + 1]);
+					c++;
+				}
+			} else if (char === "?") result += wildcard;
+			else if (char === "*") result += "".concat(wildcard, "*?");
+			else result += escapeRegExpChar(char);
+		}
+		result += currentSeparator;
+	}
+	return result;
+}
+function isMatch(regexp, sample) {
+	if (typeof sample !== "string") throw new TypeError("Sample must be a string, but ".concat(typeof sample, " given"));
+	return regexp.test(sample);
+}
+/**
+* Compiles one or more glob patterns into a RegExp and returns an isMatch function.
+* The isMatch function takes a sample string as its only argument and returns `true`
+* if the string matches the pattern(s).
+*
+* ```js
+* wildcardMatch('src/*.js')('src/index.js') //=> true
+* ```
+*
+* ```js
+* const isMatch = wildcardMatch('*.example.com', '.')
+* isMatch('foo.example.com') //=> true
+* isMatch('foo.bar.com') //=> false
+* ```
+*/
+function wildcardMatch(pattern, options) {
+	if (typeof pattern !== "string" && !Array.isArray(pattern)) throw new TypeError("The first argument must be a single pattern string or an array of patterns, but ".concat(typeof pattern, " given"));
+	if (typeof options === "string" || typeof options === "boolean") options = { separator: options };
+	if (arguments.length === 2 && !(typeof options === "undefined" || typeof options === "object" && options !== null && !Array.isArray(options))) throw new TypeError("The second argument must be an options object or a string/boolean separator, but ".concat(typeof options, " given"));
+	options = options || {};
+	if (options.separator === "\\") throw new Error("\\ is not a valid separator because it is used for escaping. Try setting the separator to `true` instead");
+	var regexpPattern = transform(pattern, options.separator);
+	var regexp = new RegExp("^".concat(regexpPattern, "$"), options.flags);
+	var fn = isMatch.bind(null, regexp);
+	fn.options = options;
+	fn.pattern = pattern;
+	fn.regexp = regexp;
+	return fn;
+}
+//#endregion
+//#region ../core/dist/index.js
+async function resolveScriptPolicies(scriptsConfig, root, packages_) {
+	const diagnostics = [];
+	const entries = Object.entries(scriptsConfig ?? {});
+	for (const [scriptName, policyOrArray] of entries) {
+		const policies = Array.isArray(policyOrArray) ? policyOrArray : [policyOrArray];
+		for (const package_ of packages_) {
+			const relativePath = path.relative(root, package_.path);
+			const policy = pickPolicy(policies, relativePath);
+			if (policy !== void 0 && policy.severity !== "off") await resolvePolicy(policy, scriptName, package_, relativePath, diagnostics);
+		}
+	}
+	return diagnostics;
+}
+function isCommandMatch(actual, expected) {
+	if (typeof expected === "function") return expected(actual);
+	if (expected instanceof RegExp) return expected.test(actual);
+	return actual === expected;
+}
+function isGlobMatch(pattern, relativePath) {
+	if (pattern === "*") return true;
+	if (pattern === ".") return relativePath === "." || relativePath === "";
+	return wildcardMatch(pattern)(relativePath);
+}
+function isMatchAny(patterns, relativePath) {
+	for (const pattern of patterns) if (isGlobMatch(pattern, relativePath)) return true;
+	return false;
+}
+function isPolicyMatch(policy, relativePath) {
+	const include = policy.include ?? ["*"];
+	const exclude = policy.exclude ?? [];
+	return isMatchAny(include, relativePath) && !isMatchAny(exclude, relativePath);
+}
+function pickPolicy(policies, relativePath) {
+	for (const policy of policies) if (isPolicyMatch(policy, relativePath)) return policy;
+}
+async function resolvePolicy(policy, scriptName, package_, relativePath, diagnostics) {
+	const packageJson = await readPackageJson(path.join(package_.path, "package.json"));
+	const packageDisplayName = packageJson["name"] ?? path.basename(package_.path);
+	const hasScript = getScript(packageJson, scriptName) !== void 0;
+	const severity = policy.severity ?? "error";
+	if (policy.required !== false && !hasScript) {
+		diagnostics.push({
+			fix: policy.autofix && typeof policy.command === "string" ? policy.command : void 0,
+			message: `Missing required script "${scriptName}"`,
+			packageName: packageDisplayName,
+			packagePath: package_.path,
+			scriptName,
+			severity
+		});
+		return;
+	}
+	if (policy.command === void 0 || !hasScript) return;
+	if (policy.allowCustomCommands !== void 0 && isMatchAny(policy.allowCustomCommands, relativePath)) return;
+	const actualCommand = getScript(packageJson, scriptName);
+	if (actualCommand !== void 0 && isCommandMatch(actualCommand, policy.command)) return;
+	diagnostics.push({
+		actual: actualCommand,
+		expected: typeof policy.command === "string" ? policy.command : void 0,
+		fix: policy.autofix && typeof policy.command === "string" ? policy.command : void 0,
+		message: `Unexpected command for script "${scriptName}"`,
+		packageName: packageDisplayName,
+		packagePath: package_.path,
+		scriptName,
+		severity
+	});
+}
+async function resolve(config, root, packages_) {
+	const diagnostics = [];
+	const scriptDiags = await resolveScriptPolicies(config.scripts, root, packages_);
+	diagnostics.push(...scriptDiags);
+	return diagnostics;
+}
+//#endregion
+//#region ../cli/dist/index.js
+function formatDiagnostics(diagnostics, options) {
+	if ((options?.format ?? "pretty") === "json") return formatJson(diagnostics);
+	return formatPretty(diagnostics, options?.isDryRun);
+}
+function formatJson(diagnostics) {
+	return `${JSON.stringify(diagnostics, void 0, 2)}\n`;
+}
+function formatPretty(diagnostics, isDryRun) {
+	if (diagnostics.length === 0) return styleText(["bold", "green"], "✅ No issues found.");
+	const lines = [];
+	const byPackage = /* @__PURE__ */ new Map();
+	for (const d of diagnostics) {
+		const array = byPackage.get(d.packageName);
+		if (array) array.push(d);
+		else byPackage.set(d.packageName, [d]);
+	}
+	for (const [packageName, diags] of byPackage) {
+		lines.push("", `📦 ${styleText(["bold", "cyan"], packageName)}`);
+		for (const d of diags) pushDiagnostic(lines, d, isDryRun);
+	}
+	const errorCount = diagnostics.filter((d) => d.severity === "error").length;
+	const warningCount = diagnostics.filter((d) => d.severity === "warn").length;
+	const countParts = [];
+	if (errorCount > 0) countParts.push(styleText("red", `${String(errorCount)} error(s)`));
+	if (warningCount > 0) countParts.push(styleText("yellow", `${String(warningCount)} warning(s)`));
+	const summary = countParts.join(", ");
+	const summaryLine = `📋 Found ${String(diagnostics.length)} issue(s) — ${summary.length > 0 ? summary : "all clear"}`;
+	lines.push("", styleText("dim", summaryLine));
+	if (isDryRun) {
+		const fixableCount = diagnostics.filter((d) => d.fix && d.severity !== "off").length;
+		lines.push("", styleText("dim", `🔮 Dry-run: ${String(fixableCount)} fix(es) available`));
+	}
+	return lines.join("\n");
+}
+function pushDiagnostic(lines, d, isDryRun) {
+	const badge = severityBadge(d.severity);
+	const emoji = severityEmoji(d.severity);
+	lines.push(`  ${emoji} ${badge} ${d.message}`);
+	if (d.expected && d.actual) lines.push(`         ${styleText("dim", "Expected:")} ${styleText("cyan", d.expected)}`, `         ${styleText("dim", "Actual:")}   ${styleText("red", d.actual)}`);
+	else if (d.expected) lines.push(`         ${styleText("dim", "Expected:")} ${styleText("cyan", d.expected)}`);
+	else if (d.actual) lines.push(`         ${styleText("dim", "Actual:")}   ${styleText("red", d.actual)}`);
+	if (d.fix) {
+		const label = styleText("dim", isDryRun ? "Would fix:" : "Fix:");
+		const icon = isDryRun ? "🔮" : "🔧";
+		lines.push(`         ${icon} ${label} ${d.fix}`);
+	}
+}
+function severityBadge(severity) {
+	if (severity === "error") return styleText(["bold", "red"], "ERROR");
+	if (severity === "warn") return styleText(["bold", "yellow"], "WARN");
+	return styleText("gray", "OFF");
+}
+function severityEmoji(severity) {
+	if (severity === "error") return "❌";
+	if (severity === "warn") return "⚠️ ";
+	return "⚪";
+}
+async function applyScriptFixes(diagnostics, options) {
+	const fixable = diagnostics.filter((d) => d.fix && d.severity !== "off");
+	const isDryRun = options?.isDryRun ?? false;
+	let fixed = 0;
+	let errors = 0;
+	const packages = /* @__PURE__ */ new Set();
+	for (const d of fixable) {
+		if (!d.fix) continue;
+		if (isDryRun) {
+			fixed++;
+			packages.add(d.packagePath);
+			continue;
+		}
+		try {
+			const packageFilePath = path.join(d.packagePath, "package.json");
+			const { readFile, writeFile } = await import("node:fs/promises");
+			const content = await readFile(packageFilePath, "utf8");
+			const package_ = JSON.parse(content);
+			const scriptName = d.scriptName;
+			if (!scriptName) continue;
+			const scriptsRecord = package_["scripts"];
+			if (scriptsRecord) {
+				const entries = Object.entries(scriptsRecord);
+				if (!Object.hasOwn(scriptsRecord, scriptName)) entries.push([scriptName, d.fix]);
+				package_["scripts"] = Object.fromEntries(entries.map(([name, command]) => {
+					return name === scriptName ? [name, d.fix ?? command] : [name, command];
+				}));
+			}
+			await writeFile(packageFilePath, `${JSON.stringify(package_, void 0, 2)}\n`, "utf8");
+			fixed++;
+			packages.add(d.packagePath);
+		} catch {
+			errors++;
+		}
+	}
+	return {
+		errors,
+		fixed,
+		isDryRun,
+		packageCount: packages.size
+	};
+}
+async function check(options) {
+	const cwd = process.cwd();
+	let config;
+	try {
+		config = await loadConfig(cwd);
+	} catch {
+		throw new Error("No moniq.config file found in or above the current directory.");
+	}
+	const packages = discoverWorkspace(cwd);
+	if (packages.length === 0) throw new Error("No workspace packages found.");
+	const diagnostics = await resolve(config, cwd, packages);
+	let fixSummary;
+	if (options.fix) fixSummary = await applyScriptFixes(diagnostics, { isDryRun: options.isDryRun });
+	if (options.format !== "json") {
+		console.log(`  🔍 Scanned ${String(packages.length)} package(s)`);
+		console.log();
+	}
+	console.log(formatDiagnostics(diagnostics, {
+		format: options.format,
+		isDryRun: options.isDryRun
+	}));
+	if (fixSummary) if (fixSummary.isDryRun) {
+		const message = `🔮 Dry-run: ${String(fixSummary.fixed)} fix(es) available, ${String(fixSummary.errors)} error(s)`;
+		console.log(styleText("dim", message));
+	} else {
+		const message = `✅ Fixed ${String(fixSummary.fixed)} issue(s) across ${String(fixSummary.packageCount)} package(s)`;
+		console.log(styleText(["bold", "green"], message));
+	}
+}
+async function doctor() {
+	const cwd = process.cwd();
+	const issues = [];
+	try {
+		const config = await loadConfig(cwd);
+		issues.push({
+			message: "moniq.config file found and loadable.",
+			severity: "warn"
+		});
+		checkScriptPolicies(config, issues);
+	} catch {
+		issues.push({
+			message: "No moniq.config file found in or above the current directory.",
+			severity: "error"
+		});
+	}
+	try {
+		const packageCount = discoverWorkspace(cwd).length;
+		if (packageCount === 0) issues.push({
+			message: "No workspace packages detected. Check your workspace configuration.",
+			severity: "warn"
+		});
+		else issues.push({
+			message: `Detected ${String(packageCount)} workspace package(s).`,
+			severity: "warn"
+		});
+	} catch {
+		issues.push({
+			message: "Failed to discover workspace packages. Ensure a lock file or packageManager field is present.",
+			severity: "error"
+		});
+	}
+	console.log();
+	console.log(`  ${styleText("bold", "🏥 Configuration Doctor")}`);
+	console.log();
+	if (issues.length === 0) {
+		console.log(`  ${styleText(["bold", "green"], "✅ Everything looks good!")}`);
+		return;
+	}
+	for (const issue of issues) {
+		const icon = issue.severity === "error" ? "❌" : "⚠️ ";
+		const label = issue.severity === "error" ? styleText(["bold", "red"], "ERROR") : styleText(["bold", "yellow"], "WARN");
+		console.log(`  ${icon} ${label} ${issue.message}`);
+	}
+	const errorCount = issues.filter((index) => index.severity === "error").length;
+	const warningCount = issues.filter((index) => index.severity === "warn").length;
+	const summary = styleText("dim", `Found ${`${String(errorCount)} error(s)`}, ${`${String(warningCount)} warning(s)`}`);
+	console.log();
+	console.log(`  ${summary}`);
+	if (errorCount > 0) {
+		const tip = styleText(["bold", "cyan"], "💡 Tip:");
+		const hint = styleText("dim", "moniq init");
+		console.log();
+		console.log(`  ${tip} Run ${hint} to scaffold a starter configuration.`);
+	}
+}
+function checkScriptPolicies(config, issues) {
+	const scripts = config.scripts;
+	if (!scripts) return;
+	for (const [name, policyOrArray] of Object.entries(scripts)) {
+		const policies = Array.isArray(policyOrArray) ? policyOrArray : [policyOrArray];
+		for (const policy of policies) {
+			const sev = policy.severity;
+			if (sev !== void 0 && ![
+				"error",
+				"off",
+				"warn"
+			].includes(sev)) issues.push({
+				message: `Script policy "${name}" has invalid severity "${sev}".`,
+				severity: "error"
+			});
+		}
+	}
+}
+const colorFns = [
+	(s) => styleText("cyan", s),
+	(s) => styleText("magenta", s),
+	(s) => styleText("green", s),
+	(s) => styleText("yellow", s),
+	(s) => styleText("blue", s)
+];
+const letterRows = [
+	[
+		"███╗   ███╗",
+		"████╗ ████║",
+		"██╔████╔██║",
+		"██║╚██╔╝██║",
+		"██║ ╚═╝ ██║",
+		"╚═╝     ╚═╝"
+	],
+	[
+		" ██████╗ ",
+		"██╔═══██╗",
+		"██║   ██║",
+		"██║   ██║",
+		"╚██████╔╝",
+		" ╚═════╝ "
+	],
+	[
+		"███╗   ██╗",
+		"████╗  ██║",
+		"██╔██╗ ██║",
+		"██║╚██╗██║",
+		"██║ ╚████║",
+		"╚═╝  ╚═══╝"
+	],
+	[
+		"██╗",
+		"██║",
+		"██║",
+		"██║",
+		"██║",
+		"╚═╝"
+	],
+	[
+		" ██████╗ ",
+		"██╔═══██╗",
+		"██║   ██║",
+		"██║   ██║",
+		"╚██████╔╝",
+		" ╚════╝╗ "
+	]
+];
+const DESCRIPTION = "Policy-driven workspace linter for JavaScript/TypeScript monorepos.";
+function renderBanner() {
+	const lines = [];
+	for (let rowIndex = 0; rowIndex < 6; rowIndex++) lines.push(assembleRow(rowIndex));
+	const description = centerPad(DESCRIPTION, 62);
+	lines.push("", description);
+	return lines.join("\n");
+}
+function assembleRow(rowIndex) {
+	let row = " ".repeat(6);
+	for (let columnIndex = 0; columnIndex < 5; columnIndex++) {
+		row += rowPart(columnIndex, rowIndex);
+		if (columnIndex < 4) row += "  ";
+	}
+	return row;
+}
+function centerPad(text, width) {
+	const pad = Math.max(0, Math.floor((width - text.length) / 2));
+	return " ".repeat(pad) + text;
+}
+function rowPart(columnIndex, rowIndex) {
+	const rows = letterRows.at(columnIndex);
+	const colorFunction = colorFns.at(columnIndex);
+	if (rows === void 0 || colorFunction === void 0) return "";
+	const line = rows.at(rowIndex);
+	return line === void 0 ? "" : colorFunction(line);
+}
+const SUPPORTED_LANGS = [
+	"ts",
+	"js",
+	"mjs",
+	"cjs",
+	"mts",
+	"cts"
+];
+const STARTER_CONFIG = `import { defineConfig } from "@udohjeremiah/moniq";
+
+export default defineConfig({
+  scripts: {
+    dev: { required: true },
+    build: { required: true },
+    lint: { required: true },
+  },
+});
+`;
+async function init(options) {
+	const { lang } = options;
+	if (!SUPPORTED_LANGS.includes(lang)) {
+		const unsupportedMessage = `Unsupported --lang "${lang}". Supported: ${SUPPORTED_LANGS.join(", ")}`;
+		console.error(`  ${styleText("yellow", unsupportedMessage)}`);
+		process.exitCode = 1;
+		return;
+	}
+	const cwd = process.cwd();
+	const filename = `moniq.config.${lang}`;
+	const targetPath = path.join(cwd, filename);
+	try {
+		await access(targetPath);
+		const existsMessage = `⚠️  ${filename} already exists. Remove it first to reinitialize.`;
+		console.log(`  ${styleText("yellow", existsMessage)}`);
+		return;
+	} catch {}
+	const { writeFile } = await import("node:fs/promises");
+	await writeFile(targetPath, STARTER_CONFIG, "utf8");
+	console.log(renderBanner());
+	console.log();
+	const created = `✅ Created ${filename}`;
+	console.log(`  ${styleText(["bold", "green"], created)}`);
+	console.log();
+	console.log(`  ${styleText("dim", "Next steps:")}`);
+	console.log(`   1. ${styleText("dim", "Edit")} ${styleText("cyan", filename)} ${styleText("dim", "to configure your script policies.")}`);
+	console.log(`   2. ${styleText("dim", "Run")} ${styleText("cyan", "moniq doctor")} ${styleText("dim", "to verify your configuration.")}`);
+	console.log(`   3. ${styleText("dim", "Run")} ${styleText("cyan", "moniq check")} ${styleText("dim", "to validate your workspace.")}`);
+	console.log(`   4. ${styleText("dim", "Run")} ${styleText("cyan", "moniq fix")} ${styleText("dim", "to apply automatic fixes.")}`);
+	console.log();
+}
+const cli = cac("moniq");
+cli.command("check", "Run policy checks").option("--format <fmt>", "Output format: pretty or json", { default: "pretty" }).action(async (options) => {
+	const fmt = typeof options["format"] === "string" ? options["format"] : "pretty";
+	try {
+		await check({
+			fix: false,
+			format: fmt
+		});
+	} catch (error) {
+		console.error(String(error));
+		process.exitCode = 1;
+	}
+});
+cli.command("fix", "Run policy checks and apply autofixes").option("--dry-run", "Preview autofixes without writing to files").option("--format <fmt>", "Output format: pretty or json", { default: "pretty" }).action(async (options) => {
+	const isDryRun = options["dryRun"] === true;
+	const fmt = typeof options["format"] === "string" ? options["format"] : "pretty";
+	try {
+		await check({
+			fix: true,
+			format: fmt,
+			isDryRun
+		});
+	} catch (error) {
+		console.error(String(error));
+		process.exitCode = 1;
+	}
+});
+cli.command("doctor", "Detect configuration mistakes").action(async () => {
+	await doctor();
+});
+cli.command("init", "Scaffold a moniq.config file in the current directory").option("--lang <type>", "Config language: ts, js, mjs, cjs, mts, cts (default: ts)").action(async (options) => {
+	await init({ lang: typeof options["lang"] === "string" ? options["lang"] : "ts" });
+});
+cli.help();
+cli.parse();
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.js.map