@liuhange/dsh-data-asset-registration-helper 3.0.0

package/lib/__tests__/registrationHelper.test.js

@@ -0,0 +1,61 @@
+import { describe, it, expect } from 'vitest';
+import { checkDisallowedScenarios } from '../disallowedScenarioChecker.js';
+import { matchAgency } from '../agencyMatcher.js';
+const disallowedScenarios = [
+    { id: 'DIS_001', label: '危害国家安全', keywords: ['国家安全', '机密', '涉密'] },
+    { id: 'DIS_002', label: '来源违反法律法规', keywords: ['非法', '窃取', '违规采集'] },
+    { id: 'DIS_003', label: '权属纠纷未解决', keywords: ['纠纷', '争议', '诉讼'] },
+    { id: 'DIS_004', label: '隐瞒真实情况', keywords: ['隐瞒', '虚假', '欺诈'] },
+];
+describe('disallowedScenarioChecker', () => {
+    it('正常描述→CAN_REGISTER', () => {
+        const result = checkDisallowedScenarios('企业内部经营数据', disallowedScenarios, false);
+        expect(result.conclusion).toBe('CAN_REGISTER');
+        expect(result.failedItems).toHaveLength(0);
+    });
+    it('含涉密关键词→CANNOT_REGISTER', () => {
+        const result = checkDisallowedScenarios('涉及国家机密数据', disallowedScenarios, false);
+        expect(result.conclusion).toBe('CANNOT_REGISTER');
+        expect(result.disallowedScenariosHit[0].id).toBe('DIS_001');
+    });
+    it('权属纠纷→CANNOT_REGISTER', () => {
+        const result = checkDisallowedScenarios('正常数据', disallowedScenarios, true);
+        expect(result.conclusion).toBe('CANNOT_REGISTER');
+        expect(result.failedItems.some(f => f.includes('权属纠纷'))).toBe(true);
+    });
+    it('多个禁止场景同时命中', () => {
+        const result = checkDisallowedScenarios('非法窃取且虚假隐瞒', disallowedScenarios, false);
+        expect(result.conclusion).toBe('CANNOT_REGISTER');
+        expect(result.disallowedScenariosHit.length).toBeGreaterThanOrEqual(2);
+    });
+});
+describe('agencyMatcher', () => {
+    const agencyConfig = {
+        mode: 'local',
+        httpEndpoints: {
+            beijing: { url: 'https://example.com/bj', apiKey: '${KEY_BJ}' },
+            shanghai: { url: 'https://example.com/sh', apiKey: '${KEY_SH}' },
+            shenzhen: { url: 'https://example.com/sz', apiKey: '${KEY_SZ}' },
+        },
+    };
+    it('指定region精确匹配', () => {
+        const result = matchAgency('金融', 'shanghai', agencyConfig);
+        expect(result.matched).toBe(true);
+        expect(result.recommendedAgency).toBe('shanghai');
+        expect(result.url).toBe('https://example.com/sh');
+    });
+    it('未指定region时从dataType推断', () => {
+        const result = matchAgency('金融', undefined, agencyConfig);
+        expect(result.recommendedAgency).toBe('shanghai');
+    });
+    it('科技数据推断为深圳', () => {
+        const result = matchAgency('科技数据', undefined, agencyConfig);
+        expect(result.recommendedAgency).toBe('shenzhen');
+    });
+    it('未知region回退到第一个endpoint', () => {
+        const result = matchAgency('未知', 'mars', agencyConfig);
+        expect(result.matched).toBe(false);
+        expect(result.recommendedAgency).toBe('beijing');
+    });
+});
+//# sourceMappingURL=registrationHelper.test.js.map

package/lib/agencyMatcher.js

@@ -0,0 +1,36 @@
+export function matchAgency(dataType, region, config) {
+    const regionKey = region ?? inferRegionFromDataType(dataType);
+    const endpoint = config.httpEndpoints[regionKey];
+    if (endpoint) {
+        return {
+            recommendedAgency: regionKey,
+            url: endpoint.url,
+            matched: true,
+        };
+    }
+    const firstKey = Object.keys(config.httpEndpoints)[0];
+    if (firstKey) {
+        const fallback = config.httpEndpoints[firstKey];
+        if (fallback) {
+            return {
+                recommendedAgency: firstKey,
+                url: fallback.url,
+                matched: false,
+            };
+        }
+    }
+    return {
+        recommendedAgency: 'unknown',
+        url: '',
+        matched: false,
+    };
+}
+function inferRegionFromDataType(dataType) {
+    const typeLower = dataType.toLowerCase();
+    if (typeLower.includes('金融') || typeLower.includes('finance'))
+        return 'shanghai';
+    if (typeLower.includes('科技') || typeLower.includes('tech'))
+        return 'shenzhen';
+    return 'beijing';
+}
+//# sourceMappingURL=agencyMatcher.js.map

