@itcase/config 1.6.79 → 1.6.81

package/README.md

@@ -90,8 +90,10 @@ npm install --save-dev commitizen @commitlint/cz-commitlint
 `smart-commit` — Cursor Agent (`ask`) планирует коммиты по `SCOPES`, печатает сообщения, спрашивает `[y/N]`. Перед коммитом ждёт и снимает устаревший `.git/index.lock`, если его никто не держит. Lockfile (`package-lock.json` и аналоги) всегда кладётся в тот же коммит, что и соседний `package.json`; при одном только bump deps агент не вызывается.
 
 ```text
-[yellow pixel banana animation]
+[random pixel animation]
 Drafting commit messages… (12s)
+Agent started (Composer)
+Reading src/foo.ts
 
 Commits:
   • feat(other): add smart-commit cli
@@ -146,7 +148,7 @@ CLI ставится в `~/.local/bin`. Логин в Cursor IDE этот CLI н
 
 Обновление CLI: `agent update`.
 
-Пока Agent думает, в терминале крутится pixel-анимация (случайно nyan cat или dancing banana) + статус `(Ns)` на одной области экрана (`log-update`). Принудительно: `--cat` / `--banana`. Для полного лога: `npm run smart-commit -- --verbose --dry-run`.
+Пока Agent думает, в терминале крутится pixel-анимация (случайно nyan cat, dancing banana, упячка или Pac-Man) + статус `(Ns)`, а под ними живой лог агента (`log-update`). Пока процесс агента жив, CLI его не убивает по таймауту. Принудительно: `--cat` / `--banana` / `--upyachka` / `--pacman`. Для полного лога: `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`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itcase/config",
-  "version": "1.6.79",
+  "version": "1.6.81",
   "author": "ITCase",
   "description": "ITCase Config",
   "engines": {
@@ -63,23 +63,23 @@
     "@svgr/plugin-jsx": "^8.1.0",
     "@svgr/plugin-svgo": "^8.1.0",
     "@svgr/webpack": "^8.1.0",
-    "autoprefixer": "^10.5.4",
+    "autoprefixer": "^10.5.5",
     "chokidar-cli": "^3.0.0",
     "commitizen": "^4.3.2",
     "conventional-changelog-conventionalcommits": "9.3.1",
-    "cssnano": "^9.0.2",
-    "cssnano-preset-default": "^9.0.2",
-    "inquirer": "^14.2.0",
+    "cssnano": "^9.0.4",
+    "cssnano-preset-default": "^9.0.4",
+    "inquirer": "^14.2.2",
     "log-update": "^8.0.0",
-    "postcss": "^8.5.26",
+    "postcss": "^8.5.28",
     "postcss-aspect-ratio-polyfill": "^2.0.0",
     "postcss-clamp": "^4.1.0",
-    "postcss-cli": "^11.0.1",
+    "postcss-cli": "^12.0.0",
     "postcss-color-hsla-fallback": "^1.0.0",
     "postcss-combine-duplicated-selectors": "^10.0.3",
     "postcss-convert-unit": "^0.1.3",
     "postcss-dark-theme-class": "^2.0.0",
-    "postcss-discard-duplicates": "^9.0.1",
+    "postcss-discard-duplicates": "^9.0.2",
     "postcss-each": "^1.1.0",
     "postcss-easings": "^4.0.0",
     "postcss-extend-rule": "^4.0.0",
@@ -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.1",
+    "postcss-preset-env": "^11.5.2",
     "postcss-pxtorem": "^6.1.0",
     "postcss-sort-media-queries": "^6.7.1",
     "postcss-unit": "^0.0.3",
@@ -109,17 +109,17 @@
     "rollup-plugin-peer-deps-external": "^2.2.4",
     "rollup-preserve-directives": "^1.1.3",
     "semantic-release": "^25.0.9",
-    "semantic-release-lerna": "^3.6.3"
+    "semantic-release-lerna": "^3.6.4"
   },
   "devDependencies": {
-    "@itcase/lint": "^1.1.122",
+    "@itcase/lint": "^1.1.123",
     "eslint": "9.39.2",
     "husky": "^9.1.7",
-    "inquirer": "^14.2.0",
-    "lint-staged": "^17.4.1",
+    "inquirer": "^14.2.2",
+    "lint-staged": "^17.5.0",
     "prettier": "^3.9.6",
-    "storybook": "^10.5.10",
-    "stylelint": "^17.14.1",
+    "storybook": "^10.6.0",
+    "stylelint": "^17.15.0",
     "typescript": "^6.0.3"
   }
 }

package/smart-commit/cli.js

@@ -17,6 +17,8 @@ import {
 } from '../commitlint/commitlintCommon.js'
 import { getBananaFrame } from './dancing-banana.js'
 import { getNyanFrame } from './nyan-cat.js'
+import { getPacmanFrame } from './pacman.js'
+import { getUpyachkaFrame } from './upyachka.js'
 
 const PACKAGE_NAME = '@itcase/config'
 const CLI_RELATIVE = 'smart-commit/cli.js'
@@ -30,10 +32,14 @@ const LOCKFILE_NAMES = new Set([
   'bun.lock',
   'bun.lockb',
 ])
-const AGENT_TIMEOUT_MS = 120_000
 const AGENT_STEP_MS = 2_500
+const AGENT_STILL_WORKING_S = 120
+const AGENT_LOG_ROWS = 8
+const AGENT_LOG_MAX = 160
 const NYAN_FRAME_MS = 90
 const BANANA_FRAME_MS = 100
+const PACMAN_FRAME_MS = 120
+const UPYACHKA_FRAME_MS = 100
 const INDEX_LOCK_RETRIES = 8
 const INDEX_LOCK_WAIT_MS = 250
 const STALE_LOCK_MS = 1500
@@ -43,13 +49,14 @@ const AGENT_WAIT_STEPS = [
   'Waiting for response',
 ]
 const HELP = `smart-commit [--dry-run] [--yes|-y] [--type t] [--model id] [--verbose]
