create-branch-cli 1.0.1 → 1.0.2

package/index.js

@@ -1,396 +1,1240 @@
-#!/usr/bin/env node
-
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const readline = require('readline');
-
-// 配置文件路径（存储在用户主目录）
-const CONFIG_DIR = path.join(require('os').homedir(), '.create-branch');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-
-// 工具函数
-function log(message) {
-  console.log(`[${new Date().toLocaleTimeString()}] ${message}`);
-}
-
-function error(message) {
-  console.error(`[错误] ${message}`);
-}
-
-function success(message) {
-  console.log(`✅ ${message}`);
-}
-
-// 读取配置文件
-function readConfig() {
-  if (!fs.existsSync(CONFIG_FILE)) {
-    return null;
-  }
-  try {
-    const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
-    return JSON.parse(content);
-  } catch (err) {
-    error(`读取配置文件失败: ${err.message}`);
-    return null;
-  }
-}
-
-// 保存配置文件
-function saveConfig(config) {
-  try {
-    // 确保配置目录存在
-    if (!fs.existsSync(CONFIG_DIR)) {
-      fs.mkdirSync(CONFIG_DIR, { recursive: true });
-    }
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
-    return true;
-  } catch (err) {
-    error(`保存配置文件失败: ${err.message}`);
-    return false;
-  }
-}
-
-// 交互式输入
-function question(query) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-
-  return new Promise(resolve => {
-    rl.question(query, answer => {
-      rl.close();
-      resolve(answer);
-    });
-  });
-}
-
-// 首次使用，录入用户信息
-async function initUserInfo() {
-  console.log('\n=== 首次使用，需要录入您的信息 ===\n');
-  
-  const workId = await question('请输入工号: ');
-  if (!workId || !workId.trim()) {
-    error('工号不能为空');
-    process.exit(1);
-  }
-
-  const name = await question('请输入姓名: ');
-  if (!name || !name.trim()) {
-    error('姓名不能为空');
-    process.exit(1);
-  }
-
-  const config = {
-    workId: workId.trim(),
-    name: name.trim()
-  };
-
-  if (saveConfig(config)) {
-    success('用户信息已保存！');
-    return config;
-  } else {
-    error('保存用户信息失败');
-    process.exit(1);
-  }
-}
-
-// 获取当前日期（格式：YYYYMMDD）
-function getCurrentDate() {
-  const now = new Date();
-  const year = now.getFullYear();
-  const month = String(now.getMonth() + 1).padStart(2, '0');
-  const day = String(now.getDate()).padStart(2, '0');
-  return `${year}${month}${day}`;
-}
-
-// 生成分支名
-function generateBranchName(workId, name, title, isBug) {
-  const prefix = isBug ? 'hotFix' : 'feature';
-  const date = getCurrentDate();
-  // 将需求标题中的空格替换为下划线，并移除特殊字符
-  const cleanTitle = title.trim().replace(/\s+/g, '_').replace(/[^\w\u4e00-\u9fa5_-]/g, '');
-  return `${prefix}/${workId}_${name}_${cleanTitle}_${date}`;
-}
-
-// 检查是否在 Git 仓库中
-function isGitRepo() {
-  try {
-    execSync('git rev-parse --git-dir', { stdio: 'ignore' });
-    return true;
-  } catch (err) {
-    return false;
-  }
-}
-
-// 检查分支是否已存在
-function branchExists(branchName) {
-  try {
-    const branches = execSync('git branch -a', { encoding: 'utf-8' });
-    const branchList = branches.split('\n').map(b => b.trim().replace(/^\*\s*/, '').replace(/^remotes\/origin\//, ''));
-    return branchList.includes(branchName);
-  } catch (err) {
-    return false;
-  }
-}
-
-// 获取当前分支名
-function getCurrentBranch() {
-  try {
-    const branch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
-    return branch;
-  } catch (err) {
-    error('无法获取当前分支');
-    throw err;
-  }
-}
-
-// 保存需求信息到配置
-function saveRequirementInfo(config, branchName, requirementId, title) {
-  if (!config.requirements) {
-    config.requirements = {};
-  }
-  config.requirements[branchName] = {
-    id: requirementId,
-    title: title,
-    branchName: branchName
-  };
-  saveConfig(config);
-}
-
-// 创建并切换到新分支
-function createBranch(branchName) {
-  try {
-    // 检查分支是否已存在
-    if (branchExists(branchName)) {
-      error(`分支 ${branchName} 已存在！`);
-      const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-      });
-      
-      return new Promise((resolve, reject) => {
-        rl.question('是否切换到已存在的分支？(y/n): ', answer => {
-          rl.close();
-          if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
-            try {
-              log(`切换到分支: ${branchName}`);
-              execSync(`git checkout ${branchName}`, { stdio: 'inherit' });
-              success(`已切换到分支: ${branchName}`);
-              resolve(true);
-            } catch (err) {
-              error(`切换分支失败: ${err.message}`);
-              reject(err);
-            }
-          } else {
-            log('已取消操作');
-            reject(new Error('用户取消'));
-          }
-        });
-      });
-    }
-
-    // 创建新分支
-    log(`创建新分支: ${branchName}`);
-    execSync(`git checkout -b ${branchName}`, { stdio: 'inherit' });
-    success(`已创建并切换到分支: ${branchName}`);
-    return Promise.resolve(true);
-  } catch (err) {
-    error(`创建分支失败: ${err.message}`);
-    throw err;
-  }
-}
-
-// 重置用户信息
-async function resetUserInfo() {
-  try {
-    console.log('\n=== 重置用户信息 ===\n');
-    
-    const workId = await question('请输入新的工号: ');
-    if (!workId || !workId.trim()) {
-      error('工号不能为空');
-      return false;
-    }
-
-    const name = await question('请输入新的姓名: ');
-    if (!name || !name.trim()) {
-      error('姓名不能为空');
-      return false;
-    }
-
-    // 读取现有配置（保留需求信息）
-    let config = readConfig() || {};
-    
-    // 更新用户信息
-    config.workId = workId.trim();
-    config.name = name.trim();
-
-    if (saveConfig(config)) {
-      success('用户信息已更新！');
-      console.log(`工号: ${config.workId}`);
-      console.log(`姓名: ${config.name}`);
-      return true;
-    } else {
-      error('保存用户信息失败');
-      return false;
-    }
-  } catch (err) {
-    error(`重置用户信息失败: ${err.message}`);
-    return false;
-  }
-}
-
-// 提交并推送代码
-function commitAndPush() {
-  try {
-    // 检查是否在 Git 仓库中
-    if (!isGitRepo()) {
-      error('当前目录不是 Git 仓库！');
-      return false;
-    }
-
-    // 获取当前分支
-    const currentBranch = getCurrentBranch();
-    log(`当前分支: ${currentBranch}`);
-
-    // 读取配置，获取需求信息
-    const config = readConfig();
-    if (!config || !config.requirements || !config.requirements[currentBranch]) {
-      error('当前分支没有保存需求信息！');
-      error('请使用以下格式创建分支：cb <需求标题> <需求唯一标识>');
-      return false;
-    }
-
-    const requirement = config.requirements[currentBranch];
-    const commitMessage = `${requirement.id}:${requirement.title}`;
-
-    // 检查是否有变更
-    try {
-      const status = execSync('git status --porcelain', { encoding: 'utf-8' });
-      if (!status.trim()) {
-        log('没有文件变更，无需提交');
-        return true;
-      }
-    } catch (err) {
-      error('无法获取 Git 状态');
-      return false;
-    }
-
-    // 添加所有更改
-    log('添加所有更改到暂存区...');
-    execSync('git add .', { stdio: 'inherit' });
-
-    // 提交
-    log(`提交更改: ${commitMessage}`);
-    execSync(`git commit -m "${commitMessage}"`, { stdio: 'inherit' });
-
-    // 推送
-    log('推送到远程仓库...');
-    execSync(`git push origin ${currentBranch}`, { stdio: 'inherit' });
-
-    success(`已提交并推送到分支: ${currentBranch}`);
-    return true;
-  } catch (err) {
-    error(`提交或推送失败: ${err.message}`);
-    return false;
-  }
-}
-
-// 主函数
-async function main() {
-  try {
-    // 解析命令行参数
-    const args = process.argv.slice(2);
-    
-    // 检查是否是 push 命令
-    if (args.length > 0 && args[0].toLowerCase() === 'push') {
-      const success = commitAndPush();
-      process.exit(success ? 0 : 1);
-      return;
-    }
-    
-    // 检查是否是 reset 命令
-    if (args.length > 0 && (args[0].toLowerCase() === 'reset' || args[0].toLowerCase() === 'config')) {
-      const success = await resetUserInfo();
-      process.exit(success ? 0 : 1);
-      return;
-    }
-    
-    // 检查是否是 bug 类型
-    const isBug = args.includes('-b') || args.includes('--bug');
-    
-    // 移除标志参数，获取需求标题和需求唯一标识
-    const titleArgs = args.filter(arg => arg !== '-b' && arg !== '--bug');
-    
-    if (titleArgs.length === 0) {
-      console.log('\n用法:');
-      console.log('  create-branch <需求标题>                    # 创建 feature 分支');
-      console.log('  create-branch <需求标题> <需求唯一标识>      # 创建 feature 分支并保存需求信息');
-      console.log('  create-branch <需求标题> -b                 # 创建 hotFix 分支');
-      console.log('  create-branch <需求标题> <需求唯一标识> -b   # 创建 hotFix 分支并保存需求信息');
-      console.log('  create-branch push                          # 提交并推送代码（使用保存的需求信息）');
-      console.log('  create-branch reset                         # 重置工号和姓名');
-      console.log('\n示例:');
-      console.log('  create-branch 用户登录功能');
-      console.log('  create-branch 用户登录功能 PROJ-123');
-      console.log('  create-branch 修复登录bug -b');
-      console.log('  create-branch 修复登录bug PROJ-124 -b');
-      console.log('  create-branch push');
-      console.log('  create-branch reset');
-      console.log('\n别名:');
-      console.log('  cb <需求标题> [需求唯一标识] [-b|--bug]');
-      console.log('  cb push');
-      console.log('  cb reset 或 cb config');
-      process.exit(0);
-    }
-
-    // 检查是否在 Git 仓库中
-    if (!isGitRepo()) {
-      error('当前目录不是 Git 仓库！');
-      process.exit(1);
-    }
-
-    // 读取或初始化用户配置
-    let config = readConfig();
-    if (!config || !config.workId || !config.name) {
-      config = await initUserInfo();
-    }
-
-    // 解析需求标题和需求唯一标识
-    // titleArgs 已经过滤掉了 -b 和 --bug
-    // 如果参数数量 >= 2，则最后一个参数是需求唯一标识
-    let title, requirementId;
-    if (titleArgs.length >= 2) {
-      // 最后一个参数是需求唯一标识
-      requirementId = titleArgs[titleArgs.length - 1];
-      title = titleArgs.slice(0, -1).join(' ');
-    } else {
-      // 只有需求标题
-      title = titleArgs.join(' ');
-      requirementId = null;
-    }
-
-    // 生成分支名
-    const branchName = generateBranchName(config.workId, config.name, title, isBug);
-    log(`生成的分支名: ${branchName}`);
-
-    // 创建分支
-    await createBranch(branchName);
-
-    // 如果提供了需求唯一标识，保存到配置
-    if (requirementId) {
-      saveRequirementInfo(config, branchName, requirementId.trim(), title);
-      success(`已保存需求信息: ${requirementId}:${title}`);
-      log('可以使用 "cb push" 快速提交和推送代码');
-    }
-
-  } catch (err) {
-    error(err.message);
-    process.exit(1);
-  }
-}
-
-// 运行主函数
-main();
-
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const https = require('https');
+const http = require('http');
+
+// 配置文件路径（存储在用户主目录）
+const CONFIG_DIR = path.join(require('os').homedir(), '.create-branch');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+// 工具函数
+function log(message) {
+  console.log(`[${new Date().toLocaleTimeString()}] ${message}`);
+}
+
+function error(message) {
+  console.error(`[错误] ${message}`);
+}
+
+function success(message) {
+  console.log(`✅ ${message}`);
+}
+
+// 验证分支名是否合法（防止命令注入）
+function validateBranchName(branchName) {
+  if (!branchName || !branchName.trim()) {
+    return false;
+  }
+  // Git 分支名规则：不能包含空格、不能以 . 开头、不能包含 ..、不能包含 ~^:?*[]\、不能以 / 结尾
+  // 允许：字母、数字、下划线、连字符、斜杠（用于分隔）
+  const branchNameRegex = /^[a-zA-Z0-9._/-]+$/;
+  const trimmed = branchName.trim();
+  
+  // 基本规则检查
+  if (trimmed.startsWith('.') || 
+      trimmed.includes('..') || 
+      trimmed.endsWith('/') ||
+      trimmed.endsWith('.') ||
+      trimmed.includes('//')) {
+    return false;
+  }
+  
+  // 检查是否包含危险字符
+  if (!branchNameRegex.test(trimmed)) {
+    return false;
+  }
+  
+  // 检查长度（Git 限制分支名长度）
+  if (trimmed.length > 250) {
+    return false;
+  }
+  
+  return true;
+}
+
+// 转义 shell 命令中的特殊字符（用于安全执行 git 命令）
+function escapeShellArg(arg) {
+  // 对于简单的分支名，使用引号包裹即可
+  // 但为了更安全，我们验证分支名合法性，然后直接使用
+  // 因为我们已经验证了分支名，所以这里主要是添加引号防止空格问题
+  return `"${arg.replace(/"/g, '\\"')}"`;
+}
+
+// 读取配置文件
+function readConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    return JSON.parse(content);
+  } catch (err) {
+    error(`读取配置文件失败: ${err.message}`);
+    return null;
+  }
+}
+
+// 保存配置文件
+function saveConfig(config) {
+  try {
+    // 确保配置目录存在
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+    return true;
+  } catch (err) {
+    error(`保存配置文件失败: ${err.message}`);
+    return false;
+  }
+}
+
+// 交互式输入
+function question(query) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise(resolve => {
+    rl.question(query, answer => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+// 首次使用，录入用户信息
+async function initUserInfo() {
+  console.log('\n=== 首次使用，需要录入您的信息 ===\n');
+  
+  const workId = await question('请输入工号: ');
+  if (!workId || !workId.trim()) {
+    error('工号不能为空');
+    process.exit(1);
+  }
+
+  const name = await question('请输入姓名: ');
+  if (!name || !name.trim()) {
+    error('姓名不能为空');
+    process.exit(1);
+  }
+
+  const autoSyncAnswer = await question('是否启用合并后自动拉取主分支？(y/n，默认 n): ');
+  const autoSyncMaster = autoSyncAnswer.toLowerCase() === 'y' || autoSyncAnswer.toLowerCase() === 'yes';
+
+  const config = {
+    workId: workId.trim(),
+    name: name.trim(),
+    autoSyncMaster: autoSyncMaster
+  };
+
+  // 如果启用了自动同步，需要配置 GitLab 信息
+  if (autoSyncMaster) {
+    console.log('\n需要配置 GitLab 信息以支持自动同步功能');
+    const gitlabUrl = await question('请输入 GitLab 地址（例如：https://gitlab.com）: ');
+    const gitlabToken = await question('请输入 GitLab Personal Access Token: ');
+    
+    if (gitlabUrl && gitlabUrl.trim() && gitlabToken && gitlabToken.trim()) {
+      config.gitlab = {
+        url: gitlabUrl.trim().replace(/\/$/, ''), // 移除末尾的斜杠
+        token: gitlabToken.trim()
+      };
+    }
+  }
+
+  if (saveConfig(config)) {
+    success('用户信息已保存！');
+    return config;
+  } else {
+    error('保存用户信息失败');
+    process.exit(1);
+  }
+}
+
+// 获取当前日期（格式：YYYYMMDD）
+function getCurrentDate() {
+  const now = new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const day = String(now.getDate()).padStart(2, '0');
+  return `${year}${month}${day}`;
+}
+
+// 生成分支名
+function generateBranchName(workId, name, title, isBug) {
+  const prefix = isBug ? 'hotfix' : 'feature';
+  const date = getCurrentDate();
+  // 将需求标题中的空格替换为下划线，并移除特殊字符
+  const cleanTitle = title.trim().replace(/\s+/g, '_').replace(/[^\w\u4e00-\u9fa5_-]/g, '');
+  return `${prefix}/${workId}_${name}_${cleanTitle}_${date}`;
+}
+
+// 检查是否在 Git 仓库中
+function isGitRepo() {
+  try {
+    execSync('git rev-parse --git-dir', { stdio: 'ignore' });
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+// 检查分支是否已存在
+function branchExists(branchName) {
+  try {
+    const branches = execSync('git branch -a', { encoding: 'utf-8' });
+    const branchList = branches.split('\n').map(b => b.trim().replace(/^\*\s*/, '').replace(/^remotes\/origin\//, ''));
+    return branchList.includes(branchName);
+  } catch (err) {
+    return false;
+  }
+}
+
+// 获取当前分支名
+function getCurrentBranch() {
+  try {
+    const branch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+    return branch;
+  } catch (err) {
+    error('无法获取当前分支');
+    throw err;
+  }
+}
+
+// 获取当前项目的唯一标识（用于区分不同项目的需求信息）
+function getProjectId() {
+  try {
+    // 使用 Git 远程仓库 URL 作为项目标识
+    const remoteUrl = getRemoteUrl();
+    if (remoteUrl) {
+      // 提取项目路径部分作为标识
+      const projectPath = parseGitLabProjectPath(remoteUrl);
+      if (projectPath) {
+        return projectPath.projectPath.replace(/\//g, '_');
+      }
+      // 如果没有 GitLab 格式，使用整个 URL（去除协议和 .git）
+      return remoteUrl.replace(/^https?:\/\//, '').replace(/\.git$/, '').replace(/[\/:]/g, '_');
+    }
+    // 如果没有远程仓库，使用当前工作目录的绝对路径
+    return require('crypto').createHash('md5').update(process.cwd()).digest('hex').substring(0, 8);
+  } catch (err) {
+    // 如果出错，使用当前目录的哈希值
+    return require('crypto').createHash('md5').update(process.cwd()).digest('hex').substring(0, 8);
+  }
+}
+
+// 获取项目的目标分支名
+function getProjectTargetBranch(config) {
+  if (!config) {
+    return null;
+  }
+  const projectId = getProjectId();
+  if (config.projects && config.projects[projectId] && config.projects[projectId].targetBranch) {
+    return config.projects[projectId].targetBranch;
+  }
+  return null;
+}
+
+// 保存项目的目标分支名
+function saveProjectTargetBranch(config, targetBranch) {
+  if (!config) {
+    error('配置对象不能为空');
+    return false;
+  }
+  if (!validateBranchName(targetBranch)) {
+    error('目标分支名不合法，请使用字母、数字、下划线、连字符和斜杠');
+    return false;
+  }
+  const projectId = getProjectId();
+  if (!config.projects) {
+    config.projects = {};
+  }
+  if (!config.projects[projectId]) {
+    config.projects[projectId] = {};
+  }
+  config.projects[projectId].targetBranch = targetBranch.trim();
+  return saveConfig(config);
+}
+
+// 保存需求信息到配置
+function saveRequirementInfo(config, branchName, requirementId, title) {
+  if (!config) {
+    error('配置对象不能为空');
+    return false;
+  }
+  if (!validateBranchName(branchName)) {
+    error(`分支名不合法: ${branchName}`);
+    return false;
+  }
+  const projectId = getProjectId();
+  if (!config.requirements) {
+    config.requirements = {};
+  }
+  if (!config.requirements[projectId]) {
+    config.requirements[projectId] = {};
+  }
+  config.requirements[projectId][branchName] = {
+    id: requirementId,
+    title: title,
+    branchName: branchName
+  };
+  return saveConfig(config);
+}
+
+// 获取需求信息
+function getRequirementInfo(config, branchName) {
+  if (!config || !config.requirements) {
+    return null;
+  }
+  const projectId = getProjectId();
+  if (config.requirements[projectId] && config.requirements[projectId][branchName]) {
+    return config.requirements[projectId][branchName];
+  }
+  // 兼容旧格式（全局存储的需求信息）
+  if (config.requirements[branchName]) {
+    return config.requirements[branchName];
+  }
+  return null;
+}
+
+// 创建并切换到新分支
+function createBranch(branchName) {
+  try {
+    // 检查分支是否已存在
+    if (branchExists(branchName)) {
+      error(`分支 ${branchName} 已存在！`);
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      
+      return new Promise((resolve, reject) => {
+        rl.question('是否切换到已存在的分支？(y/n): ', answer => {
+          rl.close();
+          if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+            try {
+              // 验证分支名合法性
+              if (!validateBranchName(branchName)) {
+                error(`分支名不合法: ${branchName}`);
+                reject(new Error('分支名不合法'));
+                return;
+              }
+              log(`切换到分支: ${branchName}`);
+              execSync(`git checkout ${escapeShellArg(branchName)}`, { stdio: 'inherit' });
+              success(`已切换到分支: ${branchName}`);
+              resolve(true);
+            } catch (err) {
+              error(`切换分支失败: ${err.message}`);
+              reject(err);
+            }
+          } else {
+            log('已取消操作');
+            reject(new Error('用户取消'));
+          }
+        });
+      });
+    }
+
+    // 验证分支名合法性
+    if (!validateBranchName(branchName)) {
+      error(`分支名不合法: ${branchName}`);
+      throw new Error('分支名不合法');
+    }
+    
+    // 创建新分支（使用引号包裹分支名，防止空格问题）
+    log(`创建新分支: ${branchName}`);
+    execSync(`git checkout -b ${escapeShellArg(branchName)}`, { stdio: 'inherit' });
+    success(`已创建并切换到分支: ${branchName}`);
+    return Promise.resolve(true);
+  } catch (err) {
+    error(`创建分支失败: ${err.message}`);
+    throw err;
+  }
+}
+
+// 设置项目的目标分支名
+async function setProjectTargetBranch() {
+  try {
+    // 检查是否在 Git 仓库中
+    if (!isGitRepo()) {
+      error('当前目录不是 Git 仓库！');
+      return false;
+    }
+
+    const config = readConfig();
+    if (!config) {
+      error('配置不存在，请先运行 cb config 进行初始化');
+      return false;
+    }
+
+    const currentTargetBranch = getProjectTargetBranch(config);
+    console.log('\n=== 设置项目的目标分支名 ===\n');
+    
+    if (currentTargetBranch) {
+      console.log(`当前目标分支: ${currentTargetBranch}`);
+    } else {
+      console.log('当前未设置目标分支');
+    }
+    
+    const targetBranch = await question('请输入新的目标分支名（例如：master、main）: ');
+    if (!targetBranch || !targetBranch.trim()) {
+      error('目标分支名不能为空');
+      return false;
+    }
+
+    if (!validateBranchName(targetBranch)) {
+      error('目标分支名不合法，请使用字母、数字、下划线、连字符和斜杠');
+      return false;
+    }
+
+    if (saveProjectTargetBranch(config, targetBranch.trim())) {
+      success(`已设置目标分支: ${targetBranch.trim()}`);
+      return true;
+    } else {
+      error('保存目标分支失败');
+      return false;
+    }
+  } catch (err) {
+    error(`设置目标分支失败: ${err.message}`);
+    return false;
+  }
+}
+
+// 配置用户信息
+async function configUserInfo() {
+  try {
+    console.log('\n=== 配置用户信息 ===\n');
+    
+    const workId = await question('请输入新的工号: ');
+    if (!workId || !workId.trim()) {
+      error('工号不能为空');
+      return false;
+    }
+
+    const name = await question('请输入新的姓名: ');
+    if (!name || !name.trim()) {
+      error('姓名不能为空');
+      return false;
+    }
+
+    // 读取现有配置（保留需求信息和现有设置）
+    let config = readConfig() || {};
+    
+    // 询问是否启用自动同步主分支
+    const currentSyncSetting = config.autoSyncMaster ? '已启用' : '未启用';
+    const autoSyncAnswer = await question(`是否启用合并后自动拉取主分支？(当前: ${currentSyncSetting}, y/n): `);
+    const autoSyncMaster = autoSyncAnswer.toLowerCase() === 'y' || autoSyncAnswer.toLowerCase() === 'yes';
+    
+    // 更新用户信息
+    config.workId = workId.trim();
+    config.name = name.trim();
+    config.autoSyncMaster = autoSyncMaster;
+    
+    // 移除旧的 autoSwitchToMaster 配置（如果存在）
+    if (config.autoSwitchToMaster !== undefined) {
+      delete config.autoSwitchToMaster;
+    }
+
+    // 如果启用了自动同步，需要配置或更新 GitLab 信息
+    if (autoSyncMaster) {
+      if (!config.gitlab || !config.gitlab.url || !config.gitlab.token) {
+        console.log('\n需要配置 GitLab 信息');
+        const gitlabUrl = await question('请输入 GitLab 地址（例如：https://gitlab.com）: ');
+        const gitlabToken = await question('请输入 GitLab Personal Access Token: ');
+        
+        if (gitlabUrl && gitlabUrl.trim() && gitlabToken && gitlabToken.trim()) {
+          config.gitlab = {
+            url: gitlabUrl.trim().replace(/\/$/, ''),
+            token: gitlabToken.trim()
+          };
+        }
+      } else {
+        const updateGitlab = await question('是否更新 GitLab 配置？(y/n，默认 n): ');
+        if (updateGitlab.toLowerCase() === 'y' || updateGitlab.toLowerCase() === 'yes') {
+          const gitlabUrl = await question(`请输入 GitLab 地址（当前: ${config.gitlab.url}）: `);
+          const gitlabToken = await question('请输入 GitLab Personal Access Token（留空保持原值）: ');
+          
+          if (gitlabUrl && gitlabUrl.trim()) {
+            config.gitlab.url = gitlabUrl.trim().replace(/\/$/, '');
+          }
+          if (gitlabToken && gitlabToken.trim()) {
+            config.gitlab.token = gitlabToken.trim();
+          }
+        }
+      }
+    }
+
+    if (saveConfig(config)) {
+      success('用户信息已更新！');
+      console.log(`工号: ${config.workId}`);
+      console.log(`姓名: ${config.name}`);
+      console.log(`自动同步主分支: ${autoSyncMaster ? '已启用' : '未启用'}`);
+      return true;
+    } else {
+      error('保存用户信息失败');
+      return false;
+    }
+  } catch (err) {
+    error(`配置用户信息失败: ${err.message}`);
+    return false;
+  }
+}
+
+// 获取 Git 远程仓库 URL
+function getRemoteUrl() {
+  try {
+    const url = execSync('git config --get remote.origin.url', { encoding: 'utf-8' }).trim();
+    return url;
+  } catch (err) {
+    return null;
+  }
+}
+
+// 从 Git URL 解析 GitLab 项目路径
+function parseGitLabProjectPath(gitUrl) {
+  // 支持多种格式：
+  // https://gitlab.com/group/project.git
+  // git@gitlab.com:group/project.git
+  // https://gitlab.example.com/group/project.git
+  
+  let match;
+  if (gitUrl.startsWith('http://') || gitUrl.startsWith('https://')) {
+    match = gitUrl.match(/https?:\/\/([^\/]+)\/(.+?)(?:\.git)?$/);
+    if (match) {
+      return {
+        host: match[1],
+        projectPath: match[2]
+      };
+    }
+  } else if (gitUrl.startsWith('git@')) {
+    match = gitUrl.match(/git@([^:]+):(.+?)(?:\.git)?$/);
+    if (match) {
+      return {
+        host: match[1],
+        projectPath: match[2]
+      };
+    }
+  }
+  return null;
+}
+
+// 调用 GitLab API
+function gitlabApiRequest(config, endpoint, method = 'GET', data = null) {
+  return new Promise((resolve, reject) => {
+    if (!config.gitlab || !config.gitlab.url || !config.gitlab.token) {
+      reject(new Error('GitLab 配置不完整，请运行 cb config 进行配置'));
+      return;
+    }
+
+    const projectPath = parseGitLabProjectPath(getRemoteUrl());
+    if (!projectPath) {
+      reject(new Error('无法解析 GitLab 项目路径'));
+      return;
+    }
+
+    // 构建完整的 API URL
+    const apiUrl = `${config.gitlab.url}/api/v4/projects/${encodeURIComponent(projectPath.projectPath)}${endpoint}`;
+    const url = new URL(apiUrl);
+    
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: url.pathname + url.search,
+      method: method,
+      headers: {
+        'PRIVATE-TOKEN': config.gitlab.token,
+        'Content-Type': 'application/json'
+      }
+    };
+
+    const protocol = url.protocol === 'https:' ? https : http;
+    
+    const req = protocol.request(options, (res) => {
+      let responseData = '';
+      
+      res.on('data', (chunk) => {
+        responseData += chunk;
+      });
+      
+      res.on('end', () => {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          try {
+            resolve(JSON.parse(responseData));
+          } catch (err) {
+            resolve(responseData);
+          }
+        } else {
+          reject(new Error(`GitLab API 错误: ${res.statusCode} - ${responseData}`));
+        }
+      });
+    });
+
+    req.on('error', (err) => {
+      reject(err);
+    });
+
+    // 如果有请求体数据，发送数据
+    if (data && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+      req.write(JSON.stringify(data));
+    }
+
+    req.end();
+  });
+}
+
+// 创建合并请求
+async function createMergeRequest(sourceBranch, targetBranch, title, description = '') {
+  try {
+    const config = readConfig();
+    if (!config || !config.gitlab || !config.gitlab.url || !config.gitlab.token) {
+      throw new Error('GitLab 配置不完整，请运行 cb config 进行配置');
+    }
+
+    // 检查是否已存在合并请求
+    const existingMRs = await gitlabApiRequest(config, `/merge_requests?source_branch=${encodeURIComponent(sourceBranch)}&state=opened`);
+    if (existingMRs && existingMRs.length > 0) {
+      log(`合并请求已存在: MR #${existingMRs[0].iid}`);
+      return existingMRs[0];
+    }
+
+    // 创建新的合并请求
+    const mrData = {
+      source_branch: sourceBranch,
+      target_branch: targetBranch,
+      title: title,
+      description: description,
+      remove_source_branch: true, // 自动删除源分支
+      squash: true // 合并时压缩提交
+    };
+
+    log('创建合并请求...');
+    const mergeRequest = await gitlabApiRequest(config, '/merge_requests', 'POST', mrData);
+    success(`合并请求已创建: MR #${mergeRequest.iid}`);
+    return mergeRequest;
+  } catch (err) {
+    error(`创建合并请求失败: ${err.message}`);
+    throw err;
+  }
+}
+
+// 打开浏览器
+function openBrowser(url) {
+  try {
+    // 验证 URL 格式
+    if (!url || typeof url !== 'string') {
+      error('URL 无效');
+      return false;
+    }
+    
+    // 基本 URL 验证
+    try {
+      new URL(url);
+    } catch (err) {
+      error(`URL 格式无效: ${url}`);
+      return false;
+    }
+    
+    const platform = process.platform;
+    let command;
+    
+    if (platform === 'win32') {
+      // Windows: 转义 URL 中的特殊字符
+      const escapedUrl = url.replace(/"/g, '\\"');
+      command = `start "" "${escapedUrl}"`;
+    } else if (platform === 'darwin') {
+      // macOS: 转义 URL 中的特殊字符
+      const escapedUrl = url.replace(/"/g, '\\"');
+      command = `open "${escapedUrl}"`;
+    } else {
+      // Linux: 转义 URL 中的特殊字符
+      const escapedUrl = url.replace(/"/g, '\\"');
+      command = `xdg-open "${escapedUrl}"`;
+    }
+    
+    execSync(command, { stdio: 'ignore' });
+    return true;
+  } catch (err) {
+    log(`无法自动打开浏览器: ${err.message}`);
+    log(`请手动访问: ${url}`);
+    return false;
+  }
+}
+
+// 检查合并请求状态
+async function checkMergeRequestStatus(branchName, config) {
+  try {
+    // 先查询所有状态的合并请求（包括已合并的）
+    const allMRs = await gitlabApiRequest(config, `/merge_requests?source_branch=${encodeURIComponent(branchName)}&per_page=10`);
+    
+    if (allMRs && allMRs.length > 0) {
+      // 优先查找已合并的合并请求
+      const mergedMR = allMRs.find(mr => mr.state === 'merged');
+      if (mergedMR) {
+        return {
+          merged: true,
+          mergeRequest: mergedMR
+        };
+      }
+      
+      // 查找打开的合并请求
+      const openMR = allMRs.find(mr => mr.state === 'opened');
+      if (openMR) {
+        return {
+          merged: false,
+          mergeRequest: openMR,
+          hasOpenMR: true
+        };
+      }
+      
+      // 如果有其他状态的合并请求（如 closed），也返回
+      return {
+        merged: false,
+        mergeRequest: allMRs[0],
+        hasOpenMR: false
+      };
+    }
+    
+    return {
+      merged: false,
+      hasOpenMR: false
+    };
+  } catch (err) {
+    error(`检查合并请求状态失败: ${err.message}`);
+    return null;
+  }
+}
+
+// 拉取最新的目标分支
+function pullTargetBranch(targetBranch) {
+  try {
+    const currentBranch = getCurrentBranch();
+    
+    // 验证目标分支名合法性
+    if (!validateBranchName(targetBranch)) {
+      error(`目标分支名不合法: ${targetBranch}`);
+      return false;
+    }
+    
+    // 如果不在目标分支，先切换
+    if (currentBranch !== targetBranch) {
+      log(`切换到 ${targetBranch} 分支...`);
+      execSync(`git checkout ${escapeShellArg(targetBranch)}`, { stdio: 'inherit' });
+    }
+    
+    // 先 fetch 获取最新信息
+    log('获取远程最新信息...');
+    execSync(`git fetch origin ${escapeShellArg(targetBranch)}`, { stdio: 'inherit' });
+    
+    // 使用 rebase 方式拉取，避免产生 merge commit
+    log(`使用 rebase 方式拉取最新的 ${targetBranch} 代码...`);
+    try {
+      execSync(`git pull --rebase origin ${escapeShellArg(targetBranch)}`, { stdio: 'inherit' });
+    } catch (err) {
+      // 如果 rebase 失败，可能是本地有未提交的更改
+      // 尝试先检查状态
+      const status = execSync('git status --porcelain', { encoding: 'utf-8' });
+      if (status.trim()) {
+        error('本地有未提交的更改，无法拉取代码');
+        error('请先提交或暂存本地更改');
+        return false;
+      }
+      // 如果没有未提交的更改，可能是 rebase 冲突
+      error(`拉取失败: ${err.message}`);
+      log('提示：如果遇到冲突，请手动解决后运行 "git rebase --continue"');
+      return false;
+    }
+    
+    success(`已拉取最新的 ${targetBranch} 代码`);
+    return true;
+  } catch (err) {
+    error(`拉取目标分支失败: ${err.message}`);
+    return false;
+  }
+}
+
+// 检查并同步主分支（如果合并请求已合并）
+async function checkAndSyncMaster(branchName = null, silent = false) {
+  try {
+    // 检查是否在 Git 仓库中
+    if (!isGitRepo()) {
+      error('当前目录不是 Git 仓库！');
+      return false;
+    }
+
+    const config = readConfig();
+    if (!config || !config.autoSyncMaster) {
+      if (!silent) {
+        log('自动同步功能未启用');
+      }
+      return false;
+    }
+
+    if (!config.gitlab || !config.gitlab.url || !config.gitlab.token) {
+      error('GitLab 配置不完整，请运行 cb config 进行配置');
+      return false;
+    }
+
+    // 如果没有指定分支名，使用当前分支
+    const sourceBranch = branchName || getCurrentBranch();
+    if (!silent) {
+      log(`检查分支 ${sourceBranch} 的合并请求状态...`);
+    }
+
+    const status = await checkMergeRequestStatus(sourceBranch, config);
+    
+    if (!status) {
+      return false;
+    }
+
+    if (status.merged) {
+      success(`合并请求已合并！MR #${status.mergeRequest.iid}`);
+      // 获取目标分支名
+      const projectTargetBranch = getProjectTargetBranch(config);
+      if (!projectTargetBranch) {
+        error('未配置项目的目标分支，请先运行 cb push 或 cb set-target');
+        return false;
+      }
+      return pullTargetBranch(projectTargetBranch);
+    } else if (status.hasOpenMR) {
+      if (!silent) {
+        log(`合并请求尚未合并，状态: ${status.mergeRequest.state}`);
+        log(`MR #${status.mergeRequest.iid}: ${status.mergeRequest.web_url}`);
+      }
+      return false;
+    } else {
+      if (!silent) {
+        log('未找到相关的合并请求');
+      }
+      return false;
+    }
+  } catch (err) {
+    if (!silent) {
+      error(`检查合并状态失败: ${err.message}`);
+    }
+    return false;
+  }
+}
+
+// 轮询检查合并状态
+async function watchMergeStatus(branchName = null, intervalSeconds = 30, maxAttempts = null) {
+  try {
+    // 检查是否在 Git 仓库中
+    if (!isGitRepo()) {
+      error('当前目录不是 Git 仓库！');
+      return false;
+    }
+
+    const config = readConfig();
+    if (!config || !config.autoSyncMaster) {
+      error('自动同步功能未启用，请运行 cb config 启用');
+      return false;
+    }
+
+    if (!config.gitlab || !config.gitlab.url || !config.gitlab.token) {
+      error('GitLab 配置不完整，请运行 cb config 进行配置');
+      return false;
+    }
+
+    const targetBranch = branchName || getCurrentBranch();
+    log(`开始轮询检查分支 ${targetBranch} 的合并状态...`);
+    log(`检查间隔: ${intervalSeconds} 秒`);
+    if (maxAttempts) {
+      log(`最大检查次数: ${maxAttempts}`);
+    } else {
+      log('将一直检查直到合并或手动停止（Ctrl+C）');
+    }
+    log('');
+
+    let attempts = 0;
+    let isCompleted = false;
+    let checkInterval = null;
+
+    // 执行检查的函数
+    const performCheck = async () => {
+      attempts++;
+      
+      if (maxAttempts && attempts > maxAttempts) {
+        if (checkInterval) {
+          clearInterval(checkInterval);
+        }
+        log(`已达到最大检查次数 (${maxAttempts})，停止轮询`);
+        isCompleted = true;
+        return;
+      }
+
+      // 检查当前分支是否还是目标分支
+      try {
+        const currentBranch = getCurrentBranch();
+        if (currentBranch !== targetBranch) {
+          if (checkInterval) {
+            clearInterval(checkInterval);
+          }
+          log(`检测到分支已切换：当前分支 ${currentBranch}，目标分支 ${targetBranch}`);
+          log('停止轮询');
+          isCompleted = true;
+          return;
+        }
+      } catch (err) {
+        // 如果获取当前分支失败，继续检查（可能是临时问题）
+        log(`警告：无法获取当前分支，继续检查...`);
+      }
+
+      const timestamp = new Date().toLocaleTimeString();
+      log(`[${timestamp}] 第 ${attempts} 次检查...`);
+      
+      try {
+        const result = await checkAndSyncMaster(targetBranch, true);
+        
+        if (result) {
+          // 已合并并同步成功
+          if (checkInterval) {
+            clearInterval(checkInterval);
+          }
+          success('轮询完成：合并请求已合并，并已同步主分支');
+          isCompleted = true;
+          return;
+        }
+        
+        // 继续等待下一次检查
+        if (!isCompleted) {
+          log(`等待 ${intervalSeconds} 秒后再次检查...\n`);
+        }
+      } catch (err) {
+        error(`检查失败: ${err.message}`);
+        if (!isCompleted) {
+          log(`等待 ${intervalSeconds} 秒后再次检查...\n`);
+        }
+      }
+    };
+
+    // 立即执行第一次检查
+    await performCheck();
+    
+    // 如果第一次检查就完成了，直接返回
+    if (isCompleted) {
+      return true;
+    }
+
+    // 设置定时器继续检查
+    checkInterval = setInterval(async () => {
+      if (!isCompleted) {
+        await performCheck();
+      } else {
+        if (checkInterval) {
+          clearInterval(checkInterval);
+        }
+      }
+    }, intervalSeconds * 1000);
+
+    // 返回一个 Promise，但实际上会一直运行直到完成或用户中断
+    return new Promise((resolve) => {
+      // 处理进程退出信号，清理资源
+      const cleanup = () => {
+        if (checkInterval) {
+          clearInterval(checkInterval);
+        }
+        log('\n轮询已停止');
+      };
+      
+      // 注册清理函数
+      const sigintHandler = () => {
+        cleanup();
+        process.exit(0);
+      };
+      
+      process.on('SIGINT', sigintHandler);
+      process.on('SIGTERM', cleanup);
+    });
+  } catch (err) {
+    error(`轮询检查失败: ${err.message}`);
+    return false;
+  }
+}
+
+// 提交并推送代码
+async function commitAndPush() {
+  try {
+    // 检查是否在 Git 仓库中
+    if (!isGitRepo()) {
+      error('当前目录不是 Git 仓库！');
+      return false;
+    }
+
+    // 获取当前分支
+    const currentBranch = getCurrentBranch();
+    log(`当前分支: ${currentBranch}`);
+
+    // 读取配置，获取需求信息
+    const config = readConfig();
+    const requirement = getRequirementInfo(config, currentBranch);
+    if (!requirement) {
+      error('当前分支没有保存需求信息！');
+      error('请使用以下格式创建分支：cb <需求标题> <需求唯一标识>');
+      return false;
+    }
+    const commitMessage = `${requirement.id}:${requirement.title}`;
+
+    // 检查是否有变更
+    try {
+      const status = execSync('git status --porcelain', { encoding: 'utf-8' });
+      if (!status.trim()) {
+        log('没有文件变更，无需提交');
+        return true;
+      }
+    } catch (err) {
+      error('无法获取 Git 状态');
+      return false;
+    }
+
+    // 添加所有更改
+    log('添加所有更改到暂存区...');
+    execSync('git add .', { stdio: 'inherit' });
+
+    // 验证分支名合法性
+    if (!validateBranchName(currentBranch)) {
+      error(`当前分支名不合法: ${currentBranch}`);
+      return false;
+    }
+    
+    // 提交（转义提交信息中的引号）
+    const escapedCommitMessage = commitMessage.replace(/"/g, '\\"');
+    log(`提交更改: ${commitMessage}`);
+    execSync(`git commit -m "${escapedCommitMessage}"`, { stdio: 'inherit' });
+
+    // 推送
+    log('推送到远程仓库...');
+    execSync(`git push origin ${escapeShellArg(currentBranch)}`, { stdio: 'inherit' });
+
+    success(`已提交并推送到分支: ${currentBranch}`);
+    
+    // 获取或设置项目的目标分支名
+    let targetBranch = getProjectTargetBranch(config);
+    if (!targetBranch) {
+      // 第一次使用，需要询问目标分支名
+      log('\n首次使用，需要配置合并目标分支');
+      targetBranch = await question('请输入合并目标分支名（例如：master、main）: ');
+      if (!targetBranch || !targetBranch.trim()) {
+        error('目标分支名不能为空');
+        return false;
+      }
+      if (!validateBranchName(targetBranch)) {
+        error('目标分支名不合法，请使用字母、数字、下划线、连字符和斜杠');
+        return false;
+      }
+      targetBranch = targetBranch.trim();
+      if (!saveProjectTargetBranch(config, targetBranch)) {
+        error('保存目标分支失败');
+        return false;
+      }
+      success(`已保存目标分支: ${targetBranch}`);
+    }
+    
+    // 如果配置了 GitLab，自动创建合并请求
+    if (config.gitlab && config.gitlab.url && config.gitlab.token) {
+      try {
+        const mergeRequest = await createMergeRequest(
+          currentBranch,
+          targetBranch,
+          `${requirement.id}: ${requirement.title}`,
+          `需求标识: ${requirement.id}\n需求标题: ${requirement.title}`
+        );
+        
+        // 打开浏览器到合并请求页面
+        const mrUrl = mergeRequest.web_url;
+        log(`打开合并请求页面: ${mrUrl}`);
+        openBrowser(mrUrl);
+        log('💡 提示：请在浏览器中确认合并请求，确认无误后点击 Merge 按钮');
+      } catch (err) {
+        log(`创建合并请求失败: ${err.message}`);
+        log('提示：可以手动在 GitLab 上创建合并请求');
+      }
+    }
+    
+    // 如果启用了自动同步，自动开始轮询检查合并状态
+    if (config.autoSyncMaster) {
+      log('\n开始自动轮询检查合并状态...');
+      log('提示：可以使用 Ctrl+C 停止轮询，或使用 "cb sync" 手动检查一次');
+      log('');
+      
+      // 在后台启动轮询（不阻塞）
+      watchMergeStatus(currentBranch, 30, null).catch(err => {
+        log(`轮询检查失败: ${err.message}`);
+      });
+    }
+    
+    return true;
+  } catch (err) {
+    error(`提交或推送失败: ${err.message}`);
+    return false;
+  }
+}
+
+// 主函数
+async function main() {
+  try {
+    // 解析命令行参数
+    const args = process.argv.slice(2);
+    
+    // 检查是否是 push 命令
+    if (args.length > 0 && args[0].toLowerCase() === 'push') {
+      const success = await commitAndPush();
+      process.exit(success ? 0 : 1);
+      return;
+    }
+    
+    // 检查是否是 config 命令
+    if (args.length > 0 && args[0].toLowerCase() === 'config') {
+      const success = await configUserInfo();
+      process.exit(success ? 0 : 1);
+      return;
+    }
+    
+    // 检查是否是 set-target 命令（设置项目的目标分支名）
+    if (args.length > 0 && args[0].toLowerCase() === 'set-target') {
+      const success = await setProjectTargetBranch();
+      process.exit(success ? 0 : 1);
+      return;
+    }
+    
+    // 检查是否是 sync 命令（检查合并状态并同步主分支）
+    if (args.length > 0 && (args[0].toLowerCase() === 'sync' || args[0].toLowerCase() === 'check')) {
+      const success = await checkAndSyncMaster();
+      process.exit(success ? 0 : 1);
+      return;
+    }
+    
+    // 检查是否是 watch 命令（轮询检查合并状态）
+    if (args.length > 0 && (args[0].toLowerCase() === 'watch' || args[0].toLowerCase() === 'poll')) {
+      // 解析参数：cb watch [分支名] [间隔秒数] [最大次数]
+      let branchName = null;
+      let intervalSeconds = 30;
+      let maxAttempts = null;
+      
+      if (args.length > 1) {
+        // 第二个参数可能是分支名或间隔秒数
+        const arg2 = args[1];
+        if (!isNaN(parseInt(arg2))) {
+          intervalSeconds = parseInt(arg2);
+        } else {
+          branchName = arg2;
+        }
+      }
+      
+      if (args.length > 2) {
+        const arg3 = args[2];
+        if (!isNaN(parseInt(arg3))) {
+          if (branchName) {
+            intervalSeconds = parseInt(arg3);
+          } else {
+            maxAttempts = parseInt(arg3);
+          }
+        }
+      }
+      
+      if (args.length > 3) {
+        maxAttempts = parseInt(args[3]);
+      }
+      
+      await watchMergeStatus(branchName, intervalSeconds, maxAttempts);
+      // watch 函数会持续运行，直到合并或用户中断
+      return;
+    }
+    
+    // 检查是否是 bug 类型
+    const isBug = args.includes('-b') || args.includes('--bug');
+    
+    // 移除标志参数，获取需求标题和需求唯一标识
+    const titleArgs = args.filter(arg => arg !== '-b' && arg !== '--bug');
+    
+    if (titleArgs.length === 0) {
+      console.log('\n用法:');
+      console.log('  create-branch <需求标题>                    # 创建 feature 分支');
+      console.log('  create-branch <需求标题> <需求唯一标识>      # 创建 feature 分支并保存需求信息');
+      console.log('  create-branch <需求标题> -b                 # 创建 hotfix 分支');
+      console.log('  create-branch <需求标题> <需求唯一标识> -b   # 创建 hotfix 分支并保存需求信息');
+      console.log('  create-branch push                          # 提交并推送代码（使用保存的需求信息）');
+      console.log('  create-branch config                        # 配置用户信息和选项');
+      console.log('  create-branch set-target                    # 设置项目的目标分支名');
+      console.log('  create-branch sync                          # 检查合并请求状态并同步主分支');
+      console.log('  create-branch watch [间隔秒数] [最大次数]   # 轮询检查合并状态并自动同步');
+      console.log('\n示例:');
+      console.log('  create-branch 用户登录功能');
+      console.log('  create-branch 用户登录功能 PROJ-123');
+      console.log('  create-branch 修复登录bug -b');
+      console.log('  create-branch 修复登录bug PROJ-124 -b');
+      console.log('  create-branch push');
+      console.log('  create-branch config');
+      console.log('  create-branch set-target');
+      console.log('  create-branch sync');
+      console.log('  create-branch watch 30 60                  # 每30秒检查一次，最多60次');
+      console.log('\n别名:');
+      console.log('  cb <需求标题> [需求唯一标识] [-b|--bug]');
+      console.log('  cb push');
+      console.log('  cb config');
+      console.log('  cb set-target                              # 设置项目的目标分支名');
+      console.log('  cb sync 或 cb check');
+      console.log('  cb watch 或 cb poll                        # 轮询检查合并状态');
+      process.exit(0);
+    }
+
+    // 检查是否在 Git 仓库中
+    if (!isGitRepo()) {
+      error('当前目录不是 Git 仓库！');
+      process.exit(1);
+    }
+
+    // 读取或初始化用户配置
+    let config = readConfig();
+    if (!config || !config.workId || !config.name) {
+      config = await initUserInfo();
+    }
+
+    // 解析需求标题和需求唯一标识
+    // titleArgs 已经过滤掉了 -b 和 --bug
+    // 如果参数数量 >= 2，则最后一个参数是需求唯一标识
+    let title, requirementId;
+    if (titleArgs.length >= 2) {
+      // 最后一个参数是需求唯一标识
+      requirementId = titleArgs[titleArgs.length - 1];
+      title = titleArgs.slice(0, -1).join(' ');
+    } else {
+      // 只有需求标题
+      title = titleArgs.join(' ');
+      requirementId = null;
+    }
+
+    // 生成分支名
+    const branchName = generateBranchName(config.workId, config.name, title, isBug);
+    log(`生成的分支名: ${branchName}`);
+
+    // 创建分支
+    await createBranch(branchName);
+
+    // 如果提供了需求唯一标识，保存到配置
+    if (requirementId) {
+      // 确保 config 存在
+      if (!config) {
+        config = readConfig() || {};
+      }
+      if (saveRequirementInfo(config, branchName, requirementId.trim(), title)) {
+        success(`已保存需求信息: ${requirementId}:${title}`);
+        log('可以使用 "cb push" 快速提交和推送代码');
+      } else {
+        error('保存需求信息失败');
+      }
+    }
+
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+
+// 运行主函数
+main();
+