1import fs from "node:fs";
2import os from "node:os";
3import path from "node:path";
4import process from "node:process";
5 
6import {
7  COLOR_PRESETS,
8  FONT_FAMILY_MAP,
9  FONT_SIZE_OPTIONS,
10  THEME_NAMES,
11  extractSummaryFromBody,
12  extractTitleFromMarkdown,
13  formatTimestamp,
14  parseArgs,
15  parseFrontmatter,
16  preprocessMermaidInMarkdown,
17  renderMarkdownDocument,
18  replaceMarkdownImagesWithPlaceholders,
19  resolveContentImages,
20  serializeFrontmatter,
21  stripWrappingQuotes,
22} from "baoyu-md";
23import type { CliOptions } from "baoyu-md";
24import { closeRenderer, renderMermaidToPng } from "baoyu-chrome-cdp/mermaid";
25 
26interface ImageInfo {
27  placeholder: string;
28  localPath: string;
29  originalPath: string;
30  alt?: string;
31}
32 
33interface MermaidImageInfo {
34  hash: string;
35  localPath: string;
36  cached: boolean;
37}
38 
39interface ParsedResult {
40  title: string;
41  author: string;
42  summary: string;
43  htmlPath: string;
44  backupPath?: string;
45  contentImages: ImageInfo[];
46  mermaidImages: MermaidImageInfo[];
47}
48 
49interface MermaidCliOptions {
50  enabled?: boolean;
51  theme?: string;
52  scale?: number;
53  background?: string;
54  minWidth?: number;
55}
56 
57type ConvertMarkdownOptions = Partial<Omit<CliOptions, "inputPath">> & {
58  title?: string;
59  mermaid?: MermaidCliOptions;
60};
61 
62function escapeHtmlAttribute(value: string): string {
63  return value
64    .replace(/&/g, "&amp;")
65    .replace(/"/g, "&quot;")
66    .replace(/</g, "&lt;")
67    .replace(/>/g, "&gt;");
68}
69 
70export async function convertMarkdown(
71  markdownPath: string,
72  options?: ConvertMarkdownOptions,
73): Promise<ParsedResult> {
74  const baseDir = path.dirname(markdownPath);
75  const content = fs.readFileSync(markdownPath, "utf-8");
76  const theme = options?.theme;
77  const keepTitle = options?.keepTitle ?? false;
78  const citeStatus = options?.citeStatus ?? false;
79 
80  const { frontmatter, body } = parseFrontmatter(content);
81 
82  let title = stripWrappingQuotes(options?.title ?? "")
83    || stripWrappingQuotes(frontmatter.title ?? "")
84    || extractTitleFromMarkdown(body);
85  if (!title) {
86    title = path.basename(markdownPath, path.extname(markdownPath));
87  }
88 
89  const author = stripWrappingQuotes(frontmatter.author ?? "");
90  let summary = stripWrappingQuotes(frontmatter.description ?? "")
91    || stripWrappingQuotes(frontmatter.summary ?? "");
92  if (!summary) {
93    summary = extractSummaryFromBody(body, 120);
94  }
95 
96  const effectiveFrontmatter = options?.title
97    ? { ...frontmatter, title }
98    : frontmatter;
99 
100  const mermaidEnabled = options?.mermaid?.enabled !== false;
101  const mermaidMinWidth = options?.mermaid?.minWidth ?? 860;
102  const { markdown: mermaidProcessedBody, images: mermaidImages } =
103    await preprocessMermaidInMarkdown(body, {
104      baseDir,
105      renderFn: renderMermaidToPng,
106      enabled: mermaidEnabled,
107      theme: options?.mermaid?.theme,
108      scale: options?.mermaid?.scale,
109      background: options?.mermaid?.background,
110      minWidth: mermaidMinWidth,
111      onError: (error, block) => {
112        const message = error instanceof Error ? error.message : String(error);
113        console.error(
114          `[markdown-to-html] mermaid render failed (${block.code.slice(0, 40).replace(/\s+/g, " ")}…): ${message}`,
115        );
116      },
117    });
118 
119  if (mermaidImages.length > 0) {
120    const fresh = mermaidImages.filter((image) => !image.cached).length;
121    console.error(
122      `[markdown-to-html] mermaid: ${mermaidImages.length} block(s), ${fresh} rendered, ${mermaidImages.length - fresh} cached`,
123    );
124  }
125 
126  const { images, markdown: rewrittenBody } = replaceMarkdownImagesWithPlaceholders(
127    mermaidProcessedBody,
128    "MDTOHTMLIMGPH_",
129  );
130  const rewrittenMarkdown = `${serializeFrontmatter(effectiveFrontmatter)}${rewrittenBody}`;
131 
132  console.error(
133    `[markdown-to-html] Rendering with theme: ${theme ?? "default"}, keepTitle: ${keepTitle}, citeStatus: ${citeStatus}`,
134  );
135 
136  const { html } = await renderMarkdownDocument(rewrittenMarkdown, {
137    codeTheme: options?.codeTheme,
138    countStatus: options?.countStatus,
139    citeStatus,
140    defaultTitle: title,
141    fontFamily: options?.fontFamily,
142    fontSize: options?.fontSize,
143    isMacCodeBlock: options?.isMacCodeBlock,
144    isShowLineNumber: options?.isShowLineNumber,
145    keepTitle,
146    legend: options?.legend,
147    primaryColor: options?.primaryColor,
148    theme,
149  });
150 
151  const finalHtmlPath = markdownPath.replace(/\.md$/i, ".html");
152  let backupPath: string | undefined;
153 
154  if (fs.existsSync(finalHtmlPath)) {
155    backupPath = `${finalHtmlPath}.bak-${formatTimestamp()}`;
156    console.error(`[markdown-to-html] Backing up existing file to: ${backupPath}`);
157    fs.renameSync(finalHtmlPath, backupPath);
158  }
159 
160  fs.writeFileSync(finalHtmlPath, html, "utf-8");
161 
162  const hasRemoteImages = images.some((image) =>
163    image.originalPath.startsWith("http://") || image.originalPath.startsWith("https://"),
164  );
165  const tempDir = hasRemoteImages
166    ? fs.mkdtempSync(path.join(os.tmpdir(), "markdown-to-html-"))
167    : baseDir;
168  const contentImages = await resolveContentImages(images, baseDir, tempDir, "markdown-to-html");
169 
170  let finalContent = fs.readFileSync(finalHtmlPath, "utf-8");
171  for (const image of contentImages) {
172    const altAttr = image.alt !== undefined
173      ? ` alt="${escapeHtmlAttribute(image.alt)}"`
174      : "";
175    const imgTag = `<img src="${escapeHtmlAttribute(image.originalPath)}" `
176      + `data-local-path="${escapeHtmlAttribute(image.localPath)}"${altAttr} `
177      + `style="display: block; width: 100%; margin: 1.5em auto;">`;
178    finalContent = finalContent.replace(image.placeholder, imgTag);
179  }
180  fs.writeFileSync(finalHtmlPath, finalContent, "utf-8");
181 
182  console.error(`[markdown-to-html] HTML saved to: ${finalHtmlPath}`);
183 
184  return {
185    title,
186    author,
187    summary,
188    htmlPath: finalHtmlPath,
189    backupPath,
190    contentImages,
191    mermaidImages: mermaidImages.map((image) => ({
192      hash: image.hash,
193      localPath: image.localPath,
194      cached: image.cached,
195    })),
196  };
197}
198 
199function printUsage(exitCode = 0): never {
200  const colorNames = Object.keys(COLOR_PRESETS).join(", ");
201  const fontFamilyNames = Object.keys(FONT_FAMILY_MAP).join(", ");
202 
203  console.log(`Convert Markdown to styled HTML
204 
205Usage:
206  npx -y bun main.ts <markdown_file> [options]
207 
208Options:
209  --title <title>         Override title
210  --theme <name>          Theme name (${THEME_NAMES.join(", ")}). Default: default
211  --color <name|hex>      Primary color: ${colorNames}
212  --font-family <name>    Font: ${fontFamilyNames}, or CSS value
213  --font-size <N>         Font size: ${FONT_SIZE_OPTIONS.join(", ")} (default: 16px)
214  --code-theme <name>     Code highlight theme (default: github)
215  --mac-code-block        Show Mac-style code block header
216  --no-mac-code-block     Hide Mac-style code block header
217  --line-number           Show line numbers in code blocks
218  --cite                  Convert ordinary external links to bottom citations. Default: off
219  --count                 Show reading time / word count
220  --legend <value>        Image caption: title-alt, alt-title, title, alt, none
221  --keep-title            Keep the first heading in content. Default: false (removed)
222  --mermaid-theme <name>  Mermaid theme: default, forest, dark, neutral. Default: default
223  --mermaid-scale <N>     Mermaid render scale: 1, 1.5, 2, 3. Default: 2
224  --mermaid-width <N>     Mermaid target display width in CSS px. Default: 860
225  --mermaid-bg <value>    Mermaid background: white, transparent, or #hex. Default: white
226  --no-mermaid            Skip Mermaid rendering; emit <pre class="mermaid"> fallback
227  --help                  Show this help
228 
229Output:
230  HTML file saved to same directory as input markdown file.
231  Example: article.md -> article.html
232 
233  If HTML file already exists, it will be backed up first:
234  article.html -> article.html.bak-YYYYMMDDHHMMSS
235 
236Output JSON format:
237{
238  "title": "Article Title",
239  "htmlPath": "/path/to/article.html",
240  "backupPath": "/path/to/article.html.bak-20260128180000",
241  "contentImages": [...]
242}
243 
244Example:
245  npx -y bun main.ts article.md
246  npx -y bun main.ts article.md --theme grace
247  npx -y bun main.ts article.md --theme modern --color red
248  npx -y bun main.ts article.md --cite
249`);
250  process.exit(exitCode);
251}
252 
253function parseArgValue(argv: string[], i: number, flag: string): string | null {
254  const arg = argv[i]!;
255  if (arg.includes("=")) {
256    return arg.slice(flag.length + 1);
257  }
258  const next = argv[i + 1];
259  return next ?? null;
260}
261 
262function extractTitleArg(argv: string[]): { renderArgs: string[]; title?: string } {
263  let title: string | undefined;
264  const renderArgs: string[] = [];
265 
266  for (let i = 0; i < argv.length; i += 1) {
267    const arg = argv[i]!;
268    if (arg === "--title" || arg.startsWith("--title=")) {
269      const value = parseArgValue(argv, i, "--title");
270      if (!value) {
271        console.error("Missing value for --title");
272        printUsage(1);
273      }
274      title = value;
275      if (!arg.includes("=")) {
276        i += 1;
277      }
278      continue;
279    }
280    renderArgs.push(arg);
281  }
282 
283  return { renderArgs, title };
284}
285 
286const VALID_MERMAID_THEMES = new Set(["default", "forest", "dark", "neutral", "base"]);
287 
288function extractMermaidArgs(argv: string[]): { renderArgs: string[]; mermaid: MermaidCliOptions } {
289  const mermaid: MermaidCliOptions = {};
290  const renderArgs: string[] = [];
291 
292  for (let i = 0; i < argv.length; i += 1) {
293    const arg = argv[i]!;
294    if (arg === "--no-mermaid") {
295      mermaid.enabled = false;
296      continue;
297    }
298    if (arg === "--mermaid-theme" || arg.startsWith("--mermaid-theme=")) {
299      const value = parseArgValue(argv, i, "--mermaid-theme");
300      if (!value) {
301        console.error("Missing value for --mermaid-theme");
302        printUsage(1);
303      }
304      if (!VALID_MERMAID_THEMES.has(value)) {
305        console.error(`Invalid --mermaid-theme: ${value} (choose one of ${[...VALID_MERMAID_THEMES].join(", ")})`);
306        printUsage(1);
307      }
308      mermaid.theme = value;
309      if (!arg.includes("=")) i += 1;
310      continue;
311    }
312    if (arg === "--mermaid-scale" || arg.startsWith("--mermaid-scale=")) {
313      const value = parseArgValue(argv, i, "--mermaid-scale");
314      const parsed = Number.parseFloat(value ?? "");
315      if (!value || !Number.isFinite(parsed) || parsed <= 0 || parsed > 4) {
316        console.error(`Invalid --mermaid-scale: ${value} (expect a positive number ≤ 4)`);
317        printUsage(1);
318      }
319      mermaid.scale = parsed;
320      if (!arg.includes("=")) i += 1;
321      continue;
322    }
323    if (arg === "--mermaid-width" || arg.startsWith("--mermaid-width=")) {
324      const value = parseArgValue(argv, i, "--mermaid-width");
325      const parsed = Number.parseInt(value ?? "", 10);
326      if (!value || !Number.isFinite(parsed) || parsed <= 0) {
327        console.error(`Invalid --mermaid-width: ${value} (expect a positive integer)`);
328        printUsage(1);
329      }
330      mermaid.minWidth = parsed;
331      if (!arg.includes("=")) i += 1;
332      continue;
333    }
334    if (arg === "--mermaid-bg" || arg.startsWith("--mermaid-bg=")) {
335      const value = parseArgValue(argv, i, "--mermaid-bg");
336      if (!value) {
337        console.error("Missing value for --mermaid-bg");
338        printUsage(1);
339      }
340      mermaid.background = value;
341      if (!arg.includes("=")) i += 1;
342      continue;
343    }
344    renderArgs.push(arg);
345  }
346 
347  return { renderArgs, mermaid };
348}
349 
350async function main(): Promise<void> {
351  const args = process.argv.slice(2);
352  if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
353    printUsage(0);
354  }
355 
356  const { renderArgs: afterTitle, title } = extractTitleArg(args);
357  const { renderArgs, mermaid } = extractMermaidArgs(afterTitle);
358  const options = parseArgs(renderArgs);
359  if (!options) {
360    printUsage(1);
361  }
362 
363  const markdownPath = path.resolve(process.cwd(), options.inputPath);
364  if (!markdownPath.toLowerCase().endsWith(".md")) {
365    console.error("Input file must end with .md");
366    process.exit(1);
367  }
368 
369  if (!fs.existsSync(markdownPath)) {
370    console.error(`Error: File not found: ${markdownPath}`);
371    process.exit(1);
372  }
373 
374  const result = await convertMarkdown(markdownPath, { ...options, title, mermaid });
375  console.log(JSON.stringify(result, null, 2));
376}
377 
378try {
379  await main();
380} catch (error) {
381  console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
382  process.exitCode = 1;
383} finally {
384  await closeRenderer();
385}
386