@liuhange/dsh-gov-data-inspector 3.1.3 → 3.1.5

package/cordis.patch.yml

@@ -0,0 +1,9 @@
+# Cordis Framework Patch Declaration for @liuhange/dsh-gov-data-inspector
+# This file declares the plugin's runtime patch for the Cordis framework.
+# Used by DSH plugin manager to apply framework-level patches during installation.
+plugin: @liuhange/dsh-gov-data-inspector
+version: 3.1.5
+patch:
+  - target: tools
+    action: register
+    description: Register plugin tools into Cordis runtime

package/lib/__tests__/exceptionInput.test.js

@@ -0,0 +1,226 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+const tmpDir = resolve(tmpdir(), 'gov-data-inspector-test');
+const badJsonPath = resolve(tmpDir, 'bad.json');
+const emptyPath = resolve(tmpDir, 'empty.json');
+const emptyArrayPath = resolve(tmpDir, 'empty-array.json');
+const nonUtf8Path = resolve(tmpDir, 'non-utf8.json');
+const partialDataPath = resolve(tmpDir, 'partial.json');
+const validDataPath = resolve(tmpDir, 'valid.json');
+beforeAll(() => {
+    mkdirSync(tmpDir, { recursive: true });
+    writeFileSync(badJsonPath, '{ "事项名称": "测试", invalid json }', 'utf-8');
+    writeFileSync(emptyPath, '', 'utf-8');
+    writeFileSync(emptyArrayPath, '[]', 'utf-8');
+    const gbkBuffer = Buffer.from([0xB2, 0xE2, 0xCA, 0xD4]);
+    writeFileSync(nonUtf8Path, gbkBuffer);
+    writeFileSync(partialDataPath, JSON.stringify([{ 事项名称: '测试事项' }]), 'utf-8');
+    writeFileSync(validDataPath, JSON.stringify([{ 事项名称: '食品经营许可', 办理时限: '20个工作日' }]), 'utf-8');
+});
+afterAll(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+});
+async function getExecute() {
+    const mod = await import('../index.js');
+    const tools = [];
+    mod.apply({ tools: { register: (t) => tools.push(t) } });
+    const tool = tools[0];
+    return tool.execute;
+}
+describe('异常输入处理', () => {
+    it('格式错误的JSON → 返回GOV_DATA_INPUT_INVALID', async () => {
+        const execute = await getExecute();
+        const result = JSON.parse(await execute({ dataSource: badJsonPath }));
+        expect(result.error).toBe('GOV_DATA_INPUT_INVALID');
+        expect(result.message).toContain('JSON 格式错误');
+    });
+    it('空数据(空文件) → 返回无数据提示', async () => {
+        const execute = await getExecute();
+        const result = JSON.parse(await execute({ dataSource: emptyPath }));
+        expect(result.error).toBe('GOV_DATA_INPUT_INVALID');
+        expect(result.message).toContain('无数据');
+    });
+    it('空数据(空数组) → 返回无数据提示', async () => {
+        const execute = await getExecute();
+        const result = JSON.parse(await execute({ dataSource: emptyArrayPath }));
+        expect(result.error).toBe('GOV_DATA_INPUT_INVALID');
+        expect(result.message).toContain('无数据');
+    });
+    it('无效URL → 返回不可达提示而非崩溃', async () => {
+        const execute = await getExecute();
+        const result = JSON.parse(await execute({ dataSource: 'http://invalid.localhost.nonexistent:99999/data.json' }));
+        expect(result.error).toBeDefined();
+        expect(result.message).toBeDefined();
+    });
+    it('部分字段缺失的数据 → 正常处理并报告缺失字段', async () => {
+        const execute = await getExecute();
+        const result = JSON.parse(await execute({ dataSource: partialDataPath, inspectionMode: 'guide' }));
+        expect(result.error).toBeUndefined();
+        expect(result.guideInspection).toBeDefined();
+        expect(result.guideInspection.missingFields).toBeGreaterThan(0);
+    });
+    it('非UTF-8编码文件 → 返回编码错误提示', async () => {
+        const execute = await getExecute();
+        const result = JSON.parse(await execute({ dataSource: nonUtf8Path }));
+        expect(result.error).toBe('GOV_DATA_ENCODING_ERROR');
+        expect(result.message).toContain('UTF-8');
+    });
+});
+describe('EncodingDetector', () => {
+    it('UTF-8文件正常读取', async () => {
+        const { EncodingDetector } = await import('../encodingDetector.js');
+        const result = EncodingDetector.detect(validDataPath);
+        expect(result.content).not.toBeNull();
+        expect(result.encodingError).toBeUndefined();
+    });
+    it('非UTF-8文件返回编码错误', async () => {
+        const { EncodingDetector } = await import('../encodingDetector.js');
+        const result = EncodingDetector.detect(nonUtf8Path);
+        expect(result.content).toBeNull();
+        expect(result.encodingError).toContain('UTF-8');
+    });
+    it('不存在的文件返回读取错误', async () => {
+        const { EncodingDetector } = await import('../encodingDetector.js');
+        const result = EncodingDetector.detect(resolve(tmpDir, 'nonexistent.json'));
+        expect(result.content).toBeNull();
+        expect(result.encodingError).toContain('无法读取');
+    });
+});
+describe('DataScaleGuard', () => {
+    it('正常规模数据通过', async () => {
+        const { DataScaleGuard } = await import('../dataScaleGuard.js');
+        const data = [{ a: 1, b: 2 }, { c: 3 }];
+        const result = DataScaleGuard.check(data);
+        expect(result.exceeded).toBe(false);
+        expect(result.fieldCount).toBe(3);
+    });
+    it('超100万字段数据返回exceeded=true', async () => {
+        const { DataScaleGuard } = await import('../dataScaleGuard.js');
+        const data = [];
+        for (let i = 0; i < 100001; i++)
+            data.push({ f: i });
+        const result = DataScaleGuard.check(data, 100000);
+        expect(result.exceeded).toBe(true);
+        expect(result.fieldCount).toBeGreaterThan(100000);
+    });
+    it('自定义上限', async () => {
+        const { DataScaleGuard } = await import('../dataScaleGuard.js');
+        const result = DataScaleGuard.check([{ a: 1, b: 2, c: 3 }], 2);
+        expect(result.exceeded).toBe(true);
+    });
+});
+describe('UrlReachabilityChecker', () => {
+    it('本地文件存在 → reachable=true', async () => {
+        const { UrlReachabilityChecker } = await import('../urlReachabilityChecker.js');
+        const result = await UrlReachabilityChecker.check(validDataPath);
+        expect(result.reachable).toBe(true);
+    });
+    it('不存在的文件 → reachable=false', async () => {
+        const { UrlReachabilityChecker } = await import('../urlReachabilityChecker.js');
+        const result = await UrlReachabilityChecker.check(resolve(tmpDir, 'nonexistent.json'));
+        expect(result.reachable).toBe(false);
+        expect(result.error).toBeDefined();
+    });
+    it('空路径 → reachable=false', async () => {
+        const { UrlReachabilityChecker } = await import('../urlReachabilityChecker.js');
+        const result = await UrlReachabilityChecker.check('');
+        expect(result.reachable).toBe(false);
+    });
+});
+describe('EndpointResolver', () => {
+    it('HTTPS URL → kind=https', async () => {
+        const { EndpointResolver } = await import('../endpointResolver.js');
+        const result = EndpointResolver.resolve('https://api.example.com/data');
+        expect(result?.kind).toBe('https');
+    });
+    it('HTTP URL → kind=http', async () => {
+        const { EndpointResolver } = await import('../endpointResolver.js');
+        const result = EndpointResolver.resolve('http://api.example.com/data');
+        expect(result?.kind).toBe('http');
+    });
+    it('本地文件路径 → kind=file', async () => {
+        const { EndpointResolver } = await import('../endpointResolver.js');
+        const result = EndpointResolver.resolve(validDataPath);
+        expect(result?.kind).toBe('file');
+    });
+    it('相对路径 → kind=file', async () => {
+        const { EndpointResolver } = await import('../endpointResolver.js');
+        const result = EndpointResolver.resolve('./data.json');
+        expect(result?.kind).toBe('file');
+    });
+    it('非法字符串 → null', async () => {
+        const { EndpointResolver } = await import('../endpointResolver.js');
+        const result = EndpointResolver.resolve('not-a-valid-endpoint');
+        expect(result).toBeNull();
+    });
+});
+describe('DegradedModeController', () => {
+    it('activate返回degradedMode=true', async () => {
+        const { DegradedModeController } = await import('../degradedModeController.js');
+        const result = DegradedModeController.activate('测试降级原因');
+        expect(result.degradedMode).toBe(true);
+        expect(result.degradedReason).toBe('测试降级原因');
+        expect(result.localKb).toBeDefined();
+        expect(result.localKb.timeLimits).toEqual([]);
+        expect(result.localKb.materials).toEqual([]);
+        expect(result.localKb.conditions).toEqual([]);
+    });
+});
+describe('UnmatchedWarningBuilder', () => {
+    it('build返回正确警告结构', async () => {
+        const { UnmatchedWarningBuilder } = await import('../unmatchedWarningBuilder.js');
+        const warning = UnmatchedWarningBuilder.build('guide-001');
+        expect(warning.type).toBe('UNMATCHED_ITEM_TYPE');
+        expect(warning.guideId).toBe('guide-001');
+        expect(warning.message).toContain('未匹配到检测规则');
+    });
+});
+describe('输入边界友好提示', () => {
+    const emptyObjectPath = resolve(tmpDir, 'empty-object.json');
+    const tooLargePath = resolve(tmpDir, 'too-large.json');
+    const atThresholdPath = resolve(tmpDir, 'at-threshold.json');
+    beforeAll(() => {
+        writeFileSync(emptyObjectPath, JSON.stringify({}), 'utf-8');
+        writeFileSync(tooLargePath, 'a'.repeat(100000), 'utf-8');
+        writeFileSync(atThresholdPath, JSON.stringify([{ 事项名称: '测试', 办理时限: '20个工作日' }]).padEnd(50000, ' '), 'utf-8');
+    });
+    it('IDX-01: 空对象{} → 返回GOV_DATA_NO_DATA', async () => {
+        const execute = await getExecute();
+        const result = JSON.parse(await execute({ dataSource: emptyObjectPath, inspectionMode: 'guide' }));
+        expect(result.error).toBe('GOV_DATA_NO_DATA');
+        expect(result.message).toContain('未检测到有效数据');
+    });
+    it('IDX-02: 10万字符 → 返回GOV_DATA_INPUT_TOO_LARGE', async () => {
+        const execute = await getExecute();
+        const result = JSON.parse(await execute({ dataSource: tooLargePath }));
+        expect(result.error).toBe('GOV_DATA_INPUT_TOO_LARGE');
+        expect(result.message).toContain('超过处理上限');
+        expect(result.message).toContain('分批提交');
+    });
+    it('IDX-03: 50000字符 → 正常处理无超长错误', async () => {
+        const execute = await getExecute();
+        const result = JSON.parse(await execute({ dataSource: atThresholdPath }));
+        expect(result.error).not.toBe('GOV_DATA_INPUT_TOO_LARGE');
+    });
+    it('IDX-04: 空对象不进入漏项检测不报告14个漏项', async () => {
+        const execute = await getExecute();
+        const result = JSON.parse(await execute({ dataSource: emptyObjectPath, inspectionMode: 'guide' }));
+        expect(result.guideInspection).toBeUndefined();
+    });
+    it('IDX-05: 空对象不报告missingFields', async () => {
+        const execute = await getExecute();
+        const result = JSON.parse(await execute({ dataSource: emptyObjectPath, inspectionMode: 'guide' }));
+        expect(result.missingFields).toBeUndefined();
+    });
+    it('IDX-06: 降级模式+含笔误数据 → 报告含degradedMode和保底校验结果', async () => {
+        const typoDataPath = resolve(tmpDir, 'typo-data.json');
+        writeFileSync(typoDataPath, JSON.stringify([{ 事项名称: '食品经营许可', 申请材料: '身份证复件', 办理时限: '20个工作日' }]), 'utf-8');
+        const execute = await getExecute();
+        const result = JSON.parse(await execute({ dataSource: typoDataPath, inspectionMode: 'guide' }));
+        expect(result.degradedMode).toBe(true);
+        expect(result.degradedReason).toBeDefined();
+    });
+});
+//# sourceMappingURL=exceptionInput.test.js.map

