import githubRequest from 'kody:@kentcdodds/github/request' import { normalizeRepoSlug } from './shared.ts' import { branchPrefix, type ChangedFile } from './scope-core.ts' type GithubResult = { ok?: boolean; status?: number; data?: unknown; text?: string } async function gh(path: string) { const result = (await githubRequest({ account: 'bot', path })) as GithubResult if (result?.ok === false || (result.status && result.status >= 400)) { throw new Error(`GitHub ${path} failed (${result.status}): ${String(result.text || '').slice(0, 200)}`) } return result.data } /** GitHub caps the compare file list at 300 files. */ export const compareFileCap = 300 export type LastFix = { sha: string; number: number; branch: string; mergedAt: string } | null /** * Most recently merged PR into `base` whose head branch starts with * `cleanup/-`. Its merge_commit_sha is the "last fix" marker. * Scans the newest 300 closed PRs (3 pages). */ export async function findLastFix(input: { repo: string; base: string; automation: string }): Promise { const slug = normalizeRepoSlug(input.repo) const prefix = branchPrefix(input.automation) let best: LastFix = null for (let page = 1; page <= 3; page += 1) { const data = await gh( `/repos/${slug}/pulls?state=closed&base=${encodeURIComponent(input.base)}&sort=updated&direction=desc&per_page=100&page=${page}`, ) const pulls = Array.isArray(data) ? (data as Array>) : [] for (const p of pulls) { const ref = String(p?.head?.ref ?? '') if (!ref.startsWith(prefix) || !p.merged_at || !p.merge_commit_sha) continue if (!best || String(p.merged_at) > best.mergedAt) { best = { sha: String(p.merge_commit_sha), number: Number(p.number), branch: ref, mergedAt: String(p.merged_at) } } } if (pulls.length < 100) break } return best } export async function getHeadSha(repo: string, branch: string) { const data = (await gh(`/repos/${normalizeRepoSlug(repo)}/branches/${encodeURIComponent(branch)}`)) as any const sha = data?.commit?.sha if (!sha) throw new Error('branch head has no commit') return String(sha) } /** * The later of two commits on the branch. `ahead` means b is newer than a. * Diverged or unknown keeps `b` (the caller passes the stored floor as b). */ export async function laterOf(repo: string, a: string | null, b: string | null) { if (!a) return b if (!b || a === b) return a try { const data = (await gh(`/repos/${normalizeRepoSlug(repo)}/compare/${a}...${b}?per_page=1`)) as any return data?.status === 'behind' ? a : b } catch { return b } } /** Parent of the oldest commit on `branch` in the last 24h (initial base), or null. */ export async function baseFromLookback(repo: string, branch: string, now = new Date()) { const since = new Date(now.getTime() - 24 * 60 * 60 * 1000).toISOString() const slug = normalizeRepoSlug(repo) let oldest: any = null for (let page = 1; page <= 5; page += 1) { const data = await gh(`/repos/${slug}/commits?sha=${encodeURIComponent(branch)}&since=${encodeURIComponent(since)}&per_page=100&page=${page}`) const list = Array.isArray(data) ? data : [] if (list.length > 0) oldest = list[list.length - 1] if (list.length < 100) break } if (!oldest) return null return oldest.parents?.[0]?.sha ? String(oldest.parents[0].sha) : null } function mapFiles(raw: unknown): ChangedFile[] { return (Array.isArray(raw) ? raw : []).map((f: any) => ({ path: String(f.filename), status: String(f.status ?? 'modified'), additions: Number(f.additions ?? 0), deletions: Number(f.deletions ?? 0), ...(typeof f.patch === 'string' ? { patch: f.patch } : {}), })) } async function listRangeCommits(slug: string, base: string, head: string) { const shas: string[] = [] for (let page = 1; page <= 20; page += 1) { const data = (await gh(`/repos/${slug}/compare/${base}...${head}?per_page=100&page=${page}`)) as any const commits = Array.isArray(data?.commits) ? data.commits : [] for (const c of commits) shas.push(String(c.sha)) if (commits.length < 100) break } return shas } function mergeFiles(target: Map, files: ChangedFile[]) { for (const f of files) { const prev = target.get(f.path) if (!prev) { target.set(f.path, { ...f }) continue } target.set(f.path, { path: f.path, status: f.status, additions: prev.additions + f.additions, deletions: prev.deletions + f.deletions, patch: [prev.patch, f.patch].filter(Boolean).join('\n'), }) } } /** * Changed files in base...head. When the comparison hits GitHub's 300 file * cap, walk the range's commits (paginated) and compare consecutive windows, * halving a window that still hits the cap, then merge per path. */ export async function compareFiles(input: { repo: string; base: string; head: string }) { const slug = normalizeRepoSlug(input.repo) const first = (await gh(`/repos/${slug}/compare/${input.base}...${input.head}`)) as any const files = mapFiles(first?.files) const totalCommits = Number(first?.total_commits ?? 0) if (files.length < compareFileCap) return { files, totalCommits, windows: 1, capped: false } const commits = await listRangeCommits(slug, input.base, input.head) const merged = new Map() let windows = 0 const walk = async (from: string, list: string[]) => { if (list.length === 0) return const to = list[list.length - 1] const data = (await gh(`/repos/${slug}/compare/${from}...${to}`)) as any const part = mapFiles(data?.files) if (part.length >= compareFileCap && list.length > 1) { const mid = Math.floor(list.length / 2) await walk(from, list.slice(0, mid)) await walk(list[mid - 1], list.slice(mid)) return } windows += 1 mergeFiles(merged, part) } await walk(input.base, commits) return { files: [...merged.values()], totalCommits, windows, capped: true } } /** All blob paths at a commit (for cheap test-coverage detection). */ export async function repoPathsAt(repo: string, sha: string) { const data = (await gh(`/repos/${normalizeRepoSlug(repo)}/git/trees/${sha}?recursive=1`)) as any const tree = Array.isArray(data?.tree) ? data.tree : [] return new Set(tree.filter((t: any) => t.type === 'blob').map((t: any) => String(t.path))) }