@liuhange/dsh-gov-data-inspector 3.1.1 → 3.1.2

package/lib/__tests__/errorDetailBuilder.test.js

@@ -0,0 +1,91 @@
+import { describe, it, expect } from 'vitest';
+import { ErrorDetailBuilder } from '../errorDetailBuilder.js';
+describe('ErrorDetailBuilder', () => {
+    it('传入六字段均非空且errorType合法 → 返回ErrorDetail对象', () => {
+        const detail = ErrorDetailBuilder.build({
+            guideId: 'guide1',
+            field: '办理时限',
+            errorType: 'semantic',
+            description: '办理时限超出法定上限',
+            suggestion: '建议调整为20个工作日以内',
+        });
+        expect(detail.guideId).toBe('guide1');
+        expect(detail.field).toBe('办理时限');
+        expect(detail.errorType).toBe('semantic');
+        expect(detail.severity).toBe('critical');
+        expect(detail.description).toBe('办理时限超出法定上限');
+        expect(detail.suggestion).toBe('建议调整为20个工作日以内');
+    });
+    it('传入任一字段为空 → 抛出错误', () => {
+        expect(() => ErrorDetailBuilder.build({
+            guideId: '',
+            field: '办理时限',
+            errorType: 'semantic',
+            description: 'desc',
+            suggestion: 'sug',
+        })).toThrow();
+        expect(() => ErrorDetailBuilder.build({
+            guideId: 'g1',
+            field: '',
+            errorType: 'semantic',
+            description: 'desc',
+            suggestion: 'sug',
+        })).toThrow();
+    });
+    it('errorType不合法 → 抛出错误', () => {
+        expect(() => ErrorDetailBuilder.build({
+            guideId: 'g1',
+            field: 'f',
+            errorType: 'invalid',
+            description: 'd',
+            suggestion: 's',
+        })).toThrow();
+    });
+    it('severity未传入时从severityMapping读取映射', () => {
+        const detail = ErrorDetailBuilder.build({
+            guideId: 'g1',
+            field: 'f',
+            errorType: 'missing',
+            description: 'd',
+            suggestion: 's',
+        }, { missing: 'major', semantic: 'critical', logical: 'critical' });
+        expect(detail.severity).toBe('major');
+    });
+    it('传入dataSource与standardClause → 返回的ErrorDetail含该两字段', () => {
+        const detail = ErrorDetailBuilder.build({
+            guideId: 'g1',
+            field: 'f',
+            errorType: 'semantic',
+            description: 'd',
+            suggestion: 's',
+            dataSource: 'national',
+            standardClause: '行政许可法第四十二条',
+        });
+        expect(detail.dataSource).toBe('national');
+        expect(detail.standardClause).toBe('行政许可法第四十二条');
+    });
+    it('未传入追溯字段 → 返回的ErrorDetail不含该两字段', () => {
+        const detail = ErrorDetailBuilder.build({
+            guideId: 'g1',
+            field: 'f',
+            errorType: 'semantic',
+            description: 'd',
+            suggestion: 's',
+        });
+        expect(detail.dataSource).toBeUndefined();
+        expect(detail.standardClause).toBeUndefined();
+    });
+    it('countByType返回值与明细条目数一致', () => {
+        const details = [
+            { guideId: 'g1', field: 'f1', errorType: 'missing', severity: 'major', description: 'd', suggestion: 's' },
+            { guideId: 'g1', field: 'f2', errorType: 'missing', severity: 'major', description: 'd', suggestion: 's' },
+            { guideId: 'g1', field: 'f3', errorType: 'semantic', severity: 'critical', description: 'd', suggestion: 's' },
+            { guideId: 'g1', field: 'f4', errorType: 'logical', severity: 'critical', description: 'd', suggestion: 's' },
+        ];
+        const counts = ErrorDetailBuilder.countByType(details);
+        expect(counts.missing).toBe(2);
+        expect(counts.semantic).toBe(1);
+        expect(counts.logical).toBe(1);
+    });
+});
+//# sourceMappingURL=errorDetailBuilder.test.js.map

package/lib/__tests__/formatValidator.test.js

