run_codedog.py

import argparse
import asyncio
import time
import traceback
import logging
from dotenv import load_dotenv
from typing import Any, Dict, List, Optional, Tuple
import os
import re
import sys
from datetime import datetime, timedelta

# Load environment variables from .env file
load_dotenv()

# Configure logger
logger = logging.getLogger(__name__)

from github import Github
from gitlab import Gitlab
from langchain_community.callbacks.manager import get_openai_callback

from codedog.actors.reporters.pull_request import PullRequestReporter
from codedog.chains import CodeReviewChain, PRSummaryChain, CodeReviewChainFactory
from codedog.retrievers import GithubRetriever, GitlabRetriever
from codedog.utils.langchain_utils import load_model_by_name
from codedog.utils.email_utils import send_report_email
from codedog.utils.git_hooks import install_git_hooks
from codedog.utils.git_log_analyzer import get_file_diffs_by_timeframe, get_commit_diff, CommitInfo
from codedog.utils.code_evaluator import DiffEvaluator, generate_evaluation_markdown, FileEvaluationResult, CodeEvaluation


def parse_args():
    """Parse command line arguments."""
    parser = argparse.ArgumentParser(description="CodeDog - AI-powered code review tool")

    # Main operation subparsers
    subparsers = parser.add_subparsers(dest="command", help="Command to run")

    # Repository evaluation command (only command available)
    repo_eval_parser = subparsers.add_parser("repo-eval", help="Evaluate all commits in a repository within a time period for all committers")
    repo_eval_parser.add_argument("repo", help="Git repository path or name (e.g. owner/repo for remote repositories)")
    repo_eval_parser.add_argument("--start-date", help="Start date (YYYY-MM-DD), defaults to 7 days ago")
    repo_eval_parser.add_argument("--end-date", help="End date (YYYY-MM-DD), defaults to today")
    repo_eval_parser.add_argument("--include", help="Included file extensions, comma separated, e.g. .py,.js")
    repo_eval_parser.add_argument("--exclude", help="Excluded file extensions, comma separated, e.g. .md,.txt")
    repo_eval_parser.add_argument("--model", help="Evaluation model, defaults to CODE_REVIEW_MODEL env var or gpt-3.5")
    repo_eval_parser.add_argument("--email", help="Email addresses to send the report to (comma-separated)")
    repo_eval_parser.add_argument("--output-dir", help="Directory to save reports, defaults to codedog_repo_eval_<date>")
    repo_eval_parser.add_argument("--platform", choices=["github", "gitlab"], default="github",
                         help="Platform to use (github or gitlab, defaults to github)")
    repo_eval_parser.add_argument("--gitlab-url", help="GitLab URL (defaults to https://gitlab.com or GITLAB_URL env var)")
    repo_eval_parser.add_argument("--model-token-limit", type=int, default=45000, help="Model token limit for evaluation (default: 45000)")

    return parser.parse_args()


def parse_emails(emails_str: Optional[str]) -> List[str]:
    """Parse comma-separated email addresses."""
    if not emails_str:
        return []

    return [email.strip() for email in emails_str.split(",") if email.strip()]


def parse_extensions(extensions_str: Optional[str]) -> Optional[List[str]]:
    """Parse comma-separated file extensions."""
    if not extensions_str:
        return None

    return [ext.strip() for ext in extensions_str.split(",") if ext.strip()]


def get_author_slug(author: str) -> str:
    """从作者名称中提取邮箱，用于文件名"""
    # 从作者名称中提取邮箱，用于文件名
    email_match = re.search(r'<([^>]+)>', author)
    if email_match:
        # 如果有邮箱，使用邮箱作为文件名的一部分
        email = email_match.group(1)
        # 提取邮箱用户名部分（去掉@及后面的域名）
        email_username = email.split('@')[0] if '@' in email else email
        author_slug = email_username.replace(".", "_").replace("-", "_")
    else:
        # 如果没有邮箱，使用作者名称
        author_slug = author.replace("@", "_at_").replace(" ", "_").replace("/", "_").replace("<", "").replace(">", "")

    return author_slug


def split_commits_into_batches(
    commits: List[CommitInfo],
    commit_file_diffs: Dict[str, Dict[str, str]],
    model_token_limit: int,
    safety_margin: float = 0.75  # 增加安全边际系数，更有效地利用模型token限制
) -> List[List[CommitInfo]]:
    """
    将提交智能分割为多个批次，确保每个批次不超过模型的处理能力

    Args:
        commits: 提交列表
        commit_file_diffs: 提交文件差异字典
        model_token_limit: 模型的token限制
        safety_margin: 安全边际系数(0-1)

    Returns:
        批次列表，每个批次包含多个提交
    """
    safe_token_limit = int(model_token_limit * safety_margin)
    batches = []
    current_batch = []
    current_tokens = 0

    # 按时间顺序排序提交
    sorted_commits = sorted(commits, key=lambda x: x.date)

    # 提示模板的基本token数量（包括指令、格式说明等）
    # 根据实际使用情况调整
    base_prompt_tokens = 800

    # 每个提交的元数据（提交哈希、消息等）的估计token数量
    commit_metadata_tokens = 100

    # 初始token计数包含基本提示
    current_tokens = base_prompt_tokens

    for commit in sorted_commits:
        # 估算当前提交的token数量
        commit_tokens = commit_metadata_tokens  # 基本元数据

        if commit.hash in commit_file_diffs:
            for file_path, file_diff in commit_file_diffs[commit.hash].items():
                # 更精确的token估算：
                # 1. 代码比普通文本需要更多token（特殊字符、缩进等）
                # 2. 使用字符数而不是单词数作为基础
                # 3. 对不同类型的内容使用不同的系数

                # 文件路径也消耗token
                commit_tokens += len(file_path) * 0.5

                # 估算diff内容的token
                # 使用更高的系数 (1.5 而不是 1.3)，因为代码通常有更多的特殊字符和结构
                char_count = len(file_diff)
                # 平均每个字符约0.33个token（更准确的估计）
                diff_tokens = char_count * 0.33

                # 添加一些额外的token用于diff格式和结构
                diff_tokens += 50  # 每个文件的diff头部等

                commit_tokens += diff_tokens

        # 如果添加当前提交会超出限制，创建新批次
        if current_tokens + commit_tokens > safe_token_limit and current_batch:
            logger.info(f"Creating new batch at estimated {current_tokens} tokens (limit: {safe_token_limit})")
            batches.append(current_batch)
            current_batch = []
            current_tokens = base_prompt_tokens  # 重置为基本提示的token数

        # 如果单个提交就超出限制，需要单独处理
        if commit_tokens > safe_token_limit:
            logger.warning(f"Large commit {commit.hash} with estimated {commit_tokens} tokens exceeds safe limit")
            # 这种情况下，我们可以选择：
            # 1. 单独评估这个提交
            # 2. 将这个提交拆分为更小的部分
            # 这里我们选择方案1，单独评估
            if not current_batch:  # 如果当前批次为空
                batches.append([commit])
                logger.info(f"Added large commit {commit.hash} as a separate batch")
            else:
                # 先保存当前批次
                batches.append(current_batch)
                logger.info(f"Saved current batch before processing large commit")
                # 然后单独处理这个大提交
                batches.append([commit])
                logger.info(f"Added large commit {commit.hash} as a separate batch")
                current_batch = []
                current_tokens = base_prompt_tokens
        else:
            # 正常情况：添加到当前批次
            current_batch.append(commit)
            current_tokens += commit_tokens
            logger.info(f"Added commit {commit.hash} to batch, new token estimate: {current_tokens}")

    # 添加最后一个批次（如果有）
    if current_batch:
        batches.append(current_batch)
        logger.info(f"Added final batch with {len(current_batch)} commits, estimated {current_tokens} tokens")

    # 记录批次信息
    for i, batch in enumerate(batches):
        logger.info(f"Batch {i+1}: {len(batch)} commits, commit hashes: {[c.hash for c in batch]}")

    return batches


async def pr_summary(retriever, summary_chain):
    """Generate PR summary asynchronously."""
    result = await summary_chain.ainvoke(
        {"pull_request": retriever.pull_request}, include_run_info=True
    )
    return result


async def code_review(retriever, review_chain):
    """Generate code review asynchronously."""
    result = await review_chain.ainvoke(
        {"pull_request": retriever.pull_request}, include_run_info=True
    )
    return result


