@eslint-config-snapshot/api 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @eslint-config-snapshot/api
 
+## 0.4.0
+
+### Minor Changes
+
+- Minor release with improved CLI output consistency and faster workspace extraction using ESLint API fallback strategy.
+
+## 0.3.2
+
+### Patch Changes
+
+- Fix deterministic aggregation when same-severity ESLint rule options differ across sampled files, preventing update crashes.
+
+## 0.3.1
+
+### Patch Changes
+
+- Release patch bump after init UX clarity improvements for default catch-all group messaging.
+
 ## 0.3.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -38,6 +38,7 @@ __export(index_exports, {
   compareSeverity: () => compareSeverity,
   diffSnapshots: () => diffSnapshots,
   discoverWorkspaces: () => discoverWorkspaces,
+  extractRulesForWorkspaceSamples: () => extractRulesForWorkspaceSamples,
   extractRulesFromPrintConfig: () => extractRulesFromPrintConfig,
   findConfigPath: () => findConfigPath,
   getConfigScaffold: () => getConfigScaffold,
@@ -288,6 +289,7 @@ var import_node_child_process = require("child_process");
 var import_node_fs = require("fs");
 var import_node_module = require("module");
 var import_node_path2 = __toESM(require("path"), 1);
+var import_node_url = require("url");
 function resolveEslintBinForWorkspace(workspaceAbs) {
   const anchor = import_node_path2.default.join(workspaceAbs, "__snapshot_anchor__.cjs");
   const req = (0, import_node_module.createRequire)(anchor);
@@ -352,6 +354,44 @@ function extractRulesFromPrintConfig(workspaceAbs, fileAbs) {
     throw new Error(`Invalid JSON from eslint --print-config for ${fileAbs}`);
   }
   const rules = parsed.rules ?? {};
+  return normalizeRules(rules);
+}
+async function extractRulesForWorkspaceSamples(workspaceAbs, fileAbsList) {
+  const evaluate = await createWorkspaceEvaluator(workspaceAbs);
+  const results = [];
+  for (const fileAbs of fileAbsList) {
+    try {
+      const rules = await evaluate(fileAbs);
+      results.push({ fileAbs, rules });
+    } catch (error) {
+      const normalizedError = error instanceof Error ? error : new Error(String(error));
+      results.push({ fileAbs, error: normalizedError });
+    }
+  }
+  return results;
+}
+async function createWorkspaceEvaluator(workspaceAbs) {
+  try {
+    const anchor = import_node_path2.default.join(workspaceAbs, "__snapshot_anchor__.cjs");
+    const req = (0, import_node_module.createRequire)(anchor);
+    const eslintModuleEntry = req.resolve("eslint");
+    const eslintModule = await import((0, import_node_url.pathToFileURL)(eslintModuleEntry).href);
+    const ESLintClass = eslintModule.ESLint ?? eslintModule.default?.ESLint;
+    if (ESLintClass) {
+      const eslint = new ESLintClass({ cwd: workspaceAbs });
+      return async (fileAbs) => {
+        const config = await eslint.calculateConfigForFile(fileAbs);
+        if (!config || typeof config !== "object") {
+          throw new Error(`Empty ESLint print-config output for ${fileAbs}`);
+        }
+        return normalizeRules(config.rules ?? {});
+      };
+    }
+  } catch {
+  }
+  return (fileAbs) => Promise.resolve(extractRulesFromPrintConfig(workspaceAbs, fileAbs));
+}
+function normalizeRules(rules) {
   const normalized = /* @__PURE__ */ new Map();
   for (const [ruleName, ruleConfig] of Object.entries(rules)) {
     normalized.set(ruleName, normalizeRuleEntry(ruleConfig));
@@ -398,8 +438,20 @@ function aggregateRules(ruleMaps) {
       }
       const currentOptions = currentEntry.length > 1 ? canonicalizeJson(currentEntry[1]) : void 0;
       const nextOptions = nextEntry.length > 1 ? canonicalizeJson(nextEntry[1]) : void 0;
-      if (JSON.stringify(currentOptions) !== JSON.stringify(nextOptions)) {
-        throw new Error(`Conflicting rule options for ${ruleName} at severity ${currentEntry[0]}`);
+      if (currentOptions === void 0 && nextOptions !== void 0) {
+        aggregated.set(ruleName, canonicalizeJson(nextEntry));
+        continue;
+      }
+      if (currentOptions !== void 0 && nextOptions === void 0) {
+        continue;
+      }
+      if (currentOptions === void 0 && nextOptions === void 0) {
+        continue;
+      }
+      const currentJson = JSON.stringify(currentOptions);
+      const nextJson = JSON.stringify(nextOptions);
+      if (nextJson < currentJson) {
+        aggregated.set(ruleName, canonicalizeJson(nextEntry));
       }
     }
   }
@@ -595,6 +647,7 @@ function getConfigScaffold(preset = "minimal") {
   compareSeverity,
   diffSnapshots,
   discoverWorkspaces,
+  extractRulesForWorkspaceSamples,
   extractRulesFromPrintConfig,
   findConfigPath,
   getConfigScaffold,

package/dist/index.js

@@ -233,6 +233,7 @@ import { spawnSync } from "child_process";
 import { existsSync, readFileSync } from "fs";
 import { createRequire } from "module";
 import path2 from "path";
+import { pathToFileURL } from "url";
 function resolveEslintBinForWorkspace(workspaceAbs) {
   const anchor = path2.join(workspaceAbs, "__snapshot_anchor__.cjs");
   const req = createRequire(anchor);
@@ -297,6 +298,44 @@ function extractRulesFromPrintConfig(workspaceAbs, fileAbs) {
     throw new Error(`Invalid JSON from eslint --print-config for ${fileAbs}`);
   }
   const rules = parsed.rules ?? {};
+  return normalizeRules(rules);
+}
+async function extractRulesForWorkspaceSamples(workspaceAbs, fileAbsList) {
+  const evaluate = await createWorkspaceEvaluator(workspaceAbs);
+  const results = [];
+  for (const fileAbs of fileAbsList) {
+    try {
+      const rules = await evaluate(fileAbs);
+      results.push({ fileAbs, rules });
+    } catch (error) {
+      const normalizedError = error instanceof Error ? error : new Error(String(error));
+      results.push({ fileAbs, error: normalizedError });
+    }
+  }
+  return results;
+}
+async function createWorkspaceEvaluator(workspaceAbs) {
+  try {
+    const anchor = path2.join(workspaceAbs, "__snapshot_anchor__.cjs");
+    const req = createRequire(anchor);
+    const eslintModuleEntry = req.resolve("eslint");
+    const eslintModule = await import(pathToFileURL(eslintModuleEntry).href);
+    const ESLintClass = eslintModule.ESLint ?? eslintModule.default?.ESLint;
+    if (ESLintClass) {
+      const eslint = new ESLintClass({ cwd: workspaceAbs });
+      return async (fileAbs) => {
+        const config = await eslint.calculateConfigForFile(fileAbs);
+        if (!config || typeof config !== "object") {
+          throw new Error(`Empty ESLint print-config output for ${fileAbs}`);
+        }
+        return normalizeRules(config.rules ?? {});
+      };
+    }
+  } catch {
+  }
+  return (fileAbs) => Promise.resolve(extractRulesFromPrintConfig(workspaceAbs, fileAbs));
+}
+function normalizeRules(rules) {
   const normalized = /* @__PURE__ */ new Map();
   for (const [ruleName, ruleConfig] of Object.entries(rules)) {
     normalized.set(ruleName, normalizeRuleEntry(ruleConfig));
@@ -343,8 +382,20 @@ function aggregateRules(ruleMaps) {
       }
       const currentOptions = currentEntry.length > 1 ? canonicalizeJson(currentEntry[1]) : void 0;
       const nextOptions = nextEntry.length > 1 ? canonicalizeJson(nextEntry[1]) : void 0;
-      if (JSON.stringify(currentOptions) !== JSON.stringify(nextOptions)) {
-        throw new Error(`Conflicting rule options for ${ruleName} at severity ${currentEntry[0]}`);
+      if (currentOptions === void 0 && nextOptions !== void 0) {
+        aggregated.set(ruleName, canonicalizeJson(nextEntry));
+        continue;
+      }
+      if (currentOptions !== void 0 && nextOptions === void 0) {
+        continue;
+      }
+      if (currentOptions === void 0 && nextOptions === void 0) {
+        continue;
+      }
+      const currentJson = JSON.stringify(currentOptions);
+      const nextJson = JSON.stringify(nextOptions);
+      if (nextJson < currentJson) {
+        aggregated.set(ruleName, canonicalizeJson(nextEntry));
       }
     }
   }
@@ -539,6 +590,7 @@ export {
   compareSeverity,
   diffSnapshots,
   discoverWorkspaces,
+  extractRulesForWorkspaceSamples,
   extractRulesFromPrintConfig,
   findConfigPath,
   getConfigScaffold,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-config-snapshot/api",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "repository": {
     "type": "git",

package/src/extract.ts

@@ -2,12 +2,14 @@ import { spawnSync } from 'node:child_process'
 import { existsSync, readFileSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import path from 'node:path'
+import { pathToFileURL } from 'node:url'
 
 import { canonicalizeJson, normalizeSeverity } from './core.js'
 
 export type NormalizedRuleEntry = [severity: 'off' | 'warn' | 'error'] | [severity: 'off' | 'warn' | 'error', options: unknown]
 
 export type ExtractedWorkspaceRules = Map<string, NormalizedRuleEntry>
+export type WorkspaceExtractionResult = { fileAbs: string; rules?: ExtractedWorkspaceRules; error?: Error }
 
 export function resolveEslintBinForWorkspace(workspaceAbs: string): string {
   const anchor = path.join(workspaceAbs, '__snapshot_anchor__.cjs')
@@ -86,6 +88,61 @@ export function extractRulesFromPrintConfig(workspaceAbs: string, fileAbs: strin
   }
 
   const rules = (parsed as { rules?: Record<string, unknown> }).rules ?? {}
+  return normalizeRules(rules)
+}
+
+export async function extractRulesForWorkspaceSamples(
+  workspaceAbs: string,
+  fileAbsList: string[]
+): Promise<WorkspaceExtractionResult[]> {
+  const evaluate = await createWorkspaceEvaluator(workspaceAbs)
+  const results: WorkspaceExtractionResult[] = []
+
+  for (const fileAbs of fileAbsList) {
+    try {
+      const rules = await evaluate(fileAbs)
+      results.push({ fileAbs, rules })
+    } catch (error: unknown) {
+      const normalizedError = error instanceof Error ? error : new Error(String(error))
+      results.push({ fileAbs, error: normalizedError })
+    }
+  }
+
+  return results
+}
+
+async function createWorkspaceEvaluator(
+  workspaceAbs: string
+): Promise<(fileAbs: string) => Promise<ExtractedWorkspaceRules>> {
+  try {
+    const anchor = path.join(workspaceAbs, '__snapshot_anchor__.cjs')
+    const req = createRequire(anchor)
+    const eslintModuleEntry = req.resolve('eslint')
+    const eslintModule = (await import(pathToFileURL(eslintModuleEntry).href)) as {
+      ESLint?: new (options: { cwd: string }) => { calculateConfigForFile: (fileAbs: string) => Promise<{ rules?: Record<string, unknown> } | undefined> }
+      default?: { ESLint?: new (options: { cwd: string }) => { calculateConfigForFile: (fileAbs: string) => Promise<{ rules?: Record<string, unknown> } | undefined> } }
+    }
+
+    const ESLintClass = eslintModule.ESLint ?? eslintModule.default?.ESLint
+    if (ESLintClass) {
+      const eslint = new ESLintClass({ cwd: workspaceAbs })
+      return async (fileAbs: string) => {
+        const config = await eslint.calculateConfigForFile(fileAbs)
+        if (!config || typeof config !== 'object') {
+          throw new Error(`Empty ESLint print-config output for ${fileAbs}`)
+        }
+
+        return normalizeRules(config.rules ?? {})
+      }
+    }
+  } catch {
+    // fall through to subprocess-based extractor
+  }
+
+  return (fileAbs: string) => Promise.resolve(extractRulesFromPrintConfig(workspaceAbs, fileAbs))
+}
+
+function normalizeRules(rules: Record<string, unknown>): ExtractedWorkspaceRules {
   const normalized = new Map<string, NormalizedRuleEntry>()
 
   for (const [ruleName, ruleConfig] of Object.entries(rules)) {

package/src/index.ts

@@ -7,8 +7,8 @@ export type { GroupAssignment, GroupDefinition, WorkspaceDiscovery, WorkspaceInp
 export { sampleWorkspaceFiles } from './sampling.js'
 export type { SamplingConfig } from './sampling.js'
 
-export { extractRulesFromPrintConfig, resolveEslintBinForWorkspace } from './extract.js'
-export type { ExtractedWorkspaceRules, NormalizedRuleEntry } from './extract.js'
+export { extractRulesForWorkspaceSamples, extractRulesFromPrintConfig, resolveEslintBinForWorkspace } from './extract.js'
+export type { ExtractedWorkspaceRules, NormalizedRuleEntry, WorkspaceExtractionResult } from './extract.js'
 
 export { aggregateRules, buildSnapshot, readSnapshotFile, writeSnapshotFile } from './snapshot.js'
 export type { SnapshotFile } from './snapshot.js'

package/src/snapshot.ts

@@ -36,8 +36,23 @@ export function aggregateRules(ruleMaps: readonly Map<string, NormalizedRuleEntr
       const currentOptions = currentEntry.length > 1 ? canonicalizeJson(currentEntry[1]) : undefined
       const nextOptions = nextEntry.length > 1 ? canonicalizeJson(nextEntry[1]) : undefined
 
-      if (JSON.stringify(currentOptions) !== JSON.stringify(nextOptions)) {
-        throw new Error(`Conflicting rule options for ${ruleName} at severity ${currentEntry[0]}`)
+      if (currentOptions === undefined && nextOptions !== undefined) {
+        aggregated.set(ruleName, canonicalizeJson(nextEntry))
+        continue
+      }
+
+      if (currentOptions !== undefined && nextOptions === undefined) {
+        continue
+      }
+
+      if (currentOptions === undefined && nextOptions === undefined) {
+        continue
+      }
+
+      const currentJson = JSON.stringify(currentOptions)
+      const nextJson = JSON.stringify(nextOptions)
+      if (nextJson < currentJson) {
+        aggregated.set(ruleName, canonicalizeJson(nextEntry))
       }
     }
   }

package/test/extract.test.ts

@@ -3,7 +3,7 @@ import os from 'node:os'
 import path from 'node:path'
 import { afterAll, describe, expect, it } from 'vitest'
 
-import { extractRulesFromPrintConfig, resolveEslintBinForWorkspace } from '../src/index.js'
+import { extractRulesForWorkspaceSamples, extractRulesFromPrintConfig, resolveEslintBinForWorkspace } from '../src/index.js'
 
 const workspace = path.join(os.tmpdir(), `snapshot-extract-${Date.now()}`)
 
@@ -137,4 +137,29 @@ describe('extract', () => {
       `Failed to run eslint --print-config for ${fileAbs}`
     )
   })
+
+  it('extracts multiple sampled files in one workspace call', async () => {
+    const multiWorkspace = `${workspace}-multi`
+    await mkdir(path.join(multiWorkspace, 'node_modules/eslint/bin'), { recursive: true })
+    await mkdir(path.join(multiWorkspace, 'src'), { recursive: true })
+    await writeFile(path.join(multiWorkspace, 'node_modules/eslint/package.json'), JSON.stringify({ name: 'eslint', version: '0.0.0' }, null, 2))
+    await writeFile(
+      path.join(multiWorkspace, 'node_modules/eslint/bin/eslint.js'),
+      "console.log(JSON.stringify({ rules: { 'no-console': 1 } }))\n"
+    )
+
+    const fileA = path.join(multiWorkspace, 'src/a.ts')
+    const fileB = path.join(multiWorkspace, 'src/b.ts')
+    await writeFile(fileA, 'export const a = 1\n')
+    await writeFile(fileB, 'export const b = 1\n')
+
+    const extracted = await extractRulesForWorkspaceSamples(multiWorkspace, [fileA, fileB])
+    expect(extracted).toHaveLength(2)
+    for (const entry of extracted) {
+      expect(entry.error).toBeUndefined()
+      expect(entry.rules ? Object.fromEntries(entry.rules.entries()) : {}).toEqual({
+        'no-console': ['warn']
+      })
+    }
+  })
 })

package/test/snapshot.test.ts

@@ -53,12 +53,25 @@ describe('snapshot', () => {
     })
   })
 
-  it('throws on conflicting options at same severity', () => {
-    expect(() =>
-      aggregateRules([
-        new Map([['no-restricted-imports', ['error', { paths: ['a'] }] as const]]),
-        new Map([['no-restricted-imports', ['error', { paths: ['b'] }] as const]])
-      ])
-    ).toThrow('Conflicting rule options for no-restricted-imports at severity error')
+  it('resolves conflicting options at same severity deterministically', () => {
+    const result = aggregateRules([
+      new Map([['no-restricted-imports', ['error', { paths: ['b'] }] as const]]),
+      new Map([['no-restricted-imports', ['error', { paths: ['a'] }] as const]])
+    ])
+
+    expect(Object.fromEntries(result.entries())).toEqual({
+      'no-restricted-imports': ['error', { paths: ['a'] }]
+    })
+  })
+
+  it('prefers configured options over bare severity at same level', () => {
+    const result = aggregateRules([
+      new Map([['@typescript-eslint/consistent-type-imports', ['warn'] as const]]),
+      new Map([['@typescript-eslint/consistent-type-imports', ['warn', { fixStyle: 'inline-type-imports' }] as const]])
+    ])
+
+    expect(Object.fromEntries(result.entries())).toEqual({
+      '@typescript-eslint/consistent-type-imports': ['warn', { fixStyle: 'inline-type-imports' }]
+    })
   })
 })