diff --git a/.gitignore b/.gitignore
index 8e1e11b2d8..c9d515cd7d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,3 +11,4 @@ lib/
 package.json.lerna_backup
 /*.iml
 tsconfig.tsbuildinfo
+coverage
diff --git a/@commitlint/cli/src/cli.test.ts b/@commitlint/cli/src/cli.test.ts
index 6507182032..ea67ee2db1 100644
--- a/@commitlint/cli/src/cli.test.ts
+++ b/@commitlint/cli/src/cli.test.ts
@@ -1,8 +1,8 @@
-import path from 'path';
 import {fix, git} from '@commitlint/test';
 import execa from 'execa';
-import merge from 'lodash/merge';
 import fs from 'fs-extra';
+import merge from 'lodash/merge';
+import path from 'path';
 
 const bin = require.resolve('../cli.js');
 
@@ -494,7 +494,8 @@ test('should print config', async () => {
 		  defaultIgnores: undefined,
 		  plugins: {},
 		  rules: { 'type-enum': [ 2, 'never', [ 'foo' ] ] },
-		  helpUrl: 'https://github.com/conventional-changelog/commitlint/#what-is-commitlint'
+		  helpUrl: 'https://github.com/conventional-changelog/commitlint/#what-is-commitlint',
+		  prompt: {}
 		}"
 	`);
 });
diff --git a/@commitlint/config-conventional/index.js b/@commitlint/config-conventional/index.js
index 8a7e3bd15a..b772bc333a 100644
--- a/@commitlint/config-conventional/index.js
+++ b/@commitlint/config-conventional/index.js
@@ -33,4 +33,103 @@ module.exports = {
 			],
 		],
 	},
+	prompt: {
+		questions: {
+			type: {
+				description: "Select the type of change that you're committing:",
+				enum: {
+					feat: {
+						description: 'A new feature',
+						title: 'Features',
+						emoji: '✨',
+					},
+					fix: {
+						description: 'A bug fix',
+						title: 'Bug Fixes',
+						emoji: '🐛',
+					},
+					docs: {
+						description: 'Documentation only changes',
+						title: 'Documentation',
+						emoji: '📚',
+					},
+					style: {
+						description:
+							'Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)',
+						title: 'Styles',
+						emoji: '💎',
+					},
+					refactor: {
+						description:
+							'A code change that neither fixes a bug nor adds a feature',
+						title: 'Code Refactoring',
+						emoji: '📦',
+					},
+					perf: {
+						description: 'A code change that improves performance',
+						title: 'Performance Improvements',
+						emoji: '🚀',
+					},
+					test: {
+						description: 'Adding missing tests or correcting existing tests',
+						title: 'Tests',
+						emoji: '🚨',
+					},
+					build: {
+						description:
+							'Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)',
+						title: 'Builds',
+						emoji: '🛠',
+					},
+					ci: {
+						description:
+							'Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)',
+						title: 'Continuous Integrations',
+						emoji: '⚙️',
+					},
+					chore: {
+						description: "Other changes that don't modify src or test files",
+						title: 'Chores',
+						emoji: '♻️',
+					},
+					revert: {
+						description: 'Reverts a previous commit',
+						title: 'Reverts',
+						emoji: '🗑',
+					},
+				},
+			},
+			scope: {
+				description:
+					'What is the scope of this change (e.g. component or file name)',
+			},
+			subject: {
+				description:
+					'Write a short, imperative tense description of the change',
+			},
+			body: {
+				description: 'Provide a longer description of the change',
+			},
+			isBreaking: {
+				description: 'Are there any breaking changes?',
+			},
+			breakingBody: {
+				description:
+					'A BREAKING CHANGE commit requires a body. Please enter a longer description of the commit itself',
+			},
+			breaking: {
+				description: 'Describe the breaking changes',
+			},
+			isIssueAffected: {
+				description: 'Does this change affect any open issues?',
+			},
+			issuesBody: {
+				description:
+					'If issues are closed, the commit requires a body. Please enter a longer description of the commit itself',
+			},
+			issues: {
+				description: 'Add issue references (e.g. "fix #123", "re #123".)',
+			},
+		},
+	},
 };
diff --git a/@commitlint/cz-commitlint/.gitignore b/@commitlint/cz-commitlint/.gitignore
new file mode 100644
index 0000000000..722d5e71d9
--- /dev/null
+++ b/@commitlint/cz-commitlint/.gitignore
@@ -0,0 +1 @@
+.vscode
diff --git a/@commitlint/cz-commitlint/README.md b/@commitlint/cz-commitlint/README.md
new file mode 100644
index 0000000000..3f572ba595
--- /dev/null
+++ b/@commitlint/cz-commitlint/README.md
@@ -0,0 +1,88 @@
+> Commitizen adapter using the commitlint.config.js
+
+# @commitlint/cz-commitlint
+
+This is a commitizen adapter, using this adapter, commitizen works based on commitlint.config.js.
+
+Submit by commitizen, lint by commitlint, just need maintain one configuration file, Consistent and Scalable.
+
+The interactive process is inspired by [cz-conventional-changelog](https://github.com/commitizen/cz-conventional-changelog).
+
+## Getting started
+
+### Using commitizen adapter
+
+```bash
+npm install --save-dev @commitlint/cz-commitlint commitizen
+```
+
+In package.json
+
+```
+{
+  "scripts": {
+    "commit": "git-cz"
+  },
+  "config": {
+    "commitizen": {
+      "path": "@commitlint/cz-commitlint"
+    }
+  }
+}
+```
+
+### Configure commitlint
+
+```bash
+# Install commitlint cli and conventional config
+npm install --save-dev @commitlint/config-conventional @commitlint/cli
+
+# Simple: config with conventional
+echo "module.exports = {extends: ['@commitlint/config-conventional']};" > commitlint.config.js
+
+# commitlint configuration is shareable,
+# Install lerna-scopes
+npm install --save-dev @commitlint/config-lerna-scopes
+# Scalable: config with lerna-scopes in monorepo mode
+echo "module.exports = {extends: ['@commitlint/config-conventional', '@commitlint/config-lerna-scopes']};" > commitlint.config.js
+```
+
+### Set Git Hooks by husky
+
+```base
+
+# ------- using npm ----------
+# Install Husky
+npm install husky --save-dev
+# Active hooks
+npx husky install
+# Add commitlint hook
+npx husky add .husky/commit-msg 'npx --no-install commitlint --edit $1'
+# Add commitizen hook
+npx husky add .husky/prepare-commit-msg 'exec < /dev/tty && node_modules/.bin/cz --hook || true'
+
+
+# ------- using yarn ----------
+# Install Husky
+yarn add husky --dev
+# Active hooks
+yarn husky install
+# Add commitlint hook
+yarn husky add .husky/commit-msg 'yarn --no-install commitlint --edit $1'
+# Add commitizen hook
+yarn husky add .husky/prepare-commit-msg 'exec < /dev/tty && node_modules/.bin/cz --hook || true'
+
+```
+
+### Try it out
+
+```bash
+git add .
+npm run commit
+# or
+yarn run commit
+```
+
+## Related
+
+- [Commitlint Shared Configuration](https://github.com/conventional-changelog/commitlint#shared-configuration) - You can find more shared configurations are available to install and use with commitlint
diff --git a/@commitlint/cz-commitlint/TODO b/@commitlint/cz-commitlint/TODO
new file mode 100644
index 0000000000..689365d222
--- /dev/null
+++ b/@commitlint/cz-commitlint/TODO
@@ -0,0 +1,5 @@
+[x] jest Test
+[x] insert prompt settings to commitlint.config.js
+[] support multi line
+[] support emoji and title
+[] recognize "signed-off-by" and "references-empty" rules
diff --git a/@commitlint/cz-commitlint/license.md b/@commitlint/cz-commitlint/license.md
new file mode 100644
index 0000000000..d13cc4b26a
--- /dev/null
+++ b/@commitlint/cz-commitlint/license.md
@@ -0,0 +1,19 @@
+The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/@commitlint/cz-commitlint/package.json b/@commitlint/cz-commitlint/package.json
new file mode 100644
index 0000000000..7a8e89ced7
--- /dev/null
+++ b/@commitlint/cz-commitlint/package.json
@@ -0,0 +1,42 @@
+{
+  "name": "cz-commitlint",
+  "version": "1.0.0",
+  "description": "Commitizen adapter using the commitlint.config.js",
+  "main": "./lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "commit": "git-cz"
+  },
+  "homepage": "https://github.com/conventional-changelog/commitlint#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/conventional-changelog/commitlint.git"
+  },
+  "engineStrict": true,
+  "engines": {
+    "node": ">= 10"
+  },
+  "author": "Curly Brackets <water.curly@outlook.com>",
+  "license": "MIT",
+  "config": {
+    "commitizen": {
+      "path": "./@commitlint/cz-commitlint"
+    }
+  },
+  "dependencies": {
+    "@commitlint/load": "^12.1.1",
+    "@commitlint/types": "^12.1.1",
+    "chalk": "^4.1.0",
+    "lodash": "^4.17.21",
+    "word-wrap": "^1.2.3"
+  },
+  "peerDependencies": {
+    "commitizen": "^4.0.3",
+    "inquirer": "^8.0.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^7.3.1"
+  }
+}
diff --git a/@commitlint/cz-commitlint/src/Process.test.ts b/@commitlint/cz-commitlint/src/Process.test.ts
new file mode 100644
index 0000000000..c5de547c79
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/Process.test.ts
@@ -0,0 +1,241 @@
+import {QualifiedRules, UserPromptConfig} from '@commitlint/types';
+import {Answers, DistinctQuestion} from 'inquirer';
+import isFunction from 'lodash/isFunction';
+import process from './Process';
+
+const mockShowTitle = jest.fn();
+const mockShowValidation = jest.fn((message) => message);
+
+// mock inquirer
+const mockPrompt = jest.fn(function (questions, answers) {
+	for (const {name, message, when, filter, validate} of questions) {
+		if (!when || when(answers)) {
+			const title =
+				message && isFunction(message)
+					? message(answers)
+					: typeof message === 'string'
+					? message
+					: '';
+			mockShowTitle(title);
+
+			const validation: boolean | string =
+				!validate || validate(answers[name] ?? '', answers);
+
+			if (typeof validation === 'string') {
+				mockShowValidation(validation);
+				break;
+			} else {
+				if (filter && answers[name]) {
+					answers[name] = filter(answers[name]);
+				}
+			}
+		}
+	}
+});
+
+function InquirerFactory(answers: Answers) {
+	const inquirer = {
+		prompt: function (questions: DistinctQuestion) {
+			return {
+				then: function (callback: (answers: Answers) => void) {
+					mockPrompt(questions, answers);
+					callback(answers);
+				},
+			};
+		},
+	};
+
+	return inquirer;
+}
+
+const MESSAGES = {
+	skip: '(press enter to skip)',
+	max: 'upper %d chars',
+	min: '%d chars at least',
+	emptyWarning: '%s can not be empty',
+	upperLimitWarning: '%s: %s over limit %d',
+	lowerLimitWarning: '%s: %s below limit %d',
+};
+
+let rules: QualifiedRules;
+let prompts: UserPromptConfig;
+
+afterEach(() => {
+	mockShowTitle.mockClear();
+	mockShowValidation.mockClear();
+});
+
+describe('conventional-changlog', () => {
+	beforeEach(() => {
+		rules = {
+			'body-leading-blank': [1, 'always'],
+			'body-max-line-length': [2, 'always', 100],
+			'footer-leading-blank': [1, 'always'],
+			'footer-max-line-length': [2, 'always', 100],
+			'header-max-length': [2, 'always', 100],
+			'subject-case': [
+				2,
+				'never',
+				['sentence-case', 'start-case', 'pascal-case', 'upper-case'],
+			],
+			'subject-empty': [2, 'never'],
+			'subject-full-stop': [2, 'never', '.'],
+			'type-case': [2, 'always', 'lower-case'],
+			'type-empty': [2, 'never'],
+			'type-enum': [
+				2,
+				'always',
+				[
+					'build',
+					'chore',
+					'ci',
+					'docs',
+					'feat',
+					'fix',
+					'perf',
+					'refactor',
+					'revert',
+					'style',
+					'test',
+				],
+			],
+		} as any;
+		prompts = {
+			messages: MESSAGES,
+			questions: {
+				type: {
+					description: "Select the type of change that you're committing:",
+					enum: {
+						feat: {
+							description: 'A new feature',
+							title: 'Features',
+							emoji: '✨',
+						},
+						fix: {
+							description: 'A bug fix',
+							title: 'Bug Fixes',
+							emoji: '🐛',
+						},
+						docs: {
+							description: 'Documentation only changes',
+							title: 'Documentation',
+							emoji: '📚',
+						},
+						style: {
+							description:
+								'Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)',
+							title: 'Styles',
+							emoji: '💎',
+						},
+						refactor: {
+							description:
+								'A code change that neither fixes a bug nor adds a feature',
+							title: 'Code Refactoring',
+							emoji: '📦',
+						},
+						perf: {
+							description: 'A code change that improves performance',
+							title: 'Performance Improvements',
+							emoji: '🚀',
+						},
+						test: {
+							description: 'Adding missing tests or correcting existing tests',
+							title: 'Tests',
+							emoji: '🚨',
+						},
+						build: {
+							description:
+								'Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)',
+							title: 'Builds',
+							emoji: '🛠',
+						},
+						ci: {
+							description:
+								'Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)',
+							title: 'Continuous Integrations',
+							emoji: '⚙️',
+						},
+						chore: {
+							description: "Other changes that don't modify src or test files",
+							title: 'Chores',
+							emoji: '♻️',
+						},
+						revert: {
+							description: 'Reverts a previous commit',
+							title: 'Reverts',
+							emoji: '🗑',
+						},
+					},
+				},
+				scope: {
+					description:
+						'What is the scope of this change (e.g. component or file name)',
+				},
+				subject: {
+					description:
+						'Write a short, imperative tense description of the change',
+				},
+				body: {
+					description: 'Provide a longer description of the change',
+				},
+				isBreaking: {
+					description: 'Are there any breaking changes?',
+				},
+				breakingBody: {
+					description:
+						'A BREAKING CHANGE commit requires a body. Please enter a longer description of the commit itself',
+				},
+				breaking: {
+					description: 'Describe the breaking changes',
+				},
+				isIssueAffected: {
+					description: 'Does this change affect any open issues?',
+				},
+				issuesBody: {
+					description:
+						'If issues are closed, the commit requires a body. Please enter a longer description of the commit itself',
+				},
+				issues: {
+					description: 'Add issue references (e.g. "fix #123", "re #123".)',
+				},
+			},
+		};
+	});
+	test('should process works well', () => {
+		const answers = {
+			type: 'refactor',
+			scope: 'prompt',
+			subject: 'refactor prompt based on inquirer',
+			body: 'inspired by commitizen/cz-conventional-changelog',
+			isBreaking: true,
+			breaking: 'refactor types',
+			isIssueAffected: true,
+			issues: 'https://github.com/conventional-changelog/commitlint/issues/94',
+		};
+		return process(rules as any, prompts, InquirerFactory(answers) as any).then(
+			(commitMessage) => {
+				expect(commitMessage).toBe(
+					'refactor(prompt): refactor prompt based on inquirer\n\ninspired by commitizen/cz-conventional-changelog\n\nBREAKING CHANGE: refactor types\nhttps://github.com/conventional-changelog/commitlint/issues/94'
+				);
+			}
+		);
+	});
+
+	test('should show validation and stop process when subject is empty', () => {
+		const answers = {
+			type: 'refactor',
+			scope: 'prompt',
+			body: 'inspired by commitizen/cz-conventional-changelog',
+			isBreaking: true,
+			breaking: 'refactor types',
+			isIssueAffected: true,
+			issues: 'https://github.com/conventional-changelog/commitlint/issues/94',
+		};
+		return process(rules as any, prompts, InquirerFactory(answers) as any).then(
+			() => {
+				expect(mockShowValidation).toBeCalledWith('subject can not be empty');
+				expect(mockShowTitle).toBeCalledTimes(3);
+			}
+		);
+	});
+});
diff --git a/@commitlint/cz-commitlint/src/Process.ts b/@commitlint/cz-commitlint/src/Process.ts
new file mode 100644
index 0000000000..f1ec42d36f
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/Process.ts
@@ -0,0 +1,36 @@
+import {QualifiedRules, UserPromptConfig} from '@commitlint/types';
+import {Inquirer} from 'inquirer';
+import {
+	combineCommitMessage as combineBody,
+	getQuestions as getBodyQuestions,
+} from './SectionBody';
+import {
+	combineCommitMessage as combineFooter,
+	getQuestions as getFooterQuestions,
+} from './SectionFooter';
+import {
+	combineCommitMessage as combineHeader,
+	getQuestions as getHeaderQuestions,
+} from './SectionHeader';
+import {setPromptConfig} from './store/prompts';
+import {setRules} from './store/rules';
+
+export default async function (
+	rules: QualifiedRules,
+	prompts: UserPromptConfig,
+	inquirer: Inquirer
+): Promise<string> {
+	setRules(rules);
+	setPromptConfig(prompts);
+	const questions = [
+		...getHeaderQuestions(),
+		...getBodyQuestions(),
+		...getFooterQuestions(),
+	];
+	const answers = await inquirer.prompt(questions);
+	const header = combineHeader(answers);
+	const body = combineBody(answers);
+	const footer = combineFooter(answers);
+
+	return [header, body, footer].filter(Boolean).join('\n');
+}
diff --git a/@commitlint/cz-commitlint/src/Question.test.ts b/@commitlint/cz-commitlint/src/Question.test.ts
new file mode 100644
index 0000000000..9f94dfe90b
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/Question.test.ts
@@ -0,0 +1,317 @@
+import chalk from 'chalk';
+import inquirer, {Answers, InputQuestionOptions} from 'inquirer';
+import Question from './Question';
+
+const MESSAGES = {
+	skip: '(press enter to skip)',
+	max: 'upper %d chars',
+	min: '%d chars at least',
+	emptyWarning: '%s can not be empty',
+	upperLimitWarning: '%s: %s over limit %d',
+	lowerLimitWarning: '%s: %s below limit %d',
+};
+const QUESTION_CONFIG = {
+	title: 'please input',
+	messages: MESSAGES,
+};
+
+describe('name', () => {
+	test('should throw error when name is not a meaningful string', () => {
+		expect(
+			() =>
+				new Question('' as any, {
+					...QUESTION_CONFIG,
+				})
+		).toThrow();
+
+		expect(
+			() =>
+				new Question(
+					function () {
+						return 'scope';
+					} as any,
+					{
+						...QUESTION_CONFIG,
+					}
+				)
+		).toThrow();
+	});
+
+	test('should set name when name is valid', () => {
+		expect(
+			new Question('test' as any, {
+				...QUESTION_CONFIG,
+			}).question
+		).toHaveProperty('name', 'test');
+	});
+});
+
+describe('type', () => {
+	test('should return "list" type when enumList is array', () => {
+		const question = new Question('scope', {
+			...QUESTION_CONFIG,
+			enumList: ['cli', 'core'],
+		}).question;
+		expect(question).toHaveProperty('type', 'list');
+		expect(question).toHaveProperty('choices', ['cli', 'core']);
+		expect(question).not.toHaveProperty('transformer');
+	});
+
+	test('should contain "skip" list item when enumList is array and skip is true', () => {
+		const question = new Question('scope', {
+			...QUESTION_CONFIG,
+			enumList: ['cli', 'core'],
+			skip: true,
+		}).question;
+		expect(question).toHaveProperty('type', 'list');
+		expect(question).toHaveProperty('choices', [
+			'cli',
+			'core',
+			new inquirer.Separator(),
+			{
+				name: 'empty',
+				value: '',
+			},
+		]);
+		expect(question).not.toHaveProperty('transformer');
+	});
+
+	test('should return "confirm" type when name is start with "is"', () => {
+		const question = new Question('isSubmit' as any, {
+			...QUESTION_CONFIG,
+		}).question;
+		expect(question).toHaveProperty('type', 'confirm');
+		expect(question).not.toHaveProperty('choices');
+		expect(question).not.toHaveProperty('transformer');
+	});
+
+	test('should return "input" type in other cases', () => {
+		const question = new Question('body', {
+			...QUESTION_CONFIG,
+		}).question;
+		expect(question).toHaveProperty('type', 'input');
+		expect(question).not.toHaveProperty('choices');
+		expect(question).toHaveProperty('transformer', expect.any(Function));
+	});
+});
+
+describe('message', () => {
+	test('should display title when it is not input', () => {
+		const question = new Question('body', {
+			...QUESTION_CONFIG,
+			enumList: ['cli', 'core'],
+		}).question;
+		expect(question).toHaveProperty('message', expect.any(Function));
+		expect((question.message as any)()).toBe('please input: ');
+	});
+
+	test('should display skip hint when it is input and can skip', () => {
+		const question = new Question('body' as any, {
+			...QUESTION_CONFIG,
+			skip: true,
+		}).question;
+		expect(question).toHaveProperty('message', expect.any(Function));
+		expect((question.message as any)()).toBe(
+			'please input(press enter to skip): \n'
+		);
+	});
+
+	test('should not display skip hint when it is input and without skip string', () => {
+		const question = new Question('scope', {
+			...QUESTION_CONFIG,
+			messages: {},
+			skip: true,
+		} as any).question;
+		expect(question).toHaveProperty('message', expect.any(Function));
+		expect((question.message as any)()).toBe('please input: \n');
+	});
+
+	test('should display upper limit hint when it is input and has max length', () => {
+		const question = new Question('scope', {
+			...QUESTION_CONFIG,
+			maxLength: 80,
+		} as any).question;
+		expect(question).toHaveProperty('message', expect.any(Function));
+		expect((question.message as any)()).toBe('please input: upper 80 chars\n');
+	});
+
+	test('should display lower limit hint when it is input and has min length', () => {
+		const question = new Question('scope', {
+			...QUESTION_CONFIG,
+			minLength: 10,
+		} as any).question;
+		expect(question).toHaveProperty('message', expect.any(Function));
+		expect((question.message as any)()).toBe(
+			'please input: 10 chars at least\n'
+		);
+	});
+
+	test('should display hints with correct format', () => {
+		const question = new Question('scope', {
+			...QUESTION_CONFIG,
+			minLength: 10,
+			maxLength: 80,
+			skip: true,
+		} as any).question;
+		expect(question).toHaveProperty('message', expect.any(Function));
+		expect((question.message as any)()).toBe(
+			'please input(press enter to skip): 10 chars at least, upper 80 chars\n'
+		);
+	});
+
+	test('should execute function beforeQuestionStart when init message', () => {
+		const mockFn = jest.fn();
+		class CustomQuestion extends Question {
+			beforeQuestionStart(answers: Answers): void {
+				mockFn(answers);
+			}
+		}
+		const question = new CustomQuestion('body', {
+			...QUESTION_CONFIG,
+		} as any).question;
+		expect(question).toHaveProperty('message', expect.any(Function));
+
+		const answers = {
+			header: 'This is header',
+			footer: 'This is footer',
+		};
+		(question.message as any)(answers);
+		expect(mockFn).toHaveBeenCalledWith(answers);
+	});
+});
+
+describe('filter', () => {
+	test('should auto fix case and full-stop', () => {
+		const question = new Question('body', {
+			...QUESTION_CONFIG,
+			caseFn: (input: string) => input[0].toUpperCase() + input.slice(1),
+			fullStopFn: (input: string) => input + '!',
+		}).question;
+
+		expect(question.filter?.('xxxx', {})).toBe('Xxxx!');
+	});
+
+	test('should works well when does not pass caseFn/fullStopFn', () => {
+		const question = new Question('body', {
+			...QUESTION_CONFIG,
+		}).question;
+
+		expect(question.filter?.('xxxx', {})).toBe('xxxx');
+	});
+});
+
+describe('validate', () => {
+	test('should display empty warning when can not skip but string is empty', () => {
+		const question = new Question('body', {
+			...QUESTION_CONFIG,
+			skip: false,
+		}).question;
+
+		expect(question.validate?.('')).toBe('body can not be empty');
+	});
+
+	test('should ignore empty validation when can skip', () => {
+		const question = new Question('body', {
+			...QUESTION_CONFIG,
+			skip: true,
+		}).question;
+
+		expect(question.validate?.('')).toBe(true);
+	});
+
+	test('should display upper limit warning when char count is over upper limit', () => {
+		const question = new Question('body', {
+			...QUESTION_CONFIG,
+			maxLength: 5,
+		}).question;
+
+		expect(question.validate?.('xxxxxx')).toBe('body: body over limit 1');
+	});
+
+	test('should display lower limit warning when char count is less than lower limit', () => {
+		const question = new Question('body', {
+			...QUESTION_CONFIG,
+			minLength: 5,
+		}).question;
+
+		expect(question.validate?.('xxx')).toBe('body: body below limit 2');
+	});
+
+	test('should validate the final submit string', () => {
+		const question = new Question('body', {
+			...QUESTION_CONFIG,
+			caseFn: () => '',
+			skip: false,
+		}).question;
+
+		expect(question.validate?.('xxxx')).not.toBe(true);
+	});
+});
+
+describe('transformer', () => {
+	test('should auto transform case and full-stop', () => {
+		const question = new Question('body', {
+			...QUESTION_CONFIG,
+			caseFn: (input: string) => input[0].toUpperCase() + input.slice(1),
+			fullStopFn: (input: string) => input + '!',
+		}).question;
+
+		expect(
+			(question as InputQuestionOptions)?.transformer?.('xxxx', {}, {})
+		).toBe('Xxxx!');
+	});
+
+	test('should char count with green color when in the limit range', () => {
+		let question = new Question('body', {
+			...QUESTION_CONFIG,
+			maxLength: 5,
+		}).question;
+
+		expect(
+			(question as InputQuestionOptions)?.transformer?.('xxx', {}, {})
+		).toEqual(chalk.green(`(3) xxx`));
+
+		question = new Question('body', {
+			...QUESTION_CONFIG,
+			minLength: 2,
+		}).question;
+
+		expect(
+			(question as InputQuestionOptions)?.transformer?.('xxx', {}, {})
+		).toEqual(chalk.green(`(3) xxx`));
+	});
+
+	test('should char count with red color when over the limit range', () => {
+		let question = new Question('body', {
+			...QUESTION_CONFIG,
+			maxLength: 5,
+		}).question;
+
+		expect(
+			(question as InputQuestionOptions)?.transformer?.('xxxxxx', {}, {})
+		).toEqual(chalk.red(`(6) xxxxxx`));
+
+		question = new Question('body', {
+			...QUESTION_CONFIG,
+			minLength: 2,
+		}).question;
+
+		expect(
+			(question as InputQuestionOptions)?.transformer?.('x', {}, {})
+		).toEqual(chalk.red(`(1) x`));
+	});
+});
+
+describe('inquirer question', () => {
+	test('should pass "when" and "default" field to inquirer question', () => {
+		const when = (answers: Answers) => !!answers.header;
+		const question = new Question('body', {
+			...QUESTION_CONFIG,
+			when,
+			defaultValue: 'update',
+		}).question;
+
+		expect(question).toHaveProperty('default', 'update');
+		expect(question).toHaveProperty('when', when);
+	});
+});
diff --git a/@commitlint/cz-commitlint/src/Question.ts b/@commitlint/cz-commitlint/src/Question.ts
new file mode 100644
index 0000000000..4abec6b53c
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/Question.ts
@@ -0,0 +1,186 @@
+import {PromptMessages, PromptName} from '@commitlint/types';
+import chalk from 'chalk';
+import inquirer, {Answers, ChoiceCollection, DistinctQuestion} from 'inquirer';
+import {CaseFn} from './utils/case-fn';
+import {FullStopFn} from './utils/full-stop-fn';
+
+export type QuestionConfig = {
+	title: string;
+	messages: PromptMessages;
+	maxLength?: number;
+	minLength?: number;
+	defaultValue?: string;
+	when?: DistinctQuestion['when'];
+	skip?: boolean;
+	enumList?: ChoiceCollection<{
+		name: string;
+		value: string;
+	}> | null;
+	fullStopFn?: FullStopFn;
+	caseFn?: CaseFn;
+};
+
+export default class Question {
+	private _question: Readonly<DistinctQuestion>;
+	private messages: PromptMessages;
+	private skip: boolean;
+	private _maxLength: number;
+	private _minLength: number;
+	private title: string;
+	private caseFn: CaseFn;
+	private fullStopFn: FullStopFn;
+	constructor(
+		name: PromptName,
+		{
+			title,
+			enumList,
+			messages,
+			defaultValue,
+			when,
+			skip,
+			fullStopFn,
+			caseFn,
+			maxLength,
+			minLength,
+		}: QuestionConfig
+	) {
+		if (!name || typeof name !== 'string')
+			throw new Error('Question: name is required');
+
+		this._maxLength = maxLength ?? Infinity;
+		this._minLength = minLength ?? 0;
+		this.messages = messages;
+		this.title = title ?? '';
+		this.skip = skip ?? false;
+		this.fullStopFn = fullStopFn ?? ((_: string) => _);
+		this.caseFn = caseFn ?? ((_: string) => _);
+
+		if (enumList && Array.isArray(enumList)) {
+			this._question = {
+				type: 'list',
+				choices: skip
+					? [
+							...enumList,
+							new inquirer.Separator(),
+							{
+								name: 'empty',
+								value: '',
+							},
+					  ]
+					: [...enumList],
+			};
+		} else if (/^is[A-Z]/.test(name)) {
+			this._question = {
+				type: 'confirm',
+			};
+		} else {
+			this._question = {
+				type: 'input',
+				transformer: this.transformer.bind(this),
+			};
+		}
+
+		Object.assign(this._question, {
+			name,
+			default: defaultValue,
+			when,
+			validate: this.validate.bind(this),
+			filter: this.filter.bind(this),
+			message: this.decorateMessage.bind(this),
+		});
+	}
+
+	getMessage(key: string): string {
+		return this.messages[key] ?? '';
+	}
+
+	get question(): Readonly<DistinctQuestion> {
+		return this._question;
+	}
+
+	get maxLength(): number {
+		return this._maxLength;
+	}
+
+	set maxLength(maxLength: number) {
+		this._maxLength = maxLength;
+	}
+
+	get minLength(): number {
+		return this._minLength;
+	}
+
+	set minLength(minLength: number) {
+		this._minLength = minLength;
+	}
+
+	protected beforeQuestionStart(_answers: Answers): void {
+		return;
+	}
+
+	protected validate(input: string): boolean | string {
+		const output = this.filter(input);
+		const questionName = this.question.name ?? '';
+		if (!this.skip && output.length === 0) {
+			return this.getMessage('emptyWarning').replace(/%s/g, questionName);
+		}
+
+		if (output.length > this.maxLength) {
+			return this.getMessage('upperLimitWarning')
+				.replace(/%s/g, questionName)
+				.replace(/%d/g, `${output.length - this.maxLength}`);
+		}
+
+		if (output.length < this.minLength) {
+			return this.getMessage('lowerLimitWarning')
+				.replace(/%s/g, questionName)
+				.replace(/%d/g, `${this.minLength - output.length}`);
+		}
+
+		return true;
+	}
+
+	protected filter(input: string): string {
+		return this.caseFn(this.fullStopFn(input));
+	}
+
+	protected transformer(input: string, _answers: Answers): string {
+		const output = this.filter(input);
+
+		if (this.maxLength === Infinity && this.minLength === 0) {
+			return output;
+		}
+		const color =
+			output.length <= this.maxLength && output.length >= this.minLength
+				? chalk.green
+				: chalk.red;
+		return color('(' + output.length + ') ' + input);
+	}
+
+	protected decorateMessage(_answers: Answers): string {
+		this.beforeQuestionStart && this.beforeQuestionStart(_answers);
+		if (this.question.type === 'input') {
+			const countLimitMessage = (() => {
+				const messages = [];
+				if (this.minLength > 0 && this.getMessage('min')) {
+					messages.push(
+						this.getMessage('min').replace(/%d/g, this.minLength + '')
+					);
+				}
+				if (this.maxLength < Infinity && this.getMessage('max')) {
+					messages.push(
+						this.getMessage('max').replace(/%d/g, this.maxLength + '')
+					);
+				}
+
+				return messages.join(', ');
+			})();
+
+			const skipMessage = this.skip ? this.getMessage('skip') : '';
+
+			return this.title + skipMessage + ': ' + countLimitMessage + '\n';
+		} else {
+			return this.title + ': ';
+		}
+	}
+}
diff --git a/@commitlint/cz-commitlint/src/SectionBody.test.ts b/@commitlint/cz-commitlint/src/SectionBody.test.ts
new file mode 100644
index 0000000000..12e4acc6e5
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/SectionBody.test.ts
@@ -0,0 +1,77 @@
+import {RuleConfigSeverity} from '@commitlint/types';
+import {combineCommitMessage, getQuestions} from './SectionBody';
+import {setRules} from './store/rules';
+
+describe('getQuestions', () => {
+	test('should exclude question when body must be empty', () => {
+		setRules({
+			'body-empty': [RuleConfigSeverity.Error, 'always'],
+		});
+		const questions = getQuestions();
+		expect(questions).toHaveLength(0);
+	});
+
+	test('should only return body question', () => {
+		setRules({});
+		const questions = getQuestions();
+		expect(questions).toHaveLength(1);
+		expect(questions).toEqual([
+			expect.objectContaining({
+				name: 'body',
+			}),
+		]);
+	});
+});
+
+describe('combineCommitMessage', () => {
+	test('should wrap message to multi lines when max-line-length set', () => {
+		setRules({
+			'body-max-line-length': [RuleConfigSeverity.Error, 'always', 10],
+		});
+
+		const commitMessage = combineCommitMessage({
+			body: 'This is the body message.',
+		});
+
+		expect(commitMessage).toBe('This is\nthe body\nmessage.');
+	});
+
+	test('should auto apply leading blank', () => {
+		setRules({
+			'body-leading-blank': [RuleConfigSeverity.Error, 'always'],
+		});
+
+		const commitMessage = combineCommitMessage({
+			body: 'This is the body message.',
+		});
+
+		expect(commitMessage).toBe('\nThis is the body message.');
+	});
+
+	test('should return correct string when leading-blank and max-line-length both set', () => {
+		setRules({
+			'body-max-line-length': [RuleConfigSeverity.Error, 'always', 10],
+			'body-leading-blank': [RuleConfigSeverity.Error, 'always'],
+		});
+		const commitMessage = combineCommitMessage({
+			body: 'This is the body message.',
+		});
+		expect(commitMessage).toBe('\nThis is\nthe body\nmessage.');
+	});
+
+	test('should use breakingBody when body message is empty but commit has BREAK CHANGE', () => {
+		setRules({});
+		const commitMessage = combineCommitMessage({
+			breakingBody: 'This is breaking body message.',
+		});
+		expect(commitMessage).toBe('This is breaking body message.');
+	});
+
+	test('should use issueBody when body message is empty but commit has issue note', () => {
+		setRules({});
+		const commitMessage = combineCommitMessage({
+			issuesBody: 'This is issue body message.',
+		});
+		expect(commitMessage).toBe('This is issue body message.');
+	});
+});
diff --git a/@commitlint/cz-commitlint/src/SectionBody.ts b/@commitlint/cz-commitlint/src/SectionBody.ts
new file mode 100644
index 0000000000..de528b8858
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/SectionBody.ts
@@ -0,0 +1,37 @@
+import {Answers, DistinctQuestion} from 'inquirer';
+import wrap from 'word-wrap';
+import Question from './Question';
+import getRuleQuestionConfig from './services/getRuleQuestionConfig';
+import {getRule} from './store/rules';
+import getLeadingBlankFn from './utils/leading-blank-fn';
+import {getMaxLength} from './utils/rules';
+
+export function getQuestions(): Array<DistinctQuestion> {
+	// body
+	const questionConfig = getRuleQuestionConfig('body');
+
+	if (!questionConfig) return [];
+	else return [new Question('body', questionConfig).question];
+}
+
+export function combineCommitMessage(answers: Answers): string {
+	const maxLineLength = getMaxLength(getRule('body', 'max-line-length'));
+	const leadingBlankFn = getLeadingBlankFn(getRule('body', 'leading-blank'));
+	const {body, breakingBody, issuesBody} = answers;
+
+	const commitBody = body ?? breakingBody ?? issuesBody ?? '-';
+
+	if (commitBody) {
+		return leadingBlankFn(
+			maxLineLength < Infinity
+				? wrap(commitBody, {
+						width: maxLineLength,
+						trim: true,
+						indent: '',
+				  })
+				: commitBody.trim()
+		);
+	} else {
+		return '';
+	}
+}
diff --git a/@commitlint/cz-commitlint/src/SectionFooter.test.ts b/@commitlint/cz-commitlint/src/SectionFooter.test.ts
new file mode 100644
index 0000000000..06752401d5
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/SectionFooter.test.ts
@@ -0,0 +1,314 @@
+import {RuleConfigSeverity} from '@commitlint/types';
+import {combineCommitMessage, getQuestions} from './SectionFooter';
+import {setPromptConfig} from './store/prompts';
+import {setRules} from './store/rules';
+
+beforeEach(() => {
+	setRules({});
+	setPromptConfig({});
+});
+describe('getQuestions', () => {
+	test('should only ask questions that listed in prompt question config', () => {
+		setPromptConfig({
+			questions: {
+				footer: {
+					description:
+						'<footer> holds further meta data, such as breaking changes and issue ids',
+				},
+				issues: {
+					description: '<issues> link',
+				},
+			},
+		});
+
+		const questions = getQuestions();
+
+		expect(questions).toHaveLength(2);
+		expect(questions).toEqual([
+			expect.objectContaining({
+				name: 'issues',
+			}),
+			expect.objectContaining({
+				name: 'footer',
+			}),
+		]);
+	});
+
+	test('should not have break change as default', () => {
+		setPromptConfig({
+			questions: {
+				isBreaking: {
+					description: 'Are there any breaking changes?',
+				},
+			},
+		});
+
+		const questions = getQuestions();
+		expect(questions).toEqual([
+			expect.objectContaining({
+				name: 'isBreaking',
+				default: false,
+			}),
+		]);
+	});
+
+	test('should ask for break change info when have break change', () => {
+		setPromptConfig({
+			questions: {
+				isBreaking: {
+					description: 'Are there any breaking changes?',
+				},
+				breaking: {
+					description: 'Describe the breaking changes',
+				},
+			},
+		});
+
+		const questions = getQuestions();
+		expect(
+			(questions[1].when as any)({
+				isBreaking: false,
+			})
+		).toBe(false);
+		expect(
+			(questions[1].when as any)({
+				isBreaking: true,
+			})
+		).toBe(true);
+	});
+
+	test('should ask for body info when have break change but does not have body message', () => {
+		setPromptConfig({
+			questions: {
+				isBreaking: {
+					description: 'Describe the breaking changes',
+				},
+				breakingBody: {
+					description:
+						'A BREAKING CHANGE commit requires a body. Please enter a longer description of the commit itself',
+				},
+			},
+		});
+
+		const questions = getQuestions();
+
+		expect(
+			(questions[1].when as any)({
+				isBreaking: true,
+			})
+		).toBe(true);
+
+		expect(
+			(questions[1].when as any)({
+				isBreaking: true,
+				body: 'xxx',
+			})
+		).toBe(false);
+
+		expect(
+			(questions[1].when as any)({
+				isBreaking: false,
+			})
+		).toBe(false);
+	});
+
+	test('should change does not affect any issues as default', () => {
+		setPromptConfig({
+			questions: {
+				isIssueAffected: {
+					description: 'Does this change affect any open issues?',
+				},
+			},
+		});
+
+		const questions = getQuestions();
+		expect(questions).toEqual([
+			expect.objectContaining({
+				name: 'isIssueAffected',
+				default: false,
+			}),
+		]);
+	});
+
+	test('should ask for issue info when have issue affected', () => {
+		setPromptConfig({
+			questions: {
+				isIssueAffected: {
+					description: 'Does this change affect any open issues?',
+				},
+				issues: {
+					description: 'Add issue references (e.g. "fix #123", "re #123".)',
+				},
+			},
+		});
+
+		const questions = getQuestions();
+		expect(
+			(questions[1].when as any)({
+				isIssueAffected: false,
+			})
+		).toBe(false);
+		expect(
+			(questions[1].when as any)({
+				isIssueAffected: true,
+			})
+		).toBe(true);
+	});
+
+	test('should ask for body info when have issue affected but does not have body message', () => {
+		setPromptConfig({
+			questions: {
+				isIssueAffected: {
+					description: 'Does this change affect any open issues?',
+				},
+				issuesBody: {
+					description:
+						'If issues are closed, the commit requires a body. Please enter a longer description of the commit itself',
+				},
+				issues: {
+					description: 'Add issue references (e.g. "fix #123", "re #123".)',
+				},
+			},
+		});
+
+		const questions = getQuestions();
+
+		expect(
+			(questions[1].when as any)({
+				isIssueAffected: true,
+			})
+		).toBe(true);
+
+		expect(
+			(questions[1].when as any)({
+				isIssueAffected: true,
+				body: 'xxx',
+			})
+		).toBe(false);
+
+		expect(
+			(questions[1].when as any)({
+				isIssueAffected: false,
+				breaking: 'xxxxx',
+			})
+		).toBe(false);
+	});
+});
+
+describe('combineCommitMessage', () => {
+	test('should return BreakChange start with "BREAKING CHANGE: "', () => {
+		let commitMessage = combineCommitMessage({
+			breaking: 'BREAKING CHANGE: xxxxxx',
+		});
+		expect(commitMessage).toBe('BREAKING CHANGE: xxxxxx');
+
+		commitMessage = combineCommitMessage({
+			breaking: 'xxxxxx',
+		});
+		expect(commitMessage).toBe('BREAKING CHANGE: xxxxxx');
+	});
+	test('should return correct string with BreakChange,issue,footer', () => {
+		const commitMessage = combineCommitMessage({
+			issues:
+				'https://github.com/conventional-changelog/commitlint/issues/2507',
+			breaking: 'BREAKING CHANGE: xxxxxx',
+			footer: 'Other footer information.',
+		});
+		expect(commitMessage).toBe(
+			'BREAKING CHANGE: xxxxxx\nhttps://github.com/conventional-changelog/commitlint/issues/2507\nOther footer information.'
+		);
+	});
+
+	test('should return wrap string with footer-max-line-length', () => {
+		setRules({
+			'footer-max-line-length': [RuleConfigSeverity.Error, 'always', 10],
+		});
+		const commitMessage = combineCommitMessage({
+			issues:
+				'https://github.com/conventional-changelog/commitlint/issues/2507',
+			breaking: 'BREAKING CHANGE: xxxxxx',
+			footer: 'Other footer information.',
+		});
+		expect(commitMessage).toBe(
+			'BREAKING\nCHANGE:\nxxxxxx\nhttps://github.com/conventional-changelog/commitlint/issues/2507\nOther\nfooter\ninformation.'
+		);
+	});
+
+	test('should auto leading blank when footer-leading-blank is set', () => {
+		setRules({
+			'footer-max-line-length': [RuleConfigSeverity.Error, 'always', 10],
+			'footer-leading-blank': [RuleConfigSeverity.Error, 'always'],
+		});
+		const commitMessage = combineCommitMessage({
+			issues:
+				'https://github.com/conventional-changelog/commitlint/issues/2507',
+			breaking: 'BREAKING CHANGE: xxxxxx',
+			footer: 'Other footer information.',
+		});
+		expect(commitMessage).toBe(
+			'\nBREAKING\nCHANGE:\nxxxxxx\nhttps://github.com/conventional-changelog/commitlint/issues/2507\nOther\nfooter\ninformation.'
+		);
+	});
+
+	test('when does not have break change', () => {
+		const commitMessage = combineCommitMessage({
+			issues:
+				'https://github.com/conventional-changelog/commitlint/issues/2507',
+			footer: 'Other footer information.',
+		});
+		expect(commitMessage).toBe(
+			'https://github.com/conventional-changelog/commitlint/issues/2507\nOther footer information.'
+		);
+	});
+
+	test('when does not have issue', () => {
+		const commitMessage = combineCommitMessage({
+			footer: 'Other footer information.',
+		});
+		expect(commitMessage).toBe('Other footer information.');
+	});
+});
+
+describe('FooterQuestion', () => {
+	test('should limited by footer maxLength and minLength', () => {
+		setRules({
+			'footer-max-length': [RuleConfigSeverity.Error, 'always', 30],
+			'footer-min-length': [RuleConfigSeverity.Error, 'always', 10],
+		});
+		setPromptConfig({
+			messages: {
+				skip: '(press enter to skip)',
+				max: 'upper %d chars',
+				min: '%d chars at least',
+				emptyWarning: '%s can not be empty',
+				upperLimitWarning: '%s: %s over limit %d',
+				lowerLimitWarning: '%s: %s below limit %d',
+			},
+			questions: {
+				breaking: {
+					description: 'Describe the breaking changes',
+				},
+				issues: {
+					description: '<issues> link',
+				},
+				footer: {
+					description:
+						'<footer> holds further meta data, such as breaking changes and issue ids',
+				},
+			},
+		});
+
+		const questions = getQuestions();
+		const answers = {
+			breaking: 'BREAKING CHANGE: xxxxxx',
+			issues: ''.padEnd(6, 'y'),
+		};
+
+		const lastQuestion = questions[2];
+
+		(lastQuestion.message as any)(answers);
+		expect(lastQuestion?.validate?.(''.padEnd(10, 'z'), answers)).toBe(
+			'footer: footer over limit 11'
+		);
+	});
+});
diff --git a/@commitlint/cz-commitlint/src/SectionFooter.ts b/@commitlint/cz-commitlint/src/SectionFooter.ts
new file mode 100644
index 0000000000..de184cd07f
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/SectionFooter.ts
@@ -0,0 +1,174 @@
+import {PromptName} from '@commitlint/types';
+import {Answers, DistinctQuestion} from 'inquirer';
+import wrap from 'word-wrap';
+import Question, {QuestionConfig} from './Question';
+import getRuleQuestionConfig from './services/getRuleQuestionConfig';
+import {getPromptMessages, getPromptQuestions} from './store/prompts';
+import {getRule} from './store/rules';
+import getLeadingBlankFn from './utils/leading-blank-fn';
+import {getMaxLength} from './utils/rules';
+
+export class FooterQuestion extends Question {
+	footerMaxLength: number;
+	footerMinLength: number;
+	constructor(
+		name: PromptName,
+		questionConfig: QuestionConfig,
+		footerMaxLength?: number,
+		footerMinLength?: number
+	) {
+		super(name, questionConfig);
+		this.footerMaxLength = footerMaxLength ?? Infinity;
+		this.footerMinLength = footerMinLength ?? 0;
+	}
+	beforeQuestionStart(answers: Answers): void {
+		const footerRemainLength =
+			this.footerMaxLength - combineCommitMessage(answers).length - '\n'.length;
+		this.maxLength = Math.min(this.maxLength, footerRemainLength);
+		this.minLength = Math.min(this.minLength, this.footerMinLength);
+	}
+}
+
+export function getQuestions(): Array<DistinctQuestion> {
+	const footerQuestionConfig = getRuleQuestionConfig('footer');
+
+	if (!footerQuestionConfig) return [];
+
+	const footerMaxLength = footerQuestionConfig.maxLength;
+	const footerMinLength = footerQuestionConfig.minLength;
+
+	const fields: PromptName[] = [
+		'isBreaking',
+		'breakingBody',
+		'breaking',
+		'isIssueAffected',
+		'issuesBody',
+		'issues',
+		'footer',
+	];
+
+	return fields
+		.filter((name) => name in getPromptQuestions())
+		.map((name) => {
+			const questions = getPromptQuestions();
+
+			const questionConfigs = {
+				title: questions[name]?.description ?? '',
+				messages: getPromptMessages(),
+				footerMaxLength,
+				footerMinLength,
+			};
+
+			if (name === 'isBreaking') {
+				Object.assign(questionConfigs, {
+					defaultValue: false,
+				});
+			}
+
+			if (name === 'breakingBody') {
+				Object.assign(questionConfigs, {
+					when: (answers: Answers) => {
+						return answers.isBreaking && !answers.body;
+					},
+				});
+			}
+
+			if (name === 'breaking') {
+				Object.assign(questionConfigs, {
+					when: (answers: Answers) => {
+						return answers.isBreaking;
+					},
+				});
+			}
+
+			if (name === 'isIssueAffected') {
+				Object.assign(questionConfigs, {
+					defaultValue: false,
+				});
+			}
+
+			if (name === 'issuesBody') {
+				Object.assign(questionConfigs, {
+					when: (answers: Answers) => {
+						return (
+							answers.isIssueAffected && !answers.body && !answers.breakingBody
+						);
+					},
+				});
+			}
+
+			if (name === 'issues') {
+				Object.assign(questionConfigs, {
+					when: (answers: Answers) => {
+						return answers.isIssueAffected;
+					},
+				});
+			}
+
+			if (name === 'footer') {
+				Object.assign(questionConfigs, {
+					...footerQuestionConfig,
+				});
+			}
+
+			const instance = new FooterQuestion(
+				name,
+				questionConfigs,
+				footerMaxLength,
+				footerMinLength
+			);
+
+			return instance.question;
+		});
+}
+
+export function combineCommitMessage(answers: Answers): string {
+	// TODO references-empty
+	// TODO signed-off-by
+	const maxLineLength = getMaxLength(getRule('footer', 'max-line-length'));
+	const leadingBlankFn = getLeadingBlankFn(getRule('footer', 'leading-blank'));
+
+	const {footer, breaking, issues} = answers;
+	const footerNotes: string[] = [];
+
+	if (breaking) {
+		const BREAKING_CHANGE = 'BREAKING CHANGE: ';
+		const message =
+			BREAKING_CHANGE + breaking.replace(new RegExp(`^${BREAKING_CHANGE}`), '');
+		footerNotes.push(
+			maxLineLength < Infinity
+				? wrap(message, {
+						width: maxLineLength,
+						trim: true,
+						indent: '',
+				  })
+				: message.trim()
+		);
+	}
+
+	if (issues) {
+		footerNotes.push(
+			maxLineLength < Infinity
+				? wrap(issues, {
+						width: maxLineLength,
+						trim: true,
+						indent: '',
+				  })
+				: issues.trim()
+		);
+	}
+
+	if (footer) {
+		footerNotes.push(
+			maxLineLength < Infinity
+				? wrap(footer, {
+						width: maxLineLength,
+						trim: true,
+						indent: '',
+				  })
+				: footer
+		);
+	}
+
+	return leadingBlankFn(footerNotes.join('\n'));
+}
diff --git a/@commitlint/cz-commitlint/src/SectionHeader.test.ts b/@commitlint/cz-commitlint/src/SectionHeader.test.ts
new file mode 100644
index 0000000000..90fe7358be
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/SectionHeader.test.ts
@@ -0,0 +1,114 @@
+import {RuleConfigSeverity} from '@commitlint/types';
+import {combineCommitMessage, getQuestions} from './SectionHeader';
+import {setPromptConfig} from './store/prompts';
+import {setRules} from './store/rules';
+describe('getQuestions', () => {
+	test("should contain 'type','scope','subject'", () => {
+		const questions = getQuestions();
+		expect(questions).toHaveLength(3);
+		expect(questions).toEqual([
+			expect.objectContaining({
+				name: 'type',
+			}),
+			expect.objectContaining({
+				name: 'scope',
+			}),
+			expect.objectContaining({
+				name: 'subject',
+			}),
+		]);
+	});
+
+	test('should exclude question when must be empty', () => {
+		setRules({
+			'scope-empty': [RuleConfigSeverity.Error, 'always'],
+		});
+		const questions = getQuestions();
+		expect(questions).toHaveLength(2);
+		expect(questions).toEqual([
+			expect.objectContaining({
+				name: 'type',
+			}),
+			expect.objectContaining({
+				name: 'subject',
+			}),
+		]);
+	});
+});
+
+describe('combineCommitMessage', () => {
+	test('should return correct string when type,scope,subject are not empty', () => {
+		const commitMessage = combineCommitMessage({
+			type: 'build',
+			scope: 'typescript',
+			subject: 'update tsconfig.json',
+		});
+		expect(commitMessage).toBe('build(typescript): update tsconfig.json');
+	});
+	test('when type is empty', () => {
+		let commitMessage = combineCommitMessage({
+			scope: 'typescript',
+			subject: 'update tsconfig.json',
+		});
+		expect(commitMessage).toBe('(typescript): update tsconfig.json');
+
+		commitMessage = combineCommitMessage({
+			scope: 'typescript',
+		});
+		expect(commitMessage).toBe('(typescript)');
+	});
+
+	test('when scope is empty', () => {
+		let commitMessage = combineCommitMessage({
+			type: 'build',
+			subject: 'update tsconfig.json',
+		});
+		expect(commitMessage).toBe('build: update tsconfig.json');
+
+		commitMessage = combineCommitMessage({
+			subject: 'update tsconfig.json',
+		});
+		expect(commitMessage).toBe('update tsconfig.json');
+	});
+
+	test('when subject is empty', () => {
+		const commitMessage = combineCommitMessage({
+			type: 'build',
+			scope: 'typescript',
+		});
+		expect(commitMessage).toBe('build(typescript)');
+	});
+});
+
+describe('HeaderQuestion', () => {
+	test('should limited by header maxLength and minLength', () => {
+		setRules({
+			'header-max-length': [RuleConfigSeverity.Error, 'always', 20],
+			'header-min-length': [RuleConfigSeverity.Error, 'always', 10],
+			'subject-max-length': [RuleConfigSeverity.Error, 'always', 10],
+			'subject-min-length': [RuleConfigSeverity.Error, 'always', 5],
+		});
+		setPromptConfig({
+			messages: {
+				skip: '(press enter to skip)',
+				max: 'upper %d chars',
+				min: '%d chars at least',
+				emptyWarning: '%s can not be empty',
+				upperLimitWarning: '%s: %s over limit %d',
+				lowerLimitWarning: '%s: %s below limit %d',
+			},
+		});
+
+		const questions = getQuestions();
+		const answers = {
+			type: ''.padEnd(8, 'x'),
+			scope: ''.padEnd(6, 'y'),
+		};
+
+		const lastQuestion = questions[2];
+		(lastQuestion.message as any)(answers);
+		expect(lastQuestion?.validate?.(''.padEnd(10, 'z'), answers)).toBe(
+			'subject: subject over limit 6'
+		);
+	});
+});
diff --git a/@commitlint/cz-commitlint/src/SectionHeader.ts b/@commitlint/cz-commitlint/src/SectionHeader.ts
new file mode 100644
index 0000000000..9905ddcc33
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/SectionHeader.ts
@@ -0,0 +1,62 @@
+import {PromptName, RuleField} from '@commitlint/types';
+import {Answers, DistinctQuestion} from 'inquirer';
+import Question, {QuestionConfig} from './Question';
+import getRuleQuestionConfig from './services/getRuleQuestionConfig';
+
+export class HeaderQuestion extends Question {
+	headerMaxLength: number;
+	headerMinLength: number;
+	constructor(
+		name: PromptName,
+		questionConfig: QuestionConfig,
+		headerMaxLength?: number,
+		headerMinLength?: number
+	) {
+		super(name, questionConfig);
+		this.headerMaxLength = headerMaxLength ?? Infinity;
+		this.headerMinLength = headerMinLength ?? 0;
+	}
+	beforeQuestionStart(answers: Answers): void {
+		const headerRemainLength =
+			this.headerMaxLength - combineCommitMessage(answers).length;
+		this.maxLength = Math.min(this.maxLength, headerRemainLength);
+		this.minLength = Math.min(this.minLength, this.headerMinLength);
+	}
+}
+
+export function combineCommitMessage(answers: Answers): string {
+	const {type = '', scope = '', subject = ''} = answers;
+	const prefix = `${type}${scope ? `(${scope})` : ''}`;
+
+	if (subject) {
+		return ((prefix ? prefix + ': ' : '') + subject).trim();
+	} else {
+		return prefix.trim();
+	}
+}
+
+export function getQuestions(): Array<DistinctQuestion> {
+	// header: type, scope, subject
+	const questions: Array<DistinctQuestion> = [];
+
+	const headerRuleFields: RuleField[] = ['type', 'scope', 'subject'];
+	const headerRuleQuestionConfig = getRuleQuestionConfig('header');
+
+	if (!headerRuleQuestionConfig) {
+		return [];
+	}
+
+	headerRuleFields.forEach((name) => {
+		const questionConfig = getRuleQuestionConfig(name);
+		if (questionConfig) {
+			const instance = new HeaderQuestion(
+				name,
+				questionConfig,
+				headerRuleQuestionConfig.maxLength,
+				headerRuleQuestionConfig.minLength
+			);
+			questions.push(instance.question);
+		}
+	});
+	return questions;
+}
diff --git a/@commitlint/cz-commitlint/src/index.ts b/@commitlint/cz-commitlint/src/index.ts
new file mode 100644
index 0000000000..7a48d0cec1
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/index.ts
@@ -0,0 +1,16 @@
+import load from '@commitlint/load';
+import {Inquirer} from 'inquirer';
+import process from './Process';
+
+type Commit = (message: string) => void;
+/**
+ * Entry point for commitizen
+ * @param  inquirer instance passed by commitizen, unused
+ * @param commit callback to execute with complete commit message
+ * @return {void}
+ */
+export function prompter(inquirer: Inquirer, commit: Commit): void {
+	load().then(({rules, prompt = {}}) => {
+		process(rules, prompt, inquirer).then(commit);
+	});
+}
diff --git a/@commitlint/cz-commitlint/src/services/getRuleQuestionConfig.test.ts b/@commitlint/cz-commitlint/src/services/getRuleQuestionConfig.test.ts
new file mode 100644
index 0000000000..6518b58483
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/services/getRuleQuestionConfig.test.ts
@@ -0,0 +1,340 @@
+import {RuleConfigSeverity} from '@commitlint/types';
+import {setPromptConfig} from '../store/prompts';
+import {setRules} from '../store/rules';
+import getRuleQuestionConfig from './getRuleQuestionConfig';
+
+// let rules = {};
+
+// let rules: QualifiedRules = {};
+// const getRules = jest.fn().mockReturnValue(rules);
+
+describe('empty rule', () => {
+	test('should return null when must be empty', () => {
+		setRules({
+			'body-empty': [RuleConfigSeverity.Error, 'always'],
+		});
+		expect(getRuleQuestionConfig('body')).toBe(null);
+	});
+
+	test("should field 'skip' be false when can not be empty", () => {
+		setRules({
+			'body-empty': [RuleConfigSeverity.Error, 'never'],
+		});
+		expect(getRuleQuestionConfig('body')?.skip).toBe(false);
+	});
+
+	test('should field "skip" be true when not set empty rule', () => {
+		setRules({
+			'body-case': [RuleConfigSeverity.Warning, 'never', 'camel-case'],
+			'body-max-length': [RuleConfigSeverity.Error, 'always', 100],
+		});
+		expect(getRuleQuestionConfig('body')?.skip).toBe(true);
+	});
+
+	test('should field "skip" be true when disable empty rule', () => {
+		setRules({
+			'body-empty': [RuleConfigSeverity.Disabled],
+		});
+
+		expect(getRuleQuestionConfig('body')?.skip).toBe(true);
+
+		setRules({
+			'body-empty': [RuleConfigSeverity.Disabled, 'always'],
+		});
+		expect(getRuleQuestionConfig('body')?.skip).toBe(true);
+
+		setRules({
+			'body-empty': [RuleConfigSeverity.Disabled, 'never'],
+		});
+		expect(getRuleQuestionConfig('body')?.skip).toBe(true);
+	});
+});
+
+describe('title', () => {
+	test("should field 'title' set by 'description config'", () => {
+		const TEST_DESC = 'test the description';
+		setPromptConfig({
+			questions: {
+				body: {
+					description: TEST_DESC,
+				},
+			},
+		});
+
+		expect(getRuleQuestionConfig('body')?.title).toBe(TEST_DESC);
+	});
+
+	test("should field 'title' be default string when without 'description' config", () => {
+		setPromptConfig({
+			questions: {
+				body: {},
+			},
+		});
+
+		expect(getRuleQuestionConfig('body')?.title).toBe('body:');
+	});
+});
+
+describe('enum list', () => {
+	test('should enumList be undefined when without enum rule', () => {
+		setRules({
+			'scope-case': [RuleConfigSeverity.Warning, 'never', 'camel-case'],
+		});
+
+		expect(getRuleQuestionConfig('scope')?.enumList).toBeUndefined();
+	});
+
+	test('should enumList be undefined when enum rule is not active', () => {
+		setRules({
+			'scope-enum': [RuleConfigSeverity.Disabled],
+		});
+		expect(getRuleQuestionConfig('scope')?.enumList).toBeUndefined();
+
+		setRules({
+			'scope-enum': [
+				RuleConfigSeverity.Error,
+				'never',
+				['cli', 'core', 'lint'],
+			],
+		});
+		expect(getRuleQuestionConfig('scope')?.enumList).toBeUndefined();
+
+		setRules({
+			'scope-enum': [RuleConfigSeverity.Error, 'always'],
+		} as any);
+		expect(getRuleQuestionConfig('scope')?.enumList).toBeUndefined();
+	});
+
+	test('should enumList be undefined when enum rule is not a array', () => {
+		setRules({
+			'scope-enum': [RuleConfigSeverity.Error, 'always', {}],
+		} as any);
+
+		expect(getRuleQuestionConfig('scope')?.enumList).toBeUndefined();
+	});
+
+	test("should enumList same with enum rule when without 'enum' config", () => {
+		const ENUM_RULE_LIST = ['cli', 'core', 'lint'];
+		setRules({
+			'scope-enum': [RuleConfigSeverity.Error, 'always', ENUM_RULE_LIST],
+		} as any);
+
+		setPromptConfig({
+			questions: {
+				scope: {
+					description: 'test scope',
+				},
+			},
+		});
+
+		const enumList = getRuleQuestionConfig('scope')?.enumList;
+		expect(enumList).not.toBe(ENUM_RULE_LIST);
+		expect(enumList).toEqual(ENUM_RULE_LIST);
+	});
+
+	test('should enumList item concat description', () => {
+		const ENUM_RULE_LIST = ['cli', 'core', 'lint'];
+		setRules({
+			'scope-enum': [RuleConfigSeverity.Error, 'always', ENUM_RULE_LIST],
+		} as any);
+
+		setPromptConfig({
+			questions: {
+				scope: {
+					description: 'test scope',
+					enum: {
+						cli: {
+							description: 'CLI',
+						},
+						core: {
+							description: 'CORE',
+						},
+						lint: {},
+					},
+				},
+			},
+		});
+
+		const enumList = getRuleQuestionConfig('scope')?.enumList;
+		expect(enumList).toHaveLength(3);
+		expect(enumList).toEqual([
+			{
+				name: expect.stringMatching(/cli:[\s]*CLI/),
+				value: 'cli',
+				short: 'cli',
+			},
+			{
+				name: expect.stringMatching(/core:[\s]*CORE/),
+				value: 'core',
+				short: 'core',
+			},
+			'lint',
+		]);
+	});
+
+	test('should enumList item padding format with 4 blank', () => {
+		const LONGEST = 12;
+		const longestItem = ''.padEnd(LONGEST, 'x');
+		const enumRuleList = ['cli', 'core', longestItem];
+		setRules({
+			'scope-enum': [RuleConfigSeverity.Error, 'always', enumRuleList],
+		} as any);
+
+		setPromptConfig({
+			questions: {
+				scope: {
+					description: 'test scope',
+					enum: {
+						cli: {
+							description: 'Test CLI',
+						},
+						core: {
+							description: 'Test CORE',
+						},
+						[longestItem]: {
+							description: 'Test',
+						},
+					},
+				},
+			},
+		});
+
+		const enumList = getRuleQuestionConfig('scope')?.enumList;
+		expect(enumList).toHaveLength(3);
+		expect(enumList).toEqual([
+			{
+				name: expect.stringMatching(
+					new RegExp(`^cli:[\\s]{${LONGEST - 4 + 4}}Test CLI$`)
+				),
+				value: 'cli',
+				short: 'cli',
+			},
+			{
+				name: expect.stringMatching(
+					new RegExp(`^core:[\\s]{${LONGEST - 5 + 4}}Test CORE$`)
+				),
+				value: 'core',
+				short: 'core',
+			},
+			{
+				name: expect.stringMatching(
+					new RegExp(`^${longestItem}:[\\s]{${-1 + 4}}Test$`)
+				),
+				value: longestItem,
+				short: longestItem,
+			},
+		]);
+	});
+
+	test("should enumList item sorted by 'enum' config order", () => {
+		const ENUM_RULE_LIST = ['cli', 'core', 'lint'];
+		setRules({
+			'scope-enum': [RuleConfigSeverity.Error, 'always', ENUM_RULE_LIST],
+		} as any);
+
+		setPromptConfig({
+			questions: {
+				scope: {
+					description: 'test scope',
+					enum: {
+						core: {},
+						lint: {},
+						cli: {},
+					},
+				},
+			},
+		});
+
+		const enumList = getRuleQuestionConfig('scope')?.enumList;
+		expect(enumList).toHaveLength(3);
+		expect(enumList?.[0]).toBe('core');
+		expect(enumList?.[1]).toBe('lint');
+		expect(enumList?.[2]).toBe('cli');
+	});
+});
+
+test('should return correct question config', () => {
+	setRules({
+		'body-empty': [RuleConfigSeverity.Error, 'never'],
+		'body-case': [RuleConfigSeverity.Error, 'always', 'sentence-case'],
+		'body-full-stop': [RuleConfigSeverity.Error, 'always', '!'],
+		'body-min-length': [RuleConfigSeverity.Error, 'always', 10],
+		'body-max-length': [RuleConfigSeverity.Error, 'always', 100],
+		'scope-enum': [RuleConfigSeverity.Error, 'always', ['cli', 'core', 'lint']],
+	} as any);
+
+	const MESSAGES = {
+		skip: ':skip',
+		max: 'upper %d chars',
+		min: '%d chars at least',
+		emptyWarning: 'can not be empty',
+		upperLimitWarning: 'over limit',
+		lowerLimitWarning: 'below limit',
+	};
+	setPromptConfig({
+		messages: MESSAGES,
+		questions: {
+			body: {
+				description: 'please input body: (Test)',
+			},
+			scope: {
+				description: 'please choose the scope: (Test)',
+				enum: {
+					core: {
+						description: 'CORE',
+					},
+					lint: {
+						description: 'LINT',
+					},
+					cli: {
+						description: 'CLI',
+					},
+				},
+			},
+		},
+	});
+
+	const scopeQuestionConfig = getRuleQuestionConfig('scope');
+	expect(scopeQuestionConfig).toEqual({
+		skip: true,
+		title: 'please choose the scope: (Test)',
+		messages: MESSAGES,
+		minLength: 0,
+		maxLength: Infinity,
+		enumList: [
+			{
+				name: 'core:   CORE',
+				value: 'core',
+				short: 'core',
+			},
+			{
+				name: 'lint:   LINT',
+				value: 'lint',
+				short: 'lint',
+			},
+			{
+				name: 'cli:    CLI',
+				value: 'cli',
+				short: 'cli',
+			},
+		],
+		caseFn: expect.any(Function),
+		fullStopFn: expect.any(Function),
+	});
+	expect(scopeQuestionConfig?.caseFn?.('xxxx')).toBe('xxxx');
+	expect(scopeQuestionConfig?.fullStopFn?.('xxxx')).toBe('xxxx');
+
+	const bodyQuestionConfig = getRuleQuestionConfig('body');
+	expect(bodyQuestionConfig).toEqual({
+		skip: false,
+		title: 'please input body: (Test)',
+		messages: MESSAGES,
+		minLength: 10,
+		maxLength: 100,
+		enumList: undefined,
+		caseFn: expect.any(Function),
+		fullStopFn: expect.any(Function),
+	});
+	expect(bodyQuestionConfig?.caseFn?.('xxxx')).toBe('Xxxx');
+	expect(bodyQuestionConfig?.fullStopFn?.('xxxx')).toBe('xxxx!');
+});
diff --git a/@commitlint/cz-commitlint/src/services/getRuleQuestionConfig.ts b/@commitlint/cz-commitlint/src/services/getRuleQuestionConfig.ts
new file mode 100644
index 0000000000..8edbef8b16
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/services/getRuleQuestionConfig.ts
@@ -0,0 +1,74 @@
+import {RuleField} from '@commitlint/types';
+import {QuestionConfig} from '../Question';
+import {getPromptMessages, getPromptQuestions} from '../store/prompts';
+import {getRule} from '../store/rules';
+import getCaseFn from '../utils/case-fn';
+import getFullStopFn from '../utils/full-stop-fn';
+import {
+	enumRuleIsActive,
+	getEnumList,
+	getMaxLength,
+	getMinLength,
+	ruleIsActive,
+	ruleIsApplicable,
+	ruleIsDisabled,
+} from '../utils/rules';
+
+export default function (rulePrefix: RuleField): QuestionConfig | null {
+	const questions = getPromptQuestions();
+	const questionSettings = questions[rulePrefix];
+	const emptyRule = getRule(rulePrefix, 'empty');
+
+	const mustBeEmpty =
+		emptyRule && ruleIsActive(emptyRule) && ruleIsApplicable(emptyRule);
+
+	if (mustBeEmpty) {
+		return null;
+	}
+
+	const canBeSkip = !emptyRule || ruleIsDisabled(emptyRule);
+
+	const enumRule = getRule(rulePrefix, 'enum');
+	const enumRuleList =
+		enumRule && enumRuleIsActive(enumRule) ? getEnumList(enumRule) : null;
+	let enumList;
+
+	if (enumRuleList) {
+		const enumDescriptions = questionSettings?.['enum'];
+
+		if (enumDescriptions) {
+			const enumNames = Object.keys(enumDescriptions);
+			const longest = Math.max(
+				...enumRuleList.map((enumName) => enumName.length)
+			);
+			// TODO emoji + title
+			enumList = enumRuleList
+				.sort((a, b) => enumNames.indexOf(a) - enumNames.indexOf(b))
+				.map((enumName) => {
+					const enumDescription = enumDescriptions[enumName]?.description;
+					if (enumDescription) {
+						return {
+							name: `${enumName}:`.padEnd(longest + 4) + enumDescription,
+							value: enumName,
+							short: enumName,
+						};
+					} else {
+						return enumName;
+					}
+				});
+		} else {
+			enumList = [...enumRuleList];
+		}
+	}
+
+	return {
+		skip: canBeSkip,
+		enumList,
+		title: questionSettings?.['description'] ?? `${rulePrefix}:`,
+		caseFn: getCaseFn(getRule(rulePrefix, 'case')),
+		fullStopFn: getFullStopFn(getRule(rulePrefix, 'full-stop')),
+		minLength: getMinLength(getRule(rulePrefix, 'min-length')),
+		maxLength: getMaxLength(getRule(rulePrefix, 'max-length')),
+		messages: getPromptMessages(),
+	};
+}
diff --git a/@commitlint/cz-commitlint/src/store/defaultPromptConfigs.ts b/@commitlint/cz-commitlint/src/store/defaultPromptConfigs.ts
new file mode 100644
index 0000000000..99c649a1e5
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/store/defaultPromptConfigs.ts
@@ -0,0 +1,29 @@
+export default {
+	messages: {
+		skip: '(press enter to skip)',
+		max: '(max %d chars)',
+		min: '(min %d chars)',
+		emptyWarning: '(%s is required)',
+		upperLimitWarning: '%s is %d characters longer than the upper limit',
+		lowerLimitWarning: '%s is %d characters less than the lower limit',
+	},
+	questions: {
+		type: {
+			description: '<type> holds information about the goal of a change.',
+		},
+		scope: {
+			description:
+				'<scope> marks which sub-component of the project is affected',
+		},
+		subject: {
+			description: '<subject> is a short, high-level description of the change',
+		},
+		body: {
+			description: '<body> holds additional information about the change',
+		},
+		footer: {
+			description:
+				'<footer> holds further meta data, such as breaking changes and issue ids',
+		},
+	},
+};
diff --git a/@commitlint/cz-commitlint/src/store/prompts.test.ts b/@commitlint/cz-commitlint/src/store/prompts.test.ts
new file mode 100644
index 0000000000..b1584d6d4b
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/store/prompts.test.ts
@@ -0,0 +1,109 @@
+import * as prompts from './prompts';
+
+let getPromptQuestions: typeof prompts.getPromptQuestions;
+let getPromptMessages: typeof prompts.getPromptMessages;
+let setPromptConfig: typeof prompts.setPromptConfig;
+
+beforeEach(() => {
+	jest.resetModules();
+	getPromptMessages = require('./prompts').getPromptMessages;
+	getPromptQuestions = require('./prompts').getPromptQuestions;
+	setPromptConfig = require('./prompts').setPromptConfig;
+});
+describe('setPromptConfig', () => {
+	test('should cover questions when prompt config questions is plain object', () => {
+		const promptConfig = {
+			questions: {
+				type: {
+					description: 'input type',
+				},
+			},
+		};
+		setPromptConfig(promptConfig);
+		expect(getPromptQuestions()).toBe(promptConfig.questions);
+	});
+
+	test('should not set questions when prompt config questions is not a plain object', () => {
+		const initialQuestions = {...getPromptQuestions()};
+		setPromptConfig({
+			questions: null,
+		} as any);
+		expect(getPromptQuestions()).toEqual(initialQuestions);
+
+		setPromptConfig({
+			questions: 'questions',
+		} as any);
+		expect(getPromptQuestions()).toEqual(initialQuestions);
+
+		setPromptConfig({
+			questions: [1, 2, 3],
+		} as any);
+		expect(getPromptQuestions()).toEqual(initialQuestions);
+	});
+
+	test('should merge message when prompt config message is string', () => {
+		const initialMessages = {...getPromptMessages()};
+		const promptConfig = {
+			messages: {
+				emptyWarning: '(%s can not be empty)',
+			},
+		};
+		setPromptConfig(promptConfig);
+
+		expect(getPromptMessages()['emptyWarning']).toBe(
+			promptConfig.messages.emptyWarning
+		);
+		expect(getPromptMessages()['lowerLimitWarning']).toBe(
+			initialMessages['lowerLimitWarning']
+		);
+	});
+
+	test('should not merge message when prompt config message is not a string', () => {
+		const initialMessages = {...getPromptMessages()};
+		const promptConfig = {
+			messages: {
+				emptyWarning: '(%s can not be empty)',
+				min: function () {
+					return 'min:';
+				},
+			},
+		};
+		setPromptConfig(promptConfig as any);
+
+		expect(getPromptMessages()['emptyWarning']).toBe(
+			promptConfig.messages.emptyWarning
+		);
+		expect(getPromptMessages()['min']).toBe(initialMessages['min']);
+	});
+
+	test('should ignore non-essential message', () => {
+		const initialMessages = {...getPromptMessages()};
+		const promptConfig = {
+			messages: {
+				more: 'learn more',
+			},
+		};
+		setPromptConfig(promptConfig);
+		expect(getPromptMessages()).toEqual(initialMessages);
+	});
+
+	test('should fields be independent', () => {
+		const initialQuestions = {...getPromptQuestions()};
+		setPromptConfig({
+			messages: {
+				emptyWarning: '(%s can not be empty)',
+			},
+		});
+		expect(getPromptQuestions()).toEqual(initialQuestions);
+
+		const initialMessages = {...getPromptMessages()};
+		setPromptConfig({
+			questions: {
+				type: {
+					description: 'input type',
+				},
+			},
+		});
+		expect(getPromptMessages()).toEqual(initialMessages);
+	});
+});
diff --git a/@commitlint/cz-commitlint/src/store/prompts.ts b/@commitlint/cz-commitlint/src/store/prompts.ts
new file mode 100644
index 0000000000..649cd8d804
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/store/prompts.ts
@@ -0,0 +1,36 @@
+import {PromptConfig, UserPromptConfig} from '@commitlint/types';
+import isPlainObject from 'lodash/isPlainObject';
+import defaultPromptConfigs from './defaultPromptConfigs';
+
+const storeKey = Symbol('promptConfig');
+
+const store: {
+	[storeKey]: PromptConfig;
+} = {
+	[storeKey]: defaultPromptConfigs,
+};
+
+export function setPromptConfig(newPromptConfig: UserPromptConfig): void {
+	const {messages, questions} = newPromptConfig;
+	if (messages) {
+		const requiredMessageKeys = Object.keys(defaultPromptConfigs.messages);
+		requiredMessageKeys.forEach((key: string) => {
+			const message = messages[key];
+			if (typeof message === 'string') {
+				store[storeKey]['messages'][key] = message;
+			}
+		});
+	}
+
+	if (questions && isPlainObject(questions)) {
+		store[storeKey]['questions'] = questions;
+	}
+}
+
+export function getPromptMessages(): Readonly<PromptConfig['messages']> {
+	return (store[storeKey] && store[storeKey]['messages']) ?? {};
+}
+
+export function getPromptQuestions(): Readonly<PromptConfig['questions']> {
+	return (store[storeKey] && store[storeKey]['questions']) ?? {};
+}
diff --git a/@commitlint/cz-commitlint/src/store/rules.test.ts b/@commitlint/cz-commitlint/src/store/rules.test.ts
new file mode 100644
index 0000000000..1d12a9e851
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/store/rules.test.ts
@@ -0,0 +1,67 @@
+import {QualifiedRules} from '@commitlint/types';
+import {GetRuleMethod, SetRulesMethod} from './rules';
+
+let getRule: GetRuleMethod;
+let setRules: SetRulesMethod;
+beforeEach(() => {
+	jest.resetModules();
+	getRule = require('./rules').getRule;
+	setRules = require('./rules').setRules;
+});
+describe('getRule', () => {
+	test('should get rule when prefix and property strict match', () => {
+		const rules: QualifiedRules = {
+			'body-max-length': [2, 'always', 100],
+			'footer-max-line-length': [2, 'always', 100],
+			'subject-empty': [2, 'never'],
+		};
+		setRules(rules);
+
+		expect(getRule('body', 'max-length')).toBe(rules['body-max-length']);
+		expect(getRule('footer', 'max-line-length')).toBe(
+			rules['footer-max-line-length']
+		);
+		expect(getRule('subject', 'empty')).toBe(rules['subject-empty']);
+	});
+
+	test('should not get rule when prefix is invalid', () => {
+		const rules: QualifiedRules = {
+			'body-max-length': [2, 'always', 100],
+		};
+		setRules(rules);
+
+		expect(getRule('body-max', 'length')).toBeUndefined();
+		expect(getRule('body-max', 'max-length')).toBeUndefined();
+		expect(getRule('', 'body-max-length')).toBeUndefined();
+	});
+
+	test('should not get rule when property is partial match', () => {
+		const rules: QualifiedRules = {
+			'body-max-length': [2, 'always', 100],
+			'body-leading-blank': [1, 'always'],
+		};
+		setRules(rules);
+
+		expect(getRule('body', 'length')).toBeUndefined();
+		expect(getRule('body', 'line-leading-blank')).toBeUndefined();
+	});
+});
+
+describe('setRule', () => {
+	test('should overwrite all rules when setRule', () => {
+		expect(getRule('body', 'max-length')).toBeUndefined();
+
+		let rules: QualifiedRules = {
+			'body-max-length': [2, 'always', 100],
+		};
+		setRules(rules);
+		expect(getRule('body', 'max-length')).toBe(rules['body-max-length']);
+
+		rules = {
+			'footer-max-length': [2, 'always', 100],
+		};
+		setRules(rules);
+		expect(getRule('body', 'max-length')).toBeUndefined();
+		expect(getRule('footer', 'max-length')).toBe(rules['footer-max-length']);
+	});
+});
diff --git a/@commitlint/cz-commitlint/src/store/rules.ts b/@commitlint/cz-commitlint/src/store/rules.ts
new file mode 100644
index 0000000000..5ad229ffb5
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/store/rules.ts
@@ -0,0 +1,24 @@
+import {QualifiedRules} from '@commitlint/types';
+import {Rule} from '../types';
+
+const storeKey = Symbol('rules');
+
+const store: {
+	[storeKey]: QualifiedRules;
+} = {
+	[storeKey]: {},
+};
+
+export function getRule(key: string, property: string): Rule | undefined {
+	if (key.split('-').length > 1) {
+		return;
+	}
+	return store[storeKey][`${key}-${property}`];
+}
+
+export function setRules(newRules: QualifiedRules): void {
+	store[storeKey] = newRules;
+}
+
+export type GetRuleMethod = typeof getRule;
+export type SetRulesMethod = typeof setRules;
diff --git a/@commitlint/cz-commitlint/src/types.ts b/@commitlint/cz-commitlint/src/types.ts
new file mode 100644
index 0000000000..fba53c54eb
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/types.ts
@@ -0,0 +1,6 @@
+import {RuleConfigCondition, RuleConfigSeverity} from '@commitlint/types';
+
+export type Rule =
+	| Readonly<[RuleConfigSeverity.Disabled]>
+	| Readonly<[RuleConfigSeverity, RuleConfigCondition]>
+	| Readonly<[RuleConfigSeverity, RuleConfigCondition, unknown]>;
diff --git a/@commitlint/cz-commitlint/src/utils/case-fn.test.ts b/@commitlint/cz-commitlint/src/utils/case-fn.test.ts
new file mode 100644
index 0000000000..038f70589f
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/utils/case-fn.test.ts
@@ -0,0 +1,80 @@
+import {RuleConfigSeverity} from '@commitlint/types';
+import getCaseFn from './case-fn';
+
+test('should not apply', () => {
+	let rule = getCaseFn([RuleConfigSeverity.Disabled]);
+	expect(rule('test')).toBe('test');
+	expect(rule('test-foo')).toBe('test-foo');
+	expect(rule('testFoo')).toBe('testFoo');
+	expect(rule('TEST_FOO')).toBe('TEST_FOO');
+
+	rule = getCaseFn();
+	expect(rule('test')).toBe('test');
+	expect(rule('test-foo')).toBe('test-foo');
+	expect(rule('testFoo')).toBe('testFoo');
+	expect(rule('TEST_FOO')).toBe('TEST_FOO');
+
+	rule = getCaseFn([RuleConfigSeverity.Warning, 'never']);
+	expect(rule('test')).toBe('test');
+	expect(rule('test-foo')).toBe('test-foo');
+	expect(rule('testFoo')).toBe('testFoo');
+	expect(rule('TEST_FOO')).toBe('TEST_FOO');
+
+	rule = getCaseFn([
+		RuleConfigSeverity.Warning,
+		'always',
+		['camel-case', 'lowercase'],
+	]);
+	expect(rule('test')).toBe('test');
+	expect(rule('test-foo')).toBe('test-foo');
+	expect(rule('testFoo')).toBe('testFoo');
+	expect(rule('TEST_FOO')).toBe('TEST_FOO');
+});
+
+test('should throw error on invalid casing', () => {
+	expect(() => getCaseFn([RuleConfigSeverity.Warning, 'always'])).toThrow(
+		'Unknown target case "undefined"'
+	);
+
+	expect(() =>
+		getCaseFn([RuleConfigSeverity.Warning, 'always', 'foo'])
+	).toThrow('Unknown target case "foo"');
+});
+
+test('should convert text correctly', () => {
+	let rule = getCaseFn([RuleConfigSeverity.Warning, 'always', 'camel-case']);
+	expect(rule('TEST_FOOBar-baz baz')).toBe('testFooBarBazBaz');
+
+	rule = getCaseFn([RuleConfigSeverity.Warning, 'always', 'kebab-case']);
+	expect(rule('TEST_FOOBar-baz baz')).toBe('test-foo-bar-baz-baz');
+
+	rule = getCaseFn([RuleConfigSeverity.Warning, 'always', 'snake-case']);
+	expect(rule('TEST_FOOBar-baz baz')).toBe('test_foo_bar_baz_baz');
+
+	rule = getCaseFn([RuleConfigSeverity.Warning, 'always', 'pascal-case']);
+	expect(rule('TEST_FOOBar-baz baz')).toBe('TestFooBarBazBaz');
+
+	rule = getCaseFn([RuleConfigSeverity.Warning, 'always', 'start-case']);
+	expect(rule('TEST_FOOBar-baz baz')).toBe('TEST FOO Bar Baz Baz');
+
+	rule = getCaseFn([RuleConfigSeverity.Warning, 'always', 'upper-case']);
+	expect(rule('TEST_FOOBar-baz baz')).toBe('TEST_FOOBAR-BAZ BAZ');
+
+	rule = getCaseFn([RuleConfigSeverity.Warning, 'always', 'uppercase']);
+	expect(rule('TEST_FOOBar-baz baz')).toBe('TEST_FOOBAR-BAZ BAZ');
+
+	rule = getCaseFn([RuleConfigSeverity.Warning, 'always', 'sentence-case']);
+	expect(rule('TEST_FOOBar-baz baz')).toBe('Test_foobar-baz baz');
+
+	rule = getCaseFn([RuleConfigSeverity.Warning, 'always', 'sentencecase']);
+	expect(rule('TEST_FOOBar-baz baz')).toBe('Test_foobar-baz baz');
+
+	rule = getCaseFn([RuleConfigSeverity.Warning, 'always', 'lower-case']);
+	expect(rule('TEST_FOOBar-baz baz')).toBe('test_foobar-baz baz');
+
+	rule = getCaseFn([RuleConfigSeverity.Warning, 'always', 'lowercase']);
+	expect(rule('TEST_FOOBar-baz baz')).toBe('test_foobar-baz baz');
+
+	rule = getCaseFn([RuleConfigSeverity.Warning, 'always', 'lowerCase']);
+	expect(rule('TEST_FOOBar-baz baz')).toBe('test_foobar-baz baz');
+});
diff --git a/@commitlint/cz-commitlint/src/utils/case-fn.ts b/@commitlint/cz-commitlint/src/utils/case-fn.ts
new file mode 100644
index 0000000000..0bb098c7bf
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/utils/case-fn.ts
@@ -0,0 +1,54 @@
+import camelCase from 'lodash/camelCase';
+import kebabCase from 'lodash/kebabCase';
+import snakeCase from 'lodash/snakeCase';
+import startCase from 'lodash/startCase';
+import upperFirst from 'lodash/upperFirst';
+import {Rule} from '../types';
+import {ruleIsActive, ruleIsNotApplicable} from './rules';
+
+export type CaseFn = (input: string) => string;
+
+/**
+ * Get forced case for rule
+ * @param rule to parse
+ * @return transform function applying the enforced case
+ */
+export default function getCaseFn(rule?: Rule): CaseFn {
+	const noop = (input: string) => input;
+
+	if (!rule || !ruleIsActive(rule) || ruleIsNotApplicable(rule)) {
+		return noop;
+	}
+
+	const target = rule[2];
+
+	if (Array.isArray(target)) {
+		return noop;
+	}
+
+	switch (target) {
+		case 'camel-case':
+			return (input: string) => camelCase(input);
+		case 'kebab-case':
+			return (input: string) => kebabCase(input);
+		case 'snake-case':
+			return (input: string) => snakeCase(input);
+		case 'pascal-case':
+			return (input: string) => upperFirst(camelCase(input));
+		case 'start-case':
+			return (input: string) => startCase(input);
+		case 'upper-case':
+		case 'uppercase':
+			return (input: string) => input.toUpperCase();
+		case 'sentence-case':
+		case 'sentencecase':
+			return (input: string) =>
+				`${input.charAt(0).toUpperCase()}${input.substring(1).toLowerCase()}`;
+		case 'lower-case':
+		case 'lowercase':
+		case 'lowerCase': // Backwards compat config-angular v4
+			return (input: string) => input.toLowerCase();
+		default:
+			throw new TypeError(`Unknown target case "${target}"`);
+	}
+}
diff --git a/@commitlint/cz-commitlint/src/utils/full-stop-fn-test.ts b/@commitlint/cz-commitlint/src/utils/full-stop-fn-test.ts
new file mode 100644
index 0000000000..a1b56a6f7d
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/utils/full-stop-fn-test.ts
@@ -0,0 +1,67 @@
+import {RuleConfigSeverity} from '@commitlint/types';
+import getFullStopFn from './full-stop-fn';
+
+test('should not apply', () => {
+	let rule = getFullStopFn([RuleConfigSeverity.Disabled]);
+	expect(rule('test.')).toBe('test.');
+	expect(rule('test')).toBe('test');
+	expect(rule('test..')).toBe('test..');
+	expect(rule('')).toBe('');
+
+	rule = getFullStopFn();
+	expect(rule('test.')).toBe('test.');
+	expect(rule('test')).toBe('test');
+	expect(rule('test..')).toBe('test..');
+	expect(rule('')).toBe('');
+
+	rule = getFullStopFn([RuleConfigSeverity.Disabled, 'always']);
+	expect(rule('test.')).toBe('test.');
+	expect(rule('test')).toBe('test');
+	expect(rule('test..')).toBe('test..');
+	expect(rule('')).toBe('');
+
+	rule = getFullStopFn([RuleConfigSeverity.Disabled, 'always', 1]);
+	expect(rule('test.')).toBe('test.');
+	expect(rule('test')).toBe('test');
+	expect(rule('test..')).toBe('test..');
+	expect(rule('')).toBe('');
+
+	rule = getFullStopFn([RuleConfigSeverity.Disabled, 'never']);
+	expect(rule('test.')).toBe('test.');
+	expect(rule('test')).toBe('test');
+	expect(rule('test..')).toBe('test..');
+	expect(rule('')).toBe('');
+
+	rule = getFullStopFn([RuleConfigSeverity.Disabled, 'never', ['.']]);
+	expect(rule('test.')).toBe('test.');
+	expect(rule('test')).toBe('test');
+	expect(rule('test..')).toBe('test..');
+	expect(rule('')).toBe('');
+});
+
+test('should add full stop', () => {
+	let rule = getFullStopFn([RuleConfigSeverity.Error, 'always', '.']);
+	expect(rule('test')).toBe('test.');
+	expect(rule('test.')).toBe('test.');
+	expect(rule('')).toBe('.');
+
+	rule = getFullStopFn([RuleConfigSeverity.Error, 'always', '\n']);
+	expect(rule('test')).toBe('test\n');
+	expect(rule('test.')).toBe('test.\n');
+	expect(rule('')).toBe('\n');
+});
+
+test('should remove full stop', () => {
+	let rule = getFullStopFn([RuleConfigSeverity.Error, 'never', '.']);
+	expect(rule('test')).toBe('test');
+	expect(rule('test.')).toBe('test');
+	expect(rule('')).toBe('');
+	expect(rule('test..')).toBe('test');
+	expect(rule('test.end')).toBe('test.end');
+
+	rule = getFullStopFn([RuleConfigSeverity.Error, 'never', '\n']);
+	expect(rule('test')).toBe('test');
+	expect(rule('test.')).toBe('test.');
+	expect(rule('test\n\n')).toBe('test');
+	expect(rule('test.\n')).toBe('test.');
+});
diff --git a/@commitlint/cz-commitlint/src/utils/full-stop-fn.ts b/@commitlint/cz-commitlint/src/utils/full-stop-fn.ts
new file mode 100644
index 0000000000..6a593720c8
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/utils/full-stop-fn.ts
@@ -0,0 +1,34 @@
+import {Rule} from '../types';
+import {ruleIsActive, ruleIsNotApplicable} from './rules';
+
+export type FullStopFn = (input: string) => string;
+
+/**
+ * Get forced case for rule
+ * @param rule to parse
+ * @return transform function applying the enforced case
+ */
+export default function getFullStopFn(rule?: Rule): FullStopFn {
+	const noop = (_: string) => _;
+
+	if (!rule || !ruleIsActive(rule)) {
+		return noop;
+	}
+
+	if (typeof rule[2] !== 'string') return noop;
+
+	const symbol: string = rule[2];
+
+	if (ruleIsNotApplicable(rule)) {
+		return (input: string) => {
+			while (input.length > 0 && input.endsWith(symbol)) {
+				input = input.slice(0, input.length - 1);
+			}
+			return input;
+		};
+	} else {
+		return (input: string) => {
+			return !input.endsWith(symbol) ? input + symbol : input;
+		};
+	}
+}
diff --git a/@commitlint/cz-commitlint/src/utils/leading-blank-fn-test.ts b/@commitlint/cz-commitlint/src/utils/leading-blank-fn-test.ts
new file mode 100644
index 0000000000..25d787d88b
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/utils/leading-blank-fn-test.ts
@@ -0,0 +1,37 @@
+import {RuleConfigSeverity} from '@commitlint/types';
+import getLeadingBlankFn from './leading-blank-fn';
+
+test('should not apply', () => {
+	let rule = getLeadingBlankFn([RuleConfigSeverity.Disabled]);
+	expect(rule('test')).toBe('test');
+	expect(rule('\ntest')).toBe('\ntest');
+	expect(rule('aaa\ntest')).toBe('aaa\ntest');
+	expect(rule('')).toBe('');
+
+	rule = getLeadingBlankFn();
+	expect(rule('test')).toBe('test');
+	expect(rule('\ntest')).toBe('\ntest');
+	expect(rule('aaa\ntest')).toBe('aaa\ntest');
+	expect(rule('')).toBe('');
+});
+
+test('should add leading blank', () => {
+	const rule = getLeadingBlankFn([RuleConfigSeverity.Error, 'always']);
+	expect(rule('test')).toBe('\ntest');
+	expect(rule('\ntest')).toBe('\ntest');
+	expect(rule('\n\ntest')).toBe('\n\ntest');
+	expect(rule('aaa\ntest')).toBe('\naaa\ntest');
+	expect(rule('\naaa\ntest')).toBe('\naaa\ntest');
+	expect(rule('')).toBe('\n');
+});
+
+test('should remove leading blank', () => {
+	const rule = getLeadingBlankFn([RuleConfigSeverity.Error, 'never']);
+	expect(rule('test')).toBe('test');
+	expect(rule('\ntest')).toBe('test');
+	expect(rule('\n\ntest')).toBe('test');
+	expect(rule('aaa\ntest')).toBe('aaa\ntest');
+	expect(rule('\naaa\ntest')).toBe('aaa\ntest');
+	expect(rule('\n\n\naaa\ntest')).toBe('aaa\ntest');
+	expect(rule('')).toBe('');
+});
diff --git a/@commitlint/cz-commitlint/src/utils/leading-blank-fn.ts b/@commitlint/cz-commitlint/src/utils/leading-blank-fn.ts
new file mode 100644
index 0000000000..e12c571276
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/utils/leading-blank-fn.ts
@@ -0,0 +1,29 @@
+import {Rule} from '../types';
+import {ruleIsActive, ruleIsNotApplicable} from './rules';
+
+/**
+ * Get forced leading for rule
+ * @param rule to parse
+ * @return transform function applying the leading
+ */
+export default function getLeadingBlankFn(
+	rule?: Rule
+): (input: string) => string {
+	if (!rule || !ruleIsActive(rule)) {
+		return (input: string): string => input;
+	}
+
+	const remove = (input: string): string => {
+		const fragments = input.split('\n');
+		while (fragments.length > 0 && fragments[0] === '') {
+			fragments.shift();
+		}
+		return fragments.join('\n');
+	};
+	const lead = (input: string): string => {
+		const fragments = input.split('\n');
+		return fragments[0] === '' ? input : ['', ...fragments].join('\n');
+	};
+
+	return !ruleIsNotApplicable(rule) ? lead : remove;
+}
diff --git a/@commitlint/cz-commitlint/src/utils/rules.test.ts b/@commitlint/cz-commitlint/src/utils/rules.test.ts
new file mode 100644
index 0000000000..880551a531
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/utils/rules.test.ts
@@ -0,0 +1,125 @@
+import {RuleConfigSeverity} from '@commitlint/types';
+import {
+	enumRuleIsActive,
+	getEnumList,
+	getMaxLength,
+	getMinLength,
+	ruleIsActive,
+	ruleIsApplicable,
+	ruleIsDisabled,
+	ruleIsNotApplicable,
+} from './rules';
+
+test('ruleIsDisabled', () => {
+	expect(ruleIsDisabled([RuleConfigSeverity.Disabled])).toBe(true);
+	expect(ruleIsDisabled([RuleConfigSeverity.Disabled, 'never'])).toBe(true);
+	expect(ruleIsDisabled([RuleConfigSeverity.Disabled, 'always'])).toBe(true);
+	expect(ruleIsDisabled([RuleConfigSeverity.Error] as any)).toBe(false);
+	expect(ruleIsDisabled([RuleConfigSeverity.Error, 'always'] as any)).toBe(
+		false
+	);
+});
+
+test('ruleIsActive', () => {
+	expect(ruleIsActive([RuleConfigSeverity.Error, 'always'])).toBe(true);
+	expect(ruleIsActive([RuleConfigSeverity.Warning, 'never'])).toBe(true);
+	expect(ruleIsActive([RuleConfigSeverity.Disabled, 'always'])).toBe(false);
+	expect(ruleIsActive([RuleConfigSeverity.Error] as any)).toBe(true);
+});
+
+test('ruleIsApplicable', () => {
+	expect(ruleIsApplicable([RuleConfigSeverity.Error, 'always'])).toBe(true);
+	expect(ruleIsApplicable([RuleConfigSeverity.Warning, 'always'])).toBe(true);
+	expect(ruleIsApplicable([RuleConfigSeverity.Disabled, 'always'])).toBe(true);
+	expect(ruleIsApplicable(undefined as any)).toBe(false);
+	expect(ruleIsApplicable('' as any)).toBe(false);
+	expect(ruleIsApplicable([RuleConfigSeverity.Disabled])).toBe(false);
+	expect(ruleIsApplicable([RuleConfigSeverity.Disabled, 'never'])).toBe(false);
+});
+
+test('ruleIsNotApplicable', () => {
+	expect(ruleIsNotApplicable([RuleConfigSeverity.Error, 'never'])).toBe(true);
+	expect(ruleIsNotApplicable([RuleConfigSeverity.Warning, 'never'])).toBe(true);
+	expect(ruleIsNotApplicable([RuleConfigSeverity.Disabled, 'never'])).toBe(
+		true
+	);
+	expect(ruleIsNotApplicable(undefined as any)).toBe(false);
+	expect(ruleIsNotApplicable('' as any)).toBe(false);
+	expect(ruleIsNotApplicable([RuleConfigSeverity.Error] as any)).toBe(false);
+	expect(ruleIsNotApplicable([RuleConfigSeverity.Error, 'always'])).toBe(false);
+	expect(ruleIsNotApplicable([RuleConfigSeverity.Error, 'always', 100])).toBe(
+		false
+	);
+});
+
+test('getMaxLength', () => {
+	expect(getMaxLength([RuleConfigSeverity.Error, 'always', 100])).toBe(100);
+	expect(getMaxLength([RuleConfigSeverity.Warning, 'never'])).toBe(Infinity);
+	expect(getMaxLength([RuleConfigSeverity.Disabled, 'always'])).toBe(Infinity);
+	expect(getMaxLength([RuleConfigSeverity.Error] as any)).toBe(Infinity);
+
+	const rules: any = {
+		'body-max-line-length': [2, 'always', 100],
+		'header-max-length': [2, 'always', 100],
+		'test-max-length': [RuleConfigSeverity.Disabled, 'always', 100],
+	};
+	let lengthRule = rules['header-max-length'];
+	expect(getMaxLength(lengthRule)).toBe(100);
+
+	lengthRule = rules['body-max-line-length'];
+	expect(getMaxLength(lengthRule)).toBe(100);
+
+	lengthRule = rules['body-max-length'];
+	expect(getMaxLength(lengthRule)).toBe(Infinity);
+
+	lengthRule = rules['test-max-length'];
+	expect(getMaxLength(lengthRule)).toBe(Infinity);
+});
+
+test('getMinLength', () => {
+	expect(getMinLength([RuleConfigSeverity.Error, 'always', 10])).toBe(10);
+	expect(getMinLength([RuleConfigSeverity.Warning, 'never'])).toBe(0);
+	expect(getMinLength([RuleConfigSeverity.Disabled, 'always'])).toBe(0);
+	expect(getMinLength([RuleConfigSeverity.Error] as any)).toBe(0);
+
+	const rules: any = {
+		'body-min-length': [2, 'always', 10],
+		'footer-min-length': [2, 'always', 20],
+		'test-min-length': [RuleConfigSeverity.Disabled, 'always', 100],
+	};
+	let lengthRule = rules['header-min-length'];
+	expect(getMinLength(lengthRule)).toBe(0);
+
+	lengthRule = rules['body-min-length'];
+	expect(getMinLength(lengthRule)).toBe(10);
+
+	lengthRule = rules['test-min-length'];
+	expect(getMinLength(lengthRule)).toBe(0);
+});
+
+test('enumRuleIsActive', () => {
+	const rules: any = {
+		'enum-string': [RuleConfigSeverity.Warning, 'always', ['1', '2', '3']],
+		'type-enum': [RuleConfigSeverity.Error, 'always', ['build', 'chore', 'ci']],
+		'scope-enum': [RuleConfigSeverity.Error, 'never', ['cli', 'core', 'lint']],
+		'bar-enum': [RuleConfigSeverity.Disabled, 'always', ['foo', 'bar', 'baz']],
+	};
+
+	expect(enumRuleIsActive(rules['type-enum'])).toBe(true);
+	expect(enumRuleIsActive(rules['string-enum'])).toBe(false);
+	expect(enumRuleIsActive(rules['enum-string'])).toBe(true);
+	expect(enumRuleIsActive(rules['bar-enum'])).toBe(false);
+	expect(enumRuleIsActive(rules['scope-enum'])).toBe(false);
+});
+
+test('getEnumList', () => {
+	const rules: any = {
+		'type-enum': [RuleConfigSeverity.Error, 'always', ['build', 'chore', 'ci']],
+		'scope-enum': [RuleConfigSeverity.Error, 'never', ''],
+		'bar-enum': [RuleConfigSeverity.Disabled, 'always'],
+	};
+
+	expect(getEnumList(rules['type-enum'])).toEqual(['build', 'chore', 'ci']);
+	expect(getEnumList(rules['scope-enum'])).toEqual([]);
+	expect(getEnumList(rules['bar-enum'])).toEqual([]);
+});
diff --git a/@commitlint/cz-commitlint/src/utils/rules.ts b/@commitlint/cz-commitlint/src/utils/rules.ts
new file mode 100644
index 0000000000..b9758e2184
--- /dev/null
+++ b/@commitlint/cz-commitlint/src/utils/rules.ts
@@ -0,0 +1,98 @@
+import {RuleConfigSeverity} from '@commitlint/types';
+import {Rule} from '../types';
+
+export function ruleIsDisabled(
+	rule: Rule
+): rule is Readonly<[RuleConfigSeverity.Disabled]> {
+	if (rule && Array.isArray(rule) && rule[0] === RuleConfigSeverity.Disabled) {
+		return true;
+	}
+	return false;
+}
+
+/**
+ * Check if a rule definition is active
+ * @param rule to check
+ * @return if the rule definition is active
+ */
+export function ruleIsActive<T extends Rule>(
+	rule: T
+): rule is Exclude<T, Readonly<[RuleConfigSeverity.Disabled]>> {
+	if (rule && Array.isArray(rule)) {
+		return rule[0] > RuleConfigSeverity.Disabled;
+	}
+	return false;
+}
+
+/**
+ * Check if a rule definition is applicable
+ * @param rule to check
+ * @return if the rule definition is applicable
+ */
+export function ruleIsApplicable(
+	rule: Rule
+): rule is
+	| Readonly<[RuleConfigSeverity, 'always']>
+	| Readonly<[RuleConfigSeverity, 'always', unknown]> {
+	if (rule && Array.isArray(rule)) {
+		return rule[1] === 'always';
+	}
+	return false;
+}
+
+/**
+ * Check if a rule definition is applicable
+ * @param rule to check
+ * @return if the rule definition is applicable
+ */
+export function ruleIsNotApplicable(
+	rule: Rule
+): rule is
+	| Readonly<[RuleConfigSeverity, 'never']>
+	| Readonly<[RuleConfigSeverity, 'never', unknown]> {
+	if (rule && Array.isArray(rule)) {
+		return rule[1] === 'never';
+	}
+	return false;
+}
+
+export function enumRuleIsActive(
+	rule: Rule
+): rule is Readonly<
+	[RuleConfigSeverity.Warning | RuleConfigSeverity.Error, 'always', string[]]
+> {
+	return (
+		ruleIsActive(rule) &&
+		ruleIsApplicable(rule) &&
+		Array.isArray(rule[2]) &&
+		rule[2].length > 0
+	);
+}
+
+export function getEnumList(rule: Rule): string[] {
+	return Array.isArray(rule[2]) ? rule[2] : [];
+}
+
+export function getMaxLength(rule?: Rule): number {
+	if (
+		rule &&
+		ruleIsActive(rule) &&
+		ruleIsApplicable(rule) &&
+		typeof rule[2] === 'number'
+	) {
+		return rule[2];
+	}
+	return Infinity;
+}
+
+export function getMinLength(rule?: Rule): number {
+	if (
+		rule &&
+		ruleIsActive(rule) &&
+		ruleIsApplicable(rule) &&
+		typeof rule[2] === 'number'
+	) {
+		return rule[2];
+	}
+	return 0;
+}
diff --git a/@commitlint/cz-commitlint/tsconfig.json b/@commitlint/cz-commitlint/tsconfig.json
new file mode 100644
index 0000000000..2a6d93a0fa
--- /dev/null
+++ b/@commitlint/cz-commitlint/tsconfig.json
@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.shared.json",
+  "compilerOptions": {
+    "composite": true,
+    "rootDir": "./src",
+    "outDir": "./lib"
+  },
+  "include": ["./src"],
+  "exclude": ["./src/**/*.test.ts", "./lib/**/*"],
+  "references": [{"path": "../cli"}]
+}
diff --git a/@commitlint/load/src/load.ts b/@commitlint/load/src/load.ts
index f6b2e7d002..a86d25fc08 100644
--- a/@commitlint/load/src/load.ts
+++ b/@commitlint/load/src/load.ts
@@ -1,25 +1,23 @@
-import Path from 'path';
-
-import merge from 'lodash/merge';
-import mergeWith from 'lodash/mergeWith';
-import pick from 'lodash/pick';
-import union from 'lodash/union';
-import resolveFrom from 'resolve-from';
-
 import executeRule from '@commitlint/execute-rule';
 import resolveExtends from '@commitlint/resolve-extends';
 import {
-	UserConfig,
 	LoadOptions,
+	ParserPreset,
 	QualifiedConfig,
-	UserPreset,
 	QualifiedRules,
-	ParserPreset,
+	UserConfig,
+	UserPreset,
 } from '@commitlint/types';
