kangshifu-board/test/showcase.test.js

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { buildModel } from '../src/core/kfs/build.js';
import {
  REPORT_TYPES, entriesForType, filterEntries, reportCenter, stageOutcome, painRanking,
  sectionDigest, chapterDigests, competitorMatrix, EMPTY_PLAN, hasEvidence,
} from '../src/core/index.js';

const NOW = Date.parse('2026-10-29T12:00:00Z');
const ago = (h) => new Date(NOW - h * 3600000).toISOString();
const raw = {
  artifact: [
    { objectId: 'a1', title: '夜宵卡 - opportunity_card', ownerName: '张伟', stage: 'S3 机会识别', evidenceLevel: 'supported', artifactType: 'opportunity_card', createdAt: ago(10) },
    { objectId: 'a2', title: '夜宵痛点 - pain_list', ownerName: '李娜', stage: 'S2需求洞察', evidenceLevel: 'verified', artifactType: 'pain_list', createdAt: ago(9) },
    { objectId: 'rep', title: '夜宵竞品 - competitor_report', ownerName: '张伟', stage: 'S1品类分析', evidenceLevel: 'supported', artifactType: 'competitor_report', createdAt: ago(8),
      report: { title: '夜宵洞察', executive: ['夜宵是最大空档'], chapters: [{ id: 'ch2', no: 2, title: '嵌套洞察', sections: [
        { kind: 'findings', data: [{ conclusion: '软塌是工艺问题', evidence: 'c1' }] },
      ] }], evidence: { c1: { claim: '软塌是工艺问题', build: undefined, quotes: [{ text: '泡完就坨', ref: '电商评论', likes: 302 }] } } } },
  ],
  opportunity: [
    { objectId: 'o1', title: '夜宵低卡', category: '拌面', stage: 'S3 机会识别', priority: 'S', evidenceLevel: 'high', linkedArtifacts: ['a1'], uploadedBy: '张伟', agentName: '主分身', uploadMethod: 'session', uploadedAt: ago(6) },
    { objectId: 'o2', title: '夜宵竞品', category: '汤面', stage: 'S1 品类市场分析', priority: 'B', evidenceLevel: 'medium', linkedArtifacts: [], uploadedBy: '赵磊', agentName: '调研 Agent', uploadMethod: 'skill', uploadedAt: ago(1) },
  ],
  source: [{ objectId: 'c1', title: '拌面品类概览', sourceType: 'category', tags: ['拌面'] }],
};
const db = buildModel(raw, { now: NOW });

test('报告中心：只计个人成果报告，机会卡对象与品类资料不混入报告数', () => {
  const c = reportCenter(db, { now: NOW });
  assert.deepEqual(c.types.map((t) => t.type.key), REPORT_TYPES.map((t) => t.key));
  assert.equal(c.types.find((t) => t.type.key === 'competitor').count, 1);
  assert.equal(c.types.find((t) => t.type.key === 'voc').count, 0);
  assert.equal(c.types.find((t) => t.type.key === 'opportunities').count, 1);
  assert.equal(c.types.find((t) => t.type.key === 'pain').count, 1);
  assert.equal(c.types.find((t) => t.type.key === 'category').count, 0);
  const sum = c.types.reduce((n, t) => n + t.count, 0);
  assert.equal(sum, 3, '已归类合计只含成果报告');
  assert.equal(c.unclassified.length, 0);
  assert.equal(c.total, 3);
  assert.deepEqual(c.separateObjects, { opportunities: 2, sources: 1 });
  assert.equal(new Set(c.entries.map(e => `${e.kind}:${e.id}`)).size, c.total);
  assert.ok(c.types.every((t) => t.share >= 0 && t.relative >= 0), '每个数字都有参照');
});

test('中心清单保留未归类成果，可打开正文，不被五个类型过滤掉', () => {
  const extra = buildModel({ ...raw, artifact: [...raw.artifact, { objectId: 'unknown1', title: '待归类原文', artifactType: 'unknown', rawText: '尚未归类的成果原文。' }] });
  const c = reportCenter(extra);
  assert.equal(c.unclassified.length, 1);
  const entry = c.entries.find(e => e.id === 'unknown1');
  assert.equal(entry.kind, 'artifact');
  assert.equal(entry.typeName, '未归类');
  assert.equal(entry.body, 'text');
});

