const fs = require('fs')
const path = require('path')
const glob = require('glob')

// Function to convert <a href="url">text</a> to [text](url)
function convertLinksInFile(filePath) {
  console.log(`Processing: ${filePath}`)
  let content = fs.readFileSync(filePath, 'utf8')

  // Count links before conversion
  const linkMatches = content.match(/<a href="[^"]*"[^>]*>[^<]*<\/a>/g) || []
  const linkCount = linkMatches.length

  // Replace <a href="url" target="_blank">text</a> with [text](url)
  const updatedContent = content.replace(
    /<a href="([^"]*)"(?:[^>]*?)>([^<]*)<\/a>/g,
    '[$2]($1)',
  )

  // Count links after conversion
  const markdownLinkMatches = updatedContent.match(/\[[^\]]*\]$[^)]*$/g) || []
  const markdownLinkCount = markdownLinkMatches.length

  // Write the updated content back to the file if changes were made
  if (content !== updatedContent) {
    fs.writeFileSync(filePath, updatedContent, 'utf8')
    console.log(`✅ Converted ${linkCount} links in ${filePath}`)
    console.log(`   Found ${markdownLinkCount} markdown links after conversion`)
    return {
      file: filePath,
      linksConverted: linkCount,
      markdownLinksAfter: markdownLinkCount,
    }
  } else {
    console.log(`ℹ️ No changes made to ${filePath}`)
    return {
      file: filePath,
      linksConverted: 0,
      markdownLinksAfter: markdownLinkCount,
    }
  }
}

// Process either a single file or all MDX files
const processFiles = (pattern) => {
  const files = glob.sync(pattern)
  console.log(`Found ${files.length} files matching pattern: ${pattern}`)

  let totalConverted = 0
  const summary = []

  files.forEach((file) => {
    const result = convertLinksInFile(file)
    totalConverted += result.linksConverted
    summary.push(result)
  })

  console.log('\n--- Summary ---')
  console.log(`Total links converted: ${totalConverted}`)

  // Files with most conversions (top 5)
  const sortedSummary = [...summary].sort(
    (a, b) => b.linksConverted - a.linksConverted,
  )
  console.log('\nTop files by number of conversions:')
  sortedSummary.slice(0, 5).forEach((item) => {
    if (item.linksConverted > 0) {
      console.log(`${item.file}: ${item.linksConverted} links converted`)
    }
  })

  // Create conversion log file
  const logContent = `# Link Conversion Log
  
Date: ${new Date().toISOString().split('T')[0]}

## Summary
- Total files processed: ${files.length}
- Total links converted: ${totalConverted}

## Files with most conversions
${sortedSummary
  .slice(0, 10)
  .map((item) =>
    item.linksConverted > 0
      ? `- ${item.file}: ${item.linksConverted} links converted`
      : '',
  )
  .filter((line) => line !== '')
  .join('\n')}

## All converted files
${summary
  .filter((item) => item.linksConverted > 0)
  .map((item) => `- ${item.file}: ${item.linksConverted} links converted`)
  .join('\n')}
`

  fs.writeFileSync(
    path.join(__dirname, 'conversion-log.md'),
    logContent,
    'utf8',
  )
  console.log('\nConversion log saved to utils/conversion-log.md')

  return { totalConverted, summary }
}

// Check arguments
const args = process.argv.slice(2)
if (args[0] === '--test') {
  // Test mode: process only one file
  if (args[1]) {
    console.log('TEST MODE: Processing single file')
    processFiles(args[1])
  } else {
    console.log(
      'Please provide a test file path, e.g.: node convert-links.js --test ./some-file.mdx',
    )
  }
} else if (args[0] === '--dry-run') {
  // Dry run mode: just report what would be changed
  console.log('DRY RUN MODE: Not making actual changes')
  const originalWriteFileSync = fs.writeFileSync
  fs.writeFileSync = (path, data, options) => {
    console.log(`Would write to ${path} (changes suppressed in dry run)`)
  }
  processFiles('./**/*.mdx')
  fs.writeFileSync = originalWriteFileSync
} else {
  // Process all MDX files in current directory
  processFiles('./**/*.mdx')
}


#!/usr/bin/env node

const fs = require('fs')
const path = require('path')
const glob = require('glob')

// Parse command line arguments
const args = process.argv.slice(2)
const dryRun = args.includes('--dry-run')
const testFile = args.find((arg, index) => arg === '--test' && args[index + 1])
  ? args[args.indexOf('--test') + 1]
  : null
const fixMode = args.includes('--fix')

// Define the pattern to match Card components with title defined as bold text
const cardWithBoldTitlePattern = /<Card[^>]*>\s*\*\*([^*]+)\*\*/

