agent-reader 1.0.0

package/src/core/opener.js

@@ -0,0 +1,329 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { createOutputDir } from '../utils/output.js';
+import { normalizeOpenMode } from '../utils/preferences.js';
+import { renderMarkdown } from './renderer.js';
+import { exportDOCX, exportPDF } from './exporter.js';
+import { createSlideshow } from './slideshow.js';
+
+const MARKDOWN_EXTENSIONS = new Set(['.md', '.markdown', '.mdown', '.mdx']);
+const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp']);
+const OPENABLE_EXTENSIONS = new Set(['.html', '.htm', '.pdf', '.docx']);
+
+function extOf(targetPath) {
+  return path.extname(targetPath).toLowerCase();
+}
+
+async function detectTargetKind(targetPath) {
+  const stat = await fs.stat(targetPath);
+
+  if (stat.isDirectory()) {
+    const entries = await fs.readdir(targetPath, { withFileTypes: true });
+    const hasImage = entries.some((entry) => entry.isFile() && IMAGE_EXTENSIONS.has(extOf(entry.name)));
+    return {
+      kind: hasImage ? 'image_directory' : 'directory',
+      stat,
+      extension: '',
+    };
+  }
+
+  if (!stat.isFile()) {
+    return {
+      kind: 'unknown',
+      stat,
+      extension: '',
+    };
+  }
+
+  const extension = extOf(targetPath);
+  if (MARKDOWN_EXTENSIONS.has(extension)) {
+    return { kind: 'markdown', stat, extension };
+  }
+  if (OPENABLE_EXTENSIONS.has(extension)) {
+    return { kind: 'openable_file', stat, extension };
+  }
+  if (IMAGE_EXTENSIONS.has(extension)) {
+    return { kind: 'image_file', stat, extension };
+  }
+
+  return { kind: 'file', stat, extension };
+}
+
+function toBase64WithLimit(buffer, maxContentBytes, warnings) {
+  const encoded = buffer.toString('base64');
+  if (Buffer.byteLength(encoded, 'utf8') > maxContentBytes) {
+    warnings.push('content_too_large');
+    return null;
+  }
+  return encoded;
+}
+
+function toTextWithLimit(text, maxContentBytes, warnings) {
+  if (Buffer.byteLength(text, 'utf8') > maxContentBytes) {
+    warnings.push('content_too_large');
+    return null;
+  }
+  return text;
+}
+
+function fileFormatFromExtension(extension) {
+  if (extension === '.pdf') return 'pdf';
+  if (extension === '.docx') return 'docx';
+  return 'html';
+}
+
+function withUniqueWarnings(payload) {
+  return {
+    ...payload,
+    warnings: [...new Set(payload.warnings || [])],
+  };
+}
+
+export async function openTarget(targetPath, options = {}) {
+  const resolvedPath = path.resolve(targetPath);
+  const target = await detectTargetKind(resolvedPath);
+
+  const warnings = [];
+  const {
+    mode = 'auto',
+    defaultMode = 'web',
+    theme = 'light',
+    outDir,
+    autoPlay,
+    pageSize = 'A4',
+    fetchRemote = true,
+    returnContent = false,
+    maxContentBytes = 50 * 1024 * 1024,
+  } = options;
+
+  const requestedMode = normalizeOpenMode(mode, 'auto');
+  const preferredMode = requestedMode === 'auto'
+    ? normalizeOpenMode(defaultMode, 'web')
+    : requestedMode;
+
+  if (target.kind === 'directory') {
+    throw new Error(`directory has no supported images: ${resolvedPath}`);
+  }
+
+  if (target.kind === 'openable_file' || target.kind === 'file' || target.kind === 'image_file') {
+    const format = target.kind === 'openable_file'
+      ? fileFormatFromExtension(target.extension)
+      : 'file';
+
+    if (!returnContent || format === 'file') {
+      return withUniqueWarnings({
+        path: resolvedPath,
+        format,
+        size: target.stat.size,
+        warnings,
+        resolved_mode: 'direct',
+      });
+    }
+
+    const fileBuffer = await fs.readFile(resolvedPath);
+    if (format === 'html') {
+      const text = toTextWithLimit(fileBuffer.toString('utf8'), maxContentBytes, warnings);
+      if (text !== null) {
+        return withUniqueWarnings({
+          content_data: text,
+          format,
+          size: Buffer.byteLength(text, 'utf8'),
+          warnings,
+          resolved_mode: 'direct',
+        });
+      }
+    } else {
+      const encoded = toBase64WithLimit(fileBuffer, maxContentBytes, warnings);
+      if (encoded !== null) {
+        return withUniqueWarnings({
+          content_data: encoded,
+          format,
+          size: fileBuffer.byteLength,
+          warnings,
+          resolved_mode: 'direct',
+        });
+      }
+    }
+
+    return withUniqueWarnings({
+      path: resolvedPath,
+      format,
+      size: target.stat.size,
+      warnings,
+      resolved_mode: 'direct',
+    });
+  }
+
+  if (target.kind === 'image_directory') {
+    const outputDir = await createOutputDir(path.basename(resolvedPath), outDir);
+
+    if (!['ppt', 'auto', 'web'].includes(preferredMode)) {
+      warnings.push(`mode_${preferredMode}_fallback_ppt`);
+    }
+
+    const slideshow = await createSlideshow(resolvedPath, {
+      autoPlay,
+      inlineAll: returnContent,
+      outDir: outputDir,
+      theme,
+    });
+    warnings.push(...slideshow.warnings);
+
+    const htmlPath = path.join(outputDir, 'slideshow.html');
+    await fs.writeFile(htmlPath, slideshow.html, 'utf8');
+    const size = (await fs.stat(htmlPath)).size;
+
+    if (returnContent) {
+      const text = toTextWithLimit(slideshow.html, maxContentBytes, warnings);
+      if (text !== null) {
+        return withUniqueWarnings({
+          content_data: text,
+          format: 'html',
+          size: Buffer.byteLength(text, 'utf8'),
+          warnings,
+          resolved_mode: 'ppt',
+          output_dir: outputDir,
+        });
+      }
+    }
+
+    return withUniqueWarnings({
+      path: htmlPath,
+      format: 'html',
+      size,
+      warnings,
+      resolved_mode: 'ppt',
+      output_dir: outputDir,
+    });
+  }
+
+  if (target.kind !== 'markdown') {
+    throw new Error(`unsupported target type: ${resolvedPath}`);
+  }
+
+  const markdown = await fs.readFile(resolvedPath, 'utf8');
+  const baseDir = path.dirname(resolvedPath);
+  const name = path.parse(resolvedPath).name;
+  const outputDir = await createOutputDir(name, outDir);
+
+  if (preferredMode === 'word') {
+    const docx = await exportDOCX(markdown, {
+      baseDir,
+      outDir: outputDir,
+      fileName: `${name}.docx`,
+    });
+    warnings.push(...docx.warnings);
+
+    if (returnContent) {
+      const buffer = await fs.readFile(docx.docxPath);
+      const encoded = toBase64WithLimit(buffer, maxContentBytes, warnings);
+      if (encoded !== null) {
+        return withUniqueWarnings({
+          content_data: encoded,
+          format: 'docx',
+          size: buffer.byteLength,
+          warnings,
+          resolved_mode: 'word',
+          output_dir: outputDir,
+        });
+      }
+    }
+
+    return withUniqueWarnings({
+      path: docx.docxPath,
+      format: 'docx',
+      size: docx.size,
+      warnings,
+      resolved_mode: 'word',
+      output_dir: outputDir,
+    });
+  }
+
+  if (preferredMode === 'pdf') {
+    const rendered = await renderMarkdown(markdown, {
+      theme,
+      baseDir,
+      inlineAll: true,
+      fetchRemote,
+      outDir: outputDir,
+      title: name,
+    });
+    warnings.push(...rendered.warnings);
+
+    const htmlPath = path.join(outputDir, `${name}.html`);
+    await fs.writeFile(htmlPath, rendered.html, 'utf8');
+
+    const pdf = await exportPDF(rendered.html, {
+      pageSize,
+      outDir: outputDir,
+      fileName: `${name}.pdf`,
+      htmlPath,
+    });
+    warnings.push(...pdf.warnings);
+
+    if (returnContent) {
+      const buffer = await fs.readFile(pdf.pdfPath);
+      const encoded = toBase64WithLimit(buffer, maxContentBytes, warnings);
+      if (encoded !== null) {
+        return withUniqueWarnings({
+          content_data: encoded,
+          format: 'pdf',
+          size: buffer.byteLength,
+          warnings,
+          resolved_mode: 'pdf',
+          output_dir: outputDir,
+        });
+      }
+    }
+
+    return withUniqueWarnings({
+      path: pdf.pdfPath,
+      format: 'pdf',
+      size: pdf.size,
+      warnings,
+      resolved_mode: 'pdf',
+      output_dir: outputDir,
+    });
+  }
+
+  if (preferredMode === 'ppt') {
+    warnings.push('mode_ppt_for_markdown_fallback_web');
+  }
+
+  const rendered = await renderMarkdown(markdown, {
+    theme,
+    baseDir,
+    inlineAll: returnContent,
+    fetchRemote,
+    outDir: outputDir,
+    title: name,
+  });
+  warnings.push(...rendered.warnings);
+
+  const htmlPath = path.join(outputDir, `${name}.html`);
+  await fs.writeFile(htmlPath, rendered.html, 'utf8');
+  const htmlSize = (await fs.stat(htmlPath)).size;
+
+  if (returnContent) {
+    const text = toTextWithLimit(rendered.html, maxContentBytes, warnings);
+    if (text !== null) {
+      return withUniqueWarnings({
+        content_data: text,
+        format: 'html',
+        size: Buffer.byteLength(text, 'utf8'),
+        warnings,
+        resolved_mode: 'web',
+        output_dir: outputDir,
+      });
+    }
+  }
+
+  return withUniqueWarnings({
+    path: htmlPath,
+    format: 'html',
+    size: htmlSize,
+    warnings,
+    resolved_mode: 'web',
+    output_dir: outputDir,
+  });
+}

