Monsieur Ganesha

What is it?

Monsieur Ganesha is a suite of five pre-commit hooks that run automatically before every git commit in a 42 piscine repository. The hooks catch norm violations, compile errors, forbidden function calls, malformed commit messages, and missing README structure before they reach the repository — so moulinette never has to see them first.

The characters

Bonjour, monde.
I am not here to be gentle.
I am here so she does not have to be harsh. — Monsieur Ganesha, Directeur, Conservatoire de Paris XLII

Named after Monsieur Ganesha, director of the Conservatoire de Paris XLII and husband of Mademoiselle Norminette.

Mademoiselle Norminette and her younger sister, Mademoiselle Francinette, are the daughters of the respectable Madame Moulinette. The rigor is the care. The demand is the protection. Madame Moulinette has no mercy; Mademoiselle Norminette, even less — but Ganesha at least has a reason.

Monsieur Ganesha was the first student of Paris XLII to complete every exercise list and exam with honours — using a single push per step. Madame Moulinette found this absurd. Ganesha recalls: c'était terrible.

Requirements

• Python 3.11+ (uses tomllib from stdlib)
• pre-commit ≥ 3.0
• norminette — for the norminette hook: pip install norminette
• gcc — for the c-compiler hook: sudo apt install gcc

Installation

Automatic (recommended)

Run the setup script from inside your piscine repository:

bash /path/to/monsieur-ganesha/install.sh

The script:

1. Sets git config --global core.editor vim
2. Installs pre-commit via uv or pip3
3. Creates .pre-commit-config.yaml pointing to this repository
4. Creates a .ganesha.toml template with sensible defaults
5. Activates the hooks with pre-commit install

Manual

Add the following to your .pre-commit-config.yaml:

repos:
  - repo: https://github.com/qlrd/monsieur-ganesha
    rev: v0.1.0
    hooks:
      - id: norminette
      - id: c-compiler
      - id: forbidden-functions
      - id: commit-message

Then activate the hooks:

pre-commit install
pre-commit install --hook-type commit-msg

Configuration

Place .ganesha.toml at the root of your piscine repository. All sections are optional; the hooks work without a configuration file.

[project]
# Identifier for the current module (informational only).
name = "C00"

[forbidden]
# Functions disallowed by the subject PDF.
# The hook rejects any .c file that calls one of these.
functions = ["printf", "malloc", "realloc", "free", "calloc"]

[commit]
# Override the default Conventional Commits 1.0.0 pattern.
# Uncomment to use the 42-school ex00: format instead.
# pattern = "^(ex|rush|exam)\\d+: .+"

Configuration reference

norminette

Runs the norminette CLI on every staged .c and .h file. Norminette enforces the 42 Norme — a strict coding standard covering indentation, line length, function length, variable placement, and more.

# .pre-commit-config.yaml
- id: norminette

If norminette is not installed the hook prints an installation hint and exits with code 1. Install with: pip install norminette

c-compiler

Runs gcc -Wall -Wextra -Werror -fsyntax-only on each staged .c file independently. The -fsyntax-only flag skips object-file generation, which avoids conflicts when multiple files are staged and some headers are not yet available.

# .pre-commit-config.yaml
- id: c-compiler

forbidden-functions

Scans every staged .c file for calls to functions listed in [forbidden] functions. Detection is word-boundary anchored: ft_printf is not flagged when printf is forbidden.

# .pre-commit-config.yaml
- id: forbidden-functions

Error output format:

ex00/ft_putchar.c:8: função proibida 'write'

commit-message

