agent-reader 1.0.0

package/src/mcp/server.js

@@ -0,0 +1,381 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import * as z from 'zod/v4';
+import { renderMarkdown } from '../core/renderer.js';
+import { exportDOCX, exportPDF } from '../core/exporter.js';
+import { createSlideshow } from '../core/slideshow.js';
+import { openTarget } from '../core/opener.js';
+import { createOutputDir } from '../utils/output.js';
+import {
+  getPreferencesPath,
+  loadPreferences,
+  normalizeOpenMode,
+  updatePreferences,
+} from '../utils/preferences.js';
+
+const MAX_CONTENT_BYTES = 50 * 1024 * 1024;
+
+function getBaseDirFromSourcePath(sourcePath) {
+  if (!sourcePath) {
+    return undefined;
+  }
+  return path.dirname(path.resolve(sourcePath));
+}
+
+function toTextResult(payload) {
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(payload, null, 2),
+      },
+    ],
+    structuredContent: payload,
+  };
+}
+
+function toErrorResult(error, code = 'internal_error') {
+  const payload = {
+    error: error instanceof Error ? error.message : String(error),
+    code,
+  };
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(payload),
+      },
+    ],
+    structuredContent: payload,
+    isError: true,
+  };
+}
+
+function byteLengthOfString(value) {
+  return Buffer.byteLength(value, 'utf8');
+}
+
+function maybeTooLargePayload(textOrBase64) {
+  return byteLengthOfString(textOrBase64) > MAX_CONTENT_BYTES;
+}
+
+async function saveHtmlResult(html, outputDir, name = 'output') {
+  const htmlPath = path.join(outputDir, `${name}.html`);
+  await fs.writeFile(htmlPath, html, 'utf8');
+  const size = (await fs.stat(htmlPath)).size;
+  return { htmlPath, size };
+}
+
+const server = new McpServer({
+  name: 'agent-reader',
+  version: '0.2.0',
+});
+
+server.registerTool(
+  'render_markdown',
+  {
+    description: 'Render markdown text into styled HTML',
+    inputSchema: {
+      content: z.string().describe('Markdown source content'),
+      source_path: z.string().optional().describe('Source markdown path for relative images'),
+      theme: z.string().optional().describe('Theme name'),
+      auto_open: z.boolean().optional().describe('Open output automatically (ignored in MCP)'),
+      return_content: z.boolean().optional().describe('Return inline HTML content directly'),
+    },
+  },
+  async ({ content, source_path, theme, return_content }) => {
+    try {
+      const baseDir = getBaseDirFromSourcePath(source_path);
+      const wantsContent = Boolean(return_content);
+
+      if (wantsContent) {
+        const rendered = await renderMarkdown(content, {
+          theme: theme || 'light',
+          baseDir,
+          inlineAll: true,
+          fetchRemote: true,
+        });
+
+        if (!maybeTooLargePayload(rendered.html)) {
+          return toTextResult({
+            content_data: rendered.html,
+            format: 'html',
+            size: byteLengthOfString(rendered.html),
+            warnings: rendered.warnings,
+          });
+        }
+
+        const outputDir = await createOutputDir('render-markdown');
+        const stored = await saveHtmlResult(rendered.html, outputDir, 'rendered');
+        return toTextResult({
+          html_path: stored.htmlPath,
+          format: 'html',
+          size: stored.size,
+          warnings: [...rendered.warnings, 'content_too_large'],
+        });
+      }
+
+      const outputDir = await createOutputDir('render-markdown');
+      const rendered = await renderMarkdown(content, {
+        theme: theme || 'light',
+        baseDir,
+        inlineAll: false,
+        fetchRemote: true,
+        outDir: outputDir,
+      });
+
+      const stored = await saveHtmlResult(rendered.html, outputDir, 'rendered');
+      return toTextResult({
+        html_path: stored.htmlPath,
+        format: 'html',
+        size: stored.size,
+        warnings: rendered.warnings,
+      });
+    } catch (error) {
+      return toErrorResult(error, 'render_failed');
+    }
+  },
+);
+
+server.registerTool(
+  'export_document',
+  {
+    description: 'Export markdown text into PDF or DOCX',
+    inputSchema: {
+      content: z.string().describe('Markdown source content'),
+      source_path: z.string().optional().describe('Source markdown path for relative images'),
+      format: z.enum(['pdf', 'docx']).describe('Export format'),
+      return_content: z.boolean().optional().describe('Return file bytes as base64'),
+    },
+  },
+  async ({ content, source_path, format, return_content }) => {
+    try {
+      const baseDir = getBaseDirFromSourcePath(source_path);
+      const outputDir = await createOutputDir('export-document');
+      let filePath;
+      let warnings = [];
+
+      if (format === 'pdf') {
+        const rendered = await renderMarkdown(content, {
+          baseDir,
+          inlineAll: true,
+          fetchRemote: true,
+          outDir: outputDir,
+          title: 'export',
+        });
+
+        const htmlPath = path.join(outputDir, 'export.html');
+        await fs.writeFile(htmlPath, rendered.html, 'utf8');
+
+        const pdf = await exportPDF(rendered.html, {
+          outDir: outputDir,
+          fileName: 'export.pdf',
+          htmlPath,
+        });
+        filePath = pdf.pdfPath;
+        warnings = [...warnings, ...rendered.warnings, ...pdf.warnings];
+      } else {
+        const docx = await exportDOCX(content, {
+          baseDir,
+          outDir: outputDir,
+          fileName: 'export.docx',
+        });
+        filePath = docx.docxPath;
+        warnings = [...warnings, ...docx.warnings];
+      }
+
+      const fileBuffer = await fs.readFile(filePath);
+      const fileSize = fileBuffer.byteLength;
+
+      if (return_content) {
+        const base64 = fileBuffer.toString('base64');
+        if (!maybeTooLargePayload(base64)) {
+          return toTextResult({
+            content_data: base64,
+            format,
+            size: fileSize,
+            warnings,
+          });
+        }
+
+        return toTextResult({
+          file_path: filePath,
+          format,
+          size: fileSize,
+          warnings: [...warnings, 'content_too_large'],
+        });
+      }
+
+      return toTextResult({
+        file_path: filePath,
+        format,
+        size: fileSize,
+        warnings,
+      });
+    } catch (error) {
+      return toErrorResult(error, 'export_failed');
+    }
+  },
+);
+
+server.registerTool(
+  'create_slideshow',
+  {
+    description: 'Create slideshow HTML from an image directory',
+    inputSchema: {
+      image_dir: z.string().describe('Absolute or relative image directory path'),
+      auto_play: z.number().optional().describe('Autoplay interval in seconds'),
+      auto_open: z.boolean().optional().describe('Open output automatically (ignored in MCP)'),
+      return_content: z.boolean().optional().describe('Return inline HTML content directly'),
+    },
+  },
+  async ({ image_dir, auto_play, return_content }) => {
+    try {
+      const outputDir = await createOutputDir('create-slideshow');
+      const wantsContent = Boolean(return_content);
+      const result = await createSlideshow(image_dir, {
+        autoPlay: auto_play,
+        inlineAll: wantsContent,
+        outDir: outputDir,
+      });
+
+      const htmlPath = path.join(outputDir, 'slideshow.html');
+      await fs.writeFile(htmlPath, result.html, 'utf8');
+      const fileSize = (await fs.stat(htmlPath)).size;
+
+      if (wantsContent) {
+        if (!maybeTooLargePayload(result.html)) {
+          return toTextResult({
+            content_data: result.html,
+            format: 'html',
+            size: byteLengthOfString(result.html),
+            warnings: result.warnings,
+          });
+        }
+
+        return toTextResult({
+          html_path: htmlPath,
+          format: 'html',
+          size: fileSize,
+          warnings: [...result.warnings, 'content_too_large'],
+        });
+      }
+
+      return toTextResult({
+        html_path: htmlPath,
+        format: 'html',
+        size: fileSize,
+        warnings: result.warnings,
+      });
+    } catch (error) {
+      return toErrorResult(error, 'slideshow_failed');
+    }
+  },
+);
+
+server.registerTool(
+  'open_file',
+  {
+    description: 'Open a local file/path using user preference or explicit mode: web/word/pdf/ppt',
+    inputSchema: {
+      file_path: z.string().describe('File path or image directory path'),
+      open_as: z.string().optional().describe('auto|web|word|pdf|ppt'),
+      theme: z.string().optional().describe('theme for web rendering'),
+      auto_play: z.number().optional().describe('auto play seconds for ppt mode'),
+      return_content: z.boolean().optional().describe('return generated content directly'),
+    },
+  },
+  async ({ file_path, open_as, theme, auto_play, return_content }) => {
+    try {
+      const preferences = await loadPreferences();
+      const requested = normalizeOpenMode(open_as || 'auto', 'auto');
+      const result = await openTarget(file_path, {
+        mode: requested,
+        defaultMode: preferences.default_open_mode,
+        theme: theme || preferences.default_theme,
+        autoPlay: auto_play,
+        returnContent: Boolean(return_content),
+        maxContentBytes: MAX_CONTENT_BYTES,
+      });
+
+      const payload = {
+        path: result.path,
+        content_data: result.content_data,
+        format: result.format,
+        size: result.size,
+        warnings: result.warnings || [],
+        resolved_mode: result.resolved_mode,
+      };
+
+      return toTextResult(payload);
+    } catch (error) {
+      return toErrorResult(error, 'open_failed');
+    }
+  },
+);
+
+server.registerTool(
+  'configure_user_preferences',
+  {
+    description: 'Set default open behavior for novice users',
+    inputSchema: {
+      default_open_mode: z.string().optional().describe('web|word|pdf|ppt'),
+      default_theme: z.string().optional().describe('default web theme'),
+    },
+  },
+  async ({ default_open_mode, default_theme }) => {
+    try {
+      const updates = {};
+      if (default_open_mode) {
+        updates.default_open_mode = normalizeOpenMode(default_open_mode, 'web');
+      }
+      if (default_theme) {
+        updates.default_theme = default_theme;
+      }
+
+      const preferences = Object.keys(updates).length
+        ? await updatePreferences(updates)
+        : await loadPreferences();
+
+      return toTextResult({
+        preferences,
+        config_path: getPreferencesPath(),
+      });
+    } catch (error) {
+      return toErrorResult(error, 'configure_failed');
+    }
+  },
+);
+
+server.registerTool(
+  'get_user_preferences',
+  {
+    description: 'Read current user preferences for open behavior',
+    inputSchema: {},
+  },
+  async () => {
+    try {
+      const preferences = await loadPreferences();
+      return toTextResult({
+        preferences,
+        config_path: getPreferencesPath(),
+      });
+    } catch (error) {
+      return toErrorResult(error, 'read_preferences_failed');
+    }
+  },
+);
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.stderr.write('agent-reader MCP server running on stdio\n');
+}
+
+main().catch((error) => {
+  process.stderr.write(`server error: ${error.message}\n`);
+  process.exit(1);
+});

