@casoon/auditmysite/dist/index.js

Professional website analysis suite with robust accessibility testing, Core Web Vitals performance monitoring, SEO analysis, and content optimization insights. Features isolated browser contexts, retry mechanisms, and comprehensive API endpoints for profe

#!/usr/bin/env node
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const commander_1 = require("commander");
const chalk_1 = __importDefault(require("chalk"));
const ora_1 = __importDefault(require("ora"));
const parsers_1 = require("./parsers");
const core_1 = require("./core");
const generators_1 = require("./generators");
const program = new commander_1.Command();
program
    .name("a11y-test")
    .description("CLI tool for automated accessibility testing based on sitemap")
    .version("1.0.0");
program
    .argument("<sitemap-url>", "URL to sitemap.xml")
    .option("-m, --max-pages <number>", "Maximum number of pages to test", "20")
    .option("-t, --timeout <number>", "Timeout in milliseconds", "10000")
    .option("-w, --wait-until <string>", "Wait until (domcontentloaded|load|networkidle)", "domcontentloaded")
    .option("-f, --filter <patterns>", "URL patterns to exclude (comma-separated)", "[...slug],[category],/demo/")
    .option("-i, --include <patterns>", "URL patterns to include (comma-separated)")
    .option("-v, --verbose", "Detailed output")
    .option("--standard <standard>", "Accessibility Standard (WCAG2A|WCAG2AA|WCAG2AAA|Section508)", "WCAG2AA")
    .option("--include-details", "Detailed information in output file")
    .option("--include-pa11y", "Include pa11y issues in output file")
    .option("--summary-only", "Summary only without page details")
    .action(async (sitemapUrl, options) => {
    const spinner = (0, ora_1.default)("Initializing accessibility tests...").start();
    try {
        // Initialize parser
        const parser = new parsers_1.SitemapParser();
        spinner.text = "Loading sitemap...";
        // Parse sitemap
        const urls = await parser.parseSitemap(sitemapUrl);
        spinner.text = `Sitemap loaded: ${urls.length} URLs found`;
        // Filter URLs
        const filterPatterns = options.filter
            ? options.filter.split(",")
            : ["[...slug]", "[category]", "/demo/"];
        const includePatterns = options.include
            ? options.include.split(",")
            : undefined;
        const filteredUrls = parser.filterUrls(urls, {
            filterPatterns,
            includePatterns,
        });
        spinner.text = `URLs filtered: ${filteredUrls.length} URLs to test`;
        // Convert URLs to local URLs (if needed)
        const baseUrl = new URL(sitemapUrl).origin;
        const localUrls = parser.convertToLocalUrls(filteredUrls, baseUrl);
        // Initialize browser pool manager for accessibility checker
        const { BrowserPoolManager } = require('./core/browser/browser-pool-manager');
        const poolManager = new BrowserPoolManager({
            maxInstances: 3,
            acquireTimeout: 30000,
            destroyTimeout: 5000,
            headless: true
        });
        await poolManager.initialize();
        // Initialize accessibility checker
        const checker = new core_1.AccessibilityChecker({
            poolManager,
            enableComprehensiveAnalysis: false // Basic CLI only needs basic accessibility
        });
        await checker.initialize();
        spinner.text = "Running accessibility tests...";
        // Run tests
        const testOptions = {
            maxPages: parseInt(options.maxPages),
            timeout: parseInt(options.timeout),
            waitUntil: options.waitUntil,
            verbose: options.verbose,
            pa11yStandard: options.standard,
        };
        const urlsToTest = localUrls.map((url) => url.loc).slice(0, parseInt(options.maxPages));
        const multi = await checker.testMultiplePages(urlsToTest, {
            timeout: parseInt(options.timeout),
            pa11yStandard: options.standard,
            verbose: options.verbose,
            maxConcurrent: 3
        });
        const results = multi.results.map(r => r.accessibilityResult);
        // Create summary
        const summary = {
            totalPages: localUrls.length,
            testedPages: results.length,
            passedPages: results.filter((r) => r.passed).length,
            failedPages: results.filter((r) => !r.passed && !r.crashed).length,
            crashedPages: results.filter((r) => r.crashed === true).length,
            totalErrors: results.reduce((sum, r) => sum + r.errors.length, 0),
            totalWarnings: results.reduce((sum, r) => sum + r.warnings.length, 0),
            totalDuration: results.reduce((sum, r) => sum + r.duration, 0),
            results,
        };
        await checker.cleanup();
        // Display results
        spinner.succeed("Tests completed!");
        // Generate JSON output if requested
        if (options.output && options.output !== 'console') {
            spinner.text = 'Generating JSON output...';
            const jsonGenerator = new generators_1.JsonGenerator();
            try {
                const jsonData = {
                    metadata: { timestamp: new Date().toISOString(), toolVersion: '2.0.0-alpha.1' },
                    summary,
                    pages: summary.results
                };
                const jsonContent = jsonGenerator.generateJson(jsonData);
                const outputPath = options.outputFile || `audit-${Date.now()}.json`;
                require('fs').writeFileSync(outputPath, jsonContent);
                spinner.succeed(`JSON output created: ${outputPath}`);
            }
            catch (error) {
                spinner.warn(`Error creating JSON output: ${error}`);
            }
        }
        displayResults(summary, options);
    }
    catch (error) {
        spinner.fail(`Error: ${error}`);
        process.exit(1);
    }
});
function displayResults(summary, options) {
    console.log("\n" + chalk_1.default.bold.blue("🎯 Accessibility Test Summary"));
    console.log(chalk_1.default.gray("─".repeat(50)));
    console.log(`📄 Total pages: ${summary.totalPages}`);
    console.log(`🧪 Tested pages: ${summary.testedPages}`);
    console.log(`✅ Passed: ${chalk_1.default.green(summary.passedPages)}`);
    console.log(`❌ Failed: ${chalk_1.default.red(summary.failedPages)}`);
    console.log(`⚠️  Warnings: ${chalk_1.default.yellow(summary.totalWarnings)}`);
    console.log(`⏱️  Total duration: ${summary.totalDuration}ms`);
    if (options.verbose) {
        console.log("\n" + chalk_1.default.bold("📋 Detailed results:"));
        summary.results.forEach((result) => {
            const status = result.passed ? chalk_1.default.green("✅") : chalk_1.default.red("❌");
            console.log(`${status} ${result.url}`);
            console.log(`   Title: ${result.title}`);
            console.log(`   Duration: ${result.duration}ms`);
            if (result.warnings.length > 0) {
                result.warnings.forEach((warning) => {
                    console.log(`   ⚠️  ${warning}`);
                });
            }
            if (result.errors.length > 0) {
                result.errors.forEach((error) => {
                    console.log(`   ❌ ${error}`);
                });
            }
        });
    }
    // Only exit with code 1 for technical crashes, not accessibility failures
    if (summary.crashedPages > 0) {
        console.log(`\n❌ ${summary.crashedPages} pages crashed due to technical errors`);
        process.exit(1);
    }
    else if (summary.failedPages > 0) {
        console.log(`\n⚠️  Note: ${summary.failedPages} pages have accessibility issues (this is normal)`);
        console.log(`💡 Check the detailed report for specific issues to fix`);
    }
}
program.parse();
//# sourceMappingURL=index.js.map