@govtechsg/oobee 0.10.83 → 0.10.84

package/src/mergeAxeResults/scanPages.ts

@@ -0,0 +1,207 @@
+import type { AllIssues } from './types.js';
+
+/**
+ * Build allIssues.scanPagesDetail and allIssues.scanPagesSummary
+ * by analyzing pagesScanned (including mustFix/goodToFix/etc.).
+ */
+export default function populateScanPagesDetail(allIssues: AllIssues): void {
+  const allScannedPages = Array.isArray(allIssues.pagesScanned) ? allIssues.pagesScanned : [];
+
+  const mustFixCategory = 'mustFix';
+  const goodToFixCategory = 'goodToFix';
+  const needsReviewCategory = 'needsReview';
+  const passedCategory = 'passed';
+
+  type RuleData = {
+    ruleId: string;
+    wcagConformance: string[];
+    occurrencesMustFix: number;
+    occurrencesGoodToFix: number;
+    occurrencesNeedsReview: number;
+    occurrencesPassed: number;
+  };
+
+  type PageData = {
+    pageTitle: string;
+    url: string;
+    totalOccurrencesFailedIncludingNeedsReview: number;
+    totalOccurrencesFailedExcludingNeedsReview: number;
+    totalOccurrencesNeedsReview: number;
+    totalOccurrencesPassed: number;
+    typesOfIssues: Record<string, RuleData>;
+  };
+
+  const pagesMap: Record<string, PageData> = {};
+
+  Object.entries(allIssues.items).forEach(([categoryName, categoryData]) => {
+    if (!categoryData?.rules) return;
+
+    categoryData.rules.forEach(rule => {
+      const { rule: ruleId, conformance = [] } = rule;
+
+      rule.pagesAffected.forEach(p => {
+        const { url, pageTitle, items = [] } = p;
+        const itemsCount = items.length;
+
+        if (!pagesMap[url]) {
+          pagesMap[url] = {
+            pageTitle,
+            url,
+            totalOccurrencesFailedIncludingNeedsReview: 0,
+            totalOccurrencesFailedExcludingNeedsReview: 0,
+            totalOccurrencesNeedsReview: 0,
+            totalOccurrencesPassed: 0,
+            typesOfIssues: {},
+          };
+        }
+
+        if (!pagesMap[url].typesOfIssues[ruleId]) {
+          pagesMap[url].typesOfIssues[ruleId] = {
+            ruleId,
+            wcagConformance: conformance,
+            occurrencesMustFix: 0,
+            occurrencesGoodToFix: 0,
+            occurrencesNeedsReview: 0,
+            occurrencesPassed: 0,
+          };
+        }
+
+        if (categoryName === mustFixCategory) {
+          pagesMap[url].typesOfIssues[ruleId].occurrencesMustFix += itemsCount;
+          pagesMap[url].totalOccurrencesFailedIncludingNeedsReview += itemsCount;
+          pagesMap[url].totalOccurrencesFailedExcludingNeedsReview += itemsCount;
+        } else if (categoryName === goodToFixCategory) {
+          pagesMap[url].typesOfIssues[ruleId].occurrencesGoodToFix += itemsCount;
+          pagesMap[url].totalOccurrencesFailedIncludingNeedsReview += itemsCount;
+          pagesMap[url].totalOccurrencesFailedExcludingNeedsReview += itemsCount;
+        } else if (categoryName === needsReviewCategory) {
+          pagesMap[url].typesOfIssues[ruleId].occurrencesNeedsReview += itemsCount;
+          pagesMap[url].totalOccurrencesFailedIncludingNeedsReview += itemsCount;
+          pagesMap[url].totalOccurrencesNeedsReview += itemsCount;
+        } else if (categoryName === passedCategory) {
+          pagesMap[url].typesOfIssues[ruleId].occurrencesPassed += itemsCount;
+          pagesMap[url].totalOccurrencesPassed += itemsCount;
+        }
+      });
+    });
+  });
+
+  const pagesInMap = Object.values(pagesMap);
+  const pagesInMapUrls = new Set(Object.keys(pagesMap));
+
+  const pagesAllPassed = pagesInMap.filter(p => p.totalOccurrencesFailedIncludingNeedsReview === 0);
+
+  const pagesNoEntries = allScannedPages
+    .filter(sp => !pagesInMapUrls.has(sp.url))
+    .map(sp => ({
+      pageTitle: sp.pageTitle,
+      url: sp.url,
+      totalOccurrencesFailedIncludingNeedsReview: 0,
+      totalOccurrencesFailedExcludingNeedsReview: 0,
+      totalOccurrencesNeedsReview: 0,
+      totalOccurrencesPassed: 0,
+      typesOfIssues: {},
+    }));
+
+  const pagesNotAffectedRaw = [...pagesAllPassed, ...pagesNoEntries];
+  const pagesAffectedRaw = pagesInMap.filter(p => p.totalOccurrencesFailedIncludingNeedsReview > 0);
+
+  function transformPageData(page: PageData) {
+    const typesOfIssuesArray = Object.values(page.typesOfIssues);
+    const mustFixSum = typesOfIssuesArray.reduce((acc, r) => acc + r.occurrencesMustFix, 0);
+    const goodToFixSum = typesOfIssuesArray.reduce((acc, r) => acc + r.occurrencesGoodToFix, 0);
+    const needsReviewSum = typesOfIssuesArray.reduce((acc, r) => acc + r.occurrencesNeedsReview, 0);
+
+    const categoriesPresent: string[] = [];
+    if (mustFixSum > 0) categoriesPresent.push('mustFix');
+    if (goodToFixSum > 0) categoriesPresent.push('goodToFix');
+    if (needsReviewSum > 0) categoriesPresent.push('needsReview');
+
+    const failedRuleIds = new Set<string>();
+    typesOfIssuesArray.forEach(r => {
+      if (
+        (r.occurrencesMustFix || 0) > 0 ||
+        (r.occurrencesGoodToFix || 0) > 0 ||
+        (r.occurrencesNeedsReview || 0) > 0
+      ) {
+        failedRuleIds.add(r.ruleId);
+      }
+    });
+    const failedRuleCount = failedRuleIds.size;
+
+    const typesOfIssuesExcludingNeedsReviewCount = typesOfIssuesArray.filter(
+      r => (r.occurrencesMustFix || 0) + (r.occurrencesGoodToFix || 0) > 0,
+    ).length;
+
+    const typesOfIssuesExclusiveToNeedsReviewCount = typesOfIssuesArray.filter(
+      r =>
+        (r.occurrencesNeedsReview || 0) > 0 &&
+        (r.occurrencesMustFix || 0) === 0 &&
+        (r.occurrencesGoodToFix || 0) === 0,
+    ).length;
+
+    const allConformance = typesOfIssuesArray.reduce((acc, curr) => {
+      const nonPassedCount =
+        (curr.occurrencesMustFix || 0) +
+        (curr.occurrencesGoodToFix || 0) +
+        (curr.occurrencesNeedsReview || 0);
+
+      if (nonPassedCount > 0) {
+        return acc.concat(curr.wcagConformance || []);
+      }
+      return acc;
+    }, [] as string[]);
+    const conformance = Array.from(new Set(allConformance));
+
+    return {
+      pageTitle: page.pageTitle,
+      url: page.url,
+      totalOccurrencesFailedIncludingNeedsReview: page.totalOccurrencesFailedIncludingNeedsReview,
+      totalOccurrencesFailedExcludingNeedsReview: page.totalOccurrencesFailedExcludingNeedsReview,
+      totalOccurrencesMustFix: mustFixSum,
+      totalOccurrencesGoodToFix: goodToFixSum,
+      totalOccurrencesNeedsReview: needsReviewSum,
+      totalOccurrencesPassed: page.totalOccurrencesPassed,
+      typesOfIssuesExclusiveToNeedsReviewCount,
+      typesOfIssuesCount: failedRuleCount,
+      typesOfIssuesExcludingNeedsReviewCount,
+      categoriesPresent,
+      conformance,
+      typesOfIssues: typesOfIssuesArray,
+    };
+  }
+
+  const pagesAffected = pagesAffectedRaw.map(transformPageData);
+  const pagesNotAffected = pagesNotAffectedRaw.map(transformPageData);
+  pagesAffected.sort((a, b) => b.typesOfIssuesCount - a.typesOfIssuesCount);
+  pagesNotAffected.sort((a, b) => b.typesOfIssuesCount - a.typesOfIssuesCount);
+
+  const scannedPagesCount = pagesAffected.length + pagesNotAffected.length;
+  const pagesNotScannedCount = Array.isArray(allIssues.pagesNotScanned)
+    ? allIssues.pagesNotScanned.length
+    : 0;
+
+  allIssues.scanPagesDetail = {
+    pagesAffected,
+    pagesNotAffected,
+    scannedPagesCount,
+    pagesNotScanned: Array.isArray(allIssues.pagesNotScanned) ? allIssues.pagesNotScanned : [],
+    pagesNotScannedCount,
+  };
+
+  function stripTypesOfIssues(page: ReturnType<typeof transformPageData>) {
+    const { typesOfIssues, ...rest } = page;
+    return rest;
+  }
+
+  const summaryPagesAffected = pagesAffected.map(stripTypesOfIssues);
+  const summaryPagesNotAffected = pagesNotAffected.map(stripTypesOfIssues);
+
+  allIssues.scanPagesSummary = {
+    pagesAffected: summaryPagesAffected,
+    pagesNotAffected: summaryPagesNotAffected,
+    scannedPagesCount,
+    pagesNotScanned: Array.isArray(allIssues.pagesNotScanned) ? allIssues.pagesNotScanned : [],
+    pagesNotScannedCount,
+  };
+}

