@liuhange/dsh-city-data-classifier 3.1.0

package/README.md

@@ -0,0 +1,22 @@
+# @liuhange/dsh-city-data-classifier
+
+## 功能说明
+
+City data AI classification plugin: auto-recommend GB/T 47949-2026 category and sensitivity grading
+
+## 安装
+
+```bash
+dsh plugin --profile web add @liuhange/dsh-city-data-classifier
+```
+
+## 用法
+
+```javascript
+import { apply } from '@liuhange/dsh-city-data-classifier';
+apply(ctx); // 注册工具: classify_city_data
+```
+
+## License
+
+MIT

package/lib/index.js

@@ -0,0 +1,139 @@
+export const name = '@liuhange/dsh-city-data-classifier';
+export const inject = ['tools'];
+import { loadJsonConfig } from '@liuhange/dsh-data-asset-shared';
+import { resolvePolicyBasis } from './policyBasis.js';
+export function apply(ctx) {
+    ctx.tools.register({
+        name: 'classify_city_data',
+        description: 'AI自动推荐城市/组织数据的国标分类和敏感度分级，生成登记台账',
+        parameters: {
+            type: 'object',
+            properties: {
+                dataSource: { type: 'string', description: '数据文件路径' },
+                autoConfirm: { type: 'boolean', default: false },
+            },
+            required: ['dataSource'],
+        },
+        async execute(args) {
+            try {
+                if (!args?.dataSource || typeof args.dataSource !== 'string') {
+                    return JSON.stringify({ error: 'CITY_CLASSIFY_INPUT_INVALID', message: 'dataSource is required' });
+                }
+                let rulesConfig;
+                try {
+                    rulesConfig = loadJsonConfig('BUSINESS_RULES_PATH', 'config/business-rules.json', '@liuhange/dsh-data-asset-shared/config/business-rules.json');
+                }
+                catch {
+                    return JSON.stringify({ error: 'CITY_CLASSIFY_RULES_MISSING', message: '无法加载business-rules.json' });
+                }
+                const cityConfig = rulesConfig.cityDataClassification;
+                if (!cityConfig) {
+                    return JSON.stringify({ error: 'CITY_CLASSIFY_RULES_MISSING', message: 'cityDataClassification配置段缺失' });
+                }
+                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: 'CITY_CLASSIFY_INPUT_INVALID', message: `无法加载数据: ${args.dataSource}` });
+                }
+                const aiRecommendation = recommendClassification(data, cityConfig.confidenceThreshold);
+                const sensitivityLevel = gradeSensitivity(data, cityConfig.sensitivityGradingRules);
+                const policyBasis = resolvePolicyBasis('CITY_DATA_CLASSIFICATION');
+                const autoConfirm = args.autoConfirm ?? false;
+                const result = {
+                    aiRecommendation,
+                    humanReview: autoConfirm
+                        ? { reviewer: 'auto-confirm', reviewedAt: new Date().toISOString(), confirmed: true }
+                        : { reviewer: null, reviewedAt: null, confirmed: false, note: '待人工复核' },
+                    sensitivityLevel,
+                    registrationEntry: {
+                        assetCode: aiRecommendation.dataAssetCode,
+                        registeredAt: new Date().toISOString(),
+                        initialRegistration: true,
+                    },
+                    policyBasis,
+                    timestamp: new Date().toISOString(),
+                };
+                return JSON.stringify(result, null, 2);
+            }
+            catch (e) {
+                return JSON.stringify({ error: 'UNKNOWN_ERROR', message: e.message });
+            }
+        },
+    });
+    ctx.tools.register({
+        name: 'confirm_city_classification',
+        description: '人工复核确认AI推荐的城市数据分类结果',
+        parameters: {
+            type: 'object',
+            properties: {
+                classificationId: { type: 'string', description: '分类结果ID' },
+                reviewer: { type: 'string', description: '复核人' },
+                confirmed: { type: 'boolean' },
+                adjustments: { type: 'string', description: '调整说明（可选）' },
+            },
+            required: ['classificationId', 'reviewer', 'confirmed'],
+        },
+        async execute(args) {
+            return JSON.stringify({
+                classificationId: args.classificationId,
+                reviewer: args.reviewer,
+                confirmed: args.confirmed,
+                adjustments: args.adjustments ?? null,
+                reviewedAt: new Date().toISOString(),
+            });
+        },
+    });
+}
+function recommendClassification(data, confidenceThreshold) {
+    let structured = 0, semiStructured = 0, unstructured = 0;
+    for (const row of data) {
+        if (typeof row === 'object' && row !== null && !Array.isArray(row)) {
+            const keys = Object.keys(row);
+            if (keys.length > 0) {
+                if (keys.every((k) => /^[a-zA-Z_]+$/.test(k)))
+                    structured++;
+                else
+                    semiStructured++;
+            }
+            else
+                unstructured++;
+        }
+        else {
+            unstructured++;
+        }
+    }
+    const total = data.length || 1;
+    const primaryCategory = structured >= semiStructured && structured >= unstructured ? 'structured' : semiStructured >= unstructured ? 'semi-structured' : 'unstructured';
+    const confidence = primaryCategory === 'structured' ? structured / total : primaryCategory === 'semi-structured' ? semiStructured / total : unstructured / total;
+    const codeMap = { structured: 'A0101', 'semi-structured': 'A0201', unstructured: 'A0301' };
+    return {
+        primaryCategory,
+        specificType: '城市数据',
+        dataAssetCode: codeMap[primaryCategory] ?? 'A0000',
+        confidence: Math.round(confidence * 100) / 100,
+        reasoning: `基于${total}条样本分析，${primaryCategory}数据占比${Math.round(confidence * 100)}%`,
+        meetsThreshold: confidence >= confidenceThreshold,
+    };
+}
+function gradeSensitivity(data, _rules) {
+    const sensitiveKeywords = ['身份证', '手机号', '地址', '密码', '银行'];
+    let maxSensitivity = 0;
+    for (const row of data) {
+        if (typeof row === 'object' && row !== null) {
+            const json = JSON.stringify(row);
+            for (const kw of sensitiveKeywords) {
+                if (json.includes(kw))
+                    maxSensitivity = Math.max(maxSensitivity, 3);
+            }
+        }
+    }
+    const levels = ['public', 'internal', 'confidential', 'restricted'];
+    return levels[maxSensitivity] ?? 'internal';
+}
+//# sourceMappingURL=index.js.map

