mdsf

Format, and lint, markdown code snippets using your favorite tools.

Table of contents

• Table of contents
• Installation
  • Linux & MacOS
  • Windows
  • Cargo
  • npm/npx
  • Homebrew
  • Conda
• Usage
  • Formatting code
    • Caching formatting results
      • Removing old caches
  • Verifying code
  • GitHub Action
  • Visual Studio Code
  • Vim / NeoVim
    • conform.nvim
  • treefmt
  • pre-commit
• Configuration
  • Language aliases
  • Newlines
  • Custom tools and commands
  • Tools
  • Commands
• Shell completions
  • Bash
  • Zsh
  • Fish
  • PowerShell
  • Elvish
  • Nushell
• Rust MSRV
• Acknowledgement
• Alternatives to mdsf

Installation

The latest version of mdsf can be downloaded directly from github.com/hougesen/mdsf/releases.

Linux & MacOS

curl --proto '=https' --tlsv1.2 -LsSf https://github.com/hougesen/mdsf/releases/latest/download/mdsf-installer.sh | sh

Windows

powershell -ExecutionPolicy ByPass -c "irm https://github.com/hougesen/mdsf/releases/latest/download/mdsf-installer.ps1 | iex"

Cargo

Install using the published crate:

cargo install mdsf --locked

or directly from source:

git clone git@github.com:hougesen/mdsf.git
cargo install --path ./mdsf --bin mdsf

If you do not have Cargo installed, you need to install it first.

npm/npx

You can install mdsf using npm:

npm install -g mdsf-cli
mdsf format .

or run it directly using npx:

npx mdsf-cli format .

Homebrew

brew install hougesen/tap/mdsf

Conda

An unofficial (and unsupported) Conda package can be found at https://anaconda.org/conda-forge/mdsf.

conda install conda-forge::mdsf

Usage

mdsf 0.12.0-next
Format, and lint, markdown code snippets using your favorite tools
Mads Hougesen <mads@mhouge.dk>

Usage: mdsf [OPTIONS] <COMMAND>

Commands:
  format       Run tools on input files
  verify       Verify files are formatted
  init         Create a new mdsf config
  completions  Generate shell completion
  cache-prune  Remove caches
  help         Print this message or the help of the given subcommand(s)

Options:
      --log-level <LOG_LEVEL>  [default: debug] [possible values: trace, debug, info, warn, error, off]
  -h, --help                   Print help
  -V, --version                Print version

Formatting code

The format command, as the name implies, is used to format documents.

mdsf format file.md

Run tools on input files

Usage: mdsf format [OPTIONS] [INPUT]...

Arguments:
  [INPUT]...
          Path to files and/or directories

Options:
      --stdin
          Read input from stdin and write output to stdout

      --config <CONFIG>
          Path to config file

      --debug
          Log stdout and stderr of formatters

      --threads <THREADS>
          Amount of threads to use.

          Defaults to 0 (auto).

      --cache
          Cache results

      --log-level <LOG_LEVEL>
          [default: debug]
          [possible values: trace, debug, info, warn, error, off]

      --timeout <TIMEOUT>
          Tool timeout in seconds.

          Defaults to no timeout.

      --on-missing-language-definition <ON_MISSING_LANGUAGE_DEFINITION>
          What to do when a codeblock language has no tools defined.

          Falls back to the value defined in your config file, if no argument is provided.

          [possible values: ignore, fail, fail-fast]

      --on-missing-tool-binary <ON_MISSING_TOOL_BINARY>
          What to do when the binary of a tool cannot be found.

          Falls back to the value defined in your config file, if no argument is provided.

          [possible values: ignore, fail, fail-fast]

  -h, --help
          Print help (see a summary with '-h')

  -V, --version
          Print version

Caching formatting results

To speed formatting caching can be enabled by supplying the format command with the --cache argument.

mdsf format --cache docs/

Removing old caches

Old caches can be removed by running the mdsf cache-prune command.

Remove caches

Usage: mdsf cache-prune [OPTIONS]

Options:
      --log-level <LOG_LEVEL>  [default: debug] [possible values: trace, debug, info, warn, error, off]
  -h, --help                   Print help
  -V, --version                Print version

Verifying code

You can verify that the document is formatted using the mdsf verify command.

mdsf verify docs/

Verify files are formatted

Usage: mdsf verify [OPTIONS] [INPUT]...

Arguments:
  [INPUT]...
          Path to files and/or directories

Options:
      --stdin
          Read input from stdin and write output to stdout

      --config <CONFIG>
          Path to config file

      --debug
          Log stdout and stderr of formatters

      --threads <THREADS>
          Amount of threads to use.

          Defaults to 0 (auto).

      --timeout <TIMEOUT>
          Tool timeout in seconds.

          Defaults to no timeout.

      --log-level <LOG_LEVEL>
          [default: debug]
          [possible values: trace, debug, info, warn, error, off]

      --on-missing-language-definition <ON_MISSING_LANGUAGE_DEFINITION>
          What to do when a codeblock language has no tools defined.

          Falls back to the value defined in your config file, if no argument is provided.

          [possible values: ignore, fail, fail-fast]

      --on-missing-tool-binary <ON_MISSING_TOOL_BINARY>
          What to do when the binary of a tool cannot be found.

          Falls back to the value defined in your config file, if no argument is provided.

          [possible values: ignore, fail, fail-fast]

  -h, --help
          Print help (see a summary with '-h')

  -V, --version
          Print version

GitHub Action

There are a lot of different ways to run mdsf using GitHub actions.

The easiest way, in my opinion, is to use the official GitHub action to install mdsf.

After that you can run the binary like you would in your terminal.

[!NOTE] mdsf is not a package manager.

You must also install the tools you wish to use in your GitHub action.

name: mdsf
on: push
jobs:
format:
runs-on: ubuntu-latest
steps:
- name: Checkout repository
uses: actions/checkout@v4
  - name: Install mdsf
    uses: hougesen/mdsf@main

  - name: Run mdsf
    run: mdsf format --log-level warn .

  - name: Commit changes
    uses: EndBug/add-and-commit@v9
    with:
      message: "style: formatted markdown code blocks"

Visual Studio Code

mdsf can be run using the VSCode extension.

[!NOTE] The mdsf VS Code extension does currently not support installing mdsf. Which means mdsf must be installed using other means.

Vim / NeoVim

conform.nvim

conform.nvim has native support for running mdsf.

local conform = require("conform")
conform.setup({
formatters_by_ft = {
markdown = { "mdsf" },
-- ...
},
-- ...
})

treefmt

Add the following to your treefmt.toml to run mdsf using treefmt.

# treefmt.toml
[formatter.mdsf]
command = "mdsf"
options = ["format"]
includes = ["*.md"]

pre-commit

See pre-commit for instructions

Sample .pre-commit-config.yaml:

repos:
  - repo: https://github.com/hougesen/mdsf
    rev: main
    hooks:
      - id: mdsf-format

Configuration

The default configuration of mdsf aims to as simple as possible. For that reason the default formatter for each language is the one most people have installed.