test('类型页：阶段二次筛选 + 只看有证据', () => {
  const all = entriesForType(db, 'competitor');
  assert.equal(filterEntries(all, { stage: 'S3' }).length, 0, '机会卡报告已有独立分类');
  assert.equal(filterEntries(all, { stage: 'S1' }).length, 1, '竞品分类只计rep');
  assert.equal(filterEntries(entriesForType(db, 'opportunities'), { stage: 'S3' }).length, 1);
  // 有证据 = 成果原始等级 verified/supported，或机会卡的高/中；「只看有证据」必须真的筛掉推测
  const withEv = filterEntries(all, { evidenceOnly: true });
  assert.ok(withEv.every(hasEvidence));
  // 本 fixture 全是 supported / 高 证据，筛后应全留；另造一条推测验证会被筛掉
  assert.equal(withEv.length, all.length);
  const spec = { kind: 'artifact', evidenceKey: 'speculative', original: 'speculative' };
  assert.equal(hasEvidence(spec), false, '模型推测不算有证据');
  assert.equal(filterEntries([spec], { evidenceOnly: true }).length, 0);
  assert.equal(filterEntries(all, { mine: '张伟' }).length, 1, '仅rep属于竞品报告');
});

test('卡片关键指标按列对齐：每张卡 4 个指标，与类型页列名一致', () => {
  for (const t of REPORT_TYPES) {
    assert.equal(t.metricLabels.length, 4);
    for (const e of entriesForType(db, t.key)) assert.equal(e.metrics.length, 4, `${t.key}/${e.id}`);
  }
});

test('阶段产出：按类型分组 + 机会卡单独成组 + 产出人', () => {
  const s3 = stageOutcome(db, 'S3');
  assert.equal(s3.total, 2);
  const opp = s3.groups.find((g) => g.key === 'opportunity');
  assert.equal(opp.count, 1);
  assert.equal(opp.items[0].title, '夜宵低卡');
  assert.deepEqual(s3.owners.map((o) => o.name).sort(), ['张伟']);
  assert.equal(stageOutcome(db, 'S4').total, 0, '没有产出的阶段给 0，不编');
});

test('痛点归并：同一条痛点（同一报告结论）多人整理只算一份；没标严重度就是 null', () => {
  const d2 = buildModel({ artifact: [
    { objectId: 'p1', title: '软塌 - pain_list', ownerName: '甲', stage: 'S2', artifactType: 'pain_list', report: { evidence: { e1: { claim: '泡完就坨' } } } },
    { objectId: 'p2', title: '泡完就坨 - pain_list', ownerName: '乙', stage: 'S2', artifactType: 'pain_list', report: { evidence: { e1: { claim: '泡完就坨' } } } },
    { objectId: 'p3', title: '太贵 - pain_list', ownerName: '丙', stage: 'S2', artifactType: 'pain_list' },
  ] }, { now: NOW });
  const rows = painRanking(d2, entriesForType(d2, 'pain'));
  assert.equal(rows[0].subject, '泡完就坨');
  assert.equal(rows[0].mentions, 2);
  assert.deepEqual(rows[0].people.sort(), ['乙', '甲']);
  assert.equal(rows.find((r) => r.subject === '太贵').severity, null);
});

test('报告可扫：章节摘要只抽原文，不生成', () => {
  const dig = chapterDigests(db, 'rep');
  assert.equal(dig[0].title, '嵌套洞察');
  assert.equal(dig[0].findings[0], '软塌是工艺问题');
  assert.deepEqual(sectionDigest({ kind: 'findings', data: [{ conclusion: '软塌是工艺问题' }] }), ['软塌是工艺问题']);
  assert.deepEqual(sectionDigest({ kind: 'para', data: { text: '短' } }), []);
});

test('竞品矩阵：按对位主题合并成一行', () => {
  const m = competitorMatrix(entriesForType(db, 'competitor'));
  const row = m.find((r) => r.subject === '夜宵竞品');
  assert.equal(row.count, 1, '独立机会o2不冒充竞品报告');
  assert.deepEqual(row.stageCodes.sort(), ['S1']);
});

test('空态说明书：每个类型都写清将来会出现什么（不是「暂无数据」）', () => {
  for (const t of REPORT_TYPES) {
    const p = EMPTY_PLAN[t.key];
    assert.ok(p?.will && p?.who && p?.field && p?.looks, t.key);
    assert.ok(!/暂无数据/.test(JSON.stringify(p)));
  }
});