@eslint-config-snapshot/cli 0.1.5 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @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
+
+- 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

package/README.md

@@ -30,11 +30,20 @@ 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`
 - `update`
 - `print`
+- `config`
 - `init`
 
 Compatibility aliases:

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);
@@ -114,17 +113,21 @@ 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
+    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 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 +170,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 +284,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 +343,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 +436,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,70 +453,42 @@ 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 });
-  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) minimal (recommended)\n  2) full\nChoose [1]: ");
-    const parsed = parseInitPresetChoice(answer);
-    if (parsed) {
-      return parsed;
-    }
-    process.stdout.write("Please choose 1 (minimal) or 2 (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 "minimal";
-  }
-  if (normalized === "1" || normalized === "minimal" || normalized === "min") {
-    return "minimal";
-  }
-  if (normalized === "2" || 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) => {
@@ -508,7 +510,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 +531,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 +556,116 @@ 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 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);
+  if (groupNumbers.length === 0) {
+    return {};
+  }
+  const explicitGroups = groupNumbers.map((number) => ({
+    name: `group-${number}`,
+    match: workspaces.filter((workspace) => assignments.get(workspace) === number)
+  }));
+  return {
+    grouping: {
+      mode: "match",
+      groups: [...explicitGroups, { name: "default", match: ["**/*"] }]
+    }
+  };
+}
+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 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;
+    }
+    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) {
+    return (0, import_api.getConfigScaffold)("minimal");
+  }
+  return `export default ${JSON.stringify(configObject, null, 2)}
+`;
+}
 function getFullPresetObject() {
   return {
     workspaceInput: { mode: "discover" },
@@ -711,10 +817,22 @@ 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 = {
+  buildRecommendedConfigFromAssignments,
   main,
-  parseInitPresetChoice,
-  parseInitTargetChoice,
   runCli
 });