@joshuafolkken/kit 1.1471.0 → 1.1784.0

package/scripts/issue/defect-report-cli.ts

@@ -0,0 +1,128 @@
+import { FULL_PAGE_QUERY, git_gh_api_path } from '#scripts/gh/git-gh-api-path'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { git_gh_exec } from '#scripts/gh/git-gh-exec'
+import { parse_json } from '#scripts/git/parse-json-array'
+import { bounded_pool } from '#scripts/lib/bounded-pool'
+import { z } from 'zod'
+import { defect_report, type OriginPr, type ReportIssue } from './defect-report'
+import { defect_report_format } from './defect-report-format'
+import { session_cite } from './session-cite'
+
+const SUCCESS_EXIT_CODE = 0
+const FAILURE_EXIT_CODE = 1
+const PR_CONCURRENCY = 4
+const USAGE = 'Usage: pnpm josh defect:report'
+const UNREADABLE_MESSAGE =
+	'Could not read the bug issues from GitHub, so no report is printed — check `gh auth status`.'
+
+const issue_schema = z.object({
+	number: z.number(),
+	created_at: z.string(),
+	body: z.string().nullish(),
+	pull_request: z.unknown().optional(),
+})
+const pull_schema = z.object({ merged_at: z.string().nullish() })
+const file_schema = z.object({
+	filename: z.string(),
+	status: z.string(),
+	additions: z.number(),
+	deletions: z.number(),
+})
+
+// Every issue labelled `bug`, open or closed — the label `issue:file` derives from the declaration.
+// The issues listing carries pull requests too, so those are dropped.
+async function read_issues(repo: string): Promise<ReadonlyArray<ReportIssue> | undefined> {
+	const raw = await git_gh_exec.exec_gh_api({
+		path: `repos/${repo}/issues?labels=bug&state=all&per_page=100`,
+		should_paginate: true,
+	})
+	const issues = parse_json.parse_json_object_or_undefined(raw, z.array(issue_schema))
+
+	return issues
+		?.filter((issue) => issue.pull_request === undefined)
+		.map((issue) => ({
+			number: issue.number,
+			created_at: issue.created_at,
+			body: issue.body ?? '',
+		}))
+}
+
+async function read_pr(repo: string, pr: number): Promise<OriginPr | undefined> {
+	const path = git_gh_api_path.pull_api_path(String(pr), repo)
+	const [pull_raw, files_raw] = await Promise.all([
+		git_gh_exec.exec_gh_api({ path }),
+		git_gh_exec.exec_gh_api({ path: `${path}/files${FULL_PAGE_QUERY}`, should_paginate: true }),
+	])
+	const pull = parse_json.parse_json_object_or_undefined(pull_raw, pull_schema)
+	const files = parse_json.parse_json_object_or_undefined(files_raw, z.array(file_schema))
+
+	if (pull === undefined || files === undefined) return undefined
+
+	return {
+		pr,
+		merged_at: pull.merged_at ?? '',
+		kind: defect_report.change_kind(files),
+		areas: defect_report.areas(files),
+	}
+}
+
+// A pull request that cannot be read contributes nothing, and the report counts it as unread.
+async function read_pr_or_none(repo: string, pr: number): Promise<ReadonlyArray<OriginPr>> {
+	try {
+		const origin = await read_pr(repo, pr)
+
+		return origin === undefined ? [] : [origin]
+	} catch {
+		return []
+	}
+}
+
+async function read_prs(repo: string, prs: ReadonlyArray<number>): Promise<Map<number, OriginPr>> {
+	const read = await bounded_pool.bounded_map(
+		prs,
+		PR_CONCURRENCY,
+		async (pr) => await read_pr_or_none(repo, pr),
+	)
+
+	return new Map(read.flat().map((origin) => [origin.pr, origin]))
+}
+
+function unreadable(): number {
+	console.error(UNREADABLE_MESSAGE)
+
+	return FAILURE_EXIT_CODE
+}
+
+async function report(repo: string): Promise<number> {
+	const issues = await read_issues(repo)
+
+	if (issues === undefined) return unreadable()
+
+	const prs = await read_prs(repo, defect_report.origin_prs(issues))
+
+	const aggregated = defect_report.aggregate(issues, prs)
+
+	console.info(session_cite.text(defect_report_format.format(aggregated)))
+
+	return SUCCESS_EXIT_CODE
+}
+
+async function run(argv: ReadonlyArray<string>): Promise<number> {
+	if (argv.length > 0) {
+		console.error(USAGE)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	try {
+		const repo = await git_gh_command.repo_get_name_with_owner()
+
+		return repo === undefined ? unreadable() : await report(repo)
+	} catch {
+		return unreadable()
+	}
+}
+
+const defect_report_cli = { run }
+
+export { defect_report_cli }

package/scripts/issue/defect-report-format.ts

@@ -0,0 +1,56 @@
+import { defect_report, type DefectReport } from './defect-report'
+import { issue_cite } from './issue-cite'
+
+// The printed `defect:report`: each grouping as a table of counts, largest first.
+
+const INDENT = '  '
+const NONE = `${INDENT}(none)`
+
+function sorted_rows<K>(counts: ReadonlyMap<K, number>, label: (key: K) => string): Array<string> {
+	return [...counts]
+		.toSorted((left, right) => right[1] - left[1])
+		.map(([key, count]) => `${INDENT}${label(key)}  ${String(count)}`)
+}
+
+function section<K>(
+	title: string,
+	counts: ReadonlyMap<K, number>,
+	label: (key: K) => string,
+): Array<string> {
+	const rows = sorted_rows(counts, label)
+
+	return [title, ...(rows.length === 0 ? [NONE] : rows)]
+}
+
+function pr_label(pr: number): string {
+	return issue_cite.plain(pr)
+}
+
+function summary(report: DefectReport): string {
+	let traced = 0
+
+	for (const count of report.by_pr.values()) traced += count
+	const parts = [
+		`traced to a pull request: ${String(traced)}`,
+		`不明: ${String(report.unknown)}`,
+		`no origin line: ${String(report.undeclared)}`,
+	]
+
+	return `defects by origin — ${parts.join(' · ')}`
+}
+
+function format(report: DefectReport): string {
+	const week = `pull requests that added a mechanism — defects filed within ${String(defect_report.WEEK_DAYS)} days of the merge:`
+
+	return [
+		summary(report),
+		...section('by pull request:', report.by_pr, pr_label),
+		...section('by change kind (add / fix / remove):', report.by_kind, String),
+		...section('by area:', report.by_area, String),
+		...section(week, report.added_within_week, pr_label),
+	].join('\n')
+}
+
+const defect_report_format = { format }
+
+export { defect_report_format }

package/scripts/issue/defect-report-main.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { defect_report_cli } from './defect-report-cli'
+
+// The `josh defect:report` entry, kept apart from `defect-report-cli.ts` so a bundle carrying that
+// module never fires this guard (joshuafolkken/kit#4186).
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	const ARGV_OFFSET = 2
+
+	process.exitCode = await defect_report_cli.run(process.argv.slice(ARGV_OFFSET))
+}

