Function reconstructGhPatch

packages/shared/pr-github.ts:96–136

(files: GitHubFileEntry[])

 * contents through the contents API on demand.
 */
export function reconstructGhPatch(files: GitHubFileEntry[]): string {
  const parts: string[] = [];

  for (const f of files) {
    const oldPath = f.previous_filename ?? f.filename;
    const newPath = f.filename;
    const isNew = f.status === "added";
    const isDeleted = f.status === "removed";

    let header = `diff --git ${headerPathToken("a", oldPath)} ${headerPathToken("b", newPath)}`;
    if (f.status === "renamed" || f.status === "copied") {
      // Git always prints a similarity score before rename/copy lines, and
      // diff parsers (e.g. Pierre's) key rename classification off it —
      // without the line a rename renders as a plain change with no old path.
      // The files API doesn't expose the score: a patch-less entry is by
      // definition a 100% match; for patched entries emit a synthetic <100%
      // value (consumers only branch on 100% vs not).
      header += f.patch ? "\nsimilarity index 99%" : "\nsimilarity index 100%";
      header += f.status === "renamed"
        ? `\nrename from ${metadataPathToken(oldPath)}\nrename to ${metadataPathToken(newPath)}`
        : `\ncopy from ${metadataPathToken(oldPath)}\ncopy to ${metadataPathToken(newPath)}`;
    }
    if (isNew) {
      header += "\nnew file mode 100644";
    }
    if (isDeleted) {
      header += "\ndeleted file mode 100644";
    }

    if (f.patch) {
      const aToken = isNew ? "/dev/null" : headerPathToken("a", oldPath);
      const bToken = isDeleted ? "/dev/null" : headerPathToken("b", newPath);
      const body = f.patch.endsWith("\n") ? f.patch : `${f.patch}\n`;
      parts.push(`${header}\n--- ${aToken}\n+++ ${bToken}\n${body}`);
    } else {
      parts.push(`${header}\n`);
    }
  }

  return parts.join("");
}

/**
 * True when a files-API entry should carry a patch but doesn't. Patch-less