@eslint-config-snapshot/api 0.3.2 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @eslint-config-snapshot/api
 
+## 0.5.0
+
+### Minor Changes
+
+- Add ESLint runtime version reporting by group in CLI summaries and improve pnpm/corepack isolated test resilience.
+
+## 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

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,
@@ -47,6 +48,7 @@ __export(index_exports, {
   normalizeSeverity: () => normalizeSeverity,
   readSnapshotFile: () => readSnapshotFile,
   resolveEslintBinForWorkspace: () => resolveEslintBinForWorkspace,
+  resolveEslintVersionForWorkspace: () => resolveEslintVersionForWorkspace,
   sampleWorkspaceFiles: () => sampleWorkspaceFiles,
   sortUnique: () => sortUnique,
   writeSnapshotFile: () => writeSnapshotFile
@@ -288,6 +290,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 +355,57 @@ function extractRulesFromPrintConfig(workspaceAbs, fileAbs) {
     throw new Error(`Invalid JSON from eslint --print-config for ${fileAbs}`);
   }
   const rules = parsed.rules ?? {};
+  return normalizeRules(rules);
+}
+function resolveEslintVersionForWorkspace(workspaceAbs) {
+  const anchor = import_node_path2.default.join(workspaceAbs, "__snapshot_anchor__.cjs");
+  const req = (0, import_node_module.createRequire)(anchor);
+  try {
+    const packageJsonPath = req.resolve("eslint/package.json");
+    const packageJson = JSON.parse((0, import_node_fs.readFileSync)(packageJsonPath, "utf8"));
+    if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
+      return packageJson.version;
+    }
+  } catch {
+  }
+  return "unknown";
+}
+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));
@@ -607,6 +661,7 @@ function getConfigScaffold(preset = "minimal") {
   compareSeverity,
   diffSnapshots,
   discoverWorkspaces,
+  extractRulesForWorkspaceSamples,
   extractRulesFromPrintConfig,
   findConfigPath,
   getConfigScaffold,
@@ -616,6 +671,7 @@ function getConfigScaffold(preset = "minimal") {
   normalizeSeverity,
   readSnapshotFile,
   resolveEslintBinForWorkspace,
+  resolveEslintVersionForWorkspace,
   sampleWorkspaceFiles,
   sortUnique,
   writeSnapshotFile

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,57 @@ function extractRulesFromPrintConfig(workspaceAbs, fileAbs) {
     throw new Error(`Invalid JSON from eslint --print-config for ${fileAbs}`);
   }
   const rules = parsed.rules ?? {};
+  return normalizeRules(rules);
+}
+function resolveEslintVersionForWorkspace(workspaceAbs) {
+  const anchor = path2.join(workspaceAbs, "__snapshot_anchor__.cjs");
+  const req = createRequire(anchor);
+  try {
+    const packageJsonPath = req.resolve("eslint/package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
+      return packageJson.version;
+    }
+  } catch {
+  }
+  return "unknown";
+}
+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));
@@ -551,6 +603,7 @@ export {
   compareSeverity,
   diffSnapshots,
   discoverWorkspaces,
+  extractRulesForWorkspaceSamples,
   extractRulesFromPrintConfig,
   findConfigPath,
   getConfigScaffold,
@@ -560,6 +613,7 @@ export {
   normalizeSeverity,
   readSnapshotFile,
   resolveEslintBinForWorkspace,
+  resolveEslintVersionForWorkspace,
   sampleWorkspaceFiles,
   sortUnique,
   writeSnapshotFile

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-config-snapshot/api",
-  "version": "0.3.2",
+  "version": "0.5.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,78 @@ export function extractRulesFromPrintConfig(workspaceAbs: string, fileAbs: strin
   }
 
   const rules = (parsed as { rules?: Record<string, unknown> }).rules ?? {}
+  return normalizeRules(rules)
+}
+
+export function resolveEslintVersionForWorkspace(workspaceAbs: string): string {
+  const anchor = path.join(workspaceAbs, '__snapshot_anchor__.cjs')
+  const req = createRequire(anchor)
+
+  try {
+    const packageJsonPath = req.resolve('eslint/package.json')
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8')) as { version?: string }
+    if (typeof packageJson.version === 'string' && packageJson.version.length > 0) {
+      return packageJson.version
+    }
+  } catch {
+    // fall through to deterministic unknown marker
+  }
+
+  return 'unknown'
+}
+
+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,13 @@ 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,
+  resolveEslintVersionForWorkspace
+} 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/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']
+      })
+    }
+  })
 })