package/src/mergeAxeResults/sentryTelemetry.ts

@@ -0,0 +1,183 @@
+import * as Sentry from '@sentry/node';
+import { sentryConfig, setSentryUser } from '../constants/constants.js';
+import { categorizeWcagCriteria, getUserDataTxt, getWcagCriteriaMap } from '../utils.js';
+import type { AllIssues } from './types.js';
+
+// Format WCAG tag in requested format: wcag111a_Occurrences
+const formatWcagTag = async (wcagId: string): Promise<string | null> => {
+  // Get dynamic WCAG criteria map
+  const wcagCriteriaMap = await getWcagCriteriaMap();
+
+  if (wcagCriteriaMap[wcagId]) {
+    const { level } = wcagCriteriaMap[wcagId];
+    return `${wcagId}${level}_Occurrences`;
+  }
+  return null;
+};
+
+// Send WCAG criteria breakdown to Sentry
+const sendWcagBreakdownToSentry = async (
+  appVersion: string,
+  wcagBreakdown: Map<string, number>,
+  ruleIdJson: any,
+  scanInfo: {
+    entryUrl: string;
+    scanType: string;
+    browser: string;
+    email?: string;
+    name?: string;
+  },
+  allIssues?: AllIssues,
+  pagesScannedCount: number = 0,
+) => {
+  try {
+    // Initialize Sentry
+    Sentry.init(sentryConfig);
+    // Set user ID for Sentry tracking
+    const userData = getUserDataTxt();
+    if (userData && userData.userId) {
+      setSentryUser(userData.userId);
+    }
+
+    // Prepare tags for the event
+    const tags: Record<string, string> = {};
+    const wcagCriteriaBreakdown: Record<string, any> = {};
+
+    // Tag app version
+    tags.version = appVersion;
+
+    // Get dynamic WCAG criteria map once
+    const wcagCriteriaMap = await getWcagCriteriaMap();
+
+    // Categorize all WCAG criteria for reporting
+    const wcagIds = Array.from(
+      new Set([...Object.keys(wcagCriteriaMap), ...Array.from(wcagBreakdown.keys())]),
+    );
+    const categorizedWcag = await categorizeWcagCriteria(wcagIds);
+
+    // First ensure all WCAG criteria are included in the tags with a value of 0
+    // This ensures criteria with no violations are still reported
+    for (const [wcagId, info] of Object.entries(wcagCriteriaMap)) {
+      const formattedTag = await formatWcagTag(wcagId);
+      if (formattedTag) {
+        // Initialize with zero
+        tags[formattedTag] = '0';
+
+        // Store in breakdown object with category information
+        wcagCriteriaBreakdown[formattedTag] = {
+          count: 0,
+          category: categorizedWcag[wcagId] || 'mustFix', // Default to mustFix if not found
+        };
+      }
+    }
+
+    // Now override with actual counts from the scan
+    for (const [wcagId, count] of wcagBreakdown.entries()) {
+      const formattedTag = await formatWcagTag(wcagId);
+      if (formattedTag) {
+        // Add as a tag with the count as value
+        tags[formattedTag] = String(count);
+
+        // Update count in breakdown object
+        if (wcagCriteriaBreakdown[formattedTag]) {
+          wcagCriteriaBreakdown[formattedTag].count = count;
+        } else {
+          // If somehow this wasn't in our initial map
+          wcagCriteriaBreakdown[formattedTag] = {
+            count,
+            category: categorizedWcag[wcagId] || 'mustFix',
+          };
+        }
+      }
+    }
+
+    // Calculate category counts based on actual issue counts from the report
+    // rather than occurrence counts from wcagBreakdown
+    const categoryCounts = {
+      mustFix: 0,
+      goodToFix: 0,
+      needsReview: 0,
+    };
+
+    if (allIssues) {
+      // Use the actual report data for the counts
+      categoryCounts.mustFix = allIssues.items.mustFix.rules.length;
+      categoryCounts.goodToFix = allIssues.items.goodToFix.rules.length;
+      categoryCounts.needsReview = allIssues.items.needsReview.rules.length;
+    } else {
+      // Fallback to the old way if allIssues not provided
+      Object.values(wcagCriteriaBreakdown).forEach(item => {
+        if (item.count > 0 && categoryCounts[item.category] !== undefined) {
+          categoryCounts[item.category] += 1; // Count rules, not occurrences
+        }
+      });
+    }
+
+    // Add category counts as tags
+    tags['WCAG-MustFix-Count'] = String(categoryCounts.mustFix);
+    tags['WCAG-GoodToFix-Count'] = String(categoryCounts.goodToFix);
+    tags['WCAG-NeedsReview-Count'] = String(categoryCounts.needsReview);
+
+    // Also add occurrence counts for reference
+    if (allIssues) {
+      tags['WCAG-MustFix-Occurrences'] = String(allIssues.items.mustFix.totalItems);
+      tags['WCAG-GoodToFix-Occurrences'] = String(allIssues.items.goodToFix.totalItems);
+      tags['WCAG-NeedsReview-Occurrences'] = String(allIssues.items.needsReview.totalItems);
+
+      // Add number of pages scanned tag
+      tags['Pages-Scanned-Count'] = String(allIssues.totalPagesScanned);
+    } else if (pagesScannedCount > 0) {
+      // Still add the pages scanned count even if we don't have allIssues
+      tags['Pages-Scanned-Count'] = String(pagesScannedCount);
+    }
+
+    // Send the event to Sentry
+    await Sentry.captureEvent({
+      message: 'Accessibility Scan Completed',
+      level: 'info',
+      tags: {
+        ...tags,
+        event_type: 'accessibility_scan',
+        scanType: scanInfo.scanType,
+        browser: scanInfo.browser,
+        entryUrl: scanInfo.entryUrl,
+      },
+      user: {
+        ...(scanInfo.email && scanInfo.name
+          ? {
+              email: scanInfo.email,
+              username: scanInfo.name,
+            }
+          : {}),
+        ...(userData && userData.userId ? { id: userData.userId } : {}),
+      },
+      extra: {
+        additionalScanMetadata: ruleIdJson != null ? JSON.stringify(ruleIdJson) : '{}',
+        wcagBreakdown: wcagCriteriaBreakdown,
+        reportCounts: allIssues
+          ? {
+              mustFix: {
+                issues: allIssues.items.mustFix.rules?.length ?? 0,
+                occurrences: allIssues.items.mustFix.totalItems ?? 0,
+              },
+              goodToFix: {
+                issues: allIssues.items.goodToFix.rules?.length ?? 0,
+                occurrences: allIssues.items.goodToFix.totalItems ?? 0,
+              },
+              needsReview: {
+                issues: allIssues.items.needsReview.rules?.length ?? 0,
+                occurrences: allIssues.items.needsReview.totalItems ?? 0,
+              },
+            }
+          : undefined,
+      },
+    });
+
+    // Wait for events to be sent
+    await Sentry.flush(2000);
+  } catch (error) {
+    console.error('Error sending WCAG breakdown to Sentry:', error);
+  }
+};
+
+export default sendWcagBreakdownToSentry;

