@liuhange/dsh-data-asset-quality-score 3.0.0

package/lib/__tests__/qualityScore.test.js

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+describe('data-asset-quality-score', () => {
+    it('导出name/inject/apply', async () => {
+        const mod = await import('../index.js');
+        expect(mod.name).toBe('@liuhange/dsh-data-asset-quality-score');
+        expect(mod.inject).toEqual(['tools']);
+        expect(typeof mod.apply).toBe('function');
+    });
+    it('apply注册score_data_quality工具', async () => {
+        const mod = await import('../index.js');
+        const tools = [];
+        mod.apply({ tools: { register: (t) => tools.push(t) } });
+        const tool = tools[0];
+        expect(tool.name).toBe('score_data_quality');
+        expect(tool.description).toContain('六维');
+    });
+});
+//# sourceMappingURL=qualityScore.test.js.map

package/lib/index.js

@@ -0,0 +1,191 @@
+export const name = '@liuhange/dsh-data-asset-quality-score';
+export const inject = ['tools'];
+export function apply(ctx) {
+    ctx.tools.register({
+        name: 'score_data_quality',
+        description: '数据质量量化评分：六维（规范性+完整性+准确性+一致性+时效性+可访问性）0-100分',
+        parameters: {
+            type: 'object',
+            properties: {
+                dataSource: { type: 'string', description: '数据文件路径或JSON数据' },
+                schema: { type: 'string', description: '数据schema声明（可选）' },
+            },
+            required: ['dataSource'],
+        },
+        async execute(args) {
+            try {
+                if (!args?.dataSource || typeof args.dataSource !== 'string') {
+                    return JSON.stringify({ error: 'INVALID_ARGS', message: 'dataSource is required' });
+                }
+                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: 'QUALITY_RULES_MISSING', message: '无法加载business-rules.json' });
+                }
+                const qsConfig = rulesConfig.qualityScoringExtended;
+                if (!qsConfig) {
+                    return JSON.stringify({ error: 'QUALITY_RULES_MISSING', message: 'qualityScoringExtended配置段缺失' });
+                }
+                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 === 'QUALITY_SCORE');
+                    policyDocuments = stage?.documents ?? [];
+                }
+                catch { /* empty */ }
+                const weights = qsConfig.weights;
+                const weightSum = Object.values(weights).reduce((a, b) => a + b, 0);
+                if (Math.abs(weightSum - 1) > 0.001) {
+                    return JSON.stringify({ error: 'WEIGHT_SUM_INVALID', message: `权重和=${weightSum}，必须为1` });
+                }
+                let data;
+                try {
+                    const raw = readFileSync(args.dataSource, 'utf-8');
+                    data = JSON.parse(raw);
+                    if (!Array.isArray(data))
+                        data = [data];
+                }
+                catch {
+                    return JSON.stringify({ error: 'DATA_LOAD_FAILED', message: `无法加载数据: ${args.dataSource}` });
+                }
+                const dimensions = [];
+                const normalityConfig = qsConfig.normality;
+                const normalityScore = scoreNormality(data, normalityConfig);
+                dimensions.push({ dimension: 'normality', score: normalityScore.score, weight: weights.normality ?? 0, issues: normalityScore.issues });
+                const completenessConfig = rulesConfig.qualityScoring?.completeness;
+                const completenessScore = scoreCompleteness(data, completenessConfig);
+                dimensions.push({ dimension: 'completeness', score: completenessScore.score, weight: weights.completeness ?? 0, issues: completenessScore.issues });
+                const accuracyScore = scoreAccuracy(data);
+                dimensions.push({ dimension: 'accuracy', score: accuracyScore.score, weight: weights.accuracy ?? 0, issues: accuracyScore.issues });
+                const consistencyScore = scoreConsistency(data);
+                dimensions.push({ dimension: 'consistency', score: consistencyScore.score, weight: weights.consistency ?? 0, issues: consistencyScore.issues });
+                const timelinessScore = scoreTimeliness(data);
+                dimensions.push({ dimension: 'timeliness', score: timelinessScore.score, weight: weights.timeliness ?? 0, issues: timelinessScore.issues });
+                const accessibilityConfig = qsConfig.accessibility;
+                const accessibilityScore = scoreAccessibility(data, accessibilityConfig);
+                dimensions.push({ dimension: 'accessibility', score: accessibilityScore.score, weight: weights.accessibility ?? 0, issues: accessibilityScore.issues });
+                const totalScore = dimensions.reduce((sum, d) => sum + d.score * d.weight, 0);
+                const report = {
+                    dimensions,
+                    totalScore: Math.round(totalScore * 10) / 10,
+                    policyReferences: policyDocuments,
+                    timestamp: new Date().toISOString(),
+                };
+                return JSON.stringify(report, null, 2);
+            }
+            catch (e) {
+                return JSON.stringify({ error: 'UNKNOWN_ERROR', message: e.message });
+            }
+        },
+    });
+}
+function scoreNormality(data, config) {
+    const issues = [];
+    const pattern = new RegExp(config.fieldNamePattern);
+    let fieldCount = 0, validCount = 0;
+    for (const row of data) {
+        if (typeof row === 'object' && row !== null) {
+            for (const key of Object.keys(row)) {
+                fieldCount++;
+                if (pattern.test(key))
+                    validCount++;
+                else
+                    issues.push(`字段名不规范: ${key}`);
+            }
+        }
+    }
+    for (const req of config.requiredFields) {
+        const hasField = data.some(row => typeof row === 'object' && row !== null && req in row);
+        if (!hasField)
+            issues.push(`必填字段缺失: ${req}`);
+    }
+    const score = fieldCount > 0 ? (validCount / fieldCount) * 100 : 50;
+    return { score: Math.round(score), issues };
+}
+function scoreCompleteness(data, config) {
+    const issues = [];
+    let totalFields = 0, missingFields = 0;
+    for (const row of data) {
+        if (typeof row === 'object' && row !== null) {
+            for (const [key, value] of Object.entries(row)) {
+                totalFields++;
+                if (value === null || value === undefined || config.missingMarkers.includes(String(value))) {
+                    missingFields++;
+                    issues.push(`字段缺失: ${key}`);
+                }
+            }
+        }
+    }
+    const score = totalFields > 0 ? ((totalFields - missingFields) / totalFields) * 100 : 50;
+    return { score: Math.round(score), issues };
+}
+function scoreAccuracy(data) {
+    const issues = [];
+    let validCount = 0;
+    for (const row of data) {
+        if (typeof row === 'object' && row !== null) {
+            const obj = row;
+            if (obj.age !== undefined) {
+                const age = Number(obj.age);
+                if (age < 0 || age > 150)
+                    issues.push(`年龄异常: ${obj.age}`);
+                else
+                    validCount++;
+            }
+            if (obj.phone !== undefined) {
+                if (!/^1[3-9]\d{9}$/.test(String(obj.phone)))
+                    issues.push(`手机号格式错误: ${obj.phone}`);
+                else
+                    validCount++;
+            }
+        }
+    }
+    return { score: Math.min(100, 60 + validCount * 5), issues };
+}
+function scoreConsistency(data) {
+    const issues = [];
+    let consistentCount = 0;
+    for (const row of data) {
+        if (typeof row === 'object' && row !== null) {
+            const obj = row;
+            if (obj.startDate && obj.endDate) {
+                if (new Date(obj.startDate) <= new Date(obj.endDate))
+                    consistentCount++;
+                else
+                    issues.push(`日期不一致: startDate=${obj.startDate} > endDate=${obj.endDate}`);
+            }
+        }
+    }
+    return { score: Math.min(100, 60 + consistentCount * 5), issues };
+}
+function scoreTimeliness(data) {
+    const issues = [];
+    const now = Date.now();
+    const thresholdMs = 720 * 60 * 60 * 1000;
+    let freshCount = 0;
+    for (const row of data) {
+        if (typeof row === 'object' && row !== null) {
+            const obj = row;
+            if (obj.updatedAt) {
+                const updated = new Date(obj.updatedAt).getTime();
+                if (now - updated < thresholdMs)
+                    freshCount++;
+                else
+                    issues.push(`数据过期: updatedAt=${obj.updatedAt}`);
+            }
+        }
+    }
+    return { score: Math.min(100, 50 + freshCount * 10), issues };
+}
+function scoreAccessibility(data, config) {
+    const issues = [];
+    const accessibleRate = data.length > 0 ? 1 : 0;
+    if (accessibleRate < config.minAccessibleRate) {
+        issues.push(`可访问率${accessibleRate} < ${config.minAccessibleRate}`);
+    }
+    return { score: accessibleRate >= config.minAccessibleRate ? 100 : 50, issues };
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@liuhange/dsh-data-asset-quality-score",
+  "description": "Data quality scoring plugin: six-dimension quantitative scoring (normality + completeness + accuracy + consistency + timeliness + accessibility)",
+  "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-quality-score" },
+  "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 } }
+}