lint-staged 16.3.4 → 17.0.0

package/lib/cli.js

@@ -0,0 +1,242 @@
+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
+  }
+
+  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: parseInt(values['max-arg-length'], 10),
+    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,11 @@
-import nodeTty from 'node:tty'
+/* eslint-disable n/no-unsupported-features/node-builtins */
 
-/**
- * @example NO_COLOR
- * @example NO_COLOR=1
- * @example NO_COLOR=true
- */
-const TRUTHRY_ENV_VAR_VALUES = ['', '1', 'true']
+import util from 'node:util'
 
-/**
- * @example FORCE_COLOR=0
- * @example FORCE_COLOR=false
- */
-const FALSY_ENV_VAR_VALUES = ['0', 'false']
+export const SUPPORTS_COLOR = !!process.stdout.hasColors?.()
 
-/**
- * @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
-  }
-
-  if (p?.env?.TERM && p.env.TERM === 'dumb') {
-    return false
-  }
-
-  /**
-   * 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'
- */
-export const SUPPORTS_COLOR = supportsAnsiColors()
-
-const ANSI_RESET = '\u001B[0m'
-
-/**
- * @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
-  }
-
-  return (text) => text
-}
-
-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 red = (text) => (SUPPORTS_COLOR ? util.styleText('red', text) : text)
+export const yellow = (text) => (SUPPORTS_COLOR ? util.styleText('yellow', text) : text)
+export const blue = (text) => (SUPPORTS_COLOR ? util.styleText('blue', text) : text)
+export const dim = (text) => (SUPPORTS_COLOR ? util.styleText('dim', text) : text)
+export const bold = (text) => (SUPPORTS_COLOR ? util.styleText('bold', text) : text)

package/lib/debug.js

@@ -1,15 +1,13 @@
 import { formatWithOptions } from 'node:util'
 
-import { blackBright, SUPPORTS_COLOR } from './colors.js'
+import { dim, SUPPORTS_COLOR } from './colors.js'
 
 const format = (...args) => formatWithOptions({ colors: SUPPORTS_COLOR }, ...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`))
   }
 }

package/lib/generateTasks.js

@@ -1,8 +1,7 @@
 import path from 'node:path'
 
-import micromatch from 'micromatch'
-
 import { createDebug } from './debug.js'
+import { matchFiles } from './matchFiles.js'
 import { normalizePath } from './normalizePath.js'
 
 const debugLog = createDebug('lint-staged:generateTasks')
@@ -30,36 +29,15 @@ export const generateTasks = ({ config, cwd = process.cwd(), files, relative = f
 
     // Only worry about children of the CWD unless the pattern explicitly
     // specifies that it concerns a parent directory.
-    const filteredFiles = relativeFiles.filter((file) => {
+    const includedFiles = relativeFiles.filter((file) => {
       if (isParentDirPattern) return true
       return !file.filepath.startsWith('..') && !path.isAbsolute(file.filepath)
     })
 
-    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 = filteredFiles.flatMap((file) =>
-      matches.includes(file.filepath)
-        ? [
-            {
-              filepath: normalizePath(relative ? file.filepath : path.resolve(cwd, file.filepath)),
-              status: file.status,
-            },
-          ]
-        : []
-    )
+    const fileList = matchFiles(includedFiles, pattern, cwd).map((file) => ({
+      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/getRenderer.js

@@ -45,7 +45,7 @@ const getMainRendererOptions = ({ color, debug, quiet }, logger, env) => {
   }
 }
 
-const getFallbackRenderer = ({ renderer }, { color = false }) => {
+const getFallbackRenderer = ({ renderer }, { color }) => {
   if (renderer === 'silent' || renderer === 'test' || !color) {
     return renderer
   }

package/lib/getSpawnedTask.js

@@ -1,7 +1,7 @@
 import { parseArgsStringToArgv } from 'string-argv'
 import { exec } from 'tinyexec'
 
-import { blackBright, red } from './colors.js'
+import { dim, red } from './colors.js'
 import { createDebug } from './debug.js'
 import { error, info } from './figures.js'
 import { Signal } from './getAbortController.js'
@@ -51,7 +51,7 @@ const handleTaskOutput = (command, output, ctx, signal, errorResult) => {
  */
 export const createTaskError = (command, result, ctx, signal = 'FAILED') => {
   ctx.errors.add(TaskError)
-  return new Error(`${red(command)} ${blackBright(`[${signal}]`)}`, { cause: result })
+  return new Error(`${red(command)} ${dim(`[${signal}]`)}`, { cause: result })
 }
 
 /**

package/lib/gitWorkflow.js

@@ -1,11 +1,11 @@
 import crypto from 'node:crypto'
-import fs from 'node:fs/promises'
 import path from 'node:path'
 
 import { createDebug } from './debug.js'
 import { execGit } from './execGit.js'
 import { readFile, unlink, writeFile } from './file.js'
 import { getDiffCommand } from './getDiffCommand.js'
+import { normalizePath } from './normalizePath.js'
 import { parseGitZOutput } from './parseGitZOutput.js'
 import {
   ApplyEmptyCommitError,
@@ -79,26 +79,14 @@ const cleanGitStashOutput = (lines) => lines.map((line) => line.replace(/^"(.*)"
 export class GitWorkflow {
   /**
    * @param {Object} opts
-   * @param {import('./getStagedFiles.js').StagedFile[][]} opts.matchedFileChunks
    */