package/scripts/issue/defect-report.ts

@@ -0,0 +1,160 @@
+import { defect_origin_line } from './defect-origin-line'
+
+// Defects grouped by the pull request each one's origin line names: how many per pull request, per
+// change kind, and per area of the tree it touched, plus how many each pull request that added a
+// mechanism drew within a week of merging. Read from the bodies and the pull requests' files only,
+// so nothing here asks for a judgement.
+
+const WEEK_DAYS = 7
+const MS_PER_DAY = 86_400_000
+const WEEK_MS = WEEK_DAYS * MS_PER_DAY
+const SCRIPTS_ROOT = 'scripts'
+// `scripts/<dir>` — the two leading segments of a path under `scripts/`.
+const SCRIPT_AREA_DEPTH = 2
+const ROOT_AREA = '(root)'
+const UNREAD_AREA = '(pull request not read)'
+const TEST_FILE = /\.(?:test|e2e)\.ts$|\.snap$/u
+// The run's own records — observations, accepted metrics — which nearly every merge adds, so they
+// say nothing about what the pull request changed.
+const RUN_RECORD_ROOT = '.josh/'
+
+type ChangeKind = 'add' | 'fix' | 'remove'
+
+interface ReportIssue {
+	number: number
+	created_at: string
+	body: string
+}
+
+interface PrFile {
+	filename: string
+	status: string
+	additions: number
+	deletions: number
+}
+
+interface OriginPr {
+	pr: number
+	merged_at: string
+	kind: ChangeKind
+	areas: ReadonlyArray<string>
+}
+
+interface Attributed {
+	issue: ReportIssue
+	pr: number
+}
+
+interface DefectReport {
+	by_pr: ReadonlyMap<number, number>
+	by_kind: ReadonlyMap<string, number>
+	by_area: ReadonlyMap<string, number>
+	unknown: number
+	undeclared: number
+	added_within_week: ReadonlyMap<number, number>
+}
+
+function changed(files: ReadonlyArray<PrFile>): ReadonlyArray<PrFile> {
+	return files.filter((file) => !file.filename.startsWith(RUN_RECORD_ROOT))
+}
+
+// A pull request that brought in a new non-test file added a mechanism; one that took out more than it
+// put in removed; anything else changed what was there.
+function change_kind(files: ReadonlyArray<PrFile>): ChangeKind {
+	const source = changed(files).filter((file) => !TEST_FILE.test(file.filename))
+
+	if (source.some((file) => file.status === 'added')) return 'add'
+
+	const added = source.reduce((sum, file) => sum + file.additions, 0)
+	const removed = source.reduce((sum, file) => sum + file.deletions, 0)
+
+	return removed > added ? 'remove' : 'fix'
+}
+
+// `scripts/<dir>` for a script, the top-level directory otherwise, and one bucket for root files.
+function area_of(filename: string): string {
+	const segments = filename.split('/')
+
+	if (segments.length === 1) return ROOT_AREA
+
+	const is_script = segments[0] === SCRIPTS_ROOT && segments.length > SCRIPT_AREA_DEPTH
+	const depth = is_script ? SCRIPT_AREA_DEPTH : 1
+
+	return segments.slice(0, depth).join('/')
+}
+
+function areas(files: ReadonlyArray<PrFile>): ReadonlyArray<string> {
+	return [...new Set(changed(files).map((file) => area_of(file.filename)))]
+}
+
+function increment<K>(counts: Map<K, number>, key: K): void {
+	counts.set(key, (counts.get(key) ?? 0) + 1)
+}
+
+function count_by<K>(
+	items: ReadonlyArray<Attributed>,
+	keys: (item: Attributed) => ReadonlyArray<K>,
+): Map<K, number> {
+	const counts = new Map<K, number>()
+
+	for (const item of items) for (const key of keys(item)) increment(counts, key)
+
+	return counts
+}
+
+function within_week(issue: ReportIssue, origin: OriginPr): boolean {
+	const elapsed = Date.parse(issue.created_at) - Date.parse(origin.merged_at)
+
+	return elapsed >= 0 && elapsed <= WEEK_MS
+}
+
+function attribute(issue: ReportIssue): Attributed | undefined {
+	const origin = defect_origin_line.parse(issue.body)
+
+	return origin?.kind === 'pr' ? { issue, pr: origin.pr } : undefined
+}
+
+function attributed(issues: ReadonlyArray<ReportIssue>): ReadonlyArray<Attributed> {
+	return issues.map((issue) => attribute(issue)).filter((item) => item !== undefined)
+}
+
+// Every pull request an origin line names, once — what the report has to read.
+function origin_prs(issues: ReadonlyArray<ReportIssue>): ReadonlyArray<number> {
+	return [...new Set(attributed(issues).map(({ pr }) => pr))]
+}
+
+function soon_after_adding(
+	items: ReadonlyArray<Attributed>,
+	prs: ReadonlyMap<number, OriginPr>,
+): Map<number, number> {
+	return count_by(items, ({ issue, pr }) => {
+		const origin = prs.get(pr)
+
+		return origin?.kind === 'add' && within_week(issue, origin) ? [pr] : []
+	})
+}
+
+function count_origins(issues: ReadonlyArray<ReportIssue>, kind: 'unknown' | undefined): number {
+	return issues.filter((issue) => defect_origin_line.parse(issue.body)?.kind === kind).length
+}
+
+function aggregate(
+	issues: ReadonlyArray<ReportIssue>,
+	prs: ReadonlyMap<number, OriginPr>,
+): DefectReport {
+	const items = attributed(issues)
+
+	return {
+		by_pr: count_by(items, ({ pr }) => [pr]),
+		by_kind: count_by(items, ({ pr }) => [prs.get(pr)?.kind ?? UNREAD_AREA]),
+		by_area: count_by(items, ({ pr }) => prs.get(pr)?.areas ?? [UNREAD_AREA]),
+		unknown: count_origins(issues, 'unknown'),
+		undeclared: count_origins(issues, undefined),
+		added_within_week: soon_after_adding(items, prs),
+	}
+}
+
+const defect_report = { aggregate, area_of, areas, change_kind, origin_prs, WEEK_DAYS }
+
+export type { ChangeKind, DefectReport, OriginPr, PrFile, ReportIssue }
+export { defect_report }

