@liuhange/dsh-underground-pipeline-inspector 1.0.0

package/lib/index.js

@@ -0,0 +1,248 @@
+export const name = '@liuhange/dsh-underground-pipeline-inspector';
+export const inject = ['tools'];
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { PipelineConfigLoader } from './pipeline-config-loader.js';
+import { InputValidator } from './input-validator.js';
+import { CoverageChecker } from './coverage-checker.js';
+import { EdgeMatchingChecker } from './edge-matching-checker.js';
+import { TopologyChecker } from './topology-checker.js';
+import { CoordinateChecker } from './coordinate-checker.js';
+import { FlowDirectionChecker } from './flow-direction-checker.js';
+import { AttributePrecisionChecker } from './attribute-precision-checker.js';
+import { SpatialReferenceChecker } from './spatial-reference-checker.js';
+import { QualityElementScorer } from './quality-element-scorer.js';
+import { ErrorClassifier } from './error-classifier.js';
+import { GrossErrorRateCalculator } from './gross-error-rate-calculator.js';
+import { InspectionReportGenerator } from './inspection-report-generator.js';
+import { ReviewOverrideRecorder } from './review-override-recorder.js';
+import { PolicyBasisBuilder } from './policy-basis-builder.js';
+import { ERROR_CODES, LEGAL_DISCLAIMER } from './invariant.js';
+export function apply(ctx) {
+    ctx.tools.register({
+        name: 'inspect_underground_pipeline',
+        description: '对地下管线数据进行质量巡检，输出检测结果、质量元素评分、错误分类统计、粗差率与政策依据',
+        parameters: {
+            type: 'object',
+            properties: {
+                datasetFilePath: { type: 'string', description: '地下管线数据集文件路径（JSON格式，含points/segments/structures）' },
+                outputPathDir: { type: 'string', description: '报告输出目录（默认数据文件所在目录）' },
+            },
+            required: ['datasetFilePath'],
+        },
+        async execute(args) {
+            try {
+                if (!args || typeof args !== 'object') {
+                    return JSON.stringify({ error: ERROR_CODES.INPUT_INVALID, message: '参数不能为空' });
+                }
+                const datasetFilePath = args.datasetFilePath;
+                if (!datasetFilePath || typeof datasetFilePath !== 'string') {
+                    return JSON.stringify({ error: ERROR_CODES.INPUT_INVALID, message: 'datasetFilePath 为必填字段' });
+                }
+                if (!existsSync(datasetFilePath)) {
+                    return JSON.stringify({ error: ERROR_CODES.FILE_NOT_FOUND, message: `文件不存在 - ${datasetFilePath}` });
+                }
+                const datasetFileRaw = readFileSync(datasetFilePath, 'utf-8');
+                let datasetFileData;
+                try {
+                    datasetFileData = JSON.parse(datasetFileRaw);
+                }
+                catch {
+                    return JSON.stringify({ error: ERROR_CODES.CONFIG_INVALID, message: '数据集文件 JSON 解析失败' });
+                }
+                const configLoader = new PipelineConfigLoader();
+                const configLoadResult = configLoader.load();
+                const { inspectionConfig, attributeConfig, qualityElementConfig } = configLoadResult;
+                const inputValidator = new InputValidator();
+                const { dataset, errors: validationErrors } = inputValidator.validateDataset(datasetFileData);
+                if (dataset === null) {
+                    return JSON.stringify({
+                        error: ERROR_CODES.DATASET_EMPTY,
+                        message: '数据集无效，无法执行巡检',
+                        validationErrors,
+                    });
+                }
+                const allCheckResults = [];
+                const allWarnings = [...configLoadResult.warnings];
+                const coverageChecker = new CoverageChecker();
+                const { checkResults: coverageResults } = coverageChecker.check(dataset, inspectionConfig);
+                allCheckResults.push(...coverageResults);
+                const edgeMatchingChecker = new EdgeMatchingChecker();
+                const { checkResults: edgeResults } = edgeMatchingChecker.check(dataset.points, inspectionConfig);
+                allCheckResults.push(...edgeResults);
+                const topologyChecker = new TopologyChecker();
+                const { checkResults: topologyResults } = topologyChecker.check(dataset, inspectionConfig);
+                allCheckResults.push(...topologyResults);
+                const coordinateChecker = new CoordinateChecker();
+                const { checkResults: coordinateResults } = coordinateChecker.check(dataset, inspectionConfig);
+                allCheckResults.push(...coordinateResults);
+                const flowDirectionChecker = new FlowDirectionChecker();
+                const { checkResults: flowResults } = flowDirectionChecker.check(dataset, attributeConfig);
+                allCheckResults.push(...flowResults);
+                const attributePrecisionChecker = new AttributePrecisionChecker();
+                const { checkResults: attributeResults } = attributePrecisionChecker.check(dataset, attributeConfig);
+                allCheckResults.push(...attributeResults);
+                const spatialReferenceChecker = new SpatialReferenceChecker();
+                const { checkResults: spatialResults } = spatialReferenceChecker.check(dataset, inspectionConfig);
+                allCheckResults.push(...spatialResults);
+                const qualityElementScorer = new QualityElementScorer();
+                const { scores: qualityElementScores, totalScore } = qualityElementScorer.score(allCheckResults, qualityElementConfig);
+                const policyBasisBuilder = new PolicyBasisBuilder();
+                const errorClassPolicyBasis = policyBasisBuilder.buildByKey('GBT_24356', '第7.2条');
+                const errorClassifier = new ErrorClassifier();
+                const errorClassStatistics = errorClassifier.classify(allCheckResults, errorClassPolicyBasis);
+                const grossErrorRateCalculator = new GrossErrorRateCalculator();
+                const grossErrorRate = grossErrorRateCalculator.calculate(allCheckResults, dataset.points.length, inspectionConfig);
+                const overrideRecorder = new ReviewOverrideRecorder();
+                const overrideList = overrideRecorder.readAll();
+                const configVersions = {
+                    inspectionConfigVersion: inspectionConfig.version,
+                    attributeConfigVersion: attributeConfig.version,
+                    qualityElementConfigVersion: qualityElementConfig.version,
+                };
+                if (dataset.points.length === 0 && dataset.segments.length === 0) {
+                    allWarnings.push('巡检范围内无管线数据');
+                }
+                const reportGenerator = new InspectionReportGenerator();
+                const report = reportGenerator.generate({
+                    checkResults: allCheckResults,
+                    qualityElementScores,
+                    totalQualityScore: totalScore,
+                    errorClassStatistics,
+                    grossErrorRate,
+                    overrideList,
+                    errorList: validationErrors,
+                    configVersions,
+                    inspectionScope: datasetFilePath,
+                    warnings: allWarnings,
+                });
+                const outputPathDir = args.outputPathDir ?? dirname(datasetFilePath);
+                const jsonPath = resolve(outputPathDir, 'inspection-report.json');
+                const markdownPath = resolve(outputPathDir, 'inspection-report.md');
+                reportGenerator.writeJson(report, jsonPath);
+                reportGenerator.writeMarkdown(report, markdownPath);
+                const result = {
+                    reportId: report.reportId,
+                    inspectionTime: report.inspectionTime,
+                    summary: {
+                        totalPoints: dataset.points.length,
+                        totalSegments: dataset.segments.length,
+                        totalStructures: dataset.structures.length,
+                        totalCheckResults: allCheckResults.length,
+                        classAErrors: errorClassStatistics.classACount,
+                        classBErrors: errorClassStatistics.classBCount,
+                        classCErrors: errorClassStatistics.classCCount,
+                        classDErrors: errorClassStatistics.classDCount,
+                        totalQualityScore: totalScore,
+                        grossErrorRate: grossErrorRate.rate,
+                        grossErrorRatePassed: grossErrorRate.passed,
+                        overrideCount: overrideList.length,
+                        validationErrorCount: validationErrors.length,
+                    },
+                    configVersions,
+                    legalDisclaimer: LEGAL_DISCLAIMER,
+                    reportPaths: { json: jsonPath, markdown: markdownPath },
+                };
+                return JSON.stringify(result, null, 2);
+            }
+            catch (e) {
+                return JSON.stringify({ error: ERROR_CODES.UNKNOWN_ERROR, message: e.message });
+            }
+        },
+    });
+    ctx.tools.register({
+        name: 'submit_review_override',
+        description: '提交人工复核覆盖指令，对自动判定结果进行人工覆盖并记录覆盖理由',
+        parameters: {
+            type: 'object',
+            properties: {
+                objectId: { type: 'string', description: '被覆盖的对象标识' },
+                overrideConclusion: { type: 'string', description: '覆盖后结论（合格/不合格/误判/需复检）' },
+                overrideReason: { type: 'string', description: '覆盖理由（不可为空）' },
+                operator: { type: 'string', description: '操作人标识' },
+                inspectionReportPath: { type: 'string', description: '巡检报告路径（用于定位判定结果）' },
+            },
+            required: ['objectId', 'overrideConclusion', 'overrideReason', 'operator', 'inspectionReportPath'],
+        },
+        async execute(args) {
+            try {
+                if (!args || typeof args !== 'object') {
+                    return JSON.stringify({ error: ERROR_CODES.INPUT_INVALID, message: '参数不能为空' });
+                }
+                const objectId = args.objectId;
+                const overrideConclusion = args.overrideConclusion;
+                const overrideReason = args.overrideReason;
+                const operator = args.operator;
+                const inspectionReportPath = args.inspectionReportPath;
+                if (!objectId || typeof objectId !== 'string') {
+                    return JSON.stringify({ error: ERROR_CODES.INPUT_INVALID, message: 'objectId 为必填字段' });
+                }
+                if (!overrideConclusion || typeof overrideConclusion !== 'string') {
+                    return JSON.stringify({ error: ERROR_CODES.INPUT_INVALID, message: 'overrideConclusion 为必填字段' });
+                }
+                if (!overrideReason || typeof overrideReason !== 'string') {
+                    return JSON.stringify({ error: ERROR_CODES.REASON_REQUIRED, message: '覆盖理由不可为空' });
+                }
+                if (!operator || typeof operator !== 'string') {
+                    return JSON.stringify({ error: ERROR_CODES.INPUT_INVALID, message: 'operator 为必填字段' });
+                }
+                if (!inspectionReportPath || typeof inspectionReportPath !== 'string') {
+                    return JSON.stringify({ error: ERROR_CODES.INPUT_INVALID, message: 'inspectionReportPath 为必填字段' });
+                }
+                if (!existsSync(inspectionReportPath)) {
+                    return JSON.stringify({ error: ERROR_CODES.FILE_NOT_FOUND, message: `巡检报告文件不存在 - ${inspectionReportPath}` });
+                }
+                const reportRaw = readFileSync(inspectionReportPath, 'utf-8');
+                let reportData;
+                try {
+                    reportData = JSON.parse(reportRaw);
+                }
+                catch {
+                    return JSON.stringify({ error: ERROR_CODES.CONFIG_INVALID, message: '巡检报告文件 JSON 解析失败' });
+                }
+                const existingObjectIds = new Set();
+                for (const item of reportData.checkResults) {
+                    existingObjectIds.add(item.objectId);
+                }
+                const overrideRecorder = new ReviewOverrideRecorder();
+                const validation = overrideRecorder.validateOverrideInstruction(objectId, overrideConclusion, overrideReason, existingObjectIds);
+                if (!validation.valid) {
+                    return JSON.stringify({ error: validation.error, message: validation.message });
+                }
+                const originalConclusion = findOriginalConclusion(reportData, objectId);
+                const overrideRecord = {
+                    objectId,
+                    originalConclusion,
+                    newConclusion: overrideConclusion,
+                    overrideReason,
+                    operator,
+                    overrideTime: new Date().toISOString(),
+                };
+                overrideRecorder.record(overrideRecord);
+                const result = {
+                    success: true,
+                    objectId,
+                    originalConclusion,
+                    newConclusion: overrideConclusion,
+                    overrideReason,
+                    operator,
+                    overrideTime: overrideRecord.overrideTime,
+                    message: '人工复核覆盖已记录',
+                };
+                return JSON.stringify(result, null, 2);
+            }
+            catch (e) {
+                return JSON.stringify({ error: ERROR_CODES.UNKNOWN_ERROR, message: e.message });
+            }
+        },
+    });
+}
+function findOriginalConclusion(report, objectId) {
+    for (const item of report.checkResults) {
+        if (item.objectId === objectId) {
+            return `${item.errorClass}类错误`;
+        }
+    }
+    return '未知';
+}
+//# sourceMappingURL=index.js.map

