1import fs from 'node:fs';
2import { mkdir, writeFile } from 'node:fs/promises';
3import os from 'node:os';
4import path from 'node:path';
5import process from 'node:process';
6import { pathToFileURL } from 'node:url';
7 
8import frontMatter from 'front-matter';
9import hljs from 'highlight.js/lib/common';
10import { Lexer, Marked, type RendererObject, type Tokens } from 'marked';
11import { unified } from 'unified';
12import remarkCjkFriendly from 'remark-cjk-friendly';
13import remarkParse from 'remark-parse';
14import remarkStringify from 'remark-stringify';
15 
16import {
17  preprocessMermaidInMarkdown,
18  replaceMarkdownImagesWithPlaceholders,
19  resolveImagePath,
20} from 'baoyu-md';
21import { closeRenderer, renderMermaidToPng } from 'baoyu-chrome-cdp/mermaid';
22 
23interface ImageInfo {
24  placeholder: string;
25  localPath: string;
26  originalPath: string;
27  blockIndex: number;
28  alt?: string;
29}
30 
31interface ParsedMarkdown {
32  title: string;
33  coverImage: string | null;
34  contentImages: ImageInfo[];
35  html: string;
36  totalBlocks: number;
37}
38 
39type FrontmatterFields = Record<string, unknown>;
40 
41function parseFrontmatter(content: string): { frontmatter: FrontmatterFields; body: string } {
42  try {
43    const parsed = frontMatter<FrontmatterFields>(content);
44    return {
45      frontmatter: parsed.attributes ?? {},
46      body: parsed.body,
47    };
48  } catch {
49    return { frontmatter: {}, body: content };
50  }
51}
52 
53function stripWrappingQuotes(value: string): string {
54  if (!value) return value;
55  const doubleQuoted = value.startsWith('"') && value.endsWith('"');
56  const singleQuoted = value.startsWith("'") && value.endsWith("'");
57  const cjkDoubleQuoted = value.startsWith('\u201c') && value.endsWith('\u201d');
58  const cjkSingleQuoted = value.startsWith('\u2018') && value.endsWith('\u2019');
59  if (doubleQuoted || singleQuoted || cjkDoubleQuoted || cjkSingleQuoted) {
60    return value.slice(1, -1).trim();
61  }
62  return value.trim();
63}
64 
65function toFrontmatterString(value: unknown): string | undefined {
66  if (typeof value === 'string') {
67    return stripWrappingQuotes(value);
68  }
69  if (typeof value === 'number' || typeof value === 'boolean') {
70    return String(value);
71  }
72  return undefined;
73}
74 
75function pickFirstString(frontmatter: FrontmatterFields, keys: string[]): string | undefined {
76  for (const key of keys) {
77    const value = toFrontmatterString(frontmatter[key]);
78    if (value) return value;
79  }
80  return undefined;
81}
82 
83function findCoverImageNearMarkdown(baseDir: string): string | null {
84  const candidateDirs = [baseDir, path.join(baseDir, 'imgs')];
85  const coverPattern = /^cover\.(png|jpe?g|webp)$/i;
86 
87  for (const dir of candidateDirs) {
88    try {
89      if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
90        continue;
91      }
92 
93      const match = fs.readdirSync(dir).find((entry) => coverPattern.test(entry));
94      if (match) {
95        return path.join(dir, match);
96      }
97    } catch {
98      continue;
99    }
100  }
101 
102  return null;
103}
104 
105function extractTitleFromMarkdown(markdown: string): string {
106  const tokens = Lexer.lex(markdown, { gfm: true, breaks: true });
107  for (const token of tokens) {
108    if (token.type === 'heading' && token.depth === 1) {
109      return stripWrappingQuotes(token.text);
110    }
111  }
112  return '';
113}
114 
115function escapeHtml(text: string): string {
116  return text
117    .replace(/&/g, '&amp;')
118    .replace(/</g, '&lt;')
119    .replace(/>/g, '&gt;')
120    .replace(/"/g, '&quot;')
121    .replace(/'/g, '&#39;');
122}
123 
124function escapeRegExp(value: string): string {
125  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
126}
127 
128function highlightCode(code: string, lang: string): string {
129  try {
130    if (lang && hljs.getLanguage(lang)) {
131      return hljs.highlight(code, { language: lang, ignoreIllegals: true }).value;
132    }
133    return hljs.highlightAuto(code).value;
134  } catch {
135    return escapeHtml(code);
136  }
137}
138 
139function preprocessCjkMarkdown(markdown: string): string {
140  try {
141    const processor = unified()
142      .use(remarkParse)
143      .use(remarkCjkFriendly)
144      .use(remarkStringify);
145 
146    const result = String(processor.processSync(markdown));
147    return result.replace(/&#x([0-9A-Fa-f]+);/g, (_, hex: string) => String.fromCodePoint(parseInt(hex, 16)));
148  } catch {
149    return markdown;
150  }
151}
152 
153function convertMarkdownToHtml(markdown: string): { html: string; totalBlocks: number } {
154  const preprocessedMarkdown = preprocessCjkMarkdown(markdown);
155  const blockTokens = Lexer.lex(preprocessedMarkdown, { gfm: true, breaks: true });
156 
157  const renderer: RendererObject = {
158    heading({ depth, tokens }: Tokens.Heading): string {
159      if (depth === 1) {
160        return '';
161      }
162      return `<h2>${this.parser.parseInline(tokens)}</h2>`;
163    },
164 
165    paragraph({ tokens }: Tokens.Paragraph): string {
166      const text = this.parser.parseInline(tokens).trim();
167      if (!text) return '';
168      return `<p>${text}</p>`;
169    },
170 
171    blockquote({ tokens }: Tokens.Blockquote): string {
172      return `<blockquote>${this.parser.parse(tokens)}</blockquote>`;
173    },
174 
175    code({ text, lang = '' }: Tokens.Code): string {
176      const language = lang.split(/\s+/)[0]!.toLowerCase();
177      const source = text.replace(/\n$/, '');
178      const highlighted = highlightCode(source, language).replace(/\n/g, '<br>');
179      const label = language ? `<strong>[${escapeHtml(language)}]</strong><br>` : '';
180      return `<blockquote>${label}${highlighted}</blockquote>`;
181    },
182 
183    image({ href, text }: Tokens.Image): string {
184      if (!href) return '';
185      return escapeHtml(text ?? '');
186    },
187 
188    link({ href, title, tokens, text }: Tokens.Link): string {
189      const label = tokens?.length ? this.parser.parseInline(tokens) : escapeHtml(text || href || '');
190      if (!href) return label;
191 
192      const titleAttr = title ? ` title="${escapeHtml(title)}"` : '';
193      return `<a href="${escapeHtml(href)}"${titleAttr} rel="noopener noreferrer nofollow">${label}</a>`;
194    },
195  };
196 
197  const parser = new Marked({
198    gfm: true,
199    breaks: true,
200  });
201  parser.use({ renderer });
202 
203  const rendered = parser.parse(preprocessedMarkdown);
204  if (typeof rendered !== 'string') {
205    throw new Error('Unexpected async markdown parse result');
206  }
207 
208  const totalBlocks = blockTokens.filter((token) => {
209    if (token.type === 'space') return false;
210    if (token.type === 'heading' && token.depth === 1) return false;
211    return true;
212  }).length;
213 
214  return {
215    html: rendered,
216    totalBlocks,
217  };
218}
219 
220export async function parseMarkdown(
221  markdownPath: string,
222  options?: { coverImage?: string; title?: string; tempDir?: string },
223): Promise<ParsedMarkdown> {
224  const content = fs.readFileSync(markdownPath, 'utf-8');
225  const baseDir = path.dirname(markdownPath);
226  const tempDir = options?.tempDir ?? path.join(os.tmpdir(), 'x-article-images');
227 
228  await mkdir(tempDir, { recursive: true });
229 
230  const { frontmatter, body } = parseFrontmatter(content);
231 
232  let title = stripWrappingQuotes(options?.title ?? '') || pickFirstString(frontmatter, ['title']) || '';
233  if (!title) {
234    title = extractTitleFromMarkdown(body);
235  }
236  if (!title) {
237    title = path.basename(markdownPath, path.extname(markdownPath));
238  }
239 
240  let coverImagePath = stripWrappingQuotes(options?.coverImage ?? '') || pickFirstString(frontmatter, [
241    'cover_image',
242    'coverImage',
243    'cover',
244    'image',
245    'featureImage',
246    'feature_image',
247  ]) || null;
248  if (!coverImagePath) {
249    coverImagePath = findCoverImageNearMarkdown(baseDir);
250  }
251 
252  const { markdown: mermaidProcessedBody, images: mermaidImages } =
253    await preprocessMermaidInMarkdown(body, {
254      baseDir,
255      renderFn: renderMermaidToPng,
256      onError: (error, block) => {
257        const message = error instanceof Error ? error.message : String(error);
258        console.error(
259          `[md-to-html] mermaid render failed (${block.code.slice(0, 40).replace(/\s+/g, ' ')}…): ${message}`,
260        );
261      },
262    });
263 
264  if (mermaidImages.length > 0) {
265    const fresh = mermaidImages.filter((image) => !image.cached).length;
266    console.error(
267      `[md-to-html] mermaid: ${mermaidImages.length} block(s), ${fresh} rendered, ${mermaidImages.length - fresh} cached`,
268    );
269  }
270 
271  const { images, markdown: rewrittenBody } = replaceMarkdownImagesWithPlaceholders(
272    mermaidProcessedBody,
273    'XIMGPH_',
274  );
275  const { html, totalBlocks } = convertMarkdownToHtml(rewrittenBody);
276 
277  const htmlLines = html.split('\n');
278  const imageBlockIndexes = new Map<string, number>();
279  for (let i = 0; i < images.length; i++) {
280    const placeholder = images[i]!.placeholder;
281    for (let lineIndex = 0; lineIndex < htmlLines.length; lineIndex++) {
282      const regex = new RegExp(`\\b${escapeRegExp(placeholder)}\\b`);
283      if (regex.test(htmlLines[lineIndex]!)) {
284        imageBlockIndexes.set(placeholder, lineIndex);
285        break;
286      }
287    }
288  }
289 
290  const contentImages: ImageInfo[] = [];
291  let firstImageAsCover: string | null = null;
292 
293  for (let i = 0; i < images.length; i++) {
294    const img = images[i]!;
295    const localPath = await resolveImagePath(img.originalPath, baseDir, tempDir, 'md-to-html');
296 
297    if (i === 0 && !coverImagePath) {
298      firstImageAsCover = localPath;
299    }
300 
301    contentImages.push({
302      placeholder: img.placeholder,
303      localPath,
304      originalPath: img.originalPath,
305      alt: img.alt,
306      blockIndex: imageBlockIndexes.get(img.placeholder) ?? -1,
307    });
308  }
309 
310  const finalHtml = html.replace(/\n{3,}/g, '\n\n').trim();
311 
312  let resolvedCoverImage: string | null = null;
313  if (coverImagePath) {
314    resolvedCoverImage = await resolveImagePath(coverImagePath, baseDir, tempDir, 'md-to-html');
315  } else if (firstImageAsCover) {
316    resolvedCoverImage = firstImageAsCover;
317  }
318 
319  return {
320    title,
321    coverImage: resolvedCoverImage,
322    contentImages,
323    html: finalHtml,
324    totalBlocks,
325  };
326}
327 
328function printUsage(): never {
329  console.log(`Convert Markdown to HTML for X Article publishing
330 
331Usage:
332  npx -y bun md-to-html.ts <markdown_file> [options]
333 
334Options:
335  --title <title>       Override title from frontmatter
336  --cover <image>       Override cover image from frontmatter
337  --output <json|html>  Output format (default: json)
338  --html-only           Output only the HTML content
339  --save-html <path>    Save HTML to file
340 
341Frontmatter fields:
342  title: Article title (or use first H1)
343  cover_image: Cover image path or URL
344  cover: Alias for cover_image
345  image: Alias for cover_image
346 
347Example:
348  npx -y bun md-to-html.ts article.md --output json
349  npx -y bun md-to-html.ts article.md --html-only > /tmp/article.html
350  npx -y bun md-to-html.ts article.md --save-html /tmp/article.html
351`);
352  process.exit(0);
353}
354 
355async function main(): Promise<void> {
356  const args = process.argv.slice(2);
357  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
358    printUsage();
359  }
360 
361  let markdownPath: string | undefined;
362  let title: string | undefined;
363  let coverImage: string | undefined;
364  let outputFormat: 'json' | 'html' = 'json';
365  let htmlOnly = false;
366  let saveHtmlPath: string | undefined;
367 
368  for (let i = 0; i < args.length; i++) {
369    const arg = args[i]!;
370    if (arg === '--title' && args[i + 1]) {
371      title = args[++i];
372    } else if (arg === '--cover' && args[i + 1]) {
373      coverImage = args[++i];
374    } else if (arg === '--output' && args[i + 1]) {
375      outputFormat = args[++i] as 'json' | 'html';
376    } else if (arg === '--html-only') {
377      htmlOnly = true;
378    } else if (arg === '--save-html' && args[i + 1]) {
379      saveHtmlPath = args[++i];
380    } else if (!arg.startsWith('-')) {
381      markdownPath = arg;
382    }
383  }
384 
385  if (!markdownPath) {
386    console.error('Error: Markdown file path required');
387    process.exit(1);
388  }
389 
390  if (!fs.existsSync(markdownPath)) {
391    console.error(`Error: File not found: ${markdownPath}`);
392    process.exit(1);
393  }
394 
395  const result = await parseMarkdown(markdownPath, { title, coverImage });
396 
397  if (saveHtmlPath) {
398    await writeFile(saveHtmlPath, result.html, 'utf-8');
399    console.error(`[md-to-html] HTML saved to: ${saveHtmlPath}`);
400  }
401 
402  if (htmlOnly) {
403    console.log(result.html);
404  } else if (outputFormat === 'html') {
405    console.log(result.html);
406  } else {
407    console.log(JSON.stringify(result, null, 2));
408  }
409}
410 
411if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
412  try {
413    await main();
414  } catch (err) {
415    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
416    process.exitCode = 1;
417  } finally {
418    await closeRenderer();
419  }
420}
421