package/lib/__tests__/formatValidator.test.js

@@ -31,5 +31,34 @@ describe('FormatValidator', () => {
         const issues = FormatValidator.validate({ 办理时限: 'abc' }, 'g1', undefined);
         expect(issues.length).toBe(0);
     });
+    it('FV-01: 时限值"7个自然日" formatIssues含semanticHint含"自然日而非工作日"', () => {
+        const issues = FormatValidator.validate({ 办理时限: '7个自然日' }, 'g1', formatRules);
+        const timeLimitIssue = issues.find((i) => i.field === '办理时限');
+        expect(timeLimitIssue).toBeDefined();
+        expect(timeLimitIssue?.semanticHint).toContain("自然日");
+        expect(timeLimitIssue?.semanticHint).toContain("工作日");
+    });
+    it('FV-02: 时限值"大约两周" semanticHint为undefined', () => {
+        const issues = FormatValidator.validate({ 办理时限: '大约两周' }, 'g1', formatRules);
+        const timeLimitIssue = issues.find((i) => i.field === '办理时限');
+        expect(timeLimitIssue).toBeDefined();
+        expect(timeLimitIssue?.semanticHint).toBeUndefined();
+    });
+    it('FV-03: 咨询电话"请联系前台" semanticHint为undefined', () => {
+        const issues = FormatValidator.validate({ 咨询电话: '请联系前台' }, 'g1', formatRules);
+        const phoneIssue = issues.find((i) => i.field === '咨询电话');
+        expect(phoneIssue).toBeDefined();
+        expect(phoneIssue?.semanticHint).toBeUndefined();
+    });
+    it('FV-04: 双标注主归类仍归属formatIssues不计入semanticErrors', () => {
+        const issues = FormatValidator.validate({ 办理时限: '7个自然日' }, 'g1', formatRules);
+        expect(issues.some((i) => i.field === '办理时限' && i.semanticHint !== undefined)).toBe(true);
+    });
+    it('FV-05: 双标注policyBasis保留原有格式校验政策依据', () => {
+        const issues = FormatValidator.validate({ 办理时限: '7个自然日' }, 'g1', formatRules);
+        const timeLimitIssue = issues.find((i) => i.field === '办理时限');
+        expect(timeLimitIssue).toBeDefined();
+        expect(timeLimitIssue?.issue).toContain('格式要求');
+    });
 });
 //# sourceMappingURL=formatValidator.test.js.map