If you are interested in customizing which formatter is run, you can create a new mdsf configuration file by running mdsf init.

Create a new mdsf config

Usage: mdsf init [OPTIONS]

Options:
      --force
          Create config even if one already exists in current directory
      --format <FORMAT>
          [default: json] [possible values: json, toml, yaml]
      --schema-version <SCHEMA_VERSION>
          [default: locked] [possible values: locked, stable, development]
      --log-level <LOG_LEVEL>
          [default: debug] [possible values: trace, debug, info, warn, error, off]
  -h, --help
          Print help
  -V, --version
          Print version

mdsf supports running multiple formatters on the code snippet.

{
  "languages": {
    // Only run `ruff` on Python snippets,
    "python": "ruff:format",
    // Run `usort` on file and then `black`
    "python": ["usort", "black"],
    // Run `usort`, if that fails run `isort`, finally run `black`
    "python": [["usort", "isort"], "black"],
// Formatters listed under "*" will be run on any snippet.
"*": ["typos"],

// Formatters listed under "_" will only be run when there is not formatter configured for the file type OR globally ("*").
"_": "prettier"

}
}

Language aliases

Multiple languages can easily be mapped to the same tools using the language_aliases option.

{
  "language_aliases": {
    "language": "is_alias_of"
  }
}

In the example below bash and zsh would use the tools defined under languages.shell.

{
  "languages": {
    "shell": "shfmt"
  },
  "language_aliases": {
    "bash": "shell",
    "zsh": "shell"
  }
}

Newlines

By default LF (\n) is used for newlines.

That can be changed by specifying the newline config option.

{
  "newline": "lf" // "lf" | "cr" | "crlf"
}

Custom tools and commands

Custom commands can be defined in the mdsf.json file.

When defining the arguments the variable $PATH will automatically be replaced with the file path.

{
  "languages": {
    "rust": {
      "binary": "rustfmt",
      "arguments": ["--edition", "2018", "$PATH"],
      "stdin": false
    }
  }
}

Tools

[!NOTE] mdsf is not a package manager.

Only tools that are already installed will be used.

mdsf currently supports 346 tools. Feel free to open an issue/pull-request if your favorite tool/command is missing! 😃

