@icode-js/icode 3.0.2

package/src/core/git-service.js

@@ -0,0 +1,428 @@
+import { IcodeError } from './errors.js'
+import { buildHookHint, detectHookFailure } from './hook-diagnostics.js'
+import { logger } from './logger.js'
+import { runCommand } from './shell.js'
+import fs from 'node:fs'
+import path from 'node:path'
+
+function cleanOutput(text) {
+  return (text || '').trim()
+}
+
+export class GitService {
+  constructor(context) {
+    this.context = context
+    this.cwd = context.topLevelPath
+  }
+
+  async exec(args, options = {}) {
+    logger.debug(`git ${args.join(' ')}`)
+    return runCommand('git', args, { cwd: this.cwd, ...options })
+  }
+
+  async getCurrentBranch() {
+    const result = await this.exec(['branch', '--show-current'], { allowFailure: true })
+    return cleanOutput(result.stdout)
+  }
+
+  async revParseShort(ref = 'HEAD') {
+    const result = await this.exec(['rev-parse', '--short', ref], { allowFailure: true })
+    return cleanOutput(result.stdout)
+  }
+
+  async fetch() {
+    await this.exec(['fetch', '--all', '--prune'])
+  }
+
+  operationFileExists(fileName) {
+    const candidatePaths = [
+      path.resolve(this.context.gitDir, fileName),
+      path.resolve(this.context.commonDir, fileName)
+    ]
+
+    return candidatePaths.some((candidatePath) => fs.existsSync(candidatePath))
+  }
+
+  async getInProgressOperation() {
+    if (this.operationFileExists('REVERT_HEAD')) {
+      return 'revert'
+    }
+
+    if (this.operationFileExists('CHERRY_PICK_HEAD')) {
+      return 'cherry-pick'
+    }
+
+    if (
+      this.operationFileExists('REBASE_HEAD') ||
+      this.operationFileExists('rebase-apply') ||
+      this.operationFileExists('rebase-merge')
+    ) {
+      return 'rebase'
+    }
+
+    return null
+  }
+
+  async branchExistsLocal(branchName) {
+    const result = await this.exec(['show-ref', '--verify', '--quiet', `refs/heads/${branchName}`], {
+      allowFailure: true
+    })
+    return result.exitCode === 0
+  }
+
+  async branchExistsRemote(branchName) {
+    const result = await this.exec(['ls-remote', '--exit-code', '--heads', 'origin', branchName], {
+      allowFailure: true
+    })
+    return result.exitCode === 0
+  }
+
+  async listLocalBranches() {
+    const result = await this.exec(['for-each-ref', '--format=%(refname:short)', 'refs/heads'])
+    return result.stdout
+      .split('\n')
+      .map((item) => item.trim())
+      .filter(Boolean)
+  }
+
+  async listRemoteBranches(remoteName = 'origin') {
+    const result = await this.exec(['for-each-ref', '--format=%(refname:strip=3)', `refs/remotes/${remoteName}`], {
+      allowFailure: true
+    })
+
+    if (result.exitCode !== 0) {
+      return []
+    }
+
+    return result.stdout
+      .split('\n')
+      .map((item) => item.trim())
+      .filter((item) => item && item !== 'HEAD')
+  }
+
+  async listMergedLocalBranches(targetRef) {
+    const result = await this.exec(['branch', '--merged', targetRef])
+    return result.stdout
+      .split('\n')
+      .map((item) => item.replace('*', '').trim())
+      .filter(Boolean)
+  }
+
+  async checkout(branchName) {
+    await this.exec(['checkout', branchName])
+  }
+
+  async checkoutTracking(branchName) {
+    await this.exec(['checkout', '-b', branchName, '--track', `origin/${branchName}`])
+  }
+
+  async checkoutNewBranch(branchName, fromBranch) {
+    await this.exec(['checkout', '-b', branchName, fromBranch])
+  }
+
+  async createTrackingFromRemote(branchName) {
+    await this.exec(['branch', '--track', branchName, `origin/${branchName}`])
+  }
+
+  async pull(branchName, options = {}) {
+    const args = ['pull', 'origin', branchName]
+
+    if (options.noRebase !== false) {
+      args.push('--no-rebase')
+    }
+
+    if (options.ffOnly) {
+      args.push('--ff-only')
+    }
+
+    if (options.allowUnrelatedHistories) {
+      args.push('--allow-unrelated-histories')
+    }
+
+    await this.exec(args)
+  }
+
+  async merge(fromBranch, options = {}) {
+    const args = ['merge', fromBranch]
+    if (options.noFf !== false) {
+      args.push('--no-ff')
+    }
+    if (options.noEdit !== false) {
+      args.push('--no-edit')
+    }
+    await this.exec(args)
+  }
+
+  async rebase(fromRef) {
+    await this.exec(['rebase', fromRef])
+  }
+
+  async rebaseAbort() {
+    await this.exec(['rebase', '--abort'], { allowFailure: true })
+  }
+
+  async statusPorcelain() {
+    const result = await this.exec(['status', '--porcelain'])
+    return result.stdout
+  }
+
+  async hasChanges() {
+    const output = await this.statusPorcelain()
+    return cleanOutput(output).length > 0
+  }
+
+  async diffWorkingTree() {
+    const result = await this.exec(['diff'])
+    return result.stdout
+  }
+
+  async diffStaged() {
+    const result = await this.exec(['diff', '--staged'])
+    return result.stdout
+  }
+
+  async diffStagedStat() {
+    const result = await this.exec(['diff', '--staged', '--stat'])
+    return result.stdout
+  }
+
+  async diffStagedNameStatus() {
+    const result = await this.exec(['diff', '--staged', '--name-status'])
+    return result.stdout
+  }
+
+  async diffStat(rangeSpec = '') {
+    const args = ['diff', '--stat']
+    if (rangeSpec) {
+      args.push(rangeSpec)
+    }
+    const result = await this.exec(args)
+    return result.stdout
+  }
+
+  async diffNameStatus(rangeSpec = '') {
+    const args = ['diff', '--name-status']
+    if (rangeSpec) {
+      args.push(rangeSpec)
+    }
+    const result = await this.exec(args)
+    return result.stdout
+  }
+
+  async diffBetween(baseRef, headRef, options = {}) {
+    const style = options.style === 'two-dot' ? '..' : '...'
+    const rangeSpec = `${baseRef}${style}${headRef}`
+    const args = ['diff', rangeSpec]
+    const result = await this.exec(args)
+    return {
+      rangeSpec,
+      diff: result.stdout
+    }
+  }
+
+  async logOneline(rangeSpec = '', limit = 30) {
+    const args = ['log', '--oneline', `-${limit}`]
+    if (rangeSpec) {
+      args.push(rangeSpec)
+    }
+    const result = await this.exec(args, { allowFailure: true })
+    return result.stdout
+  }
+
+  async showCommitSummary(ref) {
+    const result = await this.exec(['show', '-s', '--format=%h %s', ref], { allowFailure: true })
+    return cleanOutput(result.stdout)
+  }
+
+  async listConflictedFiles() {
+    const result = await this.exec(['diff', '--name-only', '--diff-filter=U'])
+    return result.stdout
+      .split('\n')
+      .map((item) => item.trim())
+      .filter(Boolean)
+  }
+
+  async showFile(filePath) {
+    const result = await this.exec(['show', `:${filePath}`], { allowFailure: true })
+    return result.stdout || ''
+  }
+
+  async stageAll() {
+    await this.exec(['add', '-A'])
+  }
+
+  async commit(message, options = {}) {
+    if (!message || !message.trim()) {
+      throw new IcodeError('提交信息不能为空，请使用 -m 或 --message 指定。', {
+        code: 'COMMIT_MESSAGE_REQUIRED',
+        exitCode: 2
+      })
+    }
+
+    const args = ['commit', '-m', message]
+    if (options.noVerify) {
+      args.push('--no-verify')
+    }
+
+    try {
+      await this.exec(args)
+    } catch (error) {
+      // 统一识别 husky / hooks 拦截，给出明确可执行的提示。
+      if (detectHookFailure(error)) {
+        throw new IcodeError(buildHookHint('git commit'), {
+          code: 'HOOK_COMMIT_BLOCKED',
+          cause: error,
+          meta: error.meta
+        })
+      }
+      throw error
+    }
+  }
+
+  async push(branchName, options = {}) {
+    const args = ['push']
+
+    if (options.noVerify) {
+      args.push('--no-verify')
+    }
+
+    args.push('origin', branchName)
+
+    if (options.setUpstream) {
+      args.push('--set-upstream')
+    }
+
+    try {
+      await this.exec(args)
+    } catch (error) {
+      // push 同样可能被 pre-push 等 hook 拦截，这里统一转成可读错误。
+      if (detectHookFailure(error)) {
+        throw new IcodeError(buildHookHint('git push'), {
+          code: 'HOOK_PUSH_BLOCKED',
+          cause: error,
+          meta: error.meta
+        })
+      }
+      throw error
+    }
+  }
+
+  async pushRefspec(sourceBranch, targetBranch, options = {}) {
+    const args = ['push']
+
+    if (options.noVerify) {
+      args.push('--no-verify')
+    }
+
+    args.push('origin', `${sourceBranch}:${targetBranch}`)
+
+    try {
+      await this.exec(args)
+    } catch (error) {
+      if (detectHookFailure(error)) {
+        throw new IcodeError(buildHookHint('git push(refspec)'), {
+          code: 'HOOK_PUSH_REFSPEC_BLOCKED',
+          cause: error,
+          meta: error.meta
+        })
+      }
+      throw error
+    }
+  }
+
+  async listTags(pattern = '*') {
+    const result = await this.exec(['tag', '--list', pattern])
+    return result.stdout
+      .split('\n')
+      .map((item) => item.trim())
+      .filter(Boolean)
+  }
+
+  async createAnnotatedTag(tagName, message, fromRef) {
+    const args = ['tag', '-a', tagName, '-m', message]
+    if (fromRef) {
+      args.push(fromRef)
+    }
+    await this.exec(args)
+  }
+
+  async pushTag(tagName, options = {}) {
+    const args = ['push']
+    if (options.noVerify) {
+      args.push('--no-verify')
+    }
+    args.push('origin', tagName)
+
+    try {
+      await this.exec(args)
+    } catch (error) {
+      if (detectHookFailure(error)) {
+        throw new IcodeError(buildHookHint('git push(tag)'), {
+          code: 'HOOK_TAG_PUSH_BLOCKED',
+          cause: error,
+          meta: error.meta
+        })
+      }
+      throw error
+    }
+  }
+
+  async reset(mode, ref = 'HEAD~1') {
+    const validModes = new Set(['soft', 'mixed', 'hard'])
+    if (!validModes.has(mode)) {
+      throw new IcodeError(`不支持的 reset 模式: ${mode}`, {
+        code: 'RESET_MODE_INVALID',
+        exitCode: 2
+      })
+    }
+
+    await this.exec(['reset', `--${mode}`, ref])
+  }
+
+  async revert(ref = 'HEAD') {
+    await this.exec(['revert', '--no-edit', ref])
+  }
+
+  async revertContinue() {
+    await this.exec(['revert', '--continue'])
+  }
+
+  async revertAbort() {
+    await this.exec(['revert', '--abort'], { allowFailure: true })
+  }
+
+  async revList(rangeSpec) {
+    const result = await this.exec(['rev-list', '--reverse', rangeSpec])
+    return result.stdout
+      .split('\n')
+      .map((item) => item.trim())
+      .filter(Boolean)
+  }
+
+  async cherryPick(commits) {
+    const normalized = Array.isArray(commits) ? commits : [commits]
+    const list = normalized.map((item) => item.trim()).filter(Boolean)
+    if (!list.length) {
+      return
+    }
+
+    await this.exec(['cherry-pick', ...list])
+  }
+
+  async cherryPickContinue() {
+    await this.exec(['cherry-pick', '--continue'])
+  }
+
+  async abortCherryPick() {
+    await this.exec(['cherry-pick', '--abort'], { allowFailure: true })
+  }
+
+  async deleteLocalBranch(branchName, options = {}) {
+    const args = ['branch', options.force ? '-D' : '-d', branchName]
+    await this.exec(args)
+  }
+
+  async deleteRemoteBranch(branchName) {
+    await this.exec(['push', 'origin', '--delete', branchName])
+  }
+}

