lint-staged 16.1.0 → 16.1.2

package/MIGRATION.md

@@ -2,7 +2,9 @@
 
 #### Updated Node.js version requirement
 
-The lowest supported Node.js version is `18.19.0` or `20.5.0`, following requirements of `execa@9`. Please upgrade your Node.js version.
+For version `lint-staged@16.0.0` the lowest supported Node.js version is `20.19.0`, following requirements of `nano-spawn`. Please upgrade your Node.js version.
+
+For version `lint-staged@16.1.0` this is lowered to `20.17.0`, again following `nano-spawn`.
 
 #### Removed validation for removed advanced configuration file options
 

package/README.md

@@ -85,7 +85,7 @@ Now change a few files, `git add` or `git add --patch` some of them to your comm
 
 See [examples](#examples) and [configuration](#configuration) for more information.
 
-> [!CAUTION]
+> [!CAUTION]  
 > _Lint-staged_ runs `git` operations affecting the files in your repository. By default _lint-staged_ creates a `git stash` as a backup of the original state before running any configured tasks to help prevent data loss.
 
 ## Changelog
@@ -143,9 +143,9 @@ Any lost modifications can be restored from a git stash:
 - **`--diff`**: By default tasks are filtered against all files staged in git, generated from `git diff --staged`. This option allows you to override the `--staged` flag with arbitrary revisions. For example to get a list of changed files between two branches, use `--diff="branch1...branch2"`. You can also read more from about [git diff](https://git-scm.com/docs/git-diff) and [gitrevisions](https://git-scm.com/docs/gitrevisions). This option also implies `--no-stash`.
 - **`--diff-filter`**: By default only files that are _added_, _copied_, _modified_, or _renamed_ are included. Use this flag to override the default `ACMR` value with something else: _added_ (`A`), _copied_ (`C`), _deleted_ (`D`), _modified_ (`M`), _renamed_ (`R`), _type changed_ (`T`), _unmerged_ (`U`), _unknown_ (`X`), or _pairing broken_ (`B`). See also the `git diff` docs for [--diff-filter](https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203).
 - **`--max-arg-length`**: long commands (a lot of files) are automatically split into multiple chunks when it detects the current shell cannot handle them. Use this flag to override the maximum length of the generated command string.
-- **`--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. This option also implies `--no-hide-partially-staged`.
-- **`--no-hide-partially-staged`**: By default, unstaged changes from partially staged files will be hidden. This option will disable this behavior and include all unstaged changes in partially staged files. Can be re-enabled with `--hide-partially-staged`
-- **`--quiet`**: Supress all CLI output, except from tasks.
+- **`--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.
+- **`--no-hide-partially-staged`**: By default, unstaged changes from partially staged files will be hidden and applied back after running tasks. This option will disable this behavior, causing those changes to also be committed.
+- **`--quiet`**: Suppress all CLI output, except from tasks.
 - **`--relative`**: Pass filepaths relative to `process.cwd()` (where `lint-staged` runs) to tasks. Default is `false`.
 - **`--no-revert`**: By default all task modifications will be reverted in case of an error. This option will disable the behavior, and apply task modifications to the index before aborting the commit.
 - **`--verbose`**: Show task output even when tasks succeed. By default only failed output is shown.

package/bin/lint-staged.js

@@ -78,7 +78,7 @@ program
   .addOption(
     new Option('--no-stash', 'disable the backup stash. Implies "--no-revert".')
       .default(false)
-      .implies({ revert: false, hidePartiallyStaged: false })
+      .implies({ revert: false })
   )
 
 program

package/lib/chunkFiles.js

@@ -10,7 +10,7 @@ const debugLog = debug('lint-staged:chunkFiles')
  * Chunk array into sub-arrays
  * @param {Array} arr
  * @param {Number} chunkCount
- * @retuns {Array<Array>}
+ * @returns {Array<Array>}
  */
 const chunkArray = (arr, chunkCount) => {
   if (chunkCount === 1) return [arr]
@@ -27,24 +27,36 @@ const chunkArray = (arr, chunkCount) => {
 
 /**
  * Chunk files into sub-arrays based on the length of the resulting argument string
+ *
+ * @typedef {import('./getStagedFiles.js').StagedFile[]} StagedFile
+ *
  * @param {Object} opts
- * @param {Array<String>} opts.files
+ * @param {Array<StagedFile>} opts.files
  * @param {String} [opts.baseDir] The optional base directory to resolve relative paths.
  * @param {number} [opts.maxArgLength] the maximum argument string length
  * @param {Boolean} [opts.relative] whether files are relative to `topLevelDir` or should be resolved as absolute
- * @returns {Array<Array<String>>}
+ * @returns {Array<Array<StagedFile>>}
  */
 export const chunkFiles = ({ files, baseDir, maxArgLength = null, relative = false }) => {
-  const normalizedFiles = files.map((file) =>
-    normalizePath(relative || !baseDir ? file : path.resolve(baseDir, file))
-  )
+  const normalizedFiles = files.map((file) => {
+    return {
+      filepath: normalizePath(
+        relative || !baseDir ? file.filepath : path.resolve(baseDir, file.filepath)
+      ),
+      status: file.status,
+    }
+  })
 
   if (!maxArgLength) {
     debugLog('Skip chunking files because of undefined maxArgLength')
     return [normalizedFiles] // wrap in an array to return a single chunk
   }
 
-  const fileListLength = normalizedFiles.join(' ').length
+  /** Calculate total character length of all filepaths, with added spaces in between */
+  const fileListLength =
+    normalizedFiles.reduce((sum, file) => sum + file.filepath.length, 0) +
+    Math.max(normalizedFiles.length - 1, 0)
+
   debugLog(
     `Resolved an argument string length of ${fileListLength} characters from ${normalizedFiles.length} files`
   )

package/lib/generateTasks.js

@@ -13,13 +13,17 @@ const debugLog = debug('lint-staged:generateTasks')
  * @param {object} options
  * @param {Object} [options.config] - Task configuration
  * @param {Object} [options.cwd] - Current working directory
- * @param {boolean} [options.files] - Staged filepaths
+ * @param {import('./getStagedFiles.js').StagedFile[]} [options.files] - Staged filepaths
  * @param {boolean} [options.relative] - Whether filepaths to should be relative to cwd
  */
 export const generateTasks = ({ config, cwd = process.cwd(), files, relative = false }) => {
   debugLog('Generating linter tasks')
 
-  const relativeFiles = files.map((file) => normalizePath(path.relative(cwd, file)))
+  /** @type {StagedFile[]} */
+  const relativeFiles = files.map((file) => ({
+    filepath: normalizePath(path.relative(cwd, file.filepath)),
+    status: file.status,
+  }))
 
   return Object.entries(config).map(([pattern, commands]) => {
     const isParentDirPattern = pattern.startsWith('../')
@@ -28,21 +32,34 @@ export const generateTasks = ({ config, cwd = process.cwd(), files, relative = f
     // specifies that it concerns a parent directory.
     const filteredFiles = relativeFiles.filter((file) => {
       if (isParentDirPattern) return true
-      return !file.startsWith('..') && !path.isAbsolute(file)
+      return !file.filepath.startsWith('..') && !path.isAbsolute(file.filepath)
     })
 
-    const matches = micromatch(filteredFiles, pattern, {
-      cwd,
-      dot: true,
-      // If the pattern doesn't look like a path, enable `matchBase` to
-      // match against filenames in every directory. This makes `*.js`
-      // match both `test.js` and `subdirectory/test.js`.
-      matchBase: !pattern.includes('/'),
-      posixSlashes: true,
-      strictBrackets: true,
-    })
+    const matches = micromatch(
+      filteredFiles.map((file) => file.filepath),
+      pattern,
+      {
+        cwd,
+        dot: true,
+        // If the pattern doesn't look like a path, enable `matchBase` to
+        // match against filenames in every directory. This makes `*.js`
+        // match both `test.js` and `subdirectory/test.js`.
+        matchBase: !pattern.includes('/'),
+        posixSlashes: true,
+        strictBrackets: true,
+      }
+    )
 
-    const fileList = matches.map((file) => normalizePath(relative ? file : path.resolve(cwd, file)))
+    const fileList = filteredFiles.flatMap((file) =>
+      matches.includes(file.filepath)
+        ? [
+            {
+              filepath: normalizePath(relative ? file.filepath : path.resolve(cwd, file.filepath)),
+              status: file.status,
+            },
+          ]
+        : []
+    )
 
     const task = { pattern, commands, fileList }
     debugLog('Generated task: \n%O', task)

package/lib/getFunctionTask.js

@@ -15,7 +15,7 @@ export const isFunctionTask = (commands) => typeof commands === 'object' && !Arr
  * Handles function configuration and pushes the tasks into the task array
  *
  * @param {object} command
- * @param {Array<string>} files
+ * @param {import('./getStagedFiles.js').StagedFile[]} files
  * @throws {Error} If the function configuration is not valid
  */
 export const getFunctionTask = async (command, files) => {
@@ -23,7 +23,7 @@ export const getFunctionTask = async (command, files) => {
 
   const task = async (ctx) => {
     try {
-      await command.task(files)
+      await command.task(files.map((file) => file.filepath))
     } catch (e) {
       throw makeErr(command.title, e, ctx)
     }

package/lib/getSpawnedTask.js

@@ -116,7 +116,7 @@ export const makeErr = (command, error, ctx) => {
  * @param {string} [options.cwd]
  * @param {String} options.topLevelDir - Current git repo top-level path
  * @param {Boolean} options.isFn - Whether the linter task is a function
- * @param {Array<string>} options.files — Filepaths to run the linter task against
+ * @param {string[]} options.files — Filepaths to run the linter task against
  * @param {Boolean} [options.verbose] — Always show task verbose
  * @returns {() => Promise<Array<string>>}
  */

package/lib/getSpawnedTasks.js

@@ -11,7 +11,7 @@ const debugLog = debug('lint-staged:getSpawnedTasks')
  * @param {object} options
  * @param {Array<string|Function>|string|Function} options.commands
  * @param {string} options.cwd
- * @param {Array<string>} options.files
+ * @param {import('./getStagedFiles.js').StagedFile[]} options.files
  * @param {string} options.topLevelDir
  * @param {Boolean} verbose
  */
@@ -21,12 +21,14 @@ export const getSpawnedTasks = async ({ commands, cwd, files, topLevelDir, verbo
 
   const commandArray = Array.isArray(commands) ? commands : [commands]
 
+  const filepaths = files.map((f) => f.filepath)
+
   for (const cmd of commandArray) {
     // command function may return array of commands that already include `stagedFiles`
     const isFn = typeof cmd === 'function'
 
     /** Pass copy of file list to prevent mutation by function from config file. */
-    const resolved = isFn ? await cmd([...files]) : cmd
+    const resolved = isFn ? await cmd([...filepaths]) : cmd
 
     const resolvedArray = Array.isArray(resolved) ? resolved : [resolved] // Wrap non-array command as array
 
@@ -43,7 +45,7 @@ export const getSpawnedTasks = async ({ commands, cwd, files, topLevelDir, verbo
         )
       }
 
-      const task = getSpawnedTask({ command, cwd, files, topLevelDir, isFn, verbose })
+      const task = getSpawnedTask({ command, cwd, files: filepaths, topLevelDir, isFn, verbose })
       cmdTasks.push({ title: command, command, task })
     }
   }

package/lib/getStagedFiles.js

@@ -5,6 +5,16 @@ import { getDiffCommand } from './getDiffCommand.js'
 import { normalizePath } from './normalizePath.js'
 import { parseGitZOutput } from './parseGitZOutput.js'
 
+/**
+ * @typedef {'A'|'C'|'D'|'M'|'R'|'T'|'U'|'X'} FileSatus
+ * @typedef { { filepath: string; status: FileSatus }} StagedFile
+ *
+ * @param {Object} args
+ * @param {string} [args.cwd]
+ * @param {string} [args.diff]
+ * @param {string} [args.diffFilter]
+ * @retuns {Promise<StagedFile[] | null>}
+ */
 export const getStagedFiles = async ({ cwd = process.cwd(), diff, diffFilter } = {}) => {
   try {
     /**
@@ -35,7 +45,7 @@ export const getStagedFiles = async ({ cwd = process.cwd(), diff, diffFilter } =
       .split('\u0000:')
       .map(parseGitZOutput)
       .flatMap(([info, src, dst]) => {
-        const [, dstMode, , , ,] = info.split(' ')
+        const [, dstMode, , , statusWithScore] = info.split(' ')
 
         /**
          * Filter out submodules and symlinks
@@ -45,10 +55,30 @@ export const getStagedFiles = async ({ cwd = process.cwd(), diff, diffFilter } =
           return []
         }
 
+        /**
+         * @example "M"
+         * @example "R86"
+         *
+         * - A: addition of a file
+         * - C: copy of a file into a new one
+         * - D: deletion of a file
+         * - M: modification of the contents or mode of a file
+         * - R: renaming of a file
+         * - T: change in the type of the file (regular file, symbolic link or submodule)
+         * - U: file is unmerged (you must complete the merge before it can be committed)
+         * - X: "unknown" change type (most probably a bug, please report it)
+         */
+        const status = statusWithScore[0]
+
         /** "dst" exists when moving files, otherwise it's undefined and only "src" exists */
         const filename = dst ?? src
 
-        return [normalizePath(path.resolve(cwd, filename))]
+        return [
+          {
+            filepath: normalizePath(path.resolve(cwd, filename)),
+            status,
+          },
+        ]
       })
   } catch {
     return null

package/lib/gitWorkflow.js

@@ -1,3 +1,4 @@
+import fs from 'node:fs/promises'
 import path from 'node:path'
 
 import debug from 'debug'
@@ -66,6 +67,10 @@ const handleError = (error, ctx, symbol) => {
 }
 
 export class GitWorkflow {
+  /**
+   * @param {Object} opts
+   * @param {import('./getStagedFiles.js').StagedFile[][]} opts.matchedFileChunks
+   */
   constructor({ allowEmpty, gitConfigDir, topLevelDir, matchedFileChunks, diff, diffFilter }) {
     this.execGit = (args, options = {}) => execGit(args, { ...options, cwd: topLevelDir })
     this.deletedFiles = []
@@ -74,6 +79,7 @@ export class GitWorkflow {
     this.diff = diff
     this.diffFilter = diffFilter
     this.allowEmpty = allowEmpty
+    /** @type {import('./getStagedFiles.js').StagedFile[][]} */
     this.matchedFileChunks = matchedFileChunks
 
     /**
@@ -185,7 +191,7 @@ export class GitWorkflow {
         const [index, workingTree] = line
         return index !== ' ' && workingTree !== ' ' && index !== '?' && workingTree !== '?'
       })
-      .map((line) => line.substr(3)) // Remove first three letters (index, workingTree, and a whitespace)
+      .map((line) => line.slice(3)) // Remove first three letters (index, workingTree, and a whitespace)
       .filter(Boolean) // Filter empty string
     debugLog('Found partially staged files:', partiallyStaged)
     return partiallyStaged.length ? partiallyStaged : null
@@ -198,13 +204,14 @@ export class GitWorkflow {
     try {
       debugLog(task.title)
 
-      // Get a list of files with bot staged and unstaged changes.
+      // Get a list of files with both staged and unstaged changes.
       // Unstaged changes to these files should be hidden before the tasks run.
       this.partiallyStagedFiles = await this.getPartiallyStagedFiles()
 
       if (this.partiallyStagedFiles) {
         ctx.hasPartiallyStagedFiles = true
         const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
+        ctx.unstagedPatch = unstagedPatch
         const files = processRenames(this.partiallyStagedFiles)
         await this.execGit(['diff', ...GIT_DIFF_ARGS, '--output', unstagedPatch, '--', ...files])
       } else {
@@ -273,7 +280,22 @@ export class GitWorkflow {
     // These additions per chunk are run "serially" to prevent race conditions.
     // Git add creates a lockfile in the repo causing concurrent operations to fail.
     for (const files of this.matchedFileChunks) {
-      await this.execGit(['add', '--', ...files])
+      const accessCheckedFiles = await Promise.allSettled(
+        files.map(async (f) => {
+          if (f.status === 'D') {
+            await fs.access(f.filepath)
+            return f.filepath // File is no longer deleted and can be added
+          } else {
+            return f.filepath
+          }
+        })
+      )
+
+      const addableFiles = accessCheckedFiles.flatMap((r) =>
+        r.status === 'fulfilled' ? [r.value] : []
+      )
+
+      await this.execGit(['add', '--', ...addableFiles])
     }
 
     debugLog('Done adding task modifications to index!')

package/lib/groupFilesByConfig.js

@@ -4,10 +4,17 @@ import debug from 'debug'
 
 const debugLog = debug('lint-staged:groupFilesByConfig')
 
+/**
+ * @typedef {import('./getStagedFiles.js').StagedFile} StagedFile
+ * @type {(args: { config: {[key: string]: { config: any; files: string[] }}; files: StagedFile[]; singleConfigMode?: boolean }) => Promise<{[key: string]: { config: any; files: StagedFile[] } }>
+ */
 export const groupFilesByConfig = async ({ configs, files, singleConfigMode }) => {
   debugLog('Grouping %d files by %d configurations', files.length, Object.keys(configs).length)
 
+  /** @type {Set<StagedFile>} */
   const filesSet = new Set(files)
+
+  /** @type {{[key: string]: { config: any; files: StagedFile[] } }} */
   const filesByConfig = {}
 
   /** Configs are sorted deepest first by `searchConfigs` */
@@ -22,7 +29,7 @@ export const groupFilesByConfig = async ({ configs, files, singleConfigMode }) =
 
     /** Check if file is inside directory of the configuration file */
     const isInsideDir = (file) => {
-      const relative = path.relative(dir, file)
+      const relative = path.relative(dir, file.filepath)
       return relative && !relative.startsWith('..') && !path.isAbsolute(relative)
     }
 

package/lib/index.js

@@ -6,6 +6,7 @@ import {
   NO_CONFIGURATION,
   PREVENTED_EMPTY_COMMIT,
   RESTORE_STASH_EXAMPLE,
+  UNSTAGED_CHANGES_BACKUP_STASH_LOCATION,
 } from './messages.js'
 import { printTaskOutput } from './printTaskOutput.js'
 import { runAll } from './runAll.js'
@@ -15,6 +16,7 @@ import {
   ConfigNotFoundError,
   GetBackupStashError,
   GitError,
+  RestoreUnstagedChangesError,
 } from './symbols.js'
 import { validateOptions } from './validateOptions.js'
 import { getVersion } from './version.js'
@@ -81,7 +83,7 @@ const lintStaged = async (
     stash = diff === undefined,
     // Cannot revert to original state without stash
     revert = stash,
-    hidePartiallyStaged = stash,
+    hidePartiallyStaged = true,
     verbose = false,
   } = {},
   logger = console
@@ -138,6 +140,9 @@ const lintStaged = async (
         logger.error(NO_CONFIGURATION)
       } else if (ctx.errors.has(ApplyEmptyCommitError)) {
         logger.warn(PREVENTED_EMPTY_COMMIT)
+      } else if (ctx.errors.has(RestoreUnstagedChangesError)) {
+        logger.warn(UNSTAGED_CHANGES_BACKUP_STASH_LOCATION)
+        logger.warn(ctx.unstagedPatch)
       } else if (
         (ctx.errors.has(GitError) || cleanupSkipped(ctx)) &&
         !ctx.errors.has(GetBackupStashError)

package/lib/messages.js

@@ -31,25 +31,15 @@ export const skippingBackup = (hasInitialCommit, diff) => {
   const reason =
     diff !== undefined
       ? '`--diff` was used'
-      : hasInitialCommit
-        ? '`--no-stash` was used'
-        : 'there’s no initial commit yet'
+      : (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`)
 }
 
-export const skippingHidePartiallyStaged = (stash, diff) => {
-  const reason =
-    diff !== undefined
-      ? '`--diff` was used'
-      : !stash
-        ? '`--no-stash` was used'
-        : '`--no-hide-partially-staged` was used'
-
-  return chalk.yellow(
-    `${warning} Skipping hiding unstaged changes from partially staged files because ${reason}.\n`
-  )
-}
+export const SKIPPING_HIDE_PARTIALLY_CHANGED = chalk.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(
   `${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.
@@ -96,3 +86,5 @@ export const failedToParseConfig = (
 ${error}
 
 See https://github.com/okonet/lint-staged#configuration.`
+
+export const UNSTAGED_CHANGES_BACKUP_STASH_LOCATION = `Unstaged changes have been kept back in a patch file:`

package/lib/resolveGitRepo.js

@@ -8,53 +8,53 @@ import { normalizePath } from './normalizePath.js'
 const debugLog = debug('lint-staged:resolveGitRepo')
 
 /**
- * Resolve .git directory relative to repo top-level directory
- *
- * @example ".git"
+ * Relative path up to the repo top-level directory
+ * @example "../"
  */
-const resolveRelativeGitDir = async (cwd) => {
-  /**
-   * Absolute repo top-level directory
-   *
-   * @example <caption>Git on macOS</caption>
-   * "/Users/iiro/Documents/git/lint-staged"
-   *
-   * @example <caption>Git for Windows</caption>
-   * "C:\Users\iiro\Documents\git\lint-staged"
-   *
-   * @example <caption>Git installed with MSYS2, this doesn't work when used as CWD with Node.js child_process</caption>
-   * "/c/Users/iiro/Documents/git/lint-staged"
-   */
-  const topLevelPromise = execGit(['rev-parse', '--show-toplevel'], { cwd })
-
-  /**
-   * Absolute .git directory, similar to top-level
-   *
-   * @example "/Users/iiro/Documents/git/lint-staged/.git"
-   */
-  const absoluteGitDirPromise = execGit(['rev-parse', '--absolute-git-dir'], { cwd })
+const CDUP = '--show-cdup'
 
-  const [topLevel, absoluteGitDir] = await Promise.all([topLevelPromise, absoluteGitDirPromise])
+/**
+ * Absolute repo top-level directory
+ *
+ * @example <caption>Git on macOS</caption>
+ * "/Users/iiro/Documents/git/lint-staged"
+ *
+ * @example <caption>Git for Windows</caption>
+ * "C:\Users\iiro\Documents\git\lint-staged"
+ *
+ * @example <caption>Git installed with MSYS2, this doesn't work when used as CWD with Node.js child_process</caption>
+ * "/c/Users/iiro/Documents/git/lint-staged"
+ */
+const TOPLEVEL = '--show-toplevel'
 
-  return path.relative(topLevel, absoluteGitDir)
-}
+/**
+ * Absolute .git directory, similar to top-level
+ *
+ * @example "/Users/iiro/Documents/git/lint-staged/.git"
+ */
+const ABSOLUTE_GIT_DIR = '--absolute-git-dir'
 
 /** Resolve git directory and possible submodule paths */
 export const resolveGitRepo = async (cwd = process.cwd()) => {
   try {
     debugLog('Resolving git repo from `%s`', cwd)
 
+    /** Git rev-parse returns all three flag values on separate lines  */
+    const revParseOutput = await execGit(['rev-parse', CDUP, TOPLEVEL, ABSOLUTE_GIT_DIR], {
+      cwd,
+    })
+    const [relativeTopLevelDir, topLevel, absoluteGitDir] = revParseOutput.split('\n')
+
     // Unset GIT_DIR before running any git operations in case it's pointing to an incorrect location
     debugLog('Unset GIT_DIR (was `%s`)', process.env.GIT_DIR)
     delete process.env.GIT_DIR
     debugLog('Unset GIT_WORK_TREE (was `%s`)', process.env.GIT_WORK_TREE)
     delete process.env.GIT_WORK_TREE
 
-    const relativeTopLevelDir = await execGit(['rev-parse', '--show-cdup'], { cwd })
     const topLevelDir = normalizePath(path.join(cwd, relativeTopLevelDir))
     debugLog('Resolved git repository top-level directory to be `%s`', topLevelDir)
 
-    const relativeGitConfigDir = await resolveRelativeGitDir(cwd)
+    const relativeGitConfigDir = path.relative(topLevel, absoluteGitDir)
     const gitConfigDir = normalizePath(path.join(topLevelDir, relativeGitConfigDir))
     debugLog('Resolved git config directory to be `%s`', gitConfigDir)
 

package/lib/runAll.js

@@ -22,8 +22,8 @@ import {
   NO_TASKS,
   NOT_GIT_REPO,
   SKIPPED_GIT_ERROR,
+  SKIPPING_HIDE_PARTIALLY_CHANGED,
   skippingBackup,
-  skippingHidePartiallyStaged,
 } from './messages.js'
 import { normalizePath } from './normalizePath.js'
 import { resolveGitRepo } from './resolveGitRepo.js'
@@ -42,7 +42,12 @@ import { ConfigNotFoundError, GetStagedFilesError, GitError, GitRepoError } from
 
 const debugLog = debug('lint-staged:runAll')
 
-const createError = (ctx) => Object.assign(new Error('lint-staged failed'), { ctx })
+/**
+ * @param {ReturnType<typeof getInitialState>} ctx context
+ * @param {unknown} cause error cause
+ */
+const createError = (ctx, cause) =>
+  Object.assign(new Error('lint-staged failed', { cause }), { ctx })
 
 /**
  * Executes all tasks and either resolves or rejects the promise
@@ -82,7 +87,7 @@ export const runAll = async (
     stash = diff === undefined,
     // Cannot revert to original state without stash
     revert = stash,
-    hidePartiallyStaged = stash,
+    hidePartiallyStaged = true,
     verbose = false,
   },
   logger = console
@@ -100,7 +105,7 @@ export const runAll = async (
   if (!topLevelDir) {
     if (!quiet) ctx.output.push(NOT_GIT_REPO)
     ctx.errors.add(GitRepoError)
-    throw createError(ctx)
+    throw createError(ctx, GitRepoError)
   }
 
   // Test whether we have any commits or not.
@@ -118,19 +123,19 @@ export const runAll = async (
 
   ctx.shouldHidePartiallyStaged = hidePartiallyStaged
   if (!ctx.shouldHidePartiallyStaged && !quiet) {
-    logger.warn(skippingHidePartiallyStaged(hasInitialCommit && stash, diff))
+    logger.warn(SKIPPING_HIDE_PARTIALLY_CHANGED)
   }
 
-  const files = await getStagedFiles({ cwd: topLevelDir, diff, diffFilter })
-  if (!files) {
+  const stagedFiles = await getStagedFiles({ cwd: topLevelDir, diff, diffFilter })
+  if (!stagedFiles) {
     if (!quiet) ctx.output.push(FAILED_GET_STAGED_FILES)
     ctx.errors.add(GetStagedFilesError)
     throw createError(ctx, GetStagedFilesError)
   }
-  debugLog('Loaded list of staged files in git:\n%O', files)
+  debugLog('Loaded list of staged files in git:\n%O', stagedFiles)
 
   // If there are no files avoid executing any lint-staged logic
-  if (files.length === 0) {
+  if (stagedFiles.length === 0) {
     if (!quiet) ctx.output.push(NO_STAGED_FILES)
     return ctx
   }
@@ -146,7 +151,7 @@ export const runAll = async (
 
   const filesByConfig = await groupFilesByConfig({
     configs: foundConfigs,
-    files,
+    files: stagedFiles,
     singleConfigMode: configObject || configPath !== undefined,
   })
 
@@ -174,6 +179,7 @@ export const runAll = async (
   const listrTasks = []
 
   // Set of all staged files that matched a task glob. Values in a set are unique.
+  /** @type {Set<import('./getStagedFiles.js').StagedFile>} */
   const matchedFiles = new Set()
 
   for (const [configPath, { config, files }] of Object.entries(filesByConfig)) {
@@ -195,7 +201,7 @@ export const runAll = async (
       const chunkListrTasks = await Promise.all(
         generateTasks({ config, cwd: groupCwd, files, relative }).map((task) =>
           (isFunctionTask(task.commands)
-            ? getFunctionTask(task.commands, files)
+            ? getFunctionTask(task.commands, task.fileList)
             : getSpawnedTasks({
                 commands: task.commands,
                 cwd: groupCwd,
@@ -209,9 +215,12 @@ export const runAll = async (
               // Make sure relative files are normalized to the
               // group cwd, because other there might be identical
               // relative filenames in the entire set.
-              const normalizedFile = path.isAbsolute(file)
+              const normalizedFile = path.isAbsolute(file.filepath)
                 ? file
-                : normalizePath(path.join(groupCwd, file))
+                : {
+                    filepath: normalizePath(path.join(groupCwd, file.filepath)),
+                    status: file.status,
+                  }
 
               matchedFiles.add(normalizedFile)
             })
@@ -275,6 +284,7 @@ export const runAll = async (
   }
 
   // Chunk matched files for better Windows compatibility
+  /** @type {import('./getStagedFiles.js').StagedFile[][]} */
   const matchedFileChunks = chunkFiles({
     // matched files are relative to `cwd`, not `topLevelDir`, when `relative` is used
     baseDir: cwd,

package/lib/state.js

@@ -9,15 +9,16 @@ import {
 } from './symbols.js'
 
 export const getInitialState = ({ quiet = false, revert = true } = {}) => ({
-  hasPartiallyStagedFiles: null,
-  shouldBackup: null,
-  shouldRevert: revert,
   backupHash: null,
-  shouldHidePartiallyStaged: true,
   errors: new Set([]),
   events: new EventEmitter(),
+  hasPartiallyStagedFiles: null,
   output: [],
   quiet,
+  shouldBackup: null,
+  shouldHidePartiallyStaged: true,
+  shouldRevert: revert,
+  unstagedPatch: null,
 })
 
 export const shouldHidePartiallyStagedFiles = (ctx) =>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-staged",
-  "version": "16.1.0",
+  "version": "16.1.2",
   "description": "Lint files staged by git",
   "license": "MIT",
   "repository": {
@@ -63,17 +63,17 @@
     "@changesets/cli": "2.29.4",
     "@commitlint/cli": "19.8.1",
     "@commitlint/config-conventional": "19.8.1",
-    "@eslint/js": "9.27.0",
+    "@eslint/js": "9.29.0",
     "consolemock": "1.1.0",
     "cross-env": "7.0.3",
-    "eslint": "9.27.0",
+    "eslint": "9.29.0",
     "eslint-config-prettier": "10.1.5",
-    "eslint-plugin-jest": "28.11.0",
-    "eslint-plugin-n": "17.18.0",
-    "eslint-plugin-prettier": "5.4.0",
+    "eslint-plugin-jest": "28.13.5",
+    "eslint-plugin-n": "17.20.0",
+    "eslint-plugin-prettier": "5.4.1",
     "eslint-plugin-simple-import-sort": "12.1.1",
     "husky": "9.1.7",
-    "jest": "29.7.0",
+    "jest": "30.0.0",
     "jest-snapshot-serializer-ansi": "2.2.1",
     "mock-stdin": "1.0.0",
     "prettier": "3.5.3",