@itcase/config 1.6.71 → 1.6.73

package/README.md

@@ -17,6 +17,8 @@ npm install --save-dev @itcase/config
   - `createCommitlintReleaseConfig(SCOPES)` — для релизных веток
   - `commitlint/commitizenAdapter.js` — адаптер Commitizen (type → scope → subScope → subject)
 
+- **Smart commit** — CLI `smart-commit` (Cursor Agent → preview → commit)
+
 - **Husky** — общие git-хуки в `husky-hooks/`
   - В git только `.husky/config`; обёртки и `_run.sh` создаёт `itcase-config-husky-install` при `npm i`
 
@@ -83,6 +85,71 @@ npm install --save-dev commitizen @commitlint/cz-commitlint
 { "path": "@itcase/config/commitlint/commitizenAdapter.js" }
 ```
 
+## Smart commit
+
+`smart-commit` — Cursor Agent (`ask`) планирует коммиты по `SCOPES`, печатает сообщения, спрашивает `[y/N]`.
+
+```text
+[yellow pixel banana animation]
+Drafting commit messages… (12s)
+
+Commits:
+  • feat(other): add smart-commit cli
+  • docs(docs): document smart-commit usage
+
+Create 2 commit(s)? [y/N]
+```
+
+Нужны Cursor Agent + логин (`agent login` / `CURSOR_API_KEY`) и `commitlint.config.*` с SCOPES.
+
+В проекте с `@itcase/config` добавьте в `package.json`:
+
+```json
+{
+  "scripts": {
+    "smart-commit": "smart-commit",
+    "smart-commit:dry": "smart-commit --dry-run"
+  }
+}
+```
+
+Запуск:
+
+```bash
+npm run smart-commit:dry
+npm run smart-commit
+make smart-commit-dry   # если есть Makefile
+make smart-commit
+```
+
+В самом `@itcase/config` (разработка пакета):
+
+```bash
+npm run smart-commit:dry
+npm run smart-commit:yes
+make smart-commit-dry
+```
+
+Если `agent` нет в PATH (`command not found`):
+
+```bash
+curl https://cursor.com/install -fsS | bash
+echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
+source ~/.bashrc
+agent --version
+agent login
+```
+
+CLI ставится в `~/.local/bin`. Логин в Cursor IDE этот CLI не авторизует.
+
+Без браузера (CI): `export CURSOR_API_KEY=…` вместо `agent login`.
+
+Обновление CLI: `agent update`.
+
+Пока Agent думает, в терминале крутится pixel-анимация dancing banana + статус `(Ns)` на одной области экрана (`log-update`). Для полного лога: `npm run smart-commit -- --verbose --dry-run`.
+
+> **Важно:** в npm есть одноимённый пакет `smart-commit`. Используйте `npm run smart-commit` из проекта с `@itcase/config` — bin берётся из `node_modules`. `npx smart-commit` без локальной установки может подтянуть чужой пакет; CLI перед запуском проверяет, что выполняется именно `@itcase/config`.
+
 ## Подключение Husky
 
 В git кладите только `.husky/config`. Обёртки хуков и `_run.sh` создаёт `itcase-config-husky-install` при `npm i`. Логика хуков живёт в `@itcase/config/husky-hooks`.

package/commitlint/commitlintCommon.js

@@ -16,7 +16,44 @@ export const commonRules = {
 }
 
 export const promptSubjectDescription =
-  'Write a short, imperative tense description of the change'
+  'Short imperative description in lower-case (no camelCase: use "public dir" not "publicDir")'
+
+export const promptSubjectRules = [
+  'lower-case only (commitlint subject-case)',
+  'no camelCase: write "public dir", not "publicDir"',
+  'imperative mood, no trailing period',
+  'single line — no body or footer',
+]
+
+/**
+ * Splits camelCase/PascalCase words so subject-case lower-case can pass.
+ * @param {string} subject
+ * @returns {string}
+ */
+export function normalizeSubjectCase(subject) {
+  return String(subject || '')
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+    .toLowerCase()
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+/**
+ * Normalizes full conventional commit header for commitlint subject-case.
+ * @param {string} message
+ * @returns {string}
+ */
+export function normalizeCommitSubject(message) {
+  const header = String(message || '')
+    .split('\n')[0]
+    .trim()
+  const match = header.match(/^(\w+)\(([^)]+)\):\s*(.+)$/)
+  if (!match) return header
+
+  const [, type, scope, subject] = match
+  return `${type}(${scope}): ${normalizeSubjectCase(subject)}`
+}
 
 /**
  * Builds flat scope-enum list from SCOPES.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itcase/config",
-  "version": "1.6.71",
+  "version": "1.6.73",
   "author": "ITCase",
   "description": "ITCase Config",
   "engines": {
@@ -8,12 +8,14 @@
   },
   "bin": {
     "itcase-config-husky-hooks": "./husky-hooks/run.js",
-    "itcase-config-husky-install": "./husky-hooks/install-launcher.js"
+    "itcase-config-husky-install": "./husky-hooks/install-launcher.js",
+    "smart-commit": "./smart-commit/cli.js"
   },
   "scripts": {
     "prepare": "husky && node ./husky-hooks/install-launcher.js",
     "postinstall": "node ./husky-hooks/install-launcher.js",
-    "semantic-release": "semantic-release"
+    "semantic-release": "semantic-release",
+    "smart-commit": "node smart-commit/cli.js"
   },
   "type": "module",
   "license": "MIT",
@@ -29,6 +31,7 @@
     "lint-staged-ts",
     "semantic-release",
     "postcss",
+    "smart-commit",
     "svgr",
     "README.md"
   ],
@@ -65,6 +68,7 @@
     "cssnano": "^8.0.6",
     "cssnano-preset-default": "^8.0.6",
     "inquirer": "^14.1.0",
+    "log-update": "^8.0.0",
     "postcss": "^8.5.26",
     "postcss-aspect-ratio-polyfill": "^2.0.0",
     "postcss-clamp": "^4.1.0",

package/smart-commit/cli.js

@@ -0,0 +1,600 @@
+#!/usr/bin/env node
+import { spawn, spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { stdin as input, stdout as output } from 'node:process'
+import readline from 'node:readline/promises'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+import lint from '@commitlint/lint'
+import load from '@commitlint/load'
+import { logUpdateStderr } from 'log-update'
+
+import {
+  buildScopeEnum,
+  normalizeCommitSubject,
+  promptSubjectRules,
+} from '../commitlint/commitlintCommon.js'
+import { getBananaFrame } from './dancing-banana.js'
+
+const PACKAGE_NAME = '@itcase/config'
+const CLI_RELATIVE = 'smart-commit/cli.js'
+
+const MAX_DIFF = 80_000
+const AGENT_TIMEOUT_MS = 120_000
+const AGENT_STEP_MS = 2_500
+const BANANA_FRAME_MS = 100
+const AGENT_WAIT_STEPS = [
+  'Asking Cursor Agent',
+  'Still thinking',
+  'Waiting for response',
+]
+const HELP = `smart-commit [--dry-run] [--yes|-y] [--type t] [--model id] [--verbose]
+
+Cursor Agent → commit messages by SCOPES → [y/N] → git commit
+Run via: npm exec smart-commit (from project with @itcase/config)
+Needs: agent login (or CURSOR_API_KEY) + commitlint.config.* with SCOPES
+`
+const AGENT_MISSING = `Cursor Agent CLI not found — smart-commit cannot run.
+
+  curl https://cursor.com/install -fsS | bash
+  echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
+  source ~/.bashrc
+  agent --version
+  agent login
+
+If agent is still missing, see README.md → Smart commit.
+Or set CURSOR_API_KEY instead of login.
+`
+
+const argv = process.argv.slice(2)
+if (argv.includes('-h') || argv.includes('--help')) {
+  process.stdout.write(HELP)
+  process.exit(0)
+}
+
+main(argv).catch((error) => {
+  process.stderr.write(`${error.message || error}\n`)
+  process.exit(1)
+})
+
+async function main(argv) {
+  const option = parseArgs(argv)
+  const cwd = process.cwd()
+  assertItcaseConfigPackage(cwd)
+  const { scopes, types } = await loadCommitlintConfig(cwd)
+  const files = listFiles(cwd, option)
+  if (!files.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, verbose: option.verbose },
+    (progress) =>
+      askAgent(
+        cwd,
+        option.model,
+        prompt,
+        option.verbose,
+        progress.onAgentActivity,
+      ),
+  )
+  const plans = parsePlan(raw, files)
+  await validateAndNormalizePlans(cwd, plans)
+
+  process.stdout.write('\nCommits:\n')
+  for (const plan of plans) process.stdout.write(`  • ${plan.message}\n`)
+  process.stdout.write('\n')
+
+  if (option.dryRun) {
+    process.stdout.write('Dry run — nothing committed.\n')
+    return
+  }
+  if (!option.yes && !(await confirm(plans.length))) {
+    process.stdout.write('Aborted.\n')
+    return
+  }
+
+  const activePlans = plans
+    .map((plan) => ({
+      ...plan,
+      files: plan.files.filter((file) => fileHasChanges(cwd, file)),
+    }))
+    .filter((plan) => plan.files.length)
+
+  if (!activePlans.length) {
+    process.stdout.write('No changes left to commit (already committed?).\n')
+    return
+  }
+
+  if (activePlans.length !== plans.length) {
+    process.stdout.write(
+      `Skipping ${plans.length - activePlans.length} empty commit(s).\n`,
+    )
+  }
+
+  let created = 0
+  for (const plan of activePlans) {
+    git(cwd, ['add', '--', ...plan.files])
+    const staged = lines(cwd, ['diff', '--cached', '--name-only'])
+    const stagedForPlan = plan.files.filter((file) => staged.includes(file))
+    if (!stagedForPlan.length) {
+      throw new Error(
+        `Nothing staged for commit: ${plan.message}\n` +
+          `Files: ${plan.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}`)
+    created++
+  }
+  process.stdout.write(`Created ${created} commit(s).\n`)
+}
+
+function parseArgs(argv) {
+  const option = {
+    type: '',
+    dryRun: false,
+    model: '',
+    staged: false,
+    verbose: false,
+    yes: false,
+  }
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    if (arg === '--dry-run') option.dryRun = true
+    else if (arg === '--yes' || arg === '-y') option.yes = true
+    else if (arg === '--verbose') option.verbose = true
+    else if (arg === '--staged') option.staged = true
+    else if (arg === '--type') option.type = argv[++i] || ''
+    else if (arg === '--model') option.model = argv[++i] || ''
+    else if (arg.startsWith('--type=')) option.type = arg.slice(7)
+    else if (arg.startsWith('--model=')) option.model = arg.slice(8)
+    else throw new Error(`Unknown argument: ${arg}`)
+  }
+  return option
+}
+
+function assertItcaseConfigPackage(cwd) {
+  const scriptPath = fileURLToPath(import.meta.url)
+
+  if (
+    scriptPath.includes(
+      `${path.sep}itcase-config${path.sep}smart-commit${path.sep}`,
+    )
+  ) {
+    return
+  }
+
+  const configSegment = `${path.sep}@itcase${path.sep}config${path.sep}`
+  if (!scriptPath.includes(configSegment)) {
+    throw wrongPackageError(cwd)
+  }
+
+  const localCli = path.join(
+    cwd,
+    'node_modules',
+    '@itcase',
+    'config',
+    CLI_RELATIVE,
+  )
+  if (!fs.existsSync(localCli)) {
+    throw new Error(
+      `@itcase/config not installed in ${cwd}.\n` +
+        '  npm install --save-dev @itcase/config\n' +
+        'Then run: npm exec smart-commit',
+    )
+  }
+
+  const resolvedSelf = fs.realpathSync(scriptPath)
+  const resolvedLocal = fs.realpathSync(localCli)
+  if (resolvedSelf !== resolvedLocal) {
+    throw wrongPackageError(cwd)
+  }
+
+  const packageJsonPath = path.join(
+    cwd,
+    'node_modules',
+    '@itcase',
+    'config',
+    'package.json',
+  )
+  if (fs.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+    if (packageJson.name !== PACKAGE_NAME) {
+      throw wrongPackageError(cwd)
+    }
+  }
+}
+
+function wrongPackageError(cwd) {
+  return new Error(
+    `Wrong smart-commit — use @itcase/config from ${cwd}, not npm registry package.\n` +
+      '  npm install --save-dev @itcase/config\n' +
+      '  npm exec smart-commit --dry-run\n' +
+      'Avoid: npx smart-commit (may install unrelated package from npm).',
+  )
+}
+
+async function loadCommitlintConfig(cwd) {
+  exportReleaseBranchEnv(cwd)
+
+  const file = [
+    'commitlint.config.mjs',
+    'commitlint.config.js',
+    'commitlint.config.cjs',
+  ]
+    .map((name) => path.join(cwd, name))
+    .find((candidate) => fs.existsSync(candidate))
+  if (!file) throw new Error(`commitlint.config.* not found in ${cwd}`)
+
+  const config = (await import(pathToFileURL(file).href)).default
+  const scopes = config?.SCOPES
+  if (!scopes) {
+    throw new Error(
+      'SCOPES missing — use createCommitlintProjectConfig(SCOPES)',
+    )
+  }
+
+  const types = config.rules?.['type-enum']?.[2]
+  if (!Array.isArray(types) || !types.length) {
+    throw new Error('type-enum missing in commitlint.config.*')
+  }
+
+  return { scopes, types }
+}
+
+function exportReleaseBranchEnv(cwd) {
+  if (process.env.RELEASE_BRANCH === 'true') return
+
+  const branch = out(cwd, ['rev-parse', '--abbrev-ref', 'HEAD'])
+  if (!branch) return
+
+  const releaseBranches = readReleaseBranches(cwd)
+  if (releaseBranches.includes(branch)) {
+    process.env.RELEASE_BRANCH = 'true'
+  }
+}
+
+function readReleaseBranches(cwd) {
+  const configPath = path.join(cwd, '.husky', 'config')
+  if (!fs.existsSync(configPath)) return ['master']
+
+  const text = fs.readFileSync(configPath, 'utf8')
+  const match = text.match(/RELEASE_BRANCHES="([^"]+)"/)
+  if (!match) return ['master']
+
+  return match[1].split(/\s+/).filter(Boolean)
+}
+
+function listFiles(cwd, option) {
+  const staged = lines(cwd, [
+    'diff',
+    '--cached',
+    '--name-only',
+    '--diff-filter=ACDMR',
+  ])
+  if (option.staged || staged.length) return staged
+  return [
+    ...new Set([
+      ...lines(cwd, ['diff', '--name-only', '--diff-filter=ACDMR']),
+      ...lines(cwd, ['ls-files', '--others', '--exclude-standard']),
+    ]),
+  ]
+}
+
+function buildPrompt(scopes, types, files, cwd, type) {
+  let diff = [
+    out(cwd, ['diff', '--cached', '--', ...files]),
+    out(cwd, ['diff', '--', ...files]),
+  ]
+    .filter(Boolean)
+    .join('\n\n')
+  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.
+Return ONLY JSON: {"commits":[{"message":"type(scope): subject","files":["a.ts"]}]}
+Types: ${types.join(', ')}
+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.
+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:
+${diff || '(none)'}
+`
+}
+
+function buildAgentProgressSteps(fileCount) {
+  const fileLabel =
+    fileCount === 1 ? '1 changed file' : `${fileCount} changed files`
+
+  return [
+    `Reading ${fileLabel}`,
+    'Loading commitlint scopes and types',
+    'Analyzing diff',
+    'Grouping changes by scope',
+    'Drafting commit messages',
+  ]
+}
+
+async function withAgentProgress(context, callback) {
+  const earlySteps = buildAgentProgressSteps(context.fileCount)
+  const startedAt = Date.now()
+  let earlyStepIndex = 0
+  let waitStepIndex = 0
+  let phase = 'early'
+  let receivedChars = 0
+  let frameIndex = 0
+
+  const onAgentActivity = (charCount) => {
+    if (charCount > 0) {
+      receivedChars = charCount
+      phase = 'receiving'
+    }
+  }
+
+  const currentLabel = () => {
+    if (phase === 'receiving') {
+      return `Receiving response (${receivedChars} chars)`
+    }
+    if (phase === 'waiting') {
+      return AGENT_WAIT_STEPS[waitStepIndex % AGENT_WAIT_STEPS.length]
+    }
+    return earlySteps[Math.min(earlyStepIndex, earlySteps.length - 1)]
+  }
+
+  const formatText = () => {
+    const elapsed = Math.floor((Date.now() - startedAt) / 1000)
+    return `${currentLabel()}… (${elapsed}s)`
+  }
+
+  if (!process.stderr.isTTY || context.verbose) {
+    process.stderr.write(`${formatText()}\n`)
+    return callback({ onAgentActivity })
+  }
+
+  const render = () => {
+    logUpdateStderr(`${getBananaFrame(frameIndex)}\n${formatText()}`)
+    frameIndex++
+  }
+
+  render()
+  const frameTimer = setInterval(render, BANANA_FRAME_MS)
+  const stepTimer = setInterval(() => {
+    if (phase === 'early') {
+      if (earlyStepIndex < earlySteps.length - 1) {
+        earlyStepIndex++
+      } else {
+        phase = 'waiting'
+      }
+    } else if (phase === 'waiting') {
+      waitStepIndex++
+    }
+  }, AGENT_STEP_MS)
+
+  try {
+    return await callback({ onAgentActivity })
+  } finally {
+    clearInterval(frameTimer)
+    clearInterval(stepTimer)
+    logUpdateStderr.clear()
+  }
+}
+
+function askAgent(cwd, model, prompt, verbose, onAgentActivity) {
+  const cmd = resolveAgent()
+  const args = [
+    '-p',
+    '--mode',
+    'ask',
+    '--output-format',
+    'text',
+    '--trust',
+    '--workspace',
+    cwd,
+  ]
+  if (model) args.push('--model', model)
+  if (process.env.CURSOR_API_KEY)
+    args.push('--api-key', process.env.CURSOR_API_KEY)
+  args.push(prompt)
+
+  if (verbose) process.stderr.write(`Using: ${cmd}\n`)
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, {
+      cwd: cwd,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk
+      if (onAgentActivity) onAgentActivity(stdout.length)
+      if (verbose) process.stderr.write(chunk)
+    })
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk
+      if (verbose) process.stderr.write(chunk)
+    })
+
+    const timeout = setTimeout(() => {
+      child.kill('SIGTERM')
+      reject(
+        new Error(
+          `Cursor Agent timed out after ${AGENT_TIMEOUT_MS / 1000}s. Check agent login / network.`,
+        ),
+      )
+    }, AGENT_TIMEOUT_MS)
+
+    child.on('error', (error) => {
+      clearTimeout(timeout)
+      reject(error)
+    })
+
+    child.on('close', (code) => {
+      clearTimeout(timeout)
+      if (code) {
+        reject(new Error(formatAgentError(stderr, stdout)))
+        return
+      }
+      resolve(stdout.trim())
+    })
+  })
+}
+
+function formatAgentError(stderr, stdout) {
+  const text = (stderr || stdout || AGENT_MISSING).trim()
+  if (/authentication required/i.test(text)) {
+    return `Cursor Agent failed.\n${text}\n\nRun: agent login\nOr set CURSOR_API_KEY.`
+  }
+  return `Cursor Agent failed.\n${text}`
+}
+
+function resolveAgent() {
+  const home = process.env.HOME || ''
+  const candidates = [
+    which('agent'),
+    which('cursor-agent'),
+    `${home}/.local/bin/agent`,
+    `${home}/.local/bin/cursor-agent`,
+    `${home}/Library/Application Support/Cursor/User/globalStorage/anysphere.cursor-agent-worker/agent-cli/.local/bin/cursor-agent`,
+  ]
+  const found = candidates.find(
+    (candidate) => candidate && fs.existsSync(candidate),
+  )
+  if (!found) throw new Error(AGENT_MISSING)
+  return found
+}
+
+function which(name) {
+  const result = spawnSync('which', [name], { encoding: 'utf8' })
+  return result.status === 0 ? result.stdout.trim() : ''
+}
+
+function parsePlan(raw, allowedFiles) {
+  const allowed = new Set(allowedFiles)
+  const body = raw.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1] || raw
+  const start = body.indexOf('{')
+  const end = body.lastIndexOf('}')
+  if (start < 0 || end <= start)
+    throw new Error(`No JSON in Cursor output:\n${raw}`)
+
+  let data
+  try {
+    data = JSON.parse(body.slice(start, end + 1))
+  } catch (error) {
+    throw new Error(`Bad JSON from Cursor:\n${raw}`, { cause: error })
+  }
+
+  const seen = new Set()
+  const plans = []
+  for (const item of data.commits || []) {
+    const message = normalizeCommitMessage(item.message)
+    const files = (item.files || [])
+      .map(String)
+      .filter((file) => allowed.has(file) && !seen.has(file))
+    files.forEach((file) => seen.add(file))
+    if (message && files.length) plans.push({ message, files })
+  }
+
+  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 normalizeCommitMessage(message) {
+  const lines = String(message || '')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .filter((line) => !/^Co-authored-by:/i.test(line))
+    .filter((line) => !/^Made-with:/i.test(line))
+
+  const subject = (lines[0] || '').replace(/\s+Co-authored-by:.*$/i, '').trim()
+  return normalizeCommitSubject(subject)
+}
+
+async function validateAndNormalizePlans(cwd, plans) {
+  const loaded = await load({}, cwd)
+  const lintOptions = {
+    defaultIgnores: loaded.defaultIgnores,
+    ignores: loaded.ignores,
+    parserPreset: loaded.parserPreset,
+  }
+
+  for (const plan of plans) {
+    plan.message = normalizeCommitSubject(plan.message)
+    const report = await lint(plan.message, loaded.rules, lintOptions)
+    if (report.valid) continue
+
+    const errors =
+      report.errors?.map((error) => error.message).join('; ') || 'invalid'
+    throw new Error(
+      `Commit message failed commitlint:\n  ${plan.message}\n  ${errors}\n` +
+        'Use lower-case subject without camelCase (e.g. "public dir" not "publicDir").',
+    )
+  }
+}
+
+function fileHasChanges(cwd, file) {
+  const filePath = path.join(cwd, file)
+  if (!fs.existsSync(filePath)) return false
+
+  const tracked =
+    spawnSync('git', ['ls-files', '--error-unmatch', '--', file], {
+      cwd: cwd,
+      encoding: 'utf8',
+    }).status === 0
+
+  if (!tracked) return true
+
+  return (
+    spawnSync('git', ['diff', '--quiet', 'HEAD', '--', file], {
+      cwd: cwd,
+      encoding: 'utf8',
+    }).status === 1
+  )
+}
+
+async function confirm(count) {
+  if (!input.isTTY) throw new Error('No TTY — use --yes or --dry-run')
+  const rl = readline.createInterface({ input, output })
+  try {
+    const answer = await rl.question(`Create ${count} commit(s)? [y/N] `)
+    return /^y(es)?$/i.test(answer.trim())
+  } finally {
+    rl.close()
+  }
+}
+
+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 out(cwd, args) {
+  return (git(cwd, args).stdout || '').trim()
+}
+
+function lines(cwd, args) {
+  return out(cwd, args).split('\n').filter(Boolean)
+}

