fe-build-cli 1.1.0 → 1.2.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fe-build-cli",
-  "version": "1.1.0",
-  "description": "前端项目打包部署 CLI 工具，支持多服务器部署、分支管理、回滚、钉钉通知等功能",
+  "version": "1.2.3",
+  "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,85 @@ 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}`,
+        keyword: config.dingtalk.keyword || '部署'
+      });
+    }
+
+    // 切回原分支
+    restoreBranch(originalBranch, hasStash);
+    process.exit(1);
   }
 
   // 生成构建版本
@@ -347,7 +410,8 @@ async function deployCommand(config) {
           deployUrl: envConfig.deployUrl,
           branch: currentBranch,
           deployMode,
-          duration: `${duration}秒`
+          duration: `${duration}秒`,
+          keyword: config.dingtalk.keyword || '部署'
         });
       }
     } catch (error) {
@@ -362,23 +426,35 @@ async function deployCommand(config) {
           buildVersion,
           serverHost: envConfig.sshHost,
           branch: currentBranch,
-          error: error.message
+          error: error.message,
+          keyword: config.dingtalk.keyword || '部署'
         });
       }
 
-      // 如果是主分支发布模式，尝试切回原分支
-      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');
+      }
     }
   }
 }
@@ -438,7 +514,8 @@ async function rollbackCommand(config) {
         backupFile: backupFile || '最新备份',
         serverHost: envConfig.sshHost,
         deployUrl: envConfig.deployUrl,
-        success: true
+        success: true,
+        keyword: config.dingtalk.keyword || '部署'
       });
     }
   } catch (error) {
@@ -453,7 +530,8 @@ async function rollbackCommand(config) {
         backupFile: backupFile || '未知',
         serverHost: envConfig.sshHost,
         deployUrl: envConfig.deployUrl,
-        success: false
+        success: false,
+        keyword: config.dingtalk.keyword || '部署'
       });
     }
 

package/src/config-template.js

@@ -78,6 +78,7 @@ export default {
    */
   dingtalk: {
     webhook: 'https://oapi.dingtalk.com/robot/send?access_token=your-token', // 钉钉机器人 webhook URL
-    enabled: true  // 是否启用钉钉通知，默认 true
+    enabled: true,  // 是否启用钉钉通知，默认 true
+    keyword: '部署'  // 安全设置关键词（如果机器人设置了关键词，必须配置此项）
   }
 };

package/src/dingtalk.js