// Function to check a single file
function checkFile(filePath) {
  try {
    const content = fs.readFileSync(filePath, 'utf8')
    const lines = content.split('\n')
    let issues = []
    let inCard = false
    let cardStart = -1
    let cardAttributes = ''
    let boldTitle = ''

    for (let i = 0; i < lines.length; i++) {
      const line = lines[i]

      // Check for Card opening tag - more inclusive to catch both standalone Cards and those in CardGroup
      if (!inCard && line.match(/<Card(\s|>|$)/)) {
        inCard = true
        cardStart = i
        // Extract card attributes more safely
        const cardMatch = line.match(/<Card([^>]*)>/)
        cardAttributes = cardMatch ? cardMatch[1] : ''

        // Check if this line or the next contains bold text
        const currentLineBold = line.match(/>\s*\*\*([^*]+)\*\*/)
        const nextLineBold =
          i < lines.length - 1 && lines[i + 1].trim().startsWith('**')

        if (currentLineBold) {
          boldTitle = currentLineBold[1].trim()
          issues.push({
            line: i + 1,
            title: boldTitle,
            attributes: cardAttributes,
            context: lines
              .slice(Math.max(0, i - 2), Math.min(lines.length, i + 4))
              .join('\n'),
          })
        } else if (nextLineBold) {
          const match = lines[i + 1].match(/\*\*([^*]+)\*\*/)
          if (match) {
            boldTitle = match[1].trim()
            issues.push({
              line: i + 2,
              title: boldTitle,
              attributes: cardAttributes,
              context: lines
                .slice(Math.max(0, i - 1), Math.min(lines.length, i + 5))
                .join('\n'),
            })
          }
        }
      }

      // Reset card tracking when we reach the closing tag
      if (inCard && line.includes('</Card>')) {
        inCard = false
        cardStart = -1
        boldTitle = ''
      }
    }

    return { filePath, issues }
  } catch (error) {
    console.error(`Error processing file ${filePath}:`, error)
    return { filePath, issues: [] }
  }
}

// Function to fix a file
function fixFile(filePath, issues) {
  if (issues.length === 0) return false

  let content = fs.readFileSync(filePath, 'utf8')
  let lines = content.split('\n')
  let modified = false

  // Process issues from bottom to top to avoid line number changes
  issues.sort((a, b) => b.line - a.line)

  for (const issue of issues) {
    const lineIndex = issue.line - 1
    if (lineIndex >= 0 && lineIndex < lines.length) {
      // If the bold text is on a separate line, we need to handle it differently
      if (lines[lineIndex].trim().startsWith('**')) {
        // Remove the bold markers and add title attribute to the Card tag
        const boldTextLine = lines[lineIndex]
        lines[lineIndex] = '' // Remove the bold text line

        // Find the Card opening tag line
        const cardLineIndex = lineIndex - 1
        if (cardLineIndex >= 0 && lines[cardLineIndex].includes('<Card')) {
          const cardLine = lines[cardLineIndex]
          const cardTagEnd = cardLine.indexOf('>')
          if (cardTagEnd !== -1) {
            // Check if the card already has a title attribute
            if (!cardLine.includes('title=')) {
              lines[cardLineIndex] =
                cardLine
                  .substring(0, cardTagEnd)
                  .replace('<Card', `<Card title="${issue.title}"`) +
                cardLine.substring(cardTagEnd)
            }
          } else {
            // Card tag spans multiple lines, handle this case
            if (!cardLine.includes('title=')) {
              lines[cardLineIndex] = cardLine.replace(
                '<Card',
                `<Card title="${issue.title}"`,
              )
            }
          }
          modified = true
        }
      } else {
        // Bold text is on the same line as the Card tag
        const line = lines[lineIndex]
        if (!line.includes('title=')) {
          const updatedLine = line.replace(
            /(<Card[^>]*>)\s*\*\*([^*]+)\*\*/,
            (match, cardTag, title) => {
              return cardTag.replace('<Card', `<Card title="${title}"`)
            },
          )

          if (updatedLine !== line) {
            lines[lineIndex] = updatedLine
            modified = true
          }
        }
      }
    }
  }

  if (modified && !dryRun) {
    fs.writeFileSync(filePath, lines.join('\n'), 'utf8')
  }

  return modified
}

