@eslint-config-snapshot/cli 1.0.0 → 1.1.1

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @eslint-config-snapshot/cli
 
+## 1.1.1
+
+### Patch Changes
+
+- Patch release: improve OSS compatibility workflow checks and align CLI zero-config print tolerance.
+- Updated dependencies
+  - @eslint-config-snapshot/api@1.1.1
+
+## 1.1.0
+
+### Minor Changes
+
+- Minor release: improve skipped workspace messaging and OSS compatibility documentation.
+
+### Patch Changes
+
+- Updated dependencies
+  - @eslint-config-snapshot/api@1.1.0
+
 ## 1.0.0
 
 ### Major Changes

package/dist/index.cjs

@@ -38,7 +38,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 var import_commander = require("commander");
 var import_debug2 = __toESM(require("debug"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 
 // src/commands/check.ts
 var import_api3 = require("@eslint-config-snapshot/api");
@@ -216,6 +216,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;
@@ -395,19 +401,24 @@ var import_node_path2 = __toESM(require("path"), 1);
 var debugWorkspace = (0, import_debug.default)("eslint-config-snapshot:workspace");
 var debugDiff = (0, import_debug.default)("eslint-config-snapshot:diff");
 var debugTiming = (0, import_debug.default)("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 (0, import_api2.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 = import_node_path2.default.resolve(discovery.rootAbs, workspaceRel);
@@ -440,7 +451,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;
         }
@@ -448,10 +459,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,
@@ -460,8 +484,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 = (0, import_api2.aggregateRules)(extractedForGroup);
-    snapshots.set(group.name, (0, import_api2.buildSnapshot)(group.name, group.workspaces, aggregated));
+    snapshots.set(group.name, (0, import_api2.buildSnapshot)(group.name, extractedWorkspaces, aggregated));
     debugWorkspace(
       "group=%s aggregatedRules=%d groupElapsedMs=%d",
       group.name,
@@ -470,11 +501,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 (0, import_api2.discoverWorkspaces)({ cwd, workspaceInput: config.workspaceInput });
   const assignments = config.grouping.mode === "standalone" ? discovery.workspacesRel.map((workspace) => ({ name: workspace, workspaces: [workspace] })) : (0, import_api2.assignGroupsByMatch)(discovery.workspacesRel, config.grouping.groups ?? [{ name: "default", match: ["**/*"] }]);
@@ -544,6 +584,63 @@ async function resolveGroupEslintVersions(cwd) {
   return result;
 }
 
+// src/commands/skipped-workspaces.ts
+var import_node_path3 = __toESM(require("path"), 1);
+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 && import_node_path3.default.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 = import_node_path3.default.relative(cwd, configPath) || import_node_path3.default.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) {
@@ -561,10 +658,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"
       );
@@ -572,6 +680,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(
@@ -631,12 +743,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;
   }
@@ -671,6 +778,21 @@ 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(import_api3.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
 var import_api4 = require("@eslint-config-snapshot/api");
@@ -681,7 +803,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;
@@ -720,6 +843,9 @@ async function executeConfig(cwd, terminal, snapshotDir, format) {
   terminal.write(`${JSON.stringify(payload, null, 2)}
 `);
 }
+function isDefaultEquivalentConfig2(config) {
+  return JSON.stringify(config) === JSON.stringify(import_api4.DEFAULT_CONFIG);
+}
 
 // src/commands/update.ts
 var import_api5 = require("@eslint-config-snapshot/api");
@@ -736,10 +862,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"
       );
@@ -747,28 +884,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(import_api5.DEFAULT_CONFIG);
+}
+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
 var import_api6 = require("@eslint-config-snapshot/api");
 var import_fast_glob2 = __toESM(require("fast-glob"), 1);
 var import_promises2 = require("fs/promises");
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 async function runInit(cwd, opts, runtime) {
   const force = opts.force ?? false;
   const showEffective = opts.showEffective ?? false;
@@ -836,7 +990,7 @@ async function runInitInFile(cwd, configObject, force, runtime) {
   ];
   for (const candidate of candidates) {
     try {
-      await (0, import_promises2.access)(import_node_path3.default.join(cwd, candidate));
+      await (0, import_promises2.access)(import_node_path4.default.join(cwd, candidate));
       if (!force) {
         runtime.writeStderr(`Config already exists: ${candidate}
 `);
@@ -845,14 +999,14 @@ async function runInitInFile(cwd, configObject, force, runtime) {
     } catch {
     }
   }
-  const target = import_node_path3.default.join(cwd, "eslint-config-snapshot.config.mjs");
+  const target = import_node_path4.default.join(cwd, "eslint-config-snapshot.config.mjs");
   await (0, import_promises2.writeFile)(target, toConfigScaffold(configObject), "utf8");
-  runtime.writeStdout(`Created ${import_node_path3.default.basename(target)}
+  runtime.writeStdout(`Created ${import_node_path4.default.basename(target)}
 `);
   return 0;
 }
 async function runInitInPackageJson(cwd, configObject, force, runtime) {
-  const packageJsonPath = import_node_path3.default.join(cwd, "package.json");
+  const packageJsonPath = import_node_path4.default.join(cwd, "package.json");
   let packageJsonRaw;
   try {
     packageJsonRaw = await (0, import_promises2.readFile)(packageJsonPath, "utf8");
@@ -913,7 +1067,7 @@ async function discoverInitWorkspaces(cwd) {
   if (!(discovered.workspacesRel.length === 1 && discovered.workspacesRel[0] === ".")) {
     return discovered.workspacesRel;
   }
-  const packageJsonPath = import_node_path3.default.join(cwd, "package.json");
+  const packageJsonPath = import_node_path4.default.join(cwd, "package.json");
   try {
     const raw = await (0, import_promises2.readFile)(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
@@ -931,7 +1085,7 @@ async function discoverInitWorkspaces(cwd) {
       onlyFiles: true,
       dot: true
     });
-    const workspaceDirs = [...new Set(workspacePackageFiles.map((entry) => (0, import_api6.normalizePath)(import_node_path3.default.dirname(entry))))].sort(
+    const workspaceDirs = [...new Set(workspacePackageFiles.map((entry) => (0, import_api6.normalizePath)(import_node_path4.default.dirname(entry))))].sort(
       (a, b) => a.localeCompare(b)
     );
     if (workspaceDirs.length > 0) {
@@ -1342,7 +1496,7 @@ function isDirectCliExecution() {
   if (!entry) {
     return false;
   }
-  const normalized = import_node_path4.default.basename(entry).toLowerCase();
+  const normalized = import_node_path5.default.basename(entry).toLowerCase();
   return normalized === "index.js" || normalized === "index.cjs" || normalized === "index.ts" || normalized === "eslint-config-snapshot";
 }
 if (isDirectCliExecution()) {