@dheerajsom/pinhub 0.1.0

package/dist/render/board.js

@@ -0,0 +1,194 @@
+import { pinStyle, warningStyle } from "./theme.js";
+const INDENT = "  ";
+/** Label plus its primary alternate function; reserved pins get a `*` marker. */
+function displayLabel(pin) {
+    const fn = pin.functions?.[0];
+    const base = fn && fn !== pin.label ? `${pin.label} / ${fn}` : pin.label;
+    return pin.category === "reserved" ? `${base} *` : base;
+}
+function pinDetails(pin) {
+    return pin.voltage ? `${pin.category}, ${pin.voltage}` : pin.category;
+}
+export function wrapText(text, width, indent) {
+    const usable = Math.max(20, width - indent.length);
+    const words = text.split(/\s+/);
+    const lines = [];
+    let line = "";
+    for (const word of words) {
+        if (line && line.length + 1 + word.length > usable) {
+            lines.push(indent + line);
+            line = word;
+        }
+        else {
+            line = line ? `${line} ${word}` : word;
+        }
+    }
+    if (line)
+        lines.push(indent + line);
+    return lines;
+}
+function byPosition(header, column, row) {
+    return header.pins.find((p) => p.position.column === column && p.position.row === row);
+}
+/** Bordered two-column diagram: label | pin | pin | label. */
+function renderDualRowTable(header, opts) {
+    const { chalk: c, chars: ch } = opts;
+    const rows = [];
+    for (let r = 1; r <= header.layout.rows; r++) {
+        rows.push([byPosition(header, 1, r), byPosition(header, 2, r)]);
+    }
+    const leftWidth = Math.max(...rows.map(([l]) => (l ? displayLabel(l).length : 0)), 4);
+    const rightWidth = Math.max(...rows.map(([, r]) => (r ? displayLabel(r).length : 0)), 4);
+    const numWidth = Math.max(...header.pins.map((p) => String(p.physical).length), 2);
+    const totalWidth = INDENT.length + leftWidth + rightWidth + 2 * numWidth + 13;
+    if (totalWidth > opts.width)
+        return undefined;
+    const h = ch.horizontal;
+    const seg = (n) => h.repeat(n + 2);
+    const lines = [];
+    lines.push(`${INDENT}${ch.topLeft}${seg(leftWidth)}${ch.topJoin}${seg(numWidth)}${ch.topJoin}${seg(numWidth)}${ch.topJoin}${seg(rightWidth)}${ch.topRight}`);
+    for (const [left, right] of rows) {
+        const leftLabel = left ? pinStyle(c, left)(displayLabel(left).padEnd(leftWidth)) : " ".repeat(leftWidth);
+        const rightLabel = right ? pinStyle(c, right)(displayLabel(right).padEnd(rightWidth)) : " ".repeat(rightWidth);
+        const leftNum = left ? String(left.physical).padStart(numWidth) : " ".repeat(numWidth);
+        const rightNum = right ? String(right.physical).padStart(numWidth) : " ".repeat(numWidth);
+        lines.push(`${INDENT}${ch.vertical} ${leftLabel} ${ch.vertical} ${leftNum} ${ch.vertical} ${rightNum} ${ch.vertical} ${rightLabel} ${ch.vertical}`);
+    }
+    lines.push(`${INDENT}${ch.bottomLeft}${seg(leftWidth)}${ch.bottomJoin}${seg(numWidth)}${ch.bottomJoin}${seg(numWidth)}${ch.bottomJoin}${seg(rightWidth)}${ch.bottomRight}`);
+    return lines;
+}
+/** Borderless two-column pairs for --compact / narrower terminals. */
+function renderDualRowCompact(header, opts) {
+    const { chalk: c, chars: ch } = opts;
+    const rows = [];
+    for (let r = 1; r <= header.layout.rows; r++) {
+        rows.push([byPosition(header, 1, r), byPosition(header, 2, r)]);
+    }
+    const leftWidth = Math.max(...rows.map(([l]) => (l ? displayLabel(l).length : 0)), 4);
+    const rightWidth = Math.max(...rows.map(([, r]) => (r ? displayLabel(r).length : 0)), 4);
+    const numWidth = Math.max(...header.pins.map((p) => String(p.physical).length), 2);
+    const totalWidth = INDENT.length + leftWidth + 2 + numWidth + 3 + numWidth + 2 + rightWidth;
+    if (totalWidth > opts.width)
+        return undefined;
+    return rows.map(([left, right]) => {
+        const leftLabel = left ? pinStyle(c, left)(displayLabel(left).padStart(leftWidth)) : " ".repeat(leftWidth);
+        const rightLabel = right ? pinStyle(c, right)(displayLabel(right)) : "";
+        const leftNum = left ? String(left.physical).padStart(numWidth) : " ".repeat(numWidth);
+        const rightNum = right ? String(right.physical).padEnd(numWidth) : " ".repeat(numWidth);
+        return `${INDENT}${leftLabel}  ${leftNum} ${ch.pairSeparator} ${rightNum}  ${rightLabel}`.trimEnd();
+    });
+}
+/** One pin per line — always fits; last-resort fallback and 1-column layout. */
+function renderPinList(header, opts) {
+    const { chalk: c } = opts;
+    const pins = [...header.pins].sort((a, b) => a.physical - b.physical);
+    const numWidth = Math.max(...pins.map((p) => String(p.physical).length), 2);
+    const labelWidth = Math.max(...pins.map((p) => displayLabel(p).length), 4);
+    return pins.map((pin) => {
+        const label = pinStyle(c, pin)(displayLabel(pin).padEnd(labelWidth));
+        return `${INDENT}${String(pin.physical).padStart(numWidth)}  ${label}  ${c.dim(pinDetails(pin))}`;
+    });
+}
+/** Bordered single-column table: # | pin | details. */
+function renderSingleColumnTable(header, opts) {
+    const { chalk: c, chars: ch } = opts;
+    const pins = [...header.pins].sort((a, b) => a.physical - b.physical);
+    const numWidth = Math.max(...pins.map((p) => String(p.physical).length), 2);
+    const labelWidth = Math.max(...pins.map((p) => displayLabel(p).length), 4);
+    const detailWidth = Math.max(...pins.map((p) => pinDetails(p).length), 4);
+    const totalWidth = INDENT.length + numWidth + labelWidth + detailWidth + 10;
+    if (totalWidth > opts.width)
+        return undefined;
+    const h = ch.horizontal;
+    const seg = (n) => h.repeat(n + 2);
+    const lines = [];
+    lines.push(`${INDENT}${ch.topLeft}${seg(numWidth)}${ch.topJoin}${seg(labelWidth)}${ch.topJoin}${seg(detailWidth)}${ch.topRight}`);
+    for (const pin of pins) {
+        const label = pinStyle(c, pin)(displayLabel(pin).padEnd(labelWidth));
+        lines.push(`${INDENT}${ch.vertical} ${String(pin.physical).padStart(numWidth)} ${ch.vertical} ${label} ${ch.vertical} ${pinDetails(pin).padEnd(detailWidth)} ${ch.vertical}`);
+    }
+    lines.push(`${INDENT}${ch.bottomLeft}${seg(numWidth)}${ch.bottomJoin}${seg(labelWidth)}${ch.bottomJoin}${seg(detailWidth)}${ch.bottomRight}`);
+    return lines;
+}
+function renderHeader(header, opts) {
+    const { chalk: c } = opts;
+    const lines = [];
+    lines.push(c.bold(header.name));
+    if (header.description) {
+        lines.push(...wrapText(header.description, opts.width, INDENT).map((l) => c.dim(l)));
+    }
+    let table;
+    if (header.layout.columns === 2) {
+        table = opts.compact
+            ? renderDualRowCompact(header, opts) ?? renderPinList(header, opts)
+            : renderDualRowTable(header, opts) ??
+                renderDualRowCompact(header, opts) ??
+                renderPinList(header, opts);
+    }
+    else {
+        table = opts.compact ? renderPinList(header, opts) : renderSingleColumnTable(header, opts) ?? renderPinList(header, opts);
+    }
+    lines.push(...table);
+    return lines;
+}
+function renderLegend(board, opts) {
+    const { chalk: c } = opts;
+    if (c.level === 0)
+        return [];
+    const order = [
+        "power",
+        "ground",
+        "gpio",
+        "digital",
+        "analog",
+        "communication",
+        "reserved",
+        "nc",
+    ];
+    const present = order.filter((cat) => board.headers.some((h) => h.pins.some((p) => p.category === cat)));
+    const swatches = present.map((cat) => {
+        const sample = board.headers
+            .flatMap((h) => h.pins)
+            .find((p) => p.category === cat);
+        return pinStyle(c, sample)(cat);
+    });
+    return [c.dim("Legend: ") + swatches.join(c.dim(" · "))];
+}
+export function renderWarnings(board, opts) {
+    const { chalk: c, chars: ch } = opts;
+    return board.warnings.flatMap((warning) => {
+        const marker = warning.severity === "info" ? ch.info : ch.warn;
+        const style = warningStyle(c, warning.severity);
+        return wrapText(`${marker} ${warning.text}`, opts.width, "").map((line, i) => style(i === 0 ? line : `  ${line}`));
+    });
+}
+export function renderBoard(board, opts) {
+    const { chalk: c, chars: ch } = opts;
+    const lines = [];
+    lines.push(`${c.bold(board.name)} ${c.dim(`— ${board.manufacturer}`)}`);
+    const primarySource = board.sources.find((s) => s.official) ?? board.sources[0];
+    if (primarySource) {
+        const tag = primarySource.official ? "official" : "third-party";
+        lines.push(c.dim(`Source: ${primarySource.title} (${tag}) — see ph ${board.id} --source`));
+    }
+    if (board.revisionNote) {
+        lines.push(...wrapText(`${ch.info} ${board.revisionNote}`, opts.width, "").map((line, i) => c.dim(i === 0 ? line : `  ${line}`)));
+    }
+    lines.push(...renderWarnings(board, opts));
+    lines.push("");
+    board.headers.forEach((header, index) => {
+        if (index > 0)
+            lines.push("");
+        lines.push(...renderHeader(header, opts));
+    });
+    const legend = renderLegend(board, opts);
+    if (legend.length > 0) {
+        lines.push("");
+        lines.push(...legend);
+    }
+    const hasReserved = board.headers.some((h) => h.pins.some((p) => p.category === "reserved"));
+    if (hasReserved) {
+        lines.push(c.dim("* reserved / control pin — see warnings above"));
+    }
+    return lines.join("\n");
+}