package/scripts/issue/expected-effect-lint.ts

@@ -0,0 +1,60 @@
+import { markdown_section } from './markdown-section'
+
+// joshuafolkken/kit#3909: a run-time-shortening proposal was filed and implemented on a criterion that
+// never weighed how often the speed-up applies against what it costs when it does not. An Issue that
+// declares that aim must therefore state its expected effect — the hit rate, the gain per hit, the loss
+// per miss and where each number came from — before `issue:lint` and `issue:file` accept it. The
+// declaration, the heading and the item labels are the template's, pinned by the document test.
+
+const DECLARATION_LINE = '- 目的: 時間短縮'
+const BACKGROUND_HEADING = '## 背景'
+const HEADING = '## 期待効果'
+const ITEM_LABELS: ReadonlyArray<string> = ['効く率', '1 回あたりの得', '外れたときの損', '出典']
+// A template placeholder value — the `<...>` guidance a filed Issue replaces. It is not an estimate, but a
+// value that only opens with `<` (an upper bound such as `<1 min`) is one, so the placeholder must close with `>` too.
+const PLACEHOLDER = /^<.*>$/u
+
+// Whether the body declares a run-time-shortening aim under its background heading.
+function is_target(body: string): boolean {
+	const background = markdown_section.section_lines(body, BACKGROUND_HEADING).join('\n')
+
+	return markdown_section.has_unfenced_line(background, DECLARATION_LINE)
+}
+
+function item_value(line: string, label: string): string | undefined {
+	const prefix = `- ${label}:`
+
+	if (!line.startsWith(prefix)) return undefined
+
+	return line.slice(prefix.length).trim()
+}
+
+function has_item(lines: ReadonlyArray<string>, label: string): boolean {
+	return lines.some((line) => {
+		const value = item_value(line.trim(), label)
+
+		return value !== undefined && value.length > 0 && !PLACEHOLDER.test(value)
+	})
+}
+
+// Every expected-effect problem a body has, or an empty array. A body without the declaration has none.
+function problems(body: string): ReadonlyArray<string> {
+	if (!is_target(body)) return []
+	if (!markdown_section.has_line(body, HEADING)) return [`missing heading: ${HEADING}`]
+	const section = markdown_section.section_lines(body, HEADING).join('\n')
+	const lines = markdown_section.unfenced_lines(section)
+
+	return ITEM_LABELS.filter((label) => !has_item(lines, label)).map(
+		(label) => `missing expected-effect item: - ${label}: <value>`,
+	)
+}
+
+const expected_effect_lint = {
+	DECLARATION_LINE,
+	HEADING,
+	ITEM_LABELS,
+	is_target,
+	problems,
+}
+
+export { expected_effect_lint }

