ctx_checker 0.1.0

data/lib/ctx_checker/cisco_ios/parsers/show_processes_cpu.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "system_values"
+
+module CtxChecker
+  module CiscoIos
+    module Parsers
+      # IOS 进程 CPU 包含中断工作量，不代表 IOS-XE 的 Linux 整机 CPU。
+      class ShowProcessesCpu < CtxChecker::Parsers::Base
+        include SystemValues
+
+        private
+
+        # 解析 show processes cpu，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          records, issues = [], []
+          recognized = false
+          clean(text).each_line.with_index(1) do |source, number|
+            line = source.strip
+            next if line.empty?
+
+            if (match = /\ACPU utilization for five seconds:\s*([^%]+)%\/([^%]+)%; one minute:\s*([^%]+)%; five minutes:\s*([^%]+)%\z/i.match(line))
+              recognized = true
+              [ [ 5, match[1], match[2] ], [ 60, match[3], nil ], [ 300, match[4], nil ] ].each do |window, value, interrupt|
+                utilization = percentage(value)
+                interrupt_utilization = percentage(interrupt)
+                valid = utilization && (!interrupt || interrupt_utilization && interrupt_utilization <= utilization)
+                issues << { code: :invalid_cpu_value, line: number } unless valid
+                records << { component: "processor", scope: "ios_processes", window_seconds: window,
+                  utilization: utilization, interrupt_utilization: interrupt_utilization }
+              end
+            elsif /\A(?:PID\s+Runtime|\d+\s+\d+\s+\d+\s+\d+\s+[\d.]+%\s+[\d.]+%\s+[\d.]+%\s+\d+\s+)/.match?(line)
+              next
+            else
+              issues << unparsed(number)
+            end
+          end
+          build_result(records, complete: complete, recognized: recognized, issues: issues,
+            identity: %i[component scope window_seconds])
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/cisco_ios/parsers/system_values.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "date"
+
+module CtxChecker
+  module CiscoIos
+    module Parsers
+      # 仅在 Cisco 命令语义一致时共享小型值转换方法。
+      module SystemValues
+        NUMBER = /[+-]?\d+(?:\.\d+)?/
+
+        private
+
+        # 映射组件回显状态，不将缺失解释为健康。
+        def component_status(value)
+          case value.to_s.strip.downcase
+          when "ok", "normal", "good", "green", "on", "powered-up" then :ok
+          when "warning", "minor", "yellow" then :warning
+          when "critical", "major", "red", "shutdown" then :critical
+          when "fail", "failed", "faulty", "bad", "off", "no input power", "non-operational" then :failed
+          when "absent", "not present", "not installed", "notsupported/none" then :absent
+          else :unknown
+          end
+        end
+
+        # 解析支持的数值字段，并拒绝格式错误的测量值。
+        def numeric(token)
+          return unless /\A#{NUMBER}\z/.match?(token.to_s)
+
+          value = Float(token)
+          value if value.finite?
+        end
+
+        # 外部数值无效时降低证据完整性，不使类型化记录构建失败。
+        def checked_number(token, issues:, component:, nonnegative: false)
+          return if %w[N/A --].include?(token.to_s.upcase)
+
+          value = numeric(token)
+          return value if value && (!nonnegative || value >= 0)
+
+          issues << { code: :invalid_numeric_value, component: component }
+          nil
+        end
+
+        # 将利用率归一化为经过校验的百分比。
+        def percentage(token)
+          value = numeric(token)
+          value if value && value.between?(0, 100)
+        end
+
+        # 保留无法解释的回显行诊断。
+        def unparsed(number) = { code: :unparsed_row, line: number }
+
+        # 读数冲突不能抹除已明确观察到的组件故障。
+        def most_severe_status(states)
+          ranks = { ok: 0, absent: 1, unknown: 2, warning: 3, failed: 4, critical: 5 }
+          states.max_by { |state| ranks.fetch(state) }
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/cisco_ios/profile.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "ctx_parser/profile"
+require_relative "parsers/show_interfaces"
+require_relative "parsers/show_etherchannel_summary"
+require_relative "parsers/show_interfaces_transceiver_detail"
+require_relative "parsers/show_ip_bgp_summary"
+require_relative "parsers/show_ip_ospf_neighbor"
+require_relative "parsers/show_processes_cpu"
+require_relative "parsers/show_memory_statistics"
+require_relative "parsers/show_environment_all"
+require_relative "parsers/show_clock_detail"
+require_relative "parsers/show_ntp_status"
+require_relative "parsers/show_facility_alarm_status"
+require_relative "parsers/show_ip_traffic"
+
+module CtxChecker
+  module CiscoIos
+    # IOS 与 IOS-XE 共用命令契约；型号特有语法通过解析器覆盖。
+    class Profile < CtxParser::Profile
+      CATALOG = CtxParser::CommandCatalog.new([
+        { dimensions: %i[interfaces counters], command: "show interfaces", parser: Parsers::ShowInterfaces },
+        { dimensions: [ :aggregation ], command: "show etherchannel summary", parser: Parsers::ShowEtherchannelSummary },
+        { dimensions: [ :optics ], command: "show interfaces transceiver detail", parser: Parsers::ShowInterfacesTransceiverDetail },
+        { dimensions: [ :bgp ], command: "show ip bgp summary", parser: Parsers::ShowIpBgpSummary },
+        { dimensions: [ :ospf ], command: "show ip ospf neighbor", parser: Parsers::ShowIpOspfNeighbor },
+        { dimensions: [ :cpu ], command: "show processes cpu", parser: Parsers::ShowProcessesCpu },
+        { dimensions: [ :memory ], command: "show memory statistics", parser: Parsers::ShowMemoryStatistics },
+        { dimensions: %i[temperature environment power], command: "show environment all", parser: Parsers::ShowEnvironmentAll },
+        { dimensions: [ :clock ], command: "show clock detail", parser: Parsers::ShowClockDetail },
+        { dimensions: [ :ntp ], command: "show ntp status", parser: Parsers::ShowNtpStatus },
+        { dimensions: [ :alarms ], command: "show facility-alarm status", parser: Parsers::ShowFacilityAlarmStatus },
+        { dimensions: [ :device_counters ], command: "show ip traffic", parser: Parsers::ShowIpTraffic }
+      ])
+      COMMANDS = CATALOG.commands
+      PARSERS = CATALOG.parsers
+    end
+  end
+end

