fe-build-cli 1.1.0 → 1.2.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fe-build-cli",
-  "version": "1.1.0",
-  "description": "前端项目打包部署 CLI 工具，支持多服务器部署、分支管理、回滚、钉钉通知等功能",
+  "version": "1.2.2",
+  "description": "前端项目打包部署 CLI 工具，支持多服务器部署、分支管理、回滚、钉钉通知、智能处理本地改动等功能",
   "type": "module",
   "main": "src/index.js",
   "bin": {
@@ -27,7 +27,8 @@
     "build",
     "ssh",
     "git",
-    "dingtalk"
+    "dingtalk",
+    "stash"
   ],
   "author": "",
   "license": "MIT",

package/src/cli.js

@@ -11,7 +11,9 @@ import {
   getGitSha,
   executeMainBranchFlow,
   executeCurrentBranchFlow,
-  restoreBranch
+  executeTestBranchFlow,
+  restoreBranch,
+  stashPop
 } from './git-branch.js';
 import {
   sendDeploySuccessNotification,
@@ -169,13 +171,19 @@ fe-build-cli - 前端项目打包部署工具
   --config <路径>    指定配置文件路径
   --current-branch   使用当前分支发布（不切换分支）
   --main-branch      使用主分支发布流程（合并到测试分支再合并到主分支）
+  --test-branch      使用 test 环境发布流程（智能处理本地改动）
+  --merge            test 发布时合并本地改动（提交+推送+合并）
+  --no-merge         test 发布时不合并，使用 stash 储藏本地改动
   --skip-build       跳过构建步骤
-  --no-push          主分支发布时不推送到远程
+  --no-push          发布时不推送到远程
 
 示例:
   fe-build                    # 交互式选择环境部署
   fe-build deploy production  # 部署到生产环境
-  fe-build deploy all         # 部署到所有环境
+  fe-build deploy test        # 部署到测试环境（使用配置的 deployMode）
+  fe-build --test-branch      # test 环境发布（智能处理本地改动）
+  fe-build --test-branch --merge    # test 发布，合并本地改动
+  fe-build --test-branch --no-merge # test 发布，stash 储藏改动
   fe-build --current-branch   # 当前分支发布
   fe-build --main-branch      # 主分支发布流程
   fe-build rollback production # 回滚生产环境
@@ -222,13 +230,18 @@ async function deployCommand(config) {
   const args = process.argv.slice(2);
   const useCurrentBranch = args.includes('--current-branch');
   const useMainBranch = args.includes('--main-branch');
+  const useTestBranch = args.includes('--test-branch');
+  const useMerge = args.includes('--merge');
+  const useNoMerge = args.includes('--no-merge');
   const skipBuild = args.includes('--skip-build');
   const noPush = args.includes('--no-push');
 
   // 确定发布模式
   let deployMode = config.deployMode || 'main'; // 默认主分支发布
 
-  if (useCurrentBranch) {
+  if (useTestBranch) {
+    deployMode = 'test';
+  } else if (useCurrentBranch) {
     deployMode = 'current';
   } else if (useMainBranch) {
     deployMode = 'main';
@@ -268,35 +281,84 @@ async function deployCommand(config) {
 
   // 执行分支发布流程
   let branchResult = null;
-  let originalBranch = null;
+  let originalBranch = getCurrentBranch(); // 记录原始分支
+  let needRestore = false;
+  let hasStash = false;
+  let autoRestore = false;  // 是否自动切回（合并模式）
 
-  if (deployMode === 'main' && !skipBuild) {
-    // 主分支发布模式
-    const branches = config.branches || { test: 'test', main: 'main' };
-    console.log('\n========================================');
-    console.log('  🌿 主分支发布模式');
-    console.log('========================================');
-    console.log(`测试分支: ${branches.test}`);
-    console.log(`主分支: ${branches.main}`);
-    console.log('========================================');
+  // 分支流程（Git 操作）
+  try {
+    if (deployMode === 'test' && !skipBuild) {
+      // test 环境发布模式（智能处理本地改动）
+      const branches = config.branches || { test: 'test', main: 'main' };
+
+      // 确定合并选项
+      let mergeChanges = undefined;
+      if (useMerge) {
+        mergeChanges = true;
+      } else if (useNoMerge) {
+        mergeChanges = false;
+      }
 
-    const confirmAnswer = await prompt('确认执行主分支发布流程? (y/n): ');
-    if (confirmAnswer.toLowerCase() !== 'y') {
-      console.log('已取消发布');
-      process.exit(0);
+      branchResult = await executeTestBranchFlow({
+        testBranch: branches.test,
+        mergeChanges,
+        pushToRemote: !noPush,
+        prompt
+      });
+      originalBranch = branchResult.originalBranch;
+      needRestore = branchResult.needRestore;
+      hasStash = branchResult.hasStash;
+      autoRestore = branchResult.autoRestore || false;
+    } else if (deployMode === 'main' && !skipBuild) {
+      // 主分支发布模式
+      const branches = config.branches || { test: 'test', main: 'main' };
+      console.log('\n========================================');
+      console.log('  🌿 主分支发布模式');
+      console.log('========================================');
+      console.log(`测试分支: ${branches.test}`);
+      console.log(`主分支: ${branches.main}`);
+      console.log('========================================');
+
+      const confirmAnswer = await prompt('确认执行主分支发布流程? (y/n): ');
+      if (confirmAnswer.toLowerCase() !== 'y') {
+        console.log('已取消发布');
+        process.exit(0);
+      }
+
+      branchResult = executeMainBranchFlow({
+        testBranch: branches.test,
+        mainBranch: branches.main,
+        pushToRemote: !noPush
+      });
+      originalBranch = branchResult.originalBranch;
+      needRestore = true;
+    } else if (deployMode === 'current') {
+      // 当前分支发布模式
+      branchResult = executeCurrentBranchFlow();
+      originalBranch = branchResult.currentBranch;
+      needRestore = false;
+      console.log('📌 当前分支发布模式：不切换分支');
     }
+  } catch (branchError) {
+    // 分支流程失败，发送钉钉通知
+    console.error(`❌ 分支流程失败:`, branchError.message);
 
-    branchResult = executeMainBranchFlow({
-      testBranch: branches.test,
-      mainBranch: branches.main,
-      pushToRemote: !noPush
-    });
-    originalBranch = branchResult.originalBranch;
-  } else if (deployMode === 'current') {
-    // 当前分支发布模式
-    branchResult = executeCurrentBranchFlow();
-    originalBranch = branchResult.currentBranch;
-    console.log('📌 当前分支发布模式：不切换分支');
+    if (config.dingtalk && config.dingtalk.enabled && config.dingtalk.webhook) {
+      console.log('\n发送钉钉失败通知...');
+      const envConfig = getServerConfig(config, selectedServers[0] || serverNames[0]);
+      await sendDeployFailureNotification(config.dingtalk.webhook, {
+        environment: selectedServers[0] || serverNames[0],
+        buildVersion: '未完成',
+        serverHost: envConfig?.sshHost || '未知',
+        branch: originalBranch,
+        error: `分支流程失败: ${branchError.message}`
+      });
+    }
+
+    // 切回原分支
+    restoreBranch(originalBranch, hasStash);
+    process.exit(1);
   }
 
   // 生成构建版本
@@ -366,19 +428,30 @@ async function deployCommand(config) {
         });
       }
 
-      // 如果是主分支发布模式，尝试切回原分支
-      if (originalBranch) {
-        restoreBranch(originalBranch);
+      // 出错时切回原分支
+      if (needRestore && originalBranch) {
+        restoreBranch(originalBranch, hasStash);
       }
       process.exit(1);
     }
   }
 
-  // 主分支发布模式：部署完成后切回原分支
-  if (deployMode === 'main' && originalBranch) {
-    const returnAnswer = await prompt('\n是否切回原分支? (y/n): ');
-    if (returnAnswer.toLowerCase() === 'y') {
-      restoreBranch(originalBranch);
+  // 部署完成后切回原分支
+  if (needRestore && originalBranch) {
+    // 合并模式：自动切回原分支
+    if (autoRestore) {
+      console.log('\n📌 自动切回原分支...');
+      restoreBranch(originalBranch, false);
+      console.log(`✅ 已切回 ${originalBranch}，可继续开发`);
+    } else {
+      // stash 模式：询问是否切回
+      const returnAnswer = await prompt('\n是否切回原分支? (y/n): ');
+      if (returnAnswer.toLowerCase() === 'y') {
+        restoreBranch(originalBranch, hasStash);
+      } else if (hasStash) {
+        console.log('\n💡 提示: 本地改动已储藏，执行以下命令恢复:');
+        console.log('   git stash pop');
+      }
     }
   }
 }

package/src/git-branch.js

@@ -127,6 +127,63 @@ export function pushBranch(branchName) {
   }
 }
 
+/**
+ * 储藏本地改动（stash）
+ * @param {string} branchName - 当前分支名（用于备注）
+ * @returns {boolean} 是否成功
+ */
+export function stashChanges(branchName = '') {
+  try {
+    console.log('\n📦 储藏本地改动...');
+    const stashMessage = branchName
+      ? `stash for test deploy from ${branchName}`
+      : 'fe-build-cli-auto-stash';
+    execSync(`git stash push -m "${stashMessage}"`, { stdio: 'inherit' });
+    console.log('✅ 本地改动已储藏');
+    return true;
+  } catch (error) {
+    console.error('❌ 储藏失败:', error.message);
+    return false;
+  }
+}
+
+/**
+ * 恢复储藏的改动（stash pop）
+ * @returns {boolean} 是否成功
+ */
+export function stashPop() {
+  try {
+    console.log('\n📦 恢复储藏的改动...');
+    execSync('git stash pop', { stdio: 'inherit' });
+    console.log('✅ 本地改动已恢复');
+    return true;
+  } catch (error) {
+    console.error('❌ 恢复失败:', error.message);
+    console.log('💡 提示: 可能存在冲突，请手动执行 git stash pop 解决');
+    return false;
+  }
+}
+
+/**
+ * 自动提交当前分支的所有改动
+ * @param {string} message - 提交信息
+ * @returns {boolean} 是否成功
+ */
+export function autoCommit(message) {
+  try {
+    console.log('\n📝 自动提交改动...');
+    // 添加所有改动
+    execSync('git add -A', { stdio: 'inherit' });
+    // 提交
+    execSync(`git commit -m "${message}"`, { stdio: 'inherit' });
+    console.log('✅ 改动已提交');
+    return true;
+  } catch (error) {
+    console.error('❌ 提交失败:', error.message);
+    return false;
+  }
+}
+
 /**
  * 执行主分支发布流程
  * 流程：当前分支 -> 测试分支 -> 主分支
@@ -232,16 +289,208 @@ export function executeCurrentBranchFlow() {
   };
 }
 
+/**
+ * 执行 test 环境发布流程（智能模式）
+ * @param {object} config - 配置
+ * @param {string} config.testBranch - test 分支名
+ * @param {boolean} config.mergeChanges - 是否合并本地改动
+ * @param {boolean} config.pushToRemote - 是否推送到远程
+ * @param {function} config.prompt - 交互提示函数
+ * @returns {object} 执行结果
+ */
+export async function executeTestBranchFlow(config) {
+  const { testBranch, mergeChanges, pushToRemote = true, prompt } = config;
+  const originalBranch = getCurrentBranch();
+  const { clean, changes } = checkUncommittedChanges();
+
+  console.log('\n========================================');
+  console.log('  🌿 Test 环境发布流程');
+  console.log('========================================');
+  console.log(`当前分支: ${originalBranch}`);
+  console.log(`Test 分支: ${testBranch}`);
+  console.log(`工作区状态: ${clean ? '干净' : '有未提交改动'}`);
+  console.log('========================================');
+
+  // 情况1：当前分支本身就是 test
+  if (originalBranch === testBranch) {
+    console.log('\n✓ 当前已在 test 分支');
+    pullBranch(testBranch);
+    return {
+      success: true,
+      originalBranch,
+      currentBranch: testBranch,
+      needRestore: false,
+      hasStash: false
+    };
+  }
+
+  // 情况2：当前分支 ≠ test，无本地改动
+  if (clean) {
+    console.log('\n✓ 无本地改动，直接切换发布');
+    checkoutBranch(testBranch);
+    pullBranch(testBranch);
+    return {
+      success: true,
+      originalBranch,
+      currentBranch: testBranch,
+      needRestore: true,
+      hasStash: false,
+      autoRestore: true  // 无改动模式自动切回
+    };
+  }
+
+  // 情况3：当前分支 ≠ test，有本地改动
+  console.log('\n⚠️ 存在未提交的改动:');
+  changes.forEach(change => console.log(`  ${change}`));
+
+  // 如果已确定合并选项，直接执行
+  if (mergeChanges === true) {
+    return await executeTestMergeFlow(originalBranch, testBranch, pushToRemote);
+  } else if (mergeChanges === false) {
+    return await executeTestStashFlow(originalBranch, testBranch);
+  }
+
+  // 否则交互询问
+  if (prompt) {
+    console.log('\n请选择处理方式:');
+    console.log('  1. 合并改动到 test 发布（提交当前分支，合并到 test）');
+    console.log('  2. 不合并，暂存改动（stash 储藏，用纯净 test 发布）');
+
+    const answer = await prompt('请输入选项 (1/2): ');
+
+    if (answer === '1') {
+      return await executeTestMergeFlow(originalBranch, testBranch, pushToRemote);
+    } else if (answer === '2') {
+      return await executeTestStashFlow(originalBranch, testBranch);
+    } else {
+      throw new Error('无效选项，已取消发布');
+    }
+  }
+
+  throw new Error('存在未提交改动，请选择处理方式');
+}
+
+/**
+ * 执行合并流程（提交当前分支，合并到 test）
+ */
+async function executeTestMergeFlow(originalBranch, testBranch, pushToRemote) {
+  console.log('\n========================================');
+  console.log('  🔀 合并改动发布模式');
+  console.log('========================================');
+
+  try {
+    // 1. 自动提交当前分支改动（备注包含原分支名）
+    const commitMessage = `auto commit: deploy test from ${originalBranch}`;
+    if (!autoCommit(commitMessage)) {
+      throw new Error('自动提交失败');
+    }
+
+    // 2. 推送当前分支到远程
+    if (pushToRemote) {
+      pushBranch(originalBranch);
+    }
+
+    // 3. 切换到 test 分支
+    checkoutBranch(testBranch);
+    pullBranch(testBranch);
+
+    // 4. 合并当前分支到 test
+    if (!mergeBranch(originalBranch, testBranch)) {
+      // 合并冲突，切回原分支
+      checkoutBranch(originalBranch);
+      throw new Error(`合并冲突: ${originalBranch} 到 ${testBranch}，请手动解决冲突后重新发布`);
+    }
+
+    // 5. 推送 test 分支
+    if (pushToRemote) {
+      pushBranch(testBranch);
+    }
+
+    console.log('\n========================================');
+    console.log('✅ 合并发布流程完成');
+    console.log(`当前分支: ${testBranch}`);
+    console.log('========================================');
+
+    return {
+      success: true,
+      originalBranch,
+      currentBranch: testBranch,
+      needRestore: true,
+      hasStash: false,
+      merged: true,
+      autoRestore: true  // 合并模式自动切回
+    };
+  } catch (error) {
+    // 出错时切回原分支
+    try {
+      checkoutBranch(originalBranch);
+    } catch (e) {
+      // 忽略
+    }
+    throw error;
+  }
+}
+
+/**
+ * 执行暂存流程（stash 储藏，用纯净 test 发布）
+ */
+async function executeTestStashFlow(originalBranch, testBranch) {
+  console.log('\n========================================');
+  console.log('  📦 暂存改动发布模式');
+  console.log('========================================');
+
+  try {
+    // 1. 储藏本地改动（备注包含原分支名）
+    if (!stashChanges(originalBranch)) {
+      throw new Error('储藏改动失败');
+    }
+
+    // 2. 切换到 test 分支
+    checkoutBranch(testBranch);
+    pullBranch(testBranch);
+
+    console.log('\n========================================');
+    console.log('✅ 暂存发布流程完成');
+    console.log(`当前分支: ${testBranch}`);
+    console.log('========================================');
+
+    return {
+      success: true,
+      originalBranch,
+      currentBranch: testBranch,
+      needRestore: true,
+      hasStash: true,
+      autoRestore: false  // stash 模式询问是否切回
+    };
+  } catch (error) {
+    // 出错时切回原分支并恢复 stash
+    try {
+      checkoutBranch(originalBranch);
+      stashPop();
+    } catch (e) {
+      // 忽略
+    }
+    throw error;
+  }
+}
+
 /**
  * 发布后切回原分支
  * @param {string} originalBranch - 原分支名
+ * @param {boolean} hasStash - 是否有储藏的改动
  */
-export function restoreBranch(originalBranch) {
+export function restoreBranch(originalBranch, hasStash = false) {
   const currentBranch = getCurrentBranch();
   if (currentBranch !== originalBranch) {
     console.log(`\n📌 切回原分支: ${originalBranch}`);
     checkoutBranch(originalBranch);
   }
+
+  // 如果有储藏的改动，提示恢复
+  if (hasStash) {
+    console.log('\n💡 提示: 本地改动已储藏，执行以下命令恢复:');
+    console.log('   git stash pop');
+  }
 }
 
 export default {
@@ -253,7 +502,11 @@ export default {
   pullBranch,
   mergeBranch,
   pushBranch,
+  stashChanges,
+  stashPop,
+  autoCommit,
   executeMainBranchFlow,
   executeCurrentBranchFlow,
+  executeTestBranchFlow,
   restoreBranch
 };

package/src/index.js

@@ -17,8 +17,12 @@ export {
   pullBranch,
   mergeBranch,
   pushBranch,
+  stashChanges,
+  stashPop,
+  autoCommit,
   executeMainBranchFlow,
   executeCurrentBranchFlow,
+  executeTestBranchFlow,
   restoreBranch
 } from './git-branch.js';