helixlife-expert-cli 0.1.0

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

@@ -0,0 +1,865 @@
+import { readFile } from "node:fs/promises";
+import { createStderrProgress, helixlifeError, helixlifeErrorCode, printOutput, renderListAsMarkdown, } from "../../core/index.js";
+import { META_API_PREFIX } from "./constants.js";
+import { requestMeta } from "./api.js";
+import { createMetaNode, getMetaNodeOutput, pollMetaNodeStatus, } from "./node.js";
+const META_NODE_TYPES = {
+    GENERATE_TOPIC: "generate_topic",
+    VERIFY_TOPIC: "verify_topic",
+    GENERATE_PICOS: "generate_picos",
+    GENERATE_SORTING_CRITERIA: "generate_sorting_criteria",
+};
+const PICOS_FIELD_LABELS = {
+    P: "Population / Participants",
+    I: "Intervention / Exposure",
+    C: "Comparator / Context",
+    O: "Outcome",
+    S: "Study Characteristics / Design",
+    Other: "Other",
+};
+/** 候选题选定后的操作选项（文案固定，禁止改写） */
+const CONFIRMED_TOPIC_OPERATION_OPTIONS = [
+    "编辑当前选题",
+    "确认无误，下一步（生成 PICOS）",
+];
+/**
+ * 构建「已确认选题」展示与选择器指令。
+ *
+ * @param selectedIndex 已选序号（1-based），未知时为 undefined。
+ * @returns displayInstruction 与 selectorTitle。
+ */
+function buildConfirmedTopicGuidance(selectedIndex) {
+    const selectorTitle = selectedIndex !== undefined
+        ? `已选择选题 ${selectedIndex}`
+        : "已选择选题";
+    return {
+        selectorTitle,
+        operationOptions: [...CONFIRMED_TOPIC_OPERATION_OPTIONS],
+        displayInstruction: `topic select 成功后：必须在聊天展示「${selectorTitle}」及题目原文；` +
+            `AskQuestion / 选择器的标题（title）必须原样为「${selectorTitle}」；` +
+            "一级选项固定为：编辑当前选题 / 确认无误，下一步（生成 PICOS）。" +
+            "禁止使用「请选择下一步操作」「请选择操作」「请选择」等泛化标题；" +
+            "禁止未展示已选选题就弹编辑/确认操作；禁止仍用「编辑选题」旧文案。",
+    };
+}
+const CRITERIA_DISPLAY_INSTRUCTION = "必须原样展示接口返回的 displayData。" +
+    "禁止增加标题、标签、前后缀、解释或其他包装文本；" +
+    "禁止翻译、改写、摘要、本地化、重排、拆分、合并或生成中英混排内容。";
+/** 对齐网站「您输入选题无法生成 PICOS」弹窗文案 */
+const VERIFY_CANDIDATES_NOTICE = {
+    title: "您输入选题无法生成 PICOS",
+    message: "您的选题无法生成 PICOS，我们根据您的输入，帮助您生成了一些 Meta 选题内容。",
+};
+const VERIFY_CANDIDATES_DISPLAY_INSTRUCTION = "verificationStatus=candidates_required 时：必须先原样向用户展示 verificationNotice.title 与 verificationNotice.message" +
+    "（对齐网站弹窗，禁止改写/省略），再原样输出 candidateListMarkdown，并弹 selectionOptions 选择器（含「重新生成选题」）。" +
+    "禁止跳过提示直接列候选题或改用自拟说明。";
+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);
+}
+async function resolveWorkflowId(options) {
+    if (options.workflowId?.trim()) {
+        return options.workflowId.trim();
+    }
+    throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "缺少 --workflow-id。Meta 选题、PICOS 和纳排标准必须沿用已创建的工作流，禁止在节点命令中自动创建新工作流。");
+}
+function transformTitleData(data) {
+    return Object.fromEntries(Object.entries(data)
+        .filter(([key]) => key !== "selected")
+        .map(([key, value]) => [
+        key,
+        typeof value === "object" && value !== null
+            ? value
+            : { English: String(value ?? ""), Chinese: "" },
+    ]));
+}
+function inferTopicSource(nodeType) {
+    if (nodeType === "verify_topic" || nodeType === "verify_topic_guard") {
+        return "verify";
+    }
+    return "generate";
+}
+function findTopicNode(workflow, source) {
+    const candidates = source === "verify"
+        ? ["verify_topic", "verify_topic_guard"]
+        : source === "generate"
+            ? ["generate_topic", "generate_topic_guard"]
+            : [
+                "generate_topic",
+                "generate_topic_guard",
+                "verify_topic",
+                "verify_topic_guard",
+            ];
+    return [...(workflow.nodes ?? [])]
+        .reverse()
+        .find((node) => candidates.includes(node.node_type));
+}
+function findLatestNode(workflow, nodeType) {
+    return [...(workflow.nodes ?? [])]
+        .reverse()
+        .find((node) => node.node_type === nodeType);
+}
+async function getWorkflowForSave(runnerId, options) {
+    return requestMeta(`${META_API_PREFIX}/workflow/runs/${encodeURIComponent(runnerId)}`, {
+        configPath: options.configPath,
+        action: "查询 Meta 工作流",
+    });
+}
+async function resolveTopicSaveTarget(options) {
+    const runnerId = await resolveWorkflowId(options);
+    const workflow = await getWorkflowForSave(runnerId, options);
+    // 显式 node-id：来源优先用参数，否则按节点类型推断
+    if (options.nodeId?.trim()) {
+        const explicitNode = (workflow.nodes ?? []).find((node) => node.id === options.nodeId?.trim());
+        return {
+            runnerId,
+            nodeId: options.nodeId.trim(),
+            source: options.source ??
+                inferTopicSource(explicitNode?.node_type) ??
+                "generate",
+        };
+    }
+    // 先按指定 source 找；找不到再在全部选题节点中回退（避免默认 generate 在 verify 工作流上报 E2001）
+    const node = findTopicNode(workflow, options.source) ??
+        (options.source ? findTopicNode(workflow) : undefined);
+    if (!node) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "当前工作流中未找到可确认的 Meta 选题节点");
+    }
+    return {
+        runnerId,
+        nodeId: node.id,
+        source: options.source ?? inferTopicSource(node.node_type),
+    };
+}
+async function resolveNodeSaveTarget(options, nodeType, label) {
+    const runnerId = await resolveWorkflowId(options);
+    if (options.nodeId?.trim()) {
+        return { runnerId, nodeId: options.nodeId.trim() };
+    }
+    const workflow = await getWorkflowForSave(runnerId, options);
+    const node = findLatestNode(workflow, nodeType);
+    if (!node) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `当前工作流中未找到可保存的 ${label} 节点`);
+    }
+    return { runnerId, nodeId: node.id };
+}
+function extractNodeOutput(node) {
+    if (node.output &&
+        typeof node.output === "object" &&
+        "output" in node.output) {
+        return node.output.output;
+    }
+    return node.output ?? {};
+}
+/**
+ * 将 Meta 选题节点的原始输出转换为题目数组。
+ *
+ * 后台可能返回 TitleN 映射、题目对象数组或字符串数组；CLI 对外仅保留
+ * 每个候选项中承载题目内容的 English 字段。English 是后台字段名，
+ * 不表示题目内容必须使用英文。
+ *
+ * @param output Meta 选题节点的原始输出。
+ * @returns 已去除空值和首尾空格的题目数组。
+ */
+function normalizeTopicTitles(output) {
+    if (Array.isArray(output)) {
+        return output
+            .map((item) => {
+            if (typeof item === "string") {
+                return item.trim();
+            }
+            if (item && typeof item === "object") {
+                return extractTopicTitle(item);
+            }
+            return "";
+        })
+            .filter(Boolean);
+    }
+    if (!output || typeof output !== "object") {
+        return [];
+    }
+    return Object.entries(output)
+        .filter(([key]) => key !== "selected")
+        .map(([, value]) => {
+        if (typeof value === "string") {
+            return value.trim();
+        }
+        if (value && typeof value === "object") {
+            return extractTopicTitle(value);
+        }
+        return "";
+    })
+        .filter(Boolean);
+}
+/**
+ * 从候选题目对象中提取可展示标题。
+ *
+ * 后台当前主要使用 English 字段，但历史或转发层可能返回 title/Title/name
+ * 等字段。这里统一兼容，避免候选项退化为“选题 1”这类泛称。
+ *
+ * @param item 候选题目对象。
+ * @returns 可展示的完整题目。
+ */
+function extractTopicTitle(item) {
+    for (const key of ["English", "english", "title", "Title", "name", "topic"]) {
+        const value = item[key];
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    const firstString = Object.values(item).find((value) => typeof value === "string" && value.trim());
+    return typeof firstString === "string" ? firstString.trim() : "";
+}
+/**
+ * 构造 WorkBuddy 选择器可直接使用的候选项。
+ *
+ * @param titles 完整题目数组。
+ * @returns label 为简短序号文案，value 为对应完整题目的选项数组。
+ */
+function buildTopicSelectionOptions(titles) {
+    return titles.map((title, index) => ({
+        index: index + 1,
+        label: `选题 ${index + 1}`,
+        value: title,
+    }));
+}
+function buildTopicCandidateListMarkdown(titles) {
+    return titles
+        .map((title, index) => `${index + 1}. ${title}`)
+        .join("\n");
+}
+/**
+ * 为「已有选题」校验失败（需选候选题）附加网站同款提示与展示指令。
+ *
+ * @param result 已归一化的选题结果。
+ * @param verifiedTitle 用户原始输入的选题（可选）。
+ * @returns 带 verificationStatus / verificationNotice / displayInstruction 的结果。
+ */
+function withVerifyCandidatesRequired(result, verifiedTitle) {
+    const candidates = result.candidates ?? [];
+    if (!candidates.length) {
+        return {
+            ...result,
+            verificationStatus: "accepted",
+            ...(verifiedTitle !== undefined ? { verifiedTitle } : {}),
+        };
+    }
+    return {
+        ...result,
+        verificationStatus: "candidates_required",
+        verificationNotice: {
+            title: VERIFY_CANDIDATES_NOTICE.title,
+            message: VERIFY_CANDIDATES_NOTICE.message,
+        },
+        displayInstruction: VERIFY_CANDIDATES_DISPLAY_INSTRUCTION,
+        ...(verifiedTitle !== undefined ? { verifiedTitle } : {}),
+    };
+}
+/**
+ * 归一化 Meta 选题命令的完整返回结果。
+ *
+ * 除顶层 output 外，同时替换 node.output 中的原始候选对象，确保 CLI JSON
+ * 不再暴露 TitleN 等后台内部字段；workflow 中保存的节点数据不受影响。
+ *
+ * @param result Meta 选题节点的执行结果。
+ * @returns 对外输出已统一为题目数组的执行结果。
+ */
+function normalizeTopicResult(result) {
+    const titles = normalizeTopicTitles(result.output);
+    const selectionOptions = buildTopicSelectionOptions(titles);
+    return {
+        ...result,
+        output: titles,
+        candidates: titles,
+        selectionOptions,
+        candidateListMarkdown: buildTopicCandidateListMarkdown(titles),
+        node: {
+            ...result.node,
+            output: { output: titles },
+        },
+    };
+}
+async function runMetaTopicNode(options) {
+    const runnerId = await resolveWorkflowId(options);
+    const progress = createStderrProgress(options.format === "json");
+    progress.start(options.progressMessage);
+    try {
+        const created = await createMetaNode({
+            workflowId: runnerId,
+            nodeType: options.nodeType,
+            input: options.input,
+            configPath: options.configPath,
+        });
+        await pollMetaNodeStatus({
+            workflowId: runnerId,
+            nodeId: created.nodeId,
+            configPath: options.configPath,
+        });
+        const output = await getMetaNodeOutput({
+            workflowId: runnerId,
+            nodeId: created.nodeId,
+            configPath: options.configPath,
+        });
+        progress.finish("Meta 节点执行完成，正在输出结果...");
+        return {
+            runnerId,
+            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;
+    }
+}
+function printMetaTopicResult(result, format) {
+    if (format === "json") {
+        printOutput(result, "json");
+        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输出：");
+    if ((result.nodeType === META_NODE_TYPES.GENERATE_TOPIC ||
+        result.nodeType === META_NODE_TYPES.VERIFY_TOPIC) &&
+        Array.isArray(result.output)) {
+        // 已有选题校验失败时先打出网站同款提示，再列候选题
+        if (result.verificationStatus === "candidates_required" &&
+            result.verificationNotice) {
+            console.log(result.verificationNotice.title);
+            console.log(result.verificationNotice.message);
+            console.log("");
+        }
+        console.log(result.candidateListMarkdown ??
+            buildTopicCandidateListMarkdown(result.output));
+        return;
+    }
+    console.log(typeof result.output === "string"
+        ? result.output
+        : JSON.stringify(result.output, null, 2));
+}
+async function buildPicosInput(options) {
+    let titleData = parseJsonObject(options.titlesJson, "--titles-json");
+    const selectedTitle = options.title.trim();
+    if (!selectedTitle) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "缺少 Meta 选题");
+    }
+    if (!options.titlesJson?.trim()) {
+        const runnerId = await resolveWorkflowId(options);
+        const workflow = await getWorkflowForSave(runnerId, options);
+        const topicNode = findTopicNode(workflow);
+        if (topicNode) {
+            const currentNode = await getMetaNodeOutput({
+                workflowId: runnerId,
+                nodeId: topicNode.id,
+                configPath: options.configPath,
+            });
+            titleData = buildTopicFieldsFromOutput(extractNodeOutput(currentNode.data));
+        }
+    }
+    return {
+        ...transformTitleData(titleData),
+        title: selectedTitle,
+    };
+}
+/**
+ * 将面向用户的完整 PICOS 字段名转换为后台接口使用的字段代码。
+ *
+ * 同时兼容 P、I、C、O、S、Other 原始字段，确保 Agent 提交完整字段名时
+ * 保存 PICOS 和生成纳排标准仍使用网站接口约定的参数结构。
+ *
+ * @param data PICOS 表单数据。
+ * @returns 使用后台字段代码且空值已转换为空字符串的 PICOS 数据。
+ */
+function normalizePicosData(data) {
+    const aliases = {
+        p: "P",
+        populationparticipants: "P",
+        i: "I",
+        interventionexposure: "I",
+        c: "C",
+        comparatorcontext: "C",
+        o: "O",
+        outcome: "O",
+        outcomes: "O",
+        s: "S",
+        studycharacteristicsdesign: "S",
+        other: "Other",
+    };
+    const normalized = {
+        P: "",
+        I: "",
+        C: "",
+        O: "",
+        S: "",
+        Other: "",
+    };
+    for (const [key, value] of Object.entries(data)) {
+        const alias = key.toLowerCase().replace(/[\s/_-]+/g, "");
+        const field = aliases[alias];
+        if (field) {
+            normalized[field] = value ?? "";
+        }
+    }
+    return normalized;
+}
+/**
+ * 将后台 PICOS 字段代码转换为与网站一致的完整展示名称。
+ *
+ * @param output PICOS 节点的原始输出。
+ * @returns 使用完整字段名称的 PICOS 数据。
+ */
+function normalizePicosOutput(output) {
+    if (!output || typeof output !== "object" || Array.isArray(output)) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(output).map(([key, value]) => [
+        PICOS_FIELD_LABELS[key] ?? key,
+        value ?? "",
+    ]));
+}
+/**
+ * 归一化 PICOS 命令的完整返回结果，避免 node.output 再暴露简写字段。
+ *
+ * @param result PICOS 节点的执行结果。
+ * @returns 顶层 output 和 node.output 均使用完整字段名称的执行结果。
+ */
+function normalizePicosResult(result) {
+    const picos = normalizePicosOutput(result.output);
+    return {
+        ...result,
+        output: picos,
+        node: {
+            ...result.node,
+            output: { output: picos },
+        },
+    };
+}
+export async function createMetaTopic(options) {
+    const result = await runMetaTopicNode({
+        workflowId: options.workflowId,
+        nodeType: META_NODE_TYPES.GENERATE_TOPIC,
+        input: { input_the_keyword: options.input },
+        format: options.format,
+        configPath: options.configPath,
+        progressMessage: "正在生成 Meta 选题...",
+    });
+    return normalizeTopicResult(result);
+}
+export async function rerunMetaTopic(options) {
+    const nodeType = options.source === "verify"
+        ? META_NODE_TYPES.VERIFY_TOPIC
+        : META_NODE_TYPES.GENERATE_TOPIC;
+    const target = await resolveNodeSaveTarget(options, nodeType, "候选选题");
+    const progress = createStderrProgress(options.format === "json");
+    progress.start("正在重新生成候选选题...");
+    try {
+        await requestMeta(`${META_API_PREFIX}/nodes/re-execute`, {
+            method: "POST",
+            body: {
+                run_id: target.runnerId,
+                node_id: target.nodeId,
+                node_type: nodeType,
+            },
+            configPath: options.configPath,
+            action: "重新生成候选选题",
+        });
+        await pollMetaNodeStatus({
+            workflowId: target.runnerId,
+            nodeId: target.nodeId,
+            configPath: options.configPath,
+        });
+        const output = await getMetaNodeOutput({
+            workflowId: target.runnerId,
+            nodeId: target.nodeId,
+            configPath: options.configPath,
+        });
+        progress.finish("候选选题重新生成完成，正在输出结果...");
+        const normalized = normalizeTopicResult({
+            runnerId: target.runnerId,
+            nodeId: target.nodeId,
+            nodeType,
+            status: output.data.status,
+            input: {},
+            output: extractNodeOutput(output.data),
+            node: output.data,
+        });
+        if (nodeType !== META_NODE_TYPES.VERIFY_TOPIC) {
+            return normalized;
+        }
+        return withVerifyCandidatesRequired(normalized);
+    }
+    catch (error) {
+        progress.dispose();
+        throw error;
+    }
+}
+export async function verifyMetaTopic(options) {
+    const result = await runMetaTopicNode({
+        workflowId: options.workflowId,
+        nodeType: META_NODE_TYPES.VERIFY_TOPIC,
+        input: { input_the_keyword: options.title },
+        format: options.format,
+        configPath: options.configPath,
+        progressMessage: "正在校验 Meta 选题...",
+    });
+    const normalized = normalizeTopicResult(result);
+    return withVerifyCandidatesRequired(normalized, options.title);
+}
+export async function selectMetaTopic(options) {
+    const selectedTitle = options.title.trim();
+    if (!selectedTitle) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "缺少 Meta 选题");
+    }
+    const target = await resolveTopicSaveTarget(options);
+    const currentNode = await getMetaNodeOutput({
+        workflowId: target.runnerId,
+        nodeId: target.nodeId,
+        configPath: options.configPath,
+    });
+    const currentOutput = extractNodeOutput(currentNode.data);
+    const current = buildTopicFieldsFromOutput(currentOutput);
+    const titles = normalizeTopicTitles(currentOutput);
+    const matchedIndex = titles.findIndex((title) => title === selectedTitle);
+    const selectedIndex = matchedIndex >= 0 ? matchedIndex + 1 : undefined;
+    const confirmed = buildConfirmedTopicGuidance(selectedIndex);
+    const input = {
+        ...current,
+        ...transformTitleData(parseJsonObject(options.titlesJson, "--titles-json")),
+        selected: { English: selectedTitle, Chinese: "" },
+    };
+    const endpoint = target.source === "verify" ? "verify-topic" : "generate-topic";
+    const data = await requestMeta(`${META_API_PREFIX}/${endpoint}`, {
+        method: "PUT",
+        params: {
+            run_id: target.runnerId,
+            node_id: target.nodeId,
+        },
+        body: input,
+        configPath: options.configPath,
+        action: "保存 Meta 选题",
+    });
+    return {
+        runnerId: target.runnerId,
+        nodeId: target.nodeId,
+        source: target.source,
+        input,
+        data,
+        ...(selectedIndex !== undefined ? { selectedIndex } : {}),
+        selectedTitle,
+        selectorTitle: confirmed.selectorTitle,
+        operationOptions: confirmed.operationOptions,
+        displayInstruction: confirmed.displayInstruction,
+    };
+}
+export async function createMetaPicos(options) {
+    const result = await runMetaTopicNode({
+        workflowId: options.workflowId,
+        nodeType: META_NODE_TYPES.GENERATE_PICOS,
+        input: await buildPicosInput(options),
+        format: options.format,
+        configPath: options.configPath,
+        progressMessage: "正在生成 PICOS...",
+    });
+    return normalizePicosResult(result);
+}
+export async function rerunMetaPicos(options) {
+    const target = await resolveNodeSaveTarget(options, META_NODE_TYPES.GENERATE_PICOS, "PICOS");
+    const progress = createStderrProgress(options.format === "json");
+    progress.start("正在重新生成 PICOS...");
+    try {
+        await requestMeta(`${META_API_PREFIX}/nodes/re-execute`, {
+            method: "POST",
+            body: {
+                run_id: target.runnerId,
+                node_id: target.nodeId,
+                node_type: META_NODE_TYPES.GENERATE_PICOS,
+            },
+            configPath: options.configPath,
+            action: "重新生成 PICOS",
+        });
+        await pollMetaNodeStatus({
+            workflowId: target.runnerId,
+            nodeId: target.nodeId,
+            configPath: options.configPath,
+        });
+        const output = await getMetaNodeOutput({
+            workflowId: target.runnerId,
+            nodeId: target.nodeId,
+            configPath: options.configPath,
+        });
+        progress.finish("PICOS 重新生成完成，正在输出结果...");
+        return normalizePicosResult({
+            runnerId: target.runnerId,
+            nodeId: target.nodeId,
+            nodeType: META_NODE_TYPES.GENERATE_PICOS,
+            status: output.data.status,
+            input: {},
+            output: extractNodeOutput(output.data),
+            node: output.data,
+        });
+    }
+    catch (error) {
+        progress.dispose();
+        throw error;
+    }
+}
+export async function saveMetaPicos(options) {
+    const target = await resolveNodeSaveTarget(options, META_NODE_TYPES.GENERATE_PICOS, "PICOS");
+    const patch = normalizePicosData(await parseJsonObjectInput(options.picosJson, options.picosFile, "--picos-json", "--picos-file"));
+    const currentNode = await getMetaNodeOutput({
+        workflowId: target.runnerId,
+        nodeId: target.nodeId,
+        configPath: options.configPath,
+    });
+    const current = normalizePicosData(extractNodeOutput(currentNode.data) ?? {});
+    const input = { ...current, ...patch };
+    const data = await requestMeta(`${META_API_PREFIX}/generate-picos`, {
+        method: "PUT",
+        params: {
+            run_id: target.runnerId,
+            node_id: target.nodeId,
+        },
+        body: input,
+        configPath: options.configPath,
+        action: "保存 PICOS",
+    });
+    return {
+        runnerId: target.runnerId,
+        nodeId: target.nodeId,
+        source: "picos",
+        input,
+        data,
+    };
+}
+export async function createMetaCriteria(options) {
+    let rawInput;
+    if (options.picosJson?.trim() || options.picosFile?.trim()) {
+        rawInput = await parseJsonObjectInput(options.picosJson, options.picosFile, "--picos-json", "--picos-file");
+    }
+    else {
+        const target = await resolveNodeSaveTarget(options, META_NODE_TYPES.GENERATE_PICOS, "PICOS");
+        const currentNode = await getMetaNodeOutput({
+            workflowId: target.runnerId,
+            nodeId: target.nodeId,
+            configPath: options.configPath,
+        });
+        rawInput =
+            extractNodeOutput(currentNode.data) ?? {};
+    }
+    const input = normalizePicosData(rawInput);
+    const result = await runMetaTopicNode({
+        workflowId: options.workflowId,
+        nodeType: META_NODE_TYPES.GENERATE_SORTING_CRITERIA,
+        input,
+        format: options.format,
+        configPath: options.configPath,
+        progressMessage: "正在生成纳排标准...",
+    });
+    return {
+        ...result,
+        displayInstruction: CRITERIA_DISPLAY_INSTRUCTION,
+        displayData: result.output,
+    };
+}
+export async function rerunMetaCriteria(options) {
+    const target = await resolveNodeSaveTarget(options, META_NODE_TYPES.GENERATE_SORTING_CRITERIA, "纳排标准");
+    const progress = createStderrProgress(options.format === "json");
+    progress.start("正在重新生成纳排标准...");
+    try {
+        await requestMeta(`${META_API_PREFIX}/nodes/re-execute`, {
+            method: "POST",
+            body: {
+                run_id: target.runnerId,
+                node_id: target.nodeId,
+                node_type: META_NODE_TYPES.GENERATE_SORTING_CRITERIA,
+            },
+            configPath: options.configPath,
+            action: "重新生成纳排标准",
+        });
+        await pollMetaNodeStatus({
+            workflowId: target.runnerId,
+            nodeId: target.nodeId,
+            configPath: options.configPath,
+        });
+        const output = await getMetaNodeOutput({
+            workflowId: target.runnerId,
+            nodeId: target.nodeId,
+            configPath: options.configPath,
+        });
+        const displayData = extractNodeOutput(output.data);
+        progress.finish("纳排标准重新生成完成，正在输出结果...");
+        return {
+            runnerId: target.runnerId,
+            nodeId: target.nodeId,
+            nodeType: META_NODE_TYPES.GENERATE_SORTING_CRITERIA,
+            status: output.data.status,
+            input: {},
+            output: displayData,
+            displayInstruction: CRITERIA_DISPLAY_INSTRUCTION,
+            displayData,
+            node: output.data,
+        };
+    }
+    catch (error) {
+        progress.dispose();
+        throw error;
+    }
+}
+export async function saveMetaCriteria(options) {
+    const target = await resolveNodeSaveTarget(options, META_NODE_TYPES.GENERATE_SORTING_CRITERIA, "纳排标准");
+    const patch = await parseJsonObjectInput(options.criteriaJson, options.criteriaFile, "--criteria-json", "--criteria-file");
+    const currentNode = await getMetaNodeOutput({
+        workflowId: target.runnerId,
+        nodeId: target.nodeId,
+        configPath: options.configPath,
+    });
+    const currentOutput = extractNodeOutput(currentNode.data);
+    const current = currentOutput && typeof currentOutput === "object" && !Array.isArray(currentOutput)
+        ? currentOutput
+        : {};
+    const input = { ...current, ...patch };
+    const data = await requestMeta(`${META_API_PREFIX}/generate-sorting-criteria`, {
+        method: "PUT",
+        params: {
+            run_id: target.runnerId,
+            node_id: target.nodeId,
+        },
+        body: input,
+        configPath: options.configPath,
+        action: "保存纳排标准",
+    });
+    return {
+        runnerId: target.runnerId,
+        nodeId: target.nodeId,
+        source: "criteria",
+        input,
+        data,
+        displayInstruction: CRITERIA_DISPLAY_INSTRUCTION,
+        displayData: data,
+    };
+}
+export async function runCreateMetaTopic(options) {
+    const result = await createMetaTopic(options);
+    printMetaTopicResult(result, options.format ?? "markdown");
+}
+export async function runVerifyMetaTopic(options) {
+    const result = await verifyMetaTopic(options);
+    printMetaTopicResult(result, options.format ?? "markdown");
+}
+export async function runSelectMetaTopic(options) {
+    const result = await selectMetaTopic(options);
+    printOutput(result, options.format ?? "markdown");
+}
+export async function runCreateMetaPicos(options) {
+    const result = await createMetaPicos(options);
+    printMetaTopicResult(result, options.format ?? "markdown");
+}
+export async function runRerunMetaTopic(options) {
+    printMetaTopicResult(await rerunMetaTopic(options), options.format ?? "markdown");
+}
+function buildTopicFieldsFromOutput(output) {
+    if (Array.isArray(output)) {
+        return Object.fromEntries(normalizeTopicTitles(output).map((title, index) => [
+            `Title${index + 1}`,
+            { English: title, Chinese: "" },
+        ]));
+    }
+    if (output && typeof output === "object") {
+        return output;
+    }
+    return {};
+}
+export async function runRerunMetaPicos(options) {
+    printMetaTopicResult(await rerunMetaPicos(options), options.format ?? "markdown");
+}
+export async function runSaveMetaPicos(options) {
+    const result = await saveMetaPicos(options);
+    printOutput(result, options.format ?? "markdown");
+}
+export async function runCreateMetaCriteria(options) {
+    const result = await createMetaCriteria(options);
+    if ((options.format ?? "markdown") === "markdown") {
+        console.log(typeof result.displayData === "string"
+            ? result.displayData
+            : JSON.stringify(result.displayData, null, 2));
+        return;
+    }
+    printOutput({
+        runnerId: result.runnerId,
+        nodeId: result.nodeId,
+        nodeType: result.nodeType,
+        status: result.status,
+        displayInstruction: result.displayInstruction,
+        displayData: result.displayData,
+    }, "json");
+}
+export async function runSaveMetaCriteria(options) {
+    const result = await saveMetaCriteria(options);
+    if ((options.format ?? "markdown") === "markdown") {
+        console.log(typeof result.displayData === "string"
+            ? result.displayData
+            : JSON.stringify(result.displayData, null, 2));
+        return;
+    }
+    printOutput({
+        runnerId: result.runnerId,
+        nodeId: result.nodeId,
+        source: result.source,
+        displayInstruction: result.displayInstruction,
+        displayData: result.displayData,
+    }, "json");
+}
+export async function runRerunMetaCriteria(options) {
+    const result = await rerunMetaCriteria(options);
+    if ((options.format ?? "markdown") === "markdown") {
+        console.log(typeof result.displayData === "string"
+            ? result.displayData
+            : JSON.stringify(result.displayData, null, 2));
+        return;
+    }
+    printOutput({
+        runnerId: result.runnerId,
+        nodeId: result.nodeId,
+        nodeType: result.nodeType,
+        status: result.status,
+        displayInstruction: result.displayInstruction,
+        displayData: result.displayData,
+    }, "json");
+}
+//# sourceMappingURL=topic.js.map