@liuhange/dsh-construction-data-inventory 0.0.0-stage → 3.1.1

package/README.md

@@ -1,3 +1,72 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# @liuhange/dsh-construction-data-inventory
+
+> 建筑工程项目数据资产盘点插件
+
+## 插件职责
+
+对建筑工程项目产生的多源异构数据进行资产化盘点，实现符合 GB/T 51269 标准的分类编码与可追溯资产台账输出。
+
+## 法规依据
+
+《建筑信息模型分类和编码标准》（GB/T 51269-2017）
+
+## 法律免责声明
+
+本报告由辅助盘点工具生成，不替代GB/T 51269标准的正式合规认证
+
+## 安装
+
+```bash
+pnpm add @liuhange/dsh-construction-data-inventory
+```
+
+## 工具
+
+### inspect_ai_dataset
+
+对建筑工程项目多源异构数据进行资产化盘点，按 GB/T 51269 标准生成分类编码与资产台账。
+
+**参数：**
+
+| 参数 | 类型 | 必填 | 说明 |
+|------|------|------|------|
+| projectId | string | 是 | 建筑工程项目标识 |
+| sourceConfigPath | string | 是 | 数据源配置文件路径 |
+| changeDataPath | string | 否 | 变更单数据文件路径 |
+| outputPathDir | string | 否 | 报告输出目录 |
+
+### submit_review_override
+
+提交人工复核覆盖指令，对自动分类与编码结果进行人工覆盖并记录覆盖理由。
+
+**参数：**
+
+| 参数 | 类型 | 必填 | 说明 |
+|------|------|------|------|
+| assetId | string | 是 | 被覆盖的资产标识 |
+| reviewItem | string | 是 | 复核项（classification/encoding/changeTraceability） |
+| overrideConclusion | string | 是 | 覆盖后结论 |
+| overrideReason | string | 是 | 覆盖理由 |
+| operator | string | 是 | 操作人标识 |
+| inventoryReportPath | string | 是 | 盘点报告路径 |
+
+## 配置文件
+
+### config/classification-config.json
+
+GB/T 51269 分类体系配置，包含建设成果（10-15）、建设进程（20-22）、建设资源（30-32, 40）、建设属性（41）四大类。
+
+### config/encoding-rule-config.json
+
+资产编码规则配置，包含分类层级码长度、顺序码长度、顺序码起始值、校验位算法。
+
+### config/source-adapter-config.json
+
+数据源适配器配置，定义 IFC/合同/进度/验收四类适配器。
+
+## 技术栈
+
+- TypeScript 5.7
+- Node.js 22+
+- DeepSeek Harness 插件框架
+- Vitest

package/config/classification-config.json

