@savvy-web/silk-effects 0.6.0 → 1.0.0

package/commitlint/hook/rules/plan-leakage.js

@@ -0,0 +1,36 @@
+import { Effect } from "effect";
+
+//#region src/commitlint/hook/rules/plan-leakage.ts
+/**
+* plan-leakage rule — advises when commit bodies reference plan files
+* or contain planning-narrative language.
+*
+* @internal
+*/
+const PATH_PATTERNS = [/\.claude\/plans\//i, /\.claude\/design\//i];
+const PHRASE_PATTERNS = [
+	/\bas decided in the plan\b/i,
+	/\bpreviously documented\b/i,
+	/\bsee the design doc\b/i,
+	/\bper the (plan|design doc|spec)\b/i
+];
+const planLeakageRule = {
+	id: "plan-leakage",
+	severity: "advise",
+	check: (input) => Effect.sync(() => {
+		const matchedPaths = PATH_PATTERNS.filter((re) => re.test(input.message));
+		const matchedPhrases = PHRASE_PATTERNS.filter((re) => re.test(input.message));
+		if (matchedPaths.length === 0 && matchedPhrases.length === 0) return null;
+		const reasons = [];
+		if (matchedPaths.length > 0) reasons.push("references planning artifacts (.claude/plans/ or .claude/design/)");
+		if (matchedPhrases.length > 0) reasons.push("contains planning-narrative phrasing");
+		return {
+			ruleId: "plan-leakage",
+			severity: "advise",
+			message: `Body ${reasons.join(" and ")}. Plan-file paths and "as decided in the plan"-style narrative belong in the PR description, not the commit body. Remove those references and re-run git commit.`
+		};
+	})
+};
+
+//#endregion
+export { planLeakageRule };

package/commitlint/hook/rules/signing-flag-conflict.js

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+
+//#region src/commitlint/hook/rules/signing-flag-conflict.ts
+/**
+* signing-flag-conflict rule — denies when the command explicitly opts out
+* of signing while the project is configured to require signing.
+*
+* @internal
+*/
+const signingFlagConflictRule = {
+	id: "signing-flag-conflict",
+	severity: "deny",
+	check: (input, ctx) => Effect.sync(() => {
+		if (input.flags.sign !== "force-off") return null;
+		if (!ctx.autoSignEnabled) return null;
+		return {
+			ruleId: "signing-flag-conflict",
+			severity: "deny",
+			message: "Command uses --no-gpg-sign while commit.gpgsign=true is configured. Either remove --no-gpg-sign, or update git config commit.gpgsign first if you intend to leave signing off."
+		};
+	})
+};
+
+//#endregion
+export { signingFlagConflictRule };

package/commitlint/hook/rules/soft-wrap.js

@@ -0,0 +1,37 @@
+import { Effect } from "effect";
+
+//#region src/commitlint/hook/rules/soft-wrap.ts
+/**
+* soft-wrap rule — advises when a bullet point appears to have an
+* artificial mid-bullet line wrap.
+*
+* Heuristic: a bullet line shorter than 80 chars, immediately followed
+* by an indented continuation line (not a new bullet), suggests the
+* agent wrapped at ~80 chars unnecessarily.
+*
+* @internal
+*/
+const BULLET = /^([ \t]*)[-*]\s/;
+const CONTINUATION = /^[ \t]+\S/;
+const softWrapRule = {
+	id: "soft-wrap",
+	severity: "advise",
+	check: (input) => Effect.sync(() => {
+		const lines = input.message.split("\n");
+		for (let i = 0; i < lines.length - 1; i++) {
+			const line = lines[i] ?? "";
+			const next = lines[i + 1] ?? "";
+			if (!line.match(BULLET)) continue;
+			if (line.length >= 80) continue;
+			if (CONTINUATION.test(next) && !BULLET.test(next)) return {
+				ruleId: "soft-wrap",
+				severity: "advise",
+				message: "A bullet point appears to have an artificial soft-wrap (a short bullet followed by an indented continuation). The body line limit is 300 chars; one bullet should fit on one line. Reflow the bullet onto a single line."
+			};
+		}
+		return null;
+	})
+};
+
+//#endregion
+export { softWrapRule };

package/commitlint/hook/rules/types.js

@@ -0,0 +1,14 @@
+//#region src/commitlint/hook/rules/types.ts
+function partitionHits(hits) {
+	const deny = [];
+	const advise = [];
+	for (const hit of hits) if (hit.severity === "deny") deny.push(hit);
+	else advise.push(hit);
+	return {
+		deny,
+		advise
+	};
+}
+
+//#endregion
+export { partitionHits };

package/commitlint/hook/rules/verbosity.js

@@ -0,0 +1,31 @@
+import { Effect } from "effect";
+
+//#region src/commitlint/hook/rules/verbosity.ts
+/**
+* verbosity rule — advises when the body exceeds line or word thresholds.
+*
+* @internal
+*/
+const VERBOSITY_LINE_THRESHOLD = 25;
+const VERBOSITY_WORD_THRESHOLD = 400;
+const verbosityRule = {
+	id: "verbosity",
+	severity: "advise",
+	check: (input) => Effect.sync(() => {
+		const body = input.message.split("\n").slice(2).filter((l) => l.length > 0);
+		const lineCount = body.length;
+		const wordCount = body.join(" ").trim().split(/\s+/).filter(Boolean).length;
+		if (lineCount <= 25 && wordCount <= 400) return null;
+		const reasons = [];
+		if (lineCount > 25) reasons.push(`${lineCount} non-empty body lines`);
+		if (wordCount > 400) reasons.push(`${wordCount} words`);
+		return {
+			ruleId: "verbosity",
+			severity: "advise",
+			message: `Body has ${reasons.join(" / ")}; the project standard keeps commit bodies under ~${25} lines and ~${400} words. Move detail to the PR description and keep the commit body to the irreducible "what + why".`
+		};
+	})
+};
+
+//#endregion
+export { verbosityRule };

package/commitlint/hook/silence-logger.js

@@ -0,0 +1,39 @@
+import { Layer, LogLevel, Logger } from "effect";
+
+//#region src/commitlint/hook/silence-logger.ts
+/**
+* Logger configuration shared by all hook subcommands.
+*
+* @remarks
+* Hook subcommands reserve stdout for the JSON envelope they emit to Claude
+* Code. Effect's default logger writes messages to stdout via `console.log`,
+* which pollutes that contract (e.g., workspaces-effect emits "Workspace root
+* found" on every CLI invocation). This Layer combines two protections:
+*
+* 1. {@link Logger.minimumLogLevel} at `Warning` silences routine Info/Debug
+*    traffic so the common case never reaches the logger at all.
+* 2. A default-logger replacement that routes anything which *does* fire to
+*    stderr, so even Warning/Error output cannot corrupt the stdout envelope.
+*
+* Only the hook command wrappers provide this Layer, so regular `savvy`
+* commands keep their stdout output intact.
+*
+* @internal
+*/
+/**
+* Replacement for the default logger that writes every message to stderr,
+* leaving stdout reserved for the hook's JSON envelope.
+*/
+const StderrLogger = Logger.replace(Logger.defaultLogger, Logger.make(({ message }) => {
+	process.stderr.write(`${JSON.stringify(message)}\n`);
+}));
+/** Minimum log level layer that suppresses Info and below. */
+const MinLogLevel = Logger.minimumLogLevel(LogLevel.Warning);
+/**
+* Combined hook logger layer: stderr redirect merged with the Warning minimum
+* log level. Provided by hook command wrappers to keep stdout corruption-proof.
+*/
+const HookSilencer = Layer.merge(StderrLogger, MinLogLevel);
+
+//#endregion
+export { HookSilencer };

package/commitlint/index.js

@@ -0,0 +1,146 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { detectDCO } from "./detection/dco.js";
+import { COMMIT_TYPES, COMMIT_TYPE_DEFINITIONS, DCO_SIGNOFF_TEXT, TDD_SCOPE_PATTERN, TDD_STATES } from "./config/rules.js";
+import { TYPE_EMOJIS, TYPE_EMOJIS_UNICODE, getTypeEmoji } from "./prompt/emojis.js";
+import { createPromptConfig, createTypeEnum, defaultPromptConfig, emojiPromptConfig } from "./prompt/config.js";
+import { createConfig } from "./config/factory.js";
+import { decodeConfigOptions } from "./config/schema.js";
+import staticConfig from "./static.js";
+import { ERROR_EXPLANATIONS, ERROR_SUGGESTIONS, getExplanation, getSuggestion } from "./formatter/messages.js";
+import { format } from "./formatter/format.js";
+import { prompter } from "./prompt/prompter.js";
+import { detectScopes } from "./detection/scopes.js";
+import { PostToolUseEnvelope, PreToolUseEnvelope, SessionStartEnvelope, UserPromptSubmitEnvelope } from "./hook/envelope.js";
+import { postToolUseAdvise, preToolUseAdvise, preToolUseAllow, preToolUseDeny, preToolUseSilent, sessionStartContext, userPromptSubmitContext } from "./hook/output.js";
+import { parseBashCommand } from "./hook/parse-bash-command.js";
+import { HookSilencer } from "./hook/silence-logger.js";
+import { inferTicketId, readBranchInfo } from "./hook/diagnostics/branch.js";
+import { readCache, writeCache } from "./hook/diagnostics/cache.js";
+import { parseHuskyConfigPath, readCommitlintConfigPath } from "./hook/diagnostics/commitlint-config.js";
+import { ISSUES_CACHE_RELATIVE_PATH, fetchAndCacheOpenIssues, readOpenIssuesFromCache, readOrFetchOpenIssues } from "./hook/diagnostics/open-issues.js";
+import { detectFromLockfiles, detectPackageManager, parsePackageManagerField } from "./hook/diagnostics/package-manager.js";
+import { buildSigningDiagnostic, parseGpgKeyExpiry, readSigningDiagnostic } from "./hook/diagnostics/signing.js";
+import { closesTrailerRule, hasClosingTrailer } from "./hook/rules/closes-trailer.js";
+import { forbiddenContentRule } from "./hook/rules/forbidden-content.js";
+import { planLeakageRule } from "./hook/rules/plan-leakage.js";
+import { signingFlagConflictRule } from "./hook/rules/signing-flag-conflict.js";
+import { softWrapRule } from "./hook/rules/soft-wrap.js";
+import { partitionHits } from "./hook/rules/types.js";
+import { verbosityRule } from "./hook/rules/verbosity.js";
+
+//#region src/commitlint/index.ts
+/**
+* Commitlint namespace — commitlint business logic extracted from \@savvy-web/commitlint.
+*
+* @remarks
+* This barrel re-exports the complete commitlint public surface (minus CLI/bin) from
+* the silk-effects package. Downstream consumers import via the Commitlint namespace:
+*
+* ```typescript
+* import { Commitlint } from "@savvy-web/silk-effects";
+* const config = Commitlint.CommitlintConfig.silk();
+* ```
+*
+* @packageDocumentation
+*/
+var commitlint_exports = /* @__PURE__ */ __exportAll({
+	COMMIT_TYPES: () => COMMIT_TYPES,
+	COMMIT_TYPE_DEFINITIONS: () => COMMIT_TYPE_DEFINITIONS,
+	CommitlintConfig: () => CommitlintConfig,
+	DCO_SIGNOFF_TEXT: () => DCO_SIGNOFF_TEXT,
+	DEFAULT_BODY_MAX_LINE_LENGTH: () => 300,
+	ERROR_EXPLANATIONS: () => ERROR_EXPLANATIONS,
+	ERROR_SUGGESTIONS: () => ERROR_SUGGESTIONS,
+	HookSilencer: () => HookSilencer,
+	ISSUES_CACHE_RELATIVE_PATH: () => ISSUES_CACHE_RELATIVE_PATH,
+	ISSUES_CACHE_TTL_SECONDS: () => 600,
+	PostToolUseEnvelope: () => PostToolUseEnvelope,
+	PreToolUseEnvelope: () => PreToolUseEnvelope,
+	SessionStartEnvelope: () => SessionStartEnvelope,
+	TDD_SCOPE_PATTERN: () => TDD_SCOPE_PATTERN,
+	TDD_STATES: () => TDD_STATES,
+	TYPE_EMOJIS: () => TYPE_EMOJIS,
+	TYPE_EMOJIS_UNICODE: () => TYPE_EMOJIS_UNICODE,
+	UserPromptSubmitEnvelope: () => UserPromptSubmitEnvelope,
+	VERBOSITY_LINE_THRESHOLD: () => 25,
+	VERBOSITY_WORD_THRESHOLD: () => 400,
+	buildSigningDiagnostic: () => buildSigningDiagnostic,
+	closesTrailerRule: () => closesTrailerRule,
+	createPromptConfig: () => createPromptConfig,
+	createTypeEnum: () => createTypeEnum,
+	default: () => CommitlintConfig,
+	defaultPromptConfig: () => defaultPromptConfig,
+	detectDCO: () => detectDCO,
+	detectFromLockfiles: () => detectFromLockfiles,
+	detectPackageManager: () => detectPackageManager,
+	detectScopes: () => detectScopes,
+	emojiPromptConfig: () => emojiPromptConfig,
+	fetchAndCacheOpenIssues: () => fetchAndCacheOpenIssues,
+	forbiddenContentRule: () => forbiddenContentRule,
+	format: () => format,
+	getExplanation: () => getExplanation,
+	getSuggestion: () => getSuggestion,
+	getTypeEmoji: () => getTypeEmoji,
+	hasClosingTrailer: () => hasClosingTrailer,
+	inferTicketId: () => inferTicketId,
+	parseBashCommand: () => parseBashCommand,
+	parseGpgKeyExpiry: () => parseGpgKeyExpiry,
+	parseHuskyConfigPath: () => parseHuskyConfigPath,
+	parsePackageManagerField: () => parsePackageManagerField,
+	partitionHits: () => partitionHits,
+	planLeakageRule: () => planLeakageRule,
+	postToolUseAdvise: () => postToolUseAdvise,
+	preToolUseAdvise: () => preToolUseAdvise,
+	preToolUseAllow: () => preToolUseAllow,
+	preToolUseDeny: () => preToolUseDeny,
+	preToolUseSilent: () => preToolUseSilent,
+	prompter: () => prompter,
+	readBranchInfo: () => readBranchInfo,
+	readCache: () => readCache,
+	readCommitlintConfigPath: () => readCommitlintConfigPath,
+	readOpenIssuesFromCache: () => readOpenIssuesFromCache,
+	readOrFetchOpenIssues: () => readOrFetchOpenIssues,
+	readSigningDiagnostic: () => readSigningDiagnostic,
+	sessionStartContext: () => sessionStartContext,
+	signingFlagConflictRule: () => signingFlagConflictRule,
+	softWrapRule: () => softWrapRule,
+	staticConfig: () => staticConfig,
+	userPromptSubmitContext: () => userPromptSubmitContext,
+	verbosityRule: () => verbosityRule,
+	writeCache: () => writeCache
+});
+/**
+* Dynamic commitlint configuration factory.
+*
+* @remarks
+* Provides static methods for creating commitlint configurations with automatic
+* detection of repository characteristics. The class co-locates configuration
+* creation with schema validation.
+*
+* @public
+*
+* @example
+* ```typescript
+* import { Commitlint } from "@savvy-web/silk-effects";
+*
+* // Auto-detect everything
+* export default Commitlint.CommitlintConfig.silk();
+*
+* // With explicit overrides
+* export default Commitlint.CommitlintConfig.silk({
+*   dco: true,
+*   scopes: ["api", "cli"],
+*   emojis: true,
+* });
+* ```
+*/
+var CommitlintConfig = class {
+	static silk(options = {}) {
+		return createConfig(decodeConfigOptions(options));
+	}
+	/* v8 ignore next 3 -- private constructor prevents direct instantiation */
+	constructor() {}
+};
+
+//#endregion
+export { commitlint_exports };

package/commitlint/prompt/config.js

@@ -0,0 +1,91 @@
+import { COMMIT_TYPE_DEFINITIONS } from "../config/rules.js";
+import { TYPE_EMOJIS } from "./emojis.js";
+
+//#region src/commitlint/prompt/config.ts
+/**
+* Create type enum configuration for prompts.
+*
+* @remarks
+* Builds the type enum object used by commitizen adapters
+* to display commit type options in the interactive prompt.
+*
+* @param emojis - Whether to include emoji shortcodes
+* @returns Type enum configuration object
+*
+* @public
+*/
+function createTypeEnum(emojis) {
+	const typeEnum = {};
+	for (const def of COMMIT_TYPE_DEFINITIONS) typeEnum[def.type] = {
+		description: def.description,
+		title: def.title,
+		emoji: emojis ? TYPE_EMOJIS[def.type] : ""
+	};
+	return typeEnum;
+}
+/**
+* Create prompt configuration for commitizen adapters.
+*
+* @remarks
+* Generates a complete prompt configuration object compatible with
+* `@commitlint/cz-commitlint` and included in `CommitlintConfig.silk()` output.
+*
+* @param options - Prompt configuration options
+* @returns Prompt configuration object
+*
+* @public
+*
+* @example
+* ```typescript
+* import { createPromptConfig } from "@savvy-web/commitlint/prompt";
+*
+* const promptConfig = createPromptConfig({ emojis: true });
+* ```
+*/
+function createPromptConfig(options = {}) {
+	const { emojis = false, scopes } = options;
+	const scopeQuestion = { description: "What is the scope of this change (e.g., component name):" };
+	if (scopes && scopes.length > 0) scopeQuestion.enum = scopes;
+	return {
+		settings: {
+			enableMultipleScopes: true,
+			scopeEnumSeparator: ","
+		},
+		messages: {
+			skip: "(press enter to skip)",
+			max: "(max %d chars)",
+			min: "(min %d chars)",
+			emptyWarning: "cannot be empty",
+			upperLimitWarning: "over the limit",
+			lowerLimitWarning: "below the limit"
+		},
+		questions: {
+			type: {
+				description: "Select the type of change you're committing:",
+				enum: createTypeEnum(emojis)
+			},
+			scope: scopeQuestion,
+			subject: { description: "Write a short, imperative description of the change:" },
+			body: { description: "Provide a longer description of the change (optional):" },
+			isBreaking: { description: "Are there any breaking changes?" },
+			breakingBody: { description: "Describe the breaking changes:" },
+			isIssueAffected: { description: "Does this change affect any open issues?" },
+			issuesBody: { description: "Add issue references (e.g., 'fix #123', 'close #456'):" }
+		}
+	};
+}
+/**
+* Default prompt configuration (no emojis).
+*
+* @public
+*/
+const defaultPromptConfig = createPromptConfig();
+/**
+* Prompt configuration with emojis enabled.
+*
+* @public
+*/
+const emojiPromptConfig = createPromptConfig({ emojis: true });
+
+//#endregion
+export { createPromptConfig, createTypeEnum, defaultPromptConfig, emojiPromptConfig };

package/commitlint/prompt/emojis.js

@@ -0,0 +1,74 @@
+//#region src/commitlint/prompt/emojis.ts
+/**
+* Emoji shortcode mapping for commit types.
+*
+* @remarks
+* Uses GitHub/GitLab compatible shortcodes (e.g., `:sparkles:`) that
+* render as emojis in Markdown contexts and web UIs.
+*
+* @public
+*/
+const TYPE_EMOJIS = {
+	ai: ":robot:",
+	feat: ":sparkles:",
+	fix: ":bug:",
+	docs: ":memo:",
+	style: ":lipstick:",
+	refactor: ":recycle:",
+	perf: ":zap:",
+	test: ":white_check_mark:",
+	tdd: ":test_tube:",
+	build: ":package:",
+	ci: ":construction_worker:",
+	chore: ":wrench:",
+	revert: ":rewind:",
+	release: ":bookmark:"
+};
+/**
+* Unicode emoji mapping for commit types.
+*
+* @remarks
+* Uses actual Unicode emojis for terminals and contexts that
+* support direct emoji rendering.
+*
+* @public
+*/
+const TYPE_EMOJIS_UNICODE = {
+	ai: "🤖",
+	feat: "✨",
+	fix: "🐛",
+	docs: "📝",
+	style: "💄",
+	refactor: "♻️",
+	perf: "⚡",
+	test: "✅",
+	tdd: "🫪",
+	build: "📦",
+	ci: "👷",
+	chore: "🔧",
+	revert: "⏪",
+	release: "🔖"
+};
+/**
+* Get emoji for a commit type.
+*
+* @param type - Commit type
+* @param unicode - Use Unicode emojis instead of shortcodes
+* @returns Emoji string (shortcode or Unicode)
+*
+* @public
+*
+* @example
+* ```typescript
+* import { getTypeEmoji } from "@savvy-web/commitlint/prompt";
+*
+* getTypeEmoji("feat");        // ":sparkles:"
+* getTypeEmoji("feat", true);  // "✨"
+* ```
+*/
+function getTypeEmoji(type, unicode = false) {
+	return unicode ? TYPE_EMOJIS_UNICODE[type] : TYPE_EMOJIS[type];
+}
+
+//#endregion
+export { TYPE_EMOJIS, TYPE_EMOJIS_UNICODE, getTypeEmoji };

package/commitlint/prompt/prompter.js

@@ -0,0 +1,135 @@
+import { COMMIT_TYPE_DEFINITIONS } from "../config/rules.js";
+import { TYPE_EMOJIS_UNICODE } from "./emojis.js";
+
+//#region src/commitlint/prompt/prompter.ts
+/** Default prompter options */
+const DEFAULT_OPTIONS = {
+	emojis: true,
+	scopes: [],
+	maxSubjectLength: 100,
+	maxBodyLength: 300
+};
+/**
+* Build type choices for the prompt.
+*/
+function buildTypeChoices(emojis) {
+	return COMMIT_TYPE_DEFINITIONS.map((def) => {
+		const emoji = emojis ? TYPE_EMOJIS_UNICODE[def.type] : "";
+		return {
+			name: `${emoji ? `${emoji}  ` : ""}${def.type}: ${def.description}`,
+			value: def.type
+		};
+	});
+}
+/**
+* Build scope choices for the prompt.
+*/
+function buildScopeChoices(scopes) {
+	return [{
+		name: "(none)",
+		value: ""
+	}, ...scopes.map((scope) => ({
+		name: scope,
+		value: scope
+	}))];
+}
+/**
+* Format the final commit message.
+*/
+function formatCommitMessage(answers) {
+	const { type, scope, subject, body, isBreaking, breakingBody, isIssueAffected, issues } = answers;
+	const parts = [`${type}${scope ? `(${scope})` : ""}${isBreaking ? "!" : ""}: ${subject}`];
+	if (body) parts.push("", body);
+	if (isBreaking && breakingBody) parts.push("", `BREAKING CHANGE: ${breakingBody}`);
+	if (isIssueAffected && issues) parts.push("", issues);
+	return parts.join("\n");
+}
+/**
+* Commitizen prompter function.
+*
+* @remarks
+* This is the main entry point for the commitizen adapter.
+* It prompts the user for commit information and calls the
+* commit callback with the formatted message.
+*
+* @param cz - Inquirer instance provided by commitizen
+* @param commit - Callback to execute the commit
+* @param options - Prompter options
+*
+* @public
+*/
+function prompter(cz, commit, options = {}) {
+	const opts = {
+		...DEFAULT_OPTIONS,
+		...options
+	};
+	const scopeQuestion = opts.scopes.length > 0 ? {
+		type: "list",
+		name: "scope",
+		message: "Select the scope of this change:",
+		choices: buildScopeChoices(opts.scopes)
+	} : {
+		type: "input",
+		name: "scope",
+		message: "Scope of this change (press enter to skip):",
+		filter: (input) => input.trim().toLowerCase()
+	};
+	const questions = [
+		{
+			type: "list",
+			name: "type",
+			message: "Select the type of change you're committing:",
+			choices: buildTypeChoices(opts.emojis)
+		},
+		scopeQuestion,
+		{
+			type: "input",
+			name: "subject",
+			message: `Short description (max ${opts.maxSubjectLength} chars):`,
+			validate: (input) => {
+				if (!input.trim()) return "Subject is required";
+				if (input.length > opts.maxSubjectLength) return `Subject must be ${opts.maxSubjectLength} characters or less (currently ${input.length})`;
+				return true;
+			},
+			filter: (input) => {
+				const trimmed = input.trim();
+				return trimmed.charAt(0).toLowerCase() + trimmed.slice(1);
+			}
+		},
+		{
+			type: "input",
+			name: "body",
+			message: "Longer description (press enter to skip):"
+		},
+		{
+			type: "confirm",
+			name: "isBreaking",
+			message: "Are there any breaking changes?",
+			default: false
+		},
+		{
+			type: "input",
+			name: "breakingBody",
+			message: "Describe the breaking changes:",
+			when: (answers) => answers.isBreaking === true
+		},
+		{
+			type: "confirm",
+			name: "isIssueAffected",
+			message: "Does this change affect any open issues?",
+			default: false
+		},
+		{
+			type: "input",
+			name: "issues",
+			message: "Issue references (e.g., 'fix #123', 'closes #456'):",
+			when: (answers) => answers.isIssueAffected === true
+		}
+	];
+	cz.prompt(questions).then((answers) => {
+		commit(formatCommitMessage(answers));
+	}).catch(() => {});
+}
+
+//#endregion
+export { prompter };