miniread 1.0.0

package/dist/scripts/sample/extract-function-samples.js

@@ -0,0 +1,105 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import { collectFileFunctionCandidates, } from "./collect-function-candidates.js";
+import { createFunctionExcerpt } from "./create-function-excerpt.js";
+import { createLineStartOffsets } from "./line-offsets.js";
+import { sampleIndicesWithoutReplacement } from "./random.js";
+const selectFilePaths = (options) => {
+    const { filePaths, maxFiles, rng } = options;
+    if (maxFiles <= 0 || maxFiles >= filePaths.length)
+        return filePaths;
+    return sampleIndicesWithoutReplacement({
+        size: filePaths.length,
+        count: maxFiles,
+        rng,
+    })
+        .map((index) => filePaths[index])
+        .filter((filePath) => filePath !== undefined);
+};
+const groupCandidatesByFile = (reservoir) => {
+    const candidatesByFile = new Map();
+    for (const entry of reservoir) {
+        const existing = candidatesByFile.get(entry.filePath);
+        if (existing) {
+            existing.push(entry.candidate);
+        }
+        else {
+            candidatesByFile.set(entry.filePath, [entry.candidate]);
+        }
+    }
+    return candidatesByFile;
+};
+export const extractFunctionSamples = async (options) => {
+    const { filePaths, rootDirectory, maxFiles, snippets, minLines, maxLines, contextLines, contextChars, maxChars, rng, } = options;
+    const selectedFiles = selectFilePaths({ filePaths, maxFiles, rng });
+    const reservoir = [];
+    let eligibleSeen = 0;
+    const consider = (entry) => {
+        eligibleSeen++;
+        if (reservoir.length < snippets) {
+            reservoir.push(entry);
+            return;
+        }
+        const index = rng.nextInt(eligibleSeen);
+        if (index < snippets) {
+            reservoir[index] = entry;
+        }
+    };
+    for (const filePath of selectedFiles) {
+        const content = await fs.readFile(filePath, "utf8");
+        const candidatesResult = collectFileFunctionCandidates({
+            filePath,
+            content,
+        });
+        if (!candidatesResult.ok) {
+            console.error(`Warning: ${candidatesResult.error}`);
+            continue;
+        }
+        for (const candidate of candidatesResult.candidates) {
+            if (candidate.endLine - candidate.startLine + 1 < minLines)
+                continue;
+            consider({ filePath, candidate });
+        }
+    }
+    const candidatesByFile = groupCandidatesByFile(reservoir);
+    const samples = [];
+    for (const [filePath, candidates] of candidatesByFile) {
+        const content = await fs.readFile(filePath, "utf8");
+        const lineStartOffsets = createLineStartOffsets(content);
+        const totalLines = lineStartOffsets.length;
+        for (const candidate of candidates) {
+            const { excerptStartLine, excerptEndLine, excerptStartOffset, excerptEndOffset, truncated, code, } = createFunctionExcerpt({
+                content,
+                lineStartOffsets,
+                totalLines,
+                startLine: candidate.startLine,
+                endLine: candidate.endLine,
+                startOffset: candidate.startOffset,
+                endOffset: candidate.endOffset,
+                contextLines,
+                contextChars,
+                maxLines,
+                maxChars,
+            });
+            samples.push({
+                filePath,
+                filePathRelative: path.relative(rootDirectory, filePath),
+                nodeType: candidate.nodeType,
+                name: candidate.name,
+                startLine: candidate.startLine,
+                endLine: candidate.endLine,
+                startColumn: candidate.startColumn,
+                endColumn: candidate.endColumn,
+                startOffset: candidate.startOffset,
+                endOffset: candidate.endOffset,
+                excerptStartLine,
+                excerptEndLine,
+                excerptStartOffset,
+                excerptEndOffset,
+                truncated,
+                code,
+            });
+        }
+    }
+    return samples;
+};

package/dist/scripts/sample/find-source-files.d.ts

@@ -0,0 +1 @@
+export declare const findSourceFiles: (inputPath: string) => Promise<string[]>;

package/dist/scripts/sample/find-source-files.js

