@liuhange/dsh-gov-data-inspector 3.1.8 → 3.2.1

package/README.md

@@ -6,7 +6,7 @@
 |------|-----|
 | 插件名 | dsh-gov-data-inspector |
 | 包名 | @liuhange/dsh-gov-data-inspector |
-| 版本 | 3.1.0 |
+| 版本 | 3.2.0 |
 | 工具 | inspect_gov_data |
 
 ## 功能说明
@@ -113,3 +113,122 @@ execute({
 ```
 
 匹配逻辑支持四通道：手动指定 → 名称关键词 → 编码前缀 → 流程字段关键词。
+## 配置包机制
+
+本插件采用**通用检测引擎 + 可替换配置包**架构。插件本体不含任何地区特定的政策标准，所有地区差异通过配置包注入。新增地区配置包无需修改插件代码。
+
+### 架构原理
+
+```
+┌─────────────────────────┐     ┌──────────────────────────┐
+│  通用检测引擎（插件）    │◄────│  地区配置包（可替换）     │
+│  - 格式校验              │     │  - 政策依据              │
+│  - 语义检测              │     │  - 必填字段              │
+│  - 逻辑检测              │     │  - 格式规则              │
+│  - 评分计算              │     │  - 标准词表              │
+│  - 分类判定              │     │  - 数据源凭证            │
+└─────────────────────────┘     └──────────────────────────┘
+```
+
+### 配置包加载优先级
+
+插件按以下三级优先级加载配置包：
+
+1. **文件路径**（`GOV_CONFIG_PACK_PATH` 环境变量）— 加载指定 JSON 文件
+2. **npm 包**（`GOV_CONFIG_PACK_PACKAGE` 环境变量）— 加载已安装的 npm 配置包
+3. **缺省配置包** — 插件内置的通用配置包，作为兜底
+
+每级加载成功后执行 Schema 校验，校验失败则记录告警并尝试下一级。三级全部失败时抛出 `GOV_CONFIG_PACK_UNAVAILABLE` 错误。
+
+### 环境变量
+
+| 环境变量 | 说明 | 示例 |
+|---------|------|------|
+| `GOV_CONFIG_PACK_PATH` | 配置包 JSON 文件的绝对或相对路径 | `/path/to/config-pack.json` |
+| `GOV_CONFIG_PACK_PACKAGE` | 已安装的 npm 配置包包名 | `@liuhange/gov-config-gd` |
+
+两个环境变量均为可选。同时设置时，`GOV_CONFIG_PACK_PATH` 优先于 `GOV_CONFIG_PACK_PACKAGE`。均未设置时使用缺省配置包。
+
+### 巡检报告来源标注
+
+加载配置包后，巡检报告包含以下来源标注字段：
+
+```json
+{
+  "configPackId": "gd-gov-2026",
+  "region": "广东省",
+  "configPackVersion": "2026.1.0"
+}
+```
+
+使用缺省配置包时，`configPackId` 为 `default`，`region` 为 `通用`。
+
+## 如何新增地区配置包
+
+### 配置包字段清单
+
+配置包 JSON 文件包含以下 14 个必填字段与 5 个可选字段：
+
+| 字段 | 类型 | 必填 | 说明 |
+|------|------|------|------|
+| `configPackId` | string | 是 | 配置包标识，格式 `^[a-z]{2}-[a-z]+-\d{4}$` |
+| `region` | string | 是 | 地区名称 |
+| `configPackVersion` | string | 是 | 语义化版本号 |
+| `policyBasis` | array | 是 | 政策依据文档列表 |
+| `requiredFields` | string[] | 是 | 办事指南必填字段列表 |
+| `formatRules` | array | 是 | 格式校验规则（含正则） |
+| `localStandardTerms` | object | 是 | 本地标准词表（materials + conditions） |
+| `logicErrorRules` | array | 是 | 逻辑错误检测规则 |
+| `scoringWeights` | object | 是 | 评分权重（completeness + accuracy + traceability，和为 1） |
+| `itemTypeMatching` | object | 是 | 事项类型匹配规则 |
+| `severityMapping` | object | 是 | 严重等级映射 |
+| `gbtMapping` | object | 是 | GB/T 47949 分类映射 |
+| `dataSourceCredentials` | object | 是 | 数据源凭证配置 |
+| `dataSourcePriority` | string[] | 是 | 数据源优先级 |
+| `convenienceWeights` | object | 否 | 便利度权重 |
+| `materialConciseThreshold` | number | 否 | 材料精简阈值 |
+| `missingFieldStandardClause` | string | 否 | 缺失字段标准条款引用 |
+| `degradedSimilarityThreshold` | number | 否 | 降级相似度阈值 |
+| `inputLengthThreshold` | number | 否 | 输入长度阈值 |
+
+### 字段名兼容映射
+
+配置包支持新旧字段名兼容。当旧名字段存在而新名字段缺失时，自动映射：
+
+| 新字段名 | 旧字段名（兼容） |
+|---------|---------------|
+| `requiredFields` | `guideRequiredElements` |
+| `scoringWeights` | `scoreWeights` |
+| `gbtMapping` | `gbt47949Mapping` |
+
+新名与旧名同时存在时，新名优先。
+
+### 创建步骤
+
+1. **创建配置包 JSON 文件**：按上述字段清单编写 `config-pack.json`，填入目标地区的政策依据、标准词表等
+
+2. **Schema 校验**：使用 `@liuhange/gov-config-schema` 包离线校验配置包内容
+
+3. **创建 npm 包**：`package.json` 中 `name` 使用 scoped 命名 `@liuhange/gov-config-{地区缩写}`，`exports` 指向 `config-pack.json`
+
+4. **发布**：`npm publish --access public`
+
+5. **使用**：安装配置包后设置环境变量 `GOV_CONFIG_PACK_PACKAGE=@liuhange/gov-config-{地区缩写}`
+
+### 已有地区配置包
+
+| 包名 | 地区 | 版本 |
+|------|------|------|
+| `@liuhange/gov-config-gd` | 广东省 | 2026.1.0 |
+| `@liuhange/gov-config-zj` | 浙江省 | 2026.1.0 |
+| `@liuhange/gov-config-schema` | Schema 校验工具 | 2026.1.0 |
+
+## 配置包交付周期
+
+配置包独立于插件发布，遵循语义化版本管理：
+
+- **政策更新时**：配置包 minor 或 patch 版本升级（如 `2026.1.0` → `2026.1.1`），插件版本不变
+- **新增地区配置包**：新建 npm 包，初始版本 `2026.1.0`
+- **配置包 Schema 变更**：`@liuhange/gov-config-schema` 版本升级，插件内嵌 Schema 同步更新
+
+配置包维护者可通过 `@liuhange/gov-config-schema` 包离线校验配置包内容，无需安装完整插件。

package/lib/__tests__/configPack.test.js

@@ -0,0 +1,76 @@
+import { describe, it, expect } from 'vitest';
+import { normalizeConfigPack } from '../configPack.js';
+describe('ConfigPack 类型与字段名映射', () => {
+    const basePack = {
+        configPackId: 'gd-gov-2026',
+        region: '广东省',
+        configPackVersion: '2026.1.0',
+        policyBasis: [{ name: '测试标准', docNumber: '测试文号', coreRequirement: '测试要求' }],
+        requiredFields: ['事项名称', '办理条件'],
+        formatRules: [{ field: '办理时限', pattern: '^\\d+个工作日$', suggestionTemplate: '提示' }],
+        localStandardTerms: { materials: ['身份证'], conditions: ['年满18周岁'] },
+        logicErrorRules: [{ ruleId: 'LOG_001', standardClause: '测试条款', triggerFields: ['办理流程'], triggerKeywords: ['现场勘查'], condition: '测试', suggestionTemplate: '测试' }],
+        scoringWeights: { completeness: 0.3, accuracy: 0.4, traceability: 0.3 },
+        itemTypeMatching: { 行政许可: { keywords: ['许可'], codePrefix: 'XK' } },
+        severityMapping: { missing: 'major', semantic: 'critical', logical: 'critical' },
+        gbtMapping: { structured: 'A01', semiStructured: 'A02', unstructured: 'A03' },
+        dataSourceCredentials: {
+            national: { apiKey: 'NATIONAL_KEY', endpoint: 'NATIONAL_ENDPOINT' },
+            provincial: { apiKey: 'PROVINCIAL_KEY', endpoint: 'PROVINCIAL_ENDPOINT' },
+            standard: { docPath: 'DOC_PATH', endpoint: 'RULES_ENDPOINT' },
+        },
+        dataSourcePriority: ['provincial', 'national'],
+    };
+    it('仅含新名时返回原值', () => {
+        const result = normalizeConfigPack({ ...basePack });
+        expect(result.requiredFields).toEqual(['事项名称', '办理条件']);
+        expect(result.scoringWeights).toEqual({ completeness: 0.3, accuracy: 0.4, traceability: 0.3 });
+        expect(result.gbtMapping).toEqual({ structured: 'A01', semiStructured: 'A02', unstructured: 'A03' });
+    });
+    it('仅含旧名时映射为新名', () => {
+        const oldPack = { ...basePack };
+        delete oldPack.requiredFields;
+        delete oldPack.scoringWeights;
+        delete oldPack.gbtMapping;
+        oldPack.guideRequiredElements = ['事项名称', '办理条件'];
+        oldPack.scoreWeights = { completeness: 0.3, accuracy: 0.4, traceability: 0.3 };
+        oldPack.gbt47949Mapping = { structured: 'A01', semiStructured: 'A02', unstructured: 'A03' };
+        const result = normalizeConfigPack(oldPack);
+        expect(result.requiredFields).toEqual(['事项名称', '办理条件']);
+        expect(result.scoringWeights).toEqual({ completeness: 0.3, accuracy: 0.4, traceability: 0.3 });
+        expect(result.gbtMapping).toEqual({ structured: 'A01', semiStructured: 'A02', unstructured: 'A03' });
+    });
+    it('新名与旧名同时存在时新名优先', () => {
+        const mixedPack = { ...basePack };
+        mixedPack.guideRequiredElements = ['旧字段'];
+        mixedPack.scoreWeights = { completeness: 0.1, accuracy: 0.1, traceability: 0.1 };
+        mixedPack.gbt47949Mapping = { structured: 'OLD' };
+        const result = normalizeConfigPack(mixedPack);
+        expect(result.requiredFields).toEqual(['事项名称', '办理条件']);
+        expect(result.scoringWeights).toEqual({ completeness: 0.3, accuracy: 0.4, traceability: 0.3 });
+        expect(result.gbtMapping).toEqual({ structured: 'A01', semiStructured: 'A02', unstructured: 'A03' });
+    });
+    it('必填字段双名均缺失时抛错', () => {
+        const missingPack = { ...basePack };
+        delete missingPack.requiredFields;
+        delete missingPack.guideRequiredElements;
+        expect(() => normalizeConfigPack(missingPack)).toThrow('GOV_CONFIG_PACK_INVALID');
+    });
+    it('configPackId 缺失时抛错', () => {
+        const missingPack = { ...basePack };
+        delete missingPack.configPackId;
+        expect(() => normalizeConfigPack(missingPack)).toThrow('GOV_CONFIG_PACK_INVALID');
+    });
+    it('可选字段保留', () => {
+        const packWithOptional = { ...basePack, convenienceWeights: { timeLimit: 0.3 }, materialConciseThreshold: 5 };
+        const result = normalizeConfigPack(packWithOptional);
+        expect(result.convenienceWeights).toEqual({ timeLimit: 0.3 });
+        expect(result.materialConciseThreshold).toBe(5);
+    });
+    it('default configPackId 被接受', () => {
+        const defaultPack = { ...basePack, configPackId: 'default' };
+        const result = normalizeConfigPack(defaultPack);
+        expect(result.configPackId).toBe('default');
+    });
+});
+//# sourceMappingURL=configPack.test.js.map

package/lib/__tests__/configPackLoader.test.js

@@ -0,0 +1,90 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { ConfigPackLoader } from '../configPackLoader.js';
+import { writeFileSync, unlinkSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+describe('配置包加载器', () => {
+    const tmpFile = resolve(tmpdir(), 'test-config-pack.json');
+    afterEach(() => {
+        try {
+            unlinkSync(tmpFile);
+        }
+        catch { /* ignore */ }
+    });
+    it('未设置环境变量时使用缺省配置包', () => {
+        const result = ConfigPackLoader.load();
+        expect(result.loadSource).toBe('default');
+        expect(result.configPack.configPackId).toBe('default');
+        expect(result.configPack.region).toBe('通用');
+    });
+    it('设置 GOV_CONFIG_PACK_PATH 指向合法文件时 loadSource 为 file', () => {
+        const pack = {
+            configPackId: 'gd-gov-2026',
+            region: '广东省',
+            configPackVersion: '2026.1.0',
+            policyBasis: [{ name: '测试', docNumber: '粤府办〔2024〕1号', coreRequirement: '测试' }],
+            requiredFields: ['事项名称'],
+            formatRules: [],
+            localStandardTerms: { materials: [], conditions: [] },
+            logicErrorRules: [{ ruleId: 'LOG_001', standardClause: '测试', triggerFields: ['办理流程'], triggerKeywords: ['测试'], condition: '测试', suggestionTemplate: '测试' }],
+            scoringWeights: { completeness: 0.3, accuracy: 0.4, traceability: 0.3 },
+            itemTypeMatching: { 行政许可: { keywords: ['许可'], codePrefix: 'XK' } },
+            severityMapping: { missing: 'major', semantic: 'critical', logical: 'critical' },
+            gbtMapping: { structured: 'A01', semiStructured: 'A02', unstructured: 'A03' },
+            dataSourceCredentials: {
+                national: { apiKey: 'KEY', endpoint: 'EP' },
+                provincial: { apiKey: 'KEY', endpoint: 'EP' },
+                standard: { docPath: 'PATH', endpoint: 'EP' },
+            },
+            dataSourcePriority: ['provincial', 'national'],
+        };
+        writeFileSync(tmpFile, JSON.stringify(pack), 'utf-8');
+        process.env.GOV_CONFIG_PACK_PATH = tmpFile;
+        const result = ConfigPackLoader.load();
+        expect(result.loadSource).toBe('file');
+        expect(result.configPack.configPackId).toBe('gd-gov-2026');
+        expect(result.configPack.region).toBe('广东省');
+        delete process.env.GOV_CONFIG_PACK_PATH;
+    });
+    it('设置 GOV_CONFIG_PACK_PATH 指向不存在文件时回退到缺省', () => {
+        process.env.GOV_CONFIG_PACK_PATH = '/nonexistent/path/pack.json';
+        const result = ConfigPackLoader.load();
+        expect(result.loadSource).toBe('default');
+        expect(result.warnings.length).toBeGreaterThan(0);
+        delete process.env.GOV_CONFIG_PACK_PATH;
+    });
+    it('设置 GOV_CONFIG_PACK_PATH 指向非法 JSON 时回退到缺省', () => {
+        writeFileSync(tmpFile, 'not json', 'utf-8');
+        process.env.GOV_CONFIG_PACK_PATH = tmpFile;
+        const result = ConfigPackLoader.load();
+        expect(result.loadSource).toBe('default');
+        expect(result.warnings.length).toBeGreaterThan(0);
+        delete process.env.GOV_CONFIG_PACK_PATH;
+    });
+    it('设置 GOV_CONFIG_PACK_PACKAGE 指向未安装包时回退到缺省', () => {
+        process.env.GOV_CONFIG_PACK_PACKAGE = '@nonexistent/config-pack';
+        const result = ConfigPackLoader.load();
+        expect(result.loadSource).toBe('default');
+        expect(result.warnings.length).toBeGreaterThan(0);
+        delete process.env.GOV_CONFIG_PACK_PACKAGE;
+    });
+    it('缺省配置包含 14 个必填字段', () => {
+        const result = ConfigPackLoader.load();
+        const pack = result.configPack;
+        expect(pack.configPackId).toBeDefined();
+        expect(pack.region).toBeDefined();
+        expect(pack.configPackVersion).toBeDefined();
+        expect(pack.policyBasis).toBeDefined();
+        expect(pack.requiredFields).toBeDefined();
+        expect(pack.formatRules).toBeDefined();
+        expect(pack.localStandardTerms).toBeDefined();
+        expect(pack.logicErrorRules).toBeDefined();
+        expect(pack.scoringWeights).toBeDefined();
+        expect(pack.itemTypeMatching).toBeDefined();
+        expect(pack.severityMapping).toBeDefined();
+        expect(pack.gbtMapping).toBeDefined();
+        expect(pack.dataSourceCredentials).toBeDefined();
+        expect(pack.dataSourcePriority).toBeDefined();
+    });
+});
+//# sourceMappingURL=configPackLoader.test.js.map

package/lib/__tests__/configPackSchemaValidator.test.js

@@ -0,0 +1,75 @@
+import { describe, it, expect } from 'vitest';
+import { ConfigPackSchemaValidator } from '../configPackSchemaValidator.js';
+import defaultPack from '../default-config-pack.json' with { type: 'json' };
+describe('Schema 校验器', () => {
+    it('缺省配置包校验通过', () => {
+        const result = ConfigPackSchemaValidator.validate(defaultPack);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toEqual([]);
+    });
+    it('非对象输入校验失败', () => {
+        const result = ConfigPackSchemaValidator.validate('not an object');
+        expect(result.valid).toBe(false);
+    });
+    it('缺少必填字段校验失败', () => {
+        const pack = { ...defaultPack };
+        delete pack.configPackId;
+        const result = ConfigPackSchemaValidator.validate(pack);
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.path === 'configPackId')).toBe(true);
+    });
+    it('configPackVersion 格式错误校验失败', () => {
+        const pack = { ...defaultPack, configPackVersion: 'invalid' };
+        const result = ConfigPackSchemaValidator.validate(pack);
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.path === 'configPackVersion')).toBe(true);
+    });
+    it('scoringWeights 三权重之和≠1校验失败', () => {
+        const pack = { ...defaultPack, scoringWeights: { completeness: 0.1, accuracy: 0.1, traceability: 0.1 } };
+        const result = ConfigPackSchemaValidator.validate(pack);
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.path === 'scoringWeights')).toBe(true);
+    });
+    it('scoringWeights 三权重之和=1校验通过', () => {
+        const pack = { ...defaultPack, scoringWeights: { completeness: 0.3, accuracy: 0.4, traceability: 0.3 } };
+        const result = ConfigPackSchemaValidator.validate(pack);
+        expect(result.errors.some((e) => e.path === 'scoringWeights')).toBe(false);
+    });
+    it('policyBasis 为空数组校验失败', () => {
+        const pack = { ...defaultPack, policyBasis: [] };
+        const result = ConfigPackSchemaValidator.validate(pack);
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.path === 'policyBasis')).toBe(true);
+    });
+    it('requiredFields 为空数组校验失败', () => {
+        const pack = { ...defaultPack, requiredFields: [] };
+        const result = ConfigPackSchemaValidator.validate(pack);
+        expect(result.valid).toBe(false);
+    });
+    it('severityMapping 值非枚举校验失败', () => {
+        const pack = { ...defaultPack, severityMapping: { missing: 'invalid', semantic: 'critical', logical: 'critical' } };
+        const result = ConfigPackSchemaValidator.validate(pack);
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.path === 'severityMapping.missing')).toBe(true);
+    });
+    it('dataSourcePriority 含非法值校验失败', () => {
+        const pack = { ...defaultPack, dataSourcePriority: ['invalid'] };
+        const result = ConfigPackSchemaValidator.validate(pack);
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.path === 'dataSourcePriority[0]')).toBe(true);
+    });
+});
+describe('正则 ReDoS 安全预检', () => {
+    it('安全正则通过', () => {
+        expect(ConfigPackSchemaValidator.checkRegexSafety('^\\d+个工作日$')).toBe(true);
+        expect(ConfigPackSchemaValidator.checkRegexSafety('1[3-9]\\d{9}')).toBe(true);
+    });
+    it('嵌套量词正则被拒绝', () => {
+        expect(ConfigPackSchemaValidator.checkRegexSafety('(a+)+')).toBe(false);
+        expect(ConfigPackSchemaValidator.checkRegexSafety('(a*)*')).toBe(false);
+    });
+    it('无效正则被拒绝', () => {
+        expect(ConfigPackSchemaValidator.checkRegexSafety('[')).toBe(false);
+    });
+});
+//# sourceMappingURL=configPackSchemaValidator.test.js.map

package/lib/__tests__/defaultConfigPack.test.js

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import { ConfigPackSchemaValidator } from '../configPackSchemaValidator.js';
+import defaultPack from '../default-config-pack.json' with { type: 'json' };
+describe('缺省配置包完整性', () => {
+    it('通过 Schema 校验', () => {
+        const result = ConfigPackSchemaValidator.validate(defaultPack);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toEqual([]);
+    });
+    it('configPackId 为 default', () => {
+        expect(defaultPack.configPackId).toBe('default');
+    });
+    it('region 为 通用', () => {
+        expect(defaultPack.region).toBe('通用');
+    });
+    it('policyBasis 含 6 条且包含广东省政务服务事项管理系统', () => {
+        expect(defaultPack.policyBasis.length).toBe(6);
+        expect(defaultPack.policyBasis.some((d) => d.name.includes('广东省政务服务事项管理系统'))).toBe(true);
+    });
+    it('14 个必填字段完整', () => {
+        const required = ['configPackId', 'region', 'configPackVersion', 'policyBasis', 'requiredFields', 'formatRules', 'localStandardTerms', 'logicErrorRules', 'scoringWeights', 'itemTypeMatching', 'severityMapping', 'gbtMapping', 'dataSourceCredentials', 'dataSourcePriority'];
+        for (const field of required) {
+            expect(defaultPack[field]).toBeDefined();
+        }
+    });
+});
+//# sourceMappingURL=defaultConfigPack.test.js.map

package/lib/__tests__/govConfigPacks.test.js

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import { ConfigPackSchemaValidator } from '../configPackSchemaValidator.js';
+import { normalizeConfigPack } from '../configPack.js';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+const gdPack = JSON.parse(readFileSync(resolve(__dirname, '..', '..', '..', 'gov-config-gd', 'config-pack.json'), 'utf-8'));
+const zjPack = JSON.parse(readFileSync(resolve(__dirname, '..', '..', '..', 'gov-config-zj', 'config-pack.json'), 'utf-8'));
+describe('广东省配置包', () => {
+    it('Schema 校验通过', () => {
+        const normalized = normalizeConfigPack(gdPack);
+        const result = ConfigPackSchemaValidator.validate(normalized);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toEqual([]);
+    });
+    it('configPackId 为 gd-gov-2026', () => {
+        expect(gdPack.configPackId).toBe('gd-gov-2026');
+    });
+    it('region 为 广东省', () => {
+        expect(gdPack.region).toBe('广东省');
+    });
+    it('policyBasis 含文号含粤字的政策文件', () => {
+        expect(gdPack.policyBasis.some((d) => d.docNumber.includes('粤'))).toBe(true);
+    });
+    it('dataSourcePriority 省级优先', () => {
+        expect(gdPack.dataSourcePriority[0]).toBe('provincial');
+    });
+});
+describe('浙江省配置包', () => {
+    it('Schema 校验通过', () => {
+        const normalized = normalizeConfigPack(zjPack);
+        const result = ConfigPackSchemaValidator.validate(normalized);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toEqual([]);
+    });
+    it('configPackId 为 zj-gov-2026', () => {
+        expect(zjPack.configPackId).toBe('zj-gov-2026');
+    });
+    it('region 为 浙江省', () => {
+        expect(zjPack.region).toBe('浙江省');
+    });
+    it('policyBasis 含文号含浙字的政策文件', () => {
+        expect(zjPack.policyBasis.some((d) => d.docNumber.includes('浙'))).toBe(true);
+    });
+    it('dataSourcePriority 省级优先', () => {
+        expect(zjPack.dataSourcePriority[0]).toBe('provincial');
+    });
+});
+describe('地区配置包独立性', () => {
+    it('广东省与浙江省 configPackId 不同', () => {
+        expect(gdPack.configPackId).not.toBe(zjPack.configPackId);
+    });
+    it('广东省与浙江省 region 不同', () => {
+        expect(gdPack.region).not.toBe(zjPack.region);
+    });
+    it('广东省与浙江省 dataSourceCredentials 不同', () => {
+        expect(gdPack.dataSourceCredentials.national.apiKey).not.toBe(zjPack.dataSourceCredentials.national.apiKey);
+    });
+});
+//# sourceMappingURL=govConfigPacks.test.js.map

package/lib/config-pack-schema.json

@@ -0,0 +1,186 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://liuhange.dev/gov-data-inspector/config-pack-schema.json",
+    "title": "Government Data Inspector Config Pack",
+    "type": "object",
+    "required": [
+        "configPackId",
+        "region",
+        "configPackVersion",
+        "policyBasis",
+        "requiredFields",
+        "formatRules",
+        "localStandardTerms",
+        "logicErrorRules",
+        "scoringWeights",
+        "itemTypeMatching",
+        "severityMapping",
+        "gbtMapping",
+        "dataSourceCredentials",
+        "dataSourcePriority"
+    ],
+    "properties": {
+        "configPackId": {
+            "type": "string",
+            "pattern": "^[a-z]{2}-[a-z]+-\\d{4}$|^default$"
+        },
+        "region": {
+            "type": "string",
+            "minLength": 2
+        },
+        "configPackVersion": {
+            "type": "string",
+            "pattern": "^\\d+\\.\\d+\\.\\d+$"
+        },
+        "policyBasis": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+                "type": "object",
+                "required": ["name", "docNumber", "coreRequirement"],
+                "properties": {
+                    "name": { "type": "string", "minLength": 1 },
+                    "docNumber": { "type": "string", "minLength": 1 },
+                    "coreRequirement": { "type": "string", "minLength": 1 }
+                }
+            }
+        },
+        "requiredFields": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "type": "string" }
+        },
+        "formatRules": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": ["field", "suggestionTemplate"],
+                "properties": {
+                    "field": { "type": "string" },
+                    "pattern": { "type": "string" },
+                    "requiredKeywords": {
+                        "type": "array",
+                        "items": { "type": "string" }
+                    },
+                    "suggestionTemplate": { "type": "string" }
+                }
+            }
+        },
+        "localStandardTerms": {
+            "type": "object",
+            "required": ["materials", "conditions"],
+            "properties": {
+                "materials": {
+                    "type": "array",
+                    "items": { "type": "string" }
+                },
+                "conditions": {
+                    "type": "array",
+                    "items": { "type": "string" }
+                }
+            }
+        },
+        "logicErrorRules": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": ["ruleId", "standardClause", "triggerFields", "triggerKeywords"],
+                "properties": {
+                    "ruleId": { "type": "string" },
+                    "standardClause": { "type": "string" },
+                    "triggerFields": {
+                        "type": "array",
+                        "items": { "type": "string" }
+                    },
+                    "condition": { "type": "string" },
+                    "threshold": { "type": ["number", "null"] },
+                    "suggestionTemplate": { "type": "string" },
+                    "triggerKeywords": {
+                        "type": "array",
+                        "items": { "type": "string" }
+                    }
+                }
+            }
+        },
+        "scoringWeights": {
+            "type": "object",
+            "required": ["completeness", "accuracy", "traceability"],
+            "properties": {
+                "completeness": { "type": "number", "minimum": 0, "maximum": 1 },
+                "accuracy": { "type": "number", "minimum": 0, "maximum": 1 },
+                "traceability": { "type": "number", "minimum": 0, "maximum": 1 }
+            }
+        },
+        "itemTypeMatching": {
+            "type": "object",
+            "minProperties": 1,
+            "additionalProperties": {
+                "type": "object",
+                "required": ["keywords", "codePrefix"],
+                "properties": {
+                    "keywords": {
+                        "type": "array",
+                        "items": { "type": "string" }
+                    },
+                    "codePrefix": { "type": "string" }
+                }
+            }
+        },
+        "severityMapping": {
+            "type": "object",
+            "properties": {
+                "missing": { "type": "string", "enum": ["critical", "major", "minor"] },
+                "semantic": { "type": "string", "enum": ["critical", "major", "minor"] },
+                "logical": { "type": "string", "enum": ["critical", "major", "minor"] }
+            }
+        },
+        "gbtMapping": {
+            "type": "object",
+            "minProperties": 1,
+            "additionalProperties": { "type": "string" }
+        },
+        "dataSourceCredentials": {
+            "type": "object",
+            "required": ["national", "provincial", "standard"],
+            "properties": {
+                "national": {
+                    "type": "object",
+                    "required": ["apiKey", "endpoint"],
+                    "properties": {
+                        "apiKey": { "type": "string" },
+                        "endpoint": { "type": "string" }
+                    }
+                },
+                "provincial": {
+                    "type": "object",
+                    "required": ["apiKey", "endpoint"],
+                    "properties": {
+                        "apiKey": { "type": "string" },
+                        "endpoint": { "type": "string" }
+                    }
+                },
+                "standard": {
+                    "type": "object",
+                    "required": ["docPath", "endpoint"],
+                    "properties": {
+                        "docPath": { "type": "string" },
+                        "endpoint": { "type": "string" }
+                    }
+                }
+            }
+        },
+        "dataSourcePriority": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "type": "string", "enum": ["national", "provincial"] }
+        },
+        "convenienceWeights": {
+            "type": "object",
+            "additionalProperties": { "type": "number" }
+        },
+        "materialConciseThreshold": { "type": "number" },
+        "missingFieldStandardClause": { "type": "string" },
+        "degradedSimilarityThreshold": { "type": "number", "minimum": 0, "maximum": 1 },
+        "inputLengthThreshold": { "type": "number" }
+    }
+}