DataToolsLab

Git & Dev Utility Tools

The unglamorous half of working in a repository: a .gitignore that ignores what you meant, a commit message that survives review and release automation, a licence file with the right text, and a diff you can actually read. Every tool runs locally — no repository is cloned, no registry is contacted and nothing you paste leaves the page.

Most popular

Repository Files

Commits & Releases

Diffs & History

Project Health

All tools

About Git & Dev Utility Tools

Git is a small vocabulary with a large surface area: a .gitignore rule that looks correct behaves differently depending on where the slash is, an abbreviation that is unique in one repository may be ambiguous in another, and a `--hard` reset where you wanted `--mixed` deletes an afternoon. This category handles those details locally. The ignore-file tools implement git's own matching algorithm — last match wins, an ignored directory hides its whole subtree — so the verdict matches git check-ignore. The commit tools parse Conventional Commits for real, so a message that lints clean also groups correctly in a generated changelog. The diff viewer is a parser, not a highlighter: it tracks hunk line numbers, rename and copy headers, mode-only changes and binary stubs. And the repository-file generators (editorconfig, dockerignore, CODEOWNERS, .gitconfig, LICENSE) produce files you can copy straight into a project, with the caveats stated rather than buried — including which licences this tool writes in full and which it points at the canonical source instead.

Related categories

Frequently asked questions

Which gitignore rules do these tools actually implement?

Git's own matcher: `*` and `?` never cross a slash but `**` does, a pattern containing a slash is anchored to the ignore file's directory, a trailing slash means directories only, `!` re-includes, and the last matching rule wins. The one rule that trips everyone up is also implemented — a file inside an ignored directory cannot be re-included — so the verdict matches what git check-ignore prints.

Do these tools need access to my repository?

No. Everything works on text you paste: the ignore matcher reads the rules and a path, the diff viewer reads a patch, the package.json tools read two files. Nothing is cloned, no GitHub API is called, and the tools keep working with the network switched off.

Is the licence text safe to ship?

For MIT, ISC, BSD-2-Clause, BSD-3-Clause, 0BSD and Unlicense the full text is written out. For Apache 2.0, GPL, LGPL, AGPL, MPL, EPL and CC0 — which run to thousands of words of numbered clauses — the tool writes the official file header, the SPDX identifier and the canonical URL to copy from, because reproducing that text from memory would risk a subtle and potentially load-bearing error.

Can I use these in CI instead of locally?

The logic is plain TypeScript with no DOM access, so the same functions could be imported into a pipeline script. As pages they are browser-only by design; for enforcement in CI use the equivalent established tools — commitlint for messages, prettier for formatting, gitleaks for secrets — whose configuration the generators here are designed to match.

What is the difference between .gitignore and .dockerignore?

They exclude files from different things: .gitignore keeps files out of the repository, .dockerignore keeps them out of the Docker build context. The syntax is close enough that the same pattern usually means the same thing, but Docker evaluates patterns from the context root and handles a trailing slash slightly differently, which is why the two generators keep their presets separate.

Online