Method fetch_changes

src/git.rs:579–702

Fetch changes from the copied repository back to the main repository. Returns a `FetchResult` with `has_changes: false` if the branch has no new commits.

(
        &self,
        repo_path: &Path,
        branch_name: &str,
        repo_root: &Path,
        source_commit: &str,
        source_branch: Option<&str>,
        git_town_enabled: bool,
    )

    /// Fetch changes from the copied repository back to the main repository.
    /// Returns a `FetchResult` with `has_changes: false` if the branch has no new commits.
    pub async fn fetch_changes(
        &self,
        repo_path: &Path,
        branch_name: &str,
        repo_root: &Path,
        source_commit: &str,
        source_branch: Option<&str>,
        git_town_enabled: bool,
    ) -> Result<FetchResult, String> {
        // Check if there are any changes by comparing HEAD with source commit
        let current_head = git_operations::get_current_commit(repo_path).await?;
        if current_head == source_commit {
            return Ok(FetchResult {
                has_changes: false,
                warnings: vec![],
            });
        }

        let repo_path_str = repo_path
            .to_str()
            .ok_or_else(|| "Invalid repo path".to_string())?;

        // Use the provided repository root
        let main_repo = repo_root.to_path_buf();

        // Add the copied repository as a remote in the main repository
        let now: DateTime<Local> = Local::now();
        let remote_name = format!("tsk-temp-{}", now.format("%Y-%m-%d-%H%M%S"));

        // Synchronize git operations on the main repository
        let (has_commits, warnings) = self
            .ctx
            .git_sync_manager()
            .with_repo_lock(&main_repo, || async {
                let mut warnings: Vec<String> = Vec::new();

                git_operations::add_remote(&main_repo, &remote_name, repo_path_str).await?;

                // Validate that the branch is accessible before attempting fetch
                if let Err(e) =
                    git_operations::validate_branch_accessible(repo_path, branch_name).await
                {
                    // Clean up remote before returning error
                    let _ = git_operations::remove_remote(&main_repo, &remote_name).await;
                    return Err(format!(
                        "Cannot fetch branch '{}': {}\n\
                         The branch was created but points to an inaccessible commit.\n\
                         This may indicate git object database inconsistency.",
                        branch_name, e
                    ));
                }

                // Fetch the specific branch from the remote
                match git_operations::fetch_branch(&main_repo, &remote_name, branch_name).await {
                    Ok(_) => {
                        // Remove the temporary remote
                        git_operations::remove_remote(&main_repo, &remote_name).await?;