@itcase/config 1.7.23 → 1.7.25

package/package.json

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

package/smart-commit/cli.js

@@ -202,28 +202,46 @@ async function main(argv) {
       continue
     }
 
+    const ignoredFiles = gitIgnoredFiles(cwd, planFiles)
+    const filesToStage = planFiles.filter(
+      (file) => !ignoredFiles.includes(file),
+    )
+    process.stdout.write(`\n${paint('1;36', step)} ${plan.message}\n`)
+    if (ignoredFiles.length) {
+      process.stdout.write(
+        `${dim(`      skipped (gitignore): ${ignoredFiles.join(', ')}`)}\n`,
+      )
+    }
+    if (!filesToStage.length) continue
+
     const startedAt = Date.now()
     const fileLabel =
-      planFiles.length === 1 ? '1 file' : `${planFiles.length} files`
-    process.stdout.write(`\n${paint('1;36', step)} ${plan.message}\n`)
+      filesToStage.length === 1 ? '1 file' : `${filesToStage.length} files`
     process.stdout.write(`${dim(`      staging ${fileLabel}…`)}\n`)
 
     // Drop leftover index entries so only this plan's files are committed.
     git(cwd, ['reset', '-q', 'HEAD'])
-    stageFiles(cwd, planFiles)
+    const skippedOnStage = stageFiles(cwd, filesToStage)
     const staged = lines(cwd, ['diff', '--cached', '--name-only'])
-    const stagedForPlan = planFiles.filter((file) => staged.includes(file))
+    const stagedForPlan = filesToStage.filter((file) => staged.includes(file))
     if (!stagedForPlan.length) {
+      const skipped = new Set(skippedOnStage)
+      // Ignored paths were not staged on purpose. Stop this commit and keep
+      // going — one ignored directory must not drop the rest of the run.
+      if (filesToStage.every((file) => skipped.has(file))) {
+        process.stdout.write(`${dim(`      skip ignored: ${plan.message}`)}\n`)
+        continue
+      }
       throw new Error(
         `Nothing staged for commit: ${plan.message}\n` +
-          `Files: ${planFiles.join(', ')}`,
+          `Files: ${filesToStage.join(', ')}`,
       )
     }
 
     const commitLabel = option.noVerify
       ? 'git commit --no-verify'
       : 'git commit'
-    const hookLocks = siblingLocksForFiles(planFiles)
+    const hookLocks = siblingLocksForFiles(filesToStage)
     const dirtyLocksBefore = new Set(
       hookLocks.filter((file) => fileHasChanges(cwd, file)),
     )