data/lib/ctx_checker/cisco_nxos/parsers/show_bgp_ipv4_unicast_summary.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../../cisco_ios/parsers/show_ip_bgp_summary"
+
+module CtxChecker
+  module CiscoNxos
+    module Parsers
+      # NX-OS 在各 VRF、地址族表内独立校验已配置对等体总数。
+      class ShowBgpIpv4UnicastSummary < CiscoIos::Parsers::ShowIpBgpSummary
+        PEER_COUNTS = /\ABGP table version is \d+,\s*(.+?)\s+config peers (\d+),\s*capable peers (\d+)\z/i
+        STATISTICS = [
+          /\ADampening configured, \d+ history paths, \d+ dampened paths\z/i,
+          /\A\d+ received paths for inbound soft reconfiguration\z/i,
+          /\A\d+ identical, \d+ modified, \d+ filtered received paths using \d+ bytes\z/i
+        ].freeze
+
+        private
+
+        # 缺少地址族能力时保留已观察对等体，但不声明会话健康。
+        def peer_state(text)
+          return super unless text.match?(/\A\d+\s+\(No Cap\)\z/i)
+
+          @issues << { code: :peer_capability_unavailable }
+          [ :unknown, nil ]
+        end
+
+        # 配置数量覆盖全部记录；具备能力的对等体数量不等于已建立数量。
+        def parse_statistics(line, section, scope, issues, number)
+          if (match = PEER_COUNTS.match(line))
+            counts = (section[:peer_counts] ||= [])
+            issues << { code: :duplicate_peer_count, line: number } unless counts.empty?
+            counts << { configured: Integer(match[2], 10), capable: Integer(match[3], 10) }
+            if address_family(match[1]) != scope[:afi_safi]
+              issues << { code: :conflicting_address_family, line: number }
+            end
+          elsif line.match?(/\ABGP table version\b.*\b(?:config|capable) peers\b/i)
+            issues << { code: :invalid_peer_count, line: number }
+          else
+            return false
+          end
+          true
+        end
+
+        # 仅当能力计数同样一致时，零数量才能证明空表。
+        def section_empty?(section)
+          super || section[:peer_counts] == [ { configured: 0, capable: 0 } ]
+        end
+
+        # 校验每条总数声明，避免重复或矛盾总数掩盖记录缺失。
+        def validate_section(section, issues)
+          super
+          Array(section[:peer_counts]).each do |counts|
+            unless counts[:configured] == section[:count]
+              issues << { code: :count_mismatch, expected: counts[:configured], observed: section[:count] }
+            end
+            if counts[:capable] > counts[:configured]
+              issues << { code: :invalid_capable_peer_count, expected: counts[:configured], observed: counts[:capable] }
+            end
+          end
+        end
+
+        # 可选路由统计仅接受文档明确的完整格式。
+        def auxiliary?(line)
+          super || STATISTICS.any? { |pattern| pattern.match?(line) }
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/cisco_nxos/parsers/show_clock.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "../../cisco_ios/parsers/show_clock_detail"
+
+module CtxChecker
+  module CiscoNxos
+    module Parsers
+      # NX-OS 使用相同的时钟正文，不含 IOS 的 detail 关键字。
+      class ShowClock < CtxChecker::CiscoIos::Parsers::ShowClockDetail
+      end
+    end
+  end
+end