package/smart-commit/dancing-banana.js

@@ -0,0 +1,267 @@
+// Extracted from the classic dancing banana GIF (Trym Stene, 1999).
+// 8 frames, 24×25px — fixed canvas, solid 2-space blocks.
+
+const RESET = '\x1b[0m'
+const FRAME_WIDTH = 24
+const FRAME_HEIGHT = 25
+
+const COLORS = {
+  B: 236,
+  d: 136,
+  E: 255,
+  R: 196,
+  W: 255,
+  Y: 226,
+  y: 214,
+}
+
+const FRAMES = [
+  [
+    '........................',
+    '........................',
+    '........................',
+    '........................',
+    '............BB..........',
+    '............BBB.........',
+    '............dYB.........',
+    '............YYYB........',
+    '............YYYBB.......',
+    '..........BBBBYyB.......',
+    '.........BEBEEByy.......',
+    '.........BEBEEByy.......',
+    '..........BBBBYBy.......',
+    '...........BYYBBy.......',
+    '............RRRyy.......',
+    '............RBByy.......',
+    '.......BB..BYYYyB.BB....',
+    '......BEB.BBYYYyBBBEB...',
+    '......BEE.BYYYyBBBEEB...',
+    '.......BBBBYyyyBWBBB....',
+    '........BBYYyyBBWB......',
+    '.......BBBBBBBBBB.......',
+    '.......BB......BB.......',
+    '......BWWBB..BBWWB......',
+    '.......BBBB..BBBB.......',
+  ],
+  [
+    '........................',
+    '........................',
+    '........................',
+    '............BB..........',
+    '............ddB.........',
+    '............dYB.........',
+    '............YYYBB.......',
+    '............YYYyB.......',
+    '..........BBBBYyB.......',
+    '.........BBBWWByy.......',
+    '.........BEBEEByy.......',
+    '...........BYYBBy.......',
+    '...........BBBRBy.......',
+    '............RRRyy.......',
+    '...........BBYYyy.......',
+    '.....BB....BYYYyy...BB..',
+    '....BEEB..BBYYYyB..BEEB.',
+    '....BEEB..BYYYyBB..BEEB.',
+    '.....BBBBBBYYyyBB.BBBB..',
+    '.........BYYyyB.........',
+    '.........BByBBB.........',
+    '........B...............',
+    '.......BB......BB.......',
+    '......BWWBB..BBWWB......',
+    '.......BBB....BBB.......',
+  ],
+  [
+    '............B...........',
+    '...........BdB..........',
+    '...........BdBB.........',
+    '..........BBYyB.........',
+    '..........BYYYy.........',
+    '.BBB.....BBBBBB......BB.',
+    '.WWW.....WBWWBWB....BWWB',
+    '.WWB.....WWWWWWB....BBWB',
+    '.BBB.....BBBBBBB....BBB.',
+    '.....BB..BBBBBRB.BBB....',
+    '.......BBBRRRRBB.B......',
+    '.........BYBBYYB........',
+    '.........BYYYYyB........',
+    '.........BYYYYyB........',
+    '.........BYYYYy.........',
+    '.........BYYYyy.........',
+    '.........BYYyyB.........',
+    '.........BYYyBB.........',
+    '.........BBBBB..........',
+    '..........B..B..........',
+    '.........BB..BB.........',
+    '.........B....B.........',
+    '.......BBBB..BBBB.......',
+    '......BWWWB..BWWWB......',
+    '......BBB......BBB......',
+  ],
+  [
+    '........................',
+    '..........BB............',
+    '.........Bdd............',
+    '.........Bdd............',
+    '.........yYYB...........',
+    '........ByYYB...........',
+    '........BBBYBB..........',
+    '.......BBWWBWWB.........',
+    '.......BBBWBBWB.........',
+    '.WWB...ByBBYBB...BWW....',
+    '.EEE...BBYYYYB...EEE....',
+    '.BBB...ByRRRRB...BBB....',
+    '....B..ByBRRBB..B.......',
+    '....BB.ByYBBYB.BB.......',
+    '.......BBYYYYB..........',
+    '........BYYYYB..........',
+    '........ByYYYB..........',
+    '.........yyYYB..........',
+    '.........ByyYB..........',
+    '.........BBBBB..........',
+    '.........B...B..........',
+    '..............B.........',
+    '.......BB.....BBB.......',
+    '......BWWBB..BBWWB......',
+    '......BBBB....BBBB......',
+  ],
+  [
+    '........................',
+    '........................',
+    '........................',
+    '........................',
+    '..........BB............',
+    '.........BBB............',
+    '.........BYd............',
+    '........BYYY............',
+    '.......BBYYY............',
+    '.......ByYBBBB..........',
+    '.......yyBEEBEB.........',
+    '.......yyBEEBEB.........',
+    '.......yBYBBBB..........',
+    '.......yBBYYB...........',
+    '.......yyRRR............',
+    '.......yyBBR............',
+    '....BB.ByYYYB..BB.......',
+    '...BEBBByYYYBB.BEB......',
+    '...BEEBBByYYYB.EEB......',
+    '....BBBWByyyYBBBB.......',
+    '......BWBByyYYBB........',
+    '.......BBBBBBBBBB.......',
+    '.......BB......BB.......',
+    '......BWWBB..BBWWB......',
+    '.......BBBB..BBBB.......',
+  ],
+  [
+    '........................',
+    '........................',
+    '........................',
+    '..........BB............',
+    '.........Bdd............',
+    '.........BYd............',
+    '.......BBYYY............',
+    '.......ByYYY............',
+    '.......ByYBBBB..........',
+    '.......yyBWWBBB.........',
+    '.......yyBEEBEB.........',
+    '.......yBBYYB...........',
+    '.......yBRBBB...........',
+    '.......yyRRR............',
+    '.......yyYYBB...........',
+    '..BB...yyYYYB....BB.....',
+    '.BEEB..ByYYYBB..BEEB....',
+    '.BEEB..BByYYYB..BEEB....',
+    '..BBBB.BByyYYBBBBBB.....',
+    '.........ByyYYB.........',
+    '.........BBByBB.........',
+    '...............B........',
+    '.......BB......BB.......',
+    '......BWWBB..BBWWB......',
+    '.......BBB....BBB.......',
+  ],
+  [
+    '...........B............',
+    '..........BdB...........',
+    '.........BBdB...........',
+    '.........ByYBB..........',
+    '.........yYYYB..........',
+    '.BB......BBBBBB.....BBB.',
+    'BWWB....BWBWWBW.....WWW.',
+    'BWBB....BWWWWWW.....BWW.',
+    '.BBB....BBBBBBB.....BBB.',
+    '....BBB.BRBBBBB..BB.....',
+    '......B.BBRRRRBBB.......',
+    '........BYYBBYB.........',
+    '........ByYYYYB.........',
+    '........ByYYYYB.........',
+    '.........yYYYYB.........',
+    '.........yyYYYB.........',
+    '.........ByyYYB.........',
+    '.........BByYYB.........',
+    '..........BBBBB.........',
+    '..........B..B..........',
+    '.........BB..BB.........',
+    '.........B....B.........',
+    '.......BBBB..BBBB.......',
+    '......BWWWB..BWWWB......',
+    '......BBB......BBB......',
+  ],
+  [
+    '........................',
+    '............BB..........',
+    '............ddB.........',
+    '............ddB.........',
+    '...........BYYy.........',
+    '...........BYYyB........',
+    '..........BBYBBB........',
+    '.........BWWBWWBB.......',
+    '.........BWBBWBBB.......',
+    '....WWB...BBYBByB...BWW.',
+    '....EEE...BYYYYBB...EEE.',
+    '....BBB...BRRRRyB...BBB.',
+    '.......B..BBRRByB..B....',
+    '.......BB.BYBBYyB.BB....',
+    '..........BYYYYBB.......',
+    '..........BYYYYB........',
+    '..........BYYYyB........',
+    '..........BYYyy.........',
+    '..........BYyyB.........',
+    '..........BBBBB.........',
+    '..........B...B.........',
+    '.........B..............',
+    '.......BBB.....BB.......',
+    '......BWWBB..BBWWB......',
+    '......BBBB....BBBB......',
+  ],
+]
+
+function renderRow(row) {
+  const padded = row.padEnd(FRAME_WIDTH, '.').slice(0, FRAME_WIDTH)
+  let line = ''
+  for (const cell of padded) {
+    if (cell === '.') {
+      line += '  '
+      continue
+    }
+    const code = COLORS[cell]
+    if (code === undefined) {
+      line += '  '
+      continue
+    }
+    const bold = cell === 'E' ? '\x1b[1m' : ''
+    line += `${bold}\x1b[48;5;${code}m  ${RESET}`
+  }
+  return line
+}
+
+export function getBananaFrame(index) {
+  const frame = FRAMES[index % FRAMES.length]
+  const lines = frame.map(renderRow)
+  while (lines.length < FRAME_HEIGHT) {
+    lines.push(' '.repeat(FRAME_WIDTH * 2))
+  }
+  return lines.slice(0, FRAME_HEIGHT).join('\n')
+}
+
+export function getBananaFrameCount() {
+  return FRAMES.length
+}