package/lib/input-validator.js

@@ -0,0 +1,245 @@
+const POINT_REQUIRED_FIELDS = ['pointId', 'pointType', 'x', 'y', 'elevation'];
+const SEGMENT_REQUIRED_FIELDS = [
+    'segmentId',
+    'startPointId',
+    'endPointId',
+    'diameter',
+    'material',
+    'buryMethod',
+];
+const STRUCTURE_REQUIRED_FIELDS = ['structureId', 'structureType'];
+export class InputValidator {
+    validatePoint(raw) {
+        if (raw === null || raw === undefined || typeof raw !== 'object' || Array.isArray(raw)) {
+            return {
+                point: null,
+                error: {
+                    objectId: 'unknown',
+                    missingFields: [...POINT_REQUIRED_FIELDS],
+                    errorMessage: '管线点数据不是有效对象',
+                },
+            };
+        }
+        const obj = raw;
+        const missingFields = [];
+        const errors = [];
+        for (const field of POINT_REQUIRED_FIELDS) {
+            const value = obj[field];
+            if (value === null || value === undefined || value === '') {
+                missingFields.push(field);
+            }
+        }
+        if (typeof obj.pointId === 'string' && obj.pointId !== '') {
+            if (typeof obj.x !== 'number' || Number.isNaN(obj.x)) {
+                errors.push('x 必须为数值');
+                if (!missingFields.includes('x'))
+                    missingFields.push('x');
+            }
+            if (typeof obj.y !== 'number' || Number.isNaN(obj.y)) {
+                errors.push('y 必须为数值');
+                if (!missingFields.includes('y'))
+                    missingFields.push('y');
+            }
+            if (typeof obj.elevation !== 'number' || Number.isNaN(obj.elevation)) {
+                errors.push('elevation 必须为数值');
+                if (!missingFields.includes('elevation'))
+                    missingFields.push('elevation');
+            }
+        }
+        if (missingFields.length > 0 || errors.length > 0) {
+            return {
+                point: null,
+                error: {
+                    objectId: typeof obj.pointId === 'string' && obj.pointId !== '' ? obj.pointId : 'unknown',
+                    missingFields,
+                    errorMessage: errors.length > 0 ? errors.join('; ') : '必填字段缺失',
+                },
+            };
+        }
+        const point = {
+            pointId: obj.pointId,
+            pointType: obj.pointType,
+            x: obj.x,
+            y: obj.y,
+            elevation: obj.elevation,
+        };
+        if (typeof obj.srid === 'string' && obj.srid !== '') {
+            point.srid = obj.srid;
+        }
+        if (typeof obj.verticalDatum === 'string' && obj.verticalDatum !== '') {
+            point.verticalDatum = obj.verticalDatum;
+        }
+        return { point, error: null };
+    }
+    validateSegment(raw) {
+        if (raw === null || raw === undefined || typeof raw !== 'object' || Array.isArray(raw)) {
+            return {
+                segment: null,
+                error: {
+                    objectId: 'unknown',
+                    missingFields: [...SEGMENT_REQUIRED_FIELDS],
+                    errorMessage: '管段数据不是有效对象',
+                },
+            };
+        }
+        const obj = raw;
+        const missingFields = [];
+        const errors = [];
+        for (const field of SEGMENT_REQUIRED_FIELDS) {
+            const value = obj[field];
+            if (value === null || value === undefined || value === '') {
+                missingFields.push(field);
+            }
+        }
+        if (typeof obj.segmentId === 'string' && obj.segmentId !== '') {
+            if (typeof obj.diameter !== 'number' || Number.isNaN(obj.diameter)) {
+                errors.push('diameter 必须为数值');
+                if (!missingFields.includes('diameter'))
+                    missingFields.push('diameter');
+            }
+        }
+        if (missingFields.length > 0 || errors.length > 0) {
+            return {
+                segment: null,
+                error: {
+                    objectId: typeof obj.segmentId === 'string' && obj.segmentId !== '' ? obj.segmentId : 'unknown',
+                    missingFields,
+                    errorMessage: errors.length > 0 ? errors.join('; ') : '必填字段缺失',
+                },
+            };
+        }
+        const segment = {
+            segmentId: obj.segmentId,
+            startPointId: obj.startPointId,
+            endPointId: obj.endPointId,
+            diameter: obj.diameter,
+            material: obj.material,
+            buryMethod: obj.buryMethod,
+        };
+        if (typeof obj.flowDirection === 'string' && obj.flowDirection !== '') {
+            segment.flowDirection = obj.flowDirection;
+        }
+        return { segment, error: null };
+    }
+    validateStructure(raw) {
+        if (raw === null || raw === undefined || typeof raw !== 'object' || Array.isArray(raw)) {
+            return {
+                structure: null,
+                error: {
+                    objectId: 'unknown',
+                    missingFields: [...STRUCTURE_REQUIRED_FIELDS],
+                    errorMessage: '构筑物数据不是有效对象',
+                },
+            };
+        }
+        const obj = raw;
+        const missingFields = [];
+        for (const field of STRUCTURE_REQUIRED_FIELDS) {
+            const value = obj[field];
+            if (value === null || value === undefined || value === '') {
+                missingFields.push(field);
+            }
+        }
+        if (missingFields.length > 0) {
+            return {
+                structure: null,
+                error: {
+                    objectId: typeof obj.structureId === 'string' && obj.structureId !== ''
+                        ? obj.structureId
+                        : 'unknown',
+                    missingFields,
+                    errorMessage: '必填字段缺失',
+                },
+            };
+        }
+        const structure = {
+            structureId: obj.structureId,
+            structureType: obj.structureType,
+        };
+        if (typeof obj.x === 'number' && !Number.isNaN(obj.x)) {
+            structure.x = obj.x;
+        }
+        if (typeof obj.y === 'number' && !Number.isNaN(obj.y)) {
+            structure.y = obj.y;
+        }
+        if (typeof obj.elevation === 'number' && !Number.isNaN(obj.elevation)) {
+            structure.elevation = obj.elevation;
+        }
+        return { structure, error: null };
+    }
+    validateDataset(raw) {
+        const errors = [];
+        if (raw === null || raw === undefined || typeof raw !== 'object' || Array.isArray(raw)) {
+            errors.push({
+                objectId: 'dataset',
+                missingFields: ['points', 'segments', 'structures'],
+                errorMessage: '数据集不是有效对象',
+            });
+            return { dataset: null, errors };
+        }
+        const obj = raw;
+        const points = [];
+        const segments = [];
+        const structures = [];
+        if (Array.isArray(obj.points)) {
+            for (const rawPoint of obj.points) {
+                const { point, error } = this.validatePoint(rawPoint);
+                if (point !== null) {
+                    points.push(point);
+                }
+                else if (error !== null) {
+                    errors.push(error);
+                }
+            }
+        }
+        else {
+            errors.push({
+                objectId: 'dataset',
+                missingFields: ['points'],
+                errorMessage: '数据集缺少 points 数组',
+            });
+        }
+        if (Array.isArray(obj.segments)) {
+            for (const rawSegment of obj.segments) {
+                const { segment, error } = this.validateSegment(rawSegment);
+                if (segment !== null) {
+                    segments.push(segment);
+                }
+                else if (error !== null) {
+                    errors.push(error);
+                }
+            }
+        }
+        else {
+            errors.push({
+                objectId: 'dataset',
+                missingFields: ['segments'],
+                errorMessage: '数据集缺少 segments 数组',
+            });
+        }
+        if (Array.isArray(obj.structures)) {
+            for (const rawStructure of obj.structures) {
+                const { structure, error } = this.validateStructure(rawStructure);
+                if (structure !== null) {
+                    structures.push(structure);
+                }
+                else if (error !== null) {
+                    errors.push(error);
+                }
+            }
+        }
+        else {
+            errors.push({
+                objectId: 'dataset',
+                missingFields: ['structures'],
+                errorMessage: '数据集缺少 structures 数组',
+            });
+        }
+        const dataset = { points, segments, structures };
+        if (Array.isArray(obj.workspaceLayers)) {
+            dataset.workspaceLayers = obj.workspaceLayers;
+        }
+        return { dataset, errors };
+    }
+}
+//# sourceMappingURL=input-validator.js.map

