lint-staged 12.1.7 → 12.3.0

package/README.md

@@ -2,8 +2,30 @@
 
 Run linters against staged git files and don't let :poop: slip into your code base!
 
+```
+$ git commit
+
+✔ Preparing lint-staged...
+❯ Running tasks for staged files...
+  ❯ packages/frontend/.lintstagedrc.json — 1 file
+    ↓ *.js — no files [SKIPPED]
+    ❯ *.{json,md} — 1 file
+      ⠹ prettier --write
+  ↓ packages/backend/.lintstagedrc.json — 2 files
+    ❯ *.js — 2 files
+      ⠼ eslint --fix
+    ↓ *.{json,md} — no files [SKIPPED]
+◼ Applying modifications from tasks...
+◼ Cleaning up temporary files...
+```
+
+<details>
+<summary>See asciinema video</summary>
+
 [![asciicast](https://asciinema.org/a/199934.svg)](https://asciinema.org/a/199934)
 
+</details>
+
 ## Why
 
 Linting makes more sense when run before committing your code. By doing so you can ensure no errors go into the repository and enforce code style. But running a lint process on a whole project is slow, and linting results can be irrelevant. Ultimately you only want to lint files that will be committed.
@@ -59,38 +81,36 @@ See [Releases](https://github.com/okonet/lint-staged/releases).
 
 ## Command line flags
 
-```bash
+```
 ❯ npx lint-staged --help
 Usage: lint-staged [options]
 
 Options:
   -V, --version                      output the version number
-  --allow-empty                      allow empty commits when tasks revert all staged changes
-                                     (default: false)
+  --allow-empty                      allow empty commits when tasks revert all staged changes (default: false)
+  -p, --concurrent <number|boolean>  the number of tasks to run concurrently, or false for serial (default: true)
   -c, --config [path]                path to configuration file, or - to read from stdin
+  --cwd [path]                       run all tasks in specific directory, instead of the current
   -d, --debug                        print additional debug information (default: false)
-  --no-stash                         disable the backup stash, and do not revert in case of
-                                     errors
-  -p, --concurrent <parallel tasks>  the number of tasks to run concurrently, or false to run
-                                     tasks serially (default: true)
+  --no-stash                         disable the backup stash, and do not revert in case of errors
   -q, --quiet                        disable lint-staged’s own console output (default: false)
   -r, --relative                     pass relative filepaths to tasks (default: false)
-  -x, --shell [path]                 skip parsing of tasks for better shell support (default:
-                                     false)
-  -v, --verbose                      show task output even when tasks succeed; by default only
-                                     failed output is shown (default: false)
+  -x, --shell [path]                 skip parsing of tasks for better shell support (default: false)
+  -v, --verbose                      show task output even when tasks succeed; by default only failed output is shown
+                                     (default: false)
   -h, --help                         display help for command
 ```
 
 - **`--allow-empty`**: By default, when linter tasks undo all staged changes, lint-staged will exit with an error and abort the commit. Use this flag to allow creating empty git commits.
-- **`--config [path]`**: Manually specify a path to a config file or npm package name. Note: when used, lint-staged won't perform the config file search and will print an error if the specified file cannot be found. If '-' is provided as the filename then the config will be read from stdin, allowing piping in the config like `cat my-config.json | npx lint-staged --config -`.
-- **`--debug`**: Run in debug mode. When set, it does the following:
+- **`--concurrent [number|boolean]`**: Controls the concurrency of tasks being run by lint-staged. **NOTE**: This does NOT affect the concurrency of subtasks (they will always be run sequentially). Possible values are:
   - uses [debug](https://github.com/visionmedia/debug) internally to log additional information about staged files, commands being executed, location of binaries, etc. Debug logs, which are automatically enabled by passing the flag, can also be enabled by setting the environment variable `$DEBUG` to `lint-staged*`.
   - uses [`verbose` renderer](https://github.com/SamVerschueren/listr-verbose-renderer) for `listr`; this causes serial, uncoloured output to the terminal, instead of the default (beautified, dynamic) output.
-- **`--concurrent [number | (true/false)]`**: Controls the concurrency of tasks being run by lint-staged. **NOTE**: This does NOT affect the concurrency of subtasks (they will always be run sequentially). Possible values are:
   - `false`: Run all tasks serially
   - `true` (default) : _Infinite_ concurrency. Runs as many tasks in parallel as possible.
   - `{number}`: Run the specified number of tasks in parallel, where `1` is equivalent to `false`.
+- **`--config [path]`**: Manually specify a path to a config file or npm package name. Note: when used, lint-staged won't perform the config file search and will print an error if the specified file cannot be found. If '-' is provided as the filename then the config will be read from stdin, allowing piping in the config like `cat my-config.json | npx lint-staged --config -`.
+- **`--cwd [path]`**: By default tasks run in the current working directory. Use the `--cwd some/directory` to override this. The path can be absolute or relative to the current working directory.
+- **`--debug`**: Run in debug mode. When set, it does the following:
 - **`--no-stash`**: By default a backup stash will be created before running the tasks, and all task modifications will be reverted in case of an error. This option will disable creating the stash, and instead leave all modifications in the index when aborting the commit.
 - **`--quiet`**: Supress all CLI output, except from tasks.
 - **`--relative`**: Pass filepaths relative to `process.cwd()` (where `lint-staged` runs) to tasks. Default is `false`.
@@ -116,6 +136,8 @@ Starting with v3.1 you can now use different ways of configuring lint-staged:
 
 Configuration should be an object where each value is a command to run and its key is a glob pattern to use for this command. This package uses [micromatch](https://github.com/micromatch/micromatch) for glob patterns. JavaScript files can also export advanced configuration as a function. See [Using JS configuration files](#using-js-configuration-files) for more info.
 
+You can also place multiple configuration files in different directories inside a project. For a given staged file, the closest configuration file will always be used. See ["How to use `lint-staged` in a multi-package monorepo?"](#how-to-use-lint-staged-in-a-multi-package-monorepo) for more info and an example.
+
 #### `package.json` example:
 
 ```json
@@ -644,12 +666,32 @@ _Thanks to [this comment](https://youtrack.jetbrains.com/issue/IDEA-135454#comme
 <details>
   <summary>Click to expand</summary>
 
-Starting with v5.0, `lint-staged` automatically resolves the git root **without any** additional configuration. You configure `lint-staged` as you normally would if your project root and git root were the same directory.
+Install _lint-staged_ on the monorepo root level, and add separate configuration files in each package. When running, _lint-staged_ will always use the configuration closest to a staged file, so having separate configuration files makes sure linters do not "leak" into other packages.
+
+For example, in a monorepo with `packages/frontend/.lintstagedrc.json` and `packages/backend/.lintstagedrc.json`, a staged file inside `packages/frontend/` will only match that configuration, and not the one in `packages/backend/`.
+
+**Note**: _lint-staged_ discovers the closest configuration to each staged file, even if that configuration doesn't include any matching globs. Given these example configurations:
 
-If you wish to use `lint-staged` in a multi package monorepo, it is recommended to install [`husky`](https://github.com/typicode/husky) in the root package.json.
-[`lerna`](https://github.com/lerna/lerna) can be used to execute the `precommit` script in all sub-packages.
+```js
+// ./.lintstagedrc.json
+{ "*.md": "prettier --write" }
+```
 
-Example repo: [sudo-suhas/lint-staged-multi-pkg](https://github.com/sudo-suhas/lint-staged-multi-pkg).
+```js
+// ./packages/frontend/.lintstagedrc.json
+{ "*.js": "eslint --fix" }
+```
+
+When committing `./packages/frontend/README.md`, it **will not run** _prettier_, because the configuration in the `frontend/` directory is closer to the file and doesn't include it. You should treat all _lint-staged_ configuration files as isolated and separated from each other. You can always use JS files to "extend" configurations, for example:
+
+```js
+import baseConfig from '../.lintstagedrc.js'
+
+export default {
+  ...baseConfig,
+  '*.js': 'eslint --fix',
+}
+```
 
 </details>
 

package/bin/lint-staged.js

@@ -26,14 +26,15 @@ const version = packageJson.version
 cmdline
   .version(version)
   .option('--allow-empty', 'allow empty commits when tasks revert all staged changes', false)
-  .option('-c, --config [path]', 'path to configuration file, or - to read from stdin')
-  .option('-d, --debug', 'print additional debug information', false)
-  .option('--no-stash', 'disable the backup stash, and do not revert in case of errors', false)
   .option(
-    '-p, --concurrent <parallel tasks>',
-    'the number of tasks to run concurrently, or false to run tasks serially',
+    '-p, --concurrent <number|boolean>',
+    'the number of tasks to run concurrently, or false for serial',
     true
   )
+  .option('-c, --config [path]', 'path to configuration file, or - to read from stdin')
+  .option('--cwd [path]', 'run all tasks in specific directory, instead of the current')
+  .option('-d, --debug', 'print additional debug information', false)
+  .option('--no-stash', 'disable the backup stash, and do not revert in case of errors', false)
   .option('-q, --quiet', 'disable lint-staged’s own console output', false)
   .option('-r, --relative', 'pass relative filepaths to tasks', false)
   .option('-x, --shell [path]', 'skip parsing of tasks for better shell support', false)
@@ -75,12 +76,13 @@ const options = {
   allowEmpty: !!cmdlineOptions.allowEmpty,
   concurrent: JSON.parse(cmdlineOptions.concurrent),
   configPath: cmdlineOptions.config,
+  cwd: cmdlineOptions.cwd,
   debug: !!cmdlineOptions.debug,
   maxArgLength: getMaxArgLength() / 2,
-  stash: !!cmdlineOptions.stash, // commander inverts `no-<x>` flags to `!x`
   quiet: !!cmdlineOptions.quiet,
   relative: !!cmdlineOptions.relative,
   shell: cmdlineOptions.shell /* Either a boolean or a string pointing to the shell */,
+  stash: !!cmdlineOptions.stash, // commander inverts `no-<x>` flags to `!x`
   verbose: !!cmdlineOptions.verbose,
 }
 

package/lib/dynamicImport.js

@@ -0,0 +1,3 @@
+import { pathToFileURL } from 'url'
+
+export const dynamicImport = (path) => import(pathToFileURL(path)).then((module) => module.default)

package/lib/generateTasks.js

@@ -16,11 +16,10 @@ const debugLog = debug('lint-staged:generateTasks')
  * @param {boolean} [options.files] - Staged filepaths
  * @param {boolean} [options.relative] - Whether filepaths to should be relative to gitDir
  */
-export const generateTasks = ({ config, cwd = process.cwd(), gitDir, files, relative = false }) => {
+export const generateTasks = ({ config, cwd = process.cwd(), files, relative = false }) => {
   debugLog('Generating linter tasks')
 
-  const absoluteFiles = files.map((file) => normalize(path.resolve(gitDir, file)))
-  const relativeFiles = absoluteFiles.map((file) => normalize(path.relative(cwd, file)))
+  const relativeFiles = files.map((file) => normalize(path.relative(cwd, file)))
 
   return Object.entries(config).map(([rawPattern, commands]) => {
     let pattern = rawPattern

package/lib/getConfigGroups.js

@@ -0,0 +1,112 @@
+/** @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)))
+
+  // Throw if no configurations were found
+  if (Object.keys(configGroups).length === 0) {
+    debugLog('Found no config groups!')
+    logger.error(`${ConfigNotFoundError.message}.`)
+    throw ConfigNotFoundError
+  }
+
+  debugLog('Grouped staged files into %d groups!', Object.keys(configGroups).length)
+
+  return configGroups
+}

package/lib/getStagedFiles.js

@@ -1,16 +1,28 @@
+import path from 'path'
+
+import normalize from 'normalize-path'
+
 import { execGit } from './execGit.js'
 
-export const getStagedFiles = async (options) => {
+export const getStagedFiles = async ({ cwd = process.cwd() } = {}) => {
   try {
     // Docs for --diff-filter option: https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203
     // Docs for -z option: https://git-scm.com/docs/git-diff#Documentation/git-diff.txt--z
-    const lines = await execGit(
-      ['diff', '--staged', '--diff-filter=ACMR', '--name-only', '-z'],
-      options
+    const lines = await execGit(['diff', '--staged', '--diff-filter=ACMR', '--name-only', '-z'], {
+      cwd,
+    })
+
+    if (!lines) return []
+
+    // With `-z`, git prints `fileA\u0000fileB\u0000fileC\u0000` so we need to
+    // remove the last occurrence of `\u0000` before splitting
+    return (
+      lines
+        // eslint-disable-next-line no-control-regex
+        .replace(/\u0000$/, '')
+        .split('\u0000')
+        .map((file) => normalize(path.resolve(cwd, file)))
     )
-    // With `-z`, git prints `fileA\u0000fileB\u0000fileC\u0000` so we need to remove the last occurrence of `\u0000` before splitting
-    // eslint-disable-next-line no-control-regex
-    return lines ? lines.replace(/\u0000$/, '').split('\u0000') : []
   } catch {
     return null
   }

package/lib/index.js

@@ -1,17 +1,9 @@
 import debug from 'debug'
-import inspect from 'object-inspect'
 
-import { loadConfig } from './loadConfig.js'
 import { PREVENTED_EMPTY_COMMIT, GIT_ERROR, RESTORE_STASH_EXAMPLE } from './messages.js'
 import { printTaskOutput } from './printTaskOutput.js'
 import { runAll } from './runAll.js'
-import {
-  ApplyEmptyCommitError,
-  ConfigNotFoundError,
-  GetBackupStashError,
-  GitError,
-} from './symbols.js'
-import { validateConfig } from './validateConfig.js'
+import { ApplyEmptyCommitError, GetBackupStashError, GitError } from './symbols.js'
 import { validateOptions } from './validateOptions.js'
 
 const debugLog = debug('lint-staged')
@@ -45,7 +37,7 @@ const lintStaged = async (
     concurrent = true,
     config: configObject,
     configPath,
-    cwd = process.cwd(),
+    cwd,
     debug = false,
     maxArgLength,
     quiet = false,
@@ -56,26 +48,7 @@ const lintStaged = async (
   } = {},
   logger = console
 ) => {
-  await validateOptions({ shell }, logger)
-
-  const inputConfig = configObject || (await loadConfig({ configPath, cwd }, logger))
-
-  if (!inputConfig) {
-    logger.error(`${ConfigNotFoundError.message}.`)
-    throw ConfigNotFoundError
-  }
-
-  const config = validateConfig(inputConfig, logger)
-
-  if (debug) {
-    // Log using logger to be able to test through `consolemock`.
-    logger.log('Running lint-staged with the following config:')
-    logger.log(inspect(config, { indent: 2 }))
-  } else {
-    // We might not be in debug mode but `DEBUG=lint-staged*` could have
-    // been set.
-    debugLog('lint-staged config:\n%O', config)
-  }
+  await validateOptions({ cwd, shell }, logger)
 
   // Unset GIT_LITERAL_PATHSPECS to not mess with path interpretation
   debugLog('Unset GIT_LITERAL_PATHSPECS (was `%s`)', process.env.GIT_LITERAL_PATHSPECS)
@@ -86,7 +59,8 @@ const lintStaged = async (
       {
         allowEmpty,
         concurrent,
-        config,
+        configObject,
+        configPath,
         cwd,
         debug,
         maxArgLength,

package/lib/loadConfig.js

@@ -1,11 +1,10 @@
 /** @typedef {import('./index').Logger} Logger */
 
-import { pathToFileURL } from 'url'
-
 import debug from 'debug'
 import { lilconfig } from 'lilconfig'
 import YAML from 'yaml'
 
+import { dynamicImport } from './dynamicImport.js'
 import { resolveConfig } from './resolveConfig.js'
 
 const debugLog = debug('lint-staged:loadConfig')
@@ -28,9 +27,6 @@ const searchPlaces = [
   'lint-staged.config.cjs',
 ]
 
-/** exported for tests */
-export const dynamicImport = (path) => import(pathToFileURL(path)).then((module) => module.default)
-
 const jsonParse = (path, content) => JSON.parse(content)
 
 const yamlParse = (path, content) => YAML.parse(content)
@@ -51,6 +47,8 @@ const loaders = {
   noExt: yamlParse,
 }
 
+const explorer = lilconfig('lint-staged', { searchPlaces, loaders })
+
 /**
  * @param {object} options
  * @param {string} [options.configPath] - Explicit path to a config file
@@ -64,22 +62,22 @@ export const loadConfig = async ({ configPath, cwd }, logger) => {
       debugLog('Searching for configuration from `%s`...', cwd)
     }
 
-    const explorer = lilconfig('lint-staged', { searchPlaces, loaders })
-
     const result = await (configPath
       ? explorer.load(resolveConfig(configPath))
       : explorer.search(cwd))
-    if (!result) return null
+
+    if (!result) return {}
 
     // config is a promise when using the `dynamicImport` loader
     const config = await result.config
+    const filepath = result.filepath
 
-    debugLog('Successfully loaded config from `%s`:\n%O', result.filepath, config)
+    debugLog('Successfully loaded config from `%s`:\n%O', filepath, config)
 
-    return config
+    return { config, filepath }
   } catch (error) {
     debugLog('Failed to load configuration!')
     logger.error(error)
-    return null
+    return {}
   }
 }

package/lib/runAll.js

@@ -1,11 +1,16 @@
 /** @typedef {import('./index').Logger} Logger */
 
+import path from 'path'
+
+import { dim } from 'colorette'
 import debug from 'debug'
 import { Listr } from 'listr2'
+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'
@@ -40,10 +45,11 @@ const createError = (ctx) => Object.assign(new Error('lint-staged failed'), { ct
  * Executes all tasks and either resolves or rejects the promise
  *
  * @param {object} options
- * @param {Object} [options.allowEmpty] - Allow empty commits when tasks revert all staged changes
+ * @param {boolean} [options.allowEmpty] - Allow empty commits when tasks revert all staged changes
  * @param {boolean | number} [options.concurrent] - The number of tasks to run concurrently, or false to run tasks serially
- * @param {Object} [options.config] - Task configuration
- * @param {Object} [options.cwd] - Current working directory
+ * @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 {boolean} [options.debug] - Enable debug mode
  * @param {number} [options.maxArgLength] - Maximum argument string length
  * @param {boolean} [options.quiet] - Disable lint-staged’s own console output
@@ -58,8 +64,9 @@ export const runAll = async (
   {
     allowEmpty = false,
     concurrent = true,
-    config,
-    cwd = process.cwd(),
+    configObject,
+    configPath,
+    cwd,
     debug = false,
     maxArgLength,
     quiet = false,
@@ -70,7 +77,11 @@ export const runAll = async (
   },
   logger = console
 ) => {
-  debugLog('Running all linter scripts')
+  debugLog('Running all linter scripts...')
+
+  // Resolve relative CWD option
+  cwd = cwd ? path.resolve(cwd) : process.cwd()
+  debugLog('Using working directory `%s`', cwd)
 
   const ctx = getInitialState({ quiet })
 
@@ -107,9 +118,7 @@ export const runAll = async (
     return ctx
   }
 
-  const stagedFileChunks = chunkFiles({ baseDir: gitDir, files, maxArgLength, relative })
-  const chunkCount = stagedFileChunks.length
-  if (chunkCount > 1) debugLog(`Chunked staged files into ${chunkCount} part`, chunkCount)
+  const configGroups = await getConfigGroups({ configObject, configPath, cwd, files }, logger)
 
   // lint-staged 10 will automatically add modifications to index
   // Warn user when their command includes `git add`
@@ -128,62 +137,76 @@ 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 [index, files] of stagedFileChunks.entries()) {
-    const chunkTasks = generateTasks({ config, cwd, gitDir, files, relative })
-    const chunkListrTasks = []
-
-    for (const task of chunkTasks) {
-      const subTasks = await makeCmdTasks({
-        commands: task.commands,
-        cwd,
-        files: task.fileList,
-        gitDir,
-        renderer: listrOptions.renderer,
-        shell,
-        verbose,
-      })
+  for (const [configPath, { config, files }] of Object.entries(configGroups)) {
+    const stagedFileChunks = chunkFiles({ baseDir: gitDir, files, maxArgLength, relative })
 
-      // Add files from task to match set
-      task.fileList.forEach((file) => {
-        matchedFiles.add(file)
-      })
+    const chunkCount = stagedFileChunks.length
+    if (chunkCount > 1) {
+      debugLog('Chunked staged files from `%s` into %d part', configPath, chunkCount)
+    }
+
+    for (const [index, files] of stagedFileChunks.entries()) {
+      const relativeConfig = normalize(path.relative(cwd, configPath))
+
+      const chunkListrTasks = await Promise.all(
+        generateTasks({ config, cwd, files, relative }).map((task) =>
+          makeCmdTasks({
+            commands: task.commands,
+            cwd,
+            files: task.fileList,
+            gitDir,
+            renderer: listrOptions.renderer,
+            shell,
+            verbose,
+          }).then((subTasks) => {
+            // Add files from task to match set
+            task.fileList.forEach((file) => {
+              matchedFiles.add(file)
+            })
 
-      hasDeprecatedGitAdd =
-        hasDeprecatedGitAdd || subTasks.some((subTask) => subTask.command === 'git add')
-
-      chunkListrTasks.push({
-        title: `Running tasks for ${task.pattern}`,
-        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,
-          }),
+            hasDeprecatedGitAdd =
+              hasDeprecatedGitAdd || subTasks.some((subTask) => subTask.command === 'git add')
+
+            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,
+                }),
+              skip: () => {
+                // Skip task when no files matched
+                if (fileCount === 0) {
+                  return `${task.pattern}${dim(' — no files')}`
+                }
+                return false
+              },
+            }
+          })
+        )
+      )
+
+      listrTasks.push({
+        title:
+          `${relativeConfig}${dim(` — ${files.length} ${files.length > 1 ? 'files' : 'file'}`)}` +
+          (chunkCount > 1 ? dim(` (chunk ${index + 1}/${chunkCount})...`) : ''),
+        task: () => new Listr(chunkListrTasks, { ...listrOptions, concurrent, exitOnError: true }),
         skip: () => {
-          // Skip task when no files matched
-          if (task.fileList.length === 0) {
-            return `No staged files match ${task.pattern}`
+          // 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 false
         },
       })
     }
-
-    listrTasks.push({
-      // No need to show number of task chunks when there's only one
-      title:
-        chunkCount > 1 ? `Running tasks (chunk ${index + 1}/${chunkCount})...` : 'Running tasks...',
-      task: () => new Listr(chunkListrTasks, { ...listrOptions, concurrent }),
-      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 'No tasks to run.'
-        return false
-      },
-    })
   }
 
   if (hasDeprecatedGitAdd) {
@@ -211,7 +234,7 @@ export const runAll = async (
   const runner = new Listr(
     [
       {
-        title: 'Preparing...',
+        title: 'Preparing lint-staged...',
         task: (ctx) => git.prepare(ctx),
       },
       {
@@ -219,9 +242,13 @@ export const runAll = async (
         task: (ctx) => git.hideUnstagedChanges(ctx),
         enabled: hasPartiallyStagedFiles,
       },
-      ...listrTasks,
       {
-        title: 'Applying modifications...',
+        title: `Running tasks for staged files...`,
+        task: () => new Listr(listrTasks, { ...listrOptions, concurrent }),
+        skip: () => listrTasks.every((task) => task.skip()),
+      },
+      {
+        title: 'Applying modifications from tasks...',
         task: (ctx) => git.applyModifications(ctx),
         skip: applyModificationsSkipped,
       },
@@ -238,7 +265,7 @@ export const runAll = async (
         skip: restoreOriginalStateSkipped,
       },
       {
-        title: 'Cleaning up...',
+        title: 'Cleaning up temporary files...',
         task: (ctx) => git.cleanup(ctx),
         enabled: cleanupEnabled,
         skip: cleanupSkipped,

package/lib/validateConfig.js

@@ -1,4 +1,7 @@
+/** @typedef {import('./index').Logger} Logger */
+
 import debug from 'debug'
+import inspect from 'object-inspect'
 
 import { configurationError } from './messages.js'
 import { ConfigEmptyError, ConfigFormatError } from './symbols.js'
@@ -21,11 +24,13 @@ const TEST_DEPRECATED_KEYS = new Map([
 
 /**
  * Runs config validation. Throws error if the config is not valid.
- * @param config {Object}
- * @returns config {Object}
+ * @param {Object} config
+ * @param {string} configPath
+ * @param {Logger} logger
+ * @returns {Object} config
  */
-export const validateConfig = (config, logger) => {
-  debugLog('Validating config')
+export const validateConfig = (config, configPath, logger) => {
+  debugLog('Validating config from `%s`...', configPath)
 
   if (!config || (typeof config !== 'object' && typeof config !== 'function')) {
     throw ConfigFormatError
@@ -103,5 +108,8 @@ See https://github.com/okonet/lint-staged#configuration.`)
     throw new Error(message)
   }
 
+  debugLog('Validated config from `%s`:', configPath)
+  debugLog(inspect(config, { indent: 2 }))
+
   return validatedConfig
 }

package/lib/validateOptions.js

@@ -1,4 +1,5 @@
 import { constants, promises as fs } from 'fs'
+import path from 'path'
 
 import debug from 'debug'
 
@@ -10,6 +11,7 @@ const debugLog = debug('lint-staged:validateOptions')
 /**
  * Validate lint-staged options, either from the Node.js API or the command line flags.
  * @param {*} options
+ * @param {boolean|string} [options.cwd] - Current working directory
  * @param {boolean|string} [options.shell] - Skip parsing of tasks for better shell support
  *
  * @throws {InvalidOptionsError}
@@ -17,6 +19,17 @@ const debugLog = debug('lint-staged:validateOptions')
 export const validateOptions = async (options = {}, logger) => {
   debugLog('Validating options...')
 
+  /** Ensure the passed cwd option exists; it might also be relative */
+  if (typeof options.cwd === 'string') {
+    try {
+      const resolved = path.resolve(options.cwd)
+      await fs.access(resolved, constants.F_OK)
+    } catch (error) {
+      logger.error(invalidOption('cwd', options.cwd, error.message))
+      throw InvalidOptionsError
+    }
+  }
+
   /** Ensure the passed shell option is executable */
   if (typeof options.shell === 'string') {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-staged",
-  "version": "12.1.7",
+  "version": "12.3.0",
   "description": "Lint files staged by git",
   "license": "MIT",
   "repository": "https://github.com/okonet/lint-staged",