@poetora/cli 0.0.1

package/bin/cli.js

@@ -0,0 +1,201 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getBrokenInternalLinks, renameFilesAndUpdateLinksInContent } from '@poetora/link-rot';
+import { addLog, dev, ErrorLog, SpinnerLog, SuccessLog, Logs, clearLogs, BrokenLinksLog, WarningLog, } from '@poetora/previewing';
+import { validate, getOpenApiDocumentFromUrl, isAllowedLocalSchemaUrl } from '@poetora/shared';
+import { render, Text } from 'ink';
+import path from 'path';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { accessibilityCheck } from './accessibilityCheck.js';
+import { checkPort, checkNodeVersion, getVersions, suppressConsoleWarnings, terminate, readLocalOpenApiFile, } from './helpers.js';
+import { init } from './init.js';
+import { mdxLinter } from './mdxLinter.js';
+import { update } from './update.js';
+export const cli = ({ packageName = 'poet' }) => {
+    render(_jsx(Logs, {}));
+    return (yargs(hideBin(process.argv))
+        .scriptName(packageName)
+        .middleware(checkNodeVersion)
+        .middleware(suppressConsoleWarnings)
+        .command('dev', 'initialize a local preview environment', (yargs) => yargs
+        .option('open', {
+        type: 'boolean',
+        default: true,
+        description: 'open a local preview in the browser',
+    })
+        .option('local-schema', {
+        type: 'boolean',
+        default: false,
+        hidden: true,
+        description: 'use a locally hosted schema file (note: only https protocol is supported in production)',
+    })
+        .option('client-version', {
+        type: 'string',
+        hidden: true,
+        description: 'the version of the client to use for cli testing',
+    })
+        .option('groups', {
+        type: 'array',
+        description: 'Mock user groups for local development and testing',
+        example: '--groups admin user',
+    })
+        .option('disable-openapi', {
+        type: 'boolean',
+        default: false,
+        description: 'Disable OpenAPI file generation',
+    })
+        .usage('usage: poetora dev [options]')
+        .example('poetora dev', 'run with default settings (opens in browser)')
+        .example('poetora dev --no-open', 'run without opening in browser'), async (argv) => {
+        let nodeVersionString = process.version;
+        if (nodeVersionString.charAt(0) === 'v') {
+            nodeVersionString = nodeVersionString.slice(1);
+        }
+        const versionArr = nodeVersionString.split('.');
+        const majorVersion = parseInt(versionArr[0], 10);
+        const minorVersion = parseInt(versionArr[1], 10);
+        if (majorVersion >= 25) {
+            addLog(_jsx(ErrorLog, { message: "poet dev is not supported on node versions 25+. Please downgrade to an LTS node version." }));
+            await terminate(1);
+        }
+        if (majorVersion < 20 || (majorVersion === 20 && minorVersion < 17)) {
+            addLog(_jsx(ErrorLog, { message: "poet dev is not supported on node versions below 20.17 Please upgrade to an LTS node version." }));
+            await terminate(1);
+        }
+        const port = await checkPort(argv);
+        const { cli: cliVersion } = getVersions();
+        if (port != undefined) {
+            await dev({
+                ...argv,
+                port,
+                packageName,
+                cliVersion,
+            });
+        }
+        else {
+            addLog(_jsx(ErrorLog, { message: "no available port found" }));
+            await terminate(1);
+        }
+    })
+        .command('openapi-check <filename>', 'check if an OpenAPI spec is valid', (yargs) => yargs
+        .positional('filename', {
+        describe: 'the filename of the OpenAPI spec (e.g. ./openapi.yaml) or the URL to the OpenAPI spec (e.g. https://petstore3.swagger.io/api/v3/openapi.json)',
+        type: 'string',
+        demandOption: true,
+    })
+        .option('local-schema', {
+        type: 'boolean',
+        default: false,
+        description: 'use a locally hosted schema file (note: only https protocol is supported in production)',
+    }), async ({ filename, 'local-schema': localSchema }) => {
+        try {
+            if (isAllowedLocalSchemaUrl(filename, localSchema)) {
+                await getOpenApiDocumentFromUrl(filename);
+                addLog(_jsx(SuccessLog, { message: "OpenAPI definition is valid." }));
+                await terminate(0);
+            }
+            if (filename.startsWith('http://') && !localSchema) {
+                addLog(_jsx(WarningLog, { message: "include the --local-schema flag to check locally hosted OpenAPI files" }));
+                addLog(_jsx(WarningLog, { message: "only https protocol is supported in production" }));
+                await terminate(0);
+            }
+            const document = await readLocalOpenApiFile(filename);
+            if (!document) {
+                throw new Error('failed to parse OpenAPI spec: could not parse file correctly, please check for any syntax errors.');
+            }
+            await validate(document);
+            addLog(_jsx(SuccessLog, { message: "OpenAPI definition is valid." }));
+        }
+        catch (err) {
+            if (err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT') {
+                addLog(_jsx(ErrorLog, { message: `file not found, please check the path provided: ${filename}` }));
+            }
+            else {
+                addLog(_jsx(ErrorLog, { message: err instanceof Error ? err.message : 'unknown error' }));
+            }
+            await terminate(1);
+        }
+        await terminate(0);
+    })
+        .command('broken-links', 'check for invalid internal links', () => undefined, async () => {
+        addLog(_jsx(SpinnerLog, { message: "checking for broken links..." }));
+        try {
+            const brokenLinks = await getBrokenInternalLinks();
+            if (brokenLinks.length === 0) {
+                clearLogs();
+                addLog(_jsx(SuccessLog, { message: "no broken links found" }));
+                await terminate(0);
+            }
+            const brokenLinksByFile = {};
+            brokenLinks.forEach((mdxPath) => {
+                const filename = path.join(mdxPath.relativeDir, mdxPath.filename);
+                const brokenLinksForFile = brokenLinksByFile[filename];
+                if (brokenLinksForFile) {
+                    brokenLinksForFile.push(mdxPath.originalPath);
+                }
+                else {
+                    brokenLinksByFile[filename] = [mdxPath.originalPath];
+                }
+            });
+            clearLogs();
+            addLog(_jsx(BrokenLinksLog, { brokenLinksByFile: brokenLinksByFile }));
+        }
+        catch (err) {
+            addLog(_jsx(ErrorLog, { message: err instanceof Error ? err.message : 'unknown error' }));
+            await terminate(1);
+        }
+        await terminate(1);
+    })
+        .command('rename <from> <to>', 'rename a file and update all internal link references', (yargs) => yargs
+        .positional('from', {
+        describe: 'the file to rename',
+        type: 'string',
+    })
+        .positional('to', {
+        describe: 'the new name for the file',
+        type: 'string',
+    })
+        .demandOption(['from', 'to'])
+        .option('force', {
+        type: 'boolean',
+        default: false,
+        description: 'rename files and skip errors',
+    })
+        .epilog('example: `poetora rename introduction.mdx overview.mdx`'), async ({ from, to, force }) => {
+        await renameFilesAndUpdateLinksInContent(from, to, force);
+        await terminate(0);
+    })
+        .command('update', 'update the CLI to the latest version', () => undefined, async () => {
+        await update({ packageName });
+        await terminate(0);
+    })
+        .command(['a11y', 'accessibility-check', 'a11y-check', 'accessibility'], 'check for accessibility issues in documentation', () => undefined, async () => {
+        const accessibilityCheckTerminateCode = await accessibilityCheck();
+        const mdxLinterTerminateCode = await mdxLinter();
+        await terminate(accessibilityCheckTerminateCode || mdxLinterTerminateCode);
+    })
+        .command(['version', 'v'], 'display the current version of the CLI and client', () => undefined, async () => {
+        const { cli, client } = getVersions();
+        addLog(_jsxs(Text, { children: [_jsx(Text, { bold: true, color: "green", children: "cli version" }), ' ', cli] }));
+        addLog(_jsxs(Text, { children: [_jsx(Text, { bold: true, color: "green", children: "client version" }), ' ', client] }));
+    })
+        .command('new [directory]', 'Create a new Poetora documentation site', (yargs) => yargs.positional('directory', {
+        describe: 'The directory to initialize your documentation',
+        type: 'string',
+        default: '.',
+    }), async ({ directory }) => {
+        try {
+            await init(directory);
+            await terminate(0);
+        }
+        catch (error) {
+            addLog(_jsx(ErrorLog, { message: error instanceof Error ? error.message : 'error occurred' }));
+            await terminate(1);
+        }
+    })
+        .strictCommands()
+        .demandCommand(1, 'unknown command. see above for the list of supported commands.')
+        .alias('h', 'help')
+        .alias('v', 'version')
+        .parse());
+};