package/src/core/hook-diagnostics.js

@@ -0,0 +1,23 @@
+const HOOK_PATTERNS = [
+  /husky/i,
+  /pre-commit/i,
+  /pre-push/i,
+  /commit-msg/i,
+  /hook failed/i,
+  /hook declined/i
+]
+
+export function collectCommandOutput(error) {
+  const stdout = error?.meta?.stdout || ''
+  const stderr = error?.meta?.stderr || ''
+  return `${stdout}\n${stderr}`
+}
+
+export function detectHookFailure(error) {
+  const output = collectCommandOutput(error)
+  return HOOK_PATTERNS.some((pattern) => pattern.test(output))
+}
+
+export function buildHookHint(action) {
+  return `${action} 被 Git hooks/Husky 拦截。若需跳过校验请重试并加上 --no-verify。`
+}

package/src/core/loading.js

@@ -0,0 +1,36 @@
+const SPINNER_FRAMES = ['-', '\\', '|', '/']
+
+function canRenderSpinner() {
+  return Boolean(process.stderr.isTTY) && process.env.ICODE_NO_SPINNER !== '1'
+}
+
+function clearLine() {
+  if (!canRenderSpinner()) {
+    return
+  }
+
+  process.stderr.write('\r\x1b[2K')
+}
+
+export async function withSpinner(text, task) {
+  if (!canRenderSpinner()) {
+    return task()
+  }
+
+  let frameIndex = 0
+  const render = () => {
+    const frame = SPINNER_FRAMES[frameIndex % SPINNER_FRAMES.length]
+    frameIndex += 1
+    process.stderr.write(`\r[icode] ${frame} ${text}`)
+  }
+
+  render()
+  const timer = setInterval(render, 80)
+
+  try {
+    return await task()
+  } finally {
+    clearInterval(timer)
+    clearLine()
+  }
+}