Name	Description	Categories	Languages
action-validator	Tool to validate GitHub Action and Workflow YAML files	linter	yaml
actionlint	Static checker for GitHub Actions workflow files	linter	yaml
air	R formatter	formatter	r
alejandra	The Uncompromising Nix Code Formatter	formatter	nix
alex	Catch insensitive, inconsiderate writing	spell-check	markdown
ameba	A static code analysis tool for Crystal	linter	crystal
ansible-lint	ansible-lint checks playbooks for practices and behavior that could potentially be improved and can fix some of the most common ones for you	linter	ansible
api-linter	A linter for APIs defined in protocol buffers	linter	protobuf
asmfmt	Go Assembler Formatter	formatter	go
astyle	A Free, Fast, and Small Automatic Formatter for C, C++, C++/CLI, Objective-C, C#, and Java Source Code	formatter	c#, c++, c, java, objective-c
atlas	Manage your database schema as code	formatter	hcl
auto-optional	Makes typed arguments Optional when the default argument is None	formatter	python
autocorrect	A linter and formatter to help you to improve copywriting, correct spaces, words, and punctuations between CJK (Chinese, Japanese, Korean)	spell-check
autoflake	Removes unused imports and unused variables as reported by pyflakes	linter	python
autopep8	A tool that automatically formats Python code to conform to the PEP 8 style guide	formatter	python
bashate	Code style enforcement for bash programs	formatter	bash
beancount-black	Opinionated code formatter, just like Python's black code formatter but for Beancount	formatter	beancount
beautysh	A Bash beautifier for the masses	formatter	bash, shell
bibtex-tidy	Cleaner and Formatter for BibTeX files	formatter	bibtex
bicep	Bicep is a declarative language for describing and deploying Azure resources	formatter	bicep
biome	A toolchain for web projects	formatter, linter	javascript, json, typescript, vue
black	The uncompromising Python code formatter	formatter	python
blade-formatter	An opinionated blade template formatter for Laravel that respects readability	formatter	blade, laravel, php
blue	The slightly less uncompromising Python code formatter	formatter	python
bpfmt	A formatter for Blueprint files	formatter	blueprint
brittany	Haskell source code formatter	formatter	haskell
brunette	A best practice Python code formatter	formatter	python
bsfmt	A code formatter for BrighterScript (and BrightScript)	formatter	brighterscript, brightscript
bslint	A linter for BrightScript and BrighterScript	linter	brightscript, brightscripter
buf	The best way of working with Protocol Buffers	formatter	protobuf
buildifier	A bazel BUILD file formatter and editor	formatter	bazel
c3fmt	A customizable code formatter for the C3 language	formatter	c3
cabal-fmt	An experiment of formatting .cabal files	formatter	cabal
cabal-gild	Format Haskell package descriptions	formatter	cabal, haskell
cabal-prettify	Prettify your Cabal package configuration files	formatter	cabal
cabal	Cabal is a system for building and packaging Haskell libraries and programs	formatter	cabal
caddy	Formats or prettifies a Caddyfile	formatter	caddy
caramel	Formatter for the Caramel programming language	formatter	caramel
cedar	Command Line Interface for Cedar	formatter	cedar
cfn-lint	CloudFormation Linter	linter	cloudformation, json, yaml
checkmake	Linter/analyzer for Makefiles	linter	makefile
clang-format	A tool to format C/C++/Java/JavaScript/JSON/Objective-C/Protobuf/C# code	formatter	c#, c++, c, java, javascript, json, objective-c, protobuf
clang-tidy	clang-tidy is a clang-based C++ “linter” tool	linter	c++
clj-kondo	Static analyzer and linter for Clojure code that sparks joy	linter	clojure, clojurescript
cljfmt	A tool for formatting Clojure code	formatter	clojure
cljstyle	A tool for formatting Clojure code	formatter	clojure
cmake-format	cmake-format can format your listfiles nicely so that they don't look like crap	formatter	cmake
cmake-lint	Lint CMake files	linter	cmake
codeql	Format queries and libraries with CodeQL	formatter	codeql
codespell	Check code for common misspellings	spell-check
coffeelint	Lint your CoffeeScript	linter	coffeescript
cppcheck	Cppcheck is a static analysis tool for C/C++ code	linter	c++, c
cpplint	Static code checker for C++	linter	c++
crlfmt	Formatter for CockroachDB's additions to the Go style guide	formatter	go
crystal	Tools for the Crystal programming language	formatter	crystal
csharpier	CSharpier is an opinionated code formatter for C#	formatter	c#
css-beautify	A CSS formatter	formatter	css
csscomb	CSS coding style formatter	formatter	css
csslint	Automated linting of Cascading Stylesheets	linter	css
cue	The home of the CUE language! Validate and define text-based and dynamic configuration	formatter	cue
cueimports	CUE tool that updates your import lines, adding missing ones and removing unused ones	formatter	cue
curlylint	Experimental HTML templates linting for Jinja, Nunjucks, Django templates, Twig, Liquid	linter	django, html, jinja, liquid, nunjucks, twig
d2	A modern language that turns text to diagrams	formatter	d2
dart	Formatter and linter for Dart	formatter, linter	dart, flutter
dcm	Code Quality Tool for Flutter Developers	formatter, linter	dart, flutter
deadnix	Scan Nix files for dead code	linter	nix
deno	Formatter and linter for JavaScript and TypeScript	formatter, linter	javascript, json, typescript
dfmt	Dfmt is a formatter for D source code	formatter	d
dhall	Tools for the Dhall configuration language	formatter	dhall
djade	A Django template formatter	formatter	django, python
djangofmt	A fast, HTML aware, Django template formatter	formatter	django, html, python
djlint	Lint & Format HTML Templates	formatter, linter	handlebars, html, jinja, mustache, nunjucks, twig
docformatter	Formats docstrings to follow PEP 257	formatter	python
dockerfmt	Dockerfile formatter. a modern dockfmt	formatter	docker
dockfmt	Dockerfile format and parser. Like gofmt but for Dockerfiles	formatter	docker
docstrfmt	A formatter for reStructuredText	formatter	python, restructuredtext, sphinx
doctoc	Generates table of contents for markdown files	formatter	markdown
dotenv-linter	Lightning-fast linter for .env files	linter	env
dprint	A pluggable and configurable code formatting platform written in Rust	formatter
dscanner	Swiss-army knife for D source code	linter	d
dune	Build tool for OCaml projects	formatter	dune, ocaml, reasonml
duster	Automatic configuration for Laravel apps to apply Tighten's standard linting & code standards	formatter, linter	php
dx	Fullstack app framework for web, desktop, and mobile	formatter	rsx, rust
easy-coding-standard	The Easiest way to add coding standard to your PHP project	formatter, linter	php
efmt	Erlang code formatter	formatter	erlang
elm-format	elm-format formats Elm source code according to a standard set of rules based on the official Elm Style Guide	formatter	elm
eradicate	Removes commented-out code from Python files	linter	python
erb-formatter	Format ERB files with speed and precision	formatter	erb, ruby
erg	A statically typed language compatible with Python	linter	erg
erlfmt	An automated code formatter for Erlang	formatter	erlang
eslint	Find and fix problems in your JavaScript code	linter	javascript, typescript
fantomas	FSharp source code formatter	formatter	f#
fish_indent	Fish indenter and prettifier	formatter	fish
fixjson	JSON Fixer for Humans using (relaxed) JSON5	formatter, linter	json5, json
floskell	Floskell is a flexible Haskell source code pretty printer	formatter	haskell
flynt	A tool to automatically convert old string literal formatting to f-strings	formatter	python
fnlfmt	A formatter for Fennel code	formatter	fennel
forge	Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust	formatter	solidity
fortitude	A Fortran linter	linter	fortran
fortran-linter	A simple fortran syntax checker, including automatic fixing of the code	formatter, linter	fortran
fourmolu	A fourk of ormolu that uses four space indentation and allows arbitrary configuration	formatter	haskell
fprettify	Auto-formatter for modern Fortran source code	formatter	fortran
futhark	Code formatter for the furhark programming language	formatter	futhark
fvm	Flutter Version Management: A simple CLI to manage Flutter SDK versions	formatter, linter	dart, flutter
gci	GCI, a tool that control golang package import order and make it always deterministic	formatter	go
gdformat	GDScript formatter	formatter	gdscript
gdlint	GDScript linter	linter	gdscript
gersemi	A formatter to make your CMake code the real treasure	formatter	cmake
ghokin	Parallelized formatter with no external dependencies for gherkin (cucumber, behat...)	formatter	behat, cucumber, gherkin
gleam	Format Gleam source code	formatter	gleam
gluon	A static, type inferred and embeddable language written in Rust	formatter	gluon
gofmt	Gofmt formats Go programs	formatter	go
gofumpt	A stricter gofmt	formatter	go
goimports-reviser	Right imports sorting & code formatting tool (goimports alternative)	formatter	go
goimports	goimports updates your Go import lines, adding missing ones and removing unreferenced ones	formatter	go
golangci-lint	Fast linters runner for Go	formatter, linter	go
golines	A golang formatter that fixes long lines	formatter	go
google-java-format	Reformats Java source code to comply with Google Java Style	formatter	java
gospel	Misspelled word linter for Go comments, string literals and embedded files	spell-check	go
grafbase	The Grafbase command line interface	linter	graphql
grain	Code formatter for the Grain programming language	formatter	grain
hadolint	Dockerfile linter, validate inline bash, written in Haskell	linter	dockerfile
haml-lint	Tool for writing clean and consistent HAML	linter	haml
hclfmt	Formatter for hcl files	formatter	hcl
hfmt	Format Haskell programs. Inspired by the gofmt utility	formatter	haskell
hindent	Haskell pretty printer	formatter	haskell
hlint	Haskell source code suggestions	linter	haskell
hongdown	Hongdown is a Markdown formatter that enforces Hong Minhee's Markdown style conventions	formatter	markdown
html-beautify	A html formatter	formatter	html
htmlbeautifier	A normaliser/beautifier for HTML that also understands embedded Ruby. Ideal for tidying up Rails templates	formatter	erb, html, ruby
htmlhint	The static code analysis tool you need for your HTML	linter	html
hurlfmt	Formatter for hurl files	formatter	hurl
imba	A formatter for Imba	formatter	imba
inko	A language for building concurrent software with confidence	formatter	inko
isort	A Python utility to sort imports	formatter	python
janet-format	A formatter for Janet code	formatter	janet
joker	Small Clojure interpreter, linter and formatter	formatter, linter	clojure
jq	Command-line JSON processor	formatter	json
jqfmt	like gofmt, but for jq	formatter	jq
js-beautify	Beautifier for javascript	formatter	javascript
json5format	JSON5 formatter that preserves contextual comments	formatter	json5, json
json_repair	A module to repair invalid JSON from LLMs	linter	json
jsona	JSONA parser, linter, formatter, lsp and cli	formatter, linter	jsona
jsonlint	A JSON parser and validator	formatter, linter	json
jsonnet-lint	Linter for jsonnet files	linter	jsonnet
jsonnetfmt	Formatter for automatically fixing jsonnet stylistic problems	formatter	jsonnet
jsonpp	A fast command line JSON pretty printer	formatter	json
juliaformatter.jl	An opinionated code formatter for Julia. Plot twist - the opinion is your own	formatter	julia
just	Just a command runner	formatter	just
kcl	KCL Format tool supports reformatting KCL files to the standard code style	formatter	kcl
kdlfmt	A formatter for kdl documents	formatter	kdl
kdoc-formatter	Reformats Kotlin KDoc comments, reflowing text and other cleanup	formatter	kotlin
keep-sorted	keep-sorted is a language-agnostic formatter that sorts lines between two markers in a larger file	formatter
ktfmt	A program that reformats Kotlin source code to comply with the common community standard for Kotlin code conventions	formatter	kotlin
ktlint	An anti-bikeshedding Kotlin linter with built-in formatter	linter	kotlin
kube-linter	KubeLinter is a static analysis tool that checks Kubernetes YAML files and Helm charts to ensure the applications represented in them adhere to best practices	linter	kubernetes, yaml
kulala-fmt	An opinionated .http and .rest files linter and formatter	formatter	http
leptosfmt	A formatter for the leptos view! macro	formatter	rust
liquidsoap-prettier	Prettier plugin for liquidsoap script	formatter	liquidsoap
luacheck	A tool for linting and static analysis of Lua code	formatter	lua
luaformatter	Code formatter for Lua	formatter	lua
luau-analyze	Typecheck and lint luau files	linter	luau
mado	A fast Markdown linter written in Rust	linter	markdown
mago	Mago is a toolchain for PHP that aims to provide a set of tools to help developers write better code	formatter, linter	php
markdownfmt	Like gofmt, but for Markdown	formatter	markdown
markdownlint-cli2	A fast, flexible, configuration-based command-line interface for linting Markdown/CommonMark files with the markdownlint library	linter	markdown
markdownlint	A Node.js style checker and lint tool for Markdown/CommonMark files	linter	markdown
markuplint	An HTML linter for all markup developers	linter	html
mbake	mbake is a Makefile formatter and linter	formatter, linter	make
md-padding	AST-based padding for Markdown and natural language, improving readability in multilingual documents	formatter	markdown
mdformat	CommonMark compliant Markdown formatter	formatter	markdwon
mdsf	Run mdsf inside mdsf	formatter	markdown
mdslw	Prepare your markdown for easy diff'ing!	formatter	markdown
meson	Meson is an open source build system meant to be both extremely fast, and, even more importantly, as user friendly as possible	formatter	meson
mh_lint	A linter for MATLAB	linter	matlab
mh_style	A formatter for MATLAB	formatter	matlab
mise	dev tools, env vars, task runner
misspell	Correct commonly misspelled English words in source files	spell-check
mix	Code formatter for Elixir	formatter	elixir
mojo	Formats Mojo source files	formatter	mojo
muon	An implementation of the meson build system in c99	formatter, linter	meson
mypy	Optional static typing for Python	linter	python
nasmfmt	Formatter for NASM source files	formatter	assembly
nginxbeautifier	Format and beautify nginx config files	formatter	nginx
nginxfmt	nginx config file formatter/beautifier written in Python with no additional dependencies	formatter	nginx
nickel	Better configuration for less	formatter	nickel
nimpretty	Code formatter for the Nim programming language	formatter	nim
nixfmt	The official formatter for Nix code	formatter	nix
nixpkgs-fmt	Nix code formatter for nixpkgs	formatter	nix
nomad	CLI for HashiCorp Nomad	formatter	hcl
nph	An opinionated code formatter for Nim	formatter	nim
npm-groovy-lint	Lint, format and auto-fix your Groovy / Jenkinsfile / Gradle files	formatter, linter	groovy
nufmt	The nushell formatter	formatter	nushell
ocamlformat	Auto-formatter for OCaml code	formatter	ocaml
ocp-indent	Indentation tool for OCaml	formatter	ocaml
odinfmt	Formatter for the Odin programming language	formatter	odin
oelint-adv	Advanced oelint	linter	bitbake
opa	Format Rego source files	formatter	rego
ormolu	A formatter for Haskell source code	formatter	haskell
oxfmt	Oxfmt a fast JavaScript/TypeScript formatter written in Rust	formatter	javascript, typescript
oxlint	Oxlint is designed to catch erroneous or useless code without requiring any configurations by default	linter	javascript, typescript
packer	Packer is used to format HCL2 configuration files	formatter	hcl
panache	A formatter and linter for Pandoc markdown, Quarto, and RMarkdown	formatter	markdown, pandoc, quarto, rmarkdown
pasfmt	Delphi code formatter	formatter	delphi, pascal
perflint	Python Linter for performance anti patterns	linter	python
perltidy	Perl::Tidy, a source code formatter for Perl	formatter	perl
pg_format	A PostgreSQL SQL syntax beautifier	formatter	sql
php-cs-fixer	A tool to automatically fix PHP Coding Standards issues	formatter, linter	php
phpcbf	PHP Code Beautifier and Fixer fixes violations of a defined coding standard	formatter	php
phpinsights	Instant PHP quality checks from your console	linter	php
pint	Laravel Pint is an opinionated PHP code style fixer for minimalists	formatter, linter	php
pkl	A configuration as code language with rich validation and tooling	formatter	pkl
prettier	Prettier is an opinionated code formatter	formatter	angular, css, ember, graphql, handlebars, html, javascript, json, less, markdown, scss, typescript, vue
prettierd	prettier, as a daemon, for improved formatting speed	formatter	angular, css, ember, graphql, handlebars, html, javascript, json, less, markdown, scss, typescript, vue
pretty-php	The opinionated PHP code formatter	formatter	php
prettypst	Formatter for Typst	formatter	typst
prisma	Commands for interacting with the prisma ORM	formatter	prisma
proselint	A linter for prose	spell-check
protolint	A pluggable linter and fixer to enforce Protocol Buffer style and conventions	linter	protobuf
ptop	Free Pascal source formatter	formatter	pascal
pug-lint	An unopinionated and configurable linter and style checker for Pug	linter	pug
puppet-lint	Check that your Puppet manifests conform to the style guide	linter	puppet
purs-tidy	A syntax tidy-upper for PureScript	formatter	purescript
purty	PureScript pretty-printer	formatter	purescript
pycln	A formatter for finding and removing unused import statements	formatter	python
pycodestyle	Simple Python style checker in one Python file	linter	python
pydoclint	A very fast Python docstring linter	linter	python
pydocstringformatter	Automatically format your Python docstrings to conform with PEP 8 and PEP 257	formatter	python
pydocstyle	docstring style checker	formatter	python
pyflakes	A simple program which checks Python source files for errors	linter	python
pyink	Pyink is a Python formatter, forked from Black with a few different formatting behaviors	formatter	python
pylint	Pylint is a static code analyser for Python 2 and 3	linter	python
pymarkdownlnt	A GitHub Flavored Markdown compliant Markdown linter	formatter, linter	markdown
pyment	Format and convert Python docstrings and generates patches	formatter	python
pyrefly	A fast type checker for Python	linter	python
pyupgrade	A tool to automatically upgrade Python syntax to newer versions	linter	python
qmlfmt	Command line application that formats QML files	formatter	qml
qmlformat	qmlformat is a tool that automatically formats QML files in accordance with the QML Coding Conventions	formatter	qml
qmllint	qmllint is a tool shipped with Qt, that verifies the syntactic validity of QML files	linter	qml
quick-lint-js	quick-lint-js finds bugs in JavaScript programs	linter	javascript
raco	An extensible code formatter for Racket	formatter	racket
reek	Code smell detector for Ruby	linter	ruby
refmt	refmt stands by Reason Formatter and it formats Reason programs, is a parser and pretty-printer for Reason	formatter	reason
reformat-gherkin	Formatter for Gherkin language	formatter	gherkin
refurb	A tool for refurbishing and modernizing Python codebases	linter	python
regal	Regal is a linter and language server for Rego, bringing your policy development experience to the next level	linter	rego
reorder-python-imports	Rewrites source to reorder python imports	formatter	python
rescript	ReScript is a robustly typed language that compiles to efficient and human-readable JavaScript	formatter	rescript
revive	~6x faster, stricter, configurable, extensible, and beautiful drop-in replacement for golint	linter	go
roc	A fast, friendly, functional language	formatter	roc
rstfmt	A formatter for reStructuredText	formatter	restructuredtext
rubocop	A Ruby static code analyzer and formatter, based on the community Ruby style guide	formatter, linter	ruby
rubyfmt	Ruby Autoformatter	formatter	ruby
ruff	An extremely fast Python linter and code formatter, written in Rust	formatter, linter	python
rufo	The Ruby Formatter	formatter	ruby
rumdl	A fast Markdown linter and formatter	formatter, linter	markdown
rune	An embeddable dynamic programming language for Rust	formatter	rune
runic	A code formatter for Julia with rules set in stone	formatter	julia
rustfmt	Format Rust code	formatter	rust
rustywind	CLI for organizing Tailwind CSS classes	formatter	html
salt-lint	A command-line utility that checks for best practices in SaltStack	linter	salt
scala	Code formatter for Scala	formatter	scala
scalafmt	Code formatter for Scala	formatter	scala
scalariform	Scala source code formatter	formatter	scala
selene	A blazing-fast modern Lua linter written in Rust	linter	lua
semistandard	All the goodness of standardjs with semicolons sprinkled on top	formatter, linter	javascript
shellcheck	ShellCheck, a static analysis tool for shell scripts	linter	bash, shell
shellharden	The corrective bash syntax highlighter	linter	bash, shell
shfmt	A shell parser, formatter, and interpreter with bash support	formatter	shell
sleek	Sleek is a CLI tool for formatting SQL. It helps you maintain a consistent style across your SQL code, enhancing readability and productivity	formatter	sql
slim-lint	Configurable tool for analyzing Slim templates	linter	slim
smlfmt	A custom parser/auto-formatter for Standard ML	formatter	standard-ml
snakefmt	The uncompromising Snakemake code formatter	formatter	snakemake
solhint	Solhint is an open-source project to provide a linting utility for Solidity code	linter	solidity
sphinx-lint	Check for stylistic and formal issues in .rst and .py files included in the documentation	linter	python, restructredtext
sql-formatter	A whitespace formatter for different query languages	formatter	sql
sqlfluff	A modular SQL linter and auto-formatter with support for multiple dialects and templated code	formatter, linter	sql
sqlfmt	sqlfmt formats your dbt SQL files so you don't have to	formatter	sql
sqlint	Simple SQL linter supporting ANSI and PostgreSQL syntaxes	linter	sql
sqruff	Fast SQL formatter/linter	formatter, linter	sql
squawk	Linter for Postgres migrations & SQL	linter	postgresql, sql
standardjs	JavaScript Style Guide, with linter & automatic code fixer	formatter, linter	javascript
standardrb	Ruby's bikeshed-proof linter and formatter	formatter, linter	ruby
statix	lints and suggestions for the nix programming language	linter	nix
stylefmt	stylefmt is a tool that automatically formats stylesheets	formatter	css, scss
stylelint	A mighty CSS linter that helps you avoid errors and enforce conventions	linter	css, scss
stylish-haskell	Haskell code prettifier	formatter	haskell
stylua	A Lua code formatter	formatter	lua
superhtml	HTML Validator, Formatter, LSP, and Templating Language Library	formatter	html
svlint	SystemVerilog linter	linter	systemverilog
swift-format	Formatting technology for Swift source code	formatter	swift
swiftformat	A command-line tool and Xcode Extension for formatting Swift code	formatter	swift
swiftlint	A tool to enforce Swift style and conventions	linter	swift
taplo	A TOML toolkit written in Rust	formatter	toml
tclfmt	Formatter for Tcl	linter	tcl
tclint	Linter for Tcl	linter	tcl
templ	A language for writing HTML user interfaces in Go	formatter	go, templ
terraform	The terraform fmt command is used to rewrite Terraform configuration files to a canonical format and style	formatter	terraform
terragrunt	Recursively find hcl files and rewrite them into a canonical format	formatter	hcl
tex-fmt	An extremely fast LaTeX formatter written in Rust	formatter	latex
textlint	textlint is the pluggable linter for natural language text	spell-check
tlint	Tighten linter for Laravel conventions	linter	php
tofu	The tofu fmt command is used to rewrite OpenTofu configuration files to a canonical format and style	formatter	terraform, tofu
tombi	TOML Formatter / Linter	formatter, linter	toml
toml-sort	A command line utility to sort and format toml files	formatter	toml
topiary	Topiary aims to be a uniform formatter for simple languages, as part of the Tree-sitter ecosystem	formatter
tryceratops	A linter to prevent exception handling antipatterns in Python	linter	python
ts-standard	Typescript style guide, linter, and formatter using StandardJS	formatter, linter	typescript
tsp	CLI for managing TypeSpec configurations	formatter	typespec
tsqllint	Configurable linting for TSQL	linter	sql
twig-cs-fixer	A tool to automatically fix Twig Coding Standards issues	formatter, linter	twig
twigcs	The missing checkstyle for twig	linter	php, twig
txtpbfmt	txtpbfmt parses, edits and formats text proto files in a way that preserves comments	formatter	protobuf
ty	An extremely fast Python type checker written in Rust	linter	python
typos	Source code spell checker	spell-check
typstfmt	Basic formatter for the Typst language	formatter	typst
typstyle	Beautiful and reliable typst code formatter	formatter	typst
ufmt	Safe, atomic formatting with black and usort	formatter	python
uiua	A stack-based array programming language	formatter	uiua
unimport	The ultimate linter and formatter for removing unused import statements in your code	formatter	python
usort	Safe, minimal import sorting for Python projects	formatter	python
v	Tooling for V lang	formatter	v
vacuum	vacuum is the worlds fastest OpenAPI 3, OpenAPI 2 / Swagger linter and quality analysis tool	linter	json, openapi, yaml
verusfmt	An Opinionated Formatter for Verus	formatter	rust, verus
veryl	Veryl: A Modern Hardware Description Language	formatter	veryl
vhdl-style-guide	Style guide enforcement for VHDL	formatter	vhdl
vint	Fast and Highly Extensible Vim script Language Lint	linter	vimscript
wa	The Wa Programming Language	formatter	wa
wfindent	Indents and optionally converts Fortran program sources	formatter	fortran
write-good	Naive linter for English prose	linter
xmlformat	Format and compress XML documents	formatter	xml
xmllint	XML linter	linter	xml
xo	JavaScript/TypeScript linter (ESLint wrapper) with great defaults	linter	javascript, typescript
xq	Command-line XML and HTML beautifier and content extractor	formatter	html, xml
yamlfix	A simple opinionated yaml formatter that keeps your comments	formatter	yaml
yamlfmt	An extensible command line tool or library to format yaml files	formatter	yaml
yamllint	A linter for YAML files	linter	yaml
yapf	A formatter for Python files	formatter	python
yard-lint	Check your YARD docs like RuboCop checks your code - a linter for YARD documentation	linter	ruby
yew-fmt	Code formatter for the Yew framework	formatter	rust
yq	yq is a portable command-line YAML, JSON, XML, CSV, TOML and properties processor	formatter	yaml
zig	Reformat Zig source into canonical form	formatter	zig
ziggy	Formats Ziggy documents and Ziggy schemas	formatter	ziggy
zprint	Beautifully format Clojure and Clojurescript source code and s-expressions	formatter	clojure, clojurescript
zsweep	Linter for Zshell scripting language	linter	zsh
zuban	Python Type Checker	linter	python

