Better pre-commit, re-engineered in Rust | Hacker News Reader

Better pre-commit, re-engineered in Rust

prek.j178.dev

47 pointsnikolay20 comments

Looks like this is just a clone of pre-commit, with the same general design.

> pre-commit is a framework to run hooks written in many languages, and it manages the language toolchain and dependencies for running the hooks

The “and” here are the main annoyances with pre-commit. It does too many things, which would each be best served by a separate tool.

As a developer working on a project, I already have mechanisms to set up a development environment. Having pre-commit install another copy of the dev environment is redundant, and typically necessitates duplicating dependency declarations too.

I’d much rather see a tool that focuses on running commit hooks, while leaving dependency management to another tool. Most projects already have something in place anyway, since dependencies are necessary for development beyond the scope of pre-commit hooks.

The really useful part of pre-commit is that it: (1) only runs hooks based on file that changed and (2) stashes all unstaged changes and untracked files.

The latter is possibly just a Git feature that should come into existence (it's annoying to have to make sure your hook is robust against this). But I think "being a package manager" is what they think the main point is.

probably not relevant to you, since it is yet another tool for managing your development environment, but maybe have a look at devenv (https://devenv.sh). it's main purpose is managing the development environment, but it has integration for pre-commit (or even prek iirc) that let's pre-commit do it's thing, but takes over the dependency management.

https://github.com/j178/prek

Imho pre-commit is an antipattern. It tends to break (or rather the janky things it typically runs break) but more importantly whatever needs to be run to gate commits has to be run server-side anyway (people disable precommit, it sometimes produces false negatives, so can't be relied upon). So once you're running the checks server side now you have a second problem which is that the two checks don't always produce the same result. Better to enforce checks in CI, but also provide a way for the dev to run the same check themselves, manually.

Well, I have one well-documented exception to this rule: Secret detection. You really don't want to push secrets to your repository, especially if it's hosted as public on GitHub. Those damned attackers can find the secrets in minutes after you've pushed them so you really don't have the time to catch and rotate this (unless you're able to properly attribute and rotate them from the CI... in which case, I'd love to see it).

And...that's exactly why you might want to use pre-commit. Set it up to run locally, treating the dev environment check as the first class citizen, then just run pre-commit on all files in CI.

We use that pattern for almost all our projects. Example: https://github.com/level12/coppy

Slow feedback loops are an antipattern. Do you like waiting 5 minutes for your checks to run on a separate computer that reports to a separate interface that you then have to navigate to and inspect the error and pull it back into your dev environment to fix? It’s soo much better running locally in 20 seconds and knowing your shit will pass or exactly where the problem is

I wish there's a better comparison to other native solutions like lefthook. I assume the builtin hooks is a core differentiator but I'm not sure if this would be useful outside the Python community.

Interesting timing since the pre-commit author recently said it’s more or less been in maintenance mode but is now interested in adding new features.

For me, I would say the most intriguing feature is no Python dependencies.

Related https://github.com/jdx/hk/, from jdx, the author of Mise.

Why would lefthook not be a more reliable tool (in design)

https://github.com/evilmartians/lefthook

I've tried to use it early on, but it hasn't moved much over time. It was opinionated and neglected. Meanwhile, pre-commit is supported by everyone. There are other alternatives, such as Husky, hk, and git-hooks, but they don't offer the out-of-the-box support that pre-commit does.

I didn’t think pre-commit was that slow but I’ll admit I am intrigued. UV has been a godsend so why not?

Agreed. For a Rust project, running Clippy and rustfmt is slow, but I’d be surprised to learn that pre-commit itself was a non-negligible part of that.

You can speed up pre-commit a lot by making it use uv but it requires a separate project:

https://github.com/tox-dev/pre-commit-uv/discussions/51

The pre-commit author was straight up hostile to discussions of uv support and ended up deleting the issue I started and banned me from the GH repo. Weirdest OSS experience I've ever had.

Wow, that guy is something. wtf is his problem.

I did some digging in the issues and PR's of pre-commit, the guy seems to be a major douche. Too bad, because uv is amazing. Might look at an alternative to pre-commit in the future.

I recently found out I've been banned from all of their repositories on GitHub, while as far as I'm aware our only interaction was on a duplicated bug issue I created, as I didn't manage to find the original with GitHub's search like in the linked issue from the OP.

I've been moving away from their tools with this and the resistance to implement/merge useful things that basically everyone wants

We've had sudo re-engineered in rust that had security problems, coreutils re-engineered in rust that had bugs, cloudflare re-engineered in rust that broke half the web, surely this one...

Reply on news.ycombinator.com