@itcase/config 1.7.11 → 1.7.13

package/lint-staged/checkNoFileDependencies.js

@@ -1,5 +1,6 @@
 import { readdirSync, readFileSync } from 'node:fs'
-import { join, relative } from 'node:path'
+import { join, relative, resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
 
 const FORBIDDEN_SPEC = /^(file:|link:)/i
 
@@ -94,37 +95,54 @@ function collectHits(pkg) {
   return hits
 }
 
-const cliFiles = process.argv.slice(2)
-const files = cliFiles.length ? cliFiles : findPackageJsonFiles(process.cwd())
+function findForbiddenDependencyHits(files) {
+  const targets = files?.length ? files : findPackageJsonFiles(process.cwd())
+  const hitsByFile = []
 
-const hitsByFile = []
+  for (const file of targets) {
+    const pkg = readPackageJson(file)
+    if (!pkg || typeof pkg !== 'object' || Array.isArray(pkg)) continue
 
-for (const file of files) {
-  const pkg = readPackageJson(file)
-  if (!pkg || typeof pkg !== 'object' || Array.isArray(pkg)) continue
-
-  const hits = collectHits(pkg)
-  if (hits.length) {
-    hitsByFile.push({ file, hits })
+    const hits = collectHits(pkg)
+    if (hits.length) {
+      hitsByFile.push({ file, hits })
+    }
   }
+
+  return hitsByFile
 }
 
-if (!hitsByFile.length) {
-  process.exit(0)
+function formatFileDependencyReport(hitsByFile) {
+  const lines = [
+    '❌ Локальные зависимости file: / link: нельзя коммитить.',
+    '   Замените их на версию из npm registry.',
+    '',
+  ]
+
+  for (const { file, hits } of hitsByFile) {
+    lines.push(`   ${relative(process.cwd(), file)}`)
+    for (const { locator, spec } of hits) {
+      lines.push(`     ${locator}: ${spec}`)
+    }
+  }
+
+  return lines.join('\n')
 }
 
-const lines = [
-  '❌ Локальные зависимости file: / link: нельзя коммитить.',
-  '   Замените их на версию из npm registry.',
-  '',
-]
+function isDirectCli() {
+  const entry = process.argv[1]
+  if (!entry) return false
+  return import.meta.url === pathToFileURL(resolve(entry)).href
+}
 
-for (const { file, hits } of hitsByFile) {
-  lines.push(`   ${relative(process.cwd(), file)}`)
-  for (const { locator, spec } of hits) {
-    lines.push(`     ${locator}: ${spec}`)
+if (isDirectCli()) {
+  const hitsByFile = findForbiddenDependencyHits(process.argv.slice(2))
+  if (!hitsByFile.length) {
+    process.exit(0)
   }
+
+  process.stderr.write(`${formatFileDependencyReport(hitsByFile)}\n`)
+  process.exit(1)
 }
 
-process.stderr.write(`${lines.join('\n')}\n`)
-process.exit(1)
+export { findForbiddenDependencyHits, formatFileDependencyReport }

package/lint-staged/common.js

@@ -1,22 +1,36 @@
+/* eslint-disable perfectionist/sort-objects */
+
 import { existsSync } from 'node:fs'
-import { dirname, join, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { resolve } from 'node:path'
 
-const checkNoFileDependencies = join(
-  dirname(fileURLToPath(import.meta.url)),
-  'checkNoFileDependencies.js',
-)
+import {
+  findForbiddenDependencyHits,
+  formatFileDependencyReport,
+} from './checkNoFileDependencies.js'
 
 function existingFiles(files) {
   return files.filter((file) => existsSync(file))
 }
 
+// Команды запускаются без shell (string-argv): каждый аргумент в кавычках,
+// иначе путь с пробелом разрежется. npx не нужен — lint-staged берёт бинарь из node_modules/.bin.
+function commandLine(parts) {
+  return parts.map((part) => JSON.stringify(part)).join(' ')
+}
+
 function eslintCommand(files) {
-  return `npx eslint --fix --color ${files.join(' ')}`
+  return commandLine(['eslint', '--fix', '--color', ...files])
 }
 
 function stylelintCommand(files) {
-  return `npx stylelint --fix --color --formatter verbose ${files.join(' ')}`
+  return commandLine([
+    'stylelint',
+    '--fix',
+    '--color',
+    '--formatter',
+    'verbose',
+    ...files,
+  ])
 }
 
 function packageJsonCommand(files) {
@@ -24,10 +38,12 @@ function packageJsonCommand(files) {
   const rootPackageJson = resolve(process.cwd(), 'package.json')
   const isRoot = files.some((file) => resolve(file) === rootPackageJson)
   if (existsSync(rootPackageJson) && isRoot) {
-    // lint-staged автоматически добавляет изменения задач в index
+    // С lint-staged 17.6 задача стейджит все tracked-файлы, которые она изменила,
+    // не только совпавшие с glob. package-lock.json попадёт в коммит без git add
+    // (git add в команде lint-staged просит убрать).
     return 'npm install --package-lock-only'
   }
-  return 'true' // Пропускаем, если не найден
+  return []
 }
 
 /**
@@ -43,9 +59,25 @@ function createLintStagedConfig({
   typecheckCommand = 'tsc --noEmit --pretty',
 } = {}) {
   return {
-    // На любой staged-файл: если в package.json есть file:/link: — exit 1, коммит не пройдёт
-    '*': () => `node ${JSON.stringify(checkNoFileDependencies)}`,
-    '*.(js|jsx|ts|tsx)': (files) => {
+    // На любой staged-файл: если в package.json есть file:/link: — задача падает, коммит не пройдёт.
+    // Function task (lint-staged 16+, log() с 17.6): без отдельного node-процесса.
+    // До 17.6 второй аргумент не передаётся — деструктуризация { log } роняла задачу
+    // и lint-staged убивал параллельный eslint (Task killed).
+    '*': {
+      title: 'check file: dependencies',
+      task: async (_filepaths, context) => {
+        const hitsByFile = findForbiddenDependencyHits()
+        if (!hitsByFile.length) return
+
+        const report = formatFileDependencyReport(hitsByFile)
+        if (typeof context?.log === 'function') context.log('%s', report)
+        else process.stderr.write(`${report}\n`)
+        throw new Error('Локальные зависимости file: / link: нельзя коммитить.')
+      },
+    },
+    // picomatch (lint-staged 16.4+) раскрывает brace-glob.
+    // tsc только для .ts/.tsx; .js/.jsx/.mjs/.cjs идут в eslint.
+    '*.{js,jsx,mjs,cjs,ts,tsx}': (files) => {
       const existing = existingFiles(files)
       const tsFiles = existing.filter((file) => /\.(ts|tsx)$/.test(file))
       const commands = []
@@ -58,16 +90,16 @@ function createLintStagedConfig({
         commands.push(eslintCommand(existing))
       }
 
-      return commands.length ? commands : 'true'
+      return commands
     },
     '*.css': (files) => {
       const existing = existingFiles(files)
-      if (!existing.length) return 'true'
+      if (!existing.length) return []
       return stylelintCommand(existing)
     },
     '*.mdx': (files) => {
       const existing = existingFiles(files)
-      if (!existing.length) return 'true'
+      if (!existing.length) return []
       return eslintCommand(existing)
     },
     'package.json': packageJsonCommand,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itcase/config",
-  "version": "1.7.11",
+  "version": "1.7.13",
   "author": "ITCase",
   "description": "ITCase Config",
   "engines": {
@@ -43,11 +43,11 @@
     "@commitlint/config-conventional": "^21.2.3",
     "@commitlint/cz-commitlint": "^21.2.3",
     "@lehoczky/postcss-fluid": "^1.0.3",
-    "@lerna-lite/cli": "^5.6.1",
-    "@lerna-lite/exec": "^5.6.1",
-    "@lerna-lite/list": "^5.6.1",
-    "@lerna-lite/run": "^5.6.1",
-    "@lerna-lite/watch": "^5.6.1",
+    "@lerna-lite/cli": "^5.6.2",
+    "@lerna-lite/exec": "^5.6.2",
+    "@lerna-lite/list": "^5.6.2",
+    "@lerna-lite/run": "^5.6.2",
+    "@lerna-lite/watch": "^5.6.2",
     "@rollup/plugin-alias": "^6.0.0",
     "@rollup/plugin-babel": "^7.1.0",
     "@rollup/plugin-commonjs": "^29.0.3",
@@ -68,8 +68,8 @@
     "commitizen": "^4.3.2",
     "conventional-changelog-conventionalcommits": "9.3.1",
     "conventional-changelog-writer": "9.2.1",
-    "cssnano": "^9.0.5",
-    "cssnano-preset-default": "^9.0.5",
+    "cssnano": "^9.1.0",
+    "cssnano-preset-default": "^9.1.0",
     "inquirer": "^14.2.2",
     "log-update": "^8.0.0",
     "postcss": "^8.5.28",
@@ -80,7 +80,7 @@
     "postcss-combine-duplicated-selectors": "^10.0.3",
     "postcss-convert-unit": "^0.1.3",
     "postcss-dark-theme-class": "^2.0.0",
-    "postcss-discard-duplicates": "^9.0.3",
+    "postcss-discard-duplicates": "^9.0.4",
     "postcss-each": "^1.1.0",
     "postcss-easings": "^4.0.0",
     "postcss-extend-rule": "^4.0.0",
@@ -96,7 +96,7 @@
     "postcss-nested-ancestors": "^3.0.0",
     "postcss-normalize": "^13.0.1",
     "postcss-prepend-imports": "^1.0.1",
-    "postcss-preset-env": "^11.5.3",
+    "postcss-preset-env": "^11.5.4",
     "postcss-pxtorem": "^6.1.0",
     "postcss-sort-media-queries": "^6.7.1",
     "postcss-unit": "^0.0.3",
@@ -118,8 +118,8 @@
     "eslint": "9.39.2",
     "husky": "^9.1.7",
     "inquirer": "^14.2.2",
-    "lint-staged": "^17.5.1",
-    "prettier": "^3.9.8",
+    "lint-staged": "^17.6.0",
+    "prettier": "^3.9.9",
     "storybook": "^10.6.0",
     "stylelint": "^17.15.0",
     "typescript": "^6.0.3"

package/smart-commit/cli.js

@@ -25,6 +25,10 @@ const CLI_RELATIVE = 'smart-commit/cli.js'
 const DEFAULT_MODEL = 'composer-2.5'
 
 const MAX_DIFF = 80_000
+const GIT_MAX_BUFFER = 32 * 1024 * 1024
+const GIT_PATH_BATCH = 40
+const PLAN_FILE_BATCH = 40
+const ARG_SAFE = 100_000
 const LOCKFILE_NAMES = new Set([
   'package-lock.json',
   'npm-shrinkwrap.json',
@@ -37,6 +41,9 @@ const AGENT_STEP_MS = 2_500
 const AGENT_STILL_WORKING_S = 120
 const AGENT_LOG_ROWS = 8
 const AGENT_LOG_MAX = 160
+const HOOK_LOG_ROWS = 6
+const SPIN_MS = 80
+const SPIN_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
 const NYAN_FRAME_MS = 90
 const BANANA_FRAME_MS = 100
 const UPYACHKA_FRAME_MS = 100
@@ -99,27 +106,18 @@ async function main(argv) {
 
   let plans = tryFastPlan(changedFiles, cwd, scopes, types)
   if (!plans) {
-    const prompt = buildPrompt(scopes, types, changedFiles, cwd, option.type)
-    const raw = await withAgentProgress(
-      {
-        fileCount: changedFiles.length,
-        sprite: pickSprite(option.sprite),
-        verbose: option.verbose,
-      },
-      (progress) =>
-        askAgent(
-          cwd,
-          option.model || process.env.SMART_COMMIT_MODEL || DEFAULT_MODEL,
-          prompt,
-          option.verbose,
-          progress.onAgentActivity,
-        ),
-    )
-    plans = parsePlan(raw, changedFiles)
+    plans = await planWithAgent({
+      cwd: cwd,
+      files: changedFiles,
+      model: option.model || process.env.SMART_COMMIT_MODEL || DEFAULT_MODEL,
+      option: option,
+      scopes: scopes,
+      types: types,
+    })
     plans = assignOmittedFiles(plans, changedFiles)
     plans = attachLockfiles(plans, changedFiles)
   }
-  await validateAndNormalizePlans(cwd, plans)
+  await validateAndNormalizePlans(cwd, plans, scopes, types)
 
   process.stdout.write('\nCommits:\n')
   for (const plan of plans) process.stdout.write(`  • ${plan.message}\n`)
@@ -155,7 +153,7 @@ async function main(argv) {
   ensureGitIndexReady(cwd)
 
   const total = activePlans.length
-  process.stdout.write(`Creating ${total} commit(s)…\n`)
+  process.stdout.write(`\n${paint('1', `Creating ${total} commit(s)…`)}\n`)
 
   let created = 0
   for (let index = 0; index < total; index++) {
@@ -163,15 +161,15 @@ async function main(argv) {
     const step = `[${index + 1}/${total}]`
     const planFiles = plan.files.filter((file) => fileHasChanges(cwd, file))
     if (!planFiles.length) {
-      process.stdout.write(`${step} skip empty: ${plan.message}\n`)
+      process.stdout.write(`${dim(step)} skip empty: ${plan.message}\n`)
       continue
     }
 
     const startedAt = Date.now()
     const fileLabel =
       planFiles.length === 1 ? '1 file' : `${planFiles.length} files`
-    process.stdout.write(`${step} ${plan.message}\n`)
-    process.stdout.write(`      staging ${fileLabel}…\n`)
+    process.stdout.write(`\n${paint('1;36', step)} ${plan.message}\n`)
+    process.stdout.write(`${dim(`      staging ${fileLabel}…`)}\n`)
 
     // Drop leftover index entries so only this plan's files are committed.
     git(cwd, ['reset', '-q', 'HEAD'])
@@ -185,26 +183,36 @@ async function main(argv) {
       )
     }
 
-    process.stdout.write(
-      option.noVerify
-        ? '      git commit --no-verify (hooks skipped)…\n'
-        : '      git commit (husky)…\n',
+    const commitLabel = option.noVerify
+      ? 'git commit --no-verify'
+      : 'git commit'
+    const hookLocks = siblingLocksForFiles(planFiles)
+    const dirtyLocksBefore = new Set(
+      hookLocks.filter((file) => fileHasChanges(cwd, file)),
     )
     try {
       const commitArgs = ['commit', '-m', plan.message]
       // Skips pre-commit (lint-staged) and commit-msg. lint-staged has no
       // equivalent flag — the hook simply does not run.
       if (option.noVerify) commitArgs.push('--no-verify')
-      git(cwd, commitArgs, { inherit: true })
+      await gitCommitWithProgress(cwd, commitArgs, commitLabel)
+      const included = includeHookLockfiles(cwd, planFiles, dirtyLocksBefore)
+      if (included.length) {
+        process.stdout.write(
+          `${dim(`      hook updated ${included.join(', ')}, added to commit`)}\n`,
+        )
+      }
     } catch (error) {
       throw new Error(`git commit failed: ${plan.message}\n${error.message}`, {
         cause: error,
       })
     }
     created++
-    process.stdout.write(`      done (${formatElapsed(startedAt)})\n`)
+    process.stdout.write(
+      `${paint('1;32', `      done ${formatElapsed(startedAt)}`)}\n`,
+    )
   }
-  process.stdout.write(`Created ${created} commit(s).\n`)
+  process.stdout.write(`\n${paint('1;32', `Created ${created} commit(s).`)}\n`)
 
   const remaining = changedFiles.filter((file) => fileHasChanges(cwd, file))
   if (remaining.length) {
@@ -391,9 +399,16 @@ function siblingManifest(file) {
   return directory === '.' ? 'package.json' : `${directory}/package.json`
 }
 
+function siblingLockPaths(manifest) {
+  const directory = path.posix.dirname(manifest)
+  return [...LOCKFILE_NAMES].map((name) =>
+    directory === '.' ? name : `${directory}/${name}`,
+  )
+}
+
 function buildPrompt(scopes, types, files, cwd, type) {
   const statusByFile = new Map(
-    lines(cwd, ['status', '--short', '--porcelain', '--', ...files]).map(
+    linesFromPaths(cwd, ['status', '--short', '--porcelain'], files).map(
       (line) => [line.slice(3), line.slice(0, 2).trim()],
     ),
   )
@@ -405,6 +420,7 @@ function buildPrompt(scopes, types, files, cwd, type) {
 
   return `Plan git commits. Do not edit files or run git commit.
 Return ONLY JSON: {"commits":[{"message":"type(scope): subject","files":["a.ts"]}]}
+Every message must be type(scope): subject. Put a scope from the list in parentheses, including when the type is "other".
 Types: ${types.join(', ')}
 Scopes (exact): ${buildScopeEnum(scopes).join(', ')}
 Subject rules:
@@ -443,13 +459,30 @@ function buildSourceDiff(cwd, files) {
   }
 
   const parts = []
-  if (tracked.length) {
-    const text = out(cwd, ['diff', 'HEAD', '--', ...tracked])
-    if (text) parts.push(text)
+  let used = 0
+  const pushLimited = (text) => {
+    if (used >= MAX_DIFF) return false
+    // Empty batch (no changes / ENOBUFS skip) — keep scanning remaining files.
+    if (!text) return true
+    const room = MAX_DIFF - used
+    if (text.length > room) {
+      parts.push(`${text.slice(0, room)}\n…truncated`)
+      used = MAX_DIFF
+      return false
+    }
+    parts.push(text)
+    used += text.length
+    return true
   }
+
+  forEachBatch(tracked, (batch) => {
+    if (used >= MAX_DIFF) return false
+    return pushLimited(tryOut(cwd, ['diff', 'HEAD', '--', ...batch]))
+  })
   for (const file of untracked) {
+    if (used >= MAX_DIFF) break
     const piece = buildUntrackedDiff(cwd, file)
-    if (piece) parts.push(piece)
+    if (!pushLimited(piece)) break
   }
   return parts.join('\n\n')
 }
@@ -634,7 +667,22 @@ function askAgent(cwd, model, prompt, verbose, onAgentActivity) {
   if (model) args.push('--model', model)
   if (process.env.CURSOR_API_KEY)
     args.push('--api-key', process.env.CURSOR_API_KEY)
-  args.push(prompt)
+
+  let promptFile = ''
+  let agentPrompt = prompt
+  if (prompt.length > ARG_SAFE) {
+    const candidate = path.join(cwd, '.git', 'smart-commit-prompt.txt')
+    try {
+      fs.writeFileSync(candidate, prompt, 'utf8')
+      promptFile = candidate
+      agentPrompt =
+        `Read the file ${candidate} and follow it exactly. ` +
+        'Return ONLY the JSON it requests. Do not edit files or run git commit.'
+    } catch {
+      // If .git cannot be written, keep the original prompt.
+    }
+  }
+  args.push(agentPrompt)
 
   if (verbose) process.stderr.write(`Using: ${cmd}\n`)
   if (onAgentActivity) {
@@ -667,6 +715,13 @@ function askAgent(cwd, model, prompt, verbose, onAgentActivity) {
       settled = true
       process.removeListener('SIGINT', onSignal)
       process.removeListener('SIGTERM', onSignal)
+      if (promptFile) {
+        try {
+          fs.unlinkSync(promptFile)
+        } catch {
+          // Ignore cleanup errors.
+        }
+      }
       if (error) reject(error)
       else resolve(value)
     }
@@ -754,20 +809,12 @@ function applyAgentLine(stream, line) {
     const text = extractThinkingText(event)
     if (event.subtype === 'completed') {
       return stream.thinking
-        ? {
-            log: `Thinking: ${stream.thinking}`,
-            stream: true,
-            streamKey: 'thinking',
-          }
+        ? thinkingLog(stream)
         : { log: 'Finished thinking' }
     }
     if (text) {
       stream.thinking += text
-      return {
-        log: `Thinking: ${stream.thinking}`,
-        stream: true,
-        streamKey: 'thinking',
-      }
+      return thinkingLog(stream)
     }
     return { log: 'Thinking' }
   }
@@ -782,13 +829,9 @@ function applyAgentLine(stream, line) {
     const thinking = extractContentText(event.message?.content, 'thinking')
     if (thinking) {
       stream.thinking += thinking
-      return {
-        log: `Thinking: ${stream.thinking}`,
-        stream: true,
-        streamKey: 'thinking',
-      }
+      return thinkingLog(stream)
     }
-    const text = extractAssistantText(event)
+    const text = extractContentText(event.message?.content, 'text')
     if (!text) return null
     if (typeof event.timestamp_ms === 'number') stream.lastAssistant += text
     else stream.lastAssistant = text
@@ -812,8 +855,12 @@ function applyAgentLine(stream, line) {
   return null
 }
 
-function extractAssistantText(event) {
-  return extractContentText(event.message?.content, 'text')
+function thinkingLog(stream) {
+  return {
+    log: `Thinking: ${stream.thinking}`,
+    stream: true,
+    streamKey: 'thinking',
+  }
 }
 
 function extractThinkingText(event) {
@@ -940,6 +987,131 @@ function parsePlan(raw, allowedFiles) {
   return plans
 }
 
+async function planWithAgent(context) {
+  const batches = splitPlanBatches(context.files)
+  const plans = []
+  for (let index = 0; index < batches.length; index++) {
+    const batch = batches[index]
+    if (batches.length > 1) {
+      process.stdout.write(
+        `Planning ${index + 1}/${batches.length} (${batch.length} files)…\n`,
+      )
+    }
+    const batchPlans = await planBatch({ ...context, files: batch })
+    plans.push(...batchPlans)
+  }
+  return plans
+}
+
+async function planBatch(context) {
+  try {
+    return await requestPlan(context)
+  } catch (error) {
+    if (context.files.length < 2 || !isRetryablePlanError(error)) throw error
+    const mid = Math.ceil(context.files.length / 2)
+    process.stderr.write(
+      `Commit plan failed for ${context.files.length} files, splitting…\n`,
+    )
+    const left = await planBatch({
+      ...context,
+      files: context.files.slice(0, mid),
+    })
+    const right = await planBatch({
+      ...context,
+      files: context.files.slice(mid),
+    })
+    return [...left, ...right]
+  }
+}
+
+function isRetryablePlanError(error) {
+  return /Bad JSON|Empty commit plan|No JSON/.test(String(error?.message || ''))
+}
+
+async function requestPlan(context) {
+  const prompt = buildPrompt(
+    context.scopes,
+    context.types,
+    context.files,
+    context.cwd,
+    context.option.type,
+  )
+  const raw = await withAgentProgress(
+    {
+      fileCount: context.files.length,
+      sprite: pickSprite(context.option.sprite),
+      verbose: context.option.verbose,
+    },
+    (progress) =>
+      askAgent(
+        context.cwd,
+        context.model,
+        prompt,
+        context.option.verbose,
+        progress.onAgentActivity,
+      ),
+  )
+  return parsePlan(raw, context.files)
+}
+
+function splitPlanBatches(files) {
+  if (files.length <= PLAN_FILE_BATCH) return [files]
+
+  const groups = new Map()
+  for (const file of files) {
+    if (isLockfile(file)) continue
+    const key = planGroupKey(file)
+    const group = groups.get(key) || []
+    group.push(file)
+    groups.set(key, group)
+  }
+
+  for (const file of files) {
+    if (!isLockfile(file)) continue
+    const manifest = siblingManifest(file)
+    let placed = false
+    for (const group of groups.values()) {
+      if (!group.includes(manifest)) continue
+      group.push(file)
+      placed = true
+      break
+    }
+    if (placed) continue
+    const key = planGroupKey(file)
+    const group = groups.get(key) || []
+    group.push(file)
+    groups.set(key, group)
+  }
+
+  const batches = []
+  let current = []
+  for (const group of groups.values()) {
+    if (group.length > PLAN_FILE_BATCH) {
+      if (current.length) {
+        batches.push(current)
+        current = []
+      }
+      for (let index = 0; index < group.length; index += PLAN_FILE_BATCH) {
+        batches.push(group.slice(index, index + PLAN_FILE_BATCH))
+      }
+      continue
+    }
+    if (current.length && current.length + group.length > PLAN_FILE_BATCH) {
+      batches.push(current)
+      current = []
+    }
+    current.push(...group)
+  }
+  if (current.length) batches.push(current)
+  return batches.length ? batches : [files]
+}
+
+function planGroupKey(file) {
+  const parts = file.split('/')
+  if (parts.length <= 2) return parts[0] || '.'
+  return `${parts[0]}/${parts[1]}`
+}
+
 function tryFastPlan(files, cwd, scopes, types) {
   const sourceFiles = files.filter((file) => !isLockfile(file))
   if (sourceFiles.length !== 1) return null
@@ -1118,7 +1290,7 @@ function normalizeCommitMessage(message) {
   return normalizeCommitSubject(subject)
 }
 
-async function validateAndNormalizePlans(cwd, plans) {
+async function validateAndNormalizePlans(cwd, plans, scopes, types) {
   const loaded = await load({}, cwd)
   const lintOptions = {
     defaultIgnores: loaded.defaultIgnores,
@@ -1128,38 +1300,71 @@ async function validateAndNormalizePlans(cwd, plans) {
 
   for (const plan of plans) {
     plan.message = normalizeCommitSubject(plan.message)
-    const report = await lint(plan.message, loaded.rules, lintOptions)
+    let report = await lint(plan.message, loaded.rules, lintOptions)
     if (report.valid) continue
 
+    const oldMessage = plan.message
+    const repaired = repairCommitHeader(plan.message, scopes, types)
+    if (repaired !== oldMessage) {
+      report = await lint(repaired, loaded.rules, lintOptions)
+      if (report.valid) {
+        process.stderr.write(
+          `Adjusted commit message for commitlint:\n  ${oldMessage}\n  ${repaired}\n`,
+        )
+        plan.message = repaired
+        continue
+      }
+    }
+
     const errors =
       report.errors?.map((error) => error.message).join('; ') || 'invalid'
     throw new Error(
       `Commit message failed commitlint:\n  ${plan.message}\n  ${errors}\n` +
-        'Use lower-case subject without camelCase (e.g. "public dir" not "publicDir").',
+        'Use type(scope): subject. Scope in parentheses is required. Subject is lower-case without camelCase (e.g. "public dir" not "publicDir").',
     )
   }
 }
 
+function repairCommitHeader(message, scopes, types) {
+  const match = String(message || '')
+    .trim()
+    .match(/^(\w+)(?:\(([^)]*)\))?:\s*(.+)$/)
+  if (!match) return message
+
+  let [, type, rawScope, subject] = match
+  const scopeEnum = buildScopeEnum(scopes)
+  if (types.length && !types.includes(type)) {
+    if (types.includes('chore')) type = 'chore'
+    else if (types.includes('other')) type = 'other'
+    else type = types[0]
+  }
+
+  const matchedScope = matchScope((rawScope || '').trim(), scopeEnum)
+  const scope = matchedScope || pickScope(scopes, ['other'])
+
+  return normalizeCommitSubject(`${type}(${scope}): ${subject}`)
+}
+
+function matchScope(scope, scopeEnum) {
+  if (scopeEnum.includes(scope)) return scope
+  const normalized = scope
+    .trim()
+    .replace(/\s*\/\s*/g, ' / ')
+    .replace(/\s+/g, ' ')
+  if (scopeEnum.includes(normalized)) return normalized
+  return ''
+}
+
 function isOnDisk(cwd, file) {
   return fs.existsSync(path.join(cwd, file))
 }
 
 function isTracked(cwd, file) {
-  return (
-    spawnSync('git', ['ls-files', '--error-unmatch', '--', file], {
-      cwd: cwd,
-      encoding: 'utf8',
-    }).status === 0
-  )
+  return gitOk(cwd, ['ls-files', '--error-unmatch', '--', file])
 }
 
 function isInHead(cwd, file) {
-  return (
-    spawnSync('git', ['cat-file', '-e', `HEAD:${file}`], {
-      cwd: cwd,
-      encoding: 'utf8',
-    }).status === 0
-  )
+  return gitOk(cwd, ['cat-file', '-e', `HEAD:${file}`])
 }
 
 function isUntracked(cwd, file) {
@@ -1181,6 +1386,44 @@ function fileHasChanges(cwd, file) {
   )
 }
 
+function siblingLocksForFiles(files) {
+  const locks = []
+  for (const file of files) {
+    if (path.basename(file) !== 'package.json') continue
+    locks.push(...siblingLockPaths(file))
+  }
+  return [...new Set(locks)]
+}
+
+// lint-staged runs `npm install --package-lock-only` for package.json, but
+// older lint-staged only re-stages the matched file. The lockfile stays dirty
+// after the commit. Fold that hook output into the commit we just created.
+function includeHookLockfiles(cwd, planFiles, dirtyBefore) {
+  const locks = []
+  for (const file of planFiles) {
+    if (path.basename(file) !== 'package.json') continue
+    for (const lock of siblingLockPaths(file)) {
+      if (!fileHasChanges(cwd, lock)) continue
+      const wasDirty = dirtyBefore.has(lock)
+      const wasInCommit = planFiles.includes(lock)
+      if (!wasDirty || wasInCommit) locks.push(lock)
+    }
+  }
+
+  const unique = [...new Set(locks)]
+  if (!unique.length) return []
+
+  stageFiles(cwd, unique)
+  const staged = new Set(lines(cwd, ['diff', '--cached', '--name-only']))
+  const stagedLocks = unique.filter((file) => staged.has(file))
+  if (!stagedLocks.length) return []
+
+  // --no-verify: the hook already ran and produced this lockfile.
+  // Running it again would call npm install and dirty the lockfile once more.
+  git(cwd, ['commit', '--amend', '--no-edit', '--no-verify'])
+  return stagedLocks
+}
+
 function stageFiles(cwd, files) {
   if (!files.length) return
 
@@ -1193,10 +1436,12 @@ function stageFiles(cwd, files) {
 
   // `git add -A -- deleted/path` warns or misses the deletion when the
   // parent directory is already gone. `git rm` stages the index removal.
-  if (existing.length) git(cwd, ['add', '-A', '--', ...existing])
-  if (removed.length) {
-    git(cwd, ['rm', '--ignore-unmatch', '-q', '--', ...removed])
-  }
+  forEachBatch(existing, (batch) => {
+    git(cwd, ['add', '-A', '--', ...batch])
+  })
+  forEachBatch(removed, (batch) => {
+    git(cwd, ['rm', '--ignore-unmatch', '-q', '--', ...batch])
+  })
 }
 
 async function confirm(count) {
@@ -1277,31 +1522,191 @@ function ensureGitIndexReady(cwd) {
   )
 }
 
+async function gitCommitWithProgress(cwd, args, label) {
+  for (let attempt = 1; attempt <= INDEX_LOCK_RETRIES; attempt++) {
+    const result = await spawnGitWithSpinner(cwd, args, label)
+    if (result.error) throw result.error
+    if (!result.status) {
+      if (process.stderr.isTTY) writeGitSummary(result.stdout)
+      else writeHookOutput(result.stdout, result.stderr)
+      return
+    }
+
+    const stderr = result.stderr || ''
+    if (!retryIndexLock(cwd, attempt, stderr)) {
+      throw new Error(
+        (stderr || result.stdout || '').trim() || `git ${args.join(' ')}`,
+      )
+    }
+    await sleep(INDEX_LOCK_WAIT_MS * attempt)
+  }
+}
+
+function spawnGitWithSpinner(cwd, args, label) {
+  return new Promise((resolve) => {
+    const child = spawn('git', args, {
+      cwd: cwd,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+    let stdout = ''
+    let stderr = ''
+    const logLines = []
+    let frame = 0
+    const startedAt = Date.now()
+    const tty = Boolean(process.stderr.isTTY)
+
+    const pushLog = (chunk) => {
+      for (const line of String(chunk).split('\n')) {
+        const trimmed = line.trim()
+        if (!trimmed) continue
+        logLines.push(trimmed)
+      }
+      if (logLines.length > 40) logLines.splice(0, logLines.length - 40)
+    }
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk
+      pushLog(chunk)
+    })
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk
+      pushLog(chunk)
+    })
+
+    let timer
+    if (tty) {
+      const render = () => {
+        const columns = process.stderr.columns || 80
+        const spin = SPIN_FRAMES[frame % SPIN_FRAMES.length]
+        frame += 1
+        const hookLines = logLines
+          .slice(-HOOK_LOG_ROWS)
+          .map((line) =>
+            dim(`      │ ${clipLog(line, Math.max(20, columns - 10))}`),
+          )
+        const status = paint(
+          '1;36',
+          `      ${spin}  ${label}  ${formatElapsed(startedAt)}`,
+        )
+        const block = [paint('1;33', '      husky'), ...hookLines, status]
+        logUpdateStderr(block.join('\n'))
+      }
+      timer = setInterval(render, SPIN_MS)
+      render()
+    } else {
+      timer = setInterval(() => {
+        process.stderr.write(`      ${label}… ${formatElapsed(startedAt)}\n`)
+      }, AGENT_STEP_MS)
+    }
+
+    const stop = () => {
+      clearInterval(timer)
+      if (tty) logUpdateStderr.clear()
+    }
+
+    const onSignal = () => {
+      if (child.exitCode === null && !child.killed) child.kill('SIGTERM')
+    }
+    process.once('SIGINT', onSignal)
+    process.once('SIGTERM', onSignal)
+
+    const finish = (result) => {
+      stop()
+      process.removeListener('SIGINT', onSignal)
+      process.removeListener('SIGTERM', onSignal)
+      resolve(result)
+    }
+
+    child.on('error', (error) => {
+      finish({ status: 1, error: error, stderr: stderr, stdout: stdout })
+    })
+    child.on('close', (code) => {
+      finish({
+        status: code ?? 1,
+        stderr: stderr,
+        stdout: stdout,
+      })
+    })
+  })
+}
+
+function writeGitSummary(stdout) {
+  const lines = String(stdout || '')
+    .split('\n')
+    .map((line) => line.trimEnd())
+    .filter(
+      (line) =>
+        /^\s*\[[^\]]+\]/.test(line) || /^\s*\d+ files? changed/.test(line),
+    )
+  if (!lines.length) return
+  process.stdout.write(`${dim(lines.join('\n'))}\n`)
+}
+
+function paint(code, text) {
+  if (!process.stdout.isTTY || process.env.NO_COLOR) return text
+  return `\x1b[${code}m${text}\x1b[0m`
+}
+
+function dim(text) {
+  return paint('2', text)
+}
+
+function writeHookOutput(stdout, stderr) {
+  if (stdout) {
+    process.stdout.write(stdout.endsWith('\n') ? stdout : `${stdout}\n`)
+  }
+  if (stderr) {
+    process.stderr.write(stderr.endsWith('\n') ? stderr : `${stderr}\n`)
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms)
+  })
+}
+
 function git(cwd, args, option = {}) {
   for (let attempt = 1; attempt <= INDEX_LOCK_RETRIES; attempt++) {
     const result = spawnSync('git', args, {
+      maxBuffer: GIT_MAX_BUFFER,
       cwd: cwd,
       encoding: 'utf8',
       stdio: option.inherit ? ['ignore', 'inherit', 'pipe'] : undefined,
     })
+    if (result.error) throw result.error
     if (!result.status) return result
     // git diff exits 1 when there are differences
     if (result.status === 1 && args[0] === 'diff') return result
 
     const stderr = result.stderr || ''
-    if (!isIndexLockError(stderr) || attempt === INDEX_LOCK_RETRIES) {
+    if (!retryIndexLock(cwd, attempt, stderr)) {
       if (option.inherit && stderr) process.stderr.write(stderr)
       throw new Error(stderr.trim() || `git ${args.join(' ')}`)
     }
-
-    if (attempt === 1) {
-      process.stderr.write('Waiting for git index.lock to clear…\n')
-    }
-    clearStaleIndexLock(cwd)
     sleepSync(INDEX_LOCK_WAIT_MS * attempt)
   }
 }
 
+function retryIndexLock(cwd, attempt, stderr) {
+  if (!isIndexLockError(stderr) || attempt === INDEX_LOCK_RETRIES) return false
+  if (attempt === 1) {
+    process.stderr.write('Waiting for git index.lock to clear…\n')
+  }
+  clearStaleIndexLock(cwd)
+  return true
+}
+
+function gitOk(cwd, args) {
+  return spawnSync('git', args, { cwd: cwd, encoding: 'utf8' }).status === 0
+}
+
+function forEachBatch(items, visit) {
+  for (let index = 0; index < items.length; index += GIT_PATH_BATCH) {
+    if (visit(items.slice(index, index + GIT_PATH_BATCH)) === false) return
+  }
+}
+
 function out(cwd, args) {
   return (git(cwd, args).stdout || '').trim()
 }
@@ -1309,3 +1714,22 @@ function out(cwd, args) {
 function lines(cwd, args) {
   return out(cwd, args).split('\n').filter(Boolean)
 }
+
+function linesFromPaths(cwd, prefix, files) {
+  if (!files.length) return []
+  const chunks = []
+  forEachBatch(files, (batch) => {
+    const text = out(cwd, [...prefix, '--', ...batch])
+    if (text) chunks.push(text)
+  })
+  return chunks.join('\n').split('\n').filter(Boolean)
+}
+
+function tryOut(cwd, args) {
+  try {
+    return out(cwd, args)
+  } catch (error) {
+    if (/ENOBUFS|maxBuffer/i.test(String(error?.message || ''))) return ''
+    throw error
+  }
+}