// Main function
async function main() {
  const startTime = new Date()
  console.log(
    `${dryRun ? '🔍 DRY RUN MODE - No changes will be made' : '🚀 Starting card title check'}${fixMode ? ' with automatic fixes' : ''}`,
  )

  let filesToCheck
  if (testFile) {
    filesToCheck = [path.resolve(testFile)]
    console.log(`🔍 Testing single file: ${testFile}`)
  } else {
    // Find all MDX files in the docs directory, excluding node_modules and utils directory
    const mdxFiles = glob.sync('../**/*.mdx', {
      ignore: ['../**/node_modules/**', '../utils/**', '../depracted-docs/**'],
      cwd: __dirname,
      absolute: true,
    })
    filesToCheck = mdxFiles.map((file) => path.resolve(file))
    console.log(`📁 Found ${filesToCheck.length} MDX files to check`)
  }

  // Check each file
  let totalIssues = 0
  let filesWithIssues = 0
  let fixedFiles = 0

  let results = []
  for (const file of filesToCheck) {
    const result = checkFile(file)
    if (result.issues.length > 0) {
      results.push(result)
      totalIssues += result.issues.length
      filesWithIssues++

      if (fixMode) {
        const wasFixed = fixFile(file, result.issues)
        if (wasFixed) fixedFiles++
      }
    }
  }

  // Generate report
  console.log('\n📊 Card Title Check Report:')
  console.log(`🔍 ${totalIssues} issues found in ${filesWithIssues} files`)

  if (fixMode) {
    console.log(`✅ Fixed ${fixedFiles} files${dryRun ? ' (dry run)' : ''}`)
  }

  if (results.length > 0) {
    console.log('\n📑 Files with issues:')
    results.forEach((result) => {
      console.log(
        `\n🔴 ${result.filePath.replace(process.cwd(), '')} (${result.issues.length} issues):`,
      )
      result.issues.forEach((issue, index) => {
        console.log(`\n  Issue #${index + 1} - Line ${issue.line}:`)
        console.log(`  ----- Current Implementation -----`)
        const contextLines = issue.context.split('\n')
        const maxLines = Math.min(5, contextLines.length)
        for (let i = 0; i < maxLines; i++) {
          console.log(`  ${contextLines[i].trim()}`)
        }
        if (contextLines.length > maxLines) {
          console.log(`  ...`)
        }

        console.log(`\n  ----- Recommended Implementation -----`)
        // Generate a preview of what the fixed code should look like
        let fixedCode = contextLines.slice(0)
        for (let i = 0; i < fixedCode.length; i++) {
          if (
            fixedCode[i].match(/<Card(\s|>|$)/) &&
            !fixedCode[i].includes('title=')
          ) {
            fixedCode[i] = fixedCode[i].replace(
              /<Card([^>]*)>/,
              `<Card title="${issue.title}"$1>`,
            )
            break
          }
        }
        for (let i = 0; i < fixedCode.length; i++) {
          if (
            fixedCode[i].trim().startsWith('**') &&
            fixedCode[i].match(/\*\*([^*]+)\*\*/)
          ) {
            fixedCode[i] = '' // Remove the bold title line
            break
          }
        }
        // Display the fixed code
        const maxFixedLines = Math.min(5, fixedCode.length)
        for (let i = 0; i < maxFixedLines; i++) {
          if (fixedCode[i].trim() !== '') {
            console.log(`  ${fixedCode[i].trim()}`)
          }
        }

        console.log(`  -----`)
      })
    })

    // Log instructions
    console.log('\n📋 To fix these issues:')
    console.log(
      '1. Run this script with the --fix flag to automatically convert bold titles to title props:',
    )
    console.log('   node utils/check-card-titles.js --fix')
    console.log('2. For testing a single file:')
    console.log('   node utils/check-card-titles.js --test path/to/file.mdx')
    console.log('3. For a dry run (simulate fixes without making changes):')
    console.log('   node utils/check-card-titles.js --fix --dry-run')
  } else {
    console.log('✅ No issues found - all Card titles are properly defined!')
  }

  // Log execution time
  const endTime = new Date()
  const executionTime = (endTime - startTime) / 1000
  console.log(`\n⏱️ Execution time: ${executionTime.toFixed(2)} seconds`)
}

main().catch((error) => {
  console.error('Error:', error)
  process.exit(1)
})


#!/usr/bin/env node

const fs = require('fs')
const path = require('path')
const glob = require('glob')
const { JSDOM } = require('jsdom')

// Parse command line arguments
const args = process.argv.slice(2)
const dryRun = args.includes('--dry-run')
const testFile = args.find((arg, index) => arg === '--test' && args[index + 1])
  ? args[args.indexOf('--test') + 1]
  : null
const fixMode = args.includes('--fix')

// Function to convert a table to Markdown format
function convertHtmlTableToMarkdown(tableEl) {
  // Get headers
  const headerRow = tableEl.querySelector('thead tr')
  const headers = headerRow
    ? Array.from(headerRow.querySelectorAll('th')).map((th) =>
        th.textContent.trim(),
      )
    : []

  // Get rows
  const rows = Array.from(tableEl.querySelectorAll('tbody tr')).map((tr) =>
    Array.from(tr.querySelectorAll('td')).map((td) => td.textContent.trim()),
  )

  // Calculate column widths for better formatting
  let columnWidths = []

  // Check header widths
  if (headers.length > 0) {
    headers.forEach((header, index) => {
      columnWidths[index] = header.length
    })
  }

  // Check data row widths
  rows.forEach((row) => {
    row.forEach((cell, index) => {
      columnWidths[index] = Math.max(columnWidths[index] || 0, cell.length)
    })
  })

  // Add padding to column widths
  columnWidths = columnWidths.map((width) => Math.max(width + 2, 5)) // Min width of 5 chars

  // Build Markdown table
  let markdown = ''

  // Add header row with padding
  if (headers.length > 0) {
    markdown +=
      '| ' +
      headers.map((header, i) => header.padEnd(columnWidths[i])).join(' | ') +
      ' |\n'

    // Add separator with proper width
    markdown +=
      '| ' + columnWidths.map((width) => '-'.repeat(width)).join(' | ') + ' |\n'
  }

  // Add data rows with padding
  for (const row of rows) {
    markdown +=
      '| ' +
      row
        .map((cell, i) => cell.padEnd(columnWidths[i] || cell.length))
        .join(' | ') +
      ' |\n'
  }

  return markdown
}

