@joshuafolkken/kit 1.1178.0 → 1.1240.0

package/scripts/gh/git-gh-issue-write.ts

@@ -29,6 +29,7 @@ const DELETE_METHOD = 'DELETE'
 // object, so the same value is unwrapped out of it rather than the shape being changed.
 const HTML_URL_FILTER = '.html_url'
 const ID_FILTER = '.id'
+const LABEL_NAMES_FILTER = '.[].name'
 
 const LABELS_SEGMENT = '/labels'
 const COMMENTS_SEGMENT = '/comments'
@@ -182,17 +183,60 @@ async function issue_create_with_label(input: {
 	)
 }
 
+// The outcome of applying one label, with the swallowed failure's gist kept for a caller that has to
+// say why it refused (joshuafolkken/kit#3312).
+type LabelWrite = { is_applied: true } | { is_applied: false; reason: string }
+
+// The issue's label names, read back after a failed write. A read that itself fails answers
+// `undefined`, which the caller treats as "not applied" — the write's own error is the reason then.
+async function read_label_names(issue_number: string): Promise<Array<string> | undefined> {
+	try {
+		const raw = await git_gh_exec.exec_gh_api({
+			path: `${git_gh_api_path.issue_api_path(issue_number)}${LABELS_SEGMENT}`,
+			should_paginate: true,
+			jq_filter: LABEL_NAMES_FILTER,
+		})
+
+		return raw.split('\n').map((name) => name.trim())
+	} catch (error) {
+		error_text.trace_swallowed('git_gh_issue_write.read_label_names', error)
+
+		return undefined
+	}
+}
+
+// **A failed answer is not a failed write.** The POST is idempotent, and a timeout, a non-zero exit
+// after the write or a secondary rate limit can each throw after the label landed — which refused a
+// lane dispatch whose label was in fact applied (joshuafolkken/kit#3312). So a throw is confirmed by
+// reading the labels back, and only a label that is really absent answers `is_applied: false`.
+async function issue_apply_label(issue_number: string, label: string): Promise<LabelWrite> {
+	const labels_path = `${git_gh_api_path.issue_api_path(issue_number)}${LABELS_SEGMENT}`
+
+	try {
+		await git_gh_exec.exec_gh_api({ path: labels_path, body: JSON.stringify({ labels: [label] }) })
+
+		return { is_applied: true }
+	} catch (error) {
+		const names = await read_label_names(issue_number)
+
+		if (names?.includes(label) === true) return { is_applied: true }
+		error_text.trace_swallowed('git_gh_issue_write.issue_apply_label', error)
+
+		// The first line is the gist: gh follows it with the response body, which a one-line refusal
+		// does not need.
+		const [gist = ''] = error_text.message_of(error).split('\n', 1)
+
+		return { is_applied: false, reason: gist }
+	}
+}
+
 // Applied after the body edit so a failure leaves an issue with the epic sections and no label,
 // which `epic:check` reports — rather than a labelled issue with nothing to track. The caller checks
 // the return: the label is what the auto-close filters on (joshuafolkken/kit#865).
 async function issue_add_label(issue_number: string, label: string): Promise<boolean> {
-	return await did_write_succeed(
-		async () =>
-			await git_gh_exec.exec_gh_api({
-				path: `${git_gh_api_path.issue_api_path(issue_number)}${LABELS_SEGMENT}`,
-				body: JSON.stringify({ labels: [label] }),
-			}),
-	)
+	const write = await issue_apply_label(issue_number, label)
+
+	return write.is_applied
 }
 
 // The counterpart to the addition above, for a run taking its own marker back off
@@ -279,6 +323,7 @@ const git_gh_issue_write = {
 	label_ensure,
 	issue_create_request,
 	issue_create_with_label,
+	issue_apply_label,
 	issue_add_label,
 	issue_remove_label,
 	issue_add_blocked_by,
@@ -286,3 +331,4 @@ const git_gh_issue_write = {
 }
 
 export { git_gh_issue_write }
+export type { LabelWrite }

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

@@ -89,9 +89,24 @@ interface PullMergeState {
 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)
@@ -130,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> {
@@ -144,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)
 
@@ -186,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
@@ -218,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)
@@ -229,9 +269,11 @@ 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),
@@ -244,19 +286,22 @@ async function pr_get_merge_state(branch_name: string): Promise<PullMergeState |
 // 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'
 }

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'
@@ -87,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,
@@ -199,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 }
@@ -297,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)
@@ -385,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

@@ -19,9 +19,7 @@ const UNTRACKED_FILES_FLAG = '--untracked-files=all'
 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
 }
@@ -31,9 +29,7 @@ function get_git_command_for_spawn(): string {
 
 	if (binary !== undefined && binary !== '') return binary
 
-	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
 }