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

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":""}

package/dist/test/util/softlink.test.js

@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdtempSync, rmSync, writeFileSync, existsSync, readFileSync, lstatSync, mkdirSync, symlinkSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createSoftlinkWithFallback, softlinkFs } from '../../src/util/softlink.js';
+/**
+ * REQ-FILE-02：跨平台软链 fallback util
+ * 三档 fallback：symlink（macOS/Linux）→ hardlink → copy + 时间戳警示（Windows 无管理员权限）。
+ *
+ * 注：fallback 路径通过 softlinkFs.* spy 模拟失败；ESM namespace 不可写，
+ * 因此 softlink.ts 显式暴露 softlinkFs 对象供测试替换。
+ */
+describe('createSoftlinkWithFallback', () => {
+    let tmpDir;
+    let target;
+    let linkPath;
+    beforeEach(() => {
+        tmpDir = mkdtempSync(path.join(os.tmpdir(), 'softlink-test-'));
+        target = path.join(tmpDir, 'code_list.md');
+        linkPath = path.join(tmpDir, 'requirement', 'code_list.md');
+        writeFileSync(target, '# upstream code list\n');
+        mkdirSync(path.dirname(linkPath), { recursive: true });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('symlink 成功时返回 strategy=symlink，且链接指向 target', () => {
+        const result = createSoftlinkWithFallback(target, linkPath);
+        expect(result.strategy).toBe('symlink');
+        expect(result.warned).toBeUndefined();
+        expect(existsSync(linkPath)).toBe(true);
+        expect(lstatSync(linkPath).isSymbolicLink()).toBe(true);
+        // 通过链接读到的内容应该和源文件一致
+        expect(readFileSync(linkPath, 'utf8')).toBe('# upstream code list\n');
+    });
+    it('目标已存在时先 unlink 再创建（覆盖语义）', () => {
+        // 先放一个老文件占位
+        writeFileSync(linkPath, '# stale content\n');
+        const result = createSoftlinkWithFallback(target, linkPath);
+        expect(result.strategy).toBe('symlink');
+        expect(lstatSync(linkPath).isSymbolicLink()).toBe(true);
+        expect(readFileSync(linkPath, 'utf8')).toBe('# upstream code list\n');
+    });
+    it('目标已存在且为旧 symlink 时也能覆盖', () => {
+        // 先建一个指向别处的 symlink
+        const altTarget = path.join(tmpDir, 'alt.md');
+        writeFileSync(altTarget, '# alt\n');
+        symlinkSync(altTarget, linkPath, 'file');
+        expect(lstatSync(linkPath).isSymbolicLink()).toBe(true);
+        const result = createSoftlinkWithFallback(target, linkPath);
+        expect(result.strategy).toBe('symlink');
+        expect(readFileSync(linkPath, 'utf8')).toBe('# upstream code list\n');
+    });
+    it('symlink 失败时回退到 hardlink', () => {
+        // mock softlinkFs.symlinkSync 抛错，模拟 Windows 无权限
+        vi.spyOn(softlinkFs, 'symlinkSync').mockImplementation(() => {
+            throw new Error('EPERM: operation not permitted');
+        });
+        const result = createSoftlinkWithFallback(target, linkPath);
+        expect(result.strategy).toBe('hardlink');
+        expect(result.warned).toBeUndefined();
+        expect(existsSync(linkPath)).toBe(true);
+        expect(lstatSync(linkPath).isSymbolicLink()).toBe(false);
+        expect(readFileSync(linkPath, 'utf8')).toBe('# upstream code list\n');
+    });
+    it('symlink 与 hardlink 均失败时回退到 copy，并返回 warned=true', () => {
+        vi.spyOn(softlinkFs, 'symlinkSync').mockImplementation(() => {
+            throw new Error('EPERM: symlink not permitted');
+        });
+        vi.spyOn(softlinkFs, 'linkSync').mockImplementation(() => {
+            throw new Error('EXDEV: cross-device link not permitted');
+        });
+        const result = createSoftlinkWithFallback(target, linkPath);
+        expect(result.strategy).toBe('copy');
+        expect(result.warned).toBe(true);
+        expect(existsSync(linkPath)).toBe(true);
+        expect(lstatSync(linkPath).isSymbolicLink()).toBe(false);
+        // copy 的文件内容等于源文件
+        expect(readFileSync(linkPath, 'utf8')).toBe('# upstream code list\n');
+    });
+});

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

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

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

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

package/dist/test/validation/credentials.test.js

@@ -0,0 +1,72 @@
+import { describe, it, expect } from 'vitest';
+import { validateCredentials } from '../../src/validation/credentials.js';
+describe('validateCredentials', () => {
+    it('合法数组（≥1 条）通过', () => {
+        const result = validateCredentials([
+            {
+                url: 'http://example.test',
+                username: 'admin',
+                password: 'pwd',
+                role: '系统管理员',
+                systemName: '基础平台',
+            },
+        ]);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toMatchObject({
+            url: 'http://example.test',
+            username: 'admin',
+            password: 'pwd',
+            role: '系统管理员',
+            systemName: '基础平台',
+        });
+    });
+    it('允许无 role / systemName 的条目', () => {
+        const result = validateCredentials([
+            { url: 'http://example.test', username: 'admin', password: 'pwd' },
+        ]);
+        expect(result[0]).toEqual({
+            url: 'http://example.test',
+            username: 'admin',
+            password: 'pwd',
+        });
+        expect(result[0]).not.toHaveProperty('role');
+        expect(result[0]).not.toHaveProperty('systemName');
+    });
+    it('非数组报错', () => {
+        expect(() => validateCredentials({ url: 'x' })).toThrow(/数组/);
+    });
+    it('空数组报错', () => {
+        expect(() => validateCredentials([])).toThrow(/至少|1 条/);
+    });
+    it('条目缺 url 报错', () => {
+        expect(() => validateCredentials([{ username: 'admin', password: 'pwd' }])).toThrow(/url/);
+    });
+    it('条目缺 username 报错', () => {
+        expect(() => validateCredentials([{ url: 'http://example.test', password: 'pwd' }])).toThrow(/username/);
+    });
+    it('条目缺 password 报错', () => {
+        expect(() => validateCredentials([{ url: 'http://example.test', username: 'admin' }])).toThrow(/password/);
+    });
+    it('条目空字符串字段（空白）报错', () => {
+        expect(() => validateCredentials([{ url: '  ', username: 'admin', password: 'pwd' }])).toThrow(/url/);
+    });
+    it('同 (url, role) 重复报错', () => {
+        expect(() => validateCredentials([
+            { url: 'http://example.test', username: 'a', password: 'p1', role: '管理员' },
+            { url: 'http://example.test', username: 'b', password: 'p2', role: '管理员' },
+        ])).toThrow(/重复/);
+    });
+    it('同 url 但 role 不同允许', () => {
+        const result = validateCredentials([
+            { url: 'http://example.test', username: 'a', password: 'p1', role: '管理员' },
+            { url: 'http://example.test', username: 'b', password: 'p2', role: '业务员' },
+        ]);
+        expect(result).toHaveLength(2);
+    });
+    it('同 url 都没 role 视作 (url, "") 也会触发重复', () => {
+        expect(() => validateCredentials([
+            { url: 'http://example.test', username: 'a', password: 'p1' },
+            { url: 'http://example.test', username: 'b', password: 'p2' },
+        ])).toThrow(/重复/);
+    });
+});

package/dist/test/validation/projects-index.test.d.ts

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

package/dist/test/validation/projects-index.test.d.ts.map

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