Use the git -C flag instead of changing directories

export const NavHelper = (reposConfig: ReposConfiguration, slugify: Function, repoName: string, branchName: string) => {
  const reposPath = reposConfig.path || ""

  // These two aren't actually used by any pages, but they're in almost
  // every page URL. E.g. all of them start with 'repos/my-repo-name'
  // or 'repos/my-repo-name/branches.'
  const repoBasePath = `${reposPath}/${slugify(repoName)}`
  const rootBasePathBranches = `${repoBasePath}/branches`


  const currentBranchPath = `${rootBasePathBranches}/${slugify(branchName)}`

  return {
    rootPath: () => {

      }
    },
    repoHomePath: () => {
      return `${rootBasePathBranches}/${slugify(reposConfig.repos[repoName].defaultBranch)}`
    },
    repoCurrentBranchHome: () => {
      return currentBranchPath
    },
    repoCurrentBranchFiles: () => {
      return `${currentBranchPath}/files`
    },
    repoCurrentBranchCommits: () => `${currentBranchPath}/commits`,
    repoCurrentBranchBranches: () => `${currentBranchPath}/branches`,
  }
}

        if (fsImport.existsSync(repoPath + ".git")) {
          // git repos are just in the repos folder, not in their subdir
          // create string of commands saying 'git fetch origin branch:branch' for each branch
          const location = eleventyConfig.dir.output + reposPath + "/" + gitRepoName
          const fetchCommands = repoConfig.branchesToPull.map(branch => `git -C ${location} fetch origin ${branch}:${branch}`).join('; ')
          await exec(`${fetchCommands} && git update-server-info`)
        } else {
          // If it is not there, do git clone
          // todo: does this work if the latest branch is not checked
          // out locally?
          const originalLocation = cwd + "/" + repoConfig.location
          await exec(`git clone ${originalLocation} ${eleventyConfig.dir.output + reposPath + "/" + gitRepoName} --bare`)
          await exec(`git -C ${eleventyConfig.dir.output + reposPath + "/" + gitRepoName} update-server-info`)
        }
        if (typeof repoConfig.artifactSteps !== 'undefined') {
          // make a temp directory for things to run in

          await exec(`mkdir ${tempDir}`)
          await exec(`git clone -s ${directories.output}${eleventyConfig.getFilter("slugify")(repoName)}.git ${tempDirRepoPath}`)
          for (let branch of repoConfig.branchesToPull) {
            await exec(`git -C ${tempDirRepoPath} checkout ${branch}`)
            for (let artifactStep of repoConfig.artifactSteps) {
              // Run the command for each step in each branch
              await exec(`(cd ${tempDirRepoPath} && ${artifactStep.command})`)

          // delete the temp dirs
          await exec(`rm -r ${tempDir}`)
        }

        const location = eleventyConfig.dir.output + reposPath + "/" + gitRepoName
        await exec(`git -C ${location} symbolic-ref HEAD refs/heads/${repoConfig.defaultBranch}`)
      }
    }
  );

  eleventyConfig.addAsyncFilter("getFileContents", async (repo: string, branch: string, filename: string) => {
    const location = getLocation(reposConfiguration, repo)
    const command = `git -C ${location} show ${branch}:${filename}`
    const res = await exec(command)
    return res.stdout
  })

  eleventyConfig.addAsyncFilter("getReadMe", async (repoName: string, branchName: string) => {
    const location = getLocation(reposConfiguration, repoName)
    const command = `git -C ${location} show ${branchName}:README.md`
    try {
      const res = await exec(command)
      return res.stdout
    } catch {
      return ""

    const branches = await Promise.all(branchNames.map(async (branchName) => {
      const repoLocation = getLocation(reposConfig, repoName)
      const branchHeadRes = await exec(`git -C ${repoLocation} show-ref --branch ${branchName}`)
      const branchHead = branchHeadRes.stdout.split(" ")[0]
      return {
        name: branchName,

import { type Repository } from '../../dataTypes.ts'

export const getFileList = async (branchName: string, repoLocation: string) => {
  const command = `git -C ${repoLocation} ls-tree -r --name-only ${branchName}`

  const result = await exec(command)
  let files = result.stdout.split("\n").filter(item => item.length > 0 && item != ".")
  // TODO: this could be better. This is adding each sub-path of a file to a set, so that
  // we don't wind up with repeats, and then converting that back into an array. E.g. if

}

export const addBranchToCommitsMap = async(branchName: string, repoLocation: string, commits: Repository['commits']): Promise<void> => {
  const totalPatchesCountRes = await exec(`git -C ${repoLocation} rev-list --count ${branchName}`)
  const totalPatchesCount = parseInt(totalPatchesCountRes.stdout)
  let previousHash: null | string = null
  for (let i = 0; i < totalPatchesCount; i = i + 10) {
    const gitLogSubsetRes = await exec(`git -C ${repoLocation} log ${branchName} -p -n 10 --skip ${i}`)
    let gitLogSubset = gitLogSubsetRes.stdout.split("\n")
    do {
      const nextPatchStart = gitLogSubset.findIndex((line, index) => {

export const getFileLastTouchInfo = async (branch: string, filename: string, repoLocation: string) => {
  const regex = RegExp(".* [0-9]+ [0-9]+")
  const command = `git -C ${repoLocation} blame --porcelain ${branch} ${filename}`
  const res = await exec(command)
  const output = res.stdout
  const outputLines = output.split("\n")
  const initialValue: Array<Array<string>> = [[outputLines[0]]]