// Function to check and convert tables in a file
function checkFile(filePath) {
  try {
    const content = fs.readFileSync(filePath, 'utf8')
    let modifiedContent = content
    let tables = []
    let converted = false

    // First pass: Find all <Table> components
    const tableComponentRegex = /<Table[\s\S]*?<\/Table>/g
    let match

    while ((match = tableComponentRegex.exec(content)) !== null) {
      const original = match[0]
      const startIndex = match.index
      const endIndex = startIndex + original.length

      try {
        // Convert the Table component to a standard HTML table
        const tableHTML = original
          .replace(/<Table[^>]*>/, '<table>')
          .replace(/<\/Table>/, '</table>')
        const dom = new JSDOM(tableHTML)
        const tableEl = dom.window.document.querySelector('table')

        if (tableEl) {
          const markdown = convertHtmlTableToMarkdown(tableEl)
          tables.push({
            original,
            markdown,
            startIndex,
            endIndex,
            lineInfo: getLineInfo(content, startIndex),
          })
        }
      } catch (error) {
        console.error('Error converting Table component:', error)
      }
    }

    // Second pass: Find all regular <table> elements (skip if they're inside a <Table> component)
    const htmlTableRegex = /<table[\s\S]*?<\/table>/g

    while ((match = htmlTableRegex.exec(content)) !== null) {
      const original = match[0]
      const startIndex = match.index
      const endIndex = startIndex + original.length

      // Skip if this table is part of a <Table> component we already processed
      if (
        content
          .substring(Math.max(0, startIndex - 50), startIndex)
          .includes('<Table')
      ) {
        continue
      }

      try {
        const dom = new JSDOM(original)
        const tableEl = dom.window.document.querySelector('table')

        if (tableEl) {
          const markdown = convertHtmlTableToMarkdown(tableEl)
          tables.push({
            original,
            markdown,
            startIndex,
            endIndex,
            lineInfo: getLineInfo(content, startIndex),
          })
        }
      } catch (error) {
        console.error('Error converting HTML table:', error)
      }
    }

    // Process tables from end to start to avoid index shifts
    if (tables.length > 0) {
      // Sort tables by their position in reverse order
      tables.sort((a, b) => b.startIndex - a.startIndex)

      for (const table of tables) {
        modifiedContent =
          modifiedContent.slice(0, table.startIndex) +
          table.markdown +
          modifiedContent.slice(table.endIndex)
        converted = true
      }
    }

    return {
      filePath,
      tables,
      modifiedContent,
      converted,
    }
  } catch (error) {
    console.error(`Error processing file ${filePath}:`, error)
    return { filePath, tables: [], modifiedContent: null, converted: false }
  }
}

// Helper function to get line number and context
function getLineInfo(content, index) {
  const lines = content.slice(0, index).split('\n')
  const lineNumber = lines.length

  // Get context (5 lines before and after)
  const allLines = content.split('\n')
  const startLine = Math.max(0, lineNumber - 5)
  const endLine = Math.min(allLines.length, lineNumber + 5)
  const context = allLines.slice(startLine, endLine).join('\n')

  return { lineNumber, context }
}

// Function to fix a file
function fixFile(filePath, checkResult) {
  if (!checkResult.converted) return false

  if (!dryRun) {
    fs.writeFileSync(filePath, checkResult.modifiedContent, 'utf8')
  }

  return true
}