def get_remote_commit_diff(
    platform: str,
    repository_name: str,
    commit_hash: str,
    include_extensions: Optional[List[str]] = None,
    exclude_extensions: Optional[List[str]] = None,
    gitlab_url: Optional[str] = None,
) -> Dict[str, Dict[str, Any]]:
    """
    Get commit diff from remote repositories (GitHub or GitLab).

    Args:
        platform (str): Platform to use (github or gitlab)
        repository_name (str): Repository name (e.g. owner/repo)
        commit_hash (str): Commit hash to review
        include_extensions (Optional[List[str]], optional): File extensions to include. Defaults to None.
        exclude_extensions (Optional[List[str]], optional): File extensions to exclude. Defaults to None.
        gitlab_url (Optional[str], optional): GitLab URL. Defaults to None.

    Returns:
        Dict[str, Dict[str, Any]]: Dictionary mapping file paths to their diffs and statistics
    """
    logger.info(f"Getting commit diff from {platform} for repository {repository_name}, commit {commit_hash}")
    logger.info(f"Include extensions: {include_extensions}, Exclude extensions: {exclude_extensions}")

    if platform.lower() == "github":
        # Initialize GitHub client
        github_token = os.environ.get("GITHUB_TOKEN", "")
        if not github_token:
            error_msg = "GITHUB_TOKEN environment variable is not set"
            logger.error(error_msg)
            print(error_msg)
            return {}

        github_client = Github(github_token)
        print(f"Analyzing GitHub repository {repository_name} for commit {commit_hash}")
        logger.info(f"Initialized GitHub client for repository {repository_name}")

        try:
            # Get repository
            logger.info(f"Fetching repository {repository_name}")
            repo = github_client.get_repo(repository_name)

            # Get commit
            logger.info(f"Fetching commit {commit_hash}")
            commit = repo.get_commit(commit_hash)
            logger.info(f"Commit found: {commit.sha}, author: {commit.commit.author.name}, date: {commit.commit.author.date}")

            # Extract file diffs
            file_diffs = {}
            logger.info(f"Processing {len(commit.files)} files in commit")

            for i, file in enumerate(commit.files):
                logger.info(f"Processing file {i+1}/{len(commit.files)}: {file.filename}")

                # Filter by file extensions
                _, ext = os.path.splitext(file.filename)
                logger.debug(f"File extension: {ext}")

                if include_extensions and ext not in include_extensions:
                    logger.info(f"Skipping file {file.filename} - extension {ext} not in include list")
                    continue
                if exclude_extensions and ext in exclude_extensions:
                    logger.info(f"Skipping file {file.filename} - extension {ext} in exclude list")
                    continue

                if file.patch:
                    logger.info(f"Adding file {file.filename} to diff (status: {file.status}, additions: {file.additions}, deletions: {file.deletions})")
                    file_diffs[file.filename] = {
                        "diff": f"diff --git a/{file.filename} b/{file.filename}\n{file.patch}",
                        "status": file.status,
                        "additions": file.additions,
                        "deletions": file.deletions,
                    }
                else:
                    logger.warning(f"No patch content for file {file.filename}")

            logger.info(f"Processed {len(file_diffs)} files after filtering")
            return file_diffs

        except Exception as e:
            error_msg = f"Failed to retrieve GitHub commit: {str(e)}"
            logger.error(error_msg, exc_info=True)
            print(error_msg)
            return {}

    elif platform.lower() == "gitlab":
        # Initialize GitLab client
        gitlab_token = os.environ.get("GITLAB_TOKEN", "")
        if not gitlab_token:
            error_msg = "GITLAB_TOKEN environment variable is not set"
            logger.error(error_msg)
            print(error_msg)
            return {}

        # Use provided GitLab URL or fall back to environment variable or default
        gitlab_url = gitlab_url or os.environ.get("GITLAB_URL", "https://gitlab.com")
        logger.info(f"Using GitLab URL: {gitlab_url}")

        gitlab_client = Gitlab(url=gitlab_url, private_token=gitlab_token)
        print(f"Analyzing GitLab repository {repository_name} for commit {commit_hash}")
        logger.info(f"Initialized GitLab client for repository {repository_name}")

        try:
            # Get repository
            logger.info(f"Fetching project {repository_name}")
            project = gitlab_client.projects.get(repository_name)
            logger.info(f"Project found: {project.name}, ID: {project.id}")

            # Get commit
            logger.info(f"Fetching commit {commit_hash}")
            commit = project.commits.get(commit_hash)
            logger.info(f"Commit found: {commit.id}, author: {commit.author_name}, date: {commit.created_at}")

            # Get commit diff
            logger.info("Fetching commit diff")
            diff = commit.diff()
            logger.info(f"Processing {len(diff)} files in commit diff")

            # Extract file diffs
            file_diffs = {}
            for i, file_diff in enumerate(diff):
                file_path = file_diff.get('new_path', '')
                old_path = file_diff.get('old_path', '')
                diff_content = file_diff.get('diff', '')

                logger.info(f"Processing file {i+1}/{len(diff)}: {file_path}")
                logger.debug(f"Old path: {old_path}, New path: {file_path}")

                # Skip if no diff content
                if not diff_content:
                    logger.warning(f"No diff content for file {file_path}, skipping")
                    continue

                # Filter by file extensions
                _, ext = os.path.splitext(file_path)
                logger.debug(f"File extension: {ext}")

                if include_extensions and ext not in include_extensions:
                    logger.info(f"Skipping file {file_path} - extension {ext} not in include list")
                    continue
                if exclude_extensions and ext in exclude_extensions:
                    logger.info(f"Skipping file {file_path} - extension {ext} in exclude list")
                    continue

                # Determine file status
                if file_diff.get('new_file', False):
                    status = 'A'  # Added
                elif file_diff.get('deleted_file', False):
                    status = 'D'  # Deleted
                else:
                    status = 'M'  # Modified

                logger.debug(f"File status: {status}")

                # Format diff content
                formatted_diff = f"diff --git a/{old_path} b/{file_path}\n{diff_content}"

                # Count additions and deletions
                additions = diff_content.count('\n+')
                deletions = diff_content.count('\n-')
                logger.debug(f"Additions: {additions}, Deletions: {deletions}")

                logger.info(f"Adding file {file_path} to diff (status: {status}, additions: {additions}, deletions: {deletions})")
                file_diffs[file_path] = {
                    "diff": formatted_diff,
                    "status": status,
                    "additions": additions,
                    "deletions": deletions,
                }

            logger.info(f"Processed {len(file_diffs)} files after filtering")
            return file_diffs

        except Exception as e:
            error_msg = f"Failed to retrieve GitLab commit: {str(e)}"
            logger.error(error_msg, exc_info=True)
            print(error_msg)
            return {}

    else:
        error_msg = f"Unsupported platform: {platform}. Use 'github' or 'gitlab'."
        logger.error(error_msg)
        print(error_msg)
        return {}


def get_all_remote_commits(
    platform: str,
    repository_name: str,
    start_date: str,
    end_date: str,
    include_extensions: Optional[List[str]] = None,
    exclude_extensions: Optional[List[str]] = None,
    gitlab_url: Optional[str] = None,
) -> Dict[str, Tuple[List[Any], Dict[str, Dict[str, str]], Dict[str, int]]]:
    """
    Get all commits from remote repositories (GitHub or GitLab) grouped by author.

    Args:
        platform (str): Platform to use (github or gitlab)
        repository_name (str): Repository name (e.g. owner/repo)
        start_date (str): Start date (YYYY-MM-DD)
        end_date (str): End date (YYYY-MM-DD)
        include_extensions (Optional[List[str]], optional): File extensions to include. Defaults to None.
        exclude_extensions (Optional[List[str]], optional): File extensions to exclude. Defaults to None.
        gitlab_url (Optional[str], optional): GitLab URL. Defaults to None.

    Returns:
        Dict[str, Tuple[List[Any], Dict[str, Dict[str, str]], Dict[str, int]]]: Dictionary mapping author names to their commits, file diffs, and code stats
    """
    if platform.lower() == "github":
        # Initialize GitHub client
        github_token = os.environ.get("GITHUB_TOKEN", "")
        if not github_token:
            error_msg = "GITHUB_TOKEN environment variable is not set"
            logger.error(error_msg)
            print(error_msg)
            return {}

        github_client = Github(github_token)
        print(f"Analyzing GitHub repository {repository_name} for all commits")
        logger.info(f"Initialized GitHub client for repository {repository_name}")

        try:
            # Get repository
            repo = github_client.get_repo(repository_name)

            # Convert dates to datetime objects
            start_datetime = datetime.strptime(start_date, "%Y-%m-%d")
            end_datetime = datetime.strptime(end_date, "%Y-%m-%d") + timedelta(days=1)  # Include the end date

            # Get all commits in the repository within the date range
            all_commits = repo.get_commits(since=start_datetime, until=end_datetime)

            # Group commits by author
            author_commits = {}

            for commit in all_commits:
                author_name = commit.commit.author.name
                author_email = commit.commit.author.email

                # Use email as part of the key to distinguish between authors with the same name
                author_key = f"{author_name} <{author_email}>" if author_email else author_name

                if author_key not in author_commits:
                    author_commits[author_key] = {
                        "commits": [],
                        "file_diffs": {},
                        "stats": {
                            "total_added_lines": 0,
                            "total_deleted_lines": 0,
                            "total_effective_lines": 0,
                            "total_files": set()
                        }
                    }

                # Create CommitInfo object
                commit_info = CommitInfo(
                    hash=commit.sha,
                    author=author_name,
                    date=commit.commit.author.date,
                    message=commit.commit.message,
                    files=[file.filename for file in commit.files],
                    diff="\n".join([f"diff --git a/{file.filename} b/{file.filename}\n{file.patch}" for file in commit.files if file.patch]),
                    added_lines=sum(file.additions for file in commit.files),
                    deleted_lines=sum(file.deletions for file in commit.files),
                    effective_lines=sum(file.additions - file.deletions for file in commit.files)
                )

                author_commits[author_key]["commits"].append(commit_info)

                # Extract file diffs
                file_diffs = {}
                for file in commit.files:
                    if file.patch:
                        # Filter by file extensions
                        _, ext = os.path.splitext(file.filename)
                        if include_extensions and ext not in include_extensions:
                            continue
                        if exclude_extensions and ext in exclude_extensions:
                            continue

                        file_diffs[file.filename] = file.patch
                        author_commits[author_key]["stats"]["total_files"].add(file.filename)

                author_commits[author_key]["file_diffs"][commit.sha] = file_diffs

                # Update stats
                author_commits[author_key]["stats"]["total_added_lines"] += commit_info.added_lines
                author_commits[author_key]["stats"]["total_deleted_lines"] += commit_info.deleted_lines
                author_commits[author_key]["stats"]["total_effective_lines"] += commit_info.effective_lines

            # Convert the set of files to count
            for author_key in author_commits:
                author_commits[author_key]["stats"]["total_files"] = len(author_commits[author_key]["stats"]["total_files"])

            # Convert to the expected return format
            result = {}
            for author_key, data in author_commits.items():
                result[author_key] = (data["commits"], data["file_diffs"], data["stats"])

            return result

        except Exception as e:
            error_msg = f"Failed to retrieve GitHub commits: {str(e)}"
            logger.error(error_msg, exc_info=True)
            print(error_msg)
            return {}

    elif platform.lower() == "gitlab":
        # Initialize GitLab client
        gitlab_token = os.environ.get("GITLAB_TOKEN", "")
        if not gitlab_token:
            error_msg = "GITLAB_TOKEN environment variable is not set"
            logger.error(error_msg)
            print(error_msg)
            return {}

        # Use provided GitLab URL or fall back to environment variable or default
        gitlab_url = gitlab_url or os.environ.get("GITLAB_URL", "https://gitlab.com")
        logger.info(f"Using GitLab URL: {gitlab_url}")

        gitlab_client = Gitlab(url=gitlab_url, private_token=gitlab_token)
        print(f"Analyzing GitLab repository {repository_name} for all commits")
        logger.info(f"Initialized GitLab client for repository {repository_name}")

        try:
            # Get repository
            project = gitlab_client.projects.get(repository_name)
            logger.info(f"Project found: {project.name}, ID: {project.id}")

            # Convert dates to ISO format
            start_iso = f"{start_date}T00:00:00Z"
            end_iso = f"{end_date}T23:59:59Z"

            # Get all commits in the repository within the date range
            all_commits = project.commits.list(all=True, get_all=True, since=start_iso, until=end_iso)
            logger.info(f"Found {len(all_commits)} commits in the date range")

            # Group commits by author
            author_commits = {}

            for commit in all_commits:
                author_name = commit.author_name
                author_email = commit.author_email

                # Use email as part of the key to distinguish between authors with the same name
                author_key = f"{author_name} <{author_email}>" if author_email else author_name

                if author_key not in author_commits:
                    author_commits[author_key] = {
                        "commits": [],
                        "file_diffs": {},
                        "stats": {
                            "total_added_lines": 0,
                            "total_deleted_lines": 0,
                            "total_effective_lines": 0,
                            "total_files": set()
                        }
                    }

                # Get commit details
                commit_detail = project.commits.get(commit.id)

                # Get commit diff
                diff = commit_detail.diff(get_all=True)

                # Filter files by extension
                filtered_diff = []
                for file_diff in diff:
                    file_path = file_diff.get('new_path', '')
                    _, ext = os.path.splitext(file_path)

                    if include_extensions and ext not in include_extensions:
                        continue
                    if exclude_extensions and ext in exclude_extensions:
                        continue

                    filtered_diff.append(file_diff)

                # Skip if no files match the filter
                if not filtered_diff:
                    continue

                # Get file content for each modified file
                file_diffs = {}
                for file_diff in filtered_diff:
                    file_path = file_diff.get('new_path', '')
                    old_path = file_diff.get('old_path', '')
                    diff_content = file_diff.get('diff', '')

                    # Skip if no diff content
                    if not diff_content:
                        continue

                    # Format diff content
                    formatted_diff = f"diff --git a/{old_path} b/{file_path}\n{diff_content}"
                    file_diffs[file_path] = formatted_diff
                    author_commits[author_key]["stats"]["total_files"].add(file_path)

                # Skip if no valid diffs
                if not file_diffs:
                    continue

                # Count additions and deletions
                added_lines = sum(diff_content.count('\n+') for diff_content in file_diffs.values())
                deleted_lines = sum(diff_content.count('\n-') for diff_content in file_diffs.values())
                effective_lines = added_lines - deleted_lines

                # Create CommitInfo object
                commit_info = CommitInfo(
                    hash=commit.id,
                    author=author_name,
                    date=datetime.strptime(commit.created_at, "%Y-%m-%dT%H:%M:%S.%f%z") if '.' in commit.created_at else datetime.strptime(commit.created_at, "%Y-%m-%dT%H:%M:%SZ"),
                    message=commit.message,
                    files=list(file_diffs.keys()),
                    diff="\n\n".join(file_diffs.values()),
                    added_lines=added_lines,
                    deleted_lines=deleted_lines,
                    effective_lines=effective_lines
                )

                author_commits[author_key]["commits"].append(commit_info)
                author_commits[author_key]["file_diffs"][commit.id] = file_diffs

                # Update stats
                author_commits[author_key]["stats"]["total_added_lines"] += added_lines
                author_commits[author_key]["stats"]["total_deleted_lines"] += deleted_lines
                author_commits[author_key]["stats"]["total_effective_lines"] += effective_lines

            # Convert the set of files to count
            for author_key in author_commits:
                author_commits[author_key]["stats"]["total_files"] = len(author_commits[author_key]["stats"]["total_files"])

            # Convert to the expected return format
            result = {}
            for author_key, data in author_commits.items():
                result[author_key] = (data["commits"], data["file_diffs"], data["stats"])

            return result

        except Exception as e:
            error_msg = f"Failed to retrieve GitLab commits: {str(e)}"
            logger.error(error_msg, exc_info=True)
            print(error_msg)
            return {}

    else:
        error_msg = f"Unsupported platform: {platform}. Use 'github' or 'gitlab'."
        logger.error(error_msg)
        print(error_msg)
        return {}

