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

package/lib/index.js

@@ -0,0 +1,304 @@
+export const name = '@liuhange/dsh-construction-data-inventory';
+export const inject = ['tools'];
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { PLUGIN_NAME } from './invariant.js';
+import { ConstructionConfigLoader } from './construction-config-loader.js';
+import { InputValidator } from './input-validator.js';
+import { IfcModelAdapter } from './ifc-model-adapter.js';
+import { ContractAdapter } from './contract-adapter.js';
+import { ProgressRecordAdapter } from './progress-record-adapter.js';
+import { AcceptanceDocAdapter } from './acceptance-doc-adapter.js';
+import { UnifiedAssetMerger } from './unified-asset-merger.js';
+import { ClassificationMapper } from './classification-mapper.js';
+import { AssetCodeGenerator } from './asset-code-generator.js';
+import { ChangeTraceabilityChecker } from './change-traceability-checker.js';
+import { ReviewOverrideRecorder } from './review-override-recorder.js';
+import { InventoryReportGenerator } from './inventory-report-generator.js';
+function errorResult(error, message) {
+    return JSON.stringify({ error, message });
+}
+function getAdapter(type) {
+    switch (type.toUpperCase()) {
+        case 'IFC':
+            return new IfcModelAdapter();
+        case 'CONTRACT':
+            return new ContractAdapter();
+        case 'PROGRESS':
+            return new ProgressRecordAdapter();
+        case 'ACCEPTANCE':
+            return new AcceptanceDocAdapter();
+        default:
+            return null;
+    }
+}
+function loadSourceConfig(sourceConfigPath) {
+    const fullPath = resolve(sourceConfigPath);
+    const raw = readFileSync(fullPath, 'utf-8');
+    return JSON.parse(raw);
+}
+function loadChangeRecords(changeDataPath) {
+    const fullPath = resolve(changeDataPath);
+    const raw = readFileSync(fullPath, 'utf-8');
+    return JSON.parse(raw);
+}
+function buildClassificationEncodingList(assets) {
+    const list = [];
+    for (const asset of assets) {
+        if (asset.classificationCode && asset.assetCode) {
+            list.push({
+                assetId: asset.assetId,
+                classificationCode: asset.classificationCode,
+                assetCode: asset.assetCode,
+                policyBasis: asset.policyBasis ?? '',
+                judgmentStatus: asset.judgmentStatus,
+            });
+        }
+    }
+    return list;
+}
+export function apply(ctx) {
+    const configLoader = new ConstructionConfigLoader();
+    const inputValidator = new InputValidator();
+    const merger = new UnifiedAssetMerger();
+    const classificationMapper = new ClassificationMapper();
+    const assetCodeGenerator = new AssetCodeGenerator();
+    const changeTraceabilityChecker = new ChangeTraceabilityChecker();
+    const reportGenerator = new InventoryReportGenerator();
+    const overrideRecorder = new ReviewOverrideRecorder();
+    ctx.tools.register({
+        name: 'inspect_ai_dataset',
+        description: '对建筑工程项目多源异构数据进行资产化盘点，按GB/T 51269标准生成分类编码与资产台账',
+        parameters: {
+            type: 'object',
+            properties: {
+                projectId: { type: 'string', description: '建筑工程项目标识' },
+                sourceConfigPath: { type: 'string', description: '数据源配置文件路径（含各数据源类型与路径）' },
+                changeDataPath: { type: 'string', description: '变更单数据文件路径（可选，缺省则跳过变更追溯检测）' },
+                outputPathDir: { type: 'string', description: '报告输出目录（默认当前工作目录）' },
+            },
+            required: ['projectId', 'sourceConfigPath'],
+        },
+        async execute(args) {
+            try {
+                const validation = inputValidator.validateInspectInput(args);
+                if (!validation.isValid) {
+                    return errorResult('INPUT_INVALID', validation.errors.map((e) => e.errorMessage).join('; '));
+                }
+                const projectId = args.projectId;
+                const sourceConfigPath = args.sourceConfigPath;
+                const changeDataPath = args.changeDataPath;
+                const outputPathDir = args.outputPathDir ?? process.cwd();
+                const configLoadResult = configLoader.load();
+                const { classificationConfig, encodingRuleConfig, sourceAdapterConfig } = configLoadResult;
+                let sourceConfig;
+                try {
+                    sourceConfig = loadSourceConfig(sourceConfigPath);
+                }
+                catch (e) {
+                    return errorResult('INPUT_INVALID', `数据源配置加载失败: ${e.message}`);
+                }
+                const sourceValidation = inputValidator.validateSources(sourceConfig);
+                if (!sourceValidation.isValid) {
+                    return errorResult('INPUT_INVALID', sourceValidation.errors.map((e) => e.errorMessage).join('; '));
+                }
+                const allWarnings = [];
+                const allErrors = [];
+                const errorList = [];
+                const adaptedLists = [];
+                for (const source of sourceConfig.sources) {
+                    if (!inputValidator.isSourceAvailable(source.path)) {
+                        allWarnings.push(`数据源 ${source.type} 不可用，已跳过`);
+                        errorList.push({ assetId: '', errorMessage: `数据源 ${source.type} 不可用，已跳过` });
+                        continue;
+                    }
+                    const adapter = getAdapter(source.type);
+                    if (adapter === null) {
+                        allWarnings.push(`未知数据源类型 ${source.type}，已跳过`);
+                        continue;
+                    }
+                    const result = adapter.adapt(source.path, source.systemId, projectId);
+                    adaptedLists.push(result);
+                    allWarnings.push(...result.warnings);
+                    allErrors.push(...result.errors);
+                }
+                const mergeResult = merger.merge(adaptedLists);
+                allWarnings.push(...mergeResult.warnings);
+                allErrors.push(...mergeResult.errors);
+                let unifiedAssets = mergeResult.unifiedAssets;
+                const classificationResult = classificationMapper.map(unifiedAssets, classificationConfig);
+                allWarnings.push(...classificationResult.warnings);
+                unifiedAssets = classificationResult.assets;
+                const codeGenResult = assetCodeGenerator.generate(unifiedAssets, encodingRuleConfig);
+                allErrors.push(...codeGenResult.errors);
+                allWarnings.push(...codeGenResult.warnings);
+                unifiedAssets = codeGenResult.assets;
+                for (const overflowAssetId of codeGenResult.overflowAssets) {
+                    errorList.push({ assetId: overflowAssetId, errorMessage: '编码生成失败：顺序码溢出' });
+                }
+                for (const errMsg of allErrors) {
+                    errorList.push({ assetId: '', errorMessage: errMsg });
+                }
+                let changeTraceabilityReport = [];
+                let skippedChangeTraceability = false;
+                if (changeDataPath) {
+                    if (!existsSync(changeDataPath)) {
+                        allWarnings.push('变更追溯因系统不可用而跳过');
+                        skippedChangeTraceability = true;
+                    }
+                    else {
+                        try {
+                            const changeRecords = loadChangeRecords(changeDataPath);
+                            const changeValidation = inputValidator.validateChangeRecords(changeRecords);
+                            for (const invalidMsg of changeValidation.invalid) {
+                                allWarnings.push(invalidMsg);
+                            }
+                            const assetIds = unifiedAssets.map((a) => a.assetId);
+                            const traceabilityResult = changeTraceabilityChecker.check(changeValidation.valid, assetIds);
+                            changeTraceabilityReport = traceabilityResult.results;
+                            allWarnings.push(...traceabilityResult.warnings);
+                        }
+                        catch (e) {
+                            allWarnings.push(`变更追溯检测失败: ${e.message}`);
+                            skippedChangeTraceability = true;
+                        }
+                    }
+                }
+                const classificationEncodingList = buildClassificationEncodingList(unifiedAssets);
+                const overrideList = overrideRecorder.getAll();
+                const configVersions = {
+                    classificationConfigVersion: classificationConfig.version,
+                    encodingRuleConfigVersion: encodingRuleConfig.version,
+                    sourceAdapterConfigVersion: sourceAdapterConfig.version,
+                };
+                const report = reportGenerator.generate({
+                    assetList: unifiedAssets,
+                    classificationEncodingList,
+                    changeTraceabilityReport,
+                    overrideList,
+                    errorList,
+                    configVersions,
+                    projectId,
+                    skippedChangeTraceability,
+                });
+                const reportJsonPath = reportGenerator.writeJson(report, outputPathDir);
+                const reportMdPath = reportGenerator.writeMarkdown(report, outputPathDir);
+                const ledgerPath = reportGenerator.exportLedger(unifiedAssets, outputPathDir);
+                const result = {
+                    reportId: report.reportId,
+                    projectId,
+                    assetCount: unifiedAssets.length,
+                    classifiedCount: unifiedAssets.filter((a) => a.classificationCode).length,
+                    codedCount: unifiedAssets.filter((a) => a.assetCode).length,
+                    unclassifiedCount: classificationResult.unclassified.length,
+                    changeTraceabilityCount: changeTraceabilityReport.length,
+                    overrideCount: overrideList.length,
+                    errorCount: errorList.length,
+                    configLoadStatus: configLoadResult.loadStatus,
+                    reportJsonPath,
+                    reportMdPath,
+                    ledgerPath,
+                    warnings: allWarnings,
+                    policyBasisSummary: report.policyBasisSummary,
+                    legalDisclaimer: report.legalDisclaimer,
+                    timestamp: new Date().toISOString(),
+                };
+                return JSON.stringify(result, null, 2);
+            }
+            catch (e) {
+                return errorResult('UNKNOWN_ERROR', e.message);
+            }
+        },
+    });
+    ctx.tools.register({
+        name: 'submit_review_override',
+        description: '提交人工复核覆盖指令，对自动分类与编码结果进行人工覆盖并记录覆盖理由',
+        parameters: {
+            type: 'object',
+            properties: {
+                assetId: { type: 'string', description: '被覆盖的资产标识' },
+                reviewItem: { type: 'string', enum: ['classification', 'encoding', 'changeTraceability'], description: '复核项' },
+                overrideConclusion: { type: 'string', description: '覆盖后结论（如新分类代码）' },
+                overrideReason: { type: 'string', description: '覆盖理由（不可为空）' },
+                operator: { type: 'string', description: '操作人标识' },
+                inventoryReportPath: { type: 'string', description: '盘点报告路径（用于定位判定结果）' },
+            },
+            required: ['assetId', 'reviewItem', 'overrideConclusion', 'overrideReason', 'operator', 'inventoryReportPath'],
+        },
+        async execute(args) {
+            try {
+                const validation = inputValidator.validateOverrideInput(args);
+                if (!validation.isValid) {
+                    return errorResult('INPUT_INVALID', validation.errors.map((e) => e.errorMessage).join('; '));
+                }
+                const assetId = args.assetId;
+                const reviewItem = args.reviewItem;
+                const overrideConclusion = args.overrideConclusion;
+                const overrideReason = args.overrideReason;
+                const operator = args.operator;
+                const inventoryReportPath = args.inventoryReportPath;
+                if (!existsSync(inventoryReportPath)) {
+                    return errorResult('ASSET_NOT_FOUND', `盘点报告不存在: ${inventoryReportPath}`);
+                }
+                const reportRaw = readFileSync(inventoryReportPath, 'utf-8');
+                const report = JSON.parse(reportRaw);
+                const asset = report.assetList.find((a) => a.assetId === assetId);
+                if (!asset) {
+                    return errorResult('ASSET_NOT_FOUND', `资产标识不存在: ${assetId}`);
+                }
+                if (reviewItem === 'classification') {
+                    const configLoadResult = configLoader.load();
+                    const isValidCode = classificationMapper.isValidClassificationCode(overrideConclusion, configLoadResult.classificationConfig);
+                    if (!isValidCode) {
+                        return errorResult('INVALID_CLASSIFICATION_CODE', `分类代码不在标准体系: ${overrideConclusion}`);
+                    }
+                }
+                const originalConclusion = asset.classificationCode;
+                const originalAssetCode = asset.assetCode;
+                const overrideRecord = overrideRecorder.buildRecord({
+                    assetId,
+                    reviewItem,
+                    originalConclusion,
+                    newConclusion: overrideConclusion,
+                    overrideReason,
+                    operator,
+                    originalAssetCode,
+                });
+                overrideRecorder.record(overrideRecord);
+                let newAssetCode = originalAssetCode;
+                let regenerated = false;
+                if (reviewItem === 'classification') {
+                    asset.classificationCode = overrideConclusion;
+                    asset.judgmentStatus = '人工确认';
+                    const configLoadResult = configLoader.load();
+                    const regenResult = assetCodeGenerator.regenerateForAsset(asset, configLoadResult.encodingRuleConfig);
+                    if (regenResult.assets[0] && regenResult.assets[0].assetCode) {
+                        newAssetCode = regenResult.assets[0].assetCode;
+                        regenerated = true;
+                    }
+                }
+                else {
+                    asset.judgmentStatus = '人工确认';
+                }
+                const result = {
+                    assetId,
+                    reviewItem,
+                    originalConclusion,
+                    newConclusion: overrideConclusion,
+                    originalAssetCode,
+                    newAssetCode,
+                    regenerated,
+                    operator,
+                    overrideTime: overrideRecord.overrideTime,
+                    status: '覆盖成功',
+                };
+                return JSON.stringify(result, null, 2);
+            }
+            catch (e) {
+                return errorResult('UNKNOWN_ERROR', e.message);
+            }
+        },
+    });
+    console.log(`[${PLUGIN_NAME}] 建筑工程数据资产盘点插件已加载`);
+}
+//# sourceMappingURL=index.js.map

