@itcase/config 1.6.77 → 1.6.78

package/package.json

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

package/smart-commit/cli.js

@@ -71,16 +71,16 @@ 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 prompt = buildPrompt(scopes, types, changedFiles, cwd, option.type)
   const raw = await withAgentProgress(
     {
-      fileCount: files.length,
+      fileCount: changedFiles.length,
       sprite: pickSprite(option.sprite),
       verbose: option.verbose,
     },
@@ -93,7 +93,8 @@ async function main(argv) {
         progress.onAgentActivity,
       ),
   )
-  const plans = parsePlan(raw, files)
+  let plans = parsePlan(raw, changedFiles)
+  plans = assignOmittedFiles(plans, changedFiles)
   await validateAndNormalizePlans(cwd, plans)
 
   process.stdout.write('\nCommits:\n')
@@ -131,21 +132,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 +160,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,15 +315,17 @@ 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']),
     ]),
@@ -322,10 +333,14 @@ function listFiles(cwd, option) {
 }
 
 function buildPrompt(scopes, types, files, cwd, type) {
-  let diff = [
-    out(cwd, ['diff', '--cached', '--', ...files]),
-    out(cwd, ['diff', '--', ...files]),
-  ]
+  const statusByFile = new Map(
+    lines(cwd, ['status', '--short', '--porcelain', '--', ...files]).map(
+      (line) => [line.slice(3), line.slice(0, 2).trim()],
+    ),
+  )
+
+  let diff = files
+    .map((file) => buildFileDiff(cwd, file))
     .filter(Boolean)
     .join('\n\n')
   if (diff.length > MAX_DIFF) diff = `${diff.slice(0, MAX_DIFF)}\n…truncated`
@@ -337,11 +352,17 @@ 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 (??).
 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')}
+${files
+  .map((file) => {
+    const status =
+      statusByFile.get(file) || (isUntracked(cwd, file) ? '??' : ' M')
+    return `- ${file} (${status})`
+  })
+  .join('\n')}
 status:
 ${out(cwd, ['status', '--short', '--', ...files]) || '(empty)'}
 diff:
@@ -349,6 +370,31 @@ ${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])
+    )
+  }
+
+  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)`
+  }
+
+  return [
+    out(cwd, ['diff', '--cached', '--', file]),
+    out(cwd, ['diff', '--', file]),
+  ]
+    .filter(Boolean)
+    .join('\n')
+}
+
 function buildAgentProgressSteps(fileCount) {
   const fileLabel =
     fileCount === 1 ? '1 changed file' : `${fileCount} changed files`
@@ -555,12 +601,60 @@ 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 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 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 +689,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
+  )
+}
 
-  if (!tracked) return true
+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 fs.existsSync(filePath)
+  if (!fs.existsSync(filePath)) return true
 
   return (
     spawnSync('git', ['diff', '--quiet', 'HEAD', '--', file], {
@@ -615,6 +717,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 })