@redpanda-data/docs-extensions-and-macros 4.15.1 → 4.15.3

package/extensions/convert-sitemap-to-markdown.js

@@ -0,0 +1,274 @@
+/**
+ * Antora extension that generates markdown versions of sitemap.xml files.
+ *
+ * For each sitemap.xml in the published site, creates a corresponding sitemap.md
+ * with a human-readable and AI-friendly markdown format.
+ *
+ * Usage in playbook:
+ * ```yaml
+ * antora:
+ *   extensions:
+ *   - require: '@redpanda-data/docs-extensions-and-macros/extensions/convert-sitemap-to-markdown'
+ * ```
+ */
+
+const path = require('path')
+const { parseStringPromise } = require('xml2js')
+
+module.exports.register = function ({ config }) {
+  const logger = this.getLogger('convert-sitemap-to-markdown')
+
+  this
+    .on('beforePublish', async ({ playbook, siteCatalog }) => {
+      const startTime = Date.now()
+
+      logger.info('Sitemap to markdown converter starting...')
+
+      try {
+        // Find all sitemap files in the site catalog
+        const sitemapFiles = siteCatalog.getFiles().filter(file =>
+          /^sitemap(-[^/]+)?\.xml$/.test(path.basename(file.out.path))
+        )
+
+        if (sitemapFiles.length === 0) {
+          logger.info('No sitemap files found in site catalog')
+          return
+        }
+
+        logger.info(`Found ${sitemapFiles.length} sitemap file(s)`)
+
+        // Convert each sitemap and collect all URLs
+        const allUrls = []
+        for (const sitemapFile of sitemapFiles) {
+          const urls = await convertSitemapToMarkdown(sitemapFile, siteCatalog, logger)
+          if (urls) {
+            allUrls.push(...urls)
+          }
+        }
+
+        // Create combined master sitemap if we have multiple sitemaps
+        if (sitemapFiles.length > 1 && allUrls.length > 0) {
+          await createMasterSitemap(sitemapFiles, allUrls, siteCatalog, logger)
+        }
+
+        const duration = ((Date.now() - startTime) / 1000).toFixed(2)
+        logger.info(`Generated ${sitemapFiles.length} sitemap markdown file(s) in ${duration}s`)
+      } catch (error) {
+        logger.error(`Failed to generate sitemap markdown: ${error.message}`)
+        throw error
+      }
+    })
+}
+
+/**
+ * Create a master combined sitemap from all individual sitemaps
+ */
+async function createMasterSitemap(sitemapFiles, allUrls, siteCatalog, logger) {
+  const sitemapCount = sitemapFiles.length
+  const sitemapWord = sitemapCount === 1 ? 'sitemap' : 'sitemaps'
+
+  let markdown = '# Complete documentation sitemap\n\n'
+  markdown += `> Combined view of all ${allUrls.length.toLocaleString()} documentation pages from ${sitemapCount} ${sitemapWord}\n\n`
+
+  // Add overview of source sitemaps
+  markdown += '## Source sitemaps\n\n'
+  for (const sitemapFile of sitemapFiles) {
+    const basename = path.basename(sitemapFile.out.path)
+    const mdName = basename.replace(/\.xml$/, '.md')
+    markdown += `- [${basename}](${mdName})\n`
+  }
+  markdown += '\n'
+
+  // Add all URLs grouped by component
+  if (allUrls.length > 0) {
+    markdown += convertUrlsetToMarkdown(allUrls)
+  }
+
+  // Add to site catalog
+  siteCatalog.addFile({
+    contents: Buffer.from(markdown, 'utf8'),
+    out: { path: 'sitemap-all.md' },
+  })
+
+  logger.info(`Generated master sitemap: sitemap-all.md (${allUrls.length} pages)`)
+}
+
+/**
+ * Convert a sitemap file to markdown
+ * Returns the URLs found in this sitemap for aggregation
+ */
+async function convertSitemapToMarkdown(sitemapFile, siteCatalog, logger) {
+  const xmlContent = sitemapFile.contents.toString('utf8')
+  const basename = path.basename(sitemapFile.out.path)
+  const outputPath = basename.replace(/\.xml$/, '.md')
+
+  try {
+    const parsed = await parseStringPromise(xmlContent)
+
+    let markdown = '# Sitemap\n\n'
+    markdown += `> Documentation sitemap generated from ${basename}\n\n`
+
+    let urls = []
+
+    // Handle standard sitemap
+    if (parsed.urlset && parsed.urlset.url) {
+      urls = parsed.urlset.url
+      markdown += convertUrlsetToMarkdown(urls)
+    }
+
+    // Handle sitemap index
+    if (parsed.sitemapindex && parsed.sitemapindex.sitemap) {
+      markdown += convertSitemapIndexToMarkdown(parsed.sitemapindex.sitemap)
+    }
+
+    // Add to site catalog
+    siteCatalog.addFile({
+      contents: Buffer.from(markdown, 'utf8'),
+      out: { path: outputPath },
+    })
+
+    logger.debug(`Generated ${outputPath}`)
+
+    return urls
+  } catch (error) {
+    logger.warn(`Failed to parse ${basename}: ${error.message}`)
+    return []
+  }
+}
+
+/**
+ * Convert URL entries to markdown
+ */
+function convertUrlsetToMarkdown(urls) {
+  let markdown = '## Pages\n\n'
+  markdown += `Total pages: ${urls.length.toLocaleString()}\n\n`
+
+  // Group URLs by component/path
+  const groups = groupUrlsByPath(urls)
+
+  for (const [groupName, groupUrls] of Object.entries(groups)) {
+    markdown += `### ${groupName}\n\n`
+
+    for (const url of groupUrls) {
+      const loc = url.loc ? url.loc[0] : ''
+      const lastmod = url.lastmod ? url.lastmod[0] : ''
+      const changefreq = url.changefreq ? url.changefreq[0] : ''
+      const priority = url.priority ? url.priority[0] : ''
+
+      if (loc) {
+        markdown += `- [${extractPageTitle(loc)}](${loc})`
+
+        const metadata = []
+        if (lastmod) metadata.push(`modified: ${lastmod}`)
+        if (changefreq) metadata.push(`frequency: ${changefreq}`)
+        if (priority) metadata.push(`priority: ${priority}`)
+
+        if (metadata.length > 0) {
+          markdown += ` (${metadata.join(', ')})`
+        }
+
+        markdown += '\n'
+      }
+    }
+
+    markdown += '\n'
+  }
+
+  return markdown
+}
+
+/**
+ * Convert sitemap index to markdown
+ */
+function convertSitemapIndexToMarkdown(sitemaps) {
+  const count = sitemaps.length
+  const sitemapWord = count === 1 ? 'sub-sitemap' : 'sub-sitemaps'
+
+  let markdown = '## Sitemap index\n\n'
+  markdown += `This sitemap index contains ${count} ${sitemapWord}:\n\n`
+
+  for (const sitemap of sitemaps) {
+    const loc = sitemap.loc ? sitemap.loc[0] : ''
+    const lastmod = sitemap.lastmod ? sitemap.lastmod[0] : ''
+
+    if (loc) {
+      // Convert .xml URL to .md for markdown version
+      const mdUrl = loc.replace(/\.xml$/, '.md')
+      const basename = path.basename(loc)
+
+      markdown += `- [${basename}](${mdUrl})`
+      if (lastmod) {
+        markdown += ` (modified: ${lastmod})`
+      }
+      markdown += '\n'
+    }
+  }
+
+  markdown += '\n'
+  return markdown
+}
+
+/**
+ * Group URLs by their path prefix for better organization
+ */
+function groupUrlsByPath(urls) {
+  const groups = {}
+
+  for (const url of urls) {
+    const loc = url.loc ? url.loc[0] : ''
+    if (!loc) continue
+
+    // Extract component from URL path
+    const urlPath = new URL(loc).pathname
+    const parts = urlPath.split('/').filter(p => p)
+
+    let groupName = 'Root'
+    if (parts.length > 0) {
+      // Use first meaningful path segment as group
+      groupName = parts[0]
+
+      // Capitalize and format
+      groupName = groupName
+        .split('-')
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ')
+    }
+
+    if (!groups[groupName]) {
+      groups[groupName] = []
+    }
+    groups[groupName].push(url)
+  }
+
+  // Sort groups alphabetically
+  const sortedGroups = {}
+  Object.keys(groups).sort().forEach(key => {
+    sortedGroups[key] = groups[key]
+  })
+
+  return sortedGroups
+}
+
+/**
+ * Extract a readable page title from URL
+ */
+function extractPageTitle(url) {
+  const urlPath = new URL(url).pathname
+  const parts = urlPath.split('/').filter(p => p)
+
+  if (parts.length === 0) return 'Home'
+
+  // Get the last meaningful part
+  let title = parts[parts.length - 1]
+
+  // Remove .html extension
+  title = title.replace(/\.html$/, '')
+
+  // Convert dashes to spaces and capitalize
+  title = title
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ')
+
+  return title
+}

