@liuhange/dsh-data-asset-inventory-scan 3.0.0

package/lib/__tests__/inventoryScan.test.js

@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest';
+import { AssetTripleConditionScreener } from '../assetTripleConditionScreener.js';
+import { OwnershipClueAnnotator } from '../ownershipClueAnnotator.js';
+describe('AssetTripleConditionScreener', () => {
+    const config = {
+        pastTransactionKeywords: ['购买', '合同', '交易'],
+        ownershipControlKeywords: ['自有', '控制', '拥有'],
+        economicBenefitKeywords: ['收益', '价值', '利润'],
+    };
+    const screener = new AssetTripleConditionScreener(config);
+    it('三条件全满足→初筛通过', () => {
+        const result = screener.screen({
+            desc: '通过购买合同取得，企业自有控制，预期带来收益',
+        });
+        expect(result.passed).toBe(true);
+        expect(result.missingConditions).toHaveLength(0);
+    });
+    it('缺少过去交易→不通过', () => {
+        const result = screener.screen({
+            desc: '企业自有控制，预期带来收益',
+        });
+        expect(result.passed).toBe(false);
+        expect(result.missingConditions).toContain('过去交易或事项形成');
+    });
+});
+describe('OwnershipClueAnnotator', () => {
+    const rules = {
+        holdingRightFields: ['owner', 'holder'],
+        usageRightFields: ['license', 'usage'],
+        operationRightFields: ['admin', 'operator'],
+    };
+    const annotator = new OwnershipClueAnnotator(rules);
+    it('正确标注权属线索', () => {
+        const result = annotator.annotate({
+            owner: '某科技公司',
+            license: '授权使用',
+            admin: '管理部门',
+        });
+        expect(result.holdingRight).toBe('某科技公司');
+        expect(result.usageRight).toBe('授权使用');
+        expect(result.operationRight).toBe('管理部门');
+    });
+    it('无匹配时返回空线索', () => {
+        const result = annotator.annotate({
+            unknown: '无',
+        });
+        expect(result.holdingRight).toBe('');
+        expect(result.usageRight).toBe('');
+        expect(result.operationRight).toBe('');
+    });
+});
+//# sourceMappingURL=inventoryScan.test.js.map

package/lib/assetTripleConditionScreener.js

@@ -0,0 +1,24 @@
+export class AssetTripleConditionScreener {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    screen(metadata) {
+        const text = JSON.stringify(metadata).toLowerCase();
+        const missing = [];
+        const hasPastTransaction = this.config.pastTransactionKeywords.some(kw => text.includes(kw.toLowerCase()));
+        if (!hasPastTransaction)
+            missing.push('过去交易或事项形成');
+        const hasOwnershipControl = this.config.ownershipControlKeywords.some(kw => text.includes(kw.toLowerCase()));
+        if (!hasOwnershipControl)
+            missing.push('企业拥有或控制');
+        const hasEconomicBenefit = this.config.economicBenefitKeywords.some(kw => text.includes(kw.toLowerCase()));
+        if (!hasEconomicBenefit)
+            missing.push('预期带来经济利益');
+        return {
+            passed: missing.length === 0,
+            missingConditions: missing,
+        };
+    }
+}
+//# sourceMappingURL=assetTripleConditionScreener.js.map

package/lib/index.js