package/src/core/renderer.js

@@ -0,0 +1,235 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import MarkdownIt from 'markdown-it';
+import hljs from 'highlight.js';
+import { processAssets } from './assets.js';
+import { sanitize } from './sanitizer.js';
+
+const require = createRequire(import.meta.url);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const THEME_DIR = path.join(__dirname, 'themes');
+const TEMPLATE_PATH = path.resolve(__dirname, '../templates/document.html');
+
+const GITHUB_MARKDOWN_CSS_PATH = require.resolve('github-markdown-css/github-markdown.css');
+const HIGHLIGHT_CSS_PATH = require.resolve('highlight.js/styles/github.css');
+
+const TOC_BASE_CSS = `
+.markdown-body :is(h1, h2, h3, h4, h5, h6) {
+  scroll-margin-top: 24px;
+}
+`;
+
+function escapeHtml(value) {
+  return String(value)
+    .replaceAll('&', '&')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;');
+}
+
+function slugify(value) {
+  const normalized = String(value)
+    .toLowerCase()
+    .trim()
+    .replace(/[^\p{L}\p{N}\s-]/gu, '')
+    .replace(/\s+/g, '-')
+    .replace(/-+/g, '-');
+
+  return normalized || 'section';
+}
+
+function inlineTokenToText(inlineToken) {
+  if (!inlineToken?.children?.length) {
+    return inlineToken?.content || '';
+  }
+
+  return inlineToken.children
+    .map((child) => {
+      if (child.type === 'text' || child.type === 'code_inline') {
+        return child.content || '';
+      }
+      if (child.type === 'image') {
+        return child.content || child.attrGet('alt') || '';
+      }
+      return '';
+    })
+    .join('');
+}
+
+function createMarkdownRenderer() {
+  const instance = new MarkdownIt({
+    html: true,
+    linkify: true,
+    typographer: true,
+    highlight(code, language) {
+      if (language && hljs.getLanguage(language)) {
+        const highlighted = hljs.highlight(code, { language }).value;
+        return `<pre><code class="hljs language-${language}">${highlighted}</code></pre>`;
+      }
+
+      const escaped = instance.utils.escapeHtml(code);
+      return `<pre><code class="hljs">${escaped}</code></pre>`;
+    },
+  });
+
+  const defaultHeadingOpen = instance.renderer.rules.heading_open
+    || ((tokens, idx, options, env, self) => self.renderToken(tokens, idx, options));
+
+  instance.renderer.rules.heading_open = (tokens, idx, options, env, self) => {
+    const headingToken = tokens[idx];
+    const inlineToken = tokens[idx + 1];
+
+    const text = inlineTokenToText(inlineToken).trim() || `Section ${idx + 1}`;
+    const level = Number(headingToken.tag.slice(1)) || 1;
+
+    if (!env.__toc) {
+      env.__toc = [];
+    }
+    if (!env.__slugMap) {
+      env.__slugMap = new Map();
+    }
+
+    const slugBase = slugify(text);
+    const count = (env.__slugMap.get(slugBase) || 0) + 1;
+    env.__slugMap.set(slugBase, count);
+    const id = count === 1 ? slugBase : `${slugBase}-${count}`;
+
+    headingToken.attrSet('id', id);
+    env.__toc.push({
+      id,
+      text,
+      level,
+    });
+
+    return defaultHeadingOpen(tokens, idx, options, env, self);
+  };
+
+  return instance;
+}
+
+function buildTocTree(tocItems) {
+  const root = { level: 0, children: [] };
+  const stack = [root];
+
+  for (const item of tocItems) {
+    const node = {
+      id: item.id,
+      text: item.text,
+      level: Math.min(6, Math.max(1, Number(item.level) || 1)),
+      children: [],
+    };
+
+    while (stack.length > 1 && node.level <= stack[stack.length - 1].level) {
+      stack.pop();
+    }
+
+    const parent = stack[stack.length - 1];
+    parent.children.push(node);
+    stack.push(node);
+  }
+
+  return root.children;
+}
+
+function renderTocNodes(nodes) {
+  if (!nodes.length) {
+    return '';
+  }
+
+  const listHtml = nodes
+    .map((node) => {
+      const safeText = escapeHtml(node.text);
+      const safeId = escapeHtml(node.id);
+      const childHtml = renderTocNodes(node.children);
+      return `<li><a class="toc-link toc-level-${node.level}" href="#${safeId}" data-toc-id="${safeId}">${safeText}</a>${childHtml}</li>`;
+    })
+    .join('');
+
+  return `<ul>${listHtml}</ul>`;
+}
+
+function buildTocHtml(tocItems) {
+  if (!tocItems.length) {
+    return '<p class="toc-empty">当前文档没有标题结构</p>';
+  }
+
+  const tree = buildTocTree(tocItems);
+  return renderTocNodes(tree);
+}
+
+async function loadStyles(theme) {
+  const themeName = theme || 'light';
+  const builtInThemePath =
+    themeName === 'dark'
+      ? path.join(THEME_DIR, 'dark.css')
+      : themeName === 'print'
+        ? path.join(THEME_DIR, 'print.css')
+        : path.join(THEME_DIR, 'light.css');
+  const customThemePath =
+    themeName === 'light' || themeName === 'dark' || themeName === 'print'
+      ? null
+      : path.resolve(themeName);
+
+  const [builtInTheme, githubCss, highlightCss, customTheme = ''] = await Promise.all([
+    fs.readFile(builtInThemePath, 'utf8'),
+    fs.readFile(GITHUB_MARKDOWN_CSS_PATH, 'utf8'),
+    fs.readFile(HIGHLIGHT_CSS_PATH, 'utf8'),
+    customThemePath ? fs.readFile(customThemePath, 'utf8') : Promise.resolve(''),
+  ]);
+
+  const mergedCss = `${githubCss}\n${highlightCss}\n${builtInTheme}\n${TOC_BASE_CSS}\n${customTheme}`;
+  return `<style>${mergedCss}</style>`;
+}
+
+function fillTemplate(template, params) {
+  return template
+    .replace('{{CSS_INJECTION}}', params.cssInjection)
+    .replace('{{TOC_CONTENT}}', params.tocContent)
+    .replace('{{CONTENT}}', params.content);
+}
+
+export async function renderMarkdown(markdownString, options = {}) {
+  const {
+    theme = 'light',
+    baseDir,
+    inlineAll = false,
+    fetchRemote = true,
+    outDir,
+  } = options;
+
+  const renderer = createMarkdownRenderer();
+  const env = {};
+  const htmlUnsafe = renderer.render(markdownString, env);
+  const htmlSanitized = sanitize(htmlUnsafe);
+
+  const assetResult = await processAssets(htmlSanitized, {
+    baseDir,
+    outDir,
+    inlineAll,
+    fetchRemote,
+  });
+
+  const tocItems = Array.isArray(env.__toc) ? env.__toc : [];
+  const tocHtml = buildTocHtml(tocItems);
+
+  const [template, cssContent] = await Promise.all([
+    fs.readFile(TEMPLATE_PATH, 'utf8'),
+    loadStyles(theme),
+  ]);
+
+  const html = fillTemplate(template, {
+    cssInjection: cssContent,
+    tocContent: tocHtml,
+    content: assetResult.html,
+  });
+
+  return {
+    html,
+    assets: assetResult.assets,
+    warnings: assetResult.warnings,
+    toc: tocItems,
+  };
+}

