git-cleanup-branches

#!/usr/bin/env -S deno run --allow-all

import yargs from "https://deno.land/x/yargs@v17.7.2-deno/deno.ts";

const DEBUG = !!Deno.env.get("DEBUG");
const DRY_RUN = !!Deno.env.get("DRY_RUN");

function tmpNameSync(prefix: string = "tmp"): string {
  const uniqueId = crypto.randomUUID();
  return `${prefix}-${uniqueId}`;
}

function runCommandSync(command: string, args: string[]): string {
  if (DEBUG) {
    console.log(`+ ${command} ${args.join(" ")}`);
  }
  const result = new Deno.Command(command, {
    args: args,
  }).outputSync();

  if (!result.success) {
    const stdout = new TextDecoder().decode(result.stdout);
    if (stdout) {
      console.log(stdout);
    }
    throw new Error(
      `Command failed: ${command} ${args.join(" ")} (exit code: ${result.code})`
    );
  }

  return new TextDecoder().decode(result.stdout);
}

interface ParsedRef {
  remote?: string;
  ref: string;
  branchName: string;
  isLocal: boolean;
  lastCommitDate: Date;
}

interface BranchesByOrigin {
  local: ParsedRef[];
  remotes: Record<string, ParsedRef[]>;
}

interface CandidateState {
  candidateInstructions(): string;
  branchCandidates(): ParsedRef[];
}

function parseRef(ref: string, lastCommitDate: Date): ParsedRef | null {
  const remoteMatch = ref.match(/^refs\/remotes\/([^/]+)\/(.+)$/);
  const localMatch = ref.match(/^refs\/heads\/(.+)$/);

  if (remoteMatch) {
    const [, remote, branchName] = remoteMatch;
    return {
      remote,
      ref,
      branchName,
      isLocal: false,
      lastCommitDate,
    };
  } else if (localMatch) {
    const [, branchName] = localMatch;
    return {
      ref,
      branchName,
      isLocal: true,
      lastCommitDate,
    };
  }
  return null;
}

function groupByOrigin(branches: ParsedRef[]): BranchesByOrigin {
  const grouped: BranchesByOrigin = {
    local: [],
    remotes: {},
  };

  for (const branch of branches) {
    const parsed = parseRef(branch.ref, branch.lastCommitDate);
    if (!parsed) {
      console.log(`I don't know how to delete ${branch.ref}`);
      continue;
    }

    if (parsed.isLocal) {
      grouped.local.push(parsed);
    } else if (parsed.remote) {
      grouped.remotes[parsed.remote] = grouped.remotes[parsed.remote] || [];
      grouped.remotes[parsed.remote].push(parsed);
    }
  }

  return grouped;
}

class BranchNotFound extends Error {}

class ConsiderAll implements CandidateState {
  private branches: ParsedRef[];

  constructor(branches: ParsedRef[]) {
    this.branches = branches;
  }

  candidateInstructions(): string {
    return "# The following is a list of all local and remote branches in your repository";
  }

  branchCandidates(): ParsedRef[] {
    return this.branches;
  }
}

function groupByOriginAlphabetically(branches: ParsedRef[]): BranchGroupNode[] {
  const byOrigin: Record<string, ParsedRef[]> = {};
  for (const branch of branches) {
    const origin = branch.isLocal
      ? "LOCAL BRANCHES"
      : branch.remote?.toUpperCase() ?? "UNKNOWN REMOTE";
    if (!byOrigin[origin]) byOrigin[origin] = [];
    byOrigin[origin].push(branch);
  }
  return Object.entries(byOrigin).map(([origin, group]) => ({
    name: origin,
    branches: group.sort((a, b) => a.branchName.localeCompare(b.branchName)),
  }));
}