package/src/core/logger.js

@@ -0,0 +1,55 @@
+const COLORS = {
+  reset: '\x1b[0m',
+  gray: '\x1b[90m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m'
+}
+
+let verboseEnabled = process.env.ICODE_LOG_LEVEL === 'verbose'
+
+function colorize(color, message) {
+  return `${COLORS[color] || ''}${message}${COLORS.reset}`
+}
+
+// Prefix every rendered line so multiline logs keep the same visible marker.
+function print(stream, level, message) {
+  const normalizedMessage = String(message ?? '')
+  const formattedMessage = normalizedMessage
+    .split('\n')
+    .map((line) => `${level}${line}`)
+    .join('\n')
+
+  stream.write(`${formattedMessage}\n`)
+}
+
+export const logger = {
+  setVerbose(enabled) {
+    verboseEnabled = Boolean(enabled)
+  },
+
+  info(message) {
+    print(process.stdout, colorize('cyan', '[icode] '), `${message}`)
+  },
+
+  success(message) {
+    print(process.stdout, colorize('green', '[icode] '), `${message}`)
+  },
+
+  warn(message) {
+    print(process.stderr, colorize('yellow', '[icode] '), `${message}`)
+  },
+
+  error(message) {
+    print(process.stderr, colorize('red', '[icode] '), `${message}`)
+  },
+
+  debug(message) {
+    if (!verboseEnabled) {
+      return
+    }
+
+    print(process.stdout, colorize('gray', '[icode:debug] '), `${message}`)
+  }
+}