package/src/templates/document.html

@@ -0,0 +1,145 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Agent Reader</title>
+    {{CSS_INJECTION}}
+</head>
+<body>
+    <aside id="sidebar">
+        <div class="sidebar-header">
+            <div class="logo">✨ Agent Reader</div>
+        </div>
+        <div id="toc-container">
+            {{TOC_CONTENT}}
+        </div>
+    </aside>
+
+    <main id="main-content">
+        <header class="doc-toolbar">
+            <button id="btn-toggle-toc" class="action-btn">
+                <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M4 6h16M4 12h16M4 18h7"/></svg>
+                <span>收起目录</span>
+            </button>
+            <div class="toolbar-right">
+                <button id="btn-export-word" class="action-btn primary">
+                    <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M4 4v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8.342a2 2 0 0 0-.602-1.43l-4.44-4.342A2 2 0 0 0 13.56 2H6a2 2 0 0 0-2 2z"/><path d="M9 13l2 3 2-3M11 10v6"/></svg>
+                    导出 Word
+                </button>
+                <button id="btn-export-pdf" class="action-btn primary">
+                    <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><path d="M14 2v6h6M12 18v-6M9 15l3 3 3-3"/></svg>
+                    导出 PDF
+                </button>
+            </div>
+        </header>
+
+        <article class="markdown-body" id="content">
+            {{CONTENT}}
+        </article>
+    </main>
+
+    <script>
+        document.addEventListener('DOMContentLoaded', () => {
+            const sidebar = document.getElementById('sidebar');
+            const mainContent = document.getElementById('main-content');
+            const btnToggleToc = document.getElementById('btn-toggle-toc');
+
+            btnToggleToc.addEventListener('click', () => {
+                sidebar.classList.toggle('hidden');
+                mainContent.classList.toggle('expanded');
+                const span = btnToggleToc.querySelector('span');
+                span.textContent = sidebar.classList.contains('hidden') ? '展开目录' : '收起目录';
+            });
+
+            const tocItems = document.querySelectorAll('#toc-container li');
+            tocItems.forEach((li) => {
+                const nestedUl = li.querySelector('ul');
+                if (nestedUl) {
+                    li.classList.add('has-children');
+                    const toggleArrow = document.createElement('span');
+                    toggleArrow.className = 'toc-toggle-arrow';
+                    toggleArrow.innerHTML = '▼';
+                    li.insertBefore(toggleArrow, li.firstChild);
+                    toggleArrow.addEventListener('click', (event) => {
+                        event.stopPropagation();
+                        li.classList.toggle('collapsed');
+                        toggleArrow.innerHTML = li.classList.contains('collapsed') ? '▶' : '▼';
+                    });
+                }
+            });
+
+            // Auto-optimize table column widths: short-content columns stay on one line
+            document.querySelectorAll('.markdown-body table').forEach((table) => {
+                const rows = table.querySelectorAll('tr');
+                if (!rows.length) return;
+                const colCount = rows[0].children.length;
+                const visualLen = (text) => {
+                    let n = 0;
+                    for (const ch of text) n += ch.charCodeAt(0) > 0x7F ? 2 : 1;
+                    return n;
+                };
+                for (let col = 0; col < colCount; col++) {
+                    let maxVLen = 0;
+                    rows.forEach((row) => {
+                        const cell = row.children[col];
+                        if (cell) maxVLen = Math.max(maxVLen, visualLen(cell.textContent.trim()));
+                    });
+                    if (maxVLen <= 20) {
+                        rows.forEach((row) => {
+                            const cell = row.children[col];
+                            if (cell) {
+                                cell.style.whiteSpace = 'nowrap';
+                                cell.style.width = '1%';
+                            }
+                        });
+                    }
+                }
+            });
+
+            const getFileName = () => {
+                const h1 = document.querySelector('.markdown-body h1');
+                return h1 ? h1.innerText.trim() : 'Agent-Document';
+            };
+
+            async function triggerBackendExport(format, btnElement) {
+                const originalText = btnElement.innerHTML;
+                btnElement.innerHTML = `⏳ 正在请求后端生成完美 ${format.toUpperCase()}...`;
+                btnElement.disabled = true;
+
+                try {
+                    const source = encodeURIComponent(window.location.pathname || '/');
+                    const response = await fetch(`/api/export?format=${format}&source=${source}`);
+                    if (!response.ok) {
+                        throw new Error('后端导出接口未响应');
+                    }
+
+                    const blob = await response.blob();
+                    const url = window.URL.createObjectURL(blob);
+                    const anchor = document.createElement('a');
+                    anchor.href = url;
+                    anchor.download = `${getFileName()}.${format}`;
+                    document.body.appendChild(anchor);
+                    anchor.click();
+                    document.body.removeChild(anchor);
+                    window.URL.revokeObjectURL(url);
+                } catch (error) {
+                    console.error(error);
+                    window.alert('请求失败。\n要使用一键完美导出，请确保您是通过 "agent-reader render --serve" 启动了本地服务。');
+                } finally {
+                    btnElement.innerHTML = originalText;
+                    btnElement.disabled = false;
+                }
+            }
+
+            document.getElementById('btn-export-pdf').addEventListener('click', function handlePdf() {
+                triggerBackendExport('pdf', this);
+            });
+
+            document.getElementById('btn-export-word').addEventListener('click', function handleWord() {
+                triggerBackendExport('docx', this);
+            });
+        });
+    </script>
+</body>
+</html>

