@icode-js/icode 3.0.2

package/src/workflows/push-workflow.js

@@ -0,0 +1,276 @@
+import { getRepoPolicy } from '../core/config-store.js'
+import { IcodeError } from '../core/errors.js'
+import { GitService } from '../core/git-service.js'
+import { resolveGitContext } from '../core/git-context.js'
+import { formatAiCommitSummary } from '../core/ai-commit-summary.js'
+import { logger } from '../core/logger.js'
+import { confirm, input } from '../core/prompts.js'
+import { runAiCommitWorkflow } from './ai-commit-workflow.js'
+
+function uniqueBranches(branches) {
+  return [...new Set(branches.map((item) => item.trim()).filter(Boolean))]
+}
+
+// Run AI commit before push and keep the full generated message in follow-up logs.
+async function prepareAiCommitIfEnabled(inputOptions) {
+  if (!inputOptions.aiCommit) {
+    return {
+      enabled: false
+    }
+  }
+
+  if (inputOptions.message?.trim()) {
+    logger.warn('--ai-commit 已启用，将优先使用 AI 生成的提交信息。')
+  }
+
+  try {
+    const result = await runAiCommitWorkflow({
+      apply: true,
+      lang: inputOptions.aiCommitLang || 'zh',
+      profile: inputOptions.aiProfile,
+      repoMode: inputOptions.repoMode,
+      noVerify: inputOptions.noVerify,
+      yes: inputOptions.yes,
+      cwd: inputOptions.cwd,
+      silentContextLog: true
+    })
+
+    if (result.canceled) {
+      logger.warn('已取消 AI 自动提交。')
+      return {
+        enabled: true,
+        canceled: true
+      }
+    }
+
+    logger.success(`AI 自动提交完成:\n${formatAiCommitSummary(result.commitId, result.commitMessage)}`)
+    return {
+      enabled: true,
+      applied: true,
+      commitId: result.commitId,
+      commitMessage: result.commitMessage
+    }
+  } catch (error) {
+    if (error?.code === 'AI_COMMIT_EMPTY_DIFF') {
+      logger.info('未检测到可提交改动，跳过 --ai-commit。')
+      return {
+        enabled: true,
+        skipped: true,
+        reason: 'no-diff'
+      }
+    }
+
+    throw error
+  }
+}
+
+async function prepareCommitIfNeeded(git, options) {
+  const hasChanges = await git.hasChanges()
+  if (!hasChanges) {
+    logger.info('工作区无改动，跳过 commit。')
+    return false
+  }
+
+  let message = options.message?.trim()
+  if (!message) {
+    message = (await input('请输入提交信息', '')).trim()
+  }
+
+  if (!message) {
+    throw new IcodeError('检测到代码改动但未提供提交信息，请使用 -m 或 --message。', {
+      code: 'PUSH_COMMIT_MESSAGE_REQUIRED',
+      exitCode: 2
+    })
+  }
+
+  // 统一自动暂存，降低同学手动 add 的负担。
+  await git.stageAll()
+  await git.commit(message, {
+    noVerify: options.noVerify
+  })
+  logger.success(`提交完成: ${message}`)
+  return true
+}
+
+async function checkoutTargetBranch(git, targetBranch, sourceBranch) {
+  const localExists = await git.branchExistsLocal(targetBranch)
+  const remoteExists = await git.branchExistsRemote(targetBranch)
+  let checkoutMode = 'local'
+
+  if (localExists) {
+    await git.checkout(targetBranch)
+  } else if (remoteExists) {
+    await git.checkoutTracking(targetBranch)
+    checkoutMode = 'tracking'
+  } else {
+    // 目标分支不存在时，默认从 source 分支切出，方便“临时发布分支”场景。
+    logger.warn(`目标分支 ${targetBranch} 不存在，将从 ${sourceBranch} 创建。`)
+    await git.checkoutNewBranch(targetBranch, sourceBranch)
+    checkoutMode = 'created'
+  }
+
+  if (remoteExists) {
+    await git.pull(targetBranch, {
+      allowUnrelatedHistories: true,
+      noRebase: true
+    })
+  }
+
+  return {
+    remoteExists,
+    checkoutMode
+  }
+}
+
+export async function runPushWorkflow(inputOptions) {
+  const context = await resolveGitContext({
+    cwd: inputOptions.cwd,
+    repoMode: inputOptions.repoMode
+  })
+
+  const git = new GitService(context)
+  const policy = getRepoPolicy(context.topLevelPath)
+  const protectedBranches = new Set((policy.protectedBranches || []).map((item) => item.trim()).filter(Boolean))
+
+  logger.info(`仓库根目录: ${context.topLevelPath}`)
+  if (context.inheritedFromParent) {
+    logger.warn('当前目录继承了父级 Git 仓库，命令将基于父仓库根目录执行。')
+  }
+
+  const currentBranch = (await git.getCurrentBranch()) || context.currentBranch
+  if (!currentBranch) {
+    throw new IcodeError('无法识别当前分支，请检查仓库状态。', {
+      code: 'PUSH_BRANCH_UNKNOWN',
+      exitCode: 2
+    })
+  }
+
+  const aiCommitResult = await prepareAiCommitIfEnabled(inputOptions)
+  if (aiCommitResult.canceled) {
+    return {
+      canceled: true,
+      reason: 'ai-commit-canceled',
+      repoRoot: context.topLevelPath,
+      currentBranch,
+      inheritedFromParent: context.inheritedFromParent
+    }
+  }
+
+  const shouldRunManualCommit = !aiCommitResult.applied && aiCommitResult.reason !== 'no-diff'
+  if (shouldRunManualCommit) {
+    await prepareCommitIfNeeded(git, inputOptions)
+  }
+  await git.fetch()
+
+  if (inputOptions.pullMain && context.defaultBranch !== currentBranch) {
+    logger.info(`先同步主分支 ${context.defaultBranch} 到当前分支 ${currentBranch}`)
+    await git.pull(context.defaultBranch, {
+      allowUnrelatedHistories: true,
+      noRebase: true
+    })
+  }
+
+  let branchTargets = uniqueBranches([
+    ...(inputOptions.notPushCurrent ? [] : [currentBranch]),
+    ...(inputOptions.targetBranches || [])
+  ])
+  if (inputOptions.notPushCurrent) {
+    branchTargets = branchTargets.filter((branchName) => branchName !== currentBranch)
+  }
+
+  if (!branchTargets.length) {
+    throw new IcodeError('没有可执行的目标分支。', {
+      code: 'PUSH_EMPTY_TARGETS',
+      exitCode: 2
+    })
+  }
+
+  if (!inputOptions.yes) {
+    const confirmed = await confirm(
+      `确认将 ${currentBranch} 推送/合并到以下分支: ${branchTargets.join(', ')} ?`,
+      true
+    )
+
+    if (!confirmed) {
+      logger.warn('已取消执行。')
+      return {
+        canceled: true,
+        branchTargets,
+        repoRoot: context.topLevelPath
+      }
+    }
+  }
+
+  const summary = []
+  const originalBranch = currentBranch
+
+  try {
+    for (const targetBranch of branchTargets) {
+      if (protectedBranches.has(targetBranch) && !inputOptions.forceProtected) {
+        logger.warn(`跳过受保护分支: ${targetBranch}（可用 --force-protected 覆盖）`)
+        summary.push({ branch: targetBranch, status: 'skipped-protected' })
+        continue
+      }
+
+      logger.info(`处理分支: ${targetBranch}`)
+
+      if (targetBranch === currentBranch) {
+        const remoteExists = await git.branchExistsRemote(targetBranch)
+        if (remoteExists) {
+          logger.info(`同步远程分支: ${targetBranch}`)
+          await git.pull(targetBranch, {
+            allowUnrelatedHistories: true,
+            noRebase: true
+          })
+        }
+
+        logger.info(`推送当前分支: ${targetBranch}`)
+        await git.push(targetBranch, {
+          setUpstream: !remoteExists,
+          noVerify: inputOptions.noVerify
+        })
+
+        logger.success(`推送成功: ${targetBranch}`)
+        summary.push({ branch: targetBranch, status: 'pushed' })
+        continue
+      }
+
+      logger.info(`切换到目标分支: ${targetBranch}`)
+      const { remoteExists, checkoutMode } = await checkoutTargetBranch(git, targetBranch, currentBranch)
+      logger.info(`目标分支准备完成: ${targetBranch} (${checkoutMode})`)
+
+      // 保留 merge commit，方便后续追溯“从哪个分支合并过来”。
+      logger.info(`合并分支: ${currentBranch} -> ${targetBranch}`)
+      await git.merge(currentBranch, {
+        noFf: true,
+        noEdit: true
+      })
+      logger.success(`合并成功: ${currentBranch} -> ${targetBranch}`)
+
+      logger.info(`推送目标分支: ${targetBranch}`)
+      await git.push(targetBranch, {
+        setUpstream: !remoteExists,
+        noVerify: inputOptions.noVerify
+      })
+
+      logger.success(`目标分支推送成功: ${targetBranch}`)
+      summary.push({ branch: targetBranch, status: 'merged-and-pushed' })
+    }
+  } finally {
+    const branchAfterWorkflow = await git.getCurrentBranch()
+    if (branchAfterWorkflow && branchAfterWorkflow !== originalBranch) {
+      try {
+        await git.checkout(originalBranch)
+      } catch (error) {
+        logger.warn(`未能自动切回原分支 ${originalBranch}: ${error.message}`)
+      }
+    }
+  }
+
+  return {
+    repoRoot: context.topLevelPath,
+    currentBranch,
+    summary,
+    inheritedFromParent: context.inheritedFromParent
+  }
+}