package/lib/__tests__/input-boundary-checker.test.js

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { InputBoundaryChecker } from '../input-boundary-checker.js';
+describe('InputBoundaryChecker', () => {
+    it('IBC-01: checkEmpty([{}]) 返回 isEmpty=true', () => {
+        const result = InputBoundaryChecker.checkEmpty([{}]);
+        expect(result.isEmpty).toBe(true);
+    });
+    it('IBC-02: checkEmpty([{事项名称:"测试"}]) 返回 isEmpty=false', () => {
+        const result = InputBoundaryChecker.checkEmpty([{ 事项名称: '测试' }]);
+        expect(result.isEmpty).toBe(false);
+    });
+    it('IBC-03: checkEmpty([{a:""},{b:null}]) 返回 isEmpty=true', () => {
+        const result = InputBoundaryChecker.checkEmpty([{ a: '' }, { b: null }]);
+        expect(result.isEmpty).toBe(true);
+    });
+    it('IBC-04: checkTooLarge 50001字符 阈值50000 返回 isTooLarge=true', () => {
+        const result = InputBoundaryChecker.checkTooLarge('a'.repeat(50001), 50000);
+        expect(result.isTooLarge).toBe(true);
+        expect(result.length).toBe(50001);
+    });
+    it('IBC-05: checkTooLarge 50000字符 阈值50000 返回 isTooLarge=false', () => {
+        const result = InputBoundaryChecker.checkTooLarge('a'.repeat(50000), 50000);
+        expect(result.isTooLarge).toBe(false);
+    });
+    it('IBC-06: checkTooLarge 100字符 阈值50000 返回 isTooLarge=false', () => {
+        const result = InputBoundaryChecker.checkTooLarge('a'.repeat(100), 50000);
+        expect(result.isTooLarge).toBe(false);
+    });
+});
+//# sourceMappingURL=input-boundary-checker.test.js.map