package/src/core/sanitizer.js

@@ -0,0 +1,79 @@
+import sanitizeHtml from 'sanitize-html';
+
+const ALLOWED_TAGS = [
+  'h1',
+  'h2',
+  'h3',
+  'h4',
+  'h5',
+  'h6',
+  'p',
+  'div',
+  'span',
+  'a',
+  'img',
+  'table',
+  'thead',
+  'tbody',
+  'tfoot',
+  'tr',
+  'th',
+  'td',
+  'ul',
+  'ol',
+  'li',
+  'blockquote',
+  'pre',
+  'code',
+  'em',
+  'strong',
+  'del',
+  'hr',
+  'br',
+  'sup',
+  'sub',
+  'details',
+  'summary',
+  'section',
+  'article',
+  'figure',
+  'figcaption',
+];
+
+const ALLOWED_ATTRIBUTES = {
+  '*': ['id', 'class', 'title', 'data-*'],
+  img: ['src', 'alt', 'width', 'height', 'loading', 'decoding'],
+  a: ['href', 'title', 'target', 'rel'],
+  code: ['class'],
+  pre: ['class'],
+  table: ['class'],
+  th: ['colspan', 'rowspan'],
+  td: ['colspan', 'rowspan'],
+};
+
+export function sanitize(htmlString) {
+  return sanitizeHtml(htmlString, {
+    allowedTags: ALLOWED_TAGS,
+    allowedAttributes: ALLOWED_ATTRIBUTES,
+    allowedSchemes: ['http', 'https', 'data', 'mailto'],
+    allowedSchemesByTag: {
+      img: ['http', 'https', 'data'],
+      a: ['http', 'https', 'mailto'],
+    },
+    allowProtocolRelative: false,
+    disallowedTagsMode: 'discard',
+    parser: {
+      lowerCaseTags: true,
+      lowerCaseAttributeNames: true,
+    },
+    transformTags: {
+      a: (tagName, attribs) => {
+        const out = { ...attribs };
+        if (out.target === '_blank') {
+          out.rel = 'noopener noreferrer';
+        }
+        return { tagName, attribs: out };
+      },
+    },
+  });
+}