@theholocron/kyber 0.0.0-stage → 5.0.0-alpha.338

package/dist/ui.d.mts

@@ -0,0 +1,151 @@
+/** A JSON-pointer-ish path: `""` is the root, children append `/<key>`. */
+type Path = string;
+/** One rendered line of the viewer. */
+interface Line {
+  /** Where this line's value sits in the document. */
+  path: Path;
+  /** The line as drawn, indent included. */
+  text: string;
+  /** Object/array with at least one child — the only lines that fold. */
+  foldable: boolean;
+  /** Whether this line's children are shown. */
+  expanded: boolean;
+  /** Number of leading indent levels, so the TTY layer can jump to a parent. */
+  level: number;
+}
+/** What {@link renderTree} needs to draw the document. */
+interface RenderOptions {
+  /** Paths currently expanded. */
+  expanded: ReadonlySet<Path>;
+}
+/** A value that can have children: an object or an array. */
+type Container = Record<string, unknown> | unknown[];
+/** How {@link viewJson} shows a document. */
+interface ViewJsonOptions {
+  /** Collapse containers deeper than this many levels (static mode and the interactive start state). */
+  depth?: number;
+  /**
+   * `true` forces the folding viewer (throws without a TTY), `false` forces
+   * static output. Left unset it auto-enables when stdin and stdout are both
+   * TTYs and no `depth` was asked for (an explicit depth means static output).
+   */
+  interactive?: boolean;
+}
+/** Where the interactive viewer is: the selected line, the first visible line and the open containers. */
+interface ViewState {
+  /** The index of the selected line. */
+  cursor: number;
+  /** The index of the first line on screen. */
+  top: number;
+  /** The paths currently open. */
+  expanded: Set<Path>;
+}
+/** A key the interactive viewer reacts to, already mapped from the terminal's escape sequences. */
+type Key = "up" | "down" | "left" | "right" | "expandAll" | "collapseAll" | "quit";
+/**
+ * Paths of every container deeper than `depth` levels are left out, so those
+ * render collapsed. `depth: 0` collapses the root; `Infinity` expands all.
+ */
+export declare function expandToDepth(value: unknown, depth: number): Set<Path>;
+/** Flatten `value` into the lines visible under `expanded`. Pure — no I/O. */
+export declare function renderTree(value: unknown, { expanded }: RenderOptions): Line[];
+/** Pure key reducer: `(state, key) -> state`. `rows` is the viewport height. */
+export declare function reduceKey(state: ViewState, key: Key, value: unknown, rows: number): ViewState;
+/**
+ * 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).
+ */
+export declare function viewJson(value: unknown, options?: ViewJsonOptions): Promise<void>;
+/**
+ * Raised when a prompt is needed but stdin isn't a TTY. A non-TTY run (CI, a
+ * script, a pipe) throws this instead of hanging on `@inquirer/prompts`, which
+ * otherwise throws its own `ExitPromptError` the moment stdin closes. `cli.ts`'s
+ * `USER_FACING_ERRORS` catch prints the message cleanly.
+ */
+export declare class NonInteractiveError extends Error {
+  /** The error's name, `NonInteractiveError`, so a catch can tell it from any other error. */
+  name: string;
+}
+/**
+ * Open `path` in the OS's default file browser (Finder / Explorer /
+ * whatever `xdg-open` resolves to on Linux). Fire-and-forget — detached so
+ * it outlives this process, and never throws when the opener binary isn't
+ * on PATH (e.g. no `xdg-open` in a minimal container).
+ */
+export declare function openPath(path: string): void;
+/** A spinner for one step at a time, which the step can print through without breaking it. */
+interface Progress {
+  /** Run `fn` under a spinner named `label`. The spinner is cleared, not kept, so the step's own result line stands alone. */
+  run<T>(label: string, fn: () => Promise<T>): Promise<T>;
+  /** Print a line without breaking the spinner: it is cleared, the line printed, and the spinner drawn again. */
+  print(line: string): void;
+}
+/**
+ * Hooks something into a running step, such as a retry notice. It is given the step's label and a way to change the
+ * spinner's text, and returns the function that unhooks it, called when the step ends.
+ */
+type ProgressListener = (label: string, setText: (text: string) => void) => () => void;
+/**
+ * Runs `fn`, showing an ora spinner for its duration in TTY environments.
+ * In non-TTY environments (CI, pipes, tests) the spinner is skipped entirely.
+ */
+export declare function withSpinner<T>(label: string, fn: () => Promise<T>): Promise<T>;
+/** Turn progress off for the run (`--quiet`, `--log`), so nothing extra shares the terminal with what those print. */
+export declare function allowProgress(on: boolean): void;
+/**
+ * Whether to draw a progress line: only when a person is watching a terminal (stdout and stderr both), not in CI, and not
+ * switched off. Everywhere else the output stays the plain line-per-step text that scripts and the docs rely on.
+ */
+export declare function progressEnabled(): boolean;
+/**
+ * A spinner for one step at a time that a step can print through. Steps that only return a result use {@link
+ * withProgress}; a step that prints its own result line while it runs prints through `print`. A `listen` hook can change the
+ * spinner's text while the step runs, for instance to say that a request is being sent again.
+ */
+export declare function createProgress(print: (line: string) => void, enabled?: () => boolean, listen?: ProgressListener): Progress;
+/** `fn` under a cleared-when-done spinner named `label`, on a terminal only. */
+export declare function withProgress<T>(label: string, fn: () => Promise<T>, listen?: ProgressListener): Promise<T>;
+/** How a row of a check or setup run came out: it passed, it failed, or it was skipped. */
+type RowStatus = "ok" | "fail" | "skip";
+/** Right-pads `s` to `width` with spaces — never truncates. */
+export declare function pad(s: string, width: number): string;
+/**
+ * One row of a status report: a 2-space indent, the status icon (✓ / ✗ / ·),
+ * then `columns` joined with a two-space gap (blank columns dropped, so a
+ * row that has nothing for its last column doesn't trail whitespace).
+ * Column padding (`pad`) is the caller's job — `doctor` pads capability and
+ * provider to a fixed width; `clone`'s repo names and paths don't, since
+ * they vary too widely for fixed-width alignment to read cleanly.
+ *
+ * Shared by `doctor` (capability / provider / message) and `clone` (repo /
+ * destination / reason) so every status table in the CLI reads the same way.
+ */
+export declare function statusRow(status: RowStatus, columns: string[]): string;
+/** Formats a message with a status marker and colour: one helper per kind of line a command prints. */
+export declare const style: {
+  /** A green `✓` for something that worked. */
+  success: (msg: string) => string;
+  /** A yellow `⚠` for something worth a second look. */
+  warn: (msg: string) => string;
+  /** A red `✗` for something that failed. */
+  fail: (msg: string) => string;
+  /** A cyan `→` for a step being taken. */
+  step: (msg: string) => string;
+  /** A dim `·` marker for a row that's neither a pass nor a failure — loaded but inactive, or skipped. */
+  skip: (msg: string) => string;
+  /** Dimmed text for a suggestion or a next step. */
+  hint: (msg: string) => string;
+  /** Dimmed text for detail that should recede. */
+  dim: (msg: string) => string;
+  /** Bold text for a heading. */
+  header: (msg: string) => string;
+};
+/**
+ * Print `message` and wait until Enter is pressed, the input ends, or Ctrl-C is pressed, whichever comes first, and
+ * return which: `enter`, or `closed` for the other two. It never hangs on a closed input. It reads from stdin and
+ * writes to stderr, so a pipe on stdout is never touched; the caller checks there is a terminal to answer it. The
+ * streams are parameters so a test can answer for the user.
+ */
+export declare function waitForEnter(message: string, input?: NodeJS.ReadableStream, output?: NodeJS.WritableStream): Promise<"enter" | "closed">;
+export type { Container, Key, Line, Path, Progress, ProgressListener, RenderOptions, RowStatus, ViewJsonOptions, ViewState };