Commands

mdsf currently supports 402 commands. Feel free to open an issue/pull-request if your favorite tool/command is missing! 😃

Name	Command
action-validator	action-validator $PATH
actionlint	actionlint $PATH
air:format	air format $PATH
alejandra	alejandra --quiet $PATH
alex	alex --quiet $PATH
ameba	ameba --fix $PATH
ansible-lint	ansible-lint $PATH
api-linter	api-linter $PATH
asmfmt	asmfmt -w $PATH
astyle	astyle --quiet $PATH
atlas:fmt	atlas schema fmt $PATH
atlas:lint	atlas schema lint $PATH
auto-optional	auto-optional $PATH
autocorrect	autocorrect --fix $PATH
autoflake	autoflake --quiet --in-place $PATH
autopep8	autopep8 --in-place $PATH
bashate	bashate $PATH
beancount-black	bean-black $PATH
beautysh	beautysh $PATH
bibtex-tidy	bibtex-tidy -m $PATH
bicep:format	bicep format $PATH
biome:check:unsafe	biome check --write --unsafe $PATH
biome:check	biome check --write $PATH
biome:format	biome format --write $PATH
biome:lint:unsafe	biome lint --write --unsafe $PATH
biome:lint	biome lint --write $PATH
black	black --quiet $PATH
blade-formatter	blade-formatter --write $PATH
blue	blue --quiet $PATH
bpfmt	bpfmt -w $PATH
brittany	brittany --write-mode=inplace $PATH
brunette	brunette --quiet $PATH
bsfmt	bsfmt $PATH --write
bslint	bslint --fix $PATH
buf:format	buf format --write $PATH
buf:lint	buf lint $PATH
buildifier	buildifier $PATH
c3fmt	c3fmt --in-place $PATH
cabal-fmt	cabal-fmt --inplace $PATH
cabal-gild	cabal-gild --input $PATH --output $PATH
cabal-prettify	cabal-prettify $PATH
cabal:format	cabal format $PATH
caddy:fmt	caddy fmt $PATH -w
caramel:fmt	caramel fmt $PATH
cedar:format	cedar format
cfn-lint	cfn-lint $PATH
checkmake	checkmake $PATH
clang-format	clang-format -i $PATH
clang-tidy	clang-tidy --fix $PATH
clj-kondo	clj-kondo --lint $PATH
cljfmt:fix	cljfmt fix $PATH
cljstyle	cljstyle fix $PATH
cmake-format	cmake-format -i $PATH
cmake-lint	cmake-lint $PATH
codeql:query:format	codeql query format -i $PATH
codespell	codespell $PATH --check-hidden --write-changes
coffeelint	coffeelint -q $PATH
cppcheck	cppcheck $PATH
cpplint	cpplint --quiet $PATH
crlfmt	crlfmt -w $PATH
crystal:format	crystal tool format $PATH
csharpier	csharpier format --write-stdout
css-beautify	css-beautify -r --type css -f $PATH
csscomb	csscomb -t $PATH
csslint	csslint --quiet $PATH
cue:fmt	cue fmt $PATH
cueimports	cueimports
curlylint	curlylint -q $PATH
d2:fmt	d2 fmt $PATH
dart:fix	dart fix --apply $PATH
dart:format	dart format $PATH
dcm:fix	dcm fix $PATH
dcm:format	dcm format $PATH
deadnix	deadnix -q --edit $PATH
deno:fmt	deno fmt --quiet $PATH
deno:lint	deno lint --fix $PATH
dfmt	dfmt -i $PATH
dhall:format	dhall format $PATH
dhall:lint	dhall lint $PATH
djade	djade $PATH
djangofmt	djangofmt $PATH
djlint	djlint $PATH --reformat
docformatter	docformatter --in-place $PATH
dockerfmt	dockerfmt -w -n $PATH
dockfmt	dockfmt fmt -w $PATH
docstrfmt	docstrfmt $PATH
doctoc	doctoc $PATH
dotenv-linter:fix	dotenv-linter fix $PATH
dprint:fmt	dprint fmt $PATH
dscanner:fix	dscanner fix $PATH
dscanner:lint	dscanner lint $PATH
dune:format-dune-file	dune format-dune-file
duster:fix	duster fix --quiet --no-interaction $PATH
duster:lint	duster lint --quiet --no-interaction $PATH
dx:fmt	dx fmt --all-code --file $PATH
easy-coding-standard	ecs check $PATH --fix --no-interaction
efmt	efmt -w $PATH
elm-format	elm-format --elm-version=0.19 --yes $PATH
eradicate	eradicate --in-place $PATH
erb-formatter	erb-format $PATH --write
erg:lint	erg lint $PATH
erlfmt	erlfmt -w '$PATH'
eslint	eslint --fix $PATH
fantomas	fantomas $PATH
fish_indent	fish_indent -w $PATH
fixjson	fixjson -w $PATH
floskell	floskell $PATH
flynt	flynt $PATH
fnlfmt	fnlfmt $PATH
forge:fmt	forge fmt $PATH
fortitude:check:fix:unsafe	fortitude check --quiet --no-respect-gitignore --fix --unsafe-fixes $PATH
fortitude:check:fix	fortitude check --quiet --no-respect-gitignore --fix $PATH
fortitude:check	fortitude check --quiet --no-respect-gitignore $PATH
fortran-linter	fortran-linter -i $PATH
fourmolu	fourmolu -i $PATH
fprettify	fprettify $PATH
futhark:fmt	futhark fmt $PATH
fvm:dart:fix	fvm dart fix --apply $PATH
fvm:dart:format	fvm dart format $PATH
gci	gci write --skip-generated --skip-vendor $PATH
gdformat	gdformat $PATH
gdlint	gdlint $PATH
gersemi	gersemi -i -q $PATH
ghokin:check	ghokin check $PATH
ghokin:fmt	ghokin fmt replace $PATH
gleam:format	gleam format $PATH
gluon:fmt	gluon fmt $PATH
gofmt	gofmt -w $PATH
gofumpt	gofumpt -w $PATH
goimports-reviser	goimports-reviser -format $PATH
goimports	goimports -w $PATH
golangci-lint:fmt	golangci-lint fmt $PATH
golangci-lint:run:fix	golangci-lint run --fix $PATH
golangci-lint:run	golangci-lint run $PATH
golines	golines -w $PATH
google-java-format	google-java-format -i $PATH
gospel	gospel $PATH
grafbase:lint	grafbase lint $PATH
grain:format	grain format $PATH -o $PATH
hadolint	hadolint $PATH
haml-lint	haml-lint --auto-correct $PATH
hclfmt	hclfmt -w $PATH
hfmt	hfmt -w $PATH
hindent	hindent $PATH
hlint	hlint $PATH
hongdown	hongdown -w $PATH
html-beautify	html-beautify -r --type html -f $PATH
htmlbeautifier	htmlbeautifier $PATH
htmlhint	htmlhint $PATH
hurlfmt	hurlfmt --in-place $PATH
imba:fmt	imba fmt -f $PATH
inko:fmt	inko fmt $PATH
isort	isort --quiet $PATH
janet-format	janet-format
joker	joker --format --write $PATH
jq	jq
jqfmt	jqfmt
js-beautify	js-beautify -r --type js -f $PATH
json5format	json5format -r $PATH
json_repair	json_repair -i $PATH
jsona:format	jsona format $PATH
jsona:lint	jsona lint $PATH
jsonlint:sort	jsonlint -s -i $PATH
jsonlint	jsonlint -i $PATH
jsonnet-lint	jsonnet-lint $PATH
jsonnetfmt	jsonnetfmt -i $PATH
jsonpp	jsonpp -s
juliaformatter.jl	julia -E using JuliaFormatter;format_file(\"$PATH\")
just	just --fmt --unstable --justfile $PATH
kcl:fmt	kcl fmt $PATH
kcl:lint	kcl lint $PATH
kdlfmt:v1	kdlfmt format --kdl-version v1 $PATH
kdlfmt:v2	kdlfmt format --kdl-version v2 $PATH
kdlfmt	kdlfmt format $PATH
kdoc-formatter	kdoc-formatter --quiet $PATH
keep-sorted	keep-sorted $PATH
ktfmt	ktfmt $PATH
ktlint	ktlint --format --log-level=error $PATH
kube-linter:lint	kube-linter lint $PATH
kulala-fmt:check	kulala-fmt check $PATH
kulala-fmt:format	kulala-fmt format $PATH
leptosfmt	leptosfmt $PATH
liquidsoap-prettier	liquidsoap-prettier --write $PATH
luacheck	luacheck $PATH
luaformatter	lua-format -i $PATH
luau-analyze	luau-analyze $PATH
mado:check	mado check $PATH
mago:analyze:fix:unsafe	mago analyze --fix --potentially-unsafe --unsafe $PATH
mago:analyze:fix	mago analyze --fix $PATH
mago:analyze	mago analyze $PATH
mago:format	mago format $PATH
mago:lint:fix:unsafe	mago lint --fix --potentially-unsafe --unsafe $PATH
mago:lint:fix	mago lint --fix $PATH
mago:lint	mago lint $PATH
markdownfmt	markdownfmt -w $PATH
markdownlint-cli2	markdownlint-cli2 --fix $PATH
markdownlint	markdownlint --fix $PATH
markuplint	markuplint --fix $PATH
mbake:format	mbake format $PATH
mbake:validate	mbake validate $PATH
md-padding	md-padding -i $PATH
mdformat	mdformat $PATH
mdsf:format	mdsf format $PATH
mdsf:verify	mdsf verify $PATH
mdslw	mdslw $PATH
meson:fmt	meson fmt -i $PATH
mh_lint	mh_lint $PATH
mh_style	mh_style $PATH
mise:fmt	mise fmt --stdin
misspell	misspell -w $PATH
mix:format	mix format $PATH
mojo:format	mojo format -q $PATH
muon:fmt	muon fmt -i $PATH
muon:lint	muon lint -i $PATH
mypy	mypy $PATH
nasmfmt	nasmfmt $PATH
nginxbeautifier	nginxbeautifier $PATH
nginxfmt	nginxfmt $PATH
nickel:format	nickel format $PATH
nimpretty	nimpretty $PATH
nixfmt	nixfmt $PATH
nixpkgs-fmt	nixpkgs-fmt $PATH
nomad:fmt	nomad fmt $PATH
nph	nph $PATH
npm-groovy-lint	npm-groovy-lint --format $PATH
nufmt	nufmt $PATH
ocamlformat	ocamlformat --ignore-invalid-option --inplace --enable-outside-detected-project $PATH
ocp-indent	ocp-indent --inplace $PATH
odinfmt	odinfmt -w $PATH
oelint-adv	oelint-adv --fix --nobackup --quiet $PATH
opa:fmt	opa fmt $PATH -w
ormolu	ormolu --mode inplace $PATH
oxfmt	oxfmt $PATH
oxlint	oxlint --fix $PATH
packer:fix	packer fix $PATH
packer:fmt	packer fmt $PATH
packer:validate	packer validate $PATH
panache:format	panache format $PATH
panache:lint	panache lint $PATH
pasfmt	pasfmt $PATH
perflint	perflint $PATH
perltidy	perltidy -b $PATH
pg_format	pg_format --inplace $PATH
php-cs-fixer:fix	php-cs-fixer fix $PATH
phpcbf	phpcbf $PATH
phpinsights:fix	phpinsights fix $PATH --no-interaction --quiet
pint	pint $PATH
pkl:format	pkl -w $PATH
prettier	prettier --embedded-language-formatting off --log-level error --write $PATH
prettierd	prettierd $PATH
pretty-php	pretty-php $PATH
prettypst	prettypst $PATH
prisma:format	prisma format --schema=$PATH
proselint	proselint $PATH
protolint	protolint lint -fix $PATH
ptop	ptop $PATH $PATH
pug-lint	pug-lint $PATH
puppet-lint	puppet-lint --fix $PATH
purs-tidy	purs-tidy format-in-place $PATH
purty	purty --write $PATH
pycln	pycln --no-gitignore --quiet $PATH
pycodestyle	pycodestyle $PATH
pydoclint	pydoclint $PATH
pydocstringformatter	pydocstringformatter -w $PATH
pydocstyle	pydocstyle $PATH
pyflakes	pyflakes $PATH
pyink	pyink --quiet $PATH
pylint	pylint --module-naming-style=any $PATH
pymarkdownlnt:fix	pymarkdownlnt --return-code-scheme minimal fix $PATH
pyment	pyment -w $PATH
pyrefly	pyrefly check $PATH
pyupgrade	pyupgrade --exit-zero-even-if-changed $PATH
qmlfmt	qmlfmt -w $PATH
qmlformat	qmlformat -i $PATH
qmllint	qmllint $PATH
quick-lint-js	quick-lint-js $PATH
raco:fmt	raco fmt -i $PATH
reek	reek $PATH
refmt	refmt --in-place $PATH
reformat-gherkin	reformat-gherkin $PATH
refurb	refurb $PATH
regal:fix	regal fix $PATH
regal:lint	regal lint $PATH
reorder-python-imports	reorder-python-imports --exit-zero-even-if-changed $PATH
rescript:format	rescript format $PATH
revive	revive $PATH
roc:format	roc format $PATH
rstfmt	rstfmt $PATH
rubocop	rubocop --fix-layout --autocorrect --format quiet $PATH
rubyfmt	rubyfmt -i $PATH
ruff:check	ruff check --fix --quiet $PATH
ruff:format	ruff format --quiet $PATH
rufo	rufo --simple-exit $PATH
rumdl:check:fix	rumdl check --fix $PATH
rumdl:check	rumdl check $PATH
rumdl:fmt	rumdl fmt $PATH
rune:fmt	rune fmt $PATH
runic	runic --inplace $PATH
rustfmt:2015	rustfmt --edition 2015 --quiet $PATH
rustfmt:2018	rustfmt --edition 2018 --quiet $PATH
rustfmt:2021	rustfmt --edition 2021 --quiet $PATH
rustfmt:2024	rustfmt --edition 2024 --quiet $PATH
rustfmt	rustfmt --edition 2024 --quiet $PATH
rustywind	rustywind --write $PATH
salt-lint	salt-lint $PATH
scala	scala fmt $PATH
scalafmt	scalafmt --quiet --mode any $PATH
scalariform	scalariform $PATH
selene	selene --no-summary --quiet $PATH
semistandard	semistandard --fix --stdin
shellcheck	shellcheck $PATH
shellharden	shellharden --transform --replace $PATH
shfmt	shfmt --write $PATH
sleek	sleek $PATH
slim-lint	slim-lint $PATH
smlfmt	smlfmt --force $PATH
snakefmt	snakefmt $PATH
solhint	solhint --quiet --fix --noPrompt $PATH
sphinx-lint	sphinx-lint $PATH
sql-formatter	sql-formatter --fix $PATH
sqlfluff:fix	sqlfluff fix --disable-progress-bar --nocolor --dialect ansi $PATH
sqlfluff:format	sqlfluff format --disable-progress-bar --nocolor --dialect ansi $PATH
sqlfluff:lint	sqlfluff lint --disable-progress-bar --nocolor --dialect ansi $PATH
sqlfmt	sqlfmt $PATH
sqlint	sqlint $PATH
sqruff	sqruff fix $PATH
squawk	squawk $PATH
standardjs	standard --fix --stdin
standardrb	standardrb --fix $PATH
statix:check	statix check $PATH
statix:fix	statix fix $PATH
stylefmt	stylefmt $PATH
stylelint	stylelint --fix $PATH
stylish-haskell	stylish-haskell --inplace $PATH
stylua	stylua --verify $PATH
superhtml:fmt	superhtml fmt $PATH
svlint	svlint $PATH
swift-format	swift-format --in-place $PATH
swiftformat	swiftformat --quiet $PATH
swiftlint	swiftlint $PATH
taplo	taplo format $PATH
tclfmt	tclfmt $PATH
tclint	tclint $PATH
templ:fmt	templ fmt $PATH
terraform:fmt	terraform fmt -write=true $PATH
terragrunt:hclfmt	terragrunt hclfmt --terragrunt-hclfmt-file $PATH
tex-fmt	tex-fmt $PATH
textlint:fix	textlint --fix $PATH
textlint	textlint $PATH
tlint:format	tlint format $PATH
tofu:fmt	tofu fmt -write=true $PATH
tombi:format	tombi format -
tombi:lint	tombi lint $PATH
toml-sort	toml-sort -i $PATH
topiary	topiary format $PATH
tryceratops	tryceratops --autofix $PATH
ts-standard	ts-standard --fix $PATH
tsp:format	tsp format $PATH
tsqllint	tsqllint --fix $PATH
twig-cs-fixer:check	twig-cs-fixer check $PATH --no-interaction
twig-cs-fixer:fix	twig-cs-fixer fix $PATH --no-interaction
twig-cs-fixer:lint	twig-cs-fixer lint $PATH --no-interaction
twigcs	twigcs $PATH
txtpbfmt	txtpbfmt $PATH
ty	ty check $PATH
typos	typos -w --no-ignore --hidden $PATH
typstfmt	typstfmt $PATH
typstyle	typstyle -i $PATH
ufmt	ufmt format $PATH
uiua:fmt	uiua fmt $PATH
unimport	unimport -r $PATH
usort	usort format $PATH
v:fmt	v fmt -w $PATH
vacuum:lint	vacuum lint $PATH
verusfmt	verusfmt $PATH
veryl:fmt	veryl fmt $PATH
vhdl-style-guide	vsg -f $PATH --fix
vint:neovim	vint --enable-neovim $PATH
vint	vint $PATH
wa:fmt	wa fmt $PATH
wfindent	wfindent $PATH
write-good	write-good $PATH
xmlformat	xmlformat --overwrite $PATH
xmllint	xmllint --format $PATH --output $PATH
xo	xo --fix --stdin
xq:html	xq --html
xq	xq
yamlfix	yamlfix $PATH
yamlfmt	yamlfmt -quiet $PATH
yamllint	yamllint $PATH
yapf	yapf --in-place $PATH
yard-lint	yard-lint $PATH
yew-fmt	yew-fmt --edition 2021 $PATH
yq	yq --inplace $PATH
zig:fmt	zig fmt $PATH
ziggy:check	ziggy check $PATH
ziggy:fmt	ziggy fmt $PATH
zprint	zprint -w $PATH
zsweep	zsweep --auto $PATH
zuban:check	zuban check $PATH
zuban:mypy	zuban mypy $PATH
zuban	zuban $PATH

Shell completions

Shell completions can be generated using mdsf completions <SHELL>.

Generate shell completion

Usage: mdsf completions [OPTIONS] <SHELL>

Arguments:
  <SHELL>  [possible values: bash, elvish, fish, nushell, powershell, zsh]

Options:
      --log-level <LOG_LEVEL>  [default: debug] [possible values: trace, debug, info, warn, error, off]
  -h, --help                   Print help
  -V, --version                Print version

Bash

Add the following to your .bashrc.

eval "$(mdsf completions bash)"

Zsh

Add the following to your .zshrc.

eval "$(mdsf completions zsh)"

Fish

Add the following to ~/.config/fish/config.fish.

mdsf completions fish | source

PowerShell

Add the following to your PowerShell configuration (Can be found by running $PROFILE).

Invoke-Expression (&mdsf completions powershell)

Elvish

Add the following to ~/.elvish/rc.elv.

eval (mdsf completions elvish)

Nushell

Generate completions for nushell.

mdsf completions nushell

Rust MSRV

mdsf is developed against the latest stable Rust version.

Older version might be indirectly supported, but it is not guaranteed without prior agreement.

Feel free to open an issue if you have a good reason for wanting support for a specific Rust compiler version.

Acknowledgement

mdsf was inspired by the amazing neovim formatting plugin conform.nvim.

Alternatives to mdsf

• conform.nvim using injected mode.
• mdformat.