@zhushanwen/pi-ask-user 6.0.1 → 7.0.2

package/src/__tests__/answer-format.test.ts

@@ -1,275 +0,0 @@
-// src/__tests__/answer-format.test.ts
-//
-// answer-format.ts 独立单元测试。
-// 覆盖审查 S5 发现的覆盖盲区：
-//   - parseAnswerParts 子串误匹配（"A" 不应命中 "AB"）
-//   - formatAnswer 空 parts → null
-//   - comment 分隔符边界
-
-import { describe, expect, it } from "vitest";
-
-import { formatAnswer, parseAnswerParts } from "../answer-format.js";
-import { ANSWER_COMMENT_SEPARATOR } from "../types.js";
-
-describe("formatAnswer", () => {
-	it("returns null for empty parts (unanswered)", () => {
-		expect(formatAnswer([])).toBeNull();
-	});
-
-	it("comment-only: empty parts + comment → separator-prefixed comment (MF-1)", () => {
-		// parts 空但有 comment = allowComment 的「无选项适用但想说明原因」场景，
-		// 不能返回 null（会把评论一起丢弃）；以 ANSWER_COMMENT_SEPARATOR 开头保持往返可解析
-		expect(formatAnswer([], "some comment")).toBe(`${ANSWER_COMMENT_SEPARATOR}some comment`);
-	});
-
-	it("joins single part without separator", () => {
-		expect(formatAnswer(["yes"])).toBe("yes");
-	});
-
-	it("joins multiple parts with ', '", () => {
-		expect(formatAnswer(["A", "B", "C"])).toBe("A, B, C");
-	});
-
-	it("appends comment with ANSWER_COMMENT_SEPARATOR", () => {
-		const result = formatAnswer(["A", "B"], "my comment");
-		expect(result).toBe(`A, B${ANSWER_COMMENT_SEPARATOR}my comment`);
-	});
-
-	it("handles null comment (no separator appended)", () => {
-		expect(formatAnswer(["A"], null)).toBe("A");
-	});
-});
-
-describe("parseAnswerParts", () => {
-	it("extracts selected labels by exact match", () => {
-		const labels = ["yes", "no", "maybe"];
-		const result = parseAnswerParts("yes, no", labels);
-		expect(result.selected).toEqual(["yes", "no"]);
-		expect(result.comment).toBeUndefined();
-	});
-
-	// S5 核心：防子串误匹配——"A" 不应命中 label "AB"
-	it("does NOT match substring labels (A vs AB)", () => {
-		const labels = ["A", "AB", "ABC"];
-		// 答案 "A, AB" 应精确匹配两个 label，而非 "A" 匹配三次
-		const result = parseAnswerParts("A, AB", labels);
-		expect(result.selected).toEqual(["A", "AB"]);
-	});
-
-	it("does NOT match 'A' when only 'AB' is in answer", () => {
-		const labels = ["A", "AB"];
-		// 答案 "AB" 只应命中 "AB"，不应命中 "A"
-		const result = parseAnswerParts("AB", labels);
-		expect(result.selected).toEqual(["AB"]);
-	});
-
-	it("preserves order of appearance in answer (not label order)", () => {
-		const labels = ["A", "B", "C"];
-		// 用户选择顺序可能与 options 定义顺序不同
-		const result = parseAnswerParts("C, A", labels);
-		expect(result.selected).toEqual(["C", "A"]);
-	});
-
-	it("extracts comment after ANSWER_COMMENT_SEPARATOR", () => {
-		const labels = ["yes"];
-		const answer = `yes${ANSWER_COMMENT_SEPARATOR}because reasons`;
-		const result = parseAnswerParts(answer, labels);
-		expect(result.selected).toEqual(["yes"]);
-		expect(result.comment).toBe("because reasons");
-	});
-
-	it("handles full-width comma (，) as separator", () => {
-		const labels = ["A", "B"];
-		const result = parseAnswerParts("A，B", labels);
-		expect(result.selected).toEqual(["A", "B"]);
-	});
-
-	it("returns non-matching tokens as neither selected nor comment (Other free text)", () => {
-		const labels = ["yes", "no"];
-		// "custom text" 不匹配任何 label → 是 Other 自由文本
-		const result = parseAnswerParts("custom text", labels);
-		expect(result.selected).toEqual([]);
-		expect(result.comment).toBeUndefined();
-	});
-
-	it("handles empty answer string", () => {
-		const result = parseAnswerParts("", ["A", "B"]);
-		expect(result.selected).toEqual([]);
-		expect(result.comment).toBeUndefined();
-	});
-
-	it("handles answer with only comment (no selected labels)", () => {
-		const labels = ["A"];
-		const answer = `${ANSWER_COMMENT_SEPARATOR}just a comment`;
-		const result = parseAnswerParts(answer, labels);
-		expect(result.selected).toEqual([]);
-		expect(result.comment).toBe("just a comment");
-	});
-
-	// MF-2 回归：label 自身含 ANSWER_COMMENT_SEPARATOR（LLM 生成 label 常见形态）时，
-	// 首个分隔符切分会把 label 拦腰截断 → token 无法精确匹配 → 选中值静默丢失
-	describe("MF-2: label contains ANSWER_COMMENT_SEPARATOR", () => {
-		const labels = ["Postgres — prod", "SQLite"];
-
-		it("whole answer exactly matches separator-containing label → selected, no comment", () => {
-			const result = parseAnswerParts("Postgres — prod", labels);
-			expect(result.selected).toEqual(["Postgres — prod"]);
-			expect(result.comment).toBeUndefined();
-		});
-
-		it("selection + comment → later separator becomes split point", () => {
-			const result = parseAnswerParts("Postgres — prod — fast", labels);
-			expect(result.selected).toEqual(["Postgres — prod"]);
-			expect(result.comment).toBe("fast");
-		});
-
-		it("two selections where first label contains separator", () => {
-			const result = parseAnswerParts("Postgres — prod, SQLite — my note", labels);
-			expect(result.selected).toEqual(["Postgres — prod", "SQLite"]);
-			expect(result.comment).toBe("my note");
-		});
-
-		it("comment containing separator keeps full remainder", () => {
-			const result = parseAnswerParts("Postgres — prod — fast — very fast", labels);
-			expect(result.selected).toEqual(["Postgres — prod"]);
-			expect(result.comment).toBe("fast — very fast");
-		});
-	});
-
-	it("returns non-matching body tokens as otherTokens (Other free text)", () => {
-		const result = parseAnswerParts("custom text", ["yes", "no"]);
-		expect(result.selected).toEqual([]);
-		expect(result.otherTokens).toEqual(["custom text"]);
-	});
-
-	it("otherTokens excludes matched labels and comment", () => {
-		const result = parseAnswerParts("A, custom text — note", ["A", "B"]);
-		expect(result.selected).toEqual(["A"]);
-		expect(result.otherTokens).toEqual(["custom text"]);
-		expect(result.comment).toBe("note");
-	});
-
-	// MF-6 回归：两个 label 都含分隔符时（"Postgres — prod, MySQL"），分隔符扫描会把
-	// 首个分隔符当切分点 → body "Postgres" 无匹配 → 剩余 "prod, MySQL" 被误判为 comment，
-	// 两个选中项全部静默丢失。纯多选分支（所有逗号 token 均为 label）在扫描前短路。
-	describe("MF-6: pure multi-select where every label contains separator", () => {
-		const labels = ["Postgres — prod", "MySQL"];
-
-		it("all comma tokens are labels → selected all, no comment", () => {
-			const result = parseAnswerParts("Postgres — prod, MySQL", labels);
-			expect(result.selected).toEqual(["Postgres — prod", "MySQL"]);
-			expect(result.comment).toBeUndefined();
-			expect(result.otherTokens).toEqual([]);
-		});
-
-		it("comment form not broken: non-label token 'MySQL — note' skips the branch", () => {
-			// "MySQL — note" 非 label → 不进纯多选分支；分隔符扫描取「body 整串可解析为
-			// 选中项」的最靠后切分（"Postgres — prod, MySQL" 两个 token 均 label）→
-			// 选中两项 + comment "note"（与 MF-2 多选 + comment 语义一致）
-			const result = parseAnswerParts("Postgres — prod, MySQL — note", labels);
-			expect(result.selected).toEqual(["Postgres — prod", "MySQL"]);
-			expect(result.comment).toBe("note");
-		});
-
-		it("three selections all containing separators", () => {
-			const labels3 = ["Postgres — prod", "MySQL — prod", "SQLite — prod"];
-			const result = parseAnswerParts("Postgres — prod, MySQL — prod, SQLite — prod", labels3);
-			expect(result.selected).toEqual(["Postgres — prod", "MySQL — prod", "SQLite — prod"]);
-			expect(result.comment).toBeUndefined();
-		});
-	});
-
-	// MF-7 回归：重叠前缀 label（短 label 是长 label 的前缀）时，分隔符扫描取「首个 body
-	// 含 label token」的切分会停在短 label 处，把长 label 的剩余部分误判为 comment。
-	// 修复：优先「body 整串精确命中 label」的切分点，多个命中取最靠后者（最长匹配）。
-	describe("MF-7: overlapping prefix labels prefer whole-body label split", () => {
-		const labels = ["Postgres", "Postgres — prod"];
-
-		it("longest whole-body label wins → 'Postgres — prod' + comment 'x'", () => {
-			const result = parseAnswerParts("Postgres — prod — x", labels);
-			expect(result.selected).toEqual(["Postgres — prod"]);
-			expect(result.comment).toBe("x");
-		});
-
-		it("short label + comment containing long-label prefix (inherent ambiguity, documented tradeoff)", () => {
-			// 长 label 不在候选时（labels 只有 "Postgres"），同一文本解析为
-			// 选短 label + comment "prod — x"——文本层面唯一可解析的归属
-			const result = parseAnswerParts("Postgres — prod — x", ["Postgres"]);
-			expect(result.selected).toEqual(["Postgres"]);
-			expect(result.comment).toBe("prod — x");
-		});
-
-		it("multi-select + comment with prefix labels → split after all labels", () => {
-			// "Postgres — prod, SQLite" 两个 token 均 label → 切分点取最后分隔符，
-			// body 完整保留两项选中，comment "note"（首个整串命中 "Postgres" 不截断）
-			const labels3 = ["Postgres", "Postgres — prod", "SQLite"];
-			const result = parseAnswerParts("Postgres — prod, SQLite — note", labels3);
-			expect(result.selected).toEqual(["Postgres — prod", "SQLite"]);
-			expect(result.comment).toBe("note");
-		});
-	});
-
-	// MF-2（R3 回归）：label 含分隔符 + Other 自由文本 + comment 的混合形态。
-	// R3 的 all-label 单谓词扫描落空 → 回退首分隔符 → 选中项静默丢失；第二级
-	// 「body 含 ≥1 label token」首个命中落在真正分隔选中/Other 与 comment 的分隔符上。
-	describe("MF-2: label with separator + Other free text + comment", () => {
-		const labels = ["Postgres — prod"];
-
-		it("mixed body (label + Other) + comment → label selected, Other kept, comment at later separator", () => {
-			const result = parseAnswerParts("Postgres — prod, custom text — note", labels);
-			expect(result.selected).toEqual(["Postgres — prod"]);
-			expect(result.otherTokens).toEqual(["custom text"]);
-			expect(result.comment).toBe("note");
-		});
-
-		it("comment containing separator keeps full remainder (no over-split at second separator)", () => {
-			// "A, B — note — x"：第一级 all-label body 在第一个分隔符命中，短路第二级
-			// ——若走「≥1 label token 取最后」会在第二个分隔符过切（comment 错位）
-			const result = parseAnswerParts("A, B — note — x", ["A", "B"]);
-			expect(result.selected).toEqual(["A", "B"]);
-			expect(result.comment).toBe("note — x");
-		});
-	});
-
-	// MF-3（pre-existing）：label 含分隔符 + Other 自由文本、无 comment 形态。
-	// 两级扫描均无命中（唯一候选 body "Postgres" 不含 label token）→ 整串含 label
-	// token 时不切分，整串作 body（选中 + Other）——首分隔符切分会把 label 拦腰截断
-	// 产生空选中。S-17 冻结边界：整串无任何 label token 时仍走首分隔符切分。
-	describe("MF-3: label with separator + Other free text, no comment", () => {
-		const labels = ["Postgres — prod"];
-
-		it("no comment variant → whole string as body, label selected + Other kept", () => {
-			const result = parseAnswerParts("Postgres — prod, custom text", labels);
-			expect(result.selected).toEqual(["Postgres — prod"]);
-			expect(result.otherTokens).toEqual(["custom text"]);
-			expect(result.comment).toBeUndefined();
-		});
-
-		it("S-17 freeze intact: whole string without any label token still first-separator split", () => {
-			// "custom — text" 整串无 label token → 不切分回退不触发，保持首分隔符切分
-			const result = parseAnswerParts("custom — text", labels);
-			expect(result.selected).toEqual([]);
-			expect(result.otherTokens).toEqual(["custom"]);
-			expect(result.comment).toBe("text");
-		});
-	});
-
-	// S-17 行为固化：Other 自由文本自身含 " — "（如 "custom — text"）与
-	// 「选中/Other + comment」形态在纯解析层面固有歧义，保持首个分隔符切分行为
-	// （body "custom" + comment "text"），不做解析层区分（见 answer-format.ts 注释）。
-	describe("S-17: Other free text containing separator (behavior freeze)", () => {
-		it("separator inside Other text → first-separator split, documented ambiguity", () => {
-			const result = parseAnswerParts("custom — text", ["yes", "no"]);
-			expect(result.selected).toEqual([]);
-			expect(result.otherTokens).toEqual(["custom"]);
-			expect(result.comment).toBe("text");
-		});
-
-		it("Other text with separator + matched label before it", () => {
-			const result = parseAnswerParts("yes, custom — text", ["yes", "no"]);
-			expect(result.selected).toEqual(["yes"]);
-			expect(result.otherTokens).toEqual(["custom"]);
-			expect(result.comment).toBe("text");
-		});
-	});
-});

