helixlife-expert-cli 0.1.0

package/cli/dist/modules/meta/writing.js

@@ -0,0 +1,1077 @@
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { ApiClient, createStderrProgress, helixlifeError, helixlifeErrorCode, printOutput, renderListAsMarkdown } from "../../core/index.js";
+import { requestMeta } from "./api.js";
+import { META_API_PREFIX, META_FULLTEXT_WAIT_HINT } from "./constants.js";
+import { createMetaNode, getMetaNodeOutput, pollMetaNodeStatus } from "./node.js";
+import { exportFinalPrismaWordArtifact, exportPrismaFlow } from "./analysis.js";
+import { exportFinalExtractionMarkdownArtifacts } from "./extraction.js";
+import { exportFinalScreeningMarkdownArtifacts } from "./screening.js";
+const META_WRITING_NODE_TYPES = {
+    PICOS: "generate_picos",
+    CRITERIA: "generate_sorting_criteria",
+    BASELINE: "baseline_information",
+    EFFECT: "effect_quantity",
+    BIAS: "publication_bias",
+    ASSESSMENT: "quality_assessment_plot",
+    METHOD: "generate_method",
+    RESULT: "generate_outcome",
+    FULLTEXT: "generate_fulltext",
+};
+/** 方法 get 后必须原文完整展示正文与产物，禁止摘要代替。 */
+const WRITING_METHOD_DISPLAY_INSTRUCTION = "必须将响应 text 原文逐字完整输出到对话，并交付 artifact（方法.md）；" +
+    "禁止摘要、截断、润色；禁止用「方法已生成」「方法正文已完整展示」「含 N 个章节」或章节名清单代替正文；" +
+    "未在回复中贴出方法正文原文即视为交付失败；展示后按操作选项以 Markdown 无序列表列出后停顿，禁止弹选择器，禁止用 / 同行拼接。";
+/** 结果：交付产物，且回复文本中也要展示部分正文预览。 */
+const WRITING_RESULT_DISPLAY_INSTRUCTION = "交付并展示 artifact（结果.md）；获取结果后回复文本中也要展示开头若干段原文，随后输出 ...，并提示「详细内容可查看文档产物」；" +
+    "禁止只用「结果已生成」而无预览；禁止只列操作选项却不展示产物；展示后按操作选项以 Markdown 无序列表列出后停顿，禁止弹选择器，禁止用 / 同行拼接。";
+/** 生成初稿：交付整包最终产物，且回复文本中也要展示部分正文预览。 */
+const WRITING_FULLTEXT_DISPLAY_INSTRUCTION = "必须交付并展示全部 artifact：初筛结果.xlsx、复筛结果.xlsx、质量评估.xlsx、结局指标.xlsx、PRISMA流程图.docx、PRISMA流程图.pdf、生成初稿.docx；" +
+    "若响应含 text，回复文本中也要展示开头若干段原文后接 ...，并提示「详细内容可查看文档产物」；" +
+    "禁止只交付生成初稿.docx 而省略其余产物；结束后不弹选择器。";
+/**
+ * 下载生成初稿同次交付的配套产物（筛选/抽提 xlsx + PRISMA docx/pdf）。
+ */
+async function exportFullTextCompanionArtifacts(options) {
+    const [screeningArtifacts, extractionArtifacts, prismaDocx, prismaPdf] = await Promise.all([
+        exportFinalScreeningMarkdownArtifacts({
+            workflowId: options.workflowId,
+            configPath: options.configPath,
+            output: options.outputDirectory,
+        }),
+        exportFinalExtractionMarkdownArtifacts({
+            workflowId: options.workflowId,
+            configPath: options.configPath,
+            output: options.outputDirectory,
+        }),
+        exportFinalPrismaWordArtifact({
+            workflowId: options.workflowId,
+            configPath: options.configPath,
+            output: options.outputDirectory,
+        }),
+        exportPrismaFlow({
+            workflowId: options.workflowId,
+            configPath: options.configPath,
+            output: options.outputDirectory,
+            exportFormat: "pdf",
+        }),
+    ]);
+    return [
+        ...screeningArtifacts,
+        ...extractionArtifacts,
+        prismaDocx,
+        prismaPdf,
+    ];
+}
+function parseJsonObject(raw, optionName) {
+    const jsonText = raw?.replace(/^\uFEFF/, "").trim();
+    if (!jsonText) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(jsonText);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error("not an object");
+        }
+        return parsed;
+    }
+    catch {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `${optionName} 必须是合法 JSON 对象`);
+    }
+}
+async function parseJsonObjectInput(raw, filePath) {
+    if (filePath?.trim()) {
+        const content = await readFile(filePath.trim(), "utf8");
+        return parseJsonObject(content, "--input-file");
+    }
+    return parseJsonObject(raw, "--input-json");
+}
+async function readTextInput(text, filePath) {
+    if (filePath?.trim()) {
+        return readFile(filePath.trim(), "utf8");
+    }
+    if (text === undefined) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "缺少 --text 或 --text-file");
+    }
+    return text;
+}
+/**
+ * 判断流程命令是否携带了需要同步到上一节点的正文。
+ *
+ * @param text 命令行直接传入的正文。
+ * @param filePath 正文文件路径。
+ * @returns 任一正文来源已提供时返回 true。
+ */
+function hasTextInput(text, filePath) {
+    return text !== undefined || Boolean(filePath?.trim());
+}
+/**
+ * 从写作接口响应中尝试读取完整正文。
+ *
+ * @param data 写作生成、查询或节点输出接口返回的数据。
+ * @returns 响应中存在非空 `text` 正文时返回该正文；否则返回 undefined。
+ */
+function tryExtractWritingText(data) {
+    if (typeof data === "string" && data.trim()) {
+        return data;
+    }
+    if (data && typeof data === "object") {
+        const payload = data;
+        const text = payload.text;
+        if (typeof text === "string" && text.trim()) {
+            return text;
+        }
+        const nestedData = tryExtractWritingText(payload.data);
+        if (nestedData) {
+            return nestedData;
+        }
+        const nestedOutput = tryExtractWritingText(payload.output);
+        if (nestedOutput) {
+            return nestedOutput;
+        }
+    }
+    return undefined;
+}
+function tryExtractWritingImages(data) {
+    if (!data || typeof data !== "object") {
+        return undefined;
+    }
+    const payload = data;
+    const images = payload.images;
+    if (images && typeof images === "object" && !Array.isArray(images)) {
+        const entries = Object.entries(images).filter((entry) => typeof entry[1] === "string" && entry[1].trim().length > 0);
+        if (entries.length > 0) {
+            return Object.fromEntries(entries);
+        }
+    }
+    return tryExtractWritingImages(payload.data) ?? tryExtractWritingImages(payload.output);
+}
+function imageMarkdownUrl(imageData) {
+    return imageData.startsWith("data:")
+        ? imageData
+        : `data:image/png;base64,${imageData}`;
+}
+function insertWritingResultImages(text, images) {
+    if (!images) {
+        return text;
+    }
+    const textWithPlots = text.replace(/\{insert-(\S+?)-plot\}/g, (match, placeholderKey) => {
+        const imageData = images[`${placeholderKey.replaceAll("-", "_")}_plot`];
+        return imageData
+            ? `![insert-${placeholderKey}-plot](${imageMarkdownUrl(imageData)})`
+            : match;
+    });
+    const prismaPlot = images.prisma_plot;
+    return prismaPlot
+        ? textWithPlots.replaceAll("{PRISMA流程图}", `![PRISMA流程图](${imageMarkdownUrl(prismaPlot)})`)
+        : textWithPlots;
+}
+/**
+ * 保存结果正文前，将展示用嵌入图还原为后端占位符。
+ *
+ * @param text 可能含 data URL 图的 Markdown 正文。
+ * @returns 还原占位符后的正文。
+ */
+function stripWritingResultImages(text) {
+    const withoutPlots = text.replace(/!\[insert-(\S+?)-plot\]\((?:data:image\/[^)]+|https?:\/\/[^)]+)\)/g, (_match, placeholderKey) => `{insert-${placeholderKey.replaceAll("_", "-")}-plot}`);
+    return withoutPlots.replace(/!\[PRISMA流程图\]\((?:data:image\/[^)]+|https?:\/\/[^)]+)\)/g, "{PRISMA流程图}");
+}
+/**
+ * 从全文查询响应中读取用于 Word 导出的正文。
+ *
+ * @param data 全文查询接口返回的数据。
+ * @returns 完整全文正文。
+ * @throws {helixlifeError} 响应中不存在可导出的正文时抛出。
+ */
+function extractWritingText(data) {
+    const text = tryExtractWritingText(data);
+    if (text) {
+        return text;
+    }
+    throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, "全文生成成功，但响应中缺少可导出的正文");
+}
+function extractNodePayload(node) {
+    if (!node) {
+        return {};
+    }
+    const output = node.output;
+    if (output && typeof output === "object") {
+        const outputObject = output;
+        if (outputObject.output && typeof outputObject.output === "object") {
+            return outputObject.output;
+        }
+        return outputObject;
+    }
+    if (node.input && typeof node.input === "object") {
+        return node.input;
+    }
+    return {};
+}
+function extractNodeOutput(node) {
+    if (node.output && typeof node.output === "object" && "output" in node.output) {
+        return node.output.output;
+    }
+    return node.output ?? {};
+}
+function joinSortingCriteria(output) {
+    let data = "";
+    if (output.inclusion_criteria) {
+        data += `Inclusion criteria include: ${String(output.inclusion_criteria)}\n\n`;
+    }
+    if (output.exclusion_criteria) {
+        data += `Exclusion criteria include: ${String(output.exclusion_criteria)}`;
+    }
+    return data;
+}
+async function getWorkflow(workflowId, configPath) {
+    return requestMeta(`${META_API_PREFIX}/workflow/runs/${encodeURIComponent(workflowId)}`, { configPath, action: "查询 Meta 工作流" });
+}
+function findLatestNode(workflow, nodeType) {
+    return [...(workflow.nodes ?? [])].reverse().find((node) => node.node_type === nodeType);
+}
+function inferTitle(workflow) {
+    const picosNode = findLatestNode(workflow, META_WRITING_NODE_TYPES.PICOS);
+    const picosInput = picosNode?.input;
+    if (typeof picosInput?.title === "string" && picosInput.title.trim()) {
+        return picosInput.title.trim();
+    }
+    const topicNode = findLatestNode(workflow, "generate_topic");
+    const topicOutput = extractNodePayload(topicNode);
+    const selected = topicOutput.selected;
+    if (typeof selected?.English === "string" && selected.English.trim()) {
+        return selected.English.trim();
+    }
+    if (typeof selected?.Chinese === "string" && selected.Chinese.trim()) {
+        return selected.Chinese.trim();
+    }
+    return "";
+}
+async function resolveNodeId(options) {
+    if (options.nodeId?.trim()) {
+        return options.nodeId.trim();
+    }
+    const workflow = await getWorkflow(options.workflowId, options.configPath);
+    const node = findLatestNode(workflow, options.nodeType);
+    if (!node) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `当前工作流中未找到 ${options.label} 节点`);
+    }
+    return node.id;
+}
+function writingMeta(kind) {
+    if (kind === "method") {
+        return { nodeType: META_WRITING_NODE_TYPES.METHOD, getPath: "generate-method", editPath: "generate-method/edit", label: "方法内容" };
+    }
+    if (kind === "result") {
+        return { nodeType: META_WRITING_NODE_TYPES.RESULT, getPath: "generate-outcome", editPath: "generate-outcome/edit", label: "结果内容" };
+    }
+    return { nodeType: META_WRITING_NODE_TYPES.FULLTEXT, getPath: "generate-fulltext", editPath: "generate-fulltext/edit", label: "全文内容" };
+}
+async function buildMethodInput(options) {
+    const workflow = await getWorkflow(options.workflowId, options.configPath);
+    const picosNode = findLatestNode(workflow, META_WRITING_NODE_TYPES.PICOS);
+    const criteriaNode = findLatestNode(workflow, META_WRITING_NODE_TYPES.CRITERIA);
+    const picos = extractNodePayload(picosNode);
+    const criteria = extractNodePayload(criteriaNode);
+    const overrides = await parseJsonObjectInput(options.inputJson, options.inputFile);
+    const title = options.title?.trim() || inferTitle(workflow);
+    return {
+        criteria: joinSortingCriteria(criteria),
+        ...picos,
+        title,
+        language: options.language?.trim() || "English",
+        ...overrides,
+    };
+}
+async function buildWritingResultInput(options) {
+    const workflow = await getWorkflow(options.workflowId, options.configPath);
+    const params = {};
+    for (const node of workflow.nodes ?? []) {
+        if (node.node_type === META_WRITING_NODE_TYPES.BASELINE) {
+            params.baseline_info_node_id = node.id;
+        }
+        if (node.node_type === META_WRITING_NODE_TYPES.EFFECT) {
+            params.effect_quantity_plot_node_id = node.id;
+        }
+        if (node.node_type === META_WRITING_NODE_TYPES.BIAS) {
+            params.publication_bias_plot_node_id = node.id;
+        }
+        if (node.node_type === META_WRITING_NODE_TYPES.ASSESSMENT) {
+            params.quality_assessment_plot_node_id = node.id;
+        }
+        if (node.node_type === META_WRITING_NODE_TYPES.METHOD) {
+            const input = node.input;
+            params.language = input?.language;
+        }
+    }
+    const overrides = await parseJsonObjectInput(options.inputJson, options.inputFile);
+    return {
+        title: options.title?.trim() || inferTitle(workflow),
+        ...params,
+        ...overrides,
+    };
+}
+async function buildFullTextInput(options) {
+    const workflow = await getWorkflow(options.workflowId, options.configPath);
+    const params = {};
+    for (const node of workflow.nodes ?? []) {
+        if (node.node_type === META_WRITING_NODE_TYPES.METHOD) {
+            params.generate_method_node_id = node.id;
+            const input = node.input;
+            params.language = input?.language;
+        }
+        if (node.node_type === META_WRITING_NODE_TYPES.RESULT) {
+            params.generate_outcome_node_id = node.id;
+        }
+    }
+    return params;
+}
+/**
+ * 读取后端已保存的 PRISMA 图片，并转换成全文生成接口需要的 base64 字符串。
+ *
+ * @param options 当前 Meta 工作流参数。
+ * @returns 可传给 `prisma_image` 的 base64 内容；没有图片时返回 undefined。
+ */
+async function queryPrismaImageForFullText(options) {
+    const data = await requestMeta(`${META_API_PREFIX}/prisma/image`, {
+        params: { run_id: options.workflowId },
+        configPath: options.configPath,
+        action: "获取 PRISMA 图片",
+    });
+    const payload = data && typeof data === "object" && "data" in data ? data.data : data;
+    if (!payload || typeof payload !== "object") {
+        return undefined;
+    }
+    const image = payload.image;
+    if (typeof image !== "string" || !image.trim()) {
+        return undefined;
+    }
+    return image.includes(",") ? image.split(",").pop() : image;
+}
+/**
+ * 校验当前工作流已经生成并上传 PRISMA PNG，阻止写作节点越过统计分析最后一步。
+ *
+ * @param options 当前 Meta 工作流参数。
+ * @returns 后端已保存的 PRISMA PNG base64 内容。
+ */
+async function requirePrismaImage(options) {
+    const image = await queryPrismaImageForFullText(options);
+    if (!image) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "尚未完成 PRISMA 流程图：请先生成、上传并确认最新 PRISMA PNG，之后才能进入辅助写作");
+    }
+    return image;
+}
+async function createMethod(options) {
+    await requirePrismaImage(options);
+    const input = await buildMethodInput(options);
+    const progress = createStderrProgress(options.format === "json");
+    progress.start("正在生成方法内容...");
+    try {
+        const created = await createMetaNode({
+            workflowId: options.workflowId,
+            nodeType: META_WRITING_NODE_TYPES.METHOD,
+            input,
+            configPath: options.configPath,
+        });
+        await pollMetaNodeStatus({ workflowId: options.workflowId, nodeId: created.nodeId, configPath: options.configPath });
+        const output = await getMetaNodeOutput({ workflowId: options.workflowId, nodeId: created.nodeId, configPath: options.configPath });
+        progress.finish("方法内容生成完成，正在输出结果...");
+        return {
+            runnerId: options.workflowId,
+            nodeId: created.nodeId,
+            nodeType: META_WRITING_NODE_TYPES.METHOD,
+            status: output.data.status,
+            input,
+            output: extractNodeOutput(output.data),
+            node: output.data,
+        };
+    }
+    catch (error) {
+        progress.dispose();
+        throw error;
+    }
+}
+async function createResult(options) {
+    await requirePrismaImage(options);
+    if (hasTextInput(options.methodText, options.methodTextFile)) {
+        await saveWriting("method", {
+            workflowId: options.workflowId,
+            nodeId: options.methodNodeId,
+            text: options.methodText,
+            textFile: options.methodTextFile,
+            configPath: options.configPath,
+        });
+    }
+    const input = await buildWritingResultInput(options);
+    const progress = createStderrProgress(options.format === "json");
+    progress.start("正在生成结果内容...");
+    try {
+        const created = await requestMeta(`${META_API_PREFIX}/generate-outcome/execute`, {
+            method: "POST",
+            params: { run_id: options.workflowId },
+            body: input,
+            configPath: options.configPath,
+            action: "生成结果内容",
+        });
+        if (!created.node_id) {
+            throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, "生成结果内容响应缺少 node_id");
+        }
+        await pollMetaNodeStatus({ workflowId: options.workflowId, nodeId: created.node_id, configPath: options.configPath });
+        const output = await getMetaNodeOutput({ workflowId: options.workflowId, nodeId: created.node_id, configPath: options.configPath });
+        progress.finish("结果内容生成完成，正在输出结果...");
+        return {
+            runnerId: options.workflowId,
+            nodeId: created.node_id,
+            nodeType: META_WRITING_NODE_TYPES.RESULT,
+            status: output.data.status,
+            input,
+            output: extractNodeOutput(output.data),
+            node: output.data,
+        };
+    }
+    catch (error) {
+        progress.dispose();
+        throw error;
+    }
+}
+async function createFullText(options) {
+    if (hasTextInput(options.resultText, options.resultTextFile)) {
+        await saveWriting("result", {
+            workflowId: options.workflowId,
+            nodeId: options.resultNodeId,
+            text: options.resultText,
+            textFile: options.resultTextFile,
+            configPath: options.configPath,
+        });
+    }
+    else {
+        const currentResult = await getWriting("result", {
+            workflowId: options.workflowId,
+            nodeId: options.resultNodeId,
+            configPath: options.configPath,
+        });
+        const resultText = prepareWritingText("result", currentResult.data)
+            ?? extractWritingText(currentResult.data);
+        await saveWriting("result", {
+            workflowId: options.workflowId,
+            nodeId: currentResult.nodeId,
+            text: resultText,
+            configPath: options.configPath,
+        });
+    }
+    const prismaImage = await requirePrismaImage(options);
+    const input = await buildFullTextInput(options);
+    input.prisma_image = prismaImage;
+    // 初稿全文+产物导出耗时长，启动前提示用户耐心等待
+    process.stderr.write(`${META_FULLTEXT_WAIT_HINT}\n`);
+    const progress = createStderrProgress(options.format === "json");
+    progress.start("正在生成全文内容...");
+    try {
+        const created = await requestMeta(`${META_API_PREFIX}/generate-fulltext/execute`, {
+            method: "POST",
+            params: { run_id: options.workflowId },
+            body: input,
+            configPath: options.configPath,
+            action: "生成全文内容",
+        });
+        if (!created.node_id) {
+            throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, "生成全文内容响应缺少 node_id");
+        }
+        await pollMetaNodeStatus({ workflowId: options.workflowId, nodeId: created.node_id, configPath: options.configPath });
+        const output = await getMetaNodeOutput({ workflowId: options.workflowId, nodeId: created.node_id, configPath: options.configPath });
+        progress.finish("全文内容生成完成，正在输出结果...");
+        return {
+            runnerId: options.workflowId,
+            nodeId: created.node_id,
+            nodeType: META_WRITING_NODE_TYPES.FULLTEXT,
+            status: output.data.status,
+            input,
+            output: extractNodeOutput(output.data),
+            node: output.data,
+        };
+    }
+    catch (error) {
+        progress.dispose();
+        throw error;
+    }
+}
+async function getWriting(kind, options) {
+    const meta = writingMeta(kind);
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: meta.nodeType,
+        label: meta.label,
+        configPath: options.configPath,
+    });
+    const data = await requestMeta(`${META_API_PREFIX}/${meta.getPath}`, {
+        params: { run_id: options.workflowId, node_id: nodeId },
+        configPath: options.configPath,
+        action: `获取${meta.label}`,
+    });
+    return { runnerId: options.workflowId, nodeId, data };
+}
+async function saveWriting(kind, options) {
+    const meta = writingMeta(kind);
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: meta.nodeType,
+        label: meta.label,
+        configPath: options.configPath,
+    });
+    const rawText = await readTextInput(options.text, options.textFile);
+    // 结果节点：提交前去掉展示嵌入图，只保留占位符
+    const text = kind === "result" ? stripWritingResultImages(rawText) : rawText;
+    const data = await requestMeta(`${META_API_PREFIX}/${meta.editPath}`, {
+        method: "POST",
+        params: { run_id: options.workflowId, node_id: nodeId },
+        body: { text },
+        configPath: options.configPath,
+        action: `保存${meta.label}`,
+    });
+    return { runnerId: options.workflowId, nodeId, input: { text }, data };
+}
+async function rerunWriting(kind, options) {
+    const meta = writingMeta(kind);
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: meta.nodeType,
+        label: meta.label,
+        configPath: options.configPath,
+    });
+    const data = await requestMeta(`${META_API_PREFIX}/nodes/re-execute`, {
+        method: "POST",
+        body: { run_id: options.workflowId, node_id: nodeId, node_type: meta.nodeType },
+        configPath: options.configPath,
+        action: `重新生成${meta.label}`,
+    });
+    await pollMetaNodeStatus({ workflowId: options.workflowId, nodeId, configPath: options.configPath });
+    return { runnerId: options.workflowId, nodeId, data };
+}
+function normalizeExportFilename(filename, extension) {
+    const safeName = basename(filename.trim()).replace(/[<>:"/\\|?*\u0000-\u001F]/g, "_");
+    if (!safeName || safeName === "." || safeName === "..") {
+        return `全文.${extension}`;
+    }
+    return extname(safeName).toLowerCase() === `.${extension.toLowerCase()}`
+        ? safeName
+        : `${safeName}.${extension}`;
+}
+function validateDocxBuffer(buffer, source) {
+    if (buffer.length < 4 || buffer.subarray(0, 4).toString("binary") !== "PK\u0003\u0004") {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, `${source}不是有效的 DOCX：缺少 ZIP/OOXML 文件头`);
+    }
+    const binary = buffer.toString("binary");
+    for (const entry of ["[Content_Types].xml", "word/document.xml"]) {
+        if (!binary.includes(entry)) {
+            throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, `${source}不是有效的 DOCX：缺少 ${entry}`);
+        }
+    }
+}
+async function exportFullText(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_WRITING_NODE_TYPES.FULLTEXT,
+        label: "全文内容",
+        configPath: options.configPath,
+    });
+    const hasExplicitText = options.text !== undefined || Boolean(options.textFile?.trim());
+    let text;
+    if (hasExplicitText) {
+        text = await readTextInput(options.text, options.textFile);
+    }
+    else {
+        const currentFullText = await getWriting("fulltext", {
+            workflowId: options.workflowId,
+            nodeId,
+            configPath: options.configPath,
+        });
+        text = prepareWritingText("fulltext", currentFullText.data)
+            ?? extractWritingText(currentFullText.data);
+    }
+    const exportFormat = options.exportFormat?.trim() || "docx";
+    if (!text.trim()) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "全文正文为空，禁止导出空 Word 文件");
+    }
+    const workflow = await getWorkflow(options.workflowId, options.configPath);
+    const requestFilename = normalizeExportFilename(options.filename?.trim() || inferTitle(workflow) || "全文", exportFormat);
+    const client = new ApiClient();
+    const result = await client.requestBinary(`${META_API_PREFIX}/generate-fulltext/export`, {
+        method: "POST",
+        params: { run_id: options.workflowId, node_id: nodeId, format: exportFormat },
+        body: { filename: requestFilename, text },
+    });
+    if (exportFormat.toLowerCase() === "docx") {
+        validateDocxBuffer(result.buffer, "后端导出响应");
+    }
+    const responseFilename = options.filename?.trim()
+        ? requestFilename
+        : normalizeExportFilename(result.filename ?? requestFilename, exportFormat);
+    const outputTarget = options.output?.trim();
+    const outputStat = outputTarget ? await stat(outputTarget).catch(() => undefined) : undefined;
+    const outputPath = resolve(!outputTarget
+        ? responseFilename
+        : outputStat?.isDirectory() || outputTarget.endsWith("/") || outputTarget.endsWith("\\")
+            ? join(outputTarget, responseFilename)
+            : extname(outputTarget).toLowerCase() === `.${exportFormat.toLowerCase()}`
+                ? outputTarget
+                : outputStat?.isFile()
+                    ? `${outputTarget}.${exportFormat}`
+                    : join(outputTarget, responseFilename));
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, result.buffer);
+    const savedBuffer = await readFile(outputPath);
+    if (savedBuffer.length !== result.buffer.length) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, `Word 文件写入不完整：期望 ${result.buffer.length} 字节，实际 ${savedBuffer.length} 字节`);
+    }
+    if (exportFormat.toLowerCase() === "docx") {
+        validateDocxBuffer(savedBuffer, "本地 Word 文件");
+    }
+    return {
+        runnerId: options.workflowId,
+        nodeId,
+        output: outputPath,
+        filename: responseFilename,
+        contentType: result.contentType ?? undefined,
+        size: savedBuffer.length,
+    };
+}
+/**
+ * 按写作节点的展示规则输出完整正文和节点信息。
+ *
+ * @param kind 写作节点类型。
+ * @param text 后端返回的完整正文。
+ * @param result 节点执行结果。
+ */
+function printWritingText(kind, text, result) {
+    console.log(`## ${writingMeta(kind).label}`);
+    console.log("");
+    console.log(text);
+    if (!result) {
+        return;
+    }
+    console.log("");
+    console.log(renderListAsMarkdown([{ runnerId: result.runnerId, nodeId: result.nodeId, nodeType: result.nodeType, status: result.status }], [
+        { key: "runnerId", label: "runnerId" },
+        { key: "nodeId", label: "nodeId" },
+        { key: "nodeType", label: "node_type" },
+        { key: "status", label: "status" },
+    ]));
+}
+function prepareWritingText(kind, data) {
+    const text = tryExtractWritingText(data);
+    if (!text) {
+        return undefined;
+    }
+    return kind === "result" || kind === "fulltext"
+        ? insertWritingResultImages(text, tryExtractWritingImages(data))
+        : text;
+}
+function replaceWritingText(data, text) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+        return data;
+    }
+    return { ...data, text };
+}
+async function writeWritingMarkdown(kind, text, output) {
+    const filename = kind === "method"
+        ? "方法.md"
+        : kind === "result"
+            ? "结果.md"
+            : "全文.md";
+    const target = output?.trim();
+    const targetStat = target ? await stat(target).catch(() => undefined) : undefined;
+    const requestedPath = !target
+        ? join(".", filename)
+        : targetStat?.isDirectory() || target.endsWith("/") || target.endsWith("\\")
+            ? join(target, filename)
+            : extname(target).toLowerCase() === ".md"
+                ? target
+                : extname(target)
+                    ? join(dirname(target), filename)
+                    : join(target, filename);
+    const outputPath = resolve(requestedPath);
+    await mkdir(dirname(outputPath), { recursive: true });
+    const buffer = Buffer.from(text, "utf8");
+    await writeFile(outputPath, buffer);
+    return {
+        output: outputPath,
+        filename: outputPath.split(/[\\/]/).pop() || filename,
+        contentType: "text/markdown; charset=utf-8",
+        size: buffer.length,
+    };
+}
+function printWritingArtifact(artifact) {
+    console.log(renderListAsMarkdown([artifact], [
+        { key: "output", label: "output" },
+        { key: "filename", label: "filename" },
+        { key: "contentType", label: "contentType" },
+        { key: "size", label: "size" },
+    ]));
+}
+/**
+ * 输出写作节点创建结果。
+ *
+ * @param kind 写作节点类型。
+ * @param result 节点创建和执行结果。
+ * @param format 输出格式。
+ */
+function printStepResult(kind, result, format) {
+    const text = prepareWritingText(kind, result.output);
+    if (format === "json") {
+        printOutput(text ? { ...result, text } : result, "json");
+        return;
+    }
+    if (text) {
+        printWritingText(kind, text, result);
+        return;
+    }
+    console.log(renderListAsMarkdown([{ runnerId: result.runnerId, nodeId: result.nodeId, nodeType: result.nodeType, status: result.status }], [
+        { key: "runnerId", label: "runnerId" },
+        { key: "nodeId", label: "nodeId" },
+        { key: "nodeType", label: "node_type" },
+        { key: "status", label: "status" },
+    ]));
+}
+/**
+ * 输出写作节点查询、保存或重跑结果。
+ *
+ * @param result 操作结果。
+ * @param format 输出格式。
+ * @param kind 写作节点类型；传入时会优先展示完整正文。
+ */
+function printActionResult(result, format, kind) {
+    const text = kind ? prepareWritingText(kind, result) : undefined;
+    if (format === "json") {
+        if (text && result && typeof result === "object" && !Array.isArray(result)) {
+            const payload = result;
+            printOutput({
+                ...payload,
+                data: replaceWritingText(payload.data, text),
+                text,
+            }, "json");
+            return;
+        }
+        printOutput(result, "json");
+        return;
+    }
+    if (kind && text) {
+        printWritingText(kind, text);
+        return;
+    }
+    console.log(renderListAsMarkdown([result], [{ key: "runnerId", label: "runnerId" }, { key: "nodeId", label: "nodeId" }]));
+}
+export async function runCreateWritingMethod(options) {
+    const created = await createMethod(options);
+    const result = await getWriting("method", {
+        workflowId: options.workflowId,
+        nodeId: created.nodeId,
+        configPath: options.configPath,
+    });
+    const text = prepareWritingText("method", result);
+    if (!text) {
+        printStepResult("method", created, options.format ?? "markdown");
+        return;
+    }
+    const artifact = await writeWritingMarkdown("method", text, options.output);
+    if ((options.format ?? "markdown") === "json") {
+        // JSON 带回完整 text，供 Agent 原文逐字完整展示方法正文
+        printOutput({
+            runnerId: created.runnerId,
+            nodeId: created.nodeId,
+            artifact,
+            text,
+            displayInstruction: WRITING_METHOD_DISPLAY_INSTRUCTION,
+        }, "json");
+        return;
+    }
+    printWritingArtifact(artifact);
+}
+export async function runGetWritingMethod(options) {
+    const result = await getWriting("method", options);
+    const text = prepareWritingText("method", result);
+    if (!text) {
+        printActionResult(result, options.format ?? "markdown", "method");
+        return;
+    }
+    const artifact = await writeWritingMarkdown("method", text, options.output);
+    if ((options.format ?? "markdown") === "json") {
+        // JSON 带回完整 text，供 Agent 原文逐字完整展示方法正文
+        printOutput({
+            runnerId: result.runnerId,
+            nodeId: result.nodeId,
+            artifact,
+            text,
+            displayInstruction: WRITING_METHOD_DISPLAY_INSTRUCTION,
+        }, "json");
+        return;
+    }
+    printWritingArtifact(artifact);
+}
+export async function runRerunWritingMethod(options) {
+    const rerun = await rerunWriting("method", options);
+    const result = await getWriting("method", {
+        workflowId: options.workflowId,
+        nodeId: rerun.nodeId,
+        configPath: options.configPath,
+    });
+    const text = prepareWritingText("method", result);
+    if (!text) {
+        printActionResult(rerun, options.format ?? "markdown");
+        return;
+    }
+    const artifact = await writeWritingMarkdown("method", text, options.output);
+    if ((options.format ?? "markdown") === "json") {
+        // JSON 带回完整 text，供 Agent 原文逐字完整展示方法正文
+        printOutput({
+            runnerId: result.runnerId,
+            nodeId: result.nodeId,
+            artifact,
+            text,
+            displayInstruction: WRITING_METHOD_DISPLAY_INSTRUCTION,
+        }, "json");
+        return;
+    }
+    printWritingArtifact(artifact);
+}
+/**
+ * 用户编辑方法正文后立即保存（不等下一步）。
+ */
+export async function runUpdateWritingMethod(options) {
+    await saveWriting("method", options);
+    const result = await getWriting("method", {
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        configPath: options.configPath,
+    });
+    const text = prepareWritingText("method", result);
+    if (!text) {
+        printActionResult(result, options.format ?? "markdown", "method");
+        return;
+    }
+    const artifact = await writeWritingMarkdown("method", text, options.output);
+    if ((options.format ?? "markdown") === "json") {
+        printOutput({
+            runnerId: result.runnerId,
+            nodeId: result.nodeId,
+            artifact,
+            text,
+            displayInstruction: WRITING_METHOD_DISPLAY_INSTRUCTION,
+        }, "json");
+        return;
+    }
+    printWritingArtifact(artifact);
+}
+export async function runCreateWritingResult(options) {
+    const result = await createResult(options);
+    const saved = await getWriting("result", {
+        workflowId: options.workflowId,
+        nodeId: result.nodeId,
+        configPath: options.configPath,
+    });
+    const text = prepareWritingText("result", saved);
+    const artifact = text ? await writeWritingMarkdown("result", text, options.output) : undefined;
+    if ((options.format ?? "markdown") === "json") {
+        printOutput(text
+            ? {
+                runnerId: result.runnerId,
+                nodeId: result.nodeId,
+                nodeType: result.nodeType,
+                status: result.status,
+                artifact,
+                // JSON 带回完整 text；对话仅部分预览，完整内容见 artifact
+                text,
+                displayInstruction: WRITING_RESULT_DISPLAY_INSTRUCTION,
+            }
+            : result, "json");
+        return;
+    }
+    if (text) {
+        if (artifact) {
+            printWritingArtifact(artifact);
+        }
+        return;
+    }
+    printStepResult("result", result, options.format ?? "markdown");
+}
+export async function runGetWritingResult(options) {
+    const result = await getWriting("result", options);
+    const text = prepareWritingText("result", result);
+    if (!text) {
+        printActionResult(result, options.format ?? "markdown", "result");
+        return;
+    }
+    const artifact = await writeWritingMarkdown("result", text, options.output);
+    if ((options.format ?? "markdown") === "json") {
+        // JSON 带回完整 text；对话仅部分预览，完整内容见 artifact
+        printOutput({
+            runnerId: result.runnerId,
+            nodeId: result.nodeId,
+            artifact,
+            text,
+            displayInstruction: WRITING_RESULT_DISPLAY_INSTRUCTION,
+        }, "json");
+        return;
+    }
+    printWritingArtifact(artifact);
+}
+export async function runRerunWritingResult(options) {
+    const rerun = await rerunWriting("result", options);
+    const result = await getWriting("result", {
+        workflowId: options.workflowId,
+        nodeId: rerun.nodeId,
+        configPath: options.configPath,
+    });
+    const text = prepareWritingText("result", result);
+    if (!text) {
+        printActionResult(rerun, options.format ?? "markdown");
+        return;
+    }
+    const artifact = await writeWritingMarkdown("result", text, options.output);
+    if ((options.format ?? "markdown") === "json") {
+        // JSON 带回完整 text；对话仅部分预览，完整内容见 artifact
+        printOutput({
+            runnerId: result.runnerId,
+            nodeId: result.nodeId,
+            artifact,
+            text,
+            displayInstruction: WRITING_RESULT_DISPLAY_INSTRUCTION,
+        }, "json");
+        return;
+    }
+    printWritingArtifact(artifact);
+}
+/**
+ * 用户编辑结果正文后立即保存（不等下一步）。
+ */
+export async function runUpdateWritingResult(options) {
+    await saveWriting("result", options);
+    const result = await getWriting("result", {
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        configPath: options.configPath,
+    });
+    const text = prepareWritingText("result", result);
+    if (!text) {
+        printActionResult(result, options.format ?? "markdown", "result");
+        return;
+    }
+    const artifact = await writeWritingMarkdown("result", text, options.output);
+    if ((options.format ?? "markdown") === "json") {
+        printOutput({
+            runnerId: result.runnerId,
+            nodeId: result.nodeId,
+            artifact,
+            text,
+            displayInstruction: WRITING_RESULT_DISPLAY_INSTRUCTION,
+        }, "json");
+        return;
+    }
+    printWritingArtifact(artifact);
+}
+export async function runCreateWritingFullText(options) {
+    const result = await createFullText(options);
+    const fullText = await getWriting("fulltext", {
+        workflowId: options.workflowId,
+        nodeId: result.nodeId,
+        configPath: options.configPath,
+    });
+    const text = prepareWritingText("fulltext", fullText.data) ?? extractWritingText(fullText.data);
+    const fullTextArtifact = await exportFullText({
+        workflowId: options.workflowId,
+        nodeId: result.nodeId,
+        text,
+        output: options.output,
+        filename: "生成初稿.docx",
+        exportFormat: options.exportFormat,
+        configPath: options.configPath,
+    });
+    const bundleOutput = dirname(fullTextArtifact.output);
+    const companionArtifacts = await exportFullTextCompanionArtifacts({
+        workflowId: options.workflowId,
+        configPath: options.configPath,
+        outputDirectory: bundleOutput,
+    });
+    const artifacts = [
+        ...companionArtifacts,
+        fullTextArtifact,
+    ];
+    if ((options.format ?? "markdown") === "json") {
+        // text 供 Agent 做部分正文预览；完整初稿以 Word 产物为准
+        printOutput({
+            runnerId: result.runnerId,
+            nodeId: result.nodeId,
+            nodeType: result.nodeType,
+            status: result.status,
+            artifact: artifacts,
+            ...(text ? { text } : {}),
+            displayInstruction: WRITING_FULLTEXT_DISPLAY_INSTRUCTION,
+        }, "json");
+        return;
+    }
+    console.log(renderListAsMarkdown(artifacts, [
+        { key: "output", label: "output" },
+        { key: "filename", label: "filename" },
+        { key: "contentType", label: "contentType" },
+        { key: "size", label: "size" },
+    ]));
+}
+export async function runGetWritingFullText(options) {
+    const result = await getWriting("fulltext", options);
+    const text = prepareWritingText("fulltext", result.data) ?? extractWritingText(result.data);
+    // 历史切入与 create 一致：导出初稿 Word，并下载同次交付的全部配套产物
+    const fullTextArtifact = await exportFullText({
+        workflowId: options.workflowId,
+        nodeId: result.nodeId,
+        text,
+        output: options.output,
+        filename: "生成初稿.docx",
+        configPath: options.configPath,
+    });
+    const companionArtifacts = await exportFullTextCompanionArtifacts({
+        workflowId: options.workflowId,
+        configPath: options.configPath,
+        outputDirectory: dirname(fullTextArtifact.output),
+    });
+    const artifacts = [
+        ...companionArtifacts,
+        fullTextArtifact,
+    ];
+    if ((options.format ?? "markdown") === "json") {
+        // text 供 Agent 做部分正文预览；完整初稿以 Word 产物为准
+        printOutput({
+            runnerId: result.runnerId,
+            nodeId: result.nodeId,
+            artifact: artifacts,
+            ...(text ? { text } : {}),
+            displayInstruction: WRITING_FULLTEXT_DISPLAY_INSTRUCTION,
+        }, "json");
+        return;
+    }
+    console.log(renderListAsMarkdown(artifacts, [
+        { key: "output", label: "output" },
+        { key: "filename", label: "filename" },
+        { key: "contentType", label: "contentType" },
+        { key: "size", label: "size" },
+    ]));
+}
+export async function runRerunWritingFullText(options) {
+    printActionResult(await rerunWriting("fulltext", options), options.format ?? "markdown");
+}
+export async function runExportWritingFullText(options) {
+    const result = await exportFullText(options);
+    if ((options.format ?? "markdown") === "json") {
+        printOutput(result, "json");
+        return;
+    }
+    console.log(renderListAsMarkdown([result], [
+        { key: "runnerId", label: "runnerId" },
+        { key: "nodeId", label: "nodeId" },
+        { key: "output", label: "output" },
+        { key: "filename", label: "filename" },
+        { key: "size", label: "size" },
+    ]));
+}
+//# sourceMappingURL=writing.js.map