package/src/core/prompts.js

@@ -0,0 +1,152 @@
+import { createInterface } from 'node:readline/promises'
+import { stdin, stdout } from 'node:process'
+
+function isInteractive() {
+  return Boolean(stdin.isTTY && stdout.isTTY)
+}
+
+export function isInteractiveTerminal() {
+  return isInteractive()
+}
+
+export async function confirm(message, defaultValue = true) {
+  if (!isInteractive()) {
+    return defaultValue
+  }
+
+  const rl = createInterface({ input: stdin, output: stdout })
+  const suffix = defaultValue ? '[Y/n]' : '[y/N]'
+  const answer = (await rl.question(`${message} ${suffix} `)).trim().toLowerCase()
+  rl.close()
+
+  if (!answer) {
+    return defaultValue
+  }
+
+  if (['y', 'yes'].includes(answer)) {
+    return true
+  }
+
+  if (['n', 'no'].includes(answer)) {
+    return false
+  }
+
+  return defaultValue
+}
+
+export async function input(message, defaultValue = '') {
+  if (!isInteractive()) {
+    return defaultValue
+  }
+
+  const rl = createInterface({ input: stdin, output: stdout })
+  const answer = await rl.question(`${message}${defaultValue ? ` (${defaultValue})` : ''}: `)
+  rl.close()
+  const normalized = answer.trim()
+  return normalized || defaultValue
+}
+
+export async function chooseOne(message, choices, defaultIndex = 0) {
+  if (!Array.isArray(choices) || choices.length === 0) {
+    throw new Error('chooseOne 需要至少一个可选项')
+  }
+
+  const safeDefaultIndex = Math.min(Math.max(defaultIndex, 0), choices.length - 1)
+  if (!isInteractive()) {
+    return choices[safeDefaultIndex].value
+  }
+
+  stdout.write(`${message}\n`)
+  choices.forEach((choice, index) => {
+    stdout.write(`  ${index + 1}. ${choice.label}\n`)
+  })
+
+  const rl = createInterface({ input: stdin, output: stdout })
+  const answer = (await rl.question(`请选择 [${safeDefaultIndex + 1}]: `)).trim()
+  rl.close()
+
+  if (!answer) {
+    return choices[safeDefaultIndex].value
+  }
+
+  const numeric = Number(answer)
+  if (!Number.isInteger(numeric) || numeric < 1 || numeric > choices.length) {
+    return choices[safeDefaultIndex].value
+  }
+
+  return choices[numeric - 1].value
+}
+
+export async function chooseMany(message, choices, options = {}) {
+  if (!Array.isArray(choices) || choices.length === 0) {
+    throw new Error('chooseMany 需要至少一个可选项')
+  }
+
+  const parsedMin = Number(options.minSelections ?? 0)
+  const parsedMax = Number(options.maxSelections ?? choices.length)
+  const minSelections = Number.isFinite(parsedMin) ? Math.max(0, Math.floor(parsedMin)) : 0
+  const maxCap = Number.isFinite(parsedMax) ? Math.max(0, Math.floor(parsedMax)) : choices.length
+  const maxSelections = Math.max(minSelections, Math.min(choices.length, maxCap))
+  const doneLabel = options.doneLabel || '完成选择'
+  const cancelLabel = options.cancelLabel || '取消'
+  const defaultValues = Array.isArray(options.defaultValues) ? options.defaultValues : []
+  const defaultSet = new Set(defaultValues)
+  const selectedValues = choices
+    .map((choice) => choice.value)
+    .filter((value) => defaultSet.has(value))
+    .slice(0, maxSelections)
+
+  if (!isInteractive()) {
+    return selectedValues
+  }
+
+  const selected = new Set(selectedValues)
+  const doneValue = '__prompt_done__'
+  const cancelValue = '__prompt_cancel__'
+
+  while (true) {
+    const menuChoices = choices.map((choice) => ({
+      value: choice.value,
+      label: `${selected.has(choice.value) ? '[x]' : '[ ]'} ${choice.label}`
+    }))
+    menuChoices.push({
+      value: doneValue,
+      label: `${doneLabel}（已选 ${selected.size} 项）`
+    })
+    menuChoices.push({
+      value: cancelValue,
+      label: cancelLabel
+    })
+
+    const defaultChoiceValue = selected.size >= minSelections ? doneValue : choices[0].value
+    const defaultIndex = Math.max(0, menuChoices.findIndex((item) => item.value === defaultChoiceValue))
+    const selectedAction = await chooseOne(`${message}`, menuChoices, defaultIndex)
+
+    if (selectedAction === cancelValue) {
+      return null
+    }
+
+    if (selectedAction === doneValue) {
+      if (selected.size < minSelections) {
+        stdout.write(`至少需要选择 ${minSelections} 项。\n`)
+        continue
+      }
+      return choices
+        .map((choice) => choice.value)
+        .filter((value) => selected.has(value))
+        .slice(0, maxSelections)
+    }
+
+    if (selected.has(selectedAction)) {
+      selected.delete(selectedAction)
+      continue
+    }
+
+    if (selected.size >= maxSelections) {
+      stdout.write(`最多只能选择 ${maxSelections} 项。\n`)
+      continue
+    }
+
+    selected.add(selectedAction)
+  }
+}