lint-staged 12.3.7 → 13.0.2

package/lib/parseGitZOutput.js

@@ -5,5 +5,7 @@
  */
 export const parseGitZOutput = (input) =>
   input
-    .replace(/\u0000$/, '') // eslint-disable-line no-control-regex
-    .split('\u0000')
+    ? input
+        .replace(/\u0000$/, '') // eslint-disable-line no-control-regex
+        .split('\u0000')
+    : []

package/lib/printTaskOutput.js

@@ -5,7 +5,7 @@
  */
 export const printTaskOutput = (ctx = {}, logger) => {
   if (!Array.isArray(ctx.output)) return
-  const log = ctx.errors && ctx.errors.size > 0 ? logger.error : logger.log
+  const log = ctx.errors?.size > 0 ? logger.error : logger.log
   for (const line of ctx.output) {
     log(line)
   }

package/lib/resolveConfig.js

@@ -1,4 +1,4 @@
-import { createRequire } from 'module'
+import { createRequire } from 'node:module'
 
 /**
  * require() does not exist for ESM, so we must create it to use require.resolve().

package/lib/resolveGitRepo.js

@@ -1,5 +1,5 @@
-import { promises as fs } from 'fs'
-import path from 'path'
+import fs from 'node:fs/promises'
+import path from 'node:path'
 
 import debug from 'debug'
 import normalize from 'normalize-path'

package/lib/resolveTaskFn.js

@@ -1,5 +1,5 @@
 import { redBright, dim } from 'colorette'
-import execa from 'execa'
+import { execa, execaCommand } from 'execa'
 import debug from 'debug'
 import { parseArgsStringToArgv } from 'string-argv'
 import pidTree from 'pidtree'
@@ -8,7 +8,7 @@ import { error, info } from './figures.js'
 import { getInitialState } from './state.js'
 import { TaskError } from './symbols.js'
 
-const ERROR_CHECK_INTERVAL = 200
+const TASK_ERROR = 'lint-staged:taskError'
 
 const debugLog = debug('lint-staged:resolveTaskFn')
 
@@ -46,31 +46,52 @@ const handleOutput = (command, result, ctx, isError = false) => {
   }
 }
 
+/**
+ * Kill an execa process along with all its child processes.
+ * @param {execa.ExecaChildProcess<string>} execaProcess
+ */
+const killExecaProcess = async (execaProcess) => {
+  try {
+    const childPids = await pidTree(execaProcess.pid)
+    for (const childPid of childPids) {
+      try {
+        process.kill(childPid)
+      } catch (error) {
+        debugLog(`Failed to kill process with pid "%d": %o`, childPid, error)
+      }
+    }
+  } catch (error) {
+    // Suppress "No matching pid found" error. This probably means
+    // the process already died before executing.
+    debugLog(`Failed to kill process with pid "%d": %o`, execaProcess.pid, error)
+  }
+
+  // The execa process is killed separately in order to get the `KILLED` status.
+  execaProcess.kill()
+}
+
 /**
  * Interrupts the execution of the execa process that we spawned if
  * another task adds an error to the context.
  *
  * @param {Object} ctx
  * @param {execa.ExecaChildProcess<string>} execaChildProcess
- * @returns {function(): void} Function that clears the interval that
+ * @returns {() => Promise<void>} Function that clears the interval that
  * checks the context.
  */
 const interruptExecutionOnError = (ctx, execaChildProcess) => {
-  async function loop() {
-    if (ctx.errors.size > 0) {
-      const ids = await pidTree(execaChildProcess.pid)
-      ids.forEach(process.kill)
-
-      // The execa process is killed separately in order
-      // to get the `KILLED` status.
-      execaChildProcess.kill()
-    }
+  let killPromise
+
+  const errorListener = async () => {
+    killPromise = killExecaProcess(execaChildProcess)
+    await killPromise
   }
 
-  const loopIntervalId = setInterval(loop, ERROR_CHECK_INTERVAL)
+  ctx.events.on(TASK_ERROR, errorListener, { once: true })
 
-  return () => {
-    clearInterval(loopIntervalId)
+  return async () => {
+    ctx.events.off(TASK_ERROR, errorListener)
+    await killPromise
   }
 }
 
@@ -89,6 +110,10 @@ const interruptExecutionOnError = (ctx, execaChildProcess) => {
  */
 const makeErr = (command, result, ctx) => {
   ctx.errors.add(TaskError)
+
+  // https://nodejs.org/api/events.html#error-events
+  ctx.events.emit(TASK_ERROR, TaskError)
+
   handleOutput(command, result, ctx, true)
   const tag = getTag(result)
   return new Error(`${redBright(command)} ${dim(`[${tag}]`)}`)
@@ -105,7 +130,7 @@ const makeErr = (command, result, ctx) => {
  * @param {Array<string>} options.files — Filepaths to run the linter task against
  * @param {Boolean} [options.shell] — Whether to skip parsing linter task for better shell support
  * @param {Boolean} [options.verbose] — Always show task verbose
- * @returns {function(): Promise<Array<string>>}
+ * @returns {() => Promise<Array<string>>}
  */
 export const resolveTaskFn = ({
   command,
@@ -133,12 +158,12 @@ export const resolveTaskFn = ({
 
   return async (ctx = getInitialState()) => {
     const execaChildProcess = shell
-      ? execa.command(isFn ? command : `${command} ${files.join(' ')}`, execaOptions)
+      ? execaCommand(isFn ? command : `${command} ${files.join(' ')}`, execaOptions)
       : execa(cmd, isFn ? args : args.concat(files), execaOptions)
 
     const quitInterruptCheck = interruptExecutionOnError(ctx, execaChildProcess)
     const result = await execaChildProcess
-    quitInterruptCheck()
+    await quitInterruptCheck()
 
     if (result.failed || result.killed || result.signal != null) {
       throw makeErr(command, result, ctx)

package/lib/runAll.js

@@ -1,6 +1,6 @@
 /** @typedef {import('./index').Logger} Logger */
 
-import path from 'path'
+import path from 'node:path'
 
 import { dim } from 'colorette'
 import debug from 'debug'
@@ -10,10 +10,10 @@ import normalize from 'normalize-path'
 import { chunkFiles } from './chunkFiles.js'
 import { execGit } from './execGit.js'
 import { generateTasks } from './generateTasks.js'
-import { getConfigGroups } from './getConfigGroups.js'
 import { getRenderer } from './getRenderer.js'
 import { getStagedFiles } from './getStagedFiles.js'
 import { GitWorkflow } from './gitWorkflow.js'
+import { groupFilesByConfig } from './groupFilesByConfig.js'
 import { makeCmdTasks } from './makeCmdTasks.js'
 import {
   DEPRECATED_GIT_ADD,
@@ -52,6 +52,8 @@ const createError = (ctx) => Object.assign(new Error('lint-staged failed'), { ct
  * @param {string} [options.configPath] - Explicit path to a config file
  * @param {string} [options.cwd] - Current working directory
  * @param {boolean} [options.debug] - Enable debug mode
+ * @param {string} [options.diff] - Override the default "--staged" flag of "git diff" to get list of files
+ * @param {string} [options.diffFilter] - Override the default "--diff-filter=ACMR" flag of "git diff" to get list of files
  * @param {number} [options.maxArgLength] - Maximum argument string length
  * @param {boolean} [options.quiet] - Disable lint-staged’s own console output
  * @param {boolean} [options.relative] - Pass relative filepaths to tasks
@@ -69,6 +71,8 @@ export const runAll = async (
     configPath,
     cwd,
     debug = false,
+    diff,
+    diffFilter,
     maxArgLength,
     quiet = false,
     relative = false,
@@ -100,13 +104,14 @@ export const runAll = async (
     .then(() => true)
     .catch(() => false)
 
-  // Lint-staged should create a backup stash only when there's an initial commit
-  ctx.shouldBackup = hasInitialCommit && stash
+  // Lint-staged should create a backup stash only when there's an initial commit,
+  // and when using the default list of staged files
+  ctx.shouldBackup = hasInitialCommit && stash && diff === undefined
   if (!ctx.shouldBackup) {
-    logger.warn(skippingBackup(hasInitialCommit))
+    logger.warn(skippingBackup(hasInitialCommit, diff))
   }
 
-  const files = await getStagedFiles({ cwd: gitDir })
+  const files = await getStagedFiles({ cwd: gitDir, diff, diffFilter })
   if (!files) {
     if (!quiet) ctx.output.push(FAILED_GET_STAGED_FILES)
     ctx.errors.add(GetStagedFilesError)
@@ -120,11 +125,8 @@ export const runAll = async (
     return ctx
   }
 
-  const configGroups = await getConfigGroups({ configObject, configPath, cwd, files }, logger)
-
-  const hasExplicitConfig = configObject || configPath
-  const foundConfigs = hasExplicitConfig ? null : await searchConfigs(gitDir, logger)
-  const numberOfConfigs = hasExplicitConfig ? 1 : Object.keys(foundConfigs).length
+  const foundConfigs = await searchConfigs({ configObject, configPath, cwd, gitDir }, logger)
+  const numberOfConfigs = Object.keys(foundConfigs).length
 
   // Throw if no configurations were found
   if (numberOfConfigs === 0) {
@@ -132,7 +134,11 @@ export const runAll = async (
     throw createError(ctx, ConfigNotFoundError)
   }
 
-  debugLog('Found %d configs:\n%O', numberOfConfigs, foundConfigs)
+  const filesByConfig = await groupFilesByConfig({
+    configs: foundConfigs,
+    files,
+    singleConfigMode: configObject || configPath !== undefined,
+  })
 
   const hasMultipleConfigs = numberOfConfigs > 1
 
@@ -152,8 +158,9 @@ export const runAll = async (
   // Set of all staged files that matched a task glob. Values in a set are unique.
   const matchedFiles = new Set()
 
-  for (const [configPath, { config, files }] of Object.entries(configGroups)) {
-    const relativeConfig = normalize(path.relative(cwd, configPath))
+  for (const [configPath, { config, files }] of Object.entries(filesByConfig)) {
+    const configName = configPath ? normalize(path.relative(cwd, configPath)) : 'Config object'
+
     const stagedFileChunks = chunkFiles({ baseDir: gitDir, files, maxArgLength, relative })
 
     // Use actual cwd if it's specified, or there's only a single config file.
@@ -196,15 +203,15 @@ export const runAll = async (
             const fileCount = task.fileList.length
 
             return {
-              title: `${task.pattern}${dim(` — ${fileCount} ${fileCount > 1 ? 'files' : 'file'}`)}`,
-              task: async () =>
-                new Listr(subTasks, {
-                  // In sub-tasks we don't want to run concurrently
-                  // and we want to abort on errors
-                  ...listrOptions,
-                  concurrent: false,
-                  exitOnError: true,
-                }),
+              title: `${task.pattern}${dim(
+                ` — ${fileCount} ${fileCount === 1 ? 'file' : 'files'}`
+              )}`,
+              task: async (ctx, task) =>
+                task.newListr(
+                  subTasks,
+                  // Subtasks should not run in parallel, and should exit on error
+                  { concurrent: false, exitOnError: true }
+                ),
               skip: () => {
                 // Skip task when no files matched
                 if (fileCount === 0) {
@@ -219,15 +226,15 @@ export const runAll = async (
 
       listrTasks.push({
         title:
-          `${relativeConfig}${dim(` — ${files.length} ${files.length > 1 ? 'files' : 'file'}`)}` +
+          `${configName}${dim(` — ${files.length} ${files.length > 1 ? 'files' : 'file'}`)}` +
           (chunkCount > 1 ? dim(` (chunk ${index + 1}/${chunkCount})...`) : ''),
-        task: () => new Listr(chunkListrTasks, { ...listrOptions, concurrent, exitOnError: true }),
+        task: (ctx, task) => task.newListr(chunkListrTasks, { concurrent, exitOnError: true }),
         skip: () => {
           // Skip if the first step (backup) failed
           if (ctx.errors.has(GitError)) return SKIPPED_GIT_ERROR
           // Skip chunk when no every task is skipped (due to no matches)
           if (chunkListrTasks.every((task) => task.skip())) {
-            return `${relativeConfig}${dim(' — no tasks to run')}`
+            return `${configName}${dim(' — no tasks to run')}`
           }
           return false
         },
@@ -255,7 +262,14 @@ export const runAll = async (
     relative: false,
   })
 
-  const git = new GitWorkflow({ allowEmpty, gitConfigDir, gitDir, matchedFileChunks })
+  const git = new GitWorkflow({
+    allowEmpty,
+    gitConfigDir,
+    gitDir,
+    matchedFileChunks,
+    diff,
+    diffFilter,
+  })
 
   const runner = new Listr(
     [
@@ -270,7 +284,7 @@ export const runAll = async (
       },
       {
         title: `Running tasks for staged files...`,
-        task: () => new Listr(listrTasks, { ...listrOptions, concurrent }),
+        task: (ctx, task) => task.newListr(listrTasks, { concurrent }),
         skip: () => listrTasks.every((task) => task.skip()),
       },
       {

package/lib/searchConfigs.js

@@ -1,7 +1,8 @@
 /** @typedef {import('./index').Logger} Logger */
 
-import { basename, join } from 'path'
+import path from 'node:path'
 
+import debug from 'debug'
 import normalize from 'normalize-path'
 
 import { execGit } from './execGit.js'
@@ -9,38 +10,70 @@ import { loadConfig, searchPlaces } from './loadConfig.js'
 import { parseGitZOutput } from './parseGitZOutput.js'
 import { validateConfig } from './validateConfig.js'
 
+const debugLog = debug('lint-staged:searchConfigs')
+
 const EXEC_GIT = ['ls-files', '-z', '--full-name']
 
-const filterPossibleConfigFiles = (file) => searchPlaces.includes(basename(file))
+const filterPossibleConfigFiles = (files) =>
+  files.filter((file) => searchPlaces.includes(path.basename(file)))
 
 const numberOfLevels = (file) => file.split('/').length
 
 const sortDeepestParth = (a, b) => (numberOfLevels(a) > numberOfLevels(b) ? -1 : 1)
 
+const isInsideDirectory = (dir) => (file) => file.startsWith(normalize(dir))
+
 /**
- * Search all config files from the git repository
+ * Search all config files from the git repository, preferring those inside `cwd`.
  *
- * @param {string} gitDir
+ * @param {object} options
+ * @param {Object} [options.configObject] - Explicit config object from the js API
+ * @param {string} [options.configPath] - Explicit path to a config file
+ * @param {string} [options.cwd] - Current working directory
  * @param {Logger} logger
- * @returns {Promise<{ [key: string]: * }>} found configs with filepath as key, and config as value
+ *
+ * @returns {Promise<{ [key: string]: { config: *, files: string[] } }>} found configs with filepath as key, and config as value
  */
-export const searchConfigs = async (gitDir = process.cwd(), logger) => {
-  /** Get all possible config files known to git */
-  const cachedFiles = parseGitZOutput(await execGit(EXEC_GIT, { cwd: gitDir })).filter(
-    filterPossibleConfigFiles
-  )
+export const searchConfigs = async (
+  { configObject, configPath, cwd = process.cwd(), gitDir = cwd },
+  logger
+) => {
+  debugLog('Searching for configuration files...')
+
+  // Return explicit config object from js API
+  if (configObject) {
+    debugLog('Using single direct configuration object...')
+
+    return { '': validateConfig(configObject, 'config object', logger) }
+  }
+
+  // Use only explicit config path instead of discovering multiple
+  if (configPath) {
+    debugLog('Using single configuration path...')
+
+    const { config, filepath } = await loadConfig({ configPath }, logger)
 
-  /** Get all possible config files from uncommitted files */
-  const otherFiles = parseGitZOutput(
-    await execGit([...EXEC_GIT, '--others', '--exclude-standard'], { cwd: gitDir })
-  ).filter(filterPossibleConfigFiles)
+    if (!config) return {}
+    return { [configPath]: validateConfig(config, filepath, logger) }
+  }
+
+  const [cachedFiles, otherFiles] = await Promise.all([
+    /** Get all possible config files known to git */
+    execGit(EXEC_GIT, { cwd: gitDir }).then(parseGitZOutput).then(filterPossibleConfigFiles),
+    /** Get all possible config files from uncommitted files */
+    execGit([...EXEC_GIT, '--others', '--exclude-standard'], { cwd: gitDir })
+      .then(parseGitZOutput)
+      .then(filterPossibleConfigFiles),
+  ])
 
   /** Sort possible config files so that deepest is first */
   const possibleConfigFiles = [...cachedFiles, ...otherFiles]
-    .map((file) => join(gitDir, file))
-    .map((file) => normalize(file))
+    .map((file) => normalize(path.join(gitDir, file)))
+    .filter(isInsideDirectory(cwd))
     .sort(sortDeepestParth)
 
+  debugLog('Found possible config files:', possibleConfigFiles)
+
   /** Create object with key as config file, and value as null */
   const configs = possibleConfigFiles.reduce(
     (acc, configPath) => Object.assign(acc, { [configPath]: null }),
@@ -49,15 +82,17 @@ export const searchConfigs = async (gitDir = process.cwd(), logger) => {
 
   /** Load and validate all configs to the above object */
   await Promise.all(
-    possibleConfigFiles
-      .map((configPath) => loadConfig({ configPath }, logger))
-      .map((promise) =>
-        promise.then(({ config, filepath }) => {
-          if (config) {
-            configs[filepath] = validateConfig(config, filepath, logger)
+    Object.keys(configs).map((configPath) =>
+      loadConfig({ configPath }, logger).then(({ config, filepath }) => {
+        if (config) {
+          if (configPath !== filepath) {
+            debugLog('Config file "%s" resolved to "%s"', configPath, filepath)
           }
-        })
-      )
+
+          configs[configPath] = validateConfig(config, filepath, logger)
+        }
+      })
+    )
   )
 
   /** Get validated configs from the above object, without any `null` values (not found) */
@@ -65,5 +100,24 @@ export const searchConfigs = async (gitDir = process.cwd(), logger) => {
     .filter(([, value]) => !!value)
     .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {})
 
+  /**
+   * Try to find a single config from parent directories
+   * to match old behavior before monorepo support
+   */
+  if (!Object.keys(foundConfigs).length) {
+    debugLog('Could not find config files inside "%s"', cwd)
+
+    const { config, filepath } = await loadConfig({ cwd }, logger)
+    if (config) {
+      debugLog('Found parent configuration file from "%s"', filepath)
+
+      foundConfigs[filepath] = validateConfig(config, filepath, logger)
+    } else {
+      debugLog('Could not find parent configuration files from "%s"', cwd)
+    }
+  }
+
+  debugLog('Found %d config files', Object.keys(foundConfigs).length)
+
   return foundConfigs
 }

package/lib/state.js

@@ -1,3 +1,5 @@
+import EventEmitter from 'events'
+
 import { GIT_ERROR, TASK_ERROR } from './messages.js'
 import {
   ApplyEmptyCommitError,
@@ -11,6 +13,7 @@ export const getInitialState = ({ quiet = false } = {}) => ({
   hasPartiallyStagedFiles: null,
   shouldBackup: null,
   errors: new Set([]),
+  events: new EventEmitter(),
   output: [],
   quiet,
 })

package/lib/validateOptions.js

@@ -1,5 +1,6 @@
-import { constants, promises as fs } from 'fs'
-import path from 'path'
+import { constants } from 'node:fs'
+import fs from 'node:fs/promises'
+import path from 'node:path'
 
 import debug from 'debug'
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-staged",
-  "version": "12.3.7",
+  "version": "13.0.2",
   "description": "Lint files staged by git",
   "license": "MIT",
   "repository": "https://github.com/okonet/lint-staged",
@@ -14,7 +14,7 @@
     "url": "https://opencollective.com/lint-staged"
   },
   "engines": {
-    "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+    "node": "^14.13.1 || >=16.0.0"
   },
   "type": "module",
   "bin": "./bin/lint-staged.js",
@@ -33,36 +33,36 @@
   },
   "dependencies": {
     "cli-truncate": "^3.1.0",
-    "colorette": "^2.0.16",
-    "commander": "^8.3.0",
-    "debug": "^4.3.3",
-    "execa": "^5.1.1",
-    "lilconfig": "2.0.4",
-    "listr2": "^4.0.1",
-    "micromatch": "^4.0.4",
+    "colorette": "^2.0.17",
+    "commander": "^9.3.0",
+    "debug": "^4.3.4",
+    "execa": "^6.1.0",
+    "lilconfig": "2.0.5",
+    "listr2": "^4.0.5",
+    "micromatch": "^4.0.5",
     "normalize-path": "^3.0.0",
-    "object-inspect": "^1.12.0",
-    "pidtree": "^0.5.0",
+    "object-inspect": "^1.12.2",
+    "pidtree": "^0.6.0",
     "string-argv": "^0.3.1",
-    "supports-color": "^9.2.1",
-    "yaml": "^1.10.2"
+    "yaml": "^2.1.1"
   },
   "devDependencies": {
-    "@babel/core": "^7.16.12",
-    "@babel/eslint-parser": "^7.16.5",
-    "@babel/preset-env": "^7.16.11",
-    "babel-jest": "^27.4.6",
+    "@babel/core": "^7.18.2",
+    "@babel/eslint-parser": "^7.18.2",
+    "@babel/preset-env": "^7.18.2",
+    "babel-jest": "^28.1.1",
+    "babel-plugin-transform-imports": "2.0.0",
     "consolemock": "^1.1.0",
-    "eslint": "^8.7.0",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-import": "^2.25.4",
+    "eslint": "^8.17.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-prettier": "^4.0.0",
-    "fs-extra": "^10.0.0",
-    "husky": "^7.0.4",
-    "jest": "^27.4.7",
+    "fs-extra": "^10.1.0",
+    "husky": "^8.0.1",
+    "jest": "^28.1.1",
     "jest-snapshot-serializer-ansi": "^1.0.0",
-    "prettier": "^2.5.1"
+    "prettier": "^2.6.2"
   },
   "keywords": [
     "lint",

package/lib/getConfigGroups.js

@@ -1,105 +0,0 @@
-/** @typedef {import('./index').Logger} Logger */
-
-import path from 'path'
-
-import debug from 'debug'
-import objectInspect from 'object-inspect'
-
-import { loadConfig } from './loadConfig.js'
-import { ConfigNotFoundError } from './symbols.js'
-import { validateConfig } from './validateConfig.js'
-
-const debugLog = debug('lint-staged:getConfigGroups')
-
-/**
- * Return matched files grouped by their configuration.
- *
- * @param {object} options
- * @param {Object} [options.configObject] - Explicit config object from the js API
- * @param {string} [options.configPath] - Explicit path to a config file
- * @param {string} [options.cwd] - Current working directory
- * @param {string} [options.files] - List of staged files
- * @param {Logger} logger
- */
-export const getConfigGroups = async (
-  { configObject, configPath, cwd, files },
-  logger = console
-) => {
-  debugLog('Grouping configuration files...')
-
-  // Return explicit config object from js API
-  if (configObject) {
-    debugLog('Using single direct configuration object...')
-
-    const config = validateConfig(configObject, 'config object', logger)
-    return { '': { config, files } }
-  }
-
-  // Use only explicit config path instead of discovering multiple
-  if (configPath) {
-    debugLog('Using single configuration path...')
-
-    const { config, filepath } = await loadConfig({ configPath }, logger)
-
-    if (!config) {
-      logger.error(`${ConfigNotFoundError.message}.`)
-      throw ConfigNotFoundError
-    }
-
-    const validatedConfig = validateConfig(config, filepath, logger)
-    return { [configPath]: { config: validatedConfig, files } }
-  }
-
-  debugLog('Grouping staged files by their directories...')
-
-  // Group files by their base directory
-  const filesByDir = files.reduce((acc, file) => {
-    const dir = path.normalize(path.dirname(file))
-
-    if (dir in acc) {
-      acc[dir].push(file)
-    } else {
-      acc[dir] = [file]
-    }
-
-    return acc
-  }, {})
-
-  debugLog('Grouped staged files into %d directories:', Object.keys(filesByDir).length)
-  debugLog(objectInspect(filesByDir, { indent: 2 }))
-
-  // Group files by their discovered config
-  // { '.lintstagedrc.json': { config: {...}, files: [...] } }
-  const configGroups = {}
-
-  debugLog('Searching config files...')
-
-  const searchConfig = async (cwd, files = []) => {
-    const { config, filepath } = await loadConfig({ cwd }, logger)
-    if (!config) {
-      debugLog('Found no config from "%s"!', cwd)
-      return
-    }
-
-    if (filepath in configGroups) {
-      debugLog('Found existing config "%s" from "%s"!', filepath, cwd)
-      // Re-use cached config and skip validation
-      configGroups[filepath].files.push(...files)
-    } else {
-      debugLog('Found new config "%s" from "%s"!', filepath, cwd)
-
-      const validatedConfig = validateConfig(config, filepath, logger)
-      configGroups[filepath] = { config: validatedConfig, files }
-    }
-  }
-
-  // Start by searching from cwd
-  await searchConfig(cwd)
-
-  // Discover configs from the base directory of each file
-  await Promise.all(Object.entries(filesByDir).map(([dir, files]) => searchConfig(dir, files)))
-
-  debugLog('Grouped staged files into %d groups!', Object.keys(configGroups).length)
-
-  return configGroups
-}