package/lib/policyBasis.js

@@ -0,0 +1,17 @@
+import { loadJsonConfig } from '@liuhange/dsh-data-asset-shared';
+export function resolvePolicyBasis(stage) {
+    try {
+        const config = loadJsonConfig('POLICY_REFS_PATH', 'config/policy-references.json', '@liuhange/dsh-data-asset-shared/config/policy-references.json');
+        const refs = config.policyReferences;
+        const stageEntry = refs?.find((s) => s.stage === stage);
+        if (!stageEntry) {
+            console.warn(`Policy stage "${stage}" not configured`);
+            return [`依据：政策依据未配置（stage=${stage}）`];
+        }
+        return stageEntry.documents.map((d) => `依据：《${d.name}》（${d.docNumber}）—${d.coreRequirement}`);
+    }
+    catch {
+        return ['依据：政策依据配置加载失败'];
+    }
+}
+//# sourceMappingURL=policyBasis.js.map

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@liuhange/dsh-city-data-classifier",
+  "description": "City data AI classification plugin: auto-recommend GB/T 47949-2026 category and sensitivity grading",
+  "version": "3.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/liuhange789/data-asset-inspector.git",
+    "directory": "packages/data-asset/city-data-classifier"
+  },
+  "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
+    }
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh-plugin",
+    "data-asset",
+    "data-asset-inspector",
+    "shujintong",
+    "数据资产",
+    "city-data",
+    "ai-classification",
+    "sensitivity-grading",
+    "gbt-47949",
+    "城市数据",
+    "AI分类",
+    "敏感度分级"
+  ],
+  "homepage": "https://github.com/liuhange789/data-asset-inspector#readme"
+}