-             [--cat|--nyan] [--banana]
+             [--cat|--nyan] [--banana] [--upyachka] [--pacman]
 
 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
 
-Progress sprite is random (nyan cat or banana). Force with --cat or --banana.
+Progress sprite is random (nyan cat, banana, upyachka, or Pac-Man).
+Force with --cat, --banana, --upyachka, or --pacman. Agent log is below.
 `
 const AGENT_MISSING = `Cursor Agent CLI not found — smart-commit cannot run.
 
@@ -142,14 +149,25 @@ async function main(argv) {
 
   ensureGitIndexReady(cwd)
 
+  const total = activePlans.length
+  process.stdout.write(`Creating ${total} commit(s)…\n`)
+
   let created = 0
-  for (const plan of activePlans) {
+  for (let index = 0; index < total; index++) {
+    const plan = activePlans[index]
+    const step = `[${index + 1}/${total}]`
     const planFiles = plan.files.filter((file) => fileHasChanges(cwd, file))
     if (!planFiles.length) {
-      process.stdout.write(`Skipping empty commit: ${plan.message}\n`)
+      process.stdout.write(`${step} skip empty: ${plan.message}\n`)
       continue
     }
 
+    const startedAt = Date.now()
+    const fileLabel =
+      planFiles.length === 1 ? '1 file' : `${planFiles.length} files`
+    process.stdout.write(`${step} ${plan.message}\n`)
+    process.stdout.write(`      staging ${fileLabel}…\n`)
+
     // Drop leftover index entries so only this plan's files are committed.
     git(cwd, ['reset', '-q', 'HEAD'])
     stageFiles(cwd, planFiles)
@@ -162,6 +180,7 @@ async function main(argv) {
       )
     }
 
+    process.stdout.write('      git commit (husky)…\n')
     try {
       git(cwd, ['commit', '-m', plan.message], { inherit: true })
     } catch (error) {
@@ -170,6 +189,7 @@ async function main(argv) {
       })
     }
     created++
+    process.stdout.write(`      done (${formatElapsed(startedAt)})\n`)
   }
   process.stdout.write(`Created ${created} commit(s).\n`)
 
@@ -200,6 +220,8 @@ function parseArgs(argv) {
     else if (arg === '--staged') option.staged = true
     else if (arg === '--cat' || arg === '--nyan') option.sprite = 'cat'
     else if (arg === '--banana') option.sprite = 'banana'
+    else if (arg === '--upyachka') option.sprite = 'upyachka'
+    else if (arg === '--pacman') option.sprite = 'pacman'
     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)