package/lib/input-validator.js

@@ -0,0 +1,113 @@
+import { existsSync } from 'node:fs';
+export class InputValidator {
+    validateInspectInput(args) {
+        const errors = [];
+        if (args === null || args === undefined) {
+            errors.push({ assetId: '', errorMessage: '输入参数为空' });
+            return { isValid: false, errors };
+        }
+        const obj = args;
+        if (typeof obj.projectId !== 'string' || obj.projectId.trim() === '') {
+            errors.push({ assetId: '', errorMessage: 'projectId必填且为非空字符串' });
+        }
+        if (typeof obj.sourceConfigPath !== 'string' || obj.sourceConfigPath.trim() === '') {
+            errors.push({ assetId: '', errorMessage: 'sourceConfigPath必填且为非空字符串' });
+        }
+        return { isValid: errors.length === 0, errors };
+    }
+    validateOverrideInput(args) {
+        const errors = [];
+        if (args === null || args === undefined) {
+            errors.push({ assetId: '', errorMessage: '输入参数为空' });
+            return { isValid: false, errors };
+        }
+        const obj = args;
+        const assetId = obj.assetId;
+        if (typeof assetId !== 'string' || assetId.trim() === '') {
+            errors.push({ assetId: '', errorMessage: 'assetId必填且为非空字符串' });
+        }
+        if (typeof obj.reviewItem !== 'string' || obj.reviewItem.trim() === '') {
+            errors.push({ assetId: String(assetId ?? ''), errorMessage: 'reviewItem必填且为非空字符串' });
+        }
+        if (typeof obj.overrideConclusion !== 'string' || obj.overrideConclusion.trim() === '') {
+            errors.push({ assetId: String(assetId ?? ''), errorMessage: 'overrideConclusion必填且为非空字符串' });
+        }
+        if (typeof obj.overrideReason !== 'string' || obj.overrideReason.trim() === '') {
+            errors.push({ assetId: String(assetId ?? ''), errorMessage: 'overrideReason必填且为非空字符串' });
+        }
+        if (typeof obj.operator !== 'string' || obj.operator.trim() === '') {
+            errors.push({ assetId: String(assetId ?? ''), errorMessage: 'operator必填且为非空字符串' });
+        }
+        if (typeof obj.inventoryReportPath !== 'string' || obj.inventoryReportPath.trim() === '') {
+            errors.push({ assetId: String(assetId ?? ''), errorMessage: 'inventoryReportPath必填且为非空字符串' });
+        }
+        return { isValid: errors.length === 0, errors };
+    }
+    validateSources(sourceConfig) {
+        const errors = [];
+        if (!sourceConfig || typeof sourceConfig !== 'object') {
+            errors.push({ assetId: '', errorMessage: '数据源配置为空' });
+            return { isValid: false, errors };
+        }
+        if (typeof sourceConfig.projectId !== 'string' || sourceConfig.projectId.trim() === '') {
+            errors.push({ assetId: '', errorMessage: '数据源配置projectId必填' });
+        }
+        if (!Array.isArray(sourceConfig.sources)) {
+            errors.push({ assetId: '', errorMessage: '数据源配置sources须为数组' });
+            return { isValid: false, errors };
+        }
+        for (const source of sourceConfig.sources) {
+            if (!source || typeof source !== 'object') {
+                errors.push({ assetId: '', errorMessage: '数据源项格式不合法' });
+                continue;
+            }
+            if (typeof source.type !== 'string' || source.type.trim() === '') {
+                errors.push({ assetId: '', errorMessage: '数据源type必填' });
+            }
+            if (typeof source.systemId !== 'string' || source.systemId.trim() === '') {
+                errors.push({ assetId: '', errorMessage: '数据源systemId必填' });
+            }
+            if (typeof source.path !== 'string' || source.path.trim() === '') {
+                errors.push({ assetId: '', errorMessage: '数据源path必填' });
+            }
+        }
+        return { isValid: errors.length === 0, errors };
+    }
+    isSourceAvailable(sourcePath) {
+        return existsSync(sourcePath);
+    }
+    validateChangeRecords(changeRecords) {
+        const valid = [];
+        const invalid = [];
+        if (!Array.isArray(changeRecords)) {
+            invalid.push('变更记录非数组');
+            return { valid, invalid };
+        }
+        for (const record of changeRecords) {
+            if (!record || typeof record !== 'object') {
+                invalid.push('变更记录格式不兼容');
+                continue;
+            }
+            const r = record;
+            if (typeof r.changeId !== 'string' || r.changeId.trim() === '') {
+                invalid.push('变更记录缺少changeId');
+                continue;
+            }
+            valid.push({
+                changeId: r.changeId,
+                relatedAssetId: typeof r.relatedAssetId === 'string' ? r.relatedAssetId : '',
+                changeReason: typeof r.changeReason === 'string' ? r.changeReason : '',
+                approvalChain: r.approvalChain ?? {
+                    initiator: '',
+                    approver: '',
+                    approvalTime: '',
+                    approvalConclusion: '',
+                },
+                impactScope: Array.isArray(r.impactScope) ? r.impactScope : [],
+                changeDate: typeof r.changeDate === 'string' ? r.changeDate : '',
+            });
+        }
+        return { valid, invalid };
+    }
+}
+//# sourceMappingURL=input-validator.js.map