package/lib/inspection-report-generator.js

@@ -0,0 +1,170 @@
+import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { PolicyBasisBuilder } from './policy-basis-builder.js';
+import { LEGAL_DISCLAIMER, INSPECTION_RATIO_STATEMENT } from './invariant.js';
+export class InspectionReportGenerator {
+    policyBasisBuilder;
+    constructor() {
+        this.policyBasisBuilder = new PolicyBasisBuilder();
+    }
+    generate(params) {
+        const { checkResults, qualityElementScores, errorClassStatistics, grossErrorRate, overrideList, errorList, configVersions, inspectionScope, warnings, } = params;
+        const allPolicyBasis = [];
+        for (const result of checkResults) {
+            allPolicyBasis.push(result.policyBasis);
+        }
+        for (const score of qualityElementScores) {
+            allPolicyBasis.push(score.policyBasis);
+        }
+        allPolicyBasis.push(errorClassStatistics.policyBasis);
+        allPolicyBasis.push(grossErrorRate.policyBasis);
+        const policyBasisSummary = this.policyBasisBuilder.buildSummary(allPolicyBasis);
+        const report = {
+            reportId: this.generateReportId(),
+            inspectionTime: new Date().toISOString(),
+            inspectionScope,
+            inspectionRatioStatement: INSPECTION_RATIO_STATEMENT,
+            checkResults,
+            qualityElementScores,
+            errorClassStatistics,
+            grossErrorRate,
+            overrideList,
+            errorList,
+            policyBasisSummary,
+            configVersions,
+            legalDisclaimer: LEGAL_DISCLAIMER,
+            warnings,
+        };
+        return report;
+    }
+    writeJson(report, outputPath) {
+        const dir = dirname(outputPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(outputPath, JSON.stringify(report, null, 2), 'utf-8');
+    }
+    writeMarkdown(report, outputPath) {
+        const dir = dirname(outputPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        const markdown = this.renderMarkdown(report);
+        writeFileSync(outputPath, markdown, 'utf-8');
+    }
+    generateReportId() {
+        const timestamp = Date.now();
+        const random = Math.floor(Math.random() * 10000);
+        return `RPT-${timestamp}-${random}`;
+    }
+    renderMarkdown(report) {
+        const lines = [];
+        lines.push('# 地下管线数据质量巡检报告');
+        lines.push('');
+        lines.push(`> ${report.legalDisclaimer}`);
+        lines.push('');
+        lines.push('## 巡检元数据');
+        lines.push('');
+        lines.push(`- 报告标识: ${report.reportId}`);
+        lines.push(`- 巡检时间: ${report.inspectionTime}`);
+        lines.push(`- 巡检范围: ${report.inspectionScope}`);
+        lines.push(`- 检测比例: ${report.inspectionRatioStatement}`);
+        lines.push(`- 巡检配置版本: ${report.configVersions.inspectionConfigVersion}`);
+        lines.push(`- 属性配置版本: ${report.configVersions.attributeConfigVersion}`);
+        lines.push(`- 质量元素配置版本: ${report.configVersions.qualityElementConfigVersion}`);
+        lines.push('');
+        lines.push('## 检测结果清单');
+        lines.push('');
+        if (report.checkResults.length === 0) {
+            lines.push('（无检测结果）');
+        }
+        else {
+            lines.push('| 检查项 | 错误类别 | 对象标识 | 描述 | 政策依据 |');
+            lines.push('|---|---|---|---|---|');
+            for (const result of report.checkResults) {
+                lines.push(`| ${result.checkName} | ${result.errorClass} | ${result.objectId} | ${result.description} | ${result.policyBasis} |`);
+            }
+        }
+        lines.push('');
+        lines.push('## 质量元素评分');
+        lines.push('');
+        if (report.qualityElementScores.length === 0) {
+            lines.push('（无质量元素评分）');
+        }
+        else {
+            lines.push('| 质量元素 | 权重 | 得分 | 政策依据 |');
+            lines.push('|---|---|---|---|');
+            for (const score of report.qualityElementScores) {
+                lines.push(`| ${score.elementName} | ${score.weight} | ${score.score} | ${score.policyBasis} |`);
+            }
+        }
+        lines.push('');
+        lines.push('## 错误分类统计');
+        lines.push('');
+        const stats = report.errorClassStatistics;
+        lines.push(`- A类错误: ${stats.classACount}`);
+        lines.push(`- B类错误: ${stats.classBCount}`);
+        lines.push(`- C类错误: ${stats.classCCount}`);
+        lines.push(`- D类错误: ${stats.classDCount}`);
+        lines.push(`- 总计: ${stats.totalCount}`);
+        lines.push(`- 政策依据: ${stats.policyBasis}`);
+        lines.push('');
+        lines.push('## 管线点粗差率');
+        lines.push('');
+        const ger = report.grossErrorRate;
+        lines.push(`- 管线点总数: ${ger.totalPoints}`);
+        lines.push(`- 粗差点数: ${ger.grossErrorPoints}`);
+        lines.push(`- 粗差率: ${(ger.rate * 100).toFixed(2)}%`);
+        lines.push(`- 阈值: ${(ger.threshold * 100).toFixed(2)}%`);
+        lines.push(`- 结论: ${ger.passed ? '合格' : '不合格'}`);
+        lines.push(`- 政策依据: ${ger.policyBasis}`);
+        lines.push('');
+        lines.push('## 人工覆盖记录清单');
+        lines.push('');
+        if (report.overrideList.length === 0) {
+            lines.push('（无人工覆盖记录）');
+        }
+        else {
+            lines.push('| 对象标识 | 原结论 | 新结论 | 覆盖理由 | 操作人 | 操作时间 |');
+            lines.push('|---|---|---|---|---|---|');
+            for (const item of report.overrideList) {
+                lines.push(`| ${item.objectId} | ${item.originalConclusion} | ${item.newConclusion} | ${item.overrideReason} | ${item.operator} | ${item.overrideTime} |`);
+            }
+        }
+        lines.push('');
+        lines.push('## 数据校验错误清单');
+        lines.push('');
+        if (report.errorList.length === 0) {
+            lines.push('（无校验错误）');
+        }
+        else {
+            lines.push('| 对象标识 | 缺失字段 | 错误信息 |');
+            lines.push('|---|---|---|');
+            for (const item of report.errorList) {
+                lines.push(`| ${item.objectId} | ${item.missingFields.join(', ')} | ${item.errorMessage} |`);
+            }
+        }
+        lines.push('');
+        lines.push('## 政策依据汇总');
+        lines.push('');
+        if (report.policyBasisSummary.length === 0) {
+            lines.push('（无政策依据）');
+        }
+        else {
+            for (const basis of report.policyBasisSummary) {
+                lines.push(`- ${basis}`);
+            }
+        }
+        lines.push('');
+        if (report.warnings.length > 0) {
+            lines.push('## 警告信息');
+            lines.push('');
+            for (const warning of report.warnings) {
+                lines.push(`- ${warning}`);
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+}
+//# sourceMappingURL=inspection-report-generator.js.map