package/bin/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const HOME_DIR: string;
+export declare const CMD_EXEC_PATH: string;

package/bin/constants.js

@@ -0,0 +1,3 @@
+import os from 'os';
+export const HOME_DIR = os.homedir();
+export const CMD_EXEC_PATH = process.cwd();

package/bin/helpers.d.ts

@@ -0,0 +1,17 @@
+import { exec } from 'node:child_process';
+import type { ArgumentsCamelCase } from 'yargs';
+export declare const checkPort: (argv: ArgumentsCamelCase) => Promise<number | undefined>;
+export declare const checkNodeVersion: () => Promise<void>;
+export declare const getCliVersion: () => string | undefined;
+export declare const getVersions: () => {
+    cli: string | undefined;
+    client: string | undefined;
+};
+export declare const getLatestCliVersion: (packageName: string) => string;
+export declare const suppressConsoleWarnings: () => void;
+export declare const readLocalOpenApiFile: (filename: string) => Promise<Record<string, unknown> | undefined>;
+export declare const terminate: (code: number) => Promise<never>;
+export declare const execAsync: typeof exec.__promisify__;
+export declare const detectPackageManager: ({ packageName }: {
+    packageName: string;
+}) => Promise<"pnpm" | "npm">;

package/bin/helpers.js

@@ -0,0 +1,104 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { addLog, ErrorLog, getClientVersion, InfoLog, LOCAL_LINKED_CLI_VERSION, } from '@poetora/previewing';
+import detect from 'detect-port';
+import fs from 'fs/promises';
+import yaml from 'js-yaml';
+import { exec, execSync } from 'node:child_process';
+import { promisify } from 'node:util';
+import path from 'path';
+import yargs from 'yargs';
+export const checkPort = async (argv) => {
+    const initialPort = typeof argv.port === 'number' ? argv.port : 3000;
+    if (initialPort === (await detect(initialPort)))
+        return initialPort;
+    for (let port = initialPort + 1; port < initialPort + 10; port++) {
+        addLog(_jsx(InfoLog, { message: `port ${port - 1} is already in use. trying ${port} instead` }));
+        if (port === (await detect(port)))
+            return port;
+    }
+};
+export const checkNodeVersion = async () => {
+    let nodeVersionString = process.version;
+    if (nodeVersionString.charAt(0) === 'v') {
+        nodeVersionString = nodeVersionString.slice(1);
+    }
+    const versionArr = nodeVersionString.split('.');
+    const majorVersion = parseInt(versionArr[0], 10);
+    if (majorVersion < 18) {
+        addLog(_jsx(ErrorLog, { message: `poetora requires a node version >= 18.0.0 (current version ${nodeVersionString}). try removing the poetora package, upgrading node, reinstalling poetora, and running again.` }));
+    }
+};
+export const getCliVersion = () => {
+    const y = yargs();
+    let version = undefined;
+    y.showVersion((s) => {
+        version = s;
+        return false;
+    });
+    if (process.env.CLI_TEST_MODE === 'true') {
+        return 'test-cli';
+    }
+    if (version === 'unknown') {
+        version = LOCAL_LINKED_CLI_VERSION;
+    }
+    return version;
+};
+export const getVersions = () => {
+    const cli = getCliVersion();
+    const client = getClientVersion().trim();
+    return { cli, client };
+};
+export const getLatestCliVersion = (packageName) => {
+    return execSync(`npm view ${packageName} version --silent`, {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+};
+export const suppressConsoleWarnings = () => {
+    const ignoredMessages = [
+        'No utility classes were detected',
+        'https://tailwindcss.com/docs/content-configuration',
+        'DeprecationWarning',
+    ];
+    const originalConsoleError = console.error;
+    console.error = (...args) => {
+        const message = args.join(' ');
+        if (ignoredMessages.some((ignoredMessage) => message.includes(ignoredMessage))) {
+            return;
+        }
+        originalConsoleError.apply(console, args);
+    };
+    const originalConsoleWarn = console.warn;
+    console.warn = (...args) => {
+        const message = args.join(' ');
+        if (ignoredMessages.some((ignoredMessage) => message.includes(ignoredMessage))) {
+            return;
+        }
+        originalConsoleWarn.apply(console, args);
+    };
+};
+export const readLocalOpenApiFile = async (filename) => {
+    const pathname = path.resolve(process.cwd(), filename);
+    const file = await fs.readFile(pathname, 'utf-8');
+    const document = yaml.load(file);
+    return document;
+};
+export const terminate = async (code) => {
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    process.exit(code);
+};
+export const execAsync = promisify(exec);
+export const detectPackageManager = async ({ packageName }) => {
+    try {
+        const { stdout: packagePath } = await execAsync(`which ${packageName}`);
+        if (packagePath.includes('pnpm')) {
+            return 'pnpm';
+        }
+        else {
+            return 'npm';
+        }
+    }
+    catch (error) {
+        return 'npm';
+    }
+};

package/bin/index.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { type ChildProcess } from 'child_process';
+declare let cli: ChildProcess | null;
+export { cli };

package/bin/index.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageName = path.basename(process.argv[1] ?? '') === 'index'
+    ? 'poet'
+    : path.basename(process.argv[1] ?? '') || 'poet';
+let cli = null;
+let isShuttingDown = false;
+let hasExited = false;
+const cleanup = async () => {
+    if (isShuttingDown)
+        return;
+    isShuttingDown = true;
+    if (cli && !cli.killed) {
+        try {
+            cli.kill('SIGTERM');
+            await new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    if (cli && !cli.killed) {
+                        cli.kill('SIGKILL');
+                    }
+                    resolve();
+                }, 5000);
+                cli.once('exit', () => {
+                    clearTimeout(timeout);
+                    resolve();
+                });
+            });
+        }
+        catch (error) {
+        }
+    }
+};
+const exitProcess = (code) => {
+    if (hasExited)
+        return;
+    hasExited = true;
+    process.exit(code);
+};
+const killSignals = ['SIGINT', 'SIGTERM', 'SIGQUIT', 'SIGHUP'];
+killSignals.forEach((signal) => {
+    process.on(signal, async () => {
+        await cleanup();
+        exitProcess(0);
+    });
+});
+process.on('uncaughtException', async () => {
+    await cleanup();
+    exitProcess(1);
+});
+process.on('unhandledRejection', async () => {
+    await cleanup();
+    exitProcess(1);
+});
+try {
+    cli = spawn('node', ['--no-deprecation', path.join(__dirname, '../bin/start'), ...process.argv.slice(2)], {
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            POETORA_PACKAGE_NAME: packageName,
+            CLI_TEST_MODE: process.env.CLI_TEST_MODE ?? 'false',
+        },
+        shell: process.platform === 'win32',
+        windowsHide: process.platform === 'win32',
+        detached: false,
+    });
+    cli.on('error', async (error) => {
+        console.error(`Failed to start ${packageName}: ${error.message}`);
+        await cleanup();
+        exitProcess(1);
+    });
+    cli.on('exit', (code) => {
+        exitProcess(code ?? 0);
+    });
+}
+catch (error) {
+    console.error(`Failed to start ${packageName}: ${error}`);
+    exitProcess(1);
+}
+process.on('exit', () => {
+    if (cli && !cli.killed) {
+        try {
+            cli.kill('SIGKILL');
+        }
+        catch (error) {
+        }
+    }
+});
+export { cli };

