maxsimcli 1.0.10 → 1.0.11

package/dist/cli.cjs

@@ -6,7 +6,21 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") {
 		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
@@ -25,12 +39,19 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 //#endregion
 let node_fs = require("node:fs");
 node_fs = __toESM(node_fs);
 let node_path = require("node:path");
 node_path = __toESM(node_path);
+let node_os = require("node:os");
+node_os = __toESM(node_os);
+let node_process = require("node:process");
+node_process = __toESM(node_process);
+let node_tty = require("node:tty");
+node_tty = __toESM(node_tty);
 
 //#region ../core/dist/types.js
 var require_types = /* @__PURE__ */ __commonJSMin(((exports) => {
@@ -1806,6 +1827,445 @@ var require_milestone = /* @__PURE__ */ __commonJSMin(((exports) => {
 	}
 }));
 
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+function assembleStyles() {
+	const codes = /* @__PURE__ */ new Map();
+	for (const [groupName, group] of Object.entries(styles$1)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles$1[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`
+			};
+			group[styleName] = styles$1[styleName];
+			codes.set(style[0], style[1]);
+		}
+		Object.defineProperty(styles$1, groupName, {
+			value: group,
+			enumerable: false
+		});
+	}
+	Object.defineProperty(styles$1, "codes", {
+		value: codes,
+		enumerable: false
+	});
+	styles$1.color.close = "\x1B[39m";
+	styles$1.bgColor.close = "\x1B[49m";
+	styles$1.color.ansi = wrapAnsi16();
+	styles$1.color.ansi256 = wrapAnsi256();
+	styles$1.color.ansi16m = wrapAnsi16m();
+	styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+	Object.defineProperties(styles$1, {
+		rgbToAnsi256: {
+			value(red, green, blue) {
+				if (red === green && green === blue) {
+					if (red < 8) return 16;
+					if (red > 248) return 231;
+					return Math.round((red - 8) / 247 * 24) + 232;
+				}
+				return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+			},
+			enumerable: false
+		},
+		hexToRgb: {
+			value(hex) {
+				const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+				if (!matches) return [
+					0,
+					0,
+					0
+				];
+				let [colorString] = matches;
+				if (colorString.length === 3) colorString = [...colorString].map((character) => character + character).join("");
+				const integer = Number.parseInt(colorString, 16);
+				return [
+					integer >> 16 & 255,
+					integer >> 8 & 255,
+					integer & 255
+				];
+			},
+			enumerable: false
+		},
+		hexToAnsi256: {
+			value: (hex) => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
+			enumerable: false
+		},
+		ansi256ToAnsi: {
+			value(code) {
+				if (code < 8) return 30 + code;
+				if (code < 16) return 90 + (code - 8);
+				let red;
+				let green;
+				let blue;
+				if (code >= 232) {
+					red = ((code - 232) * 10 + 8) / 255;
+					green = red;
+					blue = red;
+				} else {
+					code -= 16;
+					const remainder = code % 36;
+					red = Math.floor(code / 36) / 5;
+					green = Math.floor(remainder / 6) / 5;
+					blue = remainder % 6 / 5;
+				}
+				const value = Math.max(red, green, blue) * 2;
+				if (value === 0) return 30;
+				let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+				if (value === 2) result += 60;
+				return result;
+			},
+			enumerable: false
+		},
+		rgbToAnsi: {
+			value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
+			enumerable: false
+		},
+		hexToAnsi: {
+			value: (hex) => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
+			enumerable: false
+		}
+	});
+	return styles$1;
+}
+var ANSI_BACKGROUND_OFFSET, wrapAnsi16, wrapAnsi256, wrapAnsi16m, styles$1, modifierNames, foregroundColorNames, backgroundColorNames, colorNames, ansiStyles;
+var init_ansi_styles = __esmMin((() => {
+	ANSI_BACKGROUND_OFFSET = 10;
+	wrapAnsi16 = (offset = 0) => (code) => `\u001B[${code + offset}m`;
+	wrapAnsi256 = (offset = 0) => (code) => `\u001B[${38 + offset};5;${code}m`;
+	wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+	styles$1 = {
+		modifier: {
+			reset: [0, 0],
+			bold: [1, 22],
+			dim: [2, 22],
+			italic: [3, 23],
+			underline: [4, 24],
+			overline: [53, 55],
+			inverse: [7, 27],
+			hidden: [8, 28],
+			strikethrough: [9, 29]
+		},
+		color: {
+			black: [30, 39],
+			red: [31, 39],
+			green: [32, 39],
+			yellow: [33, 39],
+			blue: [34, 39],
+			magenta: [35, 39],
+			cyan: [36, 39],
+			white: [37, 39],
+			blackBright: [90, 39],
+			gray: [90, 39],
+			grey: [90, 39],
+			redBright: [91, 39],
+			greenBright: [92, 39],
+			yellowBright: [93, 39],
+			blueBright: [94, 39],
+			magentaBright: [95, 39],
+			cyanBright: [96, 39],
+			whiteBright: [97, 39]
+		},
+		bgColor: {
+			bgBlack: [40, 49],
+			bgRed: [41, 49],
+			bgGreen: [42, 49],
+			bgYellow: [43, 49],
+			bgBlue: [44, 49],
+			bgMagenta: [45, 49],
+			bgCyan: [46, 49],
+			bgWhite: [47, 49],
+			bgBlackBright: [100, 49],
+			bgGray: [100, 49],
+			bgGrey: [100, 49],
+			bgRedBright: [101, 49],
+			bgGreenBright: [102, 49],
+			bgYellowBright: [103, 49],
+			bgBlueBright: [104, 49],
+			bgMagentaBright: [105, 49],
+			bgCyanBright: [106, 49],
+			bgWhiteBright: [107, 49]
+		}
+	};
+	modifierNames = Object.keys(styles$1.modifier);
+	foregroundColorNames = Object.keys(styles$1.color);
+	backgroundColorNames = Object.keys(styles$1.bgColor);
+	colorNames = [...foregroundColorNames, ...backgroundColorNames];
+	ansiStyles = assembleStyles();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : node_process.default.argv) {
+	const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf("--");
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+function envForceColor() {
+	if ("FORCE_COLOR" in env) {
+		if (env.FORCE_COLOR === "true") return 1;
+		if (env.FORCE_COLOR === "false") return 0;
+		return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+	}
+}
+function translateLevel(level) {
+	if (level === 0) return false;
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+	const noFlagForceColor = envForceColor();
+	if (noFlagForceColor !== void 0) flagForceColor = noFlagForceColor;
+	const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+	if (forceColor === 0) return 0;
+	if (sniffFlags) {
+		if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
+		if (hasFlag("color=256")) return 2;
+	}
+	if ("TF_BUILD" in env && "AGENT_NAME" in env) return 1;
+	if (haveStream && !streamIsTTY && forceColor === void 0) return 0;
+	const min = forceColor || 0;
+	if (env.TERM === "dumb") return min;
+	if (node_process.default.platform === "win32") {
+		const osRelease = node_os.default.release().split(".");
+		if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+		return 1;
+	}
+	if ("CI" in env) {
+		if ([
+			"GITHUB_ACTIONS",
+			"GITEA_ACTIONS",
+			"CIRCLECI"
+		].some((key) => key in env)) return 3;
+		if ([
+			"TRAVIS",
+			"APPVEYOR",
+			"GITLAB_CI",
+			"BUILDKITE",
+			"DRONE"
+		].some((sign) => sign in env) || env.CI_NAME === "codeship") return 1;
+		return min;
+	}
+	if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+	if (env.COLORTERM === "truecolor") return 3;
+	if (env.TERM === "xterm-kitty") return 3;
+	if (env.TERM === "xterm-ghostty") return 3;
+	if (env.TERM === "wezterm") return 3;
+	if ("TERM_PROGRAM" in env) {
+		const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+		switch (env.TERM_PROGRAM) {
+			case "iTerm.app": return version >= 3 ? 3 : 2;
+			case "Apple_Terminal": return 2;
+		}
+	}
+	if (/-256(color)?$/i.test(env.TERM)) return 2;
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+	if ("COLORTERM" in env) return 1;
+	return min;
+}
+function createSupportsColor(stream, options = {}) {
+	return translateLevel(_supportsColor(stream, {
+		streamIsTTY: stream && stream.isTTY,
+		...options
+	}));
+}
+var env, flagForceColor, supportsColor;
+var init_supports_color = __esmMin((() => {
+	({env} = node_process.default);
+	;
+	if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
+	else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
+	supportsColor = {
+		stdout: createSupportsColor({ isTTY: node_tty.default.isatty(1) }),
+		stderr: createSupportsColor({ isTTY: node_tty.default.isatty(2) })
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+	let index = string.indexOf(substring);
+	if (index === -1) return string;
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		returnValue += string.slice(endIndex, index) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		const gotCR = string[index - 1] === "\r";
+		returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+		endIndex = index + 1;
+		index = string.indexOf("\n", endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+var init_utilities = __esmMin((() => {}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+var source_exports = /* @__PURE__ */ __exportAll({
+	Chalk: () => Chalk,
+	backgroundColorNames: () => backgroundColorNames,
+	backgroundColors: () => backgroundColorNames,
+	chalkStderr: () => chalkStderr,
+	colorNames: () => colorNames,
+	colors: () => colorNames,
+	default: () => chalk,
+	foregroundColorNames: () => foregroundColorNames,
+	foregroundColors: () => foregroundColorNames,
+	modifierNames: () => modifierNames,
+	modifiers: () => modifierNames,
+	supportsColor: () => stdoutColor,
+	supportsColorStderr: () => stderrColor
+});
+function createChalk(options) {
+	return chalkFactory(options);
+}
+var stdoutColor, stderrColor, GENERATOR, STYLER, IS_EMPTY, levelMapping, styles, applyOptions, Chalk, chalkFactory, getModelAnsi, proto, createStyler, createBuilder, applyStyle, chalk, chalkStderr;
+var init_source = __esmMin((() => {
+	init_ansi_styles();
+	init_supports_color();
+	init_utilities();
+	({stdout: stdoutColor, stderr: stderrColor} = supportsColor);
+	GENERATOR = Symbol("GENERATOR");
+	STYLER = Symbol("STYLER");
+	IS_EMPTY = Symbol("IS_EMPTY");
+	levelMapping = [
+		"ansi",
+		"ansi",
+		"ansi256",
+		"ansi16m"
+	];
+	styles = Object.create(null);
+	applyOptions = (object, options = {}) => {
+		if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) throw new Error("The `level` option should be an integer from 0 to 3");
+		const colorLevel = stdoutColor ? stdoutColor.level : 0;
+		object.level = options.level === void 0 ? colorLevel : options.level;
+	};
+	Chalk = class {
+		constructor(options) {
+			return chalkFactory(options);
+		}
+	};
+	chalkFactory = (options) => {
+		const chalk = (...strings) => strings.join(" ");
+		applyOptions(chalk, options);
+		Object.setPrototypeOf(chalk, createChalk.prototype);
+		return chalk;
+	};
+	Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+	for (const [styleName, style] of Object.entries(ansiStyles)) styles[styleName] = { get() {
+		const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+		Object.defineProperty(this, styleName, { value: builder });
+		return builder;
+	} };
+	styles.visible = { get() {
+		const builder = createBuilder(this, this[STYLER], true);
+		Object.defineProperty(this, "visible", { value: builder });
+		return builder;
+	} };
+	getModelAnsi = (model, level, type, ...arguments_) => {
+		if (model === "rgb") {
+			if (level === "ansi16m") return ansiStyles[type].ansi16m(...arguments_);
+			if (level === "ansi256") return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
+			return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
+		}
+		if (model === "hex") return getModelAnsi("rgb", level, type, ...ansiStyles.hexToRgb(...arguments_));
+		return ansiStyles[type][model](...arguments_);
+	};
+	for (const model of [
+		"rgb",
+		"hex",
+		"ansi256"
+	]) {
+		styles[model] = { get() {
+			const { level } = this;
+			return function(...arguments_) {
+				const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansiStyles.color.close, this[STYLER]);
+				return createBuilder(this, styler, this[IS_EMPTY]);
+			};
+		} };
+		const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+		styles[bgModel] = { get() {
+			const { level } = this;
+			return function(...arguments_) {
+				const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
+				return createBuilder(this, styler, this[IS_EMPTY]);
+			};
+		} };
+	}
+	proto = Object.defineProperties(() => {}, {
+		...styles,
+		level: {
+			enumerable: true,
+			get() {
+				return this[GENERATOR].level;
+			},
+			set(level) {
+				this[GENERATOR].level = level;
+			}
+		}
+	});
+	createStyler = (open, close, parent) => {
+		let openAll;
+		let closeAll;
+		if (parent === void 0) {
+			openAll = open;
+			closeAll = close;
+		} else {
+			openAll = parent.openAll + open;
+			closeAll = close + parent.closeAll;
+		}
+		return {
+			open,
+			close,
+			openAll,
+			closeAll,
+			parent
+		};
+	};
+	createBuilder = (self, _styler, _isEmpty) => {
+		const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+		Object.setPrototypeOf(builder, proto);
+		builder[GENERATOR] = self;
+		builder[STYLER] = _styler;
+		builder[IS_EMPTY] = _isEmpty;
+		return builder;
+	};
+	applyStyle = (self, string) => {
+		if (self.level <= 0 || !string) return self[IS_EMPTY] ? "" : string;
+		let styler = self[STYLER];
+		if (styler === void 0) return string;
+		const { openAll, closeAll } = styler;
+		if (string.includes("\x1B")) while (styler !== void 0) {
+			string = stringReplaceAll(string, styler.close, styler.open);
+			styler = styler.parent;
+		}
+		const lfIndex = string.indexOf("\n");
+		if (lfIndex !== -1) string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+		return openAll + string + closeAll;
+	};
+	Object.defineProperties(createChalk.prototype, styles);
+	chalk = createChalk();
+	chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+}));
+
 //#endregion
 //#region ../core/dist/commands.js
 var require_commands = /* @__PURE__ */ __commonJSMin(((exports) => {
@@ -1832,6 +2292,7 @@ var require_commands = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.cmdScaffold = cmdScaffold;
 	const node_fs_1$4 = __importDefault(require("node:fs"));
 	const node_path_1$4 = __importDefault(require("node:path"));
+	const chalk_1 = __importDefault((init_source(), __toCommonJS(source_exports)));
 	const core_js_1 = require_core();
 	const frontmatter_js_1 = require_frontmatter();
 	function cmdGenerateSlug(text, raw) {
@@ -2221,6 +2682,32 @@ var require_commands = /* @__PURE__ */ __commonJSMin(((exports) => {
 				completed: totalSummaries,
 				total: totalPlans
 			}, raw, text);
+		} else if (format === "phase-bars") {
+			const doneCount = phases.filter((p) => p.status === "Complete").length;
+			const inProgressCount = phases.filter((p) => p.status === "In Progress").length;
+			const totalCount = phases.length;
+			const lines = [chalk_1.default.bold(`Milestone: ${milestone.name} — ${doneCount}/${totalCount} phases complete (${percent}%)`), ""];
+			for (const p of phases) {
+				const pPercent = p.plans > 0 ? Math.min(100, Math.round(p.summaries / p.plans * 100)) : 0;
+				const barWidth = 10;
+				const filled = Math.round(pPercent / 100 * barWidth);
+				const bar = "█".repeat(filled) + "░".repeat(barWidth - filled);
+				const phaseLabel = `Phase ${p.number.padStart(2, "0")}`;
+				const statusLabel = p.status === "Complete" ? "DONE" : p.status === "In Progress" ? "IN PROGRESS" : "PLANNED";
+				let line = `${phaseLabel} [${bar}] ${String(pPercent).padStart(3, " ")}% — ${statusLabel}`;
+				if (p.status === "Complete") line = chalk_1.default.green(line);
+				else if (p.status === "In Progress") line = chalk_1.default.yellow(line);
+				else line = chalk_1.default.dim(line);
+				lines.push(line);
+			}
+			const rendered = lines.join("\n");
+			(0, core_js_1.output)({
+				rendered,
+				done: doneCount,
+				in_progress: inProgressCount,
+				total: totalCount,
+				percent
+			}, raw, rendered);
 		} else (0, core_js_1.output)({
 			milestone_version: milestone.version,
 			milestone_name: milestone.name,