@eslint-config-snapshot/cli 0.1.4 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @eslint-config-snapshot/cli
 
+## 0.2.0
+
+### Minor Changes
+
+- Add effective config inspection command and recommended grouped init workflow with numeric workspace assignments.
+
+### Patch Changes
+
+- Updated dependencies
+  - @eslint-config-snapshot/api@0.2.0
+
+## 0.1.5
+
+### Patch Changes
+
+- Add package-level README files for npm pages with cross-links between CLI and API docs.
+- Updated dependencies
+  - @eslint-config-snapshot/api@0.1.5
+
 ## 0.1.4
 
 ### Patch Changes

package/README.md

@@ -0,0 +1,60 @@
+# @eslint-config-snapshot/cli
+
+Deterministic ESLint config drift checker for workspaces.
+
+`@eslint-config-snapshot/cli` snapshots effective ESLint rule state and reports drift after dependency or config changes.
+
+## Install
+
+```bash
+npm i -D @eslint-config-snapshot/cli
+```
+
+Or run without install:
+
+```bash
+npx @eslint-config-snapshot/cli@latest --update
+```
+
+## Quick Start
+
+Create baseline:
+
+```bash
+eslint-config-snapshot --update
+```
+
+Check drift:
+
+```bash
+eslint-config-snapshot
+```
+
+## Commands
+
+- `check`
+- `update`
+- `print`
+- `config`
+- `init`
+
+Compatibility aliases:
+
+- `snapshot` => `update`
+- `compare` => `check --format diff`
+- `status` => `check --format status`
+- `what-changed` => `check --format summary`
+
+## Notes
+
+- Node.js `>=20` required.
+- If no config is found, built-in defaults are used.
+- Snapshots are stored under `.eslint-config-snapshot/`.
+
+## Related Packages
+
+- API engine: [`@eslint-config-snapshot/api`](https://www.npmjs.com/package/@eslint-config-snapshot/api)
+
+## More Docs
+
+- Project overview and full guides: [root README](https://github.com/gabrielmoreira/eslint-config-snapshot#readme)

package/dist/index.cjs

@@ -114,17 +114,23 @@ function createProgram(cwd, onActionExit) {
     await executePrint(cwd, format);
     onActionExit(0);
   });
-  program.command("init").description("Initialize config (file or package.json)").option("--target <target>", "Config target: file|package-json", parseInitTarget).option("--preset <preset>", "Config preset: minimal|full", parseInitPreset).option("-f, --force", "Allow init even when an existing config is detected").option("-y, --yes", "Skip prompts and use defaults/options").addHelpText(
+  program.command("config").description("Print effective evaluated config").option("--format <format>", "Output format: json|short", parsePrintFormat, "json").option("--short", "Alias for --format short").action(async (opts) => {
+    const format = opts.short ? "short" : opts.format;
+    await executeConfig(cwd, format);
+    onActionExit(0);
+  });
+  program.command("init").description("Initialize config (file or package.json)").option("--target <target>", "Config target: file|package-json", parseInitTarget).option("--preset <preset>", "Config preset: recommended|minimal|full", parseInitPreset).option("--show-effective", "Print the evaluated config that will be written").option("-f, --force", "Allow init even when an existing config is detected").option("-y, --yes", "Skip prompts and use defaults/options").addHelpText(
     "after",
     `
 Examples:
   $ eslint-config-snapshot init
     Runs interactive numbered prompts:
       target: 1) package-json, 2) file
-      preset: 1) minimal, 2) full
+      preset: 1) recommended, 2) minimal, 3) full
+      recommended preset supports per-workspace group number assignment.
 
-  $ eslint-config-snapshot init --yes --target package-json --preset minimal
-    Non-interactive minimal setup in package.json.
+  $ eslint-config-snapshot init --yes --target package-json --preset recommended --show-effective
+    Non-interactive recommended setup in package.json, with effective preview.
 
   $ eslint-config-snapshot init --yes --force --target file --preset full
     Overwrite-safe bypass when a config is already detected.
@@ -167,10 +173,10 @@ function parseInitTarget(value) {
 }
 function parseInitPreset(value) {
   const normalized = value.trim().toLowerCase();
-  if (normalized === "minimal" || normalized === "full") {
+  if (normalized === "recommended" || normalized === "minimal" || normalized === "full") {
     return normalized;
   }
-  throw new import_commander.InvalidArgumentError("Expected one of: minimal, full");
+  throw new import_commander.InvalidArgumentError("Expected one of: recommended, minimal, full");
 }
 async function executeCheck(cwd, format, defaultInvocation = false) {
   const foundConfig = await (0, import_api.findConfigPath)(cwd);
@@ -281,17 +287,31 @@ async function executePrint(cwd, format) {
   process.stdout.write(`${JSON.stringify(output, null, 2)}
 `);
 }
-async function computeCurrentSnapshots(cwd) {
+async function executeConfig(cwd, format) {
+  const foundConfig = await (0, import_api.findConfigPath)(cwd);
   const config = await (0, import_api.loadConfig)(cwd);
-  const discovery = await (0, import_api.discoverWorkspaces)({ cwd, workspaceInput: config.workspaceInput });
-  const assignments = config.grouping.mode === "standalone" ? discovery.workspacesRel.map((workspace) => ({ name: workspace, workspaces: [workspace] })) : (0, import_api.assignGroupsByMatch)(discovery.workspacesRel, config.grouping.groups ?? [{ name: "default", match: ["**/*"] }]);
-  const allowEmptyGroups = config.grouping.allowEmptyGroups ?? false;
-  if (!allowEmptyGroups) {
-    const empty = assignments.filter((group) => group.workspaces.length === 0);
-    if (empty.length > 0) {
-      throw new Error(`Empty groups are not allowed: ${empty.map((entry) => entry.name).join(", ")}`);
-    }
+  const resolved = await resolveWorkspaceAssignments(cwd, config);
+  const payload = {
+    source: foundConfig?.path ?? "built-in-defaults",
+    workspaceInput: config.workspaceInput,
+    workspaces: resolved.discovery.workspacesRel,
+    grouping: {
+      mode: config.grouping.mode,
+      allowEmptyGroups: config.grouping.allowEmptyGroups ?? false,
+      groups: resolved.assignments.map((entry) => ({ name: entry.name, workspaces: entry.workspaces }))
+    },
+    sampling: config.sampling
+  };
+  if (format === "short") {
+    process.stdout.write(formatShortConfig(payload));
+    return;
   }
+  process.stdout.write(`${JSON.stringify(payload, null, 2)}
+`);
+}
+async function computeCurrentSnapshots(cwd) {
+  const config = await (0, import_api.loadConfig)(cwd);
+  const { discovery, assignments } = await resolveWorkspaceAssignments(cwd, config);
   const snapshots = /* @__PURE__ */ new Map();
   for (const group of assignments) {
     const extractedForGroup = [];
@@ -326,6 +346,18 @@ async function computeCurrentSnapshots(cwd) {
   }
   return snapshots;
 }
+async function resolveWorkspaceAssignments(cwd, config) {
+  const discovery = await (0, import_api.discoverWorkspaces)({ cwd, workspaceInput: config.workspaceInput });
+  const assignments = config.grouping.mode === "standalone" ? discovery.workspacesRel.map((workspace) => ({ name: workspace, workspaces: [workspace] })) : (0, import_api.assignGroupsByMatch)(discovery.workspacesRel, config.grouping.groups ?? [{ name: "default", match: ["**/*"] }]);
+  const allowEmptyGroups = config.grouping.allowEmptyGroups ?? false;
+  if (!allowEmptyGroups) {
+    const empty = assignments.filter((group) => group.workspaces.length === 0);
+    if (empty.length > 0) {
+      throw new Error(`Empty groups are not allowed: ${empty.map((entry) => entry.name).join(", ")}`);
+    }
+  }
+  return { discovery, assignments };
+}
 async function loadStoredSnapshots(cwd) {
   const dir = import_node_path.default.join(cwd, SNAPSHOT_DIR);
   const files = await (0, import_fast_glob.default)("**/*.json", { cwd: dir, absolute: true, onlyFiles: true, dot: true, suppressErrors: true });
@@ -407,6 +439,7 @@ function getDisplayOptionChanges(diff) {
 }
 async function runInit(cwd, opts = {}) {
   const force = opts.force ?? false;
+  const showEffective = opts.showEffective ?? false;
   const existing = await (0, import_api.findConfigPath)(cwd);
   if (existing && !force) {
     process.stderr.write(
@@ -423,11 +456,17 @@ async function runInit(cwd, opts = {}) {
     preset = interactive.preset;
   }
   const finalTarget = target ?? "file";
-  const finalPreset = preset ?? "minimal";
+  const finalPreset = preset ?? "recommended";
+  const configObject = await resolveInitConfigObject(cwd, finalPreset, Boolean(opts.yes));
+  if (showEffective) {
+    process.stdout.write(`Effective config preview:
+${JSON.stringify(configObject, null, 2)}
+`);
+  }
   if (finalTarget === "package-json") {
-    return runInitInPackageJson(cwd, finalPreset, force);
+    return runInitInPackageJson(cwd, configObject, force);
   }
-  return runInitInFile(cwd, finalPreset, force);
+  return runInitInFile(cwd, configObject, force);
 }
 async function askInitPreferences() {
   const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
@@ -454,12 +493,15 @@ async function askInitTarget(rl) {
 }
 async function askInitPreset(rl) {
   while (true) {
-    const answer = await askQuestion(rl, "Select preset:\n  1) minimal (recommended)\n  2) full\nChoose [1]: ");
+    const answer = await askQuestion(
+      rl,
+      "Select preset:\n  1) recommended (group by workspace numbers)\n  2) minimal\n  3) full\nChoose [1]: "
+    );
     const parsed = parseInitPresetChoice(answer);
     if (parsed) {
       return parsed;
     }
-    process.stdout.write("Please choose 1 (minimal) or 2 (full).\n");
+    process.stdout.write("Please choose 1 (recommended), 2 (minimal), or 3 (full).\n");
   }
 }
 function parseInitTargetChoice(value) {
@@ -478,12 +520,15 @@ function parseInitTargetChoice(value) {
 function parseInitPresetChoice(value) {
   const normalized = value.trim().toLowerCase();
   if (normalized === "") {
-    return "minimal";
+    return "recommended";
+  }
+  if (normalized === "1" || normalized === "recommended" || normalized === "rec" || normalized === "grouped") {
+    return "recommended";
   }
-  if (normalized === "1" || normalized === "minimal" || normalized === "min") {
+  if (normalized === "2" || normalized === "minimal" || normalized === "min") {
     return "minimal";
   }
-  if (normalized === "2" || normalized === "full") {
+  if (normalized === "3" || normalized === "full") {
     return "full";
   }
   return void 0;
@@ -508,7 +553,7 @@ async function askYesNo(prompt, defaultYes) {
     rl.close();
   }
 }
-async function runInitInFile(cwd, preset, force) {
+async function runInitInFile(cwd, configObject, force) {
   const candidates = [
     ".eslint-config-snapshot.js",
     ".eslint-config-snapshot.cjs",
@@ -529,12 +574,12 @@ async function runInitInFile(cwd, preset, force) {
     }
   }
   const target = import_node_path.default.join(cwd, "eslint-config-snapshot.config.mjs");
-  await (0, import_promises.writeFile)(target, (0, import_api.getConfigScaffold)(preset), "utf8");
+  await (0, import_promises.writeFile)(target, toConfigScaffold(configObject), "utf8");
   process.stdout.write(`Created ${import_node_path.default.basename(target)}
 `);
   return 0;
 }
-async function runInitInPackageJson(cwd, preset, force) {
+async function runInitInPackageJson(cwd, configObject, force) {
   const packageJsonPath = import_node_path.default.join(cwd, "package.json");
   let packageJsonRaw;
   try {
@@ -554,12 +599,117 @@ async function runInitInPackageJson(cwd, preset, force) {
     process.stderr.write("Config already exists in package.json: eslint-config-snapshot\n");
     return 1;
   }
-  parsed["eslint-config-snapshot"] = preset === "full" ? getFullPresetObject() : {};
+  parsed["eslint-config-snapshot"] = configObject;
   await (0, import_promises.writeFile)(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
 `, "utf8");
   process.stdout.write('Created config in package.json under "eslint-config-snapshot"\n');
   return 0;
 }
+async function resolveInitConfigObject(cwd, preset, nonInteractive) {
+  if (preset === "minimal") {
+    return {};
+  }
+  if (preset === "full") {
+    return getFullPresetObject();
+  }
+  return buildRecommendedPresetObject(cwd, nonInteractive);
+}
+async function buildRecommendedPresetObject(cwd, nonInteractive) {
+  const workspaces = await discoverInitWorkspaces(cwd);
+  const assignments = new Map(workspaces.map((workspace) => [workspace, 1]));
+  if (!nonInteractive && process.stdin.isTTY && process.stdout.isTTY) {
+    process.stdout.write("Recommended setup: assign a group number for each workspace (default: 1).\n");
+    for (const workspace of workspaces) {
+      const answer = await askGroupNumber(workspace);
+      assignments.set(workspace, answer);
+    }
+  }
+  const groupNumbers = [...new Set(assignments.values())].sort((a, b) => a - b);
+  const groups = groupNumbers.map((number) => ({
+    name: `group-${number}`,
+    match: workspaces.filter((workspace) => assignments.get(workspace) === number)
+  }));
+  return {
+    workspaceInput: { mode: "manual", workspaces },
+    grouping: {
+      mode: "match",
+      groups
+    },
+    sampling: {
+      maxFilesPerWorkspace: 8,
+      includeGlobs: ["**/*.{js,jsx,ts,tsx,cjs,mjs}"],
+      excludeGlobs: ["**/node_modules/**", "**/dist/**"],
+      hintGlobs: []
+    }
+  };
+}
+async function discoverInitWorkspaces(cwd) {
+  const discovered = await (0, import_api.discoverWorkspaces)({ cwd, workspaceInput: { mode: "discover" } });
+  if (!(discovered.workspacesRel.length === 1 && discovered.workspacesRel[0] === ".")) {
+    return discovered.workspacesRel;
+  }
+  const packageJsonPath = import_node_path.default.join(cwd, "package.json");
+  try {
+    const raw = await (0, import_promises.readFile)(packageJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    let workspacePatterns = [];
+    if (Array.isArray(parsed.workspaces)) {
+      workspacePatterns = parsed.workspaces;
+    } else if (parsed.workspaces && typeof parsed.workspaces === "object" && Array.isArray(parsed.workspaces.packages)) {
+      workspacePatterns = parsed.workspaces.packages;
+    }
+    if (workspacePatterns.length === 0) {
+      return discovered.workspacesRel;
+    }
+    const workspacePackageFiles = await (0, import_fast_glob.default)(
+      workspacePatterns.map((pattern) => `${trimTrailingSlashes(pattern)}/package.json`),
+      { cwd, onlyFiles: true, dot: true }
+    );
+    const workspaceDirs = [...new Set(workspacePackageFiles.map((entry) => (0, import_api.normalizePath)(import_node_path.default.dirname(entry))))].sort(
+      (a, b) => a.localeCompare(b)
+    );
+    if (workspaceDirs.length > 0) {
+      return workspaceDirs;
+    }
+  } catch {
+  }
+  return discovered.workspacesRel;
+}
+function trimTrailingSlashes(value) {
+  let normalized = value;
+  while (normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+async function askGroupNumber(workspace) {
+  const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
+  try {
+    while (true) {
+      const answer = await askQuestion(rl, `Group number for ${workspace} [1]: `);
+      const normalized = answer.trim();
+      if (normalized === "") {
+        return 1;
+      }
+      if (/^\d+$/.test(normalized)) {
+        const parsed = Number.parseInt(normalized, 10);
+        if (parsed >= 1) {
+          return parsed;
+        }
+      }
+      process.stdout.write("Please provide a positive integer (1, 2, 3, ...).\n");
+    }
+  } finally {
+    rl.close();
+  }
+}
+function toConfigScaffold(configObject) {
+  if (Object.keys(configObject).length === 0) {
+    return (0, import_api.getConfigScaffold)("minimal");
+  }
+  return `export default ${JSON.stringify(configObject, null, 2)}
+`;
+}
 function getFullPresetObject() {
   return {
     workspaceInput: { mode: "discover" },
@@ -711,6 +861,19 @@ function formatShortPrint(snapshots) {
   return `${lines.join("\n")}
 `;
 }
+function formatShortConfig(payload) {
+  const lines = [
+    `source: ${payload.source}`,
+    `workspaces (${payload.workspaces.length}): ${payload.workspaces.join(", ") || "(none)"}`,
+    `grouping mode: ${payload.grouping.mode} (allow empty: ${payload.grouping.allowEmptyGroups})`
+  ];
+  for (const group of payload.grouping.groups) {
+    lines.push(`group ${group.name} (${group.workspaces.length}): ${group.workspaces.join(", ") || "(none)"}`);
+  }
+  lines.push(`workspaceInput: ${JSON.stringify(payload.workspaceInput)}`, `sampling: ${JSON.stringify(payload.sampling)}`);
+  return `${lines.join("\n")}
+`;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   main,

package/dist/index.js

@@ -12,6 +12,7 @@ import {
   getConfigScaffold,
   hasDiff,
   loadConfig,
+  normalizePath,
   readSnapshotFile,
   sampleWorkspaceFiles,
   writeSnapshotFile
@@ -92,17 +93,23 @@ function createProgram(cwd, onActionExit) {
     await executePrint(cwd, format);
     onActionExit(0);
   });
-  program.command("init").description("Initialize config (file or package.json)").option("--target <target>", "Config target: file|package-json", parseInitTarget).option("--preset <preset>", "Config preset: minimal|full", parseInitPreset).option("-f, --force", "Allow init even when an existing config is detected").option("-y, --yes", "Skip prompts and use defaults/options").addHelpText(
+  program.command("config").description("Print effective evaluated config").option("--format <format>", "Output format: json|short", parsePrintFormat, "json").option("--short", "Alias for --format short").action(async (opts) => {
+    const format = opts.short ? "short" : opts.format;
+    await executeConfig(cwd, format);
+    onActionExit(0);
+  });
+  program.command("init").description("Initialize config (file or package.json)").option("--target <target>", "Config target: file|package-json", parseInitTarget).option("--preset <preset>", "Config preset: recommended|minimal|full", parseInitPreset).option("--show-effective", "Print the evaluated config that will be written").option("-f, --force", "Allow init even when an existing config is detected").option("-y, --yes", "Skip prompts and use defaults/options").addHelpText(
     "after",
     `
 Examples:
   $ eslint-config-snapshot init
     Runs interactive numbered prompts:
       target: 1) package-json, 2) file
-      preset: 1) minimal, 2) full
+      preset: 1) recommended, 2) minimal, 3) full
+      recommended preset supports per-workspace group number assignment.
 
-  $ eslint-config-snapshot init --yes --target package-json --preset minimal
-    Non-interactive minimal setup in package.json.
+  $ eslint-config-snapshot init --yes --target package-json --preset recommended --show-effective
+    Non-interactive recommended setup in package.json, with effective preview.
 
   $ eslint-config-snapshot init --yes --force --target file --preset full
     Overwrite-safe bypass when a config is already detected.
@@ -145,10 +152,10 @@ function parseInitTarget(value) {
 }
 function parseInitPreset(value) {
   const normalized = value.trim().toLowerCase();
-  if (normalized === "minimal" || normalized === "full") {
+  if (normalized === "recommended" || normalized === "minimal" || normalized === "full") {
     return normalized;
   }
-  throw new InvalidArgumentError("Expected one of: minimal, full");
+  throw new InvalidArgumentError("Expected one of: recommended, minimal, full");
 }
 async function executeCheck(cwd, format, defaultInvocation = false) {
   const foundConfig = await findConfigPath(cwd);
@@ -259,17 +266,31 @@ async function executePrint(cwd, format) {
   process.stdout.write(`${JSON.stringify(output, null, 2)}
 `);
 }
-async function computeCurrentSnapshots(cwd) {
+async function executeConfig(cwd, format) {
+  const foundConfig = await findConfigPath(cwd);
   const config = await loadConfig(cwd);
-  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: ["**/*"] }]);
-  const allowEmptyGroups = config.grouping.allowEmptyGroups ?? false;
-  if (!allowEmptyGroups) {
-    const empty = assignments.filter((group) => group.workspaces.length === 0);
-    if (empty.length > 0) {
-      throw new Error(`Empty groups are not allowed: ${empty.map((entry) => entry.name).join(", ")}`);
-    }
+  const resolved = await resolveWorkspaceAssignments(cwd, config);
+  const payload = {
+    source: foundConfig?.path ?? "built-in-defaults",
+    workspaceInput: config.workspaceInput,
+    workspaces: resolved.discovery.workspacesRel,
+    grouping: {
+      mode: config.grouping.mode,
+      allowEmptyGroups: config.grouping.allowEmptyGroups ?? false,
+      groups: resolved.assignments.map((entry) => ({ name: entry.name, workspaces: entry.workspaces }))
+    },
+    sampling: config.sampling
+  };
+  if (format === "short") {
+    process.stdout.write(formatShortConfig(payload));
+    return;
   }
+  process.stdout.write(`${JSON.stringify(payload, null, 2)}
+`);
+}
+async function computeCurrentSnapshots(cwd) {
+  const config = await loadConfig(cwd);
+  const { discovery, assignments } = await resolveWorkspaceAssignments(cwd, config);
   const snapshots = /* @__PURE__ */ new Map();
   for (const group of assignments) {
     const extractedForGroup = [];
@@ -304,6 +325,18 @@ async function computeCurrentSnapshots(cwd) {
   }
   return snapshots;
 }
+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: ["**/*"] }]);
+  const allowEmptyGroups = config.grouping.allowEmptyGroups ?? false;
+  if (!allowEmptyGroups) {
+    const empty = assignments.filter((group) => group.workspaces.length === 0);
+    if (empty.length > 0) {
+      throw new Error(`Empty groups are not allowed: ${empty.map((entry) => entry.name).join(", ")}`);
+    }
+  }
+  return { discovery, assignments };
+}
 async function loadStoredSnapshots(cwd) {
   const dir = path.join(cwd, SNAPSHOT_DIR);
   const files = await fg("**/*.json", { cwd: dir, absolute: true, onlyFiles: true, dot: true, suppressErrors: true });
@@ -385,6 +418,7 @@ function getDisplayOptionChanges(diff) {
 }
 async function runInit(cwd, opts = {}) {
   const force = opts.force ?? false;
+  const showEffective = opts.showEffective ?? false;
   const existing = await findConfigPath(cwd);
   if (existing && !force) {
     process.stderr.write(
@@ -401,11 +435,17 @@ async function runInit(cwd, opts = {}) {
     preset = interactive.preset;
   }
   const finalTarget = target ?? "file";
-  const finalPreset = preset ?? "minimal";
+  const finalPreset = preset ?? "recommended";
+  const configObject = await resolveInitConfigObject(cwd, finalPreset, Boolean(opts.yes));
+  if (showEffective) {
+    process.stdout.write(`Effective config preview:
+${JSON.stringify(configObject, null, 2)}
+`);
+  }
   if (finalTarget === "package-json") {
-    return runInitInPackageJson(cwd, finalPreset, force);
+    return runInitInPackageJson(cwd, configObject, force);
   }
-  return runInitInFile(cwd, finalPreset, force);
+  return runInitInFile(cwd, configObject, force);
 }
 async function askInitPreferences() {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -432,12 +472,15 @@ async function askInitTarget(rl) {
 }
 async function askInitPreset(rl) {
   while (true) {
-    const answer = await askQuestion(rl, "Select preset:\n  1) minimal (recommended)\n  2) full\nChoose [1]: ");
+    const answer = await askQuestion(
+      rl,
+      "Select preset:\n  1) recommended (group by workspace numbers)\n  2) minimal\n  3) full\nChoose [1]: "
+    );
     const parsed = parseInitPresetChoice(answer);
     if (parsed) {
       return parsed;
     }
-    process.stdout.write("Please choose 1 (minimal) or 2 (full).\n");
+    process.stdout.write("Please choose 1 (recommended), 2 (minimal), or 3 (full).\n");
   }
 }
 function parseInitTargetChoice(value) {
@@ -456,12 +499,15 @@ function parseInitTargetChoice(value) {
 function parseInitPresetChoice(value) {
   const normalized = value.trim().toLowerCase();
   if (normalized === "") {
-    return "minimal";
+    return "recommended";
+  }
+  if (normalized === "1" || normalized === "recommended" || normalized === "rec" || normalized === "grouped") {
+    return "recommended";
   }
-  if (normalized === "1" || normalized === "minimal" || normalized === "min") {
+  if (normalized === "2" || normalized === "minimal" || normalized === "min") {
     return "minimal";
   }
-  if (normalized === "2" || normalized === "full") {
+  if (normalized === "3" || normalized === "full") {
     return "full";
   }
   return void 0;
@@ -486,7 +532,7 @@ async function askYesNo(prompt, defaultYes) {
     rl.close();
   }
 }
-async function runInitInFile(cwd, preset, force) {
+async function runInitInFile(cwd, configObject, force) {
   const candidates = [
     ".eslint-config-snapshot.js",
     ".eslint-config-snapshot.cjs",
@@ -507,12 +553,12 @@ async function runInitInFile(cwd, preset, force) {
     }
   }
   const target = path.join(cwd, "eslint-config-snapshot.config.mjs");
-  await writeFile(target, getConfigScaffold(preset), "utf8");
+  await writeFile(target, toConfigScaffold(configObject), "utf8");
   process.stdout.write(`Created ${path.basename(target)}
 `);
   return 0;
 }
-async function runInitInPackageJson(cwd, preset, force) {
+async function runInitInPackageJson(cwd, configObject, force) {
   const packageJsonPath = path.join(cwd, "package.json");
   let packageJsonRaw;
   try {
@@ -532,12 +578,117 @@ async function runInitInPackageJson(cwd, preset, force) {
     process.stderr.write("Config already exists in package.json: eslint-config-snapshot\n");
     return 1;
   }
-  parsed["eslint-config-snapshot"] = preset === "full" ? getFullPresetObject() : {};
+  parsed["eslint-config-snapshot"] = configObject;
   await writeFile(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
 `, "utf8");
   process.stdout.write('Created config in package.json under "eslint-config-snapshot"\n');
   return 0;
 }
+async function resolveInitConfigObject(cwd, preset, nonInteractive) {
+  if (preset === "minimal") {
+    return {};
+  }
+  if (preset === "full") {
+    return getFullPresetObject();
+  }
+  return buildRecommendedPresetObject(cwd, nonInteractive);
+}
+async function buildRecommendedPresetObject(cwd, nonInteractive) {
+  const workspaces = await discoverInitWorkspaces(cwd);
+  const assignments = new Map(workspaces.map((workspace) => [workspace, 1]));
+  if (!nonInteractive && process.stdin.isTTY && process.stdout.isTTY) {
+    process.stdout.write("Recommended setup: assign a group number for each workspace (default: 1).\n");
+    for (const workspace of workspaces) {
+      const answer = await askGroupNumber(workspace);
+      assignments.set(workspace, answer);
+    }
+  }
+  const groupNumbers = [...new Set(assignments.values())].sort((a, b) => a - b);
+  const groups = groupNumbers.map((number) => ({
+    name: `group-${number}`,
+    match: workspaces.filter((workspace) => assignments.get(workspace) === number)
+  }));
+  return {
+    workspaceInput: { mode: "manual", workspaces },
+    grouping: {
+      mode: "match",
+      groups
+    },
+    sampling: {
+      maxFilesPerWorkspace: 8,
+      includeGlobs: ["**/*.{js,jsx,ts,tsx,cjs,mjs}"],
+      excludeGlobs: ["**/node_modules/**", "**/dist/**"],
+      hintGlobs: []
+    }
+  };
+}
+async function discoverInitWorkspaces(cwd) {
+  const discovered = await discoverWorkspaces({ cwd, workspaceInput: { mode: "discover" } });
+  if (!(discovered.workspacesRel.length === 1 && discovered.workspacesRel[0] === ".")) {
+    return discovered.workspacesRel;
+  }
+  const packageJsonPath = path.join(cwd, "package.json");
+  try {
+    const raw = await readFile(packageJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    let workspacePatterns = [];
+    if (Array.isArray(parsed.workspaces)) {
+      workspacePatterns = parsed.workspaces;
+    } else if (parsed.workspaces && typeof parsed.workspaces === "object" && Array.isArray(parsed.workspaces.packages)) {
+      workspacePatterns = parsed.workspaces.packages;
+    }
+    if (workspacePatterns.length === 0) {
+      return discovered.workspacesRel;
+    }
+    const workspacePackageFiles = await fg(
+      workspacePatterns.map((pattern) => `${trimTrailingSlashes(pattern)}/package.json`),
+      { cwd, onlyFiles: true, dot: true }
+    );
+    const workspaceDirs = [...new Set(workspacePackageFiles.map((entry) => normalizePath(path.dirname(entry))))].sort(
+      (a, b) => a.localeCompare(b)
+    );
+    if (workspaceDirs.length > 0) {
+      return workspaceDirs;
+    }
+  } catch {
+  }
+  return discovered.workspacesRel;
+}
+function trimTrailingSlashes(value) {
+  let normalized = value;
+  while (normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+async function askGroupNumber(workspace) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    while (true) {
+      const answer = await askQuestion(rl, `Group number for ${workspace} [1]: `);
+      const normalized = answer.trim();
+      if (normalized === "") {
+        return 1;
+      }
+      if (/^\d+$/.test(normalized)) {
+        const parsed = Number.parseInt(normalized, 10);
+        if (parsed >= 1) {
+          return parsed;
+        }
+      }
+      process.stdout.write("Please provide a positive integer (1, 2, 3, ...).\n");
+    }
+  } finally {
+    rl.close();
+  }
+}
+function toConfigScaffold(configObject) {
+  if (Object.keys(configObject).length === 0) {
+    return getConfigScaffold("minimal");
+  }
+  return `export default ${JSON.stringify(configObject, null, 2)}
+`;
+}
 function getFullPresetObject() {
   return {
     workspaceInput: { mode: "discover" },
@@ -689,6 +840,19 @@ function formatShortPrint(snapshots) {
   return `${lines.join("\n")}
 `;
 }
+function formatShortConfig(payload) {
+  const lines = [
+    `source: ${payload.source}`,
+    `workspaces (${payload.workspaces.length}): ${payload.workspaces.join(", ") || "(none)"}`,
+    `grouping mode: ${payload.grouping.mode} (allow empty: ${payload.grouping.allowEmptyGroups})`
+  ];
+  for (const group of payload.grouping.groups) {
+    lines.push(`group ${group.name} (${group.workspaces.length}): ${group.workspaces.join(", ") || "(none)"}`);
+  }
+  lines.push(`workspaceInput: ${JSON.stringify(payload.workspaceInput)}`, `sampling: ${JSON.stringify(payload.sampling)}`);
+  return `${lines.join("\n")}
+`;
+}
 export {
   main,
   parseInitPresetChoice,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-config-snapshot/cli",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -29,6 +29,6 @@
   "dependencies": {
     "commander": "^14.0.3",
     "fast-glob": "^3.3.3",
-    "@eslint-config-snapshot/api": "0.1.4"
+    "@eslint-config-snapshot/api": "0.2.0"
   }
 }

package/src/index.ts

@@ -10,6 +10,7 @@ import {
   getConfigScaffold,
   hasDiff,
   loadConfig,
+  normalizePath,
   readSnapshotFile,
   sampleWorkspaceFiles,
   writeSnapshotFile
@@ -30,7 +31,7 @@ type SnapshotDiff = ReturnType<typeof diffSnapshots>
 type CheckFormat = 'summary' | 'status' | 'diff'
 type PrintFormat = 'json' | 'short'
 type InitTarget = 'file' | 'package-json'
-type InitPreset = 'minimal' | 'full'
+type InitPreset = 'recommended' | 'minimal' | 'full'
 
 type RootOptions = {
   update?: boolean
@@ -138,11 +139,23 @@ function createProgram(cwd: string, onActionExit: (code: number) => void): Comma
       onActionExit(0)
     })
 
+  program
+    .command('config')
+    .description('Print effective evaluated config')
+    .option('--format <format>', 'Output format: json|short', parsePrintFormat, 'json')
+    .option('--short', 'Alias for --format short')
+    .action(async (opts: { format: PrintFormat; short?: boolean }) => {
+      const format: PrintFormat = opts.short ? 'short' : opts.format
+      await executeConfig(cwd, format)
+      onActionExit(0)
+    })
+
   program
     .command('init')
     .description('Initialize config (file or package.json)')
     .option('--target <target>', 'Config target: file|package-json', parseInitTarget)
-    .option('--preset <preset>', 'Config preset: minimal|full', parseInitPreset)
+    .option('--preset <preset>', 'Config preset: recommended|minimal|full', parseInitPreset)
+    .option('--show-effective', 'Print the evaluated config that will be written')
     .option('-f, --force', 'Allow init even when an existing config is detected')
     .option('-y, --yes', 'Skip prompts and use defaults/options')
     .addHelpText(
@@ -152,16 +165,17 @@ Examples:
   $ eslint-config-snapshot init
     Runs interactive numbered prompts:
       target: 1) package-json, 2) file
-      preset: 1) minimal, 2) full
+      preset: 1) recommended, 2) minimal, 3) full
+      recommended preset supports per-workspace group number assignment.
 
-  $ eslint-config-snapshot init --yes --target package-json --preset minimal
-    Non-interactive minimal setup in package.json.
+  $ eslint-config-snapshot init --yes --target package-json --preset recommended --show-effective
+    Non-interactive recommended setup in package.json, with effective preview.
 
   $ eslint-config-snapshot init --yes --force --target file --preset full
     Overwrite-safe bypass when a config is already detected.
 `
     )
-    .action(async (opts: { target?: InitTarget; preset?: InitPreset; force?: boolean; yes?: boolean }) => {
+    .action(async (opts: { target?: InitTarget; preset?: InitPreset; force?: boolean; yes?: boolean; showEffective?: boolean }) => {
       onActionExit(await runInit(cwd, opts))
     })
 
@@ -217,11 +231,11 @@ function parseInitTarget(value: string): InitTarget {
 
 function parseInitPreset(value: string): InitPreset {
   const normalized = value.trim().toLowerCase()
-  if (normalized === 'minimal' || normalized === 'full') {
+  if (normalized === 'recommended' || normalized === 'minimal' || normalized === 'full') {
     return normalized
   }
 
-  throw new InvalidArgumentError('Expected one of: minimal, full')
+  throw new InvalidArgumentError('Expected one of: recommended, minimal, full')
 }
 
 async function executeCheck(cwd: string, format: CheckFormat, defaultInvocation = false): Promise<number> {
@@ -349,23 +363,34 @@ async function executePrint(cwd: string, format: PrintFormat): Promise<void> {
   process.stdout.write(`${JSON.stringify(output, null, 2)}\n`)
 }
 
-async function computeCurrentSnapshots(cwd: string): Promise<Map<string, BuiltSnapshot>> {
+async function executeConfig(cwd: string, format: PrintFormat): Promise<void> {
+  const foundConfig = await findConfigPath(cwd)
   const config = await loadConfig(cwd)
-  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: ['**/*'] }])
+  const resolved = await resolveWorkspaceAssignments(cwd, config)
+  const payload = {
+    source: foundConfig?.path ?? 'built-in-defaults',
+    workspaceInput: config.workspaceInput,
+    workspaces: resolved.discovery.workspacesRel,
+    grouping: {
+      mode: config.grouping.mode,
+      allowEmptyGroups: config.grouping.allowEmptyGroups ?? false,
+      groups: resolved.assignments.map((entry) => ({ name: entry.name, workspaces: entry.workspaces }))
+    },
+    sampling: config.sampling
+  }
 
-  const allowEmptyGroups = config.grouping.allowEmptyGroups ?? false
-  if (!allowEmptyGroups) {
-    const empty = assignments.filter((group) => group.workspaces.length === 0)
-    if (empty.length > 0) {
-      throw new Error(`Empty groups are not allowed: ${empty.map((entry) => entry.name).join(', ')}`)
-    }
+  if (format === 'short') {
+    process.stdout.write(formatShortConfig(payload))
+    return
   }
 
+  process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`)
+}
+
+async function computeCurrentSnapshots(cwd: string): Promise<Map<string, BuiltSnapshot>> {
+  const config = await loadConfig(cwd)
+  const { discovery, assignments } = await resolveWorkspaceAssignments(cwd, config)
+
   const snapshots = new Map<string, BuiltSnapshot>()
 
   for (const group of assignments) {
@@ -411,6 +436,25 @@ async function computeCurrentSnapshots(cwd: string): Promise<Map<string, BuiltSn
   return snapshots
 }
 
+async function resolveWorkspaceAssignments(cwd: string, config: Awaited<ReturnType<typeof loadConfig>>) {
+  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: ['**/*'] }])
+
+  const allowEmptyGroups = config.grouping.allowEmptyGroups ?? false
+  if (!allowEmptyGroups) {
+    const empty = assignments.filter((group) => group.workspaces.length === 0)
+    if (empty.length > 0) {
+      throw new Error(`Empty groups are not allowed: ${empty.map((entry) => entry.name).join(', ')}`)
+    }
+  }
+
+  return { discovery, assignments }
+}
+
 async function loadStoredSnapshots(cwd: string): Promise<Map<string, StoredSnapshot>> {
   const dir = path.join(cwd, SNAPSHOT_DIR)
   const files = await fg('**/*.json', { cwd: dir, absolute: true, onlyFiles: true, dot: true, suppressErrors: true })
@@ -515,9 +559,10 @@ function getDisplayOptionChanges(diff: SnapshotDiff): SnapshotDiff['optionChange
 
 async function runInit(
   cwd: string,
-  opts: { target?: InitTarget; preset?: InitPreset; force?: boolean; yes?: boolean } = {}
+  opts: { target?: InitTarget; preset?: InitPreset; force?: boolean; yes?: boolean; showEffective?: boolean } = {}
 ): Promise<number> {
   const force = opts.force ?? false
+  const showEffective = opts.showEffective ?? false
   const existing = await findConfigPath(cwd)
   if (existing && !force) {
     process.stderr.write(
@@ -535,13 +580,18 @@ async function runInit(
   }
 
   const finalTarget = target ?? 'file'
-  const finalPreset = preset ?? 'minimal'
+  const finalPreset = preset ?? 'recommended'
+  const configObject = await resolveInitConfigObject(cwd, finalPreset, Boolean(opts.yes))
+
+  if (showEffective) {
+    process.stdout.write(`Effective config preview:\n${JSON.stringify(configObject, null, 2)}\n`)
+  }
 
   if (finalTarget === 'package-json') {
-    return runInitInPackageJson(cwd, finalPreset, force)
+    return runInitInPackageJson(cwd, configObject, force)
   }
 
-  return runInitInFile(cwd, finalPreset, force)
+  return runInitInFile(cwd, configObject, force)
 }
 
 async function askInitPreferences(): Promise<{ target: InitTarget; preset: InitPreset }> {
@@ -571,12 +621,15 @@ async function askInitTarget(rl: ReturnType<typeof createInterface>): Promise<In
 
 async function askInitPreset(rl: ReturnType<typeof createInterface>): Promise<InitPreset> {
   while (true) {
-    const answer = await askQuestion(rl, 'Select preset:\n  1) minimal (recommended)\n  2) full\nChoose [1]: ')
+    const answer = await askQuestion(
+      rl,
+      'Select preset:\n  1) recommended (group by workspace numbers)\n  2) minimal\n  3) full\nChoose [1]: '
+    )
     const parsed = parseInitPresetChoice(answer)
     if (parsed) {
       return parsed
     }
-    process.stdout.write('Please choose 1 (minimal) or 2 (full).\n')
+    process.stdout.write('Please choose 1 (recommended), 2 (minimal), or 3 (full).\n')
   }
 }
 
@@ -597,12 +650,15 @@ export function parseInitTargetChoice(value: string): InitTarget | undefined {
 export function parseInitPresetChoice(value: string): InitPreset | undefined {
   const normalized = value.trim().toLowerCase()
   if (normalized === '') {
-    return 'minimal'
+    return 'recommended'
   }
-  if (normalized === '1' || normalized === 'minimal' || normalized === 'min') {
+  if (normalized === '1' || normalized === 'recommended' || normalized === 'rec' || normalized === 'grouped') {
+    return 'recommended'
+  }
+  if (normalized === '2' || normalized === 'minimal' || normalized === 'min') {
     return 'minimal'
   }
-  if (normalized === '2' || normalized === 'full') {
+  if (normalized === '3' || normalized === 'full') {
     return 'full'
   }
   return undefined
@@ -631,7 +687,7 @@ async function askYesNo(prompt: string, defaultYes: boolean): Promise<boolean> {
   }
 }
 
-async function runInitInFile(cwd: string, preset: InitPreset, force: boolean): Promise<number> {
+async function runInitInFile(cwd: string, configObject: Record<string, unknown>, force: boolean): Promise<number> {
   const candidates = [
     '.eslint-config-snapshot.js',
     '.eslint-config-snapshot.cjs',
@@ -654,12 +710,12 @@ async function runInitInFile(cwd: string, preset: InitPreset, force: boolean): P
   }
 
   const target = path.join(cwd, 'eslint-config-snapshot.config.mjs')
-  await writeFile(target, getConfigScaffold(preset), 'utf8')
+  await writeFile(target, toConfigScaffold(configObject), 'utf8')
   process.stdout.write(`Created ${path.basename(target)}\n`)
   return 0
 }
 
-async function runInitInPackageJson(cwd: string, preset: InitPreset, force: boolean): Promise<number> {
+async function runInitInPackageJson(cwd: string, configObject: Record<string, unknown>, force: boolean): Promise<number> {
   const packageJsonPath = path.join(cwd, 'package.json')
 
   let packageJsonRaw: string
@@ -683,12 +739,139 @@ async function runInitInPackageJson(cwd: string, preset: InitPreset, force: bool
       return 1
     }
 
-  parsed['eslint-config-snapshot'] = preset === 'full' ? getFullPresetObject() : {}
+  parsed['eslint-config-snapshot'] = configObject
   await writeFile(packageJsonPath, `${JSON.stringify(parsed, null, 2)}\n`, 'utf8')
   process.stdout.write('Created config in package.json under "eslint-config-snapshot"\n')
   return 0
 }
 
+async function resolveInitConfigObject(
+  cwd: string,
+  preset: InitPreset,
+  nonInteractive: boolean
+): Promise<Record<string, unknown>> {
+  if (preset === 'minimal') {
+    return {}
+  }
+
+  if (preset === 'full') {
+    return getFullPresetObject()
+  }
+
+  return buildRecommendedPresetObject(cwd, nonInteractive)
+}
+
+async function buildRecommendedPresetObject(cwd: string, nonInteractive: boolean): Promise<Record<string, unknown>> {
+  const workspaces = await discoverInitWorkspaces(cwd)
+  const assignments = new Map<string, number>(workspaces.map((workspace) => [workspace, 1]))
+
+  if (!nonInteractive && process.stdin.isTTY && process.stdout.isTTY) {
+    process.stdout.write('Recommended setup: assign a group number for each workspace (default: 1).\n')
+    for (const workspace of workspaces) {
+      const answer = await askGroupNumber(workspace)
+      assignments.set(workspace, answer)
+    }
+  }
+
+  const groupNumbers = [...new Set(assignments.values())].sort((a, b) => a - b)
+  const groups = groupNumbers.map((number) => ({
+    name: `group-${number}`,
+    match: workspaces.filter((workspace) => assignments.get(workspace) === number)
+  }))
+
+  return {
+    workspaceInput: { mode: 'manual', workspaces },
+    grouping: {
+      mode: 'match',
+      groups
+    },
+    sampling: {
+      maxFilesPerWorkspace: 8,
+      includeGlobs: ['**/*.{js,jsx,ts,tsx,cjs,mjs}'],
+      excludeGlobs: ['**/node_modules/**', '**/dist/**'],
+      hintGlobs: []
+    }
+  }
+}
+
+async function discoverInitWorkspaces(cwd: string): Promise<string[]> {
+  const discovered = await discoverWorkspaces({ cwd, workspaceInput: { mode: 'discover' } })
+  if (!(discovered.workspacesRel.length === 1 && discovered.workspacesRel[0] === '.')) {
+    return discovered.workspacesRel
+  }
+
+  const packageJsonPath = path.join(cwd, 'package.json')
+  try {
+    const raw = await readFile(packageJsonPath, 'utf8')
+    const parsed = JSON.parse(raw) as { workspaces?: string[] | { packages?: string[] } }
+    let workspacePatterns: string[] = []
+    if (Array.isArray(parsed.workspaces)) {
+      workspacePatterns = parsed.workspaces
+    } else if (parsed.workspaces && typeof parsed.workspaces === 'object' && Array.isArray(parsed.workspaces.packages)) {
+      workspacePatterns = parsed.workspaces.packages
+    }
+
+    if (workspacePatterns.length === 0) {
+      return discovered.workspacesRel
+    }
+
+    const workspacePackageFiles = await fg(
+      workspacePatterns.map((pattern) => `${trimTrailingSlashes(pattern)}/package.json`),
+      { cwd, onlyFiles: true, dot: true }
+    )
+    const workspaceDirs = [...new Set(workspacePackageFiles.map((entry) => normalizePath(path.dirname(entry))))].sort((a, b) =>
+      a.localeCompare(b)
+    )
+    if (workspaceDirs.length > 0) {
+      return workspaceDirs
+    }
+  } catch {
+    // fallback to discovered output
+  }
+
+  return discovered.workspacesRel
+}
+
+function trimTrailingSlashes(value: string): string {
+  let normalized = value
+  while (normalized.endsWith('/')) {
+    normalized = normalized.slice(0, -1)
+  }
+  return normalized
+}
+
+async function askGroupNumber(workspace: string): Promise<number> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+  try {
+    while (true) {
+      const answer = await askQuestion(rl, `Group number for ${workspace} [1]: `)
+      const normalized = answer.trim()
+      if (normalized === '') {
+        return 1
+      }
+
+      if (/^\d+$/.test(normalized)) {
+        const parsed = Number.parseInt(normalized, 10)
+        if (parsed >= 1) {
+          return parsed
+        }
+      }
+
+      process.stdout.write('Please provide a positive integer (1, 2, 3, ...).\n')
+    }
+  } finally {
+    rl.close()
+  }
+}
+
+function toConfigScaffold(configObject: Record<string, unknown>): string {
+  if (Object.keys(configObject).length === 0) {
+    return getConfigScaffold('minimal')
+  }
+
+  return `export default ${JSON.stringify(configObject, null, 2)}\n`
+}
+
 function getFullPresetObject() {
   return {
     workspaceInput: { mode: 'discover' },
@@ -859,3 +1042,22 @@ function formatShortPrint(
 
   return `${lines.join('\n')}\n`
 }
+
+function formatShortConfig(payload: {
+  source: string
+  workspaceInput: unknown
+  workspaces: string[]
+  grouping: { mode: string; allowEmptyGroups: boolean; groups: Array<{ name: string; workspaces: string[] }> }
+  sampling: unknown
+}): string {
+  const lines: string[] = [
+    `source: ${payload.source}`,
+    `workspaces (${payload.workspaces.length}): ${payload.workspaces.join(', ') || '(none)'}`,
+    `grouping mode: ${payload.grouping.mode} (allow empty: ${payload.grouping.allowEmptyGroups})`
+  ]
+  for (const group of payload.grouping.groups) {
+    lines.push(`group ${group.name} (${group.workspaces.length}): ${group.workspaces.join(', ') || '(none)'}`)
+  }
+  lines.push(`workspaceInput: ${JSON.stringify(payload.workspaceInput)}`, `sampling: ${JSON.stringify(payload.sampling)}`)
+  return `${lines.join('\n')}\n`
+}

package/test/cli.integration.test.ts

@@ -47,10 +47,12 @@ describe('cli integration', () => {
   })
 
   it('parses init interactive preset choices from numeric and aliases', () => {
-    expect(parseInitPresetChoice('')).toBe('minimal')
-    expect(parseInitPresetChoice('1')).toBe('minimal')
+    expect(parseInitPresetChoice('')).toBe('recommended')
+    expect(parseInitPresetChoice('1')).toBe('recommended')
+    expect(parseInitPresetChoice('rec')).toBe('recommended')
+    expect(parseInitPresetChoice('2')).toBe('minimal')
     expect(parseInitPresetChoice('min')).toBe('minimal')
-    expect(parseInitPresetChoice('2')).toBe('full')
+    expect(parseInitPresetChoice('3')).toBe('full')
     expect(parseInitPresetChoice('full')).toBe('full')
     expect(parseInitPresetChoice('invalid')).toBeUndefined()
   })
@@ -126,11 +128,22 @@ no-debugger: off
     expect(code).toBe(0)
 
     const content = await readFile(path.join(tmp, 'eslint-config-snapshot.config.mjs'), 'utf8')
-    expect(content).toContain("workspaceInput: { mode: 'discover' }")
+    expect(content).toContain('"workspaceInput"')
+    expect(content).toContain('"grouping"')
+    expect(content).toContain('"sampling"')
 
     await rm(tmp, { recursive: true, force: true })
   })
 
+  it('config prints effective evaluated config and exits 0', async () => {
+    const writeSpy = vi.spyOn(process.stdout, 'write')
+    const code = await runCli('config', fixtureRoot)
+    expect(code).toBe(0)
+    expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('"workspaceInput"'))
+    expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('"workspaces"'))
+    expect(writeSpy).toHaveBeenCalledWith(expect.stringContaining('"groups"'))
+  })
+
   it('init writes minimal config to package.json when target=package-json', async () => {
     const tmp = await mkdtemp(path.join(os.tmpdir(), 'snapshot-init-pkg-'))
     await writeFile(path.join(tmp, 'package.json'), JSON.stringify({ name: 'fixture', private: true }, null, 2))

package/test/cli.terminal.integration.test.ts

@@ -66,6 +66,7 @@ describe('cli terminal invocation', () => {
     expect(result.stdout).toContain('check [options]')
     expect(result.stdout).toContain('update|snapshot')
     expect(result.stdout).toContain('print [options]')
+    expect(result.stdout).toContain('config [options]')
     expect(result.stdout).toContain('init')
     expect(result.stderr).toBe('')
   })
@@ -232,6 +233,15 @@ no-debugger: off
     expect(existing.stderr).toContain('rerun with --force')
   })
 
+  it('config prints effective evaluated config output', () => {
+    const result = run(['config'])
+    expect(result.status).toBe(0)
+    expect(result.stdout).toContain('"workspaceInput"')
+    expect(result.stdout).toContain('"workspaces"')
+    expect(result.stdout).toContain('"groups"')
+    expect(result.stderr).toBe('')
+  })
+
   it('init can write config to package.json', async () => {
     const initRoot = path.join(tmpDir, 'init-package-json-case')
     await rm(initRoot, { recursive: true, force: true })
@@ -250,6 +260,37 @@ no-debugger: off
     expect(parsed['eslint-config-snapshot']).toEqual({})
   })
 
+  it('init recommended writes grouped workspace config in package.json', async () => {
+    const initRoot = path.join(tmpDir, 'init-recommended-package-json-case')
+    await rm(initRoot, { recursive: true, force: true })
+    await cp(fixtureRoot, initRoot, { recursive: true })
+    repoRoot = initRoot
+
+    await rm(path.join(repoRoot, 'eslint-config-snapshot.config.mjs'), { force: true })
+
+    const created = run(['init', '--yes', '--target', 'package-json', '--preset', 'recommended'])
+    expect(created.status).toBe(0)
+    expect(created.stdout).toBe('Created config in package.json under "eslint-config-snapshot"\n')
+    expect(created.stderr).toBe('')
+
+    const packageJsonRaw = await readFile(path.join(repoRoot, 'package.json'), 'utf8')
+    const parsed = JSON.parse(packageJsonRaw) as {
+      'eslint-config-snapshot'?: {
+        workspaceInput?: { mode?: string; workspaces?: string[] }
+        grouping?: { mode?: string; groups?: Array<{ name: string; match: string[] }> }
+      }
+    }
+
+    expect(parsed['eslint-config-snapshot']?.workspaceInput).toEqual({
+      mode: 'manual',
+      workspaces: ['packages/ws-a', 'packages/ws-b']
+    })
+    expect(parsed['eslint-config-snapshot']?.grouping).toEqual({
+      mode: 'match',
+      groups: [{ name: 'group-1', match: ['packages/ws-a', 'packages/ws-b'] }]
+    })
+  })
+
   it('init fails early on existing config unless --force is provided', async () => {
     const initRoot = path.join(tmpDir, 'init-force-case')
     await rm(initRoot, { recursive: true, force: true })
@@ -342,7 +383,8 @@ no-debugger: off
     expect(result.stdout).toContain('-f, --force')
     expect(result.stdout).toContain('Runs interactive numbered prompts:')
     expect(result.stdout).toContain('target: 1) package-json, 2) file')
-    expect(result.stdout).toContain('preset: 1) minimal, 2) full')
+    expect(result.stdout).toContain('preset: 1) recommended, 2) minimal, 3) full')
+    expect(result.stdout).toContain('--show-effective')
     expect(result.stdout).toContain('--yes --force --target file --preset full')
     expect(result.stderr).toBe('')
   })