import { program } from 'commander'

import fs from 'fs/promises'

import path from 'path'

import chalk from 'chalk'

import { execFileSync } from 'child_process'

import walkFiles from '@/workflows/walk-files.js'

import readFrontmatter from '@/frame/lib/read-frontmatter.js'

import { contentTypesEnum } from '@/frame/lib/frontmatter'

const CONTENT_TYPES = contentTypesEnum.filter(

(type) => type !== 'homepage' && type !== 'other' && type !== 'landing',

const PRODUCT_LEVEL_PATH_SEGMENTS = 3

const contentTypeToDir = (contentType: string): string => {

return contentType === 'rai' ? 'responsible-use' : contentType

const validContentTypeDirs = new Set(CONTENT_TYPES.map(contentTypeToDir))

function shouldSkipIndexFile(filePath: string): boolean {

function calculateTarget(filePath: string, contentType: string, productDir: string) {

interface FileMove {

.name('content-type-based-move')

.description('Reorganize content files into subdirectories based on their contentType property')

.argument('[paths...]', 'Content paths to process')

.action(async (paths: string[]) => {

const filesToProcess: string[] = []

if (paths?.length > 0) {

for (const p of paths) {

const stats = await fs.stat(p)

if (stats.isDirectory()) {

filesToProcess.push(...(await walkFiles(p, ['.md'])))

} else if (p.endsWith('.md')) {

filesToProcess.push(p)

}

}

} else {

filesToProcess.push(...(await walkFiles(path.join(process.cwd(), 'content'), ['.md'])))

}

console.log(chalk.white(`Processing ${filesToProcess.length} files...\n`))

console.log(chalk.white('Analyzing files...\n'))

const filesToMove: FileMove[] = []

const skipped: Array<{ file: string; reason: string }> = []

const targetDirs = new Set<string>()

const subdirTargets = new Set<string>()

const productDirs = new Set<string>()

const productsWithRai = new Set<string>()

for (const filePath of filesToProcess) {

const relativePath = path.relative(process.cwd(), filePath)

try {

if (path.basename(filePath) === 'index.md' && shouldSkipIndexFile(filePath)) {

continue

}

const fileContent = await fs.readFile(filePath, 'utf-8')

const { data } = readFrontmatter(fileContent)

if (!data?.contentType) {

skipped.push({ file: relativePath, reason: 'No contentType property found' })

console.log(chalk.yellow(`⚠ Skipping ${relativePath}: No contentType property`))

continue

}

const contentType = data.contentType as string

const parts = relativePath.split(path.sep)

const contentIndex = parts.indexOf('content')

// Landing pages belong at product-level index.md files; this script does not move them.

if (contentType === 'landing') {

console.log(chalk.gray(`→ Skipping ${relativePath}: landing pages don't move`))

continue

}

if (!CONTENT_TYPES.includes(contentType)) {

skipped.push({ file: relativePath, reason: `Invalid contentType: ${contentType}` })

console.log(

chalk.yellow(`⚠ Skipping ${relativePath}: Invalid contentType "${contentType}"`),

)

continue

}

if (contentIndex === -1 || contentIndex + 1 >= parts.length) {

console.log(

chalk.yellow(`⚠ Skipping ${relativePath}: Cannot determine product directory`),

)

continue

}

const productName = parts[contentIndex + 1]

const productDir = path.join(process.cwd(), 'content', productName)

productDirs.add(productDir)

if (contentType === 'rai') productsWithRai.add(productName)

const { targetDir, targetPath } = calculateTarget(filePath, contentType, productDir)

if (path.dirname(filePath) === targetDir) continue

try {

await fs.access(targetPath)

skipped.push({ file: relativePath, reason: 'Target already exists' })

console.log(chalk.yellow(`⚠ Skipping ${relativePath}: Target file already exists`))

continue

} catch {

// Missing target means the move can proceed.

}

filesToMove.push({ filePath, targetDir, targetPath, contentType })

const relativeTargetDir = path.relative(process.cwd(), targetDir)

targetDirs.add(relativeTargetDir)

if (

path.basename(filePath) === 'index.md' &&

relativeTargetDir.split(path.sep).length > PRODUCT_LEVEL_PATH_SEGMENTS

) {

subdirTargets.add(relativeTargetDir)

}

} catch (error) {

if (error instanceof Error) {

console.error(

chalk.red(`✗ Error analyzing ${relativePath}: ${error.message}\n${error.stack}`),

)

} else {

console.error(chalk.red(`✗ Error analyzing ${relativePath}: ${String(error)}`))

}

skipped.push({ file: relativePath, reason: `Error: ${error}` })

}

}

console.log(chalk.white('Ensuring standard content-type directories exist...\n'))

if (paths?.length > 0) {

for (const p of paths) {

const fullPath = path.resolve(process.cwd(), p)

const relativePath = path.relative(process.cwd(), fullPath)

const parts = relativePath.split(path.sep)

const contentIndex = parts.indexOf('content')

if (contentIndex !== -1 && contentIndex + 1 < parts.length) {

const productName = parts[contentIndex + 1]

for (const ct of CONTENT_TYPES.filter((t) => t !== 'rai' && t !== 'landing')) {

targetDirs.add(path.join('content', productName, contentTypeToDir(ct)))

}

if (productsWithRai.has(productName)) {

targetDirs.add(path.join('content', productName, 'responsible-use'))

}

}

}

}

console.log(chalk.white('Creating placeholder index.md files...\n'))

const newPlaceholders: string[] = []

const titleMap: Record<string, string> = {

'get-started': 'Get started',

concepts: 'Concepts',

'how-tos': 'How-tos',

reference: 'Reference',

tutorials: 'Tutorials',

'responsible-use': 'Responsible use',

}

for (const dirPath of targetDirs) {

const absoluteDirPath = path.join(process.cwd(), dirPath)

const indexPath = path.join(absoluteDirPath, 'index.md')

try {

await fs.access(indexPath)

console.log(chalk.gray(`- Skipping ${dirPath}/index.md (already exists)`))

} catch {

// Create placeholders only for top-level content-type directories.

if (dirPath.split(path.sep).length > PRODUCT_LEVEL_PATH_SEGMENTS) continue

// Moved index.md files become the placeholder for their target directory.

if (subdirTargets.has(dirPath)) {

console.log(chalk.gray(`- Skipping ${dirPath}/index.md (will be moved)`))

continue

}

const contentTypeName = path.basename(dirPath)

const title = titleMap[contentTypeName] || contentTypeName

const placeholderContentType =

contentTypeName === 'responsible-use' ? 'rai' : contentTypeName

const content = `---

await fs.mkdir(absoluteDirPath, { recursive: true })

await fs.writeFile(indexPath, content, 'utf-8')

newPlaceholders.push(indexPath)

console.log(chalk.green(`✓ Created ${dirPath}/index.md`))

}

}

// This step used to shell out to `npm run ai-tools`. Those scripts now live

// in github/technical-content at .github/scripts/ai-tools, so the intros are

// generated as a separate step and the paths are reported here.

const placeholdersNeedingIntros: string[] = []

for (const placeholderPath of newPlaceholders) {

try {

const fileContent = await fs.readFile(placeholderPath, 'utf-8')

const { data } = readFrontmatter(fileContent)

if (data?.intro) continue

placeholdersNeedingIntros.push(path.relative(process.cwd(), placeholderPath))

} catch (error) {

const detail = error instanceof Error ? error.message : String(error)

console.error(chalk.yellow(`⚠ Could not read ${placeholderPath}: ${detail}`))

}

}

console.log(chalk.white('\nMoving files...\n'))

const moved: Array<{ file: string; from: string; to: string }> = []

// Move regular files and index.md files in separate groups to avoid path conflicts.

const regularFiles = filesToMove.filter((f) => path.basename(f.filePath) !== 'index.md')

const topLevelIndexFiles = filesToMove.filter((f) => {

if (path.basename(f.filePath) !== 'index.md') return false

return (

path.relative(process.cwd(), f.targetDir).split(path.sep).length ===

PRODUCT_LEVEL_PATH_SEGMENTS

)

})

const subdirIndexFiles = filesToMove.filter((f) => {

if (path.basename(f.filePath) !== 'index.md') return false

return (

path.relative(process.cwd(), f.targetDir).split(path.sep).length >

PRODUCT_LEVEL_PATH_SEGMENTS

)

})

// Copy subdirectory index.md files first; delete sources after regular files move.

const indexFilesToDeleteLater: string[] = []

for (const file of subdirIndexFiles) {

try {

await fs.mkdir(file.targetDir, { recursive: true })

const content = await fs.readFile(file.filePath, 'utf-8')

const { data, content: body } = readFrontmatter(content)

// Clear children because the new content-type directory structure invalidates child paths.

if (data?.children) data.children = []

await fs.writeFile(

file.targetPath,

readFrontmatter.stringify(body || '', data || {}),

'utf-8',

)

indexFilesToDeleteLater.push(file.filePath)

moved.push({

file: path.relative(process.cwd(), file.filePath),

from: path.relative(process.cwd(), file.filePath),

to: path.relative(process.cwd(), file.targetPath),

})

console.log(chalk.green(`✓ Copied ${path.relative(process.cwd(), file.filePath)}`))

} catch (error) {

skipped.push({

file: path.relative(process.cwd(), file.filePath),

reason: `Error: ${error}`,

})

console.log(

chalk.red(`✗ Error copying ${path.relative(process.cwd(), file.filePath)}: ${error}`),

)

}

}

for (const file of regularFiles) {

try {

await fs.mkdir(file.targetDir, { recursive: true })

const relativeFilePath = path.relative(process.cwd(), file.filePath)

const relativeTargetPath = path.relative(process.cwd(), file.targetPath)

execFileSync(

'npm',

['run', 'move-content', '--', relativeFilePath, relativeTargetPath, '--no-git'],

{

cwd: process.cwd(),

stdio: 'inherit',

},

)

moved.push({ file: relativeFilePath, from: relativeFilePath, to: relativeTargetPath })

console.log(chalk.green(`✓ Moved ${relativeFilePath}`))

} catch (error) {

skipped.push({

file: path.relative(process.cwd(), file.filePath),

reason: `Error: ${error}`,

})

console.log(

chalk.red(`✗ Error moving ${path.relative(process.cwd(), file.filePath)}: ${error}`),

)

}

}

for (const sourcePath of indexFilesToDeleteLater) {

try {

await fs.unlink(sourcePath)

console.log(chalk.gray(`✓ Deleted source ${path.relative(process.cwd(), sourcePath)}`))

} catch (error) {

console.log(chalk.yellow(`⚠ Could not delete ${sourcePath}: ${error}`))

}

}

for (const file of topLevelIndexFiles) {

try {

await fs.mkdir(file.targetDir, { recursive: true })

await fs.copyFile(file.filePath, file.targetPath)

await fs.unlink(file.filePath)

moved.push({

file: path.relative(process.cwd(), file.filePath),

from: path.relative(process.cwd(), file.filePath),

to: path.relative(process.cwd(), file.targetPath),

})

console.log(chalk.green(`✓ Moved ${path.relative(process.cwd(), file.filePath)}`))

} catch (error) {

skipped.push({

file: path.relative(process.cwd(), file.filePath),

reason: `Error: ${error}`,

})

console.log(

chalk.red(`✗ Error moving ${path.relative(process.cwd(), file.filePath)}: ${error}`),

)

}

}

console.log(

chalk.white('\nCleaning up old directories and updating parent index.md files...\n'),

)

const deletedByProduct = new Map<string, string[]>()

for (const productDir of productDirs) {

const productName = path.basename(productDir)

const retainedChildren = new Set<string>()

try {

const entries = await fs.readdir(productDir, { withFileTypes: true })

for (const entry of entries) {

if (entry.isDirectory() && !validContentTypeDirs.has(entry.name)) {

const oldDirPath = path.join(productDir, entry.name)

const relativeOldDirPath = path.relative(process.cwd(), oldDirPath)

try {

// Unmoved articles and typed indexes would be lost; untyped category indexes go with the directory.

const remaining: string[] = []

for (const file of walkFiles(oldDirPath, ['.md'], { includeEarlyAccess: true })) {

if (path.basename(file) !== 'index.md') {

remaining.push(file)

continue

}

const { data } = readFrontmatter(await fs.readFile(file, 'utf-8'))

if (!data || data.contentType) remaining.push(file)

}

if (remaining.length > 0) {

const examples = remaining

.slice(0, 3)

.map((file) => path.relative(process.cwd(), file))

.join(', ')

console.log(

chalk.yellow(

`⚠ Not deleting ${relativeOldDirPath}: ${remaining.length} unmoved articles remain (${examples})`,

),

)

skipped.push({

file: relativeOldDirPath,

reason: `Not deleted: ${remaining.length} unmoved articles remain`,

})

try {

await fs.access(path.join(oldDirPath, 'index.md'))

retainedChildren.add(`/${entry.name}`)

} catch {

// A category without an index cannot be listed as a child.

}

continue

}

await fs.rm(oldDirPath, { recursive: true, force: true })

console.log(chalk.gray(`✓ Deleted old directory: ${relativeOldDirPath}`))

if (!deletedByProduct.has(productName)) deletedByProduct.set(productName, [])

deletedByProduct.get(productName)!.push(`/${productName}/${entry.name}`)

} catch (error) {

console.log(chalk.yellow(`⚠ Could not delete ${oldDirPath}: ${error}`))

}

}

}

} catch (error) {

console.log(chalk.yellow(`⚠ Could not read product directory ${productDir}: ${error}`))

}

const productIndexPath = path.join(productDir, 'index.md')

try {

const content = await fs.readFile(productIndexPath, 'utf-8')

const { data, content: body } = readFrontmatter(content)

if (data) {

let updated = false

const productRelativePath = path.relative(process.cwd(), productDir)

const newChildren: string[] = []

for (const ct of CONTENT_TYPES.map(contentTypeToDir)) {

const dirPath = path.join(productRelativePath, ct)

if (targetDirs.has(dirPath)) newChildren.push(`/${ct}`)

}

if (newChildren.length > 0) {

// Retained categories stay reachable in the tree until their remaining articles move.

const keptChildren = Array.isArray(data.children)

? data.children.filter((child: string) => retainedChildren.has(child))

: []

data.children = [...newChildren, ...keptChildren]

updated = true

}

const deletedPaths = deletedByProduct.get(productName) || []

if (deletedPaths.length > 0) {

if (!data.redirect_from) data.redirect_from = []

else if (!Array.isArray(data.redirect_from)) data.redirect_from = [data.redirect_from]

for (const deletedPath of deletedPaths) {

if (!data.redirect_from.includes(deletedPath)) {

data.redirect_from.push(deletedPath)

}

}

updated = true

}

if (updated) {

await fs.writeFile(productIndexPath, readFrontmatter.stringify(body, data), 'utf-8')

const changes = []

if (newChildren.length > 0) changes.push(`${newChildren.length} children`)

if (deletedPaths.length > 0) changes.push(`${deletedPaths.length} redirects`)

console.log(

chalk.green(

`✓ Updated ${path.relative(process.cwd(), productIndexPath)} (${changes.join(', ')})`,

),

)

}

}

} catch (error) {

console.log(chalk.yellow(`⚠ Could not update ${productIndexPath}: ${error}`))

}

}

console.log(chalk.white('\nSorting children arrays...\n'))

for (const dirPath of targetDirs) {

const absoluteDirPath = path.join(process.cwd(), dirPath)

const indexPath = path.join(absoluteDirPath, 'index.md')

try {

const content = await fs.readFile(indexPath, 'utf-8')

const { data, content: body } = readFrontmatter(content)

if (!data) continue

// how-tos children point to subdirectories.

if (path.basename(dirPath) === 'how-tos') {

const entries = await fs.readdir(absoluteDirPath, { withFileTypes: true })

const subdirs = entries

.filter((e) => e.isDirectory())

.map((e) => `/${e.name}`)

.sort()

if (subdirs.length > 0) {

data.children = subdirs

await fs.writeFile(indexPath, readFrontmatter.stringify(body, data), 'utf-8')

console.log(

chalk.green(

`✓ Added children to ${path.relative(process.cwd(), indexPath)} (${subdirs.length} subdirectories)`,

),

)

}

}

// Other content types sort about-* pages first.

else if (data.children && Array.isArray(data.children) && data.children.length > 0) {

const sorted = [...data.children].sort((a, b) => {

const aBasename = path.basename(a)

const bBasename = path.basename(b)

const aIsAbout = aBasename.startsWith('about-')

const bIsAbout = bBasename.startsWith('about-')

if (aIsAbout && !bIsAbout) return -1

if (!aIsAbout && bIsAbout) return 1

return aBasename.localeCompare(bBasename)

})

if (JSON.stringify(sorted) !== JSON.stringify(data.children)) {

data.children = sorted

await fs.writeFile(indexPath, readFrontmatter.stringify(body, data), 'utf-8')

console.log(

chalk.green(`✓ Sorted children in ${path.relative(process.cwd(), indexPath)}`),

)

}

}

} catch (error) {

if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {

console.log(chalk.yellow(`⚠ Could not update ${indexPath}: ${error}`))

}

}

}

console.log(chalk.white(`\n${'='.repeat(60)}`))

console.log(chalk.white('Summary:'))

console.log(chalk.white(` Moved: ${moved.length} files`))

console.log(chalk.white(` Skipped: ${skipped.length} files`))

if (newPlaceholders.length > 0) {

console.log(

chalk.cyan(`\nNote: ${newPlaceholders.length} placeholder index.md files were created.`),

)

}

if (placeholdersNeedingIntros.length > 0) {

console.log(

chalk.cyan(`\n${placeholdersNeedingIntros.length} placeholder files still need an intro.`),

)

console.log(chalk.cyan('Generate them from a github/technical-content checkout:'))

console.log(

chalk.gray(

`\n cd .github/scripts && npm run ai-tools -- --prompt intro --write \\\n` +

` --docs-dir ${process.cwd()} \\\n` +

` --files ${placeholdersNeedingIntros.join(' ')}\n`,

),

)

console.log(chalk.cyan('Review the generated intros before committing.'))

}

console.log(chalk.blue('='.repeat(60)))

if (skipped.length > 0) {

console.log(chalk.yellow('\nSkipped files:'))

for (const skip of skipped) {

console.log(chalk.gray(` ${skip.file}: ${skip.reason}`))

}

}

})