helixlife-expert-cli 0.1.0

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

@@ -0,0 +1,913 @@
+import { readFile } from "node:fs/promises";
+import { createStderrProgress, helixlifeError, helixlifeErrorCode, printOutput, renderListAsMarkdown, } from "../../core/index.js";
+import { requestMeta } from "./api.js";
+import { META_API_PREFIX } from "./constants.js";
+import { createMetaNode, getMetaNodeOutput, pollMetaNodeStatus, } from "./node.js";
+const META_RETRIEVE_NODE_TYPES = {
+    PICOS: "generate_picos",
+    EXPRESSION: "generate_retrieve_expression",
+    LITERATURE: "literature_retrieve",
+};
+/** 四库检索式字段名（与网站 RETRIEVE_LIST_ENUMS / API 一致；Cochrane 字段为 conchrane）。 */
+const RETRIEVE_DATABASE_KEYS = ["pubmed", "wos", "embase", "conchrane"];
+/** 选择器展示名 → API 字段名（编辑检索式第一步选项）。 */
+const RETRIEVE_DATABASE_LABEL_TO_KEY = {
+    Pubmed: "pubmed",
+    PubMed: "pubmed",
+    pubmed: "pubmed",
+    WOS: "wos",
+    wos: "wos",
+    Embase: "embase",
+    embase: "embase",
+    Cochrane: "conchrane",
+    conchrane: "conchrane",
+};
+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, optionName, fileOptionName) {
+    if (filePath?.trim()) {
+        const content = await readFile(filePath.trim(), "utf8");
+        return parseJsonObject(content, fileOptionName);
+    }
+    if (!raw?.trim()) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `缺少 ${optionName} 或 ${fileOptionName}`);
+    }
+    return parseJsonObject(raw, optionName);
+}
+function extractNodeOutput(node) {
+    if (node.output &&
+        typeof node.output === "object" &&
+        "output" in node.output) {
+        return node.output.output;
+    }
+    return node.output ?? {};
+}
+/**
+ * 判断值是否为合法的四库 select 字段。
+ *
+ * @param value 候选 select。
+ * @returns 合法时返回字段名，否则 undefined。
+ */
+function resolveRetrieveDatabaseKey(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (RETRIEVE_DATABASE_KEYS.includes(trimmed)) {
+        return trimmed;
+    }
+    return RETRIEVE_DATABASE_LABEL_TO_KEY[trimmed];
+}
+/**
+ * 将检索式节点输出归一化为四个数据库检索式。
+ *
+ * 四库均可展示与编辑保存。
+ *
+ * @param output 检索式节点原始输出。
+ * @returns 包含四个数据库检索式和 select 的展示/提交数据。
+ */
+function normalizeRetrieveExpressionOutput(output) {
+    if (typeof output === "string") {
+        return normalizeRetrieveExpressionPayload({ pubmed: output });
+    }
+    if (!output || typeof output !== "object" || Array.isArray(output)) {
+        return normalizeRetrieveExpressionPayload({});
+    }
+    return normalizeRetrieveExpressionPayload(output);
+}
+/**
+ * 将检索式数据归一化为后端需要的完整数据库字段结构。
+ *
+ * 保存接口一次提交 `select` + `pubmed`/`wos`/`embase`/`conchrane` 四库全文。
+ * 用户可只改其中一库；未改字段由 fallback（当前节点输出）补齐。
+ *
+ * @param input 检索式原始输出或用户编辑后的输入。
+ * @param fallback 可选的原始节点输出，用于补齐未编辑的库。
+ * @returns 可直接提交给保存或检索接口的完整检索式结构。
+ */
+function normalizeRetrieveExpressionPayload(input, fallback = {}) {
+    const source = { ...fallback, ...input };
+    const pubmed = source.pubmed ??
+        source.PubMed ??
+        source.pubMed ??
+        source.pubmed_expression ??
+        "";
+    const select = resolveRetrieveDatabaseKey(source.select) ??
+        resolveRetrieveDatabaseKey(fallback.select) ??
+        "pubmed";
+    return {
+        select,
+        pubmed: typeof pubmed === "string" ? pubmed : String(pubmed ?? ""),
+        wos: typeof source.wos === "string" ? source.wos : String(source.wos ?? ""),
+        embase: typeof source.embase === "string"
+            ? source.embase
+            : String(source.embase ?? ""),
+        conchrane: typeof source.conchrane === "string"
+            ? source.conchrane
+            : String(source.conchrane ?? ""),
+    };
+}
+/** 检索式展示指令：必须以 expressionMarkdown 为唯一展示源（含编辑/重检前展示）。 */
+const EXPRESSION_DISPLAY_INSTRUCTION = "必须将 expressionMarkdown 整段原样复制进回复（禁止重打、改写、摘要）：" +
+    "PubMed / WOS / Embase / Cochrane 四库均须完整输出；禁止用 ... / … / 「及后续完整内容」等占位截断。" +
+    "保持原文换行，勿按 AND/OR 自行拆成多行。" +
+    "编辑细则分别见 meta.md「检索式 / 编辑检索式」与「检索结果 / 编辑检索式并重新检索」。";
+/**
+ * 将四库检索式格式化为可原样展示的 Markdown。
+ *
+ * @param output 已归一化的四库检索式字段。
+ * @returns 四库均可编辑的完整 Markdown（无只读标注）。
+ */
+function buildExpressionMarkdown(output) {
+    return [
+        "## PubMed 检索式",
+        "",
+        String(output.pubmed ?? ""),
+        "",
+        "## Web of Science 检索式",
+        "",
+        String(output.wos ?? ""),
+        "",
+        "## Embase 检索式",
+        "",
+        String(output.embase ?? ""),
+        "",
+        "## Cochrane 检索式",
+        "",
+        String(output.conchrane ?? ""),
+    ].join("\n");
+}
+/**
+ * 归一化检索式结果，附加 expressionMarkdown 供 Agent 原样展示四库全文。
+ *
+ * @param result 检索式节点执行或读取结果。
+ * @returns 带 displayOutput / expressionMarkdown 的结果。
+ */
+function normalizeRetrieveExpressionResult(result) {
+    if (result.nodeType !== META_RETRIEVE_NODE_TYPES.EXPRESSION) {
+        return result;
+    }
+    const output = normalizeRetrieveExpressionOutput(result.output);
+    return {
+        ...result,
+        output,
+        displayOutput: output,
+        displayInstruction: EXPRESSION_DISPLAY_INSTRUCTION,
+        expressionMarkdown: buildExpressionMarkdown(output),
+        node: {
+            ...result.node,
+            output: { output },
+        },
+    };
+}
+function splitListField(value) {
+    if (typeof value === "string") {
+        return value
+            .split(/[，,;]/)
+            .map((item) => item.trim())
+            .filter(Boolean);
+    }
+    return value;
+}
+function normalizePublicationDate(value) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const timestamp = /^\d{4}-\d{2}-\d{2}$/.test(trimmed)
+        ? Date.parse(`${trimmed}T00:00:00Z`)
+        : Date.parse(trimmed);
+    return Number.isNaN(timestamp) ? value : Math.floor(timestamp / 1000);
+}
+/**
+ * 将补充文献输入转换为网站接口使用的数据结构。
+ *
+ * 仅保留网站补充文献表单支持的字段，并统一作者、发表类型和发表日期格式。
+ *
+ * @param input 用户提交的补充文献数据。
+ * @returns 可发送给补充文献接口的数据。
+ */
+function normalizeLiteratureInput(input) {
+    const allowedKeys = [
+        "id",
+        "author",
+        "title",
+        "doi",
+        "abstract",
+        "publication_type",
+        "publication_date",
+        "pmid",
+        "pmc",
+    ];
+    const normalized = Object.fromEntries(Object.entries(input).filter(([key]) => allowedKeys.includes(key)));
+    if ("author" in normalized) {
+        normalized.author = splitListField(normalized.author);
+    }
+    if ("publication_type" in normalized) {
+        normalized.publication_type = splitListField(normalized.publication_type);
+    }
+    if ("publication_date" in normalized) {
+        const publicationDate = normalizePublicationDate(normalized.publication_date);
+        if (publicationDate === undefined) {
+            delete normalized.publication_date;
+        }
+        else {
+            normalized.publication_date = publicationDate;
+        }
+    }
+    return normalized;
+}
+/**
+ * 校验网站补充文献表单在创建模式下要求的必填字段。
+ *
+ * @param input 已归一化的补充文献数据。
+ * @throws {helixlifeError} 缺少 author、title、abstract 或 publication_date 时抛出。
+ */
+function validateLiteratureInput(input) {
+    const requiredFields = ["author", "title", "abstract", "publication_date"];
+    const missingFields = requiredFields.filter((field) => {
+        const value = input[field];
+        if (Array.isArray(value)) {
+            return value.length === 0;
+        }
+        return value === undefined || value === null || String(value).trim() === "";
+    });
+    if (missingFields.length > 0) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `补充文献缺少必填字段：${missingFields.join(", ")}`);
+    }
+}
+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;
+}
+/**
+ * 读取当前检索式节点的原始输出，用于保存或检索时补齐隐藏数据库字段。
+ *
+ * @param options 工作流和节点定位参数。
+ * @returns 检索式节点输出对象；无法读取为对象时返回空对象。
+ */
+async function getRetrieveExpressionFallback(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_RETRIEVE_NODE_TYPES.EXPRESSION,
+        label: "检索式",
+        configPath: options.configPath,
+    });
+    const output = await getMetaNodeOutput({
+        workflowId: options.workflowId,
+        nodeId,
+        configPath: options.configPath,
+    });
+    const rawOutput = extractNodeOutput(output.data);
+    return {
+        nodeId,
+        output: rawOutput && typeof rawOutput === "object" && !Array.isArray(rawOutput)
+            ? rawOutput
+            : {},
+    };
+}
+async function runRetrieveNode(options) {
+    const progress = createStderrProgress(options.format === "json");
+    progress.start(options.progressMessage);
+    try {
+        const created = await createMetaNode({
+            workflowId: options.workflowId,
+            nodeType: options.nodeType,
+            input: options.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("Meta 节点执行完成，正在输出结果...");
+        return {
+            runnerId: options.workflowId,
+            nodeId: created.nodeId,
+            nodeType: options.nodeType,
+            status: output.data.status,
+            input: options.input,
+            output: extractNodeOutput(output.data),
+            node: output.data,
+        };
+    }
+    catch (error) {
+        progress.dispose();
+        throw error;
+    }
+}
+/**
+ * 输出文献检索 create 结果；JSON 仅暴露 tableMarkdown，避免 Agent 从 rows 自行拼缩略表。
+ *
+ * @param result create 返回的检索步骤结果。
+ * @param format 输出格式。
+ */
+function printLiteratureCreateResult(result, format) {
+    if (format === "json") {
+        printOutput({
+            runnerId: result.runnerId,
+            nodeId: result.nodeId,
+            nodeType: result.nodeType,
+            status: result.status,
+            displayInstruction: result.displayInstruction,
+            tableMarkdown: result.tableMarkdown,
+            total: result.total,
+            page: result.page,
+            limit: result.limit,
+        }, "json");
+        return;
+    }
+    console.log(result.tableMarkdown ?? "");
+}
+/**
+ * 输出文献检索 list 结果；JSON 仅暴露 tableMarkdown 与分页字段。
+ *
+ * @param result list 返回的检索列表结果。
+ * @param format 输出格式。
+ */
+function printLiteratureListResult(result, format) {
+    if (format === "json") {
+        printOutput({
+            runnerId: result.runnerId,
+            nodeId: result.nodeId,
+            displayInstruction: result.displayInstruction,
+            tableMarkdown: result.tableMarkdown,
+            total: result.total,
+            page: result.page,
+            limit: result.limit,
+        }, "json");
+        return;
+    }
+    console.log(result.tableMarkdown ?? "");
+}
+function printRetrieveStepResult(result, format) {
+    if (result.nodeType === META_RETRIEVE_NODE_TYPES.LITERATURE) {
+        printLiteratureCreateResult(result, format);
+        return;
+    }
+    if (format === "json") {
+        if (result.nodeType === META_RETRIEVE_NODE_TYPES.EXPRESSION) {
+            printOutput({
+                runnerId: result.runnerId,
+                nodeId: result.nodeId,
+                nodeType: result.nodeType,
+                status: result.status,
+                displayInstruction: result.displayInstruction,
+                expressionMarkdown: result.expressionMarkdown,
+                displayOutput: result.displayOutput,
+            }, "json");
+            return;
+        }
+        printOutput(result, "json");
+        return;
+    }
+    if (result.expressionMarkdown) {
+        console.log(result.expressionMarkdown);
+        return;
+    }
+    console.log(renderListAsMarkdown([
+        {
+            runnerId: result.runnerId,
+            nodeType: result.nodeType,
+            status: result.status,
+        },
+    ], [
+        { key: "runnerId", label: "runnerId" },
+        { key: "nodeType", label: "节点类型" },
+        { key: "status", label: "状态" },
+    ]));
+    console.log("\n输出：");
+    console.log(typeof result.output === "string"
+        ? result.output
+        : JSON.stringify(result.output, null, 2));
+}
+export async function createRetrieveExpression(options) {
+    const picosNodeId = options.picosNodeId?.trim() ??
+        (await resolveNodeId({
+            workflowId: options.workflowId,
+            nodeType: META_RETRIEVE_NODE_TYPES.PICOS,
+            label: "PICOS",
+            configPath: options.configPath,
+        }));
+    const progress = createStderrProgress(options.format === "json");
+    progress.start("正在生成检索式...");
+    try {
+        const created = await requestMeta(`${META_API_PREFIX}/generate-retrieve-expression/execute`, {
+            method: "POST",
+            params: {
+                run_id: options.workflowId,
+                picos_node_id: picosNodeId,
+            },
+            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 normalizeRetrieveExpressionResult({
+            runnerId: options.workflowId,
+            nodeId: created.node_id,
+            nodeType: META_RETRIEVE_NODE_TYPES.EXPRESSION,
+            status: output.data.status,
+            input: { picos_node_id: picosNodeId },
+            output: extractNodeOutput(output.data),
+            node: output.data,
+        });
+    }
+    catch (error) {
+        progress.dispose();
+        throw error;
+    }
+}
+export async function saveRetrieveExpression(options) {
+    const fallback = await getRetrieveExpressionFallback({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_RETRIEVE_NODE_TYPES.EXPRESSION,
+        label: "检索式",
+        configPath: options.configPath,
+    });
+    const parsedInput = await parseJsonObjectInput(options.expressionJson, options.expressionFile, "--expression-json", "--expression-file");
+    const input = normalizeRetrieveExpressionPayload(parsedInput, fallback.output);
+    const data = await requestMeta(`${META_API_PREFIX}/generate-retrieve-expression`, {
+        method: "PUT",
+        params: {
+            run_id: options.workflowId,
+            node_id: fallback.nodeId,
+        },
+        body: input,
+        configPath: options.configPath,
+        action: "保存检索式",
+    });
+    return {
+        runnerId: options.workflowId,
+        nodeId: fallback.nodeId,
+        input,
+        data,
+    };
+}
+export async function checkRetrieveExpression(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_RETRIEVE_NODE_TYPES.EXPRESSION,
+        label: "检索式",
+        configPath: options.configPath,
+    });
+    const data = await requestMeta(`${META_API_PREFIX}/generate-retrieve-expression/check-before-next`, {
+        params: {
+            run_id: options.workflowId,
+            node_id: nodeId,
+        },
+        configPath: options.configPath,
+        action: "校验检索式",
+    });
+    return {
+        runnerId: options.workflowId,
+        nodeId,
+        data,
+    };
+}
+/**
+ * 读取当前已生成的检索式（不重新执行），用于历史切换后展示。
+ *
+ * @param options 工作流与可选节点 ID。
+ * @returns 归一化后的检索式结果（含 expressionMarkdown）。
+ */
+export async function getRetrieveExpression(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_RETRIEVE_NODE_TYPES.EXPRESSION,
+        label: "检索式",
+        configPath: options.configPath,
+    });
+    const output = await getMetaNodeOutput({
+        workflowId: options.workflowId,
+        nodeId,
+        configPath: options.configPath,
+    });
+    return normalizeRetrieveExpressionResult({
+        runnerId: options.workflowId,
+        nodeId,
+        nodeType: META_RETRIEVE_NODE_TYPES.EXPRESSION,
+        status: output.data.status,
+        input: {},
+        output: extractNodeOutput(output.data),
+        node: output.data,
+    });
+}
+export async function rerunRetrieveExpression(options) {
+    const fallback = await getRetrieveExpressionFallback({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_RETRIEVE_NODE_TYPES.EXPRESSION,
+        label: "检索式",
+        configPath: options.configPath,
+    });
+    const progress = createStderrProgress(options.format === "json");
+    progress.start("正在重新生成检索式...");
+    try {
+        await requestMeta(`${META_API_PREFIX}/nodes/re-execute`, {
+            method: "POST",
+            body: {
+                run_id: options.workflowId,
+                node_id: fallback.nodeId,
+                node_type: META_RETRIEVE_NODE_TYPES.EXPRESSION,
+            },
+            configPath: options.configPath,
+            action: "重新生成检索式",
+        });
+        await pollMetaNodeStatus({
+            workflowId: options.workflowId,
+            nodeId: fallback.nodeId,
+            configPath: options.configPath,
+        });
+        const output = await getMetaNodeOutput({
+            workflowId: options.workflowId,
+            nodeId: fallback.nodeId,
+            configPath: options.configPath,
+        });
+        progress.finish("检索式重新生成完成，正在输出结果...");
+        return normalizeRetrieveExpressionResult({
+            runnerId: options.workflowId,
+            nodeId: fallback.nodeId,
+            nodeType: META_RETRIEVE_NODE_TYPES.EXPRESSION,
+            status: output.data.status,
+            input: {},
+            output: extractNodeOutput(output.data),
+            node: output.data,
+        });
+    }
+    catch (error) {
+        progress.dispose();
+        throw error;
+    }
+}
+const RETRIEVE_LITERATURE_COLUMNS = [
+    { key: "no", label: "NO." },
+    { key: "author", label: "Author" },
+    { key: "title", label: "Title" },
+    { key: "doi", label: "DOI" },
+    { key: "abstract", label: "Abstract" },
+    { key: "publication_type", label: "Publication Type" },
+    { key: "publication_date", label: "Publication Date" },
+    { key: "pmid", label: "PMID" },
+    { key: "pmc", label: "PMC" },
+];
+/** 检索结果展示硬规则：Agent 须以 tableMarkdown 为唯一展示源，完整输出 9 列 */
+const LITERATURE_DISPLAY_INSTRUCTION = "必须将 tableMarkdown 作为检索结果的唯一展示源并逐字完整输出全部 9 列和全部返回记录：" +
+    "NO. / Author / Title / DOI / Abstract / Publication Type / Publication Date / PMID / PMC。" +
+    "禁止自行删列、合并或重建为 NO./Author/Title/DOI/Publication Type/PMID 等子集列；" +
+    "禁止截断 Abstract；禁止把 Publication Date 改成 Year；禁止用「检索完成 / 共检索到 N 篇」等摘要代替完整 tableMarkdown。" +
+    "可用 total/page/limit 写一句分页说明，但表格本身只能来自 tableMarkdown。";
+/** 将接口 total/page/limit 规范为有限数字；无效时回退默认值。 */
+function toFiniteNumber(value, fallback) {
+    const num = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(num) ? num : fallback;
+}
+function unwrapRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function extractListPayload(data) {
+    const root = unwrapRecord(data);
+    const nested = unwrapRecord(root.data);
+    const payload = Object.keys(nested).length > 0 ? nested : root;
+    const items = Array.isArray(payload.items)
+        ? payload.items
+        : Array.isArray(payload.list)
+            ? payload.list
+            : Array.isArray(payload.records)
+                ? payload.records
+                : Array.isArray(payload.results)
+                    ? payload.results
+                    : Array.isArray(payload.data)
+                        ? payload.data
+                        : Array.isArray(data)
+                            ? data
+                            : [];
+    return {
+        items,
+        total: payload.total ?? payload.count,
+        page: payload.page,
+        limit: payload.limit,
+    };
+}
+function formatListField(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => String(item ?? ""))
+            .filter(Boolean)
+            .join(", ");
+    }
+    return value === undefined || value === null ? "" : String(value);
+}
+function formatPublicationDateForDisplay(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return new Date(value * 1000).toISOString().slice(0, 10);
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (/^\d{4}-\d{2}-\d{2}/.test(trimmed)) {
+            return trimmed.slice(0, 10);
+        }
+        const timestamp = Date.parse(trimmed);
+        if (!Number.isNaN(timestamp)) {
+            return new Date(timestamp).toISOString().slice(0, 10);
+        }
+        return trimmed;
+    }
+    return "";
+}
+function buildRetrieveLiteratureTable(data, options) {
+    const { items } = extractListPayload(data);
+    const page = options.page ?? 1;
+    const limit = options.limit ?? 10;
+    const rows = items.map((item, index) => {
+        const record = unwrapRecord(item);
+        return {
+            no: (page - 1) * limit + index + 1,
+            author: formatListField(record.author),
+            title: formatListField(record.title),
+            doi: formatListField(record.doi),
+            abstract: formatListField(record.abstract),
+            publication_type: formatListField(record.publication_type),
+            publication_date: formatPublicationDateForDisplay(record.publication_date),
+            pmid: formatListField(record.pmid),
+            pmc: formatListField(record.pmc),
+        };
+    });
+    return { columns: [...RETRIEVE_LITERATURE_COLUMNS], rows };
+}
+/** 与网站 NODE_PENDING_STATUS 对齐：进行中的检索结果节点需先等完成再清理重建。 */
+const LITERATURE_PENDING_STATUSES = new Set([
+    "queued",
+    "pending",
+    "running",
+    "more_coming",
+]);
+/**
+ * 对齐网站 getWorkflowInfo：已存在 literature_retrieve 时先内部 backoff，再允许 execute-as-create。
+ * 供「编辑检索式并重新检索」在检索结果节点直接重跑；Agent 无需自行 workflow backoff。
+ *
+ * @param options 工作流与配置。
+ */
+async function clearExistingLiteratureRetrieveNode(options) {
+    const workflow = await getWorkflow(options.workflowId, options.configPath);
+    const existing = findLatestNode(workflow, META_RETRIEVE_NODE_TYPES.LITERATURE);
+    if (!existing?.id) {
+        return false;
+    }
+    // 进行中则先等到终态，再清理，否则无法带上新检索式重建
+    if (LITERATURE_PENDING_STATUSES.has(String(existing.status ?? ""))) {
+        await pollMetaNodeStatus({
+            workflowId: options.workflowId,
+            nodeId: existing.id,
+            configPath: options.configPath,
+        });
+    }
+    const latest = await getWorkflow(options.workflowId, options.configPath);
+    const node = findLatestNode(latest, META_RETRIEVE_NODE_TYPES.LITERATURE);
+    if (!node?.id) {
+        return false;
+    }
+    const head = latest.head?.trim();
+    if (head && head !== node.id) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "当前工作流头已越过文献检索节点，无法在此直接重新检索。" +
+            "请先回退到检索结果节点后再执行「编辑检索式并重新检索」。");
+    }
+    // 内部清理旧检索结果节点（对齐网站 backoff(literature_retrieve)），不向 Agent 暴露回退指引
+    await requestMeta(`${META_API_PREFIX}/workflow/runs/${encodeURIComponent(options.workflowId)}/backoff`, {
+        method: "POST",
+        params: { node_id: node.id },
+        configPath: options.configPath,
+        action: "清理旧文献检索节点",
+    });
+    return true;
+}
+/**
+ * 执行文献检索；若当前已在检索结果节点，会先内部清理旧节点再带检索式重建（对齐网站 retrieve 页）。
+ *
+ * @param options 工作流与可选编辑后的检索式。
+ * @returns 检索步骤结果（含 tableMarkdown）。
+ */
+export async function createRetrieveLiterature(options) {
+    const fallback = await getRetrieveExpressionFallback({
+        workflowId: options.workflowId,
+        configPath: options.configPath,
+    });
+    const hasInlineExpression = Boolean(options.expressionJson?.trim());
+    const hasExpressionFile = Boolean(options.expressionFile?.trim());
+    const hasEditedExpression = hasInlineExpression || hasExpressionFile;
+    const parsedInput = hasEditedExpression
+        ? await parseJsonObjectInput(options.expressionJson, options.expressionFile, "--expression-json", "--expression-file")
+        : fallback.output;
+    const input = normalizeRetrieveExpressionPayload(parsedInput, fallback.output);
+    // literature_retrieve 的 execute-as-create：input.select 默认 pubmed
+    const literatureInput = { ...input, select: "pubmed" };
+    // 编辑检索式重跑：先同步写回检索式节点，便于后续 expression get；再校验
+    if (hasEditedExpression) {
+        await requestMeta(`${META_API_PREFIX}/generate-retrieve-expression`, {
+            method: "PUT",
+            params: {
+                run_id: options.workflowId,
+                node_id: fallback.nodeId,
+            },
+            body: input,
+            configPath: options.configPath,
+            action: "同步保存编辑后的检索式",
+        });
+        await checkRetrieveExpression({
+            workflowId: options.workflowId,
+            nodeId: fallback.nodeId,
+            configPath: options.configPath,
+        });
+    }
+    const cleared = await clearExistingLiteratureRetrieveNode({
+        workflowId: options.workflowId,
+        configPath: options.configPath,
+    });
+    const stepResult = await runRetrieveNode({
+        workflowId: options.workflowId,
+        nodeType: META_RETRIEVE_NODE_TYPES.LITERATURE,
+        input: literatureInput,
+        format: options.format,
+        configPath: options.configPath,
+        progressMessage: cleared
+            ? "已清理旧检索结果，正在按更新后的检索式重新检索文献..."
+            : "正在检索文献...",
+    });
+    // create 完成后自动拉第 1 页列表并挂 tableMarkdown（对齐 screening create）
+    const listResult = await listRetrieveLiterature({
+        workflowId: options.workflowId,
+        nodeId: stepResult.nodeId,
+        page: 1,
+        limit: 10,
+        configPath: options.configPath,
+    });
+    return {
+        ...stepResult,
+        displayInstruction: LITERATURE_DISPLAY_INSTRUCTION,
+        tableMarkdown: listResult.tableMarkdown,
+        total: listResult.total,
+        page: listResult.page,
+        limit: listResult.limit,
+    };
+}
+export async function listRetrieveLiterature(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_RETRIEVE_NODE_TYPES.LITERATURE,
+        label: "文献检索",
+        configPath: options.configPath,
+    });
+    const data = await requestMeta(`${META_API_PREFIX}/literature-retrieve-result`, {
+        params: {
+            run_id: options.workflowId,
+            node_id: nodeId,
+            page: options.page,
+            limit: options.limit,
+            sort: options.sort,
+            order: options.order,
+            publication_type: options.publicationType?.join(","),
+        },
+        configPath: options.configPath,
+        action: "查询文献检索结果",
+    });
+    const payload = extractListPayload(data);
+    const page = options.page ?? toFiniteNumber(payload.page, 1);
+    const limit = options.limit ?? toFiniteNumber(payload.limit, 10);
+    const table = buildRetrieveLiteratureTable(data, { ...options, page, limit });
+    const total = toFiniteNumber(payload.total, table.rows.length);
+    return {
+        runnerId: options.workflowId,
+        nodeId,
+        data,
+        displayInstruction: LITERATURE_DISPLAY_INSTRUCTION,
+        columns: table.columns,
+        rows: table.rows,
+        displayColumns: table.columns.map((column) => column.label),
+        displayRows: table.rows,
+        tableMarkdown: renderListAsMarkdown(table.rows, table.columns),
+        table,
+        total,
+        page,
+        limit,
+    };
+}
+export async function addRetrieveLiterature(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_RETRIEVE_NODE_TYPES.LITERATURE,
+        label: "文献检索",
+        configPath: options.configPath,
+    });
+    const input = normalizeLiteratureInput(await parseJsonObjectInput(options.literatureJson, options.literatureFile, "--literature-json", "--literature-file"));
+    validateLiteratureInput(input);
+    const data = await requestMeta(`${META_API_PREFIX}/literature-retrieve-result`, {
+        method: "POST",
+        params: {
+            run_id: options.workflowId,
+            node_id: nodeId,
+        },
+        body: input,
+        configPath: options.configPath,
+        action: "补充文献",
+    });
+    return {
+        runnerId: options.workflowId,
+        nodeId,
+        input,
+        data,
+    };
+}
+export async function runCreateRetrieveExpression(options) {
+    const result = await createRetrieveExpression(options);
+    printRetrieveStepResult(result, options.format ?? "markdown");
+}
+export async function runSaveRetrieveExpression(options) {
+    const result = await saveRetrieveExpression(options);
+    printOutput(result, options.format ?? "markdown");
+}
+export async function runCheckRetrieveExpression(options) {
+    const result = await checkRetrieveExpression(options);
+    printOutput(result, options.format ?? "markdown");
+}
+export async function runGetRetrieveExpression(options) {
+    const result = await getRetrieveExpression(options);
+    printRetrieveStepResult(result, options.format ?? "markdown");
+}
+export async function runRerunRetrieveExpression(options) {
+    const result = await rerunRetrieveExpression(options);
+    printRetrieveStepResult(result, options.format ?? "markdown");
+}
+export async function runCreateRetrieveLiterature(options) {
+    const result = await createRetrieveLiterature(options);
+    printRetrieveStepResult(result, options.format ?? "markdown");
+}
+export async function runListRetrieveLiterature(options) {
+    const result = await listRetrieveLiterature(options);
+    printLiteratureListResult(result, options.format ?? "markdown");
+}
+export async function runAddRetrieveLiterature(options) {
+    const result = await addRetrieveLiterature(options);
+    printOutput(result, options.format ?? "markdown");
+}
+//# sourceMappingURL=retrieve.js.map