@systemfsoftware/arethetypeswrong-cli 0.18.5

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2023 Andrew Branch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,265 @@
+# arethetypeswrong/cli
+
+A CLI for [arethetypeswrong.github.io](https://arethetypeswrong.github.io/).
+
+This project attempts to analyze npm package contents for issues with their TypeScript types, particularly ESM-related module resolution issues. The following kinds of problems can be detected in the `node10`, `node16`, and `bundler` module resolution modes:
+
+- [💀 Resolution failed](https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/NoResolution.md)
+- [❌ No types](https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/UntypedResolution.md)
+- [🎭 Masquerading as CJS](https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/FalseCJS.md)
+- [👺 Masquerading as ESM](https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/FalseESM.md)
+- [⚠️ ESM (dynamic import only)](https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/CJSResolvesToESM.md)
+- [🐛 Used fallback condition](https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/FallbackCondition.md)
+- [🤨 CJS default export](https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/CJSOnlyExportsDefault.md)
+- [❗️ Incorrect default export](https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/FalseExportDefault.md)
+- [❓ Missing `export =`](https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/MissingExportEquals.md)
+- [🚭 Unexpected module syntax](https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/UnexpectedModuleSyntax.md)
+- [🥴 Internal resolution error](https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/InternalResolutionError.md)
+- [🕵️‍♂️ Named exports](https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/NamedExports.md)
+
+## Installation
+
+```shell
+npm i -g @systemfsoftware/arethetypeswrong-cli
+```
+
+<!-- Or, using `npx`: -->
+<!---->
+<!-- ```shell -->
+<!-- npx attw -->
+<!-- ``` -->
+
+## Usage
+
+The `attw` command acts very similarly to [arethetypeswrong.github.io](https://arethetypeswrong.github.io/), with some additional features that are useful for command line usage.
+
+The CLI can check an `npm pack`ed tarball:
+
+```shell
+npm pack
+attw cool-package-1.0.0.tgz
+# or
+attw $(npm pack)
+```
+
+or pack one in-place by specifying `--pack` and a directory:
+
+```shell
+attw --pack .
+```
+
+or check a package from npm:
+
+```shell
+attw --from-npm @systemfsoftware/arethetypeswrong-cli
+```
+
+You can also use `attw` without installing globally by using `npx`. Pack one in-place by specifying `--pack` and a directory:
+
+```
+npx --yes @systemfsoftware/arethetypeswrong-cli --pack .
+```
+
+or check a package from npm:
+
+```
+npx --yes @systemfsoftware/arethetypeswrong-cli --from-npm @systemfsoftware/arethetypeswrong-cli
+```
+
+## Configuration
+
+`attw` supports a JSON config file (by default named `.attw.json`) which allows you to pre-set the command line arguments. The options are a one-to-one mapping of the command line flags, changed to camelCase, and are all documented in their relevant `Options` section below.
+
+### Options
+
+#### Help
+
+Show help information and exit.
+
+In the CLI: `--help`, `-h`
+
+```shell
+attw --help
+```
+
+#### Version
+
+Print the current version of `attw` and exit.
+
+In the CLI: `--version`, `-v`
+
+```shell
+attw --version
+```
+
+### Pack
+
+Specify a directory to run `npm pack` in (instead of specifying a tarball filename), analyze the resulting tarball, and delete it afterwards.
+
+```shell
+attw --pack .
+```
+
+Please note that the `--pack` option does not support package managers other than npm at this time.
+Therefore, if you use pnpm or yarn, you should generate the tarball yourself first (using `pnpm pack`/`yarn pack`) and run then run `attw <packed-tarball-name>`, rather than using the `--pack` option.
+
+#### From NPM
+
+Specify the name (and, optionally, version or SemVer range) of a package from the NPM registry instead of a local tarball filename.
+
+In the CLI: `--from-npm`, `-p`
+
+```shell
+attw --from-npm <package-name>
+```
+
+In the config file, `fromNpm` can be a boolean value.
+
+#### DefinitelyTyped
+
+When a package does not contain types, specifies the version or SemVer range of the DefinitelyTyped `@types` package to use. Defaults to inferring the best version match from the implementation package version.
+
+In the CLI: `--definitely-typed`, `--no-definitely-typed`
+
+```shell
+attw -p <package-name> --definitely-typed <version>
+attw -p <package-name> --no-definitely-typed
+```
+
+#### Format
+
+The format to print the output in. Defaults to `auto`.
+
+The available values are:
+
+- `table`, where columns are entrypoints and rows are resolution kinds
+- `table-flipped`, where columns are resolution kinds and rows are entrypoints
+- `ascii`, for large tables where the output is clunky
+- `auto`, which picks whichever of the above best fits the terminal width
+- `json` outputs the raw JSON data (overriding all other rendering options)
+
+In the CLI: `--format`, `-f`
+
+```shell
+attw --format <format> <file-name>
+```
+
+In the config file, `format` can be a string value.
+
+#### Entrypoints
+
+`attw` automatically discovers package entrypoints by looking at package.json `exports` and subdirectories with additional package.json files. In a package lacking `exports`, providing the `--entrypoints-legacy` option will include all published code files. This automatic discovery process can be overridden with the `--entrypoints` option, or altered with the `--include-entrypoints` and `--exclude-entrypoints` options:
+
+```shell
+attw --pack . --entrypoints . one two three    # Just ".", "./one", "./two", "./three"
+attw --pack . --include-entrypoints added      # Auto-discovered entrypoints plus "./added"
+attw --pack . --exclude-entrypoints styles.css # Auto-discovered entrypoints except "./styles.css"
+attw --pack . --entrypoints-legacy             # All published code files
+```
+
+#### Profiles
+
+Profiles select a set of resolution modes to require/ignore. All are evaluated but failures outside of those required are ignored.
+
+The available profiles are:
+
+- `strict` - requires all resolutions
+- `node16` - ignores node10 resolution failures
+- `esm-only` - ignores CJS resolution failures
+
+In the CLI: `--profile`
+
+```shell
+attw <file-name> --profile <profile>
+```
+
+In the config file, `profile` can be a string value.
+
+#### Ignore Rules
+
+Specifies rules/problems to ignore (i.e. not raise an error for).
+
+The available values are:
+
+- `no-resolution`
+- `untyped-resolution`
+- `false-cjs`
+- `false-esm`
+- `cjs-resolves-to-esm`
+- `fallback-condition`
+- `cjs-only-exports-default`
+- `false-export-default`
+- `unexpected-module-syntax`
+- `missing-export-equals`
+- `internal-resolution-error`
+- `named-exports`
+
+In the CLI: `--ignore-rules`
+
+```shell
+attw <file-name> --ignore-rules <rules...>
+```
+
+In the config file, `ignoreRules` can be an array of strings.
+
+#### Summary/No Summary
+
+Whether to display a summary of what the different errors/problems mean. Defaults to showing the summary (`--summary`).
+
+In the CLI: `--summary`/`--no-summary`
+
+```shell
+attw --summary/--no-summary <file-name>
+```
+
+In the config file, `summary` can be a boolean value.
+
+#### Emoji/No Emoji
+
+Whether to print the information with emojis. Defaults to printing with emojis (`--emoji`).
+
+In the CLI: `--emoji`/`--no-emoji`
+
+```shell
+attw --emoji/--no-emoji <file-name>
+```
+
+In the config file, `emoji` can be a boolean value.
+
+#### Color/No Color
+
+Whether to print with colors. Defaults to printing with colors (`--color`).
+
+The `FORCE_COLOR` env variable is also available for use (set is to `0` or `1`).
+
+In the CLI: `--color`/`--no-color`
+
+```shell
+attw --color/--no-color <file-name>
+```
+
+In the config file, `color` can be a boolean value.
+
+#### Quiet
+
+When set, nothing will be printed to STDOUT.
+
+In the CLI: `--quiet`, `-q`
+
+```shell
+attw --quiet <file-name>
+```
+
+In the config file, `quiet` can be a boolean value.
+
+#### Config Path
+
+The path to the config file. Defaults to `./.attw.json`.
+
+In the CLI: `--config-path <path>`
+
+```shell
+attw --config-path <path> <file-name>
+```
+
+Cannot be set from within the config file itself.

package/dist/getExitCode.d.ts

@@ -0,0 +1,6 @@
+import { n as RenderOptions } from "./index-DM-Vgonq.js";
+import { CheckResult } from "@systemfsoftware/arethetypeswrong-core";
+//#region src/getExitCode.d.ts
+declare function getExitCode(analysis: CheckResult, opts?: RenderOptions): number;
+//#endregion
+export { getExitCode };

package/dist/getExitCode.mjs

@@ -0,0 +1,14 @@
+import { n as problemFlags } from "./problemUtils-DrDcGcsf.mjs";
+//#region src/getExitCode.ts
+function getExitCode(analysis, opts) {
+	if (!analysis.types) return 0;
+	const ignoreRules = opts?.ignoreRules ?? [];
+	const ignoreResolutions = opts?.ignoreResolutions ?? [];
+	return analysis.problems.some((problem) => {
+		const notRuleIgnored = !ignoreRules.includes(problemFlags[problem.kind]);
+		const notResolutionIgnored = "resolutionKind" in problem ? !ignoreResolutions.includes(problem.resolutionKind) : true;
+		return notRuleIgnored && notResolutionIgnored;
+	}) ? 1 : 0;
+}
+//#endregion
+export { getExitCode };

package/dist/index-DM-Vgonq.d.ts

@@ -0,0 +1,36 @@
+import * as core from "@systemfsoftware/arethetypeswrong-core";
+//#region src/problemUtils.d.ts
+declare const problemFlags: {
+  readonly NoResolution: "no-resolution";
+  readonly UntypedResolution: "untyped-resolution";
+  readonly FalseCJS: "false-cjs";
+  readonly FalseESM: "false-esm";
+  readonly CJSResolvesToESM: "cjs-resolves-to-esm";
+  readonly FallbackCondition: "fallback-condition";
+  readonly CJSOnlyExportsDefault: "cjs-only-exports-default";
+  readonly NamedExports: "named-exports";
+  readonly FalseExportDefault: "false-export-default";
+  readonly MissingExportEquals: "missing-export-equals";
+  readonly UnexpectedModuleSyntax: "unexpected-module-syntax";
+  readonly InternalResolutionError: "internal-resolution-error";
+};
+declare const resolutionKinds: Record<core.ResolutionKind, string>;
+//#endregion
+//#region src/render/typed.d.ts
+declare function typed(analysis: core.Analysis, { emoji, summary, format, ignoreRules, ignoreResolutions }: RenderOptions): Promise<string>;
+//#endregion
+//#region src/render/untyped.d.ts
+declare function untyped(analysis: core.UntypedResult): string;
+//#endregion
+//#region src/render/index.d.ts
+type Format = 'auto' | 'table' | 'table-flipped' | 'ascii' | 'json';
+interface RenderOptions {
+  ignoreRules?: (typeof problemFlags)[keyof typeof problemFlags][];
+  ignoreResolutions?: (keyof typeof resolutionKinds)[];
+  format?: Format;
+  color?: boolean;
+  summary?: boolean;
+  emoji?: boolean;
+}
+//#endregion
+export { typed as i, RenderOptions as n, untyped as r, Format as t };

package/dist/index.d.ts

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

package/dist/index.mjs

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+import { n as problemFlags } from "./problemUtils-DrDcGcsf.mjs";
+import { getExitCode } from "./getExitCode.mjs";
+import { n as typed, t as untyped } from "./render-CTRBsIjQ.mjs";
+import * as core from "@systemfsoftware/arethetypeswrong-core";
+import { groupProblemsByKind, parsePackageSpec } from "@systemfsoftware/arethetypeswrong-core/utils";
+import { versions } from "@systemfsoftware/arethetypeswrong-core/versions";
+import chalk from "chalk";
+import { execSync } from "child_process";
+import { Option, program } from "commander";
+import { readFile, stat, unlink } from "fs/promises";
+import { createRequire } from "module";
+import path from "path";
+import readline from "readline";
+import { major, minor } from "semver";
+import { Writable } from "stream";
+import { Readable } from "node:stream";
+//#region src/profiles.ts
+const profiles = {
+	strict: { ignoreResolutions: [] },
+	node16: { ignoreResolutions: ["node10"] },
+	"esm-only": { ignoreResolutions: ["node10", "node16-cjs"] }
+};
+/**
+* Merges the profile with the provided options
+*
+* @param profileKey - name of the profile to apply
+* @param opts - options to apply the profile to
+*/
+function applyProfile(profileKey, opts) {
+	const profile = profiles[profileKey];
+	opts.ignoreResolutions = (opts.ignoreResolutions ?? []).concat(profile.ignoreResolutions);
+}
+//#endregion
+//#region src/readConfig.ts
+async function readConfig(program, alternate = ".attw.json") {
+	try {
+		const results = await readFile(alternate, "utf8");
+		if (!results) return;
+		const opts = JSON.parse(results);
+		for (let key in opts) {
+			if (key === "configPath") program.error(`cannot set "configPath" within ${alternate}`, { code: "INVALID_OPTION" });
+			const value = opts[key];
+			if (key === "ignoreRules") {
+				if (!Array.isArray(value)) program.error(`error: config option 'ignoreRules' should be an array.`);
+				const invalid = value.find((rule) => !Object.values(problemFlags).includes(rule));
+				if (invalid) program.error(`error: config option 'ignoreRules' argument '${invalid}' is invalid. Allowed choices are ${Object.values(problemFlags).join(", ")}.`);
+			}
+			if (key === "profile") {
+				if (typeof value !== "string") program.error(`error: config option 'profile' should be a string.`);
+				if (!(value in profiles)) program.error(`error: config option 'profile' argument '${value}' is invalid. Allowed choices are ${Object.keys(profiles).join(", ")}.`);
+			}
+			if (Array.isArray(value)) {
+				const opt = program.getOptionValue(key);
+				if (Array.isArray(opt)) {
+					program.setOptionValueWithSource(key, [...opt, ...value], "config");
+					continue;
+				}
+			}
+			if (key !== "help" && key !== "version") program.setOptionValueWithSource(key, opts[key], "config");
+		}
+	} catch (error) {
+		if (!error || typeof error !== "object" || !("code" in error) || !("message" in error)) program.error("unknown error while reading config file", { code: "UNKNOWN" });
+		else if (error.code !== "ENOENT") program.error(`error while reading config file:\n${error.message}`);
+	}
+}
+//#endregion
+//#region src/write.ts
+async function write(data, out) {
+	return new Promise((resolve, reject) => {
+		const stream = new Readable({ read() {
+			this.push(data);
+			this.push("\n");
+			this.push(null);
+		} });
+		stream.on("data", (chunk) => {
+			out.write(chunk);
+		});
+		stream.on("end", () => {
+			resolve();
+		});
+		out.on("error", (err) => {
+			reject(err);
+		});
+	});
+}
+//#endregion
+//#region src/index.ts
+const version = createRequire(import.meta.url)("../package.json").version;
+const formats = Object.keys({
+	auto: true,
+	json: true,
+	ascii: true,
+	table: true,
+	"table-flipped": true
+});
+program.addHelpText("before", `ATTW CLI (v${version})\n`).addHelpText("after", `\ncore: v${versions.core}, typescript: v${versions.typescript}`).version(`cli: v${version}\ncore: v${versions.core}\ntypescript: v${versions.typescript}`).name("attw").description(`${chalk.bold.blue("Are the Types Wrong?")} attempts to analyze npm package contents for issues with their TypeScript types,
+particularly ESM-related module resolution issues.`).argument("[file-directory-or-package-spec]", "the packed .tgz, or directory containing package.json with --pack, or package spec with --from-npm").option("-P, --pack", "Run `npm pack` in the specified directory and delete the resulting .tgz file afterwards").option("-p, --from-npm", "Read from the npm registry instead of a local file").addOption(new Option("--definitely-typed [version]", "Specify the version range of @types to use").default(true)).option("--no-definitely-typed", "Don't include @types").addOption(new Option("-f, --format <format>", "Specify the print format").choices(formats).default("auto")).option("-q, --quiet", "Don't print anything to STDOUT (overrides all other options)").option("--entrypoints <entrypoints...>", "Specify an exhaustive list of entrypoints to check. The package root is `\".\" Specifying this option disables automatic entrypoint discovery, and overrides the `--include-entrypoints` and `--exclude-entrypoints` options.").option("--include-entrypoints <entrypoints...>", "Specify entrypoints to check in addition to automatically discovered ones.").option("--exclude-entrypoints <entrypoints...>", "Specify entrypoints to exclude from checking.").option("--entrypoints-legacy", "In packages without the `exports` field, every file is an entry point. Specifying this option only takes effect when no entrypoints are automatically detected, or explicitly provided with other options.").addOption(new Option("--ignore-rules <rules...>", "Specify rules to ignore").choices(Object.values(problemFlags)).default([])).addOption(new Option("--profile <profile>", "Specify analysis profile").choices(Object.keys(profiles)).default("strict")).option("--summary, --no-summary", "Whether to print summary information about the different errors").option("--emoji, --no-emoji", "Whether to use any emojis").option("--color, --no-color", "Whether to use any colors (the FORCE_COLOR env variable is also available)").option("--config-path <path>", "Path to config file (default: ./.attw.json)").action(async (fileOrDirectory = ".") => {
+	const opts = program.opts();
+	await readConfig(program, opts.configPath);
+	if (opts.profile) applyProfile(opts.profile, opts);
+	let out = process.stdout;
+	if (opts.quiet) out = new class extends Writable {
+		_write(_chunk, _encoding, callback) {
+			callback();
+		}
+	}();
+	if (!opts.color) process.env.FORCE_COLOR = "0";
+	let analysis;
+	let deleteTgz;
+	const dtIsPath = typeof opts.definitelyTyped === "string" && (opts.definitelyTyped.includes("/") || opts.definitelyTyped.includes("\\") || opts.definitelyTyped.endsWith(".tgz") || opts.definitelyTyped.endsWith(".tar.gz"));
+	if (opts.fromNpm) {
+		if (opts.pack) program.error("--pack and --from-npm cannot be used together");
+		try {
+			const result = parsePackageSpec(fileOrDirectory);
+			if (result.status === "error") program.error(result.error);
+			else {
+				let pkg;
+				if (dtIsPath) {
+					const dtPackage = core.createPackageFromTarballData(new Uint8Array(await readFile(opts.definitelyTyped)));
+					const pkgVersion = result.data.versionKind === "none" ? `${major(dtPackage.packageVersion)}.${minor(dtPackage.packageVersion)}` : result.data.version;
+					pkg = (await core.createPackageFromNpm(`${result.data.name}@${pkgVersion}`)).mergedWithTypes(dtPackage);
+				} else pkg = await core.createPackageFromNpm(`${result.data.name}@${result.data.version}`, { definitelyTyped: opts.definitelyTyped });
+				analysis = await core.checkPackage(pkg, {
+					entrypoints: opts.entrypoints,
+					includeEntrypoints: opts.includeEntrypoints,
+					excludeEntrypoints: opts.excludeEntrypoints,
+					entrypointsLegacy: opts.entrypointsLegacy
+				});
+			}
+		} catch (error) {
+			if (error instanceof Error && "code" in error) program.error(`error while fetching package:\n${error.message}`, { code: "" + error.code });
+			handleError(error, "checking package");
+		}
+	} else try {
+		let fileName = fileOrDirectory;
+		if (await stat(fileOrDirectory).then((stat) => !stat.isFile()).catch(() => false)) {
+			if (!await stat(path.join(fileOrDirectory, "package.json")).catch(() => false)) program.error(`Specified directory must contain a package.json. No package.json found in ${path.resolve(fileOrDirectory)}.`);
+			if (!opts.pack) {
+				if (!process.stdout.isTTY) program.error("Specifying a directory requires the --pack option to confirm that running `npm pack` is ok.");
+				const rl = readline.createInterface(process.stdin, process.stdout);
+				const answer = await new Promise((resolve) => {
+					rl.question(`Run \`npm pack\`? (Pass -P/--pack to skip) (Y/n) `, resolve);
+				});
+				rl.close();
+				if (answer.trim() && !answer.trim().toLowerCase().startsWith("y")) process.exit(1);
+			}
+			const manifest = JSON.parse(await readFile(path.join(fileOrDirectory, "package.json"), { encoding: "utf8" }));
+			fileName = deleteTgz = path.join(fileOrDirectory, `${manifest.name.replace("@", "").replace("/", "-")}-${manifest.version}.tgz`);
+			execSync("npm pack", {
+				cwd: fileOrDirectory,
+				encoding: "utf8",
+				stdio: "ignore"
+			});
+		}
+		const file = await readFile(fileName);
+		const data = new Uint8Array(file);
+		const pkg = dtIsPath ? core.createPackageFromTarballData(data).mergedWithTypes(core.createPackageFromTarballData(new Uint8Array(await readFile(opts.definitelyTyped)))) : core.createPackageFromTarballData(data);
+		analysis = await core.checkPackage(pkg, {
+			entrypoints: opts.entrypoints,
+			includeEntrypoints: opts.includeEntrypoints,
+			excludeEntrypoints: opts.excludeEntrypoints,
+			entrypointsLegacy: opts.entrypointsLegacy
+		});
+	} catch (error) {
+		handleError(error, "checking file");
+	}
+	if (opts.format === "json") {
+		const result = { analysis };
+		if (analysis.types) result.problems = groupProblemsByKind(analysis.problems);
+		await write(JSON.stringify(result, void 0, 2), out);
+		if (deleteTgz) await unlink(deleteTgz);
+		const exitCode = getExitCode(analysis, opts);
+		if (exitCode) process.exit(exitCode);
+		return;
+	}
+	await write("", out);
+	if (analysis.types) {
+		await write(await typed(analysis, opts), out);
+		process.exitCode = getExitCode(analysis, opts);
+	} else await write(untyped(analysis), out);
+	if (deleteTgz) await unlink(deleteTgz);
+});
+program.parse(process.argv);
+function handleError(error, title) {
+	if (error && typeof error === "object" && "message" in error) program.error(`error while ${title}:\n${error.message}`, {
+		exitCode: 3,
+		code: "code" in error && typeof error.code === "string" ? error.code : "UNKNOWN"
+	});
+	program.error(`unknown error while ${title}`, {
+		code: "UNKNOWN",
+		exitCode: 3
+	});
+}
+process.on("unhandledRejection", (error) => {
+	handleError(error, "checking package");
+});
+//#endregion
+export {};

package/dist/problemUtils-DrDcGcsf.mjs

@@ -0,0 +1,29 @@
+import "@systemfsoftware/arethetypeswrong-core";
+//#region src/problemUtils.ts
+const problemFlags = {
+	NoResolution: "no-resolution",
+	UntypedResolution: "untyped-resolution",
+	FalseCJS: "false-cjs",
+	FalseESM: "false-esm",
+	CJSResolvesToESM: "cjs-resolves-to-esm",
+	FallbackCondition: "fallback-condition",
+	CJSOnlyExportsDefault: "cjs-only-exports-default",
+	NamedExports: "named-exports",
+	FalseExportDefault: "false-export-default",
+	MissingExportEquals: "missing-export-equals",
+	UnexpectedModuleSyntax: "unexpected-module-syntax",
+	InternalResolutionError: "internal-resolution-error"
+};
+const resolutionKinds = {
+	node10: "node10",
+	"node16-cjs": "node16 (from CJS)",
+	"node16-esm": "node16 (from ESM)",
+	bundler: "bundler"
+};
+const moduleKinds = {
+	1: "(CJS)",
+	99: "(ESM)",
+	"": ""
+};
+//#endregion
+export { problemFlags as n, resolutionKinds as r, moduleKinds as t };

package/dist/render/index.d.ts

@@ -0,0 +1,2 @@
+import { i as typed, n as RenderOptions, r as untyped, t as Format } from "../index-DM-Vgonq.js";
+export { Format, RenderOptions, typed, untyped };

package/dist/render/index.mjs

@@ -0,0 +1,2 @@
+import { n as typed, t as untyped } from "../render-CTRBsIjQ.mjs";
+export { typed, untyped };

package/dist/render-CTRBsIjQ.mjs

@@ -0,0 +1,118 @@
+import { n as problemFlags, r as resolutionKinds, t as moduleKinds } from "./problemUtils-DrDcGcsf.mjs";
+import "@systemfsoftware/arethetypeswrong-core";
+import { allResolutionKinds, getResolutionOption, groupProblemsByKind } from "@systemfsoftware/arethetypeswrong-core/utils";
+import chalk from "chalk";
+import { filterProblems, problemAffectsEntrypoint, problemAffectsResolutionKind, problemKindInfo } from "@systemfsoftware/arethetypeswrong-core/problems";
+import Table from "cli-table3";
+import { marked } from "marked";
+import TerminalRenderer from "marked-terminal";
+//#region src/render/asciiTable.ts
+function asciiTable(table) {
+	return table.options.head.slice(1).map((entryPoint, i) => {
+		const keyValuePairs = table.reduce((acc, cur) => {
+			return acc + `${cur[0]?.toString()}: ${cur[i + 1]?.toString()}\n`;
+		}, "");
+		return `${chalk.bold.blue(entryPoint)}
+
+${keyValuePairs}
+***********************************`;
+	}).join("\n\n");
+}
+//#endregion
+//#region src/render/typed.ts
+async function typed(analysis, { emoji = true, summary = true, format = "auto", ignoreRules = [], ignoreResolutions = [] }) {
+	let output = "";
+	const problems = analysis.problems.filter((problem) => !ignoreRules || !ignoreRules.includes(problemFlags[problem.kind]));
+	const requiredResolutions = allResolutionKinds.filter((kind) => !ignoreResolutions.includes(kind));
+	const ignoredResolutions = allResolutionKinds.filter((kind) => ignoreResolutions.includes(kind));
+	const resolutions = requiredResolutions.concat(ignoredResolutions);
+	const entrypoints = Object.keys(analysis.entrypoints);
+	marked.setOptions({ renderer: new TerminalRenderer() });
+	out(`${analysis.packageName} v${analysis.packageVersion}`);
+	if (analysis.types.kind === "@types") out(`${analysis.types.packageName} v${analysis.types.packageVersion}`);
+	out();
+	if (Object.keys(analysis.buildTools).length) {
+		out("Build tools:");
+		out(Object.entries(analysis.buildTools).map(([tool, version]) => {
+			return `- ${tool}@${version}`;
+		}).join("\n"));
+		out();
+	}
+	if (ignoreRules && ignoreRules.length) out(chalk.gray(` (ignoring rules: ${ignoreRules.map((rule) => `'${rule}'`).join(", ")})\n`));
+	if (ignoreResolutions && ignoreResolutions.length) out(chalk.gray(` (ignoring resolutions: ${ignoreResolutions.map((resolution) => `'${resolution}'`).join(", ")})\n`));
+	if (summary) {
+		const defaultSummary = marked(!emoji ? " No problems found" : " No problems found 🌟");
+		const grouped = groupProblemsByKind(problems);
+		out(Object.entries(grouped).map(([kind, kindProblems]) => {
+			const info = problemKindInfo[kind];
+			const affectsRequiredResolution = kindProblems.some((p) => requiredResolutions.some((r) => problemAffectsResolutionKind(p, r, analysis)));
+			const description = marked(`${info.description}${info.details ? ` Use \`-f json\` to see ${info.details}.` : ""} ${info.docsUrl}`);
+			return `${affectsRequiredResolution ? "" : "(ignored per resolution) "}${emoji ? `${info.emoji} ` : ""}${description}`;
+		}).join("") || defaultSummary);
+	}
+	const entrypointNames = entrypoints.map((s) => `"${s === "." ? analysis.packageName : `${analysis.packageName}/${s.substring(2)}`}"`);
+	const entrypointHeaders = entrypoints.map((s, i) => {
+		const color = problems.some((p) => problemAffectsEntrypoint(p, s, analysis)) ? "redBright" : "greenBright";
+		return chalk.bold[color](entrypointNames[i]);
+	});
+	const getCellContents = memo((subpath, resolutionKind) => {
+		const ignoredPrefix = ignoreResolutions.includes(resolutionKind) ? "(ignored) " : "";
+		const problemsForCell = groupProblemsByKind(filterProblems(problems, analysis, {
+			entrypoint: subpath,
+			resolutionKind
+		}));
+		const entrypoint = analysis.entrypoints[subpath].resolutions[resolutionKind];
+		const resolution = entrypoint.resolution;
+		const kinds = Object.keys(problemsForCell);
+		if (kinds.length) return kinds.map((kind) => ignoredPrefix + (emoji ? `${problemKindInfo[kind].emoji} ` : "") + problemKindInfo[kind].shortDescription).join("\n");
+		const jsonResult = !emoji ? "OK (JSON)" : "🟢 (JSON)";
+		const moduleResult = entrypoint.isWildcard ? "(wildcard)" : (!emoji ? "OK " : "🟢 ") + moduleKinds[analysis.programInfo[getResolutionOption(resolutionKind)].moduleKinds?.[resolution?.fileName ?? ""]?.detectedKind || ""];
+		return ignoredPrefix + (resolution?.isJson ? jsonResult : moduleResult);
+	});
+	const flippedTable = format === "auto" || format === "table-flipped" ? new Table({ head: ["", ...resolutions.map((kind) => chalk.reset(resolutionKinds[kind] + (ignoreResolutions.includes(kind) ? " (ignored)" : "")))] }) : void 0;
+	if (flippedTable) entrypoints.forEach((subpath, i) => {
+		flippedTable.push([entrypointHeaders[i], ...resolutions.map((resolutionKind) => getCellContents(subpath, resolutionKind))]);
+	});
+	const table = format === "auto" || !flippedTable ? new Table({ head: ["", ...entrypointHeaders] }) : void 0;
+	if (table) resolutions.forEach((kind) => {
+		table.push([resolutionKinds[kind], ...entrypoints.map((entrypoint) => getCellContents(entrypoint, kind))]);
+	});
+	switch (format) {
+		case "table":
+			out(table.toString());
+			break;
+		case "table-flipped":
+			out(flippedTable.toString());
+			break;
+		case "ascii":
+			out(asciiTable(table));
+			break;
+		case "auto":
+			const terminalWidth = process.stdout.columns || 133;
+			if (table.width <= terminalWidth) out(table.toString());
+			else if (flippedTable.width <= terminalWidth) out(flippedTable.toString());
+			else out(asciiTable(table));
+			break;
+	}
+	return output.trimEnd();
+	function out(s = "") {
+		output += s + "\n";
+	}
+}
+function memo(fn) {
+	const cache = /* @__PURE__ */ new Map();
+	return (...args) => {
+		const key = "" + args;
+		if (cache.has(key)) return cache.get(key);
+		const result = fn(...args);
+		cache.set(key, result);
+		return result;
+	};
+}
+//#endregion
+//#region src/render/untyped.ts
+function untyped(analysis) {
+	return "This package does not contain types.\nDetails: " + JSON.stringify(analysis, null, 2);
+}
+//#endregion
+export { typed as n, untyped as t };

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@systemfsoftware/arethetypeswrong-cli",
+  "version": "0.18.5",
+  "description": "A CLI tool for arethetypeswrong.github.io — forked under systemfsoftware",
+  "author": "Andrew Branch & ej-shafran (forked by systemfsoftware)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/systemfsoftware/systemfsoftware.git",
+    "directory": "packages/arethetypeswrong/cli"
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "bin": {
+    "attw": "./dist/index.mjs"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    "./internal/getExitCode": "./dist/getExitCode.mjs",
+    "./internal/render": "./dist/render/index.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.3",
+    "commander": "^10.0.1",
+    "marked": "^9.1.2",
+    "marked-terminal": "^7.1.0",
+    "semver": "^7.5.4",
+    "@systemfsoftware/arethetypeswrong-core": "0.18.5"
+  },
+  "devDependencies": {
+    "@types/marked": "^5.0.0",
+    "@types/marked-terminal": "^3.1.3",
+    "@types/node": "^24",
+    "@types/semver": "^7.5.3",
+    "rimraf": "^6.1.3",
+    "ts-expose-internals": "^5.6.0",
+    "tsdown": "^0.22.9",
+    "vite-tsconfig-paths": "^6.1.1",
+    "vitest": "^4",
+    "@systemfsoftware/tsconfig": "^1.0.0",
+    "@systemfsoftware/vitest-config": "^0.1.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "rimraf dist",
+    "typecheck": "tsc --noEmit --incremental",
+    "format": "dprint fmt",
+    "test": "vitest run",
+    "test:run": "vitest run --coverage"
+  }
+}