package/bin/init.d.ts

@@ -0,0 +1 @@
+export declare function init(installDir: string): Promise<void>;

package/bin/init.js

@@ -0,0 +1,73 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { select, input } from '@inquirer/prompts';
+import { addLogs, addLog, SpinnerLog, removeLastLog } from '@poetora/previewing';
+import { docsConfigSchema } from '@poetora/validation';
+import AdmZip from 'adm-zip';
+import fse from 'fs-extra';
+import { Box, Text } from 'ink';
+const sendOnboardingMessage = (installDir) => {
+    addLogs(_jsx(Text, { bold: true, children: "Documentation Setup!" }), _jsx(Text, { children: "To see your docs run" }), _jsxs(Box, { children: [_jsx(Text, { color: "blue", children: "cd" }), _jsxs(Text, { children: [" ", installDir] })] }), _jsx(Text, { color: "blue", children: "poet dev" }));
+};
+export async function init(installDir) {
+    await fse.ensureDir(installDir);
+    const dirContents = await fse.readdir(installDir).catch(() => []);
+    if (dirContents.length > 0) {
+        const choice = await select({
+            message: `Directory ${installDir} is not empty. What would you like to do?`,
+            choices: [
+                { name: 'Create in a subdirectory', value: 'subdir' },
+                { name: 'Overwrite current directory (may lose contents)', value: 'overwrite' },
+                { name: 'Cancel', value: 'cancel' },
+            ],
+        });
+        if (choice === 'cancel') {
+            return;
+        }
+        if (choice === 'subdir') {
+            const subdir = await input({
+                message: 'Subdirectory name:',
+                default: 'docs',
+            });
+            if (!subdir || subdir.trim() === '') {
+                throw new Error('Subdirectory name cannot be empty');
+            }
+            installDir = installDir === '.' ? subdir : `${installDir}/${subdir}`;
+            await fse.ensureDir(installDir);
+        }
+    }
+    const defaultProject = installDir == '.' ? 'Poetora' : installDir;
+    const projectName = await input({
+        message: 'Project Name',
+        default: defaultProject,
+    });
+    const themes = docsConfigSchema.options.map((option) => {
+        return option.shape.theme._def.value;
+    });
+    const theme = await select({
+        message: 'Theme',
+        choices: themes.map((t) => ({
+            name: t,
+            value: t,
+        })),
+    });
+    addLog(_jsx(SpinnerLog, { message: "downloading starter template..." }));
+    const response = await fetch('https://github.com/poetora/starter/archive/refs/heads/main.zip');
+    const buffer = await response.arrayBuffer();
+    await fse.writeFile(installDir + '/starter.zip', Buffer.from(buffer));
+    removeLastLog();
+    addLog(_jsx(SpinnerLog, { message: "extracting..." }));
+    new AdmZip(installDir + '/starter.zip').extractAllTo(installDir, true);
+    removeLastLog();
+    await fse.copy(installDir + '/starter-main', installDir, {
+        overwrite: true,
+        filter: (src) => !src.includes('starter-main/starter-main'),
+    });
+    await fse.remove(installDir + '/starter.zip');
+    await fse.remove(installDir + '/starter-main');
+    const docsJsonPath = installDir + '/docs.json';
+    const docsConfig = await fse.readJson(docsJsonPath);
+    docsConfig.theme = theme;
+    docsConfig.name = projectName;
+    await fse.writeJson(docsJsonPath, docsConfig, { spaces: 2 });
+    sendOnboardingMessage(installDir);
+}

