@joshuafolkken/kit 1.1035.0 → 1.1094.0

package/scripts/release/github-release.ts

@@ -2,15 +2,15 @@ import { setTimeout } from 'node:timers/promises'
 import semver from 'semver'
 import { z } from 'zod'
 
-const API_URL = 'https://api.github.com/repos/joshuafolkken/kit/releases'
-const WORKFLOW_RUNS_URL =
-	'https://api.github.com/repos/joshuafolkken/kit/actions/workflows/publish.yml/runs?event=repository_dispatch&per_page=100'
-const WORKFLOW_JOBS_URL = 'https://api.github.com/repos/joshuafolkken/kit/actions/runs'
+const API_ROOT = 'https://api.github.com/repos'
+const LATEST_PATH = '/releases/latest'
+const REPOSITORY_PATTERN = /^[\w.-]+\/[\w.-]+$/u
 const TAG_PATTERN = /^v\d+\.\d+\.\d+(?:[.-][0-9A-Za-z.-]+)?$/u
 const REQUEST_TIMEOUT_MS = 30_000
 const NOT_FOUND_STATUS = 404
-// Tags through v1.887.0 predate automatic GitHub Releases and must not block the first new release.
-const AUTOMATION_START_TAG = 'v1.887.0'
+// A job skipped by its `if:` (or neutral) belongs to a run that succeeded; counting it would skip a
+// lower tag whose release is still on its way.
+const FAILED_CONCLUSIONS = new Set(['failure', 'cancelled', 'timed_out', 'startup_failure'])
 const POLL_INTERVAL_MS = 30_000
 const MAX_WAIT_ATTEMPTS = 120
 const RELEASE_SCHEMA = z.object({ tag_name: z.string().min(1) })
@@ -23,16 +23,42 @@ const JOB_SCHEMA = z.object({
 })
 const RUNS_SCHEMA = z.object({ workflow_runs: z.array(RUN_SCHEMA) })
 const JOBS_SCHEMA = z.object({ jobs: z.array(JOB_SCHEMA) })
-const PREREQUISITES = ['publish-github', 'publish-npm', 'update-production']
 
 type ReleaseRequest = (url: string, init: RequestInit) => Promise<Response>
 type Wait = () => Promise<void>
 
