#!/usr/bin/env ts-node

import fs from 'fs'

import path from 'path'

import { fileURLToPath } from 'url'

import { glob } from 'glob'

console.log('Starting documentation generator...')

/**

* Cache for resolved const definitions from types files.

* Key: "toolPrefix:constName" (e.g., "calcom:SCHEDULE_DATA_OUTPUT_PROPERTIES")

* Value: The resolved properties object

*/

const constResolutionCache = new Map<string, Record<string, any>>()

const __filename = fileURLToPath(import.meta.url)

const __dirname = path.dirname(__filename)

const rootDir = path.resolve(__dirname, '..')

const BLOCKS_PATH = path.join(rootDir, 'apps/sim/blocks/blocks')

const DOCS_OUTPUT_PATH = path.join(rootDir, 'apps/docs/content/docs/en/tools')

const ICONS_PATH = path.join(rootDir, 'apps/sim/components/icons.tsx')

const DOCS_ICONS_PATH = path.join(rootDir, 'apps/docs/components/icons.tsx')

const LANDING_INTEGRATIONS_DATA_PATH = path.join(

rootDir,

'apps/sim/app/(landing)/integrations/data'

)

const TRIGGERS_PATH = path.join(rootDir, 'apps/sim/triggers')

if (!fs.existsSync(DOCS_OUTPUT_PATH)) {

fs.mkdirSync(DOCS_OUTPUT_PATH, { recursive: true })

}

// Ensure docs components directory exists

const docsComponentsDir = path.dirname(DOCS_ICONS_PATH)

if (!fs.existsSync(docsComponentsDir)) {

fs.mkdirSync(docsComponentsDir, { recursive: true })

}

interface BlockConfig {

type: string

name: string

description: string

longDescription?: string

category: string

bgColor?: string

outputs?: Record<string, any>

tools?: {

access?: string[]

}

operations?: OperationInfo[]

docsLink?: string

[key: string]: any

}

/**

* Find the position after the matching close delimiter for an opening delimiter.

* Assumes `content[openPos]` is the opening char (e.g. `{` or `[`).

* Returns the index one past the matching close char, or -1 if unbalanced.

*/

function findMatchingClose(

content: string,

openPos: number,

openChar = '{',

closeChar = '}'

): number {

let count = 1

let pos = openPos + 1

while (pos < content.length && count > 0) {

if (content[pos] === openChar) count++

else if (content[pos] === closeChar) count--

pos++

}

return count === 0 ? pos : -1

}

interface TriggerInfo {

id: string

name: string

description: string

}

interface OperationInfo {

name: string

description: string

}

interface IntegrationEntry {

type: string

slug: string

name: string

description: string

longDescription: string

bgColor: string

iconName: string

docsUrl: string

operations: OperationInfo[]

operationCount: number

triggers: TriggerInfo[]

triggerCount: number

authType: 'oauth' | 'api-key' | 'none'

category: string

integrationTypes?: string[]

tags?: string[]

}

/**

* Copy the icons.tsx file from the main sim app to the docs app

* This ensures icons are rendered consistently across both apps

*/

function copyIconsFile(): void {

try {

console.log('Copying icons from sim app to docs app...')

if (!fs.existsSync(ICONS_PATH)) {

console.error(`Source icons file not found: ${ICONS_PATH}`)

return

}

const iconsContent = fs.readFileSync(ICONS_PATH, 'utf-8')

fs.writeFileSync(DOCS_ICONS_PATH, iconsContent)

console.log('✓ Icons successfully copied to docs app')

} catch (error) {

console.error('Error copying icons file:', error)

}

}

/**

* Generate icon mapping from all block definitions

* Maps block types to their icon component names

* Skips blocks that don't have documentation generated (same logic as generateBlockDoc)

*/

