@eslint-config-snapshot/cli 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @eslint-config-snapshot/cli
 
+## 0.3.0
+
+### Minor Changes
+
+- Release minor with inquirer-based init UX and recommended dynamic grouping behavior.
+
+### Patch Changes
+
+- Updated dependencies
+  - @eslint-config-snapshot/api@0.3.0
+
 ## 0.2.0
 
 ### Minor Changes

package/README.md

@@ -30,6 +30,14 @@ Check drift:
 eslint-config-snapshot
 ```
 
+Recommended setup flow:
+
+```bash
+eslint-config-snapshot init
+```
+
+In `recommended` preset, keep default `*` group and only select outlier workspaces via checkbox, assigning numeric groups to those exceptions.
+
 ## Commands
 
 - `check`

package/dist/index.cjs

@@ -31,9 +31,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  buildRecommendedConfigFromAssignments: () => buildRecommendedConfigFromAssignments,
   main: () => main,
-  parseInitPresetChoice: () => parseInitPresetChoice,
-  parseInitTargetChoice: () => parseInitTargetChoice,
   runCli: () => runCli
 });
 module.exports = __toCommonJS(index_exports);
@@ -124,10 +123,8 @@ function createProgram(cwd, onActionExit) {
     `
 Examples:
   $ eslint-config-snapshot init
-    Runs interactive numbered prompts:
-      target: 1) package-json, 2) file
-      preset: 1) recommended, 2) minimal, 3) full
-      recommended preset supports per-workspace group number assignment.
+    Runs interactive select prompts for target/preset.
+    Recommended preset uses checkbox selection for non-default workspaces and group selection.
 
   $ eslint-config-snapshot init --yes --target package-json --preset recommended --show-effective
     Non-interactive recommended setup in package.json, with effective preview.
@@ -469,69 +466,29 @@ ${JSON.stringify(configObject, null, 2)}
   return runInitInFile(cwd, configObject, force);
 }
 async function askInitPreferences() {
-  const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
-  try {
-    const target = await askInitTarget(rl);
-    const preset = await askInitPreset(rl);
-    return { target, preset };
-  } finally {
-    rl.close();
-  }
-}
-async function askInitTarget(rl) {
-  while (true) {
-    const answer = await askQuestion(
-      rl,
-      "Select config target:\n  1) package-json (recommended)\n  2) file\nChoose [1]: "
-    );
-    const parsed = parseInitTargetChoice(answer);
-    if (parsed) {
-      return parsed;
-    }
-    process.stdout.write("Please choose 1 (package-json) or 2 (file).\n");
-  }
-}
-async function askInitPreset(rl) {
-  while (true) {
-    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 (recommended), 2 (minimal), or 3 (full).\n");
-  }
-}
-function parseInitTargetChoice(value) {
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "") {
-    return "package-json";
-  }
-  if (normalized === "1" || normalized === "package-json" || normalized === "packagejson" || normalized === "package" || normalized === "pkg") {
-    return "package-json";
-  }
-  if (normalized === "2" || normalized === "file") {
-    return "file";
-  }
-  return void 0;
+  const { select } = await import("@inquirer/prompts");
+  const target = await askInitTarget(select);
+  const preset = await askInitPreset(select);
+  return { target, preset };
+}
+async function askInitTarget(selectPrompt) {
+  return selectPrompt({
+    message: "Select config target",
+    choices: [
+      { name: "package-json (recommended)", value: "package-json" },
+      { name: "file", value: "file" }
+    ]
+  });
 }
