@icode-js/icode 3.2.0 → 3.4.0

package/src/workflows/switch-workflow.js

@@ -0,0 +1,171 @@
+import { IcodeError } from '../core/errors.js'
+import { withAutoStash } from '../core/git/autostash.js'
+import { resolveGitContext } from '../core/git/context.js'
+import { assertNoPendingOperation } from '../core/git/preconditions.js'
+import { GitService } from '../core/git/service.js'
+import { chooseOne, isInteractiveTerminal } from '../core/tools/interactive.js'
+
+/**
+ * 模糊匹配打分：完全相等 > 前缀 > 包含 > 子序列，不匹配返回 -1。
+ * 输入为候选与查询词，输出分数。
+ */
+export function fuzzyScore(candidate, query) {
+  const name = String(candidate).toLowerCase()
+  const q = String(query || '').toLowerCase()
+  if (!q) {
+    return 1
+  }
+  if (name === q) {
+    return 1000
+  }
+  const lastSegment = name.split('/').pop()
+  if (name.startsWith(q) || lastSegment.startsWith(q)) {
+    return 500 - name.length
+  }
+  const index = name.indexOf(q)
+  if (index !== -1) {
+    return 300 - index - name.length
+  }
+  let pointer = 0
+  for (const char of name) {
+    if (char === q[pointer]) {
+      pointer += 1
+      if (pointer === q.length) {
+        return 100 - name.length
+      }
+    }
+  }
+  return -1
+}
+
+/**
+ * 列出可切换的分支：本地分支（按最近提交排序）+ 可选的远程分支（本地没有的）。
+ */
+export async function listSwitchCandidates(git, options = {}) {
+  const local = await git.listBranchDetails()
+  const candidates = local.map((item) => ({ ...item, kind: 'local' }))
+
+  if (options.all) {
+    const localNames = new Set(local.map((item) => item.name))
+    const remoteBranches = await git.listRemoteBranches()
+    for (const name of remoteBranches) {
+      if (!localNames.has(name)) {
+        candidates.push({ name, kind: 'remote', relativeDate: '', ahead: 0, behind: 0, gone: false, subject: '', upstream: git.remoteRef(name) })
+      }
+    }
+  }
+
+  return candidates
+}
+
+function formatCandidateLabel(item, currentBranch) {
+  const marks = []
+  if (item.name === currentBranch) {
+    marks.push('当前')
+  }
+  if (item.kind === 'remote') {
+    marks.push('仅远程')
+  }
+  if (item.gone) {
+    marks.push('远程已删除')
+  }
+  if (item.ahead) {
+    marks.push(`↑${item.ahead}`)
+  }
+  if (item.behind) {
+    marks.push(`↓${item.behind}`)
+  }
+  const tail = [item.relativeDate, item.subject].filter(Boolean).join(' · ')
+  return `${item.name}${marks.length ? ` [${marks.join(' ')}]` : ''}${tail ? `  ${tail}` : ''}`
+}
+
+function isDirtyWorktreeError(error) {
+  const text = `${error?.meta?.stderr || ''}\n${error?.message || ''}`
+  return /would be overwritten|Please commit your changes or stash them/i.test(text)
+}
+
+/**
+ * 快速切换分支。
+ * 输入为 { query, create, from, all, autostash, yes }，输出 { branch, previousBranch, mode }。
+ * query='-' 表示切回上一个分支；精确命中直接切；多个候选时交互选择。
+ */
+export async function runSwitchWorkflow(options = {}) {
+  const context = await resolveGitContext({ cwd: options.cwd, repoMode: options.repoMode, remote: options.remote })
+  const git = new GitService(context)
+  const previousBranch = await git.getCurrentBranch()
+  assertNoPendingOperation(await git.getInProgressOperation(), 'sw', 'SWITCH_GIT_OPERATION_IN_PROGRESS')
+
+  const query = String(options.query || '').trim()
+  let target = null
+
+  if (options.create) {
+    if (!query) {
+      throw new IcodeError('新建分支需要分支名: icode sw -c <branch> [--from <base>]', { code: 'SWITCH_BRANCH_REQUIRED', exitCode: 2 })
+    }
+    if (await git.branchExistsLocal(query)) {
+      throw new IcodeError(`分支已存在: ${query}`, { code: 'SWITCH_BRANCH_EXISTS', exitCode: 2 })
+    }
+    target = { name: query, kind: 'create', startPoint: options.from || '' }
+  } else if (query === '-') {
+    target = { name: '-', kind: 'previous' }
+  } else if (query && await git.branchExistsLocal(query)) {
+    target = { name: query, kind: 'local' }
+  } else {
+    const candidates = (await listSwitchCandidates(git, { all: options.all || Boolean(query) }))
+      .map((item) => ({ item, score: fuzzyScore(item.name, query) }))
+      .filter((entry) => entry.score >= 0 && entry.item.name !== previousBranch)
+      .sort((a, b) => b.score - a.score)
+      .map((entry) => entry.item)
+
+    if (!candidates.length) {
+      throw new IcodeError(
+        query ? `没有匹配 "${query}" 的分支。新建请用: icode sw -c ${query}` : '没有其它可切换的分支。',
+        { code: 'SWITCH_NO_MATCH', exitCode: 2 }
+      )
+    }
+
+    if (candidates.length === 1 && query) {
+      target = candidates[0]
+    } else if (options.yes || !isInteractiveTerminal()) {
+      throw new IcodeError(
+        `匹配到多个分支，请写得更具体一些: ${candidates.slice(0, 10).map((item) => item.name).join(', ')}`,
+        { code: 'SWITCH_AMBIGUOUS', exitCode: 2, meta: { candidates: candidates.map((item) => item.name) } }
+      )
+    } else {
+      const picked = await chooseOne(
+        query ? `匹配 "${query}" 的分支：` : '切换到分支（最近使用在前）：',
+        candidates.slice(0, 30).map((item, index) => ({ value: String(index), label: formatCandidateLabel(item, previousBranch) })),
+        0
+      )
+      target = candidates[Number(picked)]
+    }
+  }
+
+  return withAutoStash(git, options.autostash === true, `sw ${target.name}`, async () => {
+    try {
+      if (target.kind === 'create') {
+        await git.switchBranch(target.name, { create: true, startPoint: target.startPoint })
+      } else if (target.kind === 'remote') {
+        await git.switchBranch(target.name, { create: true, startPoint: git.remoteRef(target.name), track: true })
+      } else {
+        await git.switchBranch(target.name)
+      }
+    } catch (error) {
+      if (isDirtyWorktreeError(error)) {
+        throw new IcodeError('未提交的改动会和目标分支冲突，切换已停止。可以加 --autostash 自动暂存后再切换。', {
+          code: 'SWITCH_DIRTY_WORKTREE',
+          exitCode: 2,
+          cause: error
+        })
+      }
+      throw error
+    }
+
+    return {
+      branch: await git.getCurrentBranch(),
+      previousBranch,
+      mode: target.kind,
+      repoRoot: context.topLevelPath
+    }
+  })
+}