package/dist/render/chars.d.ts

@@ -0,0 +1,16 @@
+export type CharSet = {
+    topLeft: string;
+    topRight: string;
+    bottomLeft: string;
+    bottomRight: string;
+    horizontal: string;
+    vertical: string;
+    topJoin: string;
+    bottomJoin: string;
+    warn: string;
+    info: string;
+    bullet: string;
+    pairSeparator: string;
+};
+export declare const unicodeChars: CharSet;
+export declare const asciiChars: CharSet;

package/dist/render/chars.js

@@ -0,0 +1,28 @@
+export const unicodeChars = {
+    topLeft: "┌",
+    topRight: "┐",
+    bottomLeft: "└",
+    bottomRight: "┘",
+    horizontal: "─",
+    vertical: "│",
+    topJoin: "┬",
+    bottomJoin: "┴",
+    warn: "⚠",
+    info: "ℹ",
+    bullet: "•",
+    pairSeparator: "│",
+};
+export const asciiChars = {
+    topLeft: "+",
+    topRight: "+",
+    bottomLeft: "+",
+    bottomRight: "+",
+    horizontal: "-",
+    vertical: "|",
+    topJoin: "+",
+    bottomJoin: "+",
+    warn: "!",
+    info: "i",
+    bullet: "*",
+    pairSeparator: "|",
+};

