localtools-sql-formatter 1.0.0__py3-none-any.whl

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()

localtools_sql_formatter/engine.py

@@ -0,0 +1,284 @@
+"""sqlfluff lint/fix and sqlglot transpile, safe config loading, SARIF output and the worker process entry."""
+import difflib
+import json
+import logging
+import os
+import sys
+import tempfile
+import threading
+from pathlib import Path
+
+MAX_BYTES = 512 << 10  # per request (server); sqlfluff lints roughly 1-2 KB/s of messy SQL, so more would hit the deadline
+MAX_STATEMENTS = 2000
+DOCS = "https://docs.sqlfluff.com/en/stable/reference/rules/{group}.html#{code}"
+TEMPLATERS = ("raw", "jinja", "placeholder")
+PARAM_STYLES = ("colon", "colon_nospaces", "numeric_colon", "question_mark", "numeric_dollar", "dollar",
+                "percent", "pyformat", "at", "ampersand", "apache_ignite", "flyway_var", "dollar_brace")
+
+
+class SQLError(ValueError):
+    pass
+
+
+def newlines(sql):
+    """sqlfluff's CLI reads files with universal newlines; do the same so results and fixes match it."""
+    return sql.replace("\r\n", "\n").replace("\r", "\n")
+
+
+def check_limits(files):
+    size = sum(len(sql.encode()) for _, sql in files)
+    if size > MAX_BYTES:
+        raise SQLError(f"input is {size >> 10} KB; the limit is {MAX_BYTES >> 10} KB per request (use the CLI for bigger files)")
+    n = sum(sql.count(";") for _, sql in files)
+    if n > MAX_STATEMENTS:
+        raise SQLError(f"input has about {n} statements; the limit is {MAX_STATEMENTS} per request (use the CLI for bigger files)")
+
+
+# ---------- config ----------
+def _scrub(d, dropped, path=()):
+    """Remove everything that makes sqlfluff read files or import code: *_path / *_dir keys (library_path,
+    load_macros_from_path, loader_search_path...), the python and dbt templaters, and multiprocessing."""
+    for k in list(d):
+        v, here = d[k], path + (k.lower(),)
+        if here == ("templater", "jinja", "context"):
+            continue  # opaque template variables
+        if isinstance(v, dict):
+            if here in (("templater", "python"), ("templater", "dbt")):
+                dropped.append(":".join(here))
+                del d[k]
+            else:
+                _scrub(v, dropped, here)
+        elif k.lower().endswith(("_path", "_dir")) or here == ("core", "processes"):
+            dropped.append(":".join(here))
+            del d[k]
+
+
+def load_user_config(text, name):
+    """Parse an uploaded .sqlfluff / setup.cfg / tox.ini (INI) or pyproject.toml ([tool.sqlfluff]) without running
+    anything. Returns (config dict, [dropped keys])."""
+    from sqlfluff.core.config.ini import load_ini_string
+    from sqlfluff.core.config.toml import load_toml_file_config
+    from sqlfluff.core.config.validate import validate_config_dict
+    from sqlfluff.core.errors import SQLFluffUserError
+    try:
+        if name.lower().endswith(".toml"):
+            with tempfile.TemporaryDirectory() as d:
+                p = Path(d, "pyproject.toml")
+                p.write_text(text, encoding="utf-8")
+                cfg = load_toml_file_config(str(p))
+        else:
+            cfg = load_ini_string(text)
+        dropped = []
+        _scrub(cfg, dropped)
+        t = str(cfg.get("core", {}).get("templater", "raw"))
+        if t not in TEMPLATERS:
+            raise SQLError(f'{name}: templater "{t}" is not supported here (use raw, jinja or placeholder)')
+        validate_config_dict(cfg, name)
+        return cfg, dropped
+    except SQLFluffUserError as e:
+        raise SQLError(f"{name}: {e}".replace(str(Path(tempfile.gettempdir())), "")) from None
+    except Exception as e:  # configparser / toml syntax errors
+        if isinstance(e, SQLError):
+            raise
+        raise SQLError(f"{name}: not a valid sqlfluff config ({str(e).splitlines()[0]})") from None
+
+
+def make_config(dialect="", rules="", exclude_rules="", templater="", config="", config_name=".sqlfluff"):
+    """templater: raw | jinja | placeholder:<param_style>; empty dialect/templater = from the config file, else ansi/raw."""
+    from sqlfluff.core import FluffConfig
+    from sqlfluff.core.errors import SQLFluffUserError
+    cfg, dropped = load_user_config(config, config_name) if config.strip() else ({}, [])
+    from sqlfluff.core import dialect_readout
+    known = [d.label for d in dialect_readout()]
+    for d in (dialect, cfg.get("core", {}).get("dialect")):
+        if d and d not in known:
+            raise SQLError(f'unknown dialect "{d}" (choose from {", ".join(known)})')
+    ov = {"large_file_skip_byte_limit": 0, "processes": 1}  # our own size limit and deadline apply instead
+    if dialect or not cfg.get("core", {}).get("dialect"):
+        ov["dialect"] = dialect or "ansi"
+    if rules.strip():
+        ov["rules"] = rules.replace(" ", "")
+    if exclude_rules.strip():
+        ov["exclude_rules"] = exclude_rules.replace(" ", "")
+    if templater:
+        kind, _, style = templater.partition(":")
+        if kind not in TEMPLATERS or (kind == "placeholder") != bool(style) or (style and style not in PARAM_STYLES):
+            raise SQLError(f'unknown templater "{templater}" (raw, jinja or placeholder:<{"|".join(PARAM_STYLES)}>)')
+        ov["templater"] = kind
+        if style:
+            cfg.setdefault("templater", {}).setdefault("placeholder", {})["param_style"] = style
+    try:
+        return FluffConfig(configs=cfg, overrides=ov, ignore_local_config=True), dropped
+    except SQLFluffUserError as e:
+        raise SQLError(str(e)) from None
+
+
+# ---------- engines ----------
+def violation(v):
+    d = v.to_dict()
+    code, name = d["code"], d.get("name", "")
+    group = name.split(".")[0] if "." in name else ""
+    return {"code": code, "name": name, "description": d["description"],
+            "line": d["start_line_no"], "col": d["start_line_pos"],
+            "end_line": d.get("end_line_no", d["start_line_no"]), "end_col": d.get("end_line_pos", d["start_line_pos"]),
+            "warning": d.get("warning", False), "fixable": bool(d.get("fixes")),
+            "docs": DOCS.format(group=group, code=code.lower()) if group else ""}
+
+
+def lint_string(linter, sql, name, fix=False):
+    try:
+        return linter.lint_string(sql, fname=name, fix=fix)
+    except Exception:
+        raise
+    except BaseException as e:  # sqlfluffrs raises pyo3 PanicException (a BaseException) when its parser gives up
+        if type(e).__name__ != "PanicException":
+            raise
+        raise SQLError(f"{name}: sqlfluff's parser gave up on this input ({str(e).splitlines()[0]})") from None
+
+
+def lint(files, cfg):
+    from sqlfluff.core import Linter
+    linter = Linter(config=cfg)
+    return [{"name": name, "violations": [violation(v) for v in lint_string(linter, sql, name).get_violations()]}
+            for name, sql in files]
+
+
+def fix(files, cfg, passes=5):
+    """sqlfluff fix, repeated until a pass changes nothing (or a cycle settles on its smallest state): one sqlfluff pass can stop at its loop limit or
+    leave work for a later pass, so a single run is not always idempotent. Files that do not parse are left
+    alone, like the sqlfluff CLI does."""
+    from sqlfluff.core import Linter
+    linter = Linter(config=cfg)
+    out = []
+    for name, sql in files:
+        cur, first, unparsable, seen = sql, None, False, [sql]
+        for _ in range(passes):
+            lf = lint_string(linter, cur, name, fix=True)
+            vs = lf.get_violations()
+            if any(v.rule_code() in ("PRS", "TMP") for v in vs) and not cfg.get("fix_even_unparsable"):
+                unparsable = first is None
+                break
+            first = vs if first is None else first
+            new = lf.fix_string()[0]
+            if new == cur:
+                break  # stable: whatever is still reported needs a human
+            if new in seen:  # sqlfluff can oscillate (A -> B -> A); settle on one state of the cycle so output is idempotent
+                cur = new = min(seen[seen.index(new):])
+                break
+            seen.append(new)
+            cur = new
+        left = vs if unparsable or new == cur else [v for v in vs if not getattr(v, "fixes", None)]
+        out.append({"name": name, "fixed": cur, "changed": cur != sql, "unparsable": unparsable,
+                    "fixed_count": max(0, len(first or []) - len(left)),
+                    "remaining": [violation(v) for v in left],
+                    "diff": "".join(difflib.unified_diff(sql.splitlines(True), cur.splitlines(True), f"a/{name}", f"b/{name}"))})
+    return out
+
+
+class _Collect(logging.Handler):
+    def __init__(self):
+        super().__init__(logging.WARNING)
+        self.messages = []
+
+    def emit(self, record):
+        self.messages.append(record.getMessage())
+
+
+def transpile(files, read="", write="", pretty=True):
+    import sqlglot
+    from sqlglot.errors import ErrorLevel, ParseError, TokenError
+    log, h = logging.getLogger("sqlglot"), _Collect()
+    log.addHandler(h)
+    log.propagate = False
+    out = []
+    try:
+        for name, sql in files:
+            h.messages = []
+            try:
+                stmts = sqlglot.transpile(sql, read=read or None, write=write or None, pretty=pretty,
+                                          unsupported_level=ErrorLevel.WARN)
+            except ParseError as e:
+                err = e.errors[0] if e.errors else {}
+                where = f"line {err['line']}, col {err['col']}: " if err.get("line") else ""
+                raise SQLError(f"{name}: {where}{err.get('description') or str(e).splitlines()[0]}") from None
+            except TokenError as e:
+                raise SQLError(f"{name}: {str(e).splitlines()[0]}") from None
+            except ValueError as e:  # unknown dialect
+                raise SQLError(str(e).splitlines()[0]) from None
+            text = ";\n\n".join(s for s in stmts if s.strip())
+            out.append({"name": name, "sql": text + ";\n" if text else "", "warnings": list(dict.fromkeys(h.messages))})
+    finally:
+        log.removeHandler(h)
+    return out
+
+
+def dialects():
+    from sqlfluff.core import dialect_readout
+    from sqlglot.dialects.dialect import Dialects
+    return {"sqlfluff": [d.label for d in dialect_readout()], "sqlglot": sorted(d.value for d in Dialects if d.value)}
+
+
+def rules():
+    import sqlfluff
+    return [{"code": r.code, "name": r.name, "description": r.description} for r in sqlfluff.list_rules()]
+
+
+def run_job(job):
+    files = [tuple(f) for f in job["files"]]
+    if job["op"] == "transpile":
+        return {"files": transpile(files, job.get("read", ""), job.get("write", ""), job.get("pretty", True))}
+    cfg, dropped = make_config(job.get("dialect", ""), job.get("rules", ""), job.get("exclude_rules", ""),
+                               job.get("templater", ""), job.get("config", ""), job.get("config_name", ".sqlfluff"))
+    res = (lint if job["op"] == "lint" else fix)(files, cfg)
+    return {"files": res, "dialect": cfg.get("dialect"), "ignored_config": dropped}
+
+
+def sarif(results, version):
+    used = {v["code"]: v for f in results for v in f.get("violations", f.get("remaining", []))}
+    return {
+        "$schema": "https://json.schemastore.org/sarif-2.1.0.json", "version": "2.1.0",
+        "runs": [{
+            "tool": {"driver": {"name": "sqlfluff", "version": version, "informationUri": "https://sqlfluff.com",
+                                "rules": [{"id": c, "name": v["name"] or c, "shortDescription": {"text": v["description"]},
+                                           **({"helpUri": v["docs"]} if v["docs"] else {})} for c, v in sorted(used.items())]}},
+            "results": [{"ruleId": v["code"], "level": "warning" if v["warning"] else "error",
+                         "message": {"text": v["description"]},
+                         "locations": [{"physicalLocation": {"artifactLocation": {"uri": f["name"].replace("\\", "/")},
+                                                             "region": {"startLine": v["line"], "startColumn": v["col"],
+                                                                        "endLine": v["end_line"], "endColumn": v["end_col"]}}}]}
+                        for f in results for v in f.get("violations", f.get("remaining", []))],
+        }],
+    }
+
+
+# ---------- worker process ----------
+def _die_with_parent():
+    """The server keeps our stdin open; EOF means it closed it or died (any OS), so stop at once."""
+    sys.stdin.buffer.read()
+    os._exit(3)
+
+
+def _limit_memory(nbytes=2 << 30):
+    try:
+        import resource
+        resource.setrlimit(resource.RLIMIT_AS, (nbytes, nbytes))
+    except (ImportError, ValueError, OSError):  # Windows has no rlimit; macOS refuses RLIMIT_AS
+        pass
+
+
+def worker_main(job_path):
+    threading.Thread(target=_die_with_parent, daemon=True).start()
+    _limit_memory()
+    sys.setrecursionlimit(20000)
+    try:
+        res = run_job(json.loads(Path(job_path).read_text(encoding="utf-8")))
+    except SQLError as e:
+        res = {"error": str(e), "code": 400}
+    except MemoryError:
+        res = {"error": "sqlfluff ran out of memory (2 GB limit) on this input; split it into smaller files", "code": 413}
+    except RecursionError:
+        res = {"error": "the SQL is nested too deeply for sqlfluff; simplify or split it", "code": 413}
+    except Exception as e:
+        res = {"error": f"sqlfluff failed on this input ({type(e).__name__}: {str(e).splitlines()[0] if str(e) else ''})", "code": 500}
+    Path(job_path).with_suffix(".out").write_text(json.dumps(res), encoding="utf-8")
+    os._exit(0)