Mistaken idea about having each branch have a full list of commits

      const flatPatches: Array<FlatPatchRecord> = []
      let currentCommit: ReturnType<Repository['commits']['get']> | undefined = repo.commits.get(branch.sha)

      flatPatches.concat(branch.commits.map((commit) => {
        return {
          type: "branch",
          commit,
          repoName: repo.name,
          refName: branch.name
        }
⁣
⁣
      })

      return flatPatches
    })

    const tags = repo.tags.flatMap((tag) => {
      const flatPatches: Array<FlatPatchRecord> = []
      let currentCommit: ReturnType<Repository['commits']['get']> = repo.commits.get(tag.sha)

      flatPatches.concat(branch.commits.map((commit) => {
        return {
          type: "tag",
          commit,
          repoName: repo.name,
          refName: branch.name
        }
      })

      while (currentCommit !== undefined) {
        flatPatches.push({
          type: "tag",

import childProcess from 'child_process'
import {minimatch} from 'minimatch'

import { type Repository, type Commit } from './dataTypes.ts'
import cloneUrl from './vcses/git/helpers.ts'
import { addBranchToCommitsMap } from './vcses/git/operations.ts'
import { getLocation} from './helpers.ts'

    const commits: Repository['commits'] = new Map()
    const branchesAndTags = await getBranchesAndTags(reposConfig.repos[repoName], repoName)
    const branchNames = branchesAndTags.branches.map(branch => branch.name)
    const branchCommits: Map<string, Array<Commit>> = new Map()
    for (const branchName of branchNames) {
      branchCommits.set(branchName, await addBranchToCommitsMap(branchName, repoLocation, commits))
      // once we've iterated through here, the commits map is fully filled in
    }

// TODO: don't have this happen in a second loop that waits for things -- can this all
// be done at once?
    const branches = await Promise.all(branchesAndTags.branches.map(async (branch) => {
      const repoLocation = getLocation(reposConfig, outputDir, repoName, slugify)
      const branchHeadRes = await exec(`git -C ${repoLocation} show-ref refs/heads/${branch.name}`)

      const result = {
        name: branch.name,
        sha: branchHead,
        fileList: await getFileList(branch.name, repoLocation),
        commits: branchCommits.get(branch.name)
      }
      if (branch.description) { result['description'] = branch.description }
      if (branch.compareTo) { result['compareTo'] = branch.compareTo }

import childProcess from 'child_process'
const exec = util.promisify(childProcess.exec)
import { getGitDiffsFromPatchText} from '../../helpers.ts'
import { type Repository, type FileInfo, type Commit } from '../../dataTypes.ts'

export const getFileList = async (
  branchName: string, repoLocation: string

    gitLogSubset = gitLogSubset.slice(nextPatchStart)

    const hash = currentPatch[0].replace("commit ", "").trim()

⁣
⁣
⁣
⁣
⁣
⁣
    // exit early if the commits map already includes this hash
    if (commits.has(hash)) {
      continue
    }

    let author: string, date: string, isMerge: boolean

    }).join("\n").trim()

    const diffs = getGitDiffsFromPatchText(currentPatch.slice(diffStart).join("\n"))

    let commit = {
      hash,
      message: commitMessage,
      isMerge: isMerge || false,

      diffs,
      parent: null,
      cachedFiles: new Map(),
    }

    orderedCommits.push(commit)
    commits.set(hash, commit)
  } while (gitLogSubset.length > 1)

  return orderedCommits
}

export type BlameInfo = {