localtools-sql-formatter 1.0.0__tar.gz

localtools_sql_formatter-1.0.0/.gitignore

@@ -0,0 +1,8 @@
+dist/
+/*.exe
+node_modules/
+test-results/
+playwright-report/
+__pycache__/
+*.egg-info/
+.venv/

localtools_sql_formatter-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chaitanya Prabuddha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

localtools_sql_formatter-1.0.0/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.5
+Name: localtools-sql-formatter
+Version: 1.0.0
+Summary: Lint, fix and transpile SQL in any major dialect with sqlfluff and sqlglot (localtools, offline)
+Project-URL: Source, https://github.com/chayprabs/localtools
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: multipart>=1.2
+Requires-Dist: sqlfluff[rs]<5,>=4.4
+Requires-Dist: sqlglot>=30
+Description-Content-Type: text/markdown
+
+# SQL Formatter (localtools)
+
+Lint, auto-fix and format SQL in 28 dialects with **sqlfluff**, and transpile between dialects with **sqlglot**.
+Runs on your machine: a one-page web UI on `http://127.0.0.1:47117`, plus a CLI for scripts and CI.
+
+## Install
+
+| OS | command |
+|---|---|
+| Windows (PowerShell) | `irm https://raw.githubusercontent.com/chayprabs/localtools/main/sql-formatter/install.ps1 \| iex` |
+| macOS / Linux | `curl -fsSL https://raw.githubusercontent.com/chayprabs/localtools/main/sql-formatter/install.sh \| bash` |
+| PyPI | `pipx install localtools-sql-formatter` |
+
+The script installs a self-contained build (bundled Python) into `~/.localtools/sql-formatter` and adds a launcher.
+
+## Use
+
+`localtools-sql-formatter` opens the UI. Paste SQL or drop `.sql` files (several at once), pick the dialect, then:
+
+- **Lint**: every violation with line:column, rule code (linked to the sqlfluff docs) and whether it can be auto-fixed. Download the report as JSON.
+- **Fix**: the fixed SQL with a diff, Copy and Download, plus what still needs a human.
+- **Transpile**: rewrite between dialects (e.g. T-SQL `TOP`/`ISNULL` to Postgres `LIMIT`/`COALESCE`), with notes on unsupported constructs.
+
+Options: rule selection/exclusion (`LT01,CP01`, `core`, `layout`), templater (Jinja, or placeholders `:name`, `?`, `$1`, `%(name)s`, `@name`), and an uploaded `.sqlfluff` / `setup.cfg` / `tox.ini` / `pyproject.toml`.
+
+```sh
+localtools-sql-formatter lint models/*.sql --dialect postgres --format json   # or human | sarif; exit 1 on violations
+localtools-sql-formatter fix query.sql --dialect snowflake                     # fixed SQL to stdout
+localtools-sql-formatter fix *.sql --in-place --config .sqlfluff              # rewrite files; exit 1 if anything is left
+localtools-sql-formatter fix - --diff < query.sql                             # stdin, unified diff
+localtools-sql-formatter transpile q.sql --read tsql --write duckdb
+localtools-sql-formatter dialects | rules
+```
+
+API: `POST /api/lint`, `/api/fix`, `/api/transpile` (multipart: `sql` and/or `file`..., `dialect`, `rules`, `exclude_rules`,
+`templater`, `config` file; transpile: `read`, `write`), `GET /api/meta`. `/api/lint` with `format=sarif` returns SARIF 2.1.0.
+
+## Engine and why
+
+- **sqlfluff 4** (with its Rust parser, sqlfluffrs) is the most complete open-source SQL linter: dialect-aware parsing,
+  ~70 rules, real auto-fix, Jinja/placeholder templating. Results are identical to the `sqlfluff` CLI with the same config
+  (tested on TPC-H, sqlfluff's dialect fixtures, dbt's jaffle_shop and GitLab's schema).
+- `fix` repeats sqlfluff's fix pass until nothing changes, so running it twice gives the same SQL; when sqlfluff
+  oscillates between two layouts (it happens), the tool settles on one of them deterministically.
+- **sqlglot** transpiles (sqlfluff cannot): it parses into an AST and regenerates SQL for 31 dialects. Output equals the
+  `python -m sqlglot --identify false` CLI. It reformats in its own style, which is why lint/fix stay with sqlfluff.
+
+## Limits and safety
+
+- The web UI/API takes up to 512 KB of SQL and about 2,000 statements per run, and each run has a 120 s deadline
+  (sqlfluff is thorough but slow: a messy 20 KB file can take 10+ s). Every run is a separate worker process that is
+  killed at the deadline, when the browser disconnects, or when the server exits; at most 1–4 run at once (else HTTP 503).
+  On Linux each worker is capped at 2 GB of memory. The CLI has no size limit or deadline.
+- Config files are parsed, never executed: `library_path`, macro/loader paths (any `*_path` / `*_dir` key), the python and
+  dbt templaters and `processes` are ignored and listed in the result. sqlfluff's 20 KB "skip large file" default is off.
+- Files that do not parse are not fixed (like the sqlfluff CLI); the parse error shows line and column.
+
+## Cut
+
+- dbt templater (needs a dbt project, adapters and a database connection) and the python templater (runs code): use
+  `jinja`, which provides dbt's `ref`/`source`/`config` builtins.
+- Automatic discovery of `.sqlfluff` files next to the SQL: pass `--config` explicitly.
+- winget/Homebrew/Scoop packages: Python-runtime tools ship through the install scripts and PyPI.
+
+## Update / uninstall
+
+`localtools-sql-formatter update` · `localtools-sql-formatter uninstall` (pipx: `pipx upgrade|uninstall localtools-sql-formatter`).
+
+## License
+
+MIT. Bundled components: see THIRD_PARTY_NOTICES.md.

localtools_sql_formatter-1.0.0/README.md

@@ -0,0 +1,71 @@
+# SQL Formatter (localtools)
+
+Lint, auto-fix and format SQL in 28 dialects with **sqlfluff**, and transpile between dialects with **sqlglot**.
+Runs on your machine: a one-page web UI on `http://127.0.0.1:47117`, plus a CLI for scripts and CI.
+
+## Install
+
+| OS | command |
+|---|---|
+| Windows (PowerShell) | `irm https://raw.githubusercontent.com/chayprabs/localtools/main/sql-formatter/install.ps1 \| iex` |
+| macOS / Linux | `curl -fsSL https://raw.githubusercontent.com/chayprabs/localtools/main/sql-formatter/install.sh \| bash` |
+| PyPI | `pipx install localtools-sql-formatter` |
+
+The script installs a self-contained build (bundled Python) into `~/.localtools/sql-formatter` and adds a launcher.
+
+## Use
+
+`localtools-sql-formatter` opens the UI. Paste SQL or drop `.sql` files (several at once), pick the dialect, then:
+
+- **Lint**: every violation with line:column, rule code (linked to the sqlfluff docs) and whether it can be auto-fixed. Download the report as JSON.
+- **Fix**: the fixed SQL with a diff, Copy and Download, plus what still needs a human.
+- **Transpile**: rewrite between dialects (e.g. T-SQL `TOP`/`ISNULL` to Postgres `LIMIT`/`COALESCE`), with notes on unsupported constructs.
+
+Options: rule selection/exclusion (`LT01,CP01`, `core`, `layout`), templater (Jinja, or placeholders `:name`, `?`, `$1`, `%(name)s`, `@name`), and an uploaded `.sqlfluff` / `setup.cfg` / `tox.ini` / `pyproject.toml`.
+
+```sh
+localtools-sql-formatter lint models/*.sql --dialect postgres --format json   # or human | sarif; exit 1 on violations
+localtools-sql-formatter fix query.sql --dialect snowflake                     # fixed SQL to stdout
+localtools-sql-formatter fix *.sql --in-place --config .sqlfluff              # rewrite files; exit 1 if anything is left
+localtools-sql-formatter fix - --diff < query.sql                             # stdin, unified diff
+localtools-sql-formatter transpile q.sql --read tsql --write duckdb
+localtools-sql-formatter dialects | rules
+```
+
+API: `POST /api/lint`, `/api/fix`, `/api/transpile` (multipart: `sql` and/or `file`..., `dialect`, `rules`, `exclude_rules`,
+`templater`, `config` file; transpile: `read`, `write`), `GET /api/meta`. `/api/lint` with `format=sarif` returns SARIF 2.1.0.
+
+## Engine and why
+
+- **sqlfluff 4** (with its Rust parser, sqlfluffrs) is the most complete open-source SQL linter: dialect-aware parsing,
+  ~70 rules, real auto-fix, Jinja/placeholder templating. Results are identical to the `sqlfluff` CLI with the same config
+  (tested on TPC-H, sqlfluff's dialect fixtures, dbt's jaffle_shop and GitLab's schema).
+- `fix` repeats sqlfluff's fix pass until nothing changes, so running it twice gives the same SQL; when sqlfluff
+  oscillates between two layouts (it happens), the tool settles on one of them deterministically.
+- **sqlglot** transpiles (sqlfluff cannot): it parses into an AST and regenerates SQL for 31 dialects. Output equals the
+  `python -m sqlglot --identify false` CLI. It reformats in its own style, which is why lint/fix stay with sqlfluff.
+
+## Limits and safety
+
+- The web UI/API takes up to 512 KB of SQL and about 2,000 statements per run, and each run has a 120 s deadline
+  (sqlfluff is thorough but slow: a messy 20 KB file can take 10+ s). Every run is a separate worker process that is
+  killed at the deadline, when the browser disconnects, or when the server exits; at most 1–4 run at once (else HTTP 503).
+  On Linux each worker is capped at 2 GB of memory. The CLI has no size limit or deadline.
+- Config files are parsed, never executed: `library_path`, macro/loader paths (any `*_path` / `*_dir` key), the python and
+  dbt templaters and `processes` are ignored and listed in the result. sqlfluff's 20 KB "skip large file" default is off.
+- Files that do not parse are not fixed (like the sqlfluff CLI); the parse error shows line and column.
+
+## Cut
+
+- dbt templater (needs a dbt project, adapters and a database connection) and the python templater (runs code): use
+  `jinja`, which provides dbt's `ref`/`source`/`config` builtins.
+- Automatic discovery of `.sqlfluff` files next to the SQL: pass `--config` explicitly.
+- winget/Homebrew/Scoop packages: Python-runtime tools ship through the install scripts and PyPI.
+
+## Update / uninstall
+
+`localtools-sql-formatter update` · `localtools-sql-formatter uninstall` (pipx: `pipx upgrade|uninstall localtools-sql-formatter`).
+
+## License
+
+MIT. Bundled components: see THIRD_PARTY_NOTICES.md.

localtools_sql_formatter-1.0.0/localtools_sql_formatter/__main__.py

@@ -0,0 +1,311 @@
+import argparse
+import json
+import os
+import select
+import socket
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from pathlib import Path
+
+import multipart
+
+from . import engine
+from .localtools import HTTPError, Tool, main as run
+
+USAGE = """localtools-sql-formatter: lint, fix and transpile SQL in any major dialect, offline (sqlfluff + sqlglot).
+
+Usage:
+  localtools-sql-formatter [serve] [--port N] [--no-open]    start the web UI (default port 47117)
+  localtools-sql-formatter lint FILE... [options]             report rule violations; exit 1 if any
+      --format human|json|sarif
+  localtools-sql-formatter fix FILE... [options]              print the fixed SQL (one file), or:
+      --in-place   rewrite the files      --diff   print a unified diff
+      exit 1 if violations that cannot be fixed remain (or the file does not parse)
+  localtools-sql-formatter transpile FILE... --read D --write D [--no-pretty]   convert between dialects (sqlglot)
+  localtools-sql-formatter dialects | rules                   list dialects / lint rules
+  localtools-sql-formatter update | uninstall                 re-run the installer / remove the tool
+  localtools-sql-formatter --version | --help
+
+Options for lint and fix (FILE "-" reads stdin):
+  --dialect D          ansi (default), postgres, mysql, bigquery, snowflake, tsql, sqlite, duckdb, ...
+  --rules R            only these rules, e.g. LT01,CP01 or core     --exclude-rules R   skip these
+  --templater T        raw | jinja | placeholder:colon | placeholder:question_mark | placeholder:dollar | ...
+  --config FILE        .sqlfluff, setup.cfg, tox.ini or pyproject.toml ([tool.sqlfluff]); paths, python/dbt
+                       templaters and library code in it are ignored (nothing in a config is executed)
+
+API: POST /api/lint | /api/fix | /api/transpile (multipart: sql and/or file..., dialect, rules, exclude_rules,
+     templater, config (file); transpile: read, write), GET /api/meta (dialects + rules).
+     /api/lint with format=sarif returns SARIF 2.1.0.
+"""
+
+UI = Path(__file__).with_name("ui")  # wheel: packaged ui/; source checkout: repo-root ui/
+if not UI.is_dir():
+    UI = Path(__file__).parents[1] / "ui"
+DEADLINE = float(os.environ.get("LOCALTOOLS_SQL_DEADLINE") or 120)
+JOBS = int(os.environ.get("LOCALTOOLS_SQL_JOBS") or max(1, min(4, (os.cpu_count() or 2) // 2)))
+SLOTS = threading.BoundedSemaphore(JOBS)
+
+
+def text(data, name):
+    try:
+        return engine.newlines(data.decode("utf-8-sig"))
+    except UnicodeDecodeError:
+        raise HTTPError(400, f"{name}: not UTF-8 text")
+
+
+def read_form(req):
+    ctype, opts = multipart.parse_options_header(req.headers.get("Content-Type", ""))
+    if ctype != "multipart/form-data" or "boundary" not in opts:
+        raise HTTPError(400, "expected multipart/form-data")
+    size = int(req.headers.get("Content-Length") or 0)
+    if size > engine.MAX_BYTES * 2 + (1 << 20):
+        raise HTTPError(413, f"upload too large ({engine.MAX_BYTES >> 10} KB of SQL max)")
+    try:
+        parts = list(multipart.MultipartParser(req.rfile, opts["boundary"], size))
+    except multipart.MultipartError as e:
+        raise HTTPError(400, f"malformed upload: {e}")
+    try:
+        fields = {p.name: p.value for p in parts if not p.filename}
+        files = [(p.filename, text(p.raw, p.filename)) for p in parts if p.filename and p.name == "file"]
+        cfg = next(((p.filename, text(p.raw, p.filename)) for p in parts if p.filename and p.name == "config"), None)
+    finally:
+        for p in parts:
+            p.close()
+    if fields.get("sql", "").strip():
+        files.insert(0, (fields.get("name") or "pasted.sql", engine.newlines(fields["sql"])))
+    if not files:
+        raise HTTPError(400, "paste SQL or upload at least one .sql file")
+    if cfg:
+        fields["config_name"], fields["config"] = cfg
+    return files, fields
+
+
+def client_gone(req):
+    try:
+        r, _, _ = select.select([req.connection], [], [], 0)
+        return bool(r) and req.connection.recv(1, socket.MSG_PEEK) == b""
+    except OSError:
+        return True
+
+
+def run_worker(req, job):
+    """One worker process per request: killed at the deadline, when the client disconnects, and (stdin EOF)
+    when this server exits. At most JOBS run at once; more get 503."""
+    if not SLOTS.acquire(blocking=False):
+        raise HTTPError(503, f"busy: {JOBS} SQL job(s) already running; try again when they finish")
+    try:
+        with tempfile.TemporaryDirectory(prefix="lt-sqlf-") as d:
+            jp = Path(d, "job.json")
+            jp.write_text(json.dumps(job), encoding="utf-8")
+            cmd = [sys.executable, *(["-I"] if sys.flags.isolated else []), "-m", __package__, "_worker", str(jp)]
+            p = subprocess.Popen(cmd, cwd=d, stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                                 creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0))
+            end = time.monotonic() + DEADLINE
+            try:
+                while p.poll() is None:
+                    if time.monotonic() > end:
+                        raise HTTPError(422, f"sqlfluff did not finish within {DEADLINE:g} s on this input; "
+                                             "split it, narrow the rules, or use the CLI (no deadline)")
+                    if client_gone(req):
+                        raise HTTPError(499, "client disconnected")
+                    try:
+                        p.wait(0.2)
+                    except subprocess.TimeoutExpired:
+                        pass
+            finally:
+                if p.poll() is None:
+                    p.kill()
+                p.wait()
+                p.stdin.close()
+            out = jp.with_suffix(".out")
+            if not out.exists():
+                raise HTTPError(422, f"sqlfluff crashed on this input (exit code {p.returncode}); it may be nested too deeply")
+            res = json.loads(out.read_text(encoding="utf-8"))
+    finally:
+        SLOTS.release()
+    if "error" in res:
+        raise HTTPError(res["code"], res["error"])
+    return res
+
+
+def job(op, files, f):
+    try:
+        engine.check_limits(files)
+    except engine.SQLError as e:
+        raise HTTPError(413, str(e))
+    keys = ("read", "write") if op == "transpile" else ("dialect", "rules", "exclude_rules", "templater", "config", "config_name")
+    return {"op": op, "files": files, **{k: f[k] for k in keys if k in f}}
+
+
+def api(op):
+    def handler(req):
+        files, f = read_form(req)
+        res = run_worker(req, job(op, files, f))
+        if op == "lint" and f.get("format") == "sarif":
+            body = json.dumps(engine.sarif(res["files"], sqlfluff_version()), indent=2).encode()
+            req.send_response(200)
+            req.send_header("Content-Type", "application/sarif+json")
+            req.send_header("Content-Disposition", 'attachment; filename="sqlfluff.sarif"')
+            req.send_header("Content-Length", str(len(body)))
+            req.end_headers()
+            return req.wfile.write(body)
+        req.send_json(200, res)
+    return handler
+
+
+def sqlfluff_version():
+    from importlib.metadata import version
+    return version("sqlfluff")
+
+
+META = {}
+
+
+def api_meta(req):
+    if not META:
+        META.update(engine.dialects(), rules=engine.rules(), versions={"sqlfluff": sqlfluff_version()},
+                    limits={"bytes": engine.MAX_BYTES, "statements": engine.MAX_STATEMENTS, "deadline_s": DEADLINE},
+                    param_styles=engine.PARAM_STYLES)
+    req.send_json(200, META)
+
+
+# ---------- CLI ----------
+def read_inputs(paths):
+    out = []
+    for p in paths:
+        if p == "-":
+            out.append(("stdin.sql", engine.newlines(sys.stdin.buffer.read().decode("utf-8-sig"))))
+        else:
+            try:
+                out.append((p, engine.newlines(Path(p).read_bytes().decode("utf-8-sig"))))
+            except OSError as e:
+                raise ValueError(f"{p}: {e.strerror}")
+            except UnicodeDecodeError:
+                raise ValueError(f"{p}: not UTF-8 text")
+    return out
+
+
+def lint_parser(prog):
+    p = argparse.ArgumentParser(prog=f"localtools-sql-formatter {prog}")
+    p.add_argument("files", nargs="+")
+    p.add_argument("--dialect", default="")
+    p.add_argument("--rules", default="")
+    p.add_argument("--exclude-rules", default="")
+    p.add_argument("--templater", default="")
+    p.add_argument("--config")
+    return p
+
+
+def cli_config(a):
+    cfg = Path(a.config).read_text(encoding="utf-8-sig") if a.config else ""
+    return engine.make_config(a.dialect, a.rules, a.exclude_rules, a.templater, cfg, Path(a.config).name if a.config else "")
+
+
+def human(results):
+    for f in results:
+        for v in f.get("violations", f.get("remaining", [])):
+            print(f"{f['name']}:{v['line']}:{v['col']}: {v['code']} {v['description']}" + (" (warning)" if v["warning"] else ""))
+
+
+def utf8():
+    for s in (sys.stdout, sys.stderr):
+        s.reconfigure(encoding="utf-8", newline="")  # SQL out exactly as fixed (no CRLF translation on Windows)
+
+
+def cli_lint(args):
+    p = lint_parser("lint")
+    p.add_argument("--format", default="human", choices=["human", "json", "sarif"])
+    a = p.parse_args(args)
+    utf8()
+    cfg, dropped = cli_config(a)
+    for k in dropped:
+        print(f"note: ignored config key {k}", file=sys.stderr)
+    res = engine.lint(read_inputs(a.files), cfg)
+    if a.format == "json":
+        print(json.dumps(res, indent=2, ensure_ascii=False))
+    elif a.format == "sarif":
+        print(json.dumps(engine.sarif(res, sqlfluff_version()), indent=2, ensure_ascii=False))
+    else:
+        human(res)
+        n = sum(len(f["violations"]) for f in res)
+        print(f"{n} violation(s) in {len(res)} file(s)" if n else f"{len(res)} file(s) clean", file=sys.stderr)
+    return 1 if any(f["violations"] for f in res) else 0
+
+
+def cli_fix(args):
+    p = lint_parser("fix")
+    p.add_argument("--in-place", action="store_true")
+    p.add_argument("--diff", action="store_true")
+    a = p.parse_args(args)
+    utf8()
+    files = read_inputs(a.files)
+    if len(files) > 1 and not (a.in_place or a.diff):
+        raise ValueError("several files: add --in-place to rewrite them or --diff to print a diff")
+    if a.in_place and "-" in a.files:
+        raise ValueError("--in-place cannot rewrite stdin")
+    cfg, _ = cli_config(a)
+    res = engine.fix(files, cfg)
+    for f in res:
+        if a.in_place:
+            if f["changed"]:
+                Path(f["name"]).write_text(f["fixed"], encoding="utf-8", newline="")
+            print(f"{f['name']}: {'fixed' if f['changed'] else 'unchanged'}", file=sys.stderr)
+        elif a.diff:
+            sys.stdout.write(f["diff"])
+        else:
+            sys.stdout.write(f["fixed"])
+        if f["unparsable"]:
+            print(f"{f['name']}: not fixed, the file does not parse:", file=sys.stderr)
+        elif f["remaining"]:
+            print(f"{f['name']}: {len(f['remaining'])} violation(s) cannot be fixed automatically:", file=sys.stderr)
+        for v in f["remaining"]:
+            print(f"  {v['line']}:{v['col']}: {v['code']} {v['description']}", file=sys.stderr)
+    return 1 if any(f["remaining"] for f in res) else 0
+
+
+def cli_transpile(args):
+    p = argparse.ArgumentParser(prog="localtools-sql-formatter transpile")
+    p.add_argument("files", nargs="+")
+    p.add_argument("--read", default="")
+    p.add_argument("--write", default="")
+    p.add_argument("--no-pretty", action="store_true")
+    a = p.parse_args(args)
+    utf8()
+    for f in engine.transpile(read_inputs(a.files), a.read, a.write, not a.no_pretty):
+        sys.stdout.write(f["sql"])
+        for w in f["warnings"]:
+            print(f"{f['name']}: warning: {w}", file=sys.stderr)
+
+
+def cli_dialects(args):
+    d = engine.dialects()
+    print("lint/fix (sqlfluff):", " ".join(d["sqlfluff"]))
+    print("transpile (sqlglot):", " ".join(d["sqlglot"]))
+
+
+def cli_rules(args):
+    utf8()
+    for r in engine.rules():
+        print(f"{r['code']}  {r['name']:<36} {r['description']}")
+
+
+def cli_worker(args):
+    engine.worker_main(args[0])
+
+
+tool = Tool(slug="sql-formatter", port=47117, usage=USAGE, ui=UI,
+            routes={"POST /api/lint": api("lint"), "POST /api/fix": api("fix"), "POST /api/transpile": api("transpile"),
+                    "GET /api/meta": api_meta},
+            cli={"lint": cli_lint, "fix": cli_fix, "transpile": cli_transpile,
+                 "dialects": cli_dialects, "rules": cli_rules, "_worker": cli_worker})
+
+
+def main():
+    sys.exit(run(tool))
+
+
+if __name__ == "__main__":
+    main()