package/smart-commit/scripts/extract-banana.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""Extract dancing-banana.js frames from the classic GIF."""
+
+from __future__ import annotations
+
+from collections import deque
+from pathlib import Path
+
+from PIL import Image
+
+OUT = Path(__file__).resolve().parents[1] / 'dancing-banana.js'
+BG = (255, 255, 255)
+TARGET_W = 24
+
+CHAR = {
+    (0, 0, 0): 'B',
+    (255, 255, 0): 'Y',
+    (206, 206, 0): 'y',
+    (156, 156, 0): 'd',
+    (255, 0, 0): 'R',
+    (255, 255, 255): 'W',
+}
+
+JS_TEMPLATE = '''\
+// Extracted from the classic dancing banana GIF (Trym Stene, 1999).
+// 8 frames, {w}×{h}px — fixed canvas, solid 2-space blocks.
+
+const RESET = '\\x1b[0m'
+const FRAME_WIDTH = {w}
+const FRAME_HEIGHT = {h}
+
+const COLORS = {{
+  B: 236,
+  R: 196,
+  W: 255,
+  E: 255,
+  Y: 226,
+  d: 136,
+  y: 214,
+}}
+
+const FRAMES = [
+{frames}
+]
+
+function renderRow(row) {{
+  const padded = row.padEnd(FRAME_WIDTH, '.').slice(0, FRAME_WIDTH)
+  let line = ''
+  for (const cell of padded) {{
+    if (cell === '.') {{
+      line += '  '
+      continue
+    }}
+    const code = COLORS[cell]
+    if (code === undefined) {{
+      line += '  '
+      continue
+    }}
+    const bold = cell === 'E' ? '\\x1b[1m' : ''
+    line += `${{bold}}\\x1b[48;5;${{code}}m  ${{RESET}}`
+  }}
+  return line
+}}
+
+export function getBananaFrame(index) {{
+  const frame = FRAMES[index % FRAMES.length]
+  const lines = frame.map(renderRow)
+  while (lines.length < FRAME_HEIGHT) {{
+    lines.push(' '.repeat(FRAME_WIDTH * 2))
+  }}
+  return lines.slice(0, FRAME_HEIGHT).join('\\n')
+}}
+
+export function getBananaFrameCount() {{
+  return FRAMES.length
+}}
+'''
+
+
+def remove_bg(frame: Image.Image) -> Image.Image:
+    px = frame.load()
+    w, h = frame.size
+    seen = [[False] * w for _ in range(h)]
+    q: deque[tuple[int, int]] = deque()
+
+    for x in range(w):
+        for y in (0, h - 1):
+            if px[x, y][:3] == BG:
+                q.append((x, y))
+                seen[y][x] = True
+
+    for y in range(h):
+        for x in (0, w - 1):
+            if not seen[y][x] and px[x, y][:3] == BG:
+                q.append((x, y))
+                seen[y][x] = True
+
+    while q:
+        x, y = q.popleft()
+        px[x, y] = (255, 255, 255, 0)
+        for nx, ny in ((x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)):
+            if 0 <= nx < w and 0 <= ny < h and not seen[ny][nx] and px[nx, ny][:3] == BG:
+                seen[ny][nx] = True
+                q.append((nx, ny))
+
+    return frame
+
+
+def color_key(px: tuple[int, int, int, int]) -> str:
+    if px[3] < 128:
+        return '.'
+    rgb = px[:3]
+    if rgb in CHAR:
+        return CHAR[rgb]
+    nearest = min(CHAR, key=lambda c: sum((a - b) ** 2 for a, b in zip(rgb, c)))
+    return CHAR[nearest]
+
+
+def trim_frames(frames: list[list[str]]) -> tuple[int, int, list[list[str]]]:
+    h = len(frames[0])
+    w = len(frames[0][0])
+
+    while h and all(frames[f][0][c] == '.' for f in range(len(frames)) for c in range(w)):
+        for f in range(len(frames)):
+            frames[f].pop(0)
+        h -= 1
+
+    while h and all(frames[f][h - 1][c] == '.' for f in range(len(frames)) for c in range(w)):
+        for f in range(len(frames)):
+            frames[f].pop()
+        h -= 1
+
+    while w and all(frames[f][r][0] == '.' for f in range(len(frames)) for r in range(h)):
+        for f in range(len(frames)):
+            frames[f] = [row[1:] for row in frames[f]]
+        w -= 1
+
+    while w and all(frames[f][r][w - 1] == '.' for f in range(len(frames)) for r in range(h)):
+        for f in range(len(frames)):
+            frames[f] = [row[:-1] for row in frames[f]]
+        w -= 1
+
+    return w, h, frames
+
+
+def content_bounds(frames: list[list[str]]) -> tuple[int, int, int, int]:
+    top = len(frames[0])
+    bottom = 0
+    left = len(frames[0][0])
+    right = 0
+
+    for frame in frames:
+        for y, row in enumerate(frame):
+            for x, cell in enumerate(row):
+                if cell != '.':
+                    top = min(top, y)
+                    bottom = max(bottom, y)
+                    left = min(left, x)
+                    right = max(right, x)
+
+    return top, bottom, left, right
+
+
+def normalize_canvas(frames: list[list[str]]) -> tuple[int, int, list[list[str]]]:
+    top, bottom, left, right = content_bounds(frames)
+    canvas_h = bottom - top + 1
+    canvas_w = right - left + 1
+
+    normalized: list[list[str]] = []
+    for frame in frames:
+        rows = [row[left : right + 1] for row in frame[top : bottom + 1]]
+        normalized.append([row.ljust(canvas_w, '.')[:canvas_w] for row in rows])
+
+    return canvas_w, canvas_h, normalized
+
+
+def enhance_eyes(frames: list[list[str]]) -> list[list[str]]:
+    h = len(frames[0])
+    w = len(frames[0][0])
+    out: list[list[list[str]]] = [[list(row) for row in frame] for frame in frames]
+
+    for grid in out:
+        for y in range(h):
+            for x in range(w):
+                if grid[y][x] != 'W':
+                    continue
+                if y < int(h * 0.42) or y > int(h * 0.75):
+                    continue
+                neighbors = []
+                for nx, ny in ((x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)):
+                    if 0 <= nx < w and 0 <= ny < h:
+                        neighbors.append(grid[ny][nx])
+                if any(n in 'YyBR' for n in neighbors):
+                    grid[y][x] = 'E'
+
+    return [[''.join(row) for row in grid] for grid in out]
+
+
+def main() -> None:
+    gif_path = Path(
+        '/Users/Arkasha/.cursor/projects/Volumes-Work-ITCase-itcase-ui/assets/'
+        'dancing-banana-gif-809950cd-831b-4c1e-8547-2d3612956da9.gif',
+    )
+    img = Image.open(gif_path)
+
+    minx, miny, maxx, maxy = 9999, 9999, 0, 0
+    frames_raw: list[Image.Image] = []
+
+    for i in range(img.n_frames):
+        img.seek(i)
+        frame = remove_bg(img.convert('RGBA'))
+        frames_raw.append(frame)
+        fw, fh = frame.size
+        for y in range(fh):
+            for x in range(fw):
+                if frame.getpixel((x, y))[3] >= 128:
+                    minx = min(minx, x)
+                    miny = min(miny, y)
+                    maxx = max(maxx, x)
+                    maxy = max(maxy, y)
+
+    crop_h = maxy - miny + 1
+    target_h = max(8, round(crop_h * TARGET_W / (maxx - minx + 1)))
+
+    frames: list[list[str]] = []
+    for frame in frames_raw:
+        cropped = frame.crop((minx, miny, maxx + 1, maxy + 1))
+        small = cropped.resize((TARGET_W, target_h), Image.NEAREST)
+        rows = []
+        for y in range(target_h):
+            rows.append(''.join(color_key(small.getpixel((x, y))) for x in range(TARGET_W)))
+        frames.append(rows)
+
+    w, h, frames = trim_frames(frames)
+    w, h, frames = normalize_canvas(frames)
+    frames = enhance_eyes(frames)
+
+    frame_blocks = []
+    for frame in frames:
+        frame_blocks.append('  [')
+        for row in frame:
+            frame_blocks.append(f"    '{row}',")
+        frame_blocks.append('  ],')
+
+    OUT.write_text(
+        JS_TEMPLATE.format(
+            w=w,
+            h=h,
+            frames='\n'.join(frame_blocks),
+        ),
+    )
+
+
+if __name__ == '__main__':
+    main()