package/scripts/issue/issue-already-done-cli.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { issue_evidence_exit } from '#scripts/issue/issue-evidence-exit'
+import { ALREADY_DONE_LABEL } from '#scripts/issue/issue-labels'
+import { issue_sample_gate } from '#scripts/issue/issue-sample-gate'
+import { session_cite } from '#scripts/issue/session-cite'
+
+// `josh issue:already-done <N> --evidence-file <path>` — the exit for an Issue whose work is already
+// merged (`issue-comments.md` → "When the work turns out to be already merged"): the evidence
+// comment, the `already-done` label and the `run:release`, in that order (`issue-evidence-exit.ts`).
+//
+// The label is provisioned by `josh start`, so nothing here creates it.
+// **The Issue is never closed**: closing is a person's (Tier C), and the label is the run's exit.
+//
+// **A follow-up measurement is refused before anything is written** (joshuafolkken/kit#4504): its body
+// declares the sample wait (`issue_sample_gate.DECLARATION`, read as `not-before` reads it), and its
+// exit is `josh issue:measured`, which closes it — this one would leave it OPEN and the lane parked.
+
+const ARGV_OFFSET = 2
+
+function refusal_of(issue_number: string, body: string | undefined): string | undefined {
+	const cite = session_cite.issue(issue_number)
+	if (body === undefined) return `Issue ${cite} body not read; nothing written`
+	if (issue_sample_gate.cited_number(body) === undefined) return undefined
+
+	return `Issue ${cite} is a follow-up measurement (\`${issue_sample_gate.DECLARATION}\`): run \`josh issue:measured ${issue_number} --evidence-file <path>\` instead; nothing written`
+}
+
+async function admit(issue_number: string): Promise<boolean> {
+	const refusal = refusal_of(issue_number, await git_gh_command.issue_get_body(issue_number))
+
+	if (refusal !== undefined) console.error(refusal)
+
+	return refusal === undefined
+}
+
+async function apply_label(issue_number: string): Promise<boolean> {
+	const write = await git_gh_command.issue_apply_label(issue_number, ALREADY_DONE_LABEL)
+
+	if (!write.is_applied) console.error(`${ALREADY_DONE_LABEL} not applied: ${write.reason}`)
+
+	return write.is_applied
+}
+
+async function run(argv: ReadonlyArray<string>): Promise<number> {
+	return await issue_evidence_exit.run(argv, {
+		command: 'issue:already-done',
+		finish: apply_label,
+		admit,
+	})
+}
+
+async function main(argv: ReadonlyArray<string>): Promise<void> {
+	process.exitCode = await run(argv)
+}
+
+const issue_already_done_cli = { run }
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
+
+export { issue_already_done_cli }

