Commitizen

# Main plugin base class
from commitizen import BaseCommitizen

# Configuration management
from commitizen.config import BaseConfig, read_cfg

# Factory for creating plugin instances
from commitizen.factory import commiter_factory

# Command classes for programmatic usage
from commitizen.commands import Bump, Check, Commit, Changelog

# Built-in plugins
from commitizen.cz.conventional_commits import ConventionalCommitsCz
from commitizen.cz.jira import JiraSmartCz
from commitizen.cz.customize import CustomizeCommitsCz

# Git operations
from commitizen import git

# Version schemes
from commitizen.version_schemes import get_version_scheme, Pep440, SemVer

# Output and logging utilities
from commitizen.out import write, line, error, success, info, diagnostic, warn

# Hook system
from commitizen.hooks import run

# Command execution
from commitizen.cmd import run, Command

# Exception handling
from commitizen.exceptions import CommitizenException, NoCommitizenFoundException

# Recommended global installation
pipx install commitizen

# Initialize configuration in existing project
cz init

# Basic workflow - interactive commit
git add .
cz commit

# Automatically bump version and generate changelog
cz bump --changelog

# Push changes with tags
git push && git push --tags

from commitizen.config import BaseConfig
from commitizen.factory import commiter_factory
from commitizen.commands import bump

# Create configuration
config = BaseConfig()
config.settings.update({
    "name": "cz_conventional_commits",
    "version": "1.0.0"
})

# Get commitizen plugin instance  
cz = commiter_factory(config)

# Use plugin methods
questions = cz.questions()
example = cz.example()
message = cz.message({"type": "feat", "subject": "add new feature"})

# Programmatic version bumping
result = bump.bump(
    config=config,
    increment="MINOR", 
    changelog=True,
    dry_run=False
)

def main() -> None
class Bump: ...
class Check: ...  
class Commit: ...
class Changelog: ...
class Init: ...
class Version: ...
class Info: ...
class Example: ...
class Schema: ...
class ListCz: ...

def read_cfg(project_root: str) -> BaseConfig
class BaseConfig: ...
class TomlConfig(BaseConfig): ...
class JsonConfig(BaseConfig): ...  
class YAMLConfig(BaseConfig): ...

class BaseCommitizen: ...
def discover_plugins() -> None
def commiter_factory(config: BaseConfig) -> BaseCommitizen

# Plugin registry
registry: dict[str, type[BaseCommitizen]]

def find_increment(commits: list, regex: Pattern, incremental_rev: str) -> str
def update_version_in_files(current_version: str, new_version: str, files: list) -> None
def normalize_tag(tag: str, tag_format: str) -> str

class VersionProtocol: ...
class Pep440(BaseVersion): ...
class SemVer(BaseVersion): ...
def get_version_scheme(name: str) -> VersionProtocol

def commit(message: str, args: str = "") -> Command
def tag(name: str, message: str = "", signed: bool = False) -> Command
def add(pathspecs: list[str]) -> Command
def get_commits(start: str = "", end: str = "", rev: str = "", paths: list[str] = []) -> list[GitCommit]
def get_tags() -> list[GitTag]
def is_git_project() -> bool
def find_git_project_root() -> Path

from typing import TypedDict, Protocol, NamedTuple
from enum import Enum

# Configuration types
class CzSettings(TypedDict):
    bump_message: str
    bump_pattern: str
    bump_map: dict[str, str]
    change_type_map: dict[str, str]
    change_type_order: list[str]
    commit_parser: str
    message_template: str
    questions: list[dict]
    schema: str
    schema_pattern: str
    example: str
    info: str

class Settings(TypedDict):
    name: str
    version: str
    version_files: list[str]
    tag_format: str
    update_changelog_on_bump: bool
    changelog_file: str
    # ... additional settings

# Git types
class GitCommit(NamedTuple):
    rev: str
    title: str
    body: str
    author: str
    author_email: str
    date: str

class GitTag(NamedTuple):
    name: str
    rev: str
    date: str

# Version types
class VersionProtocol(Protocol):
    def parse(self, version: str) -> Any: ...
    def bump(self, version: Any, increment: str) -> Any: ...
    def serialize(self, version: Any) -> str: ...

# Exit codes
class ExitCode(Enum):
    SUCCESS = 0
    EXPECTED_EXIT = 21
    # ... 40+ additional exit codes

# Command execution
class Command(NamedTuple):
    return_code: int
    out: str
    err: str

# Output functions
def write(message: str, quiet: bool = False) -> None: ...
def line(message: str, quiet: bool = False) -> None: ...
def error(message: str, quiet: bool = False) -> None: ...
def success(message: str, quiet: bool = False) -> None: ...
def info(message: str, quiet: bool = False) -> None: ...
def diagnostic(message: str, quiet: bool = False) -> None: ...
def warn(message: str, quiet: bool = False) -> None: ...

# Hook execution
def run() -> None: ...  # Execute pre/post hooks with environment setup