@web-auto/webauto 0.1.1 → 0.1.3

package/dist/modules/workflow/blocks/OrganizeXhsNotesBlock.js

@@ -0,0 +1,117 @@
+/**
+ * Workflow Block: OrganizeXhsNotesBlock
+ *
+ * 采集完成后的整理：
+ * 1) OCR 扫描每个 note 的 images/，输出 ocr.md
+ * 2) 合并 ocr + 正文 + 评论，输出 merged.md
+ * 3) 合并所有帖子，输出 ALL.md（编号 + 链接 + 合并正文）
+ *
+ * 注意：
+ * - 只做本地落盘整理（~/.webauto/download），不做任何浏览器操作。
+ */
+import os from 'node:os';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { countPersistedNotes } from './helpers/persistedNotes.js';
+import { organizeOneNote } from './helpers/xhsNoteOrganizer.js';
+function sanitizeForPath(name) {
+    if (!name)
+        return '';
+    return name.replace(/[\\/:"*?<>|]+/g, '_').trim();
+}
+function resolveDownloadRoot() {
+    const custom = process.env.WEBAUTO_DOWNLOAD_ROOT || process.env.WEBAUTO_DOWNLOAD_DIR;
+    if (custom && custom.trim())
+        return custom;
+    const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+    return path.join(home, '.webauto', 'download');
+}
+export async function execute(input) {
+    const platform = input.platform || 'xiaohongshu';
+    const env = input.env || 'debug';
+    const keyword = String(input.keyword || '').trim();
+    if (!keyword) {
+        return { success: false, keywordDir: '', noteCount: 0, ocrLanguagesUsed: 'eng', processed: [], error: 'missing_keyword' };
+    }
+    const persisted = await countPersistedNotes({
+        platform,
+        env,
+        keyword,
+        downloadRoot: resolveDownloadRoot(),
+        requiredFiles: ['content.md', 'comments.md'],
+        requireCommentsDone: true,
+    });
+    const keywordDir = persisted.keywordDir;
+    const noteIds = persisted.noteIds.slice().sort();
+    const ocrLang = String(input.ocrLanguages || '').trim() || 'chi_sim+eng';
+    const processed = [];
+    // 汇总 ALL.md
+    const allLines = [];
+    allLines.push(`# 合并汇总（${keyword}）`);
+    allLines.push('');
+    allLines.push(`- 关键词: ${keyword}`);
+    allLines.push(`- 环境: ${env}`);
+    allLines.push(`- 目录: ${keywordDir}`);
+    allLines.push(`- 数量: ${noteIds.length}`);
+    allLines.push(`- OCR 语言: ${ocrLang}`);
+    allLines.push('');
+    for (let i = 0; i < noteIds.length; i += 1) {
+        const noteId = noteIds[i];
+        const noteDir = path.join(keywordDir, noteId);
+        try {
+            const res = await organizeOneNote({
+                noteDir,
+                noteId,
+                keyword,
+                ocrLanguages: ocrLang,
+                runOcr: input.runOcr === true,
+                requireExistingOcr: input.runOcr !== true,
+            });
+            allLines.push(`## ${i + 1}. ${noteId}`);
+            allLines.push('');
+            if (res.link)
+                allLines.push(`- 链接: ${res.link}`);
+            allLines.push('');
+            const merged = await fs.readFile(res.mergedPath, 'utf-8');
+            allLines.push(merged.trim());
+            allLines.push('');
+            allLines.push('---');
+            allLines.push('');
+            processed.push({
+                noteId,
+                ocrPath: res.ocrPath,
+                mergedPath: res.mergedPath,
+                imageCount: res.imageCount,
+                ocrErrors: res.ocrErrors,
+                ok: true,
+            });
+        }
+        catch (e) {
+            processed.push({
+                noteId,
+                imageCount: 0,
+                ocrErrors: 0,
+                ok: false,
+                error: e?.message || String(e),
+            });
+            // 不阻断其它 note
+            continue;
+        }
+    }
+    const safeKeyword = sanitizeForPath(keyword) || 'unknown';
+    const allPath = path.join(keywordDir, `ALL-${safeKeyword}.md`);
+    await fs.writeFile(allPath, `${allLines.join('\n')}\n`, 'utf-8');
+    const failed = processed.filter((p) => !p.ok);
+    return {
+        success: failed.length === 0,
+        keywordDir,
+        noteCount: noteIds.length,
+        ocrLanguagesUsed: ocrLang,
+        allPath,
+        processed,
+        ...(failed.length
+            ? { error: `organize_failed_notes: ${failed.length}/${noteIds.length}` }
+            : {}),
+    };
+}
+//# sourceMappingURL=OrganizeXhsNotesBlock.js.map

package/dist/modules/workflow/blocks/PersistXhsNoteBlock.js

@@ -0,0 +1,270 @@
+/**
+ * PersistXhsNoteBlock
+ *
+ * 将小红书帖子详情 + 评论持久化到本地目录：
+ *   ~/.webauto/download/xiaohongshu/{env}/{keyword}/{noteId}/
+ *   - content.md
+ *   - images/{index}.jpg
+ */
+import os from 'node:os';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+function sanitizeForPath(name) {
+    if (!name)
+        return '';
+    return name.replace(/[\\/:"*?<>|]+/g, '_').trim();
+}
+function resolveDownloadRoot() {
+    const custom = process.env.WEBAUTO_DOWNLOAD_ROOT || process.env.WEBAUTO_DOWNLOAD_DIR;
+    if (custom && custom.trim())
+        return custom;
+    const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+    return path.join(home, '.webauto', 'download');
+}
+function formatUrlForLog(url, maxLen = 180) {
+    const s = (url || '').toString();
+    if (s.length <= maxLen)
+        return s;
+    return `${s.slice(0, maxLen)}…`;
+}
+async function ensureDir(dir) {
+    await fs.mkdir(dir, { recursive: true });
+}
+async function downloadImage(url, imagesDir, index) {
+    if (!url)
+        return null;
+    // 过滤明显是头像/图标等小图的最小体积阈值（字节）
+    const MIN_IMAGE_BYTES = 20 * 1024; // 约 20KB
+    let normalized = String(url).trim();
+    if (!normalized)
+        return null;
+    if (normalized.startsWith('//')) {
+        normalized = `https:${normalized}`;
+    }
+    // 绝大多数头像/静态图标不属于帖子图片，直接跳过（避免大量无意义的 fetch）
+    const skipByUrl = /sns-avatar-[^/]+\.xhscdn\.com\/avatar\//i.test(normalized) ||
+        /picasso-static\.xiaohongshu\.com\/fe-platform\//i.test(normalized) ||
+        normalized.startsWith('data:') ||
+        normalized.startsWith('blob:');
+    if (skipByUrl) {
+        return null;
+    }
+    if (!/^https?:/i.test(normalized)) {
+        console.warn(`[PersistXhsNote] Skip non-http image url: ${formatUrlForLog(normalized)}`);
+        return null;
+    }
+    try {
+        const res = await fetch(normalized);
+        if (!res.ok) {
+            console.warn(`[PersistXhsNote] Image fetch failed: ${formatUrlForLog(normalized)} status=${res.status}`);
+            return null;
+        }
+        const buf = Buffer.from(await res.arrayBuffer());
+        // 根据字节大小粗略过滤掉头像/小图标等小尺寸图片
+        if (buf.length < MIN_IMAGE_BYTES) {
+            console.warn(`[PersistXhsNote] Skip tiny image (${buf.length}B < ${MIN_IMAGE_BYTES}B): ${formatUrlForLog(normalized)}`);
+            return null;
+        }
+        const filename = `${String(index).padStart(2, '0')}.jpg`;
+        const filepath = path.join(imagesDir, filename);
+        await fs.writeFile(filepath, buf);
+        return path.join('images', filename);
+    }
+    catch (err) {
+        console.warn(`[PersistXhsNote] Image download error: ${formatUrlForLog(normalized)} - ${err?.message || err}`);
+        return null;
+    }
+}
+export async function execute(input) {
+    const { env, platform = 'xiaohongshu', keyword, noteId, searchUrl, detailUrl, detail, commentsResult, persistMode = 'both', downloadImages = true, maxImagesToDownload, } = input;
+    if (!env || !keyword || !noteId) {
+        return {
+            success: false,
+            error: 'Missing env, keyword or noteId',
+        };
+    }
+    try {
+        const baseDir = path.join(resolveDownloadRoot(), platform, env);
+        const safeKeyword = sanitizeForPath(keyword) || 'unknown';
+        const keywordDir = path.join(baseDir, safeKeyword);
+        const postDir = path.join(keywordDir, noteId);
+        const imagesDir = path.join(postDir, 'images');
+        await ensureDir(keywordDir);
+        await ensureDir(postDir);
+        if (downloadImages) {
+            await ensureDir(imagesDir);
+        }
+        const wantDetail = persistMode === 'detail' || persistMode === 'both';
+        const wantComments = persistMode === 'comments' || persistMode === 'both';
+        const detailData = detail || {};
+        const titleFromDetail = detailData.title ||
+            detailData.note_title ||
+            detailData.header?.title ||
+            detailData.content?.title ||
+            '';
+        const title = titleFromDetail || '无标题';
+        const author = detailData.author ||
+            detailData.header?.author ||
+            detailData.header?.user_name ||
+            detailData.header?.nickname ||
+            '';
+        const contentText = detailData.contentText ||
+            detailData.content?.text ||
+            detailData.content?.desc ||
+            detailData.content?.content ||
+            '';
+        const detailPath = path.join(postDir, 'content.md');
+        const commentsPath = path.join(postDir, 'comments.md');
+        const commentsDonePath = path.join(postDir, 'comments.done.json');
+        // 1) 详情（正文/图片）
+        if (wantDetail) {
+            const existingDetail = await fs.stat(detailPath).catch(() => null);
+            // 图片下载：如果 images 目录已有文件则不重复下载
+            let hasAnyImage = false;
+            if (downloadImages) {
+                try {
+                    const existing = await fs.readdir(imagesDir).catch(() => []);
+                    hasAnyImage = Array.isArray(existing) && existing.length > 0;
+                }
+                catch {
+                    hasAnyImage = false;
+                }
+            }
+            const localImages = [];
+            const images = Array.isArray(detailData?.gallery?.images)
+                ? detailData.gallery.images
+                : [];
+            const maxImages = typeof maxImagesToDownload === 'number' && Number.isFinite(maxImagesToDownload)
+                ? Math.max(0, Math.floor(maxImagesToDownload))
+                : 6;
+            if (downloadImages && !hasAnyImage && images.length > 0 && maxImages > 0) {
+                let imgIndex = 0;
+                for (const url of images) {
+                    imgIndex += 1;
+                    if (imgIndex > maxImages)
+                        break;
+                    const rel = await downloadImage(url, imagesDir, imgIndex);
+                    if (rel)
+                        localImages.push(rel);
+                }
+            }
+            if (!existingDetail || !existingDetail.isFile()) {
+                const lines = [];
+                lines.push(`# ${title}`);
+                lines.push('');
+                lines.push(`- Note ID: ${noteId || '未知'}`);
+                lines.push(`- 关键词: ${keyword || '未知'}`);
+                if (searchUrl)
+                    lines.push(`- Search URL: ${searchUrl}`);
+                if (detailUrl)
+                    lines.push(`- 链接: ${detailUrl}`);
+                if (author)
+                    lines.push(`- 作者: ${author}`);
+                lines.push(`- 采集时间: ${new Date().toISOString()}`);
+                lines.push('');
+                lines.push('## 正文');
+                lines.push('');
+                lines.push(contentText || '（无正文）');
+                lines.push('');
+                // 图片渲染：优先使用本地已下载的图片；否则仅记录数量
+                const imagesToRender = localImages.length > 0 ? localImages : [];
+                if (imagesToRender.length > 0) {
+                    lines.push('## 图片');
+                    lines.push('');
+                    for (const rel of imagesToRender) {
+                        const safeRel = rel.replace(/\\/g, '/');
+                        lines.push(`![](${safeRel})`);
+                    }
+                    lines.push('');
+                }
+                await fs.writeFile(detailPath, lines.join('\n'), 'utf-8');
+            }
+        }
+        // 2) 评论（独立文件，支持后续增量更新）
+        if (wantComments) {
+            const comments = Array.isArray(commentsResult?.comments) ? commentsResult.comments : [];
+            const headerTotal = typeof commentsResult?.totalFromHeader === 'number' ? commentsResult.totalFromHeader : null;
+            const headerPositive = typeof headerTotal === 'number' && Number.isFinite(headerTotal) && headerTotal > 0;
+            const coverageRatio = headerPositive ? comments.length / headerTotal : null;
+            const coverageNeed = headerPositive ? Math.ceil(headerTotal * 0.9) : null;
+            const coverageOk = headerPositive ? comments.length >= (coverageNeed || 0) : null;
+            const maxComments = typeof commentsResult?.maxComments === 'number' && Number.isFinite(commentsResult.maxComments)
+                ? Math.floor(commentsResult.maxComments)
+                : null;
+            const stoppedByMaxComments = Boolean(commentsResult?.stoppedByMaxComments);
+            // 没有任何评论且没有明确 reachedEnd/emptyState 信号时，不写入 comments.md
+            const hasAnySignal = comments.length > 0 ||
+                typeof commentsResult?.reachedEnd === 'boolean' ||
+                typeof commentsResult?.emptyState === 'boolean' ||
+                typeof headerTotal === 'number';
+            if (hasAnySignal) {
+                const lines = [];
+                lines.push(`# 评论（${comments.length}）`);
+                lines.push('');
+                lines.push(`- Note ID: ${noteId || '未知'}`);
+                lines.push(`- 关键词: ${keyword || '未知'}`);
+                if (searchUrl)
+                    lines.push(`- Search URL: ${searchUrl}`);
+                if (detailUrl)
+                    lines.push(`- 链接: ${detailUrl}`);
+                lines.push(`- 采集时间: ${new Date().toISOString()}`);
+                lines.push(`- 评论统计: 抓取=${comments.length}, header=${headerTotal !== null ? headerTotal : '未知'}（reachedEnd=${commentsResult?.reachedEnd ? '是' : '否'}, empty=${commentsResult?.emptyState ? '是' : '否'}${headerPositive
+                    ? `, coverage=${Math.round((coverageRatio || 0) * 100)}% (need>=${coverageNeed}, ok=${coverageOk ? '是' : '否'})`
+                    : ''}）`);
+                lines.push('');
+                if (comments.length === 0) {
+                    lines.push('（无评论）');
+                }
+                else {
+                    for (const c of comments) {
+                        if (!c)
+                            continue;
+                        const user = c.user_name || c.username || '未知用户';
+                        const uid = c.user_id || '';
+                        const ts = c.timestamp || '';
+                        const text = c.text || '';
+                        const idPart = uid ? ` (${uid})` : '';
+                        const tsPart = ts ? ` [${ts}]` : '';
+                        lines.push(`- **${user}**${idPart}${tsPart}：${text}`);
+                    }
+                }
+                if (stoppedByMaxComments && maxComments !== null) {
+                    lines.push(`- MaxComments: ${maxComments} (stoppedByMaxComments=yes)`);
+                }
+                await fs.writeFile(commentsPath, lines.join('\n'), 'utf-8');
+            }
+            const done = Boolean(commentsResult?.reachedEnd === true ||
+                commentsResult?.emptyState === true ||
+                commentsResult?.stoppedByMaxComments === true);
+            if (done) {
+                await fs.writeFile(commentsDonePath, JSON.stringify({
+                    noteId,
+                    keyword,
+                    done: true,
+                    reachedEnd: Boolean(commentsResult?.reachedEnd),
+                    emptyState: Boolean(commentsResult?.emptyState),
+                    stoppedByMaxComments: Boolean(commentsResult?.stoppedByMaxComments),
+                    totalComments: comments.length,
+                    headerTotal,
+                    ts: new Date().toISOString(),
+                }, null, 2), 'utf-8');
+            }
+            else {
+                await fs.unlink(commentsDonePath).catch(() => { });
+            }
+        }
+        return {
+            success: true,
+            outputDir: postDir,
+            contentPath: detailPath,
+            imagesDir,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: err?.message || String(err),
+        };
+    }
+}
+//# sourceMappingURL=PersistXhsNoteBlock.js.map

package/dist/modules/workflow/blocks/PickSinglePost.js

@@ -0,0 +1,69 @@
+/**
+ * Workflow Block: PickSinglePost
+ *
+ * 在 snapshot 中定位单条帖子容器
+ */
+/**
+ * 定位单条帖子容器
+ *
+ * @param input - 输入参数
+ * @returns Promise<PickSinglePostOutput>
+ */
+export async function execute(input) {
+    const { sessionId, containerSelector, index = 0, serviceUrl = 'http://127.0.0.1:7704' } = input;
+    const commandUrl = `${serviceUrl}/command`;
+    try {
+        const evalRes = await fetch(commandUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'evaluate',
+                args: {
+                    profileId: sessionId,
+                    script: `
+            (() => {
+              const containers = document.querySelectorAll('${containerSelector}');
+              if (!containers || containers.length === 0) {
+                return { error: 'No containers found' };
+              }
+              const index = ${index};
+              if (index >= containers.length) {
+                return { error: 'Index out of range' };
+              }
+              const element = containers[index];
+              return {
+                tag: element.tagName,
+                classes: Array.from(element.classList),
+                text: element.textContent?.slice(0, 200),
+                html: element.outerHTML.slice(0, 500)
+              };
+            })()
+          `
+                }
+            })
+        });
+        const evalData = await evalRes.json();
+        if (!evalData.success || evalData.data?.error) {
+            return {
+                element: null,
+                index: 0,
+                containerId: '',
+                error: evalData.data?.error || 'Failed to pick element'
+            };
+        }
+        return {
+            element: evalData.data,
+            index,
+            containerId: `post-${index}`
+        };
+    }
+    catch (error) {
+        return {
+            element: null,
+            index: 0,
+            containerId: '',
+            error: `Pick error: ${error.message}`
+        };
+    }
+}
+//# sourceMappingURL=PickSinglePost.js.map

package/dist/modules/workflow/blocks/ProgressTracker.js

@@ -0,0 +1,125 @@
+/**
+ * ProgressTracker - 任务进度持久化与恢复
+ *
+ * 功能：
+ * 1. 保存采集进度（已采集 noteId、关键词索引、搜索轮次）
+ *    - P2.1: 增加容器维度去重（noteId + containerId），避免多容器路径指向同一 note 时重复采集
+ *    - 向后兼容：旧版本进度文件只有 seenNoteIds，新版本增加 seenKeys
+ * 2. 支持断点续采（进程崩溃后可恢复）
+ * 3. 提供去重依据（seenNoteIds 集合）
+ * 4. 成功完成后自动清理进度文件
+ */
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { atomicWriteJson, readJsonMaybe } from '../../state/src/atomic-json.js';
+export class ProgressTracker {
+    dataDir;
+    sessionId;
+    progressPath;
+    constructor(dataDir, sessionId) {
+        this.dataDir = dataDir;
+        this.sessionId = sessionId;
+        this.progressPath = path.join(dataDir, `.progress_${sessionId}.json`);
+    }
+    /**
+     * 保存当前进度
+     */
+    async save(state) {
+        const fullState = {
+            version: 1,
+            updatedAt: new Date().toISOString(),
+            ...state
+        };
+        await atomicWriteJson(this.progressPath, fullState);
+        console.log(`[ProgressTracker] 进度已保存: ${state.collectedCount} 条, ` +
+            `keys=${state.seenKeys?.length || state.seenNoteIds?.length || 0}, ` +
+            `keywordIndex=${state.keywordIndex}, searchRound=${state.searchRound}`);
+    }
+    /**
+     * 加载保存的进度
+     *
+     * 向后兼容策略：
+     * - 旧版本进度文件只有 seenNoteIds，新版本会自动填充 seenKeys（假设 containerId 为空）
+     * - 新版本进度文件同时保存 seenNoteIds 和 seenKeys
+     */
+    async load() {
+        try {
+            const state = await readJsonMaybe(this.progressPath);
+            if (!state)
+                return null;
+            // 版本兼容性检查
+            if (state.version !== 1) {
+                console.warn(`[ProgressTracker] 不支持的进度版本: ${state.version}`);
+                return null;
+            }
+            // 向后兼容：如果没有 seenKeys，从 seenNoteIds 生成
+            if (!state.seenKeys && state.seenNoteIds) {
+                state.seenKeys = state.seenNoteIds.map(noteId => `${noteId}||`);
+                console.log(`[ProgressTracker] 兼容旧版本进度文件，从 seenNoteIds 生成 ${state.seenKeys.length} 个 seenKeys`);
+            }
+            console.log(`[ProgressTracker] 发现保存的进度: ${state.collectedCount} 条, 最后更新: ${state.updatedAt}`);
+            return state;
+        }
+        catch (err) {
+            console.warn(`[ProgressTracker] 加载进度失败: ${err.message}`);
+            return null;
+        }
+    }
+    /**
+     * 生成去重键
+     *
+     * @param noteId - 笔记 ID
+     * @param containerId - 容器 ID（可选）
+     * @returns 去重键：noteId||containerId
+     */
+    static makeDedupeKey(noteId, containerId) {
+        return `${noteId}||${containerId || ''}`;
+    }
+    /**
+     * 解析去重键
+     *
+     * @param key - 去重键
+     * @returns DedupeEntry
+     */
+    static parseDedupeKey(key) {
+        const [noteId, containerId] = key.split('||');
+        return {
+            noteId: noteId || '',
+            containerId: containerId || '',
+            key
+        };
+    }
+    /**
+     * 清理进度文件（任务成功完成后调用）
+     */
+    async cleanup() {
+        try {
+            await fs.unlink(this.progressPath);
+            console.log('[ProgressTracker] 进度文件已清理');
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                console.warn(`[ProgressTracker] 清理进度文件失败: ${err.message}`);
+            }
+        }
+    }
+    /**
+     * 检查是否存在保存的进度
+     */
+    async exists() {
+        try {
+            await fs.access(this.progressPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+/**
+ * 便捷函数：创建进度跟踪器
+ */
+export function createProgressTracker(dataDir, sessionId) {
+    return new ProgressTracker(dataDir, sessionId);
+}
+//# sourceMappingURL=ProgressTracker.js.map

package/dist/modules/workflow/blocks/RecordFixtureBlock.js

@@ -0,0 +1,44 @@
+/**
+ * RecordFixtureBlock
+ *
+ * 通用 fixture 录制 Block，将结构化数据写入用户目录：
+ *   ~/.webauto/fixtures/{platform}/{category}-{id}.json
+ */
+import os from 'node:os';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+export async function execute(input) {
+    const { platform, category, id, data } = input;
+    if (!platform || !category || !id) {
+        return {
+            success: false,
+            error: 'platform, category and id are required',
+        };
+    }
+    try {
+        const homeDir = os.homedir();
+        const baseDir = path.join(homeDir, '.webauto', 'fixtures', platform);
+        await fs.mkdir(baseDir, { recursive: true });
+        const filename = `${category}-${id}.json`;
+        const filePath = path.join(baseDir, filename);
+        const payload = {
+            platform,
+            category,
+            id,
+            capturedAt: new Date().toISOString(),
+            data,
+        };
+        await fs.writeFile(filePath, JSON.stringify(payload, null, 2), 'utf-8');
+        return {
+            success: true,
+            path: filePath,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: err?.message || String(err),
+        };
+    }
+}
+//# sourceMappingURL=RecordFixtureBlock.js.map

package/dist/modules/workflow/blocks/RenderMarkdown.js

@@ -0,0 +1,48 @@
+/**
+ * Workflow Block: RenderMarkdown
+ *
+ * 渲染 Markdown 输出
+ */
+/**
+ * 渲染 Markdown
+ *
+ * @param input - 输入参数
+ * @returns RenderMarkdownOutput
+ */
+export async function execute(input) {
+    const { posts, template = 'default' } = input;
+    if (!posts || !Array.isArray(posts)) {
+        return {
+            markdown: '',
+            count: 0,
+            error: 'Invalid posts data'
+        };
+    }
+    const lines = [];
+    lines.push(`# 微博采集结果`);
+    lines.push(`采集时间: ${new Date().toISOString()}`);
+    lines.push(`总计: ${posts.length} 条`);
+    lines.push('');
+    posts.forEach((post, index) => {
+        lines.push(`## ${index + 1}`);
+        if (post.author) {
+            lines.push(`**作者**: ${post.author}`);
+        }
+        if (post.time) {
+            lines.push(`**时间**: ${post.time}`);
+        }
+        if (post.postLinks && post.postLinks.length > 0) {
+            lines.push(`**帖子链接**: ${post.postLinks[0]}`);
+        }
+        lines.push('');
+        lines.push(post.content || '(无内容)');
+        lines.push('');
+        lines.push('---');
+        lines.push('');
+    });
+    return {
+        markdown: lines.join('\n'),
+        count: posts.length
+    };
+}
+//# sourceMappingURL=RenderMarkdown.js.map