package/lib/__tests__/local-terms-loader.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { LocalTermsLoader } from '../local-terms-loader.js';
+import { writeFileSync, mkdirSync, existsSync, rmSync } from 'node:fs';
+import { resolve } from 'node:path';
+describe('LocalTermsLoader', () => {
+    const tmpDir = resolve(process.cwd(), 'tmp-test-terms');
+    const tmpFile = resolve(tmpDir, 'test-terms.json');
+    it('LTL-01: 有效词表路径正常加载', () => {
+        mkdirSync(tmpDir, { recursive: true });
+        writeFileSync(tmpFile, JSON.stringify({ materials: ['身份证原件', '申请表'], conditions: ['年满18周岁'] }), 'utf-8');
+        const result = LocalTermsLoader.load(tmpFile);
+        expect(result.materials).toContain('身份证原件');
+        expect(result.materials).toContain('申请表');
+        expect(result.conditions).toContain('年满18周岁');
+    });
+    it('LTL-02: 不存在路径返回空词表不抛错', () => {
+        const result = LocalTermsLoader.load('/nonexistent/path/terms.json');
+        expect(result.materials).toEqual([]);
+        expect(result.conditions).toEqual([]);
+    });
+    it('LTL-03: 空词表文件返回空词表不抛错', () => {
+        mkdirSync(tmpDir, { recursive: true });
+        writeFileSync(tmpFile, JSON.stringify({ materials: [], conditions: [] }), 'utf-8');
+        const result = LocalTermsLoader.load(tmpFile);
+        expect(result.materials).toEqual([]);
+        expect(result.conditions).toEqual([]);
+    });
+    it('LTL-04: 未配置路径使用默认路径加载', () => {
+        const result = LocalTermsLoader.load();
+        expect(Array.isArray(result.materials)).toBe(true);
+        expect(Array.isArray(result.conditions)).toBe(true);
+    });
+    it('cleanup', () => {
+        if (existsSync(tmpDir))
+            rmSync(tmpDir, { recursive: true, force: true });
+    });
+});
+//# sourceMappingURL=local-terms-loader.test.js.map

