@pablo_clueless/printr 0.1.2

package/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+All notable changes to **printr** are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-06-22
+
+### Added
+- Initial release: a CLI that prints Markdown and plain-text files as PDFs.
+- Markdown rendering with GitHub-flavored styling (`markdown-it`) and
+  syntax-highlighted code blocks (`highlight.js`).
+- High-fidelity PDF output through headless Chrome (`puppeteer`); generated HTML
+  is fully self-contained so no external resources are fetched while rendering.
+- Plain-text files (any non-Markdown extension) rendered verbatim in a
+  monospace layout.
+- Batch conversion with glob support (e.g. `printr "docs/**/*.md"`), reusing a
+  single browser instance across files for speed.
+- `--watch` / `-w` mode: re-renders a file whenever it changes, debounced and
+  serialized, with recursive directory watching for `**` patterns and pickup of
+  newly created files matching a glob.
+- CLI options: `--output`/`-o`, `--out-dir`/`-d`, `--format`/`-f`,
+  `--margin`/`-m`, `--title`/`-t`.
+
+[Unreleased]: https://example.com/printr/compare/v0.1.0...HEAD
+[0.1.0]: https://example.com/printr/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 smsnmicheal
+
+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,103 @@
+# printr
+
+> Print **Markdown** and **plain-text** files as nicely styled PDFs — straight from your terminal.
+
+Markdown is rendered with GitHub-flavored styling and syntax-highlighted code
+blocks, then printed to PDF through headless Chrome (Puppeteer) for high
+fidelity. Plain-text files are rendered verbatim in a clean monospace layout.
+The generated HTML is fully self-contained, so no external resources are
+fetched while rendering.
+
+## Features
+
+- 📄 GitHub-flavored Markdown styling with print-tuned page breaks
+- 🎨 Syntax highlighting for code blocks via `highlight.js`
+- 🖨️ High-fidelity PDF output through headless Chrome
+- 📁 Batch conversion with glob patterns, reusing one browser for speed
+- 👀 `--watch` mode that re-renders on every save
+- 🧾 Plain-text files rendered verbatim in monospace
+
+## Install
+
+Run it on demand without installing:
+
+```bash
+npx @pablo_clueless/printr report.md
+```
+
+Or install globally to get the `printr` command everywhere:
+
+```bash
+npm install -g @pablo_clueless/printr
+```
+
+> **Chromium download:** on first install Puppeteer downloads a matching
+> Chromium build (~150 MB). To reuse an existing Chrome instead, set
+> `PUPPETEER_EXECUTABLE_PATH` to its path and install with
+> `PUPPETEER_SKIP_DOWNLOAD=1`.
+
+**Requirements:** Node.js >= 18.
+
+## Usage
+
+```bash
+# Single file → writes report.pdf beside the source
+printr report.md
+
+# Explicit output path
+printr report.md -o ~/Desktop/report.pdf
+
+# Batch convert with a glob, into one folder
+printr "docs/**/*.md" -d out/
+
+# Letter paper, tighter margins
+printr notes.txt -f Letter -m 15mm
+
+# Watch and re-render on every save (Ctrl+C to stop)
+printr "docs/**/*.md" -d out/ --watch
+```
+
+Quote glob patterns (`"docs/**/*.md"`) so your shell passes them to `printr`
+rather than expanding them itself.
+
+## Options
+
+| Flag | Description | Default |
+| ---- | ----------- | ------- |
+| `-o, --output <file>` | Output PDF path (single input only) | beside source |
+| `-d, --out-dir <dir>` | Folder for output PDFs | source folder |
+| `-f, --format <fmt>` | Paper format: `A4`, `Letter`, `Legal`, … | `A4` |
+| `-m, --margin <size>` | Page margin on all sides, e.g. `20mm`, `1in` | `20mm` |
+| `-t, --title <title>` | Document title (single input only) | filename |
+| `-w, --watch` | Re-render whenever an input file changes | off |
+| `-h, --help` | Show help | |
+
+## Supported inputs
+
+- **Markdown:** `.md`, `.markdown`, `.mdown`, `.mkd`
+- **Plain text:** anything else is rendered verbatim in monospace.
+
+## Examples
+
+A ready-to-try sample lives in [`examples/`](examples/):
+
+```bash
+printr examples/sample.md -d examples/out/
+```
+
+## Contributing
+
+```bash
+git clone https://github.com/pablo-clueless/printr.git
+cd printr
+npm install        # installs deps and downloads Chromium
+npm run dev -- examples/sample.md   # run from source without building
+npm run build      # compile TypeScript to dist/
+```
+
+Issues and pull requests are welcome. See [CHANGELOG.md](CHANGELOG.md) for the
+release history.
+
+## License
+
+[MIT](LICENSE)