package/src/workflows/sync-workflow.js

@@ -1,4 +1,8 @@
 import { IcodeError } from '../core/errors.js'
+import { ui, shortenHome } from '../core/tools/theme.js'
+import { withAutoStash } from '../core/git/autostash.js'
+import { createBackup } from '../core/git/backup.js'
+import { saveOperationState } from '../core/git/operation-state.js'
 import { resolveGitContext } from '../core/git/context.js'
 import {
   assertCleanWorktree,
@@ -8,7 +12,7 @@ import {
   readGitSafetyState
 } from '../core/git/preconditions.js'
 import { GitService } from '../core/git/service.js'
-import { confirm } from '../core/tools/interactive.js'
+import { chooseMany, confirm, isInteractiveTerminal } from '../core/tools/interactive.js'
 import { logger } from '../core/tools/logger.js'
 
 function unique(list) {
@@ -47,7 +51,8 @@ async function ensureBranchReady(git, branchName) {
 export async function runSyncWorkflow(options) {
   const context = await resolveGitContext({
     cwd: options.cwd,
-    repoMode: options.repoMode
+    repoMode: options.repoMode,
+    remote: options.remote
   })
 
   const git = new GitService(context)
@@ -56,12 +61,33 @@ export async function runSyncWorkflow(options) {
   assertOnBranch(currentBranch, 'sync', 'SYNC_DETACHED_HEAD')
   assertNoPendingOperation(safetyState.operation, 'sync', 'SYNC_GIT_OPERATION_IN_PROGRESS')
   assertNoConflictedFiles(safetyState.changes, 'sync', 'SYNC_CONFLICTED_FILES')
-  assertCleanWorktree(safetyState.changes, 'sync', 'SYNC_DIRTY_WORKTREE')
+  if (!options.autostash) {
+    assertCleanWorktree(safetyState.changes, 'sync', 'SYNC_DIRTY_WORKTREE')
+  }
 
   let targetInput = options.branches?.length
     ? [...options.branches]
     : [currentBranch, context.defaultBranch]
 
+  // 交互终端里没指定分支时，直接勾选要同步的本地分支（默认当前分支 + 主分支）。
+  let confirmedByPicker = false
+  if (!options.branches?.length && !options.allLocal && !options.yes && isInteractiveTerminal()) {
+    const details = await git.listBranchDetails()
+    if (details.length > 1) {
+      const picked = await chooseMany('选择要同步的分支', details.map((item) => ({
+        value: item.name,
+        label: item.name,
+        hint: [ui.sync(item.ahead, item.behind), item.gone ? '远程已删除' : '', item.relativeDate].filter(Boolean).join(' · ')
+      })), { defaultValues: targetInput, minSelections: 1, doneLabel: '开始同步' })
+      if (!picked) {
+        logger.warn('已取消同步。')
+        return { canceled: true, targets: [], repoRoot: context.topLevelPath }
+      }
+      targetInput = picked
+      confirmedByPicker = true
+    }
+  }
+
   if (options.allLocal) {
     // all-local 场景下自动拉取全部本地分支，降低人工逐个输入分支名的成本。
     const localBranches = await git.listLocalBranches()
@@ -77,12 +103,12 @@ export async function runSyncWorkflow(options) {
     })
   }
 
-  logger.info(`仓库根目录: ${context.topLevelPath}`)
+  logger.hint(`仓库 ${shortenHome(context.topLevelPath)}`)
   if (context.inheritedFromParent) {
     logger.warn('当前目录继承了父级 Git 仓库，命令将基于父仓库根目录执行。')
   }
 
-  if (!options.yes) {
+  if (!options.yes && !confirmedByPicker) {
     const ok = await confirm(`确认同步以下分支: ${targets.join(', ')} ?`, true)
     if (!ok) {
       logger.warn('已取消同步。')
@@ -94,64 +120,137 @@ export async function runSyncWorkflow(options) {
     }
   }
 
-  const summary = []
   await git.fetch()
   const originalBranch = currentBranch
 
+  // pull/merge 会改动多个本地分支，先记录恢复点。
+  const existingLocal = []
+  for (const branchName of targets) {
+    if (await git.branchExistsLocal(branchName)) {
+      existingLocal.push(branchName)
+    }
+  }
+  const backup = await createBackup(git, {
+    reason: `sync ${targets.join(',')}`,
+    branches: existingLocal,
+    silent: true
+  })
+
+  const summary = await withAutoStash(git, options.autostash === true, `sync ${targets.join(',')}`, () =>
+    runSyncBranches(git, context, targets, options, originalBranch)
+  )
+
+  return {
+    repoRoot: context.topLevelPath,
+    remote: git.remote,
+    targets,
+    backupId: backup.entries.length ? backup.id : '',
+    summary
+  }
+}
+
+// 单个分支的同步步骤，冲突中断后可以从 startAt 指定的步骤接着做。
+const SYNC_STEPS = ['checkout', 'pull', 'merge-main', 'push']
+
+async function syncOneBranch(git, context, branchName, options, startAt = 'checkout') {
+  const from = SYNC_STEPS.indexOf(startAt)
+  let step = startAt
   try {
-    for (const branchName of targets) {
-      logger.info(`同步分支: ${branchName}`)
+    let remoteExists = await git.branchExistsRemote(branchName)
+    if (from <= 0) {
       const setup = await ensureBranchReady(git, branchName)
-
       if (!setup.available) {
-        logger.warn(`分支不存在(本地+远程): ${branchName}`)
-        summary.push({
-          branch: branchName,
-          status: 'missing'
-        })
-        continue
+        logger.warn(`分支不存在(本地+远程): ${ui.branch(branchName)}`)
+        return { branch: branchName, status: 'missing' }
       }
+      remoteExists = setup.remoteExists
+    }
 
-      if (setup.remoteExists) {
-        await git.pull(branchName, {
-          noRebase: !options.rebase,
-          rebase: options.rebase
-        })
-      }
+    if (from <= 1 && remoteExists) {
+      step = 'pull'
+      await git.pull(branchName, {
+        noRebase: !options.rebase,
+        rebase: options.rebase
+      })
+    }
 
-      if (options.mergeMain && branchName !== context.defaultBranch) {
-        // 把最新主分支合入目标分支，降低后续提测/发布时的冲突概率。
-        await git.merge(context.defaultBranch, {
-          noFf: true,
-          noEdit: true
-        })
-      }
+    if (from <= 2 && options.mergeMain && branchName !== context.defaultBranch) {
+      step = 'merge-main'
+      // 把最新主分支合入目标分支，降低后续提测/发布时的冲突概率。
+      await git.merge(context.defaultBranch, {
+        noFf: true,
+        noEdit: true
+      })
+    }
 
-      if (options.push) {
-        await git.push(branchName, {
-          setUpstream: !setup.remoteExists,
-          noVerify: options.noVerify
+    if (options.push) {
+      step = 'push'
+      await git.push(branchName, {
+        setUpstream: !remoteExists,
+        noVerify: options.noVerify
+      })
+    }
+  } catch (error) {
+    error.syncStep = step
+    throw error
+  }
+
+  return {
+    branch: branchName,
+    status: options.push ? 'synced-and-pushed' : 'synced'
+  }
+}
+
+/**
+ * 依次同步多个分支。某个分支发生冲突时保存进度（icode continue 接着做），并留在冲突分支上。
+ * resume = { branch, startAt } 表示从某个分支的某一步继续。
+ */
+export async function runSyncBranches(git, context, targets, options, originalBranch, resume = null) {
+  const summary = []
+  let paused = false
+  try {
+    for (let index = 0; index < targets.length; index += 1) {
+      const branchName = targets[index]
+      const startAt = resume && resume.branch === branchName ? resume.startAt : 'checkout'
+      logger.info(`同步分支: ${ui.branch(branchName)}`)
+      try {
+        summary.push(await syncOneBranch(git, context, branchName, options, startAt))
+      } catch (error) {
+        if (!(await git.getInProgressOperation())) {
+          throw error
+        }
+        // 冲突：记录剩余步骤，下一步从冲突步骤之后开始。
+        const nextStep = SYNC_STEPS[SYNC_STEPS.indexOf(error.syncStep || 'pull') + 1] || 'push'
+        saveOperationState(context, {
+          command: 'sync',
+          originalBranch,
+          currentBranch: branchName,
+          startAt: nextStep,
+          remainingTargets: targets.slice(index + 1),
+          options: {
+            push: Boolean(options.push),
+            mergeMain: Boolean(options.mergeMain),
+            rebase: Boolean(options.rebase),
+            noVerify: Boolean(options.noVerify)
+          },
+          summary
         })
+        paused = true
+        throw new IcodeError(
+          `同步 ${branchName} 时发生冲突，已停在该分支。\n解决冲突后执行 \`icode continue\` 接着同步剩下的分支，或执行 \`icode abort\` 放弃并切回 ${originalBranch}。`,
+          { code: 'SYNC_CONFLICT_PAUSED', exitCode: 2, cause: error, meta: { branch: branchName, summary } }
+        )
       }
-
-      summary.push({
-        branch: branchName,
-        status: options.push ? 'synced-and-pushed' : 'synced'
-      })
     }
   } finally {
-    if (originalBranch) {
+    if (originalBranch && !paused) {
       try {
         await git.checkout(originalBranch)
       } catch (error) {
-        logger.warn(`未能自动切回原分支 ${originalBranch}: ${error.message}`)
+        logger.warn(`未能自动切回原分支 ${ui.branch(originalBranch)}: ${error.message}`)
       }
     }
   }
 
-  return {
-    repoRoot: context.topLevelPath,
-    targets,
-    summary
-  }
+  return summary
 }

package/src/workflows/tag-workflow.js

@@ -1,7 +1,8 @@
 import { IcodeError } from '../core/errors.js'
 import { resolveGitContext } from '../core/git/context.js'
+import { bumpVersion, findLatestVersionTag, formatVersion, inferBump } from '../core/git/semver.js'
 import { GitService } from '../core/git/service.js'
-import { input } from '../core/tools/interactive.js'
+import { chooseOne, input, isInteractiveTerminal } from '../core/tools/interactive.js'
 import { logger } from '../core/tools/logger.js'
 
 function todayStamp() {
@@ -24,19 +25,78 @@ function nextDailyTag(existingTags, dateStamp) {
   return `${prefix}${next}`
 }
 
+/**
+ * 计算下一个语义化版本 tag。
+ * 输入为 GitService 与 { bump, preid, fromRef, prefix }，输出 { tagName, previousTag, bump, commits }。
+ * bump=auto 时按 Conventional Commits 推断（破坏性 -> major，feat -> minor，其它 -> patch）。
+ */
+export async function resolveNextSemverTag(git, options = {}) {
+  const tags = await git.listTagsSorted()
+  const latest = findLatestVersionTag(tags, { prefix: options.prefix, includePrerelease: options.bump === 'prerelease' })
+  const headRef = options.fromRef || 'HEAD'
+  const range = latest ? `${latest.tag}..${headRef}` : headRef
+  const commits = await git.listCommitMessages(range)
+  const bump = options.bump === 'auto' ? inferBump(commits, latest?.version) : options.bump
+  const next = bumpVersion(latest?.version || { prefix: options.prefix ?? 'v', major: 0, minor: 0, patch: 0, prerelease: '' }, bump, options.preid)
+
+  return {
+    tagName: formatVersion(next, latest?.version.prefix ?? options.prefix ?? 'v'),
+    previousTag: latest?.tag || '',
+    bump,
+    commits
+  }
+}
+
 export async function runTagWorkflow(options) {
   const context = await resolveGitContext({
     cwd: options.cwd,
-    repoMode: options.repoMode
+    repoMode: options.repoMode,
+    remote: options.remote
   })
 
   const git = new GitService(context)
-  const dateStamp = todayStamp()
-  const candidateTags = await git.listTags(`v${dateStamp}_*`)
+  let tagName = options.tagName?.trim() || ''
+  let semver = null
+
+  if (!tagName && options.bump) {
+    await git.exec(['fetch', git.remote, '--tags'], { allowFailure: true })
+    semver = await resolveNextSemverTag(git, options)
+    tagName = semver.tagName
+  }
+
+  if (!tagName) {
+    const dateStamp = todayStamp()
+    const candidateTags = await git.listTags(`v${dateStamp}_*`)
+    tagName = nextDailyTag(candidateTags, dateStamp)
+  }
 
-  let tagName = options.tagName?.trim() || nextDailyTag(candidateTags, dateStamp)
-  if (!options.tagName) {
-    tagName = (await input('请输入 tag 名称', tagName)).trim() || tagName
+  // 交互终端里没有指定名字和 --bump 时，列出候选 tag 让用户直接选，不用手输。
+  if (!options.tagName && !options.bump && !options.yes && !options.dryRun && isInteractiveTerminal()) {
+    await git.exec(['fetch', git.remote, '--tags'], { allowFailure: true })
+    const choices = []
+    const seen = new Set()
+    for (const bump of ['auto', 'patch', 'minor', 'major']) {
+      const next = await resolveNextSemverTag(git, { ...options, bump })
+      if (seen.has(next.tagName)) {
+        continue
+      }
+      seen.add(next.tagName)
+      choices.push({
+        value: next.tagName,
+        label: next.tagName,
+        hint: bump === 'auto' ? `按提交推断（${next.bump}）${next.previousTag ? ` · 上一个 ${next.previousTag}` : ''}` : bump
+      })
+      if (bump === 'auto') {
+        semver = next
+      }
+    }
+    choices.push({ value: tagName, label: tagName, hint: '日期命名' })
+    choices.push({ value: '__custom__', label: '自己输入…' })
+    const picked = await chooseOne('选择 tag', choices, 0, { filter: false })
+    tagName = picked === '__custom__' ? (await input('tag 名称', '')).trim() : picked
+    if (semver && tagName !== semver.tagName) {
+      semver = null
+    }
   }
 
   if (!tagName) {
@@ -46,19 +106,45 @@ export async function runTagWorkflow(options) {
     })
   }
 
+  if (await git.tagExists(tagName)) {
+    throw new IcodeError(`tag 已存在: ${tagName}`, { code: 'TAG_EXISTS', exitCode: 2 })
+  }
+
   const message = options.message?.trim() || `release: ${tagName}`
+  const result = {
+    repoRoot: context.topLevelPath,
+    tagName,
+    message,
+    fromRef: options.fromRef || 'HEAD',
+    previousTag: semver?.previousTag || '',
+    bump: semver?.bump || '',
+    pushed: false
+  }
 
-  logger.info(`创建 tag: ${tagName}`)
-  await git.createAnnotatedTag(tagName, message, options.fromRef)
+  if (options.dryRun) {
+    return { ...result, dryRun: true }
+  }
 
-  logger.info(`推送 tag: ${tagName}`)
-  await git.pushTag(tagName, {
-    noVerify: options.noVerify
-  })
+  if (!options.silentLog) {
+    logger.info(`创建 tag: ${tagName}`)
+  }
+  await git.createAnnotatedTag(tagName, message, options.fromRef)
 
-  return {
-    repoRoot: context.topLevelPath,
-    tagName,
-    message
+  if (!options.noPush) {
+    if (!options.silentLog) {
+      logger.info(`推送 tag: ${tagName}`)
+    }
+    try {
+      await git.pushTag(tagName, {
+        noVerify: options.noVerify
+      })
+    } catch (error) {
+      // 推送失败时删掉本地 tag，避免下次重试提示“已存在”。
+      await git.deleteTag(tagName)
+      throw error
+    }
+    result.pushed = true
   }
+
+  return result
 }