@@ -0,0 +1,49 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+const isSourceFile = (fileName) => {
+    return (!fileName.endsWith(".d.ts") &&
+        (fileName.endsWith(".ts") ||
+            fileName.endsWith(".tsx") ||
+            fileName.endsWith(".js") ||
+            fileName.endsWith(".jsx")));
+};
+const findSourceFilesInDirectory = async (directory) => {
+    const entries = await fs.readdir(directory, { withFileTypes: true });
+    const sourceFiles = [];
+    for (const entry of entries) {
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            sourceFiles.push(...(await findSourceFilesInDirectory(fullPath)));
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        if (!isSourceFile(entry.name))
+            continue;
+        sourceFiles.push(fullPath);
+    }
+    return sourceFiles;
+};
+export const findSourceFiles = async (inputPath) => {
+    let stat;
+    try {
+        stat = await fs.stat(inputPath);
+    }
+    catch {
+        throw new Error(`Input path does not exist: ${inputPath}`);
+    }
+    if (stat.isFile()) {
+        if (!isSourceFile(inputPath)) {
+            throw new Error(`Input file is not a supported source file: ${inputPath}`);
+        }
+        return [inputPath];
+    }
+    if (!stat.isDirectory()) {
+        throw new Error(`Input path must be a file or directory: ${inputPath}`);
+    }
+    const files = await findSourceFilesInDirectory(inputPath);
+    if (files.length === 0) {
+        throw new Error(`No source files found under: ${inputPath}`);
+    }
+    return files;
+};

package/dist/scripts/sample/format-sample-output.d.ts

@@ -0,0 +1,22 @@
+import type { FunctionSample } from "./extract-function-samples.js";
+import type { SampleOutputFormat } from "./create-sample-command.js";
+type SampleOutput = {
+    generatedAt: string;
+    seed: string | undefined;
+    inputPath: string;
+    settings: {
+        snippets: number;
+        maxFiles: number;
+        minLines: number;
+        maxLines: number;
+        maxChars: number;
+        contextLines: number;
+        contextChars: number;
+    };
+    samples: FunctionSample[];
+};
+export declare const formatSampleOutput: (options: {
+    format: SampleOutputFormat;
+    output: SampleOutput;
+}) => string;
+export {};

package/dist/scripts/sample/format-sample-output.js

@@ -0,0 +1,29 @@
+const formatMarkdown = (output) => {
+    const lines = [
+        "# Miniread Sample Pack",
+        "",
+        `Generated at: ${output.generatedAt}`,
+        `Input: ${output.inputPath}`,
+        `Seed: ${output.seed ?? "(crypto)"}`,
+        `Settings: snippets=${output.settings.snippets} maxFiles=${output.settings.maxFiles === 0 ? "all" : output.settings.maxFiles} minLines=${output.settings.minLines} maxLines=${output.settings.maxLines} maxChars=${output.settings.maxChars} contextLines=${output.settings.contextLines} contextChars=${output.settings.contextChars}`,
+        "",
+        "## Rules for the agent",
+        "",
+        "- Use ONLY the code samples in this document.",
+        "- Do NOT pick additional files/functions beyond these samples.",
+        "- Base all analysis and proposed transforms on patterns observed here.",
+        "",
+    ];
+    for (const [index, sample] of output.samples.entries()) {
+        const nameSuffix = sample.name ? ` (${sample.name})` : "";
+        const truncationNote = sample.truncated ? " (clipped)" : "";
+        lines.push(`## Sample ${index + 1}`, "", `- File: \`${sample.filePathRelative}\``, `- Node: \`${sample.nodeType}\`${nameSuffix} • lines ${sample.startLine}:${sample.startColumn}-${sample.endLine}:${sample.endColumn} • chars ${sample.startOffset}-${sample.endOffset}${truncationNote}`, `- Excerpt: lines ${sample.excerptStartLine}-${sample.excerptEndLine} • chars ${sample.excerptStartOffset}-${sample.excerptEndOffset}`, "", "```js", sample.code.trimEnd(), "```", "");
+    }
+    return lines.join("\n");
+};
+export const formatSampleOutput = (options) => {
+    const { format, output } = options;
+    if (format === "markdown")
+        return formatMarkdown(output);
+    return `${JSON.stringify(output, undefined, 2)}\n`;
+};

package/dist/scripts/sample/line-offsets.d.ts

@@ -0,0 +1,4 @@
+export declare const createLineStartOffsets: (content: string) => number[];
+export declare const getLineStartOffset: (lineStartOffsets: number[], line: number) => number;
+export declare const getLineEndOffset: (lineStartOffsets: number[], line: number, contentLength: number) => number;
+export declare const offsetToLineNumber: (lineStartOffsets: number[], offset: number) => number;

package/dist/scripts/sample/line-offsets.js

