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

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

@@ -1,395 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import JSON5 from 'json5';
-import { describe, expect, it } from 'vitest';
-import { lookupProjectByRequirement, readStageContext, resolveStageContext, writeProjectIndex, } from '../src/index.js';
-/**
- * 创建隔离的临时目录，避免测试读写真实用户 HOME 或项目文件。
- *
- * @param prefix - 临时目录前缀。
- * @returns 生成后的临时目录绝对路径。
- */
-function createTempDir(prefix) {
-    return path.join(os.tmpdir(), `${prefix}-${crypto.randomUUID()}`);
-}
-describe('stage context resolution', () => {
-    it('parses explicit stage-context.md and normalizes relative env path', () => {
-        const projectDir = createTempDir('ep-stage-context');
-        mkdirSync(projectDir, { recursive: true });
-        const knowledgeRoot = path.join(projectDir, '..', 'knowledge-project');
-        const stageContextPath = path.join(projectDir, 'stage-context.md');
-        writeFileSync(stageContextPath, [
-            '---',
-            'projectName: demo-project',
-            'projectDir: .',
-            'mode: glue',
-            'envPath: .env',
-            'knowledgeRoot: ../knowledge-project',
-            'codeListPaths:',
-            '  - ../knowledge-project/_docs/code_list.md',
-            '---',
-            '',
-            '# demo-project',
-        ].join('\n'));
-        const context = readStageContext(stageContextPath);
-        expect(context).toMatchObject({
-            projectName: 'demo-project',
-            projectDir,
-            mode: 'glue',
-            envPath: '.env',
-            envFilePath: path.join(projectDir, '.env'),
-            knowledgeRoot: path.resolve(knowledgeRoot),
-            stageContextPath,
-            codeListPaths: [path.resolve(projectDir, '../knowledge-project/_docs/code_list.md')],
-        });
-    });
-    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');
-        const knowledgeRoot = createTempDir('ep-stage-knowledge');
-        const codeListPath = path.join(knowledgeRoot, '_docs', 'code_list.md');
-        mkdirSync(cwd, { recursive: true });
-        mkdirSync(projectDir, { recursive: true });
-        mkdirSync(path.dirname(codeListPath), { recursive: true });
-        writeFileSync(path.join(projectDir, '.env'), 'LOGIN_SYSTEM_URL=http://example.test/login\n');
-        writeFileSync(codeListPath, '# code list\n');
-        // 直接写 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,
-            homeDir,
-        });
-        expect(result.context).toMatchObject({
-            projectName: 'indexed-project',
-            projectDir,
-            mode: 'glue',
-            envFilePath: path.join(projectDir, '.env'),
-            knowledgeRoot,
-            codeListPaths: [codeListPath],
-        });
-        expect(result.trace).toMatchObject({
-            stage: 'context-resolution',
-            stageLabel: '项目上下文解析',
-            gate: { status: 'confirmed' },
-            reasoningSummary: {
-                conclusion: expect.stringContaining('projects.index.json5'),
-                needsHumanReview: false,
-            },
-        });
-    });
-    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');
-        const newKnowledgeRoot = path.join(projectDir, 'new knowledge');
-        const stageContextPath = path.join(projectDir, 'stage-context.md');
-        const codeListPath = path.join(newKnowledgeRoot, '_docs', 'code_list.md');
-        mkdirSync(path.dirname(codeListPath), { recursive: true });
-        writeFileSync(path.join(projectDir, 'actual.env'), 'LOGIN_USERNAME=demo-user\n');
-        writeFileSync(codeListPath, '# code list\n');
-        writeFileSync(stageContextPath, [
-            '---',
-            'projectName: context-project',
-            'projectDir: .',
-            'mode: glue',
-            'envPath: actual.env',
-            'knowledgeRoot: "new knowledge"',
-            'codeListPaths:',
-            '  - "new knowledge/_docs/code_list.md"',
-            '---',
-            '',
-            '# context-project',
-        ].join('\n'));
-        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,
-            homeDir,
-        });
-        expect(result.context).toMatchObject({
-            projectName: 'context-project',
-            envPath: 'actual.env',
-            envFilePath: path.join(projectDir, 'actual.env'),
-            knowledgeRoot: newKnowledgeRoot,
-            codeListPaths: [codeListPath],
-            stageContextPath,
-        });
-        expect(result.context.knowledgeRoot).not.toBe(oldKnowledgeRoot);
-        expect(result.trace.inputs).toContainEqual(expect.objectContaining({
-            kind: 'context_source',
-            path: path.join(homeDir, '.ep-stage', 'projects.index.json5'),
-        }));
-        expect(result.trace.outputs).toContainEqual(expect.objectContaining({
-            kind: 'stage_context',
-            path: stageContextPath,
-        }));
-    });
-    it('reads user project index with JSON5 comments and trailing commas', () => {
-        const homeDir = createTempDir('ep-stage-home-json5');
-        const projectDir = createTempDir('ep-stage-json5-project');
-        const codeListPath = path.join(projectDir, 'knowledge', '_docs', 'code_list.md');
-        const indexDir = path.join(homeDir, '.ep-stage');
-        mkdirSync(indexDir, { recursive: true });
-        mkdirSync(path.dirname(codeListPath), { recursive: true });
-        writeFileSync(path.join(projectDir, '.env'), 'LOGIN_USERNAME=demo-user\n');
-        writeFileSync(codeListPath, '# code list\n');
-        writeFileSync(path.join(indexDir, 'projects.index.json5'), `{
-        // 用户可编辑索引允许注释
-        projects: [
-          {
-            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,
-            codeListPath,
-            homeDir,
-        });
-        expect(result.context.projectName).toBe('json5-project');
-        expect(result.context.envFilePath).toBe(path.join(projectDir, '.env'));
-        expect(result.trace.reasoningSummary?.evidenceChain[0]).toMatchObject({
-            source: 'human',
-            path: path.join(indexDir, 'projects.index.json5'),
-        });
-    });
-    it('creates a debug stage context from explicit projectDir when no context or index exists', () => {
-        const homeDir = createTempDir('ep-stage-home-debug');
-        const projectDir = createTempDir('ep-stage-debug-project');
-        const codeListPath = path.join(projectDir, 'knowledge', '_docs', 'code_list.md');
-        mkdirSync(path.dirname(codeListPath), { recursive: true });
-        writeFileSync(codeListPath, '# code list\n');
-        const result = resolveStageContext({
-            projectDir,
-            codeListPath,
-            homeDir,
-        });
-        expect(result.context).toMatchObject({
-            projectName: path.basename(projectDir),
-            projectDir,
-            mode: 'glue',
-            envPath: '.env',
-            envFilePath: path.join(projectDir, '.env'),
-            codeListPaths: [codeListPath],
-        });
-        expect(result.trace).toMatchObject({
-            gate: { status: 'needs_review' },
-            reasoningSummary: {
-                conclusion: expect.stringContaining('显式 --project-dir'),
-                needsHumanReview: true,
-            },
-        });
-    });
-    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 });
-        const indexPath = writeProjectIndex({
-            homeDir,
-            projects: [
-                {
-                    projectName: 'versioned-project',
-                    projectDir,
-                    mode: 'glue',
-                    stageCreateVersion: '0.0.4-alpha.0',
-                    requirements: [],
-                },
-            ],
-        });
-        const parsedIndex = JSON5.parse(readFileSync(indexPath, 'utf8'));
-        // 新 schema：顶层无 version、含 systems[]、projects[] 不含 legacy 字段。
-        expect(parsedIndex).toMatchObject({
-            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');
-        mkdirSync(legacyProjectDir, { recursive: true });
-        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 / systems
-        projects: [
-          {
-            projectName: 'legacy-project',
-            projectDir: '${legacyProjectDir}',
-            mode: 'glue',
-            envPath: '.env',
-          },
-        ],
-      }`);
-        expect(resolveStageContext({
-            projectDir: legacyProjectDir,
-            homeDir: legacyHomeDir,
-        }).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/testcase-generator.test.d.ts

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

package/dist/test/testcase-generator.test.d.ts.map

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

package/dist/test/testcase-generator.test.js

@@ -1,276 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { generateGlueTestcases } from '../src/index.js';
-/**
- * 构造用例生成器测试所需的最小 CRUD 契约。
- *
- * @returns 包含完整 CRUD 流程槽位的测试契约。
- */
-function createCrudContract() {
-    return {
-        contractVersion: 'crud-business-module/v1',
-        module: {
-            id: 'zwplace',
-            label: '场所窗口信息管理',
-        },
-        pages: {
-            list: {
-                role: 'list',
-                pageId: 'gxhzwplacelist',
-                title: '场所窗口信息列表',
-                iframeSrcKeyword: 'gxhzwplacelist',
-                fields: [],
-                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: [],
-    };
-}
-/**
- * 构造用例生成器测试所需的 coverage diff trace。
- *
- * @returns 默认无未确认项的 coverage diff。
- */
-function createCoverageDiff() {
-    return {
-        moduleId: 'zwplace',
-        skeletonCoverageId: 'crud-plus-export/v1',
-        covered: [
-            {
-                actionId: 'zwplace.list.create',
-                label: '新增场所信息管理',
-                pageId: 'gxhzwplacelist',
-                status: 'covered',
-                reason: '动作标签已被当前骨架能力覆盖。',
-            },
-        ],
-        partiallyCovered: [],
-        gapCandidates: [],
-        unresolved: [],
-        nestedCrudCandidates: [],
-        baseline: { plannedWorkflows: [], candidateWorkflows: [], unresolvedWorkflows: [] },
-        comparison: { both: [], onlyBaseline: [], onlyGeneralized: [] },
-        reasoningSummary: {
-            conclusion: 'CRUD 单页能力已覆盖。',
-            evidenceChain: [],
-            alternatives: ['crud.single-page'],
-            confidence: 'medium',
-            risks: [],
-            needsHumanReview: false,
-        },
-    };
-}
-/**
- * 胶水测试用例生成器测试。
- *
- * 验证 generateGlueTestcases 能从同一份 CRUD contract、已确认场景与 coverage diff
- * 生成可审阅 JSON + Markdown。
- */
-describe('glue testcase generator', () => {
-    it('renders reviewable markdown and json cases from a confirmed scenario and contract', () => {
-        const output = generateGlueTestcases({
-            contract: createCrudContract(),
-            menu: '场所窗口信息管理>场所窗口信息列表',
-            scenarios: ['crud.single-page', 'crud.nested'],
-            confirmedScenarios: ['crud.single-page'],
-            coverageDiff: createCoverageDiff(),
-        });
-        expect(output.json.cases).toHaveLength(4);
-        expect(output.json.cases.map((item) => item.caseId)).toEqual([
-            'zwplace.create',
-            'zwplace.read',
-            'zwplace.update',
-            'zwplace.delete',
-        ]);
-        expect(output.json.cases[0]).toMatchObject({
-            caseId: 'zwplace.create',
-            reviewStatus: 'confirmed',
-        });
-        expect(output.json.cases[0]?.evidence).toContain('skeleton=crud.skeleton-testcase/v1');
-        expect(output.markdown).toContain('| TC-CRUD-001 |');
-        expect(output.markdown).toContain('查询字段：窗口名称');
-        expect(output.markdown).not.toContain('{{');
-    });
-    it('requires contract and menu instead of free-form module fields', () => {
-        expect(() => generateGlueTestcases({
-            moduleId: 'zwplace',
-            moduleName: '场所窗口信息管理',
-            scenarioStatus: 'confirmed',
-            scenarios: ['crud.single-page'],
-            confirmedScenarios: ['crud.single-page'],
-            coverageDiff: createCoverageDiff(),
-        })).toThrow('生成胶水测试用例必须提供 contract 和 menu');
-    });
-    it('keeps testcase gate in needs_review when coverage diff has unresolved items', () => {
-        const coverageDiff = createCoverageDiff();
-        coverageDiff.unresolved = [
-            {
-                actionId: 'zwplace.list.export',
-                label: '导出',
-                pageId: 'gxhzwplacelist',
-                status: 'unresolved',
-                reason: '导出动作是否纳入本轮 CRUD 用例需要人工确认。',
-            },
-        ];
-        const output = generateGlueTestcases({
-            contract: createCrudContract(),
-            menu: '场所窗口信息管理>场所窗口信息列表',
-            scenarios: ['crud.single-page'],
-            confirmedScenarios: ['crud.single-page'],
-            coverageDiff,
-        });
-        expect(output.json.cases.every((item) => item.reviewStatus === 'needs_review')).toBe(true);
-        expect(output.json.cases[0]?.unresolved).toEqual([
-            'coverageDiff.unresolved: 导出动作是否纳入本轮 CRUD 用例需要人工确认。',
-        ]);
-        expect(output.json.reasoningSummary.risks).toContain('coverageDiff.unresolved: 导出动作是否纳入本轮 CRUD 用例需要人工确认。');
-        expect(output.json.reasoningSummary.evidenceChain).toContainEqual({
-            source: 'human',
-            path: 'testcase-generation.json',
-            text: 'unresolved=coverageDiff.unresolved: 导出动作是否纳入本轮 CRUD 用例需要人工确认。',
-        });
-    });
-    it('renders nested CRUD candidates with the CRUD testcase skeleton and unresolved gate', () => {
-        const coverageDiff = createCoverageDiff();
-        coverageDiff.nestedCrudCandidates = [
-            {
-                pageId: 'gxhzwplaceadd',
-                evidence: ['弹窗页面中存在 mini-datagrid', '按钮 添加窗口'],
-                supportedActions: ['create', 'delete'],
-                unresolvedReason: '子表保存后断言需要人工确认',
-            },
-        ];
-        const output = generateGlueTestcases({
-            contract: createCrudContract(),
-            menu: '场所窗口信息管理>场所窗口信息列表',
-            scenarios: ['crud.nested'],
-            confirmedScenarios: ['crud.nested'],
-            coverageDiff,
-        });
-        expect(output.json.cases[0]).toMatchObject({
-            scenario: 'crud.nested',
-            reviewStatus: 'needs_review',
-            unresolved: ['coverageDiff.nestedCrudCandidates[gxhzwplaceadd]: 子表保存后断言需要人工确认'],
-        });
-        expect(output.json.cases[0]?.evidence).toContain('skeleton=crud.skeleton-testcase/v1');
-        expect(output.markdown).toContain('| TC-CRUD-001 |');
-        expect(output.markdown).not.toContain('{{');
-    });
-    it('does not let nested CRUD candidates block a confirmed crud.single-page scenario', () => {
-        const coverageDiff = createCoverageDiff();
-        coverageDiff.nestedCrudCandidates = [
-            {
-                pageId: 'gxhzwplaceadd',
-                evidence: ['弹窗页面中存在 mini-datagrid', '按钮 添加窗口'],
-                supportedActions: ['create', 'delete'],
-                unresolvedReason: '子表保存后断言需要人工确认',
-            },
-        ];
-        const output = generateGlueTestcases({
-            contract: createCrudContract(),
-            menu: '场所窗口信息管理>场所窗口信息列表',
-            scenarios: ['crud.single-page', 'crud.nested'],
-            confirmedScenarios: ['crud.single-page'],
-            coverageDiff,
-        });
-        expect(output.json.cases.every((item) => item.reviewStatus === 'confirmed')).toBe(true);
-        expect(output.json.cases[0]?.unresolved).toEqual([]);
-        expect(output.json.reasoningSummary.needsHumanReview).toBe(false);
-        expect(output.json.reasoningSummary.risks).toEqual([]);
-    });
-    it('surfaces inferred menu candidates in testcase unresolved output for human review', () => {
-        const output = generateGlueTestcases({
-            contract: createCrudContract(),
-            menu: '未确认菜单路径',
-            menuReviewHint: 'menu.candidate: 场所窗口信息管理>场所窗口信息列表 | 场所窗口信息列表',
-            scenarios: ['crud.single-page'],
-            confirmedScenarios: ['crud.single-page'],
-            coverageDiff: createCoverageDiff(),
-        });
-        expect(output.json.cases[0]?.unresolved).toContain('menu.candidate: 场所窗口信息管理>场所窗口信息列表 | 场所窗口信息列表');
-        expect(output.markdown).toContain('menu.candidate: 场所窗口信息管理>场所窗口信息列表 | 场所窗口信息列表');
-    });
-});

package/dist/test/testcase-skeleton.test.d.ts

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

package/dist/test/testcase-skeleton.test.d.ts.map

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