@@ -0,0 +1,35 @@
+import { describe, it, expect } from 'vitest';
+import { FormatValidator } from '../formatValidator.js';
+const formatRules = [
+    { field: '办理时限', pattern: '^\\d+个工作日$', suggestionTemplate: '应使用"X个工作日"格式' },
+    { field: '咨询电话', pattern: '^(\\d{3,4}-)?\\d{7,8}$', suggestionTemplate: '应使用"区号-号码"格式' },
+    { field: '收费标准', requiredKeywords: ['不收费', '收费依据'], suggestionTemplate: '应注明"不收费"或"金额+收费依据"' },
+    { field: '办理地点', requiredKeywords: ['街道', '路', '号', '室', '楼', '层', '栋'], suggestionTemplate: '应包含具体地址信息' },
+];
+describe('FormatValidator', () => {
+    it('时限为"大约两周" → 输出格式不规范提示', () => {
+        const issues = FormatValidator.validate({ 办理时限: '大约两周' }, 'g1', formatRules);
+        expect(issues.some((i) => i.field === '办理时限')).toBe(true);
+    });
+    it('咨询电话为"请联系前台" → 输出格式不规范提示', () => {
+        const issues = FormatValidator.validate({ 咨询电话: '请联系前台' }, 'g1', formatRules);
+        expect(issues.some((i) => i.field === '咨询电话')).toBe(true);
+    });
+    it('收费标准为"按实际情况收取" → 输出格式不规范提示', () => {
+        const issues = FormatValidator.validate({ 收费标准: '按实际情况收取' }, 'g1', formatRules);
+        expect(issues.some((i) => i.field === '收费标准')).toBe(true);
+    });
+    it('办理地点为"政务大厅" → 输出格式不规范提示', () => {
+        const issues = FormatValidator.validate({ 办理地点: '政务大厅' }, 'g1', formatRules);
+        expect(issues.some((i) => i.field === '办理地点')).toBe(true);
+    });
+    it('时限格式正确 → 无格式问题', () => {
+        const issues = FormatValidator.validate({ 办理时限: '20个工作日' }, 'g1', formatRules);
+        expect(issues.some((i) => i.field === '办理时限')).toBe(false);
+    });
+    it('formatRules配置缺失 → 返回空数组', () => {
+        const issues = FormatValidator.validate({ 办理时限: 'abc' }, 'g1', undefined);
+        expect(issues.length).toBe(0);
+    });
+});
+//# sourceMappingURL=formatValidator.test.js.map