async function generateIconMapping(): Promise<Record<string, string>> {

try {

console.log('Generating icon mapping from block definitions...')

const iconMapping: Record<string, string> = {}

const blockFiles = (await glob(`${BLOCKS_PATH}/*.ts`)).sort()

for (const blockFile of blockFiles) {

const fileContent = fs.readFileSync(blockFile, 'utf-8')

// For icon mapping, we need ALL blocks including hidden ones

// because V2 blocks inherit icons from legacy blocks via spread

// First, extract the primary icon from the file (usually the legacy block's icon)

const primaryIcon = extractIconNameFromContent(fileContent)

// Find all block exports and their types

const exportRegex = /export\s+const\s+(\w+)Block\s*:\s*BlockConfig[^=]*=\s*\{/g

let match

while ((match = exportRegex.exec(fileContent)) !== null) {

const blockName = match[1]

const startIndex = match.index + match[0].length - 1

// Extract the block content

const endIndex = findMatchingClose(fileContent, startIndex)

if (endIndex !== -1) {

const blockContent = fileContent.substring(startIndex, endIndex)

// Check hideFromToolbar - skip hidden blocks for docs but NOT for icon mapping

const hideFromToolbar = /hideFromToolbar\s*:\s*true/.test(blockContent)

// Get block type

const blockType =

extractStringPropertyFromContent(blockContent, 'type') || blockName.toLowerCase()

// Get icon - either from this block or inherited from primary

const iconName = extractIconNameFromContent(blockContent) || primaryIcon

if (!blockType || !iconName) {

continue

}

// Skip trigger/webhook/rss blocks

if (

blockType.includes('_trigger') ||

blockType.includes('_webhook') ||

blockType.includes('rss')

) {

continue

}

// Get category for additional filtering

const category = extractStringPropertyFromContent(blockContent, 'category') || 'misc'

if (

(category === 'blocks' && blockType !== 'memory' && blockType !== 'knowledge') ||

blockType === 'evaluator' ||

blockType === 'number' ||

blockType === 'webhook' ||

blockType === 'schedule' ||

blockType === 'mcp' ||

blockType === 'generic_webhook' ||

blockType === 'rss'

) {

continue

}

// Only add non-hidden blocks to icon mapping (docs won't be generated for hidden)

if (!hideFromToolbar) {

iconMapping[blockType] = iconName

}

}

}

}

console.log(`✓ Generated icon mapping for ${Object.keys(iconMapping).length} blocks`)

return iconMapping

} catch (error) {

console.error('Error generating icon mapping:', error)

return {}

}

}

/**

* Write the icon mapping to the docs app

* This file is imported by BlockInfoCard to resolve icons automatically

*/

/**

* Sort strings to match Biome's organizeImports order:

* case-insensitive character-by-character, uppercase before lowercase as tiebreaker.

*/

function biomeSortCompare(a: string, b: string): number {

const minLen = Math.min(a.length, b.length)

for (let i = 0; i < minLen; i++) {

const al = a[i].toLowerCase()

const bl = b[i].toLowerCase()

if (al !== bl) return al < bl ? -1 : 1

if (a[i] !== b[i]) return a[i] < b[i] ? -1 : 1

}

return a.length - b.length

}

function writeIconMapping(iconMapping: Record<string, string>): void {

try {

const iconMappingPath = path.join(rootDir, 'apps/docs/components/ui/icon-mapping.ts')

// Get unique icon names, sorted to match Biome's organizeImports

const iconNames = [...new Set(Object.values(iconMapping))].sort(biomeSortCompare)

// Generate imports

const imports = iconNames.map((icon) => ` ${icon},`).join('\n')

// Generate mapping with direct references (no dynamic access for tree shaking)

const mappingEntries = Object.entries(iconMapping)

.sort(([a], [b]) => a.localeCompare(b))

.map(([blockType, iconName]) => ` ${blockType}: ${iconName},`)

.join('\n')

const content = `// Auto-generated file - do not edit manually

// Generated by scripts/generate-docs.ts

// Maps block types to their icon component references

import type { ComponentType, SVGProps } from 'react'

import {

${imports}

} from '@/components/icons'

type IconComponent = ComponentType<SVGProps<SVGSVGElement>>

export const blockTypeToIconMap: Record<string, IconComponent> = {

${mappingEntries}

}

`

fs.writeFileSync(iconMappingPath, content)

console.log('✓ Icon mapping file written to docs app')

} catch (error) {

console.error('Error writing icon mapping:', error)

}

}

/**

* Extract operation options from the subBlock with id: 'operation' (if present).

* Returns { label, id } pairs — label is the display name, id is the option's id field

* (used to construct the tool ID as `{blockType}_{id}`).

* Parses the subBlocks array using brace/bracket counting to safely traverse

* the nested structure without eval or a full AST parser.

*/

function extractOperationsFromContent(blockContent: string): { label: string; id: string }[] {

const subBlocksMatch = /subBlocks\s*:\s*\[/.exec(blockContent)

if (!subBlocksMatch) return []

// Locate the opening '[' of the subBlocks array

const arrayStart = subBlocksMatch.index + subBlocksMatch[0].length - 1

const arrayEnd = findMatchingClose(blockContent, arrayStart, '[', ']')

if (arrayEnd === -1) return []

const subBlocksContent = blockContent.substring(arrayStart + 1, arrayEnd - 1)

// Iterate over top-level objects in the subBlocks array, looking for id: 'operation'

let i = 0

while (i < subBlocksContent.length) {

if (subBlocksContent[i] === '{') {

const j = findMatchingClose(subBlocksContent, i)

if (j === -1) break

const objContent = subBlocksContent.substring(i, j)

if (/\bid\s*:\s*['"]operation['"]/.test(objContent)) {

const optionsMatch = /options\s*:\s*\[/.exec(objContent)

if (!optionsMatch) return []

const optArrayStart = optionsMatch.index + optionsMatch[0].length - 1

const optArrayEnd = findMatchingClose(objContent, optArrayStart, '[', ']')

if (optArrayEnd === -1) return []

const optionsContent = objContent.substring(optArrayStart + 1, optArrayEnd - 1)

// Extract { label, id } pairs from each option object

const pairs: { label: string; id: string }[] = []

const optionObjectRegex = /\{[^{}]*\}/g

let m

while ((m = optionObjectRegex.exec(optionsContent)) !== null) {

const optObj = m[0]

const labelMatch = /label\s*:\s*['"]([^'"]+)['"]/.exec(optObj)

const idMatch = /\bid\s*:\s*['"]([^'"]+)['"]/.exec(optObj)

if (labelMatch) {

pairs.push({ label: labelMatch[1], id: idMatch ? idMatch[1] : '' })

}

}

return pairs

}

i = j

} else {

i++

}

}

return []

}

/**

* Extract a mapping from operation id → tool id by scanning switch/case/return

* patterns in a block file. Handles both simple returns and ternary returns

* (for ternaries, takes the last quoted tool-like string, which is typically

* the default/list variant). Also picks up named helper functions referenced

* from tools.config.tool (e.g. selectGmailToolId).

*/

function extractSwitchCaseToolMapping(fileContent: string): Map<string, string> {

const mapping = new Map<string, string>()

const caseRegex = /\bcase\s+['"]([^'"]+)['"]\s*:/g

let caseMatch: RegExpExecArray | null

while ((caseMatch = caseRegex.exec(fileContent)) !== null) {

const opId = caseMatch[1]

if (mapping.has(opId)) continue

const searchStart = caseMatch.index + caseMatch[0].length

const searchEnd = Math.min(searchStart + 300, fileContent.length)

const segment = fileContent.substring(searchStart, searchEnd)

const returnIdx = segment.search(/\breturn\b/)

if (returnIdx === -1) continue

const afterReturn = segment.substring(returnIdx + 'return'.length)

// Limit scope to before the next case/default to avoid capturing sibling cases

const nextCaseIdx = afterReturn.search(/\bcase\b|\bdefault\b/)

const returnScope = nextCaseIdx > 0 ? afterReturn.substring(0, nextCaseIdx) : afterReturn

const toolMatches = [...returnScope.matchAll(/['"]([a-z][a-z0-9_]+)['"]/g)]

// Take the last tool-like string (underscore = tool ID pattern); for ternaries this

// is the fallback/list variant

const toolId = toolMatches

.map((m) => m[1])

.filter((id) => id.includes('_'))

.pop()

if (toolId) {

mapping.set(opId, toolId)

}

}

return mapping

}

/**

* Scan all tool files under apps/sim/tools/ and build a map from tool ID to description.

* Used to enrich operation entries with descriptions.

*/

interface ToolMaps {

desc: Map<string, string>

name: Map<string, string>

}

async function buildToolDescriptionMap(): Promise<ToolMaps> {

const toolsDir = path.join(rootDir, 'apps/sim/tools')

const desc = new Map<string, string>()

const name = new Map<string, string>()

try {

const toolFiles = await glob(`${toolsDir}/**/*.ts`)

for (const file of toolFiles) {

const basename = path.basename(file)

if (basename === 'index.ts' || basename === 'types.ts') continue

const content = fs.readFileSync(file, 'utf-8')

// Find every `id: 'tool_id'` occurrence in the file. For each, search

// the next ~600 characters for `name:` and `description:` fields, cutting

// off at the first `params:` block within that window. This handles both

// the simple inline pattern (id → description → params in one object) and

// the two-step pattern (base object holds params, ToolConfig export holds

// id + description after the base object).

const idRegex = /\bid\s*:\s*['"]([^'"]+)['"]/g

let idMatch: RegExpExecArray | null

while ((idMatch = idRegex.exec(content)) !== null) {

const toolId = idMatch[1]

if (desc.has(toolId)) continue

const windowStart = idMatch.index

const windowEnd = Math.min(windowStart + 600, content.length)

const window = content.substring(windowStart, windowEnd)

// Stop before any params block so we don't pick up param-level values

const paramsOffset = window.search(/\bparams\s*:\s*\{/)

const searchWindow = paramsOffset > 0 ? window.substring(0, paramsOffset) : window

const descMatch = searchWindow.match(/\bdescription\s*:\s*['"]([^'"]{5,})['"]/)

const nameMatch = searchWindow.match(/\bname\s*:\s*['"]([^'"]+)['"]/)

if (descMatch) desc.set(toolId, descMatch[1])

if (nameMatch) name.set(toolId, nameMatch[1])

}

}

} catch {

// Non-fatal: descriptions will be empty strings

}

return { desc, name }

}

/**

* Detect the authentication type from block content.

* Returns 'oauth' if the block uses oauth-input credentials,

* 'api-key' if it uses a plain API key field, or 'none' otherwise.

*/

function extractAuthType(blockContent: string): 'oauth' | 'api-key' | 'none' {

if (/type\s*:\s*['"]oauth-input['"]/.test(blockContent)) return 'oauth'

if (/\bid\s*:\s*['"](?:apiKey|api_key|accessToken)['"]/.test(blockContent)) return 'api-key'

return 'none'

}

/**

* Extract the list of trigger IDs from the block's `triggers.available` array.

* Handles blocks that declare `triggers: { enabled: true, available: [...] }`.

*/

function extractTriggersAvailable(blockContent: string): string[] {

const triggersMatch = /\btriggers\s*:\s*\{/.exec(blockContent)

if (!triggersMatch) return []

const start = triggersMatch.index + triggersMatch[0].length - 1

const trigEnd = findMatchingClose(blockContent, start)

if (trigEnd === -1) return []

const triggersContent = blockContent.substring(start, trigEnd)

if (!/enabled\s*:\s*true/.test(triggersContent)) return []

const availableMatch = /available\s*:\s*\[/.exec(triggersContent)

if (!availableMatch) return []

const arrayStart = availableMatch.index + availableMatch[0].length - 1

const arrayEnd = findMatchingClose(triggersContent, arrayStart, '[', ']')

if (arrayEnd === -1) return []

const arrayContent = triggersContent.substring(arrayStart + 1, arrayEnd - 1)

const ids: string[] = []

const idRegex = /['"]([^'"]+)['"]/g

let m

while ((m = idRegex.exec(arrayContent)) !== null) {

ids.push(m[1])

}

return ids

}

/**

* Scan all trigger definition files and build a registry mapping trigger IDs

* to their human-readable name and description.

*/

async function buildTriggerRegistry(): Promise<Map<string, TriggerInfo>> {

const registry = new Map<string, TriggerInfo>()

const SKIP = new Set(['index.ts', 'registry.ts', 'types.ts', 'constants.ts', 'utils.ts'])

const triggerFiles = (await glob(`${TRIGGERS_PATH}/**/*.ts`)).filter(

(f) => !SKIP.has(path.basename(f)) && !f.includes('.test.')

)

for (const file of triggerFiles) {

try {

const content = fs.readFileSync(file, 'utf-8')

// A file may export multiple TriggerConfig objects (e.g. v1 + v2 in

// the same file). Extract all exported configs by splitting on the

// export boundaries and parsing each one independently.

const exportRegex = /export\s+const\s+\w+\s*:\s*TriggerConfig\s*=\s*\{/g

let exportMatch

const exportStarts: number[] = []

while ((exportMatch = exportRegex.exec(content)) !== null) {

exportStarts.push(exportMatch.index)

}

// If no typed exports found, fall back to simple regex on whole file

const segments =

exportStarts.length > 0

? exportStarts.map((start, i) => content.substring(start, exportStarts[i + 1]))

: [content]

for (const segment of segments) {

const idMatch = /\bid\s*:\s*['"]([^'"]+)['"]/.exec(segment)

const nameMatch = /\bname\s*:\s*['"]([^'"]+)['"]/.exec(segment)

const descMatch = /\bdescription\s*:\s*['"]([^'"]+)['"]/.exec(segment)

if (idMatch && nameMatch) {

registry.set(idMatch[1], {

id: idMatch[1],

name: nameMatch[1],

description: descMatch?.[1] ?? '',

})

}

}

} catch {

// skip unreadable files silently

}

}

console.log(`✓ Loaded ${registry.size} trigger definitions`)

return registry

}

/**

* Write the icon mapping TypeScript file for the landing integrations page.

* Mirrors writeIconMapping but targets the sim app so it imports from @/components/icons.

*/

function writeIntegrationsIconMapping(iconMapping: Record<string, string>): void {

try {

if (!fs.existsSync(LANDING_INTEGRATIONS_DATA_PATH)) {

fs.mkdirSync(LANDING_INTEGRATIONS_DATA_PATH, { recursive: true })

}

const iconMappingPath = path.join(LANDING_INTEGRATIONS_DATA_PATH, 'icon-mapping.ts')

const iconNames = [...new Set(Object.values(iconMapping))].sort(biomeSortCompare)

const imports = iconNames.map((icon) => ` ${icon},`).join('\n')

const mappingEntries = Object.entries(iconMapping)

.sort(([a], [b]) => a.localeCompare(b))

.map(([blockType, iconName]) => ` ${blockType}: ${iconName},`)

.join('\n')

const content = `// Auto-generated file - do not edit manually

// Generated by scripts/generate-docs.ts

// Maps block types to their icon component references for the integrations page

import type { ComponentType, SVGProps } from 'react'

import {

${imports}

} from '@/components/icons'

type IconComponent = ComponentType<SVGProps<SVGSVGElement>>

export const blockTypeToIconMap: Record<string, IconComponent> = {

${mappingEntries}

}

`

fs.writeFileSync(iconMappingPath, content)

console.log('✓ Integration icon mapping written to landing app')

} catch (error) {

console.error('Error writing integration icon mapping:', error)

}

}

/**

* Collect all integration entries from block definitions and write integrations.json

* to the landing integrations page data directory.

* Applies the same visibility filters as the docs generation pipeline.

*/

async function writeIntegrationsJson(iconMapping: Record<string, string>): Promise<void> {

try {

if (!fs.existsSync(LANDING_INTEGRATIONS_DATA_PATH)) {

fs.mkdirSync(LANDING_INTEGRATIONS_DATA_PATH, { recursive: true })

}

const triggerRegistry = await buildTriggerRegistry()

const { desc: toolDescMap, name: toolNameMap } = await buildToolDescriptionMap()

const integrations: IntegrationEntry[] = []

const seenBaseTypes = new Set<string>()

const blockFiles = (await glob(`${BLOCKS_PATH}/*.ts`)).sort()

for (const blockFile of blockFiles) {

const fileContent = fs.readFileSync(blockFile, 'utf-8')

const switchCaseMap = extractSwitchCaseToolMapping(fileContent)

const configs = extractAllBlockConfigs(fileContent)

for (const config of configs) {

const blockType = config.type

// Apply the same filters as docs/icon-mapping generation

if (

blockType.includes('_trigger') ||

blockType.includes('_webhook') ||

blockType.includes('rss') ||

(config.category === 'blocks' && blockType !== 'memory' && blockType !== 'knowledge') ||

blockType === 'evaluator' ||

blockType === 'number' ||

blockType === 'webhook' ||

blockType === 'schedule' ||

blockType === 'mcp' ||

blockType === 'generic_webhook'

) {

continue

}

// Deduplicate by stripped base type

const baseType = stripVersionSuffix(blockType)

if (seenBaseTypes.has(baseType)) continue

seenBaseTypes.add(baseType)

const iconName = (config as any).iconName || iconMapping[blockType] || ''

const rawOps: { label: string; id: string }[] = (config as any).operations || []

// Enrich each operation with a description from the tool registry.

// Lookup order:

// 1. Derive toolId as `{baseType}_{operationId}` and check directly.

// 2. Check switch/case mapping parsed from tools.config.tool (handles

// cases where op IDs differ from tool IDs, e.g. get_carts → list_carts,

// or send_gmail → gmail_send).

// 3. Find the tool in tools.access whose name exactly matches the label.

const toolsAccess: string[] = (config as any).tools?.access || []

const operations: OperationInfo[] = rawOps.map(({ label, id }) => {

const toolId = `${baseType}_${id}`

let opDesc = toolDescMap.get(toolId) || toolDescMap.get(id) || ''

if (!opDesc) {

const switchMappedId = switchCaseMap.get(id)

if (switchMappedId) {

opDesc = toolDescMap.get(switchMappedId) || ''

// Also check versioned variants in tools.access (e.g. gmail_send_v2)

if (!opDesc) {

for (const tId of toolsAccess) {

if (tId === switchMappedId || tId.startsWith(`${switchMappedId}_v`)) {

opDesc = toolDescMap.get(tId) || ''

if (opDesc) break

}

}

}

}

}

if (!opDesc && toolsAccess.length > 0) {

for (const tId of toolsAccess) {

if (toolNameMap.get(tId)?.toLowerCase() === label.toLowerCase()) {

opDesc = toolDescMap.get(tId) || ''

if (opDesc) break

}

}

}

return { name: label, description: opDesc }

})

const triggerIds: string[] = (config as any).triggerIds || []

const triggers: TriggerInfo[] = triggerIds

.map((id) => triggerRegistry.get(id))

.filter((t): t is TriggerInfo => t !== undefined)

const docsUrl = (config as any).docsLink || `https://docs.sim.ai/tools/${baseType}`

const slug = config.name

.toLowerCase()

.replace(/[^a-z0-9]+/g, '-')

.replace(/^-|-$/g, '')

const authType = extractAuthType(fileContent)

integrations.push({

type: blockType,

slug,

name: config.name,

description: config.description,

longDescription: config.longDescription || '',

bgColor: config.bgColor || '#6B7280',

iconName,

docsUrl,

operations,

operationCount: operations.length,

triggers,

triggerCount: triggers.length,

authType,

category: config.category,

...(config.integrationType || config.tags

? {

integrationTypes: deriveIntegrationTypes(

config.integrationType || null,

config.tags || []

),

}

: {}),

...(config.tags ? { tags: config.tags } : {}),

})

}

}

// Sort alphabetically by name for a predictable, crawl-friendly order

integrations.sort((a, b) => a.name.localeCompare(b.name))

const jsonPath = path.join(LANDING_INTEGRATIONS_DATA_PATH, 'integrations.json')

// JSON.stringify always expands arrays across multiple lines. Biome's formatter

// collapses short arrays of primitives onto single lines. Post-process to match.

const json = JSON.stringify(integrations, null, 2).replace(

/\[\n(\s+"[^"\n]*"(?:,\n\s+"[^"\n]*")*)\n\s+\]/g,

(_match, inner) => {

const items = (inner as string).split(',\n').map((s: string) => s.trim())

return `[${items.join(', ')}]`

}

)

fs.writeFileSync(jsonPath, `${json}\n`)

console.log(`✓ Integration data written: ${integrations.length} integrations → ${jsonPath}`)

} catch (error) {

console.error('Error writing integrations JSON:', error)

}

}

/**

* Extract ALL block configs from a file, filtering out hidden blocks

*/

function extractAllBlockConfigs(fileContent: string): BlockConfig[] {

const configs: BlockConfig[] = []

// First, extract the primary icon from the file (for V2 blocks that inherit via spread)

const primaryIcon = extractIconNameFromContent(fileContent)

// Find all block exports in the file

const exportRegex = /export\s+const\s+(\w+)Block\s*:\s*BlockConfig[^=]*=\s*\{/g

let match

while ((match = exportRegex.exec(fileContent)) !== null) {

const blockName = match[1]

const startIndex = match.index + match[0].length - 1 // Position of opening brace

// Extract the block content by matching braces

const endIndex = findMatchingClose(fileContent, startIndex)

if (endIndex !== -1) {

const blockContent = fileContent.substring(startIndex, endIndex)

// Check if this block has hideFromToolbar: true

const hideFromToolbar = /hideFromToolbar\s*:\s*true/.test(blockContent)

if (hideFromToolbar) {

console.log(`Skipping ${blockName}Block - hideFromToolbar is true`)

continue

}

// Pass fileContent to enable spread inheritance resolution

const config = extractBlockConfigFromContent(blockContent, blockName, fileContent)

if (config) {

// For V2 blocks that don't have an explicit icon, use the primary icon from the file

if (!config.iconName && primaryIcon) {

;(config as any).iconName = primaryIcon

}

configs.push(config)

}

}

}

return configs

}

/**

* Extract the name of the spread base block (e.g., "GitHubBlock" from "...GitHubBlock")

*/

function extractSpreadBase(blockContent: string): string | null {

const spreadMatch = blockContent.match(/^\s*\.\.\.(\w+Block)\s*,/m)

return spreadMatch ? spreadMatch[1] : null

}

/**

* Extract block config from a specific block's content

* If the block uses spread inheritance (e.g., ...GitHubBlock), attempts to resolve

* missing properties from the base block in the file content.

*/

function extractBlockConfigFromContent(

blockContent: string,

blockName: string,

fileContent?: string

): BlockConfig | null {

try {

// Check for spread inheritance

const spreadBase = extractSpreadBase(blockContent)

let baseConfig: BlockConfig | null = null

if (spreadBase && fileContent) {

// Extract the base block's content from the file

const baseBlockRegex = new RegExp(

`export\\s+const\\s+${spreadBase}\\s*:\\s*BlockConfig[^=]*=\\s*\\{`,

'g'

)

const baseMatch = baseBlockRegex.exec(fileContent)

if (baseMatch) {

const startIndex = baseMatch.index + baseMatch[0].length - 1

const endIndex = findMatchingClose(fileContent, startIndex)

if (endIndex !== -1) {

const baseBlockContent = fileContent.substring(startIndex, endIndex)

// Recursively extract base config (but don't pass fileContent to avoid infinite loops)

baseConfig = extractBlockConfigFromContent(

baseBlockContent,

spreadBase.replace('Block', '')

)

}

}

}

// Extract properties from this block, using topLevelOnly=true for main properties

const blockType =

extractStringPropertyFromContent(blockContent, 'type', true) || blockName.toLowerCase()

const name =

extractStringPropertyFromContent(blockContent, 'name', true) ||

baseConfig?.name ||

`${blockName} Block`

const description =

extractStringPropertyFromContent(blockContent, 'description', true) ||

baseConfig?.description ||

''

const longDescription =

extractStringPropertyFromContent(blockContent, 'longDescription', true) ||

baseConfig?.longDescription ||

''

const category =

extractStringPropertyFromContent(blockContent, 'category', true) ||

baseConfig?.category ||

'misc'

const bgColor =

extractStringPropertyFromContent(blockContent, 'bgColor', true) ||

baseConfig?.bgColor ||

'#F5F5F5'

const iconName = extractIconNameFromContent(blockContent) || (baseConfig as any)?.iconName || ''

const outputs = extractOutputsFromContent(blockContent)

const toolsAccess = extractToolsAccessFromContent(blockContent)

// For tools.access, if not found directly, check if it's derived from base via map

let finalToolsAccess = toolsAccess

if (toolsAccess.length === 0 && baseConfig?.tools?.access) {

// Check if there's a map operation on base tools

// Pattern: access: (SomeBlock.tools?.access || []).map((toolId) => `${toolId}_v2`)

const mapMatch = blockContent.match(

/access\s*:\s*\(\s*\w+Block\.tools\?\.access\s*\|\|\s*\[\]\s*\)\.map\s*\(\s*\(\s*\w+\s*\)\s*=>\s*`\$\{\s*\w+\s*\}_v(\d+)`\s*\)/

)

if (mapMatch) {

// V2 block - append the version suffix to base tools

const versionSuffix = `_v${mapMatch[1]}`

finalToolsAccess = baseConfig.tools.access.map((tool) => `${tool}${versionSuffix}`)

}

}

const operations = extractOperationsFromContent(blockContent)

const triggerIds = extractTriggersAvailable(blockContent)

const docsLink =

extractStringPropertyFromContent(blockContent, 'docsLink', true) ||

baseConfig?.docsLink ||

`https://docs.sim.ai/tools/${stripVersionSuffix(blockType)}`

const integrationType =

extractEnumPropertyFromContent(blockContent, 'integrationType') ||

baseConfig?.integrationType ||

null

const tags = extractArrayPropertyFromContent(blockContent, 'tags') || baseConfig?.tags || null

return {

type: blockType,

name,

description,

longDescription,

category,

bgColor,

iconName,

outputs,

tools: {

access: finalToolsAccess.length > 0 ? finalToolsAccess : baseConfig?.tools?.access || [],

},

operations: operations.length > 0 ? operations : (baseConfig as any)?.operations || [],

triggerIds: triggerIds.length > 0 ? triggerIds : (baseConfig as any)?.triggerIds || [],

docsLink,

...(integrationType ? { integrationType } : {}),

...(tags ? { tags } : {}),

}

} catch (error) {

console.error(`Error extracting block configuration for ${blockName}:`, error)

return null

}

}

/**

* Strip version suffix (e.g., _v2, _v3) from a type for display purposes

* The internal type remains unchanged for icon mapping

*/

function stripVersionSuffix(type: string): string {

return type.replace(/_v\d+$/, '')

}

/**

* Extract a string property from block content.

* For top-level properties like 'description', only looks in the portion before nested objects

* to avoid matching properties inside nested structures like outputs.

*/

function extractStringPropertyFromContent(

content: string,

propName: string,

topLevelOnly = false

): string | null {

let searchContent = content

// For top-level properties, only search before nested objects like outputs, tools, inputs, subBlocks

if (topLevelOnly) {

const nestedObjectPatterns = [

/\boutputs\s*:\s*\{/,

/\btools\s*:\s*\{/,

/\binputs\s*:\s*\{/,

/\bsubBlocks\s*:\s*\[/,

/\btriggers\s*:\s*\{/,

]

let cutoffIndex = content.length

for (const pattern of nestedObjectPatterns) {

const match = content.match(pattern)

if (match && match.index !== undefined && match.index < cutoffIndex) {

cutoffIndex = match.index

}

}

searchContent = content.substring(0, cutoffIndex)

}

const singleQuoteMatch = searchContent.match(new RegExp(`${propName}\\s*:\\s*'([^']*)'`, 'm'))

if (singleQuoteMatch) return singleQuoteMatch[1]

const doubleQuoteMatch = searchContent.match(new RegExp(`${propName}\\s*:\\s*"([^"]*)"`, 'm'))

if (doubleQuoteMatch) return doubleQuoteMatch[1]

const templateMatch = searchContent.match(new RegExp(`${propName}\\s*:\\s*\`([^\`]+)\``, 's'))

if (templateMatch) {

let templateContent = templateMatch[1]

templateContent = templateContent.replace(/\$\{[^}]+\}/g, '')

templateContent = templateContent.replace(/\s+/g, ' ').trim()

return templateContent

}

return null

}

/**

* Tag-to-category mapping used by deriveIntegrationTypes to expand a block's

* primary integrationType into a full set of categories for the landing page.

*/

const TAG_TO_CATEGORIES: Record<string, string[]> = {

llm: ['ai'],

agentic: ['ai'],

'image-generation': ['ai', 'design'],

'video-generation': ['ai', 'design'],

'text-to-speech': ['ai'],

'speech-to-text': ['ai'],

ocr: ['ai', 'documents'],

'vector-search': ['ai', 'search'],

'document-processing': ['documents'],

'content-management': ['documents'],

'e-signatures': ['documents'],

'note-taking': ['productivity', 'documents'],

'knowledge-base': ['documents', 'search'],

'data-analytics': ['analytics'],

seo: ['analytics', 'search'],

monitoring: ['developer-tools', 'analytics'],

'error-tracking': ['developer-tools'],

'incident-management': ['developer-tools'],

'version-control': ['developer-tools'],

'ci-cd': ['developer-tools'],

'feature-flags': ['developer-tools'],

messaging: ['communication'],

meeting: ['communication', 'productivity'],

calendar: ['productivity'],

scheduling: ['productivity'],

'project-management': ['productivity'],

ticketing: ['productivity', 'customer-support'],

forms: ['productivity'],

spreadsheet: ['productivity', 'databases'],

'data-warehouse': ['databases'],

cloud: ['developer-tools'],

'web-scraping': ['search'],

'sales-engagement': ['sales'],

enrichment: ['sales'],

'email-marketing': ['email'],

marketing: ['analytics'],

payments: ['ecommerce'],

subscriptions: ['ecommerce'],

hiring: ['hr'],

identity: ['security'],

'secrets-management': ['security'],

'customer-support': ['customer-support'],

webhooks: ['developer-tools'],

automation: ['developer-tools'],

}

/**

* Derive the full list of integration type categories from a block's primary

* integrationType and its tags. The primary type is always first; additional

* categories are inferred from tags via TAG_TO_CATEGORIES.

*/

function deriveIntegrationTypes(primaryType: string | null, tags: string[]): string[] {

const types = new Set<string>()

if (primaryType) {

types.add(primaryType)

}