@epoint-testtech/ep-stage-skill 0.0.3-alpha.2 → 0.0.4-alpha.0

package/dist/test/cli/spec.test.js

@@ -0,0 +1,196 @@
+/**
+ * spec.ts 单元测试（REQ-SPEC-01）。
+ *
+ * 覆盖：
+ * - parseSpecArgs 缺参 / 非法 / -- 分隔符
+ * - runSpec：
+ *   · 缺 contract.json 时报错（引导用户先跑 testcase 子命令）；
+ *   · 正确装配 v1 .spec.ts（含 SKELETON_MARKER_LINE 头部标记 + skeleton 主体）；
+ *   · testcase.json5 不通过 validateTestcase 时抛错（透传 v2 schema 校验）。
+ */
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { parseSpecArgs, runSpec } from '../../src/cli/spec.js';
+let tmpRoot;
+beforeEach(() => {
+    tmpRoot = mkdtempSync(path.join(os.tmpdir(), 'ep-stage-spec-'));
+});
+afterEach(() => {
+    // 留 tmpdir 给宿主清理，避免删 fixture 时误命中其他测试。
+});
+function createContract() {
+    return {
+        contractVersion: 'crud-business-module/v1',
+        module: { id: 'zwplace', label: '场所窗口信息管理' },
+        pages: {
+            list: {
+                role: 'list',
+                pageId: 'gxhzwplacelist',
+                title: '场所窗口信息列表',
+                iframeSrcKeyword: 'gxhzwplacelist',
+                fields: [
+                    { name: 'windowname', label: '窗口名称', controlType: 'minitext', required: false, availability: 'auto_extractable', sources: [] },
+                ],
+                buttons: [],
+                grids: [],
+                dialogs: [],
+                sources: [],
+            },
+            add: {
+                role: 'add',
+                pageId: 'gxhzwplaceadd',
+                title: '新增场所窗口',
+                iframeSrcKeyword: 'gxhzwplaceadd',
+                fields: [
+                    { name: 'windowname', label: '窗口名称', controlType: 'minitext', required: true, availability: 'auto_extractable', sources: [] },
+                ],
+                buttons: [],
+                grids: [],
+                dialogs: [],
+                sources: [],
+            },
+            edit: {
+                role: 'edit',
+                pageId: 'gxhzwplaceedit',
+                title: '修改场所窗口',
+                iframeSrcKeyword: 'gxhzwplaceedit',
+                fields: [
+                    { name: 'windowname', label: '窗口名称', controlType: 'minitext', required: true, availability: 'auto_extractable', sources: [] },
+                ],
+                buttons: [],
+                grids: [],
+                dialogs: [],
+                sources: [],
+            },
+        },
+        dataKey: {
+            field: 'windowname',
+            label: '窗口名称',
+            availability: 'derivable',
+            generationStrategy: 'timestamp_prefix',
+            sources: [],
+        },
+        searchConditions: [
+            {
+                field: 'windowname',
+                label: '窗口名称',
+                component: 'input',
+                seedValue: '自动化测试窗口',
+                generationStrategy: 'timestamp_prefix',
+                sources: [],
+            },
+        ],
+        flows: {
+            create: {
+                entryButton: { pageRole: 'list', label: '新增', sources: [] },
+                targetPageId: 'gxhzwplaceadd',
+                saveButton: { pageRole: 'add', label: '保存并关闭', sources: [] },
+                overrideFields: [],
+            },
+            search: {
+                searchField: { pageRole: 'list', field: 'windowname', label: '窗口名称', sources: [] },
+                submitControl: { pageRole: 'list', label: '查询', sources: [] },
+                resultGrid: 'datagrid',
+            },
+            update: {
+                entryAction: { pageRole: 'list', label: '修改', sources: [] },
+                targetPageId: 'gxhzwplaceedit',
+                updateField: { pageRole: 'edit', field: 'windowname', label: '窗口名称', sources: [] },
+                saveButton: { pageRole: 'edit', label: '保存并关闭', sources: [] },
+            },
+            delete: {
+                entryButton: { pageRole: 'list', label: '删除', sources: [] },
+                expectedOutcome: 'success_delete',
+                confirmControl: { pageRole: 'list', label: '确定', sources: [] },
+            },
+        },
+        assertions: [],
+        businessRules: [],
+        unresolvedSlots: [],
+    };
+}
+function createTestcase() {
+    return {
+        schemaVersion: 'v2',
+        scenario: 'crud.single-page',
+        moduleId: 'zwplace',
+        moduleName: '场所窗口信息管理',
+        menuPath: '业务管理 > 场所窗口',
+        requiredSystems: [{ url: '' }],
+        requiredRoles: [{ role: 'admin' }],
+        coveredActions: [
+            { actionId: 'create', kind: '新增', evidence: ['contract=crud-business-module/v1'] },
+        ],
+        uncoveredCandidates: [],
+        cases: [
+            {
+                caseId: 'zwplace.create',
+                title: '新增',
+                scenario: 'crud.single-page',
+                reviewStatus: 'needs_review',
+                requiredRole: 'admin',
+                evidence: ['contract=crud-business-module/v1'],
+                steps: [],
+                assertions: [],
+                unresolved: [],
+            },
+        ],
+        reasoningSummary: {
+            conclusion: '',
+            evidenceChain: [],
+            alternatives: [],
+            confidence: 'medium',
+            risks: [],
+            needsHumanReview: true,
+        },
+    };
+}
+function writeFixtures() {
+    const testsDir = path.join(tmpRoot, 'requirement-X');
+    mkdirSync(path.join(testsDir, '.ep-stage'), { recursive: true });
+    const testcasePath = path.join(testsDir, 'testcase.json5');
+    const contractPath = path.join(testsDir, '.ep-stage', 'contract.json');
+    writeFileSync(testcasePath, JSON.stringify(createTestcase()), 'utf8');
+    writeFileSync(contractPath, JSON.stringify(createContract()), 'utf8');
+    return { testcasePath, specOut: path.join(testsDir, 'crud.spec.ts') };
+}
+describe('parseSpecArgs', () => {
+    it('缺 --testcase 时抛错', () => {
+        expect(() => parseSpecArgs(['--out', '/x'])).toThrow(/缺少 --testcase/);
+    });
+    it('缺 --out 时抛错', () => {
+        expect(() => parseSpecArgs(['--testcase', '/x'])).toThrow(/缺少 --out/);
+    });
+    it('参数对非法时抛错', () => {
+        expect(() => parseSpecArgs(['--testcase'])).toThrow(/无效参数对/);
+    });
+    it('-- 分隔符被忽略', () => {
+        const args = parseSpecArgs(['--', '--testcase', '/a', '--out', '/b']);
+        expect(args).toEqual({ testcase: '/a', out: '/b' });
+    });
+});
+describe('runSpec', () => {
+    it('正常装配 v1 .spec.ts（含 SKELETON_MARKER_LINE）', () => {
+        const { testcasePath, specOut } = writeFixtures();
+        const result = runSpec({ testcase: testcasePath, out: specOut });
+        expect(result).toEqual({ specPath: specOut, version: 'v1' });
+        const body = readFileSync(specOut, 'utf8');
+        expect(body).toMatch(/^\/\/ === 胶水模式生成（基于 contract \+ coveredActions）===/);
+        // skeleton 主体（来自 generateStageSkeletonCrudSpec）应含 Playwright import 或 test 入口
+        expect(body.length).toBeGreaterThan(100);
+    });
+    it('缺 .ep-stage/contract.json 时抛错引导', () => {
+        const testsDir = path.join(tmpRoot, 'requirement-Y');
+        mkdirSync(testsDir, { recursive: true });
+        const testcasePath = path.join(testsDir, 'testcase.json5');
+        writeFileSync(testcasePath, JSON.stringify(createTestcase()), 'utf8');
+        expect(() => runSpec({ testcase: testcasePath, out: path.join(testsDir, 'out.spec.ts') })).toThrow(/未找到.*contract\.json/);
+    });
+    it('testcase.json5 schemaVersion 不是 v2 时由 validateTestcase 抛错', () => {
+        const { testcasePath, specOut } = writeFixtures();
+        writeFileSync(testcasePath, JSON.stringify({ schemaVersion: 'v1' }), 'utf8');
+        expect(() => runSpec({ testcase: testcasePath, out: specOut })).toThrow(/schemaVersion 不是 v2/);
+    });
+});

