Method import_branch

atomic-cli/src/commands/git/parallel.rs:2210–2438

Import commits from a branch into an Atomic repository. Commits are processed in **batches** to keep memory bounded and show progress sooner. Each batch: parse in parallel → write sequentially. Imports use a fixed 1,000-commit batch size. This keeps progress and memory behavior predictable across small and large repositories.

(
        &self,
        branch_name: &str,
        repo: &mut Repository,
    )

    /// Imports use a fixed 1,000-commit batch size. This keeps progress and
    /// memory behavior predictable across small and large repositories.
    pub fn import_branch(
        &self,
        branch_name: &str,
        repo: &mut Repository,
    ) -> CliResult<ImportStats> {
        let mut stats = ImportStats::default();

        // Open git repo for this thread
        let git_repo = self.open_git_repo()?;

        // Collect commit OIDs in topological order
        let commit_oids = self.collect_commit_oids(&git_repo, branch_name)?;
        stats.commits_found = commit_oids.len();

        if commit_oids.is_empty() {
            return Ok(stats);
        }

        let total = commit_oids.len();
        let batch_size = Self::batch_size_for(total);

        print_info(&format!(
            "Importing {} commits in batches of {}...",
            total, batch_size
        ));

        let import_start = Instant::now();
        let mut commits_written = 0usize;
        let mut line_index = ImportLineIndex::default();
        let mut all_imported_commits: Vec<ImportedCommitInfo> = Vec::new();

        for (batch_idx, chunk) in commit_oids.chunks(batch_size).enumerate() {
            let batch_start = batch_idx * batch_size;
            let batch_end = (batch_start + chunk.len()).min(total);

            print_info(&format!(
                "Batch {}: parsing commits {}-{} of {}...",
                batch_idx + 1,
                batch_start,
                batch_end,
                total
            ));

            // Phase 1: Parallel git parsing for this batch
            let parse_start = Instant::now();
            let parsed_commits = self.phase1_parse(chunk)?;
            let parse_elapsed = parse_start.elapsed();

            stats.phase1_duration += parse_elapsed;
            stats.commits_parsed += parsed_commits.len();

            if parsed_commits.is_empty() {
                continue;
            }

            // Phase 2: Sequential write for this batch
            let write_start = Instant::now();
            let (write_stats, batch_imported) =