工业制造 AI Agent 告警风暴根因分析与工单闭环实战：破解 SCADA/MES 跨系统告警洪峰、级联拓扑误判与排障延迟难题

/**
 * 工业制造 AI Agent 告警风暴根因分析与工单闭环核心引擎
 * 遵循全中文业务注释规范
 */

/** 工业现场原始告警严重级别 */
export type AlarmSeverity = 'CRITICAL' | 'HIGH' | 'WARNING' | 'INFO';

/** 工业现场原始时序告警事件 */
export interface RawAlarmEvent {
  eventId: string;             // 告警唯一流水号
  timestamp: number;           // 毫秒时间戳
  equipmentId: string;         // 设备与工位资产编号 (例如 "WS-03-PUNCH-PRESS")
  componentType: string;       // 部件类型 (例如 "SERVO_MOTOR", "CYLINDER", "BEARING")
  alarmCode: string;           // PLC 或 SCADA 原始错误码 (例如 "ERR_OVER_TORQUE_402")
  severity: AlarmSeverity;     // 告警严重级别
  metricValue?: number;        // 触发超限时的瞬时实测值
  thresholdValue?: number;     // 设定的安全边界阈值
  message: string;             // 原始文本告警描述
}

/** 产线设备节点定义 */
export interface EquipmentNode {
  id: string;                  // 设备 ID
  name: string;                // 设备中文名称
  workstation: string;         // 所属工位
  upstreamEquipments: string[];// 物理工艺物料/动力直接上游设备列表
}

/** 告警聚合簇定义 */
export interface AlarmCluster {
  clusterId: string;           // 聚合簇唯一编号
  anchorTimestamp: number;     // 触发聚合的首发锚点时间戳
  rawEvents: RawAlarmEvent[];  // 窗口内捕获的降噪后事件集合
  durationMs: number;          // 聚合窗口跨越总毫秒数
}

/** 根因诊断输出结果 */
export interface RootCauseDiagnosis {
  diagnosisId: string;         // 诊断唯一流水号
  primaryRootCause: {
    equipmentId: string;       // 根因源头设备 ID
    componentType: string;     // 根因部件
    alarmCode: string;         // 诱发根本告警码
    confidence: number;        // 根因置信度 (0.00 ~ 1.00)
    reasoningTrace: string[];  // 完整的拓扑因果推导链条
  };
  suppressedSecondaryCount: number; // 被降噪归因的次生告警数量
  recommendedActionSOP: string;     // 匹配的标准化维保处置规程
}

/** MES / CMMS 结构化应急工单契约 */
export interface MaintenanceWorkOrder {
  workOrderId: string;         // 工单流水号
  priority: 'EMERGENCY' | 'HIGH' | 'NORMAL';
  targetEquipment: string;     // 待检修设备工位
  faultSymptom: string;        // 故障现象简述
  rootCauseAnalysis: string;   // 根因分析结论
  actionChecklist: string[];   // 现场维修操作步骤检查清单
  requiredSpareParts: string[];// 建议领用备件型号清单
  generatedAt: string;         // 工单生成 ISO 时间
}

/**
 * 工业告警风暴滑动时序降噪与聚合器
 */
export class AlarmStormAggregator {
  private windowPreMs: number;
  private windowPostMs: number;
  private flappingThreshold: number;
  private recentAlarmHistory: Map = new Map();

  constructor(windowPreMs = 3000, windowPostMs = 12000, flappingThreshold = 5) {
    this.windowPreMs = windowPreMs;
    this.windowPostMs = windowPostMs;
    this.flappingThreshold = flappingThreshold;
  }

  /**
   * 告警抖动过滤：检测点位是否处于高频闪烁状态
   */
  public isFlapping(event: RawAlarmEvent): boolean {
    const key = `${event.equipmentId}:${event.alarmCode}`;
    const now = event.timestamp;
    const history = this.recentAlarmHistory.get(key) || [];

    // 移出 60 秒之前的历史记录
    const validHistory = history.filter(t => now - t <= 60000);
    validHistory.push(now);
    this.recentAlarmHistory.set(key, validHistory);

    // 60秒内跳变超过阈值则判定为抖动抑制
    return validHistory.length > this.flappingThreshold;
  }

