lint-staged 17.0.7 → 17.1.0

package/lib/gitWorkflow.js

@@ -2,12 +2,15 @@ import crypto from 'node:crypto'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 
+import { dim } from './colors.js'
 import { createDebug } from './debug.js'
 import { execGit } from './execGit.js'
+import * as figures from './figures.js'
 import { readFile, unlink, writeFile } from './file.js'
 import { getDiffCommand } from './getDiffCommand.js'
 import { normalizePath } from './normalizePath.js'
 import { parseGitZOutput } from './parseGitZOutput.js'
+import { runParallelTasks } from './runParallelTasks.js'
 import {
   ApplyEmptyCommitError,
   FailOnChangesError,
@@ -17,6 +20,7 @@ import {
   RestoreMergeStatusError,
   RestoreOriginalStateError,
   RestoreUnstagedChangesError,
+  TaskError,
 } from './symbols.js'
 
 const debugLog = createDebug('lint-staged:GitWorkflow')
@@ -27,7 +31,7 @@ const MERGE_MSG = 'MERGE_MSG'
 
 // In git status machine output, renames are presented as `to`NUL`from`
 // When diffing, both need to be taken into account, but in some cases on the `to`.
-// eslint-disable-next-line no-control-regex
+// oxlint-disable-next-line no-control-regex
 const RENAME = /\x00/
 
 /**
@@ -63,12 +67,6 @@ const GIT_DIFF_ARGS = [
 ]
 const GIT_APPLY_ARGS = ['-v', '--whitespace=nowarn', '--recount', '--unidiff-zero']
 
-const handleError = (error, ctx, symbol) => {
-  ctx.errors.add(GitError)
-  if (symbol) ctx.errors.add(symbol)
-  throw error
-}
-
 const calculateSha256 = (input) => crypto.createHash('sha256').update(input, 'utf-8').digest('hex')
 
 /**
@@ -87,6 +85,7 @@ export class GitWorkflow {
     diffFilter,
     failOnChanges,
     gitConfigDir,
+    logger,
     matchedFileChunks,
     topLevelDir,
   }) {
@@ -96,6 +95,7 @@ export class GitWorkflow {
     this.diffFilter = diffFilter
     this.gitConfigDir = gitConfigDir
     this.failOnChanges = !!failOnChanges
+    this.logger = logger
     /** @type {import('./getStagedFiles.js').StagedFile[][]} */
     this.matchedFileChunks = matchedFileChunks
     this.topLevelDir = topLevelDir
@@ -130,6 +130,7 @@ export class GitWorkflow {
 
     if (index === -1) {
       ctx.errors.add(GetBackupStashError)
+      this.logger.error(`${figures.error()} lint-staged automatic backup is missing!`)
       throw new Error('lint-staged automatic backup is missing!')
     }
 
@@ -162,13 +163,13 @@ export class GitWorkflow {
       ])
       debugLog('Done restoring merge state!')
     } catch (error) {
+      ctx.errors.add(GitError)
+      ctx.errors.add(RestoreMergeStatusError)
+
       debugLog('Failed restoring merge state with error:')
       debugLog(error)
-      handleError(
-        new Error('Merge state could not be restored due to an error!'),
-        ctx,
-        RestoreMergeStatusError
-      )
+
+      throw error
     }
   }
 