package/dist/ui.mjs

@@ -0,0 +1,391 @@
+import { t as NonInteractiveError } from "./non-interactive-error-Mm_Mn79M.mjs";
+import chalk from "chalk";
+import { spawn } from "node:child_process";
+import ora from "ora";
+import { createInterface } from "node:readline";
+// src/ui/json-view/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"));
+}
+// src/ui/open-path/open-path.ts
+/** Platform-appropriate command to open a path in the OS's file browser. */
+function openCommand(path) {
+	if (process.platform === "darwin") return {
+		cmd: "open",
+		args: [path]
+	};
+	if (process.platform === "win32") return {
+		cmd: "cmd",
+		args: [
+			"/c",
+			"start",
+			"",
+			path
+		]
+	};
+	return {
+		cmd: "xdg-open",
+		args: [path]
+	};
+}
+/**
+* Open `path` in the OS's default file browser (Finder / Explorer /
+* whatever `xdg-open` resolves to on Linux). Fire-and-forget — detached so
+* it outlives this process, and never throws when the opener binary isn't
+* on PATH (e.g. no `xdg-open` in a minimal container).
+*/
+function openPath(path) {
+	const { cmd, args } = openCommand(path);
+	const child = spawn(cmd, args, {
+		stdio: "ignore",
+		detached: true
+	});
+	child.on("error", () => {});
+	child.unref();
+}
+// src/ui/progress/progress.ts
+/**
+* Runs `fn`, showing an ora spinner for its duration in TTY environments.
+* In non-TTY environments (CI, pipes, tests) the spinner is skipped entirely.
+*/
+async function withSpinner(label, fn) {
+	if (!process.stdout.isTTY) return fn();
+	const spinner = ora(label).start();
+	try {
+		const result = await fn();
+		spinner.succeed();
+		return result;
+	} catch (err) {
+		spinner.fail();
+		throw err;
+	}
+}
+let allowed = true;
+/** Turn progress off for the run (`--quiet`, `--log`), so nothing extra shares the terminal with what those print. */
+function allowProgress(on) {
+	allowed = on;
+}
+/**
+* Whether to draw a progress line: only when a person is watching a terminal (stdout and stderr both), not in CI, and not
+* switched off. Everywhere else the output stays the plain line-per-step text that scripts and the docs rely on.
+*/
+function progressEnabled() {
+	return allowed && Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY) && !process.env["CI"];
+}
+/**
+* A spinner for one step at a time that a step can print through. Steps that only return a result use {@link
+* withProgress}; a step that prints its own result line while it runs prints through `print`. A `listen` hook can change the
+* spinner's text while the step runs, for instance to say that a request is being sent again.
+*/
+function createProgress(print, enabled = progressEnabled, listen) {
+	let active;
+	return {
+		async run(label, fn) {
+			if (!enabled()) return fn();
+			const spinner = ora({
+				text: label,
+				stream: process.stderr,
+				discardStdin: false
+			}).start();
+			active = spinner;
+			const stopListening = listen?.(label, (text) => {
+				spinner.text = text;
+			});
+			try {
+				return await fn();
+			} finally {
+				stopListening?.();
+				spinner.stop();
+				active = void 0;
+			}
+		},
+		print(line) {
+			const spinner = active;
+			if (!spinner) return print(line);
+			spinner.stop();
+			print(line);
+			spinner.start();
+		}
+	};
+}
+/** `fn` under a cleared-when-done spinner named `label`, on a terminal only. */
+function withProgress(label, fn, listen) {
+	return createProgress(() => {}, progressEnabled, listen).run(label, fn);
+}
+// src/ui/style/style.ts
+/** Formats a message with a status marker and colour: one helper per kind of line a command prints. */
+const style = {
+	/** A green `✓` for something that worked. */
+	success: (msg) => `${chalk.green("✓")} ${msg}`,
+	/** A yellow `⚠` for something worth a second look. */
+	warn: (msg) => `${chalk.yellow("⚠")} ${msg}`,
+	/** A red `✗` for something that failed. */
+	fail: (msg) => `${chalk.red("✗")} ${msg}`,
+	/** A cyan `→` for a step being taken. */
+	step: (msg) => `${chalk.cyan("→")} ${msg}`,
+	/** A dim `·` marker for a row that's neither a pass nor a failure — loaded but inactive, or skipped. */
+	skip: (msg) => chalk.dim(`· ${msg}`),
+	/** Dimmed text for a suggestion or a next step. */
+	hint: (msg) => chalk.dim(msg),
+	/** Dimmed text for detail that should recede. */
+	dim: (msg) => chalk.dim(msg),
+	/** Bold text for a heading. */
+	header: (msg) => chalk.bold(msg)
+};
+// src/ui/status-row/status-row.ts
+/** Right-pads `s` to `width` with spaces — never truncates. */
+function pad(s, width) {
+	return s.length >= width ? s : s + " ".repeat(width - s.length);
+}
+/**
+* One row of a status report: a 2-space indent, the status icon (✓ / ✗ / ·),
+* then `columns` joined with a two-space gap (blank columns dropped, so a
+* row that has nothing for its last column doesn't trail whitespace).
+* Column padding (`pad`) is the caller's job — `doctor` pads capability and
+* provider to a fixed width; `clone`'s repo names and paths don't, since
+* they vary too widely for fixed-width alignment to read cleanly.
+*
+* Shared by `doctor` (capability / provider / message) and `clone` (repo /
+* destination / reason) so every status table in the CLI reads the same way.
+*/
+function statusRow(status, columns) {
+	const joined = columns.filter((c) => c.length > 0).join("  ");
+	return `  ${status === "ok" ? style.success(joined) : status === "fail" ? style.fail(joined) : style.skip(joined)}`;
+}
+// src/ui/wait-for-enter/wait-for-enter.ts
+/**
+* Print `message` and wait until Enter is pressed, the input ends, or Ctrl-C is pressed, whichever comes first, and
+* return which: `enter`, or `closed` for the other two. It never hangs on a closed input. It reads from stdin and
+* writes to stderr, so a pipe on stdout is never touched; the caller checks there is a terminal to answer it. The
+* streams are parameters so a test can answer for the user.
+*/
+function waitForEnter(message, input = process.stdin, output = process.stderr) {
+	return new Promise((resolve) => {
+		const rl = createInterface({
+			input,
+			output
+		});
+		let answered = false;
+		rl.on("close", () => resolve(answered ? "enter" : "closed"));
+		rl.on("SIGINT", () => rl.close());
+		rl.question(message, () => {
+			answered = true;
+			rl.close();
+		});
+	});
+}
+export { NonInteractiveError, allowProgress, createProgress, expandToDepth, openPath, pad, progressEnabled, reduceKey, renderTree, statusRow, style, viewJson, waitForEnter, withProgress, withSpinner };