package/src/templates/slideshow.html

@@ -0,0 +1,42 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta http-equiv="Content-Security-Policy" content="{{CSP}}" />
+    <title>{{TITLE}}</title>
+    <style>{{STYLES}}</style>
+  </head>
+  <body>
+    <div class="shell">
+      <div id="slide-toc-drawer" class="slide-toc-drawer" aria-label="目录">
+        <h2 class="slide-toc-title">目录</h2>
+        <div class="slide-toc-list">
+          {{TOC_ITEMS}}
+        </div>
+      </div>
+
+      <div class="toolbar">
+        <button id="toc-toggle-btn" type="button"><svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="3" y1="6" x2="21" y2="6"/><line x1="3" y1="12" x2="21" y2="12"/><line x1="3" y1="18" x2="21" y2="18"/></svg><span>目录</span></button>
+        <button id="fullscreen-btn" type="button"><svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M8 3H5a2 2 0 0 0-2 2v3m18 0V5a2 2 0 0 0-2-2h-3m0 18h3a2 2 0 0 0 2-2v-3M3 16v3a2 2 0 0 0 2 2h3"/></svg><span>全屏</span></button>
+        <button id="export-btn" type="button"><svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></svg><span>导出</span></button>
+      </div>
+
+      <div class="swiper main-swiper">
+        <div class="swiper-wrapper">
+          {{SLIDES}}
+        </div>
+        <div class="swiper-button-prev"></div>
+        <div class="swiper-button-next"></div>
+      </div>
+
+      <div class="swiper thumb-swiper">
+        <div class="swiper-wrapper">
+          {{THUMBS}}
+        </div>
+      </div>
+    </div>
+
+    <script nonce="{{NONCE}}">{{SCRIPT}}</script>
+  </body>
+</html>