package/dist/cli.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+import { renderFileToPdf } from "./convert.js";
+import { writeFile, mkdir, stat } from "node:fs/promises";
+import puppeteer from "puppeteer";
+import { watch } from "node:fs";
+import { Command } from "commander";
+import path from "node:path";
+import { glob } from "glob";
+const program = new Command();
+program
+    .name("printr")
+    .description("Print Markdown and text files as nicely styled PDFs.")
+    .argument("<inputs...>", "files or globs to convert (.md, .markdown, .txt, …)")
+    .option("-o, --output <file>", "output PDF path (single input only)")
+    .option("-d, --out-dir <dir>", "directory for output PDFs (defaults beside each source)")
+    .option("-f, --format <format>", "paper format: A4, Letter, Legal, …", "A4")
+    .option("-m, --margin <size>", "page margin on all sides, e.g. 20mm or 1in", "20mm")
+    .option("-t, --title <title>", "document title (single input only)")
+    .option("-w, --watch", "watch inputs and re-render on change (Ctrl+C to stop)")
+    .showHelpAfterError()
+    .action(async (inputs, opts) => {
+    try {
+        await run(inputs, opts);
+    }
+    catch (err) {
+        console.error(`printr: ${err.message}`);
+        process.exitCode = 1;
+    }
+});
+async function resolveInputs(inputs) {
+    const resolved = new Set();
+    for (const input of inputs) {
+        // A literal existing path should be used as-is (handles names with glob chars).
+        const isFile = await stat(input).then((s) => s.isFile()).catch(() => false);
+        if (isFile) {
+            resolved.add(path.resolve(input));
+            continue;
+        }
+        const matches = await glob(input, { nodir: true, windowsPathsNoEscape: true });
+        for (const m of matches)
+            resolved.add(path.resolve(m));
+    }
+    return [...resolved].sort();
+}
+function outputPathFor(file, opts) {
+    if (opts.output)
+        return path.resolve(opts.output);
+    const base = path.basename(file, path.extname(file)) + ".pdf";
+    const dir = opts.outDir ? path.resolve(opts.outDir) : path.dirname(file);
+    return path.join(dir, base);
+}
+/** Render a single source file and write its PDF, logging the result. */
+async function renderOne(browser, file, opts, renderOpts) {
+    const out = outputPathFor(file, opts);
+    await mkdir(path.dirname(out), { recursive: true });
+    const pdf = await renderFileToPdf(browser, file, renderOpts);
+    await writeFile(out, pdf);
+    console.log(`${path.relative(process.cwd(), file)} → ${path.relative(process.cwd(), out)}`);
+}
+/**
+ * For a single input pattern, determine which directory to watch and whether
+ * it must be watched recursively. The watch root is the leading portion of the
+ * pattern before the first segment containing glob magic.
+ */
+function watchRootFor(input) {
+    const recursive = input.includes("**");
+    const parts = input.split(/[\\/]/);
+    const base = [];
+    for (const part of parts) {
+        if (/[*?[\]{}!()+@]/.test(part))
+            break;
+        base.push(part);
+    }
+    const basePath = base.length ? base.join(path.sep) : ".";
+    return { dir: path.resolve(basePath), recursive };
+}
+async function run(inputs, opts) {
+    const files = await resolveInputs(inputs);
+    if (files.length === 0) {
+        throw new Error("no matching files found");
+    }
+    if (opts.output && files.length > 1) {
+        throw new Error("--output can only be used with a single input file");
+    }
+    if (opts.title && files.length > 1) {
+        throw new Error("--title can only be used with a single input file");
+    }
+    const renderOpts = {
+        format: opts.format,
+        margin: opts.margin,
+        title: opts.title,
+    };
+    const browser = await puppeteer.launch({
+        headless: true,
+        args: ["--no-sandbox", "--disable-setuid-sandbox"],
+    });
+    // Initial render of everything that currently matches.
+    for (const file of files) {
+        await renderOne(browser, file, opts, renderOpts);
+    }
+    console.log(`Done. Converted ${files.length} file${files.length === 1 ? "" : "s"}.`);
+    if (!opts.watch) {
+        await browser.close();
+        return;
+    }
+    await startWatch(browser, inputs, opts, renderOpts);
+}
+/**
+ * Watch the directories backing each input pattern and re-render a file
+ * whenever it changes. Re-resolving the patterns on each event means newly
+ * created files that match a glob are picked up too. The browser is kept open
+ * for the lifetime of the watch.
+ */
+async function startWatch(browser, inputs, opts, renderOpts) {
+    // Deduplicate watch roots; a recursive root supersedes a non-recursive one
+    // for the same directory.
+    const roots = new Map();
+    for (const input of inputs) {
+        const isFile = await stat(input).then((s) => s.isFile()).catch(() => false);
+        const { dir, recursive } = isFile
+            ? { dir: path.dirname(path.resolve(input)), recursive: false }
+            : watchRootFor(input);
+        roots.set(dir, (roots.get(dir) ?? false) || recursive);
+    }
+    const watchers = [];
+    const debounce = new Map();
+    let rendering = Promise.resolve();
+    const handleChange = (root, filename) => {
+        if (!filename)
+            return;
+        const full = path.resolve(root, filename);
+        const prev = debounce.get(full);
+        if (prev)
+            clearTimeout(prev);
+        debounce.set(full, setTimeout(() => {
+            debounce.delete(full);
+            // Serialize renders so concurrent saves don't open many pages at once.
+            rendering = rendering.then(async () => {
+                const matched = await resolveInputs(inputs);
+                if (!matched.includes(full))
+                    return; // not one of our inputs
+                const exists = await stat(full).then((s) => s.isFile()).catch(() => false);
+                if (!exists)
+                    return; // file was deleted mid-edit
+                try {
+                    await renderOne(browser, full, opts, renderOpts);
+                }
+                catch (err) {
+                    console.error(`printr: failed to render ${filename}: ${err.message}`);
+                }
+            });
+        }, 120));
+    };
+    for (const [dir, recursive] of roots) {
+        try {
+            const w = watch(dir, { recursive }, (_event, filename) => handleChange(dir, filename));
+            watchers.push(w);
+            console.log(`Watching ${path.relative(process.cwd(), dir) || "."}${recursive ? " (recursive)" : ""} …`);
+        }
+        catch (err) {
+            console.error(`printr: cannot watch ${dir}: ${err.message}`);
+        }
+    }
+    console.log("Press Ctrl+C to stop.");
+    // Keep the process alive until interrupted, then clean up.
+    await new Promise((resolve) => {
+        const shutdown = () => {
+            for (const w of watchers)
+                w.close();
+            browser.close().finally(() => resolve());
+        };
+        process.once("SIGINT", shutdown);
+        process.once("SIGTERM", shutdown);
+    });
+    console.log("\nStopped.");
+}
+program.parseAsync();

