Method copy_repo

src/git.rs:108–432

Copy repository for a task using the task ID and repository root Creates a task repository by cloning the source repository and overlaying all non-ignored files from the working directory including: - Tracked files with their current working directory content (including unstaged changes) - Staged files (newly added files in the index) - Untracked files (not ignored) - The .tsk directory for proje

(
        &self,
        task_id: &str,
        repo_root: &Path,
        source_commit: Option<&str>,
        branch_name: &str,
        copy_mode: CopyMode,
    )

    ///
    /// Returns a [`CopyResult`] with the path and any non-fatal warnings.
    pub async fn copy_repo(
        &self,
        task_id: &str,
        repo_root: &Path,
        source_commit: Option<&str>,
        branch_name: &str,
        copy_mode: CopyMode,
    ) -> Result<CopyResult, String> {
        // Use the task ID directly for the directory name
        let task_dir_name = task_id;
        let branch_name = branch_name.to_string();
        let mut warnings = Vec::new();

        // Create the task directory structure in centralized location
        let task_dir = self.ctx.tsk_env().task_dir(task_dir_name);
        let repo_path = task_dir.join("repo");

        // Create directories if they don't exist
        crate::file_system::create_dir(&task_dir)
            .await
            .map_err(|e| format!("Failed to create task directory: {e}"))?;

        // Check if the provided path is in a git repository
        if !git_operations::is_git_repository(repo_root).await? {
            return Err("Not in a git repository".to_string());
        }

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

        // Get list of all files that should be copied (only needed for WorkingTree mode):
        // 1. All tracked files (from working directory, including unstaged changes)
        // 2. All staged files (including newly added files in the index)
        // 3. All untracked files (not ignored)
        let all_files_to_copy = if matches!(copy_mode, CopyMode::WorkingTree) {
            git_operations::get_all_non_ignored_files(&current_dir).await?
        } else {
            Vec::new()
        };

        // Clone repository with optimized pack files (no hardlinks)
        // This creates an efficient repository copy with 1-2 pack files instead of
        // preserving fragmented pack structure from the source repository
        git_operations::clone_local(&current_dir, &repo_path)
            .await
            .map_err(|e| format!("Failed to clone repository: {e}"))?;

        // Copy .git/modules from source to preserve submodule git data
        // This must happen BEFORE branch creation and file overlay so that
        // submodule .git files have valid targets to point to
        let src_git_common = crate::repo_utils::resolve_git_common_dir(&current_dir)
            .unwrap_or_else(|_| current_dir.join(".git"));
        let src_modules = src_git_common.join("modules");
        let dst_modules = repo_path.join(".git/modules");

        if crate::file_system::exists(&src_modules)
            .await
            .unwrap_or(false)