@@ -44,6 +44,7 @@ export async function sendDingTalkMessage(webhookUrl, message) {
  * @param {string} options.branch - 分支名称
  * @param {string} options.deployMode - 发布模式
  * @param {string} options.duration - 部署耗时（可选）
+ * @param {string} options.keyword - 安全关键词（可选）
  */
 export async function sendDeploySuccessNotification(webhookUrl, options) {
   const {
@@ -53,7 +54,8 @@ export async function sendDeploySuccessNotification(webhookUrl, options) {
     deployUrl,
     branch,
     deployMode,
-    duration
+    duration,
+    keyword = '部署'
   } = options;
 
   const now = new Date();
@@ -66,12 +68,15 @@ export async function sendDeploySuccessNotification(webhookUrl, options) {
     second: '2-digit'
   });
 
+  // 标题必须包含关键词，否则钉钉会拒绝
+  const title = `${keyword}成功 - ${environment}`;
+
   const message = {
     msgtype: 'markdown',
     markdown: {
-      title: `部署成功 - ${environment}`,
+      title,
       text: `
-## 🚀 部署成功通知
+## 🚀 ${keyword}成功通知
 
 **环境**: ${environment}
 **状态**: ✅ 成功
@@ -79,15 +84,15 @@ export async function sendDeploySuccessNotification(webhookUrl, options) {
 
 ---
 
-### 部署详情
+### ${keyword}详情
 
 | 项目 | 内容 |
 |:---:|:---|
 | 构建版本 | ${buildVersion} |
 | 发布分支 | ${branch} |
-| 发布模式 | ${deployMode === 'main' ? '主分支发布' : '当前分支发布'} |
+| 发布模式 | ${deployMode === 'main' ? '主分支发布' : deployMode === 'test' ? 'Test环境发布' : '当前分支发布'} |
 | 服务器 | ${serverHost} |
-${duration ? `| 部署耗时 | ${duration} |` : ''}
+${duration ? `| ${keyword}耗时 | ${duration} |` : ''}
 
 ---
 
@@ -95,7 +100,7 @@ ${duration ? `| 部署耗时 | ${duration} |` : ''}
 
 [${deployUrl}](${deployUrl})
 
-> 部署完成，请及时验证功能是否正常。
+> ${keyword}完成，请及时验证功能是否正常。
       `.trim()
     }
   };
@@ -112,6 +117,7 @@ ${duration ? `| 部署耗时 | ${duration} |` : ''}
  * @param {string} options.serverHost - 服务器地址
  * @param {string} options.branch - 分支名称
  * @param {string} options.error - 错误信息
+ * @param {string} options.keyword - 安全关键词（可选）
  */
 export async function sendDeployFailureNotification(webhookUrl, options) {
   const {
@@ -119,7 +125,8 @@ export async function sendDeployFailureNotification(webhookUrl, options) {
     buildVersion,
     serverHost,
     branch,
-    error
+    error,
+    keyword = '部署'
   } = options;
 
   const now = new Date();
@@ -132,12 +139,15 @@ export async function sendDeployFailureNotification(webhookUrl, options) {
     second: '2-digit'
   });
 
+  // 标题必须包含关键词
+  const title = `${keyword}失败 - ${environment}`;
+
   const message = {
     msgtype: 'markdown',
     markdown: {
-      title: `部署失败 - ${environment}`,
+      title,
       text: `
-## ❌ 部署失败通知
+## ❌ ${keyword}失败通知
 
 **环境**: ${environment}
 **状态**: ❌ 失败
@@ -159,7 +169,7 @@ export async function sendDeployFailureNotification(webhookUrl, options) {
 
 ${error}
 
-> 请及时排查问题并重新部署。
+> 请及时排查问题并重新${keyword}。
       `.trim()
     }
   };
@@ -176,6 +186,7 @@ ${error}
  * @param {string} options.serverHost - 服务器地址
  * @param {string} options.deployUrl - 部署后的访问地址
  * @param {boolean} options.success - 是否成功
+ * @param {string} options.keyword - 安全关键词（可选）
  */
 export async function sendRollbackNotification(webhookUrl, options) {
   const {
@@ -183,7 +194,8 @@ export async function sendRollbackNotification(webhookUrl, options) {
     backupFile,
     serverHost,
     deployUrl,
-    success
+    success,
+    keyword = '部署'
   } = options;
 
   const now = new Date();
@@ -196,10 +208,13 @@ export async function sendRollbackNotification(webhookUrl, options) {
     second: '2-digit'
   });
 
+  // 标题必须包含关键词
+  const title = `回滚${success ? '成功' : '失败'} - ${environment}`;
+
   const message = {
     msgtype: 'markdown',
     markdown: {
-      title: `回滚${success ? '成功' : '失败'} - ${environment}`,
+      title,
       text: `
 ## ${success ? '🔄' : '❌'} 回滚${success ? '成功' : '失败'}通知
 
@@ -222,7 +237,7 @@ ${success ? `### 访问地址
 
 [${deployUrl}](${deployUrl})` : ''}
 
-> ${success ? '回滚完成，请验证功能是否正常。' : '回滚失败，请手动处理。'}
+> ${success ? '回滚完成，请验证功能是否正常。' : '回滚失败，请手动处理。'}（${keyword}系统）
       `.trim()
     }
   };

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.d.ts

@@ -48,6 +48,8 @@ export interface DingtalkConfig {
   webhook: string;
   /** 是否启用钉钉通知，默认 true */
   enabled?: boolean;
+  /** 安全设置关键词（如果机器人设置了关键词，必须配置此项） */
+  keyword?: string;
 }
 
 /**

package/src/index.js

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