package/lib/disallowedScenarioChecker.js

@@ -0,0 +1,20 @@
+export function checkDisallowedScenarios(assetDescription, disallowedScenarios, hasDispute) {
+    const failedItems = [];
+    const hitScenarios = [];
+    for (const scenario of disallowedScenarios) {
+        const matched = scenario.keywords.some(kw => assetDescription.includes(kw));
+        if (matched) {
+            hitScenarios.push(scenario);
+            failedItems.push(`${scenario.id}: ${scenario.label}（关键词: ${scenario.keywords.join(', ')}）`);
+        }
+    }
+    if (hasDispute) {
+        failedItems.push('权属纠纷未解决: ownershipConfirmation.hasDispute = true');
+    }
+    return {
+        conclusion: failedItems.length === 0 ? 'CAN_REGISTER' : 'CANNOT_REGISTER',
+        failedItems,
+        disallowedScenariosHit: hitScenarios,
+    };
+}
+//# sourceMappingURL=disallowedScenarioChecker.js.map

package/lib/index.js

@@ -0,0 +1,76 @@
+import { checkDisallowedScenarios } from './disallowedScenarioChecker.js';
+import { matchAgency } from './agencyMatcher.js';
+import { generateRegistrationReport } from './registrationReportGenerator.js';
+import { validateRegistrationArgs } from './invariant.js';
+export const name = '@liuhange/dsh-data-asset-registration-helper';
+export const inject = ['tools'];
+export function apply(ctx) {
+    ctx.tools.register({
+        name: 'registration_helper',
+        description: '数据资产登记助手：禁止场景检查+权属纠纷检查+登记机构匹配+登记流程指引，兼容已有registration-precheck/generate-registration-docs/match-registration-agency',
+        parameters: {
+            type: 'object',
+            properties: {
+                assetName: { type: 'string', description: '数据资产名称' },
+                assetDescription: { type: 'string', description: '数据资产描述（用于禁止场景检测）' },
+                dataType: { type: 'string', description: '数据类型（金融/医疗/交通等）' },
+                region: { type: 'string', description: '意向登记地区（beijing/shanghai/shenzhen，可选）' },
+                ownershipConfirmation: {
+                    type: 'object',
+                    description: '权属确认信息',
+                    properties: {
+                        hasDispute: { type: 'boolean', description: '是否存在权属纠纷' },
+                        confirmedAt: { type: 'string', description: '确认时间' },
+                        holder: { type: 'string', description: '持有方' },
+                        processor: { type: 'string', description: '加工方' },
+                        operator: { type: 'string', description: '运营方' },
+                    },
+                },
+                orchestrationResult: { type: 'string', description: '体检全流程产物JSON' },
+            },
+            required: ['assetName', 'assetDescription', 'dataType', 'ownershipConfirmation', 'orchestrationResult'],
+        },
+        async execute(args) {
+            try {
+                const validated = validateRegistrationArgs(args);
+                const { readFileSync } = await import('node:fs');
+                let rulesConfig;
+                try {
+                    rulesConfig = JSON.parse(readFileSync(process.env.BUSINESS_RULES_PATH || 'config/business-rules.json', 'utf-8'));
+                }
+                catch {
+                    return JSON.stringify({ error: 'REGISTRATION_RULES_MISSING', message: '无法加载business-rules.json' });
+                }
+                const registrationConfig = rulesConfig.registration;
+                if (!registrationConfig) {
+                    return JSON.stringify({ error: 'REGISTRATION_RULES_MISSING', message: 'registration配置段缺失' });
+                }
+                let policyDocuments;
+                try {
+                    const policyConfig = JSON.parse(readFileSync(process.env.POLICY_REFS_PATH || 'config/policy-references.json', 'utf-8'));
+                    const stage = policyConfig.policyReferences?.find((s) => s.stage === 'PRECHECK');
+                    policyDocuments = stage?.documents ?? [];
+                }
+                catch {
+                    policyDocuments = [];
+                }
+                const disallowedScenarios = registrationConfig.rules?.disallowedScenarios ?? [];
+                const precheck = checkDisallowedScenarios(validated.assetDescription, disallowedScenarios, validated.ownershipConfirmation.hasDispute);
+                let agencyMatch = null;
+                if (precheck.conclusion === 'CAN_REGISTER') {
+                    agencyMatch = matchAgency(validated.dataType, validated.region, registrationConfig.agencies);
+                }
+                const report = generateRegistrationReport(validated.assetName, precheck, agencyMatch, policyDocuments);
+                return JSON.stringify(report, null, 2);
+            }
+            catch (e) {
+                const err = e;
+                return JSON.stringify({
+                    error: err.message.split(':')[0] ?? 'UNKNOWN_ERROR',
+                    message: err.message,
+                });
+            }
+        },
+    });
+}
+//# sourceMappingURL=index.js.map

