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

package/lib/formatValidator.js

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

package/lib/index.js

@@ -2,10 +2,13 @@ export const name = '@liuhange/dsh-gov-data-inspector';
 export const inject = ['tools'];
 import { loadJsonConfig } from '@liuhange/dsh-data-asset-shared';
 import { resolvePolicyBasis } from './policyBasis.js';
+import { KnowledgeBaseLoader } from './knowledgeBaseLoader.js';
+import { InspectionOrchestrator } from './inspectionOrchestrator.js';
+import { StandardRuleSource } from './standardRuleSource.js';
 export function apply(ctx) {
     ctx.tools.register({
         name: 'inspect_gov_data',
-        description: '政务数据专项巡检，含办事指南质量检查和公共数据资产分类',
+        description: '政务数据专项巡检，含办事指南质量检查（漏项/语义/逻辑/格式五维检测）和公共数据资产分类',
         parameters: {
             type: 'object',
             properties: {
@@ -30,6 +33,50 @@ export function apply(ctx) {
                 if (!govConfig) {
                     return JSON.stringify({ error: 'GOV_DATA_RULES_MISSING', message: 'govDataInspection配置段缺失' });
                 }
+                const credentials = govConfig.dataSourceCredentials;
+                const credConfig = {
+                    national: {
+                        apiKey: process.env[credentials.national.apiKey],
+                        endpoint: process.env[credentials.national.endpoint],
+                    },
+                    provincial: {
+                        apiKey: process.env[credentials.provincial.apiKey],
+                        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 dataSourceStatus = KnowledgeBaseLoader.getDataSourceStatus();
+                let standardRules;
+                const stdRuleResult = await StandardRuleSource.fetch({
+                    docPath: process.env[credentials.standard.docPath],
+                    endpoint: process.env[credentials.standard.endpoint],
+                });
+                if (stdRuleResult.rules.length > 0) {
+                    standardRules = stdRuleResult.rules;
+                    dataSourceStatus.standard = stdRuleResult.status;
+                }
+                else {
+                    standardRules = govConfig.logicErrorRules;
+                }
+                if (!standardRules || standardRules.length === 0) {
+                    return JSON.stringify({ error: 'GOV_DATA_LOGIC_RULES_MISSING', message: '标准规则集缺失，逻辑错误检测已中止' });
+                }
+                let policyBasis;
+                try {
+                    policyBasis = resolvePolicyBasis('GOV_DATA_INSPECTION');
+                    if (!policyBasis || policyBasis.length === 0) {
+                        return JSON.stringify({ error: 'GOV_DATA_POLICY_MISSING', message: '政策依据配置缺失' });
+                    }
+                }
+                catch {
+                    return JSON.stringify({ error: 'GOV_DATA_POLICY_MISSING', message: '政策依据配置加载失败' });
+                }
                 let data;
                 try {
                     const { readFileSync } = await import('node:fs');
@@ -42,15 +89,15 @@ export function apply(ctx) {
                     return JSON.stringify({ error: 'GOV_DATA_INPUT_INVALID', message: `无法加载数据: ${args.dataSource}` });
                 }
                 const mode = args.inspectionMode ?? 'full';
-                const policyBasis = resolvePolicyBasis('GOV_DATA_INSPECTION');
                 const result = {
                     dataSource: args.dataSource,
                     inspectionMode: mode,
                     timestamp: new Date().toISOString(),
                     policyBasis,
+                    dataSourceStatus,
                 };
                 if (mode === 'guide' || mode === 'full') {
-                    result.guideInspection = inspectGuides(data, govConfig.guideRequiredElements, govConfig.convenienceWeights);
+                    result.guideInspection = InspectionOrchestrator.orchestrate(data, govConfig, kb, standardRules);
                 }
                 if (mode === 'classification' || mode === 'full') {
                     result.classification = classifyGovData(data, govConfig.gbt47949Mapping);
@@ -63,39 +110,6 @@ export function apply(ctx) {
         },
     });
 }
-function inspectGuides(data, requiredElements, weights) {
-    let completeCount = 0;
-    let semanticErrors = 0;
-    let logicalErrors = 0;
-    let serviceConvenience = 0;
-    for (const row of data) {
-        if (typeof row === 'object' && row !== null) {
-            const obj = row;
-            let hasAllElements = true;
-            for (const elem of requiredElements) {
-                if (!obj[elem]) {
-                    hasAllElements = false;
-                    semanticErrors++;
-                }
-            }
-            if (hasAllElements)
-                completeCount++;
-            if (obj.timeLimit && typeof obj.timeLimit === 'string' && obj.timeLimit.includes('工作日')) {
-                serviceConvenience += weights.timeLimit ?? 0.3;
-            }
-            if (obj.onlineCapable === true) {
-                serviceConvenience += weights.onlineCapable ?? 0.4;
-            }
-        }
-    }
-    return {
-        completeness: data.length > 0 ? Math.round((completeCount / data.length) * 100) : 0,
-        semanticErrors,
-        logicalErrors,
-        serviceConvenience: Math.round(serviceConvenience * 100) / 100,
-        totalGuidesChecked: data.length,
-    };
-}
 function classifyGovData(data, gbtMapping) {
     let structured = 0, semiStructured = 0, unstructured = 0;
     for (const row of data) {

package/lib/inspectionOrchestrator.js

@@ -0,0 +1,70 @@
+import { MissingFieldDetector } from './missingFieldDetector.js';
+import { SemanticRuleEngine } from './semanticRuleEngine.js';
+import { LogicRuleEngine } from './logicRuleEngine.js';
+import { FormatValidator } from './formatValidator.js';
+import { QualityMetricsCalculator } from './qualityMetricsCalculator.js';
+import { ErrorDetailBuilder } from './errorDetailBuilder.js';
+export const InspectionOrchestrator = {
+    orchestrate(data, config, kb, standardRules) {
+        const allErrorDetails = [];
+        const allFormatIssues = [];
+        let completeCount = 0;
+        let serviceConvenience = 0;
+        for (let i = 0; i < data.length; i++) {
+            const row = data[i];
+            if (typeof row !== 'object' || row === null)
+                continue;
+            const guide = row;
+            const guideId = String(guide['事项名称'] ?? `指南${i + 1}`);
+            const missingDetails = MissingFieldDetector.detect(guide, guideId, config.guideRequiredElements, config.severityMapping, undefined, config.missingFieldStandardClause);
+            allErrorDetails.push(...missingDetails);
+            const isComplete = missingDetails.length === 0;
+            if (isComplete)
+                completeCount++;
+            const semanticDetails = SemanticRuleEngine.detect(guide, guideId, kb, config.itemTypeMatching, config.severityMapping);
+            allErrorDetails.push(...semanticDetails);
+            const logicalDetails = LogicRuleEngine.detect(guide, guideId, standardRules, config.severityMapping);
+            allErrorDetails.push(...logicalDetails);
+            const formatIssues = FormatValidator.validate(guide, guideId, config.formatRules);
+            allFormatIssues.push(...formatIssues);
+            if (guide['办理时限'] && typeof guide['办理时限'] === 'string' && guide['办理时限'].includes('工作日')) {
+                serviceConvenience += config.convenienceWeights.timeLimit ?? 0.3;
+            }
+            if (guide.onlineCapable === true) {
+                serviceConvenience += config.convenienceWeights.onlineCapable ?? 0.4;
+            }
+            const materialStr = String(guide['申请材料'] ?? '');
+            if (materialStr) {
+                const materialCount = materialStr.split(/[、,，;；\n]/).filter(Boolean).length;
+                if (materialCount <= (config.materialConciseThreshold ?? 5)) {
+                    serviceConvenience += config.convenienceWeights.materialConcise ?? 0.3;
+                }
+            }
+        }
+        const counts = ErrorDetailBuilder.countByType(allErrorDetails);
+        const totalFieldCount = data.length * config.guideRequiredElements.length;
+        const detectionRates = QualityMetricsCalculator.calculate({
+            semanticErrorCount: counts.semantic,
+            logicalErrorCount: counts.logical,
+            missingFieldCount: counts.missing,
+            formatIssueCount: allFormatIssues.length,
+            totalGuides: data.length,
+            requiredFieldCount: config.guideRequiredElements.length,
+            totalFieldCount: totalFieldCount > 0 ? totalFieldCount : 1,
+            errorDetails: allErrorDetails,
+            scoreWeights: config.scoreWeights,
+        });
+        return {
+            completeness: data.length > 0 ? Math.round((completeCount / data.length) * 100) : 0,
+            missingFields: counts.missing,
+            semanticErrors: counts.semantic,
+            logicalErrors: counts.logical,
+            errorDetails: allErrorDetails,
+            formatIssues: allFormatIssues,
+            serviceConvenience: Math.round(serviceConvenience * 100) / 100,
+            totalGuidesChecked: data.length,
+            detectionRates,
+        };
+    },
+};
+//# sourceMappingURL=inspectionOrchestrator.js.map

package/lib/knowledgeBaseLoader.js

@@ -0,0 +1,119 @@
+import { NationalDataSource } from './nationalDataSource.js';
+import { ProvincialDataSource } from './provincialDataSource.js';
+let cachedTimeLimits = null;
+let cachedMaterials = null;
+let cachedConditions = null;
+let cachedDataSourceStatus = null;
+const FAILED_STATUS = { status: 'failed', fetchedAt: '', recordCount: 0 };
+function mergeByPriority(national, provincial, priority) {
+    const merged = new Map();
+    const sources = { national, provincial };
+    for (const src of priority) {
+        const data = sources[src];
+        if (!data)
+            continue;
+        for (const item of data) {
+            const key = `${item.itemType}:${item.standardName ?? item.elementName ?? 'limit'}`;
+            if (!merged.has(key))
+                merged.set(key, item);
+        }
+    }
+    return Array.from(merged.values());
+}
+function toTimeLimits(data) {
+    return data
+        .filter((d) => d.legalUpperLimit !== undefined && d.legalLowerLimit !== undefined)
+        .map((d) => ({
+        itemType: d.itemType,
+        legalUpperLimit: d.legalUpperLimit,
+        legalLowerLimit: d.legalLowerLimit,
+        basisClause: d.standardClause,
+        dataSource: d.dataSource,
+        standardClause: d.standardClause,
+    }));
+}
+function toMaterials(data) {
+    return data
+        .filter((d) => d.standardName !== undefined)
+        .map((d) => ({
+        itemType: d.itemType,
+        standardName: d.standardName,
+        isRequired: d.isRequired ?? false,
+        basisClause: d.standardClause,
+        dataSource: d.dataSource,
+        standardClause: d.standardClause,
+    }));
+}
+function toConditions(data) {
+    return data
+        .filter((d) => d.elementName !== undefined && d.standardValue !== undefined)
+        .map((d) => ({
+        itemType: d.itemType,
+        elementName: d.elementName,
+        standardValue: d.standardValue,
+        basisClause: d.standardClause,
+        dataSource: d.dataSource,
+        standardClause: d.standardClause,
+    }));
+}
+export const KnowledgeBaseLoader = {
+    async load(credentials, dataSourcePriority) {
+        const priority = dataSourcePriority ?? ['provincial', 'national'];
+        const nationalResult = await NationalDataSource.fetch(credentials?.national);
+        const provincialResult = await ProvincialDataSource.fetch(credentials?.provincial);
+        const mergedData = mergeByPriority(nationalResult.data, provincialResult.data, priority);
+        cachedTimeLimits = toTimeLimits(mergedData);
+        cachedMaterials = toMaterials(mergedData);
+        cachedConditions = toConditions(mergedData);
+        cachedDataSourceStatus = {
+            national: nationalResult.status,
+            provincial: provincialResult.status,
+            standard: FAILED_STATUS,
+        };
+        const allFailed = nationalResult.status.status === 'failed' && provincialResult.status.status === 'failed';
+        if (allFailed) {
+            throw new Error('GOV_DATA_KB_MISSING: 官方数据源全部不可用，语义错误检测已中止');
+        }
+        return {
+            timeLimits: cachedTimeLimits,
+            materials: cachedMaterials,
+            conditions: cachedConditions,
+            dataSourceStatus: cachedDataSourceStatus,
+        };
+    },
+    getTimeLimits() {
+        if (!cachedTimeLimits)
+            throw new Error('GOV_DATA_KB_MISSING: 知识库尚未加载');
+        return cachedTimeLimits;
+    },
+    getMaterials() {
+        if (!cachedMaterials)
+            throw new Error('GOV_DATA_KB_MISSING: 知识库尚未加载');
+        return cachedMaterials;
+    },
+    getConditions() {
+        if (!cachedConditions)
+            throw new Error('GOV_DATA_KB_MISSING: 知识库尚未加载');
+        return cachedConditions;
+    },
+    getDataSourceStatus() {
+        if (!cachedDataSourceStatus) {
+            return {
+                national: FAILED_STATUS,
+                provincial: FAILED_STATUS,
+                standard: FAILED_STATUS,
+            };
+        }
+        return cachedDataSourceStatus;
+    },
+    isLoaded() {
+        return cachedTimeLimits !== null && cachedMaterials !== null && cachedConditions !== null;
+    },
+    _setTestData(kb) {
+        cachedTimeLimits = kb.timeLimits;
+        cachedMaterials = kb.materials;
+        cachedConditions = kb.conditions;
+        cachedDataSourceStatus = kb.dataSourceStatus;
+    },
+};
+//# sourceMappingURL=knowledgeBaseLoader.js.map

package/lib/logicRuleEngine.js

@@ -0,0 +1,133 @@
+import { ErrorDetailBuilder } from './errorDetailBuilder.js';
+function extractTimeLimitDays(timeLimit) {
+    const str = String(timeLimit ?? '');
+    const match = str.match(/(\d+)\s*个?\s*工作日/);
+    if (!match || !match[1])
+        return null;
+    return parseInt(match[1], 10);
+}
+function ruleSiteInspection(guide, guideId, rule, severityMapping) {
+    const process = String(guide['办理流程'] ?? '');
+    const timeLimit = String(guide['办理时限'] ?? '');
+    const triggerKw = rule.triggerKeywords[0];
+    if (!triggerKw || !process.includes(triggerKw) || !timeLimit)
+        return [];
+    const days = extractTimeLimitDays(timeLimit);
+    if (days === null)
+        return [];
+    const threshold = rule.threshold ?? 5;
+    if (days < threshold) {
+        return [
+            ErrorDetailBuilder.build({
+                guideId,
+                field: '办理时限',
+                errorType: 'logical',
+                description: `办理流程含"${triggerKw}"环节，但办理时限仅为${days}个工作日，少于${threshold}个工作日，存在逻辑矛盾。[条款:${rule.standardClause}]`,
+                suggestion: `建议将办理时限调整为不少于${threshold}个工作日，以确保${triggerKw}环节可充分执行`,
+                dataSource: 'standard',
+                standardClause: rule.standardClause,
+            }, severityMapping),
+        ];
+    }
+    return [];
+}
+function ruleInstantHandle(guide, guideId, rule, severityMapping) {
+    const process = String(guide['办理流程'] ?? '');
+    const timeLimit = String(guide['办理时限'] ?? '');
+    const triggerKw = rule.triggerKeywords[0];
+    if (!triggerKw || !process.includes(triggerKw) || !timeLimit)
+        return [];
+    const days = extractTimeLimitDays(timeLimit);
+    if (days === null)
+        return [];
+    const threshold = rule.threshold ?? 1;
+    if (days > threshold) {
+        return [
+            ErrorDetailBuilder.build({
+                guideId,
+                field: '办理时限',
+                errorType: 'logical',
+                description: `办理流程含"${triggerKw}"环节，但办理时限为${days}个工作日，与当场办理语义矛盾。[条款:${rule.standardClause}]`,
+                suggestion: `建议将办理流程改为非当场办理，或将办理时限调整为${threshold}个工作日以内`,
+                dataSource: 'standard',
+                standardClause: rule.standardClause,
+            }, severityMapping),
+        ];
+    }
+    return [];
+}
+function ruleConditionProxy(guide, guideId, rule, severityMapping) {
+    const condition = String(guide['办理条件'] ?? '');
+    const process = String(guide['办理流程'] ?? '');
+    if (!condition || !process)
+        return [];
+    const inPersonKws = rule.triggerKeywords.filter((kw) => kw.includes('本人'));
+    const proxyKws = rule.triggerKeywords.filter((kw) => !kw.includes('本人'));
+    const requiresInPerson = inPersonKws.some((kw) => condition.includes(kw));
+    const allowsProxy = proxyKws.some((kw) => process.includes(kw));
+    if (requiresInPerson && allowsProxy) {
+        return [
+            ErrorDetailBuilder.build({
+                guideId,
+                field: '办理流程',
+                errorType: 'logical',
+                description: `办理条件要求"本人到场"，但办理流程允许代办/委托办理，两者存在逻辑矛盾。[条款:${rule.standardClause}]`,
+                suggestion: `建议统一办理条件与流程：若确需本人到场则取消代办选项，若允许代办则调整办理条件`,
+                dataSource: 'standard',
+                standardClause: rule.standardClause,
+            }, severityMapping),
+        ];
+    }
+    return [];
+}
+function ruleMaterialCondition(guide, guideId, rule, severityMapping) {
+    const condition = String(guide['办理条件'] ?? '');
+    const materialStr = String(guide['申请材料'] ?? '');
+    if (!condition || !materialStr)
+        return [];
+    const proofKeywords = rule.triggerKeywords;
+    const requiredProofs = proofKeywords.filter((kw) => condition.includes(kw));
+    if (requiredProofs.length === 0)
+        return [];
+    const missingMaterials = requiredProofs.filter((proof) => !materialStr.includes(proof));
+    if (missingMaterials.length > 0) {
+        return missingMaterials.map((mat) => ErrorDetailBuilder.build({
+            guideId,
+            field: '申请材料',
+            errorType: 'logical',
+            description: `办理条件要求"${mat}"，但申请材料清单中未列入该证明材料，条件与材料清单不匹配。[条款:${rule.standardClause}]`,
+            suggestion: `建议在申请材料清单中补充"${mat}"，或调整办理条件中对该证明的要求`,
+            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,
+};
+export const LogicRuleEngine = {
+    detect(guide, guideId, rules, severityMapping) {
+        if (!rules || rules.length === 0) {
+            throw new Error('GOV_DATA_LOGIC_RULES_MISSING: logicErrorRules配置缺失，逻辑检测已中止');
+        }
+        const details = [];
+        for (const rule of rules) {
+            const handler = RULE_DISPATCH[rule.ruleId];
+            if (!handler)
+                continue;
+            const hasAllFields = rule.triggerFields.every((f) => {
+                const val = guide[f];
+                return val !== undefined && val !== null && (typeof val !== 'string' || val.trim() !== '');
+            });
+            if (!hasAllFields)
+                continue;
+            details.push(...handler(guide, guideId, rule, severityMapping));
+        }
+        return details;
+    },
+};
+//# sourceMappingURL=logicRuleEngine.js.map

package/lib/missingFieldDetector.js

@@ -0,0 +1,26 @@
+import { ErrorDetailBuilder } from './errorDetailBuilder.js';
+export const MissingFieldDetector = {
+    detect(guide, guideId, requiredElements, severityMapping, policyBasisText, standardClause) {
+        if (!requiredElements || requiredElements.length === 0) {
+            throw new Error('GOV_DATA_RULES_MISSING: guideRequiredElements配置缺失，无法执行漏项检测');
+        }
+        const basisText = policyBasisText ?? '办事指南应包含完整核心要素';
+        const details = [];
+        for (const elem of requiredElements) {
+            const val = guide[elem];
+            if (val === undefined || val === null || (typeof val === 'string' && val.trim() === '')) {
+                details.push(ErrorDetailBuilder.build({
+                    guideId,
+                    field: elem,
+                    errorType: 'missing',
+                    description: `办事指南"${guideId}"缺失必填字段"${elem}"，该字段为办事指南核心要素，缺失将影响办事指南可用性`,
+                    suggestion: `请补充"${elem}"字段内容，确保办事指南核心要素完整。${basisText}`,
+                    dataSource: 'standard',
+                    standardClause: standardClause ?? '',
+                }, severityMapping));
+            }
+        }
+        return details;
+    },
+};
+//# sourceMappingURL=missingFieldDetector.js.map

package/lib/nationalDataSource.js

@@ -0,0 +1,52 @@
+const FAILED_RESULT = {
+    data: [],
+    status: { status: 'failed', fetchedAt: '', recordCount: 0 },
+};
+export const NationalDataSource = {
+    async fetch(credentials) {
+        const apiKey = credentials?.apiKey ?? process.env.NATIONAL_API_KEY;
+        const endpoint = credentials?.endpoint ?? process.env.NATIONAL_API_ENDPOINT;
+        if (!apiKey || !endpoint) {
+            return { ...FAILED_RESULT, status: { ...FAILED_RESULT.status } };
+        }
+        if (!endpoint.startsWith('https://')) {
+            return { ...FAILED_RESULT, status: { ...FAILED_RESULT.status } };
+        }
+        try {
+            const url = new URL(endpoint);
+            url.searchParams.set('apiKey', apiKey);
+            const response = await fetch(url.toString(), {
+                method: 'GET',
+                headers: { 'Accept': 'application/json' },
+                signal: AbortSignal.timeout(10000),
+            });
+            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);
+            return {
+                data,
+                status: { status: 'success', fetchedAt: new Date().toISOString(), recordCount: data.length },
+            };
+        }
+        catch {
+            return { ...FAILED_RESULT, status: { ...FAILED_RESULT.status } };
+        }
+    },
+};
+//# sourceMappingURL=nationalDataSource.js.map

package/lib/provincialDataSource.js

@@ -0,0 +1,52 @@
+const FAILED_RESULT = {
+    data: [],
+    status: { status: 'failed', fetchedAt: '', recordCount: 0 },
+};
+export const ProvincialDataSource = {
+    async fetch(credentials) {
+        const apiKey = credentials?.apiKey ?? process.env.PROVINCIAL_API_KEY;
+        const endpoint = credentials?.endpoint ?? process.env.PROVINCIAL_API_ENDPOINT;
+        if (!apiKey || !endpoint) {
+            return { ...FAILED_RESULT, status: { ...FAILED_RESULT.status } };
+        }
+        if (!endpoint.startsWith('https://')) {
+            return { ...FAILED_RESULT, status: { ...FAILED_RESULT.status } };
+        }
+        try {
+            const url = new URL(endpoint);
+            url.searchParams.set('apiKey', apiKey);
+            const response = await fetch(url.toString(), {
+                method: 'GET',
+                headers: { 'Accept': 'application/json' },
+                signal: AbortSignal.timeout(10000),
+            });
+            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);
+            return {
+                data,
+                status: { status: 'success', fetchedAt: new Date().toISOString(), recordCount: data.length },
+            };
+        }
+        catch {
+            return { ...FAILED_RESULT, status: { ...FAILED_RESULT.status } };
+        }
+    },
+};
+//# sourceMappingURL=provincialDataSource.js.map

package/lib/qualityMetricsCalculator.js

@@ -0,0 +1,33 @@
+export const QualityMetricsCalculator = {
+    calculate(input) {
+        const { semanticErrorCount, logicalErrorCount, missingFieldCount, formatIssueCount, totalGuides, requiredFieldCount, totalFieldCount, errorDetails, falsePositiveCount = 0, trueSemanticErrorCount, trueLogicalErrorCount, scoreWeights, } = input;
+        const semanticDetectionRate = trueSemanticErrorCount !== undefined && trueSemanticErrorCount > 0
+            ? Math.round((semanticErrorCount / trueSemanticErrorCount) * 100)
+            : '未度量';
+        const logicalDetectionRate = trueLogicalErrorCount !== undefined && trueLogicalErrorCount > 0
+            ? Math.round((logicalErrorCount / trueLogicalErrorCount) * 100)
+            : '未度量';
+        const totalReportedErrors = semanticErrorCount + logicalErrorCount + missingFieldCount;
+        const falsePositiveRate = totalReportedErrors > 0 ? Math.round((falsePositiveCount / totalReportedErrors) * 100) : 0;
+        const totalRequiredSlots = requiredFieldCount * totalGuides;
+        const completenessScore = totalRequiredSlots > 0
+            ? Math.round((1 - missingFieldCount / totalRequiredSlots) * 100)
+            : 0;
+        const totalErrors = semanticErrorCount + logicalErrorCount + formatIssueCount;
+        const accuracyScore = totalFieldCount > 0 ? Math.round((1 - totalErrors / totalFieldCount) * 100) : 100;
+        const traceableCount = errorDetails.filter((d) => d.dataSource !== undefined && d.standardClause !== undefined && d.standardClause !== '').length;
+        const traceabilityScore = errorDetails.length > 0 ? Math.round((traceableCount / errorDetails.length) * 100) : 100;
+        const { completeness: w1, accuracy: w2, traceability: w3 } = scoreWeights;
+        const overallScore = Math.round(w1 * completenessScore + w2 * accuracyScore + w3 * traceabilityScore);
+        return {
+            semanticDetectionRate,
+            logicalDetectionRate,
+            falsePositiveRate,
+            completenessScore,
+            accuracyScore,
+            traceabilityScore,
+            overallScore,
+        };
+    },
+};
+//# sourceMappingURL=qualityMetricsCalculator.js.map