@itcase/config 1.6.78 → 1.6.80

package/README.md

@@ -87,7 +87,7 @@ npm install --save-dev commitizen @commitlint/cz-commitlint
 
 ## Smart commit
 
-`smart-commit` — Cursor Agent (`ask`) планирует коммиты по `SCOPES`, печатает сообщения, спрашивает `[y/N]`. Перед коммитом ждёт и снимает устаревший `.git/index.lock`, если его никто не держит.
+`smart-commit` — Cursor Agent (`ask`) планирует коммиты по `SCOPES`, печатает сообщения, спрашивает `[y/N]`. Перед коммитом ждёт и снимает устаревший `.git/index.lock`, если его никто не держит. Lockfile (`package-lock.json` и аналоги) всегда кладётся в тот же коммит, что и соседний `package.json`; при одном только bump deps агент не вызывается.
 
 ```text
 [yellow pixel banana animation]

package/lint-staged/index.js

@@ -9,8 +9,11 @@ export default {
   'package.json': (files) => {
     // Проверяем, есть ли package.json в корне репозитория
     const rootPackageJson = resolve(process.cwd(), 'package.json')
-    if (existsSync(rootPackageJson) && files.includes(rootPackageJson)) {
-      return 'npm install --package-lock-only'
+    const isRoot = files.some((file) => resolve(file) === rootPackageJson)
+    if (existsSync(rootPackageJson) && isRoot) {
+      // lock пишется командой, но glob только package.json — без git add
+      // он останется вне коммита (типичный leftover после bump deps)
+      return ['npm install --package-lock-only', 'git add -- package-lock.json']
     }
     return 'true' // Пропускаем, если не найден
   },

package/lint-staged-ts/index.js

@@ -17,8 +17,11 @@ export default {
   'package.json': (files) => {
     // Проверяем, есть ли package.json в корне репозитория
     const rootPackageJson = resolve(process.cwd(), 'package.json')
-    if (existsSync(rootPackageJson) && files.includes(rootPackageJson)) {
-      return 'npm install --package-lock-only'
+    const isRoot = files.some((file) => resolve(file) === rootPackageJson)
+    if (existsSync(rootPackageJson) && isRoot) {
+      // lock пишется командой, но glob только package.json — без git add
+      // он останется вне коммита (типичный leftover после bump deps)
+      return ['npm install --package-lock-only', 'git add -- package-lock.json']
     }
     return 'true' // Пропускаем, если не найден
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itcase/config",
-  "version": "1.6.78",
+  "version": "1.6.80",
   "author": "ITCase",
   "description": "ITCase Config",
   "engines": {

package/smart-commit/cli.js

@@ -22,6 +22,14 @@ const PACKAGE_NAME = '@itcase/config'
 const CLI_RELATIVE = 'smart-commit/cli.js'
 
 const MAX_DIFF = 80_000
+const LOCKFILE_NAMES = new Set([
+  'package-lock.json',
+  'npm-shrinkwrap.json',
+  'yarn.lock',
+  'pnpm-lock.yaml',
+  'bun.lock',
+  'bun.lockb',
+])
 const AGENT_TIMEOUT_MS = 120_000
 const AGENT_STEP_MS = 2_500
 const NYAN_FRAME_MS = 90
@@ -77,24 +85,28 @@ async function main(argv) {
     return
   }
 
-  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,
-        prompt,
-        option.verbose,
-        progress.onAgentActivity,
-      ),
-  )
-  let plans = parsePlan(raw, changedFiles)
-  plans = assignOmittedFiles(plans, changedFiles)
+  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 || '',
+          prompt,
+          option.verbose,
+          progress.onAgentActivity,
+        ),
+    )
+    plans = parsePlan(raw, changedFiles)
+    plans = assignOmittedFiles(plans, changedFiles)
+    plans = attachLockfiles(plans, changedFiles)
+  }
   await validateAndNormalizePlans(cwd, plans)
 
   process.stdout.write('\nCommits:\n')
@@ -130,14 +142,25 @@ async function main(argv) {
 
   ensureGitIndexReady(cwd)
 
+  const total = activePlans.length
+  process.stdout.write(`Creating ${total} commit(s)…\n`)
+
   let created = 0
-  for (const plan of activePlans) {
+  for (let index = 0; index < total; index++) {
+    const plan = activePlans[index]
+    const step = `[${index + 1}/${total}]`
     const planFiles = plan.files.filter((file) => fileHasChanges(cwd, file))
     if (!planFiles.length) {
-      process.stdout.write(`Skipping empty commit: ${plan.message}\n`)
+      process.stdout.write(`${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`)
+
     // Drop leftover index entries so only this plan's files are committed.
     git(cwd, ['reset', '-q', 'HEAD'])
     stageFiles(cwd, planFiles)
@@ -150,6 +173,7 @@ async function main(argv) {
       )
     }
 
+    process.stdout.write('      git commit (husky)…\n')
     try {
       git(cwd, ['commit', '-m', plan.message], { inherit: true })
     } catch (error) {
@@ -158,6 +182,7 @@ async function main(argv) {
       })
     }
     created++
+    process.stdout.write(`      done (${formatElapsed(startedAt)})\n`)
   }
   process.stdout.write(`Created ${created} commit(s).\n`)
 
@@ -332,6 +357,15 @@ function listFiles(cwd, option) {
   ]
 }
 
+function isLockfile(file) {
+  return LOCKFILE_NAMES.has(path.basename(file))
+}
+
+function siblingManifest(file) {
+  const directory = path.posix.dirname(file)
+  return directory === '.' ? 'package.json' : `${directory}/package.json`
+}
+
 function buildPrompt(scopes, types, files, cwd, type) {
   const statusByFile = new Map(
     lines(cwd, ['status', '--short', '--porcelain', '--', ...files]).map(
@@ -339,10 +373,9 @@ function buildPrompt(scopes, types, files, cwd, type) {
     ),
   )
 
-  let diff = files
-    .map((file) => buildFileDiff(cwd, file))
-    .filter(Boolean)
-    .join('\n\n')
+  const sourceFiles = files.filter((file) => !isLockfile(file))
+  const lockFiles = files.filter((file) => isLockfile(file))
+  let diff = buildSourceDiff(cwd, sourceFiles)
   if (diff.length > MAX_DIFF) diff = `${diff.slice(0, MAX_DIFF)}\n…truncated`
 
   return `Plan git commits. Do not edit files or run git commit.
@@ -353,46 +386,57 @@ Subject rules:
 ${promptSubjectRules.map((rule) => `- ${rule}`).join('\n')}
 Prefer one commit when changes belong to the same feature.
 Split by scope. Each listed file in exactly one commit — including new/untracked files (??).
+Put each lockfile in the same commit as its sibling package.json. Do not make a lockfile-only commit.
 Do not add Co-authored-by or Made-with trailers.
-${type ? `Prefer type "${type}".\n` : ''}SCOPES: ${JSON.stringify(scopes)}
-Files:
+${type ? `Prefer type "${type}".\n` : ''}Files:
 ${files
   .map((file) => {
     const status =
       statusByFile.get(file) || (isUntracked(cwd, file) ? '??' : ' M')
-    return `- ${file} (${status})`
+    const lockNote = isLockfile(file) ? ', lockfile' : ''
+    return `- ${file} (${status}${lockNote})`
   })
   .join('\n')}
-status:
-${out(cwd, ['status', '--short', '--', ...files]) || '(empty)'}
-diff:
+${
+  lockFiles.length
+    ? `Lockfiles (no diff, keep with package.json):\n${lockFiles
+        .map((file) => `- ${file}`)
+        .join('\n')}\n`
+    : ''
+}diff:
 ${diff || '(none)'}
 `
 }
 
-function buildFileDiff(cwd, file) {
-  const filePath = path.join(cwd, file)
-  if (!fs.existsSync(filePath)) {
-    return (
-      out(cwd, ['diff', '--cached', '--', file]) ||
-      out(cwd, ['diff', '--', file])
-    )
+function buildSourceDiff(cwd, files) {
+  const tracked = []
+  const untracked = []
+  for (const file of files) {
+    if (isUntracked(cwd, file)) untracked.push(file)
+    else tracked.push(file)
   }
 
-  if (isUntracked(cwd, file)) {
-    const nullPath = process.platform === 'win32' ? 'NUL' : '/dev/null'
-    const untrackedDiff = out(cwd, ['diff', '--no-index', nullPath, file])
-    return untrackedDiff
-      ? `new file ${file}:\n${untrackedDiff}`
-      : `new file ${file}: (empty)`
+  const parts = []
+  if (tracked.length) {
+    const text = out(cwd, ['diff', 'HEAD', '--', ...tracked])
+    if (text) parts.push(text)
   }
+  for (const file of untracked) {
+    const piece = buildUntrackedDiff(cwd, file)
+    if (piece) parts.push(piece)
+  }
+  return parts.join('\n\n')
+}
 
-  return [
-    out(cwd, ['diff', '--cached', '--', file]),
-    out(cwd, ['diff', '--', file]),
-  ]
-    .filter(Boolean)
-    .join('\n')
+function buildUntrackedDiff(cwd, file) {
+  const filePath = path.join(cwd, file)
+  if (!fs.existsSync(filePath)) return ''
+
+  const nullPath = process.platform === 'win32' ? 'NUL' : '/dev/null'
+  const untrackedDiff = out(cwd, ['diff', '--no-index', nullPath, file])
+  return untrackedDiff
+    ? `new file ${file}:\n${untrackedDiff}`
+    : `new file ${file}: (empty)`
 }
 
 function buildAgentProgressSteps(fileCount) {
@@ -604,6 +648,104 @@ function parsePlan(raw, allowedFiles) {
   return plans
 }
 
+function tryFastPlan(files, cwd, scopes, types) {
+  const sourceFiles = files.filter((file) => !isLockfile(file))
+  if (sourceFiles.length !== 1) return null
+  if (path.basename(sourceFiles[0]) !== 'package.json') return null
+
+  const message = inferDepsMessage(cwd, sourceFiles[0], scopes, types)
+  if (!message) return null
+
+  return [
+    {
+      message: message,
+      files: [...sourceFiles, ...files.filter(isLockfile)],
+    },
+  ]
+}
+
+function inferDepsMessage(cwd, file, scopes, types) {
+  const type = types.includes('deps')
+    ? 'deps'
+    : types.includes('chore')
+      ? 'chore'
+      : ''
+  if (!type) return ''
+
+  const names = changedDependencyNames(cwd, file)
+  if (!names?.length) return ''
+
+  const scope = pickScope(scopes, ['packages', 'deps', 'other'])
+  const subject =
+    names.length === 1
+      ? `bump ${names[0]}`
+      : names.length <= 3
+        ? `bump ${names.join(', ')}`
+        : 'bump dependencies'
+  return `${type}(${scope}): ${subject}`
+}
+
+function changedDependencyNames(cwd, file) {
+  const current = readJsonFile(path.join(cwd, file))
+  if (!current) return null
+
+  let previous = {}
+  const shown = spawnSync('git', ['show', `HEAD:${file}`], {
+    cwd: cwd,
+    encoding: 'utf8',
+  })
+  if (!shown.status && shown.stdout) {
+    try {
+      previous = JSON.parse(shown.stdout)
+    } catch {
+      return null
+    }
+  } else if (isUntracked(cwd, file)) {
+    return null
+  }
+
+  const sections = [
+    'dependencies',
+    'devDependencies',
+    'optionalDependencies',
+    'peerDependencies',
+  ]
+  const names = []
+  for (const key of sections) {
+    const before = previous[key] || {}
+    const after = current[key] || {}
+    for (const name of new Set([
+      ...Object.keys(before),
+      ...Object.keys(after),
+    ])) {
+      if (before[name] !== after[name]) names.push(name)
+    }
+  }
+
+  const keys = new Set([...Object.keys(previous), ...Object.keys(current)])
+  for (const key of keys) {
+    if (sections.includes(key)) continue
+    if (JSON.stringify(previous[key]) !== JSON.stringify(current[key])) {
+      return null
+    }
+  }
+
+  return names.length ? names : null
+}
+
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function pickScope(scopes, preferred) {
+  const list = buildScopeEnum(scopes)
+  return preferred.find((scope) => list.includes(scope)) || list[0] || 'other'
+}
+
 function assignOmittedFiles(plans, allowedFiles) {
   const assigned = new Set(plans.flatMap((plan) => plan.files))
   const missing = allowedFiles.filter((file) => !assigned.has(file))
@@ -619,6 +761,23 @@ function assignOmittedFiles(plans, allowedFiles) {
   return plans
 }
 
+function attachLockfiles(plans, allowedFiles) {
+  const locks = allowedFiles.filter((file) => isLockfile(file))
+  if (!locks.length) return plans
+
+  for (const lock of locks) {
+    for (const plan of plans) {
+      plan.files = plan.files.filter((file) => file !== lock)
+    }
+    const manifest = siblingManifest(lock)
+    const withManifest = plans.find((plan) => plan.files.includes(manifest))
+    const target = withManifest || findBestCommitForFile(plans, lock)
+    target.files.push(lock)
+  }
+
+  return plans.filter((plan) => plan.files.length)
+}
+
 function findBestCommitForFile(plans, file) {
   const fileDir = path.dirname(file)
 
@@ -741,6 +900,11 @@ function sleepSync(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms)
 }
 
+function formatElapsed(startedAt) {
+  const elapsed = Math.max(0, Math.floor((Date.now() - startedAt) / 1000))
+  return `${elapsed}s`
+}
+
 function indexLockPath(cwd) {
   const result = spawnSync('git', ['rev-parse', '--git-path', 'index.lock'], {
     cwd: cwd,
@@ -803,6 +967,8 @@ function git(cwd, args, option = {}) {
       stdio: option.inherit ? ['ignore', 'inherit', 'pipe'] : undefined,
     })
     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) {