package/lib/invariant.js

@@ -0,0 +1,44 @@
+export function invariant(condition, message) {
+    if (!condition) {
+        throw new Error(`INVARIANT_VIOLATION: ${message}`);
+    }
+}
+export function validateRegistrationArgs(args) {
+    if (!args || typeof args !== 'object') {
+        throw new Error('INVALID_ARGS: args must be an object');
+    }
+    if (!args.assetName || typeof args.assetName !== 'string') {
+        throw new Error('INVALID_ARGS: assetName is required and must be a string');
+    }
+    if (typeof args.assetDescription !== 'string') {
+        throw new Error('INVALID_ARGS: assetDescription is required and must be a string');
+    }
+    if (!args.dataType || typeof args.dataType !== 'string') {
+        throw new Error('INVALID_ARGS: dataType is required and must be a string');
+    }
+    const oc = args.ownershipConfirmation;
+    if (!oc || typeof oc !== 'object') {
+        throw new Error('INVALID_ARGS: ownershipConfirmation is required');
+    }
+    if (typeof oc.hasDispute !== 'boolean') {
+        throw new Error('INVALID_ARGS: ownershipConfirmation.hasDispute must be boolean');
+    }
+    if (typeof oc.confirmedAt !== 'string' || typeof oc.holder !== 'string' || typeof oc.processor !== 'string' || typeof oc.operator !== 'string') {
+        throw new Error('INVALID_ARGS: ownershipConfirmation needs confirmedAt/holder/processor/operator as strings');
+    }
+    if (!args.orchestrationResult || typeof args.orchestrationResult !== 'string') {
+        throw new Error('INVALID_ARGS: orchestrationResult is required and must be a string (JSON)');
+    }
+    const result = {
+        assetName: args.assetName,
+        assetDescription: args.assetDescription,
+        dataType: args.dataType,
+        ownershipConfirmation: oc,
+        orchestrationResult: args.orchestrationResult,
+    };
+    if (typeof args.region === 'string') {
+        result.region = args.region;
+    }
+    return result;
+}
+//# sourceMappingURL=invariant.js.map

package/lib/registrationReportGenerator.js

@@ -0,0 +1,30 @@
+export function generateRegistrationReport(assetName, precheck, agencyMatch, policyDocuments) {
+    const nextSteps = [];
+    if (precheck.conclusion === 'CANNOT_REGISTER') {
+        nextSteps.push('暂缓登记申请，需先解决以下问题:');
+        for (const item of precheck.failedItems) {
+            nextSteps.push(`  - ${item}`);
+        }
+    }
+    else {
+        nextSteps.push('预检通过，可进入登记申请流程');
+        if (agencyMatch && agencyMatch.matched) {
+            nextSteps.push(`向${agencyMatch.recommendedAgency}数据交易所提交申请: ${agencyMatch.url}`);
+        }
+        else if (agencyMatch) {
+            nextSteps.push(`建议向${agencyMatch.recommendedAgency}数据交易所咨询: ${agencyMatch.url}`);
+        }
+        nextSteps.push('准备材料: 数据描述、来源合法性声明、产权归属说明');
+        nextSteps.push('通过generate_registration_docs工具生成申请材料');
+        nextSteps.push('提交至国家数据产权登记系统');
+    }
+    return {
+        assetName,
+        precheck,
+        agencyMatch,
+        nextSteps,
+        policyReferences: policyDocuments,
+        timestamp: new Date().toISOString(),
+    };
+}
+//# sourceMappingURL=registrationReportGenerator.js.map

package/lib/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@liuhange/dsh-data-asset-registration-helper",
+  "description": "Registration helper plugin: disallowed scenario check + ownership dispute check + agency matching + registration workflow guidance",
+  "version": "3.0.0",
+  "publishConfig": { "access": "public" },
+  "repository": { "type": "git", "url": "git+https://github.com/liuhange789/data-asset-inspector.git", "directory": "packages/data-asset/data-asset-registration-helper" },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": { "types": "./lib/types/index.d.ts", "default": "./lib/index.js" },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": ["lib/**/*.js", "lib/types/**/*.d.ts"],
+  "license": "MIT",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "build": "tsc"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.0",
+    "@deepseek-ai/dsh-tools": "0.0.1-rc.1",
+    "@liuhange/dsh-data-asset-shared": "^3.0.0"
+  },
+  "dsh": { "bundle": { "patch": true } }
+}