package/bin/mdxAccessibility.d.ts

@@ -0,0 +1,13 @@
+export interface AccessibilityFixAttribute {
+    filePath: string;
+    line?: number;
+    column?: number;
+    element: 'img' | 'video' | 'a';
+    tagName: string;
+}
+export interface MdxAccessibilityResult {
+    missingAltAttributes: AccessibilityFixAttribute[];
+    totalFiles: number;
+    filesWithIssues: number;
+}
+export declare const checkMdxAccessibility: (baseDir?: string) => Promise<MdxAccessibilityResult>;

package/bin/mdxAccessibility.js

@@ -0,0 +1,102 @@
+import { categorizeFilePaths, getPoetIgnore } from '@poetora/prebuild';
+import { coreRemark } from '@poetora/shared';
+import fs from 'fs';
+import path from 'path';
+import { visit } from 'unist-util-visit';
+const checkAltAttributes = (filePath, content) => {
+    const issues = [];
+    const visitElements = () => {
+        return (tree) => {
+            visit(tree, (node) => {
+                if (node.type === 'image') {
+                    if (!node.alt || node.alt.trim() === '') {
+                        issues.push({
+                            filePath,
+                            line: node.position?.start.line,
+                            column: node.position?.start.column,
+                            element: 'img',
+                            tagName: 'image (markdown)',
+                        });
+                    }
+                    return;
+                }
+                const mdxJsxElement = node;
+                if (mdxJsxElement.name === 'img' || mdxJsxElement.name === 'video') {
+                    const altAttrIndex = mdxJsxElement.attributes.findIndex((attr) => attr.type === 'mdxJsxAttribute' && attr.name === 'alt');
+                    const altAttribute = mdxJsxElement.attributes[altAttrIndex];
+                    const hasValidAlt = altAttribute &&
+                        typeof altAttribute.value === 'string' &&
+                        altAttribute.value.trim() !== '';
+                    if (!hasValidAlt) {
+                        issues.push({
+                            filePath,
+                            line: node.position?.start.line,
+                            column: node.position?.start.column,
+                            element: mdxJsxElement.name,
+                            tagName: mdxJsxElement.name,
+                        });
+                    }
+                }
+                else if (mdxJsxElement.name === 'a') {
+                    const hasTextContent = (children) => {
+                        return children.some((child) => {
+                            if (child.type === 'text') {
+                                const textNode = child;
+                                return textNode.value.trim() !== '';
+                            }
+                            if ('children' in child && Array.isArray(child.children)) {
+                                return hasTextContent(child.children);
+                            }
+                            return false;
+                        });
+                    };
+                    if (!hasTextContent(mdxJsxElement.children)) {
+                        issues.push({
+                            filePath,
+                            line: node.position?.start.line,
+                            column: node.position?.start.column,
+                            element: 'a',
+                            tagName: '<a>',
+                        });
+                    }
+                }
+            });
+            return tree;
+        };
+    };
+    try {
+        coreRemark().use(visitElements).processSync(content);
+    }
+    catch (error) {
+        console.warn(`Warning: Could not parse ${filePath}: ${error}`);
+    }
+    return issues;
+};
+export const checkMdxAccessibility = async (baseDir = process.cwd()) => {
+    const poetIgnore = await getPoetIgnore(baseDir);
+    const { contentFilenames } = await categorizeFilePaths(baseDir, poetIgnore);
+    const mdxFiles = [];
+    for (const file of contentFilenames) {
+        mdxFiles.push(path.join(baseDir, file));
+    }
+    const allIssues = [];
+    const filesWithIssues = new Set();
+    for (const filePath of mdxFiles) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const issues = checkAltAttributes(filePath, content);
+            if (issues.length > 0) {
+                allIssues.push(...issues);
+                filesWithIssues.add(filePath);
+            }
+        }
+        catch (error) {
+            console.warn(`Warning: Could not read file ${filePath}: ${error}`);
+        }
+    }
+    return {
+        missingAltAttributes: allIssues,
+        totalFiles: mdxFiles.length,
+        filesWithIssues: filesWithIssues.size,
+    };
+};

