lint-staged 16.1.6 → 16.2.1

package/lib/loadConfig.js

@@ -2,30 +2,28 @@
 
 import fs from 'node:fs/promises'
 import path from 'node:path'
+import { pathToFileURL } from 'node:url'
 
-import debug from 'debug'
 import YAML from 'yaml'
 
-import {
-  CONFIG_FILE_NAMES,
-  CONFIG_NAME,
-  PACKAGE_JSON_FILE,
-  PACKAGE_YAML_FILES,
-} from './configFiles.js'
-import { dynamicImport } from './dynamicImport.js'
+import { CONFIG_NAME, PACKAGE_JSON_FILE, PACKAGE_YAML_FILES } from './configFiles.js'
+import { createDebug } from './debug.js'
 import { failedToLoadConfig } from './messages.js'
 import { resolveConfig } from './resolveConfig.js'
 
-const debugLog = debug('lint-staged:loadConfig')
+const debugLog = createDebug('lint-staged:loadConfig')
 
-const jsonParse = (filePath, content) => {
-  const isPackageFile = PACKAGE_JSON_FILE.includes(path.basename(filePath))
+const readFile = async (filename) => fs.readFile(path.resolve(filename), 'utf-8')
+
+const jsonParse = async (filename) => {
+  const isPackageFile = PACKAGE_JSON_FILE.includes(path.basename(filename))
   try {
+    const content = await readFile(filename)
     const json = JSON.parse(content)
     return isPackageFile ? json[CONFIG_NAME] : json
   } catch (error) {
-    if (path.basename(filePath) === PACKAGE_JSON_FILE) {
-      debugLog('Ignoring invalid package file `%s` with content:\n%s', filePath, content)
+    if (path.basename(filename) === PACKAGE_JSON_FILE) {
+      debugLog('Ignoring invalid JSON file %s', filename)
       return undefined
     }
 
@@ -33,14 +31,15 @@ const jsonParse = (filePath, content) => {
   }
 }
 
-const yamlParse = (filePath, content) => {
-  const isPackageFile = PACKAGE_YAML_FILES.includes(path.basename(filePath))
+const yamlParse = async (filename) => {
+  const isPackageFile = PACKAGE_YAML_FILES.includes(path.basename(filename))
   try {
+    const content = await readFile(filename)
     const yaml = YAML.parse(content)
     return isPackageFile ? yaml[CONFIG_NAME] : yaml
   } catch (error) {
     if (isPackageFile) {
-      debugLog('Ignoring invalid package file `%s` with content:\n%s', filePath, content)
+      debugLog('Ignoring invalid YAML file %s', filename)
       return undefined
     }
 
@@ -48,6 +47,8 @@ const yamlParse = (filePath, content) => {
   }
 }
 
+export const dynamicImport = (path) => import(pathToFileURL(path)).then((module) => module.default)
+
 const NO_EXT = 'noExt'
 
 /**
@@ -69,54 +70,30 @@ const loaders = {
   '.yml': yamlParse,
 }
 
-const readFile = async (filepath) => {
-  const absolutePath = path.resolve(filepath)
-  return fs.readFile(absolutePath, 'utf-8')
-}
-
-const loadConfigByExt = async (filepath) => {
-  filepath = path.resolve(filepath)
+const loadConfigByExt = async (filename) => {
+  const filepath = path.resolve(filename)
   const ext = path.extname(filepath) || NO_EXT
   const loader = loaders[ext]
+  const config = await loader(filepath)
 
-  /**
-   * No need to read file contents when loader only takes in the filepath argument
-   * and reads itself; this is for `lilconfig` compatibility
-   */
-  const content = loader.length > 1 ? await readFile(filepath) : undefined
-
-  return {
-    config: await loader(filepath, content),
-    filepath,
-  }
+  return { config, filepath }
 }
 
-/**
- * @param {object} options
- * @param {string} [options.configPath] - Explicit path to a config file
- * @param {string} [options.cwd] - Current working directory
- */
-export const loadConfig = async ({ configPath, cwd }, logger) => {
+/** @param {string} configPath */
+export const loadConfig = async (configPath, logger) => {
   try {
-    let result
-
-    if (configPath) {
-      debugLog('Loading configuration from `%s`...', configPath)
-      result = await loadConfigByExt(resolveConfig(configPath))
-    } else {
-      debugLog('Searching for configuration from `%s`...', cwd)
-      const { lilconfig } = await import('lilconfig')
-      const explorer = lilconfig(CONFIG_NAME, { searchPlaces: CONFIG_FILE_NAMES, loaders })
-      result = await explorer.search(cwd)
-    }
-
-    if (!result) return {}
+    debugLog('Loading configuration from `%s`...', configPath)
+    const result = await loadConfigByExt(resolveConfig(configPath))
 
     // config is a promise when using the `dynamicImport` loader
     const config = (await result.config) ?? null
     const filepath = result.filepath
 
-    debugLog('Successfully loaded config from `%s`:\n%O', filepath, config)
+    if (config) {
+      debugLog('Successfully loaded config from `%s`:\n%O', filepath, config)
+    } else {
+      debugLog('Found no config in %s', filepath)
+    }
 
     return { config, filepath }
   } catch (error) {

package/lib/messages.js

@@ -1,22 +1,21 @@
 import { inspect } from 'node:util'
 
-import chalk from 'chalk'
-
+import { bold, red, yellow } from './colors.js'
 import { error, info, warning } from './figures.js'
 
 export const configurationError = (opt, helpMsg, value) =>
-  `${chalk.redBright(`${error} Validation Error:`)}
+  `${red(`${error} Validation Error:`)}
 
-  Invalid value for '${chalk.bold(opt)}': ${chalk.bold(inspect(value))}
+  Invalid value for '${bold(opt)}': ${bold(inspect(value))}
 
   ${helpMsg}`
 
-export const NOT_GIT_REPO = chalk.redBright(`${error} Current directory is not a git directory!`)
+export const NOT_GIT_REPO = red(`${error} Current directory is not a git directory!`)
 
-export const FAILED_GET_STAGED_FILES = chalk.redBright(`${error} Failed to get staged files!`)
+export const FAILED_GET_STAGED_FILES = red(`${error} Failed to get staged files!`)
 
 export const incorrectBraces = (before, after) =>
-  chalk.yellow(
+  yellow(
     `${warning} Detected incorrect braces with only single value: \`${before}\`. Reformatted as: \`${after}\`
 `
   )
@@ -34,54 +33,54 @@ export const skippingBackup = (hasInitialCommit, diff) => {
       : (hasInitialCommit ? '`--no-stash` was used' : 'there’s no initial commit yet') +
         '. This might result in data loss'
 
-  return chalk.yellow(`${warning} Skipping backup because ${reason}.\n`)
+  return yellow(`${warning} Skipping backup because ${reason}.\n`)
 }
 
-export const SKIPPING_HIDE_PARTIALLY_CHANGED = chalk.yellow(
+export const SKIPPING_HIDE_PARTIALLY_CHANGED = yellow(
   `${warning} Skipping hiding unstaged changes from partially staged files because \`--no-hide-partially-staged\` was used.\n`
 )
 
-export const DEPRECATED_GIT_ADD = chalk.yellow(
+export const DEPRECATED_GIT_ADD = yellow(
   `${warning} Some of your tasks use \`git add\` command. Please remove it from the config since all modifications made by tasks will be automatically added to the git commit index.
 `
 )
 
 export const TASK_ERROR = 'Skipped because of errors from tasks.'
 
+export const PREVENTED_TASK_MODIFICATIONS = `\n${error} lint-staged failed because \`--fail-on-changes\` was used.`
+
 export const SKIPPED_GIT_ERROR = 'Skipped because of previous git error.'
 
-export const GIT_ERROR = `\n  ${chalk.redBright(`${error} lint-staged failed due to a git error.`)}`
+export const GIT_ERROR = `\n  ${red(`${error} lint-staged failed due to a git error.`)}`
 
-export const invalidOption = (name, value, message) => `${chalk.redBright(
-  `${error} Validation Error:`
-)}
+export const invalidOption = (name, value, message) => `${red(`${error} Validation Error:`)}
 
-  Invalid value for option '${chalk.bold(name)}': ${chalk.bold(value)}
+  Invalid value for option '${bold(name)}': ${bold(value)}
 
   ${message}
 
 See https://github.com/okonet/lint-staged#command-line-flags`
 
 export const PREVENTED_EMPTY_COMMIT = `
-  ${chalk.yellow(`${warning} lint-staged prevented an empty git commit.
+  ${yellow(`${warning} lint-staged prevented an empty git commit.
   Use the --allow-empty option to continue, or check your task configuration`)}
 `
 
 export const RESTORE_STASH_EXAMPLE = `Any lost modifications can be restored from a git stash:
 
-  > git stash list
-  stash@{0}: automatic lint-staged backup
-  > git stash apply --index stash@{0}`
+  > git stash list --format="%h %s"
+  h0a0s0h0 On main: lint-staged automatic backup
+  > git apply --index h0a0s0h0`
 
-export const CONFIG_STDIN_ERROR = chalk.redBright(`${error} Failed to read config from stdin.`)
+export const CONFIG_STDIN_ERROR = red(`${error} Failed to read config from stdin.`)
 
 export const failedToLoadConfig = (filepath) =>
-  chalk.redBright(`${error} Failed to read config from file "${filepath}".`)
+  red(`${error} Failed to read config from file "${filepath}".`)
 
 export const failedToParseConfig = (
   filepath,
   error
-) => `${chalk.redBright(`${error} Failed to parse config from file "${filepath}".`)}
+) => `${red(`${error} Failed to parse config from file "${filepath}".`)}
 
 ${error}
 

package/lib/resolveGitRepo.js

@@ -1,11 +1,10 @@
 import path from 'node:path'
 
-import debug from 'debug'
-
+import { createDebug } from './debug.js'
 import { execGit } from './execGit.js'
 import { normalizePath } from './normalizePath.js'
 
-const debugLog = debug('lint-staged:resolveGitRepo')
+const debugLog = createDebug('lint-staged:resolveGitRepo')
 
 /**
  * Relative path up to the repo top-level directory

package/lib/runAll.js

@@ -2,11 +2,11 @@
 
 import path from 'node:path'
 
-import chalk from 'chalk'
-import debug from 'debug'
 import { Listr } from 'listr2'
 
 import { chunkFiles } from './chunkFiles.js'
+import { blackBright } from './colors.js'
+import { createDebug } from './debug.js'
 import { execGit } from './execGit.js'
 import { generateTasks } from './generateTasks.js'
 import { getFunctionTask, isFunctionTask } from './getFunctionTask.js'
@@ -37,10 +37,11 @@ import {
   restoreOriginalStateSkipped,
   restoreUnstagedChangesSkipped,
   shouldHidePartiallyStagedFiles,
+  shouldRestoreUnstagedChanges,
 } from './state.js'
 import { ConfigNotFoundError, GetStagedFilesError, GitError, GitRepoError } from './symbols.js'
 
-const debugLog = debug('lint-staged:runAll')
+const debugLog = createDebug('lint-staged:runAll')
 
 /**
  * @param {ReturnType<typeof getInitialState>} ctx context
@@ -54,15 +55,20 @@ const createError = (ctx, cause) =>
  *
  * @param {object} options
  * @param {boolean} [options.allowEmpty] - Allow empty commits when tasks revert all staged changes
+ * @param {boolean} [options.color] - Enable or disable ANSI color codes in output.
  * @param {boolean | number} [options.concurrent] - The number of tasks to run concurrently, or false to run tasks serially
  * @param {Object} [options.configObject] - Explicit config object from the js API
  * @param {string} [options.configPath] - Explicit path to a config file
+ * @param {boolean} [options.continueOnError] - Run all tasks to completion even if one fails
  * @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 {boolean} [options.failOnChanges] - Fail with exit code 1 when tasks modify tracked files
+ * @param {boolean} [options.hidePartiallyStaged] - Whether to hide unstaged changes from partially staged files before running tasks
+ * @param {boolean} [options.hideUnstaged] - Whether to hide all unstaged changes before running tasks
  * @param {number} [options.maxArgLength] - Maximum argument string length
- * @param {boolean} [options.quiet] - Disable lint-staged’s own console output
+ * @param {boolean} [options.quiet] - Disable lint-staged's own console output
  * @param {boolean} [options.relative] - Pass relative filepaths to tasks
  * @param {boolean} [options.revert] - revert to original state in case of errors
  * @param {boolean} [options.stash] - Enable the backup stash, and revert in case of errors
@@ -73,13 +79,18 @@ const createError = (ctx, cause) =>
 export const runAll = async (
   {
     allowEmpty = false,
+    color = false,
     concurrent = true,
     configObject,
     configPath,
+    continueOnError = false,
     cwd,
     debug = false,
     diff,
     diffFilter,
+    failOnChanges = false,
+    hideUnstaged = false,
+    hidePartiallyStaged = !hideUnstaged,
     maxArgLength,
     quiet = false,
     relative = false,
@@ -87,7 +98,6 @@ export const runAll = async (
     stash = diff === undefined,
     // Cannot revert to original state without stash
     revert = stash,
-    hidePartiallyStaged = true,
     verbose = false,
   },
   logger = console
@@ -99,7 +109,12 @@ export const runAll = async (
   cwd = hasExplicitCwd ? path.resolve(cwd) : process.cwd()
   debugLog('Using working directory `%s`', cwd)
 
-  const ctx = getInitialState({ quiet, revert })
+  const ctx = getInitialState({
+    hidePartiallyStaged,
+    hideUnstaged,
+    quiet,
+    revert,
+  })
 
   const { topLevelDir, gitConfigDir } = await resolveGitRepo(cwd)
   if (!topLevelDir) {
@@ -121,12 +136,16 @@ export const runAll = async (
     logger.warn(skippingBackup(hasInitialCommit, diff))
   }
 
-  ctx.shouldHidePartiallyStaged = hidePartiallyStaged
-  if (!ctx.shouldHidePartiallyStaged && !quiet) {
+  if (!ctx.shouldHidePartiallyStaged && !ctx.shouldHideUnstaged && !quiet) {
     logger.warn(SKIPPING_HIDE_PARTIALLY_CHANGED)
   }
 
-  const stagedFiles = await getStagedFiles({ cwd: topLevelDir, diff, diffFilter })
+  // Run staged files retrieval and config search in parallel since they're independent
+  const [stagedFiles, foundConfigs] = await Promise.all([
+    getStagedFiles({ cwd: topLevelDir, diff, diffFilter }),
+    searchConfigs({ configObject, configPath, cwd, topLevelDir }, logger),
+  ])
+
   if (!stagedFiles) {
     if (!quiet) ctx.output.push(FAILED_GET_STAGED_FILES)
     ctx.errors.add(GetStagedFilesError)
@@ -140,7 +159,6 @@ export const runAll = async (
     return ctx
   }
 
-  const foundConfigs = await searchConfigs({ configObject, configPath, cwd, topLevelDir }, logger)
   const numberOfConfigs = Object.keys(foundConfigs).length
 
   // Throw if no configurations were found
@@ -165,7 +183,7 @@ export const runAll = async (
     ctx,
     exitOnError: false,
     registerSignalListeners: false,
-    ...getRenderer({ debug, quiet }, logger),
+    ...getRenderer({ color, debug, quiet }, logger),
   }
 
   /**
@@ -203,6 +221,7 @@ export const runAll = async (
           (isFunctionTask(task.commands)
             ? getFunctionTask(task.commands, task.fileList)
             : getSpawnedTasks({
+                color,
                 commands: task.commands,
                 cwd: groupCwd,
                 files: task.fileList,
@@ -231,19 +250,19 @@ export const runAll = async (
             const fileCount = task.fileList.length
 
             return {
-              title: `${task.pattern}${chalk.dim(
+              title: `${task.pattern}${blackBright(
                 ` — ${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 }
+                  { concurrent: false, exitOnError: !continueOnError }
                 ),
               skip: () => {
                 // Skip task when no files matched
                 if (fileCount === 0) {
-                  return `${task.pattern}${chalk.dim(' — no files')}`
+                  return `${task.pattern}${blackBright(' — no files')}`
                 }
                 return false
               },
@@ -256,15 +275,16 @@ export const runAll = async (
 
       listrTasks.push({
         title:
-          `${configName}${chalk.dim(` — ${files.length} ${files.length > 1 ? 'files' : 'file'}`)}` +
-          (chunkCount > 1 ? chalk.dim(` (chunk ${index + 1}/${chunkCount})...`) : ''),
-        task: (ctx, task) => task.newListr(chunkListrTasks, { concurrent, exitOnError: true }),
+          `${configName}${blackBright(` — ${files.length} ${files.length > 1 ? 'files' : 'file'}`)}` +
+          (chunkCount > 1 ? blackBright(` (chunk ${index + 1}/${chunkCount})...`) : ''),
+        task: (ctx, task) =>
+          task.newListr(chunkListrTasks, { concurrent, exitOnError: !continueOnError }),
         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 `${configName}${chalk.dim(' — no tasks to run')}`
+            return `${configName}${blackBright(' — no tasks to run')}`
           }
           return false
         },
@@ -295,11 +315,12 @@ export const runAll = async (
 
   const git = new GitWorkflow({
     allowEmpty,
-    gitConfigDir,
-    topLevelDir,
-    matchedFileChunks,
     diff,
     diffFilter,
+    failOnChanges,
+    gitConfigDir,
+    matchedFileChunks,
+    topLevelDir,
   })
 
   const runner = new Listr(
@@ -310,7 +331,7 @@ export const runAll = async (
       },
       {
         title: 'Hiding unstaged changes to partially staged files...',
-        task: (ctx) => git.hideUnstagedChanges(ctx),
+        task: (ctx) => git.hidePartiallyStagedChanges(ctx),
         enabled: shouldHidePartiallyStagedFiles,
       },
       {
@@ -324,9 +345,9 @@ export const runAll = async (
         skip: applyModificationsSkipped,
       },
       {
-        title: 'Restoring unstaged changes to partially staged files...',
+        title: 'Restoring unstaged changes...',
         task: (ctx) => git.restoreUnstagedChanges(ctx),
-        enabled: shouldHidePartiallyStagedFiles,
+        enabled: shouldRestoreUnstagedChanges,
         skip: restoreUnstagedChangesSkipped,
       },
       {

package/lib/searchConfigs.js

@@ -1,17 +1,17 @@
 /** @typedef {import('./index').Logger} Logger */
 
+import fs, { constants } from 'node:fs/promises'
 import path from 'node:path'
 
-import debug from 'debug'
-
 import { CONFIG_FILE_NAMES } from './configFiles.js'
+import { createDebug } from './debug.js'
 import { execGit } from './execGit.js'
 import { loadConfig } from './loadConfig.js'
 import { normalizePath } from './normalizePath.js'
 import { parseGitZOutput } from './parseGitZOutput.js'
 import { validateConfig } from './validateConfig.js'
 
-const debugLog = debug('lint-staged:searchConfigs')
+const debugLog = createDebug('lint-staged:searchConfigs')
 
 const EXEC_GIT = ['ls-files', '-z', '--full-name', '-t']
 
@@ -19,8 +19,89 @@ const CONFIG_PATHSPEC = CONFIG_FILE_NAMES.map((f) => `:(glob)**/${f}`)
 
 const numberOfLevels = (file) => file.split('/').length
 
+const sortAlphabetically = (a, b) => a.localeCompare(b)
+
 const sortDeepestParth = (a, b) => (numberOfLevels(a) > numberOfLevels(b) ? -1 : 1)
 
+/**
+ * Get all possible config files from git
+ *
+ * @param {object} options
+ * @param {string} options.cwd
+ * @param {string} options.topLevelDir
+ * @returns {Promise<string[]>}
+ */
+const listConfigFilesFromGit = async ({ cwd, topLevelDir }) =>
+  execGit(
+    [
+      ...EXEC_GIT,
+      '--cached', // show all tracked files
+      '--others', // show untracked files
+      '--exclude-standard', // apply standard git exclusions (.gitignore, etc.)
+      '--',
+      ...CONFIG_PATHSPEC,
+    ],
+    { cwd }
+  )
+    .then(parseGitZOutput)
+    .then((lines) => {
+      const possibleConfigFiles = lines.flatMap((line) => {
+        /**
+         * Leave out lines starting with "S " to ignore not-checked-out files in a sparse repo.
+         * The "S" status means a tracked file that is "skip-worktree"
+         * @see https://git-scm.com/docs/git-ls-files#Documentation/git-ls-files.txt--t
+         */
+        if (line.startsWith('S ')) {
+          return []
+        }
+
+        const relativePath = line.replace(/^[HSMRCK?U] /, '')
+        const absolutePath = normalizePath(path.join(topLevelDir, relativePath))
+        return [absolutePath]
+      })
+
+      debugLog('Found possible config files from git:', possibleConfigFiles)
+
+      return possibleConfigFiles
+    })
+
+/**
+ * Get all possible config files from filesystem, starting from `cwd` and
+ * moving upwards if nothing is found.
+ *
+ * @param {object} options
+ * @param {string} options.cwd
+ * @param {string[]} [possibleConfigFiles]
+ * @returns {Promise<string[]>}
+ */
+export const listConfigFilesFromFs = async ({ cwd }) => {
+  debugLog('Listing possible configs from filesystem starting from "%s"...', cwd)
+
+  const results = await Promise.allSettled(
+    CONFIG_FILE_NAMES.map(async (f) => {
+      const filepath = path.join(cwd, f)
+      await fs.access(filepath, constants.F_OK)
+      return filepath
+    })
+  )
+
+  const possibleConfigFiles = results.flatMap((r) =>
+    r.status === 'fulfilled' ? [normalizePath(r.value)] : []
+  )
+
+  if (possibleConfigFiles.length > 0) {
+    debugLog('Found possible config files from filesystem:', possibleConfigFiles)
+    return possibleConfigFiles
+  }
+
+  const parentDir = path.dirname(cwd)
+  if (parentDir === cwd) {
+    return [] /** Root-level / */
+  }
+
+  return listConfigFilesFromFs({ cwd: parentDir })
+}
+
 /**
  * Search all config files from the git repository, preferring those inside `cwd`.
  *
@@ -28,6 +109,7 @@ const sortDeepestParth = (a, b) => (numberOfLevels(a) > numberOfLevels(b) ? -1 :
  * @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.topLevelDir] - Top-level directory of the git repo
  * @param {Logger} logger
  *
  * @returns {Promise<{ [key: string]: { config: *, files: string[] } }>} found configs with filepath as key, and config as value
@@ -49,57 +131,35 @@ export const searchConfigs = async (
   if (configPath) {
     debugLog('Using single configuration path...')
 
-    const { config, filepath } = await loadConfig({ configPath }, logger)
+    const { config, filepath } = await loadConfig(configPath, logger)
 
     if (!config) return {}
     return { [configPath]: validateConfig(config, filepath, logger) }
   }
 
-  /** Get all possible config files from git (both cached and uncommitted) */
-  const gitListedFiles = await execGit(
-    [
-      ...EXEC_GIT,
-      '--cached', // show all tracked files
-      '--others', // show untracked files
-      '--exclude-standard', // apply standard git exclusions (.gitignore, etc.)
-      '--',
-      ...CONFIG_PATHSPEC,
-    ],
-    { cwd }
-  ).then(parseGitZOutput)
-
-  debugLog('Git listed files matching config files:', gitListedFiles)
-
-  /** Sort possible config files so that deepest is first */
-  const possibleConfigFiles = gitListedFiles
-    .flatMap((line) => {
-      /**
-       * Leave out lines starting with "S " to ignore not-checked-out files in a sparse repo.
-       * The "S" status means a tracked file that is "skip-worktree"
-       * @see https://git-scm.com/docs/git-ls-files#Documentation/git-ls-files.txt--t
-       */
-      if (line.startsWith('S ')) {
-        return []
-      }
-
-      const relativePath = line.replace(/^[HSMRCK?U] /, '')
-      const absolutePath = normalizePath(path.join(topLevelDir, relativePath))
-      return [absolutePath]
+  const possibleConfigFiles = new Set()
+
+  const addToSet = (files) => {
+    files.forEach((f) => {
+      possibleConfigFiles.add(f)
     })
-    .sort(sortDeepestParth)
+  }
 
-  debugLog('Found possible config files:', possibleConfigFiles)
+  await Promise.all([
+    listConfigFilesFromGit({ cwd, topLevelDir }).then(addToSet),
+    listConfigFilesFromFs({ cwd }).then(addToSet),
+  ])
 
   /** Create object with key as config file, and value as null */
-  const configs = possibleConfigFiles.reduce(
-    (acc, configPath) => Object.assign(acc, { [configPath]: null }),
-    {}
-  )
+  const configs = Array.from(possibleConfigFiles)
+    .sort(sortAlphabetically)
+    .sort(sortDeepestParth)
+    .reduce((acc, configPath) => Object.assign(acc, { [configPath]: null }), {})
 
   /** Load and validate all configs to the above object */
   await Promise.all(
     Object.keys(configs).map((configPath) =>
-      loadConfig({ configPath }, logger).then(({ config, filepath }) => {
+      loadConfig(configPath, logger).then(({ config, filepath }) => {
         if (config) {
           if (configPath !== filepath) {
             debugLog('Config file "%s" resolved to "%s"', configPath, filepath)
@@ -112,26 +172,13 @@ export const searchConfigs = async (
   )
 
   /** Get validated configs from the above object, without any `null` values (not found) */
-  const foundConfigs = Object.entries(configs)
-    .filter(([, value]) => !!value)
-    .reduce((acc, [key, value]) => Object.assign(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)
+  const foundConfigs = Object.entries(configs).reduce((acc, [key, value]) => {
+    if (value) {
+      Object.assign(acc, { [key]: value })
     }
-  }
+
+    return acc
+  }, {})
 
   debugLog('Found %d config files', Object.keys(foundConfigs).length)