@theholocron/cli 5.0.0-alpha.126 → 5.0.0-alpha.128

package/README.md

@@ -66,6 +66,21 @@ use `pnpm exec holocron <cmd>`. `auth check` degrades to "token present,
 verification skipped" instead. `holocron --help` prints the grouping; see
 [Execution Contexts](https://theholocron.github.io/holocron/execution-contexts).
 
+### Viewing the resolved config
+
+`holocron config show` prints the resolved config. On a TTY it opens a foldable
+tree by default; piped or redirected, it always emits plain, valid JSON
+(`holocron config show | jq`).
+
+```console
+holocron config show                  # TTY: foldable tree (↑↓ move, →/⏎ expand, ← collapse, E/C all, q quit)
+holocron config show --depth 2        # static coloured tree, anything nested deeper than 2 levels collapsed
+holocron config show --no-interactive # static coloured tree, fully expanded
+```
+
+Passing `--interactive` explicitly needs a TTY on stdin and stdout and fails
+with a one-line message otherwise; the default falls back to static output. It has no extra dependencies — nothing to install.
+
 ## Config file
 
 Holocron reads `holocron.config.{json,js,ts}` from the project root

package/dist/cli.mjs

@@ -8599,6 +8599,225 @@ async function launchMenu(entries, parentArgv, pickMessage, nonInteractiveMessag
 	process.exitCode = await spawnChild(buildChildArgv(picked, positionals, parentArgv));
 }
 //#endregion
+//#region src/ui/json-view.ts
+function isContainer(value) {
+	return typeof value === "object" && value !== null;
+}
+function childrenOf(value) {
+	return Array.isArray(value) ? value.map((v, i) => [String(i), v]) : Object.entries(value);
+}
+function scalar(value) {
+	if (typeof value === "string") return chalk.green(JSON.stringify(value));
+	if (typeof value === "number") return chalk.yellow(String(value));
+	if (typeof value === "boolean") return chalk.magenta(String(value));
+	return chalk.dim(String(value === void 0 ? null : value));
+}
+function summary(value) {
+	const n = childrenOf(value).length;
+	const unit = Array.isArray(value) ? n === 1 ? "item" : "items" : n === 1 ? "key" : "keys";
+	return chalk.dim(Array.isArray(value) ? `[… ${n} ${unit}]` : `{… ${n} ${unit}}`);
+}
+/**
+* Paths of every container deeper than `depth` levels are left out, so those
+* render collapsed. `depth: 0` collapses the root; `Infinity` expands all.
+*/
+function expandToDepth(value, depth) {
+	const out = /* @__PURE__ */ new Set();
+	const walk = (v, path, level) => {
+		if (!isContainer(v) || level >= depth) return;
+		out.add(path);
+		for (const [k, child] of childrenOf(v)) walk(child, `${path}/${k}`, level + 1);
+	};
+	walk(value, "", 0);
+	return out;
+}
+/** Flatten `value` into the lines visible under `expanded`. Pure — no I/O. */
+function renderTree(value, { expanded }) {
+	const lines = [];
+	const walk = (v, path, level, label, trailing) => {
+		const indent = "  ".repeat(level);
+		const prefix = `${indent}${label}`;
+		if (!isContainer(v)) {
+			lines.push({
+				path,
+				text: `${prefix}${scalar(v)}${trailing}`,
+				foldable: false,
+				expanded: false,
+				level
+			});
+			return;
+		}
+		const kids = childrenOf(v);
+		const [open, close] = Array.isArray(v) ? ["[", "]"] : ["{", "}"];
+		if (kids.length === 0) {
+			lines.push({
+				path,
+				text: `${prefix}${open}${close}${trailing}`,
+				foldable: false,
+				expanded: false,
+				level
+			});
+			return;
+		}
+		if (!expanded.has(path)) {
+			lines.push({
+				path,
+				text: `${prefix}${summary(v)}${trailing}`,
+				foldable: true,
+				expanded: false,
+				level
+			});
+			return;
+		}
+		lines.push({
+			path,
+			text: `${prefix}${open}`,
+			foldable: true,
+			expanded: true,
+			level
+		});
+		kids.forEach(([k, child], i) => {
+			const comma = i < kids.length - 1 ? "," : "";
+			const childLabel = Array.isArray(v) ? "" : `${chalk.cyan(JSON.stringify(k))}: `;
+			walk(child, `${path}/${k}`, level + 1, childLabel, comma);
+		});
+		lines.push({
+			path: `${path}#close`,
+			text: `${indent}${close}${trailing}`,
+			foldable: false,
+			expanded: false,
+			level
+		});
+	};
+	walk(value, "", 0, "", "");
+	return lines;
+}
+/** Pure key reducer: `(state, key) -> state`. `rows` is the viewport height. */
+function reduceKey(state, key, value, rows) {
+	const lines = renderTree(value, { expanded: state.expanded });
+	const cur = lines[state.cursor];
+	let { cursor } = state;
+	const expanded = new Set(state.expanded);
+	switch (key) {
+		case "up":
+			cursor = Math.max(0, cursor - 1);
+			break;
+		case "down":
+			cursor = Math.min(lines.length - 1, cursor + 1);
+			break;
+		case "right":
+			if (cur?.foldable) expanded.add(cur.path);
+			break;
+		case "left":
+			if (cur?.foldable && cur.expanded) expanded.delete(cur.path);
+			else if (cur) {
+				const parent = lines.findLastIndex((l, i) => i < cursor && l.foldable && l.expanded && l.level < cur.level);
+				if (parent >= 0) cursor = parent;
+			}
+			break;
+		case "expandAll": return {
+			cursor,
+			top: state.top,
+			expanded: expandToDepth(value, Infinity)
+		};
+		case "collapseAll": return {
+			cursor: 0,
+			top: 0,
+			expanded: /* @__PURE__ */ new Set()
+		};
+	}
+	const count = renderTree(value, { expanded }).length;
+	cursor = Math.min(cursor, count - 1);
+	let top = state.top;
+	if (cursor < top) top = cursor;
+	if (cursor >= top + rows) top = cursor - rows + 1;
+	return {
+		cursor,
+		top: Math.max(0, top),
+		expanded
+	};
+}
+const KEYMAP = {
+	"\x1B[A": "up",
+	k: "up",
+	"\x1B[B": "down",
+	j: "down",
+	"\x1B[C": "right",
+	l: "right",
+	"\r": "right",
+	" ": "right",
+	"\x1B[D": "left",
+	h: "left",
+	E: "expandAll",
+	C: "collapseAll",
+	q: "quit",
+	"\x1B": "quit",
+	"": "quit"
+};
+function draw(out, value, state, rows) {
+	const lines = renderTree(value, { expanded: state.expanded });
+	const view = lines.slice(state.top, state.top + rows).map((l, i) => {
+		const row = `${l.foldable ? l.expanded ? "▾ " : "▸ " : "  "}${l.text}`;
+		return state.top + i === state.cursor ? chalk.inverse(row) : row;
+	});
+	const footer = chalk.dim(`${state.cursor + 1}/${lines.length}  ↑↓ move  →/⏎ expand  ← collapse  E/C all  q quit`);
+	out.write(`\u001b[H\u001b[J${view.join("\n")}\n${footer}`);
+}
+async function runInteractive(value, depth) {
+	const { stdin, stdout } = process;
+	if (!stdin.isTTY || !stdout.isTTY) throw new NonInteractiveError("--interactive needs a TTY on stdin and stdout.");
+	const rows = () => Math.max(3, (stdout.rows ?? 24) - 1);
+	let state = {
+		cursor: 0,
+		top: 0,
+		expanded: expandToDepth(value, depth)
+	};
+	const wasRaw = stdin.isRaw;
+	stdin.setRawMode(true);
+	stdin.resume();
+	stdout.write("\x1B[?1049h\x1B[?25l");
+	const redraw = () => draw(stdout, value, state, rows());
+	stdout.on("resize", redraw);
+	try {
+		redraw();
+		await new Promise((resolve) => {
+			const onData = (buf) => {
+				const key = KEYMAP[buf.toString()];
+				if (key === "quit") {
+					stdin.off("data", onData);
+					resolve();
+					return;
+				}
+				if (key) {
+					state = reduceKey(state, key, value, rows());
+					redraw();
+				}
+			};
+			stdin.on("data", onData);
+		});
+	} finally {
+		stdout.off("resize", redraw);
+		stdout.write("\x1B[?25h\x1B[?1049l");
+		stdin.setRawMode(wasRaw);
+		stdin.pause();
+	}
+}
+/**
+* Print `value` as JSON. Non-TTY stdout always gets plain, valid
+* `JSON.stringify` output (so `| jq` and redirects keep working); a TTY gets a
+* coloured tree, collapsed past `depth`. `interactive` opens a folding viewer (the default on a TTY).
+*/
+async function viewJson(value, options = {}) {
+	const depth = options.depth ?? Infinity;
+	if (options.interactive ?? (options.depth === void 0 && Boolean(process.stdin.isTTY && process.stdout.isTTY))) return runInteractive(value, options.depth ?? 1);
+	if (!process.stdout.isTTY) {
+		console.log(JSON.stringify(value, null, 2));
+		return;
+	}
+	const lines = renderTree(value, { expanded: expandToDepth(value, depth) });
+	console.log(lines.map((l) => l.text).join("\n"));
+}
+//#endregion
 //#region src/ui/open-path.ts
 /** Platform-appropriate command to open a path in the OS's file browser. */
 function openCommand(path) {
@@ -9373,9 +9592,17 @@ try {
 			if (report.message) reportError(`sync-readme: ${report.message}`);
 			process.exitCode = 1;
 		}
-	}).command("config show", "Print the resolved holocron config", () => {}, async (argv) => {
-		const loaded = await loadConfig(argv.cwd);
-		console.log(JSON.stringify(loaded.resolved, null, 2));
+	}).command("config show", "Print the resolved holocron config", (y) => y.option("depth", {
+		type: "number",
+		describe: "Collapse objects/arrays nested deeper than N levels (TTY output only)"
+	}).option("interactive", {
+		type: "boolean",
+		describe: "Browse the config in a foldable tree (default on a TTY; --no-interactive for static output)"
+	}), async (argv) => {
+		await viewJson((await loadConfig(argv.cwd)).resolved, {
+			depth: argv.depth,
+			interactive: argv.interactive
+		});
 	}).command("new [type] [name]", "Scaffold a new repo from a GitHub template (e.g. cli, react, nextjs, node, monorepo, base)", (y) => y.positional("type", {
 		type: "string",
 		describe: "Template type — maps to theholocron/<type>-template (e.g. cli, react, nextjs, node, monorepo, base)"