@joshuafolkken/kit 1.1166.0 → 1.1229.0

package/scripts/gh/git-gh-pr-read.ts

@@ -2,6 +2,7 @@ import { FULL_PAGE_QUERY, git_gh_api_path } from './git-gh-api-path'
 import { git_gh_exec } from './git-gh-exec'
 import { git_gh_helpers } from './git-gh-helpers'
 import { git_gh_pr_rest, type RestPull } from './git-gh-pr-rest'
+import { to_gh_state } from './git-gh-rest-state'
 
 // Reading pull requests through REST, in the answers `gh pr view` used to give.
 //
@@ -81,14 +82,31 @@ interface PullMergeState {
 	is_merged: boolean
 	merged_at: string | undefined
 	head_sha: string | undefined
+	// `josh ship` reads `DIRTY` here to re-merge a conflicting pull request (joshuafolkken/kit#3221).
+	merge_state_status: string | undefined
 }
 
 type PullNumberRead =
 	{ kind: 'read'; pr_number: number } | { kind: 'missing' } | { kind: 'unreadable'; cause: unknown }
 
+// The branch-keyed detail read, in the same three answers. `missing` and `unreadable` are the
+// resolution's own; `unreadable` also covers a resolved number whose detail read failed, which every
+// branch-keyed reader used to fold into "no pull request" (joshuafolkken/kit#3263).
+type PullRead = Exclude<PullNumberRead, { kind: 'read' }> | { kind: 'read'; pull: RestPull }
+
 // The lookups still in flight, keyed the same way the resolved numbers are.
 const pending_pr_number_by_branch = new Map<string, Promise<PullNumberRead>>()
 
+// The detail reads, keyed by number and remembered for the life of the command
+// (joshuafolkken/kit#3263). `josh followup` asks `pr_get_body` and `pr_get_url` in one tick — the
+// same `GET /pulls/{N}` each time. The promise is stored, so readers in one tick share the request as
+// well as its answer; a read that fails is dropped and re-tried, the rule the number memo holds.
+// **Every write to a pull request clears it** through `forget_pr_numbers`, and the two state readers
+// never read it: `pr_get_merge_state` answers where the pull request stands *now*, which `josh ship`
+// asks again after every merge it pushes, and `pr_view` decides whether `josh git -y` writes onto the
+// pull request — after a commit and a push its preflight read would otherwise outlast.
+const pull_by_number = new Map<number, Promise<RestPull>>()
+
 async function fetch_pr_number_read(branch_name: string): Promise<PullNumberRead> {
 	try {
 		const pr_number = await fetch_pr_number(branch_name)
@@ -127,10 +145,11 @@ async function start_pr_number_read(branch_name: string): Promise<PullNumberRead
 	}
 }
 