package/dist/render/meta.d.ts

@@ -0,0 +1,6 @@
+import type { ChalkInstance } from "chalk";
+import type { Board } from "../model.js";
+import type { CharSet } from "./chars.js";
+export declare function renderBoardTable(boardList: Board[], c: ChalkInstance): string;
+export declare function renderSources(board: Board, c: ChalkInstance): string;
+export declare function renderInfo(board: Board, c: ChalkInstance, ch: CharSet, width: number): string;

package/dist/render/meta.js

@@ -0,0 +1,62 @@
+import { warningStyle } from "./theme.js";
+import { wrapText } from "./board.js";
+export function renderBoardTable(boardList, c) {
+    const rows = boardList.map((board) => ({
+        id: board.id,
+        name: board.name,
+        manufacturer: board.manufacturer,
+        pins: String(board.headers.reduce((sum, h) => sum + h.pins.length, 0)),
+    }));
+    const idWidth = Math.max(...rows.map((r) => r.id.length), 2);
+    const nameWidth = Math.max(...rows.map((r) => r.name.length), 5);
+    const mfrWidth = Math.max(...rows.map((r) => r.manufacturer.length), 12);
+    const lines = [
+        c.dim(`${"ID".padEnd(idWidth)}  ${"BOARD".padEnd(nameWidth)}  ${"MANUFACTURER".padEnd(mfrWidth)}  PINS`),
+        ...rows.map((r) => `${c.bold(r.id.padEnd(idWidth))}  ${r.name.padEnd(nameWidth)}  ${r.manufacturer.padEnd(mfrWidth)}  ${r.pins.padStart(4)}`),
+    ];
+    lines.push("");
+    lines.push(c.dim("Show a pinout with: ph <id>   e.g. ph rpi5"));
+    return lines.join("\n");
+}
+export function renderSources(board, c) {
+    const lines = [`${c.bold(board.name)} ${c.dim("— sources")}`];
+    for (const source of board.sources) {
+        const tag = source.official ? c.green("(official)") : c.yellow("(third-party)");
+        lines.push(`  ${source.title} ${tag}`);
+        lines.push(c.dim(`    ${source.url}`));
+    }
+    return lines.join("\n");
+}
+export function renderInfo(board, c, ch, width) {
+    const lines = [];
+    lines.push(`${c.bold(board.name)} ${c.dim(`— ${board.manufacturer}`)}`);
+    if (board.description)
+        lines.push(...wrapText(board.description, width, ""));
+    if (board.revisionNote) {
+        lines.push("");
+        lines.push(...wrapText(`Revision note: ${board.revisionNote}`, width, "").map((l) => c.dim(l)));
+    }
+    lines.push("");
+    lines.push(c.bold("Headers"));
+    for (const header of board.headers) {
+        lines.push(`  ${ch.bullet} ${header.name} — ${header.pins.length} pins`);
+    }
+    lines.push("");
+    lines.push(c.bold("Warnings"));
+    for (const warning of board.warnings) {
+        const marker = warning.severity === "info" ? ch.info : ch.warn;
+        const style = warningStyle(c, warning.severity);
+        lines.push(...wrapText(`${marker} ${warning.text}`, width, "  ").map((l) => style(l)));
+    }
+    lines.push("");
+    lines.push(c.bold("Sources"));
+    for (const source of board.sources) {
+        const tag = source.official ? c.green("(official)") : c.yellow("(third-party)");
+        lines.push(`  ${ch.bullet} ${source.title} ${tag}`);
+        lines.push(c.dim(`    ${source.url}`));
+    }
+    lines.push("");
+    lines.push(c.dim(`Aliases: ${board.aliases.join(", ")}`));
+    lines.push(c.dim(`Pinout: ph ${board.id}`));
+    return lines.join("\n");
+}