package/scripts/issue/issue-body-or-comment.ts

@@ -0,0 +1,40 @@
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+
+// One text written to an issue: **into the body when the body is blank, as a comment otherwise.**
+// Two writers make this decision — `followup`'s completion notice and `issue:plan`'s plan — and a copy
+// per caller is how the two would come to disagree about what "blank" means.
+//
+// A body that could not be read is not blank: overwriting a body nobody saw could erase a person's
+// text, so an unreadable body falls to a comment, which loses nothing.
+
+type Destination = 'body' | 'comment'
+
+interface PostOutcome {
+	destination: Destination
+	url: string
+}
+
+function is_blank_body(body: string | undefined): boolean {
+	return body?.trim().length === 0
+}
+
+// `repo` (`owner/name`) addresses an issue in another repository; left out, the checkout's own.
+async function post(issue_number: string, text: string, repo?: string): Promise<PostOutcome> {
+	const current_body = await git_gh_command.issue_get_body(issue_number, repo)
+
+	if (is_blank_body(current_body)) {
+		const url = await git_gh_command.issue_edit_body(issue_number, text, repo)
+
+		return { destination: 'body', url }
+	}
+
+	return {
+		destination: 'comment',
+		url: await git_gh_command.issue_comment(issue_number, text, repo),
+	}
+}
+
+const issue_body_or_comment = { post }
+
+export { issue_body_or_comment }
+export type { Destination, PostOutcome }

package/scripts/issue/issue-cite-cli.ts

@@ -1,5 +1,3 @@
-#!/usr/bin/env tsx
-import { fileURLToPath } from 'node:url'
 import { git_gh_command } from '#scripts/gh/git-gh-command'
 import type { IssueRead } from '#scripts/gh/git-gh-issue-read'
 import { bounded_pool } from '#scripts/lib/bounded-pool'
@@ -24,7 +22,6 @@ import { issue_cite, type CiteTarget } from './issue-cite'
 
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
-const ARGV_OFFSET = 2
 // The same bound `issue:read` puts on its batch read: every read is a `gh` process, and an unbounded
 // fan-out is answered with secondary rate limiting rather than with titles.
 const READ_CONCURRENCY = 8
@@ -101,16 +98,26 @@ async function local_slug_for(targets: ReadonlyArray<CiteTarget>): Promise<strin
 	return has_bare_target ? await git_gh_command.repo_get_name_with_owner() : undefined
 }
 
+// The citation lines and the failure lines of one invocation, apart.
+interface CiteReport {
+	lines: ReadonlyArray<string>
+	failures: ReadonlyArray<string>
+}
+
+function split_results(results: ReadonlyArray<LineResult>): CiteReport {
+	return {
+		lines: results.filter((result) => result.kind === 'ok').map((result) => result.line),
+		failures: results.filter((result) => result.kind === 'fail').map((result) => result.line),
+	}
+}
+
 // Citations to stdout so the block stays paste-ready; failures to stderr so each unanswered number is
 // named without landing in what gets pasted. A failure sets a non-zero exit.
