@epoint-testtech/ep-stage-skill 0.0.9 → 0.5.0-alpha.2

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

@@ -0,0 +1,395 @@
+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/testcase-markdown.test.d.ts

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

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

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

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

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest';
+import { renderUnifiedTestcaseMarkdown } from '../../src/testcase/testcase-markdown.js';
+const testcase = {
+    schemaVersion: 'ep-stage-testcase/v1-draft',
+    testcaseId: 'zwplace-testcase',
+    contractRef: '.ep-stage/contract.json5',
+    scenario: 'crud_export',
+    moduleId: 'zwplace',
+    moduleName: '场所窗口信息管理',
+    cases: [
+        {
+            caseId: 'zwplace-placename-create',
+            title: '场所名称-新增',
+            generationStrategy: 'glue',
+            coverageStatus: 'covered',
+            reviewStatus: 'confirmed',
+            queryKey: '场所名称',
+            precondition: '使用业务管理员登录并进入目标页面',
+            steps: '新增、查询、编辑、删除',
+            assertion: '列表数据符合新增、编辑、删除结果',
+        },
+    ],
+    uncoveredCandidates: [
+        {
+            caseId: 'syncWindowSystem',
+            label: '同步窗口管理系统按钮',
+            generationStrategy: 'ai',
+            coverageStatus: 'gap',
+            requiredRole: '业务管理员',
+            businessIntent: '验证同步窗口管理系统按钮',
+            assertionExpectation: '点击后返回同步结果',
+            queryKey: '不适用',
+            precondition: '使用业务管理员登录并进入目标页面',
+            steps: '观察同步按钮并执行同步动作',
+            assertion: '页面返回同步结果',
+        },
+    ],
+};
+describe('renderUnifiedTestcaseMarkdown', () => {
+    it('把 glue 和 ai 用例渲染到同一张表，并用生成策略列区分', () => {
+        const markdown = renderUnifiedTestcaseMarkdown(testcase);
+        expect(markdown).toContain('| 用例 ID | 生成策略 | 用例标题 | 查询主键 | 前置条件 | 执行步骤 | 执行断言 |');
+        expect(markdown).toContain('| zwplace-placename-create | 胶水组装 | 场所名称-新增 |');
+        expect(markdown).toContain('| syncWindowSystem | AI 推理 | 同步窗口管理系统按钮 |');
+        expect(markdown).not.toContain('## 已覆盖用例');
+        expect(markdown).not.toContain('## 未覆盖候选');
+    });
+});

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

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

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

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