def get_remote_commits(
    platform: str,
    repository_name: str,
    author: str,
    start_date: str,
    end_date: str,
    include_extensions: Optional[List[str]] = None,
    exclude_extensions: Optional[List[str]] = None,
    gitlab_url: Optional[str] = None,
) -> Tuple[List[Any], Dict[str, Dict[str, str]], Dict[str, int]]:
    """
    Get commits from remote repositories (GitHub or GitLab).

    Args:
        platform (str): Platform to use (github or gitlab)
        repository_name (str): Repository name (e.g. owner/repo)
        author (str): Author name or email
        start_date (str): Start date (YYYY-MM-DD)
        end_date (str): End date (YYYY-MM-DD)
        include_extensions (Optional[List[str]], optional): File extensions to include. Defaults to None.
        exclude_extensions (Optional[List[str]], optional): File extensions to exclude. Defaults to None.
        gitlab_url (Optional[str], optional): GitLab URL. Defaults to None.

    Returns:
        Tuple[List[Any], Dict[str, Dict[str, str]], Dict[str, int]]: Commits, file diffs, and code stats
    """
    if platform.lower() == "github":
        # Initialize GitHub client
        github_client = Github()  # Will automatically load GITHUB_TOKEN from environment
        print(f"Analyzing GitHub repository {repository_name} for commits by {author}")

        try:
            # Get repository
            repo = github_client.get_repo(repository_name)

            # Convert dates to datetime objects
            start_datetime = datetime.strptime(start_date, "%Y-%m-%d")
            end_datetime = datetime.strptime(end_date, "%Y-%m-%d") + timedelta(days=1)  # Include the end date

            # Get commits
            commits = []
            commit_file_diffs = {}

            # Get all commits in the repository within the date range
            all_commits = repo.get_commits(since=start_datetime, until=end_datetime)

            # Filter by author
            for commit in all_commits:
                if author.lower() in commit.commit.author.name.lower() or (
                    commit.commit.author.email and author.lower() in commit.commit.author.email.lower()
                ):
                    # Create CommitInfo object
                    commit_info = CommitInfo(
                        hash=commit.sha,
                        author=commit.commit.author.name,
                        date=commit.commit.author.date,
                        message=commit.commit.message,
                        files=[file.filename for file in commit.files],
                        diff="\n".join([f"diff --git a/{file.filename} b/{file.filename}\n{file.patch}" for file in commit.files if file.patch]),
                        added_lines=sum(file.additions for file in commit.files),
                        deleted_lines=sum(file.deletions for file in commit.files),
                        effective_lines=sum(file.additions - file.deletions for file in commit.files)
                    )
                    commits.append(commit_info)

                    # Extract file diffs
                    file_diffs = {}
                    for file in commit.files:
                        if file.patch:
                            # Filter by file extensions
                            _, ext = os.path.splitext(file.filename)
                            if include_extensions and ext not in include_extensions:
                                continue
                            if exclude_extensions and ext in exclude_extensions:
                                continue

                            file_diffs[file.filename] = file.patch

                    commit_file_diffs[commit.sha] = file_diffs

            # Calculate code stats
            code_stats = {
                "total_added_lines": sum(commit.added_lines for commit in commits),
                "total_deleted_lines": sum(commit.deleted_lines for commit in commits),
                "total_effective_lines": sum(commit.effective_lines for commit in commits),
                "total_files": len(set(file for commit in commits for file in commit.files))
            }

            return commits, commit_file_diffs, code_stats

        except Exception as e:
            error_msg = f"Failed to retrieve GitHub commits: {str(e)}"
            print(error_msg)
            return [], {}, {}

    elif platform.lower() == "gitlab":
        # Initialize GitLab client
        gitlab_token = os.environ.get("GITLAB_TOKEN", "")
        if not gitlab_token:
            error_msg = "GITLAB_TOKEN environment variable is not set"
            print(error_msg)
            return [], {}, {}

        # Use provided GitLab URL or fall back to environment variable or default
        gitlab_url = gitlab_url or os.environ.get("GITLAB_URL", "https://gitlab.com")

        gitlab_client = Gitlab(url=gitlab_url, private_token=gitlab_token)
        print(f"Analyzing GitLab repository {repository_name} for commits by {author}")

        try:
            # Get repository
            project = gitlab_client.projects.get(repository_name)

            # Get commits
            commits = []
            commit_file_diffs = {}

            # Convert dates to ISO format
            start_iso = f"{start_date}T00:00:00Z"
            end_iso = f"{end_date}T23:59:59Z"

            # Get all commits in the repository within the date range
            all_commits = project.commits.list(all=True, get_all=True, since=start_iso, until=end_iso)

            # Filter by author
            for commit in all_commits:
                if author.lower() in commit.author_name.lower() or (
                    commit.author_email and author.lower() in commit.author_email.lower()
                ):
                    # Get commit details
                    commit_detail = project.commits.get(commit.id)

                    # Get commit diff
                    diff = commit_detail.diff(get_all=True)

                    # Filter files by extension
                    filtered_diff = []
                    for file_diff in diff:
                        file_path = file_diff.get('new_path', '')
                        _, ext = os.path.splitext(file_path)

                        if include_extensions and ext not in include_extensions:
                            continue
                        if exclude_extensions and ext in exclude_extensions:
                            continue

                        filtered_diff.append(file_diff)

                    # Skip if no files match the filter
                    if not filtered_diff:
                        continue

                    # Get file content for each modified file
                    file_diffs = {}
                    for file_diff in filtered_diff:
                        file_path = file_diff.get('new_path', '')
                        old_path = file_diff.get('old_path', '')
                        diff_content = file_diff.get('diff', '')

                        # Skip if no diff content
                        if not diff_content:
                            continue

                        # Try to get the file content
                        try:
                            # For new files, get the content from the current commit
                            if file_diff.get('new_file', False):
                                try:
                                    # Get the file content and handle both string and bytes
                                    file_obj = project.files.get(file_path=file_path, ref=commit.id)
                                    if hasattr(file_obj, 'content'):
                                        # Raw content from API
                                        file_content = file_obj.content
                                    elif hasattr(file_obj, 'decode'):
                                        # Decode if it's bytes
                                        try:
                                            file_content = file_obj.decode()
                                        except TypeError:
                                            # If decode fails, try to get content directly
                                            file_content = file_obj.content if hasattr(file_obj, 'content') else str(file_obj)
                                    else:
                                        # Fallback to string representation
                                        file_content = str(file_obj)

                                    # Format as a proper diff with the entire file as added
                                    formatted_diff = f"diff --git a/{old_path} b/{file_path}\n--- /dev/null\n+++ b/{file_path}\n"
                                    formatted_diff += "\n".join([f"+{line}" for line in file_content.split('\n')])
                                    file_diffs[file_path] = formatted_diff
                                except Exception as e:
                                    print(f"Warning: Could not get content for new file {file_path}: {str(e)}")
                                    # Try to get the raw file content directly from the API
                                    try:
                                        import base64
                                        raw_file = project.repository_files.get(file_path=file_path, ref=commit.id)
                                        if raw_file and hasattr(raw_file, 'content'):
                                            # Decode base64 content if available
                                            try:
                                                decoded_content = base64.b64decode(raw_file.content).decode('utf-8', errors='replace')
                                                formatted_diff = f"diff --git a/{old_path} b/{file_path}\n--- /dev/null\n+++ b/{file_path}\n"
                                                formatted_diff += "\n".join([f"+{line}" for line in decoded_content.split('\n')])
                                                file_diffs[file_path] = formatted_diff
                                                continue
                                            except Exception as decode_err:
                                                print(f"Warning: Could not decode content for {file_path}: {str(decode_err)}")
                                    except Exception as api_err:
                                        print(f"Warning: Could not get raw file content for {file_path}: {str(api_err)}")

                                    # Use diff content as fallback
                                    file_diffs[file_path] = diff_content
                            # For deleted files, get the content from the parent commit
                            elif file_diff.get('deleted_file', False):
                                try:
                                    # Get parent commit
                                    parent_commits = project.commits.get(commit.id).parent_ids
                                    if parent_commits:
                                        # Get the file content and handle both string and bytes
                                        try:
                                            file_obj = project.files.get(file_path=old_path, ref=parent_commits[0])
                                            if hasattr(file_obj, 'content'):
                                                # Raw content from API
                                                file_content = file_obj.content
                                            elif hasattr(file_obj, 'decode'):
                                                # Decode if it's bytes
                                                try:
                                                    file_content = file_obj.decode()
                                                except TypeError:
                                                    # If decode fails, try to get content directly
                                                    file_content = file_obj.content if hasattr(file_obj, 'content') else str(file_obj)
                                            else:
                                                # Fallback to string representation
                                                file_content = str(file_obj)

                                            # Format as a proper diff with the entire file as deleted
                                            formatted_diff = f"diff --git a/{old_path} b/{file_path}\n--- a/{old_path}\n+++ /dev/null\n"
                                            formatted_diff += "\n".join([f"-{line}" for line in file_content.split('\n')])
                                            file_diffs[file_path] = formatted_diff
                                        except Exception as file_err:
                                            # Try to get the raw file content directly from the API
                                            try:
                                                import base64
                                                raw_file = project.repository_files.get(file_path=old_path, ref=parent_commits[0])
                                                if raw_file and hasattr(raw_file, 'content'):
                                                    # Decode base64 content if available
                                                    try:
                                                        decoded_content = base64.b64decode(raw_file.content).decode('utf-8', errors='replace')
                                                        formatted_diff = f"diff --git a/{old_path} b/{file_path}\n--- a/{old_path}\n+++ /dev/null\n"
                                                        formatted_diff += "\n".join([f"-{line}" for line in decoded_content.split('\n')])
                                                        file_diffs[file_path] = formatted_diff
                                                    except Exception as decode_err:
                                                        print(f"Warning: Could not decode content for deleted file {old_path}: {str(decode_err)}")
                                                        file_diffs[file_path] = diff_content
                                                else:
                                                    file_diffs[file_path] = diff_content
                                            except Exception as api_err:
                                                print(f"Warning: Could not get raw file content for deleted file {old_path}: {str(api_err)}")
                                                file_diffs[file_path] = diff_content
                                    else:
                                        file_diffs[file_path] = diff_content
                                except Exception as e:
                                    print(f"Warning: Could not get content for deleted file {old_path}: {str(e)}")
                                    file_diffs[file_path] = diff_content
                            # For modified files, use the diff content
                            else:
                                # Check if diff_content is empty or minimal
                                if not diff_content or len(diff_content.strip()) < 10:
                                    # Try to get the full file content for better context
                                    try:
                                        # Get the file content and handle both string and bytes
                                        file_obj = project.files.get(file_path=file_path, ref=commit.id)
                                        if hasattr(file_obj, 'content'):
                                            # Raw content from API
                                            file_content = file_obj.content
                                        elif hasattr(file_obj, 'decode'):
                                            # Decode if it's bytes
                                            try:
                                                file_content = file_obj.decode()
                                            except TypeError:
                                                # If decode fails, try to get content directly
                                                file_content = file_obj.content if hasattr(file_obj, 'content') else str(file_obj)
                                        else:
                                            # Fallback to string representation
                                            file_content = str(file_obj)

                                        # Format as a proper diff with the entire file
                                        formatted_diff = f"diff --git a/{old_path} b/{file_path}\n--- a/{old_path}\n+++ b/{file_path}\n"
                                        formatted_diff += "\n".join([f"+{line}" for line in file_content.split('\n')])
                                        file_diffs[file_path] = formatted_diff
                                    except Exception as e:
                                        print(f"Warning: Could not get content for modified file {file_path}: {str(e)}")
                                        # Try to get the raw file content directly from the API
                                        try:
                                            import base64
                                            raw_file = project.repository_files.get(file_path=file_path, ref=commit.id)
                                            if raw_file and hasattr(raw_file, 'content'):
                                                # Decode base64 content if available
                                                try:
                                                    decoded_content = base64.b64decode(raw_file.content).decode('utf-8', errors='replace')
                                                    formatted_diff = f"diff --git a/{old_path} b/{file_path}\n--- a/{old_path}\n+++ b/{file_path}\n"
                                                    formatted_diff += "\n".join([f"+{line}" for line in decoded_content.split('\n')])
                                                    file_diffs[file_path] = formatted_diff
                                                except Exception as decode_err:
                                                    print(f"Warning: Could not decode content for {file_path}: {str(decode_err)}")
                                                    # Enhance the diff format with what we have
                                                    formatted_diff = f"diff --git a/{old_path} b/{file_path}\n--- a/{old_path}\n+++ b/{file_path}\n{diff_content}"
                                                    file_diffs[file_path] = formatted_diff
                                            else:
                                                # Enhance the diff format with what we have
                                                formatted_diff = f"diff --git a/{old_path} b/{file_path}\n--- a/{old_path}\n+++ b/{file_path}\n{diff_content}"
                                                file_diffs[file_path] = formatted_diff
                                        except Exception as api_err:
                                            print(f"Warning: Could not get raw file content for {file_path}: {str(api_err)}")
                                            # Enhance the diff format with what we have
                                            formatted_diff = f"diff --git a/{old_path} b/{file_path}\n--- a/{old_path}\n+++ b/{file_path}\n{diff_content}"
                                            file_diffs[file_path] = formatted_diff
                                else:
                                    # Enhance the diff format
                                    formatted_diff = f"diff --git a/{old_path} b/{file_path}\n--- a/{old_path}\n+++ b/{file_path}\n{diff_content}"
                                    file_diffs[file_path] = formatted_diff
                        except Exception as e:
                            print(f"Warning: Error processing diff for {file_path}: {str(e)}")
                            file_diffs[file_path] = diff_content

                    # Skip if no valid diffs
                    if not file_diffs:
                        continue

                    # Create CommitInfo object with enhanced diff content
                    commit_info = CommitInfo(
                        hash=commit.id,
                        author=commit.author_name,
                        date=datetime.strptime(commit.created_at, "%Y-%m-%dT%H:%M:%S.%f%z"),
                        message=commit.message,
                        files=list(file_diffs.keys()),
                        diff="\n\n".join(file_diffs.values()),
                        added_lines=sum(diff.count('\n+') for diff in file_diffs.values()),
                        deleted_lines=sum(diff.count('\n-') for diff in file_diffs.values()),
                        effective_lines=sum(diff.count('\n+') - diff.count('\n-') for diff in file_diffs.values())
                    )
                    commits.append(commit_info)

                    # Store file diffs for this commit
                    commit_file_diffs[commit.id] = file_diffs

            # Calculate code stats
            code_stats = {
                "total_added_lines": sum(commit.added_lines for commit in commits),
                "total_deleted_lines": sum(commit.deleted_lines for commit in commits),
                "total_effective_lines": sum(commit.effective_lines for commit in commits),
                "total_files": len(set(file for commit in commits for file in commit.files))
            }

            return commits, commit_file_diffs, code_stats

        except Exception as e:
            error_msg = f"Failed to retrieve GitLab commits: {str(e)}"
            print(error_msg)
            return [], {}, {}

    else:
        error_msg = f"Unsupported platform: {platform}. Use 'github' or 'gitlab'."
        print(error_msg)
        return [], {}, {}