function getLocalRemoteBranchMaps(
  branches: ParsedRef[]
): Record<string, string> {
  const remoteBranchMaps: Record<string, string> = {};
  for (const localBranch of branches) {
    if (!localBranch.isLocal) continue;

    for (const remoteBranch of branches) {
      if (remoteBranch.isLocal) continue;
      if (remoteBranch.branchName !== localBranch.branchName) continue;
      remoteBranchMaps[localBranch.branchName] = remoteBranch.branchName;
    }
  }
  return remoteBranchMaps;
}

function editBranchList(
  allBranches: ParsedRef[],
  useStaleGrouping: boolean
): string[] {
  const tempFile = tmpNameSync();
  const lines = [
    "# The following is a list of all local and remote branches in your repository",
    "# To delete the branches, delete them from this list, and then save and quit",
  ];

  const groups: BranchGroupNode[] = useStaleGrouping
    ? groupByRemoteThenStale(allBranches)
    : groupByOriginAlphabetically(allBranches);

  const remoteBranchMaps = getLocalRemoteBranchMaps(allBranches);
  lines.push(...formatBranchGroups(groups, remoteBranchMaps));

  Deno.writeTextFileSync(tempFile, lines.join("\n"));

  new Deno.Command(Deno.env.get("EDITOR") || "vi", {
    args: [tempFile],
    stdin: "inherit",
    stdout: "inherit",
    stderr: "inherit",
  }).outputSync();

  const preserveBranches = Deno.readTextFileSync(tempFile)
    .split("\n")
    .map((line) => line.replace(/#.+$/, "").replace(/\0/g, "").trim())
    .filter((line) => line.length > 0);

  Deno.removeSync(tempFile);

  // Now, preserveBranches contains ref strings. We need to map these back to ParsedRef objects.
  const erroneousBranches = preserveBranches.filter(
    (b) => !allBranches.some((c) => c.ref === b)
  );
  if (erroneousBranches.length > 0) {
    console.error(
      "Error! unrecognized branches:\n" +
        erroneousBranches.map((b) => ` - ${b}`).join("\n")
    );
    Deno.exit(1);
  }

  // Return the list of ref strings to preserve (for deletion logic)
  return preserveBranches;
}

function deleteBranches(
  branchesForDeletion: string[],
  refMap: Record<string, ParsedRef>
): void {
  if (branchesForDeletion.length === 0) {
    console.log("No branches to delete.");
    Deno.exit(1);
  }

  console.log(
    "Deleting branches:\n" +
      branchesForDeletion.map((b) => ` - ${b}`).join("\n")
  );

  // are you sure?
  let confirmation: string | undefined = undefined;
  while (confirmation === undefined || !["y", "n"].includes(confirmation)) {
    confirmation = prompt(
      "Are you sure you want to delete these branches? [y/N] "
    )?.toLocaleLowerCase();
  }

  if (confirmation === "n") {
    console.log("Aborting.");
    Deno.exit(0);
  }

  // Get the ParsedRef objects from the refMap
  const parsedBranches = branchesForDeletion
    .map((ref) => refMap[ref])
    .filter((branch): branch is ParsedRef => branch !== undefined);

  if (parsedBranches.length !== branchesForDeletion.length) {
    console.log("Warning: Some branches could not be found in the branch map");
  }

  // Use existing groupByOrigin function
  const grouped = groupByOrigin(parsedBranches);

  // Delete local branches
  if (grouped.local.length > 0) {
    const args = ["branch", "-D", ...grouped.local.map((b) => b.branchName)];

    if (DRY_RUN) {
      console.log(`Would run: git ${args.join(" ")}`);
    } else {
      runCommandSync("git", args);
    }
  }

  // Delete remote branches
  for (const [remote, branches] of Object.entries(grouped.remotes)) {
    const args = ["push", remote, ...branches.map((b) => `:${b.branchName}`)];
    if (DRY_RUN) {
      console.log(`Would run: git ${args.join(" ")}`);
    } else {
      runCommandSync("git", args);
    }
  }
}

function fetchAndPrune(): void {
  console.log("Fetching and pruning all remotes");
  runCommandSync("git", ["fetch", "--all", "--prune"]);
  console.log("Done");
}

const GitRefParser = {
  parseGitRefLine(line: string): ParsedRef | null {
    // Split on first null character
    const nullIdx = line.indexOf("\0");
    if (nullIdx === -1) return null;
    const ref = line.slice(0, nullIdx).replace(/\0/g, "").trim();
    const dateStr = line
      .slice(nullIdx + 1)
      .replace(/\0/g, "")
      .trim();
    if (!ref || !dateStr) return null;

    const lastCommitDate = GitRefParser.parseGitDate(dateStr);
    if (!lastCommitDate) return null;

    const refInfo = GitRefParser.parseRefString(ref);
    if (!refInfo) return null;

    return { ...refInfo, ref, lastCommitDate };
  },

  parseGitDate(dateStr: string): Date | null {
    const date = new Date(dateStr);
    return isNaN(date.getTime()) ? null : date;
  },

  parseRefString(
    ref: string
  ): { remote?: string; branchName: string; isLocal: boolean } | null {
    const remoteMatch = ref.match(/^refs\/remotes\/([^/]+)\/(.+)$/);
    const localMatch = ref.match(/^refs\/heads\/(.+)$/);
    if (remoteMatch) {
      const [, remote, branchName] = remoteMatch;
      return { remote, branchName, isLocal: false };
    } else if (localMatch) {
      const [, branchName] = localMatch;
      return { branchName, isLocal: true };
    }
    return null;
  },
};

function getBranches(): ParsedRef[] {
  const output = runCommandSync("git", [
    "for-each-ref",
    "--format=%(refname)%00%(committerdate:iso8601)",
    "refs/heads/",
    "refs/remotes/",
  ]);
  if (DEBUG) {
    console.log("Raw git for-each-ref output:");
    console.log(output);
  }
  return output
    .split("\n")
    .filter((line) => line.trim().length > 0)
    .map(GitRefParser.parseGitRefLine)
    .filter((ref): ref is ParsedRef => ref !== null);
}

function main(args: string[]) {
  const argv = yargs(args)
    .scriptName("git-cleanup-branches")
    .usage("Usage: $0 [options]")
    .option("f", {
      alias: "fast",
      type: "boolean",
      description: "Fast cleanup - Skip fetch/prune remotes",
      default: false,
    })
    .option("s", {
      alias: "stale",
      type: "boolean",
      description: "Group branches by staleness",
      default: false,
    })
    .strict()
    .parseSync();
  const fast = argv.fast;
  const stale = argv.stale;

  if (!fast) {
    fetchAndPrune();
  }

  const branches = getBranches();

  try {
    const preserveBranches = editBranchList(branches, stale);

    // Create a mapping of ref to ParsedRef for deleteBranches
    const refMap: Record<string, ParsedRef> = {};
    for (const branch of branches) {
      refMap[branch.ref] = branch;
    }

    const branchesToDelete = branches
      .filter((b) => !preserveBranches.includes(b.ref))
      .map((b) => b.ref);

    deleteBranches(branchesToDelete, refMap);
  } catch (e) {
    if (e instanceof BranchNotFound) {
      console.error(e.message);
      Deno.exit(1);
    }
    console.error(e);
    throw e;
  }
}

// --- Deno tests for parser ---
if (import.meta.main) {
  main(Deno.args);
} else {
  // Only run tests if not main script
  Deno.test("parseGitRefLine parses valid line", () => {
    const line = "refs/heads/feature/foo\x002023-01-01 12:00:00 +0000";
    const parsed = GitRefParser.parseGitRefLine(line);
    if (!parsed) throw new Error("Should parse");
    if (parsed.branchName !== "feature/foo")
      throw new Error("Wrong branch name");
    if (!parsed.isLocal) throw new Error("Should be local");
    if (parsed.lastCommitDate.toISOString() !== "2023-01-01T12:00:00.000Z")
      throw new Error("Wrong date");
  });

  Deno.test("parseGitRefLine returns null for invalid line", () => {
    const line = "notaref\x00notadate";
    const parsed = GitRefParser.parseGitRefLine(line);
    if (parsed !== null) throw new Error("Should not parse");
  });

  Deno.test("parseRefString parses remote ref", () => {
    const ref = "refs/remotes/origin/feature/bar";
    const info = GitRefParser.parseRefString(ref);
    if (!info) throw new Error("Should parse");
    if (info.remote !== "origin") throw new Error("Wrong remote");
    if (info.branchName !== "feature/bar") throw new Error("Wrong branch name");
    if (info.isLocal) throw new Error("Should not be local");
  });
}

interface BranchGroupNode {
  name?: string;
  children?: BranchGroupNode[];
  branches?: ParsedRef[];
}

// Example: group by remote, then by staleness
function groupByRemoteThenStale(branches: ParsedRef[]): BranchGroupNode[] {
  const byRemote: Record<string, ParsedRef[]> = {};
  for (const branch of branches) {
    const remote = branch.remote || "local";
    if (!byRemote[remote]) byRemote[remote] = [];
    byRemote[remote].push(branch);
  }
  return Object.entries(byRemote).map(([remote, group]) => ({
    name: remote === "local" ? "LOCAL BRANCHES" : remote.toUpperCase(),
    children: groupByStaleness(group),
  }));
}

function groupByStaleness(branches: ParsedRef[]): BranchGroupNode[] {
  const now = new Date();
  const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
  const ninetyDaysAgo = new Date(now.getTime() - 90 * 24 * 60 * 60 * 1000);
  const oneYearAgo = new Date(now.getTime() - 365 * 24 * 60 * 60 * 1000);
  const buckets: { name: string; filter: (b: ParsedRef) => boolean }[] = [
    { name: "Active", filter: (b) => b.lastCommitDate >= thirtyDaysAgo },
    {
      name: "Older than 30 days",
      filter: (b) =>
        b.lastCommitDate < thirtyDaysAgo && b.lastCommitDate >= ninetyDaysAgo,
    },
    {
      name: "Older than 90 days",
      filter: (b) =>
        b.lastCommitDate < ninetyDaysAgo && b.lastCommitDate >= oneYearAgo,
    },
    { name: "Older than 1 year", filter: (b) => b.lastCommitDate < oneYearAgo },
  ];
  return buckets
    .map((bucket) => {
      const bucketBranches = branches.filter(bucket.filter);
      return bucketBranches.length > 0
        ? ({
            name: bucket.name as string | undefined,
            branches: bucketBranches,
          } as BranchGroupNode)
        : undefined;
    })
    .filter((x): x is BranchGroupNode => x !== undefined);
}

function formatBranchGroups(
  groups: BranchGroupNode[],
  remoteBranchMaps: Record<string, string>,
  indent = 0,
  isTopLevel = true
): string[] {
  const lines: string[] = [];
  for (const [i, group] of groups.entries()) {
    // Add an empty line above each heading except the very first at the top level
    if (group.name && (!isTopLevel || i > 0)) {
      lines.push("");
    }
    if (group.name) {
      lines.push(
        `${" ".repeat(indent)}${indent === 0 ? "# " : "## "}${group.name}`
      );
    }
    if (group.children) {
      lines.push(
        ...formatBranchGroups(
          group.children,
          remoteBranchMaps,
          indent + 2,
          false
        )
      );
    }
    if (group.branches) {
      for (const branch of group.branches) {
        let noRemoteIdentifier: string = "";
        if (branch.isLocal) {
          if (!remoteBranchMaps[branch.branchName]) {
            noRemoteIdentifier = ` # (no remote)`;
          }
        }
        lines.push(`${" ".repeat(indent)}${branch.ref}${noRemoteIdentifier}`);
      }
    }
  }
  return lines;
}