@itcase/config 1.6.77 → 1.6.79

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.77",
+  "version": "1.6.79",
   "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
@@ -71,29 +79,34 @@ async function main(argv) {
   const cwd = process.cwd()
   assertItcaseConfigPackage(cwd)
   const { scopes, types } = await loadCommitlintConfig(cwd)
-  const files = listFiles(cwd, option)
-  if (!files.length) {
+  const changedFiles = listFiles(cwd, option)
+  if (!changedFiles.length) {
     process.stdout.write('No changes to commit.\n')
     return
   }
 
-  const prompt = buildPrompt(scopes, types, files, cwd, option.type)
-  const raw = await withAgentProgress(
-    {
-      fileCount: files.length,
-      sprite: pickSprite(option.sprite),
-      verbose: option.verbose,
-    },
-    (progress) =>
-      askAgent(
-        cwd,
-        option.model,
-        prompt,
-        option.verbose,
-        progress.onAgentActivity,
-      ),
-  )
-  const plans = parsePlan(raw, files)
+  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')
@@ -131,21 +144,21 @@ async function main(argv) {
 
   let created = 0
   for (const plan of activePlans) {
-    const files = plan.files.filter((file) => fileHasChanges(cwd, file))
-    if (!files.length) {
+    const planFiles = plan.files.filter((file) => fileHasChanges(cwd, file))
+    if (!planFiles.length) {
       process.stdout.write(`Skipping empty commit: ${plan.message}\n`)
       continue
     }
 
     // Drop leftover index entries so only this plan's files are committed.
     git(cwd, ['reset', '-q', 'HEAD'])
-    git(cwd, ['add', '--', ...files])
+    stageFiles(cwd, planFiles)
     const staged = lines(cwd, ['diff', '--cached', '--name-only'])
-    const stagedForPlan = files.filter((file) => staged.includes(file))
+    const stagedForPlan = planFiles.filter((file) => staged.includes(file))
     if (!stagedForPlan.length) {
       throw new Error(
         `Nothing staged for commit: ${plan.message}\n` +
-          `Files: ${files.join(', ')}`,
+          `Files: ${planFiles.join(', ')}`,
       )
     }
 
@@ -159,6 +172,14 @@ async function main(argv) {
     created++
   }
   process.stdout.write(`Created ${created} commit(s).\n`)
+
+  const remaining = changedFiles.filter((file) => fileHasChanges(cwd, file))
+  if (remaining.length) {
+    process.stdout.write(
+      `\nUncommitted changes (${remaining.length}):\n` +
+        `${remaining.map((file) => `  ${file}`).join('\n')}\n`,
+    )
+  }
 }
 
 function parseArgs(argv) {
@@ -306,28 +327,42 @@ function readReleaseBranches(cwd) {
 }
 
 function listFiles(cwd, option) {
-  const staged = lines(cwd, [
-    'diff',
-    '--cached',
-    '--name-only',
-    '--diff-filter=ACDMR',
-  ])
-  if (option.staged || staged.length) return staged
+  if (option.staged) {
+    return lines(cwd, [
+      'diff',
+      '--cached',
+      '--name-only',
+      '--diff-filter=ACDMR',
+    ])
+  }
   return [
     ...new Set([
+      ...lines(cwd, ['diff', '--cached', '--name-only', '--diff-filter=ACDMR']),
       ...lines(cwd, ['diff', '--name-only', '--diff-filter=ACDMR']),
       ...lines(cwd, ['ls-files', '--others', '--exclude-standard']),
     ]),
   ]
 }
 
+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) {
-  let diff = [
-    out(cwd, ['diff', '--cached', '--', ...files]),
-    out(cwd, ['diff', '--', ...files]),
-  ]
-    .filter(Boolean)
-    .join('\n\n')
+  const statusByFile = new Map(
+    lines(cwd, ['status', '--short', '--porcelain', '--', ...files]).map(
+      (line) => [line.slice(3), line.slice(0, 2).trim()],
+    ),
+  )
+
+  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.
@@ -337,18 +372,60 @@ Scopes (exact): ${buildScopeEnum(scopes).join(', ')}
 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.
+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:
-${files.map((file) => `- ${file}`).join('\n')}
-status:
-${out(cwd, ['status', '--short', '--', ...files]) || '(empty)'}
-diff:
+${type ? `Prefer type "${type}".\n` : ''}Files:
+${files
+  .map((file) => {
+    const status =
+      statusByFile.get(file) || (isUntracked(cwd, file) ? '??' : ' M')
+    const lockNote = isLockfile(file) ? ', lockfile' : ''
+    return `- ${file} (${status}${lockNote})`
+  })
+  .join('\n')}
+${
+  lockFiles.length
+    ? `Lockfiles (no diff, keep with package.json):\n${lockFiles
+        .map((file) => `- ${file}`)
+        .join('\n')}\n`
+    : ''
+}diff:
 ${diff || '(none)'}
 `
 }
 
+function buildSourceDiff(cwd, files) {
+  const tracked = []
+  const untracked = []
+  for (const file of files) {
+    if (isUntracked(cwd, file)) untracked.push(file)
+    else tracked.push(file)
+  }
+
+  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')
+}
+
+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) {
   const fileLabel =
     fileCount === 1 ? '1 changed file' : `${fileCount} changed files`
@@ -555,12 +632,175 @@ function parsePlan(raw, allowedFiles) {
   }
 
   if (!plans.length) throw new Error(`Empty commit plan:\n${raw}`)
-  const missing = allowedFiles.filter((file) => !seen.has(file))
-  if (missing.length)
-    throw new Error(`Cursor omitted files:\n${missing.join('\n')}`)
   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))
+  if (!missing.length) return plans
+
+  for (const file of missing) {
+    const target = findBestCommitForFile(plans, file)
+    target.files.push(file)
+    process.stderr.write(
+      `Auto-assigned omitted file to commit: ${file} → ${target.message}\n`,
+    )
+  }
+  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)
+
+  const sameDir = plans.find((plan) =>
+    plan.files.some((candidate) => path.dirname(candidate) === fileDir),
+  )
+  if (sameDir) return sameDir
+
+  let best = plans[0]
+  let bestScore = -1
+  for (const plan of plans) {
+    for (const candidate of plan.files) {
+      const score = commonPathPrefixLength(candidate, file)
+      if (score > bestScore) {
+        bestScore = score
+        best = plan
+      }
+    }
+  }
+  return best
+}
+
+function commonPathPrefixLength(left, right) {
+  const leftParts = left.split('/')
+  const rightParts = right.split('/')
+  let index = 0
+  while (
+    index < leftParts.length &&
+    index < rightParts.length &&
+    leftParts[index] === rightParts[index]
+  ) {
+    index++
+  }
+  return index
+}
+
 function normalizeCommitMessage(message) {
   const lines = String(message || '')
     .split('\n')
@@ -595,17 +835,25 @@ async function validateAndNormalizePlans(cwd, plans) {
   }
 }
 
-function fileHasChanges(cwd, file) {
-  const filePath = path.join(cwd, file)
-  if (!fs.existsSync(filePath)) return false
-
-  const tracked =
+function isTracked(cwd, file) {
+  return (
     spawnSync('git', ['ls-files', '--error-unmatch', '--', file], {
       cwd: cwd,
       encoding: 'utf8',
     }).status === 0
+  )
+}
+
+function isUntracked(cwd, file) {
+  return !isTracked(cwd, file) && fs.existsSync(path.join(cwd, file))
+}
+
+function fileHasChanges(cwd, file) {
+  const filePath = path.join(cwd, file)
+  const tracked = isTracked(cwd, file)
 
-  if (!tracked) return true
+  if (!tracked) return fs.existsSync(filePath)
+  if (!fs.existsSync(filePath)) return true
 
   return (
     spawnSync('git', ['diff', '--quiet', 'HEAD', '--', file], {
@@ -615,6 +863,11 @@ function fileHasChanges(cwd, file) {
   )
 }
 
+function stageFiles(cwd, files) {
+  if (!files.length) return
+  git(cwd, ['add', '-A', '--', ...files])
+}
+
 async function confirm(count) {
   if (!input.isTTY) throw new Error('No TTY — use --yes or --dry-run')
   const rl = readline.createInterface({ input, output })
@@ -696,6 +949,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) {