package/dist/render/theme.d.ts

@@ -0,0 +1,9 @@
+import { type ChalkInstance } from "chalk";
+import type { Pin, WarningSeverity } from "../model.js";
+export declare function makeChalk(colorEnabled: boolean): ChalkInstance;
+/**
+ * Category colors. Color is never the only signal: labels and category names
+ * stay in the output so meaning survives `--no-color` and piping.
+ */
+export declare function pinStyle(c: ChalkInstance, pin: Pin): (text: string) => string;
+export declare function warningStyle(c: ChalkInstance, severity: WarningSeverity): (text: string) => string;

package/dist/render/theme.js

@@ -0,0 +1,37 @@
+import { Chalk } from "chalk";
+export function makeChalk(colorEnabled) {
+    return new Chalk({ level: colorEnabled ? 3 : 0 });
+}
+/**
+ * Category colors. Color is never the only signal: labels and category names
+ * stay in the output so meaning survives `--no-color` and piping.
+ */
+export function pinStyle(c, pin) {
+    switch (pin.category) {
+        case "power":
+            return pin.voltage?.startsWith("5") ? c.red : c.yellow;
+        case "ground":
+            return c.gray;
+        case "gpio":
+        case "digital":
+            return c.green;
+        case "analog":
+            return c.blue;
+        case "communication":
+            return c.cyan;
+        case "reserved":
+            return c.magenta;
+        case "nc":
+            return c.dim;
+    }
+}
+export function warningStyle(c, severity) {
+    switch (severity) {
+        case "danger":
+            return c.red.bold;
+        case "warning":
+            return c.yellow;
+        case "info":
+            return c.dim;
+    }
+}