Validates the commit message subject against Conventional Commits 1.0.0. Git passes .git/COMMIT_EDITMSG to the hook; comment lines (starting with #) are stripped before validation.

# .pre-commit-config.yaml
- id: commit-message

Rejection output is intentionally terse — REJECTED. — with no format hints. Students are expected to discover the correct format themselves.

readme

Checks every staged README.md for common structural issues. This hook is non-blocking: it always exits with code 0 and never prevents a commit. Files with issues receive advisory messages; files that pass all checks earn +XP.

# .pre-commit-config.yaml
- id: readme

Advisory messages

When fully documented

When README exists but is not staged

The hook always runs (always_run: true) and checks only the top-level README.md. A level-1 ATX heading is a line beginning with # (hash followed by a space). File descriptor usage is detected by scanning for stdin, stdout, stderr, or fd in the file body.

Conventional Commits 1.0.0

The commit subject must follow the pattern:

<type>[(<scope>)][!]: <description>

• type — one of the allowed types (see below)
• scope — optional, parenthesised, e.g. (cli)
• ! — optional breaking-change marker
• description — must start with a non-whitespace character

The subject line must not exceed 72 characters.

Valid examples

feat: add norminette timeout option
fix(forbidden): handle empty file list
feat!: drop support for gcc older than 12
fix(compiler)!: change exit code on parse error
docs: update installation section
test: add integration test for commit-msg
init: project setup

Invalid examples

WIP                          # no type prefix
ex00: implement ft_putchar   # 42-school format, not CC 1.0.0
FEAT: something              # type must be lowercase
feat:                        # missing description
feat: <73 chars...>          # subject too long

Type reference

Gamification layer

When the default Conventional Commits pattern is active, accepted commits trigger informational messages on stderr:

These messages are purely informational. They do not affect the hook exit code and are not shown when a custom pattern is configured.

ganesha norminette <files...>

Run norminette on the given files.

ganesha norminette ex00/ft_putchar.c include/header.h

ganesha compiler <files...>

Syntax-check the given files with gcc.

ganesha compiler ex00/ft_putchar.c ex01/ft_print_alphabet.c

ganesha forbidden <files...>

Scan the given files for forbidden function calls. Reads [forbidden] functions from .ganesha.toml in the current directory.

ganesha forbidden ex00/ft_putchar.c

ganesha commit-msg <file>

Validate the commit message stored in file. Reads the optional custom pattern from [commit] pattern in .ganesha.toml.

ganesha commit-msg .git/COMMIT_EDITMSG

ganesha readme <files...>

Check the given README.md files for structural issues. Always exits 0. Advisory messages are printed to stderr.

ganesha readme README.md

ganesha.config

from ganesha.config import load_config

cfg = load_config()
print(cfg.forbidden.functions)  # ['printf', 'malloc']
print(cfg.commit.pattern)       # None  (use default CC 1.0.0)

Dataclasses

ganesha.checks.norminette

from ganesha.checks.norminette import check
ok = check(["ex00/ft_putchar.c", "include/libft.h"])

ganesha.checks.compiler

from ganesha.checks.compiler import check
ok = check(["ex00/ft_putchar.c", "ex01/ft_print_alphabet.c"])

ganesha.checks.forbidden

from ganesha.checks.forbidden import check
ok = check(["ex00/ft_putchar.c"], ["printf", "malloc"])

ganesha.checks.commit_msg

Constants

from ganesha.checks.commit_msg import check, DEFAULT_PATTERN

ok = check(".git/COMMIT_EDITMSG")
# or with a custom pattern:
ok = check(path, pattern=r"^(ex|rush|exam)\d+: .+")

ganesha.checks.readme

from ganesha.checks.readme import check
ok = check(["README.md"])  # always True

Development

Setup

Python 3.11+ and uv are required.

git clone https://github.com/qlrd/monsieur-ganesha
cd monsieur-ganesha
uv sync --dev

Quality gates

All of the following must pass before committing:

black --check src/ tests/        # formatting (88-column)
isort --check-only src/ tests/   # import order
pylint src/ganesha/           # lint — 10.00/10 required
pytest                           # all 45 tests must pass

To auto-fix formatting before checking:

black src/ tests/
isort src/ tests/

Project layout

src/ganesha/
├── __init__.py        public API (re-exports checks + config)
├── __main__.py        python -m ganesha entry point
├── cli.py             CLI entry point (argparse)
├── config.py          .ganesha.toml loader (tomllib)
└── checks/
    ├── __init__.py
    ├── norminette.py  subprocess: norminette
    ├── compiler.py    subprocess: gcc -fsyntax-only
    ├── forbidden.py   pure-Python regex scan
    ├── commit_msg.py  CC 1.0.0 validator + gamification
    └── readme.py      README structure check (non-blocking)

tests/
├── fixtures/          valid.c · norm_error.c · compile_error.c · forbidden.c
├── test_forbidden.py  integration via lib API + tmp_path
├── test_commit_msg.py integration via lib API + tmp_path
└── test_cli.py        CLI integration via subprocess

Contributing

All contributions require a Developer Certificate of Origin. Add it with git commit -s.

Commit messages must follow Conventional Commits 1.0.0.

For large changes, open an issue before starting work. See CONTRIBUTING.md for the full workflow.

Adding a new check

1. Create src/ganesha/checks/<name>.py with a public check() function and verbose docstrings.
2. Export it in checks/__init__.py.
3. Add a CLI subcommand in cli.py.
4. Add an entry in .pre-commit-hooks.yaml.
5. Write integration tests in tests/test_<name>.py.
6. Run all quality gates and open a pull request.

Rebase note

Congratulations.
If you are reading this, you have completed at least one correct rebase — with fixup, reword, or edit — and the reflog proves it. The reflog has not been modified. It never should be. You rewrote with intention, and the reflog remembers.

git reflog does not lie. It shows every move you made. A clean rebase, visible in the reflog, is a signature. It says: I understood what I was doing.

Monsieur Ganesha has noted this. — Monsieur Ganesha, Directeur, Conservatoire de Paris XLII

The safest rebase workflow — without overwriting reflogs:

git reflog                   # read history — never modify it
git rebase -i HEAD~3         # fixup, reword, edit — with intention
git reflog                   # find the sha before the rebase
git reset --hard HEAD@{n}    # recover the exact state if needed

Never modify the reflog. Never use git push --force to overwrite a shared branch. The reflog on your machine is yours — and it is the only honest witness you have.

Public keys

All commits are signed by Monsieur Piscinette (piscinette@conservatoire42.fr) and attested by the Mahatrimurti: Madame Kali, Monsieur Shiva, and Monsieur Ganesha.

Import all keys to verify signatures locally:

gpg --import keys/*.asc
git log --show-signature