async def evaluate_repository_code(
    repo_path: str,
    start_date: str,
    end_date: str,
    include_extensions: Optional[List[str]] = None,
    exclude_extensions: Optional[List[str]] = None,
    model_name: str = "gpt-3.5",
    output_dir: Optional[str] = None,
    email_addresses: Optional[List[str]] = None,
    platform: str = "github",
    gitlab_url: Optional[str] = None,
    model_token_limit: int = 45000,
):
    """Evaluate all commits in a repository within a time period for all committers.

    This function evaluates code by committer, combining all commits from a committer
    into a single evaluation. If the combined content is too large, it will be split
    into multiple batches based on the model's token limit.

    Args:
        repo_path: Repository path or name (e.g. owner/repo for remote repositories)
        start_date: Start date (YYYY-MM-DD)
        end_date: End date (YYYY-MM-DD)
        include_extensions: List of file extensions to include
        exclude_extensions: List of file extensions to exclude
        model_name: Name of the model to use for evaluation
        output_dir: Directory to save reports
        email_addresses: List of email addresses to send the report to
        platform: Platform to use (github or gitlab, defaults to github)
        gitlab_url: GitLab URL (for GitLab platform only)
        model_token_limit: Model token limit for evaluation (default: 45000)

    Returns:
        Dict[str, str]: Dictionary mapping author names to their report paths
    """
    # Generate default output directory if not provided
    if not output_dir:
        date_slug = datetime.now().strftime("%Y%m%d")
        output_dir = f"codedog_repo_eval_{date_slug}"

    logger.info(f"Using output directory: {output_dir}")
    print(f"Output directory: {output_dir}")

    # Create output directory if it doesn't exist
    try:
        os.makedirs(output_dir, exist_ok=True)
        logger.info(f"Created or verified output directory: {output_dir}")

        # Verify directory exists and is writable
        if not os.path.exists(output_dir):
            error_msg = f"Failed to create output directory: {output_dir}"
            logger.error(error_msg)
            print(f"Error: {error_msg}")
            return {}

        # Test write access by creating a test file
        test_file = os.path.join(output_dir, ".test_write_access")
        try:
            with open(test_file, "w") as f:
                f.write("test")
            os.remove(test_file)
            logger.info(f"Verified write access to output directory: {output_dir}")
        except Exception as e:
            error_msg = f"Output directory is not writable: {output_dir}, error: {str(e)}"
            logger.error(error_msg)
            print(f"Error: {error_msg}")
            return {}
    except Exception as e:
        error_msg = f"Failed to create output directory: {output_dir}, error: {str(e)}"
        logger.error(error_msg, exc_info=True)
        print(f"Error: {error_msg}")
        return {}

    # Get model
    model = load_model_by_name(model_name)

    print(f"Evaluating repository {repo_path} commits from {start_date} to {end_date}...")

    # Get all commits grouped by author
    if platform.lower() == "local":
        # For local repositories, we need to get all authors first
        # This is a simplified implementation - in a real scenario, you'd need to implement
        # a function to get all authors from a local git repository
        print("Local repository evaluation not implemented yet. Please use github or gitlab platform.")
        return {}
    else:
        # Use remote repository (GitHub or GitLab)
        author_commits = get_all_remote_commits(
            platform,
            repo_path,
            start_date,
            end_date,
            include_extensions,
            exclude_extensions,
            gitlab_url
        )

    if not author_commits:
        print(f"No commits found in repository {repo_path} for the specified time period")
        return {}

    # 规范化作者名称，将相同邮箱的作者合并
    normalized_author_commits = {}
    email_to_author = {}  # 邮箱到规范化作者名称的映射

    # 第一步：创建邮箱到作者的映射
    for author_key in author_commits:
        # 尝试从作者键中提取邮箱
        email_match = re.search(r'<([^>]+)>', author_key)
        if email_match:
            email = email_match.group(1).lower()  # 转为小写以确保匹配

            # 如果这个邮箱已经映射到一个作者，使用已有的映射
            if email in email_to_author:
                normalized_author = email_to_author[email]
                logger.info(f"Mapping author '{author_key}' to '{normalized_author}' based on email '{email}'")
            else:
                # 否则，将这个邮箱映射到当前作者
                normalized_author = author_key
                email_to_author[email] = author_key
                logger.info(f"New email mapping: '{email}' -> '{normalized_author}'")
        else:
            # 如果没有邮箱，使用原始作者名称
            normalized_author = author_key
            logger.info(f"No email found for author '{author_key}', using as is")

        # 将当前作者的提交添加到规范化的作者名下
        if normalized_author not in normalized_author_commits:
            normalized_author_commits[normalized_author] = author_commits[author_key]
        else:
            # 合并提交
            commits, file_diffs, stats = author_commits[author_key]
            norm_commits, norm_file_diffs, norm_stats = normalized_author_commits[normalized_author]

            # 合并提交列表
            norm_commits.extend(commits)

            # 合并文件差异字典
            norm_file_diffs.update(file_diffs)

            # 更新统计信息
            norm_stats["total_added_lines"] += stats["total_added_lines"]
            norm_stats["total_deleted_lines"] += stats["total_deleted_lines"]
            norm_stats["total_effective_lines"] += stats["total_effective_lines"]

            # 如果total_files是集合，合并集合；如果是数字，相加
            if isinstance(norm_stats["total_files"], set) and isinstance(stats["total_files"], set):
                norm_stats["total_files"].update(stats["total_files"])
            elif isinstance(norm_stats["total_files"], int) and isinstance(stats["total_files"], int):
                # 这种情况下我们无法准确合并，只能相加（可能会有重复）
                norm_stats["total_files"] += stats["total_files"]

            # 更新规范化的作者提交
            normalized_author_commits[normalized_author] = (norm_commits, norm_file_diffs, norm_stats)

            logger.info(f"Merged {len(commits)} commits from '{author_key}' into '{normalized_author}'")

    # 使用规范化后的作者提交
    author_commits = normalized_author_commits
    print(f"After normalization: Found commits from {len(author_commits)} unique authors in the repository")

    # 确保logs目录存在
    os.makedirs("logs", exist_ok=True)

    # 清空LLM日志文件，使用写入模式创建新文件
    with open("logs/LLM_interactions.log", "w", encoding="utf-8") as f:
        f.write(f"# LLM Interactions Log\n")
        f.write(f"# Repository: {repo_path}\n")
        f.write(f"# Date Range: {start_date} to {end_date}\n")
        f.write(f"# Started: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")

    logger.info("Initialized new LLM interaction log file")
    print("Initialized new LLM interaction log file")

    # Initialize evaluator
    evaluator = DiffEvaluator(model)

    # Dictionary to store report paths for each author
    author_reports = {}

    # Summary of all authors
    summary_report = f"# Repository Evaluation Summary\n\n"
    summary_report += f"## Repository: {repo_path}\n"
    summary_report += f"## Period: {start_date} to {end_date}\n\n"
    summary_report += f"## Authors\n\n"

    # Process each author's commits
    for author, (commits, commit_file_diffs, code_stats) in author_commits.items():
        if not commits:
            continue

        print(f"\nEvaluating {len(commits)} commits by {author}...")

        # Generate output file name for this author
        author_slug = get_author_slug(author)
        output_file = os.path.join(output_dir, f"codedog_eval_{author_slug}.md")

        # Timing and statistics
        start_time = time.time()

        try:
            with get_openai_callback() as cb:
                # Perform evaluation
                print(f"Evaluating code commits for {author}...")
                print(f"Using committer-based evaluation with model token limit {model_token_limit}")
                logger.info(f"Using committer-based evaluation for {author} with model token limit {model_token_limit}")

                # Split commits into batches based on token limit
                batches = split_commits_into_batches(commits, commit_file_diffs, model_token_limit)
                print(f"Split {len(commits)} commits into {len(batches)} batches")
                logger.info(f"Split {len(commits)} commits into {len(batches)} batches for {author}")

                # Evaluate each batch
                all_evaluation_results = []
                for i, batch in enumerate(batches):
                    print(f"Evaluating batch {i+1}/{len(batches)} with {len(batch)} commits")
                    logger.info(f"Starting evaluation of batch {i+1}/{len(batches)} with {len(batch)} commits for {author}")

                    # Combine all file diffs in the batch
                    batch_results = []
                    combined_diff = {}
                    total_diff_chars = 0
                    batch_commit_hashes = []

                    # Collect information for all commits in the batch
                    print(f"Combining {len(batch)} commits into a single evaluation batch")
                    logger.info(f"Combining {len(batch)} commits into a single evaluation batch")

                    for commit in batch:
                        if commit.hash not in commit_file_diffs:
                            logger.warning(f"Commit {commit.hash} not found in file diffs, skipping")
                            continue

                        batch_commit_hashes.append(commit.hash)

                        for file_path, diff in commit_file_diffs[commit.hash].items():
                            # Estimate additions and deletions
                            additions = len(re.findall(r'^\+', diff, re.MULTILINE))
                            deletions = len(re.findall(r'^-', diff, re.MULTILINE))

                            # Add commit info prefix to each file
                            prefixed_diff = f"# Commit: {commit.hash}\n# Date: {commit.date}\n# Message: {commit.message.splitlines()[0]}\n\n{diff}"

                            if file_path not in combined_diff:
                                # If new file, add directly
                                combined_diff[file_path] = {
                                    "diff": prefixed_diff,
                                    "status": "M",  # Default to modified
                                    "additions": additions,
                                    "deletions": deletions,
                                    "commits": [commit.hash]  # Track which commits modified this file
                                }
                            else:
                                # If file exists, append diff
                                combined_diff[file_path]["diff"] += f"\n\n{'-' * 40}\n\n{prefixed_diff}"
                                combined_diff[file_path]["additions"] += additions
                                combined_diff[file_path]["deletions"] += deletions
                                combined_diff[file_path]["commits"].append(commit.hash)

                            total_diff_chars += len(prefixed_diff)

                    # Log batch size information
                    logger.info(f"Combined batch has {len(combined_diff)} unique files, ~{total_diff_chars} chars")
                    print(f"Combined batch has {len(combined_diff)} unique files, ~{total_diff_chars} chars")

                    # Estimate token count
                    diff_tokens = total_diff_chars * 0.33  # More accurate coefficient
                    metadata_tokens = 200  # Batch metadata
                    prompt_tokens = 1000  # Prompt template may be larger

                    estimated_tokens = diff_tokens + metadata_tokens + prompt_tokens

                    # Log detailed token estimation
                    logger.info(f"Token estimation for combined batch: diff={diff_tokens:.0f}, metadata={metadata_tokens:.0f}, prompt={prompt_tokens:.0f}, total={estimated_tokens:.0f}")
                    print(f"Token estimation for combined batch: ~{estimated_tokens:.0f} tokens (diff: {diff_tokens:.0f}, metadata: {metadata_tokens:.0f}, prompt: {prompt_tokens:.0f})")

                    # Check if batch might be too large
                    if estimated_tokens > model_token_limit * 0.9:
                        logger.warning(f"Combined batch may be too large: ~{estimated_tokens:.0f} tokens > {model_token_limit * 0.9:.0f} tokens limit")
                        print(f"⚠️ Warning: Combined batch may be too large (~{estimated_tokens:.0f} tokens)")
                        print(f"Proceeding anyway, but may encounter token limit errors")

                    # Evaluate the combined batch
                    max_retries = 1
                    retry_count = 0
                    batch_success = False

                    while retry_count < max_retries and not batch_success:
                        try:
                            # Log retry attempts
                            if retry_count > 0:
                                logger.info(f"Retry #{retry_count} for combined batch")
                                print(f"Retrying evaluation for combined batch (attempt {retry_count}/{max_retries})")

                            # Use a special batch ID as commit hash
                            batch_id = f"batch_{i+1}_of_{len(batches)}"

                            # Evaluate the combined batch
                            print(f"Evaluating combined batch of {len(batch)} commits...")
                            logger.info(f"Evaluating combined batch with ID {batch_id}")

                            batch_results_dict = await evaluator.evaluate_commit(
                                batch_id,
                                combined_diff
                            )
                            print(f"Combined batch evaluation completed successfully: {batch_results_dict}")

                            # Process evaluation results
                            logger.info(f"Successfully evaluated combined batch")
                            print(f"Successfully evaluated combined batch")

                            # Assign results to each file and commit
                            for file_eval in batch_results_dict["files"]:
                                file_path = file_eval["path"]

                                # Check which commits modified this file
                                if file_path in combined_diff:
                                    commit_hashes = combined_diff[file_path]["commits"]

                                    # Create evaluation results for each commit that modified this file
                                    for commit_hash in commit_hashes:
                                        # Find the corresponding commit object
                                        commit_obj = next((c for c in batch if c.hash == commit_hash), None)
                                        if commit_obj:
                                            result = FileEvaluationResult(
                                                file_path=file_path,
                                                commit_hash=commit_hash,
                                                commit_message=commit_obj.message,
                                                date=commit_obj.date,
                                                author=commit_obj.author,
                                                evaluation=CodeEvaluation(
                                                    readability=file_eval["readability"],
                                                    efficiency=file_eval["efficiency"],
                                                    security=file_eval["security"],
                                                    structure=file_eval["structure"],
                                                    error_handling=file_eval["error_handling"],
                                                    documentation=file_eval["documentation"],
                                                    code_style=file_eval["code_style"],
                                                    overall_score=file_eval["overall_score"],
                                                    estimated_hours=file_eval.get("estimated_hours", 0.5) / len(commit_hashes),  # Divide hours among commits
                                                    comments=f"[Batch Evaluation] {file_eval['comments']}"
                                                )
                                            )
                                            batch_results.append(result)

                            batch_success = True
                            logger.info(f"Successfully processed evaluation results for combined batch")
                            print(f"Successfully processed evaluation results for combined batch")

                        except Exception as e:
                            retry_count += 1
                            error_msg = str(e)
                            logger.error(f"Error evaluating combined batch: {error_msg}")
                            print(f"Error evaluating combined batch: {error_msg}")

                            # Check if it's a token limit error
                            if "maximum context length" in error_msg or "reduce the length" in error_msg or "too many tokens" in error_msg.lower():
                                logger.error(f"Token limit exceeded for combined batch, batch may be too large")
                                print(f"❌ Token limit exceeded for combined batch, batch may be too large")

                                if retry_count > max_retries:
                                    # If max retries reached, create default results
                                    logger.warning(f"Creating default evaluation results after {max_retries} failed attempts")
                                    print(f"Creating default evaluation results after {max_retries} failed attempts")

                                    # Create default evaluation results for each commit in the batch
                                    for commit in batch:
                                        if commit.hash not in commit_file_diffs:
                                            continue

                                        for file_path, diff in commit_file_diffs[commit.hash].items():
                                            result = FileEvaluationResult(
                                                file_path=file_path,
                                                commit_hash=commit.hash,
                                                commit_message=commit.message,
                                                date=commit.date,
                                                author=commit.author,
                                                evaluation=CodeEvaluation(
                                                    readability=5,
                                                    efficiency=5,
                                                    security=5,
                                                    structure=5,
                                                    error_handling=5,
                                                    documentation=5,
                                                    code_style=5,
                                                    overall_score=5,
                                                    estimated_hours=0.5,
                                                    comments="Evaluation failed due to token limit exceeded in batch evaluation. The combined batch was too large for the model to process."
                                                )
                                            )
                                            batch_results.append(result)
                            else:
                                # Other types of errors
                                if retry_count > max_retries:
                                    logger.error(f"Failed to evaluate combined batch after {max_retries} retries")
                                    print(f"Failed to evaluate combined batch after {max_retries} retries")

                                    # Create default evaluation results for each commit in the batch
                                    for commit in batch:
                                        if commit.hash not in commit_file_diffs:
                                            continue

                                        for file_path, diff in commit_file_diffs[commit.hash].items():
                                            result = FileEvaluationResult(
                                                file_path=file_path,
                                                commit_hash=commit.hash,
                                                commit_message=commit.message,
                                                date=commit.date,
                                                author=commit.author,
                                                evaluation=CodeEvaluation(
                                                    readability=5,
                                                    efficiency=5,
                                                    security=5,
                                                    structure=5,
                                                    error_handling=5,
                                                    documentation=5,
                                                    code_style=5,
                                                    overall_score=5,
                                                    estimated_hours=0.5,
                                                    comments=f"Evaluation failed: {error_msg}"
                                                )
                                            )
                                            batch_results.append(result)

                    # Log batch evaluation results
                    logger.info(f"Batch {i+1}/{len(batches)} completed: {len(batch_results)} file evaluations generated")
                    print(f"Batch {i+1}/{len(batches)} completed: {len(batch_results)} file evaluations generated")

                    # Create a single whole-batch evaluation result
                    if batch_success and batch_results_dict:
                        # Get the first commit in the batch for metadata
                        first_commit = batch[0] if batch else None
                        if first_commit:
                            # Create a special FileEvaluationResult for the whole batch
                            whole_batch_result = FileEvaluationResult(
                                file_path="BATCH_EVALUATION",  # Special marker
                                commit_hash=batch_id,          # Use batch ID as commit hash
                                commit_message=f"Batch evaluation of {len(batch)} commits",
                                date=first_commit.date,
                                author=first_commit.author,
                                commit_evaluation=batch_results_dict  # Store the whole evaluation result
                            )

                            # Add this as the first result
                            batch_results.insert(0, whole_batch_result)
                            logger.info(f"Added whole-batch evaluation result")
                            print(f"Added whole-batch evaluation result")

                    all_evaluation_results.extend(batch_results)

                # Use the combined results
                evaluation_results = all_evaluation_results
                logger.info(f"Completed evaluation for {author}: {len(evaluation_results)} file evaluations generated")

                # Generate Markdown report
                report = generate_evaluation_markdown(evaluation_results)

                # Calculate cost and tokens
                total_cost = cb.total_cost
                total_tokens = cb.total_tokens

            # Add evaluation statistics
            elapsed_time = time.time() - start_time

            # Calculate effective and non-effective lines
            total_added = code_stats.get('total_added_lines', 0)
            total_deleted = code_stats.get('total_deleted_lines', 0)
            total_effective = code_stats.get('total_effective_lines', 0)

            # Get effective lines from evaluation results if available
            effective_lines = 0
            non_effective_lines = 0
            for result in evaluation_results:
                if hasattr(result, 'commit_evaluation') and result.commit_evaluation:
                    if 'effective_code_lines' in result.commit_evaluation:
                        effective_lines += result.commit_evaluation.get('effective_code_lines', 0)
                    if 'non_effective_code_lines' in result.commit_evaluation:
                        non_effective_lines += result.commit_evaluation.get('non_effective_code_lines', 0)

            # If we have effective lines from evaluation, use those
            if effective_lines > 0 or non_effective_lines > 0:
                effective_percentage = (effective_lines / (effective_lines + non_effective_lines)) * 100 if (effective_lines + non_effective_lines) > 0 else 0
                effective_lines_info = (
                    f"- **Effective Code Lines**: {effective_lines} ({effective_percentage:.1f}% of total changes)\n"
                    f"- **Non-Effective Code Lines**: {non_effective_lines} ({100 - effective_percentage:.1f}% of total changes)\n"
                )
            else:
                # Otherwise use the calculated effective lines
                effective_percentage = (total_effective / (total_added + total_deleted)) * 100 if (total_added + total_deleted) > 0 else 0
                effective_lines_info = f"- **Effective Lines**: {total_effective} ({effective_percentage:.1f}% of total changes)\n"

            telemetry_info = (
                f"\n## Evaluation Statistics\n\n"
                f"- **Evaluation Model**: {model_name}\n"
                f"- **Evaluation Time**: {elapsed_time:.2f} seconds\n"
                f"- **Tokens Used**: {total_tokens}\n"
                f"- **Cost**: ${total_cost:.4f}\n"
                f"\n## Code Statistics\n\n"
                f"- **Total Files Modified**: {code_stats.get('total_files', 0)}\n"
                f"- **Lines Added**: {total_added}\n"
                f"- **Lines Deleted**: {total_deleted}\n"
                f"{effective_lines_info}"
            )

            report += telemetry_info

            # Save report immediately after evaluation is complete
            try:
                with open(output_file, "w", encoding="utf-8") as f:
                    f.write(report)

                # Verify file exists and has content
                if os.path.exists(output_file) and os.path.getsize(output_file) > 0:
                    logger.info(f"Successfully wrote report to {output_file} ({os.path.getsize(output_file)} bytes)")

                    # Add to author reports dictionary
                    author_reports[author] = output_file

                    # Print completion message with clear indication that the file is ready
                    print(f"\n✅ Evaluation for {author} completed and saved to {output_file}")
                    print(f"   - Files: {code_stats.get('total_files', 0)}")
                    print(f"   - Lines: +{code_stats.get('total_added_lines', 0)}/-{code_stats.get('total_deleted_lines', 0)}")
                    print(f"   - Time: {elapsed_time:.2f} seconds")
                    print(f"   - Cost: ${total_cost:.4f}")
                else:
                    error_msg = f"Failed to write report for {author}: File does not exist or is empty"
                    logger.error(error_msg)
                    print(f"\n❌ {error_msg}")
            except Exception as e:
                error_msg = f"Error writing report for {author}: {str(e)}"
                logger.error(error_msg, exc_info=True)
                print(f"\n❌ {error_msg}")

            # Add to summary report
            # Get effective lines from evaluation results if available
            effective_lines = 0
            non_effective_lines = 0

            # 使用字典来跟踪每个提交的工作时间，避免重复计算
            commit_hours = {}
            commit_has_hours = {}  # 标记提交是否已经有工作时间估算

            # 初始化工作时间变量，确保在所有代码路径中都有值
            total_estimated_hours = 0

            # 始终使用committer-based模式
            is_batch_committer_mode = True

            # 如果使用了batch-committer模式，直接从LLM返回值获取工作时间
            if is_batch_committer_mode:
                logger.info(f"Using committer-based evaluation, getting working hours directly from LLM evaluation")
                # 在batch-committer模式下，我们应该只有一个评估结果，包含整个批次的评估
                if len(evaluation_results) == 1 and hasattr(evaluation_results[0], 'commit_evaluation'):
                    # 直接使用LLM返回的工作时间估计
                    total_estimated_hours = evaluation_results[0].commit_evaluation.get('estimated_hours', 0)
                    logger.info(f"Using LLM estimated hours for batch: {total_estimated_hours}")

                    # 同时获取有效代码行数
                    if 'effective_code_lines' in evaluation_results[0].commit_evaluation:
                        effective_lines = evaluation_results[0].commit_evaluation.get('effective_code_lines', 0)
                    if 'non_effective_code_lines' in evaluation_results[0].commit_evaluation:
                        non_effective_lines = evaluation_results[0].commit_evaluation.get('non_effective_code_lines', 0)
                else:
                    # 如果没有找到预期的评估结果，使用默认方法
                    logger.warning(f"Expected single evaluation result in committer-based evaluation, but found {len(evaluation_results)}. Falling back to default method.")

                    # 首先尝试从评估结果中获取工作时间
                    found_hours = False
                    for result in evaluation_results:
                        if hasattr(result, 'commit_evaluation') and result.commit_evaluation:
                            if 'effective_code_lines' in result.commit_evaluation:
                                effective_lines += result.commit_evaluation.get('effective_code_lines', 0)
                            if 'non_effective_code_lines' in result.commit_evaluation:
                                non_effective_lines += result.commit_evaluation.get('non_effective_code_lines', 0)

                            # 如果有estimated_hours，使用第一个找到的值
                            if 'estimated_hours' in result.commit_evaluation and not found_hours:
                                total_estimated_hours = result.commit_evaluation.get('estimated_hours', 0)
                                logger.info(f"Using estimated hours from first evaluation: {total_estimated_hours}")
                                found_hours = True

                    # 如果没有找到工作时间，使用默认计算方法
                    if not found_hours:
                        # 尝试从评估结果中提取工作时间
                        logger.warning(f"No estimated_hours found in LLM response. Checking raw response for hours.")

                        # 尝试从原始响应中提取工作时间
                        for result in evaluation_results:
                            if hasattr(result, 'raw_response'):
                                hours_patterns = [
                                    r'"estimated_hours"\s*:\s*(\d+(?:\.\d+)?)',
                                    r'estimated_hours\s*:\s*(\d+(?:\.\d+)?)',
                                    r'estimated hours\s*:\s*(\d+(?:\.\d+)?)',
                                    r'工时估计\s*:\s*(\d+(?:\.\d+)?)',
                                    r'(\d+(?:\.\d+)?)\s*(?:hours?|hrs?)'
                                ]

                                for pattern in hours_patterns:
                                    match = re.search(pattern, result.raw_response, re.IGNORECASE)
                                    if match:
                                        total_estimated_hours = float(match.group(1))
                                        logger.info(f"Found estimated hours in raw response: {total_estimated_hours}")
                                        break

                                if total_estimated_hours > 0:
                                    break

                        # 如果仍然没有找到工作时间，使用默认计算方法
                        if total_estimated_hours == 0:
                            try:
                                temp_evaluator = DiffEvaluator(None)
                                total_added = code_stats.get('total_added_lines', 0)
                                total_deleted = code_stats.get('total_deleted_lines', 0)
                                total_estimated_hours = temp_evaluator._estimate_default_hours(total_added, total_deleted)
                                logger.info(f"Using default estimated hours calculation: {total_estimated_hours}")
                            except Exception as e:
                                logger.error(f"Error calculating default hours: {str(e)}")
                                # 简单的回退计算
                                total_changes = code_stats.get('total_added_lines', 0) + code_stats.get('total_deleted_lines', 0)
                                total_estimated_hours = max(0.5, min(40, total_changes / 50))
                                logger.info(f"Using fallback hours calculation: {total_estimated_hours}")
            else:
                # 使用原有的按提交计算工作时间的方法
                logger.info(f"Using standard mode, calculating working hours by commit")
                for result in evaluation_results:
                    if hasattr(result, 'commit_evaluation') and result.commit_evaluation:
                        if 'effective_code_lines' in result.commit_evaluation:
                            effective_lines += result.commit_evaluation.get('effective_code_lines', 0)
                        if 'non_effective_code_lines' in result.commit_evaluation:
                            non_effective_lines += result.commit_evaluation.get('non_effective_code_lines', 0)

                    # 按提交累计工作时间，避免重复计算
                    # 关键改进：每个提交只计算一次工作时间，与详细报告保持一致
                    if hasattr(result, 'evaluation') and result.evaluation and hasattr(result, 'commit_hash'):
                        commit_hash = result.commit_hash
                        hours = result.evaluation.estimated_hours

                        # 如果这个提交还没有被计算过工作时间，则添加工作时间
                        if commit_hash not in commit_has_hours or not commit_has_hours[commit_hash]:
                            commit_hours[commit_hash] = hours
                            commit_has_hours[commit_hash] = True
                            logger.info(f"Added {hours} hours for commit {commit_hash} (first file)")
                        else:
                            logger.info(f"Skipped adding hours for commit {commit_hash} (already counted)")

                # 计算总工作时间（按提交计算，而不是按文件）
                if commit_hours:
                    total_estimated_hours = sum(commit_hours.values())
                    logger.info(f"Total estimated hours for {author}: {total_estimated_hours} (from {len(commit_hours)} commits)")
                else:
                    # 如果没有找到任何提交的工作时间，使用默认计算方法
                    try:
                        temp_evaluator = DiffEvaluator(None)
                        total_added = code_stats.get('total_added_lines', 0)
                        total_deleted = code_stats.get('total_deleted_lines', 0)
                        total_estimated_hours = temp_evaluator._estimate_default_hours(total_added, total_deleted)
                        logger.info(f"No commit hours found. Using default estimated hours calculation: {total_estimated_hours}")
                    except Exception as e:
                        logger.error(f"Error calculating default hours: {str(e)}")
                        # 简单的回退计算
                        total_changes = code_stats.get('total_added_lines', 0) + code_stats.get('total_deleted_lines', 0)
                        total_estimated_hours = max(0.5, min(40, total_changes / 50))
                        logger.info(f"Using fallback hours calculation: {total_estimated_hours}")

            # 基本信息
            summary_report += f"### {author}\n\n"
            summary_report += f"- **Commits**: {len(commits)}\n"
            summary_report += f"- **Files Modified**: {code_stats.get('total_files', 0)}\n"
            summary_report += f"- **Lines Added**: {code_stats.get('total_added_lines', 0)}\n"
            summary_report += f"- **Lines Deleted**: {code_stats.get('total_deleted_lines', 0)}\n"
            summary_report += f"- **Report**: [{os.path.basename(output_file)}]({os.path.basename(output_file)})\n\n"

            # 直接从evaluation_results中提取LLM输出并以格式化方式添加到summary
            if len(evaluation_results) > 0 and hasattr(evaluation_results[0], 'commit_evaluation'):
                eval_result = evaluation_results[0].commit_evaluation
                if eval_result:
                    # 添加原始LLM输出的完整JSON
                    summary_report += f"#### Complete LLM Evaluation Output\n\n"
                    summary_report += f"```json\n"
                    if isinstance(eval_result, dict):
                        # 使用json.dumps确保格式化良好
                        import json
                        try:
                            summary_report += json.dumps(eval_result, indent=2, ensure_ascii=False)
                        except Exception as e:
                            logger.error(f"Error formatting JSON: {e}")
                            summary_report += str(eval_result)
                    else:
                        # 如果不是字典，尝试转换为字符串
                        summary_report += str(eval_result)
                    summary_report += f"\n```\n\n"

                    # 添加评分部分
                    summary_report += f"#### Code Quality Scores\n\n"

                    # 首先尝试从whole_commit_evaluation中获取评分
                    if isinstance(eval_result, dict) and 'whole_commit_evaluation' in eval_result:
                        whole_eval = eval_result['whole_commit_evaluation']
                        readability = whole_eval.get('readability', 0)
                        efficiency = whole_eval.get('efficiency', 0)
                        security = whole_eval.get('security', 0)
                        structure = whole_eval.get('structure', 0)
                        error_handling = whole_eval.get('error_handling', 0)
                        documentation = whole_eval.get('documentation', 0)
                        code_style = whole_eval.get('code_style', 0)
                        overall_score = whole_eval.get('overall_score', 0)
                    else:
                        # 直接从LLM返回的JSON中获取评分
                        readability = eval_result.get('readability', 0) if isinstance(eval_result, dict) else getattr(eval_result, 'readability', 0)
                        efficiency = eval_result.get('efficiency', 0) if isinstance(eval_result, dict) else getattr(eval_result, 'efficiency', 0)
                        security = eval_result.get('security', 0) if isinstance(eval_result, dict) else getattr(eval_result, 'security', 0)
                        structure = eval_result.get('structure', 0) if isinstance(eval_result, dict) else getattr(eval_result, 'structure', 0)
                        error_handling = eval_result.get('error_handling', 0) if isinstance(eval_result, dict) else getattr(eval_result, 'error_handling', 0)
                        documentation = eval_result.get('documentation', 0) if isinstance(eval_result, dict) else getattr(eval_result, 'documentation', 0)
                        code_style = eval_result.get('code_style', 0) if isinstance(eval_result, dict) else getattr(eval_result, 'code_style', 0)
                        overall_score = eval_result.get('overall_score', 0) if isinstance(eval_result, dict) else getattr(eval_result, 'overall_score', 0)

                        # 不尝试从DEBUG输出中提取评分，直接使用LLM返回的值


                    summary_report += f"- **Readability**: {readability}\n"
                    summary_report += f"- **Efficiency & Performance**: {efficiency}\n"
                    summary_report += f"- **Security**: {security}\n"
                    summary_report += f"- **Structure & Design**: {structure}\n"
                    summary_report += f"- **Error Handling**: {error_handling}\n"
                    summary_report += f"- **Documentation & Comments**: {documentation}\n"
                    summary_report += f"- **Code Style**: {code_style}\n"
                    summary_report += f"- **Overall Score**: {overall_score}\n\n"

                    # 添加代码分析部分
                    summary_report += f"#### Code Analysis\n\n"

                    # 直接从LLM返回的JSON中获取评分，不做任何计算或估算
                    if isinstance(eval_result, dict) and 'whole_commit_evaluation' in eval_result:
                        whole_eval = eval_result['whole_commit_evaluation']
                        effective_code_lines = whole_eval.get('effective_code_lines', 0)
                        non_effective_code_lines = whole_eval.get('non_effective_code_lines', 0)
                    else:
                        # 直接从LLM返回的JSON中获取评分
                        effective_code_lines = eval_result.get('effective_code_lines', 0) if isinstance(eval_result, dict) else getattr(eval_result, 'effective_code_lines', 0)
                        non_effective_code_lines = eval_result.get('non_effective_code_lines', 0) if isinstance(eval_result, dict) else getattr(eval_result, 'non_effective_code_lines', 0)


                    summary_report += f"- **Effective Code Lines**: {effective_code_lines}\n"
                    summary_report += f"- **Non-effective Code Lines**: {non_effective_code_lines}\n"

                    # 直接从LLM返回的JSON中获取评分，不做任何计算或估算
                    effective_additions = eval_result.get('effective_additions', 0) if isinstance(eval_result, dict) else getattr(eval_result, 'effective_additions', 0)
                    effective_deletions = eval_result.get('effective_deletions', 0) if isinstance(eval_result, dict) else getattr(eval_result, 'effective_deletions', 0)
                    estimated_hours = eval_result.get('estimated_hours', 0) if isinstance(eval_result, dict) else getattr(eval_result, 'estimated_hours', 0)

                    summary_report += f"- **Effective Additions**: {effective_additions}\n"
                    summary_report += f"- **Effective Deletions**: {effective_deletions}\n"
                    summary_report += f"- **Estimated Working Hours**: {estimated_hours}\n\n"

                    # 添加评论部分
                    has_comments = 'comments' in eval_result if isinstance(eval_result, dict) else hasattr(eval_result, 'comments')
                    if has_comments:
                        comments = eval_result.get('comments', '') if isinstance(eval_result, dict) else getattr(eval_result, 'comments', '')
                        if comments:
                            summary_report += f"#### Detailed Analysis\n\n{comments}\n\n"

                    # 添加文件评估部分
                    has_file_evaluations = 'file_evaluations' in eval_result if isinstance(eval_result, dict) else hasattr(eval_result, 'file_evaluations')
                    if has_file_evaluations:
                        file_evaluations = eval_result.get('file_evaluations', {}) if isinstance(eval_result, dict) else getattr(eval_result, 'file_evaluations', {})
                        if file_evaluations:
                            summary_report += f"#### File Evaluations\n\n"
                            for file_name, file_eval in file_evaluations.items():
                                summary_report += f"##### {file_name}\n"

                                # 使用更安全的方式访问字段
                                file_readability = file_eval.get('readability', 0) if isinstance(file_eval, dict) else getattr(file_eval, 'readability', 0)
                                file_efficiency = file_eval.get('efficiency', 0) if isinstance(file_eval, dict) else getattr(file_eval, 'efficiency', 0)
                                file_security = file_eval.get('security', 0) if isinstance(file_eval, dict) else getattr(file_eval, 'security', 0)
                                file_structure = file_eval.get('structure', 0) if isinstance(file_eval, dict) else getattr(file_eval, 'structure', 0)
                                file_error_handling = file_eval.get('error_handling', 0) if isinstance(file_eval, dict) else getattr(file_eval, 'error_handling', 0)
                                file_documentation = file_eval.get('documentation', 0) if isinstance(file_eval, dict) else getattr(file_eval, 'documentation', 0)
                                file_code_style = file_eval.get('code_style', 0) if isinstance(file_eval, dict) else getattr(file_eval, 'code_style', 0)
                                file_overall_score = file_eval.get('overall_score', 0) if isinstance(file_eval, dict) else getattr(file_eval, 'overall_score', 0)
                                # 直接使用effective_additions作为effective_lines
                                file_effective_lines = file_eval.get('effective_additions', 0) if isinstance(file_eval, dict) else getattr(file_eval, 'effective_additions', 0)

                                summary_report += f"- **Readability**: {file_readability}\n"
                                summary_report += f"- **Efficiency**: {file_efficiency}\n"
                                summary_report += f"- **Security**: {file_security}\n"
                                summary_report += f"- **Structure**: {file_structure}\n"
                                summary_report += f"- **Error Handling**: {file_error_handling}\n"
                                summary_report += f"- **Documentation**: {file_documentation}\n"
                                summary_report += f"- **Code Style**: {file_code_style}\n"
                                summary_report += f"- **Overall Score**: {file_overall_score}\n"
                                summary_report += f"- **Effective Lines**: {file_effective_lines}\n"

                                # 检查是否有effective_additions和effective_deletions
                                if 'effective_additions' in file_eval if isinstance(file_eval, dict) else hasattr(file_eval, 'effective_additions'):
                                    file_effective_additions = file_eval.get('effective_additions', 0) if isinstance(file_eval, dict) else getattr(file_eval, 'effective_additions', 0)
                                    summary_report += f"- **Effective Additions**: {file_effective_additions}\n"

                                if 'effective_deletions' in file_eval if isinstance(file_eval, dict) else hasattr(file_eval, 'effective_deletions'):
                                    file_effective_deletions = file_eval.get('effective_deletions', 0) if isinstance(file_eval, dict) else getattr(file_eval, 'effective_deletions', 0)
                                    summary_report += f"- **Effective Deletions**: {file_effective_deletions}\n"

                                summary_report += "\n"

                    logger.info(f"Successfully added formatted LLM output to summary")
                else:
                    logger.warning("LLM evaluation result is empty")
            else:
                logger.warning("Could not extract LLM evaluation results")
            # Update the summary file after each committer is evaluated
            summary_file = os.path.join(output_dir, "summary.md")
            try:
                with open(summary_file, "w", encoding="utf-8") as f:
                    f.write(summary_report)

                # Verify summary file exists and has content
                if os.path.exists(summary_file) and os.path.getsize(summary_file) > 0:
                    logger.info(f"Successfully updated summary report with {author}'s evaluation ({os.path.getsize(summary_file)} bytes)")
                    print(f"Summary report updated: {summary_file}")
                else:
                    error_msg = f"Failed to write summary report: File does not exist or is empty"
                    logger.error(error_msg)
                    print(f"Error: {error_msg}")
            except Exception as e:
                error_msg = f"Error writing summary report: {str(e)}"
                logger.error(error_msg, exc_info=True)
                print(f"Error: {error_msg}")

        except Exception as e:
            # Log the error but continue with other authors
            error_msg = f"Error evaluating {author}: {str(e)}"
            logger.error(error_msg, exc_info=True)
            print(f"\n❌ Error evaluating {author}: {str(e)}")

            # 不计算默认工作时间，直接使用0
            logger.info(f"Not calculating default working hours for {author}, using 0 instead")

            # Create an error report for this author
            error_report = f"# Evaluation Error for {author}\n\n"
            error_report += f"## Error Details\n\n"
            error_report += f"```\n{str(e)}\n```\n\n"
            error_report += f"## Commit Statistics\n\n"
            error_report += f"- **Commits**: {len(commits)}\n"
            error_report += f"- **Files Modified**: {code_stats.get('total_files', 0)}\n"
            error_report += f"- **Lines Added**: {total_added}\n"
            error_report += f"- **Lines Deleted**: {total_deleted}\n"

            # Save the error report
            try:
                with open(output_file, "w", encoding="utf-8") as f:
                    f.write(error_report)

                # Verify file exists and has content
                if os.path.exists(output_file) and os.path.getsize(output_file) > 0:
                    logger.info(f"Successfully wrote error report to {output_file} ({os.path.getsize(output_file)} bytes)")

                    # Add to author reports dictionary
                    author_reports[author] = output_file
                    print(f"Error report saved to {output_file}")
                else:
                    error_msg = f"Failed to write error report for {author}: File does not exist or is empty"
                    logger.error(error_msg)
                    print(f"Error: {error_msg}")
            except Exception as e:
                error_msg = f"Error writing error report for {author}: {str(e)}"
                logger.error(error_msg, exc_info=True)
                print(f"Error: {error_msg}")

            # Add error entry to summary report
            summary_report += f"### {author} ❌\n\n"
            summary_report += f"- **Status**: Error during evaluation\n"
            summary_report += f"- **Commits**: {len(commits)}\n"
            summary_report += f"- **Files Modified**: {code_stats.get('total_files', 0)}\n"
            summary_report += f"- **Report**: [{os.path.basename(output_file)}]({os.path.basename(output_file)})\n\n"

            # Update the summary file after each committer is evaluated (even if there's an error)
            summary_file = os.path.join(output_dir, "summary.md")
            try:
                with open(summary_file, "w", encoding="utf-8") as f:
                    f.write(summary_report)

                # Verify summary file exists and has content
                if os.path.exists(summary_file) and os.path.getsize(summary_file) > 0:
                    logger.info(f"Successfully updated summary report with error for {author} ({os.path.getsize(summary_file)} bytes)")
                    print(f"Summary report updated: {summary_file}")
                else:
                    error_msg = f"Failed to write summary report: File does not exist or is empty"
                    logger.error(error_msg)
                    print(f"Error: {error_msg}")
            except Exception as e:
                error_msg = f"Error writing summary report: {str(e)}"
                logger.error(error_msg, exc_info=True)
                print(f"Error: {error_msg}")

    # Final summary report is already saved incrementally, just print a message
    summary_file = os.path.join(output_dir, "summary.md")
    print(f"\nFinal summary report saved to {summary_file}")

    # Send email report if addresses provided
    if email_addresses:
        subject = f"[CodeDog] Repository Evaluation Report for {repo_path} ({start_date} to {end_date})"

        sent = send_report_email(
            to_emails=email_addresses,
            subject=subject,
            markdown_content=summary_report,
        )

        if sent:
            print(f"Summary report sent to {', '.join(email_addresses)}")
        else:
            print("Failed to send email notification")

    return author_reports