@@ -0,0 +1,68 @@
+import { ScanExecutor } from './scanExecutor.js';
+import { validateScanArgs } from './invariant.js';
+export const name = '@liuhange/dsh-data-asset-inventory-scan';
+export const inject = ['tools'];
+export function apply(ctx) {
+    ctx.tools.register({
+        name: 'scan_data_assets',
+        description: '数据资产深度扫描：全量元数据扫描+资产三条件初筛+权属线索标注+政策依据输出',
+        parameters: {
+            type: 'object',
+            properties: {
+                scanSource: { type: 'string', description: '目录路径或数据库连接配置JSON' },
+                sourceType: { type: 'string', enum: ['directory', 'database'], description: '扫描源类型' },
+                outputPathDir: { type: 'string', description: '报告输出目录（可选）' },
+            },
+            required: ['scanSource', 'sourceType'],
+        },
+        async execute(args) {
+            try {
+                const validated = validateScanArgs(args);
+                let rulesConfig;
+                try {
+                    const rulesPath = process.env.BUSINESS_RULES_PATH || 'config/business-rules.json';
+                    const { readFileSync } = await import('node:fs');
+                    rulesConfig = JSON.parse(readFileSync(rulesPath, 'utf-8'));
+                }
+                catch {
+                    return JSON.stringify({ error: 'SCAN_RULES_MISSING', message: '无法加载business-rules.json' });
+                }
+                const inventoryConfig = rulesConfig.inventoryScan;
+                if (!inventoryConfig) {
+                    return JSON.stringify({ error: 'SCAN_RULES_MISSING', message: 'inventoryScan配置段缺失' });
+                }
+                let policyDocuments;
+                try {
+                    const policyPath = process.env.POLICY_REFS_PATH || 'config/policy-references.json';
+                    const { readFileSync } = await import('node:fs');
+                    const policyConfig = JSON.parse(readFileSync(policyPath, 'utf-8'));
+                    const stage = policyConfig.policyReferences?.find((s) => s.stage === 'INVENTORY_SCAN');
+                    policyDocuments = stage?.documents ?? [];
+                }
+                catch {
+                    policyDocuments = [];
+                }
+                if (!policyDocuments || policyDocuments.length === 0) {
+                    return JSON.stringify({ error: 'POLICY_REFERENCES_EMPTY', message: 'INVENTORY_SCAN阶段政策依据缺失' });
+                }
+                const executorConfig = {
+                    tripleCondition: inventoryConfig.assetTripleCondition,
+                    ownershipClueRules: inventoryConfig.ownershipClueRules,
+                    scanScaleLimit: inventoryConfig.scanScaleLimit ?? 10000,
+                    policyDocuments,
+                };
+                const executor = new ScanExecutor(executorConfig);
+                const report = executor.execute(validated.scanSource, validated.sourceType, validated.outputPathDir);
+                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,25 @@
+export function invariant(condition, message) {
+    if (!condition) {
+        throw new Error(`INVARIANT_VIOLATION: ${message}`);
+    }
+}
+export function validateScanArgs(args) {
+    if (!args || typeof args !== 'object') {
+        throw new Error('INVALID_ARGS: args must be an object');
+    }
+    if (!args.scanSource || typeof args.scanSource !== 'string') {
+        throw new Error('INVALID_ARGS: scanSource is required and must be a string');
+    }
+    if (!args.sourceType || !['directory', 'database'].includes(args.sourceType)) {
+        throw new Error('INVALID_ARGS: sourceType is required and must be "directory" or "database"');
+    }
+    const result = {
+        scanSource: args.scanSource,
+        sourceType: args.sourceType,
+    };
+    if (typeof args.outputPathDir === 'string') {
+        result.outputPathDir = args.outputPathDir;
+    }
+    return result;
+}
+//# sourceMappingURL=invariant.js.map

package/lib/ownershipClueAnnotator.js

@@ -0,0 +1,23 @@
+export class OwnershipClueAnnotator {
+    rules;
+    constructor(rules) {
+        this.rules = rules;
+    }
+    annotate(metadata) {
+        return {
+            holdingRight: this._extractFirst(metadata, this.rules.holdingRightFields),
+            usageRight: this._extractFirst(metadata, this.rules.usageRightFields),
+            operationRight: this._extractFirst(metadata, this.rules.operationRightFields),
+        };
+    }
+    _extractFirst(metadata, fields) {
+        for (const field of fields) {
+            const value = metadata[field];
+            if (value !== undefined && value !== null && String(value).trim() !== '') {
+                return String(value);
+            }
+        }
+        return '';
+    }
+}
+//# sourceMappingURL=ownershipClueAnnotator.js.map

package/lib/scanExecutor.js

@@ -0,0 +1,38 @@
+import { ScanSourceAdapterFactory } from './scanSourceAdapter.js';
+import { AssetTripleConditionScreener } from './assetTripleConditionScreener.js';
+import { OwnershipClueAnnotator } from './ownershipClueAnnotator.js';
+import { ScanReportGenerator } from './scanReportGenerator.js';
+export class ScanExecutor {
+    config;
+    screener;
+    annotator;
+    reportGenerator;
+    constructor(config) {
+        this.config = config;
+        this.screener = new AssetTripleConditionScreener(config.tripleCondition);
+        this.annotator = new OwnershipClueAnnotator(config.ownershipClueRules);
+        this.reportGenerator = new ScanReportGenerator(config.policyDocuments);
+    }
+    execute(scanSource, sourceType, outputPathDir) {
+        const adapter = ScanSourceAdapterFactory.create(sourceType);
+        const metadata = adapter.scan(scanSource, this.config.scanScaleLimit);
+        const assetItems = metadata.map(obj => {
+            const screening = this.screener.screen(obj);
+            const ownershipClues = this.annotator.annotate(obj);
+            const item = {
+                id: obj.id,
+                name: obj.name,
+                sourceType,
+                metadata: obj,
+                initialScreening: screening.passed ? '初筛通过' : '初筛不通过',
+                ownershipClues,
+            };
+            if (screening.missingConditions.length > 0) {
+                item.missingConditions = screening.missingConditions;
+            }
+            return item;
+        });
+        return this.reportGenerator.generate(assetItems, scanSource, sourceType, outputPathDir);
+    }
+}
+//# sourceMappingURL=scanExecutor.js.map

package/lib/scanReportGenerator.js

@@ -0,0 +1,35 @@
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+export class ScanReportGenerator {
+    policyDocuments;
+    constructor(policyDocuments) {
+        this.policyDocuments = policyDocuments;
+    }
+    generate(assetItems, scanSource, sourceType, outputPathDir) {
+        if (!this.policyDocuments || this.policyDocuments.length === 0) {
+            throw new Error('POLICY_REFERENCES_EMPTY: policy documents must not be empty');
+        }
+        for (const doc of this.policyDocuments) {
+            if (!doc.name || doc.name === '依据文件待补充') {
+                throw new Error(`POLICY_REFERENCE_PLACEHOLDER: ${doc.name || 'undefined'}`);
+            }
+        }
+        const report = {
+            assetItems,
+            scanSource,
+            sourceType,
+            policyReferences: this.policyDocuments,
+            timestamp: new Date().toISOString(),
+            status: 'SUCCESS',
+        };
+        if (outputPathDir) {
+            const outputPath = join(outputPathDir, 'scan-report.json');
+            writeFileSync(outputPath, JSON.stringify(report, null, 2), 'utf-8');
+        }
+        return report;
+    }
+    formatPolicyReference(doc) {
+        return `依据：《${doc.name}》（${doc.docNumber}）——${doc.coreRequirement}`;
+    }
+}
+//# sourceMappingURL=scanReportGenerator.js.map

package/lib/scanSourceAdapter.js

@@ -0,0 +1,77 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join, extname, basename } from 'node:path';
+export class DirectoryScanAdapter {
+    scan(dirPath, scaleLimit) {
+        const results = [];
+        this._scanRecursive(dirPath, results, scaleLimit);
+        if (results.length > scaleLimit) {
+            throw new Error(`SCAN_SCALE_EXCEEDED: ${results.length} > ${scaleLimit}`);
+        }
+        return results;
+    }
+    _scanRecursive(dir, results, limit) {
+        if (results.length >= limit)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            throw new Error(`SCAN_SOURCE_UNREACHABLE: ${dir}`);
+        }
+        for (const entry of entries) {
+            if (results.length >= limit)
+                return;
+            const fullPath = join(dir, entry);
+            let stat;
+            try {
+                stat = statSync(fullPath);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isDirectory()) {
+                this._scanRecursive(fullPath, results, limit);
+            }
+            else {
+                results.push({
+                    id: `${results.length + 1}`,
+                    name: basename(fullPath),
+                    path: fullPath,
+                    size: stat.size,
+                    type: extname(fullPath).slice(1) || 'unknown',
+                    createdAt: stat.birthtime.toISOString(),
+                    modifiedAt: stat.mtime.toISOString(),
+                });
+            }
+        }
+    }
+}
+export class DatabaseScanAdapter {
+    scan(config, _scaleLimit) {
+        let dbConfig;
+        try {
+            dbConfig = JSON.parse(config);
+        }
+        catch {
+            throw new Error('INVALID_JSON: database config is not valid JSON');
+        }
+        const required = ['host', 'port', 'database'];
+        for (const field of required) {
+            if (!(field in dbConfig)) {
+                throw new Error(`INVALID_CONFIG: missing field ${field}`);
+            }
+        }
+        throw new Error('DATABASE_SCAN_NOT_IMPLEMENTED: use directory scan or provide database driver');
+    }
+}
+export class ScanSourceAdapterFactory {
+    static create(sourceType) {
+        if (sourceType === 'directory')
+            return new DirectoryScanAdapter();
+        if (sourceType === 'database')
+            return new DatabaseScanAdapter();
+        throw new Error(`INVALID_SOURCE_TYPE: ${sourceType}`);
+    }
+}
+//# sourceMappingURL=scanSourceAdapter.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-inventory-scan",
+  "description": "Data asset inventory scan plugin: deep metadata scan + triple condition screening + ownership clue annotation",
+  "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-inventory-scan" },
+  "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 } }
+}