// Main function
async function main() {
  const startTime = new Date()
  console.log(
    `${dryRun ? '🔍 DRY RUN MODE - No changes will be made' : '🚀 Starting table conversion'}${fixMode ? ' with automatic fixes' : ''}`,
  )

  let filesToCheck
  if (testFile) {
    filesToCheck = [path.resolve(testFile)]
    console.log(`🔍 Testing single file: ${testFile}`)
  } else {
    // Find all MDX files in the docs directory, excluding node_modules and utils directory
    const mdxFiles = glob.sync('../**/*.mdx', {
      ignore: ['../**/node_modules/**', '../utils/**', '../depracted-docs/**'],
      cwd: __dirname,
      absolute: true,
    })
    filesToCheck = mdxFiles.map((file) => path.resolve(file))
    console.log(`📁 Found ${filesToCheck.length} MDX files to check`)
  }

  // Check each file
  let totalTables = 0
  let filesWithTables = 0
  let fixedFiles = 0
  let totalConverted = 0

  let results = []
  for (const file of filesToCheck) {
    const result = checkFile(file)

    if (result.tables && result.tables.length > 0) {
      results.push(result)
      totalTables += result.tables.length
      filesWithTables++

      if (fixMode && result.converted) {
        const wasFixed = fixFile(file, result)
        if (wasFixed) {
          fixedFiles++
          totalConverted += result.tables.length
        }
      }
    }
  }

  // Generate report
  console.log('\n📊 Table Conversion Report:')
  console.log(`🔍 ${totalTables} tables found in ${filesWithTables} files`)

  if (fixMode) {
    console.log(
      `✅ Converted ${totalConverted} tables in ${fixedFiles} files${dryRun ? ' (dry run)' : ''}`,
    )
  }

  if (results.length > 0) {
    console.log('\n📑 Files with tables:')
    results.forEach((result) => {
      console.log(
        `\n🔸 ${result.filePath.replace(process.cwd(), '')} (${result.tables.length} tables):`,
      )

      result.tables.forEach((table, index) => {
        console.log(
          `\n  Table #${index + 1} - Line ${table.lineInfo.lineNumber}:`,
        )
        console.log(`  ----- Original Table -----`)
        console.log(
          `  ${table.original.substring(0, 200)}${table.original.length > 200 ? '...' : ''}`,
        )

        console.log(`\n  ----- Converted to Markdown -----`)
        console.log(
          `  ${table.markdown.substring(0, 200)}${table.markdown.length > 200 ? '...' : ''}`,
        )

        console.log(`  -----`)
      })
    })

    // Log instructions
    console.log('\n📋 To convert these tables to Markdown:')
    console.log(
      '1. Run this script with the --fix flag to automatically convert tables:',
    )
    console.log('   node utils/convert-tables.js --fix')
    console.log('2. For testing a single file:')
    console.log('   node utils/convert-tables.js --test path/to/file.mdx')
    console.log(
      '3. For a dry run (simulate conversions without making changes):',
    )
    console.log('   node utils/convert-tables.js --fix --dry-run')
  } else {
    console.log('✅ No tables found to convert!')
  }

  // Log execution time
  const endTime = new Date()
  const executionTime = (endTime - startTime) / 1000
  console.log(`\n⏱️ Execution time: ${executionTime.toFixed(2)} seconds`)
}

main().catch((error) => {
  console.error('Error:', error)
  process.exit(1)
})


const fs = require('fs')
const path = require('path')
const glob = require('glob')

/**
 * Fixes two issues with Frame and image components in MDX files:
 * 1. Converts <Frame src="..."> to <Frame>![alt](src)</Frame> (Markdown syntax)
 * 2. Ensures all <Frame> elements contain proper image markdown or img tags
 */
function fixFrameImages(filePath) {
  // Only log the filename if changes are detected
  let content = fs.readFileSync(filePath, 'utf8')
  let originalContent = content
  let changes = { framesSrc: 0, framesWithHtmlImg: 0 }

  // Pattern 1: Fix <Frame src="..."> to <Frame>![alt](src)</Frame> (Markdown syntax)
  // This regex captures <Frame src="URL" alt="TEXT"> with potential caption
  const frameSrcRegex =
    /<Frame\s+src="([^"]+)"(?:\s+alt="([^"]*)")?\s*>([^<]*)<\/Frame>/g
  const frameSrcMatches = content.match(frameSrcRegex) || []

  if (frameSrcMatches.length > 0) {
    // Log file being processed since we found changes
    console.log(`Processing: ${filePath}`)

    // Store an example of what's being changed
    const example = frameSrcMatches[0]

    // Replace each Frame with src to proper Markdown image inside Frame
    content = content.replace(
      frameSrcRegex,
      (match, src, alt = '', caption) => {
        caption = caption.trim()
        const mdImage = `![${alt}](${src})`

        if (caption) {
          return `<Frame caption="${caption}">\n  ${mdImage}\n</Frame>`
        } else {
          return `<Frame>\n  ${mdImage}\n</Frame>`
        }
      },
    )

    changes.framesSrc = frameSrcMatches.length

    if (changes.framesSrc > 0) {
      console.log(`  Example conversion (Frame src):`)
      console.log(
        `  From: ${example.substring(0, 100)}${example.length > 100 ? '...' : ''}`,
      )

      // Extract parts of the example to demonstrate the conversion
      const parts = frameSrcRegex.exec(example)
      if (parts) {
        const [_, src, alt, caption] = parts
        const mdImage = `![${alt}](${src})`
        const result = caption.trim()
          ? `<Frame caption="${caption.trim()}">\n  ${mdImage}\n</Frame>`
          : `<Frame>\n  ${mdImage}\n</Frame>`
        console.log(`  To:   ${result}`)
      }
    }
  }

  // Pattern 2: Find HTML img tags inside Frames and convert to markdown syntax
  // This regex captures <img> tags inside <Frame> tags
  const frameWithHtmlImgRegex =
    /(<Frame[^>]*>)\s*<img\s+src="([^"]+)"(?:\s+alt="([^"]*)")?\s*\/>\s*(<\/Frame>)/g
  const frameWithHtmlImgMatches = content.match(frameWithHtmlImgRegex) || []

  if (frameWithHtmlImgMatches.length > 0) {
    // Log file being processed if not already logged
    if (frameSrcMatches.length === 0) {
      console.log(`Processing: ${filePath}`)
    }

    // Store an example
    const example = frameWithHtmlImgMatches[0]

    // Replace img tags with markdown images inside Frames
    content = content.replace(
      frameWithHtmlImgRegex,
      (match, openTag, src, alt = '', closeTag) => {
        // Extract a default image description from the src URL if alt is empty
        let imageAlt = alt
        if (!imageAlt || imageAlt === 'undefined') {
          // Try to extract a meaningful name from the URL
          const urlParts = src.split('/')
          const fileName = urlParts[urlParts.length - 1].split('?')[0]
          // Convert file name to readable format (e.g., "cell-14-output-1.png" -> "Chart Image")
          if (fileName.includes('output') || fileName.includes('cell')) {
            imageAlt = 'Chart Image'
          } else {
            // Remove extension and convert to title case
            imageAlt = fileName
              .replace(/\.[^/.]+$/, '') // Remove extension
              .replace(/[-_]/g, ' ') // Replace hyphens and underscores with spaces
              .replace(/\b\w/g, (l) => l.toUpperCase()) // Title case
          }
        }
        return `${openTag}\n  ![${imageAlt}](${src})\n${closeTag}`
      },
    )

    changes.framesWithHtmlImg = frameWithHtmlImgMatches.length

    if (changes.framesWithHtmlImg > 0) {
      console.log(`  Example conversion (Frame with HTML img):`)
      console.log(
        `  From: ${example.substring(0, 100)}${example.length > 100 ? '...' : ''}`,
      )

      // Extract parts of the example to demonstrate
      const parts = frameWithHtmlImgRegex.exec(example)
      if (parts) {
        const [_, openTag, src, alt, closeTag] = parts
        const result = `${openTag}\n  ![${alt || 'Chart Image'}](${src})\n${closeTag}`
        console.log(`  To:   ${result}`)
      }
    }
  }

  // Write the updated content back to the file if changes were made
  if (content !== originalContent) {
    fs.writeFileSync(filePath, content, 'utf8')
    console.log(
      `✅ Fixed ${changes.framesSrc + changes.framesWithHtmlImg} frame-image elements in ${filePath}`,
    )
    return {
      file: filePath,
      changes,
      totalChanges: changes.framesSrc + changes.framesWithHtmlImg,
    }
  } else {
    return { file: filePath, changes: {}, totalChanges: 0 }
  }
}

