Allow globs to be used instead of branch names

import fsImport from 'fs'
import util from 'util'
import childProcess from 'child_process'
import {repos, getBranchNames} from './src/repos.ts'
import branches from './src/branches.ts'
import flatFiles from './src/flatFiles.ts'
import flatPatches from './src/flatPatches.ts'

        // 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 = directories.output + reposPath + "/" + gitRepoName
        const fetchCommands = (await getBranchNames(repoConfig, repoName)).map(branch => `git -C ${location} fetch origin ${branch}:${branch}`).join('; ')
        await exec(`${fetchCommands} && git -C ${location} update-server-info`)
      } else {
        // If it is not there, do git clone

          const tempDirRepoPath = `${tempDir}/${eleventyConfig.getFilter("slugify")(repoName)}`
          await exec(`mkdir ${tempDir}`)
          await exec(`git clone -s ${directories.output}${eleventyConfig.getFilter("slugify")(repoName)}.git ${tempDirRepoPath}`)
          for (let branch of await getBranchNames(repoConfig, repoName)) {
            // TODO why doesn't git -C checkout work? Says that repo doesn't exist
            await exec(`(cd ${tempDirRepoPath} && git checkout ${branch})`)
            for (let buildStep of repoConfig.buildSteps) {

  type ReposConfiguration,
  type GitConfig,
} from './configTypes.ts'
import util from 'util'
import childProcess from 'child_process'
import path from 'path'

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

const exec = util.promisify(childProcess.exec)

const branchesForReposMap: Map<string, string[]> = new Map()

const getBranchNames = async (repoConfig: GitConfig, repoName: string): Promise<Array<string>> => {
  const cachedBranchNames = branchesForReposMap.get(repoName)
  if (cachedBranchNames !== undefined) {
    return cachedBranchNames
  }

  // Get all branches available in the repository
  const allBranches = (await exec(`git -C ${repoConfig.location} branch --format="%(refname:short)"`)).stdout.split("\n")
  const matchingBranchesFromGlobs: Map<string, string[]> = new Map()
  const literalBranchNames: string[] = []

  repoConfig.branchesToPull.forEach((branch) => {
    if (typeof branch === "string") {
      literalBranchNames.push(branch)
    }
    else {
      // If we're here, then the "branch" was an object like:
      // { glob: string, max: number }
      // TODO: figure out which branch is the newest/oldest, and
// keep them less than `max` by kicking out the oldest from the list.
      const glob = branch['glob']
      const matching = allBranches.filter((possibleBranch) => {
        const match = path.matchesGlob(possibleBranch, glob)
        return match
      })
      matchingBranchesFromGlobs.set(
        glob,
        (matchingBranchesFromGlobs.get(glob) || []).concat(matching)
      )
    }
  })

  const matchedBranchesFromGlobs = Array.from(matchingBranchesFromGlobs.values()).flat()
  const branchNames: string[] = Array.from(new Set(matchedBranchesFromGlobs.concat(literalBranchNames)))

  if (branchesForReposMap.get(repoName) === undefined) {
    branchesForReposMap.set(repoName, branchNames)
  }

  return branchNames
}

let cachedRepos: Array<Repository> | null = null

  cachedRepos = []

  for (const repoName of repoNames) {
    const repoLocation = getLocation(reposConfig, outputDir, repoName)
    const branchNames = await getBranchNames(reposConfig.repos[repoName], repoName)
    const commits: Repository['commits'] = new Map()
    for (const branchName of branchNames) {
⁣
      await addBranchToCommitsMap(branchName, repoLocation, commits)
    }

  return cachedRepos
}

export {repos, getBranchNames}

```js
path.matchesGlob('/foo/bar', '/foo/*'); // true
```


## Jan 17, 2026

- Update getBranchNames so that it 1) pulls all branches from the repo, and 2)
  figures out which ones match the given branch globs.
- where does that get called?
  - it gets called when `repos()` is called
  - and `repos()` get called when main.ts runs, so after the beforehook is called.
  - we'll need to decide which branches get pulled in the before hook, so that the clone
    only pulls the branches we want
  - for a first-attempt solution, make a function that figures out which branches
    are available and call it multiple times: once when pulling the branches, and then also
    in subsequent calls when we're seeing which branches are available in the repo.
    - So, stop calling `repoConfig.branchesToPull` directly
  - currently failing locally because I don't have the updated beforeHook on this
    laptop. Push current work, update local repo to use the beforeHook from the
    clone-early branch, and see if that works. (update: Yes, that was the problem.)
    - this is a good reason to put the deployed repo config on the public site, too.
      I currently have different example site configs between my laptop and the deployed
      site.