lint-staged 16.1.6 → 16.2.0

package/lib/getSpawnedTask.js

@@ -1,16 +1,16 @@
-import chalk from 'chalk'
-import debug from 'debug'
 import spawn from 'nano-spawn'
 import pidtree from 'pidtree'
 import { parseArgsStringToArgv } from 'string-argv'
 
+import { blackBright, red } from './colors.js'
+import { createDebug } from './debug.js'
 import { error, info } from './figures.js'
 import { getInitialState } from './state.js'
 import { TaskError } from './symbols.js'
 
 const TASK_ERROR = 'lint-staged:taskError'
 
-const debugLog = debug('lint-staged:getSpawnedTask')
+const debugLog = createDebug('lint-staged:getSpawnedTask')
 
 /** @type {(error: import('nano-spawn').SubprocessError) => string} */
 const getTag = (error) => {
@@ -27,13 +27,13 @@ const getTag = (error) => {
  */
 const handleOutput = (command, result, ctx, isError = false) => {
   if (result.output) {
-    const outputTitle = isError ? chalk.redBright(`${error} ${command}:`) : `${info} ${command}:`
+    const outputTitle = isError ? red(`${error} ${command}:`) : `${info} ${command}:`
     const output = [...(ctx.quiet ? [] : ['', outputTitle]), result.output]
     ctx.output.push(output.join('\n'))
   } else if (isError) {
     // Show generic error when task had no output
     const tag = getTag(result)
-    const message = chalk.redBright(`\n${error} ${command} failed without output (${tag}).`)
+    const message = red(`\n${error} ${command} failed without output (${tag}).`)
     if (!ctx.quiet) ctx.output.push(message)
   }
 }
@@ -108,13 +108,14 @@ export const makeErr = (command, error, ctx) => {
 
   handleOutput(command, error, ctx, true)
   const tag = getTag(error)
-  return new Error(`${chalk.redBright(command)} ${chalk.dim(`[${tag}]`)}`)
+  return new Error(`${red(command)} ${blackBright(`[${tag}]`)}`)
 }
 
 /**
  * Returns the task function for the linter.
  *
  * @param {Object} options
+ * @param {boolean} [options.color]
  * @param {string} options.command — Linter task
  * @param {string} [options.cwd]
  * @param {String} options.topLevelDir - Current git repo top-level path
@@ -124,6 +125,7 @@ export const makeErr = (command, error, ctx) => {
  * @returns {() => Promise<Array<string>>}
  */
 export const getSpawnedTask = ({
+  color,
   command,
   cwd = process.cwd(),
   files,
@@ -141,6 +143,7 @@ export const getSpawnedTask = ({
     cwd: /^git(\.exe)?/i.test(cmd) ? topLevelDir : cwd,
     preferLocal: true,
     stdin: 'ignore',
+    env: color ? { FORCE_COLOR: 'true' } : { NO_COLOR: 'true' },
   }
 
   debugLog('Spawn options:', spawnOptions)

package/lib/getSpawnedTasks.js

@@ -1,21 +1,21 @@
-import debug from 'debug'
-
+import { createDebug } from './debug.js'
 import { getSpawnedTask } from './getSpawnedTask.js'
 import { configurationError } from './messages.js'
 
-const debugLog = debug('lint-staged:getSpawnedTasks')
+const debugLog = createDebug('lint-staged:getSpawnedTasks')
 
 /**
  * Creates and returns an array of listr tasks which map to the given commands.
  *
  * @param {object} options
+ * @param {boolean} [options.color]
  * @param {Array<string|Function>|string|Function} options.commands
  * @param {string} options.cwd
  * @param {import('./getStagedFiles.js').StagedFile[]} options.files
  * @param {string} options.topLevelDir
  * @param {Boolean} verbose
  */
-export const getSpawnedTasks = async ({ commands, cwd, files, topLevelDir, verbose }) => {
+export const getSpawnedTasks = async ({ color, commands, cwd, files, topLevelDir, verbose }) => {
   debugLog('Creating Listr tasks for commands %o', commands)
   const cmdTasks = []
 
@@ -45,7 +45,16 @@ export const getSpawnedTasks = async ({ commands, cwd, files, topLevelDir, verbo
         )
       }
 
-      const task = getSpawnedTask({ command, cwd, files: filepaths, topLevelDir, isFn, verbose })
+      const task = getSpawnedTask({
+        color,
+        command,
+        cwd,
+        files: filepaths,
+        topLevelDir,
+        isFn,
+        verbose,
+      })
+
       cmdTasks.push({ title: command, command, task })
     }
   }

package/lib/gitWorkflow.js

@@ -1,13 +1,14 @@
+import crypto from 'node:crypto'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 
-import debug from 'debug'
-
+import { createDebug } from './debug.js'
 import { execGit } from './execGit.js'
 import { readFile, unlink, writeFile } from './file.js'
 import { getDiffCommand } from './getDiffCommand.js'
 import {
   ApplyEmptyCommitError,
+  ExitCodeError,
   GetBackupStashError,
   GitError,
   HideUnstagedChangesError,
@@ -16,7 +17,7 @@ import {
   RestoreUnstagedChangesError,
 } from './symbols.js'
 
-const debugLog = debug('lint-staged:GitWorkflow')
+const debugLog = createDebug('lint-staged:GitWorkflow')
 
 const MERGE_HEAD = 'MERGE_HEAD'
 const MERGE_MODE = 'MERGE_MODE'
@@ -66,21 +67,32 @@ const handleError = (error, ctx, symbol) => {
   throw error
 }
 
+const calculateSha256 = (input) => crypto.createHash('sha256').update(input, 'utf-8').digest('hex')
+
 export class GitWorkflow {
   /**
    * @param {Object} opts
    * @param {import('./getStagedFiles.js').StagedFile[][]} opts.matchedFileChunks
    */
-  constructor({ allowEmpty, gitConfigDir, topLevelDir, matchedFileChunks, diff, diffFilter }) {
+  constructor({
+    allowEmpty,
+    diff,
+    diffFilter,
+    failOnChanges,
+    gitConfigDir,
+    matchedFileChunks,
+    topLevelDir,
+  }) {
     this.execGit = (args, options = {}) => execGit(args, { ...options, cwd: topLevelDir })
+    this.allowEmpty = allowEmpty
     this.deletedFiles = []
-    this.gitConfigDir = gitConfigDir
-    this.topLevelDir = topLevelDir
     this.diff = diff
     this.diffFilter = diffFilter
-    this.allowEmpty = allowEmpty
+    this.gitConfigDir = gitConfigDir
+    this.failOnChanges = !!failOnChanges
     /** @type {import('./getStagedFiles.js').StagedFile[][]} */
     this.matchedFileChunks = matchedFileChunks
+    this.topLevelDir = topLevelDir
 
     /**
      * These three files hold state about an ongoing git merge
@@ -172,7 +184,7 @@ export class GitWorkflow {
    * Renames have special treatment, since the single status line includes
    * both the "from" and "to" filenames, where "from" is no longer on disk.
    */
-  async getPartiallyStagedFiles() {
+  async getUnstagedFiles({ onlyPartial = false } = {}) {
     debugLog('Getting partially staged files...')
     const status = await this.execGit(['status', '-z'])
     /**
@@ -184,69 +196,85 @@ export class GitWorkflow {
      * renamed file, the file names are separated by a NUL character
      * (e.g. `to`\0`from`)
      */
-    const partiallyStaged = status
+    const unstagedFiles = status
       // eslint-disable-next-line no-control-regex
       .split(/\x00(?=[ AMDRCU?!]{2} |$)/)
       .filter((line) => {
         const [index, workingTree] = line
-        return index !== ' ' && workingTree !== ' ' && index !== '?' && workingTree !== '?'
+        const updatedInIndex = index !== ' ' && index !== '?'
+        const updatedInWorkingTree = workingTree !== ' ' && workingTree !== '?'
+
+        if (onlyPartial) {
+          return updatedInIndex && updatedInWorkingTree
+        }
+
+        return updatedInWorkingTree
       })
       .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
+      .filter(Boolean) // Filter empty strings
+    debugLog(`Found ${onlyPartial ? 'partially staged' : 'unstaged'} files:`, unstagedFiles)
+    return unstagedFiles.length ? unstagedFiles : null
   }
 
   /**
-   * Create a diff of partially staged files and backup stash if enabled.
+   * Create a diff of unstaged or partially staged files and backup stash if enabled.
    */
   async prepare(ctx, task) {
     try {
       debugLog(task.title)
 
-      // 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 {
-        ctx.hasPartiallyStagedFiles = false
+      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()
+
+        // Save stash of all staged files.
+        // The `stash create` command creates a dangling commit without removing any files,
+        // and `stash store` saves it as an actual stash.
+        const stashHash = await this.execGit(['stash', 'create'])
+        ctx.backupHash = await this.execGit(['rev-parse', '--short', stashHash])
+        await this.execGit([
+          'stash',
+          'store',
+          '--quiet',
+          '--message',
+          `${STASH} (${ctx.backupHash})`,
+          ctx.backupHash,
+        ])
+
+        task.title = `Backed up original state in git stash (${ctx.backupHash})`
+        debugLog(task.title)
       }
 
-      /**
-       * If backup stash should be skipped, no need to continue
-       */
-      if (!ctx.shouldBackup) return
-
-      // 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()
-
-      // Save stash of all staged files.
-      // The `stash create` command creates a dangling commit without removing any files,
-      // and `stash store` saves it as an actual stash.
-      const stashHash = await this.execGit(['stash', 'create'])
-      ctx.backupHash = await this.execGit(['rev-parse', '--short', stashHash])
-      await this.execGit([
-        'stash',
-        'store',
-        '--quiet',
-        '--message',
-        `${STASH} (${ctx.backupHash})`,
-        ctx.backupHash,
-      ])
+      if (this.failOnChanges) {
+        debugLog(
+          'Calculating SHA-256 hash of unstaged changes because "--fail-on-changes" was used...'
+        )
+        const diff = await this.execGit(['diff', '--patch', '--unified=0'])
+        this.unstagedDiffSha256 = calculateSha256(diff)
+        debugLog('SHA-256 hash of unstaged changes is %S', this.unstagedDiffSha256)
+      }
 
-      task.title = `Backed up original state in git stash (${ctx.backupHash})`
-      debugLog(task.title)
+      if (ctx.shouldHideUnstaged || ctx.shouldHidePartiallyStaged) {
+        // Unstaged changes to these files should be hidden before the tasks run.
+        this.unstagedFiles = await this.getUnstagedFiles({
+          onlyPartial: ctx.shouldHideUnstaged ? false : ctx.shouldHidePartiallyStaged,
+        })
+
+        if (this.unstagedFiles) {
+          ctx.hasFilesToHide = true
+          const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
+          ctx.unstagedPatch = unstagedPatch
+          const files = processRenames(this.unstagedFiles)
+          await this.execGit(['diff', ...GIT_DIFF_ARGS, '--output', unstagedPatch, '--', ...files])
+        } else {
+          ctx.hasFilesToHide = false
+        }
+      }
     } catch (error) {
       handleError(error, ctx)
     }
@@ -257,7 +285,7 @@ export class GitWorkflow {
    */
   async hideUnstagedChanges(ctx) {
     try {
-      const files = processRenames(this.partiallyStagedFiles, false)
+      const files = processRenames(this.unstagedFiles, false)
       await this.execGit(['checkout', '--force', '--', ...files])
     } catch (error) {
       /**
@@ -273,6 +301,19 @@ export class GitWorkflow {
    * In case of a merge-conflict retry with 3-way merge.
    */
   async applyModifications(ctx) {
+    if (this.failOnChanges) {
+      debugLog(
+        'Calculating SHA-256 hash of changes after tasks because "--fail-on-changes" was used...'
+      )
+      const diff = await this.execGit(['diff', '--patch', '--unified=0'])
+      const diffSha256 = calculateSha256(diff)
+      debugLog('SHA-256 hash of changes after tasks is %S', this.diffSha256)
+      if (this.unstagedDiffSha256 !== diffSha256) {
+        ctx.errors.add(ExitCodeError)
+        throw new Error('Tasks modified files and --fail-on-changes was used!')
+      }
+    }
+
     debugLog('Adding task modifications to index...')
 
     // `matchedFileChunks` includes staged files that lint-staged originally detected and matched against a task.

package/lib/groupFilesByConfig.js

@@ -1,8 +1,8 @@
 import path from 'node:path'
 
-import debug from 'debug'
+import { createDebug } from './debug.js'
 
-const debugLog = debug('lint-staged:groupFilesByConfig')
+const debugLog = createDebug('lint-staged:groupFilesByConfig')
 
 /**
  * @typedef {import('./getStagedFiles.js').StagedFile} StagedFile

package/lib/index.d.ts

@@ -32,6 +32,11 @@ export type Options = {
    * Path to single configuration file; disables automatic config file discovery when used
    */
   configPath?: string
+  /**
+   * Run all tasks to completion even if one fails
+   * @default false
+   */
+  continueOnError?: boolean
   /**
    * Working directory to run all tasks in, defaults to current working directory
    */
@@ -52,10 +57,25 @@ export type Options = {
    * @default "ACMR"
    */
   diffFilter?: string
+  /**
+   * Fail with exit code 1 when tasks modify tracked files
+   * @default false
+   */
+  failOnChanges?: true
   /**
    * Maximum argument string length, by default automatically detected
    */
   maxArgLength?: number
+  /**
+   * Whether to hide unstaged changes from partially staged files before running tasks
+   * @default true
+   */
+  hidePartiallyStaged?: boolean
+  /**
+   * Whether to hide all unstaged changes before running tasks
+   * @default false
+   */
+  hideUnstaged?: boolean
   /**
    * Disable lint-staged’s own console output
    * @default false
@@ -77,11 +97,6 @@ export type Options = {
    * @default true
    */
   stash?: boolean
-  /**
-   * Whether to hide unstaged changes from partially staged files before running tasks
-   * @default true
-   */
-  hidePartiallyStaged?: boolean
   /**
    * Show task output even when tasks succeed; by default only failed output is shown
    * @default false

package/lib/index.js

@@ -1,10 +1,11 @@
-import debugLib from 'debug'
-
+import { SUPPORTS_COLOR } from './colors.js'
+import { createDebug, enableDebug } from './debug.js'
 import { execGit } from './execGit.js'
 import {
   GIT_ERROR,
   NO_CONFIGURATION,
   PREVENTED_EMPTY_COMMIT,
+  PREVENTED_TASK_MODIFICATIONS,
   RESTORE_STASH_EXAMPLE,
   UNSTAGED_CHANGES_BACKUP_STASH_LOCATION,
 } from './messages.js'
@@ -14,6 +15,7 @@ import { cleanupSkipped } from './state.js'
 import {
   ApplyEmptyCommitError,
   ConfigNotFoundError,
+  ExitCodeError,
   GetBackupStashError,
   GitError,
   RestoreUnstagedChangesError,
@@ -21,7 +23,7 @@ import {
 import { validateOptions } from './validateOptions.js'
 import { getVersion } from './version.js'
 
-const debugLog = debugLib('lint-staged')
+const debugLog = createDebug('lint-staged')
 
 /**
  * Get the maximum length of a command-line argument string based on current platform
@@ -49,13 +51,18 @@ const getMaxArgLength = () => {
  *
  * @param {object} options
  * @param {Object} [options.allowEmpty] - Allow empty commits when tasks revert all staged changes
+ * @param {Object} [options.color] - Enable ANSI colors in output
  * @param {boolean | number} [options.concurrent] - The number of tasks to run concurrently, or false to run tasks serially
  * @param {object}  [options.config] - Object with configuration for programmatic API
  * @param {string} [options.configPath] - Path to configuration file
+ * @param {boolean} [options.continueOnError] - Run all tasks to completion even if one fails
  * @param {Object} [options.cwd] - Current working directory
  * @param {boolean} [options.debug] - Enable debug mode
  * @param {string} [options.diff] - Override the default "--staged" flag of "git diff" to get list of files
  * @param {string} [options.diffFilter] - Override the default "--diff-filter=ACMR" flag of "git diff" to get list of files
+ * @param {boolean} [options.failOnChanges] - Fail with exit code 1 when tasks modify tracked files
+ * @param {boolean} [options.hidePartiallyStaged] - Whether to hide unstaged changes from partially staged files before running tasks
+ * @param {boolean} [options.hideUnstaged] - Whether to hide all unstaged changes before running tasks
  * @param {number} [options.maxArgLength] - Maximum argument string length
  * @param {boolean} [options.quiet] - Disable lint-staged’s own console output
  * @param {boolean} [options.relative] - Pass relative filepaths to tasks
@@ -69,28 +76,32 @@ const getMaxArgLength = () => {
 const lintStaged = async (
   {
     allowEmpty = false,
+    color = SUPPORTS_COLOR,
     concurrent = true,
     config: configObject,
     configPath,
+    continueOnError = false,
     cwd,
     debug = false,
     diff,
     diffFilter,
+    failOnChanges = false,
+    hidePartiallyStaged = true,
+    hideUnstaged = false,
     maxArgLength = getMaxArgLength() / 2,
     quiet = false,
     relative = false,
     // Stashing should be disabled by default when the `diff` option is used
     stash = diff === undefined,
-    // Cannot revert to original state without stash
-    revert = stash,
-    hidePartiallyStaged = true,
+    // Default to false when using failOnChanges; cannot revert to original state without stash
+    revert = !failOnChanges && !!stash,
     verbose = false,
   } = {},
   logger = console
 ) => {
   // Seemingly enable debug twice (also done in bin), so that it also works when using the Node.js API
   if (debug) {
-    debugLib.enable('lint-staged*')
+    enableDebug(logger)
 
     debugLog(
       'Running `lint-staged@%s` on Node.js %s (%s)',
@@ -105,19 +116,23 @@ const lintStaged = async (
 
   const options = {
     allowEmpty,
+    color,
     concurrent,
     configObject,
     configPath,
+    continueOnError,
     cwd,
     debug,
     diff,
     diffFilter,
+    failOnChanges,
+    hidePartiallyStaged,
+    hideUnstaged,
     maxArgLength,
     quiet,
     relative,
     revert,
     stash,
-    hidePartiallyStaged,
     verbose,
   }
 
@@ -140,6 +155,8 @@ const lintStaged = async (
         logger.error(NO_CONFIGURATION)
       } else if (ctx.errors.has(ApplyEmptyCommitError)) {
         logger.warn(PREVENTED_EMPTY_COMMIT)
+      } else if (ctx.errors.has(ExitCodeError)) {
+        logger.warn(PREVENTED_TASK_MODIFICATIONS)
       } else if (ctx.errors.has(RestoreUnstagedChangesError)) {
         logger.warn(UNSTAGED_CHANGES_BACKUP_STASH_LOCATION)
         logger.warn(ctx.unstagedPatch)

package/lib/loadConfig.js

@@ -3,20 +3,15 @@
 import fs from 'node:fs/promises'
 import path from 'node:path'
 
-import debug from 'debug'
 import YAML from 'yaml'
 
-import {
-  CONFIG_FILE_NAMES,
-  CONFIG_NAME,
-  PACKAGE_JSON_FILE,
-  PACKAGE_YAML_FILES,
-} from './configFiles.js'
+import { CONFIG_NAME, PACKAGE_JSON_FILE, PACKAGE_YAML_FILES } from './configFiles.js'
+import { createDebug } from './debug.js'
 import { dynamicImport } from './dynamicImport.js'
 import { failedToLoadConfig } from './messages.js'
 import { resolveConfig } from './resolveConfig.js'
 
-const debugLog = debug('lint-staged:loadConfig')
+const debugLog = createDebug('lint-staged:loadConfig')
 
 const jsonParse = (filePath, content) => {
   const isPackageFile = PACKAGE_JSON_FILE.includes(path.basename(filePath))
@@ -94,22 +89,11 @@ const loadConfigByExt = async (filepath) => {
 /**
  * @param {object} options
  * @param {string} [options.configPath] - Explicit path to a config file
- * @param {string} [options.cwd] - Current working directory
  */
-export const loadConfig = async ({ configPath, cwd }, logger) => {
+export const loadConfig = async ({ configPath }, logger) => {
   try {
-    let result
-
-    if (configPath) {
-      debugLog('Loading configuration from `%s`...', configPath)
-      result = await loadConfigByExt(resolveConfig(configPath))
-    } else {
-      debugLog('Searching for configuration from `%s`...', cwd)
-      const { lilconfig } = await import('lilconfig')
-      const explorer = lilconfig(CONFIG_NAME, { searchPlaces: CONFIG_FILE_NAMES, loaders })
-      result = await explorer.search(cwd)
-    }
-
+    debugLog('Loading configuration from `%s`...', configPath)
+    const result = configPath ? await loadConfigByExt(resolveConfig(configPath)) : undefined
     if (!result) return {}
 
     // config is a promise when using the `dynamicImport` loader

package/lib/messages.js

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