-
-import loadPlugin from './utils/load-plugin';
+import isPlainObject from 'lodash/isPlainObject';
+import merge from 'lodash/merge';
+import mergeWith from 'lodash/mergeWith';
+import pick from 'lodash/pick';
+import union from 'lodash/union';
+import Path from 'path';
+import resolveFrom from 'resolve-from';
 import {loadConfig} from './utils/load-config';
 import {loadParserOpts} from './utils/load-parser-opts';
+import loadPlugin from './utils/load-plugin';
 import {pickConfig} from './utils/pick-config';
 
 const w = <T>(_: unknown, b: ArrayLike<T> | null | undefined | false) =>
@@ -117,6 +115,9 @@ export default async function load(
 			? config.helpUrl
 			: 'https://github.com/conventional-changelog/commitlint/#what-is-commitlint';
 
+	const prompt =
+		preset.prompt && isPlainObject(preset.prompt) ? preset.prompt : {};
+
 	return {
 		extends: preset.extends!,
 		formatter: preset.formatter!,
@@ -126,5 +127,6 @@ export default async function load(
 		plugins: preset.plugins!,
 		rules: qualifiedRules,
 		helpUrl,
+		prompt,
 	};
 }
diff --git a/@commitlint/load/src/utils/pick-config.ts b/@commitlint/load/src/utils/pick-config.ts
index e5e01181c0..b4dd6fd6ce 100644
--- a/@commitlint/load/src/utils/pick-config.ts
+++ b/@commitlint/load/src/utils/pick-config.ts
@@ -11,5 +11,6 @@ export const pickConfig = (input: unknown): UserConfig =>
 		'formatter',
 		'ignores',
 		'defaultIgnores',
-		'helpUrl'
+		'helpUrl',
+		'prompt'
 	);
