@redpanda-data/docs-extensions-and-macros 5.51.2 → 5.53.0

package/bin/doc-tools-mcp.js

@@ -221,6 +221,10 @@ const tools = [
           type: 'boolean',
           description: 'Include Bloblang functions and methods in generation (optional, defaults to false)'
         },
+        no_partials: {
+          type: 'boolean',
+          description: 'Skip the generated partials, config snippets, and Bloblang reference because the connect repo publishes them. What\'s new, diffs, drafts, nav, and the version bump still run (optional, defaults to false)'
+        },
         data_dir: {
           type: 'string',
           description: 'Directory where versioned connect JSON files live (optional)'

package/bin/doc-tools.js

@@ -898,6 +898,7 @@ automation
   .option('--template-bloblang <path>', 'Custom Handlebars template for bloblang function/method partials')
   .option('--overrides <path>', 'Optional JSON file with overrides', 'docs-data/overrides.json')
   .option('--include-bloblang', 'Include Bloblang functions and methods in generation')
+  .option('--no-partials', 'Skip the generated partials, config snippets, and Bloblang reference because the connect repo publishes them. What\'s new, diffs, drafts, nav, and the version bump still run')
   .option('--prune-orphaned-descriptions', 'Allow the description-partial orphan sweep to blank more than 10% of the tree. Only use this when the connector dataset is confirmed complete: an incomplete dataset looks identical to a mass upstream deletion and the sweep blanks published content')
   .option('--cloud-version <version>', 'Cloud binary version (default: auto-detect latest)')
   .option('--cgo-version <version>', 'cgo binary version (default: same as cloud-version)')
@@ -2001,6 +2002,124 @@ automation
     }
   })
 