package/src/utils/logger.js

@@ -0,0 +1,64 @@
+function writeLine(stream, args) {
+  const line = args
+    .map((arg) => (typeof arg === 'string' ? arg : JSON.stringify(arg)))
+    .join(' ');
+  stream.write(`${line}\n`);
+}
+
+export function createLogger(profile = 'human', jsonOnly = false) {
+  const agentLike = profile === 'agent' || jsonOnly;
+
+  const info = (...args) => {
+    if (agentLike) {
+      writeLine(process.stderr, args);
+      return;
+    }
+    writeLine(process.stdout, args);
+  };
+
+  const warn = (...args) => {
+    writeLine(process.stderr, args);
+  };
+
+  const error = (...args) => {
+    writeLine(process.stderr, args);
+  };
+
+  const json = (obj) => {
+    process.stdout.write(`${JSON.stringify(obj)}\n`);
+  };
+
+  const patchConsole = () => {
+    if (!agentLike) {
+      return () => {};
+    }
+
+    const original = {
+      log: console.log,
+      info: console.info,
+      warn: console.warn,
+      error: console.error,
+    };
+
+    console.log = (...args) => writeLine(process.stderr, args);
+    console.info = (...args) => writeLine(process.stderr, args);
+    console.warn = (...args) => writeLine(process.stderr, args);
+    console.error = (...args) => writeLine(process.stderr, args);
+
+    return () => {
+      console.log = original.log;
+      console.info = original.info;
+      console.warn = original.warn;
+      console.error = original.error;
+    };
+  };
+
+  return {
+    info,
+    warn,
+    error,
+    json,
+    patchConsole,
+    isJsonOnly: agentLike,
+  };
+}

package/src/utils/naturalSort.js

@@ -0,0 +1,12 @@
+const collator = new Intl.Collator(undefined, {
+  numeric: true,
+  sensitivity: 'base',
+});
+
+export function naturalCompare(a, b) {
+  return collator.compare(a, b);
+}
+
+export function naturalSort(values) {
+  return [...values].sort(naturalCompare);
+}