-function report(results: ReadonlyArray<LineResult>): number {
-	const lines = results.filter((result) => result.kind === 'ok').map((result) => result.line)
-	const failures = results.filter((result) => result.kind === 'fail').map((result) => result.line)
+function report(cited: CiteReport): number {
+	if (cited.lines.length > 0) console.info(cited.lines.join(LINE_SEPARATOR))
+	for (const failure of cited.failures) console.error(failure)
 
-	if (lines.length > 0) console.info(lines.join(LINE_SEPARATOR))
-	for (const failure of failures) console.error(failure)
-
-	return failures.length === 0 ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE
+	return cited.failures.length === 0 ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE
 }
 
 // The targets the command line names, or `undefined` for a line nobody can read — an unknown flag and
@@ -122,14 +129,11 @@ function read_targets(args: ReadonlyArray<string>): ReadonlyArray<CiteTarget> |
 	return parse_targets(parsed.positionals, parsed.values.repo)
 }
 
-async function run(args: ReadonlyArray<string>): Promise<number> {
+// The lines `issue:cite` prints for `args`, without printing them — the `Stop` hook shows them itself
+// (`stop-actions.ts`). `undefined` for a line nobody can read.
+async function cite(args: ReadonlyArray<string>): Promise<CiteReport | undefined> {
 	const targets = read_targets(args)
-
-	if (targets === undefined) {
-		console.error(USAGE)
-
-		return FAILURE_EXIT_CODE
-	}
+	if (targets === undefined) return undefined
 
 	const local_slug = await local_slug_for(targets)
 	const results = await bounded_pool.bounded_map(
@@ -138,19 +142,26 @@ async function run(args: ReadonlyArray<string>): Promise<number> {
 		async (target) => await cite_target(target, local_slug),
 	)
 
-	return report(results)
+	return split_results(results)
 }
 
-async function main(args: ReadonlyArray<string>): Promise<void> {
-	process.exitCode = await run(args)
+async function run(args: ReadonlyArray<string>): Promise<number> {
+	const cited = await cite(args)
+
+	if (cited === undefined) {
+		console.error(USAGE)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	return report(cited)
 }
 
 const issue_cite_cli = {
 	USAGE,
+	cite,
 	parse_targets,
 	run,
 }
 
-if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
-
 export { issue_cite_cli }

package/scripts/issue/issue-cite-main.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { issue_cite_cli } from './issue-cite-cli'
+
+// The `josh issue:cite` entry, kept apart from `issue-cite-cli.ts` because other modules import that
+// one: a bundle is one file, so a main guard there would fire for every command that carries it
+// (joshuafolkken/kit#4186).
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	const ARGV_OFFSET = 2
+
+	process.exitCode = await issue_cite_cli.run(process.argv.slice(ARGV_OFFSET))
+}

package/scripts/issue/issue-classification.ts

@@ -1,8 +1,9 @@
+import { defect_origin_line } from './defect-origin-line'
 import { issue_bug_label } from './issue-bug-label'
 import { BREAKING_CHANGE_LABEL, BUG_LABEL, ENHANCEMENT_LABEL, has_label_name } from './issue-labels'
 import { markdown_section } from './markdown-section'
 
-const FEATURE_DECLARATIONS = ['- 目的: 機能追加', '- 目的: 機能改善']
+const FEATURE_DECLARATIONS = ['- 目的: 機能追加', '- 目的: 機能改善', '- 目的: 時間短縮']
 const BREAKING_DECLARATION = '- 互換性: 破壊的変更'
 const NON_BUG_DECLARATION = '- 種別: 非不具合'
 const CLASSIFICATION_LABELS = [BUG_LABEL, ENHANCEMENT_LABEL, BREAKING_CHANGE_LABEL]
@@ -44,16 +45,20 @@ function bug_classification_problem(body: string): string | undefined {
 	return undefined
 }
 
-function problems(body: string): ReadonlyArray<string> {
-	const classification_problem = bug_classification_problem(body)
-	const found: Array<string> = []
-
-	if (classification_problem !== undefined) found.push(classification_problem)
+function label_conflict(body: string): string | undefined {
 	const labels = required_labels(body)
 
-	if (labels.includes(BUG_LABEL) && labels.includes(ENHANCEMENT_LABEL)) found.push(CONFLICT)
+	return labels.includes(BUG_LABEL) && labels.includes(ENHANCEMENT_LABEL) ? CONFLICT : undefined
+}
+
+function problems(body: string): ReadonlyArray<string> {
+	const found = [
+		bug_classification_problem(body),
+		label_conflict(body),
+		defect_origin_line.problem(body),
+	]
 
-	return found
+	return found.filter((problem) => problem !== undefined)
 }
 
 const issue_classification = {