package/bin/mdxLinter.d.ts

@@ -0,0 +1,2 @@
+import { TerminateCode } from './accessibilityCheck.js';
+export declare const mdxLinter: () => Promise<TerminateCode>;

package/bin/mdxLinter.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { addLog, ErrorLog, SuccessLog } from '@poetora/previewing';
+import { Text } from 'ink';
+import path from 'path';
+import { checkMdxAccessibility } from './mdxAccessibility.js';
+export const mdxLinter = async () => {
+    try {
+        addLog(_jsx(Text, { bold: true, color: "cyan", children: "Checking mdx files for accessibility issues..." }));
+        const results = await checkMdxAccessibility();
+        if (results.missingAltAttributes.length === 0) {
+            addLog(_jsx(SuccessLog, { message: "no accessibility issues found" }));
+            addLog(_jsxs(Text, { children: ["Checked ", results.totalFiles, " MDX files - all images and videos have alt attributes."] }));
+            return 0;
+        }
+        const issuesByFile = {};
+        results.missingAltAttributes.forEach((issue) => {
+            if (!issuesByFile[issue.filePath]) {
+                issuesByFile[issue.filePath] = [];
+            }
+            issuesByFile[issue.filePath]?.push(issue);
+        });
+        addLog(_jsxs(Text, { bold: true, color: "red", children: ["Found ", results.missingAltAttributes.length, " accessibility issues in", ' ', results.filesWithIssues, " files:"] }));
+        addLog(_jsx(Text, {}));
+        for (const [filePath, issues] of Object.entries(issuesByFile)) {
+            const relativePath = path.relative(process.cwd(), filePath);
+            addLog(_jsxs(Text, { bold: true, children: [relativePath, ":"] }));
+            for (const issue of issues) {
+                const location = issue.line && issue.column ? ` (line ${issue.line}, col ${issue.column})` : '';
+                if (issue.element === 'a') {
+                    addLog(_jsxs(Text, { children: [_jsx(Text, { color: "red", children: " \u2717" }), " Missing text attribute ", _jsx(Text, { bold: true, children: issue.tagName }), ' ', "element", location] }));
+                }
+                else {
+                    addLog(_jsxs(Text, { children: [_jsx(Text, { color: "red", children: " \u2717" }), " Missing alt attribute on ", _jsx(Text, { bold: true, children: issue.tagName }), ' ', "element", location] }));
+                }
+            }
+            addLog(_jsx(Text, {}));
+        }
+        addLog(_jsxs(Text, { color: "yellow", children: [_jsx(Text, { bold: true, children: "Recommendation:" }), " Add alt attributes to all images and videos for better accessibility."] }));
+        return 1;
+    }
+    catch (error) {
+        addLog(_jsx(ErrorLog, { message: `MDX accessibility check failed: ${error instanceof Error ? error.message : 'Unknown error'}` }));
+        return 1;
+    }
+};