Update CLI

Author: andrewbranch

package-lock.json

@@ -38,6 +38,8 @@
   },
   "type": "module",
   "devDependencies": {
+    "@types/marked": "^5.0.0",
+    "@types/marked-terminal": "^3.1.3",
     "@types/node": "^20.2.5",
     "@types/node-fetch": "^2.6.4",
     "typescript": "^5.0.0-dev.20230207"
@@ -46,6 +48,8 @@
     "@arethetypeswrong/core": "0.0.8",
     "chalk": "^4.1.2",
     "cli-table3": "^0.6.3",
-    "commander": "^10.0.1"
+    "commander": "^10.0.1",
+    "marked": "^5.1.0",
+    "marked-terminal": "^5.2.0"
   }
 }

packages/cli/package.json

@@ -11,6 +11,7 @@ import { createRequire } from "module";
 import * as render from "./render/index.js";
 import { readConfig } from "./readConfig.js";
 import { problemFlags } from "./problemUtils.js";
+import { groupProblemsByKind } from "@arethetypeswrong/core/utils";
 
 const packageJson = createRequire(import.meta.url)("../package.json");
 const version = packageJson.version;
@@ -100,15 +101,12 @@ particularly ESM-related module resolution issues.`
       };
 
       if (analysis.containsTypes) {
-        result.problems = core.groupByKind(core.getProblems(analysis));
+        result.problems = groupProblemsByKind(analysis.problems);
       }
 
       console.log(JSON.stringify(result));
 
-      if (
-        analysis.containsTypes &&
-        core.getProblems(analysis).some((problem) => !opts.ignoreRules?.includes(problem.kind))
-      )
+      if (analysis.containsTypes && analysis.problems.some((problem) => !opts.ignoreRules?.includes(problem.kind)))
         process.exit(1);
 
       return;
@@ -118,10 +116,7 @@ particularly ESM-related module resolution issues.`
     if (analysis.containsTypes) {
       await render.typed(analysis, opts);
 
-      if (
-        analysis.containsTypes &&
-        core.getProblems(analysis).some((problem) => !opts.ignoreRules?.includes(problem.kind))
-      )
+      if (analysis.containsTypes && analysis.problems.some((problem) => !opts.ignoreRules?.includes(problem.kind)))
         process.exit(1);
     } else {
       render.untyped(analysis as core.UntypedAnalysis);

packages/cli/src/index.ts

@@ -11,55 +11,8 @@ export const problemFlags: Record<ProblemKind, string> = {
   FallbackCondition: "fallback-condition",
   CJSOnlyExportsDefault: "cjs-only-exports-default",
   FalseExportDefault: "false-export-default",
-  UnexpectedESMSyntax: "unexpected-esm-syntax",
-  UnexpectedCJSSyntax: "unexpected-cjs-syntax",
-};
-
-export const problemEmoji: Record<ProblemKind, string> = {
-  Wildcard: "❓",
-  NoResolution: "💀",
-  UntypedResolution: "🚫",
-  FalseCJS: "🎭",
-  FalseESM: "👺",
-  CJSResolvesToESM: "⚠️",
-  FallbackCondition: "🐛",
-  CJSOnlyExportsDefault: "🤨",
-  FalseExportDefault: "❗️",
-  UnexpectedESMSyntax: "🚭",
-  UnexpectedCJSSyntax: "🚱",
-};
-
-export const withEmoji: Record<ProblemKind, string> = {
-  Wildcard: `${problemEmoji.Wildcard} Unable to check`,
-  NoResolution: `${problemEmoji.NoResolution} Failed to resolve`,
-  UntypedResolution: `${problemEmoji.UntypedResolution} No types`,
-  FalseCJS: `${problemEmoji.FalseCJS} Masquerading as CJS`,
-  FalseESM: `${problemEmoji.FalseESM} Masquerading as ESM`,
-  CJSResolvesToESM: `${problemEmoji.CJSResolvesToESM} ESM (dynamic import only)`,
-  FallbackCondition: `${problemEmoji.FallbackCondition} Used fallback condition`,
-  CJSOnlyExportsDefault: `${problemEmoji.CJSOnlyExportsDefault} CJS default export`,
-  FalseExportDefault: `${problemEmoji.FalseExportDefault} Incorrect default export`,
-  UnexpectedESMSyntax: `${problemEmoji.UnexpectedESMSyntax} Unexpected ESM syntax`,
-  UnexpectedCJSSyntax: `${problemEmoji.UnexpectedCJSSyntax} Unexpected CJS syntax`,
-};
-
-export const noEmoji: Record<ProblemKind, string> = {
-  Wildcard: `Unable to check`,
-  NoResolution: `Failed to resolve`,
-  UntypedResolution: `No types`,
-  FalseCJS: `Masquerading as CJS`,
-  FalseESM: `Masquerading as ESM`,
-  CJSResolvesToESM: `ESM (dynamic import only)`,
-  FallbackCondition: `Used fallback condition`,
-  CJSOnlyExportsDefault: `CJS default export`,
-  FalseExportDefault: `Incorrect default export`,
-  UnexpectedESMSyntax: `Unexpected ESM syntax`,
-  UnexpectedCJSSyntax: `Unexpected CJS syntax`,
-};
-
-export const problemShortDescriptions = {
-  emoji: withEmoji,
-  noEmoji: noEmoji,
+  UnexpectedModuleSyntax: "unexpected-module-syntax",
+  InternalResolutionError: "internal-resolution-error",
 };
 
 export const resolutionKinds: Record<core.ResolutionKind, string> = {

packages/cli/src/problemUtils.ts

@@ -1,18 +1,25 @@
 import * as core from "@arethetypeswrong/core";
-import { allResolutionKinds } from "@arethetypeswrong/core/utils";
-import Table, { type GenericTable, type HorizontalTableRow } from "cli-table3";
+import { allResolutionKinds, groupProblemsByKind } from "@arethetypeswrong/core/utils";
 import chalk from "chalk";
+import Table, { type GenericTable, type HorizontalTableRow } from "cli-table3";
+import { marked } from "marked";
 
-import { moduleKinds, problemEmoji, resolutionKinds, problemShortDescriptions, problemFlags } from "../problemUtils.js";
+import { filterProblems, problemAffectsEntrypoint, problemKindInfo } from "@arethetypeswrong/core/problems";
 import type { Opts } from "../index.js";
+import { moduleKinds, problemFlags, resolutionKinds } from "../problemUtils.js";
 import { tableFlipped } from "./tableFlipped.js";
+import TerminalRenderer from "marked-terminal";
 
 export async function typed(analysis: core.TypedAnalysis, opts: Opts) {
-  const problems = core
-    .getProblems(analysis)
-    .filter((problem) => !opts.ignoreRules || !opts.ignoreRules.includes(problem.kind));
-
-  const subpaths = Object.keys(analysis.entrypointResolutions);
+  const problems = analysis.problems.filter((problem) => !opts.ignoreRules || !opts.ignoreRules.includes(problem.kind));
+  const grouped = groupProblemsByKind(problems);
+  const subpaths = Object.keys(analysis.entrypoints);
+  marked.setOptions({
+    // @ts-expect-error the types are wrong (haha)
+    renderer: new TerminalRenderer(),
+    mangle: false,
+    headerIds: false,
+  });
 
   if (opts.ignoreRules && opts.ignoreRules.length) {
     console.log(
@@ -25,23 +32,18 @@ export async function typed(analysis: core.TypedAnalysis, opts: Opts) {
   }
 
   if (opts.summary) {
-    const summaries = core.summarizeProblems(problems, analysis);
     const defaultSummary = !opts.emoji ? " No problems found" : " No problems found 🌟";
-    const summaryTexts = summaries.map((summary) => {
-      return summary.messages
-        .map((message) => {
-          const messageText = message.messageText.split(". ").join(".\n   ");
-          if (!opts.emoji) return `    ${messageText}`;
-          return ` ${problemEmoji[summary.kind]} ${messageText}`;
-        })
-        .join("\n");
+    const summaryTexts = Object.keys(grouped).map((kind) => {
+      const emoji = opts.emoji ? `${problemKindInfo[kind as core.ProblemKind].emoji} ` : "";
+      const description = marked(problemKindInfo[kind as core.ProblemKind].description);
+      return `${emoji}${description}`;
     });
 
     console.log((summaryTexts.join("\n\n") || defaultSummary) + "\n");
   }
 
   const entrypoints = subpaths.map((s) => {
-    const hasProblems = problems.some((p) => p.entrypoint === s);
+    const hasProblems = problems.some((p) => problemAffectsEntrypoint(p, s, analysis));
     const color = hasProblems ? "redBright" : "greenBright";
 
     if (s === ".") return chalk.bold[color](`"${analysis.packageName}"`);
@@ -60,22 +62,21 @@ export async function typed(analysis: core.TypedAnalysis, opts: Opts) {
 
       row = row.concat(
         allResolutionKinds.map((kind) => {
-          const problemsForCell = problems.filter(
-            (problem) => problem.entrypoint === subpath && problem.resolutionKind === kind
+          const problemsForCell = groupProblemsByKind(
+            filterProblems(problems, analysis, { entrypoint: subpath, resolutionKind: kind })
           );
-
-          const resolution = analysis.entrypointResolutions[subpath][kind].resolution;
-
-          const descriptions = problemShortDescriptions[!opts.emoji ? "noEmoji" : "emoji"];
-
-          if (problemsForCell.length) {
-            return problemsForCell.map((problem) => descriptions[problem.kind]).join("\n");
+          const resolution = analysis.entrypoints[subpath].resolutions[kind].resolution;
+          const kinds = Object.keys(problemsForCell) as core.ProblemKind[];
+          if (kinds.length) {
+            return kinds
+              .map(
+                (kind) => (opts.emoji ? `${problemKindInfo[kind].emoji} ` : "") + problemKindInfo[kind].shortDescription
+              )
+              .join("\n");
           }
 
           const jsonResult = !opts.emoji ? "OK (JSON)" : "🟢 (JSON)";
-
           const moduleResult = (!opts.emoji ? "OK " : "🟢 ") + moduleKinds[resolution?.moduleKind?.detectedKind || ""];
-
           return resolution?.isJson ? jsonResult : moduleResult;
         })
       );
@@ -96,22 +97,21 @@ export async function typed(analysis: core.TypedAnalysis, opts: Opts) {
 
     row = row.concat(
       subpaths.map((subpath) => {
-        const problemsForCell = problems.filter(
-          (problem) => problem.entrypoint === subpath && problem.resolutionKind === kind
+        const problemsForCell = groupProblemsByKind(
+          filterProblems(problems, analysis, { entrypoint: subpath, resolutionKind: kind })
         );
-
-        const resolution = analysis.entrypointResolutions[subpath][kind].resolution;
-
-        const descriptions = problemShortDescriptions[!opts.emoji ? "noEmoji" : "emoji"];
-
-        if (problemsForCell.length) {
-          return problemsForCell.map((problem) => descriptions[problem.kind]).join("\n");
+        const resolution = analysis.entrypoints[subpath].resolutions[kind].resolution;
+        const kinds = Object.keys(problemsForCell) as core.ProblemKind[];
+        if (kinds.length) {
+          return kinds
+            .map(
+              (kind) => (opts.emoji ? `${problemKindInfo[kind].emoji} ` : "") + problemKindInfo[kind].shortDescription
+            )
+            .join("\n");
         }
 
         const jsonResult = !opts.emoji ? "OK (JSON)" : "🟢 (JSON)";
-
         const moduleResult = (!opts.emoji ? "OK " : "🟢 ") + moduleKinds[resolution?.moduleKind?.detectedKind || ""];
-
         return resolution?.isJson ? jsonResult : moduleResult;
       })
     );

packages/cli/src/render/typed.ts

@@ -1,4 +1,12 @@
-import type { ProblemKind } from "./types.js";
+import type { Problem, ProblemKind, ResolutionKind, ResolutionOption, TypedAnalysis } from "./types.js";
+import {
+  allResolutionKinds,
+  getResolutionKinds,
+  getResolutionOption,
+  isEntrypointResolutionProblem,
+  isFileProblem,
+  isResolutionBasedFileProblem,
+} from "./utils.js";
 
 export interface ProblemKindInfo {
   title: string;
@@ -81,3 +89,86 @@ export const problemKindInfo: Record<ProblemKind, ProblemKindInfo> = {
       "Import found in a type declaration file failed to resolve. Either this indicates that runtime resolution errors will occur, or (more likely) the types misrepresent the contents of the JavaScript files.",
   },
 };
+
+export interface ProblemFilter {
+  kind?: ProblemKind;
+  entrypoint?: string;
+  resolutionKind?: ResolutionKind;
+  resolutionOption?: ResolutionOption;
+}
+
+export function filterProblems(analysis: TypedAnalysis, filter: ProblemFilter): Problem[];
+export function filterProblems(problems: readonly Problem[], analysis: TypedAnalysis, filter: ProblemFilter): Problem[];
+export function filterProblems(
+  ...args:
+    | [analysis: TypedAnalysis, filter: ProblemFilter]
+    | [problems: readonly Problem[], analysis: TypedAnalysis, filter: ProblemFilter]
+) {
+  const [problems, analysis, filter] = args.length === 2 ? [args[0].problems, ...args] : args;
+  return problems.filter((p) => {
+    if (filter.kind && p.kind !== filter.kind) {
+      return false;
+    }
+    if (filter.entrypoint && filter.resolutionKind) {
+      return problemAffectsEntrypointResolution(p, filter.entrypoint, filter.resolutionKind, analysis);
+    }
+    if (filter.entrypoint && filter.resolutionOption) {
+      return getResolutionKinds(filter.resolutionOption).every((resolutionKind) =>
+        problemAffectsEntrypointResolution(p, filter.entrypoint!, resolutionKind, analysis)
+      );
+    }
+    if (filter.entrypoint) {
+      return problemAffectsEntrypoint(p, filter.entrypoint, analysis);
+    }
+    if (filter.resolutionKind) {
+      return problemAffectsResolutionKind(p, filter.resolutionKind, analysis);
+    }
+    return true;
+  });
+}
+
+export function problemAffectsResolutionKind(
+  problem: Problem,
+  resolutionKind: ResolutionKind,
+  analysis: TypedAnalysis
+) {
+  if (isEntrypointResolutionProblem(problem)) {
+    return problem.resolutionKind === resolutionKind;
+  }
+  if (isResolutionBasedFileProblem(problem)) {
+    return problem.resolutionOption === getResolutionOption(resolutionKind);
+  }
+  return Object.values(analysis.entrypoints).some((entrypointInfo) =>
+    entrypointInfo.resolutions[resolutionKind].files?.includes(problem.fileName)
+  );
+}
+
+export function problemAffectsEntrypoint(problem: Problem, entrypoint: string, analysis: TypedAnalysis) {
+  if (isEntrypointResolutionProblem(problem)) {
+    return problem.entrypoint === entrypoint;
+  }
+  return allResolutionKinds.some((resolutionKind) =>
+    analysis.entrypoints[entrypoint].resolutions[resolutionKind].files?.includes(problem.fileName)
+  );
+}
+
+export function problemAffectsEntrypointResolution(
+  problem: Problem,
+  entrypoint: string,
+  resolutionKind: ResolutionKind,
+  analysis: TypedAnalysis
+) {
+  if (isEntrypointResolutionProblem(problem)) {
+    return problem.entrypoint === entrypoint && problem.resolutionKind === resolutionKind;
+  }
+  if (isResolutionBasedFileProblem(problem)) {
+    return (
+      getResolutionOption(resolutionKind) === problem.resolutionOption &&
+      analysis.entrypoints[entrypoint].resolutions[resolutionKind].files?.includes(problem.fileName)
+    );
+  }
+  if (isFileProblem(problem)) {
+    return analysis.entrypoints[entrypoint].resolutions[resolutionKind].files?.includes(problem.fileName);
+  }
+  throw new Error(`Unhandled problem type '${(problem satisfies never as Problem).kind}'`);
+}

packages/core/src/problems.ts

@@ -25,6 +25,17 @@ export function getResolutionOption(resolutionKind: ResolutionKind): ResolutionO
   }
 }
 
+export function getResolutionKinds(resolutionOption: ResolutionOption): ResolutionKind[] {
+  switch (resolutionOption) {
+    case "node10":
+      return ["node10"];
+    case "node16":
+      return ["node16-cjs", "node16-esm"];
+    case "bundler":
+      return ["bundler"];
+  }
+}
+
 export function isDefined<T>(value: T | undefined): value is T {
   return value !== undefined;
 }

packages/core/src/utils.ts

@@ -17,9 +17,11 @@
   "dependencies": {
     "@arethetypeswrong/core": "file:../core",
     "immer": "^9.0.21",
+    "marked": "^5.1.0",
     "nprogress": "^0.2.0"
   },
   "devDependencies": {
+    "@types/marked": "^5.0.0",
     "@types/nprogress": "^0.2.0",
     "esbuild": "^0.17.4",
     "vite": "^4.0.4"

packages/web/package.json

@@ -116,6 +116,9 @@ dt,
 dd {
   padding: 0.5em 0;
 }
+dd > p {
+  margin: 0;
+}
 #resolutions {
   margin-bottom: 1rem;
   font-size: small;