@@ -0,0 +1,111 @@
+{
+  "version": "1.0.0",
+  "lastUpdated": "2024-01-01T00:00:00.000Z",
+  "nodes": [
+    {
+      "classificationCode": "10",
+      "classificationName": "按功能分建筑物",
+      "parentCode": "",
+      "level": 1,
+      "mappedDataTypes": ["BIM构件-建筑物", "BIM模型-建筑物", "设计图纸-建筑物"]
+    },
+    {
+      "classificationCode": "11",
+      "classificationName": "按形态分建筑物",
+      "parentCode": "",
+      "level": 1,
+      "mappedDataTypes": ["BIM构件-建筑物形态", "设计图纸-建筑物形态"]
+    },
+    {
+      "classificationCode": "12",
+      "classificationName": "按功能分建筑空间",
+      "parentCode": "",
+      "level": 1,
+      "mappedDataTypes": ["BIM构件-建筑空间", "BIM模型-建筑空间"]
+    },
+    {
+      "classificationCode": "13",
+      "classificationName": "按形态分建筑空间",
+      "parentCode": "",
+      "level": 1,
+      "mappedDataTypes": ["BIM构件-建筑空间形态"]
+    },
+    {
+      "classificationCode": "14",
+      "classificationName": "元素",
+      "parentCode": "",
+      "level": 1,
+      "mappedDataTypes": ["BIM构件-元素", "BIM模型-元素", "设计图纸-元素"]
+    },
+    {
+      "classificationCode": "15",
+      "classificationName": "工作成果",
+      "parentCode": "",
+      "level": 1,
+      "mappedDataTypes": ["BIM构件-工作成果", "设计图纸-工作成果"]
+    },
+    {
+      "classificationCode": "20",
+      "classificationName": "工程建设项目阶段",
+      "parentCode": "",
+      "level": 1,
+      "mappedDataTypes": ["进度记录-项目阶段", "工序记录-项目阶段"]
+    },
+    {
+      "classificationCode": "21",
+      "classificationName": "行为",
+      "parentCode": "",
+      "level": 1,
+      "mappedDataTypes": ["进度记录-行为", "工序记录-行为", "施工数据-行为"]
+    },
+    {
+      "classificationCode": "22",
+      "classificationName": "专业领域",
+      "parentCode": "",
+      "level": 1,
+      "mappedDataTypes": ["进度记录-专业领域", "工序记录-专业领域", "施工数据-专业领域"]
+    },
+    {
+      "classificationCode": "30",
+      "classificationName": "建筑产品",
+      "parentCode": "",
+      "level": 1,
+      "mappedDataTypes": ["材料清单-建筑产品", "材质信息-建筑产品"]
+    },
+    {
+      "classificationCode": "31",
+      "classificationName": "组织角色",
+      "parentCode": "",
+      "level": 1,
+      "mappedDataTypes": ["材料清单-组织角色", "参建方信息-组织角色"]
+    },
+    {
+      "classificationCode": "32",
+      "classificationName": "工具",
+      "parentCode": "",
+      "level": 1,
+      "mappedDataTypes": ["材料清单-工具"]
+    },
+    {
+      "classificationCode": "33",
+      "classificationName": "信息",
+      "parentCode": "",
+      "level": 1,
+      "mappedDataTypes": ["材料清单-信息", "材质信息-信息"]
+    },
+    {
+      "classificationCode": "40",
+      "classificationName": "材质",
+      "parentCode": "",
+      "level": 1,
+      "mappedDataTypes": ["材料清单-材质", "材质信息-材质", "材料数据-材质"]
+    },
+    {
+      "classificationCode": "41",
+      "classificationName": "属性",
+      "parentCode": "",
+      "level": 1,
+      "mappedDataTypes": ["验收属性", "质量属性", "验收文档-属性", "属性数据"]
+    }
+  ]
+}

package/config/encoding-rule-config.json

@@ -0,0 +1,9 @@
+{
+  "version": "1.0.0",
+  "lastUpdated": "2024-01-01T00:00:00.000Z",
+  "classificationCodeLength": 5,
+  "sequentialCodeLength": 4,
+  "sequentialCodeStart": 1,
+  "sequentialCodeMax": 9999,
+  "checksumAlgorithm": "Luhn"
+}

package/config/source-adapter-config.json

@@ -0,0 +1,26 @@
+{
+  "version": "1.0.0",
+  "lastUpdated": "2024-01-01T00:00:00.000Z",
+  "adapters": [
+    {
+      "type": "IFC",
+      "adapterClassName": "IfcModelAdapter",
+      "supportedVersions": ["IFC2X3", "IFC4"]
+    },
+    {
+      "type": "CONTRACT",
+      "adapterClassName": "ContractAdapter",
+      "supportedVersions": ["1.0"]
+    },
+    {
+      "type": "PROGRESS",
+      "adapterClassName": "ProgressRecordAdapter",
+      "supportedVersions": ["1.0"]
+    },
+    {
+      "type": "ACCEPTANCE",
+      "adapterClassName": "AcceptanceDocAdapter",
+      "supportedVersions": ["1.0"]
+    }
+  ]
+}

package/cordis.patch.yml

@@ -0,0 +1,9 @@
+# Cordis Framework Patch Declaration for @liuhange/dsh-construction-data-inventory
+# This file declares the plugin's runtime patch for the Cordis framework.
+# Used by DSH plugin manager to apply framework-level patches during installation.
+plugin: @liuhange/dsh-construction-data-inventory
+version: 3.1.1
+patch:
+  - target: tools
+    action: register
+    description: Register plugin tools into Cordis runtime

