pc-init

Generate a pre-commit or prek .pre-commit-config.yaml for your project from curated language and framework presets — so you get the right linters, formatters, and quality tools wired up with a single command instead of copying configs between repos. Works with prek and pre-commit

Motivation

Every new repository needs a .pre-commit-config.yaml. Each language and framework has its own recommended linters, formatters, and quality tools, each with its own hook URL and revision. pc-init encodes those choices in version-controlled presets so you run one command instead of copying configs and looking up hook URLs. The bundled presets pin specific hook revisions — run pre-commit autoupdate or prek autoupdate after generation to pull in the latest versions.

Alternatives

If you'd rather run one all-in-one Docker-based linter instead of wiring up individual pre-commit hooks, see MegaLinter. pc-init takes the opposite approach: it generates a .pre-commit-config.yaml of individually-pinned, curated hooks that run natively via pre-commit/prek, so you can see, version, and update each tool independently.

Awesome Pre-commit Hooks

The curated hooks bundled with pc-init are also published as a standalone reference at awesome-pre-commit-hooks — a browsable list of every hook organised by language and framework.

Installation

uv tool install pc-init

Quickstart

In an existing repository, let pc-init detect what's there and generate a config in one command:

cd my-project
pc-init --detect

Or specify languages and frameworks explicitly:

pc-init --lang py --framework django

Then install the hooks:

pre-commit install
# or
prek install

Usage

Usage: pc-init [OPTIONS] COMMAND [ARGS]...

  Generate a .pre-commit-config.yaml for your project.

Options:
  --lang       TEXT  Language preset to include (repeatable, or
                     comma-delimited: --lang=py,js). Run `pc-init list` to
                     see supported values from the active catalog.
  --framework  TEXT  Framework preset to layer on top of language baselines
                     (repeatable, or comma-delimited: --framework=react,django).
                     Run `pc-init list` to see supported values from the
                     active catalog.
  --force            Overwrite existing .pre-commit-config.yaml without
                     prompting.
  --detect           Auto-detect languages and frameworks from the current
                     directory and merge them with any explicitly supplied
                     --lang/--framework values.
  --output     TEXT  Output file path.  [default: .pre-commit-config.yaml]
  --presets    TEXT  Preset catalog to use. Accepts a local directory path or
                     a git repository URL (https://, git@, git://, ssh://).
                     The directory / repo root must contain lang/ and
                     framework/ subdirectories. Defaults to the bundled
                     presets.
  --version          Show version and exit.
  --help             Show this message and exit.

Commands:
  list  List available language and framework presets in the active catalog.

List available presets

Run pc-init list to discover all supported languages and frameworks in the active catalog (bundled or custom):

pc-init list

Languages:
  cpp, css, docker, go, img, js, kt, make, md, nb, proto, py, rb, ru, sh, sql, swift, tf, toml, ts, yaml

Frameworks:
  ansible, django, git, k8s, react, sphinx

Use --presets to list what a custom catalog provides:

pc-init list --presets /path/to/my-presets
pc-init list --presets https://github.com/org/my-presets

Supported presets

Languages — pass as --lang:

ID	Language
py	Python
js	JavaScript
go	Go
ru	Rust
sh	Shell / Bash
ts	TypeScript
nb	Jupyter Notebooks
md	Markdown
img	Images
docker	Docker
sql	SQL
tf	Terraform
toml	TOML
yaml	YAML
make	Makefiles
rb	Ruby
cpp	C / C++
proto	Protocol Buffers
swift	Swift
kt	Kotlin
css	CSS / SCSS / Sass

Language aliases python, javascript, typescript, rust, ruby, golang, shell, bash, image, notebook, jupyter, dockerfile, makefile, terraform, c, c++, and kotlin are also accepted.

Frameworks — pass as --framework:

ID	Framework
react	React
django	Django
sphinx	Sphinx documentation
git	Commit message linting
k8s	Kubernetes
ansible	Ansible

Auto-detecting languages and frameworks

--detect scans the current directory, infers languages from file extensions and frameworks from indicator files, and uses the results exactly as if you had passed them with --lang and --framework.

pc-init --detect

Detected languages: md, py, yaml, sh, js
Detected frameworks: git
Generated .pre-commit-config.yaml with languages: md, py, yaml, sh, js and frameworks: git

Detected values are merged with any explicitly supplied flags — duplicates are dropped:

pc-init --detect --lang sql   # adds sql on top of whatever is detected

If the file already exists and differs, the suggested overwrite command uses explicit --lang and --framework values so the re-run is fully deterministic:

Run with --force to overwrite '.pre-commit-config.yaml'.
  Try: pc-init --lang=md,py,yaml,sh,js --framework=git --force

Language detection is based on file extensions (common vendored directories such as .git, node_modules, .venv, __pycache__, and dist are skipped):

Extension(s)	Language
.py, .pyi	py
.js, .mjs, .cjs, .jsx	js
.ts, .tsx	ts
.go	go
.rs	ru
.rb	rb
.c, .h, .cpp, .cc, .cxx, .hpp, .hh, .hxx	cpp
.proto	proto
.swift	swift
.kt, .kts	kt
.css, .scss, .sass	css
.sh, .bash	sh
.sql	sql
.tf, .tfvars	tf
.md, .markdown	md
.ipynb	nb
.yaml, .yml	yaml
.r	r
.png, .jpg, .jpeg, .gif, .webp, .svg	img
Dockerfile (filename)	docker
Makefile (filename)	make

Framework detection is based on indicator files:

Indicator	Framework
manage.py at the repo root	django
package.json with react in dependencies or devDependencies	react
conf.py (root or docs/) containing sphinx	sphinx
Any .yaml/.yml file outside .github/ containing apiVersion: and kind:	k8s
.github/workflows/ directory with at least one .yml file	git
ansible.cfg at the repo root	ansible

Language suggestions for frameworks

Some framework presets declare the languages they are typically used with. If none of your --lang selections match, pc-init prints an informational note and a ready-to-run command that adds the missing languages:

Note: preset 'react' recommends adding: --lang=js,ts
      Try: pc-init --lang=go,js,ts --framework=react

The suggested command preserves your existing --lang values so it is safe to run with --force — no hooks you already selected will be removed.

Pass --recommended to apply all suggestions automatically in a single run:

pc-init --lang go --framework react --recommended

You can also omit --lang entirely when using --recommended with at least one framework — the recommended languages are used as the starting set:

pc-init --framework django --recommended

Examples

Auto-detect everything:

pc-init --detect

Auto-detect and add an extra language:

pc-init --detect --lang sql

Python project:

pc-init --lang py

JavaScript project with React:

pc-init --lang js --framework react

Python + Django, overwriting an existing config:

pc-init --lang py --framework django --force

Multiple languages (two equivalent forms):

pc-init --lang py --lang js
pc-init --lang=py,js

Django project, letting pc-init pick the language automatically:

pc-init --framework django --recommended

Custom presets

Point --presets at a local directory or a git repository that contains lang/ and framework/ subdirectories in the same layout as the bundled presets.

Local directory:

pc-init --lang py --presets /path/to/my-presets

Git repository:

pc-init --lang py --presets https://github.com/org/my-presets

Contributing

See CONTRIBUTING.md for development setup, preset guidelines, and the pull request checklist.