package/src/mergeAxeResults/types.ts

@@ -0,0 +1,99 @@
+export type ItemsInfo = {
+  html: string;
+  message: string;
+  screenshotPath: string;
+  xpath: string;
+  displayNeedsReview?: boolean;
+};
+
+export type PageInfo = {
+  items?: ItemsInfo[];
+  itemsCount?: number;
+  pageTitle: string;
+  url: string;
+  actualUrl: string;
+  pageImagePath?: string;
+  pageIndex?: number;
+  metadata?: string;
+  httpStatusCode?: number;
+};
+
+export type HtmlGroupItem = {
+  html: string;
+  xpath: string;
+  message: string;
+  screenshotPath: string;
+  displayNeedsReview?: boolean;
+  pageUrls: string[];
+};
+
+export type HtmlGroups = {
+  [htmlKey: string]: HtmlGroupItem;
+};
+
+export type RuleInfo = {
+  totalItems: number;
+  pagesAffected: PageInfo[];
+  pagesAffectedCount: number;
+  rule: string;
+  description: string;
+  axeImpact: string;
+  conformance: string[];
+  helpUrl: string;
+  htmlGroups?: HtmlGroups;
+};
+
+type Category = {
+  description: string;
+  totalItems: number;
+  totalRuleIssues: number;
+  rules: RuleInfo[];
+};
+
+export type AllIssues = {
+  storagePath: string;
+  oobeeAi: {
+    htmlETL: any;
+    rules: string[];
+  };
+  siteName: string;
+  startTime: Date;
+  endTime: Date;
+  urlScanned: string;
+  scanType: string;
+  deviceChosen: string;
+  formatAboutStartTime: (dateString: any) => string;
+  isCustomFlow: boolean;
+  pagesScanned: PageInfo[];
+  pagesNotScanned: PageInfo[];
+  totalPagesScanned: number;
+  totalPagesNotScanned: number;
+  totalItems: number;
+  topFiveMostIssues: Array<any>;
+  topTenPagesWithMostIssues: Array<any>;
+  topTenIssues: Array<any>;
+  wcagViolations: string[];
+  customFlowLabel: string;
+  oobeeAppVersion: string;
+  items: {
+    mustFix: Category;
+    goodToFix: Category;
+    needsReview: Category;
+    passed: Category;
+  };
+  cypressScanAboutMetadata: {
+    browser?: string;
+    viewport?: { width: number; height: number };
+  };
+  wcagLinks: { [key: string]: string };
+  wcagClauses: { [key: string]: string };
+  [key: string]: any;
+  advancedScanOptionsSummaryItems: { [key: string]: boolean };
+  scanPagesDetail: {
+    pagesAffected: any[];
+    pagesNotAffected: any[];
+    scannedPagesCount: number;
+    pagesNotScanned: any[];
+    pagesNotScannedCount: number;
+  };
+};