package/extensions/convert-to-markdown.js

@@ -1,9 +1,174 @@
 const path = require('path')
 const os = require('os')
+const yaml = require('js-yaml')
+const { toMarkdownUrl } = require('../extension-utils/url-utils')
 const TurndownService = require('turndown')
 const turndownPluginGfm = require('turndown-plugin-gfm')
 const { gfm } = turndownPluginGfm
 
+/**
+ * Decode HTML entities in a string
+ * @param {string} str - String with potential HTML entities
+ * @returns {string} Decoded string
+ */
+function decodeHtmlEntities (str) {
+  if (!str || typeof str !== 'string') return str
+  return str
+    .replace(/&#(\d+);/g, (_, dec) => String.fromCharCode(dec))
+    .replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
+    .replace(/"/g, '"')
+    .replace(/&/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&apos;/g, "'")
+}
+
+/**
+ * Converts AsciiDoc page attributes to YAML frontmatter
+ * @param {Object} page - The page object with asciidoc attributes
+ * @returns {string} YAML frontmatter string or empty string if no attributes
+ */
+function generateFrontmatter(page) {
+  const frontmatter = {}
+
+  // Add title (decode HTML entities from AsciiDoc processing)
+  if (page.asciidoc?.doctitle) {
+    frontmatter.title = decodeHtmlEntities(page.asciidoc.doctitle)
+  }
+
+  // Add navigation title if different from doctitle
+  if (page.asciidoc?.navtitle && page.asciidoc.navtitle !== page.asciidoc?.doctitle) {
+    frontmatter.navtitle = decodeHtmlEntities(page.asciidoc.navtitle)
+  }
+
+  // Get all page attributes
+  const attrs = page.asciidoc?.attributes || {}
+
+  // Allowlist of attributes to include in frontmatter
+  // Explicitly opt-in to attributes that are useful for AI consumption
+  const allowedAttributes = [
+    'title',
+    'navtitle',
+    'description',
+    'categories',
+    'page-component-name',
+    'page-component-title',
+    'page-component-version',
+    'page-version',
+    'page-relative-src-path',
+    'page-edit-url',
+    'page-topic-type',
+    'personas',
+    'docname',
+    'page-beta',
+    'page-beta-text',
+    'page-is-nearing-eol',
+    'page-is-past-eol',
+    'page-eol-date',
+    'page-git-created-date',
+    'page-git-modified-date',
+    // Component-specific version attributes (from antora.yml)
+    'latest-redpanda-tag', // Redpanda docker tag (e.g., v25.3.5)
+    'latest-console-tag',
+    'latest-operator-version',
+    'latest-connect-version',
+  ]
+
+  // Add allowed page attributes to frontmatter
+  Object.keys(attrs).forEach(key => {
+    const value = attrs[key]
+
+    // Allow all learning-objective-* attributes (learning-objective-1, -2, -3, etc.)
+    const isLearningObjective = key.startsWith('learning-objective-')
+
+    // Only include attributes in our allowlist or learning objectives
+    if (!allowedAttributes.includes(key) && !isLearningObjective) return
+
+    // Only include page-beta-text if page-beta is true
+    if (key === 'page-beta-text' && !attrs['page-beta']) {
+      return
+    }
+
+    // Skip empty attributes (AsciiDoc boolean flags)
+    if (value === '') {
+      // Special handling for version fields - use actual version from page source
+      if (key === 'page-version') {
+        frontmatter[key] = page.src?.version || 'master'
+        return
+      }
+      if (key === 'page-component-version') {
+        frontmatter[key] = page.src?.version || 'master'
+        return
+      }
+      // Preserve important boolean flags
+      if (key.startsWith('page-')) {
+        frontmatter[key] = true
+      }
+      return
+    }
+
+    // Include the attribute
+    frontmatter[key] = value
+  })
+
+  // Transform EOL fields to be more user-friendly
+  if (frontmatter['page-is-nearing-eol'] || frontmatter['page-is-past-eol']) {
+    let eolStatus = 'supported'
+    if (frontmatter['page-is-past-eol'] === 'true' || frontmatter['page-is-past-eol'] === true) {
+      eolStatus = 'past end-of-life'
+    } else if (frontmatter['page-is-nearing-eol'] === 'true' || frontmatter['page-is-nearing-eol'] === true) {
+      eolStatus = 'nearing end-of-life'
+    }
+    frontmatter['support-status'] = eolStatus
+    // Keep original fields for compatibility
+  }
+
+  // Transform beta fields to be more user-friendly
+  if (frontmatter['page-beta'] === 'true' || frontmatter['page-beta'] === true) {
+    let betaStatus = 'beta'
+    if (frontmatter['page-beta-text']) {
+      betaStatus = `beta - ${frontmatter['page-beta-text']}`
+    }
+    frontmatter['release-status'] = betaStatus
+  }
+
+  // Return empty string if no frontmatter
+  if (Object.keys(frontmatter).length === 0) return ''
+
+  // Convert to YAML format using js-yaml library for proper escaping
+  let yamlContent = yaml.dump(frontmatter, {
+    lineWidth: -1, // Disable line wrapping
+    noRefs: true, // Disable anchors/aliases
+    quotingType: '"', // Use double quotes
+    forceQuotes: false, // Only quote when necessary
+  })
+
+  // Add helpful comments for EOL (end-of-life) fields
+  // Find the first EOL-related field and add comment before it
+  if (frontmatter['page-is-nearing-eol'] || frontmatter['page-is-past-eol'] || frontmatter['support-status']) {
+    const eolFieldRegex = /^(page-is-nearing-eol:|page-is-past-eol:|support-status:)/m
+    if (!yamlContent.includes('# EOL =')) {
+      yamlContent = yamlContent.replace(
+        eolFieldRegex,
+        '# EOL = End-of-Life (support lifecycle status)\n$1'
+      )
+    }
+  }
+
+  // Add helpful comments for beta fields
+  if (frontmatter['page-beta'] || frontmatter['release-status']) {
+    const betaFieldRegex = /^(page-beta:|release-status:)/m
+    if (!yamlContent.includes('# Beta release')) {
+      yamlContent = yamlContent.replace(
+        betaFieldRegex,
+        '# Beta release status\n$1'
+      )
+    }
+  }
+
+  return `---\n${yamlContent}---\n\n`
+}
+
 module.exports.register = function () {
   const logger = this.getLogger('convert-to-markdown-extension')
   let playbook
@@ -308,22 +473,9 @@ module.exports.register = function () {
           let canonicalUrl = ''
           try {
             if (siteUrl && page.pub?.url) {
-              const htmlStyle = playbook?.urls?.htmlExtensionStyle
-              const isIndexify = htmlStyle === 'indexify'
               const baseUrl = new URL(page.pub.url, siteUrl)
-              let pathname = baseUrl.pathname
-
-              if (isIndexify) {
-                const looksLikeDir =
-                  pathname.endsWith('/') ||
-                  !path.basename(pathname).includes('.')
-                baseUrl.pathname = looksLikeDir
-                  ? pathname.replace(/\/?$/, '/index.md')
-                  : pathname.replace(/\.html$/, '.md')
-              } else {
-                baseUrl.pathname = pathname.replace(/\.html$/, '.md')
-              }
-
+              // Convert HTML URL to markdown URL using shared utility
+              baseUrl.pathname = toMarkdownUrl(baseUrl.pathname)
               canonicalUrl = baseUrl.toString()
             }
           } catch (e) {
@@ -332,11 +484,23 @@ module.exports.register = function () {
             )
           }
 
-          // Prepend Markdown source reference and URL construction hint
+          // Generate YAML frontmatter from AsciiDoc attributes
+          const frontmatter = generateFrontmatter(page)
+          if (frontmatter) {
+            logger.debug(`Generated frontmatter for ${page.src?.path}`)
+          }
+
+          // Prepend frontmatter first, then source reference and AI-friendly note
           if (canonicalUrl) {
-            const urlHint = `<!-- Note for AI: Links in this doc are relative to the current page and use indexify format. Add /index.md to directory-style links for the Markdown version. -->`
-            
-            markdown = `<!-- Source: ${canonicalUrl} -->\n${urlHint}\n\n${markdown}`
+            const componentName = page.src?.component || '';
+            const urlHint = componentName
+              ? `<!-- Note for AI: This is a Markdown export. For aggregated content, see /llms.txt (curated overview), /${componentName}-full.txt (this component only), or /llms-full.txt (complete documentation). -->`
+              : `<!-- Note for AI: This is a Markdown export. For aggregated content, see /llms.txt (curated overview) or /llms-full.txt (complete documentation). -->`;
+
+            markdown = `${frontmatter}<!-- Source: ${canonicalUrl} -->\n${urlHint}\n\n${markdown}`
+          } else if (frontmatter) {
+            // If no canonical URL but we have frontmatter, still add it
+            markdown = `${frontmatter}${markdown}`
           }
 
           // Clean up unnecessary whitespace
@@ -378,7 +542,10 @@ module.exports.register = function () {
     for (const page of pages) {
       const htmlOut = page.out?.path
       if (!htmlOut) continue
-      const mdOutPath = htmlOut.replace(/\.html$/, '.md')
+
+      // Convert HTML path to markdown path using shared utility
+      const mdOutPath = toMarkdownUrl(htmlOut)
+
       siteCatalog.addFile({
         contents: page.markdownContents,
         out: { path: mdOutPath },

package/extensions/git-full-clone.js

@@ -0,0 +1,114 @@
+'use strict'
+
+const { execSync } = require('child_process')
+const fs = require('fs')
+const path = require('path')
+
+/**
+ * Configure Antora to use full git clones instead of shallow clones.
+ * This is needed for accurate git dates from the full commit history.
+ *
+ * Two-phase approach:
+ * 1. Set depth=0 in playbook to request full clones (doesn't always work due to Antora internals)
+ * 2. After content aggregation, unshallow any repos that are still shallow
+ *
+ * Configuration options:
+ * - skipUnshallow: Set to true to skip the unshallow phase (for air-gapped environments)
+ * - unshallowTimeout: Timeout in milliseconds per repo (default: 60000)
+ *
+ * Example:
+ * antora:
+ *   extensions:
+ *   - require: '@redpanda-data/docs-extensions-and-macros/extensions/git-full-clone'
+ *     skipUnshallow: false
+ *     unshallowTimeout: 120000  # 2 minutes for very large repos
+ *
+ * Production considerations:
+ * - First build will unshallow repos (~1-5 seconds per repo)
+ * - Subsequent builds with warm cache skip unshallow (already full clones)
+ * - Large repos (10k+ commits) may take longer - increase timeout if needed
+ * - Requires network access during build (for git fetch --unshallow)
+ * - For CI/CD, consider pre-populating Antora cache with full clones
+ */
+
+module.exports.register = function ({ config, playbook }) {
+  const logger = this.getLogger('git-full-clone-extension')
+
+  logger.info('✓ git-full-clone extension loaded')
+
+  // Phase 1: Try modifying playbook during registration
+  if (playbook?.content?.sources) {
+    logger.info('Phase 1: Modifying playbook during registration')
+    let remoteCount = 0
+    playbook.content.sources.forEach(source => {
+      if (source.url && source.url.startsWith('http')) {
+        const oldDepth = source.git?.depth
+        if (!source.git) source.git = {}
+        source.git.depth = 0
+        remoteCount++
+        logger.info(`  → ${source.url}: depth ${oldDepth || 'default'} → 0 (full clone)`)
+      }
+    })
+    logger.info(`✓ Configured ${remoteCount} remote content sources for full clones`)
+  }
+
+  // Phase 2: After content is aggregated, unshallow any repos that are still shallow
+  this.on('contentAggregated', ({ contentAggregate }) => {
+    // Allow disabling unshallow phase via config (for air-gapped environments or if git dates not needed)
+    const skipUnshallow = config?.skipUnshallow || false
+    if (skipUnshallow) {
+      logger.info('Phase 2: Skipping unshallow (skipUnshallow: true)')
+      return
+    }
+
+    logger.info('Phase 2: Checking for shallow clones to unshallow')
+    const processedRepos = new Set()
+    let unshallowedCount = 0
+    const unshallowTimeout = config?.unshallowTimeout || 60000 // Default 60 seconds per repo
+
+    for (const aggregate of contentAggregate) {
+      for (const origin of aggregate.origins || []) {
+        const gitdir = origin.gitdir
+        if (!gitdir || processedRepos.has(gitdir)) continue
+        processedRepos.add(gitdir)
+
+        // Check if this is a shallow clone
+        const shallowFile = path.join(gitdir, 'shallow')
+        if (fs.existsSync(shallowFile)) {
+          const startTime = Date.now()
+          try {
+            logger.info(`  → Unshallowing ${path.basename(gitdir)}...`)
+
+            // Use git fetch --unshallow to convert to full clone
+            execSync('git fetch --unshallow', {
+              cwd: gitdir,
+              stdio: 'pipe',
+              timeout: unshallowTimeout,
+              env: { ...process.env, GIT_TERMINAL_PROMPT: '0' }
+            })
+
+            const duration = Date.now() - startTime
+            unshallowedCount++
+            logger.info(`    ✓ Successfully unshallowed ${path.basename(gitdir)} (${duration}ms)`)
+          } catch (err) {
+            const duration = Date.now() - startTime
+            if (err.killed) {
+              logger.warn(`    ✗ Unshallow timeout after ${duration}ms for ${path.basename(gitdir)} (increase unshallowTimeout if needed)`)
+            } else {
+              logger.warn(`    ✗ Failed to unshallow ${path.basename(gitdir)}: ${err.message}`)
+            }
+            logger.warn(`    ⚠️  Git dates may be inaccurate for this repo - consider using a pre-cloned cache`)
+          }
+        } else {
+          logger.debug(`  → ${path.basename(gitdir)} is already a full clone`)
+        }
+      }
+    }
+
+    if (unshallowedCount > 0) {
+      logger.info(`✓ Unshallowed ${unshallowedCount} repositories`)
+    } else {
+      logger.info('✓ All repositories are already full clones')
+    }
+  })
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redpanda-data/docs-extensions-and-macros",
-  "version": "4.15.1",
+  "version": "4.15.3",
   "description": "Antora extensions and macros developed for Redpanda documentation.",
   "keywords": [
     "antora",
@@ -59,6 +59,8 @@
     "./extensions/generate-index-data": "./extensions/generate-index-data.js",
     "./extensions/generate-rp-connect-info": "./extensions/generate-rp-connect-info.js",
     "./extensions/add-global-attributes": "./extensions/add-global-attributes.js",
+    "./extensions/add-git-dates": "./extensions/add-git-dates.js",
+    "./extensions/add-faq-structured-data": "./extensions/add-faq-structured-data.js",
     "./extensions/version-fetcher/set-latest-version": "./extensions/version-fetcher/set-latest-version.js",
     "./extensions/modify-connect-tag-playbook": "./extensions/modify-connect-tag-playbook.js",
     "./extensions/validate-attributes": "./extensions/validate-attributes.js",
@@ -66,6 +68,7 @@
     "./extensions/unpublish-pages": "./extensions/unpublish-pages.js",
     "./extensions/find-related-labs": "./extensions/find-related-labs.js",
     "./extensions/convert-llms-to-txt": "./extensions/convert-llms-to-txt.js",
+    "./extensions/convert-sitemap-to-markdown": "./extensions/convert-sitemap-to-markdown.js",
     "./extensions/modify-redirects": "./extensions/produce-redirects.js",
     "./extensions/algolia-indexer/index": "./extensions/algolia-indexer/index.js",
     "./extensions/aggregate-terms": "./extensions/aggregate-terms.js",
@@ -123,6 +126,7 @@
     "tree-sitter": "^0.22.4",
     "turndown": "^7.2.2",
     "turndown-plugin-gfm": "^1.0.2",
+    "xml2js": "^0.6.2",
     "yaml": "^2.8.2",
     "yargs": "^17.7.2"
   },