def generate_full_report(repository_name, pull_request_number, email_addresses=None, platform="github", gitlab_url=None):
    """Generate a full report including PR summary and code review.

    Args:
        repository_name (str): Repository path (e.g. owner/repo)
        pull_request_number (int): Pull request number to review
        email_addresses (list, optional): List of email addresses to send the report to
        platform (str, optional): Platform to use (github or gitlab). Defaults to "github".
        gitlab_url (str, optional): GitLab URL. Defaults to https://gitlab.com or GITLAB_URL env var.
    """
    start_time = time.time()

    # Initialize client and retriever based on platform
    if platform.lower() == "github":
        # Initialize GitHub client and retriever
        github_client = Github()  # Will automatically load GITHUB_TOKEN from environment
        print(f"Analyzing GitHub repository {repository_name} PR #{pull_request_number}")

        try:
            retriever = GithubRetriever(github_client, repository_name, pull_request_number)
            print(f"Successfully retrieved PR: {retriever.pull_request.title}")
        except Exception as e:
            error_msg = f"Failed to retrieve GitHub PR: {str(e)}"
            print(error_msg)
            return error_msg

    elif platform.lower() == "gitlab":
        # Initialize GitLab client and retriever
        gitlab_token = os.environ.get("GITLAB_TOKEN", "")
        if not gitlab_token:
            error_msg = "GITLAB_TOKEN environment variable is not set"
            print(error_msg)
            return error_msg

        # Use provided GitLab URL or fall back to environment variable or default
        gitlab_url = gitlab_url or os.environ.get("GITLAB_URL", "https://gitlab.com")

        gitlab_client = Gitlab(url=gitlab_url, private_token=gitlab_token)
        print(f"Analyzing GitLab repository {repository_name} MR #{pull_request_number}")

        try:
            retriever = GitlabRetriever(gitlab_client, repository_name, pull_request_number)
            print(f"Successfully retrieved MR: {retriever.pull_request.title}")
        except Exception as e:
            error_msg = f"Failed to retrieve GitLab MR: {str(e)}"
            print(error_msg)
            return error_msg

    else:
        error_msg = f"Unsupported platform: {platform}. Use 'github' or 'gitlab'."
        print(error_msg)
        return error_msg

    # Load models based on environment variables
    code_summary_model = os.environ.get("CODE_SUMMARY_MODEL", "gpt-3.5")
    pr_summary_model = os.environ.get("PR_SUMMARY_MODEL", "gpt-4")
    code_review_model = os.environ.get("CODE_REVIEW_MODEL", "gpt-3.5")

    # Initialize chains with specified models
    summary_chain = PRSummaryChain.from_llm(
        code_summary_llm=load_model_by_name(code_summary_model),
        pr_summary_llm=load_model_by_name(pr_summary_model),
        verbose=True
    )

    # Check if orchestration is enabled
    use_orchestration = os.environ.get("USE_ORCHESTRATION", "false").lower() == "true"

    # Create code review chain using factory
    review_chain = CodeReviewChainFactory.create_chain(
        llm=load_model_by_name(code_review_model),
        use_orchestration=use_orchestration,
        models={
            "default": load_model_by_name(code_review_model),
            "coordinator": load_model_by_name(code_review_model),
            "security": load_model_by_name(code_review_model),
            "performance": load_model_by_name(code_review_model),
            "readability": load_model_by_name(code_review_model),
            "architecture": load_model_by_name(code_review_model),
            "documentation": load_model_by_name(code_review_model)
        } if use_orchestration else None,
        verbose=True
    )

    if use_orchestration:
        print("Using orchestrated code review with specialized agents")
    else:
        print("Using standard code review")

    with get_openai_callback() as cb:
        # Get PR summary
        print(f"Generating PR summary using {pr_summary_model}...")
        pr_summary_result = asyncio.run(pr_summary(retriever, summary_chain))
        pr_summary_cost = cb.total_cost
        print(f"PR summary complete, cost: ${pr_summary_cost:.4f}")

        # Get code review
        print(f"Generating code review using {code_review_model}...")
        try:
            code_review_result = asyncio.run(code_review(retriever, review_chain))
            code_review_cost = cb.total_cost - pr_summary_cost
            print(f"Code review complete, cost: ${code_review_cost:.4f}")
        except Exception as e:
            print(f"Code review generation failed: {str(e)}")
            print(traceback.format_exc())
            # Use empty code review
            code_review_result = {"code_reviews": []}

        # Create report
        total_cost = cb.total_cost
        total_time = time.time() - start_time

        reporter = PullRequestReporter(
            pr_summary=pr_summary_result["pr_summary"],
            code_summaries=pr_summary_result["code_summaries"],
            pull_request=retriever.pull_request,
            code_reviews=code_review_result.get("code_reviews", []),
            telemetry={
                "start_time": start_time,
                "time_usage": total_time,
                "cost": total_cost,
                "tokens": cb.total_tokens,
            },
        )

        report = reporter.report()

        # Save report to file
        report_file = f"codedog_pr_{pull_request_number}.md"
        with open(report_file, "w", encoding="utf-8") as f:
            f.write(report)
        print(f"Report saved to {report_file}")

        # Send email notification if email addresses provided
        if email_addresses:
            subject = f"[CodeDog] Code Review for {repository_name} PR #{pull_request_number}: {retriever.pull_request.title}"
            sent = send_report_email(
                to_emails=email_addresses,
                subject=subject,
                markdown_content=report,
            )
            if sent:
                print(f"Report sent to {', '.join(email_addresses)}")
            else:
                print("Failed to send email notification")

        return report