package/src/answer-format.ts

@@ -1,127 +0,0 @@
-// src/answer-format.ts
-// 答案文本格式的唯一权威模块。
-// TUI 路径（submit-view.ts:getAnswerText）和 RPC 路径（index.ts:protoAnswersToResult）
-// 都调 formatAnswer 产出 "label1, label2 — comment" 格式，确保两条路径一致。
-// renderExpandedOptions（index.ts）调 parseAnswerParts 精确反解析选中项。
-import { ANSWER_COMMENT_SEPARATOR } from "./types";
-
-/**
- * 把答案各部分拼装为最终文本格式："part1, part2 — comment"。
- * - parts 为空 + comment 有值 → comment-only 答案（allowComment 的「无选项适用但想说明原因」
- *   场景）：以 ANSWER_COMMENT_SEPARATOR 开头，保持 parseAnswerParts 往返可解析
- * - parts 与 comment 都为空 → 返回 null（未答）
- * - comment 有值 → 追加 ANSWER_COMMENT_SEPARATOR + comment
- */
-export function formatAnswer(parts: string[], comment?: string | null): string | null {
-	if (parts.length === 0) return comment ? `${ANSWER_COMMENT_SEPARATOR}${comment}` : null;
-	const base = parts.join(", ");
-	return comment ? `${base}${ANSWER_COMMENT_SEPARATOR}${comment}` : base;
-}
-
-/**
- * 从最终答案文本中精确解析出选中的 labels（不依赖子串匹配）。
- * 用于 renderExpandedOptions 反向判定哪些选项被选中。
- *
- * @param answer 最终答案文本（formatAnswer 产出）
- * @param labels 候选 label 列表（q.options 的 label），精确匹配
- * @returns selected=命中的 labels（按 answer 中出现顺序），comment=评论文本（如有）
- */
-export function parseAnswerParts(
-	answer: string,
-	labels: string[],
-): { selected: string[]; comment?: string; otherTokens: string[] } {
-	const labelSet = new Set(labels);
-	const trimmed = answer.trim();
-
-	// 整串精确命中单个 label → 单选该 label、无 comment。label 自身可能含
-	// ANSWER_COMMENT_SEPARATOR（如 "Postgres — prod"），首个分隔符切分会把它拦腰截断。
-	if (labelSet.has(trimmed)) return { selected: [trimmed], comment: undefined, otherTokens: [] };
-
-	// MF-6：整串逗号切分的每个 token 都是 label → 纯多选、无 comment。
-	// 必须置于分隔符扫描之前——"Postgres — prod, MySQL"（两个 label 都含分隔符形态）
-	// 若进扫描，首个分隔符切在 "Postgres — prod" 中间，剩余 "prod, MySQL" 被误判为
-	// comment，两个选中项全部静默丢失。仅当全部 token 均为 label 时触发：
-	// "Postgres — prod, MySQL — note" 中 "MySQL — note" 非 label → 不进此分支，
-	// 由分隔符扫描解析为选中 "Postgres — prod" + "MySQL" + comment "note"
-	// （含 comment 的多选形态不破坏）。
-	const allTokens = trimmed.split(/[,，]/).map((t) => t.trim()).filter(Boolean);
-	if (allTokens.length > 0 && allTokens.every((t) => labelSet.has(t))) {
-		return { selected: allTokens, comment: undefined, otherTokens: [] };
-	}
-
-	// body/comment 切分点：两级扫描 + 不切分回退，语义见各段注释。
-	// 第一级（MF-7 语义）：取「body 整串可解析为选中项」的最靠后分隔符 = 最长选中 body，
-	// 其后的全部剩余文本为 comment。"可解析为选中项" = 整串精确命中单个 label（含逗号
-	// label 如 "A, B"），或全部逗号 token 均为 label（多选 body，如 "Postgres — prod, MySQL"）。
-	// 第二级（MF-2 回归修复）：第一级无命中时回退「body 含 ≥1 个 label token」的首个分隔符——
-	// "Postgres — prod, custom text — note"（label 含分隔符 + Other 自由文本 + comment）
-	// 无任何 all-label body，单谓词扫描落空 → 回退首分隔符把 label 拦腰截断，选中项静默丢失；
-	// ≥1 谓词在真正分隔选中/Other 与 comment 的第二个分隔符命中。
-	// 不切分回退（MF-3）：两级都无命中但整串含 label token（"Postgres — prod, custom text"
-	// 无 comment 形态）→ 整串作 body（选中 + Other），不切分——首分隔符切分把 label 拦腰
-	// 截断产生空选中。整串无任何 label token（S-17："custom — text" Other 自由文本自身含
-	// 分隔符）→ 保持首个分隔符切分（body "custom" + comment "text"），不做解析层区分，
-	// 由调用方（TUI encode）按 label 命中情况归属。
-	// MF-7 固有歧义取舍（第一级）：重叠前缀 label 如 ["Postgres", "Postgres — prod"] 时，
-	// "Postgres — prod — x" 取最靠后的整串命中即最长匹配（选中长 label + comment "x"）；
-	// 若用户意图确实是「选短 label + comment 含长 label 前缀」会被误判——文本本身无法区分，
-	// 精确 label body 优先是更优启发而非完备解；长 label 不在候选时（"Postgres — prod" 非
-	// label）该意图解析正确。
-	// 注意：分隔符扫描用原始 answer（不 trim）——comment-only 答案以 " — comment" 开头，
-	// trim 会吃掉前导空格导致 indexOf 失配。
-	let body = trimmed;
-	let comment: string | undefined;
-	let splitIdx = answer.indexOf(ANSWER_COMMENT_SEPARATOR);
-	// 第一级：取「body 整串可解析为选中项」的最靠后分隔符
-	let bestSplit = -1;
-	let scan = splitIdx;
-	while (scan >= 0) {
-		const candidateBody = answer.slice(0, scan).trim();
-		if (labelSet.has(candidateBody)) {
-			bestSplit = scan;
-		} else {
-			const candidateTokens = candidateBody.split(/[,，]/).map((t) => t.trim()).filter(Boolean);
-			if (candidateTokens.length > 0 && candidateTokens.every((t) => labelSet.has(t))) {
-				bestSplit = scan;
-			}
-		}
-		scan = answer.indexOf(ANSWER_COMMENT_SEPARATOR, scan + ANSWER_COMMENT_SEPARATOR.length);
-	}
-	if (bestSplit < 0) {
-		// 第二级：取「body 含 ≥1 个 label token」的首个分隔符（R2 的 some() 谓词回归，
-		// 仅在第一级无命中时运行——"A, B — note — x" 形态第一级已命中，不会过切）
-		scan = splitIdx;
-		while (scan >= 0) {
-			const candidateTokens = answer.slice(0, scan).trim().split(/[,，]/).map((t) => t.trim()).filter(Boolean);
-			if (candidateTokens.some((t) => labelSet.has(t))) {
-				bestSplit = scan;
-				break;
-			}
-			scan = answer.indexOf(ANSWER_COMMENT_SEPARATOR, scan + ANSWER_COMMENT_SEPARATOR.length);
-		}
-	}
-	// MF-3 不切分回退：整串含 label token 时以整串为 body（选中 + Other），不切分。
-	// splitIdx >= 0 前置（无分隔符时本就整串为 body，无需走此分支）。
-	const noSplit = bestSplit < 0 && splitIdx >= 0 && allTokens.some((t) => labelSet.has(t));
-	if (!noSplit && splitIdx >= 0) {
-		if (bestSplit >= 0) {
-			splitIdx = bestSplit;
-		}
-		body = answer.slice(0, splitIdx).trim();
-		comment = answer.slice(splitIdx + ANSWER_COMMENT_SEPARATOR.length).trim() || undefined;
-	}
-
-	// body 形如 "label1, label2" → 精确匹配候选 label；剩余 tokens 不匹配任何 label
-	// → Other 自由文本（otherTokens 返回给调用方，如 channel-handler 提取 __other）
-	const tokens = body.split(/[,，]/).map((t) => t.trim()).filter(Boolean);
-	const selected: string[] = [];
-	const otherTokens: string[] = [];
-	for (const token of tokens) {
-		if (labelSet.has(token)) {
-			selected.push(token);
-		} else {
-			otherTokens.push(token);
-		}
-	}
-	return { selected, comment, otherTokens };
-}