data/lib/ctx_checker/cisco_nxos/parsers/show_environment.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "../../cisco_ios/parsers/system_values"
+require "ctx_parser/result_set"
+
+module CtxChecker
+  module CiscoNxos
+    module Parsers
+      # 每个环境章节分别产生类型化组件观测。
+      class ShowEnvironment < CtxChecker::Parsers::Base
+        include CtxChecker::CiscoIos::Parsers::SystemValues
+        HEADERS = /\A(?:[- ]+|\(?Watts\s*\)?(?:\s+\(?Watts\s*\)?)*|\(?Celsius\)?(?:\s+\(?Celsius\)?)*|Module\s+Sensor|Clock\s+Model|Fan\s+Model|Power\s+Actual|Supply\s+Model|Actual\s+Power|Module\s+Model|Output\s+Capacity|N\/A - Per module|Voltage:)/i
+        POWER_VALUE = /(?:#{NUMBER}\s*W|N\/A(?:\s*W)?|--)/i
+
+        private
+
+        # 解析 show environment，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          @rows = { temperature: [], environment: [], power: [] }
+          @problems = @rows.transform_values { [] }
+          @section = nil
+          @section_size = 0
+          @power_columns = nil
+          clean(text).each_line.with_index(1) do |source, number|
+            line = source.strip
+            next if line.empty?
+            next if section_line(line) || header_line(line)
+            next if @section == :fan && /\AFan Zone Speed:\s*Zone\s+\d+:/i.match?(line)
+            next if parse_temperature(line) || parse_component(line) || parse_power(line)
+            next if @section == :summary && /\A(?:Power Supply redundancy|Total Power |Total Grid|Cumulative Power)/i.match?(line)
+
+            dimension = { temperature: :temperature, fan: :environment, clock: :environment, power: :power, module: :environment, summary: :power }[@section]
+            (dimension ? [ @problems[dimension] ] : @problems.values).each { |issues| issues << unparsed(number) }
+          end
+          finish_section
+          CtxParser::ResultSet.new(results: @rows.to_h do |dimension, rows|
+            identity = dimension == :temperature ? [ :component ] : %i[component kind]
+            [ dimension, build_result(rows, complete: complete, recognized: rows.any?, issues: @problems[dimension], identity: identity) ]
+          end)
+        end
+
+        # 识别环境章节内的行类型。
+        def section_line(line)
+          section = case line
+          when /\ATemperature:\z/i then :temperature
+          when /\AFan:\z/i then :fan
+          when /\AClock:\z/i then :clock
+          when /\APower Supply:\z/i then :power
+          when /\APower Usage Summary:\z/i then :summary
+          when /\AModule\s+Model.*Status/i then :module
+          else return false
+          end
+          finish_section
+          @section = section
+          @section_size = section_rows.size
+          @power_columns = nil if section == :power
+          true
+        end
+
+        # 行被截断时，不能将已声明的输入列误当作额定容量。
+        def header_line(line)
+          if @section == :power && /\ASupply\s+Model\s+Output\b/i.match?(line)
+            @power_columns = /\bInput\b/i.match?(line) ? 3 : 2
+          end
+          HEADERS.match?(line)
+        end
+
+        # 选择属于当前环境章节的数据行。
+        def section_rows
+          dimension = { temperature: :temperature, fan: :environment, clock: :environment, power: :power, module: :environment }[@section]
+          dimension ? @rows[dimension] : []
+        end
+
+        # 独立完成当前环境章节，不影响其他章节的结果。
+        def finish_section
+          return unless @section && @section != :summary && section_rows.size == @section_size
+
+          dimension = %i[fan clock module].include?(@section) ? :environment : @section
+          @problems[dimension] << { code: :empty_environment_section, scope: @section.to_s }
+        end
+
+        # 归一化温度传感器及其回显阈值。
+        def parse_temperature(line)
+          return false unless @section == :temperature
+
+          match = /\A(\S+)\s+(.+?)\s+(#{NUMBER}|N\/A)\s+(#{NUMBER}|N\/A)\s+(#{NUMBER}|N\/A)\s+(.+)\z/i.match(line)
+          return false unless match
+
+          component = "#{match[1]}/#{match[2]}"
+          high_alarm, high_warning, value = match.captures[2, 3].map do |token|
+            checked_number(token, issues: @problems[:temperature], component: component)
+          end
+          # NX-OS 使用 -127 表示传感器阈值不可用或不适用。
+          high_alarm = nil if high_alarm == -127
+          high_warning = nil if high_warning == -127
+          @rows[:temperature] << { component: component, value: value, low_alarm: nil, low_warning: nil,
+            high_warning: high_warning, high_alarm: high_alarm, high_comparison: :gt, status: component_status(match[6]) }
+          true
+        end
+
+        # 归一化单个环境组件及其运行状态。
+        def parse_component(line)
+          return false unless %i[fan clock].include?(@section)
+
+          if (match = /\AFan Air Filter\s*:\s*(.+)\z/i.match(line))
+            @rows[:environment] << { component: "fan air filter", kind: :unknown,
+              status: match[1].casecmp?("NotSupported") ? :absent : component_status(match[1]) }
+          elsif @section == :fan && (match = /\A(\S+)\s+\S+\s+\S+(?:\s+(?:front-to-back|back-to-front))?\s+(.+)\z/i.match(line))
+            @rows[:environment] << { component: "fan #{match[1]}", kind: :fan, status: component_status(match[2]) }
+          elsif (match = /\A(\S+)\s+.+?\s+(Ok|Normal|Good|Fail|Failed|Faulty|Absent|Not Present|NotSupported\/None)\z/i.match(line))
+            @rows[:environment] << { component: "#{@section} #{match[1]}", kind: @section, status: component_status(match[2]) }
+          else
+            return false
+          end
+          true
+        end
+
+        # 归一化电源测量值及回显状态。
+        def parse_power(line)
+          return false unless %i[power module].include?(@section)
+
+          match = /\A(\S+)\s+\S+\s+(#{POWER_VALUE})\s+(#{POWER_VALUE})(?:\s+(#{POWER_VALUE}))?\s+(.+)\z/i.match(line)
+          return false unless match
+          return false if @section == :module && match[4]
+          return false if @section == :power && @power_columns && @power_columns != (match[4] ? 3 : 2)
+
+          state = component_status(match[5])
+          if @section == :module
+            @rows[:environment] << { component: "module #{match[1]}", kind: :module, status: state }
+          else
+            component = "power supply #{match[1]}"
+            # 部分平台在输出与容量之间插入 Actual Input 列。
+            watts, capacity = [ match[2], match[4] || match[3] ].map do |token|
+              checked_number(token.sub(/W\z/i, "").strip, issues: @problems[:power], component: component, nonnegative: true)
+            end
+            if match[4]
+              checked_number(match[3].sub(/W\z/i, "").strip, issues: @problems[:power], component: component, nonnegative: true)
+            end
+            @rows[:power] << { component: component, kind: :power_supply, status: state,
+              present: state == :absent ? false : nil, watts: watts, capacity_watts: capacity }
+          end
+          true
+        end
+
+        # NX-OS 拼写差异仅在本平台处理；未报告的风扇状态保持未知。
+        def component_status(value)
+          case value.to_s.strip.downcase
+          when "shut" then :critical
+          when "failure", "fail/shutdown", "powered-dn" then :failed
+          else super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/cisco_nxos/parsers/show_interface.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../../cisco_ios/parsers/show_interfaces"
+
+module CtxChecker
+  module CiscoNxos
+    module Parsers
+      # NX-OS 与 IOS 共享标签式计数器，但单独提供管理状态。
+      class ShowInterface < CiscoIos::Parsers::ShowInterfaces
+        PLATFORM = :cisco_nxos
+        HEADER = /\A(\S+) is (administratively down|up|down|reset|deleted)(?:\s*\([^)]*\))?(?:, line protocol is (up|down)(?: \([^)]*\))?)?(?:, autostate (?:enabled|disabled))?\s*\z/i
+        AUXILIARY = /\A(?:\d+ seconds? (?:input|output) rate\b|Auto-mdix is (?:turned )?(?:on|off)\z|Rate mode is \S+\z|EEE \(efficient-ethernet\)\s*:|admin fec state is \S+, oper fec state is \S+\z|L3 Switched:\z|(?:input|ucast): \d+ pkts, \d+ bytes - (?:output|mcast): \d+ pkts, \d+ bytes\z)/i
+        DETAIL_METADATA = /\A(?:\d+ broadcast packets \d+ bytes|\d+ multicast frames \d+ compressed|No members|ucast: \d+ pkts, \d+ bytes)\z/i
+        COUNTERS = CiscoIos::Parsers::ShowInterfaces::COUNTERS.merge(
+          stomped_crc_errors: /(?<!\S)(\d+) Stomped\s+CRC(?=\s|\z)/i,
+          out_carrier_errors: /(?<!\S)(\d+) out_carrier_errors(?=\s|\z)/i).freeze
+        COUNTER_LABELS = CiscoIos::Parsers::ShowInterfaces::COUNTER_LABELS.merge(
+          stomped_crc_errors: /\bStomped\s+CRC\b/i, out_carrier_errors: /\bout_carrier_errors\b/i).freeze
+
+        private
+
+        # NX-OS 的 SVI 头可附带 autostate，不改变协议状态语义。
+        def interface_header(line) = HEADER.match(line)
+        # 声明当前平台支持的接口错误与丢弃计数模式。
+        def counter_patterns = COUNTERS
+        # 将平台计数器标签映射到归一化指标名称。
+        def counter_labels = COUNTER_LABELS
+        # 识别包含接口计数测量值的数据行。
+        def counter_line?(line) = COUNTER_LABELS.values.any? { |pattern| pattern.match?(line) } || super
+
+        # CRC 总数已包含 stomped 帧，该子集应独立保留。
+        def counter_source(line, metric)
+          metric == :crc_errors ? line.gsub(/\bStomped\s+CRC\b/i, "stomped_checksum") : line
+        end
+
+        # NX-OS 在 SVI 运行状态头中报告明确的 shutdown 原因。
+        def interface_record(match)
+          super.tap do |record|
+            record[:admin_status] = :down if match[0].match?(/\A\S+ is down\s*\(Administratively down\)/i)
+          end
+        end
+
+        # 保留物理成员端口回显的聚合归属关系。
+        def interface_detail(record, line)
+          if (match = /\ABelongs to ((?:Po|port-channel)\d+)\z/i.match(line))
+            record[:parent] = normalize_name(match[1])
+          elsif record[:kind] == :aggregate && (match = /\AvPC Status: (Up|Down), vPC number: \d+(?: \[packets forwarded via vPC peer-link\])?\z/i.match(line))
+            return record[:oper_status] == match[1].downcase.to_sym
+          elsif /\Amgmt\d+\z/i.match?(record[:name]) && /\AManagement transceiver: (?:Absent|Present)\z/i.match?(line)
+            (record[:management_metadata] ||= []) << :transceiver
+          elsif /\Amgmt\d+\z/i.match?(record[:name]) && /\AActive connector: (?:RJ45|SFP)\z/i.match?(line)
+            (record[:management_metadata] ||= []) << :connector
+          else
+            return false
+          end
+          true
+        end
+
+        # 部分管理接口表以连接器信息结尾，且仅提供包总数。
+        def complete_counter_coverage(record, counters, issues)
+          metadata = record.delete(:management_metadata)
+          return super unless metadata == %i[transceiver connector] && counters.empty? && issues.empty?
+
+          %i[in_errors out_errors crc_errors].map do |metric|
+            { interface: record[:name], metric: metric, value: nil, discontinuity: nil }
+          end
+        end
+
+        # 仅忽略已识别的描述字段；新出现的状态语法使结果保持部分完整。
+        def auxiliary?(line)
+          return false if line.match?(/\Aadmin state is\b/i)
+
+          AUXILIARY.match?(line) || DETAIL_METADATA.match?(line) || super
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/cisco_nxos/parsers/show_interface_transceiver_details.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "../../parsers/interface_names"
+
+module CtxChecker
+  module CiscoNxos
+    module Parsers
+      # NX-OS DOM 按接口及可选光通道组织测量值。
+      class ShowInterfaceTransceiverDetails < CtxChecker::Parsers::Base
+        POWER = /([+-]?\d+(?:\.\d+)?\s+dBm|(?:N\/A|NA|--)(?:\s+dBm)?)/i
+        MARKERS = { "++" => :high_alarm, "+" => :high_warning, "--" => :low_alarm, "-" => :low_warning }.freeze
+
+        private
+
+        # 保留 DOM 不可用和模块缺失状态，不虚构光功率。
+        def parse_output(text, complete:)
+          text = clean(text)
+          rows, issues, devices = [], [], []
+          current, lane, header, lane_valid = nil, nil, false, true
+          text.each_line.with_index(1) do |source, number|
+            line = source.strip
+            next if line.empty? || line.match?(/\A[-= ]+\z/)
+
+            if line.match?(/\A(?:Eth(?:ernet)?|mgmt)\d[\d\/.]*\z/i)
+              current = { interface: CtxChecker::Parsers::InterfaceNames.normalize(line, platform: :cisco_nxos),
+                applicable: nil, present: nil, dom_supported: nil, lanes: [], presence_states: [], dom_unsupported: false }
+              devices << current
+              lane, header, lane_valid = nil, false, true
+            elsif current && (match = /\Atransceiver is (not )?present\z/i.match(line))
+              current[:present] = match[1].nil?
+              current[:presence_states] << current[:present]
+            elsif current && line.match?(/\Atransceiver is not applicable\z/i)
+              current[:applicable] = false
+              current[:dom_supported] = false
+            elsif current && line.match?(/\ADOM is not supported\z/i)
+              current[:dom_supported] = false
+              current[:dom_unsupported] = true
+            elsif current && (match = /\ALane Number\s*:\s*(\d+)(?:\s+Network Lane)?\z/i.match(line))
+              lane = Integer(match[1], 10)
+              current[:lanes] << lane
+              header, lane_valid = false, true
+            elsif current && line.match?(/\ALane Number\b/i)
+              lane, header, lane_valid = nil, false, false
+              issues << { code: :invalid_optical_lane, line: number, interface: current[:interface] }
+            elsif current && line.match?(/\AMeasurement\s+High\s+Low\s+High\s+Low\z/i)
+              header = true
+            elsif current && (match = /\A(Tx Power|Rx Power)\s+(.+)\z/i.match(line))
+              next unless lane_valid
+
+              row = measurement(match[1], match[2], current, lane)
+              if row
+                rows << row
+                current[:dom_supported] = true
+                issues << { code: :missing_optical_header, line: number } unless header
+              else
+                issues << { code: :unparsed_optical_measurement, line: number }
+              end
+            elsif current && auxiliary?(line)
+              next
+            else
+              issues << { code: :unparsed_row, line: number }
+            end
+          end
+          devices.each { |device| complete_measurements(rows, device, issues) }
+          build_result(rows, complete: complete, recognized: devices.any?, issues: issues, identity: %i[interface lane metric])
+        end
+
+        # 解析支持的传感器测量值及回显单位。
+        def measurement(label, values, device, lane)
+          match = /\A#{POWER}\s*(\+\+|\+|--|-)?\s+#{POWER}\s+#{POWER}\s+#{POWER}\s+#{POWER}\z/i.match(values)
+          return unless match
+
+          current, marker, high_alarm, low_alarm, high_warning, low_warning = match.captures
+          value = decimal(current)
+          base_record(device, lane, label.downcase.start_with?("tx") ? :tx_power : :rx_power).merge(
+            value: value, high_alarm: decimal(high_alarm), low_alarm: decimal(low_alarm),
+            high_warning: decimal(high_warning), low_warning: decimal(low_warning),
+            alarm: marker ? MARKERS.fetch(marker) : (value.nil? ? :unknown : :normal), dom_supported: true)
+        end
+
+        # 即使配对指标解析成功，缺失指标仍须明确保留。
+        def complete_measurements(rows, device, issues)
+          device_rows = rows.select { |row| row[:interface] == device[:interface] }
+          if device[:applicable] == false && (!device[:presence_states].empty? || device[:lanes].any? || device_rows.any?)
+            issues << { code: :contradictory_optical_applicability, interface: device[:interface] }
+            device[:applicable] = nil
+            device_rows.each { |row| row[:applicable] = nil }
+          end
+          if device[:presence_states].uniq.size > 1
+            issues << { code: :contradictory_transceiver_presence, interface: device[:interface] }
+          end
+          if device[:dom_unsupported] && rows.any? { |row| row[:interface] == device[:interface] && !row[:value].nil? }
+            issues << { code: :contradictory_dom_support, interface: device[:interface] }
+          end
+          lanes = device[:lanes].empty? ? [ nil ] : device[:lanes].uniq
+          lanes.each do |lane|
+            %i[tx_power rx_power].each do |metric|
+              next if rows.any? { |row| row.values_at(:interface, :lane, :metric) == [ device[:interface], lane, metric ] }
+
+              rows << base_record(device, lane, metric)
+              unless device[:present] == false || device[:dom_supported] == false
+                issues << { code: :optical_measurement_missing, interface: device[:interface], lane: lane, metric: metric }
+              end
+            end
+          end
+          if device[:present].nil? && device[:applicable] != false
+            issues << { code: :transceiver_presence_unknown, interface: device[:interface] }
+          end
+          if device[:present] == false && rows.any? { |row| row[:interface] == device[:interface] && !row[:value].nil? }
+            issues << { code: :contradictory_transceiver_presence, interface: device[:interface] }
+          end
+        end
+
+        # 构建同一资源各测量值共用的身份字段。
+        def base_record(device, lane, metric)
+          { interface: device[:interface], lane: lane, metric: metric, value: nil, unit: :dbm,
+            low_alarm: nil, low_warning: nil, high_warning: nil, high_alarm: nil, alarm: :unknown,
+            applicable: device[:applicable], present: device[:present], dom_supported: device[:dom_supported] }
+        end
+
+        # 解析有限小数，不将占位符转换为零。
+        def decimal(value)
+          value = value.sub(/\s+dBm\z/i, "")
+          return unless value.match?(/\A[+-]?\d+(?:\.\d+)?\z/)
+
+          parsed = Float(value)
+          return parsed if parsed.finite?
+
+          @issues << { code: :invalid_optical_value }
+          nil
+        end
+
+        # 识别说明性回显，不将其作为数据记录。
+        def auxiliary?(line)
+          line.match?(/\A(?:(?:type|name|part number|revision|serial number|nominal bitrate|cisco [\w ]+|connector type|encoding|host lane count|power class) is\b|Link length supported |(?:SFP|QSFP) Detail Diagnostics Information |Current\s+Alarms\s+Warnings\z|(?:Temperature|Voltage|Current)\s+(?:[+-]?\d|N\/A)|Transmit Fault Count\s*=\s*\d+\z|Note:|\+\+ :|\*\* :|\+ :|\- :|\-\- :)/i)
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/cisco_nxos/parsers/show_ip_ospf_neighbors.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "../../cisco_ios/parsers/show_ip_ospf_neighbor"
+
+module CtxChecker
+  module CiscoNxos
+    module Parsers
+      # NX-OS 复用已校验的 OSPFv2 行，同时保留分进程总数与明确的 VRF 作用域。
+      class ShowIpOspfNeighbors < CiscoIos::Parsers::ShowIpOspfNeighbor
+        PLATFORM = :cisco_nxos
+      end
+    end
+  end
+end