package/package.json

@@ -1,6 +1,129 @@
 {
   "name": "@theholocron/kyber",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "5.0.0-alpha.338",
+  "description": "The reusable parts of a command-line tool: terminal output, prompts, the update notifier, safe handling of tokens, a test harness and the global flags.",
+  "keywords": [
+    "cli",
+    "holocron",
+    "kyber",
+    "theholocron"
+  ],
+  "homepage": "https://docs.theholocron.dev/holocron/kyber/",
+  "bugs": "https://github.com/theholocron/holocron/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theholocron/holocron.git",
+    "directory": "cli/kyber"
+  },
+  "license": "MIT",
+  "author": "Newton Koumantzelis",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    "./flags": {
+      "types": "./dist/flags.d.mts",
+      "import": "./dist/flags.mjs",
+      "default": "./dist/flags.mjs"
+    },
+    "./notifier": {
+      "types": "./dist/notifier.d.mts",
+      "import": "./dist/notifier.mjs",
+      "default": "./dist/notifier.mjs"
+    },
+    "./prompts": {
+      "types": "./dist/prompts.d.mts",
+      "import": "./dist/prompts.mjs",
+      "default": "./dist/prompts.mjs"
+    },
+    "./secrets": {
+      "types": "./dist/secrets.d.mts",
+      "import": "./dist/secrets.mjs",
+      "default": "./dist/secrets.mjs"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.mts",
+      "import": "./dist/testing.mjs",
+      "default": "./dist/testing.mjs"
+    },
+    "./ui": {
+      "types": "./dist/ui.d.mts",
+      "import": "./dist/ui.mjs",
+      "default": "./dist/ui.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@inquirer/prompts": "^8.7.5",
+    "@inquirer/search": "^4.3.6",
+    "@types/node": "^26",
+    "@types/yargs": "^17.0.35",
+    "@vitest/coverage-v8": "^5.0.5",
+    "@vitest/eslint-plugin": "^1.6.28",
+    "chalk": "^6.0.1",
+    "clipboardy": "^5.3.2",
+    "dotenv": "^17.4.2",
+    "eslint": "^10.14.0",
+    "eslint-plugin-n": "^18.5.0",
+    "globals": "^17.14.0",
+    "ora": "^9.4.1",
+    "tsdown": "^0.23.4",
+    "typescript": "^5.9.3",
+    "vitest": "^5.0.5",
+    "yargs": "^18.1.0",
+    "@theholocron/eslint-config": "^8.9.0-alpha.8",
+    "@theholocron/tsconfig": "^8.9.0-alpha.8",
+    "@theholocron/tsdown-config": "^8.9.0-alpha.8",
+    "@theholocron/vitest-config": "^8.9.0-alpha.8"
+  },
+  "peerDependencies": {
+    "@inquirer/prompts": "^8.0.0",
+    "@inquirer/search": "^4.0.0",
+    "@napi-rs/keyring": "^1.0.0",
+    "chalk": "^6.0.0",
+    "clipboardy": "^5.0.0",
+    "dotenv": "^17.0.0",
+    "ora": "^9.0.0",
+    "yargs": "^18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@inquirer/prompts": {
+      "optional": true
+    },
+    "@inquirer/search": {
+      "optional": true
+    },
+    "@napi-rs/keyring": {
+      "optional": true
+    },
+    "chalk": {
+      "optional": true
+    },
+    "clipboardy": {
+      "optional": true
+    },
+    "dotenv": {
+      "optional": true
+    },
+    "ora": {
+      "optional": true
+    },
+    "yargs": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "lint:code": "eslint .",
+    "test:unit": "vitest run --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
 }