-  constructor({
-    allowEmpty,
-    diff,
-    diffFilter,
-    failOnChanges,
-    gitConfigDir,
-    matchedFileChunks,
-    topLevelDir,
-  }) {
+  constructor({ allowEmpty, diff, diffFilter, failOnChanges, gitConfigDir, topLevelDir }) {
     this.execGit = (args, options = {}) => execGit(args, { ...options, cwd: topLevelDir })
     this.allowEmpty = allowEmpty
-    this.deletedFiles = []
     this.diff = diff
     this.diffFilter = diffFilter
     this.gitConfigDir = gitConfigDir
     this.failOnChanges = !!failOnChanges
-    /** @type {import('./getStagedFiles.js').StagedFile[][]} */
-    this.matchedFileChunks = matchedFileChunks
     this.topLevelDir = topLevelDir
 
     /**
@@ -137,20 +125,6 @@ export class GitWorkflow {
     return String(index)
   }
 
-  /**
-   * Get a list of unstaged deleted files
-   */
-  async getDeletedFiles() {
-    debugLog('Getting deleted files...')
-    const lsFiles = await this.execGit(['ls-files', '--deleted'])
-    const deletedFiles = lsFiles
-      .split('\n')
-      .filter(Boolean)
-      .map((file) => path.resolve(this.topLevelDir, file))
-    debugLog('Found deleted files:', deletedFiles)
-    return deletedFiles
-  }
-
   /**
    * Save meta information about ongoing git merge
    */
@@ -234,14 +208,9 @@ export class GitWorkflow {
       if (ctx.shouldBackup) {
         // When backup is enabled, the revert will clear ongoing merge status.
         await this.backupMergeStatus()
-
-        // Get a list of unstaged deleted files, because certain bugs might cause them to reappear:
-        // - in git versions =< 2.13.0 the `git stash --keep-index` option resurrects deleted files
-        // - git stash can't infer RD or MD states correctly, and will lose the deletion
-        this.deletedFiles = await this.getDeletedFiles()
       }
 
-      if (ctx.shouldHideUnstaged) {
+      if (ctx.shouldHideUnstaged || ctx.shouldHideAll) {
         this.unstagedFiles = await this.getUnstagedFiles({ onlyPartial: false })
         ctx.hasFilesToHide = !!this.unstagedFiles
       } else if (ctx.shouldHidePartiallyStaged) {
@@ -257,9 +226,11 @@ export class GitWorkflow {
       }
 
       if (ctx.shouldBackup) {
-        if (ctx.shouldHideUnstaged) {
+        if (ctx.shouldHideUnstaged || ctx.shouldHideAll) {
+          const args = ['stash', 'push', '--keep-index', '--message', STASH]
+          if (ctx.shouldHideAll) args.push('--include-untracked')
           /** Save stash of all changes, clearing the working tree but keeping staged files as-is */
-          await this.execGit(['stash', 'push', '--keep-index', '--message', STASH])
+          await this.execGit(args)
           /** Print stash list with short hash and subject */
           const stashes = await this.execGit(['stash', 'list', '--format="%h %s"', '-z'])
             .then(parseGitZOutput)
@@ -285,7 +256,7 @@ export class GitWorkflow {
   async hidePartiallyStagedChanges(ctx) {
     try {
       const files = processRenames(this.unstagedFiles, false)
-      await this.execGit(['checkout', '--force', '--', ...files])
+      await this.execGit(['restore', '--worktree', '--', ...files])
     } catch (error) {
       /**
        * `git checkout --force` doesn't throw errors, so it shouldn't be possible to get here.
@@ -308,11 +279,8 @@ export class GitWorkflow {
     return task.newListr(listrTasks, { concurrent })
   }
 
-  /**
-   * Applies back task modifications, and unstaged changes hidden in the stash.
-   * In case of a merge-conflict retry with 3-way merge.
-   */
-  async applyModifications(ctx) {
+  /** Update Git index again for the originally staged files to stage task modifications. */
+  async updateIndex(ctx) {
     if (ctx.shouldFailOnChanges) {
       debugLog(
         'Calculating SHA-256 hash of changes after tasks because "--fail-on-changes" was used...'
@@ -326,32 +294,18 @@ export class GitWorkflow {
       }
     }
 
-    debugLog('Adding task modifications to index...')
-
-    // `matchedFileChunks` includes staged files that lint-staged originally detected and matched against a task.
-    // Add only these files so any 3rd-party edits to other files won't be included in the commit.
-    // 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) {
-      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
-          }
-        })
-      )
+    // Unset GIT_INDEX_FILE so that the default index is always updated after running tasks
+    // Otherwise committing a pathspec (which uses a temporary non-default index) will leave
+    // changes in the worktree and default index
+    debugLog('Unset GIT_INDEX_FILE (was `%s`)', process.env.GIT_INDEX_FILE)
+    delete process.env.GIT_INDEX_FILE
 
-      const addableFiles = accessCheckedFiles.flatMap((r) =>
-        r.status === 'fulfilled' ? [r.value] : []
-      )
+    debugLog('Updating Git index again after task modifications...')
 
-      await this.execGit(['add', '--', ...addableFiles])
-    }
+    // Update index for the files that were originally staged, ignore others
+    await this.execGit(['update-index', '--again'])
 
-    debugLog('Done adding task modifications to index!')
+    debugLog('Done updating Git index again after task modifications!')
 
     const stagedFilesAfterAdd = await this.execGit([
       ...getDiffCommand(this.diff, this.diffFilter),
@@ -395,6 +349,42 @@ export class GitWorkflow {
     }
   }
 
+  async restoreUntrackedFiles(ctx) {
+    try {
+      debugLog('Restoring untracked files...')
+      const backupStash = await this.getBackupStash(ctx)
+      const untrackedFiles = await this.execGit([
+        'stash',
+        'show',
+        '--only-untracked',
+        '--name-only',
+        '-z',
+        backupStash,
+      ]).then(parseGitZOutput)
+
+      if (untrackedFiles.length) {
+        debugLog('Found untracked files: %s', untrackedFiles)
+        await this.execGit([
+          'restore',
+          '--source',
+          `${ctx.backupHash}^3`,
+          '--',
+          ...untrackedFiles.map(normalizePath),
+        ])
+      } else {
+        debugLog('No untracked files to restore!')
+      }
+    } catch (restoreUntrackedFilesError) {
+      debugLog('Error while restoring untracked files:')
+      debugLog(restoreUntrackedFilesError)
+      handleError(
+        new Error('Untracked files could not be restored!'),
+        ctx,
+        RestoreUnstagedChangesError
+      )
+    }
+  }
+
   /**
    * Restore original HEAD state in case of errors
    */
@@ -407,9 +397,6 @@ export class GitWorkflow {
       // Restore meta information about ongoing git merge
       await this.restoreMergeStatus(ctx)
 
-      // If stashing resurrected deleted files, clean them out
-      await Promise.all(this.deletedFiles.map((file) => unlink(file)))
-
       // Clean out patch
       await unlink(this.getHiddenFilepath(PATCH_UNSTAGED))
 

package/lib/index.d.ts

@@ -81,6 +81,11 @@ export type Options = {
    * @default false
    */
   hideUnstaged?: boolean
+  /**
+   * Whether to hide all unstaged changes and untracked files before running tasks
+   * @default false
+   */
+  hideAll?: boolean
   /**
    * Disable lint-staged’s own console output
    * @default false