pino-nice 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tim Zadorozhny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,99 @@
+<p align="center">
+  <img src="pino-nice.png" alt="pino-nice" width="100%" />
+</p>
+
+# pino-nice
+
+✨ Pretty-print [pino](https://github.com/pinojs/pino) (and pino-like) JSON logs from stdin into a clean, human-friendly streaming view.
+
+```bash
+node app.js | npx pino-nice
+```
+
+## 🤔 Why pino-nice?
+
+Structured JSON logs are great for machines and terrible for human eyes. `pino-pretty` helps, but pino-nice takes a different, opinionated approach focused on readability while tailing logs:
+
+- 🧾 **Sectioned details + headline.** Each record renders its structured fields as an indented, YAML-like block, connected with box-drawing lines (`│` / `└─`) down to a single headline `LEVEL  timestamp  message`.
+- 🎨 **Color-coded levels.** `trace`/`debug`/`info`/`warn`/`error`/`fatal` each get a distinct color, applied to the connectors too, so severity pops at a glance.
+- 🧨 **First-class errors.** Stack traces are cleaned up, internal `node_modules`/`node:` frames are dimmed, and nested `cause` chains and `AggregateError`s are rendered with their structure intact.
+- 🔌 **Works with more than pino.** Recognizes pino defaults plus common aliases like `severity` / `message` / `timestamp`, so logs from other services format nicely too.
+- 🕒 **Readable timestamps.** Local time by default (or `--utc`), with a missing timestamp filled in from the current time.
+- 🔗 **URL-safe wrapping.** Lines flow to your terminal's width with no manual mid-token breaks, so long URLs stay clickable.
+- 🚀 **Bun & Node, zero runtime deps.** Ships as a tiny dependency-free CLI.
+
+## 📦 Install
+
+Global install:
+
+```bash
+npm install -g pino-nice
+# or
+bun add -g pino-nice
+```
+
+Or run it without installing:
+
+```bash
+npx pino-nice
+# or
+bunx pino-nice
+```
+
+## 🛠️ Usage
+
+Pipe any stream of pino/NDJSON logs into `pino-nice`:
+
+```bash
+# installed globally
+node app.js | pino-nice
+
+# without installing
+node app.js | npx pino-nice --warn
+bun run app.ts | bunx pino-nice --utc
+```
+
+Filter by minimum level and choose a timezone:
+
+```bash
+# only warnings and above, timestamps in UTC
+node app.js | pino-nice --warn --utc
+```
+
+## ⚙️ Options
+
+```text
+pino-nice - pretty-print pino (and pino-like) JSON logs from stdin
+
+Usage:
+  <command emitting json logs> | pino-nice [options]
+
+Options:
+  --utc            Print timestamps in UTC. Default: local time.
+  --trace          Show trace and above (all levels).
+  --debug          Show debug and above.
+  --info           Show info and above.
+  --warn           Show warnings and above.
+  --error          Show errors and above.
+  --fatal          Show fatal only.
+  -h, --help       Show this help and exit.
+
+Notes:
+  Level flags filter by minimum severity; if several are given, the last wins.
+```
+
+If you pass several level flags, the **last one wins** (e.g. `--error --info` shows info and above).
+
+## 🧩 Supported log shapes
+
+pino-nice resolves fields from common conventions:
+
+- **Level:** `level` (numeric `10`–`60`) or `severity` (`"INFO"`, `"DEBUG"`, ...)
+- **Message:** `msg` or `message`
+- **Timestamp:** `time` or `timestamp` (epoch ms or ISO string); if absent, the current time is used
+
+All six pino levels are supported: `trace` (10), `debug` (20), `info` (30), `warn` (40), `error` (50), `fatal` (60).
+
+## 📄 License
+
+[MIT](LICENSE) © Tim Zadorozhny

package/dist/pino-nice.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+interface PinoNiceOptions {
+    /** Print timestamps in UTC. Defaults to local time. */
+    utc?: boolean;
+    /** Minimum numeric level to display; lower levels are hidden. Defaults to 0. */
+    minLevel?: number;
+}
+declare class PinoNice {
+    private readonly utc;
+    private readonly minLevel;
+    constructor(options?: PinoNiceOptions);
+    private handleLine;
+    pipe(): Promise<void>;
+}
+
+export { type PinoNiceOptions, PinoNice as default };

package/dist/pino-nice.js

@@ -0,0 +1,380 @@
+#!/usr/bin/env node
+
+// pino-nice.ts
+import process from "process";
+import { pathToFileURL } from "url";
+var colorsEnabled = (() => {
+  if (process.env.NO_COLOR) return false;
+  const force = process.env.FORCE_COLOR;
+  if (force !== void 0 && force !== "" && force !== "0") return true;
+  if (typeof Bun !== "undefined") return Bun.enableANSIColors;
+  return Boolean(process.stdout.isTTY);
+})();
+function sgr(open, close) {
+  return (s) => colorsEnabled ? `\x1B[${open}m${s}\x1B[${close}m` : s;
+}
+var c = {
+  bold: sgr(1, 22),
+  dim: sgr(2, 22),
+  red: sgr(31, 39),
+  green: sgr(32, 39),
+  yellow: sgr(33, 39),
+  blue: sgr(34, 39),
+  magenta: sgr(35, 39),
+  cyan: sgr(36, 39),
+  gray: sgr(90, 39)
+};
+var BOX = {
+  vertical: "\u2502",
+  // │
+  corner: "\u2514",
+  // └
+  horizontal: "\u2500"
+  // ─
+};
+var LEVELS = {
+  10: { label: "TRACE", color: c.gray },
+  20: { label: "DEBUG", color: c.cyan },
+  30: { label: "INFO", color: c.green },
+  40: { label: "WARN", color: c.yellow },
+  50: { label: "ERROR", color: c.red },
+  60: { label: "FATAL", color: (s) => c.bold(c.red(s)) }
+};
+var LEVEL_WIDTH = 5;
+var LABEL_TO_LEVEL = Object.fromEntries(
+  Object.entries(LEVELS).map(([num, info]) => [info.label, Number(num)])
+);
+function levelToNumber(level) {
+  if (typeof level === "number") return level;
+  if (typeof level === "string") {
+    const upper = level.toUpperCase();
+    const known = LABEL_TO_LEVEL[upper];
+    if (known !== void 0) return known;
+    const n = Number(level);
+    if (!Number.isNaN(n)) return n;
+  }
+  return Number.POSITIVE_INFINITY;
+}
+var SPECIAL_FIELDS = /* @__PURE__ */ new Set([
+  "time",
+  "timestamp",
+  "level",
+  "severity",
+  "msg",
+  "message",
+  "pid",
+  "hostname",
+  "v"
+]);
+var TIME_KEYS = ["time", "timestamp"];
+var LEVEL_KEYS = ["level", "severity"];
+var MESSAGE_KEYS = ["msg", "message"];
+function firstDefined(entry, keys) {
+  for (const key of keys) {
+    if (entry[key] !== void 0 && entry[key] !== null) return entry[key];
+  }
+  return void 0;
+}
+var IMPORTANT_KEYS = /* @__PURE__ */ new Set([
+  "reqId",
+  "requestId",
+  "traceId",
+  "spanId",
+  "userId"
+]);
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isErrorLike(value) {
+  return isPlainObject(value) && typeof value.message === "string" && typeof value.stack === "string";
+}
+function highlightKey(key) {
+  return IMPORTANT_KEYS.has(key) ? c.bold(c.cyan(key)) : c.cyan(key);
+}
+function formatScalar(value) {
+  if (value === null) return c.dim("null");
+  if (value === void 0) return c.dim("undefined");
+  if (typeof value === "boolean" || typeof value === "number") {
+    return c.yellow(String(value));
+  }
+  return String(value);
+}
+function errorHeader(err) {
+  const type = err.type ?? "Error";
+  const message = err.message ?? "";
+  return c.bold(c.red(`${type}: ${message}`));
+}
+function renderStackFrames(stack, indent) {
+  const pad = " ".repeat(indent);
+  const out = [];
+  const lines = stack.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = (lines[i] ?? "").trim();
+    if (line === "") continue;
+    if (i === 0 && !line.startsWith("at ")) continue;
+    if (line.startsWith("at ")) {
+      const internal = line.includes("node_modules") || line.includes("node:");
+      if (internal) {
+        out.push(pad + c.dim(line));
+        continue;
+      }
+      const m = line.match(/^at (?:(.+?) \()?(.+?):(\d+):(\d+)\)?$/);
+      if (m && m[2] && m[3] && m[4]) {
+        const fn = m[1];
+        const loc = `${c.cyan(m[2])}:${c.yellow(m[3])}:${c.yellow(m[4])}`;
+        out.push(
+          pad + (fn ? `${c.dim("at")} ${fn} (${loc})` : `${c.dim("at")} ${loc}`)
+        );
+      } else {
+        out.push(pad + c.dim(line));
+      }
+      continue;
+    }
+    if (line.startsWith("caused by:")) {
+      const rest = line.slice("caused by:".length).trim();
+      out.push(pad + c.dim("caused by:") + " " + c.bold(c.red(rest)));
+    } else {
+      out.push(pad + c.dim(line));
+    }
+  }
+  return out;
+}
+function renderErrorBody(err, indent, depth) {
+  if (depth > 6) return [];
+  const pad = " ".repeat(indent);
+  const out = [];
+  if (typeof err.stack === "string") {
+    out.push(...renderStackFrames(err.stack, indent));
+  }
+  const aggregate = err.aggregateErrors ?? err.errors;
+  if (Array.isArray(aggregate)) {
+    for (const sub of aggregate) {
+      if (isErrorLike(sub)) {
+        out.push(`${pad}${c.dim("-")} ${errorHeader(sub)}`);
+        out.push(...renderErrorBody(sub, indent + 2, depth + 1));
+      }
+    }
+  }
+  if (isErrorLike(err.cause)) {
+    out.push(`${pad}${c.dim("caused by:")} ${errorHeader(err.cause)}`);
+    out.push(...renderErrorBody(err.cause, indent + 2, depth + 1));
+  }
+  return out;
+}
+function renderData(value, indent, depth = 0) {
+  const pad = " ".repeat(indent);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return [`${pad}${c.dim("[]")}`];
+    const out = [];
+    for (const item of value) {
+      if (isErrorLike(item)) {
+        out.push(`${pad}${c.dim("-")} ${errorHeader(item)}`);
+        out.push(...renderErrorBody(item, indent + 2, depth + 1));
+      } else if (isPlainObject(item) || Array.isArray(item)) {
+        const nested = renderData(item, indent + 2, depth + 1);
+        const first = nested[0];
+        if (first !== void 0) {
+          out.push(`${pad}${c.dim("-")} ${first.slice(indent + 2)}`);
+          out.push(...nested.slice(1));
+        } else {
+          out.push(`${pad}${c.dim("-")}`);
+        }
+      } else {
+        out.push(`${pad}${c.dim("-")} ${formatScalar(item)}`);
+      }
+    }
+    return out;
+  }
+  if (isPlainObject(value)) {
+    const entries = Object.entries(value);
+    if (entries.length === 0) return [`${pad}${c.dim("{}")}`];
+    const out = [];
+    for (const [key, val] of entries) {
+      const keyStr = highlightKey(key);
+      if (isErrorLike(val)) {
+        out.push(`${pad}${keyStr}: ${errorHeader(val)}`);
+        out.push(...renderErrorBody(val, indent + 2, depth + 1));
+        continue;
+      }
+      if (Array.isArray(val) || isPlainObject(val)) {
+        const empty = Array.isArray(val) ? val.length === 0 ? "[]" : null : Object.keys(val).length === 0 ? "{}" : null;
+        if (empty !== null) {
+          out.push(`${pad}${keyStr}: ${c.dim(empty)}`);
+        } else {
+          out.push(`${pad}${keyStr}:`);
+          out.push(...renderData(val, indent + 2, depth + 1));
+        }
+        continue;
+      }
+      if (typeof val === "string" && val.includes("\n")) {
+        out.push(`${pad}${keyStr}: ${c.dim("|")}`);
+        for (const line of val.split("\n")) {
+          out.push(`${" ".repeat(indent + 2)}${line}`);
+        }
+        continue;
+      }
+      out.push(`${pad}${keyStr}: ${formatScalar(val)}`);
+    }
+    return out;
+  }
+  return [`${pad}${formatScalar(value)}`];
+}
+function toDate(time) {
+  if (typeof time === "number") {
+    const d = new Date(time);
+    return Number.isNaN(d.getTime()) ? null : d;
+  }
+  if (typeof time === "string") {
+    const d = new Date(/^\d+$/.test(time) ? Number(time) : time);
+    return Number.isNaN(d.getTime()) ? null : d;
+  }
+  return null;
+}
+function formatTimestamp(time, utc) {
+  const date = toDate(time);
+  if (!date) return typeof time === "string" ? time : String(time);
+  const pad = (n, w = 2) => String(n).padStart(w, "0");
+  const datePart = utc ? `${pad(date.getUTCFullYear(), 4)}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}` : `${pad(date.getFullYear(), 4)}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+  const clock = utc ? `${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:${pad(date.getUTCSeconds())}` : `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+  const millis = pad(
+    utc ? date.getUTCMilliseconds() : date.getMilliseconds(),
+    3
+  );
+  return `${c.dim(datePart)} ${c.bold(clock)}${c.dim(`.${millis}`)}${utc ? c.dim("Z") : ""}`;
+}
+function levelInfo(level) {
+  if (typeof level === "number" && LEVELS[level]) return LEVELS[level];
+  if (typeof level === "string") {
+    const upper = level.toUpperCase();
+    for (const info of Object.values(LEVELS)) {
+      if (info.label === upper) return info;
+    }
+    return { label: upper, color: (s) => s };
+  }
+  return { label: String(level), color: (s) => s };
+}
+function summaryLine(time, level, msg, utc) {
+  const info = levelInfo(level);
+  const paddedLabel = info.label.padEnd(LEVEL_WIDTH);
+  const hasTime = time !== void 0 && time !== null;
+  const tsPart = hasTime ? `${formatTimestamp(time, utc)}  ` : "";
+  const connector = `${BOX.corner}${BOX.horizontal} `;
+  const message = typeof msg === "string" ? msg : String(msg);
+  return `${info.color(connector)}${info.color(paddedLabel)}  ${tsPart}${message}`.trimEnd();
+}
+var PinoNice = class {
+  utc;
+  minLevel;
+  constructor(options = {}) {
+    this.utc = options.utc ?? false;
+    this.minLevel = options.minLevel ?? 0;
+  }
+  handleLine(rawLine) {
+    const line = rawLine.replace(/\r$/, "");
+    if (line.trim() === "") return;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (!isPlainObject(entry)) return;
+    const level = firstDefined(entry, LEVEL_KEYS);
+    if (level === void 0) return;
+    const message = firstDefined(entry, MESSAGE_KEYS) ?? "";
+    const time = firstDefined(entry, TIME_KEYS) ?? Date.now();
+    if (levelToNumber(level) < this.minLevel) return;
+    const rest = {};
+    for (const [key, value] of Object.entries(entry)) {
+      if (!SPECIAL_FIELDS.has(key)) rest[key] = value;
+    }
+    const info = levelInfo(level);
+    const out = [];
+    const dataLines = Object.keys(rest).length > 0 ? renderData(rest, 1) : [];
+    for (const dataLine of dataLines) {
+      out.push(info.color(BOX.vertical) + "   " + dataLine);
+    }
+    out.push(summaryLine(time, level, message, this.utc));
+    try {
+      process.stdout.write(out.join("\n") + "\n");
+    } catch (error) {
+      if (error?.code === "EPIPE") process.exit(0);
+      throw error;
+    }
+  }
+  async pipe() {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for await (const chunk of process.stdin) {
+      buffer += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+      let nl;
+      while ((nl = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        this.handleLine(line);
+      }
+    }
+    buffer += decoder.decode();
+    if (buffer.length > 0) this.handleLine(buffer);
+  }
+};
+var LEVEL_FLAGS = {
+  "--trace": 10,
+  "--debug": 20,
+  "--info": 30,
+  "--warn": 40,
+  "--error": 50,
+  "--fatal": 60
+};
+var HELP = `pino-nice - pretty-print pino (and pino-like) JSON logs from stdin
+
+Usage:
+  <command emitting json logs> | pino-nice [options]
+
+Options:
+  --utc            Print timestamps in UTC. Default: local time.
+  --trace          Show trace and above (all levels).
+  --debug          Show debug and above.
+  --info           Show info and above.
+  --warn           Show warnings and above.
+  --error          Show errors and above.
+  --fatal          Show fatal only.
+  -h, --help       Show this help and exit.
+
+Notes:
+  Level flags filter by minimum severity; if several are given, the last wins.
+`;
+function parseArgs(argv) {
+  const options = {};
+  for (const arg of argv) {
+    if (arg === "--help" || arg === "-h") {
+      process.stdout.write(HELP);
+      process.exit(0);
+    } else if (arg === "--utc") {
+      options.utc = true;
+    } else if (LEVEL_FLAGS[arg] !== void 0) {
+      options.minLevel = LEVEL_FLAGS[arg];
+    } else {
+      process.stderr.write(`pino-nice: unknown option '${arg}' (try --help)
+`);
+      process.exit(1);
+    }
+  }
+  return options;
+}
+var isMainModule = import.meta.main ?? (process.argv[1] !== void 0 && import.meta.url === pathToFileURL(process.argv[1]).href);
+if (isMainModule) {
+  process.stdout.on("error", (error) => {
+    if (error.code === "EPIPE") process.exit(0);
+    throw error;
+  });
+  const options = parseArgs(process.argv.slice(2));
+  new PinoNice(options).pipe().catch((error) => {
+    if (error?.code === "EPIPE") process.exit(0);
+    console.error(error);
+    process.exit(1);
+  });
+}
+export {
+  PinoNice as default
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "pino-nice",
+  "version": "0.0.1",
+  "description": "Pretty-print pino (and pino-like) JSON logs from stdin with a clean, human-friendly streaming view.",
+  "type": "module",
+  "author": "Tim Zadorozhny <tzador@gmail.com>",
+  "license": "MIT",
+  "bin": {
+    "pino-nice": "./dist/pino-nice.js"
+  },
+  "main": "./dist/pino-nice.js",
+  "module": "./dist/pino-nice.js",
+  "types": "./dist/pino-nice.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/pino-nice.d.ts",
+      "import": "./dist/pino-nice.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "pino-nice.png"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "pino",
+    "pretty",
+    "logger",
+    "cli",
+    "logs",
+    "formatter",
+    "ndjson"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tzador/pino-nice.git"
+  },
+  "homepage": "https://github.com/tzador/pino-nice#readme",
+  "bugs": "https://github.com/tzador/pino-nice/issues",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "bun run build",
+    "release": "bun run build && npm publish",
+    "demo": "bun run pino-nice-demo.ts | bun run pino-nice.ts",
+    "format": "prettier --write ."
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "pino": "^10.3.1",
+    "prettier": "^3.8.3",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3"
+  }
+}