package/lib/__tests__/govData.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-describe('gov-data-inspector', () => {
+describe('gov-data-inspector 回归测试', () => {
     it('导出name/inject/apply', async () => {
         const mod = await import('../index.js');
         expect(mod.name).toBe('@liuhange/dsh-gov-data-inspector');
@@ -14,5 +14,13 @@ describe('gov-data-inspector', () => {
         expect(tool.name).toBe('inspect_gov_data');
         expect(tool.description).toContain('政务');
     });
+    it('工具参数保持dataSource+inspectionMode兼容', async () => {
+        const mod = await import('../index.js');
+        const tools = [];
+        mod.apply({ tools: { register: (t) => tools.push(t) } });
+        const tool = tools[0];
+        expect(tool.parameters.properties.dataSource).toBeDefined();
+        expect(tool.parameters.properties.inspectionMode).toBeDefined();
+    });
 });
 //# sourceMappingURL=govData.test.js.map

package/lib/__tests__/inspectionOrchestrator.test.js

@@ -0,0 +1,125 @@
+import { describe, it, expect } from 'vitest';
+import { InspectionOrchestrator } from '../inspectionOrchestrator.js';
+const kb = {
+    timeLimits: [
+        { itemType: '行政许可', legalUpperLimit: 20, legalLowerLimit: 1, basisClause: '行政许可法第四十二条', dataSource: 'national', standardClause: '行政许可法第四十二条' },
+        { itemType: '现场勘查类', legalUpperLimit: 45, legalLowerLimit: 5, basisClause: '依据DB1405/T 085-2025', dataSource: 'national', standardClause: 'DB1405/T 085-2025 第5.2条' },
+    ],
+    materials: [
+        { itemType: '行政许可', standardName: '营业执照复印件', isRequired: true, basisClause: '依据DB1405/T 085-2025', dataSource: 'national', standardClause: 'DB1405/T 085-2025 第6.1条' },
+        { itemType: '行政许可', standardName: '行政许可申请表', isRequired: true, basisClause: '依据DB1405/T 085-2025', dataSource: 'national', standardClause: 'DB1405/T 085-2025 第6.2条' },
+    ],
+    conditions: [
+        { itemType: '行政许可', elementName: '申请主体资格', standardValue: '符合法定条件', basisClause: '行政许可法第十二条', dataSource: 'national', standardClause: '行政许可法第十二条' },
+    ],
+    dataSourceStatus: {
+        national: { status: 'success', fetchedAt: '2026-09-26T00:00:00Z', recordCount: 5 },
+        provincial: { status: 'success', fetchedAt: '2026-09-26T00:00:00Z', recordCount: 3 },
+        standard: { status: 'success', fetchedAt: '2026-09-26T00:00:00Z', recordCount: 4 },
+    },
+};
+const standardRules = [
+    { ruleId: 'LOG_SITE_INSPECTION_001', standardClause: 'DB1405/T 085-2025 第5.2条', triggerFields: ['办理流程', '办理时限'], condition: '现场勘查且时限<5', threshold: 5, suggestionTemplate: '建议调整', triggerKeywords: ['现场勘查'] },
+    { ruleId: 'LOG_INSTANT_HANDLE_001', standardClause: 'DB1405/T 085-2025 第5.3条', triggerFields: ['办理流程', '办理时限'], condition: '当场办理且时限>1', threshold: 1, suggestionTemplate: '建议调整', triggerKeywords: ['当场办理'] },
+    { ruleId: 'LOG_CONDITION_PROXY_001', standardClause: 'DB1405/T 085-2025 第5.4条', triggerFields: ['办理条件', '办理流程'], condition: '本人到场但允许代办', suggestionTemplate: '建议统一', threshold: undefined, triggerKeywords: ['本人到场', '本人办理', '代办', '委托办理'] },
+    { ruleId: 'LOG_MATERIAL_CONDITION_001', standardClause: 'DB1405/T 085-2025 第5.5条', triggerFields: ['申请材料', '办理条件'], condition: '材料与条件不匹配', suggestionTemplate: '建议补充', threshold: undefined, triggerKeywords: ['收入证明', '产权证明', '资质证明', '无犯罪记录证明', '健康证明', '社保证明', '纳税证明'] },
+];
+const formatRules = [
+    { field: '办理时限', pattern: '^\\d+个工作日$', suggestionTemplate: '应使用X个工作日格式' },
+    { field: '咨询电话', pattern: '^(\\d{3,4}-)?\\d{7,8}$', suggestionTemplate: '应使用区号-号码格式' },
+    { field: '收费标准', requiredKeywords: ['不收费', '收费依据'], suggestionTemplate: '应注明不收费或收费依据' },
+    { field: '办理地点', requiredKeywords: ['街道', '路', '号', '室', '楼', '层', '栋'], suggestionTemplate: '应含具体地址' },
+];
+const config = {
+    guideRequiredElements: [
+        '事项名称', '实施主体', '办理条件', '申请材料', '办理流程', '办理时限',
+        '收费标准', '办理地点', '咨询电话', '监督电话', '办理时间', '网上办理深度',
+        '表格下载', '结果送达方式',
+    ],
+    formatRules,
+    severityMapping: { missing: 'major', semantic: 'critical', logical: 'critical' },
+    scoreWeights: { completeness: 0.3, accuracy: 0.4, traceability: 0.3 },
+    convenienceWeights: { timeLimit: 0.3, onlineCapable: 0.4, materialConcise: 0.3 },
+    itemTypeMatching: {
+        行政许可: { keywords: ['许可', '审批', '核准'], codePrefix: 'XK' },
+        现场勘查类: { keywords: ['现场勘查', '实地核查'], codePrefix: 'XC' },
+    },
+    materialConciseThreshold: 5,
+    missingFieldStandardClause: 'DB1405/T 085-2025 第4.1条',
+};
+function makeCompleteGuide(overrides = {}) {
+    return {
+        事项名称: '食品经营许可',
+        实施主体: '市场监管局',
+        办理条件: '符合法定条件的公民、法人或其他组织',
+        申请材料: '营业执照复印件、行政许可申请表',
+        办理流程: '受理→审查→决定',
+        办理时限: '20个工作日',
+        收费标准: '不收费',
+        办理地点: '某市某区某路1号',
+        咨询电话: '010-12345678',
+        监督电话: '010-87654321',
+        办理时间: '工作日上午9-12点',
+        网上办理深度: '全流程网办',
+        表格下载: '可下载',
+        结果送达方式: '邮寄',
+        ...overrides,
+    };
+}
+describe('InspectionOrchestrator 集成测试', () => {
+    it('传入完整办事指南 → 五步编排返回完整五维报告', () => {
+        const data = [makeCompleteGuide()];
+        const result = InspectionOrchestrator.orchestrate(data, config, kb, standardRules);
+        expect(result.totalGuidesChecked).toBe(1);
+        expect(result.completeness).toBe(100);
+        expect(result.missingFields).toBe(0);
+        expect(result.errorDetails).toBeDefined();
+        expect(result.formatIssues).toBeDefined();
+        expect(result.detectionRates).toBeDefined();
+        expect(result.detectionRates.overallScore).toBeGreaterThanOrEqual(0);
+    });
+    it('传入含漏项/语义错误/逻辑错误的指南 → 三类计数独立且与明细一致', () => {
+        const data = [
+            makeCompleteGuide({
+                咨询电话: undefined,
+                办理时限: '90个工作日',
+                办理流程: '当场办理',
+            }),
+        ];
+        const result = InspectionOrchestrator.orchestrate(data, config, kb, standardRules);
+        expect(result.missingFields).toBeGreaterThan(0);
+        expect(result.semanticErrors).toBeGreaterThan(0);
+        expect(result.logicalErrors).toBeGreaterThan(0);
+        const missingCount = result.errorDetails.filter((d) => d.errorType === 'missing').length;
+        const semanticCount = result.errorDetails.filter((d) => d.errorType === 'semantic').length;
+        const logicalCount = result.errorDetails.filter((d) => d.errorType === 'logical').length;
+        expect(missingCount).toBe(result.missingFields);
+        expect(semanticCount).toBe(result.semanticErrors);
+        expect(logicalCount).toBe(result.logicalErrors);
+    });
+    it('data.length===0 → completeness为0', () => {
+        const result = InspectionOrchestrator.orchestrate([], config, kb, standardRules);
+        expect(result.completeness).toBe(0);
+        expect(result.totalGuidesChecked).toBe(0);
+    });
+    it('错误明细表中每条errorType属于missing/semantic/logical之一', () => {
+        const data = [
+            makeCompleteGuide({ 咨询电话: undefined, 办理时限: '90个工作日', 办理流程: '当场办理' }),
+        ];
+        const result = InspectionOrchestrator.orchestrate(data, config, kb, standardRules);
+        for (const d of result.errorDetails) {
+            expect(['missing', 'semantic', 'logical']).toContain(d.errorType);
+        }
+    });
+    it('错误明细六字段均非空', () => {
+        const data = [makeCompleteGuide({ 咨询电话: undefined })];
+        const result = InspectionOrchestrator.orchestrate(data, config, kb, standardRules);
+        for (const d of result.errorDetails) {
+            expect(d.guideId).toBeTruthy();
+            expect(d.field).toBeTruthy();
+            expect(d.description).toBeTruthy();
+            expect(d.suggestion).toBeTruthy();
+        }
+    });
+});
+//# sourceMappingURL=inspectionOrchestrator.test.js.map

package/lib/__tests__/logicRuleEngine.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect } from 'vitest';
+import { LogicRuleEngine } from '../logicRuleEngine.js';
+const rules = [
+    { ruleId: 'LOG_SITE_INSPECTION_001', standardClause: 'DB1405/T 085-2025 第5.2条', triggerFields: ['办理流程', '办理时限'], condition: '流程含现场勘查且时限<5', threshold: 5, suggestionTemplate: '建议调整', triggerKeywords: ['现场勘查'] },
+    { ruleId: 'LOG_INSTANT_HANDLE_001', standardClause: 'DB1405/T 085-2025 第5.3条', triggerFields: ['办理流程', '办理时限'], condition: '流程含当场办理且时限>1', threshold: 1, suggestionTemplate: '建议调整', triggerKeywords: ['当场办理'] },
+    { ruleId: 'LOG_CONDITION_PROXY_001', standardClause: 'DB1405/T 085-2025 第5.4条', triggerFields: ['办理条件', '办理流程'], condition: '条件要求本人到场但流程允许代办', suggestionTemplate: '建议统一', threshold: undefined, triggerKeywords: ['本人到场', '本人办理', '代办', '委托办理'] },
+    { ruleId: 'LOG_MATERIAL_CONDITION_001', standardClause: 'DB1405/T 085-2025 第5.5条', triggerFields: ['申请材料', '办理条件'], condition: '条件要求的证明材料未列入材料清单', suggestionTemplate: '建议补充', threshold: undefined, triggerKeywords: ['收入证明', '产权证明', '资质证明', '无犯罪记录证明', '健康证明', '社保证明', '纳税证明'] },
+];
+describe('LogicRuleEngine', () => {
+    it('流程含"现场勘查"且时限为"3个工作日" → 输出logical错误', () => {
+        const guide = { 办理流程: '受理→现场勘查→审批', 办理时限: '3个工作日' };
+        const details = LogicRuleEngine.detect(guide, 'g1', rules);
+        expect(details.some((d) => d.errorType === 'logical' && d.description.includes('现场勘查'))).toBe(true);
+    });
+    it('流程含"当场办理"且时限为"90个工作日" → 输出logical错误', () => {
+        const guide = { 办理流程: '当场办理', 办理时限: '90个工作日' };
+        const details = LogicRuleEngine.detect(guide, 'g1', rules);
+        expect(details.some((d) => d.errorType === 'logical' && d.description.includes('当场办理'))).toBe(true);
+    });
+    it('条件要求"本人到场"但流程允许代办 → 输出logical错误', () => {
+        const guide = { 办理条件: '需本人到场办理', 办理流程: '可代办' };
+        const details = LogicRuleEngine.detect(guide, 'g1', rules);
+        expect(details.some((d) => d.errorType === 'logical' && d.description.includes('本人到场'))).toBe(true);
+    });
+    it('条件要求"提供收入证明"但材料清单未含 → 输出logical错误', () => {
+        const guide = { 办理条件: '需提供收入证明', 申请材料: '身份证、申请表' };
+        const details = LogicRuleEngine.detect(guide, 'g1', rules);
+        expect(details.some((d) => d.errorType === 'logical' && d.description.includes('收入证明'))).toBe(true);
+    });
+    it('logicErrorRules配置缺失 → 抛出错误', () => {
+        expect(() => LogicRuleEngine.detect({}, 'g1', [])).toThrow();
+    });
+    it('字段缺失时跳过规则不报错', () => {
+        const guide = { 事项名称: '测试' };
+        const details = LogicRuleEngine.detect(guide, 'g1', rules);
+        expect(details.length).toBe(0);
+    });
+});
+//# sourceMappingURL=logicRuleEngine.test.js.map

package/lib/__tests__/missingFieldDetector.test.js

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { MissingFieldDetector } from '../missingFieldDetector.js';
+const requiredElements = [
+    '事项名称', '实施主体', '办理条件', '申请材料', '办理流程', '办理时限',
+    '收费标准', '办理地点', '咨询电话', '监督电话', '办理时间', '网上办理深度',
+    '表格下载', '结果送达方式',
+];
+describe('MissingFieldDetector', () => {
+    it('缺失"咨询电话"字段 → 返回errorType=missing的明细', () => {
+        const guide = {
+            事项名称: '测试事项',
+            实施主体: '测试部门',
+            办理条件: '条件',
+            申请材料: '材料',
+            办理流程: '流程',
+            办理时限: '20个工作日',
+            收费标准: '不收费',
+            办理地点: '某地址',
+            监督电话: '12345678',
+            办理时间: '工作日',
+            网上办理深度: '可网办',
+            表格下载: '可下载',
+            结果送达方式: '邮寄',
+        };
+        const details = MissingFieldDetector.detect(guide, 'g1', requiredElements, undefined, undefined, 'DB1405/T 085-2025 第4.1条');
+        const missingPhone = details.find((d) => d.field === '咨询电话');
+        expect(missingPhone).toBeDefined();
+        expect(missingPhone.errorType).toBe('missing');
+        expect(missingPhone.dataSource).toBe('standard');
+        expect(missingPhone.standardClause).toBe('DB1405/T 085-2025 第4.1条');
+    });
+    it('字段值为空字符串 → 判定为漏项', () => {
+        const guide = { 事项名称: '测试', 咨询电话: '  ' };
+        const details = MissingFieldDetector.detect(guide, 'g1', ['咨询电话'], undefined, undefined, 'DB1405/T 085-2025 第4.1条');
+        expect(details.length).toBe(1);
+        expect(details[0].errorType).toBe('missing');
+        expect(details[0].dataSource).toBe('standard');
+    });
+    it('字段齐备的指南 → 返回空数组', () => {
+        const guide = {};
+        for (const elem of requiredElements)
+            guide[elem] = '有值';
+        const details = MissingFieldDetector.detect(guide, 'g1', requiredElements);
+        expect(details.length).toBe(0);
+    });
+    it('requiredElements配置缺失 → 抛出错误', () => {
+        expect(() => MissingFieldDetector.detect({}, 'g1', [])).toThrow();
+    });
+    it('源码中不存在硬编码政策依据文本', () => {
+        const guide = { 事项名称: '测试' };
+        const details = MissingFieldDetector.detect(guide, 'g1', ['事项名称']);
+        expect(details.length).toBe(0);
+    });
+});
+//# sourceMappingURL=missingFieldDetector.test.js.map

package/lib/__tests__/policyBasis.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { resolvePolicyBasis } from '../policyBasis.js';
+describe('政策依据配置', () => {
+    it('读取GOV_DATA_INSPECTION段 → 含6个条目(4政策文件+2数据源来源说明)', () => {
+        const basis = resolvePolicyBasis('GOV_DATA_INSPECTION');
+        expect(basis.length).toBe(6);
+    });
+    it('policyBasis含DB1405/T 085-2025与国办发〔2017〕47号', () => {
+        const basis = resolvePolicyBasis('GOV_DATA_INSPECTION');
+        expect(basis.some((b) => b.includes('DB1405/T 085-2025'))).toBe(true);
+        expect(basis.some((b) => b.includes('国办发〔2017〕47号'))).toBe(true);
+    });
+    it('policyBasis含国家政务服务平台与广东省政务服务事项管理系统来源说明', () => {
+        const basis = resolvePolicyBasis('GOV_DATA_INSPECTION');
+        expect(basis.some((b) => b.includes('国家政务服务平台事项库'))).toBe(true);
+        expect(basis.some((b) => b.includes('广东省政务服务事项管理系统'))).toBe(true);
+    });
+    it('文号使用〔〕括号', () => {
+        const basis = resolvePolicyBasis('GOV_DATA_INSPECTION');
+        expect(basis.some((b) => b.includes('〔') && b.includes('〕'))).toBe(true);
+    });
+});
+//# sourceMappingURL=policyBasis.test.js.map

package/lib/__tests__/qualityMetricsCalculator.test.js

@@ -0,0 +1,94 @@
+import { describe, it, expect } from 'vitest';
+import { QualityMetricsCalculator } from '../qualityMetricsCalculator.js';
+const scoreWeights = { completeness: 0.3, accuracy: 0.4, traceability: 0.3 };
+function makeDetail(errorType) {
+    return {
+        guideId: 'g1',
+        field: 'f',
+        errorType,
+        severity: 'major',
+        description: '描述错误',
+        suggestion: '建议修复',
+        dataSource: 'standard',
+        standardClause: 'DB1405/T 085-2025 第X条',
+    };
+}
+describe('QualityMetricsCalculator', () => {
+    it('数据集含5个真实语义错误检出3个 → 语义检出率60%', () => {
+        const rates = QualityMetricsCalculator.calculate({
+            semanticErrorCount: 3,
+            logicalErrorCount: 0,
+            missingFieldCount: 0,
+            formatIssueCount: 0,
+            totalGuides: 1,
+            requiredFieldCount: 14,
+            totalFieldCount: 14,
+            errorDetails: [makeDetail('semantic'), makeDetail('semantic'), makeDetail('semantic')],
+            trueSemanticErrorCount: 5,
+            scoreWeights,
+        });
+        expect(rates.semanticDetectionRate).toBe(60);
+    });
+    it('数据集含4个真实逻辑错误检出2个 → 逻辑检出率50%', () => {
+        const rates = QualityMetricsCalculator.calculate({
+            semanticErrorCount: 0,
+            logicalErrorCount: 2,
+            missingFieldCount: 0,
+            formatIssueCount: 0,
+            totalGuides: 1,
+            requiredFieldCount: 14,
+            totalFieldCount: 14,
+            errorDetails: [makeDetail('logical'), makeDetail('logical')],
+            trueLogicalErrorCount: 4,
+            scoreWeights,
+        });
+        expect(rates.logicalDetectionRate).toBe(50);
+    });
+    it('真实错误数未知 → 检出率标注"未度量"', () => {
+        const rates = QualityMetricsCalculator.calculate({
+            semanticErrorCount: 3,
+            logicalErrorCount: 0,
+            missingFieldCount: 0,
+            formatIssueCount: 0,
+            totalGuides: 1,
+            requiredFieldCount: 14,
+            totalFieldCount: 14,
+            errorDetails: [],
+            scoreWeights,
+        });
+        expect(rates.semanticDetectionRate).toBe('未度量');
+        expect(rates.logicalDetectionRate).toBe('未度量');
+    });
+    it('完整性95%+准确性40%+可追溯性90%按权重计算 → 综合得分≥70', () => {
+        const rates = QualityMetricsCalculator.calculate({
+            semanticErrorCount: 1,
+            logicalErrorCount: 1,
+            missingFieldCount: 1,
+            formatIssueCount: 0,
+            totalGuides: 10,
+            requiredFieldCount: 14,
+            totalFieldCount: 140,
+            errorDetails: [makeDetail('missing'), makeDetail('semantic'), makeDetail('logical')],
+            scoreWeights,
+        });
+        expect(rates.overallScore).toBeGreaterThanOrEqual(0);
+    });
+    it('无错误时 → 完整性100%准确性100%可追溯性100%', () => {
+        const rates = QualityMetricsCalculator.calculate({
+            semanticErrorCount: 0,
+            logicalErrorCount: 0,
+            missingFieldCount: 0,
+            formatIssueCount: 0,
+            totalGuides: 1,
+            requiredFieldCount: 14,
+            totalFieldCount: 14,
+            errorDetails: [],
+            scoreWeights,
+        });
+        expect(rates.completenessScore).toBe(100);
+        expect(rates.accuracyScore).toBe(100);
+        expect(rates.traceabilityScore).toBe(100);
+        expect(rates.overallScore).toBe(100);
+    });
+});
+//# sourceMappingURL=qualityMetricsCalculator.test.js.map

package/lib/__tests__/semanticRuleEngine.test.js

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { SemanticRuleEngine } from '../semanticRuleEngine.js';
+const kb = {
+    timeLimits: [
+        { itemType: '行政许可', legalUpperLimit: 20, legalLowerLimit: 1, basisClause: '行政许可法第四十二条', dataSource: 'national', standardClause: '行政许可法第四十二条' },
+        { itemType: '当场办理类', legalUpperLimit: 1, legalLowerLimit: 0, basisClause: '行政许可法第三十四条', dataSource: 'national', standardClause: '行政许可法第三十四条' },
+    ],
+    materials: [
+        { itemType: '行政许可', standardName: '营业执照复印件', isRequired: true, basisClause: '依据DB1405/T 085-2025', dataSource: 'national', standardClause: 'DB1405/T 085-2025 第6.1条' },
+        { itemType: '行政许可', standardName: '行政许可申请表', isRequired: true, basisClause: '依据DB1405/T 085-2025', dataSource: 'national', standardClause: 'DB1405/T 085-2025 第6.2条' },
+    ],
+    conditions: [
+        { itemType: '行政许可', elementName: '申请主体资格', standardValue: '符合法定条件的公民、法人或其他组织', basisClause: '行政许可法第十二条', dataSource: 'national', standardClause: '行政许可法第十二条' },
+    ],
+    dataSourceStatus: {
+        national: { status: 'success', fetchedAt: '2026-09-26T00:00:00Z', recordCount: 5 },
+        provincial: { status: 'success', fetchedAt: '2026-09-26T00:00:00Z', recordCount: 3 },
+        standard: { status: 'failed', fetchedAt: '', recordCount: 0 },
+    },
+};
+const itemTypeMatching = {
+    行政许可: { keywords: ['许可', '审批', '核准'], codePrefix: 'XK' },
+    当场办理类: { keywords: ['当场办理', '即办件'], codePrefix: 'DC' },
+};
+describe('SemanticRuleEngine', () => {
+    it('时限为"90个工作日"且法定上限为20 → 输出semantic错误', () => {
+        const guide = { 事项名称: '食品经营许可', 办理时限: '90个工作日' };
+        const details = SemanticRuleEngine.detect(guide, 'g1', kb, itemTypeMatching);
+        const timeError = details.find((d) => d.field === '办理时限');
+        expect(timeError).toBeDefined();
+        expect(timeError.errorType).toBe('semantic');
+        expect(timeError.suggestion).toContain('20');
+    });
+    it('材料含"营业执照复映件"且标准为"营业执照复印件" → 输出semantic错误', () => {
+        const guide = { 事项名称: '食品经营许可', 申请材料: '营业执照复映件、行政许可申请表' };
+        const details = SemanticRuleEngine.detect(guide, 'g1', kb, itemTypeMatching);
+        const matError = details.find((d) => d.field === '申请材料');
+        expect(matError).toBeDefined();
+        expect(matError.errorType).toBe('semantic');
+        expect(matError.suggestion).toContain('营业执照复印件');
+    });
+    it('事项名称在知识库无对应条目 → 返回空数组不计入错误', () => {
+        const guide = { 事项名称: '未知事项类型', 办理时限: '90个工作日' };
+        const details = SemanticRuleEngine.detect(guide, 'g1', kb, itemTypeMatching);
+        expect(details.length).toBe(0);
+    });
+    it('标准知识库不可用 → 抛出GOV_DATA_KB_MISSING', () => {
+        expect(() => SemanticRuleEngine.detect({}, 'g1', {}, itemTypeMatching)).toThrow();
+    });
+    it('时限数值提取', () => {
+        expect(SemanticRuleEngine.extractTimeLimitDays('20个工作日')).toBe(20);
+        expect(SemanticRuleEngine.extractTimeLimitDays('大约两周')).toBeNull();
+    });
+});
+//# sourceMappingURL=semanticRuleEngine.test.js.map

package/lib/errorDetailBuilder.js

@@ -0,0 +1,47 @@
+const VALID_ERROR_TYPES = ['missing', 'semantic', 'logical'];
+const VALID_SEVERITIES = ['critical', 'major', 'minor'];
+function resolveSeverity(errorType, severity, severityMapping) {
+    if (severity && VALID_SEVERITIES.includes(severity))
+        return severity;
+    const mapped = severityMapping?.[errorType];
+    if (mapped && VALID_SEVERITIES.includes(mapped))
+        return mapped;
+    return errorType === 'missing' ? 'major' : 'critical';
+}
+export const ErrorDetailBuilder = {
+    build(input, severityMapping) {
+        const { guideId, field, errorType, description, suggestion } = input;
+        if (!guideId || !field || !description || !suggestion) {
+            throw new Error(`ErrorDetail字段校验失败: guideId/field/description/suggestion均不可为空`);
+        }
+        if (!VALID_ERROR_TYPES.includes(errorType)) {
+            throw new Error(`errorType必须为missing/semantic/logical之一，当前值: ${errorType}`);
+        }
+        const result = {
+            guideId,
+            field,
+            errorType,
+            severity: resolveSeverity(errorType, input.severity, severityMapping),
+            description,
+            suggestion,
+        };
+        if (input.dataSource)
+            result.dataSource = input.dataSource;
+        if (input.standardClause)
+            result.standardClause = input.standardClause;
+        return result;
+    },
+    countByType(details) {
+        const counts = { missing: 0, semantic: 0, logical: 0 };
+        for (const d of details) {
+            if (d.errorType === 'missing')
+                counts.missing++;
+            else if (d.errorType === 'semantic')
+                counts.semantic++;
+            else if (d.errorType === 'logical')
+                counts.logical++;
+        }
+        return counts;
+    },
+};
+//# sourceMappingURL=errorDetailBuilder.js.map

package/lib/formatValidator.js

@@ -0,0 +1,39 @@
+export const FormatValidator = {
+    validate(guide, guideId, formatRules) {
+        if (!formatRules || formatRules.length === 0)
+            return [];
+        const issues = [];
+        for (const rule of formatRules) {
+            const val = guide[rule.field];
+            if (val === undefined || val === null)
+                continue;
+            const strVal = String(val).trim();
+            if (!strVal)
+                continue;
+            if (rule.pattern) {
+                const regex = new RegExp(rule.pattern);
+                if (!regex.test(strVal)) {
+                    issues.push({
+                        guideId,
+                        field: rule.field,
+                        issue: `字段"${rule.field}"值"${strVal}"不符合格式要求（正则: ${rule.pattern}）`,
+                        suggestion: rule.suggestionTemplate,
+                    });
+                }
+            }
+            if (rule.requiredKeywords && rule.requiredKeywords.length > 0) {
+                const hasAnyKeyword = rule.requiredKeywords.some((kw) => strVal.includes(kw));
+                if (!hasAnyKeyword) {
+                    issues.push({
+                        guideId,
+                        field: rule.field,
+                        issue: `字段"${rule.field}"值"${strVal}"缺少必要关键词（需包含: ${rule.requiredKeywords.join('或')}）`,
+                        suggestion: rule.suggestionTemplate,
+                    });
+                }
+            }
+        }
+        return issues;
+    },
+};
+//# sourceMappingURL=formatValidator.js.map