  /**
   * 将原始时间序列告警聚类为具备因果窗口的聚合簇
   */
  public aggregateEvents(events: RawAlarmEvent[]): AlarmCluster[] {
    const validEvents = events
      .filter(e => !this.isFlapping(e))
      .sort((a, b) => a.timestamp - b.timestamp);

    if (validEvents.length === 0) return [];

    const clusters: AlarmCluster[] = [];
    let currentClusterEvents: RawAlarmEvent[] = [];
    let clusterAnchor = 0;

    for (const evt of validEvents) {
      if (currentClusterEvents.length === 0) {
        // 以首个严重告警开启新窗口
        clusterAnchor = evt.timestamp;
        currentClusterEvents.push(evt);
      } else {
        // 判断是否仍在当前聚合窗口内 (锚点时间 - 前溯窗口 至 锚点时间 + 后延窗口)
        if (evt.timestamp <= clusterAnchor + this.windowPostMs) {
          currentClusterEvents.push(evt);
        } else {
          // 当前窗口关闭，封装聚类簇
          clusters.push({
            clusterId: `CLUSTER-${clusterAnchor}`,
            anchorTimestamp: clusterAnchor,
            rawEvents: [...currentClusterEvents],
            durationMs: currentClusterEvents[currentClusterEvents.length - 1].timestamp - currentClusterEvents[0].timestamp
          });
          // 开启下一个聚合簇
          clusterAnchor = evt.timestamp;
          currentClusterEvents = [evt];
        }
      }
    }

    if (currentClusterEvents.length > 0) {
      clusters.push({
        clusterId: `CLUSTER-${clusterAnchor}`,
        anchorTimestamp: clusterAnchor,
        rawEvents: currentClusterEvents,
        durationMs: currentClusterEvents[currentClusterEvents.length - 1].timestamp - currentClusterEvents[0].timestamp
      });
    }

    return clusters;
  }
}

/**
 * 结合设备工艺拓扑的工业根因分析（RCA）推理引擎
 */
export class IndustrialRootCauseInferenceEngine {
  private topologyGraph: Map = new Map();

  constructor(equipmentNodes: EquipmentNode[]) {
    for (const node of equipmentNodes) {
      this.topologyGraph.set(node.id, node);
    }
  }

  /**
   * 拓扑可达性校验：判断 nodeA 是否处于 nodeB 的物理上游
   */
  private isUpstream(nodeA: string, nodeB: string, visited = new Set()): boolean {
    if (nodeA === nodeB) return false;
    if (visited.has(nodeB)) return false;
    visited.add(nodeB);

    const target = this.topologyGraph.get(nodeB);
    if (!target) return false;

    if (target.upstreamEquipments.includes(nodeA)) return true;

    for (const parent of target.upstreamEquipments) {
      if (this.isUpstream(nodeA, parent, visited)) return true;
    }
    return false;
  }

