@itcase/config 1.6.74 → 1.6.76

package/commitlint/commitizenAdapter.js

@@ -28,7 +28,9 @@ function buildTypeChoices(types, typeEnum) {
     const name = meta
       ? [meta.emoji, value, meta.description].filter(Boolean).join(': ')
       : value
-    return { name, value }
+    // `short` is what inquirer reprints after select. Without it the
+    // full emoji + description wraps and the next input line jumps.
+    return { name: name, short: value, value: value }
   })
 }
 
@@ -82,7 +84,11 @@ async function prompter(inquirer, commit) {
         type: 'list',
         name: 'scope',
         message: messages.scope,
-        choices: scopeList.map((value) => ({ name: value, value: value })),
+        choices: scopeList.map((value) => ({
+          name: value,
+          short: value,
+          value: value,
+        })),
       },
       {
         type: 'list',
@@ -91,9 +97,13 @@ async function prompter(inquirer, commit) {
         choices: function (answers) {
           const subs = isScopesArray ? [] : SCOPES[answers.scope] || []
           return [
-            ...subs.map((value) => ({ name: value, value: value })),
+            ...subs.map((value) => ({
+              name: value,
+              short: value,
+              value: value,
+            })),
             new inquirer.Separator(),
-            { name: 'none', value: '' },
+            { name: 'none', short: 'none', value: '' },
           ]
         },
         when: function (answers) {

package/commitlint/commitlintCommon.js

@@ -16,7 +16,7 @@ export const commonRules = {
 }
 
 export const promptSubjectDescription =
-  'Short imperative description in lower-case (no camelCase: use "public dir" not "publicDir")'
+  'Short description (lower-case, no camelCase)'
 
 export const promptSubjectRules = [
   'lower-case only (commitlint subject-case)',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itcase/config",
-  "version": "1.6.74",
+  "version": "1.6.76",
   "author": "ITCase",
   "description": "ITCase Config",
   "engines": {
@@ -95,7 +95,7 @@
     "postcss-nested-ancestors": "^3.0.0",
     "postcss-normalize": "^13.0.1",
     "postcss-prepend-imports": "^1.0.1",
-    "postcss-preset-env": "^11.5.0",
+    "postcss-preset-env": "^11.5.1",
     "postcss-pxtorem": "^6.1.0",
     "postcss-sort-media-queries": "^6.7.1",
     "postcss-unit": "^0.0.3",

package/smart-commit/cli.js

@@ -24,6 +24,9 @@ const MAX_DIFF = 80_000
 const AGENT_TIMEOUT_MS = 120_000
 const AGENT_STEP_MS = 2_500
 const BANANA_FRAME_MS = 100
+const INDEX_LOCK_RETRIES = 8
+const INDEX_LOCK_WAIT_MS = 250
+const STALE_LOCK_MS = 1500
 const AGENT_WAIT_STEPS = [
   'Asking Cursor Agent',
   'Still thinking',
@@ -115,24 +118,35 @@ async function main(argv) {
     )
   }
 
+  ensureGitIndexReady(cwd)
+
   let created = 0
   for (const plan of activePlans) {
-    git(cwd, ['add', '--', ...plan.files])
+    const files = plan.files.filter((file) => fileHasChanges(cwd, file))
+    if (!files.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])
     const staged = lines(cwd, ['diff', '--cached', '--name-only'])
-    const stagedForPlan = plan.files.filter((file) => staged.includes(file))
+    const stagedForPlan = files.filter((file) => staged.includes(file))
     if (!stagedForPlan.length) {
       throw new Error(
         `Nothing staged for commit: ${plan.message}\n` +
-          `Files: ${plan.files.join(', ')}`,
+          `Files: ${files.join(', ')}`,
       )
     }
 
-    const commit = spawnSync('git', ['commit', '-m', plan.message], {
-      cwd: cwd,
-      encoding: 'utf8',
-      stdio: ['ignore', 'inherit', 'inherit'],
-    })
-    if (commit.status) throw new Error(`git commit failed: ${plan.message}`)
+    try {
+      git(cwd, ['commit', '-m', plan.message], { inherit: true })
+    } catch (error) {
+      throw new Error(`git commit failed: ${plan.message}\n${error.message}`, {
+        cause: error,
+      })
+    }
     created++
   }
   process.stdout.write(`Created ${created} commit(s).\n`)
@@ -585,10 +599,89 @@ async function confirm(count) {
   }
 }
 
-function git(cwd, args) {
-  const result = spawnSync('git', args, { cwd: cwd, encoding: 'utf8' })
-  if (result.status) throw new Error(result.stderr || `git ${args.join(' ')}`)
-  return result
+function isIndexLockError(stderr) {
+  return /index\.lock/.test(stderr || '')
+}
+
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms)
+}
+
+function indexLockPath(cwd) {
+  const result = spawnSync('git', ['rev-parse', '--git-path', 'index.lock'], {
+    cwd: cwd,
+    encoding: 'utf8',
+  })
+  const gitPath = (result.stdout || '').trim()
+  if (!gitPath) return path.join(cwd, '.git', 'index.lock')
+  return path.resolve(cwd, gitPath)
+}
+
+function lockHolders(lockPath) {
+  const result = spawnSync('lsof', ['-t', lockPath], { encoding: 'utf8' })
+  if (result.error || result.status === 127) return null
+  return (result.stdout || '').trim().split('\n').filter(Boolean)
+}
+
+function clearStaleIndexLock(cwd) {
+  const lockPath = indexLockPath(cwd)
+  let stat
+  try {
+    stat = fs.statSync(lockPath)
+  } catch {
+    return false
+  }
+  if (Date.now() - stat.mtimeMs < STALE_LOCK_MS) return false
+  const holders = lockHolders(lockPath)
+  if (holders && holders.length) return false
+  try {
+    fs.unlinkSync(lockPath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function ensureGitIndexReady(cwd) {
+  for (let attempt = 1; attempt <= INDEX_LOCK_RETRIES; attempt++) {
+    const lockPath = indexLockPath(cwd)
+    if (!fs.existsSync(lockPath)) return
+    if (attempt === 1) {
+      process.stderr.write('Waiting for git index.lock to clear…\n')
+    }
+    clearStaleIndexLock(cwd)
+    if (!fs.existsSync(lockPath)) return
+    sleepSync(INDEX_LOCK_WAIT_MS * attempt)
+  }
+  const lockPath = indexLockPath(cwd)
+  if (!fs.existsSync(lockPath)) return
+  throw new Error(
+    `git index.lock still exists: ${lockPath}\n` +
+      'Another git process may be running. If it crashed, remove the file and retry.',
+  )
+}
+
+function git(cwd, args, option = {}) {
+  for (let attempt = 1; attempt <= INDEX_LOCK_RETRIES; attempt++) {
+    const result = spawnSync('git', args, {
+      cwd: cwd,
+      encoding: 'utf8',
+      stdio: option.inherit ? ['ignore', 'inherit', 'pipe'] : undefined,
+    })
+    if (!result.status) return result
+
+    const stderr = result.stderr || ''
+    if (!isIndexLockError(stderr) || attempt === INDEX_LOCK_RETRIES) {
+      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 out(cwd, args) {