intor-cli 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intor-cli",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Intor CLI",
   "author": "Yiming Liao",
   "homepage": "https://github.com/yiming-liao/intor-cli#readme",
@@ -66,7 +66,6 @@
     "typescript-eslint": "8.51.0",
     "vitest": "4.0.16"
   },
-  "peerDependencies": {},
   "publishConfig": {
     "access": "public"
   }

package/src/core/diagnostics/collect.ts

@@ -4,6 +4,7 @@ import type { InferredSchemas } from "../infer-schema/types";
 import { enforceMissingReplacements } from "./rules/enforce-missing-replacements";
 import { enforceMissingRich } from "./rules/enforce-missing-rich";
 import { keyEmpty, keyNotFound } from "./rules/key";
+import { preKeyNotFound } from "./rules/pre-key";
 import {
   replacementsNotAllowed,
   replacementsMissing,
@@ -18,13 +19,18 @@ export function collectDiagnostics(
 ) {
   const diagnostics: Diagnostic[] = [];
 
+  // PreKey
+  for (const usage of usages.preKey) {
+    diagnostics.push(...preKeyNotFound(usage, messagesSchema));
+  }
+
   // Key
-  for (const usage of usages.keys) {
+  for (const usage of usages.key) {
     diagnostics.push(...keyNotFound(usage, messagesSchema), ...keyEmpty(usage));
   }
 
-  // Replacements
-  for (const usage of usages.replacements) {
+  // Replacement
+  for (const usage of usages.replacement) {
     diagnostics.push(
       ...replacementsNotAllowed(usage, replacementsSchema),
       ...replacementsMissing(usage, replacementsSchema),
@@ -42,9 +48,9 @@ export function collectDiagnostics(
   }
 
   // Ensure required replacements / rich tags are detected even when no usage provides them
-  const replacementIndex = indexUsagesByKey(usages.replacements);
+  const replacementIndex = indexUsagesByKey(usages.replacement);
   const richIndex = indexUsagesByKey(usages.rich);
-  for (const usage of usages.keys) {
+  for (const usage of usages.key) {
     diagnostics.push(
       ...enforceMissingReplacements(
         usage,

package/src/core/diagnostics/group.ts

@@ -1,20 +1,38 @@
 /* eslint-disable unicorn/no-array-sort */
 import type { Diagnostic, DiagnosticGroup } from "./types";
 
+/**
+ * Group diagnostics (by file + messageKey + method).
+ */
 export function groupDiagnostics(diagnostics: Diagnostic[]): DiagnosticGroup[] {
   const map = new Map<string, DiagnosticGroup>();
 
   for (const diagnostic of diagnostics) {
-    const { severity, method, message, messageKey, file, line, column } =
-      diagnostic;
-
+    const {
+      severity,
+      factory,
+      method,
+      message,
+      messageKey,
+      file,
+      line,
+      column,
+    } = diagnostic;
+
+    // --------------------------------------------------
+    // Grouping key
+    // - Prefer semantic key (messageKey + method)
+    // - Fallback to exact source location
+    // --------------------------------------------------
     const groupId = messageKey
       ? `${file}::${messageKey}::${diagnostic.method}`
       : `${file}::${line}:${column}`;
 
+    // Initialize group if not exists
     if (!map.has(groupId)) {
       map.set(groupId, {
         severity,
+        factory,
         method,
         messageKey,
         problems: [],
@@ -24,15 +42,17 @@ export function groupDiagnostics(diagnostics: Diagnostic[]): DiagnosticGroup[] {
     }
     const group = map.get(groupId)!;
 
+    // Aggregate messages & lines
     group.problems.push(message);
     group.lines.push(line);
 
-    // severity upgrade (error > warn)
+    // Severity escalation (error > warn)
     if (severity === "error") {
       group.severity = "error";
     }
   }
 
+  // Normalize line numbers (unique + sorted)
   for (const group of map.values()) {
     group.lines = [...new Set(group.lines)].sort((a, b) => a - b);
   }

package/src/core/diagnostics/messages.ts

@@ -1,15 +1,23 @@
 export const DIAGNOSTIC_MESSAGES = {
+  // --------------------------------------------------
+  // PreKey
+  // --------------------------------------------------
+  PRE_KEY_NOT_FOUND: {
+    code: "INTOR_PRE_KEY_NOT_FOUND",
+    message: () => "preKey does not exist",
+  },
+
   // --------------------------------------------------
   // Message key
   // --------------------------------------------------
   KEY_NOT_FOUND: {
     code: "INTOR_KEY_NOT_FOUND",
-    message: () => "does not exist",
+    message: () => "key does not exist",
   },
 
   KEY_EMPTY: {
     code: "INTOR_KEY_EMPTY",
-    message: () => "translation key cannot be empty",
+    message: () => "key cannot be empty",
   },
 
   // --------------------------------------------------
@@ -17,18 +25,18 @@ export const DIAGNOSTIC_MESSAGES = {
   // --------------------------------------------------
   REPLACEMENTS_NOT_ALLOWED: {
     code: "INTOR_REPLACEMENTS_NOT_ALLOWED",
-    message: () => "does not accept replacements",
+    message: () => "replacements are not allowed",
   },
 
   REPLACEMENTS_MISSING: {
     code: "INTOR_REPLACEMENTS_MISSING",
     message: (missing: string[]) =>
-      `missing replacements: ${missing.join(", ")}`,
+      `replacements missing: ${missing.join(", ")}`,
   },
 
   REPLACEMENTS_UNUSED: {
     code: "INTOR_REPLACEMENTS_UNUSED",
-    message: (extra: string[]) => `unused replacements: ${extra.join(", ")}`,
+    message: (extra: string[]) => `replacements unused: ${extra.join(", ")}`,
   },
 
   // --------------------------------------------------
@@ -36,16 +44,16 @@ export const DIAGNOSTIC_MESSAGES = {
   // --------------------------------------------------
   RICH_NOT_ALLOWED: {
     code: "INTOR_RICH_NOT_ALLOWED",
-    message: () => "does not accept rich tags",
+    message: () => "rich tags are not allowed",
   },
 
   RICH_MISSING: {
     code: "INTOR_RICH_MISSING",
-    message: (missing: string[]) => `missing rich tags: ${missing.join(", ")}`,
+    message: (missing: string[]) => `rich tags missing: ${missing.join(", ")}`,
   },
 
   RICH_UNUSED: {
     code: "INTOR_RICH_UNUSED",
-    message: (extra: string[]) => `unused rich tags: ${extra.join(", ")}`,
+    message: (extra: string[]) => `rich tags unused: ${extra.join(", ")}`,
   },
 } as const;

package/src/core/diagnostics/rules/pre-key/index.ts

@@ -0,0 +1 @@
+export { preKeyNotFound } from "./not-found";

package/src/core/diagnostics/rules/pre-key/not-found.ts

@@ -0,0 +1,41 @@
+import type { PreKeyUsage } from "../../../extract-usages";
+import type { InferNode } from "../../../infer-schema";
+import type { Diagnostic } from "../../types";
+import { DIAGNOSTIC_MESSAGES } from "../../messages";
+import { getSchemaNodeAtPath } from "../../utils/get-schema-node-at-path";
+
+/**
+ * @example
+ * ```ts
+ * // Expected:
+ * useTranslator("hello")
+ *
+ * // Received:
+ * useTranslator("missing")
+ * ```
+ */
+export function preKeyNotFound(
+  usage: PreKeyUsage,
+  messagesSchema: InferNode,
+): Diagnostic[] {
+  const { factory, preKey, file, line, column } = usage;
+
+  if (!preKey) return [];
+
+  if (!getSchemaNodeAtPath(messagesSchema, preKey)) {
+    return [
+      {
+        severity: "warn",
+        factory,
+        messageKey: preKey,
+        code: DIAGNOSTIC_MESSAGES.PRE_KEY_NOT_FOUND.code,
+        message: DIAGNOSTIC_MESSAGES.PRE_KEY_NOT_FOUND.message(),
+        file,
+        line,
+        column,
+      },
+    ];
+  }
+
+  return [];
+}

package/src/core/diagnostics/types.ts

@@ -1,8 +1,9 @@
-import type { TranslatorMethod } from "../extract-usages";
+import type { TranslatorFactory, TranslatorMethod } from "../extract-usages";
 
 export interface Diagnostic {
   severity: "error" | "warn";
-  method: TranslatorMethod;
+  factory?: TranslatorFactory;
+  method?: TranslatorMethod;
   messageKey: string;
   code: string;
   message: string;
@@ -13,7 +14,8 @@ export interface Diagnostic {
 
 export interface DiagnosticGroup {
   severity: "error" | "warn";
-  method: TranslatorMethod;
+  factory?: TranslatorFactory;
+  method?: TranslatorMethod;
   messageKey: string;
   problems: string[]; // list of bullet messages
   file: string;

package/src/core/discover-configs/discover-configs.ts

@@ -4,6 +4,7 @@ import fg from "fast-glob";
 import { type IntorResolvedConfig } from "intor";
 import { createLogger } from "../scan-logger";
 import { isIntorResolvedConfig } from "./is-intor-resolved-config";
+import { loadModule } from "./load-module";
 
 const DEFAULT_PATTERNS = ["**/*.{ts,js}"];
 const DEFAULT_IGNORE = [
@@ -58,7 +59,7 @@ export async function discoverConfigs(debug?: boolean): Promise<ConfigEntry[]> {
     // Dynamic import & export inspection
     // ----------------------------------------------------------------------
     try {
-      const moduleExports = await import(absPath);
+      const moduleExports = await loadModule(absPath);
       let matched = false;
 
       for (const module of Object.values(moduleExports)) {

package/src/core/discover-configs/load-module.ts

@@ -0,0 +1,3 @@
+export async function loadModule(filePath: string) {
+  return import(filePath);
+}

package/src/core/extract-usages/collectors/collect-pre-keys.ts

@@ -1,4 +1,4 @@
-import type { PreKeyMap, TranslatorBindingMap } from "../types";
+import type { PreKeyMap, PreKeyUsage, TranslatorBindingMap } from "../types";
 import { SyntaxKind, type SourceFile } from "ts-morph";
 import { getObjectArg } from "./utils/get-object-arg";
 import { isStaticStringLiteral } from "./utils/is-static-string-literal";
@@ -6,6 +6,11 @@ import { walkTranslatorBindings } from "./utils/walk-translator-bindings";
 
 const PREKEY_PROPERTY_NAME = "preKey";
 
+export interface CollectPreKeysResult {
+  preKeyMap: PreKeyMap;
+  usages: PreKeyUsage[];
+}
+
 /**
  * Collect static preKey values associated with translator bindings
  * within a single source file.
@@ -13,14 +18,19 @@ const PREKEY_PROPERTY_NAME = "preKey";
 export function collectPreKeys(
   sourceFile: SourceFile,
   translatorBindingMap: TranslatorBindingMap,
-): PreKeyMap {
-  const preKeyMap = new Map<string, string>();
+): CollectPreKeysResult {
+  const preKeyMap: PreKeyMap = new Map();
+  const usages: PreKeyUsage[] = [];
 
   walkTranslatorBindings(sourceFile, ({ call, binding }) => {
     // Iterate over destructured translator binding elements (e.g. { t, hasKey, ... })
     for (const el of binding.getElements()) {
       const localName = el.getNameNode().getText(); // `t` from `const { t } = useTranslator`
       if (!translatorBindingMap.has(localName)) continue;
+      const translatorUsage = translatorBindingMap.get(localName);
+      if (!translatorUsage) return;
+
+      let preKey: string | undefined;
 
       // -----------------------------------------------------------------------
       // Resolve static preKey from translator factory arguments
@@ -28,31 +38,51 @@ export function collectPreKeys(
       // 1. From the first positional string argument (e.g. `useTranslator("preKey")`)
       const firstArg = call.getArguments()[0];
       if (isStaticStringLiteral(firstArg)) {
-        preKeyMap.set(localName, firstArg.getLiteralText());
-        continue;
+        preKey = firstArg.getLiteralText();
       }
 
       // 2. From the last options object (e.g. `getTranslator(_, { preKey })`)
-      const lastArg = getObjectArg(call, "last");
-      if (!lastArg) continue;
-
-      // Extract the `preKey` property from the options object
-      const prop = lastArg.getProperty(PREKEY_PROPERTY_NAME);
-      if (!prop || !prop.isKind(SyntaxKind.PropertyAssignment)) continue;
-
-      // Only accept static string initializers as preKey values
-      const value = prop.getInitializer();
-      if (!value) continue;
-      if (
-        !value.isKind(SyntaxKind.StringLiteral) &&
-        !value.isKind(SyntaxKind.NoSubstitutionTemplateLiteral)
-      ) {
-        continue;
+      if (!preKey) {
+        const lastArg = getObjectArg(call, "last");
+        if (!lastArg) continue;
+
+        // Extract the `preKey` property from the options object
+        const prop = lastArg.getProperty(PREKEY_PROPERTY_NAME);
+        if (!prop || !prop.isKind(SyntaxKind.PropertyAssignment)) continue;
+
+        // Only accept static string initializers as preKey values
+        const value = prop.getInitializer();
+        if (!value) continue;
+        if (
+          !value.isKind(SyntaxKind.StringLiteral) &&
+          !value.isKind(SyntaxKind.NoSubstitutionTemplateLiteral)
+        ) {
+          continue;
+        }
+        preKey = value.getLiteralText();
       }
 
-      preKeyMap.set(localName, value.getLiteralText());
+      if (!preKey) continue;
+
+      // ---------------------------------------------------------------------
+      // Record
+      // ---------------------------------------------------------------------
+      preKeyMap.set(localName, preKey);
+
+      // Resolve source location for diagnostics
+      const pos = sourceFile.getLineAndColumnAtPos(call.getStart());
+
+      usages.push({
+        factory: translatorUsage.factory,
+        configKey: translatorUsage.configKey,
+        localName,
+        preKey,
+        file: sourceFile.getFilePath(),
+        line: pos.line,
+        column: pos.column,
+      });
     }
   });
 
-  return preKeyMap;
+  return { preKeyMap, usages };
 }

package/src/core/extract-usages/extract-usages-from-source-file.ts

@@ -0,0 +1,72 @@
+import type { ExtractedUsages, PreKeyMap } from "./types";
+import type { SourceFile } from "ts-morph";
+import {
+  collectTranslatorBindings,
+  collectKeyUsages,
+  collectReplacementUsages,
+  collectRichUsages,
+  collectPreKeys,
+} from "./collectors";
+
+function attachPreKey<T extends { localName: string; preKey?: string }>(
+  usages: T[],
+  preKeyMap: PreKeyMap,
+) {
+  for (const usage of usages) usage.preKey = preKeyMap.get(usage.localName);
+}
+
+/**
+ * Extract all static translator usages from a single source file.
+ *
+ * This is a pure, file-level extractor suitable for editor extensions
+ * and incremental analysis.
+ */
+export function extractUsagesFromSourceFile(
+  sourceFile: SourceFile,
+): ExtractedUsages {
+  // -----------------------------------------------------------------------
+  // Translator binding
+  // -----------------------------------------------------------------------
+  const translatorBindingMap = collectTranslatorBindings(sourceFile);
+  if (translatorBindingMap.size === 0) {
+    return { preKey: [], key: [], replacement: [], rich: [] };
+  }
+
+  // -----------------------------------------------------------------------
+  // Key usages
+  // -----------------------------------------------------------------------
+  const keyUsages = collectKeyUsages(sourceFile, translatorBindingMap);
+
+  // -----------------------------------------------------------------------
+  // Replacement usages
+  // -----------------------------------------------------------------------
+  const replacementUsages = collectReplacementUsages(
+    sourceFile,
+    translatorBindingMap,
+  );
+
+  // -----------------------------------------------------------------------
+  // Rich usages
+  // -----------------------------------------------------------------------
+  const richUsages = collectRichUsages(sourceFile, translatorBindingMap);
+
+  // -----------------------------------------------------------------------
+  // PreKey values
+  // -----------------------------------------------------------------------
+  const { preKeyMap, usages } = collectPreKeys(
+    sourceFile,
+    translatorBindingMap,
+  );
+
+  // Attach preKey to all usages that support it
+  attachPreKey(keyUsages, preKeyMap);
+  attachPreKey(replacementUsages, preKeyMap);
+  attachPreKey(richUsages, preKeyMap);
+
+  return {
+    preKey: usages,
+    key: keyUsages,
+    replacement: replacementUsages,
+    rich: richUsages,
+  };
+}

package/src/core/extract-usages/extract-usages.ts

@@ -1,15 +1,13 @@
 import type { ExtractedUsages } from "./types";
 import pc from "picocolors";
 import { createLogger } from "../scan-logger";
-import {
-  collectTranslatorBindings,
-  collectKeyUsages,
-  collectReplacementUsages,
-  collectRichUsages,
-  collectPreKeys,
-} from "./collectors";
+import { extractUsagesFromSourceFile } from "./extract-usages-from-source-file";
 import { loadSourceFilesFromTsconfig } from "./load-source-files-from-tscofnig";
 
+/** Check whether a file-level extraction produced any meaningful usage */
+const isEmpty = (u: ExtractedUsages) =>
+  u.key.length === 0 && u.replacement.length === 0 && u.rich.length === 0;
+
 export interface ExtractUsagesOptions {
   tsconfigPath?: string;
   debug?: boolean;
@@ -23,11 +21,13 @@ export function extractUsages(options?: ExtractUsagesOptions): ExtractedUsages {
   const log = createLogger(debug);
 
   const result: ExtractedUsages = {
-    keys: [],
-    replacements: [],
+    preKey: [],
+    key: [],
+    replacement: [],
     rich: [],
   };
 
+  // Debug counters
   let scannedFiles = 0;
   let matchedFiles = 0;
 
@@ -38,46 +38,23 @@ export function extractUsages(options?: ExtractUsagesOptions): ExtractedUsages {
     scannedFiles++;
     log("scan", sourceFile.getFilePath());
 
-    // -----------------------------------------------------------------------
-    // Translator binding
-    // -----------------------------------------------------------------------
-    const translatorBindingMap = collectTranslatorBindings(sourceFile);
-    if (translatorBindingMap.size === 0) continue;
+    // ---------------------------------------------------------------------------
+    // File-level extraction (pure analysis, no side effects)
+    // ---------------------------------------------------------------------------
+    const partial = extractUsagesFromSourceFile(sourceFile);
+    if (isEmpty(partial)) continue;
     matchedFiles++;
 
-    // -----------------------------------------------------------------------
-    // Key usages
-    // -----------------------------------------------------------------------
-    const keyUsages = collectKeyUsages(sourceFile, translatorBindingMap);
-
-    // -----------------------------------------------------------------------
-    // Replacement usages
-    // -----------------------------------------------------------------------
-    const replacementUsages = collectReplacementUsages(
-      sourceFile,
-      translatorBindingMap,
-    );
-
-    // -----------------------------------------------------------------------
-    // Rich usages
-    // -----------------------------------------------------------------------
-    const richUsages = collectRichUsages(sourceFile, translatorBindingMap);
-
-    // -----------------------------------------------------------------------
-    // PreKey values
-    // -----------------------------------------------------------------------
-    const preKeyMap = collectPreKeys(sourceFile, translatorBindingMap);
-
-    // Attach preKey to all usages that support it
-    for (const usage of [...keyUsages, ...replacementUsages, ...richUsages]) {
-      usage.preKey = preKeyMap.get(usage.localName);
-    }
-
-    result.keys.push(...keyUsages);
-    result.replacements.push(...replacementUsages);
-    result.rich.push(...richUsages);
+    // ---------------------------------------------------------------------------
+    // Merge file-level results into the project-level result
+    // ---------------------------------------------------------------------------
+    result.preKey.push(...partial.preKey);
+    result.key.push(...partial.key);
+    result.replacement.push(...partial.replacement);
+    result.rich.push(...partial.rich);
   }
 
+  // Debug summary
   if (debug) {
     console.log(
       pc.dim(` › Scanned ${scannedFiles} files, matched ${matchedFiles} \n`),

package/src/core/extract-usages/index.ts

@@ -2,6 +2,7 @@ export { extractUsages } from "./extract-usages";
 
 export type {
   ExtractedUsages,
+  PreKeyUsage,
   KeyUsage,
   ReplacementUsage,
   RichUsage,

package/src/core/extract-usages/load-source-files-from-tscofnig.ts

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
-import pc from "picocolors";
 import { Project, type SourceFile } from "ts-morph";
+import { createLogger } from "../scan-logger";
 
 /**
  * Load source files from a tsconfig.
@@ -20,6 +20,7 @@ export function loadSourceFilesFromTsconfig(
   tsconfigPath: string,
   debug: boolean,
 ): SourceFile[] {
+  const log = createLogger(debug);
   // ---------------------------------------------------------------------------
   // 1. Try loading source files directly from the given tsconfig
   // ---------------------------------------------------------------------------
@@ -35,13 +36,7 @@ export function loadSourceFilesFromTsconfig(
   const references: { path: string }[] = rawConfig.references ?? [];
 
   if (references.length === 0) return [];
-
-  if (debug) {
-    console.log(
-      pc.dim(" (info)") +
-        pc.gray(" no source files found, following project references"),
-    );
-  }
+  log("info", `no source files found, following project references`);
 
   // ---------------------------------------------------------------------------
   // 3. Load source files from each referenced tsconfig
@@ -53,20 +48,11 @@ export function loadSourceFilesFromTsconfig(
 
     // Skip missing referenced tsconfig files
     if (!fs.existsSync(refPath)) {
-      if (debug) {
-        console.log(
-          pc.dim(" (warn)") +
-            pc.gray(` referenced tsconfig not found: ${refPath}`),
-        );
-      }
+      log("warn", `referenced tsconfig not found: ${refPath}`);
       continue;
     }
 
-    if (debug) {
-      console.log(
-        pc.dim(" (ref)") + pc.gray(` ${path.relative(process.cwd(), refPath)}`),
-      );
-    }
+    log("ref ", `${path.relative(process.cwd(), refPath)}`);
 
     const refProject = new Project({ tsConfigFilePath: refPath });
     collected.push(...refProject.getSourceFiles());

package/src/core/extract-usages/types.ts

@@ -22,6 +22,13 @@ interface SourceLocation {
   column: number;
 }
 
+/** Static translation prreKey usage extracted from a source file. */
+export interface PreKeyUsage
+  extends Omit<TranslatorBinding, "method">, SourceLocation {
+  localName: string;
+  preKey?: string;
+}
+
 /** Static translation key usage extracted from a source file. */
 export interface KeyUsage extends TranslatorBinding, SourceLocation {
   localName: string; // local binding name (e.g. `t`, `hasKey`)
@@ -47,7 +54,8 @@ export interface RichUsage extends TranslatorBinding, SourceLocation {
 
 /** Aggregated static translator usages extracted from a project. */
 export interface ExtractedUsages {
-  keys: KeyUsage[];
-  replacements: ReplacementUsage[];
+  preKey: PreKeyUsage[];
+  key: KeyUsage[];
+  replacement: ReplacementUsage[];
   rich: RichUsage[];
 }

package/src/features/check/check.ts

@@ -9,6 +9,7 @@ import {
 } from "../../core";
 import { printTitle } from "../../features/print-title";
 import { spinner } from "../spinner";
+import { dedupePreKeyUsages } from "./dedupe-pre-key-usages";
 import { printSummary } from "./print-summary";
 
 function resolveConfigKey(
@@ -50,10 +51,16 @@ export async function check(
 
       // per-config usages
       const scopedUsages = {
-        keys: usages.keys.filter(
+        preKey: dedupePreKeyUsages(
+          usages.preKey.filter(
+            (u) =>
+              resolveConfigKey(u.configKey, defaultConfigKey) === configKey,
+          ),
+        ),
+        key: usages.key.filter(
           (u) => resolveConfigKey(u.configKey, defaultConfigKey) === configKey,
         ),
-        replacements: usages.replacements.filter(
+        replacement: usages.replacement.filter(
           (u) => resolveConfigKey(u.configKey, defaultConfigKey) === configKey,
         ),
         rich: usages.rich.filter(

package/src/features/check/dedupe-pre-key-usages.ts

@@ -0,0 +1,25 @@
+import type { PreKeyUsage } from "../../core/extract-usages";
+
+/**
+ * Deduplicate preKey usages from the same translator factory call.
+ *
+ * A single factory call (e.g. `useTranslator("home")`) may expose
+ * multiple methods (`t`, `tRich`, ...).
+ *
+ * PreKey validation should happen once per factory call,
+ * not once per method, otherwise diagnostics would be duplicated.
+ */
+export function dedupePreKeyUsages(usages: PreKeyUsage[]): PreKeyUsage[] {
+  const seen = new Set<string>();
+
+  return usages.filter((u) => {
+    const sig = [u.factory, u.configKey, u.preKey, u.file, u.line].join("|");
+
+    if (seen.has(sig)) {
+      return false;
+    } else {
+      seen.add(sig);
+      return true;
+    }
+  });
+}

package/src/features/check/print-summary.ts

@@ -13,9 +13,9 @@ export function printSummary(configId: string, grouped: DiagnosticGroup[]) {
 
   // Log problems
   for (const group of grouped) {
-    const { method, messageKey, problems, file, lines } = group;
+    const { factory, method, messageKey, problems, file, lines } = group;
 
-    const header = `${messageKey} ${`(${method})`}\n`;
+    const header = `${messageKey} ${`(${method ?? factory})`}\n`;
 
     const problemsLine = [
       ...problems.map((p) => pc.gray(`   - ${p}`)),