package/lib/acceptance-doc-adapter.js

@@ -0,0 +1,56 @@
+import { readFileSync } from 'node:fs';
+export class AcceptanceDocAdapter {
+    adapt(sourcePath, systemId, projectId) {
+        const assets = [];
+        const warnings = [];
+        const errors = [];
+        let content;
+        try {
+            content = readFileSync(sourcePath, 'utf-8');
+        }
+        catch (e) {
+            errors.push(`验收文件读取失败: ${sourcePath} - ${e.message}`);
+            return { assets, warnings, errors };
+        }
+        let records;
+        try {
+            const parsed = JSON.parse(content);
+            records = Array.isArray(parsed) ? parsed : [parsed];
+        }
+        catch (e) {
+            errors.push(`验收文件解析失败: ${sourcePath} - ${e.message}`);
+            return { assets, warnings, errors };
+        }
+        const collectionTime = new Date().toISOString();
+        for (const record of records) {
+            if (!record || typeof record !== 'object') {
+                warnings.push('验收记录格式不合法，已跳过');
+                continue;
+            }
+            if (typeof record.acceptanceId !== 'string' || record.acceptanceId.trim() === '') {
+                warnings.push('验收记录缺少acceptanceId，已跳过');
+                continue;
+            }
+            const dataType = this.mapAcceptanceTypeToDataType(record.acceptanceType ?? '');
+            assets.push({
+                assetId: `ACCEPTANCE-${record.acceptanceId}`,
+                sourceSystemId: systemId,
+                dataType,
+                projectId,
+                collectionTime: record.acceptanceDate || collectionTime,
+                classificationCode: '',
+                assetCode: '',
+                judgmentStatus: '自动判定',
+            });
+        }
+        return { assets, warnings, errors };
+    }
+    mapAcceptanceTypeToDataType(acceptanceType) {
+        if (!acceptanceType)
+            return '验收属性';
+        if (acceptanceType.includes('质量'))
+            return '质量属性';
+        return '验收属性';
+    }
+}
+//# sourceMappingURL=acceptance-doc-adapter.js.map

package/lib/asset-code-generator.js

