@eslint-config-snapshot/cli 1.0.0 → 1.1.1

package/dist/index.js

@@ -3,10 +3,10 @@
 // src/index.ts
 import { Command, CommanderError, InvalidArgumentError } from "commander";
 import createDebug2 from "debug";
-import path4 from "path";
+import path5 from "path";
 
 // src/commands/check.ts
-import { findConfigPath } from "@eslint-config-snapshot/api";
+import { DEFAULT_CONFIG, findConfigPath } from "@eslint-config-snapshot/api";
 
 // src/formatters.ts
 function formatDiff(groupId, diff) {
@@ -181,6 +181,12 @@ function formatStoredSnapshotSummary(storedSnapshots) {
   const summary = summarizeSnapshots(storedSnapshots);
   return `${summary.groups} groups, ${summary.rules} rules (severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off)`;
 }
+function formatBaselineSummaryLines(summary, workspaceCount) {
+  return `- \u{1F4E6} baseline: ${summary.groups} groups, ${summary.rules} rules
+- \u{1F5C2}\uFE0F workspaces scanned: ${workspaceCount}
+- \u{1F39A}\uFE0F severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off
+`;
+}
 function countRuleSeverities(ruleObjects) {
   let rules = 0;
   let error = 0;
@@ -373,19 +379,24 @@ import path2 from "path";
 var debugWorkspace = createDebug("eslint-config-snapshot:workspace");
 var debugDiff = createDebug("eslint-config-snapshot:diff");
 var debugTiming = createDebug("eslint-config-snapshot:timing");
-async function computeCurrentSnapshots(cwd) {
+async function computeCurrentSnapshots(cwd, options) {
+  const allowWorkspaceExtractionFailure = options?.allowWorkspaceExtractionFailure ?? false;
+  const onWorkspacesDiscovered = options?.onWorkspacesDiscovered;
+  const onWorkspaceSkipped = options?.onWorkspaceSkipped;
   const computeStartedAt = Date.now();
   const configStartedAt = Date.now();
   const config = await loadConfig(cwd);
   debugTiming("phase=loadConfig elapsedMs=%d", Date.now() - configStartedAt);
   const assignmentStartedAt = Date.now();
   const { discovery, assignments } = await resolveWorkspaceAssignments(cwd, config);
+  onWorkspacesDiscovered?.(discovery.workspacesRel);
   debugTiming("phase=resolveWorkspaceAssignments elapsedMs=%d", Date.now() - assignmentStartedAt);
   debugWorkspace("root=%s groups=%d workspaces=%d", discovery.rootAbs, assignments.length, discovery.workspacesRel.length);
   const snapshots = /* @__PURE__ */ new Map();
   for (const group of assignments) {
     const groupStartedAt = Date.now();
     const extractedForGroup = [];
+    const extractedWorkspaces = [];
     debugWorkspace("group=%s workspaces=%o", group.name, group.workspaces);
     for (const workspaceRel of group.workspaces) {
       const workspaceAbs = path2.resolve(discovery.rootAbs, workspaceRel);
@@ -418,7 +429,7 @@ async function computeCurrentSnapshots(cwd) {
           continue;
         }
         const message = result.error instanceof Error ? result.error.message : String(result.error);
-        if (isRecoverableExtractionError(message)) {
+        if (isRecoverableExtractionError(message) || allowWorkspaceExtractionFailure) {
           lastExtractionError = message;
           continue;
         }
@@ -426,10 +437,23 @@ async function computeCurrentSnapshots(cwd) {
       }
       if (extractedCount === 0) {
         const context = lastExtractionError ? ` Last error: ${lastExtractionError}` : "";
-        throw new Error(
-          `Unable to extract ESLint config for workspace ${workspaceRel}. All sampled files were ignored or produced non-JSON output.${context}`
-        );
+        if (allowWorkspaceExtractionFailure && isSkippableWorkspaceExtractionFailure(lastExtractionError)) {
+          onWorkspaceSkipped?.({
+            groupId: group.name,
+            workspaceRel,
+            reason: lastExtractionError ?? "unknown extraction failure"
+          });
+          debugWorkspace(
+            "group=%s workspace=%s skipped=true reason=%s",
+            group.name,
+            workspaceRel,
+            lastExtractionError ?? "unknown extraction failure"
+          );
+          continue;
+        }
+        throw new Error(`Unable to extract ESLint config for workspace ${workspaceRel}.${context}`);
       }
+      extractedWorkspaces.push(workspaceRel);
       debugWorkspace(
         "group=%s workspace=%s extracted=%d failed=%d",
         group.name,
@@ -438,8 +462,15 @@ async function computeCurrentSnapshots(cwd) {
         results.length - extractedCount
       );
     }
+    if (extractedForGroup.length === 0) {
+      if (allowWorkspaceExtractionFailure) {
+        debugWorkspace("group=%s skipped=true reason=no-extracted-workspaces", group.name);
+        continue;
+      }
+      throw new Error(`Unable to extract ESLint config for group ${group.name}: no workspace produced a valid config`);
+    }
     const aggregated = aggregateRules(extractedForGroup);
-    snapshots.set(group.name, buildSnapshot(group.name, group.workspaces, aggregated));
+    snapshots.set(group.name, buildSnapshot(group.name, extractedWorkspaces, aggregated));
     debugWorkspace(
       "group=%s aggregatedRules=%d groupElapsedMs=%d",
       group.name,
@@ -448,11 +479,20 @@ async function computeCurrentSnapshots(cwd) {
     );
   }
   debugTiming("phase=computeCurrentSnapshots elapsedMs=%d", Date.now() - computeStartedAt);
+  if (snapshots.size === 0) {
+    throw new Error("Unable to extract ESLint config from discovered workspaces in zero-config mode");
+  }
   return snapshots;
 }
 function isRecoverableExtractionError(message) {
   return message.startsWith("Invalid JSON from eslint --print-config") || message.startsWith("Empty ESLint print-config output") || message.includes("File ignored because of a matching ignore pattern") || message.includes("File ignored by default");
 }
+function isSkippableWorkspaceExtractionFailure(message) {
+  if (!message) {
+    return true;
+  }
+  return isRecoverableExtractionError(message) || message.startsWith("Failed to load config") || message.startsWith("Failed to run eslint --print-config") || message.startsWith("Unable to resolve eslint from workspace");
+}
 async function resolveWorkspaceAssignments(cwd, config) {
   const discovery = await discoverWorkspaces({ cwd, workspaceInput: config.workspaceInput });
   const assignments = config.grouping.mode === "standalone" ? discovery.workspacesRel.map((workspace) => ({ name: workspace, workspaces: [workspace] })) : assignGroupsByMatch(discovery.workspacesRel, config.grouping.groups ?? [{ name: "default", match: ["**/*"] }]);
@@ -522,6 +562,63 @@ async function resolveGroupEslintVersions(cwd) {
   return result;
 }
 
+// src/commands/skipped-workspaces.ts
+import path3 from "path";
+function writeSkippedWorkspaceSummary(terminal, cwd, configPath, skippedWorkspaces) {
+  if (skippedWorkspaces.length === 0) {
+    return;
+  }
+  const workspacePaths = collectSkippedWorkspacePaths(skippedWorkspaces);
+  terminal.warning(
+    `Heads up: ${workspacePaths.length} workspace(s) were skipped because ESLint auto-discovery could not extract an effective config for them.
+`
+  );
+  terminal.warning(`Skipped workspaces: ${workspacePaths.join(", ")}
+`);
+  terminal.subtle(formatScopedConfigHint(cwd, configPath, workspacePaths));
+}
+function collectSkippedWorkspacePaths(skippedWorkspaces) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const skipped of skippedWorkspaces) {
+    unique.add(skipped.workspaceRel);
+  }
+  return [...unique].sort();
+}
+function toExcludeGlobs(workspacePaths) {
+  return workspacePaths.map((workspacePath) => `${workspacePath}/**`);
+}
+function formatScopedConfigHint(cwd, configPath, workspacePaths) {
+  const excludeGlobs = toExcludeGlobs(workspacePaths);
+  if (configPath && path3.basename(configPath) === "package.json") {
+    return `Tip: if these workspaces are intentionally out of scope, add this under "eslint-config-snapshot" in package.json:
+${JSON.stringify(
+      {
+        sampling: {
+          excludeGlobs
+        }
+      },
+      null,
+      2
+    )}
+`;
+  }
+  const objectLiteral = `{
+  sampling: {
+    excludeGlobs: [
+${excludeGlobs.map((value) => `      '${value}'`).join(",\n")}
+    ]
+  }
+}
+`;
+  if (configPath) {
+    const relConfigPath = path3.relative(cwd, configPath) || path3.basename(configPath);
+    return `Tip: if these workspaces are intentionally out of scope, add this in ${relConfigPath}:
+${objectLiteral}`;
+  }
+  return `Tip: if these workspaces are intentionally out of scope, run \`eslint-config-snapshot init\` and add this config:
+${objectLiteral}`;
+}
+
 // src/commands/check.ts
 var UPDATE_HINT = "Tip: when you intentionally accept changes, run `eslint-config-snapshot --update` to refresh the baseline.\n";
 async function executeCheck(cwd, format, terminal, snapshotDir, defaultInvocation = false) {
@@ -539,10 +636,21 @@ async function executeCheck(cwd, format, terminal, snapshotDir, defaultInvocatio
     );
   }
   let currentSnapshots;
+  const skippedWorkspaces = [];
+  let discoveredWorkspaces = [];
+  const allowWorkspaceExtractionFailure = !foundConfig || isDefaultEquivalentConfig(foundConfig.config);
   try {
-    currentSnapshots = await computeCurrentSnapshots(cwd);
+    currentSnapshots = await computeCurrentSnapshots(cwd, {
+      allowWorkspaceExtractionFailure,
+      onWorkspacesDiscovered: (workspacesRel) => {
+        discoveredWorkspaces = workspacesRel;
+      },
+      onWorkspaceSkipped: (skipped) => {
+        skippedWorkspaces.push(skipped);
+      }
+    });
   } catch (error) {
-    if (!foundConfig) {
+    if (!foundConfig && isWorkspaceDiscoveryDefaultsError(error)) {
       terminal.write(
         "Automatic workspace discovery could not complete with defaults.\nRun `eslint-config-snapshot init` to configure workspaces, then run `eslint-config-snapshot --update`.\n"
       );
@@ -550,6 +658,10 @@ async function executeCheck(cwd, format, terminal, snapshotDir, defaultInvocatio
     }
     throw error;
   }
+  if (!foundConfig) {
+    writeDiscoveredWorkspacesSummary(terminal, discoveredWorkspaces);
+  }
+  writeSkippedWorkspaceSummary(terminal, cwd, foundConfig?.path, skippedWorkspaces);
   if (storedSnapshots.size === 0) {
     const summary = summarizeSnapshots(currentSnapshots);
     terminal.write(
@@ -609,12 +721,7 @@ function printWhatChanged(terminal, changes, currentSnapshots, eslintVersionsByG
   if (changes.length === 0) {
     terminal.write(color.green("\u2705 Great news: no snapshot drift detected.\n"));
     terminal.section("\u{1F4CA} Summary");
-    terminal.write(
-      `- \u{1F4E6} baseline: ${currentSummary.groups} groups, ${currentSummary.rules} rules
-- \u{1F5C2}\uFE0F workspaces scanned: ${workspaceCount}
-- \u{1F39A}\uFE0F severity mix: ${currentSummary.error} errors, ${currentSummary.warn} warnings, ${currentSummary.off} off
-`
-    );
+    terminal.write(formatBaselineSummaryLines(currentSummary, workspaceCount));
     writeEslintVersionSummary(terminal, eslintVersionsByGroup);
     return 0;
   }
@@ -649,9 +756,24 @@ function printWhatChanged(terminal, changes, currentSnapshots, eslintVersionsByG
   terminal.subtle(UPDATE_HINT);
   return 1;
 }
+function isWorkspaceDiscoveryDefaultsError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Unable to discover workspaces") || message.includes("Unmatched workspaces") || message.includes("zero-config mode");
+}
+function isDefaultEquivalentConfig(config) {
+  return JSON.stringify(config) === JSON.stringify(DEFAULT_CONFIG);
+}
+function writeDiscoveredWorkspacesSummary(terminal, workspacesRel) {
+  if (workspacesRel.length === 0) {
+    terminal.subtle("Auto-discovered workspaces: none\n");
+    return;
+  }
+  terminal.subtle(`Auto-discovered workspaces (${workspacesRel.length}): ${workspacesRel.join(", ")}
+`);
+}
 
 // src/commands/print.ts
-import { findConfigPath as findConfigPath2, loadConfig as loadConfig2 } from "@eslint-config-snapshot/api";
+import { DEFAULT_CONFIG as DEFAULT_CONFIG2, findConfigPath as findConfigPath2, loadConfig as loadConfig2 } from "@eslint-config-snapshot/api";
 async function executePrint(cwd, terminal, snapshotDir, format) {
   const foundConfig = await findConfigPath2(cwd);
   const storedSnapshots = await loadStoredSnapshots(cwd, snapshotDir);
@@ -659,7 +781,8 @@ async function executePrint(cwd, terminal, snapshotDir, format) {
   if (terminal.showProgress) {
     terminal.subtle("\u{1F50E} Checking current ESLint configuration...\n");
   }
-  const currentSnapshots = await computeCurrentSnapshots(cwd);
+  const allowWorkspaceExtractionFailure = !foundConfig || isDefaultEquivalentConfig2(foundConfig.config);
+  const currentSnapshots = await computeCurrentSnapshots(cwd, { allowWorkspaceExtractionFailure });
   if (format === "short") {
     terminal.write(formatShortPrint([...currentSnapshots.values()]));
     return;
@@ -698,9 +821,12 @@ async function executeConfig(cwd, terminal, snapshotDir, format) {
   terminal.write(`${JSON.stringify(payload, null, 2)}
 `);
 }
+function isDefaultEquivalentConfig2(config) {
+  return JSON.stringify(config) === JSON.stringify(DEFAULT_CONFIG2);
+}
 
 // src/commands/update.ts
-import { findConfigPath as findConfigPath3 } from "@eslint-config-snapshot/api";
+import { DEFAULT_CONFIG as DEFAULT_CONFIG3, findConfigPath as findConfigPath3 } from "@eslint-config-snapshot/api";
 async function executeUpdate(cwd, terminal, snapshotDir, printSummary) {
   const foundConfig = await findConfigPath3(cwd);
   const storedSnapshots = await loadStoredSnapshots(cwd, snapshotDir);
@@ -714,10 +840,21 @@ async function executeUpdate(cwd, terminal, snapshotDir, printSummary) {
     );
   }
   let currentSnapshots;
+  const skippedWorkspaces = [];
+  let discoveredWorkspaces = [];
+  const allowWorkspaceExtractionFailure = !foundConfig || isDefaultEquivalentConfig3(foundConfig.config);
   try {
-    currentSnapshots = await computeCurrentSnapshots(cwd);
+    currentSnapshots = await computeCurrentSnapshots(cwd, {
+      allowWorkspaceExtractionFailure,
+      onWorkspacesDiscovered: (workspacesRel) => {
+        discoveredWorkspaces = workspacesRel;
+      },
+      onWorkspaceSkipped: (skipped) => {
+        skippedWorkspaces.push(skipped);
+      }
+    });
   } catch (error) {
-    if (!foundConfig) {
+    if (!foundConfig && isWorkspaceDiscoveryDefaultsError2(error)) {
       terminal.write(
         "Automatic workspace discovery could not complete with defaults.\nRun `eslint-config-snapshot init` to configure workspaces, then run `eslint-config-snapshot --update`.\n"
       );
@@ -725,28 +862,45 @@ async function executeUpdate(cwd, terminal, snapshotDir, printSummary) {
     }
     throw error;
   }
+  if (!foundConfig) {
+    writeDiscoveredWorkspacesSummary2(terminal, discoveredWorkspaces);
+  }
+  writeSkippedWorkspaceSummary(terminal, cwd, foundConfig?.path, skippedWorkspaces);
   await writeSnapshots(cwd, snapshotDir, currentSnapshots);
   if (printSummary) {
     const summary = summarizeSnapshots(currentSnapshots);
     const workspaceCount = countUniqueWorkspaces(currentSnapshots);
     const eslintVersionsByGroup = terminal.showProgress ? await resolveGroupEslintVersions(cwd) : /* @__PURE__ */ new Map();
+    const baselineAction = storedSnapshots.size === 0 ? "created" : "updated";
+    terminal.success(`\u2705 Great news: baseline was successfully ${baselineAction} for your project.
+`);
     terminal.section("\u{1F4CA} Summary");
-    terminal.write(
-      `Baseline updated: ${summary.groups} groups, ${summary.rules} rules.
-Workspaces scanned: ${workspaceCount}.
-Severity mix: ${summary.error} errors, ${summary.warn} warnings, ${summary.off} off.
-`
-    );
+    terminal.write(formatBaselineSummaryLines(summary, workspaceCount));
     writeEslintVersionSummary(terminal, eslintVersionsByGroup);
   }
   return 0;
 }
+function isWorkspaceDiscoveryDefaultsError2(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Unable to discover workspaces") || message.includes("Unmatched workspaces") || message.includes("zero-config mode");
+}
+function isDefaultEquivalentConfig3(config) {
+  return JSON.stringify(config) === JSON.stringify(DEFAULT_CONFIG3);
+}
+function writeDiscoveredWorkspacesSummary2(terminal, workspacesRel) {
+  if (workspacesRel.length === 0) {
+    terminal.subtle("Auto-discovered workspaces: none\n");
+    return;
+  }
+  terminal.subtle(`Auto-discovered workspaces (${workspacesRel.length}): ${workspacesRel.join(", ")}
+`);
+}
 
 // src/init.ts
 import { discoverWorkspaces as discoverWorkspaces2, findConfigPath as findConfigPath4, getConfigScaffold, normalizePath as normalizePath2 } from "@eslint-config-snapshot/api";
 import fg2 from "fast-glob";
 import { access, readFile, writeFile } from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 async function runInit(cwd, opts, runtime) {
   const force = opts.force ?? false;
   const showEffective = opts.showEffective ?? false;
@@ -814,7 +968,7 @@ async function runInitInFile(cwd, configObject, force, runtime) {
   ];
   for (const candidate of candidates) {
     try {
-      await access(path3.join(cwd, candidate));
+      await access(path4.join(cwd, candidate));
       if (!force) {
         runtime.writeStderr(`Config already exists: ${candidate}
 `);
@@ -823,14 +977,14 @@ async function runInitInFile(cwd, configObject, force, runtime) {
     } catch {
     }
   }
-  const target = path3.join(cwd, "eslint-config-snapshot.config.mjs");
+  const target = path4.join(cwd, "eslint-config-snapshot.config.mjs");
   await writeFile(target, toConfigScaffold(configObject), "utf8");
-  runtime.writeStdout(`Created ${path3.basename(target)}
+  runtime.writeStdout(`Created ${path4.basename(target)}
 `);
   return 0;
 }
 async function runInitInPackageJson(cwd, configObject, force, runtime) {
-  const packageJsonPath = path3.join(cwd, "package.json");
+  const packageJsonPath = path4.join(cwd, "package.json");
   let packageJsonRaw;
   try {
     packageJsonRaw = await readFile(packageJsonPath, "utf8");
@@ -891,7 +1045,7 @@ async function discoverInitWorkspaces(cwd) {
   if (!(discovered.workspacesRel.length === 1 && discovered.workspacesRel[0] === ".")) {
     return discovered.workspacesRel;
   }
-  const packageJsonPath = path3.join(cwd, "package.json");
+  const packageJsonPath = path4.join(cwd, "package.json");
   try {
     const raw = await readFile(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
@@ -909,7 +1063,7 @@ async function discoverInitWorkspaces(cwd) {
       onlyFiles: true,
       dot: true
     });
-    const workspaceDirs = [...new Set(workspacePackageFiles.map((entry) => normalizePath2(path3.dirname(entry))))].sort(
+    const workspaceDirs = [...new Set(workspacePackageFiles.map((entry) => normalizePath2(path4.dirname(entry))))].sort(
       (a, b) => a.localeCompare(b)
     );
     if (workspaceDirs.length > 0) {
@@ -1320,7 +1474,7 @@ function isDirectCliExecution() {
   if (!entry) {
     return false;
   }
-  const normalized = path4.basename(entry).toLowerCase();
+  const normalized = path5.basename(entry).toLowerCase();
   return normalized === "index.js" || normalized === "index.cjs" || normalized === "index.ts" || normalized === "eslint-config-snapshot";
 }
 if (isDirectCliExecution()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-config-snapshot/cli",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "type": "module",
   "repository": {
     "type": "git",
@@ -31,6 +31,6 @@
     "commander": "^14.0.3",
     "debug": "^4.4.3",
     "fast-glob": "^3.3.3",
-    "@eslint-config-snapshot/api": "1.0.0"
+    "@eslint-config-snapshot/api": "1.1.1"
   }
 }

package/src/commands/check.ts

@@ -1,6 +1,13 @@
-import { findConfigPath } from '@eslint-config-snapshot/api'
+import { DEFAULT_CONFIG, findConfigPath, type SnapshotConfig } from '@eslint-config-snapshot/api'
 
-import { countUniqueWorkspaces, decorateDiffLine, formatDiff, summarizeChanges, summarizeSnapshots } from '../formatters.js'
+import {
+  countUniqueWorkspaces,
+  decorateDiffLine,
+  formatBaselineSummaryLines,
+  formatDiff,
+  summarizeChanges,
+  summarizeSnapshots
+} from '../formatters.js'
 import { writeEslintVersionSummary, writeRunContextHeader } from '../run-context.js'
 import {
   type BuiltSnapshot,
@@ -9,10 +16,12 @@ import {
   type GroupEslintVersions,
   loadStoredSnapshots,
   resolveGroupEslintVersions,
+  type SkippedWorkspace,
   type SnapshotDiff,
   writeSnapshots
 } from '../runtime.js'
 import { type TerminalIO } from '../terminal.js'
+import { writeSkippedWorkspaceSummary } from './skipped-workspaces.js'
 
 export type CheckFormat = 'summary' | 'status' | 'diff'
 
@@ -42,10 +51,21 @@ export async function executeCheck(
   }
 
   let currentSnapshots: Map<string, BuiltSnapshot>
+  const skippedWorkspaces: SkippedWorkspace[] = []
+  let discoveredWorkspaces: string[] = []
+  const allowWorkspaceExtractionFailure = !foundConfig || isDefaultEquivalentConfig(foundConfig.config)
   try {
-    currentSnapshots = await computeCurrentSnapshots(cwd)
+    currentSnapshots = await computeCurrentSnapshots(cwd, {
+      allowWorkspaceExtractionFailure,
+      onWorkspacesDiscovered: (workspacesRel) => {
+        discoveredWorkspaces = workspacesRel
+      },
+      onWorkspaceSkipped: (skipped) => {
+        skippedWorkspaces.push(skipped)
+      }
+    })
   } catch (error: unknown) {
-    if (!foundConfig) {
+    if (!foundConfig && isWorkspaceDiscoveryDefaultsError(error)) {
       terminal.write(
         'Automatic workspace discovery could not complete with defaults.\nRun `eslint-config-snapshot init` to configure workspaces, then run `eslint-config-snapshot --update`.\n'
       )
@@ -54,6 +74,10 @@ export async function executeCheck(
 
     throw error
   }
+  if (!foundConfig) {
+    writeDiscoveredWorkspacesSummary(terminal, discoveredWorkspaces)
+  }
+  writeSkippedWorkspaceSummary(terminal, cwd, foundConfig?.path, skippedWorkspaces)
   if (storedSnapshots.size === 0) {
     const summary = summarizeSnapshots(currentSnapshots)
     terminal.write(
@@ -126,9 +150,7 @@ function printWhatChanged(
   if (changes.length === 0) {
     terminal.write(color.green('✅ Great news: no snapshot drift detected.\n'))
     terminal.section('📊 Summary')
-    terminal.write(
-      `- 📦 baseline: ${currentSummary.groups} groups, ${currentSummary.rules} rules\n- 🗂️ workspaces scanned: ${workspaceCount}\n- 🎚️ severity mix: ${currentSummary.error} errors, ${currentSummary.warn} warnings, ${currentSummary.off} off\n`
-    )
+    terminal.write(formatBaselineSummaryLines(currentSummary, workspaceCount))
     writeEslintVersionSummary(terminal, eslintVersionsByGroup)
     return 0
   }
@@ -155,3 +177,25 @@ function printWhatChanged(
 
   return 1
 }
+
+function isWorkspaceDiscoveryDefaultsError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error)
+  return (
+    message.includes('Unable to discover workspaces') ||
+    message.includes('Unmatched workspaces') ||
+    message.includes('zero-config mode')
+  )
+}
+
+function isDefaultEquivalentConfig(config: SnapshotConfig): boolean {
+  return JSON.stringify(config) === JSON.stringify(DEFAULT_CONFIG)
+}
+
+function writeDiscoveredWorkspacesSummary(terminal: TerminalIO, workspacesRel: string[]): void {
+  if (workspacesRel.length === 0) {
+    terminal.subtle('Auto-discovered workspaces: none\n')
+    return
+  }
+
+  terminal.subtle(`Auto-discovered workspaces (${workspacesRel.length}): ${workspacesRel.join(', ')}\n`)
+}

package/src/commands/print.ts

@@ -1,4 +1,4 @@
-import { findConfigPath, loadConfig } from '@eslint-config-snapshot/api'
+import { DEFAULT_CONFIG, findConfigPath, loadConfig, type SnapshotConfig } from '@eslint-config-snapshot/api'
 
 import { formatShortConfig, formatShortPrint } from '../formatters.js'
 import { writeRunContextHeader } from '../run-context.js'
@@ -14,7 +14,8 @@ export async function executePrint(cwd: string, terminal: TerminalIO, snapshotDi
   if (terminal.showProgress) {
     terminal.subtle('🔎 Checking current ESLint configuration...\n')
   }
-  const currentSnapshots = await computeCurrentSnapshots(cwd)
+  const allowWorkspaceExtractionFailure = !foundConfig || isDefaultEquivalentConfig(foundConfig.config)
+  const currentSnapshots = await computeCurrentSnapshots(cwd, { allowWorkspaceExtractionFailure })
 
   if (format === 'short') {
     terminal.write(formatShortPrint([...currentSnapshots.values()]))
@@ -56,3 +57,7 @@ export async function executeConfig(cwd: string, terminal: TerminalIO, snapshotD
 
   terminal.write(`${JSON.stringify(payload, null, 2)}\n`)
 }
+
+function isDefaultEquivalentConfig(config: SnapshotConfig): boolean {
+  return JSON.stringify(config) === JSON.stringify(DEFAULT_CONFIG)
+}

package/src/commands/skipped-workspaces.ts

@@ -0,0 +1,66 @@
+import path from 'node:path'
+
+import { type SkippedWorkspace } from '../runtime.js'
+import { type TerminalIO } from '../terminal.js'
+
+export function writeSkippedWorkspaceSummary(
+  terminal: TerminalIO,
+  cwd: string,
+  configPath: string | undefined,
+  skippedWorkspaces: SkippedWorkspace[]
+): void {
+  if (skippedWorkspaces.length === 0) {
+    return
+  }
+
+  const workspacePaths = collectSkippedWorkspacePaths(skippedWorkspaces)
+  terminal.warning(
+    `Heads up: ${workspacePaths.length} workspace(s) were skipped because ESLint auto-discovery could not extract an effective config for them.\n`
+  )
+  terminal.warning(`Skipped workspaces: ${workspacePaths.join(', ')}\n`)
+  terminal.subtle(formatScopedConfigHint(cwd, configPath, workspacePaths))
+}
+
+function collectSkippedWorkspacePaths(skippedWorkspaces: SkippedWorkspace[]): string[] {
+  const unique = new Set<string>()
+  for (const skipped of skippedWorkspaces) {
+    unique.add(skipped.workspaceRel)
+  }
+
+  return [...unique].sort()
+}
+
+function toExcludeGlobs(workspacePaths: string[]): string[] {
+  return workspacePaths.map((workspacePath) => `${workspacePath}/**`)
+}
+
+function formatScopedConfigHint(cwd: string, configPath: string | undefined, workspacePaths: string[]): string {
+  const excludeGlobs = toExcludeGlobs(workspacePaths)
+
+  if (configPath && path.basename(configPath) === 'package.json') {
+    return `Tip: if these workspaces are intentionally out of scope, add this under "eslint-config-snapshot" in package.json:\n${JSON.stringify(
+      {
+        sampling: {
+          excludeGlobs
+        }
+      },
+      null,
+      2
+    )}\n`
+  }
+
+  const objectLiteral = `{
+  sampling: {
+    excludeGlobs: [
+${excludeGlobs.map((value) => `      '${value}'`).join(',\n')}
+    ]
+  }
+}\n`
+
+  if (configPath) {
+    const relConfigPath = path.relative(cwd, configPath) || path.basename(configPath)
+    return `Tip: if these workspaces are intentionally out of scope, add this in ${relConfigPath}:\n${objectLiteral}`
+  }
+
+  return `Tip: if these workspaces are intentionally out of scope, run \`eslint-config-snapshot init\` and add this config:\n${objectLiteral}`
+}