@@ -210,8 +232,9 @@ function parseArgs(argv) {
 }
 
 function pickSprite(forced) {
-  if (forced === 'cat' || forced === 'banana') return forced
-  return Math.random() < 0.5 ? 'cat' : 'banana'
+  const sprites = ['cat', 'banana', 'upyachka', 'pacman']
+  if (sprites.includes(forced)) return forced
+  return sprites[Math.floor(Math.random() * sprites.length)]
 }
 
 function assertItcaseConfigPackage(cwd) {
@@ -447,49 +470,109 @@ async function withAgentProgress(context, callback) {
   let phase = 'early'
   let receivedChars = 0
   let frameIndex = 0
+  const logLines = []
+  const streamByKey = { assistant: -1, thinking: -1 }
+
+  const elapsedSeconds = () => Math.floor((Date.now() - startedAt) / 1000)
 
-  const onAgentActivity = (charCount) => {
-    if (charCount > 0) {
-      receivedChars = charCount
+  const onAgentActivity = (activity = {}) => {
+    if (activity.charCount > 0) {
+      receivedChars = activity.charCount
       phase = 'receiving'
     }
+    if (!activity.log) return
+    if (activity.stream) {
+      const key = activity.streamKey || 'assistant'
+      const index = streamByKey[key]
+      if (index >= 0 && index < logLines.length) logLines[index] = activity.log
+      else {
+        logLines.push(activity.log)
+        streamByKey[key] = logLines.length - 1
+      }
+    } else if (logLines[logLines.length - 1] !== activity.log) {
+      logLines.push(activity.log)
+      streamByKey.assistant = -1
+    }
+    if (phase !== 'receiving') phase = 'working'
   }
 
   const currentLabel = () => {
+    const elapsed = elapsedSeconds()
     if (phase === 'receiving') {
       return `Receiving response (${receivedChars} chars)`
     }
-    if (phase === 'waiting') {
+    if (elapsed >= AGENT_STILL_WORKING_S) return 'Agent still working'
+    if (phase === 'waiting' || phase === 'working') {
       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)`
+    const text = `${currentLabel()}… (${elapsedSeconds()}s)`
+    const width = process.stderr.columns || process.stdout.columns || 80
+    return clipLog(text, width)
+  }
+
+  const reportActivity = (activity) => {
+    onAgentActivity(activity)
+    if (
+      (!process.stderr.isTTY || context.verbose) &&
+      activity.log &&
+      !activity.stream
+    ) {
+      process.stderr.write(`${activity.log}\n`)
+    }
   }
 
   if (!process.stderr.isTTY || context.verbose) {
     process.stderr.write(`${formatText()}\n`)
-    return callback({ onAgentActivity })
+    const waitTimer = setInterval(() => {
+      if (phase === 'receiving') return
+      process.stderr.write(`Thinking… (${elapsedSeconds()}s)\n`)
+    }, AGENT_STEP_MS)
+    try {
+      return await callback({ onAgentActivity: reportActivity })
+    } finally {
+      clearInterval(waitTimer)
+    }
   }
 
   const columns = process.stderr.columns || process.stdout.columns || 80
   const rows = process.stderr.rows || process.stdout.rows || 24
-  const getFrame =
-    context.sprite === 'cat'
-      ? (index) => getNyanFrame(index, columns)
-      : (index) => getBananaFrame(index, columns, rows)
-  const frameMs = context.sprite === 'cat' ? NYAN_FRAME_MS : BANANA_FRAME_MS
+  const logRows = Math.min(AGENT_LOG_ROWS, Math.max(3, rows - 10))
+  const spriteRows = Math.max(10, rows - logRows)
+  const sprite = {
+    banana: {
+      render: (index) => getBananaFrame(index, columns, spriteRows),
+      frameMs: BANANA_FRAME_MS,
+    },
+    cat: {
+      render: (index) => getNyanFrame(index, columns),
+      frameMs: NYAN_FRAME_MS,
+    },
+    pacman: {
+      render: (index) => getPacmanFrame(index, columns, spriteRows),
+      frameMs: PACMAN_FRAME_MS,
+    },
+    upyachka: {
+      render: (index) => getUpyachkaFrame(index, columns, spriteRows),
+      frameMs: UPYACHKA_FRAME_MS,
+    },
+  }[context.sprite]
   process.stderr.write('\x1b[?7l')
 
   const render = () => {
-    logUpdateStderr(`${getFrame(frameIndex)}\n${formatText()}`)
+    const waiting = phase !== 'receiving'
+    const extra = waiting ? `Thinking… ${elapsedSeconds()}s` : ''
+    const logBlock = formatLogBlock(logLines, columns, logRows, extra)
+    logUpdateStderr(
+      `${sprite.render(frameIndex)}\n${formatText()}${logBlock ? `\n${logBlock}` : ''}`,
+    )
     frameIndex++
   }
 
-  const frameTimer = setInterval(render, frameMs)
+  const frameTimer = setInterval(render, sprite.frameMs)
   const stepTimer = setInterval(() => {
     if (phase === 'early') {
       if (earlyStepIndex < earlySteps.length - 1) {
@@ -497,14 +580,14 @@ async function withAgentProgress(context, callback) {
       } else {
         phase = 'waiting'
       }
-    } else if (phase === 'waiting') {
+    } else if (phase !== 'receiving') {
       waitStepIndex++
     }
   }, AGENT_STEP_MS)
 
   try {
     render()
-    return await callback({ onAgentActivity })
+    return await callback({ onAgentActivity: reportActivity })
   } finally {
     clearInterval(frameTimer)
     clearInterval(stepTimer)
@@ -513,6 +596,16 @@ async function withAgentProgress(context, callback) {
   }
 }
 
+function formatLogBlock(lines, columns, logRows, extra = '') {
+  const all = extra ? [...lines, extra] : lines
+  if (!all.length) return ''
+  const width = Math.max(20, columns || 80)
+  return all
+    .slice(-logRows)
+    .map((line) => clipLog(line, width))
+    .join('\n')
+}
+
 function askAgent(cwd, model, prompt, verbose, onAgentActivity) {
   const cmd = resolveAgent()
   const args = [
@@ -520,7 +613,8 @@ function askAgent(cwd, model, prompt, verbose, onAgentActivity) {
     '--mode',
     'ask',
     '--output-format',
-    'text',
+    'stream-json',
+    '--stream-partial-output',
     '--trust',
     '--workspace',
     cwd,
@@ -531,6 +625,9 @@ function askAgent(cwd, model, prompt, verbose, onAgentActivity) {
   args.push(prompt)
 
   if (verbose) process.stderr.write(`Using: ${cmd}\n`)
+  if (onAgentActivity) {
+    onAgentActivity({ log: `Sending prompt (${prompt.length} chars)` })
+  }
 
   return new Promise((resolve, reject) => {
     const child = spawn(cmd, args, {
@@ -538,44 +635,240 @@ function askAgent(cwd, model, prompt, verbose, onAgentActivity) {
       stdio: ['ignore', 'pipe', 'pipe'],
     })
 
-    let stdout = ''
+    const stream = {
+      buffer: '',
+      lastAssistant: '',
+      raw: '',
+      result: '',
+      thinking: '',
+    }
     let stderr = ''
+    let settled = false
+
+    const stopChild = (signal = 'SIGTERM') => {
+      if (child.exitCode !== null || child.killed) return
+      child.kill(signal)
+    }
+
+    const finish = (error, value) => {
+      if (settled) return
+      settled = true
+      process.removeListener('SIGINT', onSignal)
+      process.removeListener('SIGTERM', onSignal)
+      if (error) reject(error)
+      else resolve(value)
+    }
+
+    const onSignal = () => {
+      stopChild('SIGTERM')
+      finish(new Error('Interrupted'))
+    }
+    process.once('SIGINT', onSignal)
+    process.once('SIGTERM', onSignal)
 
     child.stdout.on('data', (chunk) => {
-      stdout += chunk
-      if (onAgentActivity) onAgentActivity(stdout.length)
-      if (verbose) process.stderr.write(chunk)
+      const text = String(chunk)
+      stream.raw += text
+      const activities = consumeAgentStdout(stream, text)
+      for (const activity of activities) {
+        if (onAgentActivity) onAgentActivity(activity)
+      }
     })
     child.stderr.on('data', (chunk) => {
-      stderr += chunk
-      if (verbose) process.stderr.write(chunk)
+      const text = String(chunk)
+      stderr += text
+      const line = lastNonEmptyLine(text)
+      if (line && onAgentActivity) onAgentActivity({ log: line })
+      if (verbose) process.stderr.write(text)
     })
 
-    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)
+      finish(error)
     })
 
     child.on('close', (code) => {
-      clearTimeout(timeout)
+      consumeAgentStdout(stream, '\n')
+      const raw = (
+        stream.result ||
+        stream.lastAssistant ||
+        stream.buffer ||
+        stream.raw
+      ).trim()
       if (code) {
-        reject(new Error(formatAgentError(stderr, stdout)))
+        finish(new Error(formatAgentError(stderr, raw)))
+        return
+      }
+      if (!raw) {
+        finish(new Error(formatAgentError(stderr, '')))
         return
       }
-      resolve(stdout.trim())
+      finish(null, raw)
     })
   })
 }
 
+function consumeAgentStdout(stream, chunk) {
+  stream.buffer += chunk
+  const lines = stream.buffer.split('\n')
+  stream.buffer = lines.pop() || ''
+  const activities = []
+  for (const line of lines) {
+    const activity = applyAgentLine(stream, line)
+    if (activity) activities.push(activity)
+  }
+  return activities
+}
+
+function applyAgentLine(stream, line) {
+  const trimmed = line.trim()
+  if (!trimmed) return null
+
+  let event
+  try {
+    event = JSON.parse(trimmed)
+  } catch {
+    if (!stream.result) stream.result = trimmed
+    return {
+      charCount: trimmed.length,
+      log: trimmed,
+      stream: true,
+    }
+  }
+
+  if (!event || typeof event !== 'object') return null
+  if (event.type === 'user') return null
+
+  if (event.type === 'thinking') {
+    const text = extractThinkingText(event)
+    if (event.subtype === 'completed') {
+      return stream.thinking
+        ? {
+            log: `Thinking: ${stream.thinking}`,
+            stream: true,
+            streamKey: 'thinking',
+          }
+        : { log: 'Finished thinking' }
+    }
+    if (text) {
+      stream.thinking += text
+      return {
+        log: `Thinking: ${stream.thinking}`,
+        stream: true,
+        streamKey: 'thinking',
+      }
+    }
+    return { log: 'Thinking' }
+  }
+
+  if (event.type === 'result' && typeof event.result === 'string') {
+    stream.result = event.result
+    return { charCount: stream.result.length, log: 'Agent finished' }
+  }
+
+  if (event.type === 'assistant') {
+    if (event.model_call_id != null) return null
+    const thinking = extractContentText(event.message?.content, 'thinking')
+    if (thinking) {
+      stream.thinking += thinking
+      return {
+        log: `Thinking: ${stream.thinking}`,
+        stream: true,
+        streamKey: 'thinking',
+      }
+    }
+    const text = extractAssistantText(event)
+    if (!text) return null
+    if (typeof event.timestamp_ms === 'number') stream.lastAssistant += text
+    else stream.lastAssistant = text
+    return {
+      charCount: stream.lastAssistant.length,
+      log: stream.lastAssistant,
+      stream: true,
+      streamKey: 'assistant',
+    }
+  }
+
+  const log = describeAgentEvent(event)
+  if (log) return { log }
+  if (event.type) {
+    return {
+      log: event.subtype
+        ? `${event.type}: ${event.subtype}`
+        : String(event.type),
+    }
+  }
+  return null
+}
+
+function extractAssistantText(event) {
+  return extractContentText(event.message?.content, 'text')
+}
+
+function extractThinkingText(event) {
+  if (typeof event.text === 'string' && event.text) return event.text
+  if (typeof event.delta === 'string' && event.delta) return event.delta
+  return (
+    extractContentText(event.message?.content, 'thinking') ||
+    extractContentText(event.content, 'thinking') ||
+    extractContentText(event.message?.content, 'text')
+  )
+}
+
+function extractContentText(content, type) {
+  if (!Array.isArray(content)) return ''
+  return content
+    .filter((part) => part?.type === type && typeof part.text === 'string')
+    .map((part) => part.text)
+    .join('')
+}
+
+function describeAgentEvent(event) {
+  if (event.type === 'system' && event.subtype === 'init') {
+    return event.model ? `Agent started (${event.model})` : 'Agent started'
+  }
+  if (event.type === 'tool_call') {
+    return describeToolCall(event.tool_call, event.subtype === 'completed')
+  }
+  return ''
+}
+
+function describeToolCall(toolCall, done) {
+  if (!toolCall || typeof toolCall !== 'object') {
+    return done ? 'Tool done' : 'Tool call'
+  }
+  const [key, payload] = Object.entries(toolCall)[0] || []
+  if (key === 'function' && payload?.name) {
+    return done ? `Done ${payload.name}` : payload.name
+  }
+  const args =
+    payload?.args && typeof payload.args === 'object' ? payload.args : {}
+  const name = (key || 'tool').replace(/ToolCall$/, '')
+  const detail =
+    args.path ||
+    args.file_path ||
+    args.command ||
+    args.query ||
+    args.pattern ||
+    args.glob ||
+    ''
+  const label = detail ? `${name} ${detail}` : name
+  return done ? `Done ${label}` : `${label}`
+}
+
+function lastNonEmptyLine(text) {
+  const lines = String(text)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+  return lines.at(-1) || ''
+}
+
+function clipLog(text, max = AGENT_LOG_MAX) {
+  const oneLine = String(text).replace(/\s+/g, ' ').trim()
+  if (oneLine.length <= max) return oneLine
+  return `…${oneLine.slice(-(max - 1))}`
+}
+
 function formatAgentError(stderr, stdout) {
   const text = (stderr || stdout || AGENT_MISSING).trim()
   if (/authentication required/i.test(text)) {
@@ -887,6 +1180,11 @@ function sleepSync(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms)
 }
 
+function formatElapsed(startedAt) {
+  const elapsed = Math.max(0, Math.floor((Date.now() - startedAt) / 1000))
+  return `${elapsed}s`
+}
+
 function indexLockPath(cwd) {
   const result = spawnSync('git', ['rev-parse', '--git-path', 'index.lock'], {
     cwd: cwd,

package/smart-commit/pacman.js

@@ -0,0 +1,140 @@
+// High-resolution terminal sprites reconstructed from the supplied reference.
+// Two vertical source pixels share one terminal cell via half-block glyphs.
+
+const RESET = '\x1b[0m'
+const FRAME_WIDTH = 80
+const FRAME_HEIGHT = 16
+const FRAME_COUNT = 82
+const SPRITE_WIDTH = 14
+const SPRITE_HEIGHT = 16
+const COLORS = { B: 33, C: 51, O: 208, P: 218, R: 196, W: 231, Y: 226 }
+
+const GHOST = [
+  '................',
+  '......XXXX......',
+  '....XXXXXXXX....',
+  '...XXXXXXXXXX...',
+  '..XXXXXXXXXXXX..',
+  '..XWWXXXXWWWXXX.',
+  '..WWWWXXWWWWXX..',
+  '..BBWWXXBBWWXX..',
+  '.XBBWWXXBBWWXXX.',
+  '.XXWWXXXXWWXXXX.',
+  '.XXXXXXXXXXXXXX.',
+  '.XXXXXXXXXXXXXX.',
+  '.XXXXXXXXXXXXXX.',
+  '.XXXXXXXXXXXXXX.',
+  '.XXXXXXXXXXXXXX.',
+  '.XX.XXX..XXX.XX.',
+  '.X...XX..XX...X.',
+  '................',
+]
+
+const PACMAN_CLOSED = [
+  '................',
+  '.....YYYYYY.....',
+  '...YYYYYYYYYY...',
+  '..YYYYYYYYYYYY..',
+  '.YYYYYYYYYYYYYY.',
+  'YYYYYYYYYYYYYYYY',
+  'YYYYYYYYYYYYYYYY',
+  'YYYYYYYYYYYYYYYY',
+  'YYYYYYYYYYYYYYYY',
+  'YYYYYYYYYYYYYYYY',
+  'YYYYYYYYYYYYYYYY',
+  'YYYYYYYYYYYYYYYY',
+  'YYYYYYYYYYYYYYYY',
+  '.YYYYYYYYYYYYYY.',
+  '..YYYYYYYYYYYY..',
+  '...YYYYYYYYYY...',
+  '.....YYYYYY.....',
+  '................',
+]
+
+const PACMAN_OPEN = [
+  '................',
+  '.....YYYYYY.....',
+  '...YYYYYYYYYY...',
+  '..YYYYYYYYYYYY..',
+  '.YYYYYYYYYYYYYY.',
+  'YYYYYYYYYYYYYYYY',
+  '..YYYYYYYYYYYYYY',
+  '....YYYYYYYYYYYY',
+  '......YYYYYYYYYY',
+  '........YYYYYYYY',
+  '......YYYYYYYYYY',
+  '....YYYYYYYYYYYY',
+  '..YYYYYYYYYYYYYY',
+  '.YYYYYYYYYYYYYY.',
+  '..YYYYYYYYYYYY..',
+  '...YYYYYYYYYY...',
+  '.....YYYYYY.....',
+  '................',
+]
+
+function drawSprite(canvas, sprite, left, color) {
+  const columns = pickIndexes(sprite[0].length, SPRITE_WIDTH)
+  const rows = pickIndexes(sprite.length, SPRITE_HEIGHT)
+  for (let y = 0; y < rows.length; y++) {
+    for (let x = 0; x < columns.length; x++) {
+      const cell = sprite[rows[y]][columns[x]]
+      const targetX = left + x
+      if (cell === '.' || targetX < 0 || targetX >= FRAME_WIDTH) continue
+      canvas[y][targetX] = cell === 'X' ? color : cell
+    }
+  }
+}
+
+function buildFrame(index) {
+  const canvas = Array.from({ length: FRAME_HEIGHT }, () =>
+    Array(FRAME_WIDTH).fill('.'),
+  )
+  const pacmanLeft = FRAME_WIDTH - 7 - index * 2
+  const pacman = Math.floor(index / 2) % 2 ? PACMAN_CLOSED : PACMAN_OPEN
+  drawSprite(canvas, pacman, pacmanLeft, 'Y')
+
+  for (const [ghostIndex, color] of ['R', 'C', 'P', 'O'].entries()) {
+    drawSprite(canvas, GHOST, pacmanLeft + 20 + ghostIndex * 18, color)
+  }
+  return canvas
+}
+
+function pickIndexes(srcSize, maxSize) {
+  if (srcSize <= maxSize) {
+    return Array.from({ length: srcSize }, (_, index) => index)
+  }
+  return Array.from({ length: maxSize }, (_, index) =>
+    Math.round((index * (srcSize - 1)) / (maxSize - 1)),
+  )
+}
+
+function paint(top, bottom) {
+  const topColor = COLORS[top]
+  const bottomColor = COLORS[bottom]
+  if (topColor === undefined && bottomColor === undefined) return ' '
+  if (topColor === bottomColor) return `\x1b[48;5;${topColor}m \x1b[0m`
+  if (topColor === undefined) return `\x1b[38;5;${bottomColor}m▄\x1b[0m`
+  if (bottomColor === undefined) return `\x1b[38;5;${topColor}m▀\x1b[0m`
+  return `\x1b[38;5;${topColor};48;5;${bottomColor}m▀\x1b[0m`
+}
+
+export function getPacmanFrame(index, terminalColumns = 80, terminalRows = 24) {
+  const frame = buildFrame(index % FRAME_COUNT)
+  const maxColumns = Math.max(16, (terminalColumns || 80) - 1)
+  const maxLogicalRows = Math.max(4, ((terminalRows || 24) - 2) * 2)
+  const columns = pickIndexes(FRAME_WIDTH, maxColumns)
+  const rowCount = Math.min(FRAME_HEIGHT, maxLogicalRows)
+  const rows = pickIndexes(FRAME_HEIGHT, rowCount - (rowCount % 2))
+  const lines = []
+
+  for (let index = 0; index < rows.length; index += 2) {
+    const top = frame[rows[index]]
+    const bottom = frame[rows[index + 1]]
+    lines.push(columns.map((x) => paint(top[x], bottom[x])).join('') + RESET)
+  }
+  return lines.join('\n')
+}
+
+export function getPacmanFrameCount() {
+  return FRAME_COUNT
+}

package/smart-commit/upyachka.js

@@ -0,0 +1,229 @@
+// Five frames extracted from the classic upyachka GIF.
+// Default-color block pixels stay visible on light and dark terminals.
+
+const FRAME_WIDTH = 29
+const FRAME_HEIGHT = 36
+
+const FRAMES = [
+  [
+    '..................#..........',
+    '................#####........',
+    '...............#######.......',
+    '............#..##....##......',
+    '............#####....##......',
+    '...........######....##......',
+    '...........##.####.###.......',
+    '...........##...#####........',
+    '...........##....###.........',
+    '...........##....###.........',
+    '...........##...#####........',
+    '...........#....##.##........',
+    '.............#####..#........',
+    '..............########.......',
+    '...............##.####.......',
+    '..............##.............',
+    '..............##.............',
+    '.............######..........',
+    '.............##########......',
+    '.............##....#####.....',
+    '.............##.......##.....',
+    '.............##.......##.....',
+    '.............##......##......',
+    '.............##......##......',
+    '.............##......##......',
+    '.............##......##......',
+    '.............##.....##.......',
+    '.............##.....##.......',
+    '.............##.....##.......',
+    '.............##..............',
+    '.............##..............',
+    '.............##..............',
+    '.............##..............',
+    '.............##..............',
+    '.............##..............',
+    '..............#..............',
+  ],
+  [
+    '...............##............',
+    '.............######..........',
+    '............###..###.........',
+    '............##....##.##......',
+    '............##....#####......',
+    '............##....######.....',
+    '.............#######..##.....',
+    '..............#####...##.....',
+    '...............###....##.....',
+    '...............###....##.....',
+    '..............##.##...##.....',
+    '..............##.##....#.....',
+    '.............##.#####........',
+    '.............########........',
+    '.............####.##.........',
+    '...................##........',
+    '...................##........',
+    '...............#######.......',
+    '............##########.......',
+    '...........#####....##.......',
+    '...........##.......##.......',
+    '............##......##.......',
+    '............##......##.......',
+    '............##......##.......',
+    '............##......##.......',
+    '............##......##.......',
+    '.............##.....##.......',
+    '.............##.....##.......',
+    '.............##.....##.......',
+    '....................##.......',
+    '....................##.......',
+    '....................##.......',
+    '....................##.......',
+    '....................##.......',
+    '....................##.......',
+    '....................#........',
+  ],
+  [
+    '.............................',
+    '.............................',
+    '.............................',
+    '.............................',
+    '.............................',
+    '.............................',
+    '..............#..............',
+    '............#####............',
+    '...........###.###...........',
+    '...........##...##...........',
+    '..........##.....#...........',
+    '...........##...##...........',
+    '.......###############.......',
+    '.......###############.......',
+    '.......##....###....##.......',
+    '........##....#.....##.......',
+    '........##....##....#........',
+    '.........##...##...##........',
+    '.........##...##...##........',
+    '..........#...##...##........',
+    '..............##.............',
+    '..............##.............',
+    '..............##.............',
+    '..............##.............',
+    '..........###########........',
+    '......#######...########.....',
+    '.....#####..........####.....',
+    '.....##...............##.....',
+    '......##..............##.....',
+    '......##.............##......',
+    '......##.............##......',
+    '......##.............##......',
+    '.......##...........##.......',
+    '.......##...........##.......',
+    '.......##...........##.......',
+    '.......##....................',
+  ],
+  [
+    '.............................',
+    '............#####............',
+    '...........#######...........',
+    '###.......###...##...........',
+    '.####.....##....##.......####',
+    '...####...##....##....######.',
+    '.....########..##########....',
+    '.......###############.......',
+    '............#####............',
+    '.............##..............',
+    '.............##..............',
+    '..............#..............',
+    '..............#..............',
+    '..............#..............',
+    '..............#..............',
+    '..............##.............',
+    '..............##.............',
+    '..............##.............',
+    '..............##.............',
+    '.............###.............',
+    '............#####............',
+    '............##.###...........',
+    '...........##...##...........',
+    '...........##....##..........',
+    '..........##.....##..........',
+    '.........##.......##.........',
+    '.........##.......##.........',
+    '.........##........##........',
+    '........###........##........',
+    '........##.........##........',
+    '........##.........##........',
+    '........##.........##........',
+    '.......##...........##.......',
+    '.......##...........##.......',
+    '.......##...........##.......',
+    '.............................',
+  ],
+  [
+    '.............................',
+    '.............................',
+    '.............................',
+    '.............................',
+    '.............................',
+    '.............................',
+    '.............................',
+    '.............................',
+    '.............................',
+    '.............................',
+    '.............................',
+    '............###..............',
+    '...........######............',
+    '..........###..###...........',
+    '..........##....##...........',
+    '..........##....##...........',
+    '..........##...###...........',
+    '...........######............',
+    '............####.............',
+    '...........#####.............',
+    '..........#######............',
+    '.........#########...........',
+    '........##########...........',
+    '........###..######..........',
+    '.............##..##..........',
+    '.....###.....##......###.....',
+    '.....######..##...#####......',
+    '......#################......',
+    '......##...#######...##......',
+    '......##.....##.....##.......',
+    '.......##...........##.......',
+    '.......##..........##........',
+    '.......###.........##........',
+    '........##.........##........',
+    '........##.........#.........',
+    '.............................',
+  ],
+]
+
+function pickIndexes(srcSize, maxSize) {
+  if (srcSize <= maxSize) {
+    return Array.from({ length: srcSize }, (_, index) => index)
+  }
+  return Array.from({ length: maxSize }, (_, index) =>
+    Math.round((index * (srcSize - 1)) / (maxSize - 1)),
+  )
+}
+
+export function getUpyachkaFrame(
+  index,
+  terminalColumns = 80,
+  terminalRows = 24,
+) {
+  const maxColumns = Math.max(8, Math.floor((terminalColumns - 1) / 2))
+  const maxRows = Math.max(8, (terminalRows || 24) - 2)
+  const columns = pickIndexes(FRAME_WIDTH, maxColumns)
+  const rows = pickIndexes(FRAME_HEIGHT, maxRows)
+  const frame = FRAMES[index % FRAMES.length]
+
+  return rows
+    .map((y) =>
+      columns.map((x) => (frame[y][x] === '#' ? '██' : '  ')).join(''),
+    )
+    .join('\n')
+}
+
+export function getUpyachkaFrameCount() {
+  return FRAMES.length
+}