@@ -0,0 +1,82 @@
+import { POLICY_STANDARD_NAME } from './invariant.js';
+import { SequentialCodeAllocator } from './sequential-code-allocator.js';
+import { ChecksumCalculator } from './checksum-calculator.js';
+import { CodeUniquenessValidator } from './code-uniqueness-validator.js';
+export class AssetCodeGenerator {
+    checksumCalculator;
+    uniquenessValidator;
+    constructor() {
+        this.checksumCalculator = new ChecksumCalculator();
+        this.uniquenessValidator = new CodeUniquenessValidator();
+    }
+    generate(classifiedAssets, encodingRuleConfig) {
+        const errors = [];
+        const warnings = [];
+        const overflowAssets = [];
+        const policyBasis = `依据：${POLICY_STANDARD_NAME}编码规则`;
+        const allocator = new SequentialCodeAllocator(encodingRuleConfig);
+        this.uniquenessValidator.clear();
+        if (!encodingRuleConfig.checksumAlgorithm || encodingRuleConfig.checksumAlgorithm.trim() === '') {
+            errors.push('校验位算法配置缺失，终止编码生成');
+            for (const asset of classifiedAssets) {
+                asset.assetCode = '';
+            }
+            return { assets: classifiedAssets, errors, warnings, overflowAssets };
+        }
+        for (const asset of classifiedAssets) {
+            if (!asset.classificationCode || asset.classificationCode.trim() === '') {
+                continue;
+            }
+            const classificationLevelCode = this.padToLength(asset.classificationCode, encodingRuleConfig.classificationCodeLength);
+            const sequentialCode = allocator.allocate();
+            if (sequentialCode === null) {
+                errors.push(`顺序码溢出，资产 ${asset.assetId} 编码生成失败`);
+                overflowAssets.push(asset.assetId);
+                asset.assetCode = '';
+                continue;
+            }
+            const sequentialCodeStr = this.padToLength(String(sequentialCode), encodingRuleConfig.sequentialCodeLength);
+            let checksum;
+            try {
+                checksum = this.checksumCalculator.calculate(classificationLevelCode + sequentialCodeStr, encodingRuleConfig.checksumAlgorithm);
+            }
+            catch (e) {
+                errors.push(`校验位计算失败: ${e.message}`);
+                asset.assetCode = '';
+                continue;
+            }
+            const assetCode = classificationLevelCode + sequentialCodeStr + checksum;
+            if (!this.uniquenessValidator.validate(assetCode)) {
+                errors.push(`编码重复: ${assetCode}`);
+                asset.assetCode = '';
+                continue;
+            }
+            asset.assetCode = assetCode;
+            asset.policyBasis = policyBasis;
+        }
+        return { assets: classifiedAssets, errors, warnings, overflowAssets };
+    }
+    regenerateForAsset(asset, encodingRuleConfig) {
+        const originalAssetCode = asset.assetCode;
+        const result = this.generate([asset], encodingRuleConfig);
+        if (result.assets[0] && result.assets[0].assetCode) {
+            result.assets[0].originalAssetCode = originalAssetCode;
+        }
+        return result;
+    }
+    generateSingleCode(classificationCode, sequentialCode, encodingRuleConfig) {
+        const policyBasis = `依据：${POLICY_STANDARD_NAME}编码规则`;
+        const classificationLevelCode = this.padToLength(classificationCode, encodingRuleConfig.classificationCodeLength);
+        const sequentialCodeStr = this.padToLength(String(sequentialCode), encodingRuleConfig.sequentialCodeLength);
+        const checksum = this.checksumCalculator.calculate(classificationLevelCode + sequentialCodeStr, encodingRuleConfig.checksumAlgorithm);
+        const assetCode = classificationLevelCode + sequentialCodeStr + checksum;
+        return { assetCode, policyBasis };
+    }
+    padToLength(value, length) {
+        if (value.length >= length) {
+            return value.slice(0, length);
+        }
+        return value.padStart(length, '0');
+    }
+}
+//# sourceMappingURL=asset-code-generator.js.map

package/lib/asset-ledger-exporter.js