diff --git a/@commitlint/types/src/index.ts b/@commitlint/types/src/index.ts
index 562a9a6373..40de3d4299 100644
--- a/@commitlint/types/src/index.ts
+++ b/@commitlint/types/src/index.ts
@@ -1,7 +1,8 @@
 export * from './ensure';
 export * from './format';
 export * from './is-ignored';
-export * from './rules';
 export * from './lint';
 export * from './load';
 export * from './parse';
+export * from './prompt';
+export * from './rules';
diff --git a/@commitlint/types/src/load.ts b/@commitlint/types/src/load.ts
index fa08e9982e..b46b49b0ff 100644
--- a/@commitlint/types/src/load.ts
+++ b/@commitlint/types/src/load.ts
@@ -1,8 +1,9 @@
+import {PromptConfig, UserPromptConfig} from './prompt';
 import {
+	AsyncRule,
 	Rule,
-	RulesConfig,
 	RuleConfigQuality,
-	AsyncRule,
+	RulesConfig,
 	SyncRule,
 } from './rules';
 
@@ -28,6 +29,7 @@ export interface UserConfig {
 	defaultIgnores?: boolean;
 	plugins?: (string | Plugin)[];
 	helpUrl?: string;
+	prompt?: PromptConfig;
 }
 
 export interface UserPreset {
@@ -38,6 +40,7 @@ export interface UserPreset {
 	ignores?: ((commit: string) => boolean)[];
 	defaultIgnores?: boolean;
 	plugins: PluginRecords;
+	prompt?: PromptConfig;
 }
 
 export type QualifiedRules = Partial<RulesConfig<RuleConfigQuality.Qualified>>;
@@ -51,6 +54,7 @@ export interface QualifiedConfig {
 	defaultIgnores: boolean;
 	plugins: PluginRecords;
 	helpUrl: string;
+	prompt: UserPromptConfig;
 }
 
 export interface ParserPreset {
diff --git a/@commitlint/types/src/prompt.ts b/@commitlint/types/src/prompt.ts
new file mode 100644
index 0000000000..28bea77b1b
--- /dev/null
+++ b/@commitlint/types/src/prompt.ts
@@ -0,0 +1,54 @@
+export type RuleField =
+	| 'header'
+	| 'type'
+	| 'scope'
+	| 'subject'
+	| 'body'
+	| 'footer';
+
+export type PromptName =
+	| RuleField
+	| 'isBreaking'
+	| 'breakingBody'
+	| 'breaking'
+	| 'isIssueAffected'
+	| 'issuesBody'
+	| 'issues';
+
+export type PromptConfig = {
+	messages: PromptMessages;
+	questions: Partial<
+		Record<
+			PromptName,
+			{
+				description?: string;
+				messages?: {[K: string]: string};
+				enum?: {
+					[enumName: string]: {
+						description?: string;
+						title?: string;
+						emoji?: string;
+					};
+				};
+			}
+		>
+	>;
+};
+
+export type PromptMessages = {
+	skip: string;
+	max: string;
+	min: string;
+	emptyWarning: string;
+	upperLimitWarning: string;
+	lowerLimitWarning: string;
+	[_key: string]: string;
+};
+
+export type UserPromptConfig = DeepPartial<PromptConfig>;
+
+type DeepPartial<T> = {
+	[P in keyof T]?: {
+		[K in keyof T[P]]?: T[P][K];
+	};
+};
diff --git a/docs/assets/cz-commitlint.png b/docs/assets/cz-commitlint.png
new file mode 100644
index 0000000000..4f06b71d50
Binary files /dev/null and b/docs/assets/cz-commitlint.png differ
diff --git a/docs/guides-use-prompt.md b/docs/guides-use-prompt.md
index d636020315..f32a947a30 100644
--- a/docs/guides-use-prompt.md
+++ b/docs/guides-use-prompt.md
@@ -35,7 +35,12 @@ git add .
 npm run commit
 ```
 
-## An alternative to `@commitlint/prompt`: commitizen
+## An alternative to `@commitlint/prompt-cli`: commitizen
 
 Another way to author commit messages that adhere to the commit convention configured in `commitlint.config.js` is to use `commitizen`.
 For more information, checkout their [official website](http://commitizen.github.io/cz-cli/).
+
+commitlint provides two adapters for `commitizen`:
+
+1. `@commitlint/prompt` provides a way to interact same as `@commitlint/prompt-cli`
+2. `@commitlint/cz-commitlint` is inspired by [cz-conventional-changelog](https://github.com/commitizen/cz-conventional-changelog), it provides a more modern way to interact.
diff --git a/docs/reference-configuration.md b/docs/reference-configuration.md
index 1b07e86151..fa3f2a8b6a 100644
--- a/docs/reference-configuration.md
+++ b/docs/reference-configuration.md
@@ -52,6 +52,17 @@ const Configuration = {
    */
   helpUrl:
     'https://github.com/conventional-changelog/commitlint/#what-is-commitlint',
+  /*
+   * Custom prompt configs
+   */
+  prompt: {
+    messages: {},
+    questions: {
+      type: {
+        description: 'please input type:',
+      },
+    },
+  },
 };
 
 module.exports = Configuration;
@@ -97,6 +108,17 @@ const Configuration: UserConfig = {
    */
   helpUrl:
     'https://github.com/conventional-changelog/commitlint/#what-is-commitlint',
+  /*
+   * Custom prompt configs
+   */
+  prompt: {
+    messages: {},
+    questions: {
+      type: {
+        description: 'please input type:',
+      },
+    },
+  },
 };
 
 module.exports = Configuration;
@@ -205,3 +227,9 @@ module.exports = {
 ## Rules
 
 Refer to [Rules](reference-rules.md) for a complete list of available rules.
+
+## Prompt
+
+Config command-line submit interaction, works with `@commitlint/cz-commitlint`.
+
+Refer to [Prompt Config](reference-prompt.md) for details.
diff --git a/docs/reference-prompt.md b/docs/reference-prompt.md
new file mode 100644
index 0000000000..0c4794ffd7
--- /dev/null
+++ b/docs/reference-prompt.md
@@ -0,0 +1,148 @@
+# Prompt
+
+Prompt Config is used by `@commitlint/cz-commitlint`.
+
+There are two fields: `messages` and `questions`
+
+## `messages`
+
+Set hint contents, you can configure it to support localization.
+
+- skip: The field can be skip by enter
+- max: Maximum number of characters
+- min: Minimum number of characters
+- emptyWarning: The field can not be empty
+- upperLimitWarning: The characters limit is exceeded
+- lowerLimitWarning: The characters is less than lower limit
+
+## `questions`
+
+Specify the interactive steps, Steps can only be configure in
+
+- header
+- type
+- scope
+- subject
+- body
+- footer
+- isBreaking
+- breaking
+- breakingBody
+- isIssueAffected
+- issues
+- issuesBody
+
+<div class="sequence">
+    <img src="./assets/cz-commitlint.png"/>
+</div>
+
+```js
+module.exports = {
+  parserPreset: 'conventional-changelog-conventionalcommits',
+  rules: {
+    ...
+  },
+  prompt: {
+    messages: {
+      skip: ':skip',
+      max: 'upper %d chars',
+      min: '%d chars at least',
+      emptyWarning: 'can not be empty',
+      upperLimitWarning: 'over limit',
+      lowerLimitWarning: 'below limit'
+    },
+    questions: {
+      type: {
+        description: "Select the type of change that you're committing:",
+        enum: {
+          feat: {
+            description: 'A new feature',
+            title: 'Features',
+            emoji: '✨',
+          },
+          fix: {
+            description: 'A bug fix',
+            title: 'Bug Fixes',
+            emoji: '🐛',
+          },
+          docs: {
+            description: 'Documentation only changes',
+            title: 'Documentation',
+            emoji: '📚',
+          },
+          style: {
+            description: 'Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)',
+            title: 'Styles',
+            emoji: '💎',
+          },
+          refactor: {
+            description: 'A code change that neither fixes a bug nor adds a feature',
+            title: 'Code Refactoring',
+            emoji: '📦',
+          },
+          perf: {
+            description: 'A code change that improves performance',
+            title: 'Performance Improvements',
+            emoji: '🚀',
+          },
+          test: {
+            description: 'Adding missing tests or correcting existing tests',
+            title: 'Tests',
+            emoji: '🚨',
+          },
+          build: {
+            description: 'Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)',
+            title: 'Builds',
+            emoji: '🛠',
+          },
+          ci: {
+            description: 'Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)',
+            title: 'Continuous Integrations',
+            emoji: '⚙️',
+          },
+          chore: {
+            description: "Other changes that don't modify src or test files",
+            title: 'Chores',
+            emoji: '♻️',
+          },
+          revert: {
+            description: 'Reverts a previous commit',
+            title: 'Reverts',
+            emoji: '🗑',
+          },
+        },
+      },
+      scope: {
+        description:
+          'What is the scope of this change (e.g. component or file name)',
+      },
+      subject: {
+        description: 'Write a short, imperative tense description of the change',
+      },
+      body: {
+        description: 'Provide a longer description of the change',
+      },
+      isBreaking: {
+        description: 'Are there any breaking changes?',
+      },
+      breakingBody: {
+        description:
+          'A BREAKING CHANGE commit requires a body. Please enter a longer description of the commit itself',
+      },
+      breaking: {
+        description: 'Describe the breaking changes',
+      },
+      isIssueAffected: {
+        description: 'Does this change affect any open issues?',
+      },
+      issuesBody: {
+        description:
+          'If issues are closed, the commit requires a body. Please enter a longer description of the commit itself',
+      },
+      issues: {
+        description: 'Add issue references (e.g. "fix #123", "re #123".)',
+      },
+    },
+  }
+};
+```
diff --git a/tsconfig.json b/tsconfig.json
index 4dec545ae4..4a7263020b 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -21,6 +21,7 @@
     {"path": "@commitlint/core"},
     {"path": "@commitlint/cli"},
     {"path": "@commitlint/travis-cli"},
-    {"path": "@commitlint/prompt"}
+    {"path": "@commitlint/prompt"},
+    {"path": "@commitlint/cz-commitlint"}
   ]
 }
diff --git a/yarn.lock b/yarn.lock
index 44a70daa08..fa1f20b8aa 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2240,6 +2240,14 @@
   dependencies:
     "@types/node" "*"
 
+"@types/inquirer@^7.3.1":
+  version "7.3.1"
+  resolved "https://registry.npmjs.org/@types/inquirer/-/inquirer-7.3.1.tgz#1f231224e7df11ccfaf4cf9acbcc3b935fea292d"
+  integrity sha512-osD38QVIfcdgsPCT0V3lD7eH0OFurX71Jft18bZrsVQWVRt6TuxRzlr0GJLrxoHZR2V5ph7/qP8se/dcnI7o0g==
+  dependencies:
+    "@types/through" "*"
+    rxjs "^6.4.0"
+
 "@types/istanbul-lib-coverage@*", "@types/istanbul-lib-coverage@^2.0.0", "@types/istanbul-lib-coverage@^2.0.1":
   version "2.0.1"
   resolved "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.1.tgz#42995b446db9a48a11a07ec083499a860e9138ff"
@@ -2332,6 +2340,13 @@
   resolved "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.0.tgz#7036640b4e21cc2f259ae826ce843d277dad8cff"
   integrity sha512-RJJrrySY7A8havqpGObOB4W92QXKJo63/jFLLgpvOtsGUqbQZ9Sbgl35KMm1DjC6j7AvmmU2bIno+3IyEaemaw==
 
+"@types/through@*":
+  version "0.0.30"
+  resolved "https://registry.npmjs.org/@types/through/-/through-0.0.30.tgz#e0e42ce77e897bd6aead6f6ea62aeb135b8a3895"
+  integrity sha512-FvnCJljyxhPM3gkRgWmxmDZyAQSiBQQWLI0A0VFL0K7W1oRUrPJSqNO0NvTnLkBcotdlp3lKvaT0JrnyRDkzOg==
+  dependencies:
+    "@types/node" "*"
+
 "@types/tmp@^0.2.0":
   version "0.2.0"
   resolved "https://registry.npmjs.org/@types/tmp/-/tmp-0.2.0.tgz#e3f52b4d7397eaa9193592ef3fdd44dc0af4298c"
@@ -3747,9 +3762,9 @@ core-js-compat@^3.8.1, core-js-compat@^3.9.0:
     semver "7.0.0"
 
 core-js@^2.4.0, core-js@^2.5.0:
-  version "2.6.11"
-  resolved "https://registry.npmjs.org/core-js/-/core-js-2.6.11.tgz#38831469f9922bded8ee21c9dc46985e0399308c"
-  integrity sha512-5wjnpaT/3dV+XB4borEsnAYQchn00XSgTAWKDkEqv+K8KevjbzmofK6hfJ9TZIlpj2N0xQpazy7PiRQiWHqzWg==
+  version "2.6.12"
+  resolved "https://registry.npmjs.org/core-js/-/core-js-2.6.12.tgz#d9333dfa7b065e347cc5682219d6f690859cc2ec"
+  integrity sha512-Kb2wC0fvsWfQrgk8HU5lW6U/Lcs8+9aaYcy4ZFc6DDlo4nZ7n70dEgE5rtR0oG6ufKDUnrwfWL1mXR5ljDatrQ==
 
 core-util-is@1.0.2, core-util-is@~1.0.0:
   version "1.0.2"
@@ -5532,9 +5547,9 @@ imurmurhash@^0.1.4:
   integrity sha1-khi5srkoojixPcT7a21XbyMUU+o=
 
 in-publish@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/in-publish/-/in-publish-2.0.0.tgz#e20ff5e3a2afc2690320b6dc552682a9c7fadf51"
-  integrity sha1-4g/146KvwmkDILbcVSaCqcf631E=
+  version "2.0.1"
+  resolved "https://registry.npmjs.org/in-publish/-/in-publish-2.0.1.tgz#948b1a535c8030561cea522f73f78f4be357e00c"
+  integrity sha512-oDM0kUSNFC31ShNxHKUyfZKy8ZeXZBWMjMdZHKLOk13uvT27VTL/QzRGfRUcevJhpkZAvlhPYuXkF7eNWrtyxQ==
 
 indent-string@^2.1.0:
   version "2.1.0"
@@ -9754,9 +9769,9 @@ throat@^5.0.0:
   integrity sha512-fcwX4mndzpLQKBS1DVYhGAcYaYt7vsHNIvQV+WXMvnow5cgjPphq5CaayLaGsjRdSCKZFNGt7/GYAuXaNOiYCA==
 
 throat@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.npmjs.org/throat/-/throat-6.0.0.tgz#e5d793bff24e2d329e25239978ba79b9c797b3a6"
-  integrity sha512-xFKdqx9QpWfXq471eaKQ/ao7xOFye4CKc8pyNJ9wU+oa6R4EKPTVY6V7JMqPVMZhB8TUbY5TB/mgU4AYA4Y8dA==
+  version "6.0.1"
+  resolved "https://registry.npmjs.org/throat/-/throat-6.0.1.tgz#d514fedad95740c12c2d7fc70ea863eb51ade375"
+  integrity sha512-8hmiGIJMDlwjg7dlJ4yKGLK8EsYqKgPWbG3b4wjJddKNwc7N7Dpn08Df4szr/sZdMVeOstrdYSsqzX6BYbcB+w==
 
 through2@^2.0.0, through2@^2.0.2:
   version "2.0.5"