@joshuafolkken/kit 1.887.0 → 1.921.0

package/scripts/ci/pr-classification.ts

@@ -0,0 +1,114 @@
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { z } from 'zod'
+
+const BUGFIX = 'bugfix'
+const BREAKING = 'breaking-change'
+const CLASSIFICATION_LABELS = [
+	BREAKING,
+	'enhancement',
+	BUGFIX,
+	'other-change',
+	'ignore-for-release',
+] as const
+type ReleaseClassification = (typeof CLASSIFICATION_LABELS)[number]
+const CLASSIFICATION_SET: ReadonlySet<string> = new Set(CLASSIFICATION_LABELS)
+const ISSUE_BUG_LABEL = 'bug'
+const DECLARATION = /^- リリース分類: (.+)$/gmu
+const LEGACY_LABELS: ReadonlySet<string> = new Set(['semver-major', 'semver-minor'])
+
+const LABEL = z.object({ name: z.string() })
+const USER = z.object({ login: z.string() })
+const PULL_REQUEST = z.object({ user: USER, labels: z.array(LABEL) })
+const EVENT = z.object({
+	pull_request: PULL_REQUEST,
+})
+
+function classification_error(labels: ReadonlyArray<string>, author: string): string | undefined {
+	const legacy = labels.filter((label) => LEGACY_LABELS.has(label.toLowerCase()))
+	if (legacy.length > 0) return `Remove legacy release labels: ${legacy.join(', ')}`
+
+	const selected = labels.filter((label) => CLASSIFICATION_SET.has(label.toLowerCase()))
+
+	if (selected.length > 1) {
+		return `Choose exactly one release classification; found: ${selected.join(', ')}`
+	}
+
+	if (selected.length === 1 || author.endsWith('[bot]')) return undefined
+
+	return `Choose one release classification: ${CLASSIFICATION_LABELS.join(', ')}`
+}
+
+function is_classification(value: string): value is ReleaseClassification {
+	return CLASSIFICATION_SET.has(value)
+}
+
+function release_candidates(
+	candidates: ReadonlyArray<ReleaseClassification>,
+): ReadonlyArray<ReleaseClassification> {
+	if (!candidates.includes(BREAKING)) return candidates
+
+	return candidates.filter((candidate) => candidate !== 'enhancement')
+}
+
+function issue_candidates(issue_json: string): ReadonlyArray<ReleaseClassification> {
+	const issue = z
+		.object({ labels: z.array(LABEL), body: z.string().nullable() })
+		.parse(JSON.parse(issue_json))
+	const names = issue.labels.map((label) => label.name.toLowerCase())
+	const declared = [...(issue.body ?? '').matchAll(DECLARATION)].map((match) => match[1] ?? '')
+	const candidates = [...release_candidates([...names, ...declared].filter(is_classification))]
+	const unknown = declared.filter((value) => !is_classification(value))
+
+	if (unknown.length > 0) throw new Error(`Unknown release classification: ${unknown.join(', ')}`)
+
+	if (names.includes(ISSUE_BUG_LABEL) && !candidates.includes(BREAKING)) {
+		candidates.push(BUGFIX)
+	}
+
+	return candidates
+}
+
+function select_issue_classification(issue_json: string): ReleaseClassification {
+	const candidates = issue_candidates(issue_json)
+	const selected = [...new Set(candidates)]
+	const [label] = selected
+
+	if (label === undefined || selected.length > 1) {
+		throw new Error(
+			`Choose one release classification before opening the PR: ${CLASSIFICATION_LABELS.join(', ')}; found: ${selected.join(', ') || 'none'}. Add "- リリース分類: <label>" to the Issue body.`,
+		)
+	}
+
+	return label
+}
+
+function check_event(event_path: string): string | undefined {
+	const event = EVENT.parse(JSON.parse(readFileSync(event_path, 'utf8')))
+
+	return classification_error(
+		event.pull_request.labels.map((label) => label.name),
+		event.pull_request.user.login,
+	)
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	const event_path = process.env['GITHUB_EVENT_PATH']
+	if (!event_path) throw new Error('GITHUB_EVENT_PATH is required')
+
+	const error = check_event(event_path)
+
+	if (error) {
+		console.error(`::error::${error}`)
+		process.exitCode = 1
+	}
+}
+
+const pr_classification = {
+	classification_error,
+	check_event,
+	is_classification,
+	select_issue_classification,
+}
+
+export { pr_classification, CLASSIFICATION_LABELS, type ReleaseClassification }