@@ -0,0 +1,35 @@
+import { writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { resolve, sep } from 'node:path';
+export class AssetLedgerExporter {
+    export(assetList, outputPath) {
+        const ledger = this.buildLedger(assetList);
+        const fullPath = resolve(outputPath);
+        const lastSep = fullPath.lastIndexOf(sep);
+        const dir = lastSep > 0 ? fullPath.substring(0, lastSep) : '';
+        if (dir && !existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(fullPath, JSON.stringify(ledger, null, 2), 'utf-8');
+        return fullPath;
+    }
+    buildLedger(assetList) {
+        const inventoryTime = new Date().toISOString();
+        return assetList.map((asset) => ({
+            assetCode: asset.assetCode,
+            classificationCode: asset.classificationCode,
+            sourceSystemId: asset.sourceSystemId,
+            inventoryTime,
+            judgmentStatus: asset.judgmentStatus,
+        }));
+    }
+    exportToPath(assetList, outputPathDir) {
+        const fullPath = resolve(outputPathDir, 'asset-ledger.json');
+        if (!existsSync(outputPathDir)) {
+            mkdirSync(outputPathDir, { recursive: true });
+        }
+        const ledger = this.buildLedger(assetList);
+        writeFileSync(fullPath, JSON.stringify(ledger, null, 2), 'utf-8');
+        return fullPath;
+    }
+}
+//# sourceMappingURL=asset-ledger-exporter.js.map

package/lib/change-traceability-checker.js

@@ -0,0 +1,79 @@
+import { POLICY_STANDARD_NAME } from './invariant.js';
+export class ChangeTraceabilityChecker {
+    check(changeRecords, assetIds) {
+        const results = [];
+        const warnings = [];
+        const policyBasis = `依据：${POLICY_STANDARD_NAME}变更管理要求`;
+        const assetIdSet = new Set(assetIds);
+        for (const change of changeRecords) {
+            if (!change || typeof change !== 'object') {
+                warnings.push('变更记录格式不兼容，已跳过');
+                continue;
+            }
+            const missingItems = [];
+            const assetLinked = typeof change.relatedAssetId === 'string' &&
+                change.relatedAssetId.trim() !== '' &&
+                assetIdSet.has(change.relatedAssetId);
+            if (!assetLinked) {
+                missingItems.push('变更未关联资产');
+            }
+            const recordComplete = typeof change.changeReason === 'string' && change.changeReason.trim() !== '';
+            if (!recordComplete) {
+                missingItems.push('缺少变更原因');
+            }
+            const approvalChain = change.approvalChain;
+            const approvalChainComplete = approvalChain !== null &&
+                approvalChain !== undefined &&
+                typeof approvalChain === 'object' &&
+                typeof approvalChain.initiator === 'string' &&
+                approvalChain.initiator.trim() !== '' &&
+                typeof approvalChain.approver === 'string' &&
+                approvalChain.approver.trim() !== '' &&
+                typeof approvalChain.approvalTime === 'string' &&
+                approvalChain.approvalTime.trim() !== '' &&
+                typeof approvalChain.approvalConclusion === 'string' &&
+                approvalChain.approvalConclusion.trim() !== '';
+            if (!approvalChainComplete) {
+                const missingFields = [];
+                if (!approvalChain || typeof approvalChain.initiator !== 'string' || approvalChain.initiator.trim() === '') {
+                    missingFields.push('发起人');
+                }
+                if (!approvalChain || typeof approvalChain.approver !== 'string' || approvalChain.approver.trim() === '') {
+                    missingFields.push('审批人');
+                }
+                if (!approvalChain || typeof approvalChain.approvalTime !== 'string' || approvalChain.approvalTime.trim() === '') {
+                    missingFields.push('审批时间');
+                }
+                if (!approvalChain || typeof approvalChain.approvalConclusion !== 'string' || approvalChain.approvalConclusion.trim() === '') {
+                    missingFields.push('审批结论');
+                }
+                missingItems.push(`审批链不完整：缺少${missingFields.join('、')}`);
+            }
+            const impactScopeLinked = Array.isArray(change.impactScope) && change.impactScope.length > 0;
+            if (!impactScopeLinked) {
+                missingItems.push('影响范围未明确');
+            }
+            results.push({
+                changeId: change.changeId,
+                assetLinked,
+                recordComplete,
+                approvalChainComplete,
+                impactScopeLinked,
+                missingItems,
+                policyBasis,
+            });
+        }
+        return { results, warnings, skipped: false };
+    }
+    checkWithSkip(changeRecords, assetIds) {
+        if (changeRecords === null) {
+            return {
+                results: [],
+                warnings: ['变更追溯因系统不可用而跳过'],
+                skipped: true,
+            };
+        }
+        return this.check(changeRecords, assetIds);
+    }
+}
+//# sourceMappingURL=change-traceability-checker.js.map

package/lib/checksum-calculator.js

@@ -0,0 +1,53 @@
+export class ChecksumCalculator {
+    calculate(code, algorithm) {
+        if (!algorithm || algorithm.trim() === '') {
+            throw new Error('CHECKSUM_ALGORITHM_MISSING');
+        }
+        switch (algorithm.toUpperCase()) {
+            case 'LUHN':
+                return this.luhnChecksum(code);
+            case 'MOD11':
+                return this.mod11Checksum(code);
+            default:
+                throw new Error('CHECKSUM_ALGORITHM_MISSING');
+        }
+    }
+    luhnChecksum(code) {
+        const digits = code.replace(/\D/g, '').split('').map(Number);
+        let sum = 0;
+        let shouldDouble = false;
+        for (let i = digits.length - 1; i >= 0; i--) {
+            let digit = digits[i];
+            if (shouldDouble) {
+                digit *= 2;
+                if (digit > 9)
+                    digit -= 9;
+            }
+            sum += digit;
+            shouldDouble = !shouldDouble;
+        }
+        const checksum = (10 - (sum % 10)) % 10;
+        return String(checksum);
+    }
+    mod11Checksum(code) {
+        const digits = code.replace(/\D/g, '').split('').map(Number);
+        let sum = 0;
+        const weights = [2, 3, 4, 5, 6, 7, 8, 9, 10, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        for (let i = 0; i < digits.length; i++) {
+            const weight = weights[i % weights.length];
+            sum += digits[i] * weight;
+        }
+        const remainder = sum % 11;
+        const checksum = remainder === 0 ? '0' : remainder === 1 ? 'X' : String(11 - remainder);
+        return checksum;
+    }
+    validate(codeWithChecksum, algorithm) {
+        if (codeWithChecksum.length < 2)
+            return false;
+        const code = codeWithChecksum.slice(0, -1);
+        const providedChecksum = codeWithChecksum.slice(-1);
+        const expectedChecksum = this.calculate(code, algorithm);
+        return providedChecksum === expectedChecksum;
+    }
+}
+//# sourceMappingURL=checksum-calculator.js.map

package/lib/classification-mapper.js

@@ -0,0 +1,50 @@
+import { POLICY_STANDARD_NAME } from './invariant.js';
+export class ClassificationMapper {
+    map(unifiedAssets, classificationConfig) {
+        const warnings = [];
+        const unclassified = [];
+        const policyBasis = `依据：${POLICY_STANDARD_NAME}分类体系`;
+        if (!classificationConfig || !Array.isArray(classificationConfig.nodes) || classificationConfig.nodes.length === 0) {
+            warnings.push('分类配置未提供，所有数据项标记为"未分类"');
+            for (const asset of unifiedAssets) {
+                asset.classificationCode = '';
+                asset.policyBasis = '';
+                unclassified.push(asset.assetId);
+            }
+            return { assets: unifiedAssets, warnings, unclassified };
+        }
+        for (const asset of unifiedAssets) {
+            const matchedRules = this.findMatchingRules(asset.dataType, classificationConfig.nodes);
+            if (matchedRules.length === 0) {
+                asset.classificationCode = '';
+                asset.policyBasis = '';
+                unclassified.push(asset.assetId);
+                warnings.push(`资产 ${asset.assetId} 无法分类，标记为"未分类"，原始数据类型: ${asset.dataType}`);
+            }
+            else if (matchedRules.length === 1) {
+                asset.classificationCode = matchedRules[0].classificationCode;
+                asset.policyBasis = policyBasis;
+            }
+            else {
+                const selectedRule = matchedRules[0];
+                asset.classificationCode = selectedRule.classificationCode;
+                asset.policyBasis = policyBasis;
+                warnings.push(`资产 ${asset.assetId} 多规则匹配，已按优先级选取 ${selectedRule.classificationCode}`);
+            }
+        }
+        return { assets: unifiedAssets, warnings, unclassified };
+    }
+    findMatchingRules(dataType, nodes) {
+        const matched = [];
+        for (const node of nodes) {
+            if (node.mappedDataTypes && node.mappedDataTypes.includes(dataType)) {
+                matched.push(node);
+            }
+        }
+        return matched;
+    }
+    isValidClassificationCode(code, config) {
+        return config.nodes.some((node) => node.classificationCode === code);
+    }
+}
+//# sourceMappingURL=classification-mapper.js.map

package/lib/code-uniqueness-validator.js

@@ -0,0 +1,20 @@
+export class CodeUniquenessValidator {
+    codeSet = new Set();
+    validate(assetCode) {
+        if (this.codeSet.has(assetCode)) {
+            return false;
+        }
+        this.codeSet.add(assetCode);
+        return true;
+    }
+    has(assetCode) {
+        return this.codeSet.has(assetCode);
+    }
+    clear() {
+        this.codeSet.clear();
+    }
+    size() {
+        return this.codeSet.size;
+    }
+}
+//# sourceMappingURL=code-uniqueness-validator.js.map