@joshuafolkken/kit 1.883.0 → 1.921.0

package/scripts/lint/lint-parallel.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
+import { project_checks } from '#scripts/gate/project-checks'
 import { ESLINT_CACHE_FILE, ESLINT_CACHE_FLAGS } from '#scripts/josh/josh-command-types'
 import { lane_cache_run } from '#scripts/lane/lane-cache-run'
 import {
@@ -29,6 +30,38 @@ function write_output(result: BufferedProcessResult): void {
 	if (result.output) process.stdout.write(result.output)
 }
 
+function skipped(check: string, reason: string): BufferedProcessResult {
+	return { output: `${project_checks.skip_notice(check, reason)}\n`, exit_code: 0, elapsed_ms: 0 }
+}
+
+async function run_static_prettier(directory: string): Promise<BufferedProcessResult> {
+	if (!project_checks.has_files(directory, project_checks.WEB_FILES)) {
+		return skipped('prettier', 'no HTML, CSS or JavaScript files were found')
+	}
+
+	if (!project_checks.has_bin(directory, 'prettier')) {
+		return skipped('prettier', 'prettier is not installed')
+	}
+
+	return await buffered_process.run_buffered_process(PRETTIER_ARGS)
+}
+
+async function run_static_eslint(directory: string): Promise<BufferedProcessResult> {
+	if (!project_checks.has_files(directory, project_checks.SCRIPT_FILES)) {
+		return skipped('eslint', 'no JavaScript or TypeScript files were found')
+	}
+
+	if (!project_checks.has_config(directory, project_checks.ESLINT_CONFIGS)) {
+		return skipped('eslint', 'no ESLint configuration was found')
+	}
+
+	if (!project_checks.has_bin(directory, 'eslint')) {
+		return skipped('eslint', 'eslint is not installed')
+	}
+
+	return await run_eslint(ESLINT_ARGS, ESLINT_CACHE_FILE)
+}
+
 function lint_exit_code(prettier: BufferedProcessResult, eslint: BufferedProcessResult): number {
 	return buffered_process.is_process_failed(prettier) || buffered_process.is_process_failed(eslint)
 		? FAIL_EXIT_CODE
@@ -55,7 +88,17 @@ async function run_lint_checks(
 }
 
 async function run_lint_parallel_checks(): Promise<number> {
-	return await run_lint_checks(PRETTIER_ARGS, ESLINT_ARGS)
+	const directory = process.cwd()
+	if (!project_checks.is_static(directory)) return await run_lint_checks(PRETTIER_ARGS, ESLINT_ARGS)
+	const [prettier, eslint] = await Promise.all([
+		run_static_prettier(directory),
+		run_static_eslint(directory),
+	])
+
+	write_output(prettier)
+	write_output(eslint)
+
+	return lint_exit_code(prettier, eslint)
 }
 
 // `process.exitCode` rather than `process.exit()`: both reports are buffered and written here in

package/scripts/observations/observations-flush.ts

@@ -255,7 +255,7 @@ async function push_and_open(branch_name: string): Promise<string> {
 	try {
 		await git_command.push()
 
-		return await git_gh_command.pr_create(COMMIT_MESSAGE, pull_request_body())
+		return await git_gh_command.pr_create(COMMIT_MESSAGE, pull_request_body(), 'ignore-for-release')
 	} catch (error) {
 		throw new Error(stranded_branch_message(branch_name, message_of(error)), { cause: error })
 	}

package/scripts/package/production-dependency-graph.ts

@@ -0,0 +1,68 @@
+interface LockDependency {
+	specifier: string
+	version: string
+}
+
+interface LockSnapshot {
+	dependencies?: Record<string, string>
+	optionalDependencies?: Record<string, string>
+}
+
+interface LockImporter {
+	dependencies: Record<string, LockDependency>
+	optionalDependencies?: Record<string, LockDependency>
+}
+
+interface Lockfile {
+	importers: Record<string, LockImporter>
+	snapshots: Record<string, LockSnapshot>
+}
+
+function collect_snapshot(
+	lockfile: Lockfile,
+	names: Set<string>,
+	name: string,
+	version: string,
+): void {
+	const key = `${name}@${version}`
+	if (names.has(key)) return
+	const snapshot = lockfile.snapshots[key]
+	if (!snapshot) throw new Error(`Missing production snapshot: ${key}`)
+	names.add(key)
+
+	const children = { ...snapshot.dependencies, ...snapshot.optionalDependencies }
+
+	for (const [child, child_version] of Object.entries(children)) {
+		collect_snapshot(lockfile, names, child, child_version)
+	}
+}
+
+function root_version(importer: LockImporter, name: string, specifier: string): string {
+	const entry = importer.dependencies[name] ?? importer.optionalDependencies?.[name]
+	if (entry?.specifier !== specifier) throw new Error(`Production lockfile mismatch: ${name}`)
+
+	return entry.version
+}
+
+function production_names(
+	lockfile: Lockfile,
+	dependencies: Record<string, string>,
+	optional_dependencies: Record<string, string> = {},
+): Set<string> {
+	const seen = new Set<string>()
+	const importer = lockfile.importers['.']
+	if (!importer) throw new Error('Missing root importer in production lockfile')
+
+	const roots = { ...dependencies, ...optional_dependencies }
+
+	for (const [name, specifier] of Object.entries(roots)) {
+		collect_snapshot(lockfile, seen, name, root_version(importer, name, specifier))
+	}
+
+	return new Set([...seen].map((key) => key.slice(0, key.lastIndexOf('@'))))
+}
+
+const production_dependency_graph = { names: production_names }
+
+export type { Lockfile }
+export { production_dependency_graph }

package/scripts/package/verify-optional-eslint-install.ts

@@ -0,0 +1,62 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { execaSync } from 'execa'
+
+const root = process.cwd()
+const scratch = mkdtempSync(path.join(os.tmpdir(), 'kit-eslint-install-'))
+const PACKAGE_JSON = 'package.json'
+const IGNORE_SCRIPTS = '--ignore-scripts'
+const manifest = JSON.parse(readFileSync(path.join(root, PACKAGE_JSON), 'utf8')) as {
+	devDependencies: Record<string, string>
+	peerDependencies: Record<string, string>
+}
+const eslint_peers = Object.keys(manifest.peerDependencies).filter((name) =>
+	/^(?:@eslint\/|@stylistic\/|eslint|globals$|typescript)/u.test(name),
+)
+
+try {
+	const { stdout } = execaSync(
+		'pnpm',
+		['pack', IGNORE_SCRIPTS, '--pack-destination', scratch, '--json'],
+		{ cwd: root },
+	)
+	const { filename } = JSON.parse(stdout) as { filename: string }
+	const probe = path.join(scratch, 'consumer.mjs')
+	const tarball = path.resolve(scratch, filename)
+
+	writeFileSync(
+		path.join(scratch, '.npmrc'),
+		'auto-install-peers=false\nstrict-peer-dependencies=true\n',
+	)
+	writeFileSync(path.join(scratch, PACKAGE_JSON), '{"private":true,"type":"module"}\n')
+	const peer_specs = eslint_peers.map((name) => {
+		const version = manifest.devDependencies[name]
+
+		if (version === undefined) throw new Error(`Missing development dependency for ${name}`)
+
+		return `${name}@${version}`
+	})
+
+	execaSync('pnpm', ['--dir', scratch, 'add', IGNORE_SCRIPTS, tarball, ...peer_specs], {
+		cwd: root,
+		stdio: 'inherit',
+	})
+	writeFileSync(path.join(scratch, '.gitignore'), '')
+	writeFileSync(
+		probe,
+		`import { create_vanilla_config } from '@joshuafolkken/kit/eslint/vanilla'
+import { ESLint } from 'eslint'
+const config = create_vanilla_config({ gitignore_path: new URL('./.gitignore', import.meta.url), tsconfig_root_dir: process.cwd() })
+const lint = new ESLint({ cwd: process.cwd(), overrideConfigFile: true, overrideConfig: config })
+const [result] = await lint.lintText('var foo = 1', { filePath: 'probe.js' })
+if (result.fatalErrorCount !== 0 || !result.messages.some((message) => message.ruleId === 'no-var')) process.exit(1)
+`,
+	)
+	execaSync(process.execPath, [probe], { cwd: scratch, stdio: 'inherit' })
+	console.info(
+		'Packed kit installs with explicit ESLint peers and its public config lints successfully.',
+	)
+} finally {
+	rmSync(scratch, { recursive: true, force: true })
+}

package/scripts/propagate/propagate-run.ts

@@ -13,6 +13,8 @@ import type { PropagateTarget } from './propagate-targets'
 const STEP_PRECHECK = 'working tree check'
 const STEP_UPGRADE = 'josh vu'
 const STEP_SYNC = 'josh sync'
+const STEP_LINT_RELATED = 'related lint check'
+const STEP_TEST_RELATED = 'related test check'
 const STEP_VERIFY = 'verification gate'
 const STEP_ISSUE = 'open issue'
 const STEP_PR = 'josh git'
@@ -23,6 +25,8 @@ const STEP_ORDER: ReadonlyArray<string> = [
 	STEP_PRECHECK,
 	STEP_UPGRADE,
 	STEP_SYNC,
+	STEP_LINT_RELATED,
+	STEP_TEST_RELATED,
 	STEP_VERIFY,
 	STEP_ISSUE,
 	STEP_PR,
@@ -187,6 +191,8 @@ const propagate_run = {
 	STEP_ISSUE,
 	STEP_UPGRADE,
 	STEP_SYNC,
+	STEP_LINT_RELATED,
+	STEP_TEST_RELATED,
 	STEP_VERIFY,
 	STEP_PR,
 	STEP_ORDER,

package/scripts/propagate/propagate-steps.ts

@@ -29,6 +29,8 @@ const VERIFY_SCRIPT = `pnpm josh ${GATE_COMMAND}`
 // The commands the release-independent spawning steps run inside the target's own directory. The
 // upgrade and the sync are not here: both are per toolkit, so they are built from the plan instead.
 const STEP_COMMANDS: Readonly<Record<string, ReadonlyArray<string>>> = {
+	[propagate_run.STEP_LINT_RELATED]: ['pnpm', 'josh', 'lint:related'],
+	[propagate_run.STEP_TEST_RELATED]: ['pnpm', 'josh', 'test:related'],
 	[propagate_run.STEP_VERIFY]: ['sh', '-c', VERIFY_SCRIPT],
 }
 

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

@@ -0,0 +1,11 @@
+import { execFileSync } from 'node:child_process'
+import { github_release } from './github-release'
+
+const token = process.env['GH_TOKEN']
+const tag = process.env['RELEASE_TAG']
+
+if (!token || !tag) throw new Error('GH_TOKEN and RELEASE_TAG are required')
+
+const tags = execFileSync('git', ['tag', '--list'], { encoding: 'utf8' }).trim().split('\n')
+
+console.info(await github_release.publish(fetch, token, tag, { tags }))

package/scripts/release/github-release.ts

@@ -0,0 +1,220 @@
+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 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'
+const POLL_INTERVAL_MS = 30_000
+const MAX_WAIT_ATTEMPTS = 120
+const RELEASE_SCHEMA = z.object({ tag_name: z.string().min(1) })
+const NOTES_SCHEMA = z.object({ name: z.string().min(1), body: z.string().min(1) })
+const RUN_SCHEMA = z.object({ id: z.number(), display_title: z.string() })
+const JOB_SCHEMA = z.object({
+	name: z.string(),
+	status: z.string(),
+	conclusion: z.string().nullable(),
+})
+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 {
+	tags?: ReadonlyArray<string>
+	wait?: Wait
+}
+
+function request_options(token: string, method: string, body?: object): RequestInit {
+	return {
+		method,
+		headers: {
+			Accept: 'application/vnd.github+json',
+			Authorization: `Bearer ${token}`,
+			'X-GitHub-Api-Version': '2022-11-28',
+		},
+		...(body !== undefined && { body: JSON.stringify(body) }),
+		signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+	}
+}
+
+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'),
+	)
+	if (response.status === NOT_FOUND_STATUS) return false
+
+	RELEASE_SCHEMA.parse(await read_response(response))
+
+	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))
+
+	return release.tag_name
+}
+
+function predecessor(tags: ReadonlyArray<string>, target: string): string | undefined {
+	return tags
+		.filter(
+			(tag) => semver.valid(tag) && semver.gt(tag, AUTOMATION_START_TAG) && 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
+
+	return PREREQUISITES.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(
+	request: ReleaseRequest,
+	token: string,
+	tag: string,
+): Promise<boolean> {
+	const runs_response = await request(WORKFLOW_RUNS_URL, request_options(token, 'GET'))
+	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'))
+
+	return publication_failed(JOBS_SCHEMA.parse(await read_response(jobs_response)).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'
+
+	return 'pending'
+}
+
+async function wait_for_release(
+	request: ReleaseRequest,
+	token: string,
+	tag: string,
+	wait: Wait,
+): Promise<boolean> {
+	for (let attempt = 0; attempt < MAX_WAIT_ATTEMPTS; attempt += 1) {
+		const state = await release_state(request, token, tag)
+		if (state !== 'pending') return state === 'ready'
+
+		await wait()
+	}
+
+	throw new Error(`Timed out waiting for previous GitHub Release ${tag}`)
+}
+
+async function baseline_tag(
+	request: ReleaseRequest,
+	token: string,
+	tag: string,
+	options: PublishOptions,
+): Promise<string> {
+	const prior = predecessor(options.tags ?? [], tag)
+	if (!prior) return await previous_tag(request, token)
+
+	if (!(await wait_for_release(request, token, prior, options.wait ?? default_wait))) {
+		return await baseline_tag(request, token, prior, options)
+	}
+
+	return prior
+}
+
+async function generate_notes(
+	request: ReleaseRequest,
+	token: string,
+	tag: string,
+	previous: string,
+): 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',
+		}),
+	)
+
+	return NOTES_SCHEMA.parse(await read_response(response))
+}
+
+async function create_release(
+	request: ReleaseRequest,
+	token: string,
+	tag: string,
+	previous: string,
+): 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,
+		}),
+	)
+
+	RELEASE_SCHEMA.parse(await read_response(response))
+}
+
+async function publish(
+	request: ReleaseRequest,
+	token: string,
+	tag: string,
+	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)
+
+	if (!semver.lt(previous, tag)) {
+		throw new Error(`Latest release ${previous} is not older than ${tag}`)
+	}
+
+	await create_release(request, token, tag, previous)
+
+	return `published ${tag} from ${previous}`
+}
+
+const github_release = { publish }
+
+export { github_release }

