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

package/cordis.patch.yml

@@ -2,7 +2,7 @@
 # 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.2
+version: 3.1.5
 patch:
   - target: tools
     action: register

package/lib/__tests__/exceptionInput.test.js

@@ -177,4 +177,50 @@ describe('UnmatchedWarningBuilder', () => {
         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

@@ -86,5 +86,36 @@ describe('SemanticRuleEngine', () => {
         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/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);
                 }
             }
         }

package/lib/index.js

@@ -8,6 +8,7 @@ import { StandardRuleSource } from './standardRuleSource.js';
 import { EncodingDetector } from './encodingDetector.js';
 import { DataScaleGuard } from './dataScaleGuard.js';
 import { UrlReachabilityChecker } from './urlReachabilityChecker.js';
+import { InputBoundaryChecker } from './input-boundary-checker.js';
 export function apply(ctx) {
     ctx.tools.register({
         name: 'inspect_gov_data',
@@ -93,6 +94,11 @@ export function apply(ctx) {
                     if (raw.trim() === '') {
                         return JSON.stringify({ error: 'GOV_DATA_INPUT_INVALID', message: '无数据，请确认输入文件内容' });
                     }
+                    const inputLengthThreshold = govConfig?.inputLengthThreshold ?? 50000;
+                    const tooLargeResult = InputBoundaryChecker.checkTooLarge(raw, inputLengthThreshold);
+                    if (tooLargeResult.isTooLarge) {
+                        return JSON.stringify({ error: 'GOV_DATA_INPUT_TOO_LARGE', message: '输入数据超过处理上限，请分批提交' });
+                    }
                     data = JSON.parse(raw);
                     if (!Array.isArray(data))
                         data = [data];
@@ -103,6 +109,10 @@ export function apply(ctx) {
                 if (data.length === 0) {
                     return JSON.stringify({ error: 'GOV_DATA_INPUT_INVALID', message: '无数据，请确认输入文件内容' });
                 }
+                const emptyCheck = InputBoundaryChecker.checkEmpty(data);
+                if (emptyCheck.isEmpty) {
+                    return JSON.stringify({ error: 'GOV_DATA_NO_DATA', message: '未检测到有效数据' });
+                }
                 const maxFieldCount = rulesConfig.govDataInspection?.maxFieldCount;
                 const scaleResult = DataScaleGuard.check(data, maxFieldCount);
                 if (scaleResult.exceeded) {
@@ -166,7 +176,12 @@ export function apply(ctx) {
                     result.degradedReason = degradedReason;
                 }
                 if (mode === 'guide' || mode === 'full') {
-                    const orchestrateResult = InspectionOrchestrator.orchestrate(data, govConfigTyped, kb, standardRules, { degradedMode, itemTypeOverride });
+                    const orchestrateResult = InspectionOrchestrator.orchestrate(data, govConfigTyped, kb, standardRules, {
+                        degradedMode,
+                        itemTypeOverride,
+                        localTermsPath: govConfig?.localTermsPath,
+                        degradedSimilarityThreshold: govConfig?.degradedSimilarityThreshold,
+                    });
                     result.guideInspection = orchestrateResult;
                     if (orchestrateResult.warnings && orchestrateResult.warnings.length > 0) {
                         result.warnings = orchestrateResult.warnings;

package/lib/input-boundary-checker.js

@@ -0,0 +1,20 @@
+export const InputBoundaryChecker = {
+    checkEmpty(data) {
+        if (!Array.isArray(data) || data.length === 0)
+            return { isEmpty: true };
+        for (const item of data) {
+            if (typeof item !== 'object' || item === null)
+                return { isEmpty: false };
+            const values = Object.values(item);
+            const hasValid = values.some((v) => v !== undefined && v !== null && v !== '' && (typeof v !== 'string' || v.trim() !== ''));
+            if (hasValid)
+                return { isEmpty: false };
+        }
+        return { isEmpty: true };
+    },
+    checkTooLarge(raw, threshold) {
+        const length = raw.length;
+        return { isTooLarge: length > threshold, length };
+    },
+};
+//# sourceMappingURL=input-boundary-checker.js.map

package/lib/inspectionOrchestrator.js

@@ -22,7 +22,7 @@ export const InspectionOrchestrator = {
             const isComplete = missingDetails.length === 0;
             if (isComplete)
                 completeCount++;
-            const semanticResult = SemanticRuleEngine.detect(guide, guideId, kb, config.itemTypeMatching, config.severityMapping, { degradedMode: options?.degradedMode, itemTypeOverride: options?.itemTypeOverride });
+            const semanticResult = SemanticRuleEngine.detect(guide, guideId, kb, config.itemTypeMatching, config.severityMapping, { degradedMode: options?.degradedMode, itemTypeOverride: options?.itemTypeOverride, localTermsPath: options?.localTermsPath, degradedSimilarityThreshold: options?.degradedSimilarityThreshold });
             allErrorDetails.push(...semanticResult.details);
             if (semanticResult.warning) {
                 allWarnings.push(semanticResult.warning);

package/lib/local-terms-loader.js

@@ -0,0 +1,26 @@
+import { existsSync } from 'node:fs';
+import { loadJsonConfig } from '@liuhange/dsh-data-asset-shared';
+const DEFAULT_LOCAL_TERMS_PATH = 'config/local-standard-terms.json';
+const SHARED_LOCAL_TERMS_PATH = '@liuhange/dsh-data-asset-shared/config/local-standard-terms.json';
+export const LocalTermsLoader = {
+    load(configPath) {
+        try {
+            if (configPath && !existsSync(configPath)) {
+                return { materials: [], conditions: [] };
+            }
+            const path = configPath ?? DEFAULT_LOCAL_TERMS_PATH;
+            const raw = loadJsonConfig('LOCAL_TERMS_PATH', path, SHARED_LOCAL_TERMS_PATH);
+            const parsed = raw;
+            if (typeof parsed !== 'object' || parsed === null)
+                return { materials: [], conditions: [] };
+            const obj = parsed;
+            const materials = Array.isArray(obj.materials) ? obj.materials.filter((m) => typeof m === 'string') : [];
+            const conditions = Array.isArray(obj.conditions) ? obj.conditions.filter((c) => typeof c === 'string') : [];
+            return { materials, conditions };
+        }
+        catch {
+            return { materials: [], conditions: [] };
+        }
+    },
+};
+//# sourceMappingURL=local-terms-loader.js.map

package/lib/logicRuleEngine.js

@@ -103,11 +103,40 @@ function ruleMaterialCondition(guide, guideId, rule, severityMapping) {
     }
     return [];
 }
+function ruleConditionAgeProxy(guide, guideId, rule, severityMapping) {
+    const condition = String(guide['办理条件'] ?? '');
+    const process = String(guide['办理流程'] ?? '');
+    if (!condition || !process)
+        return [];
+    if (!rule.triggerKeywords || rule.triggerKeywords.length === 0)
+        return [];
+    const ageKeywords = rule.triggerKeywords.filter((kw) => !kw.includes('代办'));
+    const proxyKeywords = rule.triggerKeywords.filter((kw) => kw.includes('代办'));
+    if (ageKeywords.length === 0 || proxyKeywords.length === 0)
+        return [];
+    const ageHit = ageKeywords.some((kw) => condition.includes(kw));
+    const proxyHit = proxyKeywords.some((kw) => process.includes(kw));
+    if (ageHit && proxyHit) {
+        return [
+            ErrorDetailBuilder.build({
+                guideId,
+                field: '办理流程',
+                errorType: 'logical',
+                description: `办理条件要求年满18周岁，但办理流程允许监护人代办，两者存在逻辑矛盾。[条款:${rule.standardClause}]`,
+                suggestion: `建议明确：未成年人由监护人代办，或删除年龄限制`,
+                dataSource: 'standard',
+                standardClause: rule.standardClause,
+            }, severityMapping),
+        ];
+    }
+    return [];
+}
 const RULE_DISPATCH = {
     LOG_SITE_INSPECTION_001: ruleSiteInspection,
     LOG_INSTANT_HANDLE_001: ruleInstantHandle,
     LOG_CONDITION_PROXY_001: ruleConditionProxy,
     LOG_MATERIAL_CONDITION_001: ruleMaterialCondition,
+    LOG_CONDITION_AGE_PROXY_001: ruleConditionAgeProxy,
 };
 export const LogicRuleEngine = {
     detect(guide, guideId, rules, severityMapping) {

package/lib/semanticRuleEngine.js

@@ -1,5 +1,6 @@
 import { ErrorDetailBuilder } from './errorDetailBuilder.js';
 import { UnmatchedWarningBuilder } from './unmatchedWarningBuilder.js';
+import { LocalTermsLoader } from './local-terms-loader.js';
 const FLOW_FIELD_KEYS = ['办理流程', '工作流程', '流程描述', '业务流程', '办理环节'];
 function matchItemType(guide, itemTypeMatching, options) {
     if (options?.itemTypeOverride) {
@@ -175,7 +176,39 @@ export const SemanticRuleEngine = {
         }
         const hasKbData = kb.timeLimits.length > 0 || kb.materials.length > 0 || kb.conditions.length > 0;
         if (!hasKbData && options?.degradedMode) {
-            return { details: [] };
+            const localTerms = LocalTermsLoader.load(options.localTermsPath);
+            if (localTerms.materials.length === 0) {
+                return { details: [] };
+            }
+            const threshold = options.degradedSimilarityThreshold ?? 0.8;
+            const materialStr = String(guide['申请材料'] ?? '');
+            if (!materialStr)
+                return { details: [] };
+            const materials = materialStr.split(/[、,，;；\n]/).map((s) => s.trim()).filter(Boolean);
+            const details = [];
+            for (const mat of materials) {
+                let maxSim = 0;
+                let closestTerm = '';
+                for (const term of localTerms.materials) {
+                    const sim = levenshteinSimilarity(mat, term);
+                    if (sim > maxSim) {
+                        maxSim = sim;
+                        closestTerm = term;
+                    }
+                }
+                if (maxSim < threshold && maxSim > 0) {
+                    details.push(ErrorDetailBuilder.build({
+                        guideId,
+                        field: '申请材料',
+                        errorType: 'semantic',
+                        description: `申请材料"${mat}"与标准词表"${closestTerm}"高度相似（相似度${maxSim.toFixed(2)}），可能存在笔误。[降级模式·本地词表校验]`,
+                        suggestion: `建议将"${mat}"修改为标准名称"${closestTerm}"`,
+                        dataSource: 'standard',
+                        standardClause: '降级模式·本地词表校验',
+                    }, severityMapping));
+                }
+            }
+            return { details };
         }
         const details = [];
         details.push(...detectTimeLimit(guide, guideId, itemType, kb, severityMapping));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@liuhange/dsh-gov-data-inspector",
   "description": "Government data inspection plugin: service guide quality check and public data asset classification",
-  "version": "3.1.4",
+  "version": "3.1.5",
   "publishConfig": {
     "access": "public"
   },
@@ -27,6 +27,11 @@
     "cordis.patch.yml"
   ],
   "license": "MIT",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "build": "tsc"
+  },
   "dependencies": {
     "@liuhange/dsh-data-asset-shared": "^3.1.0"
   },
@@ -64,10 +69,5 @@
     "plugin",
     "open-source"
   ],
-  "homepage": "https://github.com/liuhange789/data-asset-inspector#readme",
-  "scripts": {
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "build": "tsc"
-  }
-}
+  "homepage": "https://github.com/liuhange789/data-asset-inspector#readme"
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 liuhange789
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.