package/lib/invariant.js

@@ -0,0 +1,32 @@
+export const PLUGIN_NAME = '@liuhange/dsh-construction-data-inventory';
+export const DEFAULT_CLASSIFICATION_CONFIG_PATH = 'config/classification-config.json';
+export const DEFAULT_ENCODING_RULE_CONFIG_PATH = 'config/encoding-rule-config.json';
+export const DEFAULT_SOURCE_ADAPTER_CONFIG_PATH = 'config/source-adapter-config.json';
+export const DEFAULT_OVERRIDE_LOG_PATH = 'logs/override-records.log';
+export const LEGAL_DISCLAIMER = '本报告由辅助盘点工具生成，不替代GB/T 51269标准的正式合规认证';
+export const POLICY_STANDARD_NAME = '《建筑信息模型分类和编码标准》（GB/T 51269-2017）';
+export const SUPPORTED_IFC_VERSIONS = ['IFC2X3', 'IFC4'];
+export const IFC_ENTITY_TYPES = [
+    'IFCWALL',
+    'IFCWALLSTANDARDCASE',
+    'IFCCOLUMN',
+    'IFCCOLUMNSTANDARDCASE',
+    'IFCSLAB',
+    'IFCSLABSTANDARDCASE',
+    'IFCDOOR',
+    'IFCWINDOW',
+    'IFCSPACE',
+    'IFCBUILDINGSTOREY',
+    'IFCBUILDING',
+    'IFCSITE',
+    'IFCROOF',
+    'IFCBEAM',
+    'IFCBEAMSTANDARDCASE',
+    'IFCFOOTING',
+    'IFCSTAIR',
+    'IFCSTAIRFLIGHT',
+    'IFCRAILING',
+    'IFCCURTAINWALL',
+    'IFCPROPERTYSET',
+];
+//# sourceMappingURL=invariant.js.map