package/scripts/release/publish-tag-cli.ts

@@ -0,0 +1,8 @@
+import { publish_tag } from './publish-tag'
+
+const ARGUMENT_START = 2
+const [version, latest] = process.argv.slice(ARGUMENT_START)
+
+if (!version || !latest) throw new Error('Package version and current latest are required')
+
+console.info(publish_tag(version, latest))

package/scripts/release/publish-tag.ts

@@ -0,0 +1,11 @@
+import semver from 'semver'
+
+function publish_tag(version: string, latest: string): string {
+	if (!semver.valid(version) || !semver.valid(latest)) {
+		throw new Error('Both package versions must be valid semantic versions')
+	}
+
+	return semver.gt(version, latest) ? 'latest' : 'backfill'
+}
+
+export { publish_tag }

package/scripts/release/release-publish.ts

@@ -19,6 +19,7 @@ import { release_worktree } from './release-worktree'
 const { PACKAGE_JSON } = version_targets
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
+const IGNORE_FOR_RELEASE_LABEL = 'ignore-for-release'
 
 function branch_name_for(version: string): string {
 	return `release/v${version}`
@@ -96,9 +97,13 @@ async function commit_release(plan: ReleasePlan): Promise<void> {
 	await git_command.add_path(PACKAGE_JSON)
 	await git_command.commit(commit_message(plan.next_version))
 	await git_command.push()
-	console.info(
-		await git_gh_command.pr_create(commit_message(plan.next_version), pull_request_body(plan)),
+	const pr_url = await git_gh_command.pr_create(
+		commit_message(plan.next_version),
+		pull_request_body(plan),
+		IGNORE_FOR_RELEASE_LABEL,
 	)
+
+	console.info(pr_url)
 }
 
 async function merge_and_tag(plan: ReleasePlan, branch_name: string): Promise<number> {

package/scripts/rules/delivered-rules.ts

@@ -9,6 +9,7 @@ import { filing_cap } from './filing-cap'
 import { gh_api } from './gh-api'
 import { git_force } from './git-force'
 import { implementation_cut } from './implementation-cut'
+import { issue_bug_label_rule } from './issue-bug-label'
 import { issue_fold } from './issue-fold'
 import { issue_scout } from './issue-scout'
 import { josh_git_bare } from './josh-git-bare'
@@ -536,6 +537,7 @@ const DELIVERED_RULES: ReadonlyArray<DeliveredRule> = [
 	// `issue-fold` have each had their turn. The non-overlapping firing point (`pkg:scout` on a package
 	// add) claims a command no row above matches.
 	...oracle_consulted.ROWS,
+	issue_bug_label_rule.ROW,
 ]
 
 // A turn that issued more than this many calls is a turn that batched. The guard counts turns that

package/scripts/rules/issue-bug-label.ts

@@ -0,0 +1,85 @@
+import { readFileSync } from 'node:fs'
+import path from 'node:path'
+import { issue_classification } from '#scripts/issue/issue-classification'
+import type { GuardRun } from '#scripts/josh/hook-decision'
+import { time_density_hook } from '#scripts/time-runtime/time-density-hook'
+import { time_shell } from '#scripts/time-runtime/time-shell'
+import { bash_triggers } from './bash-triggers'
+import { issue_filing_args } from './issue-filing-args'
+import { shell_segments } from './shell-segments'
+import { tail_commands } from './tail-commands'
+
+const LINT_NAMES = new Set(['issue:lint'])
+const LINT_PATH = /\b(?:issue:lint|iln)\s+(?:'([^']+)'|"([^"]+)"|(\S+))/u
+
+function lint_argument(segment: string): string | undefined {
+	const [, single_quoted, double_quoted, bare] = LINT_PATH.exec(segment) ?? []
+
+	return single_quoted ?? double_quoted ?? bare
+}
+
+function latest_lint_path(tail: string): string | undefined {
+	const segments = tail_commands
+		.prior_bash_commands(tail)
+		.flatMap((command) => shell_segments.segments_of(command))
+	const lint = segments.findLast((segment) => shell_segments.is_josh_command(segment, LINT_NAMES))
+
+	return lint === undefined ? undefined : lint_argument(lint)
+}
+
+function linted_body(body_path: string): string | undefined {
+	try {
+		return readFileSync(body_path, 'utf8')
+	} catch {
+		return undefined
+	}
+}
+
+function matches_linted_file(command: string, lint_path: string): boolean {
+	const filing_path = issue_filing_args.body_file(command)
+
+	return filing_path !== undefined && path.resolve(filing_path) === path.resolve(lint_path)
+}
+
+function needs_classification_labels(command: string, tail: string): boolean {
+	const lint_path = latest_lint_path(tail)
+
+	if (lint_path === undefined) return false
+	const body = linted_body(lint_path)
+
+	if (body === undefined) return false
+
+	if (!matches_linted_file(command, lint_path) || issue_classification.problems(body).length > 0) {
+		return true
+	}
+
+	const expected = issue_classification.required_labels(body)
+
+	return issue_classification.CLASSIFICATION_LABELS.some(
+		(label) => expected.includes(label) !== issue_filing_args.has_label(command, label),
+	)
+}
+
+function decide(call: { input: unknown }, run: GuardRun): boolean {
+	const command = time_shell.bash_command(call.input)
+	const tail = time_density_hook.read_tail(run.transcript)
+
+	return needs_classification_labels(command, tail)
+}
+
+const ISSUE_CLASSIFICATION_REASON =
+	'⛔ issue classification mismatch: use the exact body file checked by `pnpm josh issue:lint` ' +
+	'in this creation call (`-F body=@<path>` or `gh issue create --body-file <path>`) and ' +
+	'apply exactly the `labels:` it reports (`bug`, `enhancement`, `breaking-change`). See ' +
+	'`prompts/collaboration-workflow/issue-template.md`.'
+
+const ROW = {
+	id: 'issue-bug-label',
+	is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
+	reason: ISSUE_CLASSIFICATION_REASON,
+	decide,
+}
+
+const issue_bug_label_rule = { ROW, latest_lint_path, needs_classification_labels }
+
+export { issue_bug_label_rule }

package/scripts/rules/issue-filing-args.ts

@@ -0,0 +1,50 @@
+const SHELL_WORD = /(?:[^\s'"]|'[^']*'|"[^"]*")+/gu
+const QUOTE = /['"]/gu
+const RAW_FIELDS = new Set(['-f', '--raw-field'])
+const FILE_FIELDS = new Set(['-F', '--field'])
+const LABEL_OPTIONS = new Set(['-l', '--label'])
+const BODY_FILE_OPTIONS = new Set(['--body-file'])
+const INLINE_BODY_OPTIONS = new Set(['-b', '--body'])
+const BODY_FILE_PREFIX = 'body=@'
+
+function words_of(command: string): Array<string> {
+	return [...command.matchAll(SHELL_WORD)].map((match) => match[0].replaceAll(QUOTE, ''))
+}
+
+function values_after(words: ReadonlyArray<string>, flags: ReadonlySet<string>): Array<string> {
+	return words.flatMap((word, index) => {
+		const value = words[index + 1]
+
+		return value !== undefined && flags.has(word) ? [value] : []
+	})
+}
+
+function has_inline_body(words: ReadonlyArray<string>): boolean {
+	const has_raw = values_after(words, RAW_FIELDS).some((value) => value.startsWith('body='))
+
+	return has_raw || values_after(words, INLINE_BODY_OPTIONS).length > 0
+}
+
+function body_file(command: string): string | undefined {
+	const words = words_of(command)
+	const fields = values_after(words, FILE_FIELDS).filter((value) => value.startsWith('body='))
+	const options = values_after(words, BODY_FILE_OPTIONS)
+
+	if (has_inline_body(words) || fields.length + options.length !== 1) return undefined
+
+	return fields[0]?.startsWith(BODY_FILE_PREFIX)
+		? fields[0].slice(BODY_FILE_PREFIX.length)
+		: options[0]
+}
+
+function has_label(command: string, label: string): boolean {
+	const words = words_of(command)
+	const fields = [...values_after(words, RAW_FIELDS), ...values_after(words, FILE_FIELDS)]
+	const options = values_after(words, LABEL_OPTIONS).flatMap((value) => value.split(','))
+
+	return fields.includes(`labels[]=${label}`) || options.includes(label)
+}
+
+const issue_filing_args = { body_file, has_label, words_of }
+
+export { issue_filing_args }