@joshuafolkken/kit 1.1035.0 → 1.1094.0

package/scripts/{git → gh}/git-pr-checks-eval.ts

@@ -240,17 +240,7 @@ function is_auto_merge_blocked(snapshot: PrStateSnapshot): boolean {
 	)
 }
 
-const git_pr_checks_eval = {
-	evaluate_pr_state,
-	is_review_decision_decisive,
-	read_required_statuses,
-	is_coderabbit_check,
-	collect_blocking_failures,
-	describe_pr_failure,
-}
-
 export {
-	git_pr_checks_eval,
 	evaluate_pr_state,
 	is_auto_merge_blocked,
 	is_review_decision_decisive,

package/scripts/{git → gh}/git-pr-checks-parse.ts

@@ -1,4 +1,5 @@
-import { pr_raw_schema, type RollupItemData } from './schemas'
+import { pr_raw_schema, type RollupItemData } from '#scripts/git/schemas'
+import { json_value } from '#scripts/lib/json-value'
 
 const CHECK_STATUS_PASS = 'pass'
 const CHECK_STATUS_PENDING = 'pending'
@@ -92,14 +93,6 @@ function read_rollup_array(parsed: unknown): Array<RollupItemData> {
 	return result.data.statusCheckRollup ?? []
 }
 
-function parse_json_safe(raw_json: string): unknown {
-	try {
-		return JSON.parse(raw_json)
-	} catch {
-		return undefined
-	}
-}
-
 function parse_rollup_item(item: RollupItemData): RollupCheck | undefined {
 	const name = read_string(item[KEY_NAME]) ?? read_string(item[KEY_CONTEXT])
 	if (name === undefined) return undefined
@@ -108,7 +101,7 @@ function parse_rollup_item(item: RollupItemData): RollupCheck | undefined {
 }
 
 function parse_rollup_checks(raw_json: string): Array<RollupCheck> {
-	const parsed = parse_json_safe(raw_json)
+	const parsed = json_value.parse_or_undefined(raw_json)
 	const rollup = read_rollup_array(parsed)
 	const checks: Array<RollupCheck> = []
 
@@ -121,7 +114,7 @@ function parse_rollup_checks(raw_json: string): Array<RollupCheck> {
 }
 
 function parse_pr_state_snapshot(raw_json: string): PrStateSnapshot {
-	const parsed = parse_json_safe(raw_json)
+	const parsed = json_value.parse_or_undefined(raw_json)
 	const result = pr_raw_schema.safeParse(parsed)
 	const data = result.success ? result.data : undefined
 
@@ -132,17 +125,8 @@ function parse_pr_state_snapshot(raw_json: string): PrStateSnapshot {
 	}
 }
 
-const git_pr_checks_parse = {
-	parse_rollup_checks,
-	parse_json_safe,
-	read_string,
-	parse_pr_state_snapshot,
-}
-
 export {
-	git_pr_checks_parse,
 	parse_rollup_checks,
-	parse_json_safe,
 	read_string,
 	parse_pr_state_snapshot,
 	CHECK_STATUS_PASS,

package/scripts/{git → gh}/git-pr-checks.ts

@@ -1,3 +1,4 @@
+import { package_name_schema } from '#scripts/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'
@@ -9,7 +10,6 @@ import {
 	type PrEvaluation,
 } from './git-pr-checks-eval'
 import { parse_pr_state_snapshot, read_string, type PrStateSnapshot } from './git-pr-checks-parse'
-import { package_name_schema } from './schemas'
 
 const SECONDS_TO_MS = 1000
 const CHECK_WAIT_INTERVAL_MS = 10_000
@@ -262,6 +262,7 @@ async function wait_for_pr_success(options: WaitForPrSuccessOptions): Promise<Pr
 
 	for (let attempt = 0; attempt < options.max_attempts; attempt += 1) {
 		console.info(`Checking PR status… (${String(attempt + 1)}/${String(options.max_attempts)})`)
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		carried = await attempt_pr_success_poll({
 			options,
 			stable_count: carried.next_stable_count,

package/scripts/{git → gh}/git-pr-coderabbit.ts

@@ -1,7 +1,7 @@
+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'
-import { parse_json_array_or_undefined } from './parse-json-array'
-import { pull_comment_schema } from './schemas'
 
 // cspell:words coderabbit coderabbitai
 
@@ -120,9 +120,6 @@ async function handle_coderabbit_findings(input: {
 }
 
 const git_pr_coderabbit = {
-	parse_pull_comments,
-	read_unresolved_cr_urls,
-	build_ignore_reason_comment,
 	handle_coderabbit_findings,
 }
 

package/scripts/{git → gh}/git-pr-confirmation.ts

@@ -1,4 +1,4 @@
-import { telegram_notify, type TelegramSendInput } from './telegram-notify'
+import { telegram_notify, type TelegramSendInput } from '#scripts/notify/telegram-notify'
 
 // What to type when the confirmation notification itself could not be delivered
 // (joshuafolkken/kit#1564). The `--body-file` spelling rather than `--body`, because the body names
@@ -53,8 +53,6 @@ function has_ignore_reason(reason: string | undefined): reason is string {
 // gates drift apart.
 const git_pr_confirmation = {
 	notify_confirmation,
-	build_confirmation_input,
-	has_ignore_reason,
 }
 
 // `has_ignore_reason` stays a named export beside the namespace: `git-pr-coderabbit.ts` imports it

package/scripts/{git → gh}/git-pr-managed-config.ts

@@ -1,6 +1,6 @@
+import { changed_paths } from '#scripts/git/changed-paths'
+import { git_command } from '#scripts/git/git-command'
 import { managed_config_scope, type ManagedHit } from '#scripts/sync/managed-config-scope'
-import { changed_paths } from './changed-paths'
-import { git_command } from './git-command'
 
 // **The tracked diff against the merge base — untracked files excluded.**
 // `changed_paths.read_changed_paths(false)` appends the untracked files as well, and those are not in
@@ -63,7 +63,6 @@ async function handle_managed_config_changes(input: {
 
 const git_pr_managed_config = {
 	handle_managed_config_changes,
-	build_report,
 }
 
 export { git_pr_managed_config }

package/scripts/{git → gh}/git-pr.ts

@@ -1,10 +1,10 @@
 import { pr_classification, type ReleaseClassification } from '#scripts/ci/pr-classification'
-import { animation_helpers, type AnimationOptions } from './animation-helpers'
+import type { IssueInfo } from '#scripts/git/git-issue'
+import { pr_info_schema } from '#scripts/git/schemas'
+import { animation_helpers, type AnimationOptions } from '#scripts/lib/animation-helpers'
 import { git_gh_command } from './git-gh-command'
-import type { IssueInfo } from './git-issue'
 import { git_pr_error } from './git-pr-error'
 import { git_pr_messages } from './git-pr-messages'
-import { pr_info_schema } from './schemas'
 
 // **Answers the new pull request's URL, and `undefined` when one already existed.** `pr_create`
 // filters its REST response to `.html_url`, so the address is in hand the moment the call returns —

package/scripts/git/changed-file-scope.ts

@@ -194,7 +194,6 @@ const changed_file_scope = {
 	LISTED_FILE_LIMIT,
 	UNREADABLE_REASON,
 	describe_scope,
-	explicit_files_of,
 	flags_of,
 	is_flag,
 	read_changed_files,

package/scripts/git/git-branch.ts

@@ -2,9 +2,9 @@ import {
 	animation_helpers,
 	create_git_operation_config,
 	type AnimationOptions,
-} from './animation-helpers'
+} from '#scripts/lib/animation-helpers'
 import { git_command } from './git-command'
-import { git_error } from './git-error'
+import { BranchMismatchError } from './git-error'
 
 async function current(): Promise<string> {
 	const config: AnimationOptions<string> = {
@@ -124,7 +124,7 @@ async function check_and_create_branch(
 	}
 
 	if (is_mismatch(current_branch, target_branch_name, default_branch)) {
-		git_error.display_branch_mismatch_error(current_branch, target_branch_name)
+		throw new BranchMismatchError({ current_branch, target_branch_name })
 	}
 
 	return current_branch
@@ -132,9 +132,6 @@ async function check_and_create_branch(
 
 const git_branch = {
 	current,
-	create,
-	switch_to,
-	exists,
 	check_and_create_branch,
 	is_mismatch,
 	// Exported so a lane's branch name can be checked against the real matcher rather than against a

package/scripts/git/git-command.ts

@@ -418,7 +418,7 @@ async function push(): Promise<void> {
 // has diverged is a state to fail loudly on rather than to grow a merge commit over. The name says
 // which of the two this is, as `merge_fast_forward` does beside `merge_branch`.
 async function pull_fast_forward(): Promise<void> {
-	await git_spawn.with_output('pull', ['--ff-only'])
+	await git_spawn.with_output_remote('pull', ['--ff-only'])
 }
 
 // Every local branch matching a `git branch --list` pattern, one name per line. The boolean below is

package/scripts/git/git-commit.ts

@@ -1,4 +1,4 @@
-import { animation_helpers, create_git_operation_config } from './animation-helpers'
+import { animation_helpers, create_git_operation_config } from '#scripts/lib/animation-helpers'
 import { git_command } from './git-command'
 
 async function commit(commit_message: string): Promise<void> {

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

@@ -1,46 +1,102 @@
 import { execFileSync } from 'node:child_process'
 import { git_utilities } from './constants'
 import { git_command } from './git-command'
+import { git_location_environment, GIT_LOCATION_VARIABLES } from './git-location-environment'
+
+// The one synchronous read of a checkout's two git directories (joshuafolkken/kit#2986) — the same
+// `GIT_DIRECTORY_ARGUMENTS` `git_command.git_directories` asks asynchronously, so the two spellings
+// cannot name different directories. It had been run in three places with three timeouts and no
+// memory of the answer, though a `PreToolUse` hook may ask it several times in one call.
 
 const OWN_GIT_DIRECTORY = 0
 const COMMON_GIT_DIRECTORY = 1
-const PROBE_TIMEOUT_MS = 2000
+// The read runs inside `PreToolUse` hooks, which hold the tool call for as long as it takes;
+// `rev-parse` takes no lock, so anything past a few seconds is a fault rather than slow work.
+const PROBE_TIMEOUT_MS = 5000
+
+// **Only an answer is remembered, never a failure** — a timeout or a directory that is not yet a
+// repository is asked again next time. The key carries every input git resolves from: the directory
+// asked about and, where the environment is inherited, the git location variables it holds.
+const answers = new Map<string, ReadonlyArray<string>>()
 
-function read_directories(cwd: string): Array<string> {
-	const git = git_utilities.get_git_command_for_spawn()
-	const output = execFileSync(git, [...git_command.GIT_DIRECTORY_ARGUMENTS], {
-		cwd,
-		encoding: 'utf8',
-		stdio: ['ignore', 'pipe', 'ignore'],
-		timeout: PROBE_TIMEOUT_MS,
-	})
+// With an explicit `cwd`, the git location variables are cleared so that directory is what git answers
+// for: a hook exports `GIT_DIR`, which beats `cwd` and would name the hook's checkout instead
+// (joshuafolkken/kit#2515). Without one the environment is kept, so the read resolves the same
+// checkout as the asynchronous `git_directories`.
+function probe_environment(cwd: string | undefined): NodeJS.ProcessEnv {
+	if (cwd === undefined) return process.env
 
-	return output.trim().split('\n')
+	return { ...process.env, ...git_location_environment.location_free_environment() }
 }
 
-function select_linked(directories: ReadonlyArray<string>): string | undefined {
-	const own = directories[OWN_GIT_DIRECTORY]
-	const common = directories[COMMON_GIT_DIRECTORY]
+function cache_key(cwd: string | undefined): string {
+	if (cwd !== undefined) return `explicit\0${cwd}`
+
+	const locations = GIT_LOCATION_VARIABLES.map((name) => process.env[name] ?? '')
 
-	return own !== undefined && common !== undefined && own !== common ? common : undefined
+	return ['inherited', process.cwd(), ...locations].join('\0')
 }
 
-function resolve(cwd: string): string | undefined {
+// git's own diagnostics are discarded: a checkout it cannot describe is already the empty answer, and
+// a hook that let `fatal: not a git repository` through would print it in front of a tool call. The
+// binary is resolved through `git_utilities` exactly as `git-spawn.ts` resolves it and run with an
+// argument array and no `shell`; both are internally controlled, never untrusted input.
+function read_directories(cwd: string | undefined): ReadonlyArray<string> {
 	try {
-		return select_linked(read_directories(cwd))
+		const output = execFileSync(
+			git_utilities.get_git_command_for_spawn(),
+			[...git_command.GIT_DIRECTORY_ARGUMENTS],
+			{
+				cwd,
+				env: probe_environment(cwd),
+				encoding: 'utf8',
+				stdio: ['ignore', 'pipe', 'ignore'],
+				timeout: PROBE_TIMEOUT_MS,
+			},
+		) // NOSONAR
+
+		return output.split('\n').filter((line) => line !== '')
 	} catch {
-		return undefined
+		return []
 	}
 }
 
-function repository(cwd: string): string | undefined {
-	try {
-		return read_directories(cwd)[COMMON_GIT_DIRECTORY]
-	} catch {
-		return undefined
-	}
+// The work tree's own git directory, then the common one every work tree of the repository shares —
+// or nothing, where git cannot describe the checkout.
+function directories(cwd?: string): ReadonlyArray<string> {
+	const key = cache_key(cwd)
+	const known = answers.get(key)
+
+	if (known !== undefined) return known
+
+	const read = read_directories(cwd)
+
+	if (read.length > 0) answers.set(key, read)
+
+	return read
+}
+
+function own(cwd?: string): string | undefined {
+	return directories(cwd)[OWN_GIT_DIRECTORY]
+}
+
+function repository(cwd?: string): string | undefined {
+	return directories(cwd)[COMMON_GIT_DIRECTORY]
+}
+
+function select_linked(found: ReadonlyArray<string>): string | undefined {
+	const own_directory = found[OWN_GIT_DIRECTORY]
+	const common = found[COMMON_GIT_DIRECTORY]
+
+	return own_directory !== undefined && common !== undefined && own_directory !== common
+		? common
+		: undefined
+}
+
+function resolve(cwd: string): string | undefined {
+	return select_linked(directories(cwd))
 }
 
-const git_common_directory = { repository, resolve, select_linked }
+const git_common_directory = { directories, own, repository, resolve, select_linked }
 
 export { git_common_directory }

package/scripts/git/git-error.ts

@@ -1,5 +1,5 @@
+import { has_stderr_field } from '#scripts/gh/git-gh-exec'
 import { error_text } from '#scripts/lib/error-message'
-import { has_stderr_field } from './git-gh-exec'
 
 function get_stderr_from_error(cause: Error): string | undefined {
 	if (!has_stderr_field(cause)) return undefined
@@ -42,7 +42,41 @@ function display_error_details(cause: unknown): void {
 	console.error('💡 Details:', cause_message)
 }
 
-function handle(error: unknown): void {
+const FAILURE_EXIT_CODE = 1
+const OPERATION_CANCELLED_MESSAGE = '💡 Operation cancelled.'
+
+// **A library refuses by throwing; only the CLI entry decides the exit code** (joshuafolkken/kit#2985).
+// `process.exit()` from an imported module skips every `finally` above it (a lock release included)
+// and truncates a piped stdout, so these modules throw a typed error instead, and `handle` — the catch
+// at each entry — renders it and sets `process.exitCode`.
+interface BranchMismatch {
+	current_branch: string
+	target_branch_name: string
+}
+
+class BranchMismatchError extends Error {
+	readonly current_branch: string
+	readonly target_branch_name: string
+
+	constructor(mismatch: BranchMismatch, options?: ErrorOptions) {
+		super(
+			`Branch mismatch: on ${mismatch.current_branch}, expected ${mismatch.target_branch_name}`,
+			options,
+		)
+		this.name = 'BranchMismatchError'
+		this.current_branch = mismatch.current_branch
+		this.target_branch_name = mismatch.target_branch_name
+	}
+}
+
+class OperationCancelledError extends Error {
+	constructor() {
+		super('Operation cancelled')
+		this.name = 'OperationCancelledError'
+	}
+}
+
+function display_failure(error: unknown): void {
 	const error_message = error_text.message_of(error)
 
 	console.error('')
@@ -53,23 +87,46 @@ function handle(error: unknown): void {
 	}
 
 	console.error('')
-	process.exit(1)
 }
 
-function display_branch_mismatch_error(current_branch: string, target_branch_name: string): void {
+function display_branch_mismatch(error: BranchMismatchError): void {
 	console.error('')
 	console.error('❌ Branch mismatch detected')
 	console.error('')
-	console.error(`Current branch: ${current_branch}`)
-	console.error(`Expected branch: ${target_branch_name}`)
+	console.error(`Current branch: ${error.current_branch}`)
+	console.error(`Expected branch: ${error.target_branch_name}`)
 	console.error('')
 	console.error('💡 Please update main branch to the latest and try again.')
-	process.exit(1)
+}
+
+function display_cancelled(): void {
+	console.info(OPERATION_CANCELLED_MESSAGE)
+	console.info('')
+}
+
+function display(error: unknown): void {
+	if (error instanceof BranchMismatchError) {
+		display_branch_mismatch(error)
+
+		return
+	}
+
+	if (error instanceof OperationCancelledError) {
+		display_cancelled()
+
+		return
+	}
+
+	display_failure(error)
+}
+
+function handle(error: unknown): void {
+	display(error)
+	process.exitCode = FAILURE_EXIT_CODE
 }
 
 const git_error = {
 	handle,
-	display_branch_mismatch_error,
 }
 
-export { git_error }
+export { git_error, BranchMismatchError, OperationCancelledError }

package/scripts/git/git-execa-error.ts

@@ -22,6 +22,11 @@ function has_timed_out(error: unknown): boolean {
 	return error.timedOut === true
 }
 
+// A timeout has no exit code — the process was killed rather than allowed to exit — so `cause` says
+// so in the slot every other git failure puts a number in. Shared by every git spawn that carries a
+// budget: the push (`git-push-transport.ts`) and the fetch and pull (`git-spawn.ts`).
+const TIMEOUT_EXIT_CODE = 'timeout'
+
 // The error a spawned git command fails with. The exit code is carried on `cause` as well as in the
 // message, because callers branch on it rather than parse it: `git_command.push` reads 128 there to
 // decide whether to retry with `--set-upstream`.
@@ -32,4 +37,4 @@ function create_spawn_error(command: string, exit_code: number | undefined): Err
 	return new Error(error_message, { cause: { exit_code: exit_code_string } })
 }
 
-export { create_spawn_error, get_exit_code, has_timed_out }
+export { create_spawn_error, get_exit_code, has_timed_out, TIMEOUT_EXIT_CODE }

package/scripts/git/git-issue.ts

@@ -1,6 +1,6 @@
+import { git_gh_issue_read } from '#scripts/gh/git-gh-issue-read'
 import { lane_paths } from '#scripts/lane/lane-paths'
 import { SEPARATOR_LINE } from './constants'
-import { git_gh_issue_read } from './git-gh-issue-read'
 import { git_prompt } from './git-prompt'
 
 interface IssueInfo {

package/scripts/git/git-preflight.ts

@@ -1,11 +1,11 @@
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { git_pr } from '#scripts/gh/git-pr'
 import { error_text } from '#scripts/lib/error-message'
 import { live_evidence } from '#scripts/review/live-evidence'
 import { changed_paths } from './changed-paths'
 import { git_branch } from './git-branch'
 import { git_command } from './git-command'
-import { git_gh_command } from './git-gh-command'
 import { git_issue, type IssueInfo } from './git-issue'
-import { git_pr } from './git-pr'
 
 // joshuafolkken/kit#2817. A first `josh git -y` was refused once per unmet precondition — the title's
 // issue number, the branch name, the issue's release classification — each only after the stage
@@ -117,19 +117,37 @@ function refusal(problems: ReadonlyArray<string>): Error {
 	)
 }
 
-async function check(input: PreflightInput): Promise<void> {
+interface PreflightAnswer {
+	pr_target: Target | undefined
+	problems: Array<string>
+}
+
+async function answer(input: PreflightInput): Promise<PreflightAnswer> {
 	const { target, problems } = await resolve_target(input.cli_input)
 	// The classification and the evidence belong to the pull request, so a `--skip-pr` run asks neither.
 	const pr_target = input.will_open_pr ? target : undefined
 	const pr_problems = pr_target === undefined ? [] : await classification_problems(pr_target)
-	const all_problems = [...problems, ...pr_problems]
 
-	if (all_problems.length > 0) throw refusal(all_problems)
+	return { pr_target, problems: [...problems, ...pr_problems] }
+}
+
+// joshuafolkken/kit#2946: the unmet preconditions as a list, so `josh ship` can ask them before its
+// review and gate start instead of meeting the refusal at the commit stage.
+async function problems_of(input: PreflightInput): Promise<Array<string>> {
+	const { problems } = await answer(input)
+
+	return problems
+}
+
+async function check(input: PreflightInput): Promise<void> {
+	const { pr_target, problems } = await answer(input)
+
+	if (problems.length > 0) throw refusal(problems)
 
 	if (pr_target !== undefined) await announce_evidence(pr_target.branch_name)
 }
 
-const git_preflight = { check }
+const git_preflight = { check, problems_of }
 
 export type { PreflightInput }
 export { git_preflight }

package/scripts/git/git-prompt.ts

@@ -1,9 +1,8 @@
 import { stdin as input, stdout as output } from 'node:process'
 import { createInterface, type Interface } from 'node:readline/promises'
+import { OperationCancelledError } from './git-error'
 import { git_prompt_display } from './git-prompt-display'
 
-const OPERATION_CANCELLED_MESSAGE = '💡 Operation cancelled.'
-
 const PROMPT_MESSAGES = {
 	unstaged_files: '💬 Unstaged files found. Continue anyway? (y/n): ',
 	package_json_not_staged: '💬 package.json is not staged. Continue anyway? (y/n): ',
@@ -85,16 +84,10 @@ async function with_prompt<T>(callback: PromptCallback<T>, fallback_value?: T):
 	}
 }
 
-async function confirm_with_exit_on_cancel(should_continue: () => Promise<boolean>): Promise<void> {
+async function confirm_or_cancel(should_continue: () => Promise<boolean>): Promise<void> {
 	const is_confirmed = await should_continue()
 
-	if (is_confirmed) {
-		return
-	}
-
-	console.info(OPERATION_CANCELLED_MESSAGE)
-	console.info('')
-	process.exit(1)
+	if (!is_confirmed) throw new OperationCancelledError()
 }
 
 function create_confirm_function(message: string): () => Promise<boolean> {
@@ -112,11 +105,11 @@ async function confirm_without_package_json(): Promise<boolean> {
 }
 
 async function confirm_unstaged_files(): Promise<void> {
-	await confirm_with_exit_on_cancel(confirm_continue)
+	await confirm_or_cancel(confirm_continue)
 }
 
 async function confirm_missing_package_json(): Promise<void> {
-	await confirm_with_exit_on_cancel(confirm_without_package_json)
+	await confirm_or_cancel(confirm_without_package_json)
 }
 
 async function confirm_version_not_updated(): Promise<boolean> {
@@ -124,19 +117,7 @@ async function confirm_version_not_updated(): Promise<boolean> {
 }
 
 async function confirm_without_version_update(): Promise<void> {
-	await confirm_with_exit_on_cancel(confirm_version_not_updated)
-}
-
-async function confirm_commit(): Promise<boolean> {
-	return await create_confirm_function(PROMPT_MESSAGES.commit)()
-}
-
-async function confirm_push(): Promise<boolean> {
-	return await create_confirm_function(PROMPT_MESSAGES.push)()
-}
-
-async function confirm_pr(): Promise<boolean> {
-	return await create_confirm_function(PROMPT_MESSAGES.pr)()
+	await confirm_or_cancel(confirm_version_not_updated)
 }
 
 async function ask_issue_info(prompt: Interface, question: string): Promise<string> {
@@ -190,15 +171,9 @@ async function confirm_workflow_steps(): Promise<WorkflowConfirmations> {
 }
 
 const git_prompt = {
-	confirm_continue,
 	confirm_unstaged_files,
-	confirm_without_package_json,
 	confirm_missing_package_json,
-	confirm_version_not_updated,
 	confirm_without_version_update,
-	confirm_commit,
-	confirm_push,
-	confirm_pr,
 	get_issue_info,
 	confirm_workflow_steps,
 }