cfix 1.0.0

package/src/git-service.js

@@ -0,0 +1,1278 @@
+const fs = require('fs');
+const path = require('path');
+const ExecUtil = require('./utils/exec');
+const { logger } = require('./logger');
+const RetryUtil = require('./utils/retry');
+
+/**
+ * Git 操作服务
+ */
+class GitService {
+  /**
+   * 获取当前分支信息
+   * @param {string} projectPath - 项目路径
+   * @returns {Object} 分支信息
+   */
+  static getCurrentBranchInfo(projectPath) {
+    try {
+      const currentBranch = ExecUtil.execSync('git rev-parse --abbrev-ref HEAD', {
+        cwd: projectPath,
+      }).trim();
+
+      const commitHash = ExecUtil.execSync('git rev-parse HEAD', {
+        cwd: projectPath,
+      }).trim();
+
+      const commitMessage = ExecUtil.execSync('git log -1 --pretty=%B', {
+        cwd: projectPath,
+      }).trim();
+
+      const remoteUrl = this.getRemoteUrl(projectPath);
+
+      return {
+        branch: currentBranch,
+        commit: commitHash.substring(0, 8),
+        commitFull: commitHash,
+        commitMessage: commitMessage.substring(0, 100),
+        remote: remoteUrl,
+        projectPath
+      };
+    } catch (error) {
+      logger.error('获取分支信息失败:', error);
+      return {
+        branch: 'unknown',
+        commit: 'unknown',
+        projectPath
+      };
+    }
+  }
+
+  /**
+   * 获取远程仓库地址
+   * @param {string} projectPath - 项目路径
+   * @returns {string} 远程地址
+   */
+  static getRemoteUrl(projectPath) {
+    try {
+      return ExecUtil.execSync('git remote get-url origin', {
+        cwd: projectPath,
+      }).trim();
+    } catch {
+      return 'no-remote';
+    }
+  }
+
+  /**
+   * 记录分支操作上下文
+   * @param {string} projectPath - 项目路径
+   * @param {string} operation - 操作名称
+   */
+  static logBranchContext(projectPath, operation) {
+    const branchInfo = this.getCurrentBranchInfo(projectPath);
+    logger.info(`🔧 [${operation}] 分支上下文:`, {
+      operation,
+      currentBranch: branchInfo.branch,
+      commit: branchInfo.commit,
+      remote: branchInfo.remote,
+      projectPath: path.basename(projectPath)
+    });
+  }
+
+  /**
+   * 检查项目是否存在
+   * @param {string} projectPath - 项目路径
+   * @returns {boolean}
+   */
+  static projectExists(projectPath) {
+    return fs.existsSync(projectPath) && fs.existsSync(path.join(projectPath, '.git'));
+  }
+
+  /**
+   * 检测项目的默认分支 (main/master)
+   * @param {string} projectPath - 项目路径
+   * @returns {string} 默认分支名称
+   */
+  static detectDefaultBranch(projectPath) {
+    try {
+      // 1. 尝试从远程获取默认分支
+      try {
+        const remoteHead = ExecUtil.execSync(
+          'git symbolic-ref refs/remotes/origin/HEAD',
+          { cwd: projectPath }
+        ).trim();
+        // 格式: refs/remotes/origin/main
+        const defaultBranch = remoteHead.replace('refs/remotes/origin/', '');
+        logger.debug(`🔍 从远程检测到默认分支: ${defaultBranch}`);
+        return defaultBranch;
+      } catch (err) {
+        logger.debug('无法从远程获取默认分支，尝试本地检测');
+      }
+
+      // 2. 检查本地分支
+      try {
+        ExecUtil.execSync('git rev-parse --verify main', { cwd: projectPath, stdio: 'ignore' });
+        logger.debug('🔍 检测到本地 main 分支');
+        return 'main';
+      } catch (err) {
+        // main 不存在
+      }
+
+      try {
+        ExecUtil.execSync('git rev-parse --verify master', { cwd: projectPath, stdio: 'ignore' });
+        logger.debug('🔍 检测到本地 master 分支');
+        return 'master';
+      } catch (err) {
+        // master 不存在
+      }
+
+      // 3. 都不存在，返回默认值
+      logger.warn('⚠️ 无法检测默认分支，使用 main 作为默认值');
+      return 'main';
+    } catch (error) {
+      logger.error(`❌ 检测默认分支失败: ${error.message}`);
+      return 'main';
+    }
+  }
+
+  /**
+   * 智能准备项目（处理现有项目的各种分支状态）
+   * @param {string} projectPath - 项目路径
+   * @param {string} baseBranch - 基准分支名称（可选，默认自动检测 main/master）
+   * @returns {Promise<Object>} 准备结果 { baseBranch, originalBranch, switched }
+   */
+  static async prepareExistingProject(projectPath, baseBranch = null) {
+    logger.info('🔧 智能准备现有项目...', { projectPath: path.basename(projectPath) });
+
+    // 1. 获取当前状态
+    const branchInfo = this.getCurrentBranchInfo(projectPath);
+    const originalBranch = branchInfo.branch;
+
+    logger.info('📍 当前分支状态:', {
+      branch: originalBranch,
+      commit: branchInfo.commit,
+      remote: branchInfo.remote,
+      projectPath: path.basename(projectPath)
+    });
+
+    // 2. 检测或使用基准分支
+    if (!baseBranch) {
+      baseBranch = this.detectDefaultBranch(projectPath);
+      logger.info(`🔍 自动检测到基准分支: ${baseBranch}`);
+    }
+
+    // 3. 判断当前分支类型
+    const isFeatureBranch = originalBranch.startsWith('fix_') ||
+                           originalBranch.startsWith('feature_') ||
+                           originalBranch.includes('task-');
+
+    const isBaseBranch = originalBranch === baseBranch ||
+                        originalBranch === 'main' ||
+                        originalBranch === 'master';
+
+    let switched = false;
+
+    if (isFeatureBranch) {
+      logger.warn('⚠️ 当前处于功能分支，切换到基准分支以获取最新代码', {
+        currentBranch: originalBranch,
+        baseBranch
+      });
+
+      // 4. 保存当前工作区（如果有未提交的更改）
+      const hasChanges = this.hasUncommittedChanges(projectPath);
+      if (hasChanges) {
+        logger.info('💾 检测到未提交的更改，暂存工作区...');
+        try {
+          ExecUtil.execSync('git stash push -m "Auto stash before switching branch"', {
+            cwd: projectPath,
+          });
+          logger.info('✅ 工作区已暂存');
+        } catch (error) {
+          logger.warn('⚠️ 暂存工作区失败，尝试继续...', { error: error.message });
+        }
+      }
+
+      // 5. 切换到基准分支
+      try {
+        logger.info(`🔀 切换到基准分支: ${baseBranch}`);
+        ExecUtil.execSync(`git checkout ${baseBranch}`, {
+          cwd: projectPath,
+        });
+        switched = true;
+        logger.info(`✅ 已切换到 ${baseBranch} 分支`);
+      } catch (error) {
+        logger.error(`❌ 切换分支失败: ${error.message}`);
+        throw new Error(`无法切换到基准分支 ${baseBranch}: ${error.message}`);
+      }
+
+      // 6. 拉取基准分支最新代码
+      logger.info(`🔄 拉取 ${baseBranch} 分支最新代码...`);
+      await this.pullLatest(projectPath);
+
+    } else if (isBaseBranch) {
+      logger.info('✅ 当前已在基准分支，直接拉取最新代码', {
+        branch: originalBranch
+      });
+
+      // 直接拉取最新代码
+      await this.pullLatest(projectPath);
+
+    } else {
+      logger.warn('⚠️ 当前分支既不是功能分支也不是基准分支，谨慎处理', {
+        currentBranch: originalBranch,
+        baseBranch
+      });
+
+      // 尝试切换到基准分支
+      try {
+        logger.info(`🔀 尝试切换到基准分支: ${baseBranch}`);
+        ExecUtil.execSync(`git checkout ${baseBranch}`, {
+          cwd: projectPath,
+        });
+        switched = true;
+        logger.info(`✅ 已切换到 ${baseBranch} 分支`);
+        await this.pullLatest(projectPath);
+      } catch (error) {
+        logger.error(`❌ 切换分支失败，停留在当前分支: ${error.message}`);
+        // 不抛出错误，允许继续
+      }
+    }
+
+    const finalBranchInfo = this.getCurrentBranchInfo(projectPath);
+    logger.info('📊 项目准备完成:', {
+      originalBranch,
+      currentBranch: finalBranchInfo.branch,
+      baseBranch,
+      switched,
+      commit: finalBranchInfo.commit
+    });
+
+    return {
+      baseBranch,
+      originalBranch,
+      currentBranch: finalBranchInfo.branch,
+      switched
+    };
+  }
+
+  /**
+   * 检查是否有未提交的更改
+   * @param {string} projectPath - 项目路径
+   * @returns {boolean}
+   */
+  static hasUncommittedChanges(projectPath) {
+    try {
+      const status = ExecUtil.execSync('git status --porcelain', {
+        cwd: projectPath,
+      }).trim();
+      return status.length > 0;
+    } catch (error) {
+      logger.warn('检查 Git 状态失败', { error: error.message });
+      return false;
+    }
+  }
+
+  /**
+   * 克隆仓库
+   * @param {string} repoUrl - 仓库地址
+   * @param {string} targetPath - 目标路径
+   */
+  static cloneRepo(repoUrl, targetPath) {
+    logger.info(`📦 克隆仓库: ${repoUrl}`);
+    ExecUtil.execSync(`git clone "${repoUrl}" "${targetPath}"`);
+    logger.info(`✅ 仓库已克隆到: ${targetPath}`);
+  }
+
+  /**
+   * 拉取最新代码（带重试）
+   * @param {string} projectPath - 项目路径
+   */
+  static async pullLatest(projectPath) {
+    // 记录操作前的分支上下文
+    this.logBranchContext(projectPath, 'Pull Latest - Before');
+
+    const branchInfo = this.getCurrentBranchInfo(projectPath);
+    logger.info('🔄 拉取最新代码...', {
+      branch: branchInfo.branch,
+      commit: branchInfo.commit,
+      remote: branchInfo.remote,
+      projectPath: path.basename(projectPath)
+    });
+
+    try {
+      await RetryUtil.withRetry(
+        () => {
+          const output = ExecUtil.execSync('git pull', { cwd: projectPath });
+          logger.debug('Git pull 输出:', { output: output.trim() });
+        },
+        {
+          maxRetries: 3,
+          delay: 2000,
+          operation: 'Git 拉取',
+          shouldRetry: (error) => {
+            // 记录拉取失败的详细信息
+            logger.warn('Git 拉取失败，分析错误原因:', {
+              branch: branchInfo.branch,
+              commit: branchInfo.commit,
+              error: error.message,
+              projectPath: path.basename(projectPath)
+            });
+
+            const message = error.message.toLowerCase();
+
+            // 检查是否是未设置上游分支的错误
+            if (message.includes('no tracking information') ||
+                message.includes('set-upstream-to')) {
+              logger.warn('⚠️ 检测到未设置上游分支，尝试自动修复...', {
+                branch: branchInfo.branch,
+                suggestion: `git branch --set-upstream-to=origin/${branchInfo.branch} ${branchInfo.branch}`
+              });
+
+              // 尝试设置上游分支
+              try {
+                ExecUtil.execSync(`git branch --set-upstream-to=origin/${branchInfo.branch} ${branchInfo.branch}`, {
+                  cwd: projectPath,
+                });
+                logger.info('✅ 已自动设置上游分支，重新拉取...', {
+                  branch: branchInfo.branch
+                });
+                // 重新拉取
+                ExecUtil.execSync('git pull', { cwd: projectPath });
+                return false; // 成功，不需要重试
+              } catch (setupError) {
+                logger.error('❌ 设置上游分支失败:', {
+                  branch: branchInfo.branch,
+                  error: setupError.message
+                });
+              }
+            }
+
+            // 网络错误才重试
+            return message.includes('network') ||
+                   message.includes('timeout') ||
+                   message.includes('connection');
+          }
+        }
+      );
+
+      // 记录操作后的分支上下文
+      this.logBranchContext(projectPath, 'Pull Latest - After');
+
+      const afterInfo = this.getCurrentBranchInfo(projectPath);
+      logger.info('✅ 代码已更新', {
+        branch: afterInfo.branch,
+        fromCommit: branchInfo.commit,
+        toCommit: afterInfo.commit,
+        projectPath: path.basename(projectPath)
+      });
+    } catch (error) {
+      logger.warn('⚠️ 拉取失败，继续使用本地代码', {
+        branch: branchInfo.branch,
+        commit: branchInfo.commit,
+        error: error.message,
+        projectPath: path.basename(projectPath),
+        suggestion: '请检查分支是否有远程跟踪分支或网络连接'
+      });
+    }
+  }
+
+  /**
+   * 创建新分支（使用新的命名规则）
+   * @param {string} projectPath - 项目路径
+   * @param {string} username - 用户名
+   * @param {string} taskId - 任务ID
+   * @param {string|null} baseBranch - 基准分支（可选，默认自动查找 main/master）
+   * @returns {string} 创建的分支名称
+   */
+  static createBranch(projectPath, username, taskId, baseBranch = null) {
+    // 记录操作前的分支上下文
+    this.logBranchContext(projectPath, 'Create Branch - Before');
+
+    // 生成新分支名称: fix_[username]_[taskid]_[timestamp]
+    const timestamp = Date.now();
+    let branchName = `fix_${username}_${taskId}_${timestamp}`;
+
+    logger.info('🌿 开始创建新分支', {
+      username,
+      taskId,
+      baseBranch: baseBranch || 'auto-detect',
+      projectPath: path.basename(projectPath)
+    });
+
+    // 检查分支是否已存在
+    let attempt = 0;
+    while (this.branchExists(projectPath, branchName)) {
+      attempt++;
+
+      if (attempt > 10) {
+        const error = `无法生成唯一分支名，已尝试 ${attempt} 次`;
+        logger.error('❌ ' + error, {
+          username,
+          taskId,
+          lastAttempt: branchName,
+          projectPath: path.basename(projectPath)
+        });
+        throw new Error(error);
+      }
+
+      // 添加随机后缀
+      const randomSuffix = Math.random().toString(36).substr(2, 4);
+      const oldBranchName = branchName;
+      branchName = `fix_${username}_${taskId}_${timestamp}_${randomSuffix}`;
+
+      logger.warn(`⚠️ 分支名冲突，尝试新名称 (尝试 ${attempt}/10)`, {
+        oldName: oldBranchName,
+        newName: branchName,
+        projectPath: path.basename(projectPath)
+      });
+    }
+
+    // 验证分支名称合法性
+    if (!this.validateBranchName(branchName)) {
+      const error = `分支名称不合法: ${branchName}`;
+      logger.error('❌ ' + error, {
+        branchName,
+        projectPath: path.basename(projectPath)
+      });
+      throw new Error(error);
+    }
+
+    logger.info(`📝 分支名称验证通过: ${branchName}`);
+
+    // 如果指定了基准分支，直接使用
+    if (baseBranch) {
+      logger.info(`📌 从基准分支创建: ${baseBranch}`, {
+        targetBranch: branchName,
+        projectPath: path.basename(projectPath)
+      });
+
+      try {
+        // 切换到基准分支前记录当前状态
+        const beforeInfo = this.getCurrentBranchInfo(projectPath);
+
+        ExecUtil.execSync(`git checkout "${baseBranch}"`, { cwd: projectPath });
+
+        const afterCheckoutInfo = this.getCurrentBranchInfo(projectPath);
+        logger.info(`✅ 已切换到基准分支`, {
+          from: beforeInfo.branch,
+          to: afterCheckoutInfo.branch,
+          commit: afterCheckoutInfo.commit,
+          projectPath: path.basename(projectPath)
+        });
+
+        // 拉取最新代码
+        try {
+          ExecUtil.execSync('git pull', { cwd: projectPath });
+          const afterPullInfo = this.getCurrentBranchInfo(projectPath);
+          logger.info('✅ 基准分支已更新到最新', {
+            branch: baseBranch,
+            fromCommit: afterCheckoutInfo.commit,
+            toCommit: afterPullInfo.commit,
+            projectPath: path.basename(projectPath)
+          });
+        } catch (pullError) {
+          logger.warn('⚠️ 拉取基准分支失败，使用本地版本', {
+            branch: baseBranch,
+            error: pullError.message,
+            projectPath: path.basename(projectPath)
+          });
+        }
+      } catch (error) {
+        logger.error(`❌ 切换到基准分支 ${baseBranch} 失败`, {
+          baseBranch,
+          error: error.message,
+          projectPath: path.basename(projectPath),
+          suggestion: `请确认分支 ${baseBranch} 存在`
+        });
+        throw new Error(`基准分支 ${baseBranch} 不存在或无法切换`);
+      }
+    } else {
+      // 自动查找 main 或 master
+      logger.info('🔍 自动查找主分支 (main/master)...', {
+        projectPath: path.basename(projectPath)
+      });
+
+      try {
+        ExecUtil.execSync('git checkout main', { cwd: projectPath });
+        logger.info('✅ 找到并切换到 main 分支', {
+          projectPath: path.basename(projectPath)
+        });
+      } catch {
+        try {
+          ExecUtil.execSync('git checkout master', { cwd: projectPath });
+          logger.info('✅ 找到并切换到 master 分支', {
+            projectPath: path.basename(projectPath)
+          });
+        } catch {
+          const currentInfo = this.getCurrentBranchInfo(projectPath);
+          logger.warn('⚠️ 未找到 main 或 master 分支，使用当前分支', {
+            currentBranch: currentInfo.branch,
+            projectPath: path.basename(projectPath)
+          });
+        }
+      }
+    }
+
+    // 创建并切换到新分支
+    const baseInfo = this.getCurrentBranchInfo(projectPath);
+    logger.info(`🔨 创建新分支: ${branchName}`, {
+      from: baseInfo.branch,
+      commit: baseInfo.commit,
+      projectPath: path.basename(projectPath)
+    });
+
+    try {
+      ExecUtil.execSync(`git checkout -b "${branchName}"`, { cwd: projectPath });
+
+      // 验证分支创建成功
+      const newBranchInfo = this.getCurrentBranchInfo(projectPath);
+      logger.info('✅ 分支创建成功', {
+        branchName,
+        basedOn: baseInfo.branch,
+        commit: newBranchInfo.commit,
+        projectPath: path.basename(projectPath)
+      });
+
+      // 记录操作后的分支上下文
+      this.logBranchContext(projectPath, 'Create Branch - After');
+
+      return branchName;
+    } catch (error) {
+      logger.error('❌ 创建分支失败', {
+        branchName,
+        baseBranch: baseInfo.branch,
+        error: error.message,
+        projectPath: path.basename(projectPath)
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * 切换到现有分支（不创建新分支）
+   * @param {string} projectPath - 项目路径
+   * @param {string|null} baseBranch - 目标分支（可选，默认自动查找 main/master）
+   * @returns {string} 当前分支名称
+   */
+  static checkoutBranch(projectPath, baseBranch = null) {
+    // 记录操作前的分支上下文
+    this.logBranchContext(projectPath, 'Checkout Branch - Before');
+
+    const beforeInfo = this.getCurrentBranchInfo(projectPath);
+    let targetBranch = baseBranch;
+
+    if (!targetBranch) {
+      // 自动查找 main 或 master
+      logger.info('🔍 自动查找主分支 (main/master)...', {
+        currentBranch: beforeInfo.branch,
+        projectPath: path.basename(projectPath)
+      });
+
+      try {
+        ExecUtil.execSync('git checkout main', { cwd: projectPath });
+        targetBranch = 'main';
+        logger.info('✅ 找到并切换到 main 分支', {
+          from: beforeInfo.branch,
+          to: 'main',
+          projectPath: path.basename(projectPath)
+        });
+      } catch {
+        try {
+          ExecUtil.execSync('git checkout master', { cwd: projectPath });
+          targetBranch = 'master';
+          logger.info('✅ 找到并切换到 master 分支', {
+            from: beforeInfo.branch,
+            to: 'master',
+            projectPath: path.basename(projectPath)
+          });
+        } catch {
+          // 获取当前分支名称
+          const currentBranch = ExecUtil.execSync('git rev-parse --abbrev-ref HEAD', {
+            cwd: projectPath,
+          }).trim();
+          logger.warn('⚠️ 未找到 main 或 master 分支，使用当前分支', {
+            currentBranch,
+            projectPath: path.basename(projectPath)
+          });
+          targetBranch = currentBranch;
+        }
+      }
+    } else {
+      logger.info(`📌 切换到基准分支: ${targetBranch}`, {
+        from: beforeInfo.branch,
+        to: targetBranch,
+        projectPath: path.basename(projectPath)
+      });
+
+      try {
+        ExecUtil.execSync(`git checkout "${targetBranch}"`, { cwd: projectPath });
+
+        const afterCheckoutInfo = this.getCurrentBranchInfo(projectPath);
+        logger.info('✅ 分支切换成功', {
+          from: beforeInfo.branch,
+          to: afterCheckoutInfo.branch,
+          commit: afterCheckoutInfo.commit,
+          projectPath: path.basename(projectPath)
+        });
+      } catch (error) {
+        logger.error(`❌ 切换到分支 ${targetBranch} 失败`, {
+          targetBranch,
+          currentBranch: beforeInfo.branch,
+          error: error.message,
+          projectPath: path.basename(projectPath),
+          suggestion: `请确认分支 ${targetBranch} 存在`
+        });
+        throw new Error(`分支 ${targetBranch} 不存在或无法切换`);
+      }
+    }
+
+    // 拉取最新代码
+    const beforePullInfo = this.getCurrentBranchInfo(projectPath);
+    try {
+      ExecUtil.execSync('git pull', { cwd: projectPath });
+
+      const afterPullInfo = this.getCurrentBranchInfo(projectPath);
+      logger.info(`✅ 已切换到分支 ${targetBranch} 并拉取最新代码`, {
+        branch: targetBranch,
+        fromCommit: beforePullInfo.commit,
+        toCommit: afterPullInfo.commit,
+        projectPath: path.basename(projectPath)
+      });
+    } catch (error) {
+      logger.warn('⚠️ 拉取最新代码失败', {
+        branch: targetBranch,
+        commit: beforePullInfo.commit,
+        error: error.message,
+        projectPath: path.basename(projectPath),
+        suggestion: '请检查网络连接或分支是否有远程跟踪分支'
+      });
+    }
+
+    // 记录操作后的分支上下文
+    this.logBranchContext(projectPath, 'Checkout Branch - After');
+
+    return targetBranch;
+  }
+
+  /**
+   * 提交更改
+   * @param {string} projectPath - 项目路径
+   * @param {string} commitMessage - 提交信息
+   */
+  static commit(projectPath, commitMessage) {
+    // 记录操作前的分支上下文
+    this.logBranchContext(projectPath, 'Commit - Before');
+
+    const branchInfo = this.getCurrentBranchInfo(projectPath);
+    logger.info('📝 提交更改...', {
+      branch: branchInfo.branch,
+      currentCommit: branchInfo.commit,
+      projectPath: path.basename(projectPath)
+    });
+
+    // 检查是否有更改
+    const status = ExecUtil.execSync('git status --porcelain', { cwd: projectPath });
+    if (!status.trim()) {
+      logger.info('ℹ️ 没有文件更改，跳过提交', {
+        branch: branchInfo.branch,
+        commit: branchInfo.commit,
+        projectPath: path.basename(projectPath)
+      });
+      return false;
+    }
+
+    // 统计变更文件
+    const changedFiles = status.trim().split('\n');
+    const fileStats = {
+      total: changedFiles.length,
+      modified: changedFiles.filter(f => f.startsWith(' M')).length,
+      added: changedFiles.filter(f => f.startsWith('??') || f.startsWith('A ')).length,
+      deleted: changedFiles.filter(f => f.startsWith(' D')).length,
+    };
+
+    logger.info('📊 检测到文件变更', {
+      branch: branchInfo.branch,
+      ...fileStats,
+      files: changedFiles.map(f => f.trim()).slice(0, 10), // 只显示前10个文件
+      projectPath: path.basename(projectPath)
+    });
+
+    try {
+      // 添加所有更改
+      ExecUtil.execSync('git add .', { cwd: projectPath });
+      logger.debug('✅ 文件已暂存', {
+        branch: branchInfo.branch,
+        fileCount: fileStats.total,
+        projectPath: path.basename(projectPath)
+      });
+
+      // 提交
+      ExecUtil.execSync(`git commit -m "${commitMessage}"`, { cwd: projectPath });
+
+      // 获取新的提交信息
+      const afterInfo = this.getCurrentBranchInfo(projectPath);
+      logger.info('✅ 更改已提交', {
+        branch: afterInfo.branch,
+        fromCommit: branchInfo.commit,
+        toCommit: afterInfo.commit,
+        commitMessage: commitMessage.substring(0, 100),
+        changedFiles: fileStats.total,
+        projectPath: path.basename(projectPath)
+      });
+
+      // 记录操作后的分支上下文
+      this.logBranchContext(projectPath, 'Commit - After');
+
+      return true;
+    } catch (error) {
+      logger.error('❌ 提交失败', {
+        branch: branchInfo.branch,
+        commit: branchInfo.commit,
+        error: error.message,
+        projectPath: path.basename(projectPath)
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * 推送分支（带重试）
+   * @param {string} projectPath - 项目路径
+   * @param {string} branchName - 分支名称
+   */
+  static async push(projectPath, branchName) {
+    // 记录操作前的分支上下文
+    this.logBranchContext(projectPath, 'Push - Before');
+
+    const branchInfo = this.getCurrentBranchInfo(projectPath);
+    logger.info('📤 推送到远程仓库...', {
+      branch: branchName,
+      currentBranch: branchInfo.branch,
+      commit: branchInfo.commit,
+      remote: branchInfo.remote,
+      projectPath: path.basename(projectPath)
+    });
+
+    try {
+      await RetryUtil.withRetry(
+        () => {
+          const output = ExecUtil.execSync(`git push origin "${branchName}"`, {
+            cwd: projectPath,
+          });
+          logger.debug('Git push 输出:', {
+            branch: branchName,
+            output: output.trim(),
+            projectPath: path.basename(projectPath)
+          });
+        },
+        {
+          maxRetries: 3,
+          delay: 2000,
+          operation: 'Git 推送',
+          shouldRetry: (error) => {
+            // 记录推送失败的详细信息
+            logger.warn('Git 推送失败，分析错误原因:', {
+              branch: branchName,
+              currentBranch: branchInfo.branch,
+              commit: branchInfo.commit,
+              remote: branchInfo.remote,
+              error: error.message,
+              projectPath: path.basename(projectPath)
+            });
+
+            // 网络错误才重试，权限错误不重试
+            const message = error.message.toLowerCase();
+            const isNetworkError = message.includes('network') ||
+                                  message.includes('timeout') ||
+                                  message.includes('connection') ||
+                                  message.includes('failed to connect');
+            const isPermissionError = message.includes('permission') ||
+                                     message.includes('authentication') ||
+                                     message.includes('denied');
+
+            if (isPermissionError) {
+              logger.error('❌ 检测到权限错误，不进行重试', {
+                branch: branchName,
+                error: error.message,
+                suggestion: '请检查 Git 凭证配置或远程仓库访问权限'
+              });
+            }
+
+            return isNetworkError && !isPermissionError;
+          }
+        }
+      );
+
+      // 推送成功后记录
+      const afterInfo = this.getCurrentBranchInfo(projectPath);
+      logger.info('✅ 推送成功', {
+        branch: branchName,
+        commit: afterInfo.commit,
+        remote: afterInfo.remote,
+        projectPath: path.basename(projectPath)
+      });
+
+      // 记录操作后的分支上下文
+      this.logBranchContext(projectPath, 'Push - After');
+
+      return true;
+    } catch (error) {
+      logger.error('❌ 推送失败', {
+        branch: branchName,
+        currentBranch: branchInfo.branch,
+        commit: branchInfo.commit,
+        remote: branchInfo.remote,
+        error: error.message,
+        projectPath: path.basename(projectPath),
+        suggestion: '请检查网络连接、远程仓库访问权限或分支是否已存在'
+      });
+      return false;
+    }
+  }
+
+  /**
+   * 运行测试（可选）
+   * @param {string} projectPath - 项目路径
+   * @returns {boolean} 测试是否通过
+   */
+  static runTests(projectPath) {
+    logger.info('🧪 运行测试...');
+
+    // 检查是否有测试脚本
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+      logger.info('ℹ️ 未找到 package.json，跳过测试');
+      return true;
+    }
+
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    if (!packageJson.scripts || !packageJson.scripts.test) {
+      logger.info('ℹ️ 未配置测试脚本，跳过测试');
+      return true;
+    }
+
+    try {
+      ExecUtil.execSync('npm test', {
+        cwd: projectPath,
+        stdio: 'inherit'  // 测试需要实时输出
+      });
+      logger.info('✅ 测试通过');
+      return true;
+    } catch (error) {
+      logger.error('❌ 测试失败');
+      return false;
+    }
+  }
+
+  /**
+   * 获取项目名称
+   * @param {string} projectPath - 项目路径
+   * @returns {string}
+   */
+  static getProjectName(projectPath) {
+    return path.basename(projectPath);
+  }
+
+  /**
+   * 合并分支到目标分支
+   * @param {string} projectPath - 项目路径
+   * @param {string} sourceBranch - 源分支
+   * @param {string} targetBranch - 目标分支
+   * @returns {boolean} 是否合并成功
+   */
+  static mergeBranch(projectPath, sourceBranch, targetBranch) {
+    // 记录操作前的分支上下文
+    this.logBranchContext(projectPath, 'Merge - Before');
+
+    const beforeInfo = this.getCurrentBranchInfo(projectPath);
+    logger.info(`🔀 合并分支 ${sourceBranch} 到 ${targetBranch}...`, {
+      sourceBranch,
+      targetBranch,
+      currentBranch: beforeInfo.branch,
+      currentCommit: beforeInfo.commit,
+      projectPath: path.basename(projectPath)
+    });
+
+    try {
+      // 切换到目标分支
+      ExecUtil.execSync(`git checkout "${targetBranch}"`, { cwd: projectPath });
+
+      const afterCheckoutInfo = this.getCurrentBranchInfo(projectPath);
+      logger.info(`✅ 已切换到目标分支 ${targetBranch}`, {
+        from: beforeInfo.branch,
+        to: afterCheckoutInfo.branch,
+        commit: afterCheckoutInfo.commit,
+        projectPath: path.basename(projectPath)
+      });
+
+      // 拉取最新代码
+      const beforePullInfo = this.getCurrentBranchInfo(projectPath);
+      try {
+        ExecUtil.execSync('git pull', { cwd: projectPath });
+        const afterPullInfo = this.getCurrentBranchInfo(projectPath);
+        logger.info('✅ 目标分支已更新', {
+          branch: targetBranch,
+          fromCommit: beforePullInfo.commit,
+          toCommit: afterPullInfo.commit,
+          projectPath: path.basename(projectPath)
+        });
+      } catch (pullError) {
+        logger.warn('⚠️ 拉取目标分支失败，使用本地版本', {
+          branch: targetBranch,
+          commit: beforePullInfo.commit,
+          error: pullError.message,
+          projectPath: path.basename(projectPath)
+        });
+      }
+
+      // 合并源分支
+      const beforeMergeInfo = this.getCurrentBranchInfo(projectPath);
+      logger.info(`🔀 开始合并 ${sourceBranch}...`, {
+        sourceBranch,
+        targetBranch,
+        targetCommit: beforeMergeInfo.commit,
+        projectPath: path.basename(projectPath)
+      });
+
+      ExecUtil.execSync(`git merge "${sourceBranch}" --no-ff -m "Merge branch '${sourceBranch}' into ${targetBranch}"`, {
+        cwd: projectPath,
+      });
+
+      // 获取合并后的信息
+      const afterMergeInfo = this.getCurrentBranchInfo(projectPath);
+      logger.info(`✅ 成功合并到 ${targetBranch}`, {
+        sourceBranch,
+        targetBranch,
+        beforeCommit: beforeMergeInfo.commit,
+        afterCommit: afterMergeInfo.commit,
+        commitMessage: afterMergeInfo.commitMessage,
+        projectPath: path.basename(projectPath)
+      });
+
+      // 记录操作后的分支上下文
+      this.logBranchContext(projectPath, 'Merge - After');
+
+      return true;
+    } catch (error) {
+      const currentInfo = this.getCurrentBranchInfo(projectPath);
+      logger.error(`❌ 合并到 ${targetBranch} 失败`, {
+        sourceBranch,
+        targetBranch,
+        currentBranch: currentInfo.branch,
+        currentCommit: currentInfo.commit,
+        error: error.message,
+        projectPath: path.basename(projectPath),
+        suggestion: '可能存在冲突，请手动解决或检查分支是否存在'
+      });
+
+      // 尝试中止合并
+      try {
+        ExecUtil.execSync('git merge --abort', { cwd: projectPath });
+        logger.info('✅ 已中止合并操作', {
+          targetBranch,
+          projectPath: path.basename(projectPath)
+        });
+      } catch (abortError) {
+        logger.warn('⚠️ 中止合并失败', {
+          targetBranch,
+          error: abortError.message,
+          projectPath: path.basename(projectPath)
+        });
+      }
+
+      return false;
+    }
+  }
+
+  /**
+   * 批量合并到多个目标分支（异步）
+   * @param {string} projectPath - 项目路径
+   * @param {string} sourceBranch - 源分支
+   * @param {string[]} targetBranches - 目标分支数组
+   * @returns {Promise<Object>} 合并结果 { branch: success }
+   */
+  static async mergeToMultipleBranches(projectPath, sourceBranch, targetBranches) {
+    const results = {};
+
+    if (!targetBranches || targetBranches.length === 0) {
+      logger.info('ℹ️ 未指定合并目标分支，跳过合并', {
+        sourceBranch,
+        projectPath: path.basename(projectPath)
+      });
+      return results;
+    }
+
+    const beforeInfo = this.getCurrentBranchInfo(projectPath);
+    logger.info(`🔀 开始批量合并`, {
+      sourceBranch,
+      targetBranches: targetBranches.join(', '),
+      currentBranch: beforeInfo.branch,
+      currentCommit: beforeInfo.commit,
+      totalTargets: targetBranches.length,
+      projectPath: path.basename(projectPath)
+    });
+
+    let successCount = 0;
+    let failedCount = 0;
+
+    for (const targetBranch of targetBranches) {
+      logger.info(`📋 处理目标分支 ${targetBranch} (${Object.keys(results).length + 1}/${targetBranches.length})`, {
+        sourceBranch,
+        targetBranch,
+        projectPath: path.basename(projectPath)
+      });
+
+      const success = this.mergeBranch(projectPath, sourceBranch, targetBranch);
+      results[targetBranch] = success;
+
+      if (success) {
+        successCount++;
+      } else {
+        failedCount++;
+      }
+
+      // 如果合并成功，推送目标分支
+      if (success) {
+        logger.info(`📤 推送合并后的分支 ${targetBranch}...`, {
+          sourceBranch,
+          targetBranch,
+          projectPath: path.basename(projectPath)
+        });
+
+        try {
+          await RetryUtil.withRetry(
+            () => {
+              ExecUtil.execSync(`git push origin "${targetBranch}"`, {
+                cwd: projectPath,
+              });
+            },
+            {
+              maxRetries: 3,
+              delay: 2000,
+              operation: `推送 ${targetBranch}`,
+            }
+          );
+
+          const pushedInfo = this.getCurrentBranchInfo(projectPath);
+          logger.info(`✅ ${targetBranch} 已推送到远程`, {
+            branch: targetBranch,
+            commit: pushedInfo.commit,
+            remote: pushedInfo.remote,
+            projectPath: path.basename(projectPath)
+          });
+        } catch (error) {
+          logger.error(`❌ 推送 ${targetBranch} 失败`, {
+            branch: targetBranch,
+            error: error.message,
+            projectPath: path.basename(projectPath),
+            suggestion: '合并成功但推送失败，可稍后手动推送'
+          });
+        }
+      }
+    }
+
+    // 切回源分支
+    try {
+      ExecUtil.execSync(`git checkout "${sourceBranch}"`, { cwd: projectPath });
+      const finalInfo = this.getCurrentBranchInfo(projectPath);
+      logger.info('✅ 已切回源分支', {
+        sourceBranch,
+        branch: finalInfo.branch,
+        commit: finalInfo.commit,
+        projectPath: path.basename(projectPath)
+      });
+    } catch (error) {
+      logger.warn(`⚠️ 无法切回源分支 ${sourceBranch}`, {
+        sourceBranch,
+        error: error.message,
+        projectPath: path.basename(projectPath),
+        suggestion: '请手动切换到源分支'
+      });
+    }
+
+    // 输出批量合并总结
+    logger.info('📊 批量合并完成', {
+      sourceBranch,
+      totalTargets: targetBranches.length,
+      successCount,
+      failedCount,
+      results,
+      projectPath: path.basename(projectPath)
+    });
+
+    return results;
+  }
+
+  /**
+   * 检查分支是否存在
+   * @param {string} projectPath - 项目路径
+   * @param {string} branchName - 分支名称
+   * @returns {boolean} 分支是否存在
+   */
+  static branchExists(projectPath, branchName) {
+    try {
+      ExecUtil.execSync(`git rev-parse --verify "${branchName}"`, {
+        cwd: projectPath,
+        stdio: 'ignore',
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * 验证分支名称合法性
+   * @param {string} branchName - 分支名称
+   * @returns {boolean} 是否合法
+   */
+  static validateBranchName(branchName) {
+    // Git 分支名规则
+    const invalidPatterns = [
+      /\.\./,           // 不能包含 ..
+      /^[.-]/,          // 不能以 . 或 - 开头
+      /[\/.]$/,         // 不能以 / 或 . 结尾
+      /\/\//,           // 不能包含连续的 /
+      /[@{\\^~:?*\[\]]/, // 不能包含特殊字符
+    ];
+
+    for (const pattern of invalidPatterns) {
+      if (pattern.test(branchName)) {
+        return false;
+      }
+    }
+
+    // 长度限制
+    if (branchName.length > 255) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * 获取工作区的 Git Diff 详细信息
+   * @param {string} projectPath - 项目路径
+   * @returns {Object} Git diff 结果
+   */
+  static getWorkspaceDiff(projectPath) {
+    const result = {
+      fullDiff: "",
+      actualChangedFiles: [],
+      untrackedFiles: [],
+      stagedFiles: [],
+      unstagedFiles: [],
+      fileChanges: [],
+    };
+
+    try {
+      // 1. 获取完整的 diff
+      try {
+        result.fullDiff = ExecUtil.execSync("git diff HEAD", {
+          cwd: projectPath,
+        });
+      } catch (err) {
+        logger.warn("获取完整 diff 失败:", err.message);
+      }
+
+      // 2. 获取已修改文件列表(已跟踪的文件)
+      let modifiedFiles = [];
+      try {
+        const diffOutput = ExecUtil.execSync("git diff HEAD --name-only", {
+          cwd: projectPath,
+        });
+        modifiedFiles = diffOutput.split("\n").filter(Boolean);
+      } catch (err) {
+        logger.warn("获取已修改文件失败:", err.message);
+      }
+
+      // 3. 获取未跟踪的新文件
+      try {
+        const untrackedOutput = ExecUtil.execSync(
+          "git ls-files --others --exclude-standard",
+          {
+            cwd: projectPath,
+          }
+        );
+        result.untrackedFiles = untrackedOutput.split("\n").filter(Boolean);
+      } catch (err) {
+        // 没有未跟踪文件或命令失败
+      }
+
+      // 4. 合并文件列表
+      result.actualChangedFiles = [...modifiedFiles, ...result.untrackedFiles];
+
+      // 5. 获取暂存文件列表
+      try {
+        const stagedOutput = ExecUtil.execSync("git diff --cached --name-only", {
+          cwd: projectPath,
+        });
+        result.stagedFiles = stagedOutput.split("\n").filter(Boolean);
+      } catch (err) {
+        // 没有暂存文件
+      }
+
+      // 6. 获取未暂存文件列表
+      try {
+        const unstagedOutput = ExecUtil.execSync("git diff --name-only", {
+          cwd: projectPath,
+        });
+        result.unstagedFiles = unstagedOutput.split("\n").filter(Boolean);
+      } catch (err) {
+        // 没有未暂存文件
+      }
+
+      // 7. 为每个文件获取详细信息
+      result.fileChanges = result.actualChangedFiles.map((filePath) => {
+        const isUntracked = result.untrackedFiles.includes(filePath);
+
+        if (isUntracked) {
+          // 新文件,读取完整内容
+          const fullPath = path.join(projectPath, filePath);
+          const content = fs.existsSync(fullPath)
+            ? fs.readFileSync(fullPath, "utf-8")
+            : null;
+
+          return {
+            file: filePath,
+            diff: null,
+            content,
+            isNewFile: true,
+            isUntracked: true,
+            isStaged: result.stagedFiles.includes(filePath),
+          };
+        } else {
+          // 已跟踪文件,获取 diff
+          try {
+            const fileDiff = ExecUtil.execSync(`git diff HEAD -- "${filePath}"`, {
+              cwd: projectPath,
+            });
+
+            return {
+              file: filePath,
+              diff: fileDiff,
+              content: null,
+              isNewFile: false,
+              isUntracked: false,
+              isStaged: result.stagedFiles.includes(filePath),
+              isUnstaged: result.unstagedFiles.includes(filePath),
+            };
+          } catch (err) {
+            return {
+              file: filePath,
+              error: err.message,
+            };
+          }
+        }
+      });
+
+      logger.debug(`📊 Git Diff 结果: ${result.actualChangedFiles.length} 个文件变更`);
+      return result;
+    } catch (error) {
+      logger.error("❌ 获取 Git diff 失败:", error.message);
+      return result; // 返回空结果
+    }
+  }
+}
+
+
+module.exports = GitService;