@systemfsoftware/arethetypeswrong-cli 1.1.1 → 3.0.0

package/dist/AttwHandler-CidnXJbU.mjs

@@ -0,0 +1,624 @@
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Command from "effect/unstable/cli/Command";
+import * as Config from "effect/Config";
+import * as Effect$1 from "effect/Effect";
+import * as Option from "effect/Option";
+import * as S from "effect/Schema";
+import * as Argument from "effect/unstable/cli/Argument";
+import * as Flag from "effect/unstable/cli/Flag";
+import { CheckPackage, CheckPackageLive, CheckResultSchema, PackageStoreAdapterStub } from "@systemfsoftware/arethetypeswrong-core";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import * as PlatformFs from "effect/FileSystem";
+import * as PlatformPathMod from "effect/Path";
+import * as ChildProcess from "effect/unstable/process/ChildProcess";
+import * as PlatformTerminal from "effect/Terminal";
+//#region src/Filesystem.schema.ts
+var FileNotFoundError = class extends Schema.TaggedError()("FileNotFoundError", { filePath: Schema.String }) {};
+Schema.TaggedError()("DirectoryError", { directoryPath: Schema.String });
+//#endregion
+//#region src/FilesystemAdapter.ts
+var CliFilesystem = class extends Context.Service()("@systemfsoftware/arethetypeswrong-cli/filesystem.adapter/Filesystem") {};
+const fromPlatform = (fs, path) => ({
+	fileExists: (filePath) => fs.exists(filePath).pipe(Effect.orElseSucceed(() => false)),
+	isDirectory: (filePath) => fs.stat(filePath).pipe(Effect.map((s) => s.type === "directory"), Effect.orElseSucceed(() => false)),
+	readUtf8: (filePath) => fs.readFileString(filePath).pipe(Effect.mapError(() => new FileNotFoundError({ filePath }))),
+	readBytes: (filePath) => fs.readFile(filePath).pipe(Effect.mapError(() => new FileNotFoundError({ filePath }))),
+	deleteFile: (filePath) => fs.remove(filePath).pipe(Effect.orElseSucceed(() => void 0)),
+	resolve: (...segments) => path.resolve(...segments),
+	join: (...segments) => path.join(...segments)
+});
+const FilesystemLive = Layer.effect(CliFilesystem, Effect.gen(function* () {
+	const fs = yield* PlatformFs.FileSystem;
+	const path = yield* PlatformPathMod.Path;
+	return fromPlatform(fs, path);
+}));
+//#endregion
+//#region src/GetExitCode.schema.ts
+/**
+* The exit-code decision's input. `result` is the core's own `CheckResult`, not
+* an opaque payload: the decision reads `types` and `problems` off it, so the
+* shape it relies on is stated here and a mismatch fails at the boundary.
+*/
+var ComputeExitCodeCommand = class extends S.TaggedClass()("ComputeExitCodeCommand", {
+	result: CheckResultSchema,
+	ignoreRules: S.Array(S.String),
+	ignoreResolutions: S.Array(S.String)
+}) {};
+var ComputeExitCodeDecision = class extends S.TaggedClass()("ComputeExitCodeDecision", { exitCode: S.Number }) {};
+//#endregion
+//#region src/ProblemUtils.ts
+const problemFlagForKind = (kind) => {
+	switch (kind) {
+		case "NoResolution": return "no-resolution";
+		case "UntypedResolution": return "untyped-resolution";
+		case "FalseCJS": return "false-cjs";
+		case "FalseESM": return "false-esm";
+		case "CJSResolvesToESM": return "cjs-resolves-to-esm";
+		case "FallbackCondition": return "fallback-condition";
+		case "CJSOnlyExportsDefault": return "cjs-only-exports-default";
+		case "NamedExports": return "named-exports";
+		case "FalseExportDefault": return "false-export-default";
+		case "MissingExportEquals": return "missing-export-equals";
+		case "UnexpectedModuleSyntax": return "unexpected-module-syntax";
+		case "InternalResolutionError": return "internal-resolution-error";
+	}
+};
+const CliFormat = [
+	"auto",
+	"table",
+	"table-flipped",
+	"ascii",
+	"json"
+];
+const CliProfile = [
+	"strict",
+	"node16",
+	"esm-only"
+];
+//#endregion
+//#region src/GetExitCode.ts
+const isVisibleProblem = (problem, ignoredRules, ignoredResolutions) => {
+	const ruleIgnored = ignoredRules.has(problemFlagForKind(problem.kind));
+	const resolutionIgnored = "resolutionKind" in problem && ignoredResolutions.has(problem.resolutionKind);
+	return !ruleIgnored && !resolutionIgnored;
+};
+const computeExitCode = (command) => {
+	const result = command.result;
+	if (result.types === false) return new ComputeExitCodeDecision({ exitCode: 0 });
+	const ignoredRules = new Set(command.ignoreRules);
+	const ignoredResolutions = new Set(command.ignoreResolutions);
+	return new ComputeExitCodeDecision({ exitCode: result.problems.some((p) => isVisibleProblem(p, ignoredRules, ignoredResolutions)) ? 1 : 0 });
+};
+//#endregion
+//#region src/PackRunner.schema.ts
+/** A failed `npm pack`, carrying the spawn failure it came from. */
+var PackRunnerFailed = class extends Schema.TaggedError()("PackRunnerFailed", {
+	message: Schema.String,
+	cause: Schema.optional(Schema.Unknown)
+}) {};
+//#endregion
+//#region src/PackRunnerAdapter.ts
+var PackRunner = class extends Context.Service()("@systemfsoftware/arethetypeswrong-cli/pack-runner.adapter/PackRunner") {};
+const PackRunnerLive = Layer.succeed(PackRunner, { pack: (cwd) => Effect.gen(function* () {
+	const spawner = yield* ChildProcessSpawner;
+	const cmd = ChildProcess.make("npm", ["pack", "--ignore-scripts"]).pipe(ChildProcess.setCwd(cwd));
+	const tarballName = (yield* spawner.string(cmd).pipe(Effect.mapError((e) => new PackRunnerFailed({
+		message: `npm pack failed in ${cwd}`,
+		cause: e
+	})))).trim().split("\n").pop() ?? "";
+	if (!tarballName) return yield* Effect.fail(new PackRunnerFailed({ message: "npm pack produced no tarball name" }));
+	return { tarballPath: tarballName };
+}) });
+//#endregion
+//#region src/Profiles.schema.ts
+/** The resolution kinds a profile may silence. */
+const IgnoredResolution = S.Literals([
+	"node10",
+	"node16-cjs",
+	"node16-esm",
+	"bundler"
+]);
+/** The profiles the CLI offers. */
+const ProfileName = S.Literals([
+	"strict",
+	"node16",
+	"esm-only"
+]);
+/**
+* The request the profile decision receives. It carries the resolutions the
+* caller already silenced - the only field the decision reads - so the decision
+* never widens an opaque payload back to a shape it guessed.
+*/
+var ApplyProfileCommand = class extends S.TaggedClass()("ApplyProfileCommand", {
+	profileName: ProfileName,
+	ignoreResolutions: S.optional(S.Array(IgnoredResolution))
+}) {};
+var ApplyProfileDecision = class extends S.TaggedClass()("ApplyProfileDecision", { ignoreResolutions: S.Array(IgnoredResolution) }) {};
+//#endregion
+//#region src/Profiles.ts
+const profileIgnoreResolutions = {
+	strict: [],
+	node16: ["node10"],
+	"esm-only": ["node10", "node16-cjs"]
+};
+/**
+* Merge the caller's silenced resolutions with the profile's own. Order is the
+* caller's first, then the profile's, and duplicates are kept: the list is a
+* record of what was asked for, not a set.
+*/
+const applyProfile = (command) => new ApplyProfileDecision({ ignoreResolutions: [...command.ignoreResolutions ?? [], ...profileIgnoreResolutions[command.profileName]] });
+//#endregion
+//#region src/Registry.schema.ts
+/**
+* The packument fields this CLI reads. Declared so the response is decoded
+* rather than asserted: a registry that changes shape fails here, naming the
+* field, instead of surfacing as a member access on `any` further downstream.
+*/
+const RegistryDocument = S.Struct({
+	name: S.String,
+	version: S.String,
+	dist: S.Struct({ tarball: S.String })
+});
+/** A registry request that never produced a tarball, carrying its cause. */
+var RegistryFetchError = class extends S.TaggedError()("RegistryFetchError", {
+	message: S.String,
+	cause: S.optional(S.Unknown)
+}) {};
+//#endregion
+//#region src/RenderTable.ts
+const cellWidth = (cell) => visibleWidth(cell);
+const visibleWidth = (s) => {
+	let w = 0;
+	for (const ch of s) {
+		if (ch === "\x1B") continue;
+		w += 1;
+	}
+	return w;
+};
+const computeColumnWidths = (header, rows) => {
+	const widths = header.map((h) => cellWidth(h));
+	for (const row of rows) for (let i = 0; i < row.length; i++) {
+		const cell = row[i] ?? "";
+		const w = cellWidth(cell);
+		if (w > (widths[i] ?? 0)) widths[i] = w;
+	}
+	return widths;
+};
+const renderCell = (cell, width) => cell.padEnd(width);
+const renderTable = (header, rows, gap = 2) => {
+	if (header.length === 0) return "";
+	const widths = computeColumnWidths(header, rows);
+	const gapText = " ".repeat(gap);
+	const renderRow = (cells) => {
+		const parts = [];
+		for (let i = 0; i < cells.length; i++) {
+			if (i > 0) parts.push(gapText);
+			parts.push(renderCell(cells[i] ?? "", widths[i] ?? 0));
+		}
+		return parts.join("");
+	};
+	return [renderRow(header), ...rows.map(renderRow)].join("\n");
+};
+const renderFlippedTable = (header, rows, gap = 2) => {
+	if (header.length === 0) return "";
+	if (rows.length === 0) return header.join("\n");
+	const numCols = rows[0]?.length ?? 0;
+	if (numCols === 0) return header.join("\n");
+	const transposed = [];
+	for (let col = 0; col < numCols; col++) {
+		const newRow = [];
+		for (const row of rows) newRow.push(row[col] ?? "");
+		newRow.unshift(header[col] ?? "");
+		transposed.push(newRow);
+	}
+	return renderTable(transposed[0] ?? [], transposed.slice(1), gap);
+};
+//#endregion
+//#region src/RenderAnsi.ts
+const colorCode = (c) => {
+	switch (c) {
+		case "red": return "31";
+		case "green": return "32";
+		case "yellow": return "33";
+		case "blue": return "34";
+		case "magenta": return "35";
+		case "cyan": return "36";
+		case "gray": return "90";
+		case "white": return "37";
+	}
+};
+const annotate = (text, anno) => {
+	if (anno.color === void 0 && !anno.bold) return text;
+	const parts = [];
+	if (anno.bold) parts.push("1");
+	if (anno.color !== void 0) parts.push(colorCode(anno.color));
+	return `\u001b[${parts.join(";")}m${text}\u001b[0m`;
+};
+new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+const colorizeCell = (cell, color, annotations) => {
+	if (!color) return cell;
+	let out = cell;
+	for (const [marker, anno] of Object.entries(annotations)) if (out.includes(marker)) out = out.split(marker).join(annotate(marker, anno));
+	return out;
+};
+//#endregion
+//#region src/RenderTyped.ts
+const resolutionKindOrder = [
+	"node10",
+	"node16-cjs",
+	"node16-esm",
+	"bundler"
+];
+const symbolForProblem = (p, useEmoji) => {
+	return (useEmoji ? {
+		NoResolution: "✘",
+		UntypedResolution: "◌",
+		FalseESM: "✘",
+		FalseCJS: "✘",
+		CJSResolvesToESM: "✘",
+		NamedExports: "✘",
+		FallbackCondition: "⚠",
+		FalseExportDefault: "✘",
+		MissingExportEquals: "✘",
+		UnexpectedModuleSyntax: "✘",
+		InternalResolutionError: "✘",
+		CJSOnlyExportsDefault: "✘"
+	} : {
+		NoResolution: "X",
+		UntypedResolution: "-",
+		FalseESM: "X",
+		FalseCJS: "X",
+		CJSResolvesToESM: "X",
+		NamedExports: "X",
+		FallbackCondition: "!",
+		FalseExportDefault: "X",
+		MissingExportEquals: "X",
+		UnexpectedModuleSyntax: "X",
+		InternalResolutionError: "X",
+		CJSOnlyExportsDefault: "X"
+	})[p.kind] ?? "?";
+};
+const cellKey = (entrypoint, resolutionKind) => `${entrypoint}\u0000${resolutionKind}`;
+/**
+* Bucket every problem into the (entrypoint x resolutionKind) cells it belongs to in one pass.
+* A problem carrying neither field is global and lands in every cell, which is why the walk is
+* over the problem's own axes rather than over the cells.
+*/
+const partitionProblemsByCell = (entrypoints, problems) => {
+	const cells = /* @__PURE__ */ new Map();
+	for (const entrypoint of entrypoints) for (const resolutionKind of resolutionKindOrder) cells.set(cellKey(entrypoint, resolutionKind), []);
+	for (const problem of problems) {
+		const axisEntrypoints = "entrypoint" in problem ? [problem.entrypoint] : entrypoints;
+		const axisKinds = "resolutionKind" in problem ? [problem.resolutionKind] : resolutionKindOrder;
+		for (const entrypoint of axisEntrypoints) for (const resolutionKind of axisKinds) cells.get(cellKey(entrypoint, resolutionKind))?.push(problem);
+	}
+	return cells;
+};
+const problemsForCell = (cells, entrypoint, resolutionKind) => cells.get(cellKey(entrypoint, resolutionKind)) ?? [];
+const renderTypedAnalysis = (entrypoints, problems, opts, annotations = {}) => {
+	if (entrypoints.length === 0) return "No entrypoints found.";
+	const header = ["Entrypoint", ...resolutionKindOrder];
+	const cells = partitionProblemsByCell(entrypoints, problems);
+	const rows = entrypoints.map((entrypoint) => {
+		const row = [entrypoint];
+		for (const rk of resolutionKindOrder) {
+			const relevant = problemsForCell(cells, entrypoint, rk);
+			if (relevant.length === 0) {
+				row.push(opts.useEmoji ? "✔" : "OK");
+				continue;
+			}
+			const symbols = relevant.map((p) => symbolForProblem(p, opts.useEmoji)).join("");
+			row.push(symbols);
+		}
+		return row.map((c) => colorizeCell(c, opts.color, annotations));
+	});
+	return opts.flipped ? renderFlippedTable(header, rows) : renderTable(header, rows);
+};
+//#endregion
+//#region src/RenderAscii.ts
+const renderAsciiAnalysis = (entrypoints, problems, opts) => {
+	if (entrypoints.length === 0) return "No entrypoints found.";
+	const header = ["Entrypoint", ...resolutionKindOrder];
+	const cells = partitionProblemsByCell(entrypoints, problems);
+	const rows = entrypoints.map((entrypoint) => {
+		const row = [entrypoint];
+		for (const rk of resolutionKindOrder) {
+			const relevant = problemsForCell(cells, entrypoint, rk);
+			if (relevant.length === 0) {
+				row.push("OK");
+				continue;
+			}
+			row.push(relevant.map((p) => symbolForProblem(p, opts.useEmoji)).join(""));
+		}
+		return row;
+	});
+	return renderTable(header, rows);
+};
+//#endregion
+//#region src/RenderJson.ts
+const renderJson = (value, options = { pretty: true }) => {
+	if (options.pretty) return JSON.stringify(value, null, 2);
+	return JSON.stringify(value);
+};
+//#endregion
+//#region src/RenderUntyped.ts
+const renderUntyped = (ctx) => {
+	const lines = [];
+	lines.push(`Package ${ctx.packageName}@${ctx.packageVersion} has no types.`);
+	if (ctx.typesPackageName !== null) lines.push(`Install @types/${ctx.typesPackageName} for TypeScript support.`);
+	else lines.push("No @types package found.");
+	return lines.join("\n");
+};
+//#endregion
+//#region src/Render.ts
+const isUntyped = (r) => "types" in r && r.types === false;
+const visibleProblems = (analysis, options) => analysis.problems.filter((p) => !options.ignoreRules.includes(problemFlagForKind(p.kind)));
+const renderAnalysis = (result, options, annotations = {}) => {
+	if (options.quiet) return "";
+	const format = resolveFormat(options);
+	if (format === "json") {
+		if (isUntyped(result)) return renderJson({ analysis: result }, { pretty: true });
+		const visible = visibleProblems(result, options);
+		return renderJson({
+			analysis: result,
+			problems: visible,
+			...options.summary ? { summary: renderSummary(visible) } : {}
+		}, { pretty: true });
+	}
+	if (isUntyped(result)) return renderUntyped({
+		packageName: result.packageName,
+		packageVersion: result.packageVersion,
+		typesPackageName: null
+	});
+	const visible = visibleProblems(result, options);
+	if (options.summary) return renderSummary(visible) + "\n" + renderAnalysis(result, {
+		...options,
+		summary: false
+	}, annotations);
+	const entrypointNames = Object.keys(result.entrypoints);
+	switch (format) {
+		case "ascii": return renderAsciiAnalysis(entrypointNames, visible, { useEmoji: options.useEmoji });
+		case "table-flipped": return renderTypedAnalysis(entrypointNames, visible, {
+			flipped: true,
+			useEmoji: options.useEmoji,
+			color: options.color
+		}, annotations);
+		case "table": return renderTypedAnalysis(entrypointNames, visible, {
+			flipped: false,
+			useEmoji: options.useEmoji,
+			color: options.color
+		}, annotations);
+	}
+};
+const resolveFormat = (options) => {
+	if (options.format === "json") return "json";
+	if (options.format === "ascii") return "ascii";
+	if (options.format === "table") return "table";
+	if (options.format === "table-flipped") return "table-flipped";
+	if (options.isTTY && options.terminalWidth >= 100) return "table-flipped";
+	return "ascii";
+};
+const renderSummary = (problems) => {
+	if (problems.length === 0) return "No problems found.";
+	const grouped = {};
+	for (const p of problems) {
+		grouped[p.kind] = grouped[p.kind] ?? [];
+		grouped[p.kind].push(p);
+	}
+	return Object.entries(grouped).map(([kind, list]) => `${kind}: ${list.length}`).join("\n");
+};
+//#endregion
+//#region src/StdinAdapter.ts
+var Stdin = class extends Context.Service()("@systemfsoftware/arethetypeswrong-cli/stdin.adapter/Stdin") {};
+const fromTerminal = (terminal) => ({ confirm: (question) => Effect.gen(function* () {
+	yield* terminal.display(question).pipe(Effect.orElseSucceed(() => void 0));
+	const answer = (yield* terminal.readLine.pipe(Effect.orElseSucceed(() => ""))).trim();
+	return answer === "" || answer.toLowerCase().startsWith("y");
+}) });
+const StdinLive = Layer.effect(Stdin, Effect.gen(function* () {
+	const terminal = yield* PlatformTerminal.Terminal;
+	return fromTerminal(terminal);
+}));
+//#endregion
+//#region src/TerminalAdapter.ts
+var Terminal = class extends Context.Service()("@systemfsoftware/arethetypeswrong-cli/terminal.adapter/Terminal") {};
+const TerminalLive = Layer.effect(Terminal, Effect.gen(function* () {
+	const terminal = yield* PlatformTerminal.Terminal;
+	return {
+		isTty: process.stdout.isTTY === true,
+		env: process.env,
+		stdout: { write: (text) => terminal.display(text).pipe(Effect.as(void 0), Effect.orElseSucceed(() => void 0)) },
+		stderr: { write: (text) => Effect.sync(() => {
+			process.stderr.write(text);
+		}) },
+		exit: (code) => Effect.sync(() => process.exit(code))
+	};
+}));
+//#endregion
+//#region src/AttwExecutor.ts
+const prepareAnalysis = (request, result) => {
+	const profileDecision = request.profile !== void 0 ? applyProfile(new ApplyProfileCommand(request.ignoreResolutions === void 0 ? { profileName: request.profile } : {
+		profileName: request.profile,
+		ignoreResolutions: request.ignoreResolutions
+	})) : void 0;
+	const profileApplied = profileDecision !== void 0 ? {
+		...request,
+		ignoreResolutions: profileDecision.ignoreResolutions
+	} : request;
+	return {
+		result,
+		ignoreRules: profileApplied.ignoreRules ?? [],
+		ignoreResolutions: profileApplied.ignoreResolutions ?? []
+	};
+};
+const acquireTarball = (request) => Effect.gen(function* () {
+	const fs = yield* CliFilesystem;
+	const target = request.fileOrDirectory;
+	if (request.pack) {
+		const packed = yield* (yield* PackRunner).pack(target).pipe(Effect.orDie);
+		const tarballPath = fs.join(target, packed.tarballPath);
+		const bytes = yield* fs.readBytes(tarballPath).pipe(Effect.orDie);
+		yield* fs.deleteFile(tarballPath);
+		return {
+			bytes,
+			ref: {
+				packageName: target,
+				packageVersion: "local",
+				tarballUrl: `file://${tarballPath}`
+			}
+		};
+	}
+	if (target.endsWith(".tgz") || target.endsWith(".tar.gz")) return {
+		bytes: yield* fs.readBytes(target).pipe(Effect.orDie),
+		ref: {
+			packageName: target,
+			packageVersion: "local",
+			tarballUrl: `file://${target}`
+		}
+	};
+	const npmTarget = request.fromNpm ? target : /^[a-z@]/.test(target) && !target.includes("/") ? target : `file:${target}`;
+	if (!npmTarget.startsWith("file:")) {
+		const [name, version = "latest"] = npmTarget.split("@").filter(Boolean);
+		const registryJson = yield* Effect.tryPromise({
+			try: async () => {
+				const res = await fetch(`${request.registry.replace(/\/$/, "")}/${encodeURIComponent(name ?? npmTarget)}/${version}`);
+				if (res.status === 404) throw new RegistryFetchError({ message: `Package not found: ${npmTarget}` });
+				if (!res.ok) throw new RegistryFetchError({ message: `Registry returned ${res.status} for ${npmTarget}` });
+				return await res.json();
+			},
+			catch: (e) => e instanceof RegistryFetchError ? e : new RegistryFetchError({
+				message: `Registry request failed for ${npmTarget}`,
+				cause: e
+			})
+		}).pipe(Effect.orDie);
+		const registry = yield* Schema.decodeUnknownEffect(RegistryDocument)(registryJson).pipe(Effect.orDie);
+		return {
+			bytes: yield* Effect.tryPromise({
+				try: async () => {
+					const res = await fetch(registry.dist.tarball);
+					if (!res.ok) throw new RegistryFetchError({ message: `Tarball fetch returned ${res.status}` });
+					return new Uint8Array(await res.arrayBuffer());
+				},
+				catch: (e) => e instanceof RegistryFetchError ? e : new RegistryFetchError({
+					message: `Tarball fetch failed for ${npmTarget}`,
+					cause: e
+				})
+			}).pipe(Effect.orDie),
+			ref: {
+				packageName: registry.name,
+				packageVersion: registry.version,
+				tarballUrl: registry.dist.tarball
+			}
+		};
+	}
+	return {
+		bytes: yield* fs.readBytes(target).pipe(Effect.orDie),
+		ref: {
+			packageName: target,
+			packageVersion: "local",
+			tarballUrl: `file://${target}`
+		}
+	};
+});
+const runAttw = (request) => Effect.gen(function* () {
+	const terminal = yield* Terminal;
+	const { bytes, ref } = yield* acquireTarball(request);
+	const storeLayer = PackageStoreAdapterStub(ref, bytes);
+	const checkPackageLayer = CheckPackageLive.pipe(Layer.provide(storeLayer));
+	const result = yield* Effect.gen(function* () {
+		return yield* (yield* CheckPackage).execute(request.fileOrDirectory, {
+			entrypoints: request.entrypoints?.length ? [...request.entrypoints] : void 0,
+			includeEntrypoints: request.includeEntrypoints?.length ? [...request.includeEntrypoints] : void 0,
+			excludeEntrypoints: request.excludeEntrypoints?.length ? [...request.excludeEntrypoints] : void 0,
+			entrypointsLegacy: request.entrypointsLegacy
+		});
+	}).pipe(Effect.provide(Layer.mergeAll(checkPackageLayer, storeLayer)), Effect.catch(() => Effect.succeed({
+		packageName: request.fileOrDirectory,
+		packageVersion: "error",
+		types: false
+	})));
+	const prepared = prepareAnalysis(request, result);
+	const exitDecision = computeExitCode(new ComputeExitCodeCommand({
+		result: prepared.result,
+		ignoreRules: [...prepared.ignoreRules],
+		ignoreResolutions: [...prepared.ignoreResolutions]
+	}));
+	if (!request.quiet) {
+		const output = renderAnalysis(prepared.result, {
+			format: request.format ?? "auto",
+			color: request.color ?? true,
+			summary: request.summary ?? true,
+			ignoreRules: prepared.ignoreRules,
+			useEmoji: request.emoji ?? true,
+			quiet: request.quiet ?? false,
+			terminalWidth: 120,
+			isTTY: true
+		});
+		yield* terminal.stdout.write(output);
+	}
+	return exitDecision.exitCode;
+});
+//#endregion
+//#region src/AttwHandler.ts
+const formatOptions = () => Flag.choice("format", CliFormat).pipe(Flag.withAlias("f"), Flag.withDefault("auto"));
+const profileOptions = () => Flag.choice("profile", CliProfile).pipe(Flag.withDefault("strict"));
+/**
+* The only flag a `.attw.json` is ever written for. Without the fallback config
+* the file's `ignoreRules` reaches nothing: the config layer is present, but a
+* flag that never consults a `Config` cannot see it, so a project's ignore list
+* was read, parsed, and then discarded — the build went red on exactly the
+* problems the file existed to waive.
+*/
+const ignoreRulesOptions = () => Flag.optional(Flag.atLeast(1)(Flag.string("ignore-rules").pipe(Flag.withAlias("ignore-rule"))).pipe(Flag.withFallbackConfig(Config.schema(Config.Array(S.String), "ignoreRules"))));
+/**
+* `--definitely-typed` is tri-state: absent | `true` | a version-or-path string.
+* Commander parsed this with `new Option('--definitely-typed [version]')` and
+* `default(true)`. We model the decoded value as a tagged union and translate.
+*/
+const definitelyTypedOptions = () => Flag.optional(Flag.string("definitely-typed")).pipe(Flag.withDescription("Specify the version range of @types to use. Pass `false` to disable."));
+const registryOptions = () => Flag.string("registry").pipe(Flag.withDescription("URL of the npm registry to read packages from with --from-npm (default: https://registry.npmjs.org)"), Flag.withFallbackConfig(Config.string("registry").pipe(Config.withDefault("https://registry.npmjs.org"))));
+const unwrap = (opt) => Option.isSome(opt) ? opt.value : void 0;
+const attwCommand = Command.make("attw", {
+	fileOrDirectory: Argument.optional(Argument.string("file-directory-or-package-spec")),
+	pack: Flag.boolean("pack").pipe(Flag.withAlias("P"), Flag.withDescription("Run `npm pack` in the specified directory and delete the resulting .tgz file afterwards")),
+	fromNpm: Flag.boolean("from-npm").pipe(Flag.withAlias("p"), Flag.withDescription("Read from the npm registry instead of a local file")),
+	definitelyTyped: definitelyTypedOptions(),
+	format: formatOptions(),
+	quiet: Flag.boolean("quiet").pipe(Flag.withAlias("q"), Flag.withDescription("Don't print anything to STDOUT (overrides all other options)")),
+	entrypoints: Flag.optional(Flag.atLeast(1)(Flag.string("entrypoints"))),
+	includeEntrypoints: Flag.optional(Flag.atLeast(1)(Flag.string("include-entrypoints"))),
+	excludeEntrypoints: Flag.optional(Flag.atLeast(1)(Flag.string("exclude-entrypoints"))),
+	entrypointsLegacy: Flag.boolean("entrypoints-legacy"),
+	ignoreRules: ignoreRulesOptions(),
+	profile: profileOptions(),
+	summary: Flag.boolean("summary").pipe(Flag.withDefault(true)),
+	emoji: Flag.boolean("emoji").pipe(Flag.withDefault(true)),
+	color: Flag.boolean("color").pipe(Flag.withDefault(true)),
+	registry: registryOptions()
+}, (config) => Effect$1.gen(function* () {
+	const input = {
+		fileOrDirectory: unwrap(config.fileOrDirectory) ?? ".",
+		pack: config.pack,
+		fromNpm: config.fromNpm,
+		definitelyTyped: unwrap(config.definitelyTyped),
+		format: config.format,
+		quiet: config.quiet,
+		entrypoints: unwrap(config.entrypoints),
+		includeEntrypoints: unwrap(config.includeEntrypoints),
+		excludeEntrypoints: unwrap(config.excludeEntrypoints),
+		entrypointsLegacy: config.entrypointsLegacy,
+		ignoreRules: unwrap(config.ignoreRules),
+		profile: config.profile,
+		summary: config.summary,
+		emoji: config.emoji,
+		color: config.color,
+		registry: config.registry
+	};
+	const exitCode = yield* runAttw(input);
+	yield* Effect$1.sync(() => {
+		process.exitCode = exitCode;
+	});
+	return exitCode;
+}));
+//#endregion
+export { FilesystemLive as a, PackRunnerLive as i, TerminalLive as n, StdinLive as r, attwCommand as t };