package/lib/inventory-report-generator.js

@@ -0,0 +1,140 @@
+import { writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { LEGAL_DISCLAIMER } from './invariant.js';
+import { PolicyBasisBuilder } from './policy-basis-builder.js';
+import { ReportDesensitizer } from './report-desensitizer.js';
+import { AssetLedgerExporter } from './asset-ledger-exporter.js';
+export class InventoryReportGenerator {
+    policyBasisBuilder;
+    desensitizer;
+    ledgerExporter;
+    constructor() {
+        this.policyBasisBuilder = new PolicyBasisBuilder();
+        this.desensitizer = new ReportDesensitizer();
+        this.ledgerExporter = new AssetLedgerExporter();
+    }
+    generate(params) {
+        const { assetList, classificationEncodingList, changeTraceabilityReport, overrideList, errorList, configVersions, projectId, } = params;
+        const policyBasisList = [];
+        for (const asset of assetList) {
+            if (asset.policyBasis)
+                policyBasisList.push(asset.policyBasis);
+        }
+        for (const entry of classificationEncodingList) {
+            if (entry.policyBasis)
+                policyBasisList.push(entry.policyBasis);
+        }
+        for (const result of changeTraceabilityReport) {
+            if (result.policyBasis)
+                policyBasisList.push(result.policyBasis);
+        }
+        const policyBasisSummary = this.policyBasisBuilder.buildSummary(policyBasisList);
+        let report = {
+            reportId: randomUUID(),
+            inventoryTime: new Date().toISOString(),
+            projectId,
+            assetList,
+            classificationEncodingList,
+            changeTraceabilityReport,
+            overrideList,
+            errorList,
+            policyBasisSummary,
+            configVersions,
+            legalDisclaimer: LEGAL_DISCLAIMER,
+        };
+        const desensitizeResult = this.desensitizer.desensitize(report);
+        report = desensitizeResult.report;
+        return report;
+    }
+    writeJson(report, outputPathDir) {
+        const fullPath = resolve(outputPathDir, 'inventory-report.json');
+        if (!existsSync(outputPathDir)) {
+            mkdirSync(outputPathDir, { recursive: true });
+        }
+        writeFileSync(fullPath, JSON.stringify(report, null, 2), 'utf-8');
+        return fullPath;
+    }
+    writeMarkdown(report, outputPathDir) {
+        const fullPath = resolve(outputPathDir, 'inventory-report.md');
+        if (!existsSync(outputPathDir)) {
+            mkdirSync(outputPathDir, { recursive: true });
+        }
+        const markdown = this.renderMarkdown(report);
+        writeFileSync(fullPath, markdown, 'utf-8');
+        return fullPath;
+    }
+    exportLedger(assetList, outputPathDir) {
+        return this.ledgerExporter.exportToPath(assetList, outputPathDir);
+    }
+    renderMarkdown(report) {
+        const lines = [];
+        lines.push(`# 建筑工程项目数据资产盘点报告`);
+        lines.push('');
+        lines.push(`> ${report.legalDisclaimer}`);
+        lines.push('');
+        lines.push(`## 报告元信息`);
+        lines.push(`- 报告标识: ${report.reportId}`);
+        lines.push(`- 盘点时间: ${report.inventoryTime}`);
+        lines.push(`- 项目标识: ${report.projectId}`);
+        lines.push(`- 分类配置版本: ${report.configVersions.classificationConfigVersion}`);
+        lines.push(`- 编码规则配置版本: ${report.configVersions.encodingRuleConfigVersion}`);
+        lines.push(`- 适配器配置版本: ${report.configVersions.sourceAdapterConfigVersion}`);
+        lines.push('');
+        lines.push(`## 资产清单 (${report.assetList.length} 项)`);
+        lines.push('| 资产标识 | 数据类型 | 分类代码 | 资产编码 | 判定状态 | 政策依据 |');
+        lines.push('|---------|---------|---------|---------|---------|---------|');
+        for (const asset of report.assetList) {
+            lines.push(`| ${asset.assetId} | ${asset.dataType} | ${asset.classificationCode || '未分类'} | ${asset.assetCode || '未生成'} | ${asset.judgmentStatus} | ${asset.policyBasis || '-'} |`);
+        }
+        lines.push('');
+        lines.push(`## 分类编码清单 (${report.classificationEncodingList.length} 项)`);
+        lines.push('| 资产标识 | 分类代码 | 资产编码 | 判定状态 | 政策依据 |');
+        lines.push('|---------|---------|---------|---------|---------|');
+        for (const entry of report.classificationEncodingList) {
+            lines.push(`| ${entry.assetId} | ${entry.classificationCode} | ${entry.assetCode} | ${entry.judgmentStatus} | ${entry.policyBasis} |`);
+        }
+        lines.push('');
+        lines.push(`## 变更追溯报告 (${report.changeTraceabilityReport.length} 项)`);
+        if (report.changeTraceabilityReport.length === 0) {
+            lines.push('无变更追溯结果');
+        }
+        else {
+            lines.push('| 变更标识 | 关联资产 | 记录完整 | 审批链完整 | 影响范围 | 缺失项 | 政策依据 |');
+            lines.push('|---------|---------|---------|---------|---------|---------|---------|');
+            for (const result of report.changeTraceabilityReport) {
+                lines.push(`| ${result.changeId} | ${result.assetLinked ? '是' : '否'} | ${result.recordComplete ? '是' : '否'} | ${result.approvalChainComplete ? '是' : '否'} | ${result.impactScopeLinked ? '是' : '否'} | ${result.missingItems.join('、') || '-'} | ${result.policyBasis} |`);
+            }
+        }
+        lines.push('');
+        lines.push(`## 人工覆盖记录 (${report.overrideList.length} 项)`);
+        if (report.overrideList.length === 0) {
+            lines.push('无人工覆盖记录');
+        }
+        else {
+            lines.push('| 资产标识 | 复核项 | 原结论 | 新结论 | 覆盖理由 | 操作人 | 操作时间 | 原资产编码 |');
+            lines.push('|---------|---------|---------|---------|---------|---------|---------|---------|');
+            for (const override of report.overrideList) {
+                lines.push(`| ${override.assetId} | ${override.reviewItem} | ${override.originalConclusion} | ${override.newConclusion} | ${override.overrideReason} | ${override.operator} | ${override.overrideTime} | ${override.originalAssetCode} |`);
+            }
+        }
+        lines.push('');
+        lines.push(`## 错误清单 (${report.errorList.length} 项)`);
+        if (report.errorList.length === 0) {
+            lines.push('无错误');
+        }
+        else {
+            for (const error of report.errorList) {
+                lines.push(`- ${error.assetId}: ${error.errorMessage}`);
+            }
+        }
+        lines.push('');
+        lines.push(`## 政策依据汇总`);
+        for (const basis of report.policyBasisSummary) {
+            lines.push(`- ${basis}`);
+        }
+        lines.push('');
+        return lines.join('\n');
+    }
+}
+//# sourceMappingURL=inventory-report-generator.js.map

package/lib/policy-basis-builder.js

@@ -0,0 +1,25 @@
+import { POLICY_STANDARD_NAME } from './invariant.js';
+export class PolicyBasisBuilder {
+    build(clause) {
+        return `依据：${POLICY_STANDARD_NAME}第${clause}章`;
+    }
+    buildClassification() {
+        return `依据：${POLICY_STANDARD_NAME}分类体系`;
+    }
+    buildEncoding() {
+        return `依据：${POLICY_STANDARD_NAME}编码规则`;
+    }
+    buildChangeTraceability() {
+        return `依据：${POLICY_STANDARD_NAME}变更管理要求`;
+    }
+    buildSummary(policyBasisList) {
+        const unique = new Set();
+        for (const basis of policyBasisList) {
+            if (basis && basis.trim() !== '') {
+                unique.add(basis);
+            }
+        }
+        return Array.from(unique).sort();
+    }
+}
+//# sourceMappingURL=policy-basis-builder.js.map

package/lib/progress-record-adapter.js

@@ -0,0 +1,58 @@
+import { readFileSync } from 'node:fs';
+export class ProgressRecordAdapter {
+    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.recordId !== 'string' || record.recordId.trim() === '') {
+                warnings.push('进度记录缺少recordId，已跳过');
+                continue;
+            }
+            const dataType = this.mapProcessTypeToDataType(record.processType ?? '');
+            assets.push({
+                assetId: `PROGRESS-${record.recordId}`,
+                sourceSystemId: systemId,
+                dataType,
+                projectId,
+                collectionTime: record.completionTime || collectionTime,
+                classificationCode: '',
+                assetCode: '',
+                judgmentStatus: '自动判定',
+            });
+        }
+        return { assets, warnings, errors };
+    }
+    mapProcessTypeToDataType(processType) {
+        if (!processType)
+            return '进度记录-行为';
+        if (processType.includes('阶段'))
+            return '进度记录-项目阶段';
+        if (processType.includes('专业'))
+            return '进度记录-专业领域';
+        return '进度记录-行为';
+    }
+}
+//# sourceMappingURL=progress-record-adapter.js.map