package/dist/run.d.ts

@@ -0,0 +1,18 @@
+export type RunOptions = {
+    /** Override detected terminal width (defaults to stdout columns or 80). */
+    columns?: number;
+    /** Override TTY detection (piped output disables color automatically). */
+    isTTY?: boolean;
+    /** Override environment (for NO_COLOR handling in tests). */
+    env?: Record<string, string | undefined>;
+};
+export type RunResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+/**
+ * Runs the CLI against captured buffers instead of process streams, so the
+ * whole command surface is testable without spawning child processes.
+ */
+export declare function runCli(argv: string[], runOpts?: RunOptions): Promise<RunResult>;

package/dist/run.js

@@ -0,0 +1,167 @@
+import { Command, CommanderError } from "commander";
+import { boards, resolveBoard, searchBoards, suggestBoards } from "./catalog.js";
+import { VERSION } from "./version.js";
+import { asciiChars, unicodeChars } from "./render/chars.js";
+import { makeChalk } from "./render/theme.js";
+import { renderBoard } from "./render/board.js";
+import { renderBoardTable, renderInfo, renderSources } from "./render/meta.js";
+/**
+ * Runs the CLI against captured buffers instead of process streams, so the
+ * whole command surface is testable without spawning child processes.
+ */
+export async function runCli(argv, runOpts = {}) {
+    let stdout = "";
+    let stderr = "";
+    let code = 0;
+    const print = (text) => {
+        stdout += text + "\n";
+    };
+    const printErr = (text) => {
+        stderr += text + "\n";
+    };
+    const env = runOpts.env ?? process.env;
+    const isTTY = runOpts.isTTY ?? Boolean(process.stdout.isTTY);
+    const detectedColumns = runOpts.columns ?? (isTTY ? process.stdout.columns : undefined) ?? 80;
+    const colorEnabled = (flags) => flags.color !== false && !env.NO_COLOR && isTTY;
+    const buildRender = (flags) => {
+        let width = detectedColumns;
+        if (flags.width !== undefined) {
+            const parsed = Number.parseInt(flags.width, 10);
+            if (!Number.isFinite(parsed) || parsed < 40) {
+                return { error: "Invalid --width: expected a number of at least 40." };
+            }
+            width = parsed;
+        }
+        return {
+            chalk: makeChalk(colorEnabled(flags)),
+            chars: flags.ascii ? asciiChars : unicodeChars,
+            width,
+            compact: Boolean(flags.compact),
+        };
+    };
+    const resolveOrSuggest = (words) => {
+        const query = words.join(" ");
+        const board = resolveBoard(query);
+        if (board)
+            return board;
+        printErr(`Board "${query}" was not found.`);
+        const suggestions = suggestBoards(query);
+        if (suggestions.length > 0) {
+            printErr("");
+            printErr("Did you mean:");
+            for (const suggestion of suggestions) {
+                printErr(`  ph ${suggestion.alias}`);
+            }
+        }
+        printErr("");
+        printErr("Run `ph list` to see all supported boards.");
+        code = 1;
+        return undefined;
+    };
+    const showBoard = (words, flags) => {
+        const board = resolveOrSuggest(words);
+        if (!board)
+            return;
+        if (flags.json) {
+            // JSON mode must emit only valid JSON to stdout.
+            print(JSON.stringify(board, null, 2));
+            return;
+        }
+        const render = buildRender(flags);
+        if ("error" in render) {
+            printErr(render.error);
+            code = 1;
+            return;
+        }
+        if (flags.source) {
+            print(renderSources(board, render.chalk));
+            return;
+        }
+        print(renderBoard(board, render));
+    };
+    const metaChalk = (flags = {}) => makeChalk(colorEnabled(flags));
+    const metaChars = (flags = {}) => (flags.ascii ? asciiChars : unicodeChars);
+    const program = new Command();
+    program
+        .name("ph")
+        .description("Hardware board pinout diagrams in your terminal.")
+        .version(VERSION, "-v, --version", "print the version")
+        .helpCommand("help [command]", "display help for a command")
+        .exitOverride()
+        .configureOutput({
+        writeOut: (text) => {
+            stdout += text;
+        },
+        writeErr: (text) => {
+            stderr += text;
+        },
+    })
+        .argument("[board...]", "board id or alias (e.g. rpi5, pico, uno, esp32)")
+        .option("--compact", "tighter, borderless layout")
+        .option("--ascii", "ASCII-only borders and symbols")
+        .option("--no-color", "disable ANSI colors (the NO_COLOR env var is also honored)")
+        .option("--json", "emit the board data as JSON")
+        .option("--source", "print official source links for the board")
+        .option("--width <number>", "override the detected terminal width")
+        .addHelpText("after", "\nExamples:\n  ph rpi5\n  ph raspberry pi 5\n  ph pico --compact\n  ph esp32 --ascii --no-color\n  ph uno --json\n  ph rpi5 --source")
+        .action((words, flags) => {
+        if (words.length === 0) {
+            program.outputHelp();
+            return;
+        }
+        showBoard(words, flags);
+    });
+    program
+        .command("list")
+        .description("list all boards in the catalog")
+        .action(() => {
+        print(renderBoardTable(boards, metaChalk()));
+    });
+    program
+        .command("search <query...>")
+        .description("search boards by name, alias, or manufacturer")
+        .action((words) => {
+        const query = words.join(" ");
+        const results = searchBoards(query);
+        if (results.length === 0) {
+            printErr(`No boards matched "${query}". Run \`ph list\` to see all boards.`);
+            code = 1;
+            return;
+        }
+        print(renderBoardTable(results, metaChalk()));
+    });
+    program
+        .command("info <board...>")
+        .description("show board details, warnings, sources, and aliases")
+        .option("--ascii", "ASCII-only symbols")
+        .option("--json", "emit the board data as JSON")
+        .action((words, localFlags, command) => {
+        // Flags like --json are also declared on the root command, which
+        // consumes them before dispatch; merge both option scopes.
+        const flags = command.optsWithGlobals();
+        void localFlags;
+        const board = resolveOrSuggest(words);
+        if (!board)
+            return;
+        if (flags.json) {
+            print(JSON.stringify(board, null, 2));
+            return;
+        }
+        print(renderInfo(board, metaChalk(flags), metaChars(flags), detectedColumns));
+    });
+    try {
+        await program.parseAsync(argv, { from: "user" });
+    }
+    catch (error) {
+        if (error instanceof CommanderError) {
+            // Help/version display exits with 0; user mistakes exit non-zero,
+            // without a stack trace either way.
+            code = error.exitCode;
+        }
+        else {
+            printErr(error instanceof Error ? error.message : String(error));
+            code = 1;
+        }
+    }
+    return { code, stdout, stderr };
+}

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+/** Keep in sync with package.json. */
+export declare const VERSION = "0.1.0";

package/dist/version.js

@@ -0,0 +1,2 @@
+/** Keep in sync with package.json. */
+export const VERSION = "0.1.0";

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@dheerajsom/pinhub",
+  "version": "0.1.0",
+  "description": "Hardware board pinout diagrams in your terminal. `ph rpi5` and go.",
+  "keywords": [
+    "pinout",
+    "gpio",
+    "raspberry-pi",
+    "arduino",
+    "esp32",
+    "pico",
+    "hardware",
+    "cli",
+    "terminal"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "ph": "dist/cli.js"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "SETUP.md"
+  ],
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "lint": "eslint .",
+    "package:check": "npm pack --dry-run",
+    "prepublishOnly": "npm run lint && npm run test && npm run build"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.20.0",
+    "@types/node": "^22.13.0",
+    "eslint": "^9.20.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.24.0",
+    "vitest": "^3.0.5"
+  }
+}