modelfunction-cli 0.1.3 → 0.3.0

package/lib/lint.js

@@ -1,4 +1,5 @@
-import { suspectedPairs } from "./cases.js";
+import { suspectedPairs, nameTokens } from "./cases.js";
+import { normalizeProfiles } from "./profile.js";
 
 const GENERIC_NAMES = new Set([
   "run",
@@ -29,13 +30,18 @@ const DESCRIPTION_ID_HINT = /(会话\s*id|session\s*id|租户|tenant|trace|请
 const ID_SOURCE_HINT = /(来源|取自|来自|传入|注入|平台|系统|上下文|请求头|header|无需|自动|会提供|由调用方|上一步)/i;
 const FIXED_ID_LENGTHS = new Set([8, 16, 24, 32, 36, 40, 64]);
 
-function nameTokens(name) {
-  return String(name)
-    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
-    .split(/[^A-Za-z0-9]+/)
-    .map((token) => token.toLowerCase())
-    .filter(Boolean);
-}
+// Skills have no parameter schema, so name + description is all there is to
+// compare. Two skills above this similarity are competing for the same intent.
+// SKILL.md files share an authoring vocabulary ("Discord archive: search, sync
+// freshness") that says nothing about overlap; tuned against a real 53-skill
+// set, without it unrelated per-platform skills pair up.
+const SKILL_PAIR_SIMILARITY = 0.35;
+const SKILL_BOILERPLATE = new Set([
+  "skill", "description", "operation", "management", "archive", "sync",
+  "freshness", "triage", "work", "group", "related", "state", "count", "sql",
+  "repo", "activate", "mention", "pipeline", "provider", "handle", "handling"
+]);
+const SKILL_NAME = /^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$/;
 
 function idStrength(name) {
   const tokens = nameTokens(name);
@@ -54,7 +60,32 @@ const NO_BOUNDARY_SIMILARITY = 0.5;
 export function lintSuite(suite) {
   const findings = [];
   const add = (severity, code, tool, message, extra = {}) =>
-    findings.push({ severity, code, tool, message, ...extra });
+    findings.push({ severity, code, kind: "tool", tool, message, ...extra });
+  const addSkill = (severity, code, skill, message, extra = {}) =>
+    findings.push({ severity, code, kind: "skill", skill, message, ...extra });
+
+  // Mounting groups, when declared: a confusable pair split across groups is a
+  // merge hazard (mounting both groups on one agent recreates the collision),
+  // while the same pair inside one group is just a normal authoring problem.
+  const profileGroups = suite.profiles
+    ? normalizeProfiles(suite.profiles, suite.tools.map((tool) => tool.name))
+    : [];
+  const toolGroups = new Map();
+  for (const profile of profileGroups) {
+    for (const name of profile.tools) {
+      const groups = toolGroups.get(name);
+      if (groups) groups.push(profile.name);
+      else toolGroups.set(name, [profile.name]);
+    }
+  }
+  const crossGroups = new Map();
+  const recordCrossPair = (groupA, groupB, pair) => {
+    const [a, b] = groupA < groupB ? [groupA, groupB] : [groupB, groupA];
+    const key = `${JSON.stringify([a, b])}`;
+    const entry = crossGroups.get(key) ?? { a, b, pairs: [] };
+    entry.pairs.push({ toolA: pair.a, toolB: pair.b, similarity: pair.similarity });
+    crossGroups.set(key, entry);
+  };
 
   for (const tool of suite.tools) {
     const description = (tool.description ?? "").trim();
@@ -178,6 +209,13 @@ export function lintSuite(suite) {
         pair: [pair.a, pair.b]
       });
     } else if (pair.similarity >= NO_BOUNDARY_SIMILARITY) {
+      const aGroups = toolGroups.get(pair.a) ?? [];
+      const bGroups = toolGroups.get(pair.b) ?? [];
+      if (aGroups.length > 0 && bGroups.length > 0 && !aGroups.some((group) => bGroups.includes(group))) {
+        for (const groupA of aGroups) {
+          for (const groupB of bGroups) recordCrossPair(groupA, groupB, pair);
+        }
+      }
       const reason = pair.basis === "structural" ? "名字与参数形状接近" : "描述相近";
       add("warn", "pair-no-boundary", pair.a, `与 ${pair.b} ${reason}（相似度 ${similarity}），且两边都没写“不适用于”边界，模型只能靠相似度硬猜`, {
         pair: [pair.a, pair.b],
@@ -186,23 +224,159 @@ export function lintSuite(suite) {
     }
   }
 
+  // Skills are prompt-injected (name + description only), so the install-time
+  // question is narrower than for tools: is the description specific enough to
+  // be triggered, and does it collide with another installed skill?
+  const skills = suite.skills ?? [];
+  for (const skill of skills) {
+    const description = String(skill.description ?? "").trim();
+    if (!description) {
+      addSkill("info", "skill-desc-missing", skill.name, "skill 没有 description，模型只能靠名字判断是否触发", {
+        suggestion: "在 SKILL.md frontmatter 补一句 description，写清楚“用于什么任务、不适用于什么”"
+      });
+    } else if (description.length < 20) {
+      addSkill("warn", "skill-desc-short", skill.name, `description 只有 ${description.length} 字，信息不足`, {
+        suggestion: "写清楚触发场景与边界，例如「用于____；不适用于____」"
+      });
+    } else if (description.length > 600) {
+      addSkill("info", "skill-desc-long", skill.name, `description ${description.length} 字，可能挤占上下文`);
+    }
+    if (!SKILL_NAME.test(skill.name)) {
+      addSkill("warn", "skill-name-style", skill.name, "skill 名建议用小写 kebab-case 或 snake_case");
+    }
+  }
+
+  for (const pair of suspectedPairs(skills, {
+    threshold: SKILL_PAIR_SIMILARITY,
+    extraStop: SKILL_BOILERPLATE
+  })) {
+    const similarity = pair.similarity.toFixed(2);
+    const declaresBoundary = [pair.a, pair.b].some((name) => {
+      const skill = skills.find((item) => item.name === name);
+      return BOUNDARY_HINT.test(skill?.description ?? "");
+    });
+    // Same-vendor siblings ("feishu-doc" / "feishu-wiki") share the vendor token
+    // but each name carries its own distinguishing word. That is a family, not a
+    // duplicate — worth telling the author, not worth a warning.
+    const nameBits = [pair.a, pair.b].map(
+      (name) => new Set(nameTokens(name).filter((token) => !SKILL_BOILERPLATE.has(token)))
+    );
+    const sharedNames = [...nameBits[0]].filter((token) => nameBits[1].has(token));
+    const uniqueNames = nameBits.map((own, index) =>
+      [...own].filter((token) => !nameBits[1 - index].has(token))
+    );
+    const sibling = sharedNames.length > 0 && uniqueNames.every((list) => list.length > 0);
+
+    if (declaresBoundary) {
+      addSkill("info", "skill-pair-overlap", pair.a, `与 ${pair.b} 的描述相似度 ${similarity}，已写互斥边界`, {
+        pair: [pair.a, pair.b]
+      });
+    } else if (sibling) {
+      addSkill(
+        "info",
+        "skill-pair-sibling",
+        pair.a,
+        `与 ${pair.b} 同族（共享 ${sharedNames.join("/")}，以 ${uniqueNames[0].join("/")} 与 ${uniqueNames[1].join("/")} 区分），相似度 ${similarity}`,
+        {
+          pair: [pair.a, pair.b],
+          suggestion: `确认 ${pair.a} 与 ${pair.b} 的 description 里各自写清区别；同族分开挂载通常没问题`
+        }
+      );
+    } else {
+      addSkill(
+        "warn",
+        "skill-pair-no-boundary",
+        pair.a,
+        `与 ${pair.b} 的描述高度重叠（相似度 ${similarity}），skills 没有参数形状可区分，模型只能靠字面猜`,
+        {
+          pair: [pair.a, pair.b],
+          suggestion: `在 ${pair.a} 和 ${pair.b} 的 description 里写清各自边界，或合并成一个 skill`
+        }
+      );
+    }
+  }
+
   const counts = { error: 0, warn: 0, info: 0 };
   for (const finding of findings) counts[finding.severity] += 1;
-  return { tools: suite.tools.length, counts, findings };
+  const profilePairs = [...crossGroups.values()]
+    .map((entry) => ({ ...entry, max: Math.max(...entry.pairs.map((item) => item.similarity)) }))
+    .sort(
+      (x, y) =>
+        y.max - x.max ||
+        y.pairs.length - x.pairs.length ||
+        `${x.a} ${x.b}`.localeCompare(`${y.a} ${y.b}`)
+    );
+  return { tools: suite.tools.length, skills: skills.length, counts, findings, profilePairs };
+}
+
+// A mature 47-tool gateway produces ~70 findings where 60 are the same rule
+// repeated. An install gate that prints all of them is unreadable, so repeats
+// are folded into one block; the JSON keeps every finding for tooling.
+const AGGREGATE_MIN = 3;
+const KEEP_INDIVIDUAL = new Set([
+  "pair-no-boundary",
+  "pair-overlap",
+  "skill-pair-no-boundary",
+  "skill-pair-overlap"
+]);
+
+function subjectOf(finding) {
+  if (finding.kind === "skill") return `skill ${finding.skill}`;
+  return `${finding.tool}${finding.param ? `.${finding.param}` : ""}`;
 }
 
 export function formatLint(report) {
-  const lines = [
-    `tools: ${report.tools}  findings: ${report.findings.length}（error ${report.counts.error} / warn ${report.counts.warn} / info ${report.counts.info}）`
-  ];
-  if (report.findings.length === 0) {
-    lines.push("没有发现问题");
-    return lines.join("\n");
+  const { counts, findings } = report;
+  const skillCount = report.skills ?? 0;
+  const head = `tools: ${report.tools}${skillCount > 0 ? `  skills: ${skillCount}` : ""}  findings: ${findings.length}（error ${counts.error} / warn ${counts.warn} / info ${counts.info}）`;
+  const profilePairs = report.profilePairs ?? [];
+  if (findings.length === 0 && profilePairs.length === 0) {
+    return `${head}\n没有发现问题`;
   }
-  for (const finding of report.findings) {
-    const param = finding.param ? `.${finding.param}` : "";
-    lines.push(`[${finding.severity}] ${finding.tool}${param}  ${finding.code}: ${finding.message}`);
-    if (finding.suggestion) lines.push(`         ${finding.suggestion}`);
+
+  const byCode = new Map();
+  for (const finding of findings) {
+    const list = byCode.get(finding.code) ?? [];
+    list.push(finding);
+    byCode.set(finding.code, list);
+  }
+  const bulk = [...byCode].filter(
+    ([code, list]) =>
+      list.length >= AGGREGATE_MIN && !KEEP_INDIVIDUAL.has(code) && list[0].severity !== "error"
+  );
+  const bulkCodes = new Set(bulk.map(([code]) => code));
+  const lines = [head];
+
+  if (bulk.length > 0) {
+    lines.push("", `重复问题（同一规则 ≥${AGGREGATE_MIN} 条，已合并；逐条明细见 --json）:`);
+    for (const [code, list] of bulk) {
+      const first = list[0];
+      lines.push(`[${first.severity}] ${code} × ${list.length}  ${first.message}`);
+      const subjects = list.map(subjectOf);
+      lines.push(
+        `        涉及：${subjects.slice(0, 8).join("、")}${subjects.length > 8 ? ` 等 ${subjects.length} 处` : ""}`
+      );
+      if (first.suggestion) lines.push(`         ${first.suggestion}`);
+    }
+  }
+
+  const rest = findings.filter((finding) => !bulkCodes.has(finding.code));
+  if (rest.length > 0) {
+    if (bulk.length > 0) lines.push("", "逐条:");
+    for (const finding of rest) {
+      lines.push(`[${finding.severity}] ${subjectOf(finding)}  ${finding.code}: ${finding.message}`);
+      if (finding.suggestion) lines.push(`         ${finding.suggestion}`);
+    }
+  }
+
+  if (profilePairs.length > 0) {
+    lines.push("", "组间高风险对（这些组不建议合并挂载）:");
+    for (const group of profilePairs) {
+      lines.push(`  ${group.a} × ${group.b}  ${group.pairs.length} 对（最高 ${group.max.toFixed(2)}）`);
+      for (const item of group.pairs) {
+        lines.push(`    ${item.toolA} × ${item.toolB}  ${item.similarity.toFixed(2)}`);
+      }
+    }
   }
   return lines.join("\n");
 }

package/lib/mcp-server.js

@@ -32,7 +32,7 @@ export async function startMcpServer() {
     {
       title: "Scan tools",
       description:
-        "扫描仓库里的 function.json / OpenAPI / MCP 配置 / SKILL.md / 代码内定义。probe=true 时连接 stdio MCP server 拉取 tools/list。不执行工具。默认只读；传 writeSuite 时在该路径写出套件草稿（cases 为空，需补用例并复核）。",
+        "扫描仓库里的 function.json / OpenAPI / MCP 配置 / SKILL.md / 代码内定义。probe=true 时连接 stdio MCP server 拉取 tools/list。不执行工具。默认只读；传 writeSuite 时在该路径写出套件草稿（cases 为空，需补用例并复核；来源 ≥2 时草稿带按来源分组的 profiles，并列出不参与评测的 skills）。",
       inputSchema: {
         root: z.string().optional().describe("仓库目录，默认进程当前目录"),
         probe: z.boolean().optional().describe("是否连接 MCP server 拉取工具清单"),
@@ -142,13 +142,26 @@ export async function startMcpServer() {
         suite: z.string().optional().describe("套件路径，默认 ./mf.suite.json"),
         models: z.string().optional().describe("逗号分隔的模型 id，如 mock,dsv4-flash"),
         cases: z.string().optional().describe("只跑这些用例 id（逗号分隔）"),
+        profile: z
+          .string()
+          .optional()
+          .describe("按挂载组评分：all 或组名（逗号分隔）；套件需含 profiles，结果里带 groups/lifted/jammed"),
+        repeat: z
+          .number()
+          .int()
+          .min(1)
+          .max(10)
+          .optional()
+          .describe("每条用例重复次数，取多数结果；建议正式基线用 3"),
         failUnder: z.number().optional().describe("选择准确率阈值，低于则退出码为 2")
       }
     },
-    async ({ suite, models, cases, failUnder }) => {
+    async ({ suite, models, cases, profile, repeat, failUnder }) => {
       const args = ["eval", "--json", "--suite", suitePath(suite)];
       if (models) args.push("--models", models);
       if (cases) args.push("--case", cases);
+      if (profile) args.push("--profile", profile);
+      if (repeat !== undefined) args.push("--repeat", String(repeat));
       if (failUnder !== undefined) args.push("--fail-under", String(failUnder));
 
       const result = await runCli(args);

package/lib/profile.js

@@ -0,0 +1,304 @@
+import { pct } from "./score.js";
+
+export function normalizeProfiles(raw, toolNames) {
+  if (raw === undefined || raw === null) return null;
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error('suite "profiles" must be an object of { "group": ["tool", ...] }');
+  }
+  const known = new Set(toolNames);
+  const profiles = [];
+  for (const [key, list] of Object.entries(raw)) {
+    const name = String(key).trim();
+    if (!name) throw new Error('suite "profiles": group name must be non-empty');
+    if (!Array.isArray(list) || list.length === 0) {
+      throw new Error(`profile "${name}": must be a non-empty array of tool names`);
+    }
+    const tools = [];
+    for (const item of list) {
+      if (typeof item !== "string" || item.trim() === "") {
+        throw new Error(`profile "${name}": tool names must be non-empty strings`);
+      }
+      const toolName = item.trim();
+      if (!known.has(toolName)) throw new Error(`profile "${name}": unknown tool "${toolName}"`);
+      if (!tools.includes(toolName)) tools.push(toolName);
+    }
+    profiles.push({ name, tools });
+  }
+  if (profiles.length === 0) throw new Error('suite "profiles" is empty');
+  return profiles;
+}
+
+export function selectProfiles(profiles, wanted) {
+  if (!wanted || wanted.length === 0 || wanted.includes("all")) return profiles;
+  const byName = new Map(profiles.map((profile) => [profile.name, profile]));
+  const missing = wanted.filter((name) => !byName.has(name));
+  if (missing.length > 0) {
+    throw new Error(
+      `unknown profile(s): ${missing.join(", ")}（可用：${profiles.map((profile) => profile.name).join(", ")}）`
+    );
+  }
+  return wanted.map((name) => byName.get(name));
+}
+
+// A case belongs to a group when its expected tool is mounted there. Negative
+// cases ("no tool applies") hold everywhere: the group's agent still gets them.
+export function selectProfileCases(cases, mountedTools) {
+  return cases.filter((testCase) => testCase.expectedTool === null || mountedTools.has(testCase.expectedTool));
+}
+
+export function profileWarnings(profiles, suite) {
+  const mounted = new Set(profiles.flatMap((profile) => profile.tools));
+  const warnings = [];
+  const unmounted = suite.tools.map((tool) => tool.name).filter((name) => !mounted.has(name));
+  if (unmounted.length > 0) warnings.push(`工具不在任何挂载组: ${unmounted.join(", ")}`);
+  const homeless = suite.cases.filter(
+    (testCase) => testCase.expectedTool !== null && !mounted.has(testCase.expectedTool)
+  ).length;
+  if (homeless > 0) warnings.push(`${homeless} 条用例的期望工具不在任何挂载组，不参与分组评分`);
+  const everything = suite.tools.length;
+  for (const profile of profiles) {
+    if (profile.tools.length === everything) {
+      warnings.push(`profile "${profile.name}" 挂载了全部工具，与全量对比没有意义`);
+    }
+  }
+  return warnings;
+}
+
+export function profileCaseCoverage(profiles, cases) {
+  const negatives = cases.filter((testCase) => testCase.expectedTool === null).length;
+  return profiles.map((profile) => {
+    const mounted = new Set(profile.tools);
+    const counts = new Map(profile.tools.map((name) => [name, 0]));
+    for (const testCase of cases) {
+      if (testCase.expectedTool !== null && mounted.has(testCase.expectedTool)) {
+        counts.set(testCase.expectedTool, counts.get(testCase.expectedTool) + 1);
+      }
+    }
+    const missing = [...counts.entries()].filter(([, count]) => count === 0).map(([name]) => name);
+    let total = 0;
+    for (const count of counts.values()) total += count;
+    return { name: profile.name, tools: profile.tools.length, cases: total, negatives, missing };
+  });
+}
+
+export function analyzeMount(profile, mounted, allInOne) {
+  const after = new Map(mounted.rows.map((row) => [row.id, row]));
+  const lifted = [];
+  const jammed = [];
+  for (const before of allInOne.rows) {
+    const row = after.get(before.id);
+    if (!row || before.reviewed === false || row.reviewed === false) continue;
+    if (!before.selectionCorrect && row.selectionCorrect) lifted.push(changeOf(before, row));
+    else if (before.selectionCorrect && !row.selectionCorrect) jammed.push(changeOf(before, row));
+  }
+
+  const mountedMetrics = metricsOf(mounted);
+  const allMetrics = metricsOf(allInOne);
+  const reviewed = mounted.reviewedTotal;
+  return {
+    profile: profile.name,
+    mountedTools: profile.tools.length,
+    cases: mounted.total,
+    reviewed,
+    mounted: mountedMetrics,
+    allInOne: allMetrics,
+    delta: {
+      selection: reviewed ? mountedMetrics.selectionAccuracy - allMetrics.selectionAccuracy : null,
+      args:
+        mountedMetrics.argAccuracy === null || allMetrics.argAccuracy === null
+          ? null
+          : mountedMetrics.argAccuracy - allMetrics.argAccuracy,
+      pass: reviewed ? mountedMetrics.passRate - allMetrics.passRate : null
+    },
+    lifted,
+    jammed
+  };
+}
+
+export function modelTotals(entries) {
+  let reviewed = 0;
+  let mountedCorrect = 0;
+  let allCorrect = 0;
+  for (const entry of entries) {
+    reviewed += entry.reviewed;
+    mountedCorrect += entry.mounted.correct;
+    allCorrect += entry.allInOne.correct;
+  }
+  if (reviewed === 0) {
+    return {
+      reviewed: 0,
+      mountedCorrect: 0,
+      allCorrect: 0,
+      mountedAccuracy: null,
+      allAccuracy: null,
+      delta: null
+    };
+  }
+  const mountedAccuracy = mountedCorrect / reviewed;
+  const allAccuracy = allCorrect / reviewed;
+  return {
+    reviewed,
+    mountedCorrect,
+    allCorrect,
+    mountedAccuracy,
+    allAccuracy,
+    delta: mountedAccuracy - allAccuracy
+  };
+}
+
+export function formatProfileReport(report, { showCases = false } = {}) {
+  const lines = [
+    `mount compare: ${report.groups.length} 组（profiles ${report.hash}）`,
+    "组内用例只在对应挂载下评分；all-in-one 用同一批用例、全部工具都挂。"
+  ];
+
+  for (const model of report.models) {
+    lines.push("", `[${model.model}]`);
+    const rows = model.profiles.map((entry) => [
+      entry.profile,
+      String(entry.mountedTools),
+      String(entry.cases),
+      pct(entry.mounted.selectionAccuracy),
+      pct(entry.allInOne.selectionAccuracy),
+      signedPoints(entry.delta.selection)
+    ]);
+    lines.push(
+      ...renderTable(
+        ["profile", "tools", "cases", "mounted", "all-in-one", "delta"],
+        rows,
+        [1, 2, 3, 4, 5]
+      )
+    );
+    const totals = model.totals;
+    if (totals.reviewed > 0) {
+      lines.push(
+        `  合计: 分组 ${pct(totals.mountedAccuracy)}（${totals.mountedCorrect}/${totals.reviewed}）` +
+          ` / 全量 ${pct(totals.allAccuracy)}（${totals.allCorrect}/${totals.reviewed}）` +
+          `，${signedPoints(totals.delta)}`
+      );
+    }
+    const unstable = unstableOf(model.profiles);
+    if (unstable.length > 0) lines.push(`  组内不稳定: ${unstable.join(", ")}`);
+    if (showCases) {
+      for (const entry of model.profiles) {
+        for (const item of entry.lifted) {
+          lines.push(
+            `  + ${entry.profile}/${item.id}: ${item.before ?? "(no tool)"} → ${item.after ?? "(no tool)"}（期望 ${item.expected ?? "(no tool)"}）`
+          );
+        }
+        for (const item of entry.jammed) {
+          lines.push(
+            `  - ${entry.profile}/${item.id}: ${item.before ?? "(no tool)"} → ${item.after ?? "(no tool)"}（期望 ${item.expected ?? "(no tool)"}）`
+          );
+        }
+      }
+    }
+  }
+
+  if (report.warnings.length > 0) {
+    lines.push("", "warnings:");
+    for (const warning of report.warnings) lines.push(`  - ${warning}`);
+  }
+  return lines.join("\n");
+}
+
+export function formatProfileMarkdown(report) {
+  const lines = [
+    "## 挂载对比（分组 vs 全量）",
+    "",
+    "组内用例只在对应挂载下评分；全量 = 同一批用例、全部工具都挂。",
+    ""
+  ];
+  for (const model of report.models) {
+    lines.push(
+      `### ${model.model}`,
+      "",
+      "| group | tools | cases | mounted | all-in-one | delta |",
+      "| --- | --- | --- | --- | --- | --- |"
+    );
+    for (const entry of model.profiles) {
+      lines.push(
+        `| ${entry.profile} | ${entry.mountedTools} | ${entry.cases} | ${pct(entry.mounted.selectionAccuracy)} | ${pct(entry.allInOne.selectionAccuracy)} | ${signedPoints(entry.delta.selection)} |`
+      );
+    }
+    const totals = model.totals;
+    lines.push("");
+    if (totals.reviewed > 0) {
+      lines.push(
+        `- 合计：分组 ${pct(totals.mountedAccuracy)}（${totals.mountedCorrect}/${totals.reviewed}），` +
+          `全量 ${pct(totals.allAccuracy)}（${totals.allCorrect}/${totals.reviewed}），${signedPoints(totals.delta)}`
+      );
+    } else {
+      lines.push("- 合计：没有已复核用例，无法比较");
+    }
+    const unstable = unstableOf(model.profiles);
+    if (unstable.length > 0) lines.push(`- 组内不稳定：${unstable.join(", ")}`);
+    lines.push("");
+  }
+  if (report.warnings.length > 0) lines.push(`> ${report.warnings.join("；")}`, "");
+  return lines.join("\n").trimEnd();
+}
+
+function unstableOf(entries) {
+  return entries.flatMap((entry) =>
+    (entry.stability?.unstable ?? []).map((item) => `${entry.profile}/${item.id}`)
+  );
+}
+
+function changeOf(before, after) {
+  return {
+    id: before.id,
+    expected: before.expectedTool ?? null,
+    before: before.actualTool ?? null,
+    after: after.actualTool ?? null
+  };
+}
+
+function metricsOf(summary) {
+  const reviewedRows = summary.rows.filter((row) => row.reviewed !== false);
+  const correct = reviewedRows.filter((row) => row.selectionCorrect).length;
+  return {
+    selectionAccuracy: reviewedRows.length ? correct / reviewedRows.length : null,
+    argAccuracy: summary.argAccuracy,
+    passRate: reviewedRows.length
+      ? reviewedRows.filter((row) => row.passed).length / reviewedRows.length
+      : null,
+    correct
+  };
+}
+
+function signedPoints(value) {
+  if (value === null || value === undefined) return "n/a";
+  const points = Math.round(value * 100);
+  return `${points > 0 ? "+" : ""}${points}pp`;
+}
+
+function renderTable(headers, rows, numericColumns) {
+  const widths = headers.map((header, index) =>
+    Math.max(displayWidth(header), ...rows.map((row) => displayWidth(row[index])))
+  );
+  const line = (cells) =>
+    cells
+      .map((cell, index) => padDisplay(cell, widths[index], numericColumns.includes(index)))
+      .join("  ");
+  return [line(headers), widths.map((width) => "-".repeat(width)).join("  "), ...rows.map(line)].map(
+    (text) => `  ${text}`
+  );
+}
+
+function padDisplay(text, width, rightAlign) {
+  const fill = " ".repeat(Math.max(0, width - displayWidth(text)));
+  return rightAlign ? fill + text : text + fill;
+}
+
+export function displayWidth(text) {
+  let width = 0;
+  for (const char of String(text)) {
+    width += /[ᄀ-ᅟ⺀-꓏가-힣豈-﫿︰-﹏＀-｠￠-￦]/.test(
+      char
+    )
+      ? 2
+      : 1;
+  }
+  return width;
+}