def main():
    """Main function to parse arguments and run the repository evaluation command."""
    # Configure logging
    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        handlers=[
            logging.FileHandler("codedog.log"),
            logging.StreamHandler()
        ]
    )
    logger.info("Starting CodeDog")

    # 确保logs目录存在
    os.makedirs("logs", exist_ok=True)

    # 清空LLM日志文件，使用写入模式创建新文件
    with open("logs/LLM_interactions.log", "w", encoding="utf-8") as f:
        f.write(f"# LLM Interactions Log\n")
        f.write(f"# Started: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")

    logger.info("Initialized new LLM interaction log file")

    # Parse arguments
    args = parse_args()
    logger.info(f"Command: {args.command}")
    logger.debug(f"Arguments: {args}")

    if args.command == "repo-eval":
        logger.info(f"Running repository evaluation for {args.repo}")

        # Set default dates if not provided
        if not args.start_date:
            args.start_date = (datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
            logger.info(f"Using default start date: {args.start_date}")

        if not args.end_date:
            args.end_date = datetime.now().strftime("%Y-%m-%d")
            logger.info(f"Using default end date: {args.end_date}")

        # Process file extension parameters
        include_extensions = None
        if args.include:
            include_extensions = parse_extensions(args.include)
            logger.info(f"Using provided include extensions: {include_extensions}")
        elif os.environ.get("DEV_EVAL_DEFAULT_INCLUDE"):
            include_extensions = parse_extensions(os.environ.get("DEV_EVAL_DEFAULT_INCLUDE"))
            logger.info(f"Using default include extensions from environment: {include_extensions}")

        exclude_extensions = None
        if args.exclude:
            exclude_extensions = parse_extensions(args.exclude)
            logger.info(f"Using provided exclude extensions: {exclude_extensions}")
        elif os.environ.get("DEV_EVAL_DEFAULT_EXCLUDE"):
            exclude_extensions = parse_extensions(os.environ.get("DEV_EVAL_DEFAULT_EXCLUDE"))
            logger.info(f"Using default exclude extensions from environment: {exclude_extensions}")

        # Get model
        model_name = args.model or os.environ.get("CODE_REVIEW_MODEL", "gpt-3.5")
        logger.info(f"Using model: {model_name}")

        # Get email addresses
        email_addresses = parse_emails(args.email or os.environ.get("NOTIFICATION_EMAILS", ""))
        if email_addresses:
            logger.info(f"Will send report to: {email_addresses}")

        # Log platform information
        logger.info(f"Using {args.platform} platform with repository: {args.repo}")
        if args.platform == "gitlab" and args.gitlab_url:
            logger.info(f"Using GitLab URL: {args.gitlab_url}")

        # Run repository evaluation
        logger.info("Starting repository evaluation process")

        # Log evaluation settings
        logger.info(f"Using committer-based evaluation with token limit {args.model_token_limit}")
        print(f"Using committer-based evaluation (all commits from a committer evaluated together)")
        print(f"- Model token limit: {args.model_token_limit}")

        try:
            author_reports = asyncio.run(evaluate_repository_code(
                repo_path=args.repo,
                start_date=args.start_date,
                end_date=args.end_date,
                include_extensions=include_extensions,
                exclude_extensions=exclude_extensions,
                model_name=model_name,
                output_dir=args.output_dir,
                email_addresses=email_addresses,
                platform=args.platform,
                gitlab_url=args.gitlab_url,
                model_token_limit=args.model_token_limit
            ))

            logger.info("Repository evaluation completed successfully")

            if author_reports:
                logger.info(f"Generated reports for {len(author_reports)} authors")
                print("\n===================== Repository Evaluation Report =====================\n")
                print(f"Reports generated successfully for {len(author_reports)} authors.")
                print("See output directory for details.")
                print("\n===================== Report End =====================\n")
        except Exception as e:
            logger.error(f"Error during repository evaluation: {str(e)}", exc_info=True)
            print(f"Error during repository evaluation: {str(e)}")

    else:
        # No command specified, show usage
        print("Please specify a command. Use --help for more information.")
        print("Example: python run_codedog.py repo-eval owner/repo --start-date 2023-01-01 --end-date 2023-01-31 --platform github  # Evaluate all commits in a GitHub repo")
        print("Example: python run_codedog.py repo-eval owner/repo --start-date 2023-01-01 --end-date 2023-01-31 --platform gitlab --gitlab-url https://gitlab.example.com  # Evaluate all commits in a GitLab repo")


if __name__ == "__main__":
    try:
        main()
    except Exception as e:
        error_msg = f"Error: {str(e)}"
        print(error_msg)
        print("\nDetailed error information:")
        traceback.print_exc()

        # Log the error if logging is configured
        try:
            logger.error(error_msg, exc_info=True)
            logger.error("Program terminated with error")
        except:
            # If logging is not yet configured, just print
            pass