-interface PublishOptions {
+// What differs between repositories. `start_tag` is the last tag that predates automatic releases;
+// without it the latest existing release is the floor. `workflow` names the publish workflow whose
+// failed run lets a lower tag be skipped, and `jobs` the jobs in it that count (empty: every job).
+interface ReleaseSettings {
+	repository: string
+	start_tag?: string | undefined
+	workflow?: string | undefined
+	jobs?: ReadonlyArray<string> | undefined
+}
+
+interface PublishOptions extends ReleaseSettings {
 	tags?: ReadonlyArray<string>
 	wait?: Wait
 }
 
+interface Client {
+	request: ReleaseRequest
+	token: string
+	url: string
+	workflow: string | undefined
+	jobs: ReadonlyArray<string>
+}
+
+// `fallback` answers when no tag sits between the floor and the target; without one the floor itself
+// is the latest release and the answer.
+interface Ladder {
+	tags: ReadonlyArray<string>
+	floor: string | undefined
+	fallback?: () => Promise<string>
+	wait: Wait
+}
+
 function request_options(token: string, method: string, body?: object): RequestInit {
 	return {
 		method,
@@ -46,21 +72,22 @@ function request_options(token: string, method: string, body?: object): RequestI
 	}
 }
 
+async function api_get(client: Client, path: string): Promise<Response> {
+	return await client.request(`${client.url}${path}`, request_options(client.token, 'GET'))
+}
+
+async function api_post(client: Client, path: string, body: object): Promise<Response> {
+	return await client.request(`${client.url}${path}`, request_options(client.token, 'POST', body))
+}
+
 async function read_response(response: Response): Promise<unknown> {
 	if (!response.ok) throw new Error(`GitHub Releases API returned HTTP ${String(response.status)}`)
 
 	return await response.json()
 }
 
-async function existing_release(
-	request: ReleaseRequest,
-	token: string,
-	tag: string,
-): Promise<boolean> {
-	const response = await request(
-		`${API_URL}/tags/${encodeURIComponent(tag)}`,
-		request_options(token, 'GET'),
-	)
+async function existing_release(client: Client, tag: string): Promise<boolean> {
+	const response = await api_get(client, `/releases/tags/${encodeURIComponent(tag)}`)
 	if (response.status === NOT_FOUND_STATUS) return false
 
 	RELEASE_SCHEMA.parse(await read_response(response))
@@ -68,153 +95,183 @@ async function existing_release(
 	return true
 }
 
-async function previous_tag(request: ReleaseRequest, token: string): Promise<string> {
-	const response = await request(`${API_URL}/latest`, request_options(token, 'GET'))
-	const release = RELEASE_SCHEMA.parse(await read_response(response))
+async function previous_tag(client: Client): Promise<string> {
+	const response = await api_get(client, LATEST_PATH)
 
-	return release.tag_name
+	return RELEASE_SCHEMA.parse(await read_response(response)).tag_name
 }
 
-function predecessor(tags: ReadonlyArray<string>, target: string): string | undefined {
+async function latest_release(client: Client): Promise<string | undefined> {
+	const response = await api_get(client, LATEST_PATH)
+	if (response.status === NOT_FOUND_STATUS) return undefined
+
+	return RELEASE_SCHEMA.parse(await read_response(response)).tag_name
+}
+
+function predecessor(
+	tags: ReadonlyArray<string>,
+	target: string,
+	floor: string | undefined,
+): string | undefined {
 	return tags
 		.filter(
-			(tag) => semver.valid(tag) && semver.gt(tag, AUTOMATION_START_TAG) && semver.lt(tag, target),
+			(tag) =>
+				semver.valid(tag) &&
+				(floor === undefined || semver.gt(tag, floor)) &&
+				semver.lt(tag, target),
 		)
 		.toSorted((left, right) => semver.compare(right, left))[0]
 }
 
-function is_failed_job(job: z.infer<typeof JOB_SCHEMA>): boolean {
-	if (job.status !== 'completed' || job.conclusion === 'success') return false
+function is_failed_job(job: z.infer<typeof JOB_SCHEMA>, names: ReadonlyArray<string>): boolean {
+	if (job.status !== 'completed' || !FAILED_CONCLUSIONS.has(job.conclusion ?? '')) return false
+	if (names.length === 0) return true
 
-	return PREREQUISITES.some((name) => job.name === name || job.name.startsWith(`${name} /`))
+	return names.some((name) => job.name === name || job.name.startsWith(`${name} /`))
 }
 
-function publication_failed(jobs: Array<z.infer<typeof JOB_SCHEMA>>): boolean {
-	return jobs.some((job) => is_failed_job(job))
-}
+async function failed_publication(client: Client, tag: string): Promise<boolean> {
+	if (client.workflow === undefined) return false
 
-async function failed_publication(
-	request: ReleaseRequest,
-	token: string,
-	tag: string,
-): Promise<boolean> {
-	const runs_response = await request(WORKFLOW_RUNS_URL, request_options(token, 'GET'))
+	const workflow = encodeURIComponent(client.workflow)
+	const runs_response = await api_get(client, `/actions/workflows/${workflow}/runs?per_page=100`)
 	const runs = RUNS_SCHEMA.parse(await read_response(runs_response)).workflow_runs
 	const run = runs.find((item) => item.display_title === `Publish ${tag}`)
 	if (!run) return false
 
-	const url = `${WORKFLOW_JOBS_URL}/${String(run.id)}/jobs?per_page=100`
-	const jobs_response = await request(url, request_options(token, 'GET'))
+	const jobs_response = await api_get(client, `/actions/runs/${String(run.id)}/jobs?per_page=100`)
+	const { jobs } = JOBS_SCHEMA.parse(await read_response(jobs_response))
 
-	return publication_failed(JOBS_SCHEMA.parse(await read_response(jobs_response)).jobs)
+	return jobs.some((job) => is_failed_job(job, client.jobs))
 }
 
 async function default_wait(): Promise<void> {
 	await setTimeout(POLL_INTERVAL_MS)
 }
 
-async function release_state(
-	request: ReleaseRequest,
-	token: string,
-	tag: string,
-): Promise<'ready' | 'failed' | 'pending'> {
-	if (await existing_release(request, token, tag)) return 'ready'
-	if (await failed_publication(request, token, tag)) return 'failed'
+async function release_state(client: Client, tag: string): Promise<'ready' | 'failed' | 'pending'> {
+	if (await existing_release(client, tag)) return 'ready'
+	if (await failed_publication(client, tag)) return 'failed'
 
 	return 'pending'
 }
 
-async function wait_for_release(
-	request: ReleaseRequest,
-	token: string,
-	tag: string,
-	wait: Wait,
-): Promise<boolean> {
+async function wait_for_release(client: Client, tag: string, wait: Wait): Promise<boolean> {
 	for (let attempt = 0; attempt < MAX_WAIT_ATTEMPTS; attempt += 1) {
-		const state = await release_state(request, token, tag)
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
+		const state = await release_state(client, tag)
 		if (state !== 'pending') return state === 'ready'
 
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await wait()
 	}
 
 	throw new Error(`Timed out waiting for previous GitHub Release ${tag}`)
 }
 
+async function ladder_end(ladder: Ladder): Promise<string | undefined> {
+	return ladder.fallback ? await ladder.fallback() : ladder.floor
+}
+
+// With no floor the repository has no release at all, so no lower tag will ever gain one: the
+// nearest lower tag is the baseline as it stands, and none means notes without a baseline.
 async function baseline_tag(
-	request: ReleaseRequest,
-	token: string,
+	client: Client,
 	tag: string,
-	options: PublishOptions,
-): Promise<string> {
-	const prior = predecessor(options.tags ?? [], tag)
-	if (!prior) return await previous_tag(request, token)
+	ladder: Ladder,
+): Promise<string | undefined> {
+	const prior = predecessor(ladder.tags, tag, ladder.floor)
+	if (ladder.floor === undefined) return prior
+	if (!prior) return await ladder_end(ladder)
+
+	return (await wait_for_release(client, prior, ladder.wait))
+		? prior
+		: await baseline_tag(client, prior, ladder)
+}
 
-	if (!(await wait_for_release(request, token, prior, options.wait ?? default_wait))) {
-		return await baseline_tag(request, token, prior, options)
+function assert_older(previous: string | undefined, tag: string): void {
+	if (previous !== undefined && !semver.lt(previous, tag)) {
+		throw new Error(`Latest release ${previous} is not older than ${tag}`)
+	}
+}
+
+async function build_ladder(client: Client, options: PublishOptions): Promise<Ladder> {
+	const tags = options.tags ?? []
+	const wait = options.wait ?? default_wait
+	const { start_tag } = options
+
+	if (start_tag !== undefined) {
+		return { tags, wait, floor: start_tag, fallback: async () => await previous_tag(client) }
 	}
 
-	return prior
+	return { tags, wait, floor: await latest_release(client) }
 }
 
 async function generate_notes(
-	request: ReleaseRequest,
-	token: string,
+	client: Client,
 	tag: string,
-	previous: string,
+	previous: string | undefined,
 ): Promise<z.infer<typeof NOTES_SCHEMA>> {
-	const response = await request(
-		`${API_URL}/generate-notes`,
-		request_options(token, 'POST', {
-			tag_name: tag,
-			previous_tag_name: previous,
-			configuration_file_path: '.github/release.yml',
-		}),
-	)
+	const response = await api_post(client, '/releases/generate-notes', {
+		tag_name: tag,
+		...(previous !== undefined && { previous_tag_name: previous }),
+		configuration_file_path: '.github/release.yml',
+	})
 
 	return NOTES_SCHEMA.parse(await read_response(response))
 }
 
 async function create_release(
-	request: ReleaseRequest,
-	token: string,
+	client: Client,
 	tag: string,
-	previous: string,
+	previous: string | undefined,
 ): Promise<void> {
-	const notes = await generate_notes(request, token, tag, previous)
-	const response = await request(
-		API_URL,
-		request_options(token, 'POST', {
-			tag_name: tag,
-			name: notes.name,
-			body: notes.body,
-			draft: false,
-			prerelease: false,
-		}),
-	)
+	const notes = await generate_notes(client, tag, previous)
+	const response = await api_post(client, '/releases', {
+		tag_name: tag,
+		name: notes.name,
+		body: notes.body,
+		draft: false,
+		prerelease: false,
+	})
 
 	RELEASE_SCHEMA.parse(await read_response(response))
 }
 
+function create_client(request: ReleaseRequest, token: string, settings: ReleaseSettings): Client {
+	if (!REPOSITORY_PATTERN.test(settings.repository)) {
+		throw new Error(`Invalid repository: ${settings.repository}`)
+	}
+
+	return {
+		request,
+		token,
+		url: `${API_ROOT}/${settings.repository}`,
+		workflow: settings.workflow,
+		jobs: settings.jobs ?? [],
+	}
+}
+
 async function publish(
 	request: ReleaseRequest,
 	token: string,
 	tag: string,
-	options: PublishOptions = {},
+	options: PublishOptions,
 ): Promise<string> {
 	if (!TAG_PATTERN.test(tag)) throw new Error(`Invalid release tag: ${tag}`)
-	if (await existing_release(request, token, tag)) return 'already-published'
 
-	const previous = await baseline_tag(request, token, tag, options)
+	const client = create_client(request, token, options)
+	if (await existing_release(client, tag)) return 'already-published'
 
-	if (!semver.lt(previous, tag)) {
-		throw new Error(`Latest release ${previous} is not older than ${tag}`)
-	}
+	const previous = await baseline_tag(client, tag, await build_ladder(client, options))
 
-	await create_release(request, token, tag, previous)
+	assert_older(previous, tag)
+	await create_release(client, tag, previous)
 
-	return `published ${tag} from ${previous}`
+	return `published ${tag} from ${previous ?? 'the first commit'}`
 }
 
 const github_release = { publish }
 
+export type { ReleaseSettings }
 export { github_release }

package/scripts/release/release-history.ts

@@ -125,7 +125,6 @@ const release_history = {
 	read_current_version,
 	read_release_plan,
 	BASE_SEARCH_LIMIT,
-	DEFAULT_TIP,
 }
 
 export { release_history }

package/scripts/release/release-plan.ts

@@ -123,7 +123,6 @@ const release_plan = {
 	format_plan,
 	next_version,
 	short_sha,
-	PENDING_ICON,
 }
 
 export { release_plan }

package/scripts/release/release-publish.ts

@@ -1,6 +1,6 @@
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { git_pr_checks } from '#scripts/gh/git-pr-checks'
 import { git_command } from '#scripts/git/git-command'
-import { git_gh_command } from '#scripts/git/git-gh-command'
-import { git_pr_checks } from '#scripts/git/git-pr-checks'
 import { git_remote_branch } from '#scripts/git/git-remote-branch'
 import { write_version } from '#scripts/version/bump-version'
 import { version_targets } from '#scripts/version/version-targets'
@@ -150,7 +150,6 @@ const release_publish = {
 	publish,
 	pull_request_body,
 	unreachable_remote_message,
-	FAILURE_EXIT_CODE,
 	SUCCESS_EXIT_CODE,
 }
 

package/scripts/release/release-scope-cli.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
-import { git_followup_pending } from '#scripts/git/git-followup-pending'
+import { git_followup_pending } from '#scripts/followup/git-followup-pending'
 import { path_decision } from '#scripts/josh/path-decision'
 import { release_plan } from './release-plan'
 
@@ -87,7 +87,6 @@ const release_scope_cli = {
 	main,
 	run,
 	JSON_KEY,
-	KNOWN_FLAGS,
 	NOTHING_PENDING_REASON,
 	RELEASE_HINT,
 	REQUIRED_SCOPE,

package/scripts/release/release-tag.ts

@@ -1,5 +1,5 @@
-import { git_gh_api_path } from '#scripts/git/git-gh-api-path'
-import { git_gh_exec } from '#scripts/git/git-gh-exec'
+import { git_gh_api_path } from '#scripts/gh/git-gh-api-path'
+import { git_gh_exec } from '#scripts/gh/git-gh-exec'
 import { poll, type PollOptions } from '#scripts/lib/poll'
 
 // **The release is not finished when the pull request merges — it is finished when the tag exists.**
@@ -82,12 +82,10 @@ const release_tag = {
 	attempts_for,
 	configured_timeout_seconds,
 	format_result,
-	tag_exists,
 	tag_name,
 	wait_for_tag,
 	DEFAULT_TIMEOUT_SECONDS,
 	TAG_POLL_INTERVAL_MS,
-	TIMEOUT_ENV,
 }
 
 export { release_tag }

package/scripts/repo/auto-merge-setting-logic.ts

@@ -41,7 +41,7 @@ function format_disabled_detail(repo: string | undefined): ReadonlyArray<string>
 		`    off, so ${WORKFLOW_PATH} fails with`,
 		'    `Auto-merge is not allowed for this repository` and Dependabot pull requests stay open.',
 		`    Enable: ${enable_command(repo)}`,
-		`    ${ORIGIN_ISSUE} distributes the workflow; kit never changes a repository setting.`,
+		`    ${ORIGIN_ISSUE} distributes the workflow; kit never changes this setting.`,
 	]
 }
 
@@ -89,9 +89,6 @@ function format_auto_merge_report(
 
 const auto_merge_setting_logic = {
 	SETTING_LABEL,
-	ALLOW_AUTO_MERGE_FIELD,
-	WORKFLOW_PATH,
-	enable_command,
 	classify_auto_merge,
 	format_auto_merge_report,
 }

package/scripts/repo/repo-setting.ts

@@ -1,4 +1,4 @@
-import { git_gh_exec } from '#scripts/git/git-gh-exec'
+import { git_gh_exec } from '#scripts/gh/git-gh-exec'
 import { PROJECT_ROOT } from '#scripts/init/init-paths'
 
 // The shared half of every "report a GitHub repository setting kit cannot write" check.

package/scripts/repo/repository-labels.ts

@@ -1,5 +1,5 @@
-import { git_gh_exec } from '#scripts/git/git-gh-exec'
-import { REPOSITORY_LABELS, type LabelDefinition } from '#scripts/git/issue-labels'
+import { git_gh_exec } from '#scripts/gh/git-gh-exec'
+import { REPOSITORY_LABELS, type LabelDefinition } from '#scripts/issue/issue-labels'
 
 // Creates the labels kit's workflow and the distributed `pr-classification.yml` rely on, and only
 // those the repository is missing (joshuafolkken/kit#2797). The one place labels are created: `josh
@@ -86,6 +86,6 @@ function ensure_labels(repo: string | undefined): ReadonlyArray<string> {
 	return create_missing(missing_labels(existing), repo)
 }
 
-const repository_labels = { missing_labels, ensure_labels }
+const repository_labels = { ensure_labels }
 
 export { repository_labels }