package/src/mergeAxeResults/writeCsv.ts

@@ -0,0 +1,145 @@
+import { createWriteStream } from 'fs';
+import { AsyncParser, ParserOptions } from '@json2csv/node';
+import { a11yRuleShortDescriptionMap } from '../constants/constants.js';
+import type { AllIssues, RuleInfo } from './types.js';
+
+const writeCsv = async (allIssues: AllIssues, storagePath: string): Promise<void> => {
+  const csvOutput = createWriteStream(`${storagePath}/report.csv`, { encoding: 'utf8' });
+  const formatPageViolation = (pageNum: number) => {
+    if (pageNum < 0) return 'Document';
+    return `Page ${pageNum}`;
+  };
+
+  // transform allIssues into the form:
+  // [['mustFix', rule1], ['mustFix', rule2], ['goodToFix', rule3], ...]
+  const getRulesByCategory = (issues: AllIssues) => {
+    return Object.entries(issues.items)
+      .filter(([category]) => category !== 'passed')
+      .reduce((prev: [string, RuleInfo][], [category, value]) => {
+        const rulesEntries = Object.entries(value.rules);
+        rulesEntries.forEach(([, ruleInfo]) => {
+          prev.push([category, ruleInfo]);
+        });
+        return prev;
+      }, [])
+      .sort((a, b) => {
+        // sort rules according to severity, then ruleId
+        const compareCategory = -a[0].localeCompare(b[0]);
+        return compareCategory === 0 ? a[1].rule.localeCompare(b[1].rule) : compareCategory;
+      });
+  };
+
+  const flattenRule = (catAndRule: [string, RuleInfo]) => {
+    const [severity, rule] = catAndRule;
+    const results = [];
+    const {
+      rule: issueId,
+      description: issueDescription,
+      axeImpact,
+      conformance,
+      pagesAffected,
+      helpUrl: learnMore,
+    } = rule;
+
+    // format clauses as a string
+    const wcagConformance = conformance.join(',');
+
+    pagesAffected.sort((a, b) => a.url.localeCompare(b.url));
+
+    pagesAffected.forEach(affectedPage => {
+      const { url, items } = affectedPage;
+      items.forEach(item => {
+        const { html, message, xpath } = item;
+        const page = (item as any).page;
+        const howToFix = message.replace(/(\r\n|\n|\r)/g, '\\n'); // preserve newlines as \n
+        const violation = html || formatPageViolation(page); // page is a number, not a string
+        const context = violation.replace(/(\r\n|\n|\r)/g, ''); // remove newlines
+
+        results.push({
+          customFlowLabel: allIssues.customFlowLabel || '',
+          deviceChosen: allIssues.deviceChosen || '',
+          scanCompletedAt: allIssues.endTime ? allIssues.endTime.toISOString() : '',
+          severity: severity || '',
+          issueId: issueId || '',
+          issueDescription: a11yRuleShortDescriptionMap[issueId] || issueDescription || '',
+          wcagConformance: wcagConformance || '',
+          url: url || '',
+          pageTitle: affectedPage.pageTitle || 'No page title',
+          context: context || '',
+          howToFix: howToFix || '',
+          axeImpact: axeImpact || '',
+          xpath: xpath || '',
+          learnMore: learnMore || '',
+        });
+      });
+    });
+    if (results.length === 0) return {};
+    return results;
+  };
+
+  const opts: ParserOptions<any, any> = {
+    transforms: [getRulesByCategory, flattenRule],
+    fields: [
+      'customFlowLabel',
+      'deviceChosen',
+      'scanCompletedAt',
+      'severity',
+      'issueId',
+      'issueDescription',
+      'wcagConformance',
+      'url',
+      'pageTitle',
+      'context',
+      'howToFix',
+      'axeImpact',
+      'xpath',
+      'learnMore',
+    ],
+    includeEmptyRows: true,
+  };
+
+  // Create the parse stream (it's asynchronous)
+  const parser = new AsyncParser(opts);
+  const parseStream = parser.parse(allIssues);
+
+  // Pipe JSON2CSV output into the file, but don't end automatically
+  parseStream.pipe(csvOutput, { end: false });
+
+  // Once JSON2CSV is done writing all normal rows, append any "pagesNotScanned"
+  parseStream.on('end', () => {
+    if (allIssues.pagesNotScanned && allIssues.pagesNotScanned.length > 0) {
+      csvOutput.write('\n');
+      allIssues.pagesNotScanned.forEach(page => {
+        const skippedPage = {
+          customFlowLabel: allIssues.customFlowLabel || '',
+          deviceChosen: allIssues.deviceChosen || '',
+          scanCompletedAt: allIssues.endTime ? allIssues.endTime.toISOString() : '',
+          severity: 'error',
+          issueId: 'error-pages-skipped',
+          issueDescription: page.metadata
+            ? page.metadata
+            : 'An unknown error caused the page to be skipped',
+          wcagConformance: '',
+          url: page.url || page || '',
+          pageTitle: 'Error',
+          context: '',
+          howToFix: '',
+          axeImpact: '',
+          xpath: '',
+          learnMore: '',
+        };
+        csvOutput.write(`${Object.values(skippedPage).join(',')}\n`);
+      });
+    }
+
+    // Now close the CSV file
+    csvOutput.end();
+  });
+
+  parseStream.on('error', (err: unknown) => {
+    console.error('Error parsing CSV:', err);
+    csvOutput.end();
+  });
+};
+
+export default writeCsv;