@@ -190,7 +191,7 @@ export class GitWorkflow {
      * (e.g. `to`\0`from`)
      */
     const unstagedFiles = status
-      // eslint-disable-next-line no-control-regex
+      // oxlint-disable-next-line no-control-regex
       .split(/\x00(?=[ AMDRCU?!]{2} |$)/)
       .filter((line) => {
         const [index, workingTree] = line
@@ -212,10 +213,14 @@ export class GitWorkflow {
   /**
    * Create a diff of unstaged or partially staged files and backup stash if enabled.
    */
-  async prepare(ctx, task) {
-    try {
-      debugLog(task.title)
+  async prepare(ctx) {
+    this.logger.log(
+      dim(
+        `${figures.wip()} ${ctx.shouldBackup ? 'Backing up original state…' : 'Preparing lint-staged…'}`
+      )
+    )
 
+    try {
       if (ctx.shouldBackup) {
         // When backup is enabled, the revert will clear ongoing merge status.
         await this.backupMergeStatus()
@@ -249,120 +254,183 @@ export class GitWorkflow {
 
           /** The stash line starts with the short hash, so we split from space and choose the first part */
           ctx.backupHash = stashes.find((line) => line.includes(STASH))?.split(' ')[0]
+
+          await this.restoreMergeStatus(ctx)
         } else {
           /** Save stash of all changes, keeping all files as-is */
           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])
         }
-
-        task.title = `Backed up original state in git stash (${ctx.backupHash})`
-        debugLog(task.title)
       }
+
+      this.logger.log(
+        `${figures.done()} ${
+          ctx.shouldBackup
+            ? `Done backing up original state (${ctx.backupHash})!`
+            : 'Done preparing lint-staged!'
+        }`
+      )
     } catch (error) {
-      handleError(error, ctx)
+      ctx.errors.add(GitError)
+
+      const errorMessage = ctx.shouldBackup
+        ? 'Failed to back up original state!'
+        : 'Failed to prepare lint-staged!'
+
+      this.logger.error(`${figures.error()} ${errorMessage}`)
+      debugLog(error)
     }
   }
 
   async hidePartiallyStagedChanges(ctx) {
+    this.logger.log(dim(`${figures.wip()} Hiding unstaged changes to partially staged files…`))
+
     try {
       const files = processRenames(this.unstagedFiles, false)
       await this.execGit(['restore', '--worktree', '--', ...files])
+      this.logger.log(`${figures.done()} Done hiding unstaged changes to partially staged files!`)
     } catch (error) {
       /**
        * `git checkout --force` doesn't throw errors, so it shouldn't be possible to get here.
-       * If this does fail, the handleError method will set ctx.gitError and lint-staged will fail.
        */
-      handleError(error, ctx, HideUnstagedChangesError)
-    }
-  }
+      ctx.errors.add(GitError)
+      ctx.errors.add(HideUnstagedChangesError)
 
-  async runTasks(ctx, task, { listrTasks, concurrent }) {
-    if (ctx.shouldFailOnChanges) {
-      debugLog(
-        'Calculating SHA-256 hash of unstaged changes because "--fail-on-changes" was used...'
-      )
-      const diff = await this.execGit(['diff', '--patch', '--unified=0'])
-      ctx.unstagedDiffSha256 = calculateSha256(diff)
-      debugLog('SHA-256 hash of unstaged changes is %s', ctx.unstagedDiffSha256)
-    }
+      const errorMessage = `${figures.error()} Failed to hude unstaged changes to partially staged files!`
 
-    return task.newListr(listrTasks, { concurrent })
+      this.logger.error(errorMessage)
+      debugLog(error)
+    }
   }
 
-  /** Update Git index again for the originally staged files to stage task modifications. */
-  async updateIndex(ctx) {
+  async runTasks(ctx, tasks, { abortController, concurrent }) {
+    this.logger.log(
+      dim(`${figures.wip()} Running tasks for ${this.diff ? 'changed' : 'staged'} files…`)
+    )
+
     if (ctx.shouldFailOnChanges) {
-      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', diffSha256)
-      if (ctx.unstagedDiffSha256 !== diffSha256) {
-        ctx.errors.add(FailOnChangesError)
-        throw new Error('Tasks modified files and --fail-on-changes was used!')
+      try {
+        debugLog(
+          'Calculating SHA-256 hash of unstaged changes because "--fail-on-changes" was used...'
+        )
+        const diff = await this.execGit(['diff', '--patch', '--unified=0'])
+        ctx.unstagedDiffSha256 = calculateSha256(diff)
+        debugLog('SHA-256 hash of unstaged changes is %s', ctx.unstagedDiffSha256)
+      } catch (error) {
+        ctx.errors.add(GitError)
+        this.logger.error('Failed to calculate SHA-256 hash of unstaged changes!')
+        debugLog(error)
+        return
       }
     }
 
-    // This looks confusing but the intent is to only normalize truthy values
-    const activeIndexFile = process.env.GIT_INDEX_FILE
-      ? normalizePath(process.env.GIT_INDEX_FILE)
-      : process.env.GIT_INDEX_FILE
-
-    /** Needs to be run serially because of locking Git operation */
-    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
-          }
-        })
-      )
+    const failureMessage = `${figures.error()} Failed to run tasks for ${this.diff ? 'changed' : 'staged'} files!`
 
-      const addableFiles = accessCheckedFiles.flatMap((r) =>
-        r.status === 'fulfilled' ? [r.value] : []
+    try {
+      await runParallelTasks(ctx, tasks, { abortController, concurrent, logger: this.logger })
+
+      this.logger.log(
+        ctx.errors.has(TaskError)
+          ? failureMessage
+          : `${figures.done()} Done running tasks for ${this.diff ? 'changed' : 'staged'} files!`
       )
+    } catch (error) {
+      ctx.errors.add(TaskError)
+      this.logger.error(failureMessage)
+      debugLog(error)
+    }
+  }
 
-      debugLog('Updating active Git index: %s', activeIndexFile)
-      await this.execGit(['add', '--', ...addableFiles])
-      debugLog('Done updating Git index: %s', activeIndexFile)
+  /** Update Git index again for the originally staged files to stage task modifications. */
+  async updateIndex(ctx) {
+    this.logger.log(dim(`${figures.wip()} Staging changes from tasks…`))
 
-      if (activeIndexFile?.endsWith('.lock')) {
-        const defaultIndexLock = normalizePath(
-          await this.execGit(['rev-parse', '--path-format=absolute', '--git-path', 'index.lock'])
+    try {
+      if (ctx.shouldFailOnChanges) {
+        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', diffSha256)
+
+        if (ctx.unstagedDiffSha256 !== diffSha256) {
+          ctx.errors.add(FailOnChangesError)
+          this.logger.error(
+            `${figures.error()} Tasks modified files and --fail-on-changes was used!`
+          )
+          return
+        }
+      }
 
-        /**
-         * If the active index file is a non-default lockfile, we are committing with a pathspec
-         * without having explicitly run `git add`. In this case we need to also update the
-         * default index, otherwise there will be leftover diff after committing
-         */
-        if (activeIndexFile !== defaultIndexLock) {
-          debugLog('Updating default Git index again: %s', defaultIndexLock)
-          await this.execGit(['add', '--', ...addableFiles], {
-            env: {
-              GIT_INDEX_FILE: defaultIndexLock,
-            },
+      // This looks confusing but the intent is to only normalize truthy values
+      const activeIndexFile = process.env.GIT_INDEX_FILE
+        ? normalizePath(process.env.GIT_INDEX_FILE)
+        : process.env.GIT_INDEX_FILE
+
+      /** Needs to be run serially because of locking Git operation */
+      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
+            }
           })
-          debugLog('Done updating default Git index lock: %s', defaultIndexLock)
+        )
+
+        const addableFiles = accessCheckedFiles.flatMap((r) =>
+          r.status === 'fulfilled' ? [r.value] : []
+        )
+
+        debugLog('Updating active Git index: %s', activeIndexFile)
+        await this.execGit(['add', '--', ...addableFiles])
+        debugLog('Done updating Git index: %s', activeIndexFile)
+
+        if (activeIndexFile?.endsWith('.lock')) {
+          const defaultIndexLock = normalizePath(
+            await this.execGit(['rev-parse', '--path-format=absolute', '--git-path', 'index.lock'])
+          )
+
+          /**
+           * If the active index file is a non-default lockfile, we are committing with a pathspec
+           * without having explicitly run `git add`. In this case we need to also update the
+           * default index, otherwise there will be leftover diff after committing
+           */
+          if (activeIndexFile !== defaultIndexLock) {
+            debugLog('Updating default Git index again: %s', defaultIndexLock)
+            await this.execGit(['add', '--', ...addableFiles], {
+              env: {
+                GIT_INDEX_FILE: defaultIndexLock,
+              },
+            })
+            debugLog('Done updating default Git index lock: %s', defaultIndexLock)
+          }
         }
       }
-    }
 
-    const stagedFilesAfterAdd = await this.execGit([
-      ...getDiffCommand(this.diff, this.diffFilter),
-      '--name-only',
-      '-z',
-    ])
+      const stagedFilesAfterAdd = await this.execGit([
+        ...getDiffCommand(this.diff, this.diffFilter),
+        '--name-only',
+        '-z',
+      ])
 
-    if (!stagedFilesAfterAdd && !this.allowEmpty) {
-      // Tasks reverted all staged changes and the commit would be empty
-      // Throw error to stop commit unless `--allow-empty` was used
-      handleError(new Error('Prevented an empty git commit!'), ctx, ApplyEmptyCommitError)
+      if (!stagedFilesAfterAdd && !this.allowEmpty) {
+        // Tasks reverted all staged changes and the commit would be empty
+        // Stop commit unless `--allow-empty` was used
+        ctx.errors.add(ApplyEmptyCommitError)
+        this.logger.error(`${figures.error()} Prevented an empty git commit!`)
+      } else {
+        this.logger.log(`${figures.done()} Done staging changes from tasks!`)
+      }
+    } catch (error) {
+      ctx.errors.add(GitError)
+
+      this.logger.log(`${figures.error()} Failed to stage changes from tasks!`)
+      debugLog(error)
     }
   }
 
@@ -372,8 +440,10 @@ export class GitWorkflow {
    * 3-way merge usually fixes this, and in case it doesn't we should just give up and throw.
    */
   async restoreUnstagedChanges(ctx) {
-    debugLog('Restoring unstaged changes...')
+    this.logger.log(dim(`${figures.wip()} Restoring unstaged changes…`))
+
     const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
+
     try {
       await this.execGit(['apply', ...GIT_APPLY_ARGS, unstagedPatch])
     } catch (applyError) {
@@ -384,20 +454,19 @@ export class GitWorkflow {
       try {
         await this.execGit(['apply', ...GIT_APPLY_ARGS, '--3way', unstagedPatch])
       } catch (threeWayApplyError) {
-        debugLog('Error while restoring unstaged changes using 3-way merge:')
+        ctx.errors.add(GitError)
+        ctx.errors.add(RestoreUnstagedChangesError)
+
+        this.logger.error(`${figures.error()} Failed to restore unstaged changes!`)
         debugLog(threeWayApplyError)
-        handleError(
-          new Error('Unstaged changes could not be restored due to a merge conflict!'),
-          ctx,
-          RestoreUnstagedChangesError
-        )
       }
     }
   }
 
   async restoreUntrackedFiles(ctx) {
+    this.logger.log(dim(`${figures.wip()} Restoring untracked files…`))
+
     try {
-      debugLog('Restoring untracked files...')
       const backupStash = await this.getBackupStash(ctx)
       const untrackedFiles = await this.execGit([
         'stash',
@@ -417,17 +486,17 @@ export class GitWorkflow {
           '--',
           ...untrackedFiles.map(normalizePath),
         ])
+
+        this.logger.log(`${figures.done()} ${'Done restoring untracked files!'}`)
       } else {
-        debugLog('No untracked files to restore!')
+        this.logger.log(`${figures.cancelled()} ${dim('No untracked files to restore!')}`)
       }
     } catch (restoreUntrackedFilesError) {
-      debugLog('Error while restoring untracked files:')
+      ctx.errors.add(GitError)
+      ctx.errors.add(RestoreUnstagedChangesError)
+
+      this.logger.error(`${figures.error()} ${'Failed to restore untracked files!'}`)
       debugLog(restoreUntrackedFilesError)
-      handleError(
-        new Error('Untracked files could not be restored!'),
-        ctx,
-        RestoreUnstagedChangesError
-      )
     }
   }
 
@@ -435,20 +504,25 @@ export class GitWorkflow {
    * Restore original HEAD state in case of errors
    */
   async restoreOriginalState(ctx) {
+    this.logger.log(dim(`${figures.wip()} Reverting to original state because of errors…`))
+
     try {
       debugLog('Restoring original state...')
       await this.execGit(['reset', '--hard', 'HEAD'])
       await this.execGit(['stash', 'apply', '--quiet', '--index', await this.getBackupStash(ctx)])
 
-      // Restore meta information about ongoing git merge
       await this.restoreMergeStatus(ctx)
 
       // Clean out patch
       await unlink(this.getHiddenFilepath(PATCH_UNSTAGED))
 
-      debugLog('Done restoring original state!')
+      this.logger.log(`${figures.done()} Done reverting to original state!`)
     } catch (error) {
-      handleError(error, ctx, RestoreOriginalStateError)
+      ctx.errors.add(GitError)
+      ctx.errors.add(RestoreOriginalStateError)
+
+      this.logger.error(`${figures.error()} Failed to revert to original state!`)
+      debugLog(error)
     }
   }
 
@@ -456,12 +530,15 @@ export class GitWorkflow {
    * Drop the created stashes after everything has run
    */
   async cleanup(ctx) {
+    this.logger.log(dim(`${figures.wip()} Cleaning up temporary files…`))
+
     try {
-      debugLog('Dropping backup stash...')
       await this.execGit(['stash', 'drop', '--quiet', await this.getBackupStash(ctx)])
-      debugLog('Done dropping backup stash!')
+      this.logger.log(`${figures.done()} Done cleaning up temporary files!`)
     } catch (error) {
-      handleError(error, ctx)
+      ctx.errors.add(GitError)
+      this.logger.error(`${figures.error()} Failed to clean up temporary files!`)
+      debugLog(error)
     }
   }
 }

package/lib/index.js

@@ -1,15 +1,15 @@
 import { assertGitVersion, MIN_GIT_VERSION } from './assertGitVersion.js'
-import { SUPPORTS_COLOR } from './colors.js'
+import { enableColors } from './colors.js'
 import { createDebug, enableDebug } from './debug.js'
 import { execGit } from './execGit.js'
 import {
-  GIT_ERROR,
+  gitError,
   minGitVersionRequired,
-  NO_CONFIGURATION,
-  PREVENTED_EMPTY_COMMIT,
-  PREVENTED_TASK_MODIFICATIONS,
+  noConfiguration,
+  preventedEmptyCommit,
+  preventedTaskModifications,
   restoreStashExample,
-  UNSTAGED_CHANGES_BACKUP_STASH_LOCATION,
+  unstagedChangesBackupStashLocation,
 } from './messages.js'
 import { printTaskOutput } from './printTaskOutput.js'
 import { runAll } from './runAll.js'
@@ -78,7 +78,7 @@ const getMaxArgLength = () => {
 const lintStaged = async (
   {
     allowEmpty = false,
-    color = SUPPORTS_COLOR,
+    color = !!process.stdout.hasColors?.(),
     concurrent = true,
     config: configObject,
     configPath,
@@ -102,6 +102,8 @@ const lintStaged = async (
   } = {},
   logger = console
 ) => {
+  enableColors(color)
+
   // Seemingly enable debug twice (also done in bin), so that it also works when using the Node.js API
   if (debug) {
     enableDebug(logger)
@@ -160,20 +162,20 @@ const lintStaged = async (
       const { ctx } = runAllError
 
       if (ctx.errors.has(ConfigNotFoundError)) {
-        logger.error(NO_CONFIGURATION)
+        logger.error(noConfiguration())
       } else if (ctx.errors.has(ApplyEmptyCommitError)) {
-        logger.warn(PREVENTED_EMPTY_COMMIT)
+        logger.warn(preventedEmptyCommit())
       } else if (ctx.errors.has(FailOnChangesError)) {
-        logger.warn(PREVENTED_TASK_MODIFICATIONS + '\n')
+        logger.warn(preventedTaskModifications() + '\n')
         logger.warn(restoreStashExample(ctx.backupHash))
       } else if (ctx.errors.has(RestoreUnstagedChangesError)) {
-        logger.warn(UNSTAGED_CHANGES_BACKUP_STASH_LOCATION)
+        logger.warn(unstagedChangesBackupStashLocation())
         logger.warn(ctx.unstagedPatch)
       } else if (
         (ctx.errors.has(GitError) || cleanupSkipped(ctx)) &&
         !ctx.errors.has(GetBackupStashError)
       ) {
-        logger.error(GIT_ERROR)
+        logger.error(gitError())
         if (ctx.shouldBackup) {
           // No sense to show this if the backup stash itself is missing.
           logger.error(restoreStashExample(ctx.backupHash) + '\n')

package/lib/messages.js

@@ -1,30 +1,32 @@
 import { inspect } from 'node:util'
 
 import { bold, red, yellow } from './colors.js'
-import { error, info, warning } from './figures.js'
+import * as figures from './figures.js'
 
 export const configurationError = (opt, helpMsg, value) =>
-  `${red(`${error} Validation Error:`)}
+  `${red(`${figures.error()} Validation Error:`)}
 
   Invalid value for '${bold(opt)}': ${bold(inspect(value))}
 
   ${helpMsg}`
 
-export const NOT_GIT_REPO = red(`${error} Current directory is not a git directory!`)
+export const notGitRepo = () => red(`${figures.error()} Current directory is not a git directory!`)
 
-export const FAILED_GET_STAGED_FILES = red(`${error} Failed to get staged files!`)
+export const failedGetStagedFiles = () => red(`${figures.error()} Failed to get staged files!`)
 
 export const incorrectBraces = (before, after) =>
   yellow(
-    `${warning} Detected incorrect braces with only single value: \`${before}\`. Reformatted as: \`${after}\`
+    `${figures.warning()} Detected incorrect braces with only single value: \`${before}\`. Reformatted as: \`${after}\`
 `
   )
 
-export const NO_CONFIGURATION = `${error} lint-staged could not find any valid configuration.`
+export const noConfiguration = () =>
+  `${figures.error()} lint-staged could not find any valid configuration.`
 
-export const NO_STAGED_FILES = `${info} lint-staged could not find any staged files.`
+export const noStagedFiles = () => `${figures.info()} lint-staged could not find any staged files.`
 
-export const NO_TASKS = `${info} lint-staged could not find any staged files matching configured tasks.`
+export const noTasks = () =>
+  `${figures.info()} lint-staged could not find any staged files matching configured tasks.`
 
 export const skippingBackup = (hasInitialCommit, diff) => {
   const reason =
@@ -33,27 +35,33 @@ export const skippingBackup = (hasInitialCommit, diff) => {
       : (hasInitialCommit ? '`--no-stash` was used' : 'there’s no initial commit yet') +
         '. This might result in data loss'
 
-  return yellow(`${warning} Skipping backup because ${reason}.\n`)
+  return yellow(`${figures.warning()} Skipping backup because ${reason}.\n`)
 }
 
-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 skippingHidePartiallyChanged = () =>
+  yellow(
+    `${figures.warning()} Skipping hiding unstaged changes from partially staged files because \`--no-hide-partially-staged\` was used.\n`
+  )
 
-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 deprecatedGitAdd = () =>
+  yellow(
+    `${figures.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 taskError = () => 'Skipped because of errors from tasks.'
 
-export const SKIPPED_GIT_ERROR = 'Skipped because of previous git error.'
+export const preventedTaskModifications = () =>
+  `\n${figures.error()} lint-staged failed because \`--fail-on-changes\` was used.`
 
-export const GIT_ERROR = `\n  ${red(`${error} lint-staged failed due to a git error.`)}`
+export const gitError = () =>
+  `\n  ${red(`${figures.error()} lint-staged failed due to a git error.`)}`
 
-export const invalidOption = (name, value, message) => `${red(`${error} Validation Error:`)}
+export const invalidOption = (
+  name,
+  value,
+  message
+) => `${red(`${figures.error()} Validation Error:`)}
 
   Invalid value for option '${bold(name)}': ${bold(value)}
 
@@ -61,8 +69,8 @@ export const invalidOption = (name, value, message) => `${red(`${error} Validati
 
 See https://github.com/lint-staged/lint-staged#command-line-flags`
 
-export const PREVENTED_EMPTY_COMMIT = `
-  ${yellow(`${warning} lint-staged prevented an empty git commit.
+export const preventedEmptyCommit = () => `
+  ${yellow(`${figures.warning()} lint-staged prevented an empty git commit.
   Use the --allow-empty option to continue, or check your task configuration`)}
 `
 
@@ -75,23 +83,22 @@ export const restoreStashExample = (
   > git apply --index ${hash}
 `
 
-export const CONFIG_STDIN_ERROR = red(`${error} Failed to read config from stdin.`)
-
 export const failedToLoadConfig = (filepath) =>
-  red(`${error} Failed to read config from file "${filepath}".`)
+  red(`${figures.error()} Failed to read config from file "${filepath}".`)
 
 export const failedToParseConfig = (
   filepath,
   error
-) => `${red(`${error} Failed to parse config from file "${filepath}".`)}
+) => `${red(`${figures.error()} Failed to parse config from file "${filepath}".`)}
 
 ${error}
 
 See https://github.com/lint-staged/lint-staged#configuration.`
 
-export const UNSTAGED_CHANGES_BACKUP_STASH_LOCATION = `Unstaged changes have been kept back in a patch file:`
+export const unstagedChangesBackupStashLocation = () =>
+  'Unstaged changes have been kept back in a patch file:'
 
 export const minGitVersionRequired = (expected) =>
-  red(`${error} lint-staged requires at least Git version ${bold(expected)}.
+  red(`${figures.error()} lint-staged requires at least Git version ${bold(expected)}.
 
 Please update Git: https://git-scm.com/downloads`)