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

package/lib/index.js

@@ -5,6 +5,10 @@ import { resolvePolicyBasis } from './policyBasis.js';
 import { KnowledgeBaseLoader } from './knowledgeBaseLoader.js';
 import { InspectionOrchestrator } from './inspectionOrchestrator.js';
 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',
@@ -14,6 +18,7 @@ export function apply(ctx) {
             properties: {
                 dataSource: { type: 'string', description: '政务数据文件路径' },
                 inspectionMode: { type: 'string', enum: ['guide', 'classification', 'full'] },
+                itemTypeOverride: { type: 'string', description: '手动指定事项类型，覆盖自动匹配结果' },
             },
             required: ['dataSource'],
         },
@@ -29,11 +34,91 @@ export function apply(ctx) {
                 catch {
                     return JSON.stringify({ error: 'GOV_DATA_RULES_MISSING', message: '无法加载business-rules.json' });
                 }
-                const govConfig = rulesConfig.govDataInspection;
-                if (!govConfig) {
+                const govConfigRaw = rulesConfig.govDataInspection;
+                if (!govConfigRaw || typeof govConfigRaw !== 'object') {
                     return JSON.stringify({ error: 'GOV_DATA_RULES_MISSING', message: 'govDataInspection配置段缺失' });
                 }
-                const credentials = govConfig.dataSourceCredentials;
+                const govConfig = govConfigRaw;
+                const requiredFields = {
+                    guideRequiredElements: 'string[]',
+                    logicErrorRules: 'array',
+                    formatRules: 'array',
+                    severityMapping: 'object',
+                    scoreWeights: 'object',
+                    convenienceWeights: 'object',
+                    gbt47949Mapping: 'object',
+                    itemTypeMatching: 'object',
+                    materialConciseThreshold: 'number',
+                    missingFieldStandardClause: 'string',
+                    dataSourcePriority: 'array',
+                    dataSourceCredentials: 'object',
+                };
+                for (const [field, expectedType] of Object.entries(requiredFields)) {
+                    const val = govConfig[field];
+                    if (val === undefined || val === null) {
+                        return JSON.stringify({ error: 'GOV_DATA_RULES_MISSING', message: `govDataInspection.${field}配置缺失` });
+                    }
+                    if (expectedType === 'array' && !Array.isArray(val)) {
+                        return JSON.stringify({ error: 'GOV_DATA_RULES_MISSING', message: `govDataInspection.${field}应为数组` });
+                    }
+                    if (expectedType === 'object' && (typeof val !== 'object' || Array.isArray(val))) {
+                        return JSON.stringify({ error: 'GOV_DATA_RULES_MISSING', message: `govDataInspection.${field}应为对象` });
+                    }
+                    if (expectedType === 'string' && typeof val !== 'string') {
+                        return JSON.stringify({ error: 'GOV_DATA_RULES_MISSING', message: `govDataInspection.${field}应为字符串` });
+                    }
+                    if (expectedType === 'number' && typeof val !== 'number') {
+                        return JSON.stringify({ error: 'GOV_DATA_RULES_MISSING', message: `govDataInspection.${field}应为数字` });
+                    }
+                    if (expectedType === 'string[]' && (!Array.isArray(val) || val.some((v) => typeof v !== 'string'))) {
+                        return JSON.stringify({ error: 'GOV_DATA_RULES_MISSING', message: `govDataInspection.${field}应为字符串数组` });
+                    }
+                }
+                const govConfigTyped = govConfig;
+                const encodingResult = EncodingDetector.detect(args.dataSource);
+                if (encodingResult.content === null) {
+                    if (encodingResult.encodingError === '文件为空') {
+                        return JSON.stringify({ error: 'GOV_DATA_INPUT_INVALID', message: '无数据，请确认输入文件内容' });
+                    }
+                    if (encodingResult.encodingError?.includes('无法读取文件')) {
+                        const reachability = await UrlReachabilityChecker.check(args.dataSource);
+                        if (!reachability.reachable) {
+                            return JSON.stringify({ error: 'GOV_DATA_URL_UNREACHABLE', message: reachability.error ?? '数据源不可达，请检查路径或 URL' });
+                        }
+                    }
+                    return JSON.stringify({ error: 'GOV_DATA_ENCODING_ERROR', message: encodingResult.encodingError ?? '文件编码错误' });
+                }
+                let data;
+                try {
+                    const raw = encodingResult.content;
+                    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];
+                }
+                catch (e) {
+                    return JSON.stringify({ error: 'GOV_DATA_INPUT_INVALID', message: `JSON 格式错误，请检查文件内容: ${e.message}` });
+                }
+                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) {
+                    return JSON.stringify({ error: 'GOV_DATA_SCALE_EXCEEDED', message: `数据量超出处理上限（字段数${scaleResult.fieldCount}），请分批处理或增加maxFieldCount配置` });
+                }
+                const credentials = govConfigTyped.dataSourceCredentials;
                 const credConfig = {
                     national: {
                         apiKey: process.env[credentials.national.apiKey],
@@ -44,13 +129,10 @@ export function apply(ctx) {
                         endpoint: process.env[credentials.provincial.endpoint],
                     },
                 };
-                let kb;
-                try {
-                    kb = await KnowledgeBaseLoader.load(credConfig, govConfig.dataSourcePriority);
-                }
-                catch {
-                    return JSON.stringify({ error: 'GOV_DATA_KB_MISSING', message: '官方数据源全部不可用，语义错误检测已中止' });
-                }
+                const kbLoadResult = await KnowledgeBaseLoader.load(credConfig, govConfigTyped.dataSourcePriority);
+                const kb = kbLoadResult.kb;
+                const degradedMode = kbLoadResult.degraded;
+                const degradedReason = kbLoadResult.degradedReason;
                 const dataSourceStatus = KnowledgeBaseLoader.getDataSourceStatus();
                 let standardRules;
                 const stdRuleResult = await StandardRuleSource.fetch({
@@ -62,10 +144,13 @@ export function apply(ctx) {
                     dataSourceStatus.standard = stdRuleResult.status;
                 }
                 else {
-                    standardRules = govConfig.logicErrorRules;
+                    standardRules = govConfigTyped.logicErrorRules;
                 }
                 if (!standardRules || standardRules.length === 0) {
-                    return JSON.stringify({ error: 'GOV_DATA_LOGIC_RULES_MISSING', message: '标准规则集缺失，逻辑错误检测已中止' });
+                    if (!degradedMode) {
+                        return JSON.stringify({ error: 'GOV_DATA_LOGIC_RULES_MISSING', message: '标准规则集缺失，逻辑错误检测已中止' });
+                    }
+                    standardRules = [];
                 }
                 let policyBasis;
                 try {
@@ -77,18 +162,8 @@ export function apply(ctx) {
                 catch {
                     return JSON.stringify({ error: 'GOV_DATA_POLICY_MISSING', message: '政策依据配置加载失败' });
                 }
-                let data;
-                try {
-                    const { readFileSync } = await import('node:fs');
-                    const raw = readFileSync(args.dataSource, 'utf-8');
-                    data = JSON.parse(raw);
-                    if (!Array.isArray(data))
-                        data = [data];
-                }
-                catch {
-                    return JSON.stringify({ error: 'GOV_DATA_INPUT_INVALID', message: `无法加载数据: ${args.dataSource}` });
-                }
                 const mode = args.inspectionMode ?? 'full';
+                const itemTypeOverride = args.itemTypeOverride;
                 const result = {
                     dataSource: args.dataSource,
                     inspectionMode: mode,
@@ -96,11 +171,24 @@ export function apply(ctx) {
                     policyBasis,
                     dataSourceStatus,
                 };
+                if (degradedMode) {
+                    result.degradedMode = true;
+                    result.degradedReason = degradedReason;
+                }
                 if (mode === 'guide' || mode === 'full') {
-                    result.guideInspection = InspectionOrchestrator.orchestrate(data, govConfig, kb, standardRules);
+                    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;
+                    }
                 }
                 if (mode === 'classification' || mode === 'full') {
-                    result.classification = classifyGovData(data, govConfig.gbt47949Mapping);
+                    result.classification = classifyGovData(data, govConfigTyped.gbt47949Mapping);
                 }
                 return JSON.stringify(result, null, 2);
             }

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

@@ -5,9 +5,10 @@ import { FormatValidator } from './formatValidator.js';
 import { QualityMetricsCalculator } from './qualityMetricsCalculator.js';
 import { ErrorDetailBuilder } from './errorDetailBuilder.js';
 export const InspectionOrchestrator = {
-    orchestrate(data, config, kb, standardRules) {
+    orchestrate(data, config, kb, standardRules, options) {
         const allErrorDetails = [];
         const allFormatIssues = [];
+        const allWarnings = [];
         let completeCount = 0;
         let serviceConvenience = 0;
         for (let i = 0; i < data.length; i++) {
@@ -21,8 +22,11 @@ export const InspectionOrchestrator = {
             const isComplete = missingDetails.length === 0;
             if (isComplete)
                 completeCount++;
-            const semanticDetails = SemanticRuleEngine.detect(guide, guideId, kb, config.itemTypeMatching, config.severityMapping);
-            allErrorDetails.push(...semanticDetails);
+            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);
+            }
             const logicalDetails = LogicRuleEngine.detect(guide, guideId, standardRules, config.severityMapping);
             allErrorDetails.push(...logicalDetails);
             const formatIssues = FormatValidator.validate(guide, guideId, config.formatRules);
@@ -64,6 +68,7 @@ export const InspectionOrchestrator = {
             serviceConvenience: Math.round(serviceConvenience * 100) / 100,
             totalGuidesChecked: data.length,
             detectionRates,
+            warnings: allWarnings,
         };
     },
 };

package/lib/knowledgeBaseLoader.js

@@ -71,15 +71,20 @@ export const KnowledgeBaseLoader = {
             standard: FAILED_STATUS,
         };
         const allFailed = nationalResult.status.status === 'failed' && provincialResult.status.status === 'failed';
-        if (allFailed) {
-            throw new Error('GOV_DATA_KB_MISSING: 官方数据源全部不可用，语义错误检测已中止');
-        }
-        return {
+        const kb = {
             timeLimits: cachedTimeLimits,
             materials: cachedMaterials,
             conditions: cachedConditions,
             dataSourceStatus: cachedDataSourceStatus,
         };
+        if (allFailed) {
+            return {
+                kb,
+                degraded: true,
+                degradedReason: '官方数据源全部不可用，已降级为本地规则检测模式',
+            };
+        }
+        return { kb, degraded: false };
     },
     getTimeLimits() {
         if (!cachedTimeLimits)

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/nationalDataSource.js

@@ -1,7 +1,26 @@
+import { EndpointResolver } from './endpointResolver.js';
 const FAILED_RESULT = {
     data: [],
     status: { status: 'failed', fetchedAt: '', recordCount: 0 },
 };
+function parseOfficialData(raw, source) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .filter((item) => item && typeof item === 'object')
+        .map((item) => ({
+        dataSource: source,
+        itemType: String(item.itemType ?? ''),
+        legalUpperLimit: item.legalUpperLimit,
+        legalLowerLimit: item.legalLowerLimit,
+        standardName: item.standardName,
+        isRequired: item.isRequired,
+        elementName: item.elementName,
+        standardValue: item.standardValue,
+        standardClause: String(item.standardClause ?? ''),
+    }))
+        .filter((d) => d.itemType && d.standardClause);
+}
 export const NationalDataSource = {
     async fetch(credentials) {
         const apiKey = credentials?.apiKey ?? process.env.NATIONAL_API_KEY;
@@ -9,12 +28,23 @@ export const NationalDataSource = {
         if (!apiKey || !endpoint) {
             return { ...FAILED_RESULT, status: { ...FAILED_RESULT.status } };
         }
-        if (!endpoint.startsWith('https://')) {
+        const resolved = EndpointResolver.resolve(endpoint);
+        if (!resolved) {
             return { ...FAILED_RESULT, status: { ...FAILED_RESULT.status } };
         }
         try {
-            const url = new URL(endpoint);
-            url.searchParams.set('apiKey', apiKey);
+            if (resolved.kind === 'file') {
+                const { readFileSync } = require('node:fs');
+                const raw = JSON.parse(readFileSync(resolved.target, 'utf-8'));
+                const data = parseOfficialData(raw, 'national');
+                return {
+                    data,
+                    status: { status: 'success', fetchedAt: new Date().toISOString(), recordCount: data.length },
+                };
+            }
+            const url = new URL(resolved.target);
+            if (apiKey)
+                url.searchParams.set('apiKey', apiKey);
             const response = await fetch(url.toString(), {
                 method: 'GET',
                 headers: { 'Accept': 'application/json' },
@@ -23,22 +53,7 @@ export const NationalDataSource = {
             if (!response.ok)
                 return { ...FAILED_RESULT, status: { ...FAILED_RESULT.status } };
             const raw = await response.json();
-            if (!Array.isArray(raw))
-                return { ...FAILED_RESULT, status: { ...FAILED_RESULT.status } };
-            const data = raw
-                .filter((item) => item && typeof item === 'object')
-                .map((item) => ({
-                dataSource: 'national',
-                itemType: String(item.itemType ?? ''),
-                legalUpperLimit: item.legalUpperLimit,
-                legalLowerLimit: item.legalLowerLimit,
-                standardName: item.standardName,
-                isRequired: item.isRequired,
-                elementName: item.elementName,
-                standardValue: item.standardValue,
-                standardClause: String(item.standardClause ?? ''),
-            }))
-                .filter((d) => d.itemType && d.standardClause);
+            const data = parseOfficialData(raw, 'national');
             return {
                 data,
                 status: { status: 'success', fetchedAt: new Date().toISOString(), recordCount: data.length },

package/lib/provincialDataSource.js

@@ -1,7 +1,26 @@
+import { EndpointResolver } from './endpointResolver.js';
 const FAILED_RESULT = {
     data: [],
     status: { status: 'failed', fetchedAt: '', recordCount: 0 },
 };
+function parseOfficialData(raw, source) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .filter((item) => item && typeof item === 'object')
+        .map((item) => ({
+        dataSource: source,
+        itemType: String(item.itemType ?? ''),
+        legalUpperLimit: item.legalUpperLimit,
+        legalLowerLimit: item.legalLowerLimit,
+        standardName: item.standardName,
+        isRequired: item.isRequired,
+        elementName: item.elementName,
+        standardValue: item.standardValue,
+        standardClause: String(item.standardClause ?? ''),
+    }))
+        .filter((d) => d.itemType && d.standardClause);
+}
 export const ProvincialDataSource = {
     async fetch(credentials) {
         const apiKey = credentials?.apiKey ?? process.env.PROVINCIAL_API_KEY;
@@ -9,12 +28,23 @@ export const ProvincialDataSource = {
         if (!apiKey || !endpoint) {
             return { ...FAILED_RESULT, status: { ...FAILED_RESULT.status } };
         }
-        if (!endpoint.startsWith('https://')) {
+        const resolved = EndpointResolver.resolve(endpoint);
+        if (!resolved) {
             return { ...FAILED_RESULT, status: { ...FAILED_RESULT.status } };
         }
         try {
-            const url = new URL(endpoint);
-            url.searchParams.set('apiKey', apiKey);
+            if (resolved.kind === 'file') {
+                const { readFileSync } = require('node:fs');
+                const raw = JSON.parse(readFileSync(resolved.target, 'utf-8'));
+                const data = parseOfficialData(raw, 'provincial');
+                return {
+                    data,
+                    status: { status: 'success', fetchedAt: new Date().toISOString(), recordCount: data.length },
+                };
+            }
+            const url = new URL(resolved.target);
+            if (apiKey)
+                url.searchParams.set('apiKey', apiKey);
             const response = await fetch(url.toString(), {
                 method: 'GET',
                 headers: { 'Accept': 'application/json' },
@@ -23,22 +53,7 @@ export const ProvincialDataSource = {
             if (!response.ok)
                 return { ...FAILED_RESULT, status: { ...FAILED_RESULT.status } };
             const raw = await response.json();
-            if (!Array.isArray(raw))
-                return { ...FAILED_RESULT, status: { ...FAILED_RESULT.status } };
-            const data = raw
-                .filter((item) => item && typeof item === 'object')
-                .map((item) => ({
-                dataSource: 'provincial',
-                itemType: String(item.itemType ?? ''),
-                legalUpperLimit: item.legalUpperLimit,
-                legalLowerLimit: item.legalLowerLimit,
-                standardName: item.standardName,
-                isRequired: item.isRequired,
-                elementName: item.elementName,
-                standardValue: item.standardValue,
-                standardClause: String(item.standardClause ?? ''),
-            }))
-                .filter((d) => d.itemType && d.standardClause);
+            const data = parseOfficialData(raw, 'provincial');
             return {
                 data,
                 status: { status: 'success', fetchedAt: new Date().toISOString(), recordCount: data.length },

package/lib/semanticRuleEngine.js

@@ -1,16 +1,36 @@
 import { ErrorDetailBuilder } from './errorDetailBuilder.js';
-function matchItemType(guide, itemTypeMatching) {
+import { UnmatchedWarningBuilder } from './unmatchedWarningBuilder.js';
+import { LocalTermsLoader } from './local-terms-loader.js';
+const FLOW_FIELD_KEYS = ['办理流程', '工作流程', '流程描述', '业务流程', '办理环节'];
+function matchItemType(guide, itemTypeMatching, options) {
+    if (options?.itemTypeOverride) {
+        return { itemType: options.itemTypeOverride, matchSource: 'manual' };
+    }
     if (!itemTypeMatching)
-        return null;
+        return { itemType: null, matchSource: null };
     const itemName = String(guide['事项名称'] ?? '');
     const itemCode = String(guide['事项编码'] ?? '');
     for (const [itemType, rule] of Object.entries(itemTypeMatching)) {
-        if (rule.keywords.some((kw) => itemName.includes(kw)))
-            return itemType;
-        if (itemCode && itemCode.startsWith(rule.codePrefix))
-            return itemType;
+        if (rule.keywords.some((kw) => itemName.includes(kw))) {
+            return { itemType, matchSource: 'name' };
+        }
+    }
+    for (const [itemType, rule] of Object.entries(itemTypeMatching)) {
+        if (itemCode && itemCode.startsWith(rule.codePrefix)) {
+            return { itemType, matchSource: 'code' };
+        }
+    }
+    for (const flowKey of FLOW_FIELD_KEYS) {
+        const flowText = String(guide[flowKey] ?? '');
+        if (!flowText)
+            continue;
+        for (const [itemType, rule] of Object.entries(itemTypeMatching)) {
+            if (rule.keywords.some((kw) => flowText.includes(kw))) {
+                return { itemType, matchSource: 'flow' };
+            }
+        }
     }
-    return null;
+    return { itemType: null, matchSource: null };
 }
 function extractTimeLimitDays(timeLimit) {
     const str = String(timeLimit ?? '');
@@ -141,18 +161,60 @@ function detectConditions(guide, guideId, itemType, kb, severityMapping) {
     return details;
 }
 export const SemanticRuleEngine = {
-    detect(guide, guideId, kb, itemTypeMatching, severityMapping) {
+    detect(guide, guideId, kb, itemTypeMatching, severityMapping, options) {
+        const matchResult = matchItemType(guide, itemTypeMatching, options);
+        const itemType = matchResult.itemType;
+        if (!itemType) {
+            const warning = UnmatchedWarningBuilder.build(guideId);
+            return { details: [], unmatched: true, warning };
+        }
         if (!kb || !kb.timeLimits || !kb.materials || !kb.conditions) {
+            if (options?.degradedMode) {
+                return { details: [] };
+            }
             throw new Error('GOV_DATA_KB_MISSING: 标准知识库不可用，语义错误检测已中止');
         }
-        const itemType = matchItemType(guide, itemTypeMatching);
-        if (!itemType)
-            return [];
+        const hasKbData = kb.timeLimits.length > 0 || kb.materials.length > 0 || kb.conditions.length > 0;
+        if (!hasKbData && options?.degradedMode) {
+            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));
         details.push(...detectMaterials(guide, guideId, itemType, kb, severityMapping));
         details.push(...detectConditions(guide, guideId, itemType, kb, severityMapping));
-        return details;
+        return { details };
     },
     matchItemType,
     extractTimeLimitDays,

package/lib/unmatchedWarningBuilder.js

@@ -0,0 +1,10 @@
+export const UnmatchedWarningBuilder = {
+    build(guideId) {
+        return {
+            type: 'UNMATCHED_ITEM_TYPE',
+            guideId,
+            message: '该事项未匹配到检测规则，语义检测被跳过',
+        };
+    },
+};
+//# sourceMappingURL=unmatchedWarningBuilder.js.map

package/lib/urlReachabilityChecker.js

@@ -0,0 +1,28 @@
+export const UrlReachabilityChecker = {
+    async check(dataSource) {
+        if (!dataSource || typeof dataSource !== 'string') {
+            return { reachable: false, error: '数据源路径为空' };
+        }
+        if (dataSource.startsWith('http://') || dataSource.startsWith('https://')) {
+            try {
+                const response = await fetch(dataSource, {
+                    method: 'HEAD',
+                    signal: AbortSignal.timeout(5000),
+                });
+                if (response.ok) {
+                    return { reachable: true };
+                }
+                return { reachable: false, error: `数据源不可达，HTTP状态码: ${response.status}` };
+            }
+            catch (e) {
+                return { reachable: false, error: `数据源不可达: ${e.message}` };
+            }
+        }
+        const { existsSync } = require('node:fs');
+        if (existsSync(dataSource)) {
+            return { reachable: true };
+        }
+        return { reachable: false, error: '数据源不可达，请检查路径或 URL' };
+    },
+};
+//# sourceMappingURL=urlReachabilityChecker.js.map