@depup/lint-staged 16.4.0-depup.0 → 17.1.0-depup.0

package/MIGRATION.md

@@ -1,3 +1,23 @@
+## v17
+
+#### Node.js v20 is no longer supported.
+
+The oldest supported Node.js version is now 22.22.1, which is the latest active v22 LTS version at the time of release. You can — of course — update to v24 or v25, or later.
+
+#### The `yaml` dependency is now optional
+
+The dependency `yaml` is now marked as optional and probably won't be installed by default. If you're using a YAML configuration file you should install the package separately:
+
+```shell
+npm install --development yaml
+```
+
+If you're using `.lintstagedrc` as the config file name (without a file extension), it will be treated as a YAML file. If the content is JSON, consider renaming it to `.lintstagedrc.json` to avoid needing to install `yaml`.
+
+#### Git version needs to be at least 2.32.0
+
+_Lint-staged_ now tries to verify the installed Git version is at least `2.32.0`, released in 2021. If you're using an even older Git version, you need to [upgrade](https://git-scm.com/install/mac) it before running _lint-staged_!
+
 ## v16
 
 #### Updated Node.js version requirement

package/README.md

@@ -13,16 +13,10 @@ npm install @depup/lint-staged
 
 | Field | Value |
 |-------|-------|
-| Original | [lint-staged](https://www.npmjs.com/package/lint-staged) @ 16.4.0 |
-| Processed | 2026-03-14 |
+| Original | [lint-staged](https://www.npmjs.com/package/lint-staged) @ 17.1.0 |
+| Processed | 2026-07-21 |
 | Smoke test | passed |
-| Deps updated | 1 |
-
-## Dependency Changes
-
-| Dependency | From | To |
-|------------|------|-----|
-| listr2 | ^9.0.5 | ^10.2.1 |
+| Deps updated | 0 |
 
 ---
 

package/bin/lint-staged.js

@@ -2,152 +2,34 @@
 
 import { userInfo } from 'node:os'
 
-import { Option, program } from 'commander'
-
+import { getVersionNumber, parseCliOptions, printHelpText } from '../lib/cli.js'
+import { enableColors } from '../lib/colors.js'
 import { createDebug, enableDebug } from '../lib/debug.js'
 import lintStaged from '../lib/index.js'
-import { CONFIG_STDIN_ERROR, restoreStashExample } from '../lib/messages.js'
 import { readStdin } from '../lib/readStdin.js'
-import { getVersion } from '../lib/version.js'
 
+enableColors(!!process.stdout.hasColors?.())
 const debugLog = createDebug('lint-staged:bin')
 
-// Do not terminate main Listr process on SIGINT
+// SIGINT handled by an AbortController
 process.on('SIGINT', () => {})
 
-program
-  .version(await getVersion())
-
-  /**
-   * This shouldn't be necessary for lint-staged, but add migration step just in case
-   * to preserve old behavior of "commander".
-   *
-   * @todo remove this in the major version
-   * @see https://github.com/tj/commander.js/releases/tag/v13.0.0
-   * */
-  .allowExcessArguments()
-
-  .addOption(
-    new Option('--allow-empty', 'allow empty commits when tasks revert all staged changes').default(
-      false
-    )
-  )
-  .addOption(
-    new Option(
-      '-p, --concurrent <number|boolean>',
-      'the number of tasks to run concurrently, or false for serial'
-    ).default(true)
-  )
-  .addOption(
-    new Option('-c, --config [path]', 'path to configuration file, or - to read from stdin')
-  )
-  .addOption(
-    new Option('--cwd [path]', 'run all tasks in specific directory, instead of the current')
-  )
-  .addOption(new Option('-d, --debug', 'print additional debug information').default(false))
-  .addOption(
-    new Option(
-      '--diff [string]',
-      'override the default "--staged" flag of "git diff" to get list of files. Implies "--no-stash".'
-    ).implies({ stash: false })
-  )
-  .addOption(
-    new Option(
-      '--diff-filter [string]',
-      'override the default "--diff-filter=ACMR" flag of "git diff" to get list of files'
-    )
-  )
-  .addOption(
-    new Option('--continue-on-error', 'run all tasks to completion even if one fails').default(
-      false
-    )
-  )
-  .addOption(
-    new Option('--fail-on-changes', 'fail with exit code 1 when tasks modify tracked files')
-      .default(false)
-      .implies({ revert: false })
-  )
-  .addOption(
-    new Option(
-      '--max-arg-length [number]',
-      'maximum length of the command-line argument string'
-    ).default(0)
-  )
-
-  /**
-   * We don't want to show the `--revert` flag because it's on by default, and only show the
-   * negatable flag `--no-rever` instead. There seems to be a bug in Commander.js where
-   * configuring only the latter won't actually set the default value.
-   */
-  .addOption(
-    new Option('--revert', 'revert to original state in case of errors').default(true).hideHelp()
-  )
-  .addOption(
-    new Option('--no-revert', 'do not revert to original state in case of errors.').default(false)
-  )
-
-  .addOption(new Option('--stash', 'enable the backup stash').default(true).hideHelp())
-  .addOption(
-    new Option('--no-stash', 'disable the backup stash. Implies "--no-revert".')
-      .default(false)
-      .implies({ revert: false })
-  )
-
-  .addOption(
-    new Option('--hide-partially-staged', 'hide unstaged changes from partially staged files')
-      .default(true)
-      .hideHelp()
-  )
-  .addOption(
-    new Option(
-      '--no-hide-partially-staged',
-      'disable hiding unstaged changes from partially staged files'
-    ).default(false)
-  )
+const cliOptions = parseCliOptions(process.argv)
 
-  .addOption(
-    new Option('--hide-unstaged', 'hide all unstaged changes, instead of just partially staged')
-      .default(false)
-      .implies({ hidePartiallyStaged: false })
-  )
-
-  .addOption(new Option('-q, --quiet', 'disable lint-staged’s own console output').default(false))
-  .addOption(new Option('-r, --relative', 'pass relative filepaths to tasks').default(false))
-  .addOption(
-    new Option(
-      '-v, --verbose',
-      'show task output even when tasks succeed; by default only failed output is shown'
-    ).default(false)
-  )
-
-  .addHelpText('afterAll', '\n' + restoreStashExample())
+if (cliOptions.version) {
+  console.log(await getVersionNumber())
+  process.exit(0)
+}
 
-const cliOptions = program.parse(process.argv).opts()
+if (cliOptions.help) {
+  console.log(await printHelpText())
+  process.exit(0)
+}
 
 if (cliOptions.debug) {
   enableDebug()
 }
 
-const options = {
-  allowEmpty: !!cliOptions.allowEmpty,
-  concurrent: JSON.parse(cliOptions.concurrent),
-  configPath: cliOptions.config,
-  continueOnError: !!cliOptions.continueOnError,
-  cwd: cliOptions.cwd,
-  debug: !!cliOptions.debug,
-  diff: cliOptions.diff,
-  diffFilter: cliOptions.diffFilter,
-  failOnChanges: !!cliOptions.failOnChanges,
-  hidePartiallyStaged: !!cliOptions.hidePartiallyStaged, // commander inverts `no-<x>` flags to `!x`
-  hideUnstaged: !!cliOptions.hideUnstaged,
-  maxArgLength: cliOptions.maxArgLength || undefined,
-  quiet: !!cliOptions.quiet,
-  relative: !!cliOptions.relative,
-  revert: !!cliOptions.revert, // commander inverts `no-<x>` flags to `!x`
-  stash: !!cliOptions.stash, // commander inverts `no-<x>` flags to `!x`
-  verbose: !!cliOptions.verbose,
-}
-
 try {
   const { shell } = userInfo()
   debugLog('Using shell: %s', shell)
@@ -155,21 +37,20 @@ try {
   debugLog('Could not determine current shell')
 }
 
-debugLog('Options parsed from command-line: %o', options)
+debugLog('Options parsed from command-line: %o', cliOptions)
 
-if (options.configPath === '-') {
-  delete options.configPath
+if (cliOptions.configPath === '-') {
+  delete cliOptions.configPath
   try {
     debugLog('Reading config from stdin')
-    options.config = JSON.parse(await readStdin())
+    cliOptions.config = JSON.parse(await readStdin())
   } catch (error) {
-    debugLog(CONFIG_STDIN_ERROR, error)
-    console.error(CONFIG_STDIN_ERROR)
-    process.exit(1)
+    console.error('Failed to read config from stdin!')
+    throw error
   }
 }
 
-const passed = await lintStaged(options)
+const passed = await lintStaged(cliOptions)
 if (!passed) {
   process.exitCode = 1
 }

package/changes.json

@@ -0,0 +1,5 @@
+{
+  "bumped": {},
+  "timestamp": "2026-07-21T17:26:54.382Z",
+  "totalUpdated": 0
+}

package/lib/assertGitVersion.js

@@ -0,0 +1,48 @@
+/** @see {@link https://github.com/git/git/blob/master/Documentation/RelNotes/2.32.0.adoc} */
+export const MIN_GIT_VERSION = '2.32.0'
+
+/**
+ * @param {string} gitVersionOutput the Git version command output
+ * @returns {string} the Git version number in format `<major>.<minor>.<patch>`
+ */
+const extractGitVersionNumber = (gitVersionOutput) => {
+  const match = gitVersionOutput.match(/git version\s+(\d+\.\d+\.\d+)/i)
+  return match?.[1]
+}
+
+/**
+ * @param {string} version the version number in format `<major>.<minor>.<patch>`
+ * @returns {[string, string, string]} the version number parsed as integers `[major, minor, patch]`
+ */
+const parseSemver = (version) => {
+  const match = /(\d+)\.(\d+)\.(\d+)/.exec(version)
+  return match?.slice(1, 4).map(Number)
+}
+
+/**
+ *
+ * @param {string} actual the actual version number in format `<major>.<minor>.<patch>`
+ * @param {string} expected the expected version number in format `<major>.<minor>.<patch>`
+ * @returns {boolean} `true` when the actual version number is at least the expected version number
+ */
+export const satisfiesVersion = (actual, expected) => {
+  const a = parseSemver(actual)
+  const e = parseSemver(expected)
+  if (a[0] !== e[0]) return a[0] > e[0]
+  if (a[1] !== e[1]) return a[1] > e[1]
+  return a[2] >= e[2]
+}
+
+/**
+ *
+ * @param {string} gitVersionOutput the Git version command output
+ * @returns {boolean} `true` when the Git version number is supported
+ */
+export const assertGitVersion = (gitVersionOutput) => {
+  try {
+    const version = extractGitVersionNumber(gitVersionOutput)
+    return satisfiesVersion(version, MIN_GIT_VERSION)
+  } catch {
+    return false
+  }
+}

package/lib/cli.js

@@ -0,0 +1,251 @@
+import { readFile } from 'node:fs/promises'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { parseArgs } from 'node:util'
+
+import { restoreStashExample } from './messages.js'
+
+const CLI_OPTIONS = [
+  {
+    short: 'h',
+    flag: 'help',
+    type: 'boolean',
+    description: 'display this help message',
+  },
+  {
+    short: 'V',
+    flag: 'version',
+    type: 'boolean',
+    description: 'display the current version number',
+  },
+  {
+    flag: 'allow-empty',
+    type: 'boolean',
+    description: 'allow empty commits when tasks revert all staged changes (default: false)',
+  },
+  {
+    short: 'p',
+    flag: 'concurrent',
+    positional: '<number|boolean>',
+    type: 'string',
+    description: 'the number of tasks to run concurrently, or false for serial (default: true)',
+  },
+  {
+    short: 'c',
+    flag: 'config',
+    positional: '[path]',
+    type: 'string',
+    description: 'path to configuration file, or - to read from stdin',
+  },
+  {
+    flag: 'continue-on-error',
+    type: 'boolean',
+    description: 'run all tasks to completion even if one fails (default: false)',
+  },
+  {
+    flag: 'cwd',
+    positional: '[path]',
+    type: 'string',
+    description: 'run all tasks in specific directory, instead of the current',
+  },
+  {
+    short: 'd',
+    flag: 'debug',
+    type: 'boolean',
+    description: 'print additional debug information (default: false)',
+  },
+  {
+    flag: 'diff',
+    positional: '[string]',
+    type: 'string',
+    description:
+      'override the default "--staged" flag of "git diff" to get list of files. Implies "--no-stash".',
+  },
+  {
+    flag: 'diff-filter',
+    positional: '[string]',
+    type: 'string',
+    description:
+      'override the default "--diff-filter=ACMR" flag of "git diff" to get list of files',
+  },
+  {
+    flag: 'fail-on-changes',
+    type: 'boolean',
+    description: 'fail with exit code 1 when tasks modify tracked files (default: false)',
+  },
+  {
+    negative: true,
+    flag: 'hide-partially-staged',
+    type: 'boolean',
+    description: 'hide unstaged changes from partially staged files (default: true)',
+  },
+  {
+    flag: 'hide-unstaged',
+    type: 'boolean',
+    description: 'hide all unstaged changes, instead of just partially staged (default: false)',
+  },
+  {
+    flag: 'hide-all',
+    type: 'boolean',
+    description: 'hide all unstaged changes and untracked files (default: false)',
+  },
+  {
+    flag: 'max-arg-length',
+    type: 'string', // Parsed with `parseInt()` below
+    positional: '[number]',
+    description: 'maximum length of the command-line argument string (default: 0)',
+  },
+  {
+    short: 'q',
+    flag: 'quiet',
+    type: 'boolean',
+    description: "disable lint-staged's own console output (default: false)",
+  },
+  {
+    short: 'r',
+    flag: 'relative',
+    type: 'boolean',
+    description: 'pass relative filepaths to tasks (default: false)',
+  },
+  {
+    negative: true,
+    flag: 'revert',
+    type: 'boolean',
+    description: 'revert to original state in case of errors (default: true)',
+  },
+  {
+    negative: true,
+    flag: 'stash',
+    type: 'boolean',
+    description: 'enable the backup stash (default: true)',
+  },
+  {
+    short: 'v',
+    flag: 'verbose',
+    type: 'boolean',
+    description:
+      'show task output even when tasks succeed; by default only failed output is shown (default: false)',
+  },
+]
+
+/** @param {string[]} argv */
+export const parseCliOptions = (argv) => {
+  const options = CLI_OPTIONS.reduce((acc, current) => {
+    acc[current.flag] = { type: current.type }
+    if (current.short) acc[current.flag].short = current.short
+    return acc
+  }, {})
+
+  const { values } = parseArgs({
+    args: argv,
+    allowNegative: true,
+    allowPositionals: true,
+    options,
+  })
+
+  if (values.diff !== undefined && values.stash === undefined) {
+    /** Disable stashing by default when diffing specific value */
+    values.stash = false
+  }
+
+  if (values['fail-on-changes'] && values.revert === undefined) {
+    /** When using --fail-on-changes, default to not reverting on errors */
+    values.revert = false
+  }
+
+  if (values.stash === false && values.revert === undefined) {
+    /** Can't revert when using --no-stash */
+    values.revert = false
+  }
+
+  if (values['hide-unstaged'] === true) {
+    values['hide-partially-staged'] = false // becomes redundant
+  }
+
+  if (values['hide-all'] === true) {
+    values['hide-partially-staged'] = false // becomes redundant
+    values['hide-unstaged'] = false // becomes redundant
+  }
+
+  const maxArgLength =
+    values['max-arg-length'] !== undefined ? parseInt(values['max-arg-length'], 10) : undefined
+
+  if (Number.isNaN(maxArgLength)) {
+    throw new TypeError(`Option '--mar-arg-length' takes a numeric argument`, {
+      cause: { '--max-arg-length': values['max-arg-length'] },
+    })
+  }
+
+  return {
+    allowEmpty: values['allow-empty'] ?? false,
+    concurrent: values.concurrent === undefined ? true : JSON.parse(values.concurrent),
+    configPath: values.config,
+    continueOnError: !!values['continue-on-error'],
+    cwd: values.cwd,
+    debug: !!values.debug,
+    diff: values.diff,
+    diffFilter: values['diff-filter'],
+    failOnChanges: !!values['fail-on-changes'],
+    help: !!values.help,
+    hidePartiallyStaged: values['hide-partially-staged'] ?? true,
+    hideUnstaged: !!values['hide-unstaged'],
+    hideAll: !!values['hide-all'],
+    maxArgLength,
+    quiet: !!values.quiet,
+    relative: !!values.relative,
+    revert: values.revert ?? true,
+    stash: values.stash ?? true,
+    verbose: !!values.verbose,
+    version: !!values.version,
+  }
+}
+
+export const getVersionNumber = async () => {
+  const dirname = path.dirname(fileURLToPath(import.meta.url))
+  const packageJsonFile = await readFile(path.join(dirname, '../package.json'), 'utf-8')
+  /** @type {import('../package.json')} */
+  const packageJson = JSON.parse(packageJsonFile)
+
+  return packageJson.version
+}
+
+const helpOptions = CLI_OPTIONS.map((option) => {
+  if (option.negative) {
+    /** @example `--no-stash` */
+    return [`--no-${option.flag}`, option.description]
+  }
+
+  /**
+   * @example `-V, --version
+   * or
+   * @example `--allow-empty`
+   */
+  let arg = option.short ? `-${option.short}, --${option.flag}` : `--${option.flag}`
+
+  /** @example `--cwd [path]` */
+  if (option.positional) arg += ` ${option.positional}`
+
+  return [arg, option.description]
+})
+
+const createWrap = (width) => {
+  const regExp = new RegExp(`.{1,${width}}(\\s|$)`, 'g')
+  return (text) => text.match(regExp)?.map((s) => s.trimEnd())
+}
+
+export const printHelpText = async (width = process.stdout.columns ?? 80) => {
+  const output = ['Usage: lint-staged [options]', '']
+
+  const col1Width = Math.max(...helpOptions.map(([arg]) => arg.length)) + 2
+  const wrap = createWrap(width - col1Width)
+
+  for (const [arg, description] of helpOptions) {
+    const lines = wrap(description)
+    const pad = ' '.repeat(col1Width)
+    output.push(arg.padEnd(col1Width) + lines[0], ...lines.slice(1).map((line) => pad + line))
+  }
+
+  output.push('', restoreStashExample())
+
+  return output.join('\n')
+}

package/lib/colors.js

@@ -1,106 +1,29 @@
-import nodeTty from 'node:tty'
+import util from 'node:util'
 
-/**
- * @example NO_COLOR
- * @example NO_COLOR=1
- * @example NO_COLOR=true
- */
-const TRUTHRY_ENV_VAR_VALUES = ['', '1', 'true']
-
-/**
- * @example FORCE_COLOR=0
- * @example FORCE_COLOR=false
- */
-const FALSY_ENV_VAR_VALUES = ['0', 'false']
-
-/**
- * @returns `true` if ANSI colors are supported
- *
- * @param {NodeJS.Process} [p]
- * @param {boolean} [isTty]
- */
-export const supportsAnsiColors = (p = process, isTty = nodeTty.isatty(1)) => {
-  const noColor = p?.env?.NO_COLOR?.toLowerCase()
-  if (TRUTHRY_ENV_VAR_VALUES.includes(noColor)) {
-    return false
-  }
-
-  const forceColor = p?.env?.FORCE_COLOR?.toLowerCase()
-  if (TRUTHRY_ENV_VAR_VALUES.includes(forceColor)) {
-    return true
-  } else if (FALSY_ENV_VAR_VALUES.includes(forceColor)) {
-    return false
-  }
-
-  const forceTty = p?.env?.FORCE_TTY
-  if (TRUTHRY_ENV_VAR_VALUES.includes(forceTty)) {
-    return true
-  } else if (FALSY_ENV_VAR_VALUES.includes(forceTty)) {
-    return false
-  }
-
-  if (isTty) {
-    return true
-  }
-
-  /**
-   * Assume CI supports color
-   * @see {@link https://github.com/alexeyraspopov/picocolors/blob/0e7c4af2de299dd7bc5916f2bddd151fa2f66740/picocolors.js#L4}
-   * @see {@link https://github.com/tinylibs/tinyrainbow/blob/071034bf2eafa28d91ef0ba48a3837420d81a40a/src/index.ts#L91}
-   */
-  if (TRUTHRY_ENV_VAR_VALUES.includes(p?.env?.CI)) {
-    return true
-  }
+export let COLORS_ENABLED = false
 
-  if (p?.env?.TERM && p.env.TERM === 'dumb') {
-    return false
+/** @param {boolean} [enabled] */
+export const enableColors = (enabled) => {
+  if (enabled) {
+    COLORS_ENABLED = true
   }
-
-  /**
-   * Assume Windows supports color
-   * @see {@link https://github.com/alexeyraspopov/picocolors/blob/0e7c4af2de299dd7bc5916f2bddd151fa2f66740/picocolors.js#L4}
-   * @see {@link https://github.com/tinylibs/tinyrainbow/blob/071034bf2eafa28d91ef0ba48a3837420d81a40a/src/index.ts#L89}
-   */
-  if (p?.platform === 'win32') {
-    return true
-  }
-
-  return false
 }
 
 /**
- * @deprecated replace this with Node.js builtin after minimum supported version is >=20.18.0
- * @example util.styleText('red', 'test') !== 'text'
+ * @param {util.InspectColor | readonly util.InspectColor[]} format
+ * @returns {(text: string) => string}
  */
-export const SUPPORTS_COLOR = supportsAnsiColors()
+const styleText = (format) => (text) =>
+  COLORS_ENABLED ? util.styleText(format, text, { validateStream: false }) : text
 
-const ANSI_RESET = '\u001B[0m'
+export const green = styleText('green')
 
-/**
- * @callback WrapAnsi
- * @param {string} text
- * @returns {string}
- */
-/**
- * @deprecated replace this with Node.js builtin after minimum supported version is >=20.18.0
- * @example (format) => (text) => util.styleText(format, text)
- *
- * @param {string} code
- * @param {boolean} [supported]
- * @returns {WrapAnsi}
- *
- */
-export const wrapAnsiColor = (code, supported = SUPPORTS_COLOR) => {
-  if (supported) {
-    return (text) => code + text + ANSI_RESET
-  }
+export const red = styleText('red')
 
-  return (text) => text
-}
+export const yellow = styleText('yellow')
+
+export const blue = styleText('blue')
+
+export const dim = styleText('dim')
 
-export const red = wrapAnsiColor('\u001B[0;31m')
-export const green = wrapAnsiColor('\u001B[0;32m')
-export const yellow = wrapAnsiColor('\u001B[0;33m')
-export const blue = wrapAnsiColor('\u001B[0;34m')
-export const blackBright = wrapAnsiColor('\u001B[0;90m')
-export const bold = wrapAnsiColor('\u001b[1m')
+export const bold = styleText('bold')

package/lib/debug.js

@@ -1,15 +1,13 @@
 import { formatWithOptions } from 'node:util'
 
-import { blackBright, SUPPORTS_COLOR } from './colors.js'
+import { COLORS_ENABLED, dim } from './colors.js'
 
-const format = (...args) => formatWithOptions({ colors: SUPPORTS_COLOR }, ...args)
+const format = (...args) => formatWithOptions({ colors: COLORS_ENABLED }, ...args)
 
 let activeLogger
 
 export const enableDebug = (logger = console) => {
-  if (!activeLogger) {
-    activeLogger = logger
-  }
+  activeLogger = logger
 }
 
 /** @param {string} name */
@@ -22,6 +20,6 @@ export const createDebug = (name) => {
     const now = process.hrtime.bigint()
     const ms = (now - previous) / 1_000_000n
     previous = now
-    activeLogger.debug(blackBright(name + ': ') + format(...args) + blackBright(` +${ms}ms`))
+    activeLogger.debug(dim(name + ': ') + format(...args) + dim(` +${ms}ms`))
   }
 }