@hs-x/cli 0.4.2-next.0 → 0.4.2

package/dist/commands/react-health.js

@@ -0,0 +1,673 @@
+import { execFile } from 'node:child_process';
+import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { dirname, extname, join, relative, resolve } from 'node:path';
+import { scanReactProject, } from '@hs-x/react-doctor';
+import { AmbiguousProjectError, diagnose, filterSourceFiles, getDiffInfo, isProjectDiscoveryError, } from 'react-doctor/api';
+export async function scopeHubSpotReactReport(report, options) {
+    if (!options.staged && (options.scope ?? (options.ci ? 'changed' : 'full')) === 'full') {
+        return report;
+    }
+    if ('projects' in report) {
+        const projects = await Promise.all(report.projects.map((project) => scopeHubSpotProject(project, options)));
+        const summary = projects.reduce((total, project) => ({
+            errors: total.errors + project.summary.errors,
+            reviews: total.reviews + project.summary.reviews,
+            recommendations: total.recommendations + project.summary.recommendations,
+            warnings: total.warnings + project.summary.warnings,
+        }), { errors: 0, reviews: 0, recommendations: 0, warnings: 0 });
+        return {
+            ...report,
+            projects,
+            filesScanned: projects.reduce((total, project) => total + project.filesScanned, 0),
+            summary,
+            ok: summary.errors === 0,
+        };
+    }
+    return scopeHubSpotProject(report, options);
+}
+const require = createRequire(import.meta.url);
+const reactDoctorEntry = require.resolve('react-doctor');
+const reactDoctorPackage = resolve(dirname(reactDoctorEntry), '..', 'package.json');
+let reactDoctorVersion;
+export async function scanReactHealth(root, options = {}) {
+    const reports = await scanReactHealthProjects([root], options, 1);
+    const report = reports[0];
+    if (!report)
+        throw new Error('React Doctor did not return a project result');
+    return report;
+}
+async function buildReactHealthReport(prepared, result, baselineResult) {
+    const { root, options, scope } = prepared;
+    if (!result.ok) {
+        const reason = result.error.message || 'React project was not detected';
+        if (isProjectDiscoveryError(result.error))
+            return skippedReport(root, reason, options, scope, prepared.baseRef);
+        throw new Error(`React Doctor failed: ${reason}`);
+    }
+    const projectRoot = result.directory;
+    const displayRoot = prepared.analysisRoot ?? root;
+    let upstreamDiagnostics = result.diagnostics;
+    if (scope === 'lines' && prepared.lineRanges) {
+        const lineRanges = prepared.lineRanges;
+        upstreamDiagnostics = upstreamDiagnostics.filter((diagnostic) => diagnosticTouchesChangedLines(diagnostic, lineRanges));
+    }
+    if (scope === 'changed' && baselineResult?.ok && prepared.baselineRoot) {
+        upstreamDiagnostics = await introducedDiagnostics(upstreamDiagnostics, baselineResult.diagnostics, projectRoot, prepared.baselineRoot);
+    }
+    const filtered = await filterHubSpotDiagnostics(upstreamDiagnostics, projectRoot);
+    const diagnostics = filtered.diagnostics.map((diagnostic) => ({
+        ruleId: `${diagnostic.plugin}/${diagnostic.rule}`,
+        severity: diagnostic.severity,
+        title: diagnostic.title ?? diagnostic.rule,
+        message: diagnostic.message,
+        suggestion: normalizeUpstreamSuggestion(diagnostic),
+        category: diagnostic.category,
+        file: relative(displayRoot, resolve(projectRoot, diagnostic.filePath)),
+        line: diagnostic.line,
+        column: diagnostic.column,
+        ...(diagnostic.offset !== undefined ? { offset: diagnostic.offset } : {}),
+        ...(diagnostic.length !== undefined ? { length: diagnostic.length } : {}),
+        ...(diagnostic.endLine !== undefined ? { endLine: diagnostic.endLine } : {}),
+        ...(diagnostic.endColumn !== undefined ? { endColumn: diagnostic.endColumn } : {}),
+        ...(diagnostic.matchByOccurrence ? { matchByOccurrence: diagnostic.matchByOccurrence } : {}),
+        ...(diagnostic.fileContext ? { fileContext: diagnostic.fileContext } : {}),
+        ...(diagnostic.suppressionHint ? { suppressionHint: diagnostic.suppressionHint } : {}),
+        ...(diagnostic.fixGroupId ? { fixGroupId: diagnostic.fixGroupId } : {}),
+        ...(diagnostic.relatedLocations?.length
+            ? {
+                relatedLocations: diagnostic.relatedLocations.map((location) => ({
+                    file: relative(displayRoot, resolve(projectRoot, location.filePath)),
+                    line: location.line,
+                    column: location.column,
+                    ...(location.offset !== undefined ? { offset: location.offset } : {}),
+                    ...(location.length !== undefined ? { length: location.length } : {}),
+                    ...(location.endLine !== undefined ? { endLine: location.endLine } : {}),
+                    ...(location.endColumn !== undefined ? { endColumn: location.endColumn } : {}),
+                    message: location.message,
+                })),
+            }
+            : {}),
+        ...(diagnostic.url ? { url: diagnostic.url } : {}),
+    }));
+    const errors = diagnostics.filter((diagnostic) => diagnostic.severity === 'error').length;
+    const warnings = diagnostics.length - errors;
+    return {
+        status: 'scanned',
+        engineVersion: await loadReactDoctorVersion(),
+        root,
+        projectRoot,
+        filesScanned: result.scannedFileCount ?? result.analyzedFiles?.length ?? 0,
+        diagnostics,
+        summary: { errors, warnings },
+        score: null,
+        scoreLabel: null,
+        skippedChecks: result.skippedChecks,
+        ...(result.skippedCheckReasons ? { skippedCheckReasons: result.skippedCheckReasons } : {}),
+        suppressedDiagnostics: filtered.suppressions,
+        scope,
+        ...(prepared.baseRef ? { baseRef: prepared.baseRef } : {}),
+        staged: options.staged ?? false,
+        deep: options.deep ?? false,
+        ci: options.ci ?? false,
+        elapsedMilliseconds: result.elapsedMilliseconds,
+    };
+}
+async function filterHubSpotDiagnostics(diagnostics, projectRoot) {
+    const kept = [];
+    const suppressionCounts = new Map();
+    for (const diagnostic of diagnostics) {
+        const reason = await hubSpotSuppressionReason(diagnostic, diagnostics, projectRoot);
+        if (!reason) {
+            kept.push(diagnostic);
+            continue;
+        }
+        const ruleId = `${diagnostic.plugin}/${diagnostic.rule}`;
+        const current = suppressionCounts.get(ruleId);
+        suppressionCounts.set(ruleId, { count: (current?.count ?? 0) + 1, reason });
+    }
+    return {
+        diagnostics: kept,
+        suppressions: [...suppressionCounts.entries()].map(([ruleId, value]) => ({
+            ruleId,
+            ...value,
+        })),
+    };
+}
+async function hubSpotSuppressionReason(diagnostic, diagnostics, projectRoot) {
+    if (diagnostic.rule === 'no-vulnerable-react-server-components') {
+        return 'React Server Components are not part of the HubSpot UI-extension client runtime.';
+    }
+    if (diagnostic.rule === 'no-unstable-nested-components' &&
+        diagnostics.some((candidate) => candidate.plugin === diagnostic.plugin &&
+            candidate.rule === 'no-nested-component-definition' &&
+            candidate.filePath === diagnostic.filePath &&
+            candidate.line === diagnostic.line)) {
+        return 'The equivalent no-nested-component-definition finding already describes this location.';
+    }
+    if (diagnostic.rule === 'exhaustive-deps' &&
+        diagnostics.some((candidate) => candidate.plugin === diagnostic.plugin &&
+            candidate.rule === 'no-effect-with-fresh-deps' &&
+            candidate.filePath === diagnostic.filePath &&
+            candidate.line === diagnostic.line)) {
+        return 'The more specific no-effect-with-fresh-deps finding already describes this dependency problem.';
+    }
+    if (diagnostic.rule === 'no-pass-data-to-parent' &&
+        diagnostics.some((candidate) => candidate.plugin === diagnostic.plugin &&
+            candidate.rule === 'no-pass-live-state-to-parent' &&
+            candidate.filePath === diagnostic.filePath &&
+            candidate.line === diagnostic.line)) {
+        return 'The more specific no-pass-live-state-to-parent finding already describes this parent synchronization problem.';
+    }
+    if (diagnostic.rule !== 'no-prop-callback-in-render')
+        return undefined;
+    try {
+        const source = await readFile(resolve(projectRoot, diagnostic.filePath), 'utf8');
+        const lines = source.split(/\r?\n/);
+        const start = Math.max(0, diagnostic.line - 3);
+        const end = Math.min(lines.length, diagnostic.line + 2);
+        if (/\bonCrmPropertiesUpdate\s*\(/.test(lines.slice(start, end).join('\n'))) {
+            return 'HubSpot documents onCrmPropertiesUpdate as a hook-like component-level subscription.';
+        }
+    }
+    catch {
+        // Preserve the upstream finding when source context cannot be verified.
+    }
+    return undefined;
+}
+function normalizeUpstreamSuggestion(diagnostic) {
+    if (diagnostic.rule === 'rerender-state-only-in-handlers') {
+        return 'Confirm the value is not rendered. Remove it when the state and its handler are dead; use a ref only when live handlers still need mutable storage.';
+    }
+    if (diagnostic.rule === 'rerender-functional-setstate') {
+        const setter = /\b(set[A-Z][A-Za-z0-9_$]*)\s*\(/.exec(diagnostic.message)?.[1];
+        return setter
+            ? `Use the functional form of ${setter} so async work and batched updates do not overwrite newer state.`
+            : 'Use the functional setter form so async work and batched updates do not overwrite newer state.';
+    }
+    if (diagnostic.rule === 'js-combine-iterations') {
+        return 'If this is a hot or large list, combine the predicates in one readable pass; otherwise keep the clearer code.';
+    }
+    if (diagnostic.rule === 'js-hoist-intl' && diagnostic.message.includes('Intl.DateTimeFormat')) {
+        return diagnostic.help.replaceAll('Intl.NumberFormat', 'Intl.DateTimeFormat');
+    }
+    return diagnostic.help;
+}
+export async function scanReactHealthProjects(roots, options = {}, concurrency = 2) {
+    const prepared = await Promise.all(roots.map((root) => prepareScan(root, options)));
+    try {
+        const active = prepared.filter((scan) => scan.includePaths?.length !== 0);
+        const current = await diagnosePrepared(active, concurrency);
+        const currentByRoot = new Map(active.map((scan, index) => [scan.root, current[index]]));
+        const baselineScans = prepared.filter((scan) => scan.scope === 'changed' && scan.baselineRoot);
+        const baselines = await diagnosePrepared(baselineScans.map((scan) => ({
+            ...scan,
+            root: scan.baselineRoot ?? scan.root,
+        })), concurrency);
+        const baselineByOriginalRoot = new Map(baselineScans.map((scan, index) => [scan.root, baselines[index]]));
+        return Promise.all(prepared.map(async (scan) => {
+            if (scan.includePaths?.length === 0)
+                return emptyScopedReport(scan);
+            const result = currentByRoot.get(scan.root);
+            if (!result)
+                throw new Error(`React Doctor omitted ${scan.root} from its results`);
+            return buildReactHealthReport(scan, result, baselineByOriginalRoot.get(scan.root));
+        }));
+    }
+    finally {
+        await Promise.all(prepared.flatMap((scan) => scan.cleanupRoot ? [rm(scan.cleanupRoot, { recursive: true, force: true })] : []));
+    }
+}
+async function prepareScan(root, options) {
+    const scope = options.staged ? 'files' : (options.scope ?? (options.ci ? 'changed' : 'full'));
+    if (scope === 'full')
+        return { root, options, scope };
+    if (options.staged) {
+        const stagedChanges = await stagedFiles(root);
+        const changedFiles = filterSourceFiles(stagedChanges);
+        if (changedFiles.length === 0) {
+            return { root, options, scope, includePaths: [], baseRef: 'HEAD' };
+        }
+        const cleanupRoot = await mkdtemp(join(tmpdir(), 'hs-x-react-doctor-staged-'));
+        const analysisRoot = await extractStagedSnapshot(root, cleanupRoot, stagedChanges);
+        return {
+            root,
+            analysisRoot,
+            options,
+            scope,
+            includePaths: changedFiles,
+            baseRef: 'HEAD',
+            cleanupRoot,
+        };
+    }
+    const selection = await getDiffInfo(root, options.base, true);
+    const changedFiles = filterSourceFiles(selection?.changedFiles ?? []);
+    const baseRef = selection?.diffBaseRef ??
+        (selection && 'baseBranch' in selection ? selection.baseBranch : undefined);
+    const lineRanges = scope === 'lines'
+        ? await changedLineRanges(root, changedFiles, baseRef, options.staged)
+        : undefined;
+    if (scope !== 'changed' || !baseRef || changedFiles.length === 0) {
+        return {
+            root,
+            options,
+            scope,
+            includePaths: changedFiles,
+            ...(lineRanges ? { lineRanges } : {}),
+            ...(baseRef ? { baseRef } : {}),
+        };
+    }
+    const cleanupRoot = await mkdtemp(join(tmpdir(), 'hs-x-react-doctor-base-'));
+    const baselineRoot = await extractGitSnapshot(root, baseRef, join(cleanupRoot, 'project'));
+    return {
+        root,
+        options,
+        scope,
+        includePaths: changedFiles,
+        baseRef,
+        baselineRoot,
+        cleanupRoot,
+    };
+}
+async function scopeHubSpotProject(report, options) {
+    const prepared = await prepareScan(report.root, options);
+    try {
+        if (prepared.includePaths === undefined)
+            return report;
+        const includedFiles = new Set(prepared.includePaths);
+        const sourceReport = prepared.analysisRoot
+            ? await scanReactProject({ root: prepared.analysisRoot, deep: options.deep ?? false })
+            : report;
+        let diagnostics = sourceReport.diagnostics.filter((diagnostic) => includedFiles.has(diagnostic.file));
+        if (prepared.scope === 'lines' && prepared.lineRanges) {
+            diagnostics = diagnostics.filter((diagnostic) => {
+                const ranges = prepared.lineRanges?.get(diagnostic.file);
+                if (ranges === null)
+                    return true;
+                return (ranges?.some((range) => diagnostic.line >= range.start && diagnostic.line <= range.end) ??
+                    false);
+            });
+        }
+        if (prepared.scope === 'changed' && prepared.baselineRoot) {
+            const baseline = await scanReactProject({
+                root: prepared.baselineRoot,
+                deep: options.deep ?? false,
+            });
+            diagnostics = await introducedHubSpotDiagnostics(diagnostics, baseline.diagnostics.filter((diagnostic) => includedFiles.has(diagnostic.file)), report.root, prepared.baselineRoot);
+        }
+        const summary = diagnostics.reduce((total, diagnostic) => {
+            if (diagnostic.kind === 'error')
+                total.errors += 1;
+            else if (diagnostic.kind === 'review')
+                total.reviews += 1;
+            else
+                total.recommendations += 1;
+            total.warnings = total.reviews + total.recommendations;
+            return total;
+        }, { errors: 0, reviews: 0, recommendations: 0, warnings: 0 });
+        return {
+            ...report,
+            ...(sourceReport.projectName ? { projectName: sourceReport.projectName } : {}),
+            ...(sourceReport.platformVersion ? { platformVersion: sourceReport.platformVersion } : {}),
+            filesScanned: prepared.includePaths.length,
+            diagnostics,
+            summary,
+            ok: summary.errors === 0,
+        };
+    }
+    finally {
+        if (prepared.cleanupRoot) {
+            await rm(prepared.cleanupRoot, { recursive: true, force: true });
+        }
+    }
+}
+async function introducedHubSpotDiagnostics(current, baseline, currentRoot, baselineRoot) {
+    const baselineCounts = new Map();
+    for (const diagnostic of baseline) {
+        const key = await hubSpotEvidenceKey(diagnostic, baselineRoot);
+        baselineCounts.set(key, (baselineCounts.get(key) ?? 0) + 1);
+    }
+    const introduced = [];
+    for (const diagnostic of current) {
+        const key = await hubSpotEvidenceKey(diagnostic, currentRoot);
+        const remaining = baselineCounts.get(key) ?? 0;
+        if (remaining > 0)
+            baselineCounts.set(key, remaining - 1);
+        else
+            introduced.push(diagnostic);
+    }
+    return introduced;
+}
+async function hubSpotEvidenceKey(diagnostic, root) {
+    return [
+        diagnostic.file,
+        diagnostic.ruleId,
+        diagnostic.message.replace(/\s+/g, ' ').trim(),
+        await sourceLine(root, diagnostic.file, diagnostic.line),
+    ].join('\0');
+}
+async function diagnosePrepared(scans, concurrency) {
+    if (scans.length === 0)
+        return [];
+    const result = await runReactDoctorBatch(scans.map((scan) => ({
+        directory: scan.analysisRoot ?? scan.root,
+        deadCode: scan.options.deep ?? false,
+        ...(scan.includePaths ? { includePaths: [...scan.includePaths] } : {}),
+    })), concurrency);
+    return Promise.all(result.projects.map(async (project, index) => {
+        const scan = scans[index];
+        if (!scan || project.ok || !(project.error instanceof AmbiguousProjectError)) {
+            return project;
+        }
+        return diagnoseAmbiguousProject(scan, project.error, concurrency);
+    }));
+}
+async function runReactDoctorBatch(projects, concurrency) {
+    return withOfflineScoreApi(() => diagnose({
+        projects,
+        config: {
+            noScore: true,
+            supplyChain: { enabled: false },
+        },
+        concurrency,
+        warnings: true,
+    }));
+}
+async function diagnoseAmbiguousProject(scan, error, concurrency) {
+    const requestedRoot = scan.analysisRoot ?? scan.root;
+    const allCandidates = error.candidates.map((candidate) => resolve(error.directory, candidate));
+    const sourceBearing = (await Promise.all(allCandidates.map(async (candidate) => ({
+        candidate,
+        hasReactSource: await containsReactUiSource(candidate),
+    }))))
+        .filter((entry) => entry.hasReactSource)
+        .map((entry) => entry.candidate);
+    const candidates = sourceBearing.length > 0 ? sourceBearing : allCandidates;
+    const projects = candidates.flatMap((candidate) => {
+        const candidateRelative = relative(requestedRoot, candidate).replaceAll('\\', '/');
+        const includePaths = scan.includePaths
+            ?.map((path) => path.replaceAll('\\', '/'))
+            .filter((path) => path === candidateRelative || path.startsWith(`${candidateRelative}/`))
+            .map((path) => (path === candidateRelative ? '.' : path.slice(candidateRelative.length + 1)));
+        if (scan.includePaths && includePaths?.length === 0)
+            return [];
+        return [
+            {
+                directory: candidate,
+                deadCode: scan.options.deep ?? false,
+                ...(includePaths ? { includePaths } : {}),
+            },
+        ];
+    });
+    if (projects.length === 0)
+        return { ok: false, directory: requestedRoot, error };
+    const result = await runReactDoctorBatch(projects, concurrency);
+    return mergeReactProjectResults(requestedRoot, result.projects, error);
+}
+async function containsReactUiSource(root) {
+    const walk = async (directory) => {
+        let entries;
+        try {
+            entries = await readdir(directory, { withFileTypes: true });
+        }
+        catch {
+            return false;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.'))
+                continue;
+            const path = join(directory, entry.name);
+            if (entry.isDirectory()) {
+                if (['build', 'coverage', 'dist', 'node_modules', 'out'].includes(entry.name))
+                    continue;
+                if (await walk(path))
+                    return true;
+                continue;
+            }
+            if (!entry.isFile() || !['.js', '.jsx', '.ts', '.tsx'].includes(extname(entry.name))) {
+                continue;
+            }
+            if (entry.name.endsWith('.jsx') || entry.name.endsWith('.tsx'))
+                return true;
+            try {
+                const source = await readFile(path, 'utf8');
+                if (/(?:from\s*['"]react['"]|require\(\s*['"]react['"]\s*\)|@hubspot\/ui-extensions|React\.createElement|react\/jsx-runtime)/.test(source)) {
+                    return true;
+                }
+            }
+            catch {
+                // Keep searching when an individual source file cannot be read.
+            }
+        }
+        return false;
+    };
+    return walk(root);
+}
+function mergeReactProjectResults(root, results, fallbackError) {
+    const successful = results.filter((result) => result.ok);
+    const first = successful[0];
+    if (!first) {
+        return results[0] ?? { ok: false, directory: root, error: fallbackError };
+    }
+    const normalizePath = (projectRoot, path) => relative(root, resolve(projectRoot, path));
+    const diagnostics = successful.flatMap((result) => result.diagnostics.map((diagnostic) => ({
+        ...diagnostic,
+        filePath: normalizePath(result.directory, diagnostic.filePath),
+        ...(diagnostic.relatedLocations?.length
+            ? {
+                relatedLocations: diagnostic.relatedLocations.map((location) => ({
+                    ...location,
+                    filePath: normalizePath(result.directory, location.filePath),
+                })),
+            }
+            : {}),
+    })));
+    const skippedCheckReasons = Object.assign({}, ...successful.flatMap((result) => result.skippedCheckReasons ? [result.skippedCheckReasons] : []));
+    return {
+        ok: true,
+        directory: root,
+        diagnostics,
+        score: null,
+        skippedChecks: [...new Set(successful.flatMap((result) => result.skippedChecks))],
+        ...(Object.keys(skippedCheckReasons).length > 0 ? { skippedCheckReasons } : {}),
+        analyzedFiles: successful.flatMap((result) => (result.analyzedFiles ?? []).map((path) => normalizePath(result.directory, path))),
+        scannedFileCount: successful.reduce((total, result) => total + (result.scannedFileCount ?? result.analyzedFiles?.length ?? 0), 0),
+        project: first.project,
+        reactDetected: successful.some((result) => result.reactDetected === true),
+        elapsedMilliseconds: successful.reduce((total, result) => total + result.elapsedMilliseconds, 0),
+    };
+}
+async function withOfflineScoreApi(work) {
+    const originalFetch = globalThis.fetch;
+    // react-doctor/api 0.9.12 does not honor `noScore` on diagnose(). Keep the
+    // richer in-process diagnostics without allowing its score upload to leave
+    // the machine. Supply-chain requests are separately disabled above.
+    globalThis.fetch = ((input, init) => {
+        const url = input instanceof Request ? input.url : String(input);
+        if (url.startsWith('https://www.react.doctor/api/score')) {
+            return Promise.resolve(new Response(JSON.stringify({ score: 100, label: 'offline' }), {
+                status: 200,
+                headers: { 'content-type': 'application/json' },
+            }));
+        }
+        return originalFetch(input, init);
+    });
+    try {
+        return await work();
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+}
+async function loadReactDoctorVersion() {
+    reactDoctorVersion ??= readFile(reactDoctorPackage, 'utf8').then((source) => JSON.parse(source).version);
+    return reactDoctorVersion;
+}
+async function stagedFiles(root) {
+    const { stdout } = await exec('git', ['diff', '--cached', '--relative', '--name-only', '--diff-filter=ACMR', '-z'], root);
+    return stdout.split('\0').filter(Boolean);
+}
+async function changedLineRanges(root, files, baseRef, staged) {
+    const ranges = new Map();
+    if (files.length === 0)
+        return ranges;
+    const args = ['diff', '--relative', '--unified=0'];
+    if (staged)
+        args.push('--cached');
+    else if (baseRef)
+        args.push(baseRef);
+    args.push('--', ...files);
+    const { stdout } = await exec('git', args, root);
+    let currentFile;
+    for (const line of stdout.split(/\r?\n/)) {
+        if (line.startsWith('+++ b/')) {
+            currentFile = line.slice(6);
+            continue;
+        }
+        const match = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/.exec(line);
+        if (!match || !currentFile)
+            continue;
+        const start = Number(match[1]);
+        const count = match[2] === undefined ? 1 : Number(match[2]);
+        if (count === 0)
+            continue;
+        const current = ranges.get(currentFile) ?? [];
+        if (current !== null)
+            current.push({ start, end: start + count - 1 });
+        ranges.set(currentFile, current);
+    }
+    const untracked = staged ? new Set() : await untrackedFiles(root);
+    for (const file of files) {
+        if (untracked.has(file))
+            ranges.set(file, null);
+        else if (!ranges.has(file))
+            ranges.set(file, []);
+    }
+    return ranges;
+}
+async function untrackedFiles(root) {
+    const { stdout } = await exec('git', ['ls-files', '--others', '--exclude-standard', '-z'], root);
+    return new Set(stdout.split('\0').filter(Boolean));
+}
+function diagnosticTouchesChangedLines(diagnostic, ranges) {
+    const fileRanges = ranges.get(diagnostic.filePath);
+    if (fileRanges === null)
+        return true;
+    if (!fileRanges)
+        return false;
+    const endLine = diagnostic.endLine ?? diagnostic.line;
+    return fileRanges.some((range) => diagnostic.line <= range.end && endLine >= range.start);
+}
+async function introducedDiagnostics(current, baseline, currentRoot, baselineRoot) {
+    const baselineCounts = new Map();
+    for (const diagnostic of baseline) {
+        const key = await diagnosticEvidenceKey(diagnostic, baselineRoot);
+        baselineCounts.set(key, (baselineCounts.get(key) ?? 0) + 1);
+    }
+    const introduced = [];
+    for (const diagnostic of current) {
+        const key = await diagnosticEvidenceKey(diagnostic, currentRoot);
+        const remaining = baselineCounts.get(key) ?? 0;
+        if (remaining > 0)
+            baselineCounts.set(key, remaining - 1);
+        else
+            introduced.push(diagnostic);
+    }
+    return introduced;
+}
+async function diagnosticEvidenceKey(diagnostic, root) {
+    // Upstream wording and source locations can carry run-specific detail even
+    // when the underlying rule evidence is unchanged. Baseline by stable
+    // file/plugin/rule identity; introducedDiagnostics' occurrence counts still
+    // expose any net-new finding for that rule in the file.
+    const file = relative(root, resolve(root, diagnostic.filePath));
+    return [file, diagnostic.plugin, diagnostic.rule].join('\0');
+}
+async function sourceLine(root, file, line) {
+    try {
+        const source = await readFile(resolve(root, file), 'utf8');
+        return (source.split(/\r?\n/)[line - 1] ?? '').replace(/\s+/g, ' ').trim();
+    }
+    catch {
+        return '';
+    }
+}
+async function extractGitSnapshot(root, baseRef, destination) {
+    const { stdout } = await exec('git', ['rev-parse', '--show-toplevel'], root);
+    const repositoryRoot = stdout.trim();
+    const archive = join(dirname(destination), 'base.tar');
+    await exec('git', ['archive', '--format=tar', '--output', archive, baseRef], repositoryRoot);
+    await mkdir(destination, { recursive: true });
+    await exec('tar', ['-xf', archive, '-C', destination], repositoryRoot);
+    const projectPath = relative(repositoryRoot, root);
+    return projectPath && projectPath !== '.' ? join(destination, projectPath) : destination;
+}
+async function extractStagedSnapshot(root, cleanupRoot, stagedChanges) {
+    const { stdout: prefixOutput } = await exec('git', ['rev-parse', '--show-prefix'], root);
+    const prefix = prefixOutput.trim();
+    let stagedRoot;
+    try {
+        stagedRoot = await extractGitSnapshot(root, 'HEAD', join(cleanupRoot, 'index'));
+    }
+    catch {
+        stagedRoot = prefix ? join(cleanupRoot, 'index', prefix) : join(cleanupRoot, 'index');
+        await mkdir(stagedRoot, { recursive: true });
+    }
+    for (const file of stagedChanges) {
+        const { stdout } = await exec('git', ['show', `:${prefix}${file}`], root);
+        const destination = resolve(stagedRoot, file);
+        await mkdir(dirname(destination), { recursive: true });
+        await writeFile(destination, stdout);
+    }
+    return stagedRoot;
+}
+function exec(command, args, cwd) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        execFile(command, [...args], { cwd, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }, (error, stdout, stderr) => {
+            if (error) {
+                rejectPromise(new Error(`${command} ${args.join(' ')} failed: ${stderr || error.message}`));
+                return;
+            }
+            resolvePromise({ stdout, stderr });
+        });
+    });
+}
+function emptyScopedReport(scan) {
+    return {
+        status: 'scanned',
+        root: scan.root,
+        filesScanned: 0,
+        diagnostics: [],
+        summary: { errors: 0, warnings: 0 },
+        score: null,
+        scoreLabel: null,
+        skippedChecks: [],
+        suppressedDiagnostics: [],
+        scope: scan.scope,
+        ...(scan.baseRef ? { baseRef: scan.baseRef } : {}),
+        staged: scan.options.staged ?? false,
+        deep: scan.options.deep ?? false,
+        ci: scan.options.ci ?? false,
+    };
+}
+function skippedReport(root, reason, options, scope, baseRef) {
+    return {
+        status: 'skipped',
+        root,
+        filesScanned: 0,
+        diagnostics: [],
+        summary: { errors: 0, warnings: 0 },
+        score: null,
+        scoreLabel: null,
+        skippedChecks: [],
+        suppressedDiagnostics: [],
+        scope,
+        ...(baseRef ? { baseRef } : {}),
+        staged: options.staged ?? false,
+        deep: options.deep ?? false,
+        ci: options.ci ?? false,
+        reason,
+    };
+}
+//# sourceMappingURL=react-health.js.map