+/**
+ * generate redpanda-release-notes
+ *
+ * @description
+ * Converts a Self-Managed rpchangelog release body into a candidate AsciiDoc
+ * section and inserts it into the Redpanda Release Notes page, newest-first.
+ * Applies the mechanical guards: GA tags only (a prerelease is a no-op), the
+ * `:earliest-tracked-version:` floor, and idempotency (an already-present
+ * version is a no-op). The section carries de-noised source prose as plain
+ * bullets — it is a CANDIDATE for the curation step that rewrites voice, adds
+ * `Area::` labels, normalizes units, and phrases CVEs.
+ *
+ * @why
+ * Release notes are the one reference surface whose source of truth is
+ * engineer-authored prose rather than code, so the deterministic part
+ * (parsing, de-noising, de-duplicating backports, ordering, insertion) is
+ * split from the editorial part. This command is the deterministic half; it is
+ * unit-tested and makes no editorial change.
+ *
+ * @example
+ * # Phase 1: build the candidate the curation skill will edit (no page touched).
+ * # Paths must stay inside the repository; write the fetched body somewhere local.
+ * npx doc-tools generate redpanda-release-notes \
+ *   --tag v26.2.3 --date 2026-09-15 --body docs-data/v26.2.3-body.md --section-only > candidate.adoc
+ *
+ * # (the sm-release-notes skill curates candidate.adoc into curated.adoc)
+ *
+ * # Phase 2: insert the curated section into the page under the guards
+ * npx doc-tools generate redpanda-release-notes \
+ *   --tag v26.2.3 --section-file curated.adoc
+ *
+ * @requirements
+ * - Phase 1 needs --body (+ --date); phase 2 needs --section-file. Fetching the
+ *   body from the private streaming-enterprise release, and running the curation
+ *   skill between the two phases, are wired by the docs-repo workflow, not here.
+ */
+automation
+  .command('redpanda-release-notes')
+  .description('Generate a Self-Managed release-notes section from an rpchangelog release body')
+  .requiredOption('--tag <tag>', 'GA release tag, such as v26.2.3')
+  .option('--body <file>', 'Phase 1: rpchangelog release body markdown to build a candidate from (relative to repo root, must stay inside the repository)')
+  .option('--section-file <file>', 'Phase 2: a curated section (from the sm-release-notes skill) to insert (relative to repo root, must stay inside the repository)')
+  .option('--date <date>', 'Authored release date as YYYY-MM-DD (required with --body; confirmed on the PR)')
+  .option('--page <file>', 'Target release-notes page (relative to repo root, must stay inside the repository)', 'modules/reference/pages/releases/redpanda.adoc')
+  .option('--section-only', 'Phase 1 only: print the candidate section and do not read or modify the page')
+  .option('--dry-run', 'Print output to stdout instead of writing the page')
+  .action(async (options) => {
+    const {
+      generateReleaseNotes,
+      buildReleaseSection,
+      isGaTag,
+    } = require('../tools/redpanda-release-notes/generate-release-notes.js')
+    try {
+      const repoRoot = findRepoRoot()
+
+      // Exactly one input: --body (phase 1, build a candidate) XOR --section-file
+      // (phase 2, insert the curated section). Curation sits between them.
+      const hasBody = Boolean(options.body)
+      const hasSection = Boolean(options.sectionFile)
+      if (hasBody === hasSection) {
+        throw new Error('Provide exactly one of --body (phase 1) or --section-file (phase 2).')
+      }
+      if (hasBody && !options.date) {
+        throw new Error('--date is required with --body.')
+      }
+
+      const readInside = (rel, label) => {
+        const abs = resolveInsideRepo(repoRoot, rel, label)
+        if (!fs.existsSync(abs)) throw new Error(`File not found for ${label}: ${abs}`)
+        return abs
+      }
+
+      // Phase-1 candidate preview: emit the candidate for the curation step. No
+      // page is read or written — this is the LLM step's input, nothing else.
+      if (options.sectionOnly) {
+        if (!hasBody) throw new Error('--section-only applies to --body (candidate generation).')
+        // Same GA-only contract as the insert path: a non-GA tag is a clean
+        // no-op, not an "invalid version" throw from buildReleaseSection.
+        if (!isGaTag(options.tag)) {
+          console.log(`[release-notes] Skipped: not a GA tag: ${options.tag}`)
+          return
+        }
+        const body = fs.readFileSync(readInside(options.body, '--body'), 'utf8')
+        const section = buildReleaseSection({ body, version: options.tag, date: options.date })
+        process.stdout.write(section)
+        return
+      }
+
+      const pagePath = readInside(options.page, '--page')
+      const pageContent = fs.readFileSync(pagePath, 'utf8')
+      const genArgs = { tag: options.tag, date: options.date, pageContent }
+      if (hasBody) {
+        genArgs.body = fs.readFileSync(readInside(options.body, '--body'), 'utf8')
+      } else {
+        genArgs.section = fs.readFileSync(readInside(options.sectionFile, '--section-file'), 'utf8')
+      }
+      const result = generateReleaseNotes(genArgs)
+
+      if (result.status === 'skipped') {
+        // A guard miss is a clean no-op, not an error: the workflow runs this on
+        // every release and most runs have nothing to add.
+        console.log(`[release-notes] Skipped: ${result.reason}`)
+        return
+      }
+
+      if (options.dryRun) {
+        process.stdout.write(result.content)
+        console.log(`\nDone: (dry-run) updated page for ${options.tag} printed to stdout.`)
+      } else {
+        fs.writeFileSync(pagePath, result.content, 'utf8')
+        console.log(`Done: Inserted the ${options.tag} section into ${pagePath}`)
+      }
+    } catch (err) {
+      console.error(`Error: Failed to generate release notes: ${err.message}`)
+      process.exit(1)
+    }
+  })
+
 /**
  * generate crd-spec
  *

package/bin/mcp-tools/rpcn-docs.js

@@ -41,6 +41,7 @@ function generateRpConnectDocs(args = {}) {
     if (args.draft_missing) cmdArgs.push('--draft-missing');
     if (args.update_whats_new) cmdArgs.push('--update-whats-new');
     if (args.include_bloblang) cmdArgs.push('--include-bloblang');
+    if (args.no_partials) cmdArgs.push('--no-partials');
     if (args.skip_cloud_detection) cmdArgs.push('--skip-cloud-detection');
     if (args.skip_binary_analysis) cmdArgs.push('--skip-binary-analysis');
     if (args.skip_cloud_analysis) cmdArgs.push('--skip-cloud-analysis');

package/extensions/REFERENCE.adoc

@@ -404,13 +404,28 @@ You can optionally display pages only if they match the component and version of
 
 == Redpanda Connect tag modifier
 
-This extension updates the playbook to use the latest release tag for the Redpanda Connect documentation. It ensures that the Redpanda Connect documentation is always pulled from the latest release tag available on GitHub.
+This extension sources the Redpanda Connect reference partials (field reference, examples, metadata, descriptions, config snippets, and the Bloblang reference) from the `docs/` directory of the connect repository, at the latest Connect release.
 
-=== Environment variables
+Add the connect repository as a content source next to rp-connect-docs:
 
-- `REDPANDA_GITHUB_TOKEN` (optional): A Personal access token (PAT) that has `repo` permissions for the `redpanda-data` GitHub organization.
+```yaml
+content:
+  sources:
+  - url: https://github.com/redpanda-data/connect
+    tags: latest # replaced with the latest release tag at build time
+    start_path: docs
+```
+
+At build time the extension:
+
+* Pins a source that sets `tags: latest` to the latest Connect release tag and clears its branches (a source with any other refs, such as a PR branch for a preview, is left as configured), so the site never shows fields from unreleased code on connect's `main` branch. It asks the GitHub API for the latest release and falls back to the highest stable `vX.Y.Z` tag from `git ls-remote`. If neither works, the build stops with an error.
+* Keeps only the `modules/components/partials/` and `modules/components/examples/` files of the `connect` component from that source. Any file that another source, such as rp-connect-docs, already provides is skipped, and so is content from older Connect tags that name their component `redpanda-connect`. Antora fails the build on a duplicate page or partial, so you can add the source to a playbook before or after rp-connect-docs stops committing its own generated copies.
+
+A local clone whose directory is named `connect` is filtered the same way but not pinned, so a local playbook can use `branches: HEAD` to test uncommitted changes.
+
+=== Environment variables
 
-NOTE: If you don't set the environment variable, the latest version of Redpanda Connect may not be fetched. When the environment variable is not set, the extension sends unauthenticated requests to GitHub. Unauthenticated requests may result in hitting the API rate limit and cause GitHub to reject the request. In this case the fallback version is used. This version is defined in the playbook where the extension is registered.
+- `REDPANDA_GITHUB_TOKEN` (optional): A GitHub token for the release lookup. Without it, the extension sends unauthenticated API requests, which GitHub can rate limit. The `git ls-remote` fallback needs no token.
 
 === Configuration options
 

package/extensions/generate-rp-connect-categories.js

@@ -1,6 +1,65 @@
 'use strict'
 
 const { raiseListenerLimit } = require('./util/raise-listener-limit')
+const { normalizeType, typeFromRelative } = require('./util/connect-catalog')
+
+// Page :type: values for each data type. Pages use metrics where the data says metric.
+const PAGE_TYPE = { metric: 'metrics' }
+
+/**
+ * Indexes translated catalog rows (from generate-rp-connect-info) by
+ * `name:type`. Names are not unique across types: parquet is a certified input
+ * and a community processor, and sql is a certified cache and a community
+ * output, so a name-only key lets one type's row overwrite another's.
+ */
+function buildRowLookup (rows) {
+  const lookup = new Map()
+  for (const row of rows || []) {
+    const name = String(row.connector || '').trim()
+    const type = normalizeType(row.type)
+    if (name && type) lookup.set(`${name}:${type}`, row)
+  }
+  return lookup
+}
+
+/**
+ * The catalog facts for one connector page, from its data row when there is
+ * one and from the page's own attributes otherwise.
+ * - type: the page's :type:, or the type its directory implies when the data
+ *   has a row for that name and type (drafts no longer write :type:)
+ * - deprecated: the data row's deprecated flag (info.csv deprecated column, or
+ *   catalog.json status), so a hand-kept :status: cannot hide a live component
+ *   or list a deprecated one. Pages without a data row fall back to :status:.
+ * - categories: catalog.json categories when the row has them, else :categories:
+ */
+function resolveComponent ({ name, relative, pageType, pageStatus, pageCategories }, lookup) {
+  const dirType = typeFromRelative(relative)
+  const key = (t) => `${name}:${normalizeType(t)}`
+  let type = pageType || null
+  let row = type ? lookup.get(key(type)) : undefined
+  if (!type && dirType && lookup.has(key(dirType))) {
+    row = lookup.get(key(dirType))
+    type = PAGE_TYPE[dirType] || dirType
+  }
+  if (!type) return null
+  const deprecated = row
+    ? row.deprecated === 'y' || row.status === 'deprecated'
+    : pageStatus === 'deprecated'
+  const categories = row && Array.isArray(row.categories) && row.categories.length
+    ? row.categories.join(', ')
+    : pageCategories
+  return {
+    type,
+    row,
+    deprecated,
+    categories,
+    supportLevel: row ? (row.support_level || 'community').toLowerCase() : null,
+    isEnterprise: row ? row.is_licensed === 'Yes' : false
+  }
+}
+
+module.exports.buildRowLookup = buildRowLookup
+module.exports.resolveComponent = resolveComponent
 
 /**
  * Redpanda Connect Category Aggregation Extension
@@ -38,19 +97,9 @@ module.exports.register = function ({ config }) {
       return
     }
 
-    // Build lookup maps from CSV data
-    const supportLookup = new Map()
-    for (const row of csvData.data) {
-      const connector = row.connector
-      if (connector) {
-        supportLookup.set(connector, {
-          supportLevel: (row.support_level || 'community').toLowerCase(),
-          isEnterprise: row.is_licensed === 'Yes'
-        })
-      }
-    }
+    const rowLookup = buildRowLookup(csvData.data)
 
-    logger.info(`Loaded support data for ${supportLookup.size} connectors from CSV`)
+    logger.info(`Loaded support data for ${rowLookup.size} connectors from CSV`)
 
     const connectCategoriesData = {}
     const flatComponentsData = []
@@ -71,8 +120,6 @@ module.exports.register = function ({ config }) {
         const attrs = file.asciidoc?.attributes || {}
 
         // Get attributes - prefer API, fallback to content parsing
-        const fileType = attrs.type || extractAttribute(file, 'type')
-        const categories = attrs.categories || extractAttribute(file, 'categories')
         const status = attrs.status || extractAttribute(file, 'status')
         const driverSupport = attrs['driver-support'] || extractAttribute(file, 'driver-support')
         const cacheSupport = attrs['cache-support'] || extractAttribute(file, 'cache-support')
@@ -81,23 +128,27 @@ module.exports.register = function ({ config }) {
         const pubUrl = file.pub.url
         const name = file.src.stem
 
-        if (!fileType) continue
-
-        let componentStatus = status || 'community'
+        const resolved = resolveComponent({
+          name,
+          relative: file.src.relative,
+          pageType: attrs.type || extractAttribute(file, 'type'),
+          pageStatus: status,
+          pageCategories: attrs.categories || extractAttribute(file, 'categories')
+        }, rowLookup)
+        if (!resolved) continue
+        const { type: fileType, categories, isEnterprise } = resolved
 
         // Skip deprecated components
-        if (componentStatus === 'deprecated') continue
+        if (resolved.deprecated) continue
 
-        // Get support level from CSV data
-        const csvInfo = supportLookup.get(name)
-        const isEnterprise = csvInfo?.isEnterprise || false
+        let componentStatus = status || 'community'
 
-        // Determine status from CSV support level (CSV takes precedence)
-        if (csvInfo) {
-          if (csvInfo.supportLevel === 'certified' || csvInfo.supportLevel === 'enterprise') {
+        // Determine status from the data row's support level (data takes precedence)
+        if (resolved.supportLevel) {
+          if (resolved.supportLevel === 'certified' || resolved.supportLevel === 'enterprise') {
             componentStatus = 'certified'
           } else {
-            componentStatus = csvInfo.supportLevel
+            componentStatus = resolved.supportLevel
           }
         }
 

package/extensions/generate-rp-connect-info.js

@@ -4,6 +4,7 @@ const { raiseListenerLimit } = require('./util/raise-listener-limit')
 const fs = require('fs')
 const path = require('path')
 const Papa = require('papaparse')
+const catalogUtil = require('./util/connect-catalog')
 
 // Default configuration - can be overridden via playbook config
 const DEFAULTS = {
@@ -12,6 +13,31 @@ const DEFAULTS = {
   githubRepo: 'connect'
 }
 
+// Connector pages include the generated field reference from the connect repo
+// (see the modify-connect-tag-playbook extension). If a playbook has the
+// Connect pages but none of those partials, every connector page would publish
+// without its fields, and Antora only logs the missing includes. Fail the
+// build instead so the playbook gets fixed before anything is published.
+function assertConnectReferencePresent (contentCatalog) {
+  const component = contentCatalog.getComponents().find((c) => c.name === 'connect')
+  if (!component) return
+  // Only connector pages (inputs/kafka.adoc and so on) include field
+  // partials. Overview pages at the module root don't.
+  const pages = contentCatalog.findBy({ component: 'connect', module: 'components', family: 'page' })
+    .filter((p) => p.src.relative.includes('/'))
+  if (!pages.length) return
+  const fields = contentCatalog.findBy({ component: 'connect', module: 'components', family: 'partial' })
+    .filter((f) => f.src.relative.startsWith('fields/'))
+  if (fields.length) return
+  throw new Error(
+    'The connect component has connector pages but no generated field partials (components:partial$fields/*). ' +
+    'Add the connect repository as a content source (url: https://github.com/redpanda-data/connect, tags: latest, start_path: docs) ' +
+    'and register the modify-connect-tag-playbook extension, or check that the latest Connect release includes docs/modules/components.'
+  )
+}
+
+module.exports.assertConnectReferencePresent = assertConnectReferencePresent
+
 module.exports.register = function ({ config }) {
   raiseListenerLimit(this)
   const logger = this.getLogger('redpanda-connect-info-extension')
@@ -38,6 +64,7 @@ module.exports.register = function ({ config }) {
 
   // Use 'on' and return the promise so Antora waits for async completion
   this.on('contentClassified', ({ contentCatalog }) => {
+    assertConnectReferencePresent(contentCatalog)
     return processContent(contentCatalog)
   })
 
@@ -65,12 +92,8 @@ module.exports.register = function ({ config }) {
     const pages = contentCatalog.getPages()
 
     try {
-      // Get the Connect version from antora.yml
-      const connectVersion = getAntoraValue('asciidoc.attributes.latest-connect-version')
-
-      // Fetch CSV data (from local file first, then GitHub as fallback)
-      const csvData = await fetchCSV(localCsvPath, connectVersion, logger)
-      const parsedData = Papa.parse(csvData, { header: true, skipEmptyLines: true })
+      const rawRows = await loadCatalogRows(contentCatalog)
+      const parsedData = { data: rawRows }
       const enrichedData = translateCsvData(parsedData, pages, logger)
       parsedData.data = enrichedData
       translatedRows = enrichedData
@@ -107,8 +130,46 @@ module.exports.register = function ({ config }) {
     }
   }
 
+  // Raw catalog rows (info.csv column names) for this build.
+  //
+  // The generated partials/platforms/catalog.json from the connect content
+  // source comes first: it is pinned to the same ref as the reference content
+  // and carries status, categories, and cgo data that info.csv lacks. info.csv
+  // still supplies the SQL driver rows, which are not components and so are
+  // not in the catalog. Without catalog.json, info.csv supplies every row.
+  async function loadCatalogRows (contentCatalog) {
+    const catalogFile = catalogUtil.findConnectCatalogFile(contentCatalog)
+    let catalogRows = null
+    if (catalogFile) {
+      try {
+        catalogRows = catalogUtil.catalogEntriesToCsvRows(JSON.parse(catalogFile.contents.toString('utf8')))
+        logger.info(`Loaded ${catalogRows.length} components from ${describeFile(catalogFile)}`)
+      } catch (error) {
+        logger.warn(`Could not read ${describeFile(catalogFile)}, so falling back to info.csv: ${error.message}`)
+      }
+    }
+
+    let csvRows = []
+    try {
+      const csvText = await fetchCSV(localCsvPath, contentCatalog)
+      csvRows = Papa.parse(csvText, { header: true, skipEmptyLines: true }).data
+    } catch (error) {
+      if (!catalogRows) throw error
+      logger.warn(`Could not fetch info.csv for the SQL driver rows, so the SQL driver support list is empty: ${error.message}`)
+    }
+    if (!catalogRows) return csvRows
+    const isDriver = (row) => String(row.type || '').trim().toLowerCase() === 'sql_driver'
+    return [...catalogRows, ...csvRows.filter(isDriver)]
+  }
+
+  function describeFile (file) {
+    const origin = file.src.origin || {}
+    const ref = origin.tag || origin.branch || origin.refname
+    return `${file.src.component}:${file.src.module}:partial$${file.src.relative}${ref ? ` (${ref})` : ''}`
+  }
+
   // Fetch CSV from GitHub or local file (local file for testing/override only)
-  async function fetchCSV (localPath, connectVersion, logger) {
+  async function fetchCSV (localPath, contentCatalog) {
     // Priority 1: Use explicitly provided CSV path (for testing/override)
     if (localPath && fs.existsSync(localPath)) {
       if (path.extname(localPath).toLowerCase() !== '.csv') {
@@ -118,29 +179,50 @@ module.exports.register = function ({ config }) {
       return fs.readFileSync(localPath, 'utf8')
     }
 
-    // Priority 2: Fetch from GitHub using the version tag
-    logger.info(`Fetching CSV from GitHub (version: ${connectVersion || 'main'})...`)
-    return fetchCsvFromGitHub(connectVersion)
+    // Priority 2: Fetch from GitHub at the connect ref of this build
+    const target = resolveCsvRef(contentCatalog)
+    logger.info(`Fetching ${csvPath} from ${target.owner}/${target.repo} at ${target.ref} (${target.source})`)
+    return fetchCsvFromGitHub(target)
+  }
+
+  // The ref to read info.csv from, in order:
+  // 1. the tag modify-connect-tag-playbook resolved for the connect content source
+  // 2. the ref of the connect content source in the content catalog
+  // 3. latest-connect-version in antora.yml in the working directory
+  // 4. main, with a warning, because the catalog can then disagree with the
+  //    reference content
+  function resolveCsvRef (contentCatalog) {
+    const base = { owner: githubOwner, repo: githubRepo }
+    const shared = catalogUtil.getResolvedConnectRef()
+    if (shared) return { ...base, ref: shared, source: 'the tag modify-connect-tag-playbook resolved' }
+    const origin = catalogUtil.connectOriginRef(contentCatalog)
+    if (origin && origin.ref) return { ...base, ...origin, source: 'the connect content source' }
+    const connectVersion = getAntoraValue('asciidoc.attributes.latest-connect-version')
+    const normalizedVersion = connectVersion ? String(connectVersion).trim().replace(/^v/, '') : ''
+    if (normalizedVersion) return { ...base, ref: `v${normalizedVersion}`, source: 'latest-connect-version in antora.yml' }
+    logger.warn(
+      'No connect content source or latest-connect-version found, so info.csv is read from connect main. ' +
+      'Catalog badges can then disagree with the reference content. Add the connect content source and the ' +
+      'modify-connect-tag-playbook extension to the playbook.'
+    )
+    return { ...base, ref: 'main', source: 'fallback' }
   }
 
   // Fetch CSV data from GitHub
-  async function fetchCsvFromGitHub (connectVersion) {
+  async function fetchCsvFromGitHub ({ owner, repo, ref }) {
     const octokit = await loadOctokit()
-    // Normalize version: trim whitespace and remove leading 'v' if present
-    const normalizedVersion = connectVersion ? connectVersion.trim().replace(/^v/, '') : ''
-    // Use version tag if valid, otherwise fallback to main branch
-    const ref = normalizedVersion ? `v${normalizedVersion}` : 'main'
-
     try {
       const { data: fileContent } = await octokit.rest.repos.getContent({
-        owner: githubOwner,
-        repo: githubRepo,
+        owner,
+        repo,
         path: csvPath,
-        ref: ref
+        ref
       })
       return Buffer.from(fileContent.content, 'base64').toString('utf8')
     } catch (error) {
-      logger.error(`Error fetching Redpanda Connect catalog from GitHub (ref: ${ref}): ${error.message}`)
+      // The caller decides how loud this is: fatal to the catalog without
+      // catalog.json, a warning with it.
+      error.message = `${owner}/${repo} ${csvPath} at ${ref}: ${error.message}`
       throw error
     }
   }
@@ -206,8 +288,9 @@ module.exports.register = function ({ config }) {
 
     return parsedData.data.map(row => {
       // Create a new object with trimmed keys and values
+      // Rows from catalog.json also carry arrays (categories, commercial_names)
       const trimmedRow = Object.fromEntries(
-        Object.entries(row).map(([key, value]) => [key.trim(), (value || '').trim()])
+        Object.entries(row).map(([key, value]) => [key.trim(), typeof value === 'string' || value == null ? (value || '').trim() : value])
       )
 
       // Map fields from the trimmed row to the desired output
@@ -216,8 +299,13 @@ module.exports.register = function ({ config }) {
       const commercialName = trimmedRow.commercial_name
       const availableConnectVersion = trimmedRow.version
       const deprecated = (trimmedRow.deprecated || '').toLowerCase() === 'y' ? 'y' : 'n'
+      // is_cloud_supported is the standard Cloud pipeline flag and cloud_ai the
+      // GPU pipeline flag. A component in either one is available in Cloud
+      // (catalogUtil.isCloudAvailable); gpu_only and no_gpu say which.
       const isCloudSupported = (trimmedRow.cloud || '').toLowerCase() === 'y' ? 'y' : 'n'
       const cloudAi = (trimmedRow.cloud_with_gpu || '').toLowerCase() === 'y' ? 'y' : 'n'
+      const cloudAvailable = isCloudSupported === 'y' || cloudAi === 'y'
+      const { gpu_only: gpuOnly, no_gpu: noGpu } = catalogUtil.gpuFlags(isCloudSupported, cloudAi)
 
       // Handle enterprise to certified conversion and set enterprise license flag
       const originalSupport = (trimmedRow.support || '').toLowerCase()
@@ -239,13 +327,13 @@ module.exports.register = function ({ config }) {
         // - Only run in Redpanda Cloud (not in self-managed rpk connect)
         // - Have docs in cloud-docs repo but not in rp-connect-docs pages
         // - Are marked with cloud: y in CSV but don't ship with OSS binary
-        const isCloudOnly = isCloudSupported === 'y' && !redpandaConnectUrl && redpandaCloudUrl
+        const isCloudOnly = cloudAvailable && !redpandaConnectUrl && redpandaCloudUrl
 
         // Only warn about missing self-managed docs if it's NOT cloud-only
         if (!redpandaConnectUrl && !isCloudOnly) {
           logger.warn(`Self-Managed docs missing for: ${connector} of type: ${type}`)
         }
-        if (isCloudSupported === 'y' && !redpandaCloudUrl && redpandaConnectUrl) {
+        if (cloudAvailable && !redpandaCloudUrl && redpandaConnectUrl) {
           logger.warn(`Cloud docs missing for: ${connector} of type: ${type}`)
         }
       }
@@ -259,7 +347,14 @@ module.exports.register = function ({ config }) {
         deprecated,
         is_cloud_supported: isCloudSupported,
         cloud_ai: cloudAi,
+        gpu_only: gpuOnly,
+        no_gpu: noGpu,
         is_licensed: isLicensed,
+        // From catalog.json only; empty or absent for info.csv rows
+        status: trimmedRow.status || (deprecated === 'y' ? 'deprecated' : ''),
+        categories: Array.isArray(trimmedRow.categories) ? trimmedRow.categories : undefined,
+        commercial_names: Array.isArray(trimmedRow.commercial_names) ? trimmedRow.commercial_names : undefined,
+        cgo_only: trimmedRow.cgo_only === 'y' ? 'y' : 'n',
         redpandaConnectUrl,
         redpandaCloudUrl
       }
@@ -274,20 +369,23 @@ module.exports.register = function ({ config }) {
     const csvCommercialNames = new Map()
 
     for (const row of parsedData.data) {
-      const { connector, commercial_name: commercialName } = row
-      if (!connector || !commercialName) continue
-
-      // Skip N/A and empty values
-      const trimmedName = commercialName.trim()
-      if (trimmedName.toLowerCase() === 'n/a' || trimmedName === '') continue
-
-      if (!csvCommercialNames.has(connector)) {
-        csvCommercialNames.set(connector, new Set())
-      }
+      const { connector, commercial_name: commercialName, commercial_names: commercialNames } = row
+      if (!connector) continue
+      // catalog.json rows list every commercial name; info.csv rows have one
+      const names = Array.isArray(commercialNames) && commercialNames.length ? commercialNames : [commercialName]
+      for (const name of names) {
+        // Skip N/A and empty values
+        const trimmedName = String(name || '').trim()
+        if (trimmedName.toLowerCase() === 'n/a' || trimmedName === '') continue
+
+        if (!csvCommercialNames.has(connector)) {
+          csvCommercialNames.set(connector, new Set())
+        }
 
-      // Add the commercial name if it's different from the connector name
-      if (trimmedName.toLowerCase() !== connector.toLowerCase()) {
-        csvCommercialNames.get(connector).add(trimmedName)
+        // Add the commercial name if it's different from the connector name
+        if (trimmedName.toLowerCase() !== connector.toLowerCase()) {
+          csvCommercialNames.get(connector).add(trimmedName)
+        }
       }
     }
 
@@ -370,7 +468,13 @@ module.exports.register = function ({ config }) {
    * - page-cloud-available + page-cloud-available-url: on Self-Managed pages with a Cloud variant
    * - page-self-managed-available + page-self-managed-available-url: on Cloud pages with a
    *   Self-Managed variant
-   * - page-self-managed-only: on Self-Managed pages with no Cloud variant
+   * - page-self-managed-only: on Self-Managed pages whose type is not available in Cloud
+   * - page-cloud-gpu-only: on both variants when the type runs only in Cloud GPU pipelines
+   * - page-cloud-no-gpu: on both variants when the type runs in Cloud, but not in GPU pipelines
+   *
+   * Availability is decided per row (name and type), not per connector: the http_server
+   * input runs in Cloud and the http_server output does not. Only the Type dropdown is
+   * built from all of the connector's rows.
    */
   function setStickyBarPageAttributes (contentCatalog, rows, logger) {
     const pagesByUrl = new Map()
@@ -388,9 +492,13 @@ module.exports.register = function ({ config }) {
     }
 
     let decoratedCount = 0
+    const setGpuFlags = (attrs, row) => {
+      if (row.gpu_only === 'y') attrs['page-cloud-gpu-only'] = 'true'
+      if (row.no_gpu === 'y') attrs['page-cloud-no-gpu'] = 'true'
+    }
     for (const connectorRows of rowsByConnector.values()) {
-      const isCloudSupported = connectorRows.some((row) => row.is_cloud_supported === 'y')
       for (const row of connectorRows) {
+        const isCloudAvailable = catalogUtil.isCloudAvailable(row)
         // Self-Managed (Connect) variant of this connector page
         const connectPage = row.redpandaConnectUrl && pagesByUrl.get(row.redpandaConnectUrl)
         if (connectPage) {
@@ -398,10 +506,11 @@ module.exports.register = function ({ config }) {
           if (connectorRows.length > 1) {
             attrs['page-context-switcher'] = buildContextSwitcher(connectorRows, row, 'connect')
           }
-          if (isCloudSupported && row.redpandaCloudUrl) {
+          if (isCloudAvailable && row.redpandaCloudUrl) {
             attrs['page-cloud-available'] = 'true'
             attrs['page-cloud-available-url'] = row.redpandaCloudUrl
-          } else if (!isCloudSupported) {
+            setGpuFlags(attrs, row)
+          } else if (!isCloudAvailable) {
             attrs['page-self-managed-only'] = 'true'
           }
           decoratedCount++
@@ -417,6 +526,7 @@ module.exports.register = function ({ config }) {
             attrs['page-self-managed-available'] = 'true'
             attrs['page-self-managed-available-url'] = row.redpandaConnectUrl
           }
+          setGpuFlags(attrs, row)
           decoratedCount++
         }
       }