@cloudcare/guance-front-tools 1.0.12 → 1.0.13

package/skills/grafana-to-guance-dashboard/scripts/convert-grafana-dashboard.mjs

@@ -0,0 +1,1899 @@
+#!/usr/bin/env node
+
+import fs from 'fs'
+import path from 'path'
+import { pathToFileURL } from 'url'
+import Ajv from 'ajv'
+
+const PANEL_TYPE_MAP = {
+  stat: 'singlestat',
+  singlestat: 'singlestat',
+  timeseries: 'sequence',
+  graph: 'sequence',
+  trend: 'sequence',
+  bargauge: 'toplist',
+  gauge: 'gauge',
+  barchart: 'bar',
+  piechart: 'pie',
+  table: 'table',
+  text: 'text',
+  heatmap: 'heatmap',
+  histogram: 'histogram',
+  treemap: 'treemap',
+  geomap: 'worldmap',
+  logs: 'log',
+}
+
+const GRAFANA_BUILTIN_VARS = new Set([
+  '__interval',
+  '__interval_ms',
+  '__range',
+  '__range_s',
+  '__range_ms',
+  '__from',
+  '__to',
+  '__dashboard',
+  '__name',
+  '__org',
+  '__user',
+])
+
+const PROMQL_RESERVED_WORDS = new Set([
+  'and',
+  'or',
+  'unless',
+  'by',
+  'without',
+  'on',
+  'ignoring',
+  'group_left',
+  'group_right',
+  'bool',
+  'offset',
+])
+
+const UNIT_MAP = {
+  percent: ['percent', 'percent'],
+  bytes: ['digital', 'B'],
+  decbytes: ['digital', 'B'],
+  bits: ['digital', 'b'],
+  deckbytes: ['digital', 'KB'],
+  decgbytes: ['digital', 'GB'],
+  ms: ['time', 'ms'],
+  s: ['time', 's'],
+  m: ['time', 'min'],
+  h: ['time', 'h'],
+  d: ['time', 'd'],
+  short: ['custom', 'short'],
+  none: ['custom', 'none'],
+  reqps: ['custom', 'reqps'],
+  ops: ['custom', 'ops'],
+}
+
+const COMPARE_OPTIONS = {
+  hourCompare: { label: '小时同比', value: 'hourCompare' },
+  dayCompare: { label: '日同比', value: 'dayCompare' },
+  weekCompare: { label: '周同比', value: 'weekCompare' },
+  monthCompare: { label: '月同比', value: 'monthCompare' },
+  circleCompare: { label: '环比', value: 'circleCompare' },
+}
+
+if (isDirectExecution()) {
+  main()
+}
+
+function isDirectExecution() {
+  if (!process.argv[1]) return false
+  return import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href
+}
+
+function main() {
+  const { inputPath, outputPath, validateOutput, schemaId, guancePromqlCompatible, keepGrafanaMeta } = parseArgs(process.argv.slice(2))
+  const grafanaDashboard = readJson(inputPath)
+  const guanceDashboard = convertDashboard(grafanaDashboard, { guancePromqlCompatible, keepGrafanaMeta })
+
+  fs.mkdirSync(path.dirname(outputPath), { recursive: true })
+  fs.writeFileSync(outputPath, `${JSON.stringify(guanceDashboard, null, 2)}\n`, 'utf8')
+  console.log(`Converted ${inputPath} -> ${outputPath}`)
+
+  if (validateOutput) {
+    validateDashboardFile(outputPath, schemaId)
+  }
+}
+
+function parseArgs(args) {
+  let inputPath = ''
+  let outputPath = ''
+  let validateOutput = false
+  let schemaId = 'dashboard-schema.json'
+  let guancePromqlCompatible = false
+  let keepGrafanaMeta = false
+
+  for (let index = 0; index < args.length; index++) {
+    const value = args[index]
+    if ((value === '-i' || value === '--input') && args[index + 1]) {
+      inputPath = path.resolve(args[++index])
+      continue
+    }
+    if ((value === '-o' || value === '--output') && args[index + 1]) {
+      outputPath = path.resolve(args[++index])
+      continue
+    }
+    if (value === '--validate') {
+      validateOutput = true
+      continue
+    }
+    if (value === '--schema' && args[index + 1]) {
+      schemaId = args[++index]
+      continue
+    }
+    if (value === '--guance-promql-compatible') {
+      guancePromqlCompatible = true
+      continue
+    }
+    if (value === '--keep-grafana-meta') {
+      keepGrafanaMeta = true
+      continue
+    }
+    if (value === '-h' || value === '--help') {
+      printHelp()
+      process.exit(0)
+    }
+  }
+
+  if (!inputPath) {
+    printHelp()
+    process.exit(1)
+  }
+
+  if (!outputPath) {
+    const parsed = path.parse(inputPath)
+    outputPath = path.join(parsed.dir, `${parsed.name}.guance.json`)
+  }
+
+  return { inputPath, outputPath, validateOutput, schemaId, guancePromqlCompatible, keepGrafanaMeta }
+}
+
+function printHelp() {
+  console.error(
+    'Usage: node convert-grafana-dashboard.mjs --input <grafana.json> [--output <guance.json>] [--validate] [--schema <schema-id>] [--guance-promql-compatible] [--keep-grafana-meta]'
+  )
+}
+
+export function validateDashboardFile(filePath, schemaId) {
+  const projectRoot = findProjectRoot()
+  const schemasDirectory = path.join(projectRoot, 'schemas')
+  const ajv = new Ajv({ allErrors: true })
+
+  forEachFile(schemasDirectory, (schemaPath) => {
+    if (!schemaPath.endsWith('.json')) return
+    ajv.addSchema(readJson(schemaPath))
+  })
+
+  const valid = ajv.validate(schemaId, readJson(filePath))
+  if (valid) {
+    console.log(`Validated ${filePath} against ${schemaId}`)
+    return
+  }
+
+  console.error(`Validation failed for ${filePath} against ${schemaId}:`)
+  for (const error of ajv.errors || []) {
+    const instancePath = error.instancePath || '/'
+    console.error(`- ${instancePath} ${error.message}`)
+  }
+  process.exit(1)
+}
+
+function findProjectRoot() {
+  let currentDirectory = process.cwd()
+
+  while (true) {
+    if (fs.existsSync(path.join(currentDirectory, 'schemas', 'dashboard-schema.json'))) {
+      return currentDirectory
+    }
+
+    const parentDirectory = path.dirname(currentDirectory)
+    if (parentDirectory === currentDirectory) {
+      throw new Error('Could not locate project root containing schemas/dashboard-schema.json')
+    }
+    currentDirectory = parentDirectory
+  }
+}
+
+export function convertDashboard(grafanaDashboard, options = {}) {
+  const variableNames = new Set((grafanaDashboard.templating?.list || []).map((item) => item?.name).filter(Boolean))
+  const state = {
+    groups: [],
+    groupUnfoldStatus: {},
+    charts: [],
+  }
+
+  const sortedPanels = sortPanels(grafanaDashboard.panels || [])
+  collectPanels(sortedPanels, state, null, variableNames, options)
+
+  return pruneEmpty({
+    title: grafanaDashboard.title || '',
+    description: grafanaDashboard.description || undefined,
+    tags: grafanaDashboard.tags || undefined,
+    uid: grafanaDashboard.uid || undefined,
+    dashboardExtend: {
+      groupUnfoldStatus: state.groupUnfoldStatus,
+    },
+    main: {
+      vars: convertVariables(grafanaDashboard.templating?.list || [], variableNames),
+      charts: state.charts,
+      groups: state.groups,
+      type: 'template',
+    },
+  })
+}
+
+function collectPanels(panels, state, inheritedGroup = null, variableNames = new Set(), options = {}) {
+  let activeRow = inheritedGroup
+  let openRowPanel = null
+
+  for (const panel of panels) {
+    if (panel.type === 'row') {
+      const rowName = panel.title || ''
+      if (rowName) {
+        state.groups.push({ name: rowName })
+        state.groupUnfoldStatus[rowName] = !panel.collapsed
+      }
+
+      if (panel.collapsed) {
+        collectPanels(sortPanels(panel.panels || []), state, rowName || null, variableNames, options)
+        activeRow = inheritedGroup
+        openRowPanel = null
+      } else {
+        activeRow = rowName || null
+        openRowPanel = panel
+      }
+      continue
+    }
+
+    const chart = convertPanel(panel, activeRow, openRowPanel, variableNames, options)
+    if (chart) {
+      state.charts.push(chart)
+    }
+  }
+}
+
+function sortPanels(panels) {
+  return [...panels].sort((left, right) => {
+    const leftPos = left.gridPos || {}
+    const rightPos = right.gridPos || {}
+    const leftY = leftPos.y ?? Number.MAX_SAFE_INTEGER
+    const rightY = rightPos.y ?? Number.MAX_SAFE_INTEGER
+    if (leftY !== rightY) return leftY - rightY
+    const leftX = leftPos.x ?? Number.MAX_SAFE_INTEGER
+    const rightX = rightPos.x ?? Number.MAX_SAFE_INTEGER
+    if (leftX !== rightX) return leftX - rightX
+    return (left.id || 0) - (right.id || 0)
+  })
+}
+
+function convertVariables(variables, variableNames) {
+  return variables
+    .map((variable, index) => convertVariable(variable, index, variableNames))
+    .filter(Boolean)
+}
+
+function convertVariable(variable, index, variableNames) {
+  const variableType = String(variable.type || '')
+  const current = variable.current || {}
+  const currentText = stringifyCurrent(current.text)
+  const currentValue = stringifyCurrent(current.value)
+  const includeAll = Boolean(variable.includeAll)
+  const defaultVal = {
+    label: normalizeAllValue(currentText, variable.allValue),
+    value: normalizeAllValue(currentValue, variable.allValue, true),
+  }
+
+  const base = {
+    name: variable.label || variable.name || '',
+    seq: index,
+    code: variable.name || `var_${index}`,
+    hide: variable.hide && variable.hide !== 0 ? 1 : 0,
+    multiple: Boolean(variable.multi),
+    includeStar: includeAll,
+    valueSort: 'desc',
+    extend: pruneEmpty({
+      originalType: variableType,
+      description: variable.description || undefined,
+      starMeaning: includeAll ? '*' : undefined,
+      options: Array.isArray(variable.options) ? variable.options : undefined,
+      refresh: variable.refresh,
+      skipUrlSync: variable.skipUrlSync,
+      sort: variable.sort,
+    }),
+  }
+
+  if (variableType === 'textbox' || variableType === 'constant' || variableType === 'interval') {
+    return pruneEmpty({
+      ...base,
+      datasource: 'custom',
+      type: 'CUSTOM_LIST',
+      multiple: false,
+      includeStar: false,
+      definition: {
+        value: variable.query || currentValue || '',
+        defaultVal,
+      },
+    })
+  }
+
+  if (variableType === 'custom' || variableType === 'datasource') {
+    return pruneEmpty({
+      ...base,
+      datasource: 'custom',
+      type: 'CUSTOM_LIST',
+      definition: {
+        value: variable.query || extractCustomOptions(variable.options || []),
+        defaultVal,
+      },
+    })
+  }
+
+  if (variableType === 'query') {
+    const queryString = extractVariableQuery(variable)
+    const queryKind = inferVariableQueryType(variable, queryString)
+    return pruneEmpty({
+      ...base,
+      datasource: queryKind === 'FIELD' ? 'object' : 'dataflux',
+      type: queryKind,
+      definition: {
+        tag: '',
+        field: queryKind === 'FIELD' ? extractFieldName(queryString) : '',
+        value: replaceVariables(queryString || '', variableNames),
+        metric: extractMetricName(queryString, variableNames),
+        object: queryKind === 'FIELD' ? 'HOST' : '',
+        defaultVal,
+      },
+    })
+  }
+
+  return pruneEmpty({
+    ...base,
+    datasource: 'custom',
+    type: 'CUSTOM_LIST',
+    multiple: false,
+    includeStar: false,
+    definition: {
+      value: variable.query || currentValue || '',
+      defaultVal,
+    },
+  })
+}
+
+function convertPanel(panel, groupName, rowPanel, variableNames, options) {
+  const chartType = inferChartType(panel)
+  if (!chartType || !panel.gridPos) {
+    return null
+  }
+
+  const queries = buildQueries(panel, chartType, variableNames, options)
+  const settings = buildSettings(panel, chartType, queries, variableNames)
+  const links = extractPanelLinks(panel, variableNames)
+  const group = groupName ?? null
+  const position = buildPosition(panel, rowPanel)
+
+  return pruneEmpty({
+    name: replaceVariables(panel.title || '', variableNames),
+    type: chartType,
+    group: { name: group },
+    pos: position,
+    extend: {
+      settings,
+      links: links.length ? links : undefined,
+      sourcePanelType: options.keepGrafanaMeta ? panel.type : undefined,
+      sourcePanelId: options.keepGrafanaMeta ? panel.id : undefined,
+      pluginVersion: options.keepGrafanaMeta ? panel.pluginVersion || undefined : undefined,
+      grafana: options.keepGrafanaMeta
+        ? pruneEmpty({
+            fieldConfig: panel.fieldConfig,
+            options: panel.options,
+            transformations: panel.transformations,
+            transparent: panel.transparent,
+            repeat: panel.repeat,
+            datasource: panel.datasource,
+          })
+        : undefined,
+    },
+    queries,
+  })
+}
+
+function buildPosition(panel, rowPanel) {
+  const gridPos = panel.gridPos || {}
+  const rowOffset = rowPanel?.gridPos?.y ?? 0
+  const rawY = typeof gridPos.y === 'number' ? gridPos.y - rowOffset : 0
+
+  return {
+    x: numberOr(gridPos.x, 0),
+    y: round1(rawY * 1.9 + 0.5),
+    w: numberOr(gridPos.w, 12),
+    h: round1(numberOr(gridPos.h, 8) * 1.9 + 0.1),
+  }
+}
+
+function buildQueries(panel, chartType, variableNames, options = {}) {
+  const queries = []
+  const targets = Array.isArray(panel.targets) ? panel.targets : []
+
+  for (let index = 0; index < targets.length; index++) {
+    const target = targets[index]
+    const queryText = extractTargetQuery(target)
+    if (!queryText) continue
+
+    const qtype = inferQueryLanguage(target, queryText)
+    const normalizedQueryText = normalizeTargetQuery(queryText, qtype, options)
+    queries.push(
+      pruneEmpty({
+        name: target.legendFormat || target.alias || '',
+        type: chartType,
+        qtype,
+        datasource: 'dataflux',
+        disabled: Boolean(target.hide),
+        query: {
+          q: replaceVariables(normalizedQueryText, variableNames),
+          code: normalizeQueryCode(target.refId, index),
+          type: qtype,
+          promqlCode: qtype === 'promql' ? index + 1 : undefined,
+          alias: target.legendFormat || target.alias || '',
+          field: target.field || undefined,
+        },
+        extend: pruneEmpty({
+          refId: target.refId || undefined,
+          datasource: target.datasource || undefined,
+          editorMode: target.editorMode || undefined,
+          queryMode: target.queryMode || undefined,
+        }),
+      })
+    )
+  }
+
+  if (chartType === 'text' && panel.options?.content) {
+    queries.push({
+      query: {
+        content: replaceVariables(panel.options.content, variableNames),
+      },
+    })
+  }
+
+  return queries
+}
+
+function buildSettings(panel, chartType, queries, variableNames) {
+  const defaults = panel.fieldConfig?.defaults || {}
+  const custom = defaults.custom || {}
+  const options = panel.options || {}
+  const legend = options.legend || panel.legend || {}
+  const transformationInfo = parseTransformations(panel.transformations || [])
+  const aliases = buildAliases(queries)
+  const tableColumns = buildTableColumns(panel.fieldConfig, transformationInfo.organize, variableNames)
+  const fieldOverrides = buildFieldOverrides(panel.fieldConfig, variableNames)
+  const legacyGauge = panel.gauge || {}
+  const valueMappings = buildLegacyValueMappings(panel.valueMaps)
+  const rangeMappings = buildLegacyRangeMappings(panel.rangeMaps)
+  const mappingItems = [...buildMappings(defaults.mappings), ...valueMappings, ...rangeMappings]
+  const explicitUnit = firstDefined(defaults.unit, panel.format, panel.yaxes?.[0]?.format)
+  const unit = explicitUnit || inferUnitFromQueries(queries, chartType)
+  const precision = firstDefinedNumber(defaults.decimals, panel.decimals)
+  const min = firstDefinedNumber(defaults.min, legacyGauge.minValue, panel.yaxes?.[0]?.min)
+  const max = firstDefinedNumber(defaults.max, legacyGauge.maxValue, panel.yaxes?.[0]?.max)
+  const lineWidth = firstDefinedNumber(custom.lineWidth, panel.linewidth)
+  const fillOpacity = firstDefinedNumber(custom.fillOpacity, normalizeLegacyFill(panel.fill))
+  const reduceOptions = options.reduceOptions || {}
+  const legendValues = mapLegendCalcs(legend.calcs?.length ? legend.calcs : extractLegacyLegendCalcs(legend))
+  const connectNulls = normalizeConnectNulls(firstDefined(custom.spanNulls, panel.nullPointMode))
+  const pointMode = firstDefined(custom.showPoints, panel.points === true ? 'always' : panel.points === false ? 'never' : undefined)
+  const graphMode = options.graphMode || undefined
+  const legacyTextMode = panel.valueName || undefined
+  const workspaceInfo = extractWorkspaceInfo(panel.targets || [])
+  const tooltip = options.tooltip || panel.tooltip || {}
+  const statText = options.text || {}
+  const textInfo = chartType === 'text' ? analyzeTextPanel(options.content, options.mode) : null
+  const tableFooter = options.footer || {}
+  const tableSortBy = Array.isArray(options.sortBy) ? options.sortBy : []
+  const tableCustom = chartType === 'table' ? custom : {}
+  const compareInfo = inferCompareSettings(queries, chartType)
+  const sortInfo = inferSortSettings(chartType, legend, tableSortBy)
+  const customUnits = buildCustomUnits(panel.fieldConfig)
+  const customColors = buildCustomColors(panel.fieldConfig)
+  const colorMappings = buildColorMappings(panel.fieldConfig, chartType)
+  const valColorMappings = buildValColorMappings(panel.fieldConfig, transformationInfo.organize)
+  const effectiveUnitType = customUnits.length ? 'custom' : unit ? 'global' : undefined
+  const slimit = inferSeriesLimit(queries, options, chartType)
+  const settings = {
+    showTitle: true,
+    titleDesc: panel.description || '',
+    isSampling: true,
+    changeWorkspace: workspaceInfo.changeWorkspace,
+    workspaceUUID: workspaceInfo.workspaceUUID,
+    workspaceName: workspaceInfo.workspaceName,
+    showFieldMapping: false,
+    openThousandsSeparator: true,
+    precision: typeof precision === 'number' ? String(precision) : '2',
+    timeInterval: normalizeTimeInterval(firstDefined(panel.interval, panel.targets?.find((item) => item.interval)?.interval, 'auto')),
+    fixedTime: panel.timeFrom || '',
+    maxPointCount: panel.maxDataPoints ?? null,
+    showLegend: legend.showLegend,
+    legendPostion: mapLegendPlacement(legend.placement),
+    legendValues,
+    showLegend: firstDefined(legend.showLegend, legend.show),
+    showLine: chartType === 'sequence' ? inferShowLine(panel, custom) : undefined,
+    lineType: mapLineInterpolation(custom.lineInterpolation),
+    connectNulls,
+    openStack: inferOpenStack(panel, custom),
+    stackType: mapStackType(firstDefined(custom.stacking?.mode, panel.stack ? 'normal' : 'none')),
+    chartType: inferDisplayChartType(panel, chartType),
+    isTimeInterval: chartType === 'sequence' || chartType === 'bar' || chartType === 'heatmap' || chartType === 'histogram',
+    xAxisShowType: chartType === 'sequence' || chartType === 'bar' ? 'time' : undefined,
+    unitType: effectiveUnitType,
+    globalUnit: customUnits.length ? undefined : mapUnit(unit),
+    units: customUnits.length ? customUnits : undefined,
+    colors: customColors.length ? customColors : undefined,
+    colorMappings: colorMappings.length ? colorMappings : undefined,
+    levels: buildLevels(defaults.thresholds),
+    slimit,
+    mappings: mappingItems,
+    alias: aliases,
+    min,
+    max,
+    showPercent: Array.isArray(options.displayLabels) ? options.displayLabels.includes('percent') : undefined,
+    showLabel: chartType === 'pie' ? Array.isArray(options.displayLabels) && options.displayLabels.length > 0 : undefined,
+    showLabelValue: Array.isArray(options.displayLabels)
+      ? options.displayLabels.includes('value') || options.displayLabels.includes('name')
+      : undefined,
+    direction: options.orientation || undefined,
+    queryMode: chartType === 'table' ? 'toGroupColumn' : undefined,
+    showTableHead: chartType === 'table' ? options.showHeader !== false : undefined,
+    pageEnable: chartType === 'table' ? false : undefined,
+    pageSize: chartType === 'table' ? 20 : undefined,
+    showColumns: chartType === 'table' ? tableColumns.map((column) => column.title || column.field) : undefined,
+    valMappings: chartType === 'table' ? buildTableMappings(panel.fieldConfig, transformationInfo.organize) : undefined,
+    valColorMappings: chartType === 'table' && valColorMappings.length ? valColorMappings : undefined,
+    legendValueOpen: Array.isArray(legend.values) ? legend.values.includes('value') : undefined,
+    legendValuePercentOpen: Array.isArray(legend.values) ? legend.values.includes('percent') : undefined,
+    showTopSize: chartType === 'toplist' ? true : undefined,
+    topSize: chartType === 'toplist' ? extractReduceLimit(options) : undefined,
+    scientificNotation: unit === 'short' ? true : undefined,
+    mainMeasurementQueryCode: queries[0]?.query?.code || undefined,
+    mainMeasurementLimit: chartType === 'pie' ? extractReduceLimit(options) : undefined,
+    color: defaults.color?.fixedColor || undefined,
+    fontColor: options.colorMode === 'value' ? defaults.color?.fixedColor : undefined,
+    bgColor: options.colorMode === 'background' ? defaults.color?.fixedColor : undefined,
+    sequenceChartType: chartType === 'singlestat' && graphMode ? inferSequenceChartType(panel, graphMode) : undefined,
+    showLineAxis: chartType === 'singlestat' ? graphMode !== 'none' : undefined,
+    repeatChartVariable: typeof panel.repeat === 'string' && panel.repeat ? panel.repeat : undefined,
+    repeatChartRowLimit: typeof panel.maxPerRow === 'number' ? panel.maxPerRow : undefined,
+    compares: compareInfo.compares,
+    compareType: compareInfo.compareType,
+    openCompare: compareInfo.openCompare,
+    compareChartType: compareInfo.compareChartType,
+    mainMeasurementSort: sortInfo.mainMeasurementSort,
+    sorderByOrder: sortInfo.sorderByOrder,
+  }
+
+  const links = extractPanelLinks(panel)
+  if (links.length) {
+    settings.queryCodes = queries.map((query) => query.query?.code).filter(Boolean)
+  }
+
+  settings.extend = pruneEmpty({
+    appearance: pruneEmpty({
+      lineWidth,
+      fillOpacity,
+      gradientMode: custom.gradientMode || undefined,
+      pointMode,
+      pointSize: firstDefinedNumber(custom.pointSize, panel.pointradius),
+      axisPlacement: custom.axisPlacement || undefined,
+      axisLabel: custom.axisLabel || undefined,
+      axisColorMode: custom.axisColorMode || undefined,
+      axisCenteredZero: typeof custom.axisCenteredZero === 'boolean' ? custom.axisCenteredZero : undefined,
+      axisSoftMin: numberOrUndefined(custom.axisSoftMin),
+      axisSoftMax: numberOrUndefined(custom.axisSoftMax),
+      barAlignment: numberOrUndefined(custom.barAlignment),
+      scaleDistribution: custom.scaleDistribution || undefined,
+      drawStyle: custom.drawStyle || undefined,
+      lineStyle: custom.lineStyle || undefined,
+      spanNulls: custom.spanNulls,
+      stackingGroup: custom.stacking?.group || undefined,
+      graphMode,
+      colorMode: options.colorMode || undefined,
+      fieldColorMode: defaults.color?.mode || undefined,
+      fixedColor: defaults.color?.fixedColor || undefined,
+      thresholdsMode: defaults.thresholds?.mode || undefined,
+      thresholdsStyleMode: custom.thresholdsStyle?.mode || undefined,
+      textMode: options.textMode || legacyTextMode,
+      reduceCalcs: Array.isArray(reduceOptions.calcs) ? reduceOptions.calcs : undefined,
+      reduceFields: reduceOptions.fields || undefined,
+      reduceValues: typeof reduceOptions.values === 'boolean' ? reduceOptions.values : undefined,
+      pieType: options.pieType || undefined,
+      gaugeMode: chartType === 'gauge' || panel.type === 'singlestat' ? inferGaugeMode(panel, options, legacyGauge) : undefined,
+      thresholdMarkers: typeof legacyGauge.thresholdMarkers === 'boolean' ? legacyGauge.thresholdMarkers : undefined,
+      thresholdLabels: typeof legacyGauge.thresholdLabels === 'boolean' ? legacyGauge.thresholdLabels : undefined,
+      hideFrom: custom.hideFrom || undefined,
+      justifyMode: options.justifyMode || undefined,
+      titleSize: typeof statText.titleSize === 'number' ? statText.titleSize : undefined,
+      valueSize: typeof statText.valueSize === 'number' ? statText.valueSize : undefined,
+    }),
+    legend: pruneEmpty({
+      displayMode: legend.displayMode || undefined,
+      sortBy: legend.sortBy || legend.sort || undefined,
+      sortDesc: typeof legend.sortDesc === 'boolean' ? legend.sortDesc : undefined,
+      width: firstDefinedNumber(legend.width, legend.sideWidth),
+    }),
+    tooltip: pruneEmpty({
+      mode: tooltip.mode || tooltip.sharedMode || undefined,
+      sort: tooltip.sort || tooltip.value_type || undefined,
+    }),
+    table: chartType === 'table'
+      ? pruneEmpty({
+          align: tableCustom.align || undefined,
+          displayMode: tableCustom.displayMode || undefined,
+          sortBy: tableSortBy,
+          footer: pruneEmpty({
+            fields: tableFooter.fields || undefined,
+            reducer: Array.isArray(tableFooter.reducer) ? tableFooter.reducer : undefined,
+            show: typeof tableFooter.show === 'boolean' ? tableFooter.show : undefined,
+          }),
+        })
+      : undefined,
+    text: textInfo || undefined,
+    tableColumns: chartType === 'table' && tableColumns.length ? tableColumns : undefined,
+    fieldOverrides: fieldOverrides.length ? fieldOverrides : undefined,
+    transformations: transformationInfo.normalized.length ? transformationInfo.normalized : undefined,
+    fieldFilterPattern: transformationInfo.fieldFilterPattern || undefined,
+    valueFilters: transformationInfo.valueFilters.length ? transformationInfo.valueFilters : undefined,
+    layout: pruneEmpty({
+      repeatDirection: panel.repeatDirection || undefined,
+    }),
+  })
+
+  return pruneEmpty(settings)
+}
+
+function buildLevels(thresholds) {
+  const steps = Array.isArray(thresholds?.steps) ? thresholds.steps : []
+  return steps
+    .filter((step) => typeof step.value === 'number' || typeof step.color === 'string')
+    .map((step, index) => ({
+      title: `Level ${index + 1}`,
+      value: typeof step.value === 'number' ? step.value : 0,
+      bgColor: normalizeColor(step.color),
+    }))
+}
+
+function buildMappings(mappings) {
+  if (!Array.isArray(mappings)) return []
+  const result = []
+
+  for (const mapping of mappings) {
+    if (mapping.type === 'value' && mapping.options && typeof mapping.options === 'object') {
+      for (const [rawValue, item] of Object.entries(mapping.options)) {
+        result.push({
+          originalVal: [rawValue],
+          operation: '=',
+          mappingVal: item.text || rawValue,
+        })
+      }
+    }
+
+    if (mapping.type === 'range' && mapping.options) {
+      const from = mapping.options.from
+      const to = mapping.options.to
+      result.push({
+        originalVal: [String(from ?? ''), String(to ?? '')],
+        operation: 'between',
+        mappingVal: mapping.options.result?.text || '',
+      })
+    }
+  }
+
+  return result
+}
+
+function buildTableMappings(fieldConfig, organize) {
+  const overrideMappings = []
+  const overrides = Array.isArray(fieldConfig?.overrides) ? fieldConfig.overrides : []
+  const organizeMaps = createOrganizeMaps(organize)
+
+  for (const override of overrides) {
+    const field = override.matcher?.options
+    if (!field) continue
+    const displayField = resolveDisplayFieldName(field, organizeMaps)
+    const properties = Array.isArray(override.properties) ? override.properties : []
+    for (const property of properties) {
+      if (property.id !== 'mappings') continue
+      const mappings = buildMappings(property.value)
+      for (const mapping of mappings) {
+        overrideMappings.push({
+          field: displayField,
+          ...mapping,
+        })
+      }
+    }
+  }
+
+  return overrideMappings
+}
+
+function buildTableColumns(fieldConfig, organize, variableNames = new Set()) {
+  const columns = new Map()
+  const defaultCustom = fieldConfig?.defaults?.custom || {}
+  const overrides = Array.isArray(fieldConfig?.overrides) ? fieldConfig.overrides : []
+  const organizeMaps = createOrganizeMaps(organize)
+  const { renamedFields, excludedFields, indexedFields } = organizeMaps
+
+  for (const override of overrides) {
+    const rawField = override.matcher?.options
+    if (!rawField) continue
+    const field = resolveRawFieldName(rawField, organizeMaps)
+    if (excludedFields[field] === true || excludedFields[rawField] === true) continue
+    const columnKey = resolveDisplayFieldName(field, organizeMaps)
+    const currentColumn = columns.get(columnKey) || {
+      field,
+      title: columnKey,
+      order: typeof indexedFields[field] === 'number' ? indexedFields[field] : undefined,
+      align: defaultCustom.align || undefined,
+      displayMode: defaultCustom.displayMode || undefined,
+    }
+    for (const property of override.properties || []) {
+      if (property.id === 'custom.width') {
+        currentColumn.width = property.value
+      }
+      if (property.id === 'custom.align') {
+        currentColumn.align = property.value
+      }
+      if (property.id === 'custom.displayMode') {
+        currentColumn.displayMode = property.value
+      }
+      if (property.id === 'links') {
+        currentColumn.links = Array.isArray(property.value)
+          ? property.value.map((link) => normalizeGuanceLinkItem(link, variableNames))
+          : undefined
+      }
+      if (property.id === 'mappings') {
+        currentColumn.mappings = buildMappings(property.value)
+      }
+    }
+    columns.set(columnKey, pruneEmpty(currentColumn))
+  }
+
+  if (organize) {
+    for (const [field, order] of Object.entries(indexedFields)) {
+      if (excludedFields[field] === true) continue
+      const columnKey = resolveDisplayFieldName(field, organizeMaps)
+      if (columns.has(columnKey)) {
+        const currentColumn = columns.get(columnKey)
+        currentColumn.field = field
+        currentColumn.order = typeof order === 'number' ? order : currentColumn.order
+        currentColumn.title = columnKey
+        columns.set(columnKey, pruneEmpty(currentColumn))
+        continue
+      }
+      columns.set(
+        columnKey,
+        pruneEmpty({
+          field,
+          title: columnKey,
+          order: typeof order === 'number' ? order : undefined,
+        })
+      )
+    }
+  }
+
+  return finalizeTableColumns([...columns.values()])
+}
+
+function buildAliases(queries) {
+  return queries
+    .filter((query) => query.query?.alias)
+    .map((query) => ({
+      alias: query.query.alias,
+      key: query.query.code || query.name || '',
+      name: query.query.code || query.name || '',
+    }))
+}
+
+function buildCustomUnits(fieldConfig) {
+  const overrides = Array.isArray(fieldConfig?.overrides) ? fieldConfig.overrides : []
+  const units = []
+
+  for (const override of overrides) {
+    const rawKey = String(override?.matcher?.options || '').trim()
+    if (!rawKey) continue
+
+    const unitProperty = Array.isArray(override?.properties)
+      ? override.properties.find((property) => property?.id === 'unit')
+      : undefined
+    if (!unitProperty || typeof unitProperty.value !== 'string') continue
+
+    const unit = unitProperty.value
+    units.push(
+      pruneEmpty({
+        key: rawKey,
+        name: rawKey,
+        unit,
+        units: mapUnit(unit),
+      })
+    )
+  }
+
+  return units
+}
+
+function buildCustomColors(fieldConfig) {
+  const overrides = Array.isArray(fieldConfig?.overrides) ? fieldConfig.overrides : []
+  const colors = []
+
+  for (const override of overrides) {
+    const rawKey = String(override?.matcher?.options || '').trim()
+    if (!rawKey) continue
+
+    const colorProperty = Array.isArray(override?.properties)
+      ? override.properties.find((property) => property?.id === 'color')
+      : undefined
+    const fixedColor = colorProperty?.value?.fixedColor
+    const colorMode = colorProperty?.value?.mode
+    if (typeof fixedColor !== 'string' || !fixedColor) continue
+    if (colorMode && colorMode !== 'fixed') continue
+
+    colors.push(
+      pruneEmpty({
+        key: rawKey,
+        name: rawKey,
+        color: normalizeColor(fixedColor),
+      })
+    )
+  }
+
+  return colors
+}
+
+function buildColorMappings(fieldConfig, chartType) {
+  if (chartType !== 'toplist') return []
+
+  const steps = Array.isArray(fieldConfig?.defaults?.thresholds?.steps) ? fieldConfig.defaults.thresholds.steps : []
+  if (steps.length === 0) return []
+
+  const mappings = []
+  for (let index = 0; index < steps.length; index++) {
+    const current = steps[index]
+    const next = steps[index + 1]
+    const bgColor = normalizeColor(current?.color)
+    const start = current?.value
+    const end = next?.value
+
+    if (typeof start === 'number' && typeof end === 'number') {
+      mappings.push({
+        value: [start, end],
+        bgColor,
+        operation: 'between',
+      })
+      continue
+    }
+
+    if (typeof start === 'number') {
+      mappings.push({
+        value: [start],
+        bgColor,
+        operation: '>=',
+      })
+      continue
+    }
+
+    if (typeof end === 'number') {
+      mappings.push({
+        value: [end],
+        bgColor,
+        operation: '<',
+      })
+    }
+  }
+
+  return mappings
+}
+
+function buildValColorMappings(fieldConfig, organize) {
+  const overrides = Array.isArray(fieldConfig?.overrides) ? fieldConfig.overrides : []
+  const organizeMaps = createOrganizeMaps(organize)
+  const mappings = []
+
+  for (const override of overrides) {
+    const rawField = override?.matcher?.options
+    if (!rawField) continue
+
+    const field = resolveDisplayFieldName(resolveRawFieldName(rawField, organizeMaps), organizeMaps)
+    const properties = Array.isArray(override?.properties) ? override.properties : []
+    const mappingProperty = properties.find((property) => property?.id === 'mappings')
+    if (!mappingProperty) continue
+
+    const colorProperty = properties.find((property) => property?.id === 'color')
+    const fixedColor = typeof colorProperty?.value?.fixedColor === 'string' ? normalizeColor(colorProperty.value.fixedColor) : ''
+    const tableMappings = buildMappings(mappingProperty.value)
+
+    for (const mapping of tableMappings) {
+      mappings.push(
+        pruneEmpty({
+          field,
+          value: mapping.originalVal,
+          bgColor: '',
+          fontColor: fixedColor,
+          lineColor: '',
+          operation: mapping.operation,
+        })
+      )
+    }
+  }
+
+  return mappings
+}
+
+function buildFieldOverrides(fieldConfig, variableNames = new Set()) {
+  const overrides = Array.isArray(fieldConfig?.overrides) ? fieldConfig.overrides : []
+  const normalized = []
+
+  for (const override of overrides) {
+    const properties = Array.isArray(override.properties) ? override.properties : []
+    const normalizedProperties = properties
+      .map((property) => normalizeOverrideProperty(property, variableNames))
+      .filter(Boolean)
+
+    if (normalizedProperties.length === 0) continue
+
+    normalized.push(
+      pruneEmpty({
+        matcher: pruneEmpty({
+          id: override.matcher?.id || undefined,
+          options: override.matcher?.options,
+        }),
+        properties: normalizedProperties,
+      })
+    )
+  }
+
+  return normalized
+}
+
+function normalizeOverrideProperty(property, variableNames = new Set()) {
+  if (!property?.id) return undefined
+
+  if (property.id === 'links') {
+    return pruneEmpty({
+      id: property.id,
+      value: Array.isArray(property.value)
+        ? property.value.map((link) => normalizeGuanceLinkItem(link, variableNames))
+        : undefined,
+    })
+  }
+
+  return pruneEmpty({
+    id: property.id,
+    value: property.value,
+  })
+}
+
+function analyzeTextPanel(content, mode) {
+  if (typeof content !== 'string' || !content.trim()) return undefined
+
+  const normalizedMode = typeof mode === 'string' ? mode : undefined
+  const containsScript = /<script\b/i.test(content)
+  const containsHtml = /<[a-z][\s\S]*>/i.test(content)
+  const contentKind = containsScript ? 'interactive_html' : containsHtml ? 'html' : 'markdown'
+  const actions = extractTextActions(content)
+
+  return pruneEmpty({
+    mode: normalizedMode,
+    contentKind,
+    containsScript: containsScript || undefined,
+    actions: actions.length ? actions : undefined,
+  })
+}
+
+function extractTextActions(content) {
+  const actions = []
+  const seen = new Set()
+
+  const anchorRegex = /<a\b[^>]*href=(['"])(.*?)\1[^>]*>([\s\S]*?)<\/a>/gi
+  for (const match of content.matchAll(anchorRegex)) {
+    const url = (match[2] || '').trim()
+    const label = stripHtmlTags(match[3] || '').trim()
+    pushTextAction(actions, seen, {
+      title: label || undefined,
+      url: url || undefined,
+      open: url === '#' ? 'curWin' : 'newWin',
+      type: inferGuanceLinkType({ title: label, url }),
+      show: true,
+      showChanged: false,
+    })
+  }
+
+  const constUrlRegex = /\bconst\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*([`'"])([\s\S]*?)\2\s*;/g
+  const constantUrls = new Map()
+  for (const match of content.matchAll(constUrlRegex)) {
+    constantUrls.set(match[1], match[3])
+  }
+
+  const windowOpenRegex = /window\.open\(\s*([A-Za-z_$][A-Za-z0-9_$]*|[`'"][\s\S]*?[`'"])\s*(?:,\s*([`'"][\s\S]*?[`'"]))?\s*\)/g
+  for (const match of content.matchAll(windowOpenRegex)) {
+    const rawTarget = match[1]?.trim() || ''
+    const rawBlank = match[2]?.trim() || ''
+    const directUrl = unwrapQuoted(rawTarget)
+    const variableUrl = constantUrls.get(rawTarget)
+    const url = directUrl || variableUrl
+    pushTextAction(actions, seen, {
+      title: inferActionTitle(content, url),
+      url: url || undefined,
+      open: rawBlank.includes('_blank') ? 'newWin' : 'curWin',
+      type: inferGuanceLinkType({ title: inferActionTitle(content, url), url }),
+      show: true,
+      showChanged: false,
+    })
+  }
+
+  return actions
+}
+
+function pushTextAction(actions, seen, action) {
+  const normalized = pruneEmpty(action)
+  const key = JSON.stringify(normalized)
+  if (!key || seen.has(key) || Object.keys(normalized).length === 0) return
+  seen.add(key)
+  actions.push(normalized)
+}
+
+function inferActionTitle(content, url) {
+  if (typeof url !== 'string' || !url) return undefined
+  if (content.includes('HotCall') || url.includes('hotcall')) return 'HotCall'
+  if (content.includes('业务大盘')) return '业务大盘'
+  if (content.includes('拓扑图') || content.includes('traceLink')) return '跳转观测云'
+  return undefined
+}
+
+function unwrapQuoted(value) {
+  if (typeof value !== 'string') return ''
+  const trimmed = value.trim()
+  if (trimmed.length < 2) return ''
+  const quote = trimmed[0]
+  if ((quote === '"' || quote === "'" || quote === '`') && trimmed.at(-1) === quote) {
+    return trimmed.slice(1, -1)
+  }
+  return ''
+}
+
+function stripHtmlTags(value) {
+  return String(value).replace(/<[^>]+>/g, ' ')
+}
+
+function normalizeColumnTitle(field, renamedField) {
+  if (typeof renamedField === 'string' && renamedField.trim()) return renamedField.trim()
+  return field
+}
+
+function finalizeTableColumns(columns) {
+  const mergedColumns = new Map()
+
+  for (const column of columns) {
+    const key = column.title || column.field
+    const existing = mergedColumns.get(key)
+    if (!existing) {
+      mergedColumns.set(key, { ...column })
+      continue
+    }
+
+    mergedColumns.set(
+      key,
+      pruneEmpty({
+        ...existing,
+        ...column,
+        field: existing.field || column.field,
+        title: key,
+        order: Math.min(numberOr(existing.order, Number.MAX_SAFE_INTEGER), numberOr(column.order, Number.MAX_SAFE_INTEGER)),
+        width: firstDefined(existing.width, column.width),
+        align: firstDefined(existing.align, column.align),
+        displayMode: firstDefined(existing.displayMode, column.displayMode),
+        links: existing.links || column.links,
+        mappings: existing.mappings || column.mappings,
+      })
+    )
+  }
+
+  return [...mergedColumns.values()].sort(
+    (left, right) => numberOr(left.order, Number.MAX_SAFE_INTEGER) - numberOr(right.order, Number.MAX_SAFE_INTEGER)
+  )
+}
+
+function createOrganizeMaps(organize) {
+  const renamedFields = organize?.renameByName || {}
+  const excludedFields = organize?.excludeByName || {}
+  const indexedFields = organize?.indexByName || {}
+  const displayToRaw = {}
+
+  for (const [rawField, renamedField] of Object.entries(renamedFields)) {
+    const title = normalizeColumnTitle(rawField, renamedField)
+    if (title && title !== rawField) {
+      displayToRaw[title] = rawField
+    }
+  }
+
+  return {
+    renamedFields,
+    excludedFields,
+    indexedFields,
+    displayToRaw,
+  }
+}
+
+function resolveRawFieldName(field, organizeMaps) {
+  return organizeMaps.displayToRaw[field] || field
+}
+
+function resolveDisplayFieldName(field, organizeMaps) {
+  return normalizeColumnTitle(field, organizeMaps.renamedFields[field])
+}
+
+function parseTransformations(transformations) {
+  const normalized = []
+  let organize = null
+  let fieldFilterPattern = ''
+  const valueFilters = []
+
+  for (const transformation of Array.isArray(transformations) ? transformations : []) {
+    if (!transformation?.id) continue
+
+    if (transformation.id === 'organize') {
+      organize = transformation.options || {}
+      normalized.push(
+        pruneEmpty({
+          type: 'organize',
+          renameByName: organize.renameByName,
+          excludeByName: organize.excludeByName,
+          indexByName: organize.indexByName,
+        })
+      )
+      continue
+    }
+
+    if (transformation.id === 'filterFieldsByName') {
+      fieldFilterPattern = transformation.options?.include?.pattern || transformation.options?.exclude?.pattern || ''
+      normalized.push(
+        pruneEmpty({
+          type: 'filterFieldsByName',
+          include: transformation.options?.include,
+          exclude: transformation.options?.exclude,
+        })
+      )
+      continue
+    }
+
+    if (transformation.id === 'filterByValue') {
+      const filters = Array.isArray(transformation.options?.filters) ? transformation.options.filters : []
+      valueFilters.push(
+        pruneEmpty({
+          match: transformation.options?.match || undefined,
+          type: transformation.options?.type || undefined,
+          filters,
+        })
+      )
+      normalized.push(
+        pruneEmpty({
+          type: 'filterByValue',
+          match: transformation.options?.match || undefined,
+          mode: transformation.options?.type || undefined,
+          filters,
+        })
+      )
+      continue
+    }
+
+    normalized.push(
+      pruneEmpty({
+        type: transformation.id,
+        options: transformation.options,
+      })
+    )
+  }
+
+  return {
+    organize,
+    fieldFilterPattern,
+    valueFilters,
+    normalized,
+  }
+}
+
+function extractPanelLinks(panel, variableNames) {
+  const links = []
+  const defaults = panel.fieldConfig?.defaults || {}
+  const overrideLinks = Array.isArray(panel.fieldConfig?.overrides)
+    ? panel.fieldConfig.overrides.flatMap((override) =>
+        (override.properties || [])
+          .filter((property) => property.id === 'links')
+          .flatMap((property) => property.value || [])
+      )
+    : []
+
+  const allLinks = [
+    ...(Array.isArray(panel.links) ? panel.links : []),
+    ...(Array.isArray(defaults.links) ? defaults.links : []),
+    ...overrideLinks,
+  ]
+
+  for (const link of allLinks) {
+    if (!link || !link.url) continue
+    links.push(normalizeGuanceLinkItem(link, variableNames))
+  }
+
+  return links
+}
+
+function normalizeGuanceLinkItem(link, variableNames = new Set()) {
+  return pruneEmpty({
+    url: replaceVariables(link.url || '', variableNames),
+    open: Boolean(link.targetBlank) ? 'newWin' : 'curWin',
+    show: true,
+    type: inferGuanceLinkType(link),
+    showChanged: false,
+  })
+}
+
+function inferGuanceLinkType(link) {
+  const title = String(link?.title || '').toLowerCase()
+  const url = String(link?.url || '').toLowerCase()
+  const combined = `${title} ${url}`
+
+  if (url.includes('pipeline-log')) return 'custom'
+  if (url.includes('/tracing/')) return 'tracing'
+  if (url.includes('/logindi/') || url.includes('/log/') || url.includes('/logging/')) return 'logging'
+  if (url.includes('/objectadmin/docker_containers') || url.includes('/container')) return 'container'
+  if (url.includes('/objectadmin/host_processes') || url.includes('/process')) return 'processes'
+  if (url.includes('/scene/builtinview/detail') || url.includes('/host')) return 'host'
+  if (title.includes('trace') || title.includes('tracing')) return 'tracing'
+  if (title.includes('日志')) return 'logging'
+  return 'custom'
+}
+
+function inferChartType(panel) {
+  return PANEL_TYPE_MAP[panel.type] || null
+}
+
+function inferDisplayChartType(panel, chartType) {
+  if (chartType === 'pie') {
+    return panel.options?.pieType === 'donut' ? 'donut' : 'pie'
+  }
+
+  if (chartType === 'bar') return 'bar'
+  if (chartType === 'toplist') return 'bar'
+
+  const drawStyle = panel.fieldConfig?.defaults?.custom?.drawStyle
+  const fillOpacity = panel.fieldConfig?.defaults?.custom?.fillOpacity
+  if (drawStyle === 'bars') return 'bar'
+  if (fillOpacity && fillOpacity > 0) return 'areaLine'
+  return 'line'
+}
+
+function inferQueryLanguage(target, queryText) {
+  const datasourceType = getDatasourceType(target.datasource)
+  // Guance datasource defaults to DQL unless the Grafana target explicitly marks the query as PromQL.
+  if (target.qtype === 'promql') return 'promql'
+  if (target.qtype === 'dql') return 'dql'
+  if (datasourceType.includes('guance-guance-datasource')) return 'dql'
+  if (isPrometheusLikeDatasource(datasourceType)) return 'promql'
+  if (isDqlLikeDatasource(datasourceType)) return 'dql'
+  if (/^\s*(with|select)\b/i.test(queryText)) return 'dql'
+  if (/^[A-Z]::/.test(queryText)) return 'dql'
+  return 'promql'
+}
+
+function inferVariableQueryType(variable, queryString) {
+  const datasourceType = getDatasourceType(variable.datasource)
+  const explicitQtype = String(variable.query?.qtype || '').toLowerCase()
+  if (datasourceType.includes('object')) return 'FIELD'
+  if (explicitQtype === 'promql') return 'PROMQL_QUERY'
+  if (explicitQtype === 'dql') return 'QUERY'
+  if (isDqlLikeDatasource(datasourceType) && /^\s*(with|select)\b/i.test(queryString)) return 'QUERY'
+  if (/field_values\(/i.test(queryString) || /label_values\(/i.test(queryString)) return 'QUERY'
+  if (/^[A-Z]::/.test(queryString) || /L\('/.test(queryString)) return 'QUERY'
+  if (/^\s*(with|select)\b/i.test(queryString)) return 'QUERY'
+  return 'PROMQL_QUERY'
+}
+
+function extractVariableQuery(variable) {
+  if (typeof variable.query === 'string') return variable.query
+  if (variable.query && typeof variable.query === 'object') {
+    return variable.query.rawQuery || variable.query.query || variable.query.expr || ''
+  }
+  if (typeof variable.definition === 'string') return variable.definition
+  return ''
+}
+
+function extractTargetQuery(target) {
+  const candidates = [target.expr, target.query, target.queryText, target.expression, target.rawSql]
+  for (const candidate of candidates) {
+    if (typeof candidate === 'string' && candidate.trim()) return candidate
+  }
+  return ''
+}
+
+function extractWorkspaceInfo(targets) {
+  const workspaceUUIDs = []
+  const workspaceNames = []
+
+  for (const target of Array.isArray(targets) ? targets : []) {
+    for (const item of Array.isArray(target.workspaceUUIDs) ? target.workspaceUUIDs : []) {
+      if (item?.value && !workspaceUUIDs.includes(item.value)) workspaceUUIDs.push(item.value)
+      if (item?.label && !workspaceNames.includes(item.label)) workspaceNames.push(item.label)
+    }
+  }
+
+  return pruneEmpty({
+    changeWorkspace: workspaceUUIDs.length > 0,
+    workspaceUUID: workspaceUUIDs.length ? workspaceUUIDs.join(',') : undefined,
+    workspaceName: workspaceNames.length ? workspaceNames : undefined,
+  })
+}
+
+function normalizeTargetQuery(queryText, qtype, options = {}) {
+  if (qtype !== 'promql') return queryText
+  if (!options.guancePromqlCompatible) return queryText
+  return normalizePromqlForGuance(queryText)
+}
+
+function extractMetricName(queryString, variableNames) {
+  if (/^\s*(with|select)\b/i.test(queryString)) return ''
+  const labelValuesMatch = queryString.match(/label_values\(([^,]+),\s*([^)]+)\)/i)
+  if (labelValuesMatch) return replaceVariables(labelValuesMatch[1].trim(), variableNames)
+  return ''
+}
+
+function extractFieldName(queryString) {
+  const fieldValuesMatch = queryString.match(/field_values\(`?([^`)\s]+)`?\)/i)
+  if (fieldValuesMatch) return fieldValuesMatch[1].trim()
+  const labelValuesMatch = queryString.match(/label_values\([^,]+,\s*([^)]+)\)/i)
+  if (labelValuesMatch) return labelValuesMatch[1].replace(/[`'"]/g, '').trim()
+  return ''
+}
+
+function normalizeTimeInterval(value) {
+  if (!value || typeof value !== 'string') return 'auto'
+  const normalized = value.trim()
+  if (!normalized) return 'auto'
+  return normalized
+}
+
+function normalizePromqlForGuance(queryText) {
+  if (typeof queryText !== 'string' || !queryText.trim()) return queryText
+  let result = ''
+  let index = 0
+  let braceDepth = 0
+
+  while (index < queryText.length) {
+    const current = queryText[index]
+
+    if (current === '{') {
+      braceDepth++
+      result += current
+      index++
+      continue
+    }
+
+    if (current === '}') {
+      braceDepth = Math.max(0, braceDepth - 1)
+      result += current
+      index++
+      continue
+    }
+
+    if (braceDepth === 0 && /[A-Za-z_:]/.test(current)) {
+      let end = index + 1
+      while (end < queryText.length && /[A-Za-z0-9_:]/.test(queryText[end])) end++
+      const token = queryText.slice(index, end)
+      let lookahead = end
+      while (lookahead < queryText.length && /\s/.test(queryText[lookahead])) lookahead++
+      const next = queryText[lookahead]
+      if (next === '{' || next === '[') {
+        result += toGuancePromqlMetricName(token)
+        index = end
+        continue
+      }
+    }
+
+    result += current
+    index++
+  }
+
+  return result
+}
+
+function inferUnitFromQueries(queries, chartType) {
+  if (!Array.isArray(queries) || queries.length === 0) return undefined
+  if (['text', 'table', 'topology', 'iframe', 'picture', 'video'].includes(chartType)) return undefined
+
+  const inferredUnits = queries
+    .map((query) => inferUnitFromQueryText(query?.query?.q || ''))
+    .filter(Boolean)
+
+  if (inferredUnits.length === 0) return undefined
+
+  const counts = new Map()
+  for (const unit of inferredUnits) {
+    counts.set(unit, (counts.get(unit) || 0) + 1)
+  }
+
+  let bestUnit = inferredUnits[0]
+  let bestCount = counts.get(bestUnit) || 0
+  for (const unit of inferredUnits) {
+    const currentCount = counts.get(unit) || 0
+    if (currentCount > bestCount) {
+      bestUnit = unit
+      bestCount = currentCount
+    }
+  }
+
+  return bestUnit
+}
+
+function inferCompareSettings(queries, chartType) {
+  if (!Array.isArray(queries) || queries.length === 0) {
+    return { compares: undefined, compareType: undefined, openCompare: undefined, compareChartType: undefined }
+  }
+
+  if (!['sequence', 'singlestat'].includes(chartType)) {
+    return { compares: undefined, compareType: undefined, openCompare: undefined, compareChartType: undefined }
+  }
+
+  const compareTypes = []
+  for (const query of queries) {
+    const compareType = inferCompareTypeFromQuery(query?.query?.q || '')
+    if (compareType && !compareTypes.includes(compareType)) {
+      compareTypes.push(compareType)
+    }
+  }
+
+  if (compareTypes.length === 0) {
+    return { compares: undefined, compareType: undefined, openCompare: undefined, compareChartType: undefined }
+  }
+
+  return {
+    compares: compareTypes.map((type) => COMPARE_OPTIONS[type]).filter(Boolean),
+    compareType: compareTypes,
+    openCompare: true,
+    compareChartType: chartType,
+  }
+}
+
+function inferCompareTypeFromQuery(queryText) {
+  if (typeof queryText !== 'string' || !queryText.trim()) return undefined
+  const normalized = queryText.toLowerCase()
+
+  if (/\boffset\s+1h\b/.test(normalized)) return 'hourCompare'
+  if (/\boffset\s+1d\b/.test(normalized)) return 'dayCompare'
+  if (/\boffset\s+(7d|1w)\b/.test(normalized)) return 'weekCompare'
+  if (/\boffset\s+(30d|4w)\b/.test(normalized)) return 'monthCompare'
+
+  return undefined
+}
+
+function inferSortSettings(chartType, legend, tableSortBy) {
+  const sequenceSort = inferSequenceSortOrder(legend)
+  const mainMeasurementSort = inferMainMeasurementSort(chartType, legend, tableSortBy)
+
+  return {
+    sorderByOrder: sequenceSort,
+    mainMeasurementSort,
+  }
+}
+
+function inferSeriesLimit(queries, options, chartType) {
+  const explicitLimit = extractReduceLimit(options)
+  if (['pie', 'toplist', 'treemap'].includes(chartType)) {
+    return extractTopkLimit(queries) || explicitLimit
+  }
+
+  if (['sequence', 'table'].includes(chartType)) {
+    return extractTopkLimit(queries) || undefined
+  }
+
+  return undefined
+}
+
+function extractTopkLimit(queries) {
+  if (!Array.isArray(queries)) return undefined
+
+  for (const query of queries) {
+    const queryText = String(query?.query?.q || '')
+    const match = queryText.match(/\btopk\s*\(\s*(\d+)/i)
+    if (!match) continue
+    const limit = Number(match[1])
+    if (Number.isFinite(limit)) return limit
+  }
+
+  return undefined
+}
+
+function inferSequenceSortOrder(legend) {
+  if (typeof legend?.sortDesc === 'boolean') {
+    return legend.sortDesc ? 'desc' : 'asc'
+  }
+  return undefined
+}
+
+function inferMainMeasurementSort(chartType, legend, tableSortBy) {
+  if (!['pie', 'toplist', 'table', 'treemap'].includes(chartType)) return undefined
+
+  if (chartType === 'table') {
+    const primarySort = Array.isArray(tableSortBy) ? tableSortBy[0] : undefined
+    if (primarySort && typeof primarySort.desc === 'boolean') {
+      return primarySort.desc ? 'top' : 'bottom'
+    }
+  }
+
+  if (typeof legend?.sortDesc === 'boolean') {
+    return legend.sortDesc ? 'top' : 'bottom'
+  }
+
+  return undefined
+}
+
+function inferUnitFromQueryText(queryText) {
+  if (typeof queryText !== 'string' || !queryText.trim()) return undefined
+  const normalized = queryText.toLowerCase()
+  const isRateLike = /rate\(|irate\(|increase\(|delta\(|deriv\(/.test(normalized)
+
+  if (
+    /cpu.*(?:usage|utili[sz]ation|used)|cpu_usage|cpu_used|usage_seconds_total/.test(normalized) &&
+    /limit|quota|max|capacity|total|cores?|100/.test(normalized)
+  ) {
+    return 'percent'
+  }
+
+  if (
+    /memory.*(?:usage|used|utili[sz]ation)|heap.*used|rss|working_set|used_bytes|usage_bytes/.test(normalized)
+  ) {
+    return 'bytes'
+  }
+
+  if (
+    /disk.*(?:usage|used|utili[sz]ation)|filesystem.*(?:avail|free|size|used)|storage.*(?:used|usage)/.test(normalized)
+  ) {
+    return 'bytes'
+  }
+
+  if (
+    /error_rate|success_rate|failure_rate|biz_error_rate|_ratio\b|_percent\b|percent/.test(normalized) ||
+    /container_cpu_usage_seconds_total/.test(normalized) && /kube_pod_container_resource_limits/.test(normalized) ||
+    /\*\s*100\b/.test(normalized)
+  ) {
+    return 'percent'
+  }
+
+  if (
+    /p99|p95|p90|latency|duration|response_time|cost\b|elapsed|load_time|_ms\b|milliseconds?/.test(normalized) ||
+    /performance_host_interface_p\d+/.test(normalized)
+  ) {
+    return 'ms'
+  }
+
+  if (
+    /_bytes\b|_bytes_total\b|memory|heap|rss|bandwidth|byte\b/.test(normalized)
+  ) {
+    return 'bytes'
+  }
+
+  if (
+    /gc_pause_seconds|gc.*(?:pause|time)|duration_seconds|latency_seconds|response_seconds/.test(normalized)
+  ) {
+    return 's'
+  }
+
+  if (
+    /\bqps\b|\brps\b|reqps|requests?_per_second|interface_qps|host_qps|requests?_total/.test(normalized) && isRateLike
+  ) {
+    return 'reqps'
+  }
+
+  if (
+    /\btps\b|\biops\b|\bops\b|operations?_per_second|ops_total/.test(normalized) && isRateLike
+  ) {
+    return 'ops'
+  }
+
+  if (
+    /cpu:load\d+s|load5s|load1s|load15s|system_load/.test(normalized)
+  ) {
+    return 'short'
+  }
+
+  if (
+    !isRateLike &&
+    /goroutines?|threads?|connections?|conn_count|fd|file_descriptors?|queue(_size|_depth)?|pool(_size)?|inflight|pending|blocked|active_requests|jvm_.*_count|_count\b|_total\b|count_over_time\(/.test(normalized)
+  ) {
+    return 'none'
+  }
+
+  if (
+    /_seconds\b/.test(normalized) && !/rate\(|increase\(|irate\(/.test(normalized)
+  ) {
+    return 's'
+  }
+
+  return undefined
+}
+
+function toGuancePromqlMetricName(token) {
+  if (!token) return token
+  if (token.includes(':')) return token
+  if (!token.includes('_')) return token
+  if (token.startsWith('__')) return token
+  if (PROMQL_RESERVED_WORDS.has(token)) return token
+  const firstUnderscore = token.indexOf('_')
+  if (firstUnderscore <= 0 || firstUnderscore === token.length - 1) return token
+  return `${token.slice(0, firstUnderscore)}:${token.slice(firstUnderscore + 1)}`
+}
+
+function getDatasourceType(datasource) {
+  return String(datasource?.type || datasource || '').toLowerCase()
+}
+
+function isPrometheusLikeDatasource(datasourceType) {
+  return datasourceType.includes('prometheus') || datasourceType.includes('guance-guance-datasource')
+}
+
+function isDqlLikeDatasource(datasourceType) {
+  return (
+    datasourceType.includes('mysql') ||
+    datasourceType.includes('postgres') ||
+    datasourceType.includes('mssql') ||
+    datasourceType.includes('sql') ||
+    datasourceType.includes('loki') ||
+    datasourceType.includes('elasticsearch') ||
+    datasourceType.includes('opensearch') ||
+    datasourceType.includes('cloudwatch') ||
+    datasourceType.includes('influx') ||
+    datasourceType.includes('tempo') ||
+    datasourceType.includes('jaeger') ||
+    datasourceType.includes('zipkin')
+  )
+}
+
+function extractReduceLimit(options) {
+  const limit = options.reduceOptions?.limit
+  return typeof limit === 'number' ? limit : 10
+}
+
+function extractCustomOptions(options) {
+  if (!Array.isArray(options)) return ''
+  return options
+    .filter((item) => item && item.value !== '$__all')
+    .map((item) => item.text || item.value || '')
+    .filter(Boolean)
+    .join(',')
+}
+
+function mapLegendPlacement(value) {
+  if (value === 'bottom') return 'bottom'
+  if (value === 'right') return 'right'
+  if (value === 'left') return 'left'
+  if (value === 'top') return 'top'
+  return 'none'
+}
+
+function mapLegendCalcs(values) {
+  if (!Array.isArray(values)) return []
+  const allowed = new Set(['first', 'last', 'avg', 'min', 'max', 'sum', 'count'])
+  return values
+    .map((value) => String(value).toLowerCase())
+    .filter((value) => allowed.has(value))
+}
+
+function extractLegacyLegendCalcs(legend) {
+  if (!legend || typeof legend !== 'object') return []
+  const calcs = []
+  if (legend.current) calcs.push('last')
+  if (legend.avg) calcs.push('avg')
+  if (legend.min) calcs.push('min')
+  if (legend.max) calcs.push('max')
+  if (legend.total) calcs.push('sum')
+  return calcs
+}
+
+function mapLineInterpolation(value) {
+  if (value === 'smooth') return 'smooth'
+  if (value === 'stepAfter') return 'stepAfter'
+  if (value === 'stepBefore') return 'stepBefore'
+  return 'linear'
+}
+
+function mapStackType(value) {
+  if (value === 'percent') return 'percent'
+  if (value === 'normal') return 'time'
+  return 'time'
+}
+
+function inferShowLine(panel, custom) {
+  if (typeof panel.lines === 'boolean') return panel.lines
+  if (custom.drawStyle === 'bars') return false
+  return true
+}
+
+function inferOpenStack(panel, custom) {
+  if (custom.stacking?.mode) return custom.stacking.mode !== 'none'
+  if (typeof panel.stack === 'boolean') return panel.stack
+  return undefined
+}
+
+function inferSequenceChartType(panel, graphMode) {
+  if (graphMode === 'area') return 'line'
+  if (graphMode === 'none') return undefined
+  return inferDisplayChartType(panel, 'sequence') === 'bar' ? 'bar' : 'line'
+}
+
+function inferGaugeMode(panel, options, legacyGauge) {
+  if (panel.type === 'gauge') return 'gauge'
+  if (legacyGauge.show) return 'gauge'
+  if (options.graphMode === 'none') return 'value'
+  return 'value'
+}
+
+function normalizeConnectNulls(value) {
+  if (typeof value === 'boolean') return value
+  if (typeof value === 'number') return value > 0
+  if (value === 'connected') return true
+  if (value === 'null' || value === 'null as zero') return false
+  return undefined
+}
+
+function mapUnit(unit) {
+  if (!unit) return []
+  const mapped = UNIT_MAP[String(unit).toLowerCase()]
+  if (mapped) return mapped
+  return ['custom', String(unit)]
+}
+
+function buildLegacyValueMappings(valueMaps) {
+  if (!Array.isArray(valueMaps)) return []
+  return valueMaps
+    .filter((item) => item && Object.prototype.hasOwnProperty.call(item, 'value'))
+    .map((item) => ({
+      originalVal: [String(item.value)],
+      operation: normalizeLegacyMappingOperation(item.op),
+      mappingVal: item.text || String(item.value),
+    }))
+}
+
+function buildLegacyRangeMappings(rangeMaps) {
+  if (!Array.isArray(rangeMaps)) return []
+  return rangeMaps.map((item) => ({
+    originalVal: [String(item.from ?? ''), String(item.to ?? '')],
+    operation: 'between',
+    mappingVal: item.text || '',
+  }))
+}
+
+function normalizeLegacyMappingOperation(value) {
+  const allowed = new Set(['>', '>=', '<', '<=', '=', '!=', 'between', '=~', '!=~', 'nodata'])
+  if (allowed.has(value)) return value
+  return '='
+}
+
+function normalizeLegacyFill(value) {
+  if (typeof value !== 'number') return undefined
+  return Math.max(0, Math.min(100, value * 10))
+}
+
+function firstDefinedNumber(...values) {
+  for (const value of values) {
+    if (typeof value === 'number' && Number.isFinite(value)) return value
+  }
+  return undefined
+}
+
+function replaceVariables(input, variableNames = new Set()) {
+  if (typeof input !== 'string') return input
+  return input
+    .replace(/\$\{([^}]+)\}/g, (match, expression) => {
+      const variable = normalizeTemplateVariable(expression)
+      if (!variable) return match
+      if (GRAFANA_BUILTIN_VARS.has(variable)) return match
+      if (!variableNames.has(variable)) return match
+      return `#{${variable}}`
+    })
+    .replace(/(^|[^{])\$([A-Za-z0-9_]+)/g, (match, prefix, variable) => {
+      if (GRAFANA_BUILTIN_VARS.has(variable)) return match
+      if (!variableNames.has(variable)) return match
+      return `${prefix}#{${variable}}`
+    })
+}
+
+function normalizeTemplateVariable(expression) {
+  const trimmed = String(expression).trim()
+  if (!trimmed) return ''
+  const beforeFormat = trimmed.split(':')[0]
+  if (!/^[A-Za-z0-9_.]+$/.test(beforeFormat)) return ''
+  return beforeFormat
+}
+
+function normalizeQueryCode(refId, index) {
+  if (typeof refId === 'string' && refId.trim()) return refId.trim()
+  const codePoint = 65 + index
+  return String.fromCharCode(codePoint)
+}
+
+function stringifyCurrent(value) {
+  if (Array.isArray(value)) return value.join(',')
+  if (typeof value === 'string') return value
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value)
+  return ''
+}
+
+function normalizeAllValue(value, allValue, isValue = false) {
+  if (value === 'All') return allValue === '.*' ? '*' : 'all values'
+  if (value === '$__all') return allValue === '.*' ? '*' : '__all__'
+  if (isValue && value === '.*') return '*'
+  return value
+}
+
+function normalizeColor(color) {
+  if (!color) return '#999999'
+  return String(color)
+}
+
+function numberOr(value, fallback) {
+  return typeof value === 'number' && Number.isFinite(value) ? value : fallback
+}
+
+function numberOrUndefined(value) {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined
+}
+
+function round1(value) {
+  return Number(value.toFixed(1))
+}
+
+function firstDefined(...values) {
+  for (const value of values) {
+    if (value !== undefined && value !== null && value !== '') return value
+  }
+  return undefined
+}
+
+function pruneEmpty(value) {
+  if (Array.isArray(value)) {
+    return value
+      .map((item) => pruneEmpty(item))
+      .filter((item) => item !== undefined)
+  }
+
+  if (!value || typeof value !== 'object') {
+    return value
+  }
+
+  const entries = Object.entries(value)
+    .map(([key, current]) => [key, pruneEmpty(current)])
+    .filter(([, current]) => {
+      if (current === undefined) return false
+      if (Array.isArray(current) && current.length === 0) return false
+      if (current && typeof current === 'object' && !Array.isArray(current) && Object.keys(current).length === 0)
+        return false
+      return true
+    })
+
+  return Object.fromEntries(entries)
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'))
+}
+
+function forEachFile(directoryPath, callback) {
+  for (const entry of fs.readdirSync(directoryPath, { withFileTypes: true })) {
+    const entryPath = path.join(directoryPath, entry.name)
+    if (entry.isDirectory()) {
+      forEachFile(entryPath, callback)
+    } else {
+      callback(entryPath)
+    }
+  }
+}