package/dist/convert.js

@@ -0,0 +1,71 @@
+import { readFile } from "node:fs/promises";
+import MarkdownIt from "markdown-it";
+import hljs from "highlight.js";
+import path from "node:path";
+import { githubMarkdownCss } from "./styles.js";
+const MARKDOWN_EXTS = new Set([".md", ".markdown", ".mdown", ".mkd"]);
+const md = new MarkdownIt({
+    html: true,
+    linkify: true,
+    typographer: true,
+    highlight(code, lang) {
+        if (lang && hljs.getLanguage(lang)) {
+            try {
+                return hljs.highlight(code, { language: lang, ignoreIllegals: true })
+                    .value;
+            }
+            catch {
+                /* fall through to auto */
+            }
+        }
+        return hljs.highlightAuto(code).value;
+    },
+});
+function escapeHtml(s) {
+    return s
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+/** Build the full self-contained HTML document for a source file. */
+export function buildHtml(source, filePath, options = {}) {
+    const ext = path.extname(filePath).toLowerCase();
+    const isMarkdown = MARKDOWN_EXTS.has(ext);
+    const title = options.title ?? path.basename(filePath);
+    const bodyHtml = isMarkdown
+        ? md.render(source)
+        : // Plain text: preserve it verbatim inside a code block.
+            `<pre class="plain-text">${escapeHtml(source)}</pre>`;
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>${escapeHtml(title)}</title>
+<style>${githubMarkdownCss}
+.plain-text { background: transparent; padding: 0; font-size: 0.9em; }
+${options.extraCss ?? ""}</style>
+</head>
+<body><article class="markdown-body">${bodyHtml}</article></body>
+</html>`;
+}
+/**
+ * Render a single source file to a PDF buffer using an already-launched
+ * browser. Reusing the browser across files keeps batch conversion fast.
+ */
+export async function renderFileToPdf(browser, filePath, options = {}) {
+    const source = await readFile(filePath, "utf8");
+    const html = buildHtml(source, filePath, options);
+    const page = await browser.newPage();
+    try {
+        await page.setContent(html, { waitUntil: "load" });
+        const margin = options.margin ?? "20mm";
+        return await page.pdf({
+            format: (options.format ?? "A4"),
+            printBackground: true,
+            margin: { top: margin, bottom: margin, left: margin, right: margin },
+        });
+    }
+    finally {
+        await page.close();
+    }
+}

package/dist/styles.js

@@ -0,0 +1,124 @@
+/**
+ * GitHub-flavored Markdown stylesheet plus a highlight.js theme, scoped for
+ * print. Kept inline so the produced HTML is fully self-contained and Chrome
+ * never has to fetch external resources while rendering the PDF.
+ */
+export const githubMarkdownCss = `
+:root {
+  --fg: #1f2328;
+  --muted: #59636e;
+  --border: #d1d9e0;
+  --border-muted: #d1d9e0b3;
+  --accent: #0969da;
+  --code-bg: #f6f8fa;
+  --code-fg: #1f2328;
+}
+
+* { box-sizing: border-box; }
+
+body {
+  color: var(--fg);
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Noto Sans",
+    Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+  font-size: 11pt;
+  line-height: 1.55;
+  word-wrap: break-word;
+  margin: 0;
+}
+
+.markdown-body > *:first-child { margin-top: 0 !important; }
+.markdown-body > *:last-child { margin-bottom: 0 !important; }
+
+h1, h2, h3, h4, h5, h6 {
+  margin-top: 1.4em;
+  margin-bottom: 0.6em;
+  font-weight: 600;
+  line-height: 1.25;
+}
+h1 { font-size: 1.9em; padding-bottom: 0.3em; border-bottom: 1px solid var(--border-muted); }
+h2 { font-size: 1.45em; padding-bottom: 0.3em; border-bottom: 1px solid var(--border-muted); }
+h3 { font-size: 1.2em; }
+h4 { font-size: 1em; }
+h5 { font-size: 0.9em; }
+h6 { font-size: 0.85em; color: var(--muted); }
+
+p, blockquote, ul, ol, dl, table, pre { margin-top: 0; margin-bottom: 1em; }
+
+a { color: var(--accent); text-decoration: none; }
+a:hover { text-decoration: underline; }
+
+blockquote {
+  padding: 0 1em;
+  color: var(--muted);
+  border-left: 0.25em solid var(--border);
+  margin-left: 0;
+}
+
+ul, ol { padding-left: 2em; }
+li + li { margin-top: 0.25em; }
+li > p { margin-top: 0.5em; }
+
+code, kbd, pre, samp {
+  font-family: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas,
+    "Liberation Mono", monospace;
+}
+
+code {
+  font-size: 0.88em;
+  background: var(--code-bg);
+  padding: 0.2em 0.4em;
+  border-radius: 6px;
+}
+
+pre {
+  padding: 1em;
+  overflow: auto;
+  font-size: 0.85em;
+  line-height: 1.45;
+  background: var(--code-bg);
+  border-radius: 6px;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+pre code {
+  background: transparent;
+  padding: 0;
+  font-size: inherit;
+  border-radius: 0;
+}
+
+table {
+  border-collapse: collapse;
+  display: block;
+  width: max-content;
+  max-width: 100%;
+  overflow: auto;
+}
+table th, table td { padding: 6px 13px; border: 1px solid var(--border); }
+table th { font-weight: 600; }
+table tr:nth-child(2n) { background: var(--code-bg); }
+
+img { max-width: 100%; }
+
+hr {
+  height: 1px;
+  border: 0;
+  background: var(--border);
+  margin: 1.6em 0;
+}
+
+/* Page-break behavior for print */
+h1, h2, h3, h4, h5, h6 { break-after: avoid-page; }
+pre, blockquote, table, img { break-inside: avoid; }
+
+/* highlight.js — GitHub light theme */
+.hljs { color: var(--code-fg); background: var(--code-bg); }
+.hljs-comment, .hljs-quote { color: #6a737d; }
+.hljs-keyword, .hljs-selector-tag, .hljs-doctag, .hljs-type, .hljs-name, .hljs-strong { color: #d73a49; }
+.hljs-literal, .hljs-number, .hljs-variable, .hljs-template-variable, .hljs-tag .hljs-attr { color: #005cc5; }
+.hljs-string, .hljs-regexp, .hljs-addition, .hljs-attribute, .hljs-meta .hljs-string { color: #032f62; }
+.hljs-title, .hljs-section, .hljs-built_in, .hljs-title.class_, .hljs-title.function_ { color: #6f42c1; }
+.hljs-attr, .hljs-attribute, .hljs-symbol, .hljs-bullet, .hljs-link { color: #e36209; }
+.hljs-emphasis { font-style: italic; }
+.hljs-strong { font-weight: 600; }
+`;

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@pablo_clueless/printr",
+  "version": "0.1.2",
+  "description": "Print Markdown and text files as nicely styled PDFs.",
+  "type": "module",
+  "license": "MIT",
+  "author": "smsnmicheal <smsnmicheal@gmail.com>",
+  "homepage": "https://github.com/pablo-clueless/printr#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pablo-clueless/printr.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pablo-clueless/printr/issues"
+  },
+  "keywords": [
+    "markdown",
+    "pdf",
+    "cli",
+    "puppeteer",
+    "markdown-to-pdf",
+    "print",
+    "highlight.js",
+    "github-markdown"
+  ],
+  "bin": {
+    "printr": "dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "start": "node dist/cli.js",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "glob": "^11.0.0",
+    "highlight.js": "^11.10.0",
+    "markdown-it": "^14.1.0",
+    "puppeteer": "^24.15.0"
+  },
+  "devDependencies": {
+    "@types/markdown-it": "^14.1.2",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  }
+}