package/src/workflows/rollback-workflow.js

@@ -0,0 +1,84 @@
+import { IcodeError } from '../core/errors.js'
+import { resolveGitContext } from '../core/git-context.js'
+import { GitService } from '../core/git-service.js'
+import { logger } from '../core/logger.js'
+import { confirm } from '../core/prompts.js'
+
+function isRevertConflict(error) {
+  const output = `${error?.meta?.stdout || ''}\n${error?.meta?.stderr || ''}\n${error?.message || ''}`
+  return /revert is already in progress|could not revert|after resolving the conflicts|CONFLICT \(/i.test(output)
+}
+
+export async function runRollbackWorkflow(options) {
+  const mode = options.mode || 'revert'
+  const ref = options.ref || (mode === 'revert' ? 'HEAD' : 'HEAD~1')
+
+  const context = await resolveGitContext({
+    cwd: options.cwd,
+    repoMode: options.repoMode
+  })
+
+  const git = new GitService(context)
+
+  logger.info(`仓库根目录: ${context.topLevelPath}`)
+  if (context.inheritedFromParent) {
+    logger.warn('当前目录继承了父级 Git 仓库，命令将基于父仓库根目录执行。')
+  }
+
+  if (mode === 'revert') {
+    logger.info(`执行回滚(revert): ${ref}`)
+    try {
+      await git.revert(ref)
+    } catch (error) {
+      if (isRevertConflict(error)) {
+        throw new IcodeError(
+          'revert 发生冲突。请解决冲突后执行 `git revert --continue`，或使用 `icode undo --recover abort` 直接中止。',
+          {
+            code: 'REVERT_CONFLICT',
+            cause: error,
+            meta: error.meta
+          }
+        )
+      }
+      throw error
+    }
+    return {
+      mode,
+      ref,
+      repoRoot: context.topLevelPath
+    }
+  }
+
+  if (!['soft', 'mixed', 'hard'].includes(mode)) {
+    throw new IcodeError('mode 仅支持: revert | soft | mixed | hard', {
+      code: 'ROLLBACK_MODE_INVALID',
+      exitCode: 2
+    })
+  }
+
+  if (mode === 'hard' && !options.yes) {
+    // hard reset 会直接丢弃工作区改动，这里强制确认一次降低误操作风险。
+    const accepted = await confirm(
+      `你将执行 git reset --hard ${ref}，这会丢失未提交改动，是否继续？`,
+      false
+    )
+    if (!accepted) {
+      logger.warn('已取消 hard 回滚。')
+      return {
+        canceled: true,
+        mode,
+        ref,
+        repoRoot: context.topLevelPath
+      }
+    }
+  }
+
+  logger.info(`执行回滚(reset --${mode}): ${ref}`)
+  await git.reset(mode, ref)
+
+  return {
+    mode,
+    ref,
+    repoRoot: context.topLevelPath
+  }
+}

package/src/workflows/sync-workflow.js

@@ -0,0 +1,141 @@
+import { IcodeError } from '../core/errors.js'
+import { resolveGitContext } from '../core/git-context.js'
+import { GitService } from '../core/git-service.js'
+import { logger } from '../core/logger.js'
+import { confirm } from '../core/prompts.js'
+
+function unique(list) {
+  return [...new Set(list.map((item) => item.trim()).filter(Boolean))]
+}
+
+async function ensureBranchReady(git, branchName) {
+  const localExists = await git.branchExistsLocal(branchName)
+  const remoteExists = await git.branchExistsRemote(branchName)
+
+  if (!localExists && !remoteExists) {
+    return {
+      available: false,
+      localExists,
+      remoteExists
+    }
+  }
+
+  if (localExists) {
+    await git.checkout(branchName)
+  } else {
+    await git.checkoutTracking(branchName)
+  }
+
+  return {
+    available: true,
+    localExists,
+    remoteExists
+  }
+}
+
+export async function runSyncWorkflow(options) {
+  const context = await resolveGitContext({
+    cwd: options.cwd,
+    repoMode: options.repoMode
+  })
+
+  const git = new GitService(context)
+  const currentBranch = (await git.getCurrentBranch()) || context.currentBranch
+
+  let targetInput = options.branches?.length
+    ? [...options.branches]
+    : [currentBranch, context.defaultBranch]
+
+  if (options.allLocal) {
+    // all-local 场景下自动拉取全部本地分支，降低人工逐个输入分支名的成本。
+    const localBranches = await git.listLocalBranches()
+    targetInput = [...localBranches, ...targetInput]
+  }
+
+  const targets = unique(targetInput)
+
+  if (!targets.length) {
+    throw new IcodeError('没有可同步的分支。', {
+      code: 'SYNC_EMPTY_TARGETS',
+      exitCode: 2
+    })
+  }
+
+  logger.info(`仓库根目录: ${context.topLevelPath}`)
+  if (context.inheritedFromParent) {
+    logger.warn('当前目录继承了父级 Git 仓库，命令将基于父仓库根目录执行。')
+  }
+
+  if (!options.yes) {
+    const ok = await confirm(`确认同步以下分支: ${targets.join(', ')} ?`, true)
+    if (!ok) {
+      logger.warn('已取消同步。')
+      return {
+        canceled: true,
+        targets,
+        repoRoot: context.topLevelPath
+      }
+    }
+  }
+
+  const summary = []
+  await git.fetch()
+  const originalBranch = currentBranch
+
+  try {
+    for (const branchName of targets) {
+      logger.info(`同步分支: ${branchName}`)
+      const setup = await ensureBranchReady(git, branchName)
+
+      if (!setup.available) {
+        logger.warn(`分支不存在(本地+远程): ${branchName}`)
+        summary.push({
+          branch: branchName,
+          status: 'missing'
+        })
+        continue
+      }
+
+      if (setup.remoteExists) {
+        await git.pull(branchName, {
+          noRebase: !options.rebase,
+          allowUnrelatedHistories: true
+        })
+      }
+
+      if (options.mergeMain && branchName !== context.defaultBranch) {
+        // 把最新主分支合入目标分支，降低后续提测/发布时的冲突概率。
+        await git.merge(context.defaultBranch, {
+          noFf: true,
+          noEdit: true
+        })
+      }
+
+      if (options.push) {
+        await git.push(branchName, {
+          setUpstream: !setup.remoteExists,
+          noVerify: options.noVerify
+        })
+      }
+
+      summary.push({
+        branch: branchName,
+        status: options.push ? 'synced-and-pushed' : 'synced'
+      })
+    }
+  } finally {
+    if (originalBranch) {
+      try {
+        await git.checkout(originalBranch)
+      } catch (error) {
+        logger.warn(`未能自动切回原分支 ${originalBranch}: ${error.message}`)
+      }
+    }
+  }
+
+  return {
+    repoRoot: context.topLevelPath,
+    targets,
+    summary
+  }
+}

package/src/workflows/tag-workflow.js

@@ -0,0 +1,64 @@
+import { IcodeError } from '../core/errors.js'
+import { GitService } from '../core/git-service.js'
+import { resolveGitContext } from '../core/git-context.js'
+import { logger } from '../core/logger.js'
+import { input } from '../core/prompts.js'
+
+function todayStamp() {
+  const now = new Date()
+  const year = String(now.getFullYear())
+  const month = String(now.getMonth() + 1).padStart(2, '0')
+  const date = String(now.getDate()).padStart(2, '0')
+  return `${year}${month}${date}`
+}
+
+function nextDailyTag(existingTags, dateStamp) {
+  const prefix = `v${dateStamp}_`
+  const serials = existingTags
+    .filter((tag) => tag.startsWith(prefix))
+    .map((tag) => Number(tag.split('_')[1]))
+    .filter((value) => Number.isFinite(value))
+
+  const max = serials.length ? Math.max(...serials) : 0
+  const next = String(max + 1).padStart(2, '0')
+  return `${prefix}${next}`
+}
+
+export async function runTagWorkflow(options) {
+  const context = await resolveGitContext({
+    cwd: options.cwd,
+    repoMode: options.repoMode
+  })
+
+  const git = new GitService(context)
+  const dateStamp = todayStamp()
+  const candidateTags = await git.listTags(`v${dateStamp}_*`)
+
+  let tagName = options.tagName?.trim() || nextDailyTag(candidateTags, dateStamp)
+  if (!options.tagName) {
+    tagName = (await input('请输入 tag 名称', tagName)).trim() || tagName
+  }
+
+  if (!tagName) {
+    throw new IcodeError('tag 名称不能为空。', {
+      code: 'TAG_NAME_REQUIRED',
+      exitCode: 2
+    })
+  }
+
+  const message = options.message?.trim() || `release: ${tagName}`
+
+  logger.info(`创建 tag: ${tagName}`)
+  await git.createAnnotatedTag(tagName, message, options.fromRef)
+
+  logger.info(`推送 tag: ${tagName}`)
+  await git.pushTag(tagName, {
+    noVerify: options.noVerify
+  })
+
+  return {
+    repoRoot: context.topLevelPath,
+    tagName,
+    message
+  }
+}