  /**
   * 执行拓扑剪枝与贝叶斯加权因果推断
   */
  public diagnose(cluster: AlarmCluster): RootCauseDiagnosis {
    const events = cluster.rawEvents;
    if (events.length === 0) {
      throw new Error("Cannot diagnose empty alarm cluster.");
    }

    // 按设备统计发生告警的最高严重级别与首次出现时间
    const candidateScores = new Map();

    for (const evt of events) {
      if (!candidateScores.has(evt.equipmentId)) {
        candidateScores.set(evt.equipmentId, {
          firstTimestamp: evt.timestamp,
          highestSeverity: evt.severity,
          alarmCode: evt.alarmCode,
          componentType: evt.componentType,
          explainedSecondary: [],
          score: 0
        });
      }
    }

    // 拓扑因果关系消解：上游设备能够解释下游设备的次生衍生停机
    const equipmentIds = Array.from(candidateScores.keys());
    for (const eqA of equipmentIds) {
      for (const eqB of equipmentIds) {
        if (eqA !== eqB && this.isUpstream(eqA, eqB)) {
          // eqA 位于 eqB 上游，eqA 发生的故障可以解释 eqB 的次生报警
          candidateScores.get(eqA)!.explainedSecondary.push(eqB);
        }
      }
    }

    // 计算综合置信度得分
    let bestEquipmentId = equipmentIds[0];
    let highestFinalScore = -1;

    const earliestTime = events[0].timestamp;
    const timeSpread = Math.max(1, events[events.length - 1].timestamp - earliestTime);

    for (const [eqId, item] of candidateScores.entries()) {
      // 1. 时间先后权重 (越早出现得分越高, 占比 30%)
      const timeFactor = 1.0 - ((item.firstTimestamp - earliestTime) / timeSpread);

      // 2. 拓扑支配解释度 (能够解释的下游报警越多得分越高, 占比 50%)
      const topoFactor = equipmentIds.length > 1
        ? item.explainedSecondary.length / (equipmentIds.length - 1)
        : 1.0;

      // 3. 告警严重级别权重 (占比 20%)
      const severityMap: Record = {
        'CRITICAL': 1.0,
        'HIGH': 0.8,
        'WARNING': 0.5,
        'INFO': 0.2
      };
      const severityFactor = severityMap[item.highestSeverity] || 0.5;

      const finalScore = (0.30 * timeFactor) + (0.50 * topoFactor) + (0.20 * severityFactor);
      item.score = finalScore;

      if (finalScore > highestFinalScore) {
        highestFinalScore = finalScore;
        bestEquipmentId = eqId;
      }
    }

    const winner = candidateScores.get(bestEquipmentId)!;
    const reasoning = [
      `源头节点 [${bestEquipmentId}] 位于产线工艺物理上游，首次异常时间戳相对领先 ${winner.firstTimestamp - earliestTime} ms。`,
      `经拓扑有向图遍历，该故障成功解释并支配了下游 ${winner.explainedSecondary.length} 个从属工位设备的级联停机。`,
      `源头告警代码为 [${winner.alarmCode}]（部件: ${winner.componentType}），置信度达到 ${(highestFinalScore * 100).toFixed(1)}%。`
    ];

    return {
      diagnosisId: `DIAG-${Date.now()}`,
      primaryRootCause: {
        equipmentId: bestEquipmentId,
        componentType: winner.componentType,
        alarmCode: winner.alarmCode,
        confidence: Number(highestFinalScore.toFixed(2)),
        reasoningTrace: reasoning
      },
      suppressedSecondaryCount: cluster.rawEvents.length - 1,
      recommendedActionSOP: `SOP-PM-${winner.componentType}-REPAIR: 执行驱动电机断电挂牌联锁，检查减速机油位与联轴器同轴度。`
    };
  }

  /**
   * 将根因分析结果与 RAG 维保知识库结合，生成标准结构化 MES 维修工单
   */
  public generateWorkOrder(diagnosis: RootCauseDiagnosis): MaintenanceWorkOrder {
    const rc = diagnosis.primaryRootCause;
    return {
      workOrderId: `WO-${new Date().toISOString().slice(0, 10).replace(/-/g, '')}-${Math.floor(1000 + Math.random() * 9000)}`,
      priority: rc.confidence > 0.75 ? 'EMERGENCY' : 'HIGH',
      targetEquipment: rc.equipmentId,
      faultSymptom: `产线突发急停风暴（瞬时吸收次生告警 ${diagnosis.suppressedSecondaryCount} 条），诱发工位: ${rc.equipmentId}`,
      rootCauseAnalysis: rc.reasoningTrace.join(' '),
      actionChecklist: [
        '1. 到达现场工位，执行安全生命锁断电联锁挂牌（LOTO）程序',
        `2. 针对 [${rc.componentType}] 进行物理机械卡阻检测与线缆对地绝缘摇表测试`,
        `3. 参考规程: ${diagnosis.recommendedActionSOP}`,
        '4. 更换易损件后进行点动试车（JOG Mode），确认 OPC UA 传感器无振动过载越限'
      ],
      requiredSpareParts: [
        `SP-${rc.componentType}-SEAL-01`,
        `SP-${rc.componentType}-BEARING-SKF-6205`
      ],
      generatedAt: new Date().toISOString()
    };
  }
}