@@ -0,0 +1,40 @@
+export const createLineStartOffsets = (content) => {
+    const offsets = [0];
+    for (let index = 0; index < content.length; index++) {
+        if (content.codePointAt(index) === 10) {
+            offsets.push(index + 1);
+        }
+    }
+    return offsets;
+};
+export const getLineStartOffset = (lineStartOffsets, line) => {
+    const offset = lineStartOffsets[line - 1];
+    return offset ?? 0;
+};
+export const getLineEndOffset = (lineStartOffsets, line, contentLength) => {
+    const offset = lineStartOffsets[line];
+    return offset ?? contentLength;
+};
+export const offsetToLineNumber = (lineStartOffsets, offset) => {
+    if (lineStartOffsets.length === 0)
+        return 1;
+    if (offset <= 0)
+        return 1;
+    let low = 0;
+    let high = lineStartOffsets.length - 1;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const midOffset = lineStartOffsets[mid];
+        if (midOffset === undefined)
+            break;
+        if (midOffset === offset)
+            return mid + 1;
+        if (midOffset < offset) {
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    return Math.max(1, high + 1);
+};

package/dist/scripts/sample/parse-sample-cli-options.d.ts

@@ -0,0 +1,18 @@
+import type { SampleCliRawOptions } from "./create-sample-command.js";
+import type { SampleOutputFormat } from "./create-sample-command.js";
+export type SampleCliOptions = {
+    inputPath: string;
+    snippets: number;
+    maxFiles: number;
+    minLines: number;
+    maxLines: number;
+    maxChars: number;
+    contextLines: number;
+    contextChars: number;
+    seed: string | undefined;
+    format: SampleOutputFormat;
+};
+export declare const parseSampleCliOptions: (options: {
+    cwd: string;
+    rawOptions: SampleCliRawOptions;
+}) => SampleCliOptions;

package/dist/scripts/sample/parse-sample-cli-options.js

@@ -0,0 +1,36 @@
+import path from "node:path";
+export const parseSampleCliOptions = (options) => {
+    const { cwd, rawOptions } = options;
+    const snippets = rawOptions.snippets;
+    const maxFiles = rawOptions.maxFiles;
+    if (rawOptions.maxLines < 1) {
+        throw new Error("--max-lines must be >= 1");
+    }
+    if (rawOptions.minLines < 1) {
+        throw new Error("--min-lines must be >= 1");
+    }
+    if (rawOptions.minLines > rawOptions.maxLines) {
+        throw new Error("--min-lines must be <= --max-lines");
+    }
+    if (rawOptions.maxChars < 200) {
+        throw new Error("--max-chars must be >= 200");
+    }
+    if (snippets < 1) {
+        throw new Error("--snippets must be >= 1");
+    }
+    if (maxFiles < 0) {
+        throw new Error("--max-files must be >= 0");
+    }
+    return {
+        inputPath: path.resolve(cwd, rawOptions.input),
+        snippets,
+        maxFiles,
+        minLines: rawOptions.minLines,
+        maxLines: rawOptions.maxLines,
+        maxChars: rawOptions.maxChars,
+        contextLines: rawOptions.contextLines,
+        contextChars: rawOptions.contextChars,
+        seed: rawOptions.seed,
+        format: rawOptions.format,
+    };
+};

package/dist/scripts/sample/random.d.ts

@@ -0,0 +1,10 @@
+export type RandomNumberGenerator = {
+    nextInt: (maxExclusive: number) => number;
+};
+export declare const createCryptoRng: () => RandomNumberGenerator;
+export declare const createSeededRng: (seed: string) => RandomNumberGenerator;
+export declare const sampleIndicesWithoutReplacement: (options: {
+    size: number;
+    count: number;
+    rng: RandomNumberGenerator;
+}) => number[];

package/dist/scripts/sample/random.js

@@ -0,0 +1,60 @@
+import { createHash, randomInt } from "node:crypto";
+export const createCryptoRng = () => {
+    return {
+        nextInt(maxExclusive) {
+            if (!Number.isInteger(maxExclusive) || maxExclusive <= 0) {
+                throw new Error(`maxExclusive must be a positive integer (got: ${maxExclusive})`);
+            }
+            return randomInt(maxExclusive);
+        },
+    };
+};
+const createMulberry32 = (seed) => {
+    let state = seed >>> 0;
+    return () => {
+        state = (state + 0x6d_2b_79_f5) >>> 0;
+        let t = Math.imul(state ^ (state >>> 15), state | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4_294_967_296;
+    };
+};
+export const createSeededRng = (seed) => {
+    const digest = createHash("sha256").update(seed).digest();
+    const seedInt = digest.readUInt32LE(0);
+    const nextFloat = createMulberry32(seedInt === 0 ? 1 : seedInt);
+    return {
+        nextInt(maxExclusive) {
+            if (!Number.isInteger(maxExclusive) || maxExclusive <= 0) {
+                throw new Error(`maxExclusive must be a positive integer (got: ${maxExclusive})`);
+            }
+            return Math.floor(nextFloat() * maxExclusive);
+        },
+    };
+};
+export const sampleIndicesWithoutReplacement = (options) => {
+    const { size, count, rng } = options;
+    if (!Number.isInteger(size) || size < 0) {
+        throw new Error(`size must be a non-negative integer (got: ${size})`);
+    }
+    if (!Number.isInteger(count) || count < 0) {
+        throw new Error(`count must be a non-negative integer (got: ${count})`);
+    }
+    if (count > size) {
+        throw new Error(`count (${count}) cannot be greater than size (${size})`);
+    }
+    if (count === 0)
+        return [];
+    if (size === 0)
+        return [];
+    const swaps = new Map();
+    const selected = [];
+    for (let index = 0; index < count; index++) {
+        const randomIndex = index + rng.nextInt(size - index);
+        const valueAtRandomIndex = swaps.get(randomIndex) ?? randomIndex;
+        const valueAtIndex = swaps.get(index) ?? index;
+        swaps.set(randomIndex, valueAtIndex);
+        swaps.set(index, valueAtRandomIndex);
+        selected.push(valueAtRandomIndex);
+    }
+    return selected;
+};

package/dist/scripts/sample/run-sample-cli.d.ts

@@ -0,0 +1 @@
+export declare const runSampleCli: (argv: string[]) => Promise<number>;

package/dist/scripts/sample/run-sample-cli.js

@@ -0,0 +1,79 @@
+import packageJson from "../../../package.json" with { type: "json" };
+import { createSampleCommand } from "./create-sample-command.js";
+import { parseSampleCliOptions, } from "./parse-sample-cli-options.js";
+import { createCryptoRng, createSeededRng } from "./random.js";
+import { findSourceFiles } from "./find-source-files.js";
+import { extractFunctionSamples } from "./extract-function-samples.js";
+import { formatSampleOutput } from "./format-sample-output.js";
+export const runSampleCli = async (argv) => {
+    const program = createSampleCommand({ version: packageJson.version });
+    program.parse(argv.filter((argument) => argument !== "--"));
+    const rawOptions = program.opts();
+    let parsedOptions;
+    try {
+        parsedOptions = parseSampleCliOptions({
+            cwd: process.cwd(),
+            rawOptions,
+        });
+    }
+    catch (error) {
+        program.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+    const rng = parsedOptions.seed
+        ? createSeededRng(parsedOptions.seed)
+        : createCryptoRng();
+    let filePaths;
+    try {
+        filePaths = await findSourceFiles(parsedOptions.inputPath);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        return 1;
+    }
+    let samples;
+    try {
+        samples = await extractFunctionSamples({
+            filePaths,
+            rootDirectory: process.cwd(),
+            maxFiles: parsedOptions.maxFiles,
+            snippets: parsedOptions.snippets,
+            minLines: parsedOptions.minLines,
+            maxLines: parsedOptions.maxLines,
+            maxChars: parsedOptions.maxChars,
+            contextLines: parsedOptions.contextLines,
+            contextChars: parsedOptions.contextChars,
+            rng,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        return 1;
+    }
+    if (samples.length === 0) {
+        console.error("No samples produced. Try lowering --min-lines, increasing --max-lines/--max-chars, increasing --max-files, or increasing --snippets.");
+        return 1;
+    }
+    const outputText = formatSampleOutput({
+        format: parsedOptions.format,
+        output: {
+            generatedAt: new Date().toISOString(),
+            seed: parsedOptions.seed,
+            inputPath: parsedOptions.inputPath,
+            settings: {
+                snippets: parsedOptions.snippets,
+                maxFiles: parsedOptions.maxFiles,
+                minLines: parsedOptions.minLines,
+                maxLines: parsedOptions.maxLines,
+                maxChars: parsedOptions.maxChars,
+                contextLines: parsedOptions.contextLines,
+                contextChars: parsedOptions.contextChars,
+            },
+            samples,
+        },
+    });
+    process.stdout.write(outputText);
+    return 0;
+};

package/dist/scripts/sample.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/scripts/sample.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { runSampleCli } from "./sample/run-sample-cli.js";
+try {
+    const exitCode = await runSampleCli(process.argv);
+    if (exitCode !== 0) {
+        process.exitCode = exitCode;
+    }
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exitCode = 1;
+}

package/dist/transforms/add-prefix/add-prefix-transform.d.ts

@@ -0,0 +1,2 @@
+import type { Transform } from "../../core/types.js";
+export declare const addPrefixTransform: Transform;

package/dist/transforms/add-prefix/add-prefix-transform.js

@@ -0,0 +1,40 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const PREFIX = "renamed_";
+export const addPrefixTransform = {
+    id: "add-prefix",
+    description: `Adds "${PREFIX}" prefix to variable and function declarations`,
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type === "Identifier" && !id.name.startsWith(PREFIX)) {
+                        path.scope.rename(id.name, `${PREFIX}${id.name}`);
+                        transformationsApplied++;
+                    }
+                },
+                FunctionDeclaration(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id && !id.name.startsWith(PREFIX)) {
+                        path.scope.rename(id.name, `${PREFIX}${id.name}`);
+                        transformationsApplied++;
+                    }
+                },
+            });
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/dist/transforms/add-suffix/add-suffix-transform.d.ts

@@ -0,0 +1,2 @@
+import type { Transform } from "../../core/types.js";
+export declare const addSuffixTransform: Transform;

package/dist/transforms/add-suffix/add-suffix-transform.js

@@ -0,0 +1,40 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const SUFFIX = "_end";
+export const addSuffixTransform = {
+    id: "add-suffix",
+    description: `Adds "${SUFFIX}" suffix to variable and function declarations`,
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type === "Identifier" && !id.name.endsWith(SUFFIX)) {
+                        path.scope.rename(id.name, `${id.name}${SUFFIX}`);
+                        transformationsApplied++;
+                    }
+                },
+                FunctionDeclaration(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id && !id.name.endsWith(SUFFIX)) {
+                        path.scope.rename(id.name, `${id.name}${SUFFIX}`);
+                        transformationsApplied++;
+                    }
+                },
+            });
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/dist/transforms/expand-boolean-literals/expand-boolean-literals-transform.d.ts

