vouchington-tooling 0.13.1 → 0.13.3

package/dist/gha-post-review/pull-io.d.mts

@@ -0,0 +1,13 @@
+import type { GhExec } from './github.mts';
+import type { PostResult, PostReviewIo, SanitizedReview } from './post.mts';
+export declare function postWithGh(repository: string, prNumber: string, payload: SanitizedReview, token: string, exec: GhExec): PostResult;
+export declare function createGhPostReviewIo(options: {
+    repository: string;
+    prNumber: string;
+    payloadPath: string;
+    payloadBytes: Buffer;
+    token: string;
+    exec: GhExec;
+    expectedHeadSha?: string;
+    expectedBaseSha?: string;
+}): PostReviewIo;

package/dist/gha-post-review/pull-io.mjs

@@ -0,0 +1,88 @@
+import { rmSync } from 'node:fs';
+import { parseReviewFilesJson, ReviewPayloadError } from '../gha-review-payload/index.mjs';
+export function postWithGh(repository, prNumber, payload, token, exec) {
+    try {
+        exec(['api', '--method', 'POST', `repos/${repository}/pulls/${prNumber}/reviews`, '--input', '-'], {
+            input: JSON.stringify(payload),
+            env: { ...process.env, GH_TOKEN: token, GITHUB_TOKEN: token },
+        });
+        return { ok: true, status: 201, body: '' };
+    }
+    catch (error) {
+        // oxlint-disable-next-line no-mistakes/ts-no-const-aliases -- isolate the process-error shape assertion at the catch boundary
+        const err = error;
+        const text = `${err.stdout ?? ''}${err.stderr ?? ''}${err.message ?? ''}`;
+        const status = Number(/HTTP\s+(\d{3})/u.exec(text)?.[1] ?? 0);
+        return { ok: false, status, body: text };
+    }
+}
+function readPullState(repository, prNumber, exec) {
+    let lastError;
+    for (let attempt = 1; attempt <= 3; attempt += 1) {
+        try {
+            return exec([
+                'api',
+                `repos/${repository}/pulls/${prNumber}`,
+                '--jq',
+                '[.head.sha, .base.sha, .draft, .state] | @tsv',
+            ]).split('\t');
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError;
+}
+export function createGhPostReviewIo(options) {
+    const { repository, prNumber, payloadBytes, token, exec, expectedHeadSha, expectedBaseSha } = options;
+    return {
+        readFile() {
+            return payloadBytes;
+        },
+        removeFile(path) {
+            rmSync(path, { force: true });
+        },
+        getHeadSha() {
+            if (!/^[1-9][0-9]*$/u.test(prNumber)) {
+                throw new ReviewPayloadError('PR_NUMBER must be a positive integer.');
+            }
+            if (Boolean(expectedHeadSha) !== Boolean(expectedBaseSha)) {
+                throw new ReviewPayloadError('EXPECTED_HEAD_SHA and EXPECTED_BASE_SHA must be provided together.');
+            }
+            if (expectedHeadSha && !/^[0-9a-f]{40}$/u.test(expectedHeadSha)) {
+                throw new ReviewPayloadError('EXPECTED_HEAD_SHA must be a full lowercase commit SHA.');
+            }
+            if (expectedBaseSha && !/^[0-9a-f]{40}$/u.test(expectedBaseSha)) {
+                throw new ReviewPayloadError('EXPECTED_BASE_SHA must be a full lowercase commit SHA.');
+            }
+            const state = readPullState(repository, prNumber, exec);
+            const [headSha = '', baseSha = '', draft = '', pullState = ''] = state;
+            if (!/^[0-9a-f]{40}$/u.test(headSha)) {
+                throw new ReviewPayloadError(`Could not resolve PR head SHA (got "${headSha}").`);
+            }
+            if (!/^[0-9a-f]{40}$/u.test(baseSha)) {
+                throw new ReviewPayloadError(`Could not resolve PR base SHA (got "${baseSha}").`);
+            }
+            if (draft !== 'false') {
+                throw new ReviewPayloadError('Pull request became a draft before posting the review.');
+            }
+            if (pullState !== 'open') {
+                throw new ReviewPayloadError('Pull request closed before posting the review.');
+            }
+            if (expectedHeadSha && headSha !== expectedHeadSha) {
+                throw new ReviewPayloadError('PR head changed before posting the selected review.');
+            }
+            if (expectedBaseSha && baseSha !== expectedBaseSha) {
+                throw new ReviewPayloadError('PR base changed before posting the selected review.');
+            }
+            // Preserve the orchestrator-selected revision as the review commit_id after equality checks.
+            return expectedHeadSha || headSha;
+        },
+        listPullFiles() {
+            return parseReviewFilesJson(exec(['api', '--paginate', `repos/${repository}/pulls/${prNumber}/files?per_page=100`]));
+        },
+        postReview(payload) {
+            return postWithGh(repository, prNumber, payload, token, exec);
+        },
+    };
+}

package/dist/index.d.mts

@@ -25,7 +25,8 @@ export { requireUpToDate } from './require-up-to-date/index.mts';
 export type { GitExecutor, RequireUpToDateOptions } from './require-up-to-date/index.mts';
 export { gitleaksDirectoryScanArguments, runGitleaksDirectoryScan, } from './gitleaks-directory-scan/index.mts';
 export type { DirectoryScanExecutor, GitleaksDirectoryScanOptions, } from './gitleaks-directory-scan/index.mts';
-export { astGrepExamplesArguments, runAstGrepExamples } from './ast-grep-examples/index.mts';
+export { astGrepExamplesArguments, compareAstGrepCompanions, runAstGrepExamples, } from './ast-grep-examples/index.mts';
+export type { AstGrepCompanionContext, AstGrepCompanionDifference, AstGrepCompanionParityOptions, } from './ast-grep-examples/index.mts';
 export type { AstGrepExamplesExecutor, AstGrepExamplesOptions } from './ast-grep-examples/index.mts';
 export { astGrepPackPaths, astGrepPackPathsFrom } from './ast-grep-pack/index.mts';
 export type { AstGrepPackPaths } from './ast-grep-pack/index.mts';
@@ -72,8 +73,8 @@ export { EPOCH_PRUNED_AT, normalizeDeployedLayer, pruneDeployedRuntimeDeps, rest
 export type { NormalizeDeployedLayerResult, PruneResult, RestoreWorkspacePackagesOptions, } from './pnpm-deploy/index.mts';
 export { parseDockerfilePrewarmStages, parseDockerfileRuntimeImages, } from './dockerfile-parse/index.mts';
 export type { DockerfilePrewarmStage, DockerfileRuntimeImage, ParseDockerfilePrewarmOptions, ParseDockerfileRuntimeImagesOptions, } from './dockerfile-parse/index.mts';
-export { buildSccArgs, checkSccComplexity, parseSccComplexityViolations, SCC_COMPLEXITY_LIMIT, } from './scc-complexity/index.mts';
-export type { SccComplexityOptions, SccComplexityViolation } from './scc-complexity/index.mts';
+export { buildSccArgs, checkSccComplexity, parseSccComplexityBaseline, parseSccComplexityViolations, SCC_COMPLEXITY_BASELINE_VERSION, SCC_COMPLEXITY_LIMIT, } from './scc-complexity/index.mts';
+export type { SccComplexityBaseline, SccComplexityBaselineEntry, SccComplexityOptions, SccComplexityScope, SccComplexityViolation, } from './scc-complexity/index.mts';
 export { assertWorkflowCommandDrift, parseCiLocalArgs, runCiLocal } from './ci-local/index.mts';
 export type { CiLocalCommand, CiLocalSpawn, CiLocalSpawnOptions, CiLocalSpawnResult, CiLocalTarget, RunCiLocalOptions, } from './ci-local/index.mts';
 export { GitHubRateLimitError, isRateLimited, isRetryableCancellationError, MAX_RATE_LIMIT_WAIT_MS, rateLimitDelay, reserveRateLimitDelay, } from './gha-rate-limit/index.mts';

package/dist/index.mjs

@@ -13,7 +13,7 @@ export { auditCiJobRuntime, parseWorkflowNameMatch } from './gha-runtime-audit/i
 export { checkGhaWorkspacePolicy } from './gha-workspace-policy/index.mjs';
 export { requireUpToDate } from './require-up-to-date/index.mjs';
 export { gitleaksDirectoryScanArguments, runGitleaksDirectoryScan, } from './gitleaks-directory-scan/index.mjs';
-export { astGrepExamplesArguments, runAstGrepExamples } from './ast-grep-examples/index.mjs';
+export { astGrepExamplesArguments, compareAstGrepCompanions, runAstGrepExamples, } from './ast-grep-examples/index.mjs';
 export { astGrepPackPaths, astGrepPackPathsFrom } from './ast-grep-pack/index.mjs';
 export { createVitestBlobManifest, createVitestReportAttempt, inspectVitestBlobBundle, parseVitestBlobManifest, parseVitestReportAttempt, readVitestReportAttempts, serializeVitestBlobManifest, serializeVitestReportAttempt, VITEST_BLOB_MANIFEST_FILENAME, VITEST_BLOB_MANIFEST_VERSION, VITEST_REPORT_ATTEMPT_PREFIX, VITEST_REPORT_ATTEMPT_VERSION, vitestBlobBundlePaths, writeVitestBlobManifest, writeVitestReportAttempt, } from './vitest-blob-manifest/index.mjs';
 export { prepareVitestReports } from './vitest-blob-manifest/reports.mjs';
@@ -39,7 +39,7 @@ export { nextPageCursorFromLinkHeader, nextPageUrlFromLinkHeader, validatePagina
 export { cmdDownloadCoverage, cmdDownloadVitestBlobs, cmdUpload, mintPresignedControl, transportObjectKeys, } from './coverage-transport/index.mjs';
 export { EPOCH_PRUNED_AT, normalizeDeployedLayer, pruneDeployedRuntimeDeps, restoreDeployedWorkspacePackages, } from './pnpm-deploy/index.mjs';
 export { parseDockerfilePrewarmStages, parseDockerfileRuntimeImages, } from './dockerfile-parse/index.mjs';
-export { buildSccArgs, checkSccComplexity, parseSccComplexityViolations, SCC_COMPLEXITY_LIMIT, } from './scc-complexity/index.mjs';
+export { buildSccArgs, checkSccComplexity, parseSccComplexityBaseline, parseSccComplexityViolations, SCC_COMPLEXITY_BASELINE_VERSION, SCC_COMPLEXITY_LIMIT, } from './scc-complexity/index.mjs';
 export { assertWorkflowCommandDrift, parseCiLocalArgs, runCiLocal } from './ci-local/index.mjs';
 export { GitHubRateLimitError, isRateLimited, isRetryableCancellationError, MAX_RATE_LIMIT_WAIT_MS, rateLimitDelay, reserveRateLimitDelay, } from './gha-rate-limit/index.mjs';
 export { CHECKPOINT_MARKER, isTrustedCheckpointComment, parseCheckpoint, renderCheckpoint, sortedCheckpointCandidates, validateCheckpoint, } from './gha-pr-checkpoint/index.mjs';

package/dist/markdown/ast.d.mts

@@ -0,0 +1,8 @@
+import type { Root } from 'mdast';
+import type { MarkdownNode } from './types.mts';
+export declare function parseGfmMarkdown(markdown: string): Root;
+export declare function walkMarkdown(node: MarkdownNode, visitor: (node: MarkdownNode) => void): void;
+export declare function findMarkdownNode<T extends MarkdownNode>(node: MarkdownNode, predicate: (node: MarkdownNode) => node is T): T | null;
+export declare function findMarkdownNode(node: MarkdownNode, predicate: (node: MarkdownNode) => boolean): MarkdownNode | null;
+export declare function findMarkdownNodes<T extends MarkdownNode>(node: MarkdownNode, predicate: (node: MarkdownNode) => node is T): T[];
+export declare function findMarkdownNodes(node: MarkdownNode, predicate: (node: MarkdownNode) => boolean): MarkdownNode[];

package/dist/markdown/ast.mjs

@@ -0,0 +1,29 @@
+import { remark } from 'remark';
+import remarkGfm from 'remark-gfm';
+const processor = remark().use(remarkGfm);
+export function parseGfmMarkdown(markdown) {
+    return processor.parse(markdown);
+}
+export function walkMarkdown(node, visitor) {
+    visitor(node);
+    if (!('children' in node))
+        return;
+    for (const child of node.children)
+        walkMarkdown(child, visitor);
+}
+export function findMarkdownNode(node, predicate) {
+    let match = null;
+    walkMarkdown(node, (candidate) => {
+        if (!match && predicate(candidate))
+            match = candidate;
+    });
+    return match;
+}
+export function findMarkdownNodes(node, predicate) {
+    const matches = [];
+    walkMarkdown(node, (candidate) => {
+        if (predicate(candidate))
+            matches.push(candidate);
+    });
+    return matches;
+}

package/dist/markdown/index.d.mts

@@ -0,0 +1,6 @@
+export { findMarkdownNode, findMarkdownNodes, parseGfmMarkdown, walkMarkdown } from './ast.mts';
+export { extractLooseMarkdownTableRows } from './loose-pipe-rows.mts';
+export { markdownSectionBetweenHeadings } from './sections.mts';
+export { extractMarkdownTables, parseMarkdownTables } from './tables.mts';
+export { markdownNodeText } from './text.mts';
+export type { LooseMarkdownTableRow, LooseMarkdownTableRowsOptions, MarkdownNode, MarkdownSection, MarkdownSectionOptions, MarkdownTableRow, MarkdownTextOptions, ParseMarkdownTablesOptions, PositionedMarkdownTable, } from './types.mts';

package/dist/markdown/index.mjs

@@ -0,0 +1,5 @@
+export { findMarkdownNode, findMarkdownNodes, parseGfmMarkdown, walkMarkdown } from './ast.mjs';
+export { extractLooseMarkdownTableRows } from './loose-pipe-rows.mjs';
+export { markdownSectionBetweenHeadings } from './sections.mjs';
+export { extractMarkdownTables, parseMarkdownTables } from './tables.mjs';
+export { markdownNodeText } from './text.mjs';

package/dist/markdown/loose-pipe-rows.d.mts

@@ -0,0 +1,2 @@
+import type { LooseMarkdownTableRow, LooseMarkdownTableRowsOptions } from './types.mts';
+export declare function extractLooseMarkdownTableRows(markdown: string, options?: LooseMarkdownTableRowsOptions): LooseMarkdownTableRow[];

package/dist/markdown/loose-pipe-rows.mjs

@@ -0,0 +1,31 @@
+export function extractLooseMarkdownTableRows(markdown, options = {}) {
+    const rows = [];
+    let offset = 0;
+    for (const [index, line] of markdown.split('\n').entries()) {
+        if (!isExcluded(offset, offset + line.length, options.excludePositions)) {
+            const cells = parseLoosePipeRow(line);
+            if (cells.length > 0)
+                rows.push({ cells, line: index + 1, offset });
+        }
+        offset += line.length + 1;
+    }
+    return rows;
+}
+function isExcluded(lineStart, lineEnd, positions) {
+    return (positions?.some((position) => {
+        const start = position.start.offset;
+        const end = position.end.offset;
+        return start !== undefined && end !== undefined && lineStart < end && lineEnd > start;
+    }) ?? false);
+}
+function parseLoosePipeRow(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('|'))
+        return [];
+    const row = trimmed.endsWith('|') ? trimmed.slice(1, -1) : trimmed.slice(1);
+    const cells = row
+        .split('|')
+        .map((cell) => cell.trim())
+        .filter(Boolean);
+    return cells.every((cell) => /^:?-{3,}:?$/u.test(cell)) ? [] : cells;
+}

package/dist/markdown/sections.d.mts

@@ -0,0 +1,2 @@
+import type { MarkdownSection, MarkdownSectionOptions } from './types.mts';
+export declare function markdownSectionBetweenHeadings(markdown: string, start: string, end: string, options?: MarkdownSectionOptions): MarkdownSection | null;

package/dist/markdown/sections.mjs

@@ -0,0 +1,25 @@
+import { parseGfmMarkdown } from './ast.mjs';
+import { markdownNodeText } from './text.mjs';
+export function markdownSectionBetweenHeadings(markdown, start, end, options = {}) {
+    const children = parseGfmMarkdown(markdown).children;
+    const startIndex = children.findIndex((node) => isNamedHeading(node, start));
+    if (startIndex < 0)
+        return null;
+    const startHeading = children[startIndex];
+    const endIndex = children.findIndex((node, index) => index > startIndex &&
+        isNamedHeading(node, end) &&
+        (options.endBoundary === 'any' || node.depth <= startHeading.depth));
+    const endHeading = endIndex < 0 ? null : children[endIndex];
+    const startOffset = startHeading.position.end.offset;
+    const endOffset = endHeading ? endHeading.position.start.offset : markdown.length;
+    return {
+        content: markdown.slice(startOffset, endOffset),
+        endHeading,
+        endOffset,
+        startHeading,
+        startOffset,
+    };
+}
+function isNamedHeading(node, expected) {
+    return node.type === 'heading' && markdownNodeText(node, { whitespace: 'collapse' }) === expected;
+}

package/dist/markdown/tables.d.mts

@@ -0,0 +1,3 @@
+import type { MarkdownNode, MarkdownTableRow, ParseMarkdownTablesOptions, PositionedMarkdownTable } from './types.mts';
+export declare function extractMarkdownTables(root: MarkdownNode): PositionedMarkdownTable[];
+export declare function parseMarkdownTables(markdown: string, options?: ParseMarkdownTablesOptions): MarkdownTableRow[][];

package/dist/markdown/tables.mjs

@@ -0,0 +1,43 @@
+import { findMarkdownNodes, parseGfmMarkdown } from './ast.mjs';
+import { markdownNodeText } from './text.mjs';
+export function extractMarkdownTables(root) {
+    return findMarkdownNodes(root, (node) => node.type === 'table').map((table) => {
+        const result = {
+            rows: normalizeTableRows(table),
+        };
+        if (table.position)
+            result.position = table.position;
+        return result;
+    });
+}
+export function parseMarkdownTables(markdown, options = {}) {
+    const root = parseGfmMarkdown(normalizeTableDelimiterRows(markdown));
+    return findMarkdownNodes(root, (node) => node.type === 'table').map((table) => normalizeTableRows(table, {
+        inlineCode: options.preserveInlineCodeMarkers ? 'markers' : 'content',
+        issueReferences: 'brackets',
+    }));
+}
+function normalizeTableRows(table, textOptions = {}) {
+    return table.children.map((row) => ({
+        cells: row.children.map((cell) => markdownNodeText(cell, textOptions).trim()),
+        line: row.position?.start.line ?? 1,
+    }));
+}
+function normalizeTableDelimiterRows(markdown) {
+    return markdown
+        .split('\n')
+        .map((line) => {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('|'))
+            return line;
+        const cells = trimmed
+            .replace(/^\|/u, '')
+            .replace(/\|$/u, '')
+            .split('|')
+            .map((cell) => cell.trim());
+        if (!cells.every((cell) => /^:?-+:?$/u.test(cell)))
+            return line;
+        return `| ${cells.map((cell) => cell.replace(/-+/u, '---')).join(' | ')} |`;
+    })
+        .join('\n');
+}

package/dist/markdown/text.d.mts

@@ -0,0 +1,2 @@
+import type { MarkdownNode, MarkdownTextOptions } from './types.mts';
+export declare function markdownNodeText(node: MarkdownNode, options?: MarkdownTextOptions): string;

package/dist/markdown/text.mjs

@@ -0,0 +1,22 @@
+export function markdownNodeText(node, options = {}) {
+    const text = textFor(node, options);
+    return options.whitespace === 'collapse' ? text.replace(/\s+/gu, ' ').trim() : text;
+}
+function textFor(node, options) {
+    if (node.type === 'break')
+        return ' ';
+    if ('value' in node && typeof node.value === 'string') {
+        if (node.type === 'inlineCode' && options.inlineCode === 'markers')
+            return `\`${node.value}\``;
+        return node.value;
+    }
+    if (!('children' in node))
+        return '';
+    const text = node.children.map((child) => textFor(child, options)).join('');
+    if (options.issueReferences === 'brackets' &&
+        (node.type === 'link' || node.type === 'linkReference') &&
+        /^#\d+$/u.test(text.trim())) {
+        return `[${text.trim()}]`;
+    }
+    return text;
+}

package/dist/markdown/types.d.mts

@@ -0,0 +1,35 @@
+import type { Heading, Root, RootContent } from 'mdast';
+import type { Position } from 'unist';
+export type MarkdownNode = Root | RootContent;
+export type MarkdownTableRow = {
+    cells: string[];
+    line: number;
+};
+export type PositionedMarkdownTable = {
+    position?: Position;
+    rows: MarkdownTableRow[];
+};
+export type MarkdownTextOptions = {
+    inlineCode?: 'content' | 'markers';
+    issueReferences?: 'text' | 'brackets';
+    whitespace?: 'preserve' | 'collapse';
+};
+export type ParseMarkdownTablesOptions = {
+    preserveInlineCodeMarkers?: boolean;
+};
+export type MarkdownSectionOptions = {
+    endBoundary?: 'same-or-higher' | 'any';
+};
+export type LooseMarkdownTableRowsOptions = {
+    excludePositions?: readonly Position[];
+};
+export type MarkdownSection = {
+    content: string;
+    endHeading: Heading | null;
+    endOffset: number;
+    startHeading: Heading;
+    startOffset: number;
+};
+export type LooseMarkdownTableRow = MarkdownTableRow & {
+    offset: number;
+};

package/dist/markdown/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/scc-complexity/baseline.d.mts

@@ -0,0 +1,6 @@
+import type { SccComplexityBaseline, SccComplexityBaselineEntry, SccComplexityScope, SccComplexityValue } from './types.mts';
+export declare const SCC_COMPLEXITY_BASELINE_VERSION: 1;
+export declare function parseSccComplexityBaseline(json: string): SccComplexityBaseline;
+export declare function validateSccComplexityBaseline(baseline: SccComplexityBaseline, scopes: readonly SccComplexityScope[], trackedFileSet: ReadonlySet<string>, valuesByScope: ReadonlyMap<string, readonly SccComplexityValue[]>): void;
+export declare function normalizeSccComplexityBaseline(baseline: SccComplexityBaseline, repoRoot: string): SccComplexityBaseline;
+export declare function baselineEntryByScopeAndFile(baseline: SccComplexityBaseline | undefined): ReadonlyMap<string, ReadonlyMap<string, SccComplexityBaselineEntry>>;

package/dist/scc-complexity/baseline.mjs

@@ -0,0 +1,90 @@
+import { assertWorkflowCommandData, canonicalRepoPath, isInScope } from './paths.mjs';
+import { SCC_COMPLEXITY_LIMIT } from './constants.mjs';
+export const SCC_COMPLEXITY_BASELINE_VERSION = 1;
+export function parseSccComplexityBaseline(json) {
+    const parsed = JSON.parse(json);
+    if (!isRecord(parsed))
+        throw new Error('baseline must be an object');
+    if (parsed.version !== SCC_COMPLEXITY_BASELINE_VERSION)
+        throw new Error(`baseline version must be ${SCC_COMPLEXITY_BASELINE_VERSION}`);
+    if (!Array.isArray(parsed.entries))
+        throw new Error('baseline entries must be an array');
+    const entries = parsed.entries.map(parseEntry);
+    const seen = new Map();
+    for (const entry of entries) {
+        if (seen.get(entry.scope)?.has(entry.file))
+            throw new Error(`baseline entry ${entry.scope}:${entry.file} is duplicated`);
+        const files = seen.get(entry.scope) ?? new Set();
+        files.add(entry.file);
+        seen.set(entry.scope, files);
+    }
+    return { entries, version: SCC_COMPLEXITY_BASELINE_VERSION };
+}
+export function validateSccComplexityBaseline(baseline, scopes, trackedFileSet, valuesByScope) {
+    const scopeByName = new Map(scopes.map((scope) => [scope.name, scope]));
+    const allFiles = new Set();
+    for (const values of valuesByScope.values()) {
+        for (const value of values)
+            allFiles.add(value.file);
+    }
+    for (const entry of baseline.entries) {
+        const key = `${entry.scope}:${entry.file}`;
+        const scope = scopeByName.get(entry.scope);
+        if (!scope)
+            throw new Error(`baseline entry ${key} is out of scope`);
+        if (!trackedFileSet.has(entry.file))
+            throw new Error(`baseline entry ${key} is untracked`);
+        if (!isInScope(entry.file, scope.includePaths))
+            throw new Error(`baseline entry ${key} is out of scope`);
+        const value = valuesByScope.get(scope.name)?.find((item) => item.file === entry.file);
+        if (!value) {
+            if (allFiles.has(entry.file))
+                throw new Error(`baseline entry ${key} is out of scope`);
+            throw new Error(`baseline entry ${key} is stale`);
+        }
+        if (value.complexity <= (scope.limit ?? SCC_COMPLEXITY_LIMIT))
+            throw new Error(`baseline entry ${key} is stale`);
+    }
+}
+export function normalizeSccComplexityBaseline(baseline, repoRoot) {
+    const entries = baseline.entries.map((entry) => ({
+        ...entry,
+        file: canonicalRepoPath(repoRoot, entry.file),
+    }));
+    const seen = new Map();
+    for (const entry of entries) {
+        if (seen.get(entry.scope)?.has(entry.file))
+            throw new Error(`baseline entry ${entry.scope}:${entry.file} is duplicated`);
+        const files = seen.get(entry.scope) ?? new Set();
+        files.add(entry.file);
+        seen.set(entry.scope, files);
+    }
+    return { entries, version: baseline.version };
+}
+export function baselineEntryByScopeAndFile(baseline) {
+    const scopes = new Map();
+    for (const entry of baseline?.entries ?? []) {
+        const files = scopes.get(entry.scope) ?? new Map();
+        files.set(entry.file, entry);
+        scopes.set(entry.scope, files);
+    }
+    return scopes;
+}
+function parseEntry(value, index) {
+    if (!isRecord(value))
+        throw new Error(`baseline entry ${index} must be an object`);
+    if (typeof value.scope !== 'string' || value.scope.length === 0)
+        throw new Error(`baseline entry ${index} has an invalid scope`);
+    if (typeof value.file !== 'string' || value.file.length === 0)
+        throw new Error(`baseline entry ${index} has an invalid file`);
+    assertWorkflowCommandData(value.scope, `baseline entry ${index}`);
+    assertWorkflowCommandData(value.file, `baseline entry ${index}`);
+    if (typeof value.complexity !== 'number' ||
+        !Number.isSafeInteger(value.complexity) ||
+        value.complexity < 0)
+        throw new Error(`baseline entry ${index} has an invalid complexity`);
+    return { complexity: value.complexity, file: value.file, scope: value.scope };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/scc-complexity/constants.d.mts

@@ -0,0 +1 @@
+export declare const SCC_COMPLEXITY_LIMIT = 50;

package/dist/scc-complexity/constants.mjs

@@ -0,0 +1 @@
+export const SCC_COMPLEXITY_LIMIT = 50;

package/dist/scc-complexity/index.d.mts

@@ -1,19 +1,11 @@
 import type { SharedContext } from '../shared-context/index.mts';
-export declare const SCC_COMPLEXITY_LIMIT = 50;
-export interface SccComplexityOptions {
-    limit?: number;
-    includeExt?: string;
-    excludeDir?: string;
-    notMatch?: string;
-    tmpdirPrefix?: string;
-    command?: string;
-}
-export interface SccComplexityViolation {
-    file: string;
-    complexity: number;
-}
+import type { SccComplexityOptions, SccComplexityScope, SccComplexityViolation } from './types.mts';
+export { parseSccComplexityBaseline, SCC_COMPLEXITY_BASELINE_VERSION } from './baseline.mts';
+export { SCC_COMPLEXITY_LIMIT } from './constants.mts';
+export type { SccComplexityBaseline, SccComplexityBaselineEntry, SccComplexityOptions, SccComplexityScope, SccComplexityViolation, } from './types.mts';
+type RunScc = (outputPath: string, scope?: SccComplexityScope) => Promise<string>;
 export declare function buildSccArgs(options?: SccComplexityOptions): string[];
-export declare function checkSccComplexity(ctx: SharedContext, options?: SccComplexityOptions, runScc?: (outputPath: string) => Promise<string>): Promise<{
+export declare function checkSccComplexity(ctx: SharedContext, options?: SccComplexityOptions, runScc?: RunScc): Promise<{
     errors: string[];
 }>;
 export declare function parseSccComplexityViolations(json: string, trackedFileSet: ReadonlySet<string>, limit?: number): SccComplexityViolation[];