package/scripts/document/document-byte-budget.ts

@@ -95,7 +95,8 @@ const DOCUMENT_BYTE_BUDGET: ReadonlyArray<DocumentBudget> = [
 	{ path: 'prompts/collaboration-workflow/file-edits.md', bytes: 12_288 },
 	{ path: 'prompts/collaboration-workflow/gh-rest.md', bytes: 8192 },
 	{ path: 'prompts/collaboration-workflow/issue-citation.md', bytes: 8192 },
-	{ path: 'prompts/collaboration-workflow/issue-template.md', bytes: 24_576 },
+	// #2662 adds the feature and compatibility declarations to the canonical filing procedure.
+	{ path: 'prompts/collaboration-workflow/issue-template.md', bytes: 28_672 },
 	{ path: 'prompts/collaboration-workflow/latest-first.md', bytes: 4096 },
 	{ path: 'prompts/collaboration-workflow/no-clones.md', bytes: 4096 },
 	{ path: 'prompts/collaboration-workflow/operating-rules.md', bytes: 24_576 },
@@ -116,7 +117,7 @@ const DOCUMENT_BYTE_BUDGET: ReadonlyArray<DocumentBudget> = [
 	{ path: 'prompts/review-rubric.md', bytes: 20_480 },
 	{ path: 'prompts/review.md', bytes: 20_480 },
 	{ path: 'prompts/sonar-hotspot-handling.md', bytes: 8192 },
-	{ path: 'prompts/testing-guide.md', bytes: 20_480 },
+	{ path: 'prompts/testing-guide.md', bytes: 24_576 },
 ]
 
 // The recorded ceiling for one path, or undefined when it carries no budget entry.

package/scripts/gate/gate-report.ts

@@ -16,6 +16,8 @@ const { FAIL_ICON, PASS_ICON } = status_icons
 interface GateStep {
 	label: string
 	command_args: ReadonlyArray<string>
+	cwd?: string | undefined
+	skip_reason?: string | undefined
 }
 
 interface GateStepResult extends BufferedProcessResult {

package/scripts/gate/gate-steps.ts

@@ -0,0 +1,50 @@
+import { gate_plan, type GateCheck, type GatePlan } from './gate-plan'
+import type { GateStep } from './gate-report'
+import { project_checks } from './project-checks'
+import { type_check_step } from './type-check-step'
+
+const JOSH = 'josh'
+const { TYPE_CHECK_LABEL, UNIT_LABEL } = gate_plan
+const UNIT_WORKER_FLAG = '--maxWorkers'
+
+function unit_worker_args(check: GateCheck, plan: GatePlan): ReadonlyArray<string> {
+	if (check.label !== UNIT_LABEL || plan.unit_worker_cap === undefined) return []
+
+	return [`${UNIT_WORKER_FLAG}=${String(plan.unit_worker_cap)}`]
+}
+
+// Resolve the type checker per project and run every static check from its package root.
+async function build_gate_step(
+	check: GateCheck,
+	start_directory: string,
+	plan: GatePlan = gate_plan.resolve_gate_plan(),
+): Promise<GateStep> {
+	const cwd = project_checks.is_static(start_directory)
+		? project_checks.project_root(start_directory)
+		: undefined
+
+	if (check.label !== TYPE_CHECK_LABEL) {
+		return {
+			label: check.label,
+			command_args: [JOSH, check.target, ...unit_worker_args(check, plan)],
+			cwd,
+		}
+	}
+
+	const command_args = await type_check_step.resolve_type_check_args(start_directory)
+	const skip_reason =
+		command_args[0] === JOSH ? project_checks.type_check_skip_reason(start_directory) : undefined
+
+	return { label: check.label, command_args, cwd, skip_reason }
+}
+
+async function build_gate_steps(
+	start_directory: string,
+	plan: GatePlan = gate_plan.resolve_gate_plan(),
+): Promise<ReadonlyArray<GateStep>> {
+	return await Promise.all(
+		plan.checks.map(async (check) => await build_gate_step(check, start_directory, plan)),
+	)
+}
+
+export { build_gate_step, build_gate_steps, UNIT_WORKER_FLAG }

package/scripts/gate/project-checks.ts

@@ -0,0 +1,121 @@
+import { existsSync, globSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { find_local_bin_upwards } from '#scripts/build/local-bin'
+import { SKIP_MARKER } from '#scripts/test/skip-marker'
+
+const PACKAGE_JSON = 'package.json'
+const IGNORED_DIRS = new Set([
+	'node_modules',
+	'.git',
+	'.venv',
+	'venv',
+	'target',
+	'dist',
+	'build',
+	'.svelte-kit',
+])
+const WEB_FILES = '**/*.{html,css,js,jsx,mjs,cjs}'
+const SCRIPT_FILES = '**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}'
+const TYPE_FILES = '**/*.{ts,tsx,mts,cts}'
+const ESLINT_CONFIGS = [
+	'eslint.config.js',
+	'eslint.config.mjs',
+	'eslint.config.cjs',
+	'eslint.config.ts',
+	'eslint.config.mts',
+	'eslint.config.cts',
+]
+const CSPELL_CONFIGS = [
+	'cspell.config.yaml',
+	'cspell.config.yml',
+	'cspell.config.json',
+	'cspell.config.js',
+	'cspell.config.cjs',
+	'cspell.config.mjs',
+	'cspell.json',
+	'cspell.yaml',
+]
+const TYPE_CONFIGS = ['tsconfig.json', 'jsconfig.json']
+
+function project_root(directory: string): string {
+	let current = directory
+
+	while (!existsSync(path.join(current, PACKAGE_JSON))) {
+		const parent = path.dirname(current)
+		if (parent === current) return directory
+		current = parent
+	}
+
+	return current
+}
+
+function is_ignored(entry: string): boolean {
+	return entry.split(/[/\\]/u).some((part) => IGNORED_DIRS.has(part))
+}
+
+function has_files(directory: string, pattern: string): boolean {
+	return globSync(pattern, { cwd: project_root(directory), exclude: is_ignored }).length > 0
+}
+
+function has_config(directory: string, names: ReadonlyArray<string>): boolean {
+	return names.some((name) => existsSync(path.join(project_root(directory), name)))
+}
+
+function has_bin(directory: string, bin_name: string): boolean {
+	return find_local_bin_upwards(directory, bin_name) !== undefined
+}
+
+function josh_settings(manifest: unknown): unknown {
+	if (typeof manifest !== 'object' || manifest === null || !('josh' in manifest)) return undefined
+
+	return manifest.josh
+}
+
+function is_static_manifest(manifest: unknown): boolean {
+	const josh = josh_settings(manifest)
+	if (typeof josh !== 'object' || josh === null || !('profile' in josh)) return false
+
+	return josh.profile === 'static'
+}
+
+function is_static(directory: string): boolean {
+	try {
+		const manifest_path = path.join(project_root(directory), PACKAGE_JSON)
+		const manifest: unknown = JSON.parse(readFileSync(manifest_path, 'utf8'))
+
+		return is_static_manifest(manifest)
+	} catch {
+		return false
+	}
+}
+
+function skip_notice(check: string, reason: string): string {
+	return `josh ${check}: ${reason} ${SKIP_MARKER} ${check}.`
+}
+
+function type_check_skip_reason(directory: string): string | undefined {
+	if (!is_static(directory)) return undefined
+	if (!has_files(directory, TYPE_FILES)) return 'no TypeScript files were found'
+	if (!has_config(directory, TYPE_CONFIGS)) return 'no TypeScript configuration was found'
+	if (!has_bin(directory, 'tsc')) return 'typescript is not installed'
+
+	return undefined
+}
+
+const project_checks = {
+	CSPELL_CONFIGS,
+	ESLINT_CONFIGS,
+	SCRIPT_FILES,
+	TYPE_CONFIGS,
+	TYPE_FILES,
+	WEB_FILES,
+	has_bin,
+	has_config,
+	has_files,
+	is_static,
+	project_root,
+	skip_notice,
+	type_check_skip_reason,
+}
+
+export { project_checks }

package/scripts/gate/verification-gate.ts

@@ -10,12 +10,13 @@ import { review_stamps } from '#scripts/review/review-stamps'
 import { review_tree } from '#scripts/review/review-tree'
 import { unit_worker_share } from '#scripts/test/unit-worker-share'
 import { core_budget } from './core-budget'
-import { gate_plan, type GateCheck, type GatePlan } from './gate-plan'
+import { gate_plan, type GatePlan } from './gate-plan'
 import { gate_report, type GateStep, type GateStepResult } from './gate-report'
 import { gate_skip } from './gate-skip'
+import { build_gate_step, build_gate_steps, UNIT_WORKER_FLAG } from './gate-steps'
 import { gate_tree, type GateTree } from './gate-tree'
+import { project_checks } from './project-checks'
 import { scoped_green, type ScopedSources } from './scoped-green'
-import { type_check_step } from './type-check-step'
 
 // joshuafolkken/kit#914: the completion gate's four checks are independent and share no mutable
 // state, yet every entry point ran them one after another — paid again on every `epicrun` child,
@@ -33,55 +34,25 @@ import { type_check_step } from './type-check-step'
 // `process.argv` is [runner, script, ...arguments].
 const FIRST_ARGUMENT_INDEX = 2
 
-const JOSH = 'josh'
-const { GATE_CHECKS, TYPE_CHECK_LABEL, UNIT_LABEL } = gate_plan
+const { GATE_CHECKS } = gate_plan
 
 const GATE_TARGETS: ReadonlyArray<string> = GATE_CHECKS.map((check) => check.target)
 
-// vitest's own flag, appended to the sub-command rather than set in `vitest.config.ts`: the config
-// is one project's, and the number this carries is a property of the machine the gate is running
-// on (joshuafolkken/kit#1258). `josh test:unit` forwards what it is given straight to
-// `vitest run`, so nothing between here and vitest has to know about it.
-const UNIT_WORKER_FLAG = '--maxWorkers'
-
-function unit_worker_args(check: GateCheck, plan: GatePlan): ReadonlyArray<string> {
-	if (check.label !== UNIT_LABEL || plan.unit_worker_cap === undefined) return []
-
-	return [`${UNIT_WORKER_FLAG}=${String(plan.unit_worker_cap)}`]
-}
-
-// Only the type check is resolved per project (joshuafolkken/kit#934) — a SvelteKit project
-// type-checks through its own toolkit, not through `tsc --noEmit`. Resolving inside the step keeps
-// the probe concurrent with the other three checks rather than delaying every one of them.
-async function build_gate_step(
-	check: GateCheck,
-	start_directory: string,
-	plan: GatePlan = gate_plan.resolve_gate_plan(),
-): Promise<GateStep> {
-	if (check.label !== TYPE_CHECK_LABEL) {
+async function run_gate_step(step: GateStep): Promise<GateStepResult> {
+	if (step.skip_reason !== undefined) {
 		return {
-			label: check.label,
-			command_args: [JOSH, check.target, ...unit_worker_args(check, plan)],
+			label: step.label,
+			command: step.command_args.join(' '),
+			output: project_checks.skip_notice('check', step.skip_reason),
+			exit_code: 0,
+			elapsed_ms: 0,
 		}
 	}
 
-	return {
-		label: check.label,
-		command_args: await type_check_step.resolve_type_check_args(start_directory),
-	}
-}
-
-async function build_gate_steps(
-	start_directory: string,
-	plan: GatePlan = gate_plan.resolve_gate_plan(),
-): Promise<ReadonlyArray<GateStep>> {
-	return await Promise.all(
-		plan.checks.map(async (check) => await build_gate_step(check, start_directory, plan)),
+	const result = await buffered_process.run_buffered_process(
+		step.command_args,
+		step.cwd === undefined ? {} : { cwd: step.cwd },
 	)
-}
-
-async function run_gate_step(step: GateStep): Promise<GateStepResult> {
-	const result = await buffered_process.run_buffered_process(step.command_args)
 
 	return { label: step.label, command: step.command_args.join(' '), ...result }
 }

package/scripts/git/git-common-directory.ts

@@ -33,6 +33,14 @@ function resolve(cwd: string): string | undefined {
 	}
 }
 
-const git_common_directory = { resolve, select_linked }
+function repository(cwd: string): string | undefined {
+	try {
+		return read_directories(cwd)[COMMON_GIT_DIRECTORY]
+	} catch {
+		return undefined
+	}
+}
+
+const git_common_directory = { repository, resolve, select_linked }
 
 export { git_common_directory }

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

@@ -29,6 +29,7 @@ const check_runs_page_schema = z.looseObject({
 	// answer an empty rollup — which `git-pr-followup.ts` reports as "this branch has no checks".
 	check_runs: z.array(rollup_element_schema),
 })
+const check_run_app_schema = z.object({ id: z.number() })
 
 const status_page_schema = z.looseObject({
 	statuses: z.array(rollup_element_schema),
@@ -50,10 +51,37 @@ function read_pages<T>(raw_json: string, schema: z.ZodType<T>, message: string):
 	return pages
 }
 
+function check_run_group_key(run: RollupElement): string | undefined {
+	const { name, app: raw_app } = run
+	if (typeof name !== 'string') return undefined
+	const app = check_run_app_schema.safeParse(raw_app)
+
+	return JSON.stringify([name, app.success ? app.data.id : undefined])
+}
+
+function remember_newest_run(run: RollupElement, latest_ids: Map<string, number>): void {
+	const key = check_run_group_key(run)
+	const { id } = run
+	if (key === undefined || typeof id !== 'number') return
+	const previous_id = latest_ids.get(key)
+	if (previous_id === undefined || id > previous_id) latest_ids.set(key, id)
+}
+
+function is_newest_run(run: RollupElement, latest_ids: Map<string, number>): boolean {
+	const key = check_run_group_key(run)
+	const { id } = run
+	if (key === undefined || typeof id !== 'number') return true
+
+	return id === latest_ids.get(key)
+}
+
 function to_check_run_items(check_runs_json: string): Array<RollupElement> {
 	const pages = read_pages(check_runs_json, check_runs_page_schema, NOT_A_CHECK_RUNS_LISTING)
+	const runs = pages.flatMap((page) => page.check_runs)
+	const latest_ids = new Map<string, number>()
+	for (const run of runs) remember_newest_run(run, latest_ids)
 
-	return pages.flatMap((page) => page.check_runs)
+	return runs.filter((run) => is_newest_run(run, latest_ids))
 }
 
 function to_status_context_items(status_json: string): Array<RollupElement> {

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

@@ -1,4 +1,6 @@
+import { pr_classification, type ReleaseClassification } from '#scripts/ci/pr-classification'
 import { poll } from '#scripts/lib/poll'
+import { z } from 'zod'
 import { git_command } from './git-command'
 import { git_gh_api_path } from './git-gh-api-path'
 import { git_gh_exec } from './git-gh-exec'
@@ -46,6 +48,44 @@ const MERGE_UNCONFIRMED_MESSAGE =
 	'gh api could not read the pull request back after the merge request failed'
 const MERGE_READ_BACK_ATTEMPTS = 3
 const MERGE_READ_BACK_INTERVAL_MS = 1000
+const PR_NUMBER_PATTERN = /\/pull\/([1-9]\d*)$/u
+const LABELS_SEGMENT = '/labels'
+const PR_LABELS = z.array(z.object({ name: z.string() }))
+
+async function add_pr_classification(number: string, label: ReleaseClassification): Promise<void> {
+	await git_gh_exec.exec_gh_api({
+		path: `${git_gh_api_path.issue_api_path(number)}${LABELS_SEGMENT}`,
+		body: JSON.stringify({ labels: [label] }),
+	})
+}
+
+async function pr_get_classification(
+	branch_name: string,
+): Promise<ReleaseClassification | undefined> {
+	const number = await require_pr_number(branch_name)
+	const response = await git_gh_exec.exec_gh_api({
+		path: `${git_gh_api_path.issue_api_path(String(number))}${LABELS_SEGMENT}`,
+	})
+	const names = PR_LABELS.parse(JSON.parse(response)).map((label) => label.name.toLowerCase())
+	const selected = names.filter((name) => pr_classification.is_classification(name))
+	if (selected.length === 0) return undefined
+
+	const error = pr_classification.classification_error(names, 'human')
+	if (error !== undefined) throw new Error(error)
+
+	return selected[0]
+}
+
+async function pr_ensure_classification(
+	branch_name: string,
+	label: ReleaseClassification,
+): Promise<void> {
+	if ((await pr_get_classification(branch_name)) !== undefined) return
+
+	const number = await require_pr_number(branch_name)
+
+	await add_pr_classification(String(number), label)
+}
 
 // **`head` is required and `gh pr create` never asked for it.** The CLI inferred it from the current
 // branch; REST does not, and a request without it is a 422. The branch is read from git rather than
@@ -64,7 +104,7 @@ const MERGE_READ_BACK_INTERVAL_MS = 1000
 // `to_gh_error` appends stdout (joshuafolkken/kit#1029); the `already exists` match itself is
 // unchanged, because both wordings contain it and the 422 carries no machine-readable code for the
 // case (`"code":"custom"`).
-async function pr_create(title: string, body: string): Promise<string> {
+async function post_pull_request(title: string, body: string): Promise<string> {
 	const base = await git_command.get_default_branch()
 	const head = await git_command.branch()
 
@@ -81,6 +121,24 @@ async function pr_create(title: string, body: string): Promise<string> {
 	}
 }
 
+async function pr_create(
+	title: string,
+	body: string,
+	label: ReleaseClassification,
+): Promise<string> {
+	const classification_error = pr_classification.classification_error([label], 'human')
+	if (classification_error !== undefined) throw new Error(classification_error)
+
+	const url = await post_pull_request(title, body)
+	const number = PR_NUMBER_PATTERN.exec(url)?.[1]
+
+	if (number === undefined) throw new Error(`Could not identify the created pull request: ${url}`)
+
+	await add_pr_classification(number, label)
+
+	return url
+}
+
 // **`gh pr checkout` does use GraphQL** — one `POST /graphql` to resolve the pull request, measured
 // with `GH_DEBUG=api` on the throwaway pull request (joshuafolkken/kit#1029). Everything after that
 // is git, so only the resolution had to move: `pr_head_reference` is the REST read that already
@@ -210,6 +268,8 @@ const git_gh_pr = {
 	...git_gh_pr_read,
 	...git_gh_pr_snapshot,
 	pr_create,
+	pr_get_classification,
+	pr_ensure_classification,
 	pr_checkout,
 	pr_comment,
 	pr_merge,