-function parseInitPresetChoice(value) {
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "") {
-    return "recommended";
-  }
-  if (normalized === "1" || normalized === "recommended" || normalized === "rec" || normalized === "grouped") {
-    return "recommended";
-  }
-  if (normalized === "2" || normalized === "minimal" || normalized === "min") {
-    return "minimal";
-  }
-  if (normalized === "3" || normalized === "full") {
-    return "full";
-  }
-  return void 0;
+async function askInitPreset(selectPrompt) {
+  return selectPrompt({
+    message: "Select preset",
+    choices: [
+      { name: 'recommended (default group "*" + static overrides)', value: "recommended" },
+      { name: "minimal", value: "minimal" },
+      { name: "full", value: "full" }
+    ]
+  });
 }
 function askQuestion(rl, prompt) {
   return new Promise((resolve) => {
@@ -616,30 +573,23 @@ async function resolveInitConfigObject(cwd, preset, 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 useInteractiveGrouping = !nonInteractive && process.stdin.isTTY && process.stdout.isTTY;
+  const assignments = useInteractiveGrouping ? await askRecommendedGroupAssignments(workspaces) : /* @__PURE__ */ new Map();
+  return buildRecommendedConfigFromAssignments(workspaces, assignments);
+}
+function buildRecommendedConfigFromAssignments(workspaces, assignments) {
   const groupNumbers = [...new Set(assignments.values())].sort((a, b) => a - b);
-  const groups = groupNumbers.map((number) => ({
+  if (groupNumbers.length === 0) {
+    return {};
+  }
+  const explicitGroups = 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: []
+      groups: [...explicitGroups, { name: "default", match: ["**/*"] }]
     }
   };
 }
@@ -682,26 +632,32 @@ function trimTrailingSlashes(value) {
   }
   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");
+async function askRecommendedGroupAssignments(workspaces) {
+  const { checkbox, select } = await import("@inquirer/prompts");
+  process.stdout.write('Recommended setup: select only workspaces that should leave default group "*".\n');
+  const overrides = await checkbox({
+    message: "Workspaces outside default group:",
+    choices: workspaces.map((workspace) => ({ name: workspace, value: workspace })),
+    pageSize: Math.min(12, Math.max(4, workspaces.length))
+  });
+  const assignments = /* @__PURE__ */ new Map();
+  let nextGroup = 1;
+  for (const workspace of overrides) {
+    const usedGroups = [...new Set(assignments.values())].sort((a, b) => a - b);
+    while (usedGroups.includes(nextGroup)) {
+      nextGroup += 1;
     }
-  } finally {
-    rl.close();
+    const selected = await select({
+      message: `Select group for ${workspace}`,
+      choices: [
+        ...usedGroups.map((group) => ({ name: `group-${group}`, value: group })),
+        { name: `create new group (group-${nextGroup})`, value: "new" }
+      ]
+    });
+    const groupNumber = selected === "new" ? nextGroup : selected;
+    assignments.set(workspace, groupNumber);
   }
+  return assignments;
 }
 function toConfigScaffold(configObject) {
   if (Object.keys(configObject).length === 0) {
@@ -876,8 +832,7 @@ function formatShortConfig(payload) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  buildRecommendedConfigFromAssignments,
   main,
-  parseInitPresetChoice,
-  parseInitTargetChoice,
   runCli
 });

package/dist/index.js

@@ -103,10 +103,8 @@ function createProgram(cwd, onActionExit) {
     `
 Examples:
   $ eslint-config-snapshot init
-    Runs interactive numbered prompts:
-      target: 1) package-json, 2) file
-      preset: 1) recommended, 2) minimal, 3) full
-      recommended preset supports per-workspace group number assignment.
+    Runs interactive select prompts for target/preset.
+    Recommended preset uses checkbox selection for non-default workspaces and group selection.
 
   $ eslint-config-snapshot init --yes --target package-json --preset recommended --show-effective
     Non-interactive recommended setup in package.json, with effective preview.
@@ -448,69 +446,29 @@ ${JSON.stringify(configObject, null, 2)}
   return runInitInFile(cwd, configObject, force);
 }
 async function askInitPreferences() {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    const target = await askInitTarget(rl);
-    const preset = await askInitPreset(rl);
-    return { target, preset };
-  } finally {
-    rl.close();
-  }
-}
-async function askInitTarget(rl) {
-  while (true) {
-    const answer = await askQuestion(
-      rl,
-      "Select config target:\n  1) package-json (recommended)\n  2) file\nChoose [1]: "
-    );
-    const parsed = parseInitTargetChoice(answer);
-    if (parsed) {
-      return parsed;
-    }
-    process.stdout.write("Please choose 1 (package-json) or 2 (file).\n");
-  }
-}
-async function askInitPreset(rl) {
-  while (true) {
-    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 (recommended), 2 (minimal), or 3 (full).\n");
-  }
-}
-function parseInitTargetChoice(value) {
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "") {
-    return "package-json";
-  }
-  if (normalized === "1" || normalized === "package-json" || normalized === "packagejson" || normalized === "package" || normalized === "pkg") {
-    return "package-json";
-  }
-  if (normalized === "2" || normalized === "file") {
-    return "file";
-  }
-  return void 0;
+  const { select } = await import("@inquirer/prompts");
+  const target = await askInitTarget(select);
+  const preset = await askInitPreset(select);
+  return { target, preset };
+}
+async function askInitTarget(selectPrompt) {
+  return selectPrompt({
+    message: "Select config target",
+    choices: [
+      { name: "package-json (recommended)", value: "package-json" },
+      { name: "file", value: "file" }
+    ]
+  });
 }
-function parseInitPresetChoice(value) {
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "") {
-    return "recommended";
-  }
-  if (normalized === "1" || normalized === "recommended" || normalized === "rec" || normalized === "grouped") {
-    return "recommended";
-  }
-  if (normalized === "2" || normalized === "minimal" || normalized === "min") {
-    return "minimal";
-  }
-  if (normalized === "3" || normalized === "full") {
-    return "full";
-  }
-  return void 0;
+async function askInitPreset(selectPrompt) {
+  return selectPrompt({
+    message: "Select preset",
+    choices: [
+      { name: 'recommended (default group "*" + static overrides)', value: "recommended" },
+      { name: "minimal", value: "minimal" },
+      { name: "full", value: "full" }
+    ]
+  });
 }
 function askQuestion(rl, prompt) {
   return new Promise((resolve) => {
@@ -595,30 +553,23 @@ async function resolveInitConfigObject(cwd, preset, 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 useInteractiveGrouping = !nonInteractive && process.stdin.isTTY && process.stdout.isTTY;
+  const assignments = useInteractiveGrouping ? await askRecommendedGroupAssignments(workspaces) : /* @__PURE__ */ new Map();
+  return buildRecommendedConfigFromAssignments(workspaces, assignments);
+}
+function buildRecommendedConfigFromAssignments(workspaces, assignments) {
   const groupNumbers = [...new Set(assignments.values())].sort((a, b) => a - b);
-  const groups = groupNumbers.map((number) => ({
+  if (groupNumbers.length === 0) {
+    return {};
+  }
+  const explicitGroups = 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: []
+      groups: [...explicitGroups, { name: "default", match: ["**/*"] }]
     }
   };
 }
@@ -661,26 +612,32 @@ function trimTrailingSlashes(value) {
   }
   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");
+async function askRecommendedGroupAssignments(workspaces) {
+  const { checkbox, select } = await import("@inquirer/prompts");
+  process.stdout.write('Recommended setup: select only workspaces that should leave default group "*".\n');
+  const overrides = await checkbox({
+    message: "Workspaces outside default group:",
+    choices: workspaces.map((workspace) => ({ name: workspace, value: workspace })),
+    pageSize: Math.min(12, Math.max(4, workspaces.length))
+  });
+  const assignments = /* @__PURE__ */ new Map();
+  let nextGroup = 1;
+  for (const workspace of overrides) {
+    const usedGroups = [...new Set(assignments.values())].sort((a, b) => a - b);
+    while (usedGroups.includes(nextGroup)) {
+      nextGroup += 1;
     }
-  } finally {
-    rl.close();
+    const selected = await select({
+      message: `Select group for ${workspace}`,
+      choices: [
+        ...usedGroups.map((group) => ({ name: `group-${group}`, value: group })),
+        { name: `create new group (group-${nextGroup})`, value: "new" }
+      ]
+    });
+    const groupNumber = selected === "new" ? nextGroup : selected;
+    assignments.set(workspace, groupNumber);
   }
+  return assignments;
 }
 function toConfigScaffold(configObject) {
   if (Object.keys(configObject).length === 0) {
@@ -854,8 +811,7 @@ function formatShortConfig(payload) {
 `;
 }
 export {
+  buildRecommendedConfigFromAssignments,
   main,
-  parseInitPresetChoice,
-  parseInitTargetChoice,
   runCli
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-config-snapshot/cli",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -27,8 +27,9 @@
     }
   },
   "dependencies": {
+    "@inquirer/prompts": "^8.2.0",
     "commander": "^14.0.3",
     "fast-glob": "^3.3.3",
-    "@eslint-config-snapshot/api": "0.2.0"
+    "@eslint-config-snapshot/api": "0.3.0"
   }
 }

package/src/index.ts

@@ -163,10 +163,8 @@ function createProgram(cwd: string, onActionExit: (code: number) => void): Comma
       `
 Examples:
   $ eslint-config-snapshot init
-    Runs interactive numbered prompts:
-      target: 1) package-json, 2) file
-      preset: 1) recommended, 2) minimal, 3) full
-      recommended preset supports per-workspace group number assignment.
+    Runs interactive select prompts for target/preset.
+    Recommended preset uses checkbox selection for non-default workspaces and group selection.
 
   $ eslint-config-snapshot init --yes --target package-json --preset recommended --show-effective
     Non-interactive recommended setup in package.json, with effective preview.
@@ -595,73 +593,35 @@ async function runInit(
 }
 
 async function askInitPreferences(): Promise<{ target: InitTarget; preset: InitPreset }> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout })
-  try {
-    const target = await askInitTarget(rl)
-    const preset = await askInitPreset(rl)
-    return { target, preset }
-  } finally {
-    rl.close()
-  }
+  const { select } = await import('@inquirer/prompts')
+  const target = await askInitTarget(select)
+  const preset = await askInitPreset(select)
+  return { target, preset }
 }
 
-async function askInitTarget(rl: ReturnType<typeof createInterface>): Promise<InitTarget> {
-  while (true) {
-    const answer = await askQuestion(
-      rl,
-      'Select config target:\n  1) package-json (recommended)\n  2) file\nChoose [1]: '
-    )
-    const parsed = parseInitTargetChoice(answer)
-    if (parsed) {
-      return parsed
-    }
-    process.stdout.write('Please choose 1 (package-json) or 2 (file).\n')
-  }
-}
-
-async function askInitPreset(rl: ReturnType<typeof createInterface>): Promise<InitPreset> {
-  while (true) {
-    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 (recommended), 2 (minimal), or 3 (full).\n')
-  }
-}
-
-export function parseInitTargetChoice(value: string): InitTarget | undefined {
-  const normalized = value.trim().toLowerCase()
-  if (normalized === '') {
-    return 'package-json'
-  }
-  if (normalized === '1' || normalized === 'package-json' || normalized === 'packagejson' || normalized === 'package' || normalized === 'pkg') {
-    return 'package-json'
-  }
-  if (normalized === '2' || normalized === 'file') {
-    return 'file'
-  }
-  return undefined
+async function askInitTarget(
+  selectPrompt: (options: { message: string; choices: Array<{ name: string; value: InitTarget }> }) => Promise<InitTarget>
+): Promise<InitTarget> {
+  return selectPrompt({
+    message: 'Select config target',
+    choices: [
+      { name: 'package-json (recommended)', value: 'package-json' },
+      { name: 'file', value: 'file' }
+    ]
+  })
 }
 
-export function parseInitPresetChoice(value: string): InitPreset | undefined {
-  const normalized = value.trim().toLowerCase()
-  if (normalized === '') {
-    return 'recommended'
-  }
-  if (normalized === '1' || normalized === 'recommended' || normalized === 'rec' || normalized === 'grouped') {
-    return 'recommended'
-  }
-  if (normalized === '2' || normalized === 'minimal' || normalized === 'min') {
-    return 'minimal'
-  }
-  if (normalized === '3' || normalized === 'full') {
-    return 'full'
-  }
-  return undefined
+async function askInitPreset(
+  selectPrompt: (options: { message: string; choices: Array<{ name: string; value: InitPreset }> }) => Promise<InitPreset>
+): Promise<InitPreset> {
+  return selectPrompt({
+    message: 'Select preset',
+    choices: [
+      { name: 'recommended (default group "*" + static overrides)', value: 'recommended' },
+      { name: 'minimal', value: 'minimal' },
+      { name: 'full', value: 'full' }
+    ]
+  })
 }
 
 function askQuestion(rl: ReturnType<typeof createInterface>, prompt: string): Promise<string> {
@@ -763,33 +723,29 @@ async function resolveInitConfigObject(
 
 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]))
+  const useInteractiveGrouping = !nonInteractive && process.stdin.isTTY && process.stdout.isTTY
+  const assignments = useInteractiveGrouping ? await askRecommendedGroupAssignments(workspaces) : new Map<string, number>()
+  return buildRecommendedConfigFromAssignments(workspaces, assignments)
+}
 
-  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)
-    }
+export function buildRecommendedConfigFromAssignments(
+  workspaces: string[],
+  assignments: Map<string, number>
+): Record<string, unknown> {
+  const groupNumbers = [...new Set(assignments.values())].sort((a, b) => a - b)
+  if (groupNumbers.length === 0) {
+    return {}
   }
 
-  const groupNumbers = [...new Set(assignments.values())].sort((a, b) => a - b)
-  const groups = groupNumbers.map((number) => ({
+  const explicitGroups = 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: []
+      groups: [...explicitGroups, { name: 'default', match: ['**/*'] }]
     }
   }
 }
@@ -840,28 +796,35 @@ function trimTrailingSlashes(value: string): string {
   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
-        }
-      }
+async function askRecommendedGroupAssignments(workspaces: string[]): Promise<Map<string, number>> {
+  const { checkbox, select } = await import('@inquirer/prompts')
+  process.stdout.write('Recommended setup: select only workspaces that should leave default group "*".\n')
+  const overrides = await checkbox<string>({
+    message: 'Workspaces outside default group:',
+    choices: workspaces.map((workspace) => ({ name: workspace, value: workspace })),
+    pageSize: Math.min(12, Math.max(4, workspaces.length))
+  })
 
-      process.stdout.write('Please provide a positive integer (1, 2, 3, ...).\n')
+  const assignments = new Map<string, number>()
+  let nextGroup = 1
+  for (const workspace of overrides) {
+    const usedGroups = [...new Set(assignments.values())].sort((a, b) => a - b)
+    while (usedGroups.includes(nextGroup)) {
+      nextGroup += 1
     }
-  } finally {
-    rl.close()
+
+    const selected = await select<number | 'new'>({
+      message: `Select group for ${workspace}`,
+      choices: [
+        ...usedGroups.map((group) => ({ name: `group-${group}`, value: group })),
+        { name: `create new group (group-${nextGroup})`, value: 'new' }
+      ]
+    })
+    const groupNumber = selected === 'new' ? nextGroup : selected
+    assignments.set(workspace, groupNumber)
   }
+
+  return assignments
 }
 
 function toConfigScaffold(configObject: Record<string, unknown>): string {

package/test/cli.integration.test.ts

@@ -1,18 +1,19 @@
 import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
-import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import { parseInitPresetChoice, parseInitTargetChoice, runCli } from '../src/index.js'
+import { buildRecommendedConfigFromAssignments, runCli } from '../src/index.js'
 
-const fixtureRoot = path.resolve('test/fixtures/repo')
-
-afterAll(async () => {
-  await rm(path.join(fixtureRoot, '.eslint-config-snapshot'), { recursive: true, force: true })
-})
+const fixtureTemplateRoot = path.resolve('test/fixtures/repo')
+let tmpDir = ''
+let fixtureRoot = ''
 
 beforeEach(async () => {
-  await rm(path.join(fixtureRoot, '.eslint-config-snapshot'), { recursive: true, force: true })
+  tmpDir = await mkdtemp(path.join(os.tmpdir(), 'snapshot-cli-integration-'))
+  fixtureRoot = path.join(tmpDir, 'repo')
+  await cp(fixtureTemplateRoot, fixtureRoot, { recursive: true })
+
   await mkdir(path.join(fixtureRoot, 'packages/ws-a/node_modules/eslint/bin'), { recursive: true })
   await mkdir(path.join(fixtureRoot, 'packages/ws-b/node_modules/eslint/bin'), { recursive: true })
 
@@ -35,26 +36,31 @@ beforeEach(async () => {
   )
 })
 
-describe('cli integration', () => {
-  it('parses init interactive target choices from numeric and aliases', () => {
-    expect(parseInitTargetChoice('')).toBe('package-json')
-    expect(parseInitTargetChoice('1')).toBe('package-json')
-    expect(parseInitTargetChoice('package')).toBe('package-json')
-    expect(parseInitTargetChoice('pkg')).toBe('package-json')
-    expect(parseInitTargetChoice('2')).toBe('file')
-    expect(parseInitTargetChoice('file')).toBe('file')
-    expect(parseInitTargetChoice('invalid')).toBeUndefined()
+afterEach(async () => {
+  if (tmpDir) {
+    await rm(tmpDir, { recursive: true, force: true })
+    tmpDir = ''
+    fixtureRoot = ''
+  }
+})
+
+describe.sequential('cli integration', () => {
+  it('builds recommended config as dynamic-only when no static overrides are selected', () => {
+    const config = buildRecommendedConfigFromAssignments(['packages/ws-a', 'packages/ws-b'], new Map())
+    expect(config).toEqual({})
   })
 
-  it('parses init interactive preset choices from numeric and aliases', () => {
-    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('3')).toBe('full')
-    expect(parseInitPresetChoice('full')).toBe('full')
-    expect(parseInitPresetChoice('invalid')).toBeUndefined()
+  it('builds recommended config with static overrides plus dynamic catch-all', () => {
+    const config = buildRecommendedConfigFromAssignments(['packages/ws-a', 'packages/ws-b'], new Map([['packages/ws-b', 2]]))
+    expect(config).toEqual({
+      grouping: {
+        mode: 'match',
+        groups: [
+          { name: 'group-2', match: ['packages/ws-b'] },
+          { name: 'default', match: ['**/*'] }
+        ]
+      }
+    })
   })
 
   it('snapshot writes deterministic snapshot files', async () => {

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

@@ -275,20 +275,27 @@ no-debugger: off
 
     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[] }> }
-      }
+      'eslint-config-snapshot'?: Record<string, unknown>
     }
 
-    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'] }]
-    })
+    expect(parsed['eslint-config-snapshot']).toEqual({})
+  })
+
+  it('init recommended --show-effective prints preview without explicit sampling block', async () => {
+    const initRoot = path.join(tmpDir, 'init-recommended-preview-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 result = run(['init', '--yes', '--target', 'package-json', '--preset', 'recommended', '--show-effective'])
+    expect(result.status).toBe(0)
+    expect(result.stdout).toContain('Effective config preview:')
+    expect(result.stdout).toContain('{}')
+    expect(result.stdout).not.toContain('"workspaceInput"')
+    expect(result.stdout).not.toContain('"grouping"')
+    expect(result.stdout).not.toContain('"sampling"')
   })
 
   it('init fails early on existing config unless --force is provided', async () => {
@@ -376,14 +383,13 @@ no-debugger: off
     expect(result.stderr).toBe('')
   })
 
-  it('prints init help with numbered prompt and force guidance', () => {
+  it('prints init help with select-prompt and force guidance', () => {
     const result = run(['init', '--help'])
     expect(result.status).toBe(0)
     expect(result.stdout).toContain('Initialize config (file or package.json)')
     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) recommended, 2) minimal, 3) full')
+    expect(result.stdout).toContain('Runs interactive select prompts for target/preset.')
+    expect(result.stdout).toContain('Recommended preset uses checkbox selection')
     expect(result.stdout).toContain('--show-effective')
     expect(result.stdout).toContain('--yes --force --target file --preset full')
     expect(result.stderr).toBe('')

package/test/fixtures/repo/packages/ws-a/node_modules/eslint/bin/eslint.js

@@ -1 +0,0 @@
-console.log(JSON.stringify({ rules: { 'no-console': 1, eqeqeq: [2, 'always'] } }))

package/test/fixtures/repo/packages/ws-a/node_modules/eslint/package.json

@@ -1,4 +0,0 @@
-{
-  "name": "eslint",
-  "version": "9.0.0"
-}

package/test/fixtures/repo/packages/ws-b/node_modules/eslint/bin/eslint.js

@@ -1 +0,0 @@
-console.log(JSON.stringify({ rules: { 'no-console': 2, 'no-debugger': 0 } }))

package/test/fixtures/repo/packages/ws-b/node_modules/eslint/package.json

@@ -1,4 +0,0 @@
-{
-  "name": "eslint",
-  "version": "9.0.0"
-}