package/dist/test/stage-context.test.js

@@ -3,7 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import JSON5 from 'json5';
 import { describe, expect, it } from 'vitest';
-import { readStageContext, resolveStageContext, writeProjectIndex, } from '../src/index.js';
+import { lookupProjectByRequirement, readStageContext, resolveStageContext, writeProjectIndex, } from '../src/index.js';
 /**
  * 创建隔离的临时目录，避免测试读写真实用户 HOME 或项目文件。
  *
@@ -44,7 +44,8 @@ describe('stage context resolution', () => {
             codeListPaths: [path.resolve(projectDir, '../knowledge-project/_docs/code_list.md')],
         });
     });
-    it('resolves current project from user index by code list path when local context is absent', () => {
+    it('resolves current project from legacy user index by code list path when local context is absent', () => {
+        // 旧链路：legacy projects.index.json5 含 envPath/knowledgeRoot/codeListPaths，仍需可读（REQ-DATA-01 graceful read）。
         const homeDir = createTempDir('ep-stage-home');
         const projectDir = createTempDir('ep-stage-project');
         const cwd = createTempDir('ep-stage-outside-cwd');
@@ -55,19 +56,25 @@ describe('stage context resolution', () => {
         mkdirSync(path.dirname(codeListPath), { recursive: true });
         writeFileSync(path.join(projectDir, '.env'), 'LOGIN_SYSTEM_URL=http://example.test/login\n');
         writeFileSync(codeListPath, '# code list\n');
-        writeProjectIndex({
-            homeDir,
+        // 直接写 legacy schema（含 envPath/knowledgeRoot/codeListPaths），模拟旧版数据残留。
+        const indexDir = path.join(homeDir, '.ep-stage');
+        mkdirSync(indexDir, { recursive: true });
+        writeFileSync(path.join(indexDir, 'projects.index.json5'), JSON5.stringify({
             projects: [
                 {
                     projectName: 'indexed-project',
                     projectDir,
                     mode: 'glue',
+                    stageCreateVersion: '0.0.4-alpha.0',
+                    requirements: [],
+                    // legacy 字段
                     envPath: '.env',
                     knowledgeRoot,
                     codeListPaths: [codeListPath],
                 },
             ],
-        });
+            systems: [],
+        }, null, 2));
         const result = resolveStageContext({
             cwd,
             codeListPath,
@@ -91,7 +98,8 @@ describe('stage context resolution', () => {
             },
         });
     });
-    it('uses stage-context.md as source of truth when user index has stageContextPath', () => {
+    it('uses stage-context.md as source of truth when legacy user index has stageContextPath', () => {
+        // 旧链路：legacy projects.index.json5 含 stageContextPath 时，回到 stage-context.md 作为真相源（graceful read）。
         const homeDir = createTempDir('ep-stage-home-source');
         const projectDir = createTempDir('ep-stage-source-project');
         const oldKnowledgeRoot = path.join(projectDir, 'old knowledge');
@@ -114,20 +122,25 @@ describe('stage context resolution', () => {
             '',
             '# context-project',
         ].join('\n'));
-        writeProjectIndex({
-            homeDir,
+        const indexDir = path.join(homeDir, '.ep-stage');
+        mkdirSync(indexDir, { recursive: true });
+        writeFileSync(path.join(indexDir, 'projects.index.json5'), JSON5.stringify({
             projects: [
                 {
                     projectName: 'stale-index-project',
                     projectDir,
                     mode: 'glue',
+                    stageCreateVersion: '0.0.4-alpha.0',
+                    requirements: [],
+                    // legacy 字段
                     envPath: 'old.env',
                     knowledgeRoot: oldKnowledgeRoot,
                     codeListPaths: [codeListPath],
                     stageContextPath,
                 },
             ],
-        });
+            systems: [],
+        }, null, 2));
         const result = resolveStageContext({
             cwd: createTempDir('ep-stage-source-outside'),
             codeListPath,
@@ -167,12 +180,16 @@ describe('stage context resolution', () => {
             projectName: 'json5-project',
             projectDir: '${projectDir}',
             mode: 'glue',
+            stageCreateVersion: '0.0.4-alpha.0',
+            requirements: [],
+            // legacy 字段（graceful read，向后兼容）
             envPath: '.env',
             codeListPaths: [
               '${codeListPath}',
             ],
           },
         ],
+        systems: [],
       }`);
         const result = resolveStageContext({
             projectDir,
@@ -213,7 +230,7 @@ describe('stage context resolution', () => {
             },
         });
     });
-    it('writes v1 project index and keeps reading legacy JSON5 index files', () => {
+    it('writes new schema project index (no version field, with systems[]) and keeps reading legacy JSON5', () => {
         const homeDir = createTempDir('ep-stage-home-version');
         const projectDir = createTempDir('ep-stage-version-project');
         mkdirSync(projectDir, { recursive: true });
@@ -224,20 +241,31 @@ describe('stage context resolution', () => {
                     projectName: 'versioned-project',
                     projectDir,
                     mode: 'glue',
-                    envPath: '.env',
+                    stageCreateVersion: '0.0.4-alpha.0',
+                    requirements: [],
                 },
             ],
         });
         const parsedIndex = JSON5.parse(readFileSync(indexPath, 'utf8'));
+        // 新 schema：顶层无 version、含 systems[]、projects[] 不含 legacy 字段。
         expect(parsedIndex).toMatchObject({
-            version: 1,
             projects: [
                 {
                     projectName: 'versioned-project',
                     projectDir,
+                    mode: 'glue',
+                    stageCreateVersion: '0.0.4-alpha.0',
+                    requirements: [],
                 },
             ],
+            systems: [],
         });
+        expect(parsedIndex.version).toBeUndefined();
+        expect(parsedIndex.projects[0].envPath).toBeUndefined();
+        expect(parsedIndex.projects[0].knowledgeRoot).toBeUndefined();
+        expect(parsedIndex.projects[0].codeListPaths).toBeUndefined();
+        expect(parsedIndex.projects[0].stageContextPath).toBeUndefined();
+        // legacy 数据：旧版 index 不带 systems 字段，仍要可读（graceful read）。
         const legacyHomeDir = createTempDir('ep-stage-legacy-version');
         const legacyProjectDir = createTempDir('ep-stage-legacy-project');
         const legacyIndexDir = path.join(legacyHomeDir, '.ep-stage');
@@ -245,7 +273,7 @@ describe('stage context resolution', () => {
         mkdirSync(legacyIndexDir, { recursive: true });
         writeFileSync(path.join(legacyProjectDir, '.env'), 'LOGIN_USERNAME=demo-user\n');
         writeFileSync(path.join(legacyIndexDir, 'projects.index.json5'), `{
-        // legacy index without version
+        // legacy index without version / systems
         projects: [
           {
             projectName: 'legacy-project',
@@ -261,3 +289,107 @@ describe('stage context resolution', () => {
         }).context.projectName).toBe('legacy-project');
     });
 });
+describe('lookupProjectByRequirement (REQ-DATA-01)', () => {
+    it('returns null when projects.index.json5 is missing', () => {
+        const homeDir = createTempDir('ep-stage-lookup-missing');
+        // 不创建 ~/.ep-stage 目录
+        const result = lookupProjectByRequirement({
+            requirementPath: path.join(homeDir, 'no-such-requirement'),
+            homeDir,
+        });
+        expect(result).toBeNull();
+    });
+    it('matches when requirementPath exactly equals a requirement requirementDir', () => {
+        const homeDir = createTempDir('ep-stage-lookup-req');
+        const projectDir = createTempDir('ep-stage-lookup-projdir');
+        const requirementDir = path.join(projectDir, 'requirements', 'req-001');
+        const testsDir = path.join(projectDir, 'tests', 'req-001');
+        writeProjectIndex({
+            homeDir,
+            projects: [
+                {
+                    projectName: 'lookup-project',
+                    projectDir,
+                    mode: 'glue',
+                    stageCreateVersion: '0.0.4-alpha.0',
+                    requirements: [
+                        {
+                            name: 'req-001',
+                            requirementDir,
+                            testsDir,
+                        },
+                    ],
+                },
+            ],
+        });
+        const result = lookupProjectByRequirement({ requirementPath: requirementDir, homeDir });
+        expect(result).not.toBeNull();
+        expect(result?.projectName).toBe('lookup-project');
+        expect(result?.requirements[0]?.name).toBe('req-001');
+    });
+    it('matches when requirementPath exactly equals a requirement testsDir', () => {
+        const homeDir = createTempDir('ep-stage-lookup-tests');
+        const projectDir = createTempDir('ep-stage-lookup-projdir');
+        const requirementDir = path.join(projectDir, 'requirements', 'req-002');
+        const testsDir = path.join(projectDir, 'tests', 'req-002');
+        writeProjectIndex({
+            homeDir,
+            projects: [
+                {
+                    projectName: 'lookup-project',
+                    projectDir,
+                    mode: 'glue',
+                    stageCreateVersion: '0.0.4-alpha.0',
+                    requirements: [
+                        {
+                            name: 'req-002',
+                            requirementDir,
+                            testsDir,
+                        },
+                    ],
+                },
+            ],
+        });
+        const result = lookupProjectByRequirement({ requirementPath: testsDir, homeDir });
+        expect(result).not.toBeNull();
+        expect(result?.projectName).toBe('lookup-project');
+    });
+    it('matches when requirementPath exactly equals a project projectDir', () => {
+        const homeDir = createTempDir('ep-stage-lookup-pd');
+        const projectDir = createTempDir('ep-stage-lookup-projdir-only');
+        writeProjectIndex({
+            homeDir,
+            projects: [
+                {
+                    projectName: 'projdir-only',
+                    projectDir,
+                    mode: 'glue',
+                    stageCreateVersion: '0.0.4-alpha.0',
+                    requirements: [],
+                },
+            ],
+        });
+        const result = lookupProjectByRequirement({ requirementPath: projectDir, homeDir });
+        expect(result).not.toBeNull();
+        expect(result?.projectName).toBe('projdir-only');
+    });
+    it('returns null when no project matches', () => {
+        const homeDir = createTempDir('ep-stage-lookup-nomatch');
+        const projectDir = createTempDir('ep-stage-lookup-projdir');
+        writeProjectIndex({
+            homeDir,
+            projects: [
+                {
+                    projectName: 'unrelated-project',
+                    projectDir,
+                    mode: 'glue',
+                    stageCreateVersion: '0.0.4-alpha.0',
+                    requirements: [],
+                },
+            ],
+        });
+        const otherDir = createTempDir('ep-stage-lookup-other');
+        const result = lookupProjectByRequirement({ requirementPath: otherDir, homeDir });
+        expect(result).toBeNull();
+    });
+});

package/dist/test/util/credentials.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=credentials.test.d.ts.map

package/dist/test/util/credentials.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentials.test.d.ts","sourceRoot":"","sources":["../../../test/util/credentials.test.ts"],"names":[],"mappings":""}

package/dist/test/util/credentials.test.js

@@ -0,0 +1,64 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { loadCredentials } from '../../src/util/credentials.js';
+/**
+ * REQ-ENV-02 / REQ-ENV-03：从 <需求名>/credentials.json5 加载数组形态凭据。
+ *
+ * 不重复实现 schema 校验（已由 validateCredentials 覆盖），本测试关注 IO 行为：
+ * 文件读取、JSON5 解析、对校验器的组合调用，以及缺失场景的友好错误。
+ */
+describe('loadCredentials', () => {
+    let tmpDir;
+    let credPath;
+    beforeEach(() => {
+        tmpDir = mkdtempSync(path.join(os.tmpdir(), 'credentials-test-'));
+        credPath = path.join(tmpDir, 'credentials.json5');
+    });
+    afterEach(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('读合法数组形态凭据返回 Credential[]', () => {
+        writeFileSync(credPath, `[
+        // 普通账号
+        { url: 'https://demo.example.com', username: 'alice', password: 'p1', role: 'admin', systemName: '后台' },
+        { url: 'https://demo.example.com', username: 'bob', password: 'p2', role: 'user' },
+      ]`);
+        const list = loadCredentials(credPath);
+        expect(list).toHaveLength(2);
+        expect(list[0]).toMatchObject({
+            url: 'https://demo.example.com',
+            username: 'alice',
+            password: 'p1',
+            role: 'admin',
+            systemName: '后台',
+        });
+        expect(list[1]).toMatchObject({ username: 'bob', role: 'user' });
+        expect(list[1].systemName).toBeUndefined();
+    });
+    it('单条凭据无可选字段也能解析', () => {
+        writeFileSync(credPath, `[{ url: 'https://x.test', username: 'u', password: 'p' }]`);
+        const list = loadCredentials(credPath);
+        expect(list).toHaveLength(1);
+        expect(list[0].role).toBeUndefined();
+        expect(list[0].systemName).toBeUndefined();
+    });
+    it('缺必填字段 url 时抛 schema 错误（来自 validateCredentials）', () => {
+        writeFileSync(credPath, `[{ username: 'u', password: 'p' }]`);
+        expect(() => loadCredentials(credPath)).toThrow(/缺必填字段 url/);
+    });
+    it('顶层不是数组时抛 schema 错误', () => {
+        writeFileSync(credPath, `{ url: 'x', username: 'u', password: 'p' }`);
+        expect(() => loadCredentials(credPath)).toThrow(/顶层必须是数组/);
+    });
+    it('文件不存在时抛带路径的友好错误', () => {
+        const missing = path.join(tmpDir, 'not-here.json5');
+        expect(() => loadCredentials(missing)).toThrow(/credentials\.json5 不存在/);
+        expect(() => loadCredentials(missing)).toThrow(new RegExp(missing.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+    });
+    it('JSON5 语法错误时抛解析错误', () => {
+        writeFileSync(credPath, `[ { url: 'x', username: 'u', password: 'p' `); // 缺右括号
+        expect(() => loadCredentials(credPath)).toThrow();
+    });
+});

package/dist/test/util/i18n-testcase.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=i18n-testcase.test.d.ts.map

package/dist/test/util/i18n-testcase.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n-testcase.test.d.ts","sourceRoot":"","sources":["../../../test/util/i18n-testcase.test.ts"],"names":[],"mappings":""}

package/dist/test/util/i18n-testcase.test.js

@@ -0,0 +1,119 @@
+import { describe, it, expect } from 'vitest';
+import { i18nTestcase } from '../../src/util/i18n-testcase.js';
+/**
+ * REQ-UX-03：testcase.json5 英文字段名 / 状态值 → testcase.md 中文显示文案。
+ * 映射表见 spec §4.6。CLI 写 testcase.md 时调用本 util；testcase.json5 内部字段名永远英文。
+ *
+ * 说明：`unresolved` 在 spec 表中同时出现于「字段名」(未确认项) 和「状态值」(未解决)，
+ * 这是已知冲突；当前实现以扁平 lookup 表为准（后者覆盖前者），见 i18nTestcase 注释。
+ */
+describe('i18nTestcase', () => {
+    describe('审阅状态值', () => {
+        it('confirmed → 已确认', () => {
+            expect(i18nTestcase('confirmed')).toBe('已确认');
+        });
+        it('needs_review → 待审阅', () => {
+            expect(i18nTestcase('needs_review')).toBe('待审阅');
+        });
+        it('blocked → 已阻断', () => {
+            expect(i18nTestcase('blocked')).toBe('已阻断');
+        });
+        it('planned → 已计划', () => {
+            expect(i18nTestcase('planned')).toBe('已计划');
+        });
+        it('candidate → 候选', () => {
+            expect(i18nTestcase('candidate')).toBe('候选');
+        });
+        it('resolved → 已解决', () => {
+            expect(i18nTestcase('resolved')).toBe('已解决');
+        });
+    });
+    describe('推荐动作值', () => {
+        it('infer → 推理', () => {
+            expect(i18nTestcase('infer')).toBe('推理');
+        });
+        it('supplement-hints → 补充 hints', () => {
+            expect(i18nTestcase('supplement-hints')).toBe('补充 hints');
+        });
+        it('skip → 跳过', () => {
+            expect(i18nTestcase('skip')).toBe('跳过');
+        });
+    });
+    describe('场景值', () => {
+        it('crud.single-page → 单页 CRUD', () => {
+            expect(i18nTestcase('crud.single-page')).toBe('单页 CRUD');
+        });
+        it('crud.nested → 嵌套 CRUD', () => {
+            expect(i18nTestcase('crud.nested')).toBe('嵌套 CRUD');
+        });
+        it('statistic → 统计视图', () => {
+            expect(i18nTestcase('statistic')).toBe('统计视图');
+        });
+        it('approval → 审批流', () => {
+            expect(i18nTestcase('approval')).toBe('审批流');
+        });
+    });
+    describe('字段名', () => {
+        it('caseId → 用例 ID', () => {
+            expect(i18nTestcase('caseId')).toBe('用例 ID');
+        });
+        it('actionId → 动作 ID', () => {
+            expect(i18nTestcase('actionId')).toBe('动作 ID');
+        });
+        it('scenario → 场景类型', () => {
+            expect(i18nTestcase('scenario')).toBe('场景类型');
+        });
+        it('menuPath → 菜单路径', () => {
+            expect(i18nTestcase('menuPath')).toBe('菜单路径');
+        });
+        it('requiredRole → 操作角色', () => {
+            expect(i18nTestcase('requiredRole')).toBe('操作角色');
+        });
+        it('requiredSystems → 需求系统集', () => {
+            expect(i18nTestcase('requiredSystems')).toBe('需求系统集');
+        });
+        it('requiredRoles → 需求角色集', () => {
+            expect(i18nTestcase('requiredRoles')).toBe('需求角色集');
+        });
+        it('coveredActions → 骨架已命中动作', () => {
+            expect(i18nTestcase('coveredActions')).toBe('骨架已命中动作');
+        });
+        it('uncoveredCandidates → 骨架未命中候选', () => {
+            expect(i18nTestcase('uncoveredCandidates')).toBe('骨架未命中候选');
+        });
+        it('businessIntent → 业务意图', () => {
+            expect(i18nTestcase('businessIntent')).toBe('业务意图');
+        });
+        it('assertionExpectation → 预期断言', () => {
+            expect(i18nTestcase('assertionExpectation')).toBe('预期断言');
+        });
+        it('recommendedAction → 推荐动作', () => {
+            expect(i18nTestcase('recommendedAction')).toBe('推荐动作');
+        });
+        it('reviewStatus → 审阅状态', () => {
+            expect(i18nTestcase('reviewStatus')).toBe('审阅状态');
+        });
+        it('evidence → 证据', () => {
+            expect(i18nTestcase('evidence')).toBe('证据');
+        });
+    });
+    describe('未知值兜底', () => {
+        it('未知值原样返回', () => {
+            expect(i18nTestcase('some-unknown-value')).toBe('some-unknown-value');
+        });
+        it('空字符串原样返回', () => {
+            expect(i18nTestcase('')).toBe('');
+        });
+        it('英文字段名未在表中时原样返回', () => {
+            expect(i18nTestcase('createdAt')).toBe('createdAt');
+        });
+    });
+    describe('unresolved 冲突（已知 trade-off）', () => {
+        // spec §4.6 中 `unresolved` 同时是字段名（未确认项）和状态值（未解决）。
+        // 扁平 lookup 表无法同时持有两个映射，后定义的状态值覆盖字段名。
+        // 字段名场景下 CLI 可在调用前对 key 做硬编码标签替换；此 util 保留单值兜底。
+        it('unresolved → 未解决（状态值优先）', () => {
+            expect(i18nTestcase('unresolved')).toBe('未解决');
+        });
+    });
+});

package/dist/test/util/softlink.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=softlink.test.d.ts.map

package/dist/test/util/softlink.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"softlink.test.d.ts","sourceRoot":"","sources":["../../../test/util/softlink.test.ts"],"names":[],"mappings":""}