@@ -0,0 +1,2 @@
+import type { Transform } from "../../core/types.js";
+export declare const expandBooleanLiteralsTransform: Transform;

package/dist/transforms/expand-boolean-literals/expand-boolean-literals-transform.js

@@ -0,0 +1,39 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const t = require("@babel/types");
+export const expandBooleanLiteralsTransform = {
+    id: "expand-boolean-literals",
+    description: "Expands !0 to true and !1 to false",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                UnaryExpression(path) {
+                    nodesVisited++;
+                    const { operator, argument } = path.node;
+                    // Check for !0 or !1 pattern
+                    if (operator === "!" &&
+                        argument.type === "NumericLiteral" &&
+                        (argument.value === 0 || argument.value === 1)) {
+                        // !0 = true, !1 = false
+                        const booleanValue = argument.value === 0;
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                        path.replaceWith(t.booleanLiteral(booleanValue));
+                        transformationsApplied++;
+                    }
+                },
+            });
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/dist/transforms/expand-undefined-literals/expand-undefined-literals-transform.d.ts

@@ -0,0 +1,2 @@
+import type { Transform } from "../../core/types.js";
+export declare const expandUndefinedLiteralsTransform: Transform;

package/dist/transforms/expand-undefined-literals/expand-undefined-literals-transform.js

@@ -0,0 +1,40 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const t = require("@babel/types");
+export const expandUndefinedLiteralsTransform = {
+    id: "expand-undefined-literals",
+    description: "Expands void 0 to undefined (when undefined is not shadowed)",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                UnaryExpression(path) {
+                    nodesVisited++;
+                    const { operator, argument } = path.node;
+                    if (operator !== "void")
+                        return;
+                    if (argument.type !== "NumericLiteral")
+                        return;
+                    if (argument.value !== 0)
+                        return;
+                    if (path.scope.hasBinding("undefined", true))
+                        return;
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                    path.replaceWith(t.identifier("undefined"));
+                    transformationsApplied++;
+                },
+            });
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/dist/transforms/rename-catch-parameters/rename-catch-parameters-transform.d.ts

@@ -0,0 +1,2 @@
+import type { Transform } from "../../core/types.js";
+export declare const renameCatchParametersTransform: Transform;