@@ -233,7 +251,7 @@ async function main(argv) {
       // equivalent flag — the hook simply does not run.
       if (option.noVerify) commitArgs.push('--no-verify')
       await gitCommitWithProgress(cwd, commitArgs, commitLabel)
-      const included = includeHookLockfiles(cwd, planFiles, dirtyLocksBefore)
+      const included = includeHookLockfiles(cwd, filesToStage, dirtyLocksBefore)
       if (included.length) {
         process.stdout.write(
           `${dim(`      hook updated ${included.join(', ')}, added to commit`)}\n`,
@@ -1534,6 +1552,101 @@ function isOnDisk(cwd, file) {
   return fs.existsSync(path.join(cwd, file))
 }
 
+function gitIgnoredFiles(cwd, files) {
+  if (!files.length) return []
+
+  // Without --no-index, check-ignore hides tracked files that match
+  // gitignore. Those still stage, unless a parent directory is ignored:
+  // `git add` then exits 1 and names the directory, not the file.
+  const direct = pathsIgnoredByGit(cwd, files)
+  const underIgnoredDirectory = filesUnderIgnoredDirectory(cwd, files)
+  return [...new Set([...direct, ...underIgnoredDirectory])]
+}
+
+function pathsIgnoredByGit(cwd, paths, option = {}) {
+  if (!paths.length) return []
+
+  const args = ['check-ignore', '-z', '--stdin']
+  if (option.noIndex) args.push('--no-index')
+  const result = spawnSync('git', args, {
+    maxBuffer: GIT_MAX_BUFFER,
+    cwd: cwd,
+    encoding: 'utf8',
+    input: `${paths.join('\0')}\0`,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  })
+  // 0 — at least one path is ignored, 1 — none. Any other status is a
+  // fatal; treat it as "nothing ignored" and let git add surface it.
+  if (result.status !== 0) return []
+
+  const ignored = new Set(
+    String(result.stdout || '')
+      .split('\0')
+      .filter(Boolean),
+  )
+  return paths.filter((file) => ignored.has(file))
+}
+
+function ancestorDirectories(file) {
+  const ancestors = []
+  let directory = path.posix.dirname(file)
+  while (directory && directory !== '.') {
+    ancestors.push(directory)
+    directory = path.posix.dirname(directory)
+  }
+  return ancestors
+}
+
+function filesUnderIgnoredDirectory(cwd, files) {
+  const ancestorsByFile = new Map()
+  const uniqueAncestors = []
+  const seen = new Set()
+  for (const file of files) {
+    const ancestors = ancestorDirectories(file)
+    ancestorsByFile.set(file, ancestors)
+    for (const ancestor of ancestors) {
+      if (seen.has(ancestor)) continue
+      seen.add(ancestor)
+      uniqueAncestors.push(ancestor)
+    }
+  }
+
+  const ignoredAncestors = new Set(
+    pathsIgnoredByGit(cwd, uniqueAncestors, { noIndex: true }),
+  )
+  if (!ignoredAncestors.size) return []
+
+  return files.filter((file) =>
+    ancestorsByFile
+      .get(file)
+      .some((ancestor) => ignoredAncestors.has(ancestor)),
+  )
+}
+
+function pathMatchesIgnored(file, ignoredPaths) {
+  return ignoredPaths.some(
+    (ignored) => file === ignored || file.startsWith(`${ignored}/`),
+  )
+}
+
+function ignoredPathsFromGitAdd(stderr) {
+  const header =
+    'The following paths are ignored by one of your .gitignore files:'
+  const start = String(stderr || '').indexOf(header)
+  if (start < 0) return []
+
+  const paths = []
+  for (const line of String(stderr)
+    .slice(start + header.length)
+    .split('\n')) {
+    const trimmed = line.trim().replace(/\/+$/, '')
+    if (!trimmed) continue
+    if (trimmed.startsWith('hint:')) break
+    paths.push(trimmed)
+  }
+  return paths
+}
+
 function isTracked(cwd, file) {
   return gitOk(cwd, ['ls-files', '--error-unmatch', '--', file])
 }
@@ -1600,11 +1713,21 @@ function includeHookLockfiles(cwd, planFiles, dirtyBefore) {
 }
 
 function stageFiles(cwd, files) {
-  if (!files.length) return
+  if (!files.length) return []
+
+  // `git add -- path/inside/ignored-dir` exits 1 and names the directory,
+  // after it has already updated the index. Drop those paths first. If git
+  // add still reports an ignored directory, take those paths back out and
+  // keep the rest of the batch. Tracked files that match gitignore but do
+  // not sit inside an ignored directory still stage.
+  const ignored = new Set(gitIgnoredFiles(cwd, files))
+  const stageableFiles = files.filter((file) => !ignored.has(file))
+  const skipped = [...ignored]
+  if (!stageableFiles.length) return skipped
 
   const existing = []
   const removed = []
-  for (const file of files) {
+  for (const file of stageableFiles) {
     if (isOnDisk(cwd, file)) existing.push(file)
     else removed.push(file)
   }
@@ -1612,11 +1735,33 @@ 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.
   forEachBatch(existing, (batch) => {
-    git(cwd, ['add', '-A', '--', ...batch])
+    const result = git(cwd, ['add', '-A', '--', ...batch], {
+      allowIgnored: true,
+    })
+    if (!result.status) return
+
+    const ignoredPaths = ignoredPathsFromGitAdd(result.stderr || '')
+    const blocked = batch.filter((file) =>
+      pathMatchesIgnored(file, ignoredPaths),
+    )
+    if (!blocked.length) {
+      throw new Error(
+        (result.stderr || '').trim() || `git add -A -- ${batch.join(' ')}`,
+      )
+    }
+
+    // git add writes the index before returning 1, including tracked files
+    // under the ignored directory. Take those back out of this commit.
+    git(cwd, ['reset', '-q', 'HEAD', '--', ...blocked])
+    skipped.push(...blocked)
+    process.stdout.write(
+      `${dim(`      skipped (gitignore): ${blocked.join(', ')}`)}\n`,
+    )
   })
   forEachBatch(removed, (batch) => {
     git(cwd, ['rm', '--ignore-unmatch', '-q', '--', ...batch])
   })
+  return skipped
 }
 
 async function confirm(count) {
@@ -1861,6 +2006,9 @@ function git(cwd, args, option = {}) {
 
     const stderr = result.stderr || ''
     if (!retryIndexLock(cwd, attempt, stderr)) {
+      if (option.allowIgnored && ignoredPathsFromGitAdd(stderr).length) {
+        return result
+      }
       if (option.inherit && stderr) process.stderr.write(stderr)
       throw new Error(stderr.trim() || `git ${args.join(' ')}`)
     }