@eslint-config-snapshot/api 0.9.0 → 0.14.1

package/dist/index.cjs

@@ -185,9 +185,11 @@ function lowestCommonAncestor(paths) {
 }
 
 // src/sampling.ts
+var import_debug = __toESM(require("debug"), 1);
 var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_picomatch2 = __toESM(require("picomatch"), 1);
+var debugSampling = (0, import_debug.default)("eslint-config-snapshot:sampling");
 async function sampleWorkspaceFiles(workspaceAbs, config) {
+  const startedAt = Date.now();
   const all = await (0, import_fast_glob.default)(config.includeGlobs, {
     cwd: workspaceAbs,
     ignore: config.excludeGlobs,
@@ -196,45 +198,46 @@ async function sampleWorkspaceFiles(workspaceAbs, config) {
     unique: true
   });
   const normalized = sortUnique(all.map((entry) => normalizePath(entry)));
+  debugSampling("workspace=%s candidates=%d", workspaceAbs, normalized.length);
   if (normalized.length === 0) {
     return [];
   }
   if (normalized.length <= config.maxFilesPerWorkspace) {
+    debugSampling("workspace=%s using all files=%d elapsedMs=%d", workspaceAbs, normalized.length, Date.now() - startedAt);
     return normalized;
   }
-  if (config.hintGlobs.length === 0) {
-    return selectDistributed(normalized, config.maxFilesPerWorkspace);
-  }
-  const hinted = normalized.filter((entry) => config.hintGlobs.some((pattern) => (0, import_picomatch2.default)(pattern, { dot: true })(entry)));
-  const notHinted = normalized.filter((entry) => !hinted.includes(entry));
-  return selectDistributed([...hinted, ...notHinted], config.maxFilesPerWorkspace);
-}
-function selectDistributed(files, count) {
+  const selected = selectDistributed(normalized, config.maxFilesPerWorkspace, config.tokenHints);
+  debugSampling(
+    "workspace=%s selected=%d mode=token-distributed elapsedMs=%d files=%o",
+    workspaceAbs,
+    selected.length,
+    Date.now() - startedAt,
+    selected
+  );
+  return selected;
+}
+function selectDistributed(files, count, tokenHints) {
   if (files.length <= count) {
     return files;
   }
+  const tokenPriorityMap = createTokenPriorityMap(tokenHints);
   const selected = [];
   const selectedSet = /* @__PURE__ */ new Set();
-  const tokenSeen = /* @__PURE__ */ new Set();
-  for (const file of files) {
-    if (selected.length >= count) {
-      break;
-    }
-    const token = getPrimaryToken(file);
-    if (!token || tokenSeen.has(token)) {
-      continue;
-    }
-    tokenSeen.add(token);
-    selected.push(file);
-    selectedSet.add(file);
-  }
+  const preferred = files.filter((file) => isPreferredForLintSampling(file));
+  const nonPreferred = files.filter((file) => !isPreferredForLintSampling(file));
+  appendTokenRepresentatives(preferred, tokenPriorityMap, selected, selectedSet, count);
+  appendTokenRepresentatives(nonPreferred, tokenPriorityMap, selected, selectedSet, count);
   if (selected.length >= count) {
     return sortUnique(selected).slice(0, count);
   }
   const remaining = files.filter((file) => !selectedSet.has(file));
   const needed = count - selected.length;
-  const spaced = pickUniformly(remaining, needed);
-  return sortUnique([...selected, ...spaced]).slice(0, count);
+  const preferredRemaining = remaining.filter((file) => isPreferredForLintSampling(file));
+  const nonPreferredRemaining = remaining.filter((file) => !isPreferredForLintSampling(file));
+  const preferredPicked = pickUniformly(preferredRemaining, needed);
+  const afterPreferredNeed = needed - preferredPicked.length;
+  const fallbackPicked = afterPreferredNeed > 0 ? pickUniformly(nonPreferredRemaining, afterPreferredNeed) : [];
+  return sortUnique([...selected, ...preferredPicked, ...fallbackPicked]).slice(0, count);
 }
 function pickUniformly(files, count) {
   if (count <= 0 || files.length === 0) {
@@ -248,14 +251,60 @@ function pickUniformly(files, count) {
   }
   const picked = [];
   const usedIndices = /* @__PURE__ */ new Set();
-  for (let index = 0; index < count; index += 1) {
-    const raw = Math.round(index * (files.length - 1) / (count - 1));
-    const safeIndex = nextFreeIndex(raw, usedIndices, files.length);
+  if (count >= 3) {
+    const anchorIndices = [0, Math.floor((files.length - 1) / 2), files.length - 1];
+    for (const anchorIndex of anchorIndices) {
+      if (picked.length >= count || usedIndices.has(anchorIndex)) {
+        continue;
+      }
+      usedIndices.add(anchorIndex);
+      const anchored = files[anchorIndex];
+      if (anchored !== void 0) {
+        picked.push(anchored);
+      }
+    }
+  }
+  for (const candidate of buildDistributedCandidates(files.length, count)) {
+    if (picked.length >= count) {
+      break;
+    }
+    const safeIndex = nextFreeIndex(candidate, usedIndices, files.length);
+    if (usedIndices.has(safeIndex)) {
+      continue;
+    }
     usedIndices.add(safeIndex);
-    picked.push(files[safeIndex]);
+    const selected = files[safeIndex];
+    if (selected !== void 0) {
+      picked.push(selected);
+    }
+  }
+  if (picked.length < count) {
+    for (let index = 0; index < files.length && picked.length < count; index += 1) {
+      if (usedIndices.has(index)) {
+        continue;
+      }
+      usedIndices.add(index);
+      const fallback = files[index];
+      if (fallback !== void 0) {
+        picked.push(fallback);
+      }
+    }
   }
   return picked;
 }
+function buildDistributedCandidates(length, count) {
+  if (length <= 0 || count <= 0) {
+    return [];
+  }
+  if (count === 1) {
+    return [0];
+  }
+  const candidates = [];
+  for (let index = 0; index < count; index += 1) {
+    candidates.push(Math.round(index * (length - 1) / (count - 1)));
+  }
+  return candidates;
+}
 function nextFreeIndex(candidate, used, max) {
   if (!used.has(candidate)) {
     return candidate;
@@ -272,25 +321,257 @@ function nextFreeIndex(candidate, used, max) {
   }
   return candidate;
 }
-function getPrimaryToken(file) {
-  const parts = file.split("/");
-  const basename = parts.slice(-1)[0];
-  if (!basename) {
+function getPrimaryToken(file, tokenPriorityMap) {
+  const parts = file.split("/").filter((entry) => entry.length > 0);
+  if (parts.length === 0) {
+    return null;
+  }
+  const basename = parts[parts.length - 1];
+  if (basename === void 0) {
     return null;
   }
-  const nameOnly = basename.replace(/\.[^.]+$/u, "");
-  const expanded = nameOnly.replaceAll(/([a-z])([A-Z])/gu, "$1 $2").replaceAll(/[_\-.]+/gu, " ").toLowerCase();
-  const token = expanded.split(/\s+/u).find((entry) => entry.length > 1 && !GENERIC_TOKENS.has(entry));
-  return token ?? null;
+  const basenameTokens = tokenizePathPart(basename, true);
+  const directoryTokensForward = parts.slice(0, -1).flatMap((entry) => tokenizePathPart(entry, false));
+  const directoryTokens = [];
+  for (let index = directoryTokensForward.length - 1; index >= 0; index -= 1) {
+    const token = directoryTokensForward[index];
+    if (token !== void 0) {
+      directoryTokens.push(token);
+    }
+  }
+  const allTokens = [...basenameTokens, ...directoryTokens].filter((entry) => entry.length > 1);
+  const bestKnownToken = pickBestKnownToken(allTokens, tokenPriorityMap);
+  if (bestKnownToken !== null) {
+    return bestKnownToken;
+  }
+  const fallback = allTokens.find((entry) => !GENERIC_TOKENS.has(entry));
+  return fallback ?? null;
+}
+function tokenizePathPart(part, stripExtension) {
+  const normalized = stripExtension ? part.replace(/\.[^.]+$/u, "") : part;
+  const expanded = normalized.replaceAll(/([a-z])([A-Z])/gu, "$1 $2").replaceAll(/[_\-.]+/gu, " ").toLowerCase();
+  return expanded.split(/\s+/u).filter((entry) => entry.length > 0);
+}
+function pickBestKnownToken(tokens, tokenPriorityMap) {
+  let bestToken = null;
+  let bestGroupPriority = Number.POSITIVE_INFINITY;
+  for (const token of tokens) {
+    const normalizedToken = normalizeToken(token);
+    const groupPriority = tokenPriorityMap.get(normalizedToken);
+    if (groupPriority === void 0) {
+      continue;
+    }
+    if (groupPriority < bestGroupPriority) {
+      bestGroupPriority = groupPriority;
+      bestToken = normalizedToken;
+    }
+  }
+  return bestToken;
+}
+function normalizeToken(token) {
+  if (token.endsWith("ies") && token.length > 3) {
+    return `${token.slice(0, -3)}y`;
+  }
+  if (token.endsWith("s") && token.length > 3) {
+    return token.slice(0, -1);
+  }
+  return token;
+}
+function isPreferredForLintSampling(file) {
+  return CODE_PREFERRED_EXTENSIONS.has(getExtension(file));
+}
+function getExtension(file) {
+  const lastDot = file.lastIndexOf(".");
+  if (lastDot === -1 || lastDot === file.length - 1) {
+    return "";
+  }
+  return file.slice(lastDot + 1).toLowerCase();
 }
 var GENERIC_TOKENS = /* @__PURE__ */ new Set(["src", "index", "main", "test", "spec", "package", "packages", "lib", "dist"]);
+var CODE_PREFERRED_EXTENSIONS = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "cjs", "mjs"]);
+var DEFAULT_TOKEN_HINT_GROUPS = [
+  [
+    "chunk",
+    "conf",
+    "config",
+    "container",
+    "controller",
+    "helpers",
+    "mock",
+    "mocks",
+    "presentation",
+    "repository",
+    "route",
+    "routes",
+    "schema",
+    "setup",
+    "spec",
+    "stories",
+    "style",
+    "styles",
+    "test",
+    "type",
+    "types",
+    "utils",
+    "view",
+    "views"
+  ],
+  [
+    "adapter",
+    "api",
+    "apis",
+    "builder",
+    "client",
+    "component",
+    "components",
+    "constants",
+    "context",
+    "core",
+    "dto",
+    "entity",
+    "entry",
+    "env",
+    "factory",
+    "fetcher",
+    "handler",
+    "hook",
+    "hooks",
+    "init",
+    "integration",
+    "interceptor",
+    "interface",
+    "layout",
+    "layouts",
+    "listener",
+    "logger",
+    "manager",
+    "mapper",
+    "meta",
+    "middleware",
+    "model",
+    "module",
+    "normalizer",
+    "options",
+    "page",
+    "pages",
+    "parser",
+    "plugin",
+    "provider",
+    "registry",
+    "resolver",
+    "router",
+    "runtime",
+    "serializer",
+    "server",
+    "service",
+    "settings",
+    "shared",
+    "slice",
+    "state",
+    "store",
+    "subscriber",
+    "theme",
+    "tracker",
+    "transform",
+    "unit",
+    "validator"
+  ],
+  [
+    "base",
+    "bundle",
+    "common",
+    "compiler",
+    "contract",
+    "definition",
+    "definitions",
+    "deserializer",
+    "event",
+    "events",
+    "fixture",
+    "fixtures",
+    "guard",
+    "internal",
+    "loader",
+    "publisher",
+    "reducer",
+    "stub",
+    "stubs",
+    "tests",
+    "util"
+  ]
+];
+function createTokenPriorityMap(input) {
+  const groups = normalizeTokenHintGroups(input);
+  const entries = [];
+  for (const [index, group] of groups.entries()) {
+    entries.push(...toPriorityEntries(group, index + 1));
+  }
+  return new Map(entries);
+}
+function normalizeTokenHintGroups(input) {
+  if (!input || input.length === 0) {
+    return DEFAULT_TOKEN_HINT_GROUPS.map((group) => [...group]);
+  }
+  if (Array.isArray(input[0])) {
+    const nested = input;
+    return nested.map((group) => group.filter((token) => token.trim().length > 0));
+  }
+  const flat = input;
+  return [flat.filter((token) => token.trim().length > 0)];
+}
+function toPriorityEntries(tokens, priority) {
+  return tokens.map((token) => [normalizeToken(token), priority]);
+}
+function appendTokenRepresentatives(files, tokenPriorityMap, selected, selectedSet, count) {
+  if (selected.length >= count || files.length === 0) {
+    return;
+  }
+  const tokenToFiles = /* @__PURE__ */ new Map();
+  const tokenFirstIndex = /* @__PURE__ */ new Map();
+  for (const [index, file] of files.entries()) {
+    const token = getPrimaryToken(file, tokenPriorityMap);
+    if (!token) {
+      continue;
+    }
+    tokenFirstIndex.set(token, Math.min(tokenFirstIndex.get(token) ?? Number.POSITIVE_INFINITY, index));
+    const current = tokenToFiles.get(token) ?? [];
+    current.push(file);
+    tokenToFiles.set(token, current);
+  }
+  const orderedTokens = [...tokenToFiles.keys()].sort((left, right) => {
+    const leftPriority = tokenPriorityMap.get(left) ?? Number.POSITIVE_INFINITY;
+    const rightPriority = tokenPriorityMap.get(right) ?? Number.POSITIVE_INFINITY;
+    if (leftPriority !== rightPriority) {
+      return leftPriority - rightPriority;
+    }
+    const leftIndex = tokenFirstIndex.get(left) ?? Number.POSITIVE_INFINITY;
+    const rightIndex = tokenFirstIndex.get(right) ?? Number.POSITIVE_INFINITY;
+    if (leftIndex !== rightIndex) {
+      return leftIndex - rightIndex;
+    }
+    return left.localeCompare(right);
+  });
+  for (const token of orderedTokens) {
+    if (selected.length >= count) {
+      break;
+    }
+    const firstFile = tokenToFiles.get(token)?.[0];
+    if (!firstFile || selectedSet.has(firstFile)) {
+      continue;
+    }
+    selected.push(firstFile);
+    selectedSet.add(firstFile);
+  }
+}
 
 // src/extract.ts
+var import_debug2 = __toESM(require("debug"), 1);
 var import_node_child_process = require("child_process");
 var import_node_fs = require("fs");
 var import_node_module = require("module");
 var import_node_path2 = __toESM(require("path"), 1);
 var import_node_url = require("url");
+var debugExtract = (0, import_debug2.default)("eslint-config-snapshot:extract");
 function resolveEslintBinForWorkspace(workspaceAbs) {
   const anchor = import_node_path2.default.join(workspaceAbs, "__snapshot_anchor__.cjs");
   const req = (0, import_node_module.createRequire)(anchor);
@@ -337,11 +618,16 @@ function findPackageRoot(entryAbs) {
 }
 function extractRulesFromPrintConfig(workspaceAbs, fileAbs) {
   const eslintBin = resolveEslintBinForWorkspace(workspaceAbs);
+  const commandArgs = [eslintBin, "--print-config", fileAbs];
+  const startedAt = Date.now();
+  debugExtract("spawn: cwd=%s cmd=%s %o", workspaceAbs, process.execPath, commandArgs);
   const proc = (0, import_node_child_process.spawnSync)(process.execPath, [eslintBin, "--print-config", fileAbs], {
     cwd: workspaceAbs,
     encoding: "utf8"
   });
+  debugExtract("spawn: done status=%s elapsedMs=%d", String(proc.status), Date.now() - startedAt);
   if (proc.status !== 0) {
+    debugExtract("spawn: stderr=%s", proc.stderr.trim());
     throw new Error(`Failed to run eslint --print-config for ${fileAbs}`);
   }
   const stdout = proc.stdout.trim();
@@ -371,6 +657,7 @@ function resolveEslintVersionForWorkspace(workspaceAbs) {
   return "unknown";
 }
 async function extractRulesForWorkspaceSamples(workspaceAbs, fileAbsList) {
+  debugExtract("workspace=%s sampleCount=%d", workspaceAbs, fileAbsList.length);
   const evaluate = await createWorkspaceEvaluator(workspaceAbs);
   const results = [];
   for (const fileAbs of fileAbsList) {
@@ -379,9 +666,16 @@ async function extractRulesForWorkspaceSamples(workspaceAbs, fileAbsList) {
       results.push({ fileAbs, rules });
     } catch (error) {
       const normalizedError = error instanceof Error ? error : new Error(String(error));
+      debugExtract("extract failed: workspace=%s file=%s error=%s", workspaceAbs, fileAbs, normalizedError.message);
       results.push({ fileAbs, error: normalizedError });
     }
   }
+  debugExtract(
+    "workspace=%s extracted=%d failed=%d",
+    workspaceAbs,
+    results.filter((entry) => entry.rules !== void 0).length,
+    results.filter((entry) => entry.error !== void 0).length
+  );
   return results;
 }
 async function createWorkspaceEvaluator(workspaceAbs) {
@@ -392,6 +686,7 @@ async function createWorkspaceEvaluator(workspaceAbs) {
     const eslintModule = await import((0, import_node_url.pathToFileURL)(eslintModuleEntry).href);
     const ESLintClass = eslintModule.ESLint ?? eslintModule.default?.ESLint;
     if (ESLintClass) {
+      debugExtract("workspace=%s evaluator=eslint-api", workspaceAbs);
       const eslint = new ESLintClass({ cwd: workspaceAbs });
       return async (fileAbs) => {
         const config = await eslint.calculateConfigForFile(fileAbs);
@@ -403,6 +698,7 @@ async function createWorkspaceEvaluator(workspaceAbs) {
     }
   } catch {
   }
+  debugExtract("workspace=%s evaluator=spawn-print-config", workspaceAbs);
   return (fileAbs) => Promise.resolve(extractRulesFromPrintConfig(workspaceAbs, fileAbs));
 }
 function normalizeRules(rules) {
@@ -437,45 +733,27 @@ function aggregateRules(ruleMaps) {
   const aggregated = /* @__PURE__ */ new Map();
   for (const rules of ruleMaps) {
     for (const [ruleName, nextEntry] of rules.entries()) {
-      const currentEntry = aggregated.get(ruleName);
-      if (!currentEntry) {
-        aggregated.set(ruleName, canonicalizeJson(nextEntry));
-        continue;
-      }
-      const severityCmp = compareSeverity(nextEntry[0], currentEntry[0]);
-      if (severityCmp > 0) {
-        aggregated.set(ruleName, canonicalizeJson(nextEntry));
-        continue;
-      }
-      if (severityCmp < 0) {
-        continue;
-      }
-      const currentOptions = currentEntry.length > 1 ? canonicalizeJson(currentEntry[1]) : void 0;
-      const nextOptions = nextEntry.length > 1 ? canonicalizeJson(nextEntry[1]) : void 0;
-      if (currentOptions === void 0 && nextOptions !== void 0) {
-        aggregated.set(ruleName, canonicalizeJson(nextEntry));
-        continue;
-      }
-      if (currentOptions !== void 0 && nextOptions === void 0) {
-        continue;
-      }
-      if (currentOptions === void 0 && nextOptions === void 0) {
-        continue;
-      }
-      const currentJson = JSON.stringify(currentOptions);
-      const nextJson = JSON.stringify(nextOptions);
-      if (nextJson < currentJson) {
-        aggregated.set(ruleName, canonicalizeJson(nextEntry));
-      }
+      const normalizedEntry = canonicalizeJson(nextEntry);
+      const variantKey = toVariantKey(normalizedEntry);
+      const variants = aggregated.get(ruleName) ?? /* @__PURE__ */ new Map();
+      variants.set(variantKey, normalizedEntry);
+      aggregated.set(ruleName, variants);
     }
   }
-  return new Map([...aggregated.entries()].sort(([a], [b]) => a.localeCompare(b)));
+  const entries = [...aggregated.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([ruleName, variants]) => {
+    const sortedVariants = [...variants.values()].sort(compareVariants);
+    if (sortedVariants.length === 1) {
+      return [ruleName, sortedVariants[0]];
+    }
+    return [ruleName, sortedVariants];
+  });
+  return new Map(entries);
 }
 function buildSnapshot(groupId, workspaces, rules) {
   const sortedRules = [...rules.entries()].sort(([a], [b]) => a.localeCompare(b));
   const rulesObject = {};
   for (const [name, config] of sortedRules) {
-    rulesObject[name] = canonicalizeJson(config);
+    rulesObject[name] = isSingleRuleEntry(config) ? canonicalizeJson(config) : config.map((variant) => canonicalizeJson(variant)).sort(compareVariants);
   }
   return {
     formatVersion: 1,
@@ -497,6 +775,17 @@ async function readSnapshotFile(fileAbs) {
   const raw = await (0, import_promises.readFile)(fileAbs, "utf8");
   return JSON.parse(raw);
 }
+function toVariantKey(entry) {
+  return JSON.stringify(canonicalizeJson(entry));
+}
+function compareVariants(a, b) {
+  const aJson = JSON.stringify(canonicalizeJson(a));
+  const bJson = JSON.stringify(canonicalizeJson(b));
+  return aJson.localeCompare(bJson);
+}
+function isSingleRuleEntry(entry) {
+  return !Array.isArray(entry[0]);
+}
 
 // src/diff.ts
 function diffSnapshots(before, after) {
@@ -511,32 +800,51 @@ function diffSnapshots(before, after) {
   for (const name of beforeNames.filter((entry) => afterNames.includes(entry))) {
     const oldEntry = beforeRules[name];
     const newEntry = afterRules[name];
-    if (oldEntry[0] !== newEntry[0]) {
+    const oldVariants = toVariants(oldEntry);
+    const newVariants = toVariants(newEntry);
+    const oldSeverity = summarizeSeveritySet(oldVariants);
+    const newSeverity = summarizeSeveritySet(newVariants);
+    if (oldSeverity !== newSeverity) {
       severityChanges.push({
         rule: name,
-        before: oldEntry[0],
-        after: newEntry[0]
+        before: oldSeverity,
+        after: newSeverity
       });
     }
-    const oldOptions = oldEntry.length > 1 ? canonicalizeJson(oldEntry[1]) : void 0;
-    const newOptions = newEntry.length > 1 ? canonicalizeJson(newEntry[1]) : void 0;
-    if (oldEntry[0] === "off" || newEntry[0] === "off") {
-      if (oldEntry[0] === "off" && newEntry[0] === "off") {
-        if (oldOptions !== void 0 && newOptions === void 0) {
+    const oldSerialized = JSON.stringify(oldVariants);
+    const newSerialized = JSON.stringify(newVariants);
+    if (oldSerialized === newSerialized) {
+      continue;
+    }
+    const oldIsOnlyOff = oldVariants.every((entry) => entry[0] === "off");
+    const newIsOnlyOff = newVariants.every((entry) => entry[0] === "off");
+    if (oldIsOnlyOff || newIsOnlyOff) {
+      if (oldIsOnlyOff && newIsOnlyOff) {
+        const oldHasOptions = oldVariants.some((variant) => variant.length > 1);
+        const newHasOptions = newVariants.some((variant) => variant.length > 1);
+        if (oldHasOptions && !newHasOptions) {
           removedRules.push(name);
-        } else if (oldOptions === void 0 && newOptions !== void 0) {
+        } else if (!oldHasOptions && newHasOptions) {
           introducedRules.push(name);
+        } else if (oldVariants.length > newVariants.length) {
+          removedRules.push(name);
+        } else if (oldVariants.length < newVariants.length) {
+          introducedRules.push(name);
+        } else {
+          optionChanges.push({
+            rule: name,
+            before: oldVariants,
+            after: newVariants
+          });
         }
       }
       continue;
     }
-    if (JSON.stringify(oldOptions) !== JSON.stringify(newOptions)) {
-      optionChanges.push({
-        rule: name,
-        before: oldOptions,
-        after: newOptions
-      });
-    }
+    optionChanges.push({
+      rule: name,
+      before: oldVariants,
+      after: newVariants
+    });
   }
   const beforeWorkspaces = sortUnique(before.workspaces);
   const afterWorkspaces = sortUnique(after.workspaces);
@@ -551,6 +859,17 @@ function diffSnapshots(before, after) {
     }
   };
 }
+function toVariants(entry) {
+  if (!Array.isArray(entry[0])) {
+    return [canonicalizeJson(entry)];
+  }
+  return entry.map((variant) => canonicalizeJson(variant));
+}
+function summarizeSeveritySet(variants) {
+  const severityOrder = ["error", "warn", "off"];
+  const severities = new Set(variants.map((variant) => variant[0]));
+  return severityOrder.filter((severity) => severities.has(severity)).join("|");
+}
 function hasDiff(diff) {
   return diff.introducedRules.length > 0 || diff.removedRules.length > 0 || diff.severityChanges.length > 0 || diff.optionChanges.length > 0 || diff.workspaceMembershipChanges.added.length > 0 || diff.workspaceMembershipChanges.removed.length > 0;
 }
@@ -565,10 +884,9 @@ var DEFAULT_CONFIG = {
     groups: [{ name: "default", match: ["**/*"] }]
   },
   sampling: {
-    maxFilesPerWorkspace: 8,
-    includeGlobs: ["**/*.{js,jsx,ts,tsx,cjs,mjs}"],
-    excludeGlobs: ["**/node_modules/**", "**/dist/**"],
-    hintGlobs: []
+    maxFilesPerWorkspace: 10,
+    includeGlobs: ["**/*.{js,jsx,ts,tsx,cjs,mjs,md,mdx,json,css}"],
+    excludeGlobs: ["**/node_modules/**", "**/dist/**"]
   }
 };
 var SPEC_SEARCH_PLACES = [
@@ -643,10 +961,35 @@ function getConfigScaffold(preset = "minimal") {
     groups: [{ name: 'default', match: ['**/*'] }]
   },
   sampling: {
-    maxFilesPerWorkspace: 8,
-    includeGlobs: ['**/*.{js,jsx,ts,tsx,cjs,mjs}'],
+    maxFilesPerWorkspace: 10,
+    includeGlobs: ['**/*.{js,jsx,ts,tsx,cjs,mjs,md,mdx,json,css}'],
     excludeGlobs: ['**/node_modules/**', '**/dist/**'],
-    hintGlobs: []
+    tokenHints: [
+      'chunk',
+      'conf',
+      'config',
+      'container',
+      'controller',
+      'helpers',
+      'mock',
+      'mocks',
+      'presentation',
+      'repository',
+      'route',
+      'routes',
+      'schema',
+      'setup',
+      'spec',
+      'stories',
+      'style',
+      'styles',
+      'test',
+      'type',
+      'types',
+      'utils',
+      'view',
+      'views'
+    ]
   }
 }
 `;