package/src/mergeAxeResults/writeScanDetailsCsv.ts

@@ -0,0 +1,51 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+const streamEncodedDataToFile = async (
+  inputFilePath: string,
+  writeStream: fs.WriteStream,
+  appendComma: boolean,
+) => {
+  const readStream = fs.createReadStream(inputFilePath, { encoding: 'utf8' });
+  let isFirstChunk = true;
+
+  for await (const chunk of readStream) {
+    if (isFirstChunk) {
+      isFirstChunk = false;
+      writeStream.write(chunk);
+    } else {
+      writeStream.write(chunk);
+    }
+  }
+
+  if (appendComma) {
+    writeStream.write(',');
+  }
+};
+
+const writeScanDetailsCsv = async (
+  scanDataFilePath: string,
+  scanItemsFilePath: string,
+  scanItemsSummaryFilePath: string,
+  storagePath: string,
+) => {
+  const filePath = path.join(storagePath, 'scanDetails.csv');
+  const csvWriteStream = fs.createWriteStream(filePath, { encoding: 'utf8' });
+  const directoryPath = path.dirname(filePath);
+
+  if (!fs.existsSync(directoryPath)) {
+    fs.mkdirSync(directoryPath, { recursive: true });
+  }
+
+  csvWriteStream.write('scanData_base64,scanItems_base64,scanItemsSummary_base64\n');
+  await streamEncodedDataToFile(scanDataFilePath, csvWriteStream, true);
+  await streamEncodedDataToFile(scanItemsFilePath, csvWriteStream, true);
+  await streamEncodedDataToFile(scanItemsSummaryFilePath, csvWriteStream, false);
+
+  await new Promise((resolve, reject) => {
+    csvWriteStream.end(resolve);
+    csvWriteStream.on('error', reject);
+  });
+};
+
+export default writeScanDetailsCsv;

package/src/mergeAxeResults/writeSitemap.ts

@@ -0,0 +1,13 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { consoleLogger } from '../logs.js';
+import type { PageInfo } from './types.js';
+
+const writeSitemap = async (pagesScanned: PageInfo[], storagePath: string): Promise<void> => {
+  const sitemapPath = path.join(storagePath, 'sitemap.txt');
+  const content = pagesScanned.map(p => p.url).join('\n');
+  await fs.writeFile(sitemapPath, content, { encoding: 'utf-8' });
+  consoleLogger.info(`Sitemap written to ${sitemapPath}`);
+};
+
+export default writeSitemap;