package/lib/__tests__/logicRuleEngine.test.js

@@ -5,6 +5,7 @@ const rules = [
     { 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: ['收入证明', '产权证明', '资质证明', '无犯罪记录证明', '健康证明', '社保证明', '纳税证明'] },
+    { ruleId: 'LOG_CONDITION_AGE_PROXY_001', standardClause: 'DB1405/T 085-2025 第5.6条', triggerFields: ['办理条件', '办理流程'], condition: '办理条件含年龄限制且办理流程含代办', suggestionTemplate: '建议明确：未成年人由监护人代办，或删除年龄限制', threshold: undefined, triggerKeywords: ['年满18周岁', '年满十八周岁', '须为成年人', '监护人代办', '未成年人代办', '法定代理人代办'] },
 ];
 describe('LogicRuleEngine', () => {
     it('流程含"现场勘查"且时限为"3个工作日" → 输出logical错误', () => {
@@ -35,5 +36,42 @@ describe('LogicRuleEngine', () => {
         const details = LogicRuleEngine.detect(guide, 'g1', rules);
         expect(details.length).toBe(0);
     });
+    it('LRE-01: 条件含"年满18周岁"+流程含"监护人代办" → 检出矛盾', () => {
+        const guide = { 办理条件: '申请人须年满18周岁', 办理流程: '可由监护人代办' };
+        const details = LogicRuleEngine.detect(guide, 'g1', rules);
+        expect(details.some((d) => d.errorType === 'logical' && d.description.includes('年满18周岁'))).toBe(true);
+    });
+    it('LRE-02: 条件含"年满十八周岁"+流程含"法定代理人代办" → 检出矛盾', () => {
+        const guide = { 办理条件: '申请人须年满十八周岁', 办理流程: '可由法定代理人代办' };
+        const details = LogicRuleEngine.detect(guide, 'g1', rules);
+        expect(details.some((d) => d.errorType === 'logical' && d.description.includes('年满18周岁'))).toBe(true);
+    });
+    it('LRE-03: 仅年龄无代办 → 不报告', () => {
+        const guide = { 办理条件: '申请人须年满18周岁', 办理流程: '受理→审批→发证' };
+        const details = LogicRuleEngine.detect(guide, 'g1', rules);
+        expect(details.some((d) => d.description.includes('年满18周岁') && d.description.includes('代办'))).toBe(false);
+    });
+    it('LRE-04: 仅代办无年龄 → 不报告', () => {
+        const guide = { 办理条件: '符合法定条件', 办理流程: '可由监护人代办' };
+        const details = LogicRuleEngine.detect(guide, 'g1', rules);
+        expect(details.some((d) => d.description.includes('年满18周岁'))).toBe(false);
+    });
+    it('LRE-05: 现有LOG_CONDITION_PROXY_001(本人到场+代办)不回归', () => {
+        const guide = { 办理条件: '需本人到场办理', 办理流程: '可代办' };
+        const details = LogicRuleEngine.detect(guide, 'g1', rules);
+        expect(details.some((d) => d.description.includes('本人到场'))).toBe(true);
+    });
+    it('LRE-06: 新规则standardClause含"DB1405/T 085-2025 第5.6条"', () => {
+        const guide = { 办理条件: '申请人须年满18周岁', 办理流程: '可由监护人代办' };
+        const details = LogicRuleEngine.detect(guide, 'g1', rules);
+        expect(details.some((d) => d.standardClause === 'DB1405/T 085-2025 第5.6条')).toBe(true);
+    });
+    it('LRE-07: 新规则suggestion含"未成年人由监护人代办"', () => {
+        const guide = { 办理条件: '申请人须年满18周岁', 办理流程: '可由监护人代办' };
+        const details = LogicRuleEngine.detect(guide, 'g1', rules);
+        const ageProxyDetail = details.find((d) => d.description.includes('年满18周岁'));
+        expect(ageProxyDetail).toBeDefined();
+        expect(ageProxyDetail?.suggestion).toContain('未成年人由监护人代办');
+    });
 });
 //# sourceMappingURL=logicRuleEngine.test.js.map

package/lib/__tests__/semanticRuleEngine.test.js

@@ -25,31 +25,97 @@ const itemTypeMatching = {
 describe('SemanticRuleEngine', () => {
     it('时限为"90个工作日"且法定上限为20 → 输出semantic错误', () => {
         const guide = { 事项名称: '食品经营许可', 办理时限: '90个工作日' };
-        const details = SemanticRuleEngine.detect(guide, 'g1', kb, itemTypeMatching);
-        const timeError = details.find((d) => d.field === '办理时限');
+        const result = SemanticRuleEngine.detect(guide, 'g1', kb, itemTypeMatching);
+        const timeError = result.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 === '申请材料');
+        const result = SemanticRuleEngine.detect(guide, 'g1', kb, itemTypeMatching);
+        const matError = result.details.find((d) => d.field === '申请材料');
         expect(matError).toBeDefined();
         expect(matError.errorType).toBe('semantic');
         expect(matError.suggestion).toContain('营业执照复印件');
     });
-    it('事项名称在知识库无对应条目 → 返回空数组不计入错误', () => {
+    it('事项名称在知识库无对应条目 → 返回unmatched警告', () => {
         const guide = { 事项名称: '未知事项类型', 办理时限: '90个工作日' };
-        const details = SemanticRuleEngine.detect(guide, 'g1', kb, itemTypeMatching);
-        expect(details.length).toBe(0);
+        const result = SemanticRuleEngine.detect(guide, 'g1', kb, itemTypeMatching);
+        expect(result.details.length).toBe(0);
+        expect(result.unmatched).toBe(true);
+        expect(result.warning).toBeDefined();
+        expect(result.warning.type).toBe('UNMATCHED_ITEM_TYPE');
     });
-    it('标准知识库不可用 → 抛出GOV_DATA_KB_MISSING', () => {
-        expect(() => SemanticRuleEngine.detect({}, 'g1', {}, itemTypeMatching)).toThrow();
+    it('标准知识库不可用且非降级 → 抛出GOV_DATA_KB_MISSING', () => {
+        expect(() => SemanticRuleEngine.detect({ 事项名称: '食品经营许可' }, 'g1', {}, itemTypeMatching)).toThrow();
+    });
+    it('标准知识库不可用且降级模式 → 返回空details不抛错', () => {
+        const result = SemanticRuleEngine.detect({ 事项名称: '食品经营许可' }, 'g1', {}, itemTypeMatching, undefined, { degradedMode: true });
+        expect(result.details).toEqual([]);
+    });
+    it('流程字段含关键词可匹配事项类型', () => {
+        const guide = { 事项名称: '建设工程规划核实', 办理流程: '受理→现场勘查→核实→出证', 办理时限: '90个工作日' };
+        const itemTypeMatchingWithFlow = {
+            现场勘查类: { keywords: ['现场勘查', '实地核查'], codePrefix: 'XC' },
+        };
+        const result = SemanticRuleEngine.detect(guide, 'g1', kb, itemTypeMatchingWithFlow);
+        expect(result.unmatched).toBeUndefined();
+    });
+    it('itemTypeOverride手动指定事项类型', () => {
+        const guide = { 事项名称: '建设工程规划核实', 办理时限: '90个工作日' };
+        const result = SemanticRuleEngine.detect(guide, 'g1', kb, itemTypeMatching, undefined, { itemTypeOverride: '行政许可' });
+        expect(result.unmatched).toBeUndefined();
+        const timeError = result.details.find((d) => d.field === '办理时限');
+        expect(timeError).toBeDefined();
+    });
+    it('matchItemType返回matchSource', () => {
+        const nameMatch = SemanticRuleEngine.matchItemType({ 事项名称: '食品经营许可' }, itemTypeMatching);
+        expect(nameMatch.matchSource).toBe('name');
+        const codeMatch = SemanticRuleEngine.matchItemType({ 事项编码: 'XK001' }, itemTypeMatching);
+        expect(codeMatch.matchSource).toBe('code');
+        const flowMatch = SemanticRuleEngine.matchItemType({ 事项名称: '测试', 办理流程: '现场勘查' }, { 现场勘查类: { keywords: ['现场勘查'], codePrefix: 'XC' } });
+        expect(flowMatch.matchSource).toBe('flow');
+        const manualMatch = SemanticRuleEngine.matchItemType({ 事项名称: '测试' }, itemTypeMatching, { itemTypeOverride: '行政许可' });
+        expect(manualMatch.matchSource).toBe('manual');
+        const noMatch = SemanticRuleEngine.matchItemType({ 事项名称: '测试' }, itemTypeMatching);
+        expect(noMatch.matchSource).toBeNull();
+        expect(noMatch.itemType).toBeNull();
     });
     it('时限数值提取', () => {
         expect(SemanticRuleEngine.extractTimeLimitDays('20个工作日')).toBe(20);
         expect(SemanticRuleEngine.extractTimeLimitDays('大约两周')).toBeNull();
     });
+    it('SRE-01: 降级+空KB+本地词表含"身份证复印件"+材料含"身份证复" → 检出笔误', () => {
+        const guide = { 事项名称: '食品经营许可', 申请材料: '身份证复、申请表' };
+        const result = SemanticRuleEngine.detect(guide, 'g1', { timeLimits: [], materials: [], conditions: [] }, itemTypeMatching, undefined, { degradedMode: true });
+        expect(result.details.some((d) => d.errorType === 'semantic' && d.description.includes('笔误'))).toBe(true);
+    });
+    it('SRE-02: 降级+空KB+本地词表含"营业执照复印件"+材料含"营业执照复" → 检出笔误', () => {
+        const guide = { 事项名称: '食品经营许可', 申请材料: '营业执照复' };
+        const result = SemanticRuleEngine.detect(guide, 'g1', { timeLimits: [], materials: [], conditions: [] }, itemTypeMatching, undefined, { degradedMode: true });
+        expect(result.details.some((d) => d.errorType === 'semantic' && d.description.includes('笔误'))).toBe(true);
+    });
+    it('SRE-03: 降级+空KB+本地词表为空 → 返回空details不抛错', () => {
+        const guide = { 事项名称: '食品经营许可', 申请材料: '身份证复件' };
+        const result = SemanticRuleEngine.detect(guide, 'g1', { timeLimits: [], materials: [], conditions: [] }, itemTypeMatching, undefined, { degradedMode: true, localTermsPath: '/nonexistent/path/terms.json' });
+        expect(result.details).toEqual([]);
+    });
+    it('SRE-04: 降级+空KB+材料与本地词表完全匹配 → 返回空details', () => {
+        const guide = { 事项名称: '食品经营许可', 申请材料: '身份证复印件' };
+        const result = SemanticRuleEngine.detect(guide, 'g1', { timeLimits: [], materials: [], conditions: [] }, itemTypeMatching, undefined, { degradedMode: true });
+        expect(result.details).toEqual([]);
+    });
+    it('SRE-05: 降级+空KB+材料相似度=0.8 → 不报告(严格小于)', () => {
+        const guide = { 事项名称: '食品经营许可', 申请材料: '身份证复印件' };
+        const result = SemanticRuleEngine.detect(guide, 'g1', { timeLimits: [], materials: [], conditions: [] }, itemTypeMatching, undefined, { degradedMode: true, degradedSimilarityThreshold: 0.8 });
+        const hasPenalty = result.details.some((d) => d.description.includes('笔误'));
+        expect(hasPenalty).toBe(false);
+    });
+    it('SRE-06: 降级保底错误明细standardClause含"降级模式·本地词表校验"', () => {
+        const guide = { 事项名称: '食品经营许可', 申请材料: '身份证复' };
+        const result = SemanticRuleEngine.detect(guide, 'g1', { timeLimits: [], materials: [], conditions: [] }, itemTypeMatching, undefined, { degradedMode: true });
+        expect(result.details.some((d) => d.standardClause === '降级模式·本地词表校验')).toBe(true);
+    });
 });
 //# sourceMappingURL=semanticRuleEngine.test.js.map

package/lib/dataScaleGuard.js

@@ -0,0 +1,19 @@
+export const DataScaleGuard = {
+    check(data, maxFieldCount) {
+        const limit = maxFieldCount ?? 1000000;
+        let fieldCount = 0;
+        for (const row of data) {
+            if (typeof row === 'object' && row !== null) {
+                fieldCount += Object.keys(row).length;
+            }
+            else {
+                fieldCount++;
+            }
+            if (fieldCount > limit) {
+                return { exceeded: true, fieldCount };
+            }
+        }
+        return { exceeded: false, fieldCount };
+    },
+};
+//# sourceMappingURL=dataScaleGuard.js.map

package/lib/degradedModeController.js

@@ -0,0 +1,21 @@
+const DEGRADED_STATUS = { status: 'degraded', fetchedAt: '', recordCount: 0 };
+const EMPTY_KB = {
+    timeLimits: [],
+    materials: [],
+    conditions: [],
+    dataSourceStatus: {
+        national: DEGRADED_STATUS,
+        provincial: DEGRADED_STATUS,
+        standard: DEGRADED_STATUS,
+    },
+};
+export const DegradedModeController = {
+    activate(reason) {
+        return {
+            degradedMode: true,
+            degradedReason: reason,
+            localKb: { ...EMPTY_KB, dataSourceStatus: { ...EMPTY_KB.dataSourceStatus } },
+        };
+    },
+};
+//# sourceMappingURL=degradedModeController.js.map

package/lib/encodingDetector.js

@@ -0,0 +1,31 @@
+export const EncodingDetector = {
+    detect(filePath) {
+        const { readFileSync } = require('node:fs');
+        let buffer;
+        try {
+            buffer = readFileSync(filePath);
+        }
+        catch {
+            return { content: null, encodingError: `无法读取文件: ${filePath}` };
+        }
+        if (buffer.length === 0) {
+            return { content: '', encodingError: '文件为空' };
+        }
+        const isUtf8 = this.isValidUtf8(buffer);
+        if (!isUtf8) {
+            return { content: null, encodingError: '文件编码非 UTF-8，请将文件转换为 UTF-8 编码后重试' };
+        }
+        return { content: buffer.toString('utf-8') };
+    },
+    isValidUtf8(buffer) {
+        try {
+            const str = buffer.toString('utf-8');
+            const reencoded = Buffer.from(str, 'utf-8');
+            return reencoded.equals(buffer);
+        }
+        catch {
+            return false;
+        }
+    },
+};
+//# sourceMappingURL=encodingDetector.js.map

package/lib/endpointResolver.js

@@ -0,0 +1,21 @@
+export const EndpointResolver = {
+    resolve(endpoint) {
+        if (!endpoint || typeof endpoint !== 'string')
+            return null;
+        if (endpoint.startsWith('https://')) {
+            return { kind: 'https', target: endpoint };
+        }
+        if (endpoint.startsWith('http://')) {
+            return { kind: 'http', target: endpoint };
+        }
+        const { existsSync } = require('node:fs');
+        if (existsSync(endpoint)) {
+            return { kind: 'file', target: endpoint };
+        }
+        if (endpoint.startsWith('./') || endpoint.startsWith('../') || endpoint.startsWith('/') || /^[a-zA-Z]:[\\/]/.test(endpoint)) {
+            return { kind: 'file', target: endpoint };
+        }
+        return null;
+    },
+};
+//# sourceMappingURL=endpointResolver.js.map

package/lib/formatValidator.js

@@ -13,23 +13,31 @@ export const FormatValidator = {
             if (rule.pattern) {
                 const regex = new RegExp(rule.pattern);
                 if (!regex.test(strVal)) {
-                    issues.push({
+                    const issue = {
                         guideId,
                         field: rule.field,
                         issue: `字段"${rule.field}"值"${strVal}"不符合格式要求（正则: ${rule.pattern}）`,
                         suggestion: rule.suggestionTemplate,
-                    });
+                    };
+                    if (rule.field === '办理时限' && strVal.includes('自然日')) {
+                        issue.semanticHint = "时限使用'自然日'而非'工作日'，可能存在语义偏差";
+                    }
+                    issues.push(issue);
                 }
             }
             if (rule.requiredKeywords && rule.requiredKeywords.length > 0) {
                 const hasAnyKeyword = rule.requiredKeywords.some((kw) => strVal.includes(kw));
                 if (!hasAnyKeyword) {
-                    issues.push({
+                    const issue = {
                         guideId,
                         field: rule.field,
                         issue: `字段"${rule.field}"值"${strVal}"缺少必要关键词（需包含: ${rule.requiredKeywords.join('或')}）`,
                         suggestion: rule.suggestionTemplate,
-                    });
+                    };
+                    if (rule.field === '办理时限' && strVal.includes('自然日')) {
+                        issue.semanticHint = "时限使用'自然日'而非'工作日'，可能存在语义偏差";
+                    }
+                    issues.push(issue);
                 }
             }
         }