feat(attw): add profile-based filtering and configurable error levels (#313)

Co-authored-by: Kevin Deng <sxzz@sxzz.moe>

Author: christian-bromann

src/features/attw.ts

@@ -8,11 +8,82 @@ import { blue, dim } from 'ansis'
 import Debug from 'debug'
 import { fsRemove } from '../utils/fs'
 import { logger } from '../utils/logger'
-import type { ResolvedOptions } from '../options'
+import type { AttwOptions, ResolvedOptions } from '../options'
+import type { Problem } from '@arethetypeswrong/core'
 
 const debug = Debug('tsdown:attw')
 const exec = promisify(child_process.exec)
 
+/**
+ * ATTW profiles.
+ * Defines the resolution modes to ignore for each profile.
+ *
+ * @see https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/packages/cli/README.md#profiles
+ */
+const profiles: Record<Required<AttwOptions>['profile'], string[]> = {
+  strict: [],
+  node16: ['node10'],
+  esmOnly: ['node10', 'node16-cjs'],
+}
+
+/**
+ * Format an ATTW problem for display
+ */
+function formatProblem(problem: Problem): string {
+  const resolutionKind =
+    'resolutionKind' in problem ? ` (${problem.resolutionKind})` : ''
+  const entrypoint = 'entrypoint' in problem ? ` at ${problem.entrypoint}` : ''
+
+  switch (problem.kind) {
+    case 'NoResolution':
+      return `  ❌ No resolution${resolutionKind}${entrypoint}`
+
+    case 'UntypedResolution':
+      return `  ⚠️  Untyped resolution${resolutionKind}${entrypoint}`
+
+    case 'FalseESM':
+      return `  🔄 False ESM: Types indicate ESM (${problem.typesModuleKind}) but implementation is CJS (${problem.implementationModuleKind})\n     Types: ${problem.typesFileName} | Implementation: ${problem.implementationFileName}`
+
+    case 'FalseCJS':
+      return `  🔄 False CJS: Types indicate CJS (${problem.typesModuleKind}) but implementation is ESM (${problem.implementationModuleKind})\n     Types: ${problem.typesFileName} | Implementation: ${problem.implementationFileName}`
+
+    case 'CJSResolvesToESM':
+      return `  ⚡ CJS resolves to ESM${resolutionKind}${entrypoint}`
+
+    case 'NamedExports': {
+      const missingExports =
+        problem.missing?.length > 0
+          ? ` Missing: ${problem.missing.join(', ')}`
+          : ''
+      const allMissing = problem.isMissingAllNamed
+        ? ' (all named exports missing)'
+        : ''
+      return `  📤 Named exports problem${allMissing}${missingExports}\n     Types: ${problem.typesFileName} | Implementation: ${problem.implementationFileName}`
+    }
+
+    case 'FallbackCondition':
+      return `  🎯 Fallback condition used${resolutionKind}${entrypoint}`
+
+    case 'FalseExportDefault':
+      return `  🎭 False export default\n     Types: ${problem.typesFileName} | Implementation: ${problem.implementationFileName}`
+
+    case 'MissingExportEquals':
+      return `  📝 Missing export equals\n     Types: ${problem.typesFileName} | Implementation: ${problem.implementationFileName}`
+
+    case 'InternalResolutionError':
+      return `  💥 Internal resolution error in ${problem.fileName} (${problem.resolutionOption})\n     Module: ${problem.moduleSpecifier} | Mode: ${problem.resolutionMode}`
+
+    case 'UnexpectedModuleSyntax':
+      return `  📋 Unexpected module syntax in ${problem.fileName}\n     Expected: ${problem.moduleKind} | Found: ${problem.syntax === 99 ? 'ESM' : 'CJS'}`
+
+    case 'CJSOnlyExportsDefault':
+      return `  🏷️  CJS only exports default in ${problem.fileName}`
+
+    default:
+      return `  ❓ Unknown problem: ${JSON.stringify(problem)}`
+  }
+}
+
 export async function attw(options: ResolvedOptions): Promise<void> {
   if (!options.attw) return
   if (!options.pkg) {
@@ -38,7 +109,7 @@ export async function attw(options: ResolvedOptions): Promise<void> {
   try {
     const { stdout: tarballInfo } = await exec(
       `npm pack --json ----pack-destination ${tempDir}`,
-      { encoding: 'utf-8' },
+      { encoding: 'utf-8', cwd: options.cwd },
     )
     const parsed = JSON.parse(tarballInfo)
     if (!Array.isArray(parsed) || !parsed[0]?.filename) {
@@ -48,14 +119,29 @@ export async function attw(options: ResolvedOptions): Promise<void> {
     const tarball = await readFile(tarballPath)
 
     const pkg = attwCore.createPackageFromTarballData(tarball)
-    const checkResult = await attwCore.checkPackage(
-      pkg,
-      options.attw === true ? {} : options.attw,
-    )
+    const attwOptions = options.attw === true ? {} : options.attw
+    const checkResult = await attwCore.checkPackage(pkg, attwOptions)
+    const profile = attwOptions.profile ?? 'strict'
+    const level = attwOptions.level ?? 'warn'
 
     if (checkResult.types !== false && checkResult.problems) {
-      for (const problem of checkResult.problems) {
-        logger.warn('Are the types wrong problem:', problem)
+      const problems = checkResult.problems.filter((problem) => {
+        // Only apply profile filter to problems that have resolutionKind
+        if ('resolutionKind' in problem) {
+          return !profiles[profile]?.includes(problem.resolutionKind)
+        }
+        // Include all other problem types
+        return true
+      })
+      if (problems.length) {
+        const problemList = problems.map(formatProblem).join('\n')
+        const problemMessage = `Are the types wrong problems found:\n${problemList}`
+
+        if (level === 'error') {
+          throw new Error(problemMessage)
+        }
+
+        logger.warn(problemMessage)
       }
     } else {
       logger.success(

src/options/types.ts

@@ -9,7 +9,7 @@ import type {
   MarkPartial,
   Overwrite,
 } from '../utils/types'
-import type { CheckPackageOptions as AttwOptions } from '@arethetypeswrong/core'
+import type { CheckPackageOptions } from '@arethetypeswrong/core'
 import type { Hookable } from 'hookable'
 import type { PackageJson } from 'pkg-types'
 import type { Options as PublintOptions } from 'publint'
@@ -87,6 +87,31 @@ export interface ExportsOptions {
   ) => Awaitable<Record<string, any>>
 }
 
+export interface AttwOptions extends CheckPackageOptions {
+  /**
+   * 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
+   * - `esmOnly`: ignores CJS resolution failures
+   *
+   * @default 'strict'
+   */
+  profile?: 'strict' | 'node16' | 'esmOnly'
+  /**
+   * The level of the check.
+   *
+   * The available levels are:
+   * - `error`: fails the build
+   * - `warn`: warns the build
+   *
+   * @default 'warn'
+   */
+  level?: 'error' | 'warn'
+}
+
 /**
  * Options for tsdown.
  */