helixlife-expert-cli 0.1.0

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

@@ -0,0 +1,1165 @@
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, extname, join, resolve } from "node:path";
+import { Resvg } from "@resvg/resvg-js";
+import { PDFDocument } from "pdf-lib";
+import { createStderrProgress, ApiClient, helixlifeError, helixlifeErrorCode, printOutput, sanitizeFilename, } from "../../core/index.js";
+import { requestMeta } from "./api.js";
+import { META_API_PREFIX } from "./constants.js";
+import { getMetaNodeOutput, pollMetaNodeStatus } from "./node.js";
+import { buildEditableParamsDocument, buildQualityPlotEditableParams, EDIT_PLOT_PARAMS_INSTRUCTION, EDIT_QUALITY_PLOT_PARAMS_INSTRUCTION, } from "./plot-params.js";
+import { buildPrismaFlowDocx, } from "./prisma-flow-docx.js";
+const META_ANALYSIS_NODE_TYPES = {
+    OUTCOME: "outcome_indicator_extraction",
+    QUALITY: "quality_assessment",
+    FULLTEXT_SCREENING: "fulltext_screening",
+    EFFECT: "effect_quantity",
+    BIAS: "publication_bias",
+    ASSESSMENT: "quality_assessment_plot",
+    PRISMA: "prisma",
+};
+const DEFAULT_EFFECT_PLOT_DATA = {
+    table: { line_width: "0.75pt", text_size: "6pt", plot_width: 1 },
+    line: { color: ["#000000"], type: "实线", size: "0.75pt", alpha: 1 },
+    point: {
+        fill: ["#4DBBD5"],
+        color: ["#4DBBD5"],
+        shape: "菱形",
+        size: 1,
+        alpha: 1,
+    },
+    cutoff: { position: "1", color: ["#000000"], type: "虚线", size: "0.75pt" },
+    title: { title: "", size: "7pt" },
+    axis: { limits_x: "" },
+    figure: { width: "10", height: "6", family: "Arial" },
+    analysis: {
+        summary_measure: "RR(相对危险度)",
+        method: "MH",
+        model: "随机效应",
+        method_tau: "PM",
+        method_random_ci: true,
+    },
+};
+const DEFAULT_BIAS_PLOT_DATA = {
+    method: { model: "Trim剪补法前" },
+    style: { type: "标准漏斗图" },
+    point: {
+        fill: ["#4DBBD5", "#E64B35"],
+        color: ["#000000"],
+        shape: "圆形",
+        size: 2,
+        alpha: 0.6,
+    },
+    line: { color: ["#C9C9C9"], type: "虚线", size: "0.75pt", alpha: 1 },
+    title: { title: "", x: "", y: "" },
+    legend: { show: true, title: "", position: "默认" },
+    axis: { show_x: true, show_y: true, limits_x: "" },
+    theme: { border: true, panel: false, size: "7pt" },
+    figure: { width: "6", height: "5", family: "Arial" },
+    analysis: {
+        summary_measure: "RR(相对危险度)",
+        method: "MH",
+        model: "随机效应",
+        method_tau: "PM",
+        method_random_ci: true,
+    },
+};
+const DEFAULT_ASSESSMENT_PLOT_DATA = {
+    summary: {
+        bar: {
+            fill: [
+                "#02C100",
+                "#E2DF07",
+                "#BF0000",
+                "#3C5488",
+                "#F39B7F",
+                "#8491B4",
+                "#91D1C2",
+                "#DC0000",
+                "#7E6148",
+                "#B09C85",
+            ],
+            color: [
+                "#000000",
+                "#000000",
+                "#000000",
+                "#000000",
+                "#000000",
+                "#000000",
+                "#000000",
+                "#000000",
+                "#000000",
+                "#000000",
+            ],
+            size: "0.25pt",
+            width: 0.8,
+            alpha: 1,
+        },
+        title: { title: "", x: "", y: "" },
+        legend: { show: true, title: "", position: "下" },
+        axis: { angle_x: "0" },
+        theme: { border: false, panel: false, size: "6pt" },
+        figure: { width: "7", height: "5", family: "Arial" },
+    },
+    traffic_light: {
+        point: {
+            fill: [
+                "#02C100",
+                "#E2DF07",
+                "#BF0000",
+                "#3C5488",
+                "#F39B7F",
+                "#8491B4",
+                "#91D1C2",
+                "#DC0000",
+                "#7E6148",
+                "#B09C85",
+            ],
+            color: [
+                "#000000",
+                "#000000",
+                "#000000",
+                "#000000",
+                "#000000",
+                "#000000",
+                "#000000",
+                "#000000",
+                "#000000",
+                "#000000",
+            ],
+            style: ["加号", "减号", "叉号", "问号"],
+            size: 3,
+            alpha: 1,
+        },
+        title: { title: "", x: "", y: "" },
+        legend: { show: true, title: "", labels: "", position: "默认" },
+        theme: { border: true, panel: false, size: "7pt" },
+        figure: { width: "9", height: "6", family: "Arial" },
+    },
+};
+/** 图表 get/create 后必须展示 PDF 产物，禁止只报参数或口头声称已展示。 */
+const ANALYSIS_ARTIFACT_DISPLAY_INSTRUCTION = "必须从响应 artifact 打开/嵌入预览 PDF 产物文件本身（与正常 create 流程一致）；" +
+    "可附带当前参数说明；禁止只输出参数列表、文件路径文字或声称「已展示」而不展示文件。" +
+    "展示完成后按该节点操作选项以 Markdown 无序列表列出后停顿，禁止弹选择器，禁止用 / 同行拼接。";
+/** PRISMA create/get-image 后必须展示 PNG，且不得提前索要写作语言。 */
+const PRISMA_IMAGE_DISPLAY_INSTRUCTION = "必须从响应 artifact 打开/嵌入预览 PRISMA PNG 产物；" +
+    "禁止只输出元数据或声称已展示；展示后按 PRISMA 操作选项以 Markdown 无序列表列出后停顿：\n" +
+    "- 导出其他格式\n- 确认无误，下一步（辅助写作）\n" +
+    "禁止弹选择器；禁止用 / 同行拼接；禁止此时弹全文语言选择器；禁止声称即将进入辅助写作并索要语言。" +
+    "仅当用户点选「确认无误，下一步（辅助写作）」后，才必须弹出可点击交互选择器选择 English / 中文（禁止聊天列表代替），选定后再进入写作。";
+/** PRISMA 节点操作选项（与 workflow guidance 保持一致；本节点无编辑操作）。 */
+const PRISMA_OPERATION_OPTIONS = [
+    "导出其他格式",
+    "确认无误，下一步（辅助写作）",
+];
+const DEFAULT_PRISMA_DATA = {
+    pubmed_retrieval_count: 0,
+    registers_count: 0,
+    duplicate_count: 0,
+    automation_excluded_count: 0,
+    other_exclusion_count: 0,
+    screened_count: 0,
+    tiab_excluded_count: 0,
+    reports_sought_count: 0,
+    reports_not_retrieved_count: 0,
+    fulltext_count: 0,
+    wrong_population_count: 0,
+    wrong_intervention_count: 0,
+    wrong_comparator_count: 0,
+    wrong_study_design_count: 0,
+    wrong_outcomes_count: 0,
+    irrelevant_count: 0,
+    included_count: 0,
+    included_reports_count: 0,
+};
+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 parseJsonObjectFileInput(raw, filePath, optionName) {
+    if (filePath?.trim()) {
+        return parseJsonObject(await readFile(filePath.trim(), "utf8"), "--data-file");
+    }
+    return parseJsonObject(raw, optionName);
+}
+async function parseConfigInput(raw, filePath, defaultConfig) {
+    if (filePath?.trim()) {
+        return parseJsonObject(await readFile(filePath.trim(), "utf8"), "--config-file");
+    }
+    if (raw?.trim()) {
+        return parseJsonObject(raw, "--config-json");
+    }
+    return defaultConfig;
+}
+function mergeConfigRecords(base, patch) {
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+        const current = merged[key];
+        if (current && typeof current === "object" && !Array.isArray(current) &&
+            value && typeof value === "object" && !Array.isArray(value)) {
+            merged[key] = mergeConfigRecords(current, value);
+        }
+        else {
+            merged[key] = value;
+        }
+    }
+    return merged;
+}
+/** 质量评估图顶层子树 key */
+const QUALITY_PLOT_TYPES = ["traffic_light", "summary"];
+/**
+ * 将质量评估图 config 补丁规范为只含选定图类型。
+ * 支持扁平/嵌套写法；丢弃另一组。
+ */
+function normalizeQualityPlotConfigPatch(patch, plotType) {
+    const otherType = plotType === "traffic_light" ? "summary" : "traffic_light";
+    const hasSelected = Object.prototype.hasOwnProperty.call(patch, plotType);
+    const hasOther = Object.prototype.hasOwnProperty.call(patch, otherType);
+    const hasAnyPlotKey = QUALITY_PLOT_TYPES.some((key) => Object.prototype.hasOwnProperty.call(patch, key));
+    if (hasAnyPlotKey) {
+        if (!hasSelected) {
+            throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `--plot-type=${plotType} 但 config 缺少 ${plotType}` +
+                (hasOther ? `（禁止改 ${otherType}）` : ""));
+        }
+        const selected = patch[plotType];
+        if (!selected || typeof selected !== "object" || Array.isArray(selected)) {
+            throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `${plotType} 配置须为 JSON 对象`);
+        }
+        return { [plotType]: selected };
+    }
+    if (Object.keys(patch).length === 0) {
+        return {};
+    }
+    return { [plotType]: patch };
+}
+/** 有改参时必须提供 plotType，限定只改红绿灯或总结图。 */
+function resolveQualityPlotType(plotType, patch) {
+    const normalized = plotType?.trim();
+    if (!normalized) {
+        if (Object.keys(patch).length === 0) {
+            return undefined;
+        }
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "质量评估图改参须传 --plot-type traffic_light|summary");
+    }
+    if (normalized !== "traffic_light" && normalized !== "summary") {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "--plot-type 仅支持 traffic_light 或 summary");
+    }
+    return normalized;
+}
+function extractNodeOutput(node) {
+    if (node.output &&
+        typeof node.output === "object" &&
+        "output" in node.output) {
+        return node.output.output;
+    }
+    return node.output ?? {};
+}
+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);
+}
+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 kindConfig(kind) {
+    if (kind === "effect") {
+        return {
+            nodeType: META_ANALYSIS_NODE_TYPES.EFFECT,
+            sourceNodeType: META_ANALYSIS_NODE_TYPES.OUTCOME,
+            sourceParam: "outcome_indicator_extraction_id",
+            executePath: "effect-quantity-plot/execute",
+            plotPath: "effect-quantity-plot/plot",
+            rerunPath: "effect-quantity-plot/re-execute",
+            label: "森林图",
+            defaultConfig: DEFAULT_EFFECT_PLOT_DATA,
+        };
+    }
+    if (kind === "bias") {
+        return {
+            nodeType: META_ANALYSIS_NODE_TYPES.BIAS,
+            sourceNodeType: META_ANALYSIS_NODE_TYPES.OUTCOME,
+            sourceParam: "outcome_indicator_extraction_id",
+            executePath: "publication-bias-plot/execute",
+            plotPath: "publication-bias-plot/plot",
+            rerunPath: "publication-bias-plot/re-execute",
+            label: "漏斗图",
+            defaultConfig: DEFAULT_BIAS_PLOT_DATA,
+        };
+    }
+    return {
+        nodeType: META_ANALYSIS_NODE_TYPES.ASSESSMENT,
+        sourceNodeType: META_ANALYSIS_NODE_TYPES.QUALITY,
+        sourceParam: "quality_assessment_id",
+        executePath: "quality-assessment-plot/execute",
+        plotPath: "quality-assessment-plot/plot",
+        rerunPath: "quality-assessment-plot/re-execute",
+        label: "质量评估图",
+        defaultConfig: DEFAULT_ASSESSMENT_PLOT_DATA,
+    };
+}
+/**
+ * Enforces both server-side plot validations before statistical analysis starts.
+ * Any validation error propagates and keeps the workflow in data extraction.
+ */
+async function verifyAnalysisPrerequisites(options) {
+    const qualityNodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeType: META_ANALYSIS_NODE_TYPES.QUALITY,
+        label: "quality assessment",
+        configPath: options.configPath,
+    });
+    await requestMeta(`${META_API_PREFIX}/quality-assessment/verify-for-plot`, {
+        params: { run_id: options.workflowId, node_id: qualityNodeId },
+        configPath: options.configPath,
+        action: "校验质量评估绘图数据",
+    });
+    const outcomeNodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeType: META_ANALYSIS_NODE_TYPES.OUTCOME,
+        label: "outcome indicator extraction",
+        configPath: options.configPath,
+    });
+    await requestMeta(`${META_API_PREFIX}/outcome-indicator-extraction/verify-for-plot`, {
+        params: { run_id: options.workflowId, node_id: outcomeNodeId },
+        configPath: options.configPath,
+        action: "校验结局指标绘图数据",
+    });
+}
+async function createAnalysis(kind, options) {
+    await verifyAnalysisPrerequisites(options);
+    const meta = kindConfig(kind);
+    const configPatch = await parseConfigInput(options.configJson, options.configFile, meta.defaultConfig);
+    const config = mergeConfigRecords(meta.defaultConfig, configPatch);
+    const sourceNodeId = options.sourceNodeId?.trim() ??
+        (await resolveNodeId({
+            workflowId: options.workflowId,
+            nodeType: meta.sourceNodeType,
+            label: kind === "assessment" ? "质量评估" : "结局指标",
+            configPath: options.configPath,
+        }));
+    const progress = createStderrProgress(options.format === "json");
+    progress.start(`正在生成${meta.label}...`);
+    try {
+        const created = await requestMeta(`${META_API_PREFIX}/${meta.executePath}`, {
+            method: "POST",
+            params: {
+                run_id: options.workflowId,
+                [meta.sourceParam]: sourceNodeId,
+            },
+            body: config,
+            configPath: options.configPath,
+            action: `生成${meta.label}`,
+        });
+        if (!created.node_id) {
+            throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, `生成${meta.label}响应缺少 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(`${meta.label}生成完成，正在输出结果...`);
+        return {
+            runnerId: options.workflowId,
+            nodeId: created.node_id,
+            nodeType: meta.nodeType,
+            status: output.data.status,
+            input: config,
+            output: extractNodeOutput(output.data),
+            node: output.data,
+        };
+    }
+    catch (error) {
+        progress.dispose();
+        throw error;
+    }
+}
+/**
+ * 读取节点当前绘图配置，并与默认值深度合并。
+ *
+ * @param kind 图表类型
+ * @param options 工作流与节点定位
+ * @param knownInput 已有 input（create/rerun 结果可直接传入，避免重复查询）
+ */
+async function resolveCurrentPlotConfig(kind, options, knownInput) {
+    const meta = kindConfig(kind);
+    if (knownInput) {
+        return mergeConfigRecords(meta.defaultConfig, knownInput);
+    }
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: meta.nodeType,
+        label: meta.label,
+        configPath: options.configPath,
+    });
+    const workflow = await getWorkflow(options.workflowId, options.configPath);
+    const currentNode = (workflow.nodes ?? []).find((node) => node.id === nodeId);
+    const currentInput = currentNode?.input && typeof currentNode.input === "object"
+        ? currentNode.input
+        : {};
+    return mergeConfigRecords(meta.defaultConfig, currentInput);
+}
+/**
+ * 为图表结果附加可编辑参数清单，供 Agent 在「编辑参数」时原样展示。
+ *
+ * @param kind 图表类型
+ * @param result 原始图表结果
+ * @param options 工作流定位
+ * @param knownInput 已知配置（可选）
+ */
+async function withEditablePlotParams(kind, result, options, knownInput) {
+    const currentConfig = await resolveCurrentPlotConfig(kind, options, knownInput ??
+        ("input" in result &&
+            result.input &&
+            typeof result.input === "object" &&
+            !Array.isArray(result.input)
+            ? result.input
+            : undefined));
+    // 质量评估图：两组参数分开返回，由 Agent 先弹选择器再单组展示
+    if (kind === "assessment") {
+        const qualityParams = buildQualityPlotEditableParams(currentConfig);
+        return {
+            ...result,
+            currentConfig,
+            editableParamsMarkdownTrafficLight: qualityParams.trafficLight.markdown,
+            editableParamsSectionsTrafficLight: qualityParams.trafficLight.sections,
+            requiredSectionLabelsTrafficLight: qualityParams.trafficLight.requiredSectionLabels,
+            editableParamsMarkdownSummary: qualityParams.summary.markdown,
+            editableParamsSectionsSummary: qualityParams.summary.sections,
+            requiredSectionLabelsSummary: qualityParams.summary.requiredSectionLabels,
+            editInstruction: EDIT_QUALITY_PLOT_PARAMS_INSTRUCTION,
+        };
+    }
+    // 森林图 / 漏斗图：同一套分组结构，禁止图种特例合并省略
+    const doc = buildEditableParamsDocument(kind, currentConfig);
+    return {
+        ...result,
+        currentConfig,
+        editableParamsMarkdown: doc.markdown,
+        editableParamsSections: doc.sections,
+        requiredSectionLabels: doc.requiredSectionLabels,
+        editInstruction: EDIT_PLOT_PARAMS_INSTRUCTION,
+    };
+}
+async function getAnalysis(kind, options) {
+    const meta = kindConfig(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.plotPath}`, {
+        params: { run_id: options.workflowId, node_id: nodeId },
+        configPath: options.configPath,
+        action: `获取${meta.label}`,
+    });
+    return { runnerId: options.workflowId, nodeId, data };
+}
+/** Downloads plot URLs using fixed website-step names instead of backend URL basenames. */
+async function materializeAnalysisArtifacts(kind, data) {
+    const record = data && typeof data === "object" && !Array.isArray(data)
+        ? data
+        : {};
+    const targets = kind === "effect"
+        ? [{ key: "file", filename: "森林图.pdf" }]
+        : kind === "bias"
+            ? [{ key: "file", filename: "漏斗图.pdf" }]
+            : [
+                { key: "traffic_light_file", filename: "质量评估红绿灯图.pdf" },
+                { key: "summary_file", filename: "质量评估总结图.pdf" },
+            ];
+    const client = new ApiClient();
+    const artifacts = [];
+    for (const target of targets) {
+        const sourceUrl = record[target.key];
+        const url = typeof sourceUrl === "string" ? sourceUrl.trim() : "";
+        if (!url) {
+            throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, `${target.filename.replace(/\.pdf$/i, "")}产物地址为空`);
+        }
+        const response = await client.requestBinary(url);
+        if (response.buffer.length === 0) {
+            throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, `${target.filename}下载内容为空`);
+        }
+        const output = resolve(target.filename);
+        await mkdir(dirname(output), { recursive: true });
+        await writeFile(output, response.buffer);
+        artifacts.push({
+            output,
+            filename: target.filename,
+            contentType: response.contentType ?? undefined,
+            size: response.buffer.length,
+        });
+    }
+    return artifacts.length === 1 ? artifacts[0] : artifacts;
+}
+async function rerunAnalysis(kind, options) {
+    const meta = kindConfig(kind);
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: meta.nodeType,
+        label: meta.label,
+        configPath: options.configPath,
+    });
+    let patch = await parseConfigInput(options.configJson, options.configFile, {});
+    let editedPlotType;
+    // 质量评估图：只合并选定子树
+    if (kind === "assessment") {
+        editedPlotType = resolveQualityPlotType(options.plotType, patch);
+        if (editedPlotType) {
+            patch = normalizeQualityPlotConfigPatch(patch, editedPlotType);
+        }
+    }
+    const workflow = await getWorkflow(options.workflowId, options.configPath);
+    const currentNode = (workflow.nodes ?? []).find((node) => node.id === nodeId);
+    const currentInput = currentNode?.input && typeof currentNode.input === "object"
+        ? currentNode.input
+        : {};
+    const input = mergeConfigRecords(mergeConfigRecords(meta.defaultConfig, currentInput), patch);
+    const data = await requestMeta(`${META_API_PREFIX}/${meta.rerunPath}`, {
+        method: "POST",
+        params: { run_id: options.workflowId, node_id: nodeId },
+        body: input,
+        configPath: options.configPath,
+        action: `重新生成${meta.label}`,
+    });
+    await pollMetaNodeStatus({
+        workflowId: options.workflowId,
+        nodeId,
+        configPath: options.configPath,
+    });
+    return {
+        runnerId: options.workflowId,
+        nodeId,
+        input,
+        data,
+        editedPlotType,
+    };
+}
+/**
+ * 获取 PRISMA 流程图数据。
+ *
+ * 网站使用全文复筛节点作为 PRISMA 数据来源，CLI 保持同样的 run_id/node_id 参数关系。
+ *
+ * @param options PRISMA 数据查询参数。
+ * @returns PRISMA 流程图结构化数据。
+ */
+async function getPrismaFlowData(options) {
+    const nodeId = options.sourceNodeId?.trim() ??
+        (await resolveNodeId({
+            workflowId: options.workflowId,
+            nodeType: META_ANALYSIS_NODE_TYPES.FULLTEXT_SCREENING,
+            label: "全文复筛",
+            configPath: options.configPath,
+        }));
+    const data = await requestMeta(`${META_API_PREFIX}/prisma`, {
+        params: { run_id: options.workflowId, node_id: nodeId },
+        configPath: options.configPath,
+        action: "获取 PRISMA 流程图数据",
+    });
+    return { runnerId: options.workflowId, nodeId, data };
+}
+/**
+ * 更新 PRISMA 流程图数据。
+ *
+ * @param options PRISMA 数据更新参数，数据字段需与网站 PRISMA 表单字段一致。
+ * @returns 后端保存结果。
+ */
+async function updatePrismaFlowData(options) {
+    const nodeId = options.sourceNodeId?.trim() ??
+        (await resolveNodeId({
+            workflowId: options.workflowId,
+            nodeType: META_ANALYSIS_NODE_TYPES.FULLTEXT_SCREENING,
+            label: "全文复筛",
+            configPath: options.configPath,
+        }));
+    const patch = await parseJsonObjectFileInput(options.dataJson, options.dataFile, "--data-json");
+    const current = normalizePrismaFlowData((await getPrismaFlowData({
+        workflowId: options.workflowId,
+        sourceNodeId: nodeId,
+        configPath: options.configPath,
+    })).data);
+    const input = { ...current, ...patch };
+    const data = await requestMeta(`${META_API_PREFIX}/prisma-flow-data`, {
+        method: "PUT",
+        params: { run_id: options.workflowId, node_id: nodeId },
+        body: input,
+        configPath: options.configPath,
+        action: "更新 PRISMA 流程图数据",
+    });
+    return { runnerId: options.workflowId, nodeId, input, data };
+}
+/**
+ * 从后端读取已上传的 PRISMA 图片原始响应（不落盘）。
+ *
+ * @param options 工作流参数。
+ * @returns 后端原始图片响应。
+ */
+async function fetchPrismaImageData(options) {
+    return requestMeta(`${META_API_PREFIX}/prisma/image`, {
+        params: { run_id: options.workflowId },
+        configPath: options.configPath,
+        action: "获取 PRISMA 图片",
+    });
+}
+/**
+ * 获取已上传到后端的 PRISMA 图片，并落盘为可展示的 PNG 产物。
+ *
+ * @param options PRISMA 图片查询参数。
+ * @returns 图片数据与本地 artifact（供历史切换后展示）。
+ */
+async function getPrismaImage(options) {
+    const data = await fetchPrismaImageData(options);
+    const extracted = extractImageBuffer(data);
+    const filename = "PRISMA流程图.png";
+    const outputOpt = options.output?.trim();
+    let output;
+    if (!outputOpt) {
+        output = resolve(filename);
+    }
+    else {
+        const outputStat = await stat(outputOpt).catch(() => undefined);
+        if (outputStat?.isDirectory() ||
+            outputOpt.endsWith("/") ||
+            outputOpt.endsWith("\\")) {
+            output = join(outputOpt, filename);
+        }
+        else {
+            output = extname(outputOpt) ? resolve(outputOpt) : join(outputOpt, filename);
+        }
+    }
+    await mkdir(dirname(output), { recursive: true });
+    await writeFile(output, extracted.buffer);
+    return {
+        runnerId: options.workflowId,
+        data,
+        artifact: {
+            output,
+            filename,
+            contentType: "image/png",
+            size: extracted.buffer.length,
+        },
+        displayInstruction: PRISMA_IMAGE_DISPLAY_INSTRUCTION,
+        operationOptions: [...PRISMA_OPERATION_OPTIONS],
+    };
+}
+/**
+ * 上传 PRISMA 流程图图片，供后续全文写作接口使用。
+ *
+ * @param options 图片上传参数。
+ * @returns 后端上传结果。
+ */
+async function uploadPrismaImage(options) {
+    const bytes = await readFile(options.file);
+    const filename = options.file.split(/[\\/]/).pop() || "prisma-flow.png";
+    const data = await uploadPrismaImageBuffer({
+        workflowId: options.workflowId,
+        configPath: options.configPath,
+        buffer: bytes,
+        filename,
+    });
+    return { runnerId: options.workflowId, input: { file: options.file }, data };
+}
+/**
+ * 上传内存中的 PRISMA PNG 图片，供默认生成流程在生成图片后立即同步到后端。
+ *
+ * @param options 上传参数，包含工作流、图片内容与文件名。
+ * @returns 后端上传响应。
+ */
+async function uploadPrismaImageBuffer(options) {
+    const form = new FormData();
+    form.append("file", new Blob([new Uint8Array(options.buffer)], { type: "image/png" }), options.filename || "prisma-flow.png");
+    return requestMeta(`${META_API_PREFIX}/prisma/upload`, {
+        method: "POST",
+        params: { run_id: options.workflowId },
+        body: form,
+        configPath: options.configPath,
+        action: "上传 PRISMA 图片",
+    });
+}
+/**
+ * 上传本次生成的 PRISMA PNG，并立即从后端读取校验，确保后续全文写作能拿到同一张图。
+ *
+ * @param options 上传和校验参数。
+ * @returns 上传接口响应与后端已保存图片信息。
+ * @throws {helixlifeError} 上传失败、后端未保存图片或保存内容不是本次生成图片时抛出。
+ */
+async function uploadAndVerifyPrismaImage(options) {
+    let upload;
+    try {
+        upload = await uploadPrismaImageBuffer(options);
+    }
+    catch (error) {
+        const message = error instanceof Error && error.message ? `：${error.message}` : "";
+        throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, `PRISMA 图片上传失败${message}`);
+    }
+    let saved;
+    try {
+        saved = extractImageBuffer(await fetchPrismaImageData({
+            workflowId: options.workflowId,
+            configPath: options.configPath,
+        }));
+    }
+    catch (error) {
+        const message = error instanceof Error && error.message ? `：${error.message}` : "";
+        throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, `PRISMA 图片上传后校验失败，后端未返回已保存图片${message}`);
+    }
+    if (!saved.buffer.equals(options.buffer)) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, "PRISMA 图片上传后校验失败，后端保存的图片不是本次生成的最新图片");
+    }
+    return {
+        upload,
+        image: {
+            filename: saved.filename,
+            size: saved.buffer.byteLength,
+        },
+    };
+}
+function normalizePrismaFlowData(data) {
+    const payload = data && typeof data === "object" && "data" in data
+        ? data.data
+        : data;
+    const record = payload && typeof payload === "object"
+        ? payload
+        : {};
+    const normalized = { ...DEFAULT_PRISMA_DATA };
+    const numericKeys = Object.keys(DEFAULT_PRISMA_DATA);
+    for (const key of numericKeys) {
+        const value = record[key];
+        const numericValue = typeof value === "number" ? value : Number(value ?? 0);
+        normalized[key] = Number.isFinite(numericValue)
+            ? numericValue
+            : 0;
+    }
+    if (typeof record.prisma_text === "string") {
+        normalized.prisma_text = record.prisma_text;
+    }
+    if (normalized.included_reports_count === 0) {
+        normalized.included_reports_count = normalized.included_count;
+    }
+    return normalized;
+}
+function parsePrismaExportFormat(raw) {
+    const value = (raw ?? "png").trim().toLowerCase();
+    if (value === "png" || value === "pdf" || value === "docx") {
+        return value;
+    }
+    throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "--export-format 仅支持 png、pdf、docx");
+}
+async function resolvePrismaExportPath(options) {
+    const filename = sanitizeFilename(`PRISMA流程图.${options.format}`);
+    const output = options.output?.trim();
+    if (!output) {
+        return join(".", filename);
+    }
+    const outputStat = await stat(output).catch(() => undefined);
+    if (outputStat?.isDirectory() ||
+        output.endsWith("/") ||
+        output.endsWith("\\")) {
+        return join(output, filename);
+    }
+    return extname(output) ? output : join(output, filename);
+}
+async function buildPrismaDocx(data) {
+    return buildPrismaFlowDocx(data);
+}
+function escapeSvgText(value) {
+    return String(value)
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+function svgTextLines(lines, x, y, options = {}) {
+    const size = options.size ?? 16;
+    const weight = options.weight ?? "400";
+    const anchor = options.anchor ?? "start";
+    const fill = options.fill ?? "#1C1F21";
+    const lineHeight = options.lineHeight ?? 21;
+    const style = options.italic ? ' font-style="italic"' : "";
+    return lines
+        .map((line, index) => {
+        return `<text x="${x}" y="${y + index * lineHeight}" font-family="Arial, Helvetica, sans-serif" font-size="${size}" font-weight="${weight}" text-anchor="${anchor}" fill="${fill}"${style}>${escapeSvgText(line)}</text>`;
+    })
+        .join("");
+}
+function estimateSvgTextWidth(value, fontSize) {
+    return [...value].reduce((width, character) => {
+        if (character === " ")
+            return width + fontSize * 0.28;
+        if (/[A-Z]/.test(character))
+            return width + fontSize * 0.62;
+        if (/[0-9]/.test(character))
+            return width + fontSize * 0.56;
+        if (/[,.:;()=*%\-]/.test(character))
+            return width + fontSize * 0.32;
+        return width + fontSize * 0.52;
+    }, 0);
+}
+function wrapSvgTextLines(lines, maxWidth, fontSize) {
+    const wrapped = [];
+    for (const rawLine of lines) {
+        const words = String(rawLine).trim().split(/\s+/).filter(Boolean);
+        if (words.length === 0) {
+            wrapped.push("");
+            continue;
+        }
+        let current = words[0];
+        for (const word of words.slice(1)) {
+            const candidate = `${current} ${word}`;
+            if (estimateSvgTextWidth(candidate, fontSize) <= maxWidth) {
+                current = candidate;
+            }
+            else {
+                wrapped.push(current);
+                current = word;
+            }
+        }
+        wrapped.push(current);
+    }
+    return wrapped;
+}
+function prismaBox(x, y, width, height, lines, fill = "#ffffff") {
+    const fontSize = 16;
+    const wrappedLines = wrapSvgTextLines(lines, width - 28, fontSize);
+    return [
+        `<rect x="${x}" y="${y}" width="${width}" height="${height}" rx="2" fill="${fill}" stroke="#1C1F21" stroke-width="1"/>`,
+        `<path d="M ${x + 1} ${y + height} L ${x + width + 1} ${y + height}" stroke="rgba(0,0,0,0.1)" stroke-width="1"/>`,
+        svgTextLines(wrappedLines, x + 14, y + 23, { size: fontSize, fill: "#1C1F21", lineHeight: 20 }),
+    ].join("");
+}
+function prismaArrowDown(x, y1, y2) {
+    return `<path d="M ${x} ${y1} L ${x} ${y2}" stroke="#101828" stroke-width="1.2" fill="none" marker-end="url(#arrow)"/>`;
+}
+function prismaArrowRight(x1, x2, y) {
+    return `<path d="M ${x1} ${y} L ${x2} ${y}" stroke="#101828" stroke-width="1.2" fill="none" marker-end="url(#arrow)"/>`;
+}
+function prismaSideLabel(label, x, y, height) {
+    return [
+        `<rect x="${x}" y="${y}" width="45" height="${height}" rx="6" fill="#9DC3E6"/>`,
+        `<path d="M ${x + 1} ${y + height} L ${x + 46} ${y + height}" stroke="rgba(0,0,0,0.1)" stroke-width="1"/>`,
+        `<text x="${x + 29}" y="${y + height / 2}" font-family="Arial, Helvetica, sans-serif" font-size="16" font-weight="700" fill="#101828" text-anchor="middle" dominant-baseline="middle" transform="rotate(-90 ${x + 29} ${y + height / 2})">${escapeSvgText(label)}</text>`,
+    ].join("");
+}
+/**
+ * 根据 PRISMA 结构化数据生成网站同类流程图的 SVG 画布。
+ *
+ * @param data PRISMA 结构化数据。
+ * @returns 可渲染为 PNG 的 SVG 字符串。
+ */
+function buildPrismaSvg(data) {
+    const canvasW = 1040;
+    const canvasH = 960;
+    const sidebarX = 60;
+    const leftX = 125;
+    const rightX = 525;
+    const boxW = 305;
+    const rightW = 390;
+    const arrowX = leftX + boxW / 2;
+    const rightArrowStartX = leftX + boxW;
+    const footerX = 20;
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="${canvasW}" height="${canvasH}" viewBox="0 0 ${canvasW} ${canvasH}">
+  <defs>
+    <marker id="arrow" markerWidth="10" markerHeight="10" refX="8" refY="3" orient="auto" markerUnits="strokeWidth">
+      <path d="M0,0 L0,6 L9,3 z" fill="#101828"/>
+    </marker>
+  </defs>
+  <rect width="${canvasW}" height="${canvasH}" rx="20" fill="#ffffff"/>
+  ${svgTextLines(["PRISMA 2020 flow diagram for new systematic reviews which included", "searches of databases and registers only"], canvasW / 2, 34, { size: 18, weight: "700", anchor: "middle", fill: "#61666D", lineHeight: 20 })}
+  <rect x="${leftX}" y="82" width="${rightX + rightW - leftX}" height="45" rx="6" fill="#FFC000"/>
+  ${svgTextLines(["Identification of studies via databases and registers"], (leftX + rightX + rightW) / 2, 110, { size: 16, weight: "700", anchor: "middle", fill: "#1C1F21" })}
+  ${prismaSideLabel("Identification", sidebarX, 145, 125)}
+  ${prismaBox(leftX, 145, boxW, 125, ["Records identified from*:", `  Databases (n = ${data.pubmed_retrieval_count})`, `  Registers (n = ${data.registers_count})`])}
+  ${prismaBox(rightX, 145, rightW, 125, ["Records removed before screening:", `Duplicate records removed (n = ${data.duplicate_count})`, `Records marked as ineligible by automation tools (n = ${data.automation_excluded_count})`, `Records removed for other reasons (n = ${data.other_exclusion_count})`])}
+  ${prismaArrowRight(rightArrowStartX, rightX, 207)}
+  ${prismaArrowDown(arrowX, 270, 315)}
+  ${prismaSideLabel("Screening", sidebarX, 315, 282)}
+  ${prismaBox(leftX, 315, boxW, 75, ["Records screened", `(n = ${data.screened_count})`])}
+  ${prismaBox(rightX, 315, rightW, 75, ["Records excluded**", `(n = ${data.tiab_excluded_count})`])}
+  ${prismaArrowRight(rightArrowStartX, rightX, 352)}
+  ${prismaArrowDown(arrowX, 390, 430)}
+  ${prismaBox(leftX, 430, boxW, 75, ["Reports sought for retrieval", `(n = ${data.reports_sought_count})`])}
+  ${prismaBox(rightX, 430, rightW, 75, ["Reports not retrieved", `(n = ${data.reports_not_retrieved_count})`])}
+  ${prismaArrowRight(rightArrowStartX, rightX, 467)}
+  ${prismaArrowDown(arrowX, 505, 545)}
+  ${prismaBox(leftX, 545, boxW, 75, ["Reports assessed for eligibility", `(n = ${data.fulltext_count})`])}
+  ${prismaBox(rightX, 545, rightW, 225, ["Reports excluded:", `  Inappropriate population (n = ${data.wrong_population_count})`, `  Inappropriate intervention (n = ${data.wrong_intervention_count})`, `  Inappropriate comparator (n = ${data.wrong_comparator_count})`, `  Inappropriate study design (n = ${data.wrong_study_design_count})`, `  Inappropriate outcome (n = ${data.wrong_outcomes_count})`, `  Irrelevant (n = ${data.irrelevant_count})`, "  etc."])}
+  ${prismaArrowRight(rightArrowStartX, rightX, 582)}
+  ${prismaArrowDown(arrowX, 620, 660)}
+  ${prismaSideLabel("Included", sidebarX, 660, 110)}
+  ${prismaBox(leftX, 660, boxW, 110, ["Studies included in review", `(n = ${data.included_count})`, "Reports of included studies", `(n = ${data.included_reports_count})`])}
+  ${svgTextLines(["*Consider, if feasible to do so, reporting the number of records identified from each database or register searched (rather than the", "total number across all databases/registers).", "**If automation tools were used, indicate how many records were excluded by a human and how many were excluded by automation", "tools."], footerX, 800, { size: 15, weight: "700", fill: "#61666D", lineHeight: 19 })}
+  ${svgTextLines(["Source: Page MJ, et al. BMJ 2021;372:n71. doi: 10.1136/bmj.n71."], footerX, 895, { size: 15, weight: "700", fill: "#93999F" })}
+  ${svgTextLines(["This work is licensed under CC BY 4.0. To view a copy of this license, visit"], footerX, 920, { size: 15, weight: "700", fill: "#93999F" })}
+  ${svgTextLines(["https://creativecommons.org/licenses/by/4.0"], footerX, 943, { size: 15, weight: "700", fill: "#9747FF" })}
+</svg>`;
+}
+/**
+ * 将 PRISMA 结构化数据渲染为真实 PNG 图片。
+ *
+ * @param data PRISMA 结构化数据。
+ * @returns PNG 文件内容。
+ */
+function buildPrismaPng(data) {
+    const svg = buildPrismaSvg(data);
+    return Buffer.from(new Resvg(svg).render().asPng());
+}
+/**
+ * 基于与 PNG 相同的 SVG 渲染生成 PRISMA PDF，保证英文文案与箭头间距一致。
+ *
+ * @param data PRISMA 结构化数据。
+ * @returns PDF 文件内容。
+ */
+export async function buildPrismaPdf(data) {
+    const png = buildPrismaPng(data);
+    const pdfDoc = await PDFDocument.create();
+    const image = await pdfDoc.embedPng(png);
+    // A4，边距内等比缩放，与标准流程图视觉一致
+    const pageWidth = 595.28;
+    const pageHeight = 841.89;
+    const margin = 20;
+    const maxW = pageWidth - margin * 2;
+    const maxH = pageHeight - margin * 2;
+    const scale = Math.min(maxW / image.width, maxH / image.height);
+    const drawW = image.width * scale;
+    const drawH = image.height * scale;
+    const page = pdfDoc.addPage([pageWidth, pageHeight]);
+    page.drawImage(image, {
+        x: (pageWidth - drawW) / 2,
+        y: (pageHeight - drawH) / 2,
+        width: drawW,
+        height: drawH,
+    });
+    return Buffer.from(await pdfDoc.save());
+}
+function extractImageBuffer(data) {
+    const payload = data && typeof data === "object" && "data" in data
+        ? data.data
+        : data;
+    if (!payload || typeof payload !== "object") {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, "PRISMA 图片响应为空");
+    }
+    const image = payload.image;
+    const fileName = payload.file_name;
+    if (typeof image !== "string" || !image.trim()) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, "后端尚未保存 PRISMA PNG 图片，请先上传图片");
+    }
+    const base64 = image.includes(",") ? (image.split(",").pop() ?? "") : image;
+    return {
+        buffer: Buffer.from(base64, "base64"),
+        filename: typeof fileName === "string" && fileName.trim()
+            ? fileName.trim()
+            : "prisma-flow.png",
+    };
+}
+/**
+ * 导出 PRISMA 流程图产物。
+ *
+ * @param options PRISMA 导出参数。
+ * @returns 导出文件信息。
+ */
+export async function exportPrismaFlow(options) {
+    await verifyAnalysisPrerequisites(options);
+    const exportFormat = parsePrismaExportFormat(options.exportFormat);
+    const outputPath = await resolvePrismaExportPath({
+        workflowId: options.workflowId,
+        configPath: options.configPath,
+        output: options.output,
+        title: options.title,
+        format: exportFormat,
+    });
+    const result = await getPrismaFlowData(options);
+    const data = normalizePrismaFlowData(result.data);
+    let buffer = exportFormat === "png"
+        ? buildPrismaPng(data)
+        : exportFormat === "pdf"
+            ? await buildPrismaPdf(data)
+            : await buildPrismaDocx(data);
+    let upload;
+    if (exportFormat === "png") {
+        upload = await uploadAndVerifyPrismaImage({
+            workflowId: options.workflowId,
+            configPath: options.configPath,
+            buffer,
+            filename: outputPath.split(/[\\/]/).pop() || "prisma-flow.png",
+        });
+    }
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, buffer);
+    // 默认 PNG：明确告知 Agent 先停在本节点，勿提前弹全文语言选择器
+    const isDefaultPng = exportFormat === "png";
+    return {
+        runnerId: options.workflowId,
+        nodeId: result.nodeId,
+        output: outputPath,
+        filename: outputPath.split(/[\\/]/).pop() || `PRISMA流程图.${exportFormat}`,
+        contentType: exportFormat === "docx"
+            ? "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+            : exportFormat === "pdf"
+                ? "application/pdf"
+                : "image/png",
+        exportFormat,
+        size: buffer.byteLength,
+        data,
+        upload,
+        ...(isDefaultPng
+            ? {
+                displayInstruction: PRISMA_IMAGE_DISPLAY_INSTRUCTION,
+                operationOptions: [...PRISMA_OPERATION_OPTIONS],
+            }
+            : {
+                displayInstruction: "已导出 PRISMA 其他格式产物；仍停在本节点，按操作选项以 Markdown 无序列表列出后停顿：\n" +
+                    "- 导出其他格式\n- 确认无误，下一步（辅助写作）\n" +
+                    "禁止弹全文语言选择器；仅用户点选进入辅助写作后，才必须弹出可点击交互选择器选择 English / 中文。",
+                operationOptions: [...PRISMA_OPERATION_OPTIONS],
+            }),
+    };
+}
+/**
+ * 生成分析图表，并在节点成功后立即获取可展示的产物。
+ *
+ * @param kind 分析图表类型。
+ * @param options 图表生成参数。
+ * @returns 节点执行结果及对应的图表产物。
+ */
+async function createAnalysisWithArtifact(kind, options) {
+    const result = await createAnalysis(kind, options);
+    const artifact = await getAnalysis(kind, {
+        workflowId: options.workflowId,
+        nodeId: result.nodeId,
+        configPath: options.configPath,
+    });
+    return withEditablePlotParams(kind, {
+        ...result,
+        artifact: await materializeAnalysisArtifacts(kind, artifact.data),
+        displayInstruction: ANALYSIS_ARTIFACT_DISPLAY_INSTRUCTION,
+    }, {
+        workflowId: options.workflowId,
+        nodeId: result.nodeId,
+        configPath: options.configPath,
+    }, result.input);
+}
+/**
+ * 重新生成分析图表，并在节点成功后立即获取最新产物。
+ *
+ * @param kind 分析图表类型。
+ * @param options 图表重新生成参数。
+ * @returns 重新生成结果及最新图表产物。
+ */
+async function rerunAnalysisWithArtifact(kind, options) {
+    const result = await rerunAnalysis(kind, options);
+    const artifact = await getAnalysis(kind, {
+        workflowId: options.workflowId,
+        nodeId: result.nodeId,
+        configPath: options.configPath,
+    });
+    const withParams = await withEditablePlotParams(kind, {
+        ...result,
+        artifact: await materializeAnalysisArtifacts(kind, artifact.data),
+        displayInstruction: ANALYSIS_ARTIFACT_DISPLAY_INSTRUCTION,
+    }, {
+        workflowId: options.workflowId,
+        nodeId: result.nodeId,
+        configPath: options.configPath,
+    }, result.input);
+    // 质量评估图：强调只改了选定组
+    if (kind === "assessment" && result.editedPlotType) {
+        const plotLabel = result.editedPlotType === "traffic_light" ? "红绿灯图" : "总结图";
+        const otherLabel = result.editedPlotType === "traffic_light" ? "总结图" : "红绿灯图";
+        return {
+            ...withParams,
+            editedPlotType: result.editedPlotType,
+            displayInstruction: ANALYSIS_ARTIFACT_DISPLAY_INSTRUCTION +
+                `本次仅修改了${plotLabel}（editedPlotType=${result.editedPlotType}）；` +
+                `${otherLabel}参数未改。两份 PDF 可能同节点刷新，禁止声称${otherLabel}也被修改。`,
+        };
+    }
+    return withParams;
+}
+async function getAnalysisWithArtifact(kind, options) {
+    const result = await getAnalysis(kind, options);
+    return withEditablePlotParams(kind, {
+        ...result,
+        artifact: await materializeAnalysisArtifacts(kind, result.data),
+        displayInstruction: ANALYSIS_ARTIFACT_DISPLAY_INSTRUCTION,
+    }, options);
+}
+export async function runCreateEffectPlot(options) {
+    printOutput(await createAnalysisWithArtifact("effect", options), options.format ?? "markdown");
+}
+export async function runGetEffectPlot(options) {
+    printOutput(await getAnalysisWithArtifact("effect", options), options.format ?? "markdown");
+}
+export async function runRerunEffectPlot(options) {
+    printOutput(await rerunAnalysisWithArtifact("effect", options), options.format ?? "markdown");
+}
+export async function runCreateBiasPlot(options) {
+    printOutput(await createAnalysisWithArtifact("bias", options), options.format ?? "markdown");
+}
+export async function runGetBiasPlot(options) {
+    printOutput(await getAnalysisWithArtifact("bias", options), options.format ?? "markdown");
+}
+export async function runRerunBiasPlot(options) {
+    printOutput(await rerunAnalysisWithArtifact("bias", options), options.format ?? "markdown");
+}
+export async function runCreateAssessmentPlot(options) {
+    printOutput(await createAnalysisWithArtifact("assessment", options), options.format ?? "markdown");
+}
+export async function runGetAssessmentPlot(options) {
+    printOutput(await getAnalysisWithArtifact("assessment", options), options.format ?? "markdown");
+}
+export async function runRerunAssessmentPlot(options) {
+    printOutput(await rerunAnalysisWithArtifact("assessment", options), options.format ?? "markdown");
+}
+export async function runCreatePrismaFlow(options) {
+    printOutput(await exportPrismaFlow(options), options.format ?? "markdown");
+}
+/** Exports the editable PRISMA Word artifact as part of the final draft bundle. */
+export async function exportFinalPrismaWordArtifact(options) {
+    return exportPrismaFlow({ ...options, exportFormat: "docx" });
+}
+export async function runUpdatePrismaFlowData(options) {
+    printOutput(await updatePrismaFlowData(options), options.format ?? "markdown");
+}
+export async function runGetPrismaImage(options) {
+    printOutput(await getPrismaImage(options), options.format ?? "markdown");
+}
+export async function runUploadPrismaImage(options) {
+    printOutput(await uploadPrismaImage(options), options.format ?? "markdown");
+}
+export async function runExportPrismaFlow(options) {
+    printOutput(await exportPrismaFlow(options), options.format ?? "markdown");
+}
+//# sourceMappingURL=analysis.js.map