-// Defined after the map it clears, so the two memos are declared before anything reaches them.
+// Defined after the maps it clears, so the memos are declared before anything reaches them.
 function forget_pr_numbers(): void {
 	pr_number_by_branch.clear()
 	pending_pr_number_by_branch.clear()
+	pull_by_number.clear()
 }
 
 async function read_pr_number(branch_name: string): Promise<PullNumberRead> {
@@ -141,9 +160,9 @@ async function read_pr_number(branch_name: string): Promise<PullNumberRead> {
 }
 
 // `undefined` covers both "this branch has no pull request" and "the lookup failed", which is the
-// distinction `gh pr view` never made either — every *read* here folds them together on purpose:
-// `pr_view` answers the empty string either way, the comment readers `undefined`. The two callers
-// that act on the absence rather than displaying it — `require_pr_number` and `pr_exists` — opt out.
+// distinction `gh pr view` never made either — the *display* reads here fold them together on
+// purpose: the comment readers answer `undefined` either way. The callers that act on the absence
+// rather than displaying it — `require_pr_number`, `pr_exists` and `pr_view` — opt out.
 async function resolve_pr_number(branch_name: string): Promise<number | undefined> {
 	const read = await read_pr_number(branch_name)
 
@@ -183,19 +202,43 @@ async function read_pull(pr_number: number): Promise<RestPull> {
 	return git_gh_pr_rest.parse_rest_pull(json)
 }
 
+// The identity check keeps a failure from evicting a read that `forget_pr_numbers` already replaced.
+async function read_remembered_pull(pr_number: number): Promise<RestPull> {
+	const pending = pull_by_number.get(pr_number) ?? read_pull(pr_number)
+
+	pull_by_number.set(pr_number, pending)
+
+	try {
+		return await pending
+	} catch (error) {
+		if (pull_by_number.get(pr_number) === pending) pull_by_number.delete(pr_number)
+		throw error
+	}
+}
+
 // One pull request named by its branch: the resolution, then the detail read that carries
 // `mergeable` and `mergeable_state`, which the lookup listing does not.
-async function read_pull_of_branch(branch_name: string): Promise<RestPull | undefined> {
-	const pr_number = await resolve_pr_number(branch_name)
-	if (pr_number === undefined) return undefined
+async function read_pull_of_branch(
+	branch_name: string,
+	read: (pr_number: number) => Promise<RestPull> = read_remembered_pull,
+): Promise<PullRead> {
+	const number_read = await read_pr_number(branch_name)
+	if (number_read.kind !== 'read') return number_read
 
 	try {
-		return await read_pull(pr_number)
-	} catch {
-		return undefined
+		return { kind: 'read', pull: await read(number_read.pr_number) }
+	} catch (error) {
+		return { kind: 'unreadable', cause: error }
 	}
 }
 
+// The display readers' fold: "no pull request" and "nothing could be read" are one empty answer.
+async function read_pull_or_undefined(branch_name: string): Promise<RestPull | undefined> {
+	const read = await read_pull_of_branch(branch_name)
+
+	return read.kind === 'read' ? read.pull : undefined
+}
+
 // **`false` means the branch has no pull request, and nothing else.** This is the second half of
 // joshuafolkken/kit#1048's distinction, on the caller that needs it most: `pr_exists` is not read for
 // display, it decides whether `git-pr.ts` **opens** a pull request. Folding an unreadable lookup into
@@ -215,7 +258,7 @@ async function pr_get_number(branch_name: string): Promise<number | undefined> {
 }
 
 async function pr_get_url(branch_name: string): Promise<string | undefined> {
-	const pull = await read_pull_of_branch(branch_name)
+	const pull = await read_pull_or_undefined(branch_name)
 	if (pull?.html_url === undefined) return undefined
 
 	return git_gh_helpers.parse_pr_state_string(pull.html_url)
@@ -226,33 +269,39 @@ async function pr_get_url(branch_name: string): Promise<string | undefined> {
 // made on GitHub moves without touching the local branch. `undefined` covers both "no pull request"
 // and "nothing could be read": `followup` then takes its ordinary path, whose merge step settles a
 // pull request that did merge after all (`pr_merge`), so an unread answer costs a wait, not a wrong tail.
+// Read past the detail memo: `josh ship` asks it again after each merge it pushes (joshuafolkken/kit#3263).
 async function pr_get_merge_state(branch_name: string): Promise<PullMergeState | undefined> {
-	const pull = await read_pull_of_branch(branch_name)
-	if (pull === undefined) return undefined
+	const read = await read_pull_of_branch(branch_name, read_pull)
+	if (read.kind !== 'read') return undefined
+	const { pull } = read
 
 	return {
 		is_merged: git_gh_pr_rest.is_merged(pull),
 		merged_at: pull.merged_at ?? undefined,
 		head_sha: pull.head?.sha,
+		merge_state_status: to_gh_state(pull.mergeable_state),
 	}
 }
 
 // REST answers JSON null for a pull request with no body where `gh --json body` answered an empty
 // string, and both used to arrive here as the empty answer this folds to `undefined`.
 async function pr_get_body(branch_name: string): Promise<string | undefined> {
-	const pull = await read_pull_of_branch(branch_name)
+	const pull = await read_pull_or_undefined(branch_name)
 	const body = pull?.body
 
 	return typeof body === 'string' && body.length > 0 ? body : undefined
 }
 
-// The empty string means "there is nothing to read" — a branch with no pull request, or a read that
-// failed. `git-pr.ts` checks the length before parsing.
+// The empty string means "this branch has no pull request", and nothing else. A read that failed
+// throws, carrying gh's reason as the `cause`: `git-pr.ts` decides from this state whether the
+// branch's pull request merged, and a rate limit answered as "no state" sent a merged pull request
+// down the open one's path (joshuafolkken/kit#3263). Read past the detail memo, like the merge state.
 async function pr_view(branch_name: string): Promise<string> {
-	const pull = await read_pull_of_branch(branch_name)
-	if (pull === undefined) return ''
+	const read = await read_pull_of_branch(branch_name, read_pull)
+	if (read.kind === 'unreadable') throw to_unreadable_error(branch_name, read.cause)
+	if (read.kind === 'missing') return ''
 
-	return JSON.stringify(git_gh_pr_rest.to_pr_info(pull))
+	return JSON.stringify(git_gh_pr_rest.to_pr_info(read.pull))
 }
 
 // `undefined` when the listing could not be read — a failed request, or a PR whose number could not

package/scripts/gh/git-gh-pr-rest.ts

@@ -1,8 +1,8 @@
+import { rest_comment_schema } from '#scripts/git/git-schemas'
 import {
 	parse_json_array_or_undefined,
 	parse_json_object_safe,
 } from '#scripts/git/parse-json-array'
-import { rest_comment_schema } from '#scripts/git/schemas'
 import { z } from 'zod'
 import { MERGED_STATE, to_gh_state } from './git-gh-rest-state'
 

package/scripts/gh/git-gh-pr.ts

@@ -152,10 +152,12 @@ async function pr_comment(branch_name: string, body: string): Promise<string> {
 
 // Replaces the body of the branch's open pull request. `git -y` opens a pull request once, so a
 // body supplied on a later run — the live-execution evidence `followup` gates the merge on
-// (joshuafolkken/kit#2446) — reaches an already-open one only through this write.
+// (joshuafolkken/kit#2446) — reaches an already-open one only through this write. The remembered
+// detail read holds the old body, so it is cleared first (joshuafolkken/kit#3263).
 async function pr_update_body(branch_name: string, body: string): Promise<void> {
 	const pr_number = await require_pr_number(branch_name)
 
+	forget_pr_numbers()
 	await git_gh_exec.exec_gh_api({
 		path: git_gh_api_path.pull_api_path(String(pr_number)),
 		method: PATCH_METHOD,
@@ -163,7 +165,9 @@ async function pr_update_body(branch_name: string, body: string): Promise<void>
 	})
 }
 
+// A merge moves the remembered detail read's state, so it is cleared first (joshuafolkken/kit#3263).
 async function put_merge(pr_number: number): Promise<void> {
+	forget_pr_numbers()
 	await git_gh_exec.exec_gh_api({
 		path: git_gh_api_path.pull_merge_api_path(String(pr_number)),
 		method: PUT_METHOD,

package/scripts/gh/git-pr-ai-review.ts

@@ -1,6 +1,6 @@
 // cspell:words coderabbit coderabbitai
+import { ai_review_pull_comment_schema } from '#scripts/git/git-schemas'
 import { parse_json_array_or_undefined } from '#scripts/git/parse-json-array'
-import { ai_review_pull_comment_schema } from '#scripts/git/schemas'
 import {
 	classify_ai_review_comments,
 	type ClassifiedFinding,

package/scripts/gh/git-pr-checks-eval.ts

@@ -191,9 +191,7 @@ function evaluate_pr_state(snapshot: PrStateSnapshot): PrEvaluation {
 
 	if (failure !== undefined) return failure
 
-	if (is_mergeable_state(snapshot) && is_every_required_passing(statuses)) {
-		return 'success'
-	}
+	if (is_mergeable_state(snapshot) && is_every_required_passing(statuses)) return 'success'
 
 	return 'pending'
 }
@@ -240,7 +238,14 @@ function is_auto_merge_blocked(snapshot: PrStateSnapshot): boolean {
 	)
 }
 
+// A failed wait whose cause is a merge conflict (joshuafolkken/kit#3221), so `followup` names its last
+// lap `conflict` rather than `interrupted` and the cause is read from the stage block, not looked up.
+class PrConflictError extends Error {
+	override name = 'PrConflictError'
+}
+
 export {
+	PrConflictError,
 	evaluate_pr_state,
 	is_auto_merge_blocked,
 	is_review_decision_decisive,
@@ -251,5 +256,6 @@ export {
 	REQUIRED_CHECKS,
 	CODERABBIT_CHECK_NAME,
 	is_required_check,
+	is_merge_conflict,
 }
 export type { PrEvaluation }

package/scripts/gh/git-pr-checks-parse.ts

@@ -1,4 +1,4 @@
-import { pr_raw_schema, type RollupItemData } from '#scripts/git/schemas'
+import { pr_raw_schema, type RollupItemData } from '#scripts/git/git-schemas'
 import { json_value } from '#scripts/lib/json-value'
 
 const CHECK_STATUS_PASS = 'pass'

package/scripts/gh/git-pr-checks-watch.ts

@@ -7,7 +7,6 @@ import {
 	SECONDS_TO_MS,
 	wait_for_pr_success,
 	type PrStateEvaluator,
-	type ReviewDecisionPredicate,
 } from './git-pr-checks'
 import { is_coderabbit_check, is_required_check, type PrEvaluation } from './git-pr-checks-eval'
 import {
@@ -116,12 +115,14 @@ function describe_checks_failure(snapshot: PrStateSnapshot): string {
 // **The watch never reads `review_decision`**, so the poll must not spend a request fetching it. It
 // is the same difference `evaluate_checks_settled` is written for, said to the fetcher instead of to
 // the verdict: three requests a poll rather than four (joshuafolkken/kit#1043).
-const SHOULD_NEVER_READ_REVIEW_DECISION: ReviewDecisionPredicate = () => false
+function should_never_read_review_decision(): boolean {
+	return false
+}
 
 const CHECKS_SETTLED_EVALUATOR: PrStateEvaluator = {
 	evaluate: evaluate_checks_settled,
 	describe: describe_checks_failure,
-	should_read_review_decision: SHOULD_NEVER_READ_REVIEW_DECISION,
+	should_read_review_decision: should_never_read_review_decision,
 }
 
 async function watch_until_settled(branch_name: string): Promise<void> {
@@ -145,7 +146,7 @@ async function watch_until_settled(branch_name: string): Promise<void> {
 // from failing on the first read: two minutes is the grace, and an empty rollup at the end of them
 // is the answer `gh` gave immediately.
 async function fail_when_no_checks(branch_name: string): Promise<void> {
-	const snapshot = await default_fetch_pr_state(branch_name, SHOULD_NEVER_READ_REVIEW_DECISION)
+	const snapshot = await default_fetch_pr_state(branch_name, should_never_read_review_decision)
 	if (snapshot.rollup.length === 0) throw new Error(NO_CHECKS_MESSAGE)
 }
 
@@ -173,7 +174,7 @@ export {
 	git_pr_checks_watch,
 	fail_when_no_checks,
 	CHECKS_SETTLED_EVALUATOR,
-	SHOULD_NEVER_READ_REVIEW_DECISION,
+	should_never_read_review_decision,
 	evaluate_checks_settled,
 	is_awaited_check,
 	describe_checks_failure,

package/scripts/gh/git-pr-checks.ts

@@ -1,4 +1,4 @@
-import { package_name_schema } from '#scripts/git/schemas'
+import { package_name_schema } from '#scripts/git/git-schemas'
 import { poll } from '#scripts/lib/poll'
 import { git_gh_pr_auto_merge } from './git-gh-pr-auto-merge'
 import { git_gh_pr_snapshot } from './git-gh-pr-snapshot'
@@ -6,7 +6,9 @@ import {
 	describe_pr_failure,
 	evaluate_pr_state,
 	is_auto_merge_blocked,
+	is_merge_conflict,
 	is_review_decision_decisive,
+	PrConflictError,
 	type PrEvaluation,
 } from './git-pr-checks-eval'
 import { parse_pr_state_snapshot, read_string, type PrStateSnapshot } from './git-pr-checks-parse'
@@ -85,7 +87,9 @@ type ReviewDecisionPredicate = (snapshot: PrStateSnapshot) => boolean
 
 // The conservative answer, and the one every evaluator that does not say gets: read it every poll,
 // which is what all of them did before the predicate existed.
-const SHOULD_ALWAYS_READ_REVIEW_DECISION: ReviewDecisionPredicate = () => true
+function should_always_read_review_decision(): boolean {
+	return true
+}
 
 type PrStateFetcher = (
 	branch_name: string,
@@ -142,6 +146,12 @@ function advance_stable_count(previous: number, state: PrEvaluation): number {
 	return state === 'success' ? previous + 1 : 0
 }
 
+function failure_error(message: string, snapshot: PrStateSnapshot): Error {
+	return is_merge_conflict(snapshot.merge_state_status)
+		? new PrConflictError(message)
+		: new Error(message)
+}
+
 function classify_poll_result(input: {
 	snapshot: PrStateSnapshot
 	stable_count: number
@@ -150,7 +160,9 @@ function classify_poll_result(input: {
 }): { is_done: boolean; next_stable_count: number } {
 	const state = input.evaluator.evaluate(input.snapshot)
 
-	if (state === 'failure') throw new Error(input.evaluator.describe(input.snapshot))
+	if (state === 'failure') {
+		throw failure_error(input.evaluator.describe(input.snapshot), input.snapshot)
+	}
 
 	const next_stable_count = advance_stable_count(input.stable_count, state)
 
@@ -189,7 +201,7 @@ async function read_pr_state(
 	try {
 		const snapshot = await input.options.fetcher(
 			input.options.branch_name,
-			evaluator.should_read_review_decision ?? SHOULD_ALWAYS_READ_REVIEW_DECISION,
+			evaluator.should_read_review_decision ?? should_always_read_review_decision,
 		)
 
 		return { kind: 'read', snapshot }
@@ -287,7 +299,7 @@ async function wait_for_pr_success(options: WaitForPrSuccessOptions): Promise<Pr
 // (joshuafolkken/kit#1043).
 async function default_fetch_pr_state(
 	branch_name: string,
-	should_read_review_decision: ReviewDecisionPredicate = SHOULD_ALWAYS_READ_REVIEW_DECISION,
+	should_read_review_decision: ReviewDecisionPredicate = should_always_read_review_decision,
 ): Promise<PrStateSnapshot> {
 	const checks = await git_gh_pr_snapshot.pr_get_checks_snapshot(branch_name)
 	const snapshot = parse_pr_state_snapshot(checks.snapshot_json)
@@ -375,7 +387,7 @@ export {
 	is_pr_checks_timeout,
 	default_fetch_pr_state,
 	MERGE_GATE_EVALUATOR,
-	SHOULD_ALWAYS_READ_REVIEW_DECISION,
+	should_always_read_review_decision,
 }
 export type { MergeProgress, PrStateFetcher, PrStateEvaluator, ReviewDecisionPredicate }
 export {

package/scripts/gh/git-pr-coderabbit.ts

@@ -1,5 +1,5 @@
+import { pull_comment_schema } from '#scripts/git/git-schemas'
 import { parse_json_array_or_undefined } from '#scripts/git/parse-json-array'
-import { pull_comment_schema } from '#scripts/git/schemas'
 import { git_gh_command } from './git-gh-command'
 import { has_ignore_reason } from './git-pr-ai-review'
 

package/scripts/gh/git-pr-error.ts

@@ -8,9 +8,7 @@ function has_error_cause(error: Error): boolean {
 
 function is_pr_already_exists_error(error: unknown): boolean {
 	if (error instanceof Error) {
-		if (is_pr_already_exists_message(error.message)) {
-			return true
-		}
+		if (is_pr_already_exists_message(error.message)) return true
 
 		return has_error_cause(error)
 	}

package/scripts/gh/git-pr.ts

@@ -1,6 +1,6 @@
 import { pr_classification, type ReleaseClassification } from '#scripts/ci/pr-classification'
 import type { IssueInfo } from '#scripts/git/git-issue'
-import { pr_info_schema } from '#scripts/git/schemas'
+import { pr_info_schema } from '#scripts/git/git-schemas'
 import { animation_helpers, type AnimationOptions } from '#scripts/lib/animation-helpers'
 import { git_gh_command } from './git-gh-command'
 import { git_pr_error } from './git-pr-error'
@@ -98,18 +98,14 @@ function parse_pr_state(pr_info_json: string): string | undefined {
 	}
 }
 
-async function get_pr_state_safe(branch_name: string): Promise<string | undefined> {
-	try {
-		const pr_info_json = await git_gh_command.pr_view(branch_name)
+// A read that failed throws rather than answering `undefined`: "no state" is read as "not merged",
+// which would write onto a pull request that already merged (joshuafolkken/kit#3263).
+async function get_pr_state(branch_name: string): Promise<string | undefined> {
+	const pr_info_json = await git_gh_command.pr_view(branch_name)
 
-		if (pr_info_json.length === 0) {
-			return undefined
-		}
+	if (pr_info_json.length === 0) return undefined
 
-		return parse_pr_state(pr_info_json)
-	} catch {
-		return undefined
-	}
+	return parse_pr_state(pr_info_json)
 }
 
 function is_pr_state_merged(pr_state: string | undefined): boolean {
@@ -137,7 +133,7 @@ async function handle_existing_pr(
 	branch_name: string,
 	options: { label: ReleaseClassification; should_replace_body: boolean },
 ): Promise<void> {
-	const pr_state_result = await get_pr_state_safe(branch_name)
+	const pr_state_result = await get_pr_state(branch_name)
 
 	if (is_pr_state_merged(pr_state_result)) {
 		git_pr_messages.display_merged_pr_message()
@@ -181,7 +177,7 @@ function build_body(issue_info: IssueInfo, extra_body?: string): string {
 
 async function existing_pr_label(branch_name: string): Promise<ReleaseClassification | undefined> {
 	if (!(await git_gh_command.pr_exists(branch_name))) return undefined
-	if (is_pr_state_merged(await get_pr_state_safe(branch_name))) return undefined
+	if (is_pr_state_merged(await get_pr_state(branch_name))) return undefined
 
 	return await git_gh_command.pr_get_classification(branch_name)
 }

package/scripts/gh/github-issue-url.ts

@@ -75,8 +75,8 @@ function build_target(match: RegExpExecArray): ParsedUrl {
 	}
 }
 
-function parse_with(pattern: RegExp, url: string | undefined): ParsedUrl | undefined {
-	const match = pattern.exec(url ?? '')
+function parse_with(pattern: RegExp, url: string | undefined = ''): ParsedUrl | undefined {
+	const match = pattern.exec(url)
 	if (match === null) return undefined
 
 	return build_target(match)

package/scripts/git/constants.ts

@@ -12,19 +12,24 @@ const PORCELAIN_FLAG = '--porcelain'
 // The untracked-files mode every porcelain status reading passes (`git-command.ts` carries why it is
 // passed and why it is `all`), shared so another module's own reading cannot drift from it.
 const UNTRACKED_FILES_FLAG = '--untracked-files=all'
+// The git binary a spawn runs in place of the platform's own (joshuafolkken/kit#3234). The spawn path
+// is absolute, so a `git` placed in front on `PATH` never stands in for it: the unit suite's network
+// guard shimmed `git` that way, and `josh ship`'s tests fetched and merged the default branch into the
+// checkout they ran in without the guard ever seeing the call. The guard names its shim here instead.
+const GIT_BINARY_KEY = 'JOSH_GIT_BINARY'
 
 function get_git_command(): string {
-	if (platform() === 'win32') {
-		return String.raw`"C:\Program Files\Git\cmd\git.exe"`
-	}
+	if (platform() === 'win32') return String.raw`"C:\Program Files\Git\cmd\git.exe"`
 
 	return GIT_COMMAND_UNIX
 }
 
 function get_git_command_for_spawn(): string {
-	if (platform() === 'win32') {
-		return String.raw`C:\Program Files\Git\cmd\git.exe`
-	}
+	const binary = process.env[GIT_BINARY_KEY]
+
+	if (binary !== undefined && binary !== '') return binary
+
+	if (platform() === 'win32') return String.raw`C:\Program Files\Git\cmd\git.exe`
 
 	return GIT_COMMAND_UNIX
 }
@@ -35,6 +40,7 @@ const git_utilities = {
 }
 
 export {
+	GIT_BINARY_KEY,
 	REQUIRED_STATUS_LENGTH,
 	STAGED_STATUS_INDEX,
 	UNTRACKED_FILE_PREFIX,