// Process either a single file or all MDX files
const processFiles = (pattern) => {
  const files = glob.sync(pattern)
  console.log(`Found ${files.length} files matching pattern: ${pattern}`)

  // Add a blank line after the initial message
  console.log('')

  let totalFixed = 0
  const summary = []
  let filesWithChanges = 0
  let detailedExamples = [] // Store examples of the transformations

  files.forEach((file) => {
    const result = fixFrameImages(file)
    totalFixed += result.totalChanges
    if (result.totalChanges > 0) {
      filesWithChanges++
      summary.push(result)

      // Capture examples for the log
      try {
        const content = fs.readFileSync(file, 'utf8')

        // Try to find examples of the fixed patterns
        if (result.changes.framesSrc > 0) {
          // Find a Frame with markdown image that was likely converted from src
          const frameImgMatch = content.match(
            /<Frame[^>]*>\s*!\[([^\]]*)\]$([^)]+)$\s*<\/Frame>/m,
          )
          if (frameImgMatch) {
            detailedExamples.push({
              file,
              type: 'Frame with src attribute',
              before: `<Frame src="${frameImgMatch[2]}" alt="${frameImgMatch[1]}"></Frame>`,
              after: frameImgMatch[0].trim(),
            })
          }
        }

        if (result.changes.framesWithHtmlImg > 0) {
          // Find a Frame with markdown image that was likely converted from HTML img
          const frameImgMatch = content.match(
            /<Frame[^>]*>\s*!\[([^\]]*)\]$([^)]+)$\s*<\/Frame>/m,
          )
          if (frameImgMatch && !detailedExamples.some((e) => e.file === file)) {
            detailedExamples.push({
              file,
              type: 'Frame with HTML img',
              before: `<Frame>\n  <img src="${frameImgMatch[2]}" alt="${frameImgMatch[1]}" />\n</Frame>`,
              after: frameImgMatch[0].trim(),
            })
          }
        }
      } catch (err) {
        console.error(`Error capturing examples from ${file}:`, err.message)
      }
    }
  })

  // Add a blank line before summary
  console.log('')
  console.log('--- Summary ---')
  console.log(`Files with changes: ${filesWithChanges} out of ${files.length}`)
  console.log(`Total frame-image elements fixed: ${totalFixed}`)

  // Files with most fixes (top 5)
  const sortedSummary = [...summary].sort(
    (a, b) => b.totalChanges - a.totalChanges,
  )
  console.log('\nTop files by number of fixes:')
  sortedSummary.slice(0, 5).forEach((item) => {
    if (item.totalChanges > 0) {
      console.log(`${item.file}: ${item.totalChanges} elements fixed`)
    }
  })

  // Create log file with detailed information
  const logContent = `# Frame-Image Fix Log
  
Date: ${new Date().toISOString().split('T')[0]}

## Summary
- Total files processed: ${files.length}
- Files with changes: ${filesWithChanges}
- Total frame-image elements fixed: ${totalFixed}

## Files with most fixes
${sortedSummary
  .slice(0, 10)
  .map((item) =>
    item.totalChanges > 0
      ? `- ${item.file}: ${item.totalChanges} elements fixed (Frame src: ${item.changes.framesSrc}, Frame HTML img: ${item.changes.framesWithHtmlImg})`
      : '',
  )
  .filter((line) => line !== '')
  .join('\n')}

## Transformation Examples

${detailedExamples
  .slice(0, Math.min(10, detailedExamples.length))
  .map(
    (example) =>
      `### File: ${example.file}\n\n**Type:** ${example.type}\n\n**Before:**\n\`\`\`jsx\n${example.before}\n\`\`\`\n\n**After:**\n\`\`\`jsx\n${example.after}\n\`\`\`\n`,
  )
  .join('\n\n')}

