markdansi 0.1.1 → 0.1.3

package/README.md

@@ -1,4 +1,4 @@
-# 🎨 Markdansi: Wraps, colors, links - no baggage.
+# 🎨 Markdansi: Wraps, colors, links—no baggage.
 ![npm](https://img.shields.io/npm/v/markdansi) ![license MIT](https://img.shields.io/badge/license-MIT-blue.svg) ![node >=22](https://img.shields.io/badge/node-%3E%3D22-brightgreen) ![tests vitest](https://img.shields.io/badge/tests-vitest-blue?logo=vitest)
 
 Tiny, dependency-light Markdown → ANSI renderer and CLI for modern Node (>=22). Focuses on readable terminal output with sensible wrapping, GFM support (tables, task lists, strikethrough), optional OSC‑8 hyperlinks, and zero built‑in syntax highlighting (pluggable hook). Written in TypeScript, ships ESM.
@@ -50,6 +50,39 @@ const custom = createRenderer({
   highlighter: (code, lang) => code.toUpperCase(),
 });
 console.log(custom('`inline`\n\n```\nblock code\n```'));
+
+// Example: real syntax highlighting with Shiki (TS + Swift)
+import { bundledLanguages, bundledThemes, createHighlighter } from 'shiki';
+
+const shiki = await createHighlighter({
+  themes: [bundledThemes['github-dark']],
+  langs: [bundledLanguages.typescript, bundledLanguages.swift],
+});
+
+const highlighted = createRenderer({
+  highlighter: (code, lang) => {
+    if (!lang) return code;
+    const normalized = lang.toLowerCase();
+    if (!['ts', 'typescript', 'swift'].includes(normalized)) return code;
+    const { tokens } = shiki.codeToTokens(code, {
+      lang: normalized === 'swift' ? 'swift' : 'ts',
+      theme: 'github-dark',
+    });
+    return tokens
+      .map((line) =>
+        line
+          .map((token) =>
+            token.color ? `\u001b[38;2;${parseInt(token.color.slice(1, 3), 16)};${parseInt(
+              token.color.slice(3, 5),
+              16,
+            )};${parseInt(token.color.slice(5, 7), 16)}m${token.content}\u001b[39m` : token.content,
+          )
+          .join(''),
+      )
+      .join('\n');
+  },
+});
+console.log(highlighted('```ts\nconst x: number = 1\n```\n```swift\nlet x = 1\n```'));
 ```
 
 ### Options
@@ -69,13 +102,14 @@ console.log(custom('`inline`\n\n```\nblock code\n```'));
 
 ## Status
 
-Version: `0.1.1` (released)  
+Version: `0.1.2` (released)  
 Tests: `pnpm test`  
 License: MIT
 
 ## Notes
 
 - Code blocks wrap to the render width by default; disable with `codeWrap=false`. If `lang` is present, a faint `[lang]` label is shown and boxes use unicode borders.
+- Link/reference definitions that spill their titles onto indented lines are merged back into one line so copied notes don’t turn into boxed code.
 - Tables use unicode borders by default, include padding, respect GFM alignment, and truncate long cells with `…` so layouts stay tidy. Turn off truncation with `tableTruncate=false`.
 - Tight vs loose lists follow GFM; task items render `[ ]` / `[x]`.
 

package/dist/cli.d.ts

@@ -5,6 +5,10 @@ type CliArgs = Partial<RenderOptions> & {
     out?: string;
     help?: boolean;
 };
+/**
+ * Ignore EPIPE when downstream (e.g., `head`) closes early.
+ */
+export declare function handleStdoutEpipe(): void;
 /**
  * Parse CLI arguments into RenderOptions-ish object (plus in/out paths).
  */

package/dist/cli.js

@@ -3,6 +3,20 @@ import fs from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { render } from "./index.js";
+/**
+ * Ignore EPIPE when downstream (e.g., `head`) closes early.
+ */
+export function handleStdoutEpipe() {
+    process.stdout.on("error", (err) => {
+        if (err && err.code === "EPIPE") {
+            process.exit(0);
+            return;
+        }
+        // For other stdout errors, fail fast but don't throw unhandled.
+        console.error(err instanceof Error ? err.message : err);
+        process.exit(1);
+    });
+}
 /**
  * Parse CLI arguments into RenderOptions-ish object (plus in/out paths).
  */
@@ -97,6 +111,7 @@ export function parseArgs(argv) {
  * CLI entrypoint.
  */
 function main() {
+    handleStdoutEpipe();
     const args = parseArgs(process.argv);
     if (args.help) {
         process.stdout.write(`markdansi options:

package/dist/hyperlink.js

@@ -4,8 +4,18 @@ import supportsHyperlinks from "supports-hyperlinks";
  */
 export function hyperlinkSupported(stream = process.stdout) {
     const helper = supportsHyperlinks;
-    if (helper.stdout)
-        return helper.stdout(stream);
+    try {
+        if (typeof supportsHyperlinks === "function") {
+            return Boolean(supportsHyperlinks(stream));
+        }
+        if (helper.stdout)
+            return Boolean(helper.stdout(stream));
+        if (helper.default && typeof helper.default === "function")
+            return Boolean(helper.default(stream));
+    }
+    catch {
+        return false;
+    }
     return false;
 }
 /**

package/dist/render.js

@@ -4,6 +4,18 @@ import { hyperlinkSupported, osc8 } from "./hyperlink.js";
 import { parse } from "./parser.js";
 import { createStyler, themes } from "./theme.js";
 import { visibleWidth, wrapText, wrapWithPrefix } from "./wrap.js";
+function dedent(markdown) {
+    const lines = markdown.split("\n");
+    const indents = lines
+        .filter((l) => l.trim() !== "")
+        .map((l) => l.match(/^[ \t]*/)?.[0].length ?? 0);
+    if (indents.length === 0)
+        return markdown;
+    const minIndent = Math.min(...indents);
+    if (minIndent === 0)
+        return markdown;
+    return lines.map((l) => l.slice(Math.min(minIndent, l.length))).join("\n");
+}
 function resolveOptions(userOptions = {}) {
     const wrap = userOptions.wrap !== undefined ? userOptions.wrap : true;
     const baseWidth = userOptions.width ?? (wrap ? process.stdout.columns || 80 : undefined);
@@ -63,6 +75,158 @@ function resolveOptions(userOptions = {}) {
         resolved.width = baseWidth;
     return resolved;
 }
+/**
+ * Normalize parsed nodes to avoid misclassifying reference-style metadata as code.
+ * Some sources emit footnote-like link definitions where the title is placed
+ * on the following indented lines (often copied with tabs). When GFM parsing
+ * misses the closing quote, those continuations become indented code blocks.
+ * To keep output readable, merge such continuations back into the definition
+ * paragraph and render as regular text.
+ */
+function extractText(node) {
+    if (typeof node.value === "string")
+        return node.value;
+    if (Array.isArray(node.children)) {
+        return node.children.map((child) => extractText(child)).join("");
+    }
+    return "";
+}
+function getParagraphText(node) {
+    return extractText(node);
+}
+function normalizeNodes(tree) {
+    const normalized = [];
+    for (let i = 0; i < tree.children.length; i += 1) {
+        const node = tree.children[i];
+        if (node?.type === "paragraph" && node.children.length >= 1) {
+            const text = getParagraphText(node);
+            const defMatch = text.match(/^\[(\d+|\w+)]:\s+\S.*"\s*$/);
+            const next = tree.children[i + 1];
+            if (defMatch && next?.type === "code" && !next.lang) {
+                const continuation = next.value
+                    .replace(/^[ \t>]+/gm, " ")
+                    .replace(/\s+/g, " ")
+                    .trim();
+                const merged = `${text.replace(/\s+"$/, '"')} ${continuation ? continuation.replace(/^"+|"+$/g, "").trim() : ""}`.trim();
+                normalized.push({
+                    type: "paragraph",
+                    children: [{ type: "text", value: merged }],
+                    position: node.position,
+                });
+                i += 1; // skip the consumed code block
+                continue;
+            }
+        }
+        // As a fallback, rewrite indented code blocks that look like lone definitions.
+        if (node?.type === "code" && !node.lang) {
+            const stripped = node.value.replace(/^[ \t>]+/gm, "").trim();
+            if (/^\[(\d+|\w+)]:\s+\S+/.test(stripped)) {
+                normalized.push({
+                    type: "paragraph",
+                    children: [{ type: "text", value: stripped }],
+                    position: node.position,
+                });
+                continue;
+            }
+        }
+        if (node)
+            normalized.push(node);
+    }
+    const mergedCodes = mergeAdjacentCodeBlocks(normalized);
+    const taggedDiffs = mergedCodes.map((child) => tagDiffBlock(child));
+    return { ...tree, children: taggedDiffs };
+}
+function flattenCodeList(list) {
+    if (!list.children.length ||
+        !list.children.every((item) => item.children.length === 1 &&
+            item.children[0]?.type === "code" &&
+            item.children[0].value !== undefined))
+        return null;
+    const codes = list.children.map((item) => item.children[0]);
+    const sameLang = codes.every((c) => c.lang === codes[0]?.lang);
+    const lang = sameLang ? (codes[0]?.lang ?? undefined) : undefined;
+    return {
+        type: "code",
+        lang: lang ?? undefined,
+        value: codes.map((c) => c.value).join("\n"),
+        position: list.position,
+    };
+}
+function mergeAdjacentCodeBlocks(nodes) {
+    const out = [];
+    let pending = null;
+    const flush = () => {
+        if (pending) {
+            out.push(pending);
+            pending = null;
+        }
+    };
+    for (const node of nodes) {
+        if (node?.type === "code") {
+            if (pending &&
+                (pending.lang === node.lang || (!pending.lang && !node.lang))) {
+                const nextValue = `${pending.value}\n${node.value}`;
+                pending = {
+                    type: "code",
+                    lang: pending.lang,
+                    meta: pending.meta,
+                    value: nextValue,
+                    position: pending.position,
+                };
+            }
+            else {
+                flush();
+                pending = node;
+            }
+            continue;
+        }
+        if (node?.type === "list") {
+            const flattened = flattenCodeList(node);
+            if (flattened) {
+                if (pending &&
+                    (pending.lang === flattened.lang ||
+                        (!pending.lang && !flattened.lang))) {
+                    const nextValue = `${pending.value}\n${flattened.value}`;
+                    pending = {
+                        type: "code",
+                        lang: pending.lang,
+                        meta: pending.meta,
+                        value: nextValue,
+                        position: pending.position,
+                    };
+                }
+                else {
+                    flush();
+                    pending = flattened;
+                }
+                continue;
+            }
+        }
+        flush();
+        out.push(node);
+    }
+    flush();
+    return out;
+}
+function looksLikeDiff(text) {
+    const lines = text.split("\n").map((l) => l.trim());
+    if (lines.some((l) => l.startsWith("diff --git") ||
+        l.startsWith("--- a/") ||
+        l.startsWith("+++ b/") ||
+        l.startsWith("@@ ")))
+        return true;
+    const nonEmpty = lines.filter((l) => l !== "");
+    if (nonEmpty.length < 3)
+        return false;
+    const markers = nonEmpty.filter((l) => /^[+\-@]/.test(l)).length;
+    return markers >= Math.max(3, Math.ceil(nonEmpty.length * 0.6));
+}
+function tagDiffBlock(node) {
+    if (node?.type === "code" && !node.lang && looksLikeDiff(node.value)) {
+        return { ...node, lang: "diff" };
+    }
+    return node;
+}
 const HR_WIDTH = 40;
 const MAX_COL = 40;
 const TABLE_BOX = {
@@ -99,7 +263,7 @@ const TABLE_BOX = {
 export function render(markdown, userOptions = {}) {
     const options = resolveOptions(userOptions);
     const style = createStyler({ color: options.color });
-    const tree = parse(markdown);
+    const tree = normalizeNodes(parse(dedent(markdown)));
     const ctx = { options, style };
     const body = renderChildren(tree.children, ctx, 0, true).join("");
     return options.color ? body : stripAnsi(body);
@@ -112,7 +276,23 @@ export function createRenderer(options) {
 }
 function renderChildren(children, ctx, indentLevel = 0, isTightList = false) {
     const out = [];
-    for (const node of children) {
+    for (let i = 0; i < children.length; i += 1) {
+        const node = children[i];
+        if (!node)
+            continue;
+        // Heuristic: some sources emit a standalone "[lang]" line before a fenced block.
+        if (node.type === "paragraph" &&
+            node.children.length === 1 &&
+            node.children[0]?.type === "text") {
+            const langMatch = node.children[0]?.value.trim().match(/^\[([^\]]+)]$/);
+            const next = children[i + 1];
+            if (langMatch && next && next.type === "code" && !next.lang) {
+                next.lang = langMatch[1];
+                i += 1; // skip label paragraph, render the code next
+                out.push(renderNode(next, ctx, indentLevel, isTightList));
+                continue;
+            }
+        }
         out.push(renderNode(node, ctx, indentLevel, isTightList));
     }
     return out.flat();
@@ -135,6 +315,8 @@ function renderNode(node, ctx, indentLevel, isTightList) {
             return renderCodeBlock(node, ctx);
         case "table":
             return renderTable(node, ctx);
+        case "definition":
+            return renderDefinition(node, ctx);
         default:
             return []; // inline handled elsewhere or intentionally skipped
     }
@@ -142,7 +324,29 @@ function renderNode(node, ctx, indentLevel, isTightList) {
 function renderParagraph(node, ctx, indentLevel) {
     const text = renderInline(node.children, ctx);
     const prefix = " ".repeat(ctx.options.listIndent * indentLevel);
-    const lines = wrapWithPrefix(text, ctx.options.width ?? 80, ctx.options.wrap, prefix);
+    const rawLines = text.split("\n");
+    const normalized = [];
+    const defPattern = /^\[[^\]]+]:\s+\S/;
+    let inDefinitions = false;
+    for (const line of rawLines) {
+        if (defPattern.test(line) &&
+            normalized.length > 0 &&
+            normalized.at(-1) !== "") {
+            normalized.push(""); // insert blank line before footer-style definitions
+        }
+        if (defPattern.test(line)) {
+            inDefinitions = true;
+            normalized.push(line);
+            continue;
+        }
+        if (inDefinitions && line.trim() === "") {
+            // skip extra blank lines inside the definitions block
+            continue;
+        }
+        inDefinitions = false;
+        normalized.push(line);
+    }
+    const lines = normalized.flatMap((l) => wrapWithPrefix(l, ctx.options.width ?? 80, ctx.options.wrap, prefix));
     return lines.map((l) => `${l}\n`);
 }
 function renderHeading(node, ctx) {
@@ -200,14 +404,23 @@ function renderListItem(node, ctx, indentLevel, tight, ordered = false, start =
         lines.push("");
     return lines.map((l) => `${l}\n`);
 }
+function renderDefinition(node, _ctx) {
+    const title = node.title ? ` "${node.title}"` : "";
+    const line = `[${node.identifier}]: ${node.url ?? ""}${title}`;
+    // Insert a leading blank line to visually separate footers from body.
+    return [`\n${line}\n`];
+}
 function renderCodeBlock(node, ctx) {
     const theme = ctx.options.theme.blockCode || ctx.options.theme.inlineCode;
     const lines = (node.value ?? "").split("\n");
+    const isDiff = node.lang === "diff";
     const gutterWidth = ctx.options.codeGutter
         ? String(lines.length).length + 2
         : 0;
-    const boxPadding = ctx.options.codeBox ? 4 : 0;
-    const wrapLimit = ctx.options.codeWrap && ctx.options.wrap && ctx.options.width
+    const shouldWrap = isDiff ? false : ctx.options.codeWrap;
+    const useBox = ctx.options.codeBox && lines.length > 1;
+    const boxPadding = useBox ? 4 : 0;
+    const wrapLimit = shouldWrap && ctx.options.wrap && ctx.options.width
         ? Math.max(1, ctx.options.width - boxPadding - gutterWidth)
         : undefined; // undefined => no hard wrap limit
     const contentLines = lines.flatMap((line, idx) => {
@@ -223,7 +436,7 @@ function renderCodeBlock(node, ctx) {
             return `${ctx.style(num, { dim: true })} ${highlighted}`;
         });
     });
-    if (!ctx.options.codeBox) {
+    if (!useBox) {
         return [`${contentLines.join("\n")}\n\n`];
     }
     // Boxed block
@@ -232,15 +445,18 @@ function renderCodeBlock(node, ctx) {
     const wrapTarget = ctx.options.codeWrap && ctx.options.width
         ? Math.min(maxLine, Math.max(1, ctx.options.width - 4))
         : maxLine;
-    const innerWidth = Math.max(ctx.options.codeWrap ? wrapTarget : maxLine, minInner);
-    const topLang = node.lang
-        ? `${ctx.style(`[${node.lang}]`, { dim: true })} `
-        : "";
-    const h = "─".repeat(Math.max(innerWidth, topLang.length));
-    const top = `┌ ${topLang}${h.slice(topLang.length)}┐`;
-    const bottom = `└${"─".repeat(h.length + 1)}┘`;
+    const labelRaw = node.lang ? `[${node.lang}]` : "";
+    const labelStyled = labelRaw ? ctx.style(labelRaw, { dim: true }) : "";
+    const innerWidth = Math.max(ctx.options.codeWrap ? wrapTarget : maxLine, minInner, labelRaw.length);
+    const topPadding = Math.max(0, innerWidth - labelRaw.length + 1);
+    const topRaw = labelRaw.length > 0
+        ? `┌ ${labelStyled}${"─".repeat(topPadding)}┐`
+        : `┌ ${"─".repeat(innerWidth)} ┐`;
+    const bottomRaw = `└${"─".repeat(innerWidth + 2)}┘`;
+    const top = ctx.style(topRaw, { dim: true });
+    const bottom = ctx.style(bottomRaw, { dim: true });
     const boxLines = contentLines.map((ln) => {
-        const pad = Math.max(0, h.length - visibleWidth(ln));
+        const pad = Math.max(0, innerWidth - visibleWidth(ln));
         const left = ctx.style("│ ", { dim: true });
         const right = ctx.style(" │", { dim: true });
         return `${left}${ln}${" ".repeat(pad)}${right}`;
@@ -285,6 +501,10 @@ function renderInline(children, ctx) {
 function renderLink(node, ctx) {
     const label = renderInline(node.children, ctx) || node.url;
     const url = node.url || "";
+    if (url.startsWith("mailto:")) {
+        // Treat mailto autolinks as plain text to avoid unwanted styling in tables.
+        return label;
+    }
     if (ctx.options.hyperlinks && url) {
         return osc8(url, label);
     }

package/docs/spec.md

@@ -1,4 +1,4 @@
-# Markdansi v0.1.1 – Design Spec
+# Markdansi v0.1.2 – Design Spec
 
 Goal: Tiny, dependency‑light Markdown → ANSI renderer & CLI for Node ≥22, using pnpm. Output is terminal ANSI only (no HTML). Focus on readable defaults, sensible wrapping, and minimal runtime deps.
 
@@ -94,3 +94,4 @@ Each theme entry holds simple SGR intents (bold/italic/fg color names). `inlineC
 - Lists: honor GFM tight vs loose lists (tight => no blank line between items; loose => blank line). Nesting indent = 2 spaces per level; bullets use `-`; ordered lists use input numbering.
 - Blockquotes: prefix each wrapped line with `│ ` (configurable via `quotePrefix`); quote content wraps accounting for the prefix width.
 - List indent is configurable via `listIndent` (default 2 spaces per level).
+- Reference-style definitions with indented title continuations are merged into a single paragraph (instead of becoming indented code blocks), preventing stray boxed output in copied logs.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "markdansi",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Tiny dependency-light markdown to ANSI converter.",
   "type": "module",
   "main": "dist/index.js",
@@ -58,6 +58,7 @@
     "@types/mdast": "^4.0.4",
     "@types/node": "^24.10.1",
     "@vitest/coverage-v8": "^4.0.9",
+    "tsx": "^4.20.6",
     "typescript": "^5.9.3",
     "vitest": "^4.0.9"
   },
@@ -68,6 +69,7 @@
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "types": "tsc -p tsconfig.json --emitDeclarationOnly",
-    "compile": "tsc -p tsconfig.json"
+    "compile": "tsc -p tsconfig.json",
+    "markdansi": "tsx src/cli.ts"
   }
 }