## All Fixed Files
${summary
  .filter((item) => item.totalChanges > 0)
  .map(
    (item) =>
      `- ${item.file}: ${item.totalChanges} elements fixed (Frame src: ${item.changes.framesSrc}, Frame HTML img: ${item.changes.framesWithHtmlImg})`,
  )
  .join('\n')}
`

  fs.writeFileSync(
    path.join(__dirname, 'frame-image-fix-log.md'),
    logContent,
    'utf8',
  )
  console.log('\nFix log saved to utils/frame-image-fix-log.md')

  return { totalFixed, summary }
}

// Check arguments
const args = process.argv.slice(2)
if (args[0] === '--test') {
  // Test mode: process only one file
  if (args[1]) {
    console.log('TEST MODE: Processing single file')
    processFiles(args[1])
  } else {
    console.log(
      'Please provide a test file path, e.g.: node fix-frame-images.js --test ./some-file.mdx',
    )
  }
} else if (args[0] === '--dry-run') {
  // Dry run mode: just report what would be changed
  console.log('DRY RUN MODE: Not making actual changes')
  const originalWriteFileSync = fs.writeFileSync
  fs.writeFileSync = (path, data, options) => {
    if (!path.includes('frame-image-fix-log.md')) {
      console.log(`Would write to ${path} (changes suppressed in dry run)`)
    }
  }
  processFiles('./**/*.mdx')
  fs.writeFileSync = originalWriteFileSync
} else {
  // Process all MDX files in current directory
  processFiles('./**/*.mdx')
}


Overview

Get in Touch

Overview of TimeGPT's Enterprise subscription plans with deployment options, support, and trial details.

TimeGPT Subscription Plans

TimeGPT Foundational model for time series forecasting and anomaly detection

Welcome to TimeGPT - The foundational model for time series forecasting and anomaly detection

Introduction

Learn how to use TimeGPT for accurate time series forecasting in just a few steps

Quickstart

Learn about TimeGPT - the foundation model for time series.

About TimeGPT

Understand the benefits of using TimeGPT for time series analysis.

Why TimeGPT?

TimeGPT FAQ

Get started with TimeGPT using Polars for efficient data processing.

TimeGPT Quickstart (Polars)

Quickstart guide to deploy and use TimeGEN-1 on Azure with the Nixtla Python SDK for time series forecasting.

TimeGEN-1 Quickstart (Azure)

Learn how to securely configure your Nixtla SDK API key using direct code or environment variables.

Setting up your API key

Overview of the data format and requirements for TimeGPT forecasting.

Data Requirements

Key terminology and concepts for time series forecasting with TimeGPT

Glossary

Complete list of changes for each version of the Nixtla client.

Changelog

Advanced zero-shot forecasting capabilities for time series data

Forecast

Get started quickly with TimeGPT forecasting using the Nixtla API.

Forecasting Quickstart

Learn how to incorporate external factors to improve forecast accuracy.

Add Exogenous Variables to Forecasts

Incorporate country-specific holidays and custom special dates into your forecasting models to improve accuracy.

Add holidays and special dates

Learn how to create and use custom categorical variables with SpecialDates in TimeGPT forecasting.

Add categorical variables

Learn how to predict multiple seasonal cycles into the future using TimeGPT

Long-horizon forecasting

Learn how to forecast multiple time series at once with TimeGPT.

Multiple Series Forecasting

How to fine-tune TimeGPT forecasts using finetune_steps and finetune_depth parameters for improved accuracy.

Fine-tuning

Learn how to fine-tune forecasting models using a preferred loss function for improved performance.

Finetuning with a custom loss function

Learn how to validate your forecast models using time series cross-validation.

Cross Validation

Learn how to use the level parameter to generate prediction intervals that quantify forecast uncertainty.

Prediction Intervals

Learn how to work with both regular and irregular timestamps in TimeGPT for accurate forecasting.

Irregular Timestamps

Configure confidence levels to control anomaly detection sensitivity.

Add Confidence Levels

Learn how to detect anomalies in historical time series data using confidence intervals and TimeGPT.

Historical anomaly detection

Get started with TimeGPT's historical anomaly detection capabilities.

Historical Anomaly Detection Quickstart

Learn how to improve anomaly detection by incorporating external factors.

Add Exogenous Variables to Anomaly Detection

How to enrich datasets with date features for historical anomaly detection.

Add date features

Intro Online (Real-Time) anomaly concepts

Online (Real-Time) Anomaly Detection

Learn how to use the detect_anomalies_online method for real-time anomaly detection in streaming time series data with TimeGPT.

Introduction to Online (Real-Time) Anomaly Detection

Learn how to refine TimeGPT’s anomaly detection process by tuning parameters for improved accuracy and alignment with specific use cases.

Adjusting the Anomaly Detection Process

Explore the differences between single and multiple variable anomaly detection approaches.

Univariate vs Multivariate Anomaly Detection

Guide to deploying and using the TimeGEN-1 model as an Azure AI endpoint.

AzureAI

Tutorial on detecting anomalies in time series data using TimeGPT.

Anomaly detection

Learn how to incorporate external variables to improve your forecasting accuracy.

Exogenous Variables Tutorial

Guide to using calendar variables and special dates to improve forecast accuracy in time series.

Holidays and special dates

Learn how to incorporate categorical variables in your TimeGPT forecasts to improve accuracy.

Adding Categorical Variables

Learn how to interpret model predictions using SHAP values to understand the impact of exogenous variables.

SHAP Values for TimeGPT and TimeGEN

Tutorials and steps for training TimeGPT for various forecasting scenarios

Training

Learn how to use the TimeGPT long-horizon model for forecasting far into the future with Nixtla client.

Long-horizon forecasting Tutorial

Learn how to generate forecasts for multiple time series simultaneously.

Multiple Series Forecasting Tutorial

Adapt TimeGPT to your specific datasets for more accurate forecasts

Fine-tuning Tutorial TimeGPT

Learn how to save, fine-tune, list, and delete TimeGPT models to optimize forecasting.

Re-using fine-tuned models

Learn how to fine-tune a model using specific loss functions, configure the Nixtla client, and evaluate performance improvements.

Fine-tuning with a Specific Loss Function

Learn how to use the finetune_depth parameter to control the extent of fine-tuning in TimeGPT models.

Controlling the Level of Fine-Tuning

Learn how to validate time series models with cross-validation and historical forecasts

Validation

Learn how to validate time series models with rolling-window cross-validation

Cross-validation Tutorial

Learn how to validate TimeGPT models by comparing historical forecasts against actual data.

Historical Forecast Evaluation

Uncertainty quantification is a key component of forecasting. Learn how to quantify uncertainty in your forecasts.

Uncertainty Quantification Tutorial

Learn how to generate forecasts at different probability levels to quantify uncertainty.

Quantile Forecasts

Learn how to create robust prediction intervals to quantify uncertainty in forecasts.

Prediction Intervals Tutorial

Explore special topics in TimeGPT including irregular timestamps, bounded forecasts, hierarchical forecasts, missing values, and improving forecast accuracy.

Special topics

Learn how to generate forecasts with upper and lower bounds to match your business constraints.

Bounded Forecasts

Learn how to use TimeGPT for hierarchical forecasting across multiple levels.

Hierarchical Forecasting

Learn how to combine forecasts at different time frequencies to improve accuracy.

Temporal Hierarchical Forecasting with TimeGPT

Learn how to handle missing values in time series data for accurate forecasting with TimeGPT.

Missing Values

Advanced techniques to enhance TimeGPT forecast accuracy for energy and electricity.

Improve Forecast Accuracy with TimeGPT

Learn how to use TimeGPT with distributed computing frameworks for processing large datasets.

Computing at Scale Tutorial

Learn how to run TimeGPT in a distributed manner on Spark for scalable forecasting and cross-validation.

Spark

Run TimeGPT in a distributed manner using Dask for scalable forecasting.

Dask

Distribute TimeGPT forecasting jobs on Ray for scalable Python workloads.

Learn how to predict website traffic patterns using TimeGPT.

Forecasting Web Traffic

Learn how to use TimeGPT to predict Bitcoin prices and evaluate forecast accuracy.

Bitcoin Price Prediction

Learn how TimeGPT accurately predicts electricity consumption patterns

Forecasting Energy Demand

Learn how to forecast sporadic demand patterns for inventory management.

Forecasting Intermittent Demand

Learn how to use TimeGPT to forecast sales scenarios with different pricing strategies.

QUICK START

GETTING STARTED

CAPABILITIES

DEPLOYMENT

TUTORIALS

USE CASES

REFERENCE

About

TimeGPT Subscription Plans

Overview

Get in Touch

Next Steps

Contact Us

QUICK START

GETTING STARTED

CAPABILITIES

DEPLOYMENT

TUTORIALS

USE CASES

REFERENCE

About

​Overview

​Get in Touch

Next Steps

Contact Us

Overview

Get in Touch