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

localtools_sql_formatter/localtools.py

@@ -0,0 +1,223 @@
+"""Shared localtools runtime implementing kit/CONTRACT.md v1. Copy verbatim; tool code lives in __main__.py.
+
+Multipart: Python 3.13 removed `cgi`, and email.parser buffers whole bodies in memory, so uploads are parsed with
+`multipart` (defnull, MIT, single pure-Python file, no deps): parts over 64 KB spool to anonymous temp files that
+the OS deletes on close; `form()` closes them after the request.
+"""
+import argparse
+import json
+import mimetypes
+import os
+import signal
+import subprocess
+import sys
+import tempfile
+import urllib.request
+import webbrowser
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from importlib.metadata import PackageNotFoundError, version as pkg_version
+from pathlib import Path
+from urllib.parse import urlsplit
+
+import multipart
+
+
+class HTTPError(Exception):
+    def __init__(self, code, message):
+        super().__init__(message)
+        self.code = code
+
+
+@dataclass
+class Tool:
+    slug: str
+    port: int
+    usage: str
+    ui: Path
+    routes: dict = field(default_factory=dict)  # "POST /api/<action>" -> fn(handler)
+    cli: dict = field(default_factory=dict)  # tool-specific subcommand -> fn(args) -> exit code | None
+
+    def __post_init__(self):
+        try:
+            self.version = pkg_version(f"localtools-{self.slug}")
+        except PackageNotFoundError:
+            self.version = "dev"
+
+
+@contextmanager
+def form(req):
+    """Yields {field name: multipart.MultipartPart}; use part.file (seekable), part.filename, part.value."""
+    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")
+    try:
+        parts = {p.name: p for p in multipart.MultipartParser(req.rfile, opts["boundary"], int(req.headers.get("Content-Length") or 0))}
+    except multipart.MultipartError as e:
+        raise HTTPError(400, f"malformed upload: {e}")
+    try:
+        yield parts
+    finally:
+        for p in parts.values():
+            p.close()
+
+
+def make_handler(t):
+    """UI + /api/health + tool routes behind the Host (DNS rebinding) and Origin (CSRF) guards."""
+    own = {f"127.0.0.1:{t.port}", f"localhost:{t.port}"}
+    ui = {p.relative_to(t.ui).as_posix(): p for p in t.ui.rglob("*") if p.is_file()}
+
+    class Handler(BaseHTTPRequestHandler):
+        def log_message(self, *args):
+            pass
+
+        def send_body(self, code, body, ctype):
+            self.send_response(code)
+            self.send_header("Content-Type", ctype)
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+        def send_json(self, code, obj):
+            self.send_body(code, json.dumps(obj).encode(), "application/json")
+
+        def dispatch(self):
+            if self.headers.get("Host") not in own:
+                return self.send_json(403, {"error": "forbidden host"})
+            origin = self.headers.get("Origin")
+            if origin and self.command != "GET" and origin.removeprefix("http://") not in own:
+                return self.send_json(403, {"error": "forbidden origin"})
+            path = urlsplit(self.path).path
+            try:
+                if self.command == "GET" and path == "/api/health":
+                    return self.send_json(200, {"tool": t.slug, "version": t.version, "ok": True})
+                if route := t.routes.get(f"{self.command} {path}"):
+                    return route(self)
+                if self.command == "GET" and (f := ui.get("index.html" if path == "/" else path[1:])):
+                    return self.send_body(200, f.read_bytes(), mimetypes.guess_type(f.name)[0] or "application/octet-stream")
+                self.send_json(404, {"error": "not found"})
+            except HTTPError as e:
+                self.send_json(e.code, {"error": str(e)})
+            except Exception as e:
+                self.send_json(500, {"error": str(e)})
+
+        do_GET = do_POST = dispatch
+
+    return Handler
+
+
+class Server(ThreadingHTTPServer):
+    allow_reuse_address = os.name != "nt"  # on Windows SO_REUSEADDR would let two servers share a port
+
+
+def open_browser(url):
+    if os.environ.get("LOCALTOOLS_NO_OPEN") != "1":
+        webbrowser.open(url)
+
+
+def localtools_root():
+    return Path(os.environ.get("LOCALTOOLS_HOME") or Path.home() / ".localtools")
+
+
+def managed_by(exe, root, slug, action):
+    """Empty string when exe lives under <root>/<slug>/ (installed by our scripts); else the package-manager
+    command(s) to print instead of running update/uninstall (CONTRACT "package-manager installs")."""
+    if Path(exe).resolve().is_relative_to((Path(root) / slug).resolve()):
+        return ""
+    pkg, up = f"localtools-{slug}", action == "update"
+    pascal = "".join(w[:1].upper() + w[1:] for w in slug.split("-"))
+    cmds = {
+        "brew": f"brew {'upgrade' if up else 'uninstall'} {pkg}",
+        "scoop": f"scoop {'update' if up else 'uninstall'} {pkg}",
+        "winget": f"winget {'upgrade' if up else 'uninstall'} localtools.{pascal}",
+        "npm": f"npm i -g {pkg}@latest" if up else f"npm uninstall -g {pkg}",
+        "pipx": f"pipx {'upgrade' if up else 'uninstall'} {pkg}",
+    }
+    p = str(exe).replace("\\", "/").lower()
+    for pm, mark in (("brew", "/cellar/"), ("brew", "homebrew"), ("brew", "linuxbrew"), ("scoop", "/scoop/"),
+                     ("winget", "/winget/"), ("npm", "node_modules"), ("pipx", "pipx")):
+        if mark in p:
+            return f"{pkg} was installed with {pm}; to {action} it run:\n  {cmds[pm]}\n"
+    return (f"{pkg} was not installed by the localtools script; to {action} it use the package manager you installed it with:\n"
+            + "".join(f"  {c}\n" for c in cmds.values()))
+
+
+def run_script(slug, name, action):
+    """Re-run the public install/uninstall script. Windows: detached (so files can be replaced), logged to
+    <root>/<slug>-install.log (uninstall: <temp>/<slug>-uninstall.log). The bundled interpreter lives under <root>/<slug>/, a pipx/pip one does not."""
+    if hint := managed_by(sys.executable, localtools_root(), slug, action):
+        print(hint, end="")
+        return 0
+    base = f"https://raw.githubusercontent.com/chayprabs/localtools/main/{slug}/{name}"
+    env = {**os.environ, "LOCALTOOLS_NO_OPEN": "1"}
+    if os.name == "nt":
+        # the uninstaller may delete the root, so its log goes to the temp dir
+        log = (localtools_root() if name == "install" else Path(tempfile.gettempdir())) / f"{slug}-{name}.log"
+        log.parent.mkdir(parents=True, exist_ok=True)
+        with open(log, "w") as f:
+            subprocess.Popen(["powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", f"irm {base}.ps1 | iex"],
+                             env=env, stdout=f, stderr=f, stdin=subprocess.DEVNULL)
+        print(f"{action} running in the background; progress and errors are logged to {log}")
+        return 0
+    # exec, not a child: the installer pkills everything under <root>/<slug>/, which includes this bundled python
+    os.execvpe("sh", ["sh", "-c", f"curl -fsSL {base}.sh | bash"], env)
+
+
+def serve(t):
+    url = f"http://127.0.0.1:{t.port}"
+    try:
+        srv = Server(("127.0.0.1", t.port), make_handler(t))
+    except OSError:
+        try:
+            with urllib.request.urlopen(url + "/api/health", timeout=2) as r:
+                running = json.load(r).get("tool") == t.slug
+        except Exception:
+            running = False
+        if running:
+            print(f"localtools-{t.slug} already running at {url}")
+            open_browser(url)
+            return 0
+        print(f"error: port {t.port} is in use by another program; pick another with --port N", file=sys.stderr)
+        return 1
+    print(f"localtools-{t.slug} {t.version} running at {url}  (Ctrl+C to stop)", flush=True)
+    open_browser(url)
+    signal.signal(signal.SIGTERM, signal.default_int_handler)
+    try:
+        srv.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        srv.server_close()
+    return 0
+
+
+def main(t, argv=None):
+    args = list(sys.argv[1:] if argv is None else argv)
+    sub = args.pop(0) if args and not args[0].startswith("-") else "serve"
+    try:
+        if sub in ("update", "uninstall"):
+            return run_script(t.slug, "install" if sub == "update" else "uninstall", sub)
+        if sub in t.cli:
+            return t.cli[sub](args) or 0
+        if sub != "serve":
+            raise ValueError(f'unknown command "{sub}" (see --help)')
+        p = argparse.ArgumentParser(prog=f"localtools-{t.slug}", add_help=False)
+        p.add_argument("--port", type=int, default=int(os.environ.get("LOCALTOOLS_PORT") or t.port))
+        p.add_argument("--no-open", action="store_true")
+        p.add_argument("--version", action="store_true")
+        p.add_argument("-h", "--help", action="store_true")
+        o = p.parse_args(args)
+        if o.help:
+            print(t.usage, end="")
+            return 0
+        if o.version:
+            print(t.version)
+            return 0
+        if o.no_open:
+            os.environ["LOCALTOOLS_NO_OPEN"] = "1"
+        t.port = o.port
+        return serve(t)
+    except Exception as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1

localtools_sql_formatter/ui/index.html

@@ -0,0 +1,294 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>SQL Formatter</title>
+<link rel="stylesheet" href="kit/localtools.css">
+<style>
+  #sql { min-height: 240px; }
+  .lt-files button { border: 0; background: none; color: var(--muted); font: 700 13px var(--mono); cursor: pointer; padding: 0 var(--s1); }
+  .lt-files button:hover { color: var(--accent); }
+  .lt-files li span:first-child { margin-right: auto; }
+  .row { display: grid; grid-template-columns: 1fr 1fr; gap: var(--s4); margin-top: var(--s4); }
+  .cfg { min-height: 38px; padding: var(--s2) var(--s3); place-items: start; text-align: left; }
+  .file { border-top: 3px solid var(--rule); }
+  .file:first-child { border-top: 0; }
+  .file h3 { margin: 0; font: 700 14px/1.3 var(--mono); overflow-wrap: anywhere; }
+  .count { font: 700 12px/1 var(--mono); letter-spacing: .04em; text-transform: uppercase; }
+  .count[data-n="0"] { color: var(--ok); }
+  .count:not([data-n="0"]) { color: var(--accent); }
+  .lt-table td:first-child, .lt-table td:nth-child(2) { white-space: nowrap; }
+  .lt-table a { font-weight: 700; }
+  .diff .add { color: var(--ok); }
+  .diff .del { color: var(--accent); }
+  .diff .hunk { color: var(--info); }
+  .note { padding: var(--s2) var(--s4); font: 12px/1.4 var(--mono); color: var(--muted); border-bottom: 1px solid var(--hair); }
+  .lt-tabs { border-bottom: 1px solid var(--rule); }
+  @media (max-width: 560px) { .row { grid-template-columns: 1fr; } }
+</style>
+</head>
+<body>
+<main class="lt-page">
+  <header class="lt-header">
+    <a class="lt-issue" href="https://github.com/chayprabs/localtools/issues/new?template=sql-formatter.yml" target="_blank" rel="noopener">Report an issue</a>
+    <h1 class="lt-title">SQL Formatter</h1>
+    <p class="lt-desc">Lint and auto-fix SQL in 28 dialects with sqlfluff, or transpile between dialects with sqlglot. Runs on your machine.</p>
+  </header>
+
+  <section class="lt-section" aria-labelledby="in-l">
+    <h2 class="lt-label" id="in-l">SQL</h2>
+    <textarea class="lt-textarea" id="sql" spellcheck="false" aria-label="SQL" placeholder="select a,b from t where x=1"></textarea>
+    <div class="lt-or">or</div>
+    <label class="lt-drop" id="drop">
+      <input type="file" id="file" multiple accept=".sql,.txt,text/plain,application/sql">
+      <strong>Drop .sql files here</strong>
+      <span>Several at once is fine. Up to <span id="lim">512 KB</span> per run.</span>
+    </label>
+    <ul class="lt-files" id="files"></ul>
+  </section>
+
+  <section class="lt-section" aria-labelledby="opt-l">
+    <h2 class="lt-label" id="opt-l">Options</h2>
+    <fieldset class="lt-field">
+      <legend>Action</legend>
+      <div class="lt-seg" id="mode">
+        <label><input type="radio" name="mode" value="lint" checked><span>Lint</span></label>
+        <label><input type="radio" name="mode" value="fix"><span>Fix</span></label>
+        <label><input type="radio" name="mode" value="transpile"><span>Transpile</span></label>
+      </div>
+    </fieldset>
+    <div id="fluff">
+      <div class="lt-options" style="margin-top: var(--s4)">
+        <div class="lt-field">
+          <label for="dialect">Dialect</label>
+          <select class="lt-select" id="dialect"><option>ansi</option></select>
+        </div>
+        <div class="lt-field">
+          <label for="templater">Templater</label>
+          <select class="lt-select" id="templater">
+            <option value="">none (or config)</option>
+            <option value="jinja">jinja {{ }}</option>
+            <option value="placeholder:colon">:name</option>
+            <option value="placeholder:question_mark">?</option>
+            <option value="placeholder:numeric_dollar">$1</option>
+            <option value="placeholder:dollar">$name</option>
+            <option value="placeholder:pyformat">%(name)s</option>
+            <option value="placeholder:percent">%s</option>
+            <option value="placeholder:at">@name</option>
+          </select>
+        </div>
+        <div class="lt-field">
+          <label for="rules">Only rules</label>
+          <input class="lt-input" id="rules" list="rule-list" placeholder="all" spellcheck="false">
+        </div>
+        <div class="lt-field">
+          <label for="exclude">Exclude rules</label>
+          <input class="lt-input" id="exclude" list="rule-list" placeholder="LT05,AM04" spellcheck="false">
+        </div>
+      </div>
+      <datalist id="rule-list"><option value="core"></datalist>
+      <div class="lt-field" style="margin-top: var(--s4)">
+        <label for="cfg">Config file</label>
+        <label class="lt-drop cfg" id="cfg-drop">
+          <input type="file" id="cfg" accept=".sqlfluff,.cfg,.ini,.toml">
+          <span>.sqlfluff, setup.cfg, tox.ini or pyproject.toml. Nothing in it is executed; path and python/dbt templater settings are ignored.</span>
+        </label>
+        <ul class="lt-files" id="cfg-files"></ul>
+      </div>
+    </div>
+    <div class="lt-options" id="tr" style="margin-top: var(--s4)" hidden>
+      <div class="lt-field">
+        <label for="read">From</label>
+        <select class="lt-select" id="read"><option value="">generic</option></select>
+      </div>
+      <div class="lt-field">
+        <label for="write">To</label>
+        <select class="lt-select" id="write"><option value="">generic</option></select>
+      </div>
+    </div>
+  </section>
+
+  <section class="lt-section">
+    <div class="lt-actions">
+      <button class="lt-btn lt-btn-primary" type="button" id="go">Lint</button>
+      <span class="lt-status" id="status" aria-live="polite"></span>
+    </div>
+    <div class="lt-error" id="err" role="alert" hidden></div>
+  </section>
+
+  <section class="lt-section" aria-labelledby="out-l">
+    <h2 class="lt-label" id="out-l">Output</h2>
+    <div class="lt-output" id="out">
+      <div class="lt-empty">Paste SQL or drop files, pick a dialect, press Lint.</div>
+    </div>
+  </section>
+</main>
+
+<script type="module">
+import { dropZone, run, copy, download, fmtBytes, fmtMs } from "./kit/localtools.js";
+
+const $ = (id) => document.getElementById(id);
+const el = (tag, props = {}, ...kids) => { const e = Object.assign(document.createElement(tag), props); e.append(...kids); return e; };
+const MAX_ROWS = 2000;
+const picked = [];
+let cfgFile = null;
+
+function fileList(ul, list, onRemove) {
+  ul.replaceChildren(...list.map((f, i) => {
+    const x = el("button", { type: "button", textContent: "x", title: "Remove " + f.name });
+    x.setAttribute("aria-label", "Remove " + f.name);
+    x.onclick = () => onRemove(i);
+    return el("li", {}, el("span", { textContent: f.name }), el("span", { textContent: fmtBytes(f.size) }), x);
+  }));
+}
+const renderPicked = () => fileList($("files"), picked, (i) => { picked.splice(i, 1); renderPicked(); });
+const renderCfg = () => fileList($("cfg-files"), cfgFile ? [cfgFile] : [], () => { cfgFile = null; renderCfg(); });
+dropZone($("drop"), null, (fs) => { picked.push(...fs); $("file").value = ""; renderPicked(); });
+dropZone($("cfg-drop"), null, (fs) => { cfgFile = fs[0] || cfgFile; $("cfg").value = ""; renderCfg(); });
+
+const mode = () => document.querySelector('input[name="mode"]:checked').value;
+$("mode").onchange = () => {
+  const m = mode();
+  $("go").textContent = m[0].toUpperCase() + m.slice(1);
+  $("fluff").hidden = m === "transpile";
+  $("tr").hidden = m !== "transpile";
+};
+
+fetch("/api/meta").then((r) => r.json()).then((m) => {
+  $("dialect").replaceChildren(...m.sqlfluff.map((d) => el("option", { value: d, textContent: d, selected: d === "ansi" })));
+  for (const id of ["read", "write"]) $(id).append(...m.sqlglot.map((d) => el("option", { value: d, textContent: d })));
+  $("read").value = "tsql"; $("write").value = "postgres";
+  $("rule-list").append(...m.rules.map((r) => el("option", { value: r.code, textContent: `${r.name}: ${r.description}` })));
+  $("lim").textContent = fmtBytes(m.limits.bytes);
+});
+
+function sources() {
+  const sql = $("sql").value;
+  if (!sql.trim() && !picked.length) throw new Error("Paste SQL or drop at least one .sql file.");
+  return { files: picked, sql };
+}
+
+function link(v) {
+  if (!v.docs) return document.createTextNode(v.code);
+  return el("a", { href: v.docs, target: "_blank", rel: "noopener", textContent: v.code, title: v.name });
+}
+
+function table(vs) {
+  const t = el("table", { className: "lt-table" });
+  t.createTHead().append(el("tr", {}, ...["Line:Col", "Rule", "Problem", ""].map((h) => el("th", { textContent: h }))));
+  const body = t.createTBody();
+  for (const v of vs.slice(0, MAX_ROWS)) {
+    const sev = ["PRS", "TMP", "LXR"].includes(v.code) ? "error" : v.warning ? "warn" : v.fixable ? "info" : "warn";
+    const badge = el("span", { className: "lt-badge", textContent: sev === "error" ? "parse" : v.fixable ? "fixable" : v.warning ? "warning" : "manual" });
+    badge.dataset.sev = sev;
+    body.append(el("tr", {}, el("td", { textContent: `${v.line}:${v.col}` }), el("td", {}, link(v)),
+      el("td", { textContent: v.description }), el("td", {}, badge)));
+  }
+  const wrap = el("div", { className: "lt-table-wrap" }, t);
+  return vs.length > MAX_ROWS ? [el("div", { className: "note", textContent: `Showing ${MAX_ROWS} of ${vs.length}; download the report for all.` }), wrap] : [wrap];
+}
+
+function bar(name, count, ...buttons) {
+  const c = el("span", { className: "count", textContent: count[1] });
+  c.dataset.n = count[0];
+  return el("div", { className: "lt-bar" }, el("h3", { textContent: name }), c, ...buttons);
+}
+function btn(label, fn) { const b = el("button", { className: "lt-btn", type: "button", textContent: label }); b.onclick = (e) => fn(e.currentTarget); return b; }
+const sqlName = (n) => n.replace(/\.[^.\/\\]+$/, "") + ".sql";
+
+function diffView(diff) {
+  const pre = el("pre", { className: "lt-pre diff" });
+  pre.append(...diff.split(/(?<=\n)/).map((l) => el("span", {
+    className: l.startsWith("@@") ? "hunk" : l.startsWith("+") && !l.startsWith("+++") ? "add" : l.startsWith("-") && !l.startsWith("---") ? "del" : "",
+    textContent: l,
+  })));
+  return pre;
+}
+
+let n = 0;
+function tabbed(panes) {
+  const id = "t" + ++n;
+  const list = el("div", { className: "lt-tabs", role: "tablist" });
+  const boxes = panes.map(([label, node], i) => {
+    const b = el("button", { type: "button", role: "tab", textContent: label, id: `${id}-${i}` });
+    b.setAttribute("aria-selected", i === 0);
+    const p = el("div", { role: "tabpanel", hidden: i !== 0 }, node);
+    b.onclick = () => boxes.forEach(([bb, pp], j) => { bb.setAttribute("aria-selected", j === i); pp.hidden = j !== i; });
+    list.append(b);
+    return [b, p];
+  });
+  return [list, ...boxes.map(([, p]) => p)];
+}
+
+const render = {
+  lint(res) {
+    return res.files.map((f) => {
+      const k = f.violations.length;
+      return el("article", { className: "file" }, bar(f.name, [k, k ? `${k} violation${k > 1 ? "s" : ""}` : "clean"]), ...(k ? table(f.violations) : []));
+    });
+  },
+  fix(res) {
+    return res.files.map((f) => {
+      const r = f.remaining.length;
+      const status = f.unparsable ? [1, "does not parse; not fixed"] : !f.changed ? [r, r ? `${r} need manual fixes` : "already clean"]
+        : [r, `${f.fixed_count} fixed` + (r ? `, ${r} need manual fixes` : "")];
+      const blob = new Blob([f.fixed], { type: "application/sql" });
+      const body = f.changed ? tabbed([["Diff", diffView(f.diff)], ["Fixed SQL", el("pre", { className: "lt-pre", textContent: f.fixed })]]) : [];
+      return el("article", { className: "file" },
+        bar(f.name, status, btn("Copy", (b) => copy(f.fixed, b)), btn("Download", () => download(blob, sqlName(f.name)))),
+        ...body, ...(r ? table(f.remaining) : []));
+    });
+  },
+  transpile(res) {
+    return res.files.map((f) => {
+      const blob = new Blob([f.sql], { type: "application/sql" });
+      return el("article", { className: "file" },
+        bar(f.name, [0, `${$("read").value || "generic"} > ${$("write").value || "generic"}`],
+          btn("Copy", (b) => copy(f.sql, b)), btn("Download", () => download(blob, sqlName(f.name)))),
+        ...f.warnings.map((w) => el("div", { className: "note", textContent: "Unsupported: " + w })),
+        el("pre", { className: "lt-pre", textContent: f.sql }));
+    });
+  },
+};
+
+async function go(m = mode()) {
+  const t0 = performance.now();
+  const { files, sql } = sources();
+  const fields = { sql };
+  if (m === "transpile") Object.assign(fields, { read: $("read").value, write: $("write").value });
+  else Object.assign(fields, { dialect: $("dialect").value, templater: $("templater").value, rules: $("rules").value, exclude_rules: $("exclude").value });
+  const body = new FormData();
+  for (const f of files) body.append("file", f, f.name);
+  if (cfgFile && m !== "transpile") body.append("config", cfgFile, cfgFile.name);
+  for (const [k, v] of Object.entries(fields)) body.append(k, v);
+  $("out").replaceChildren(el("div", { className: "lt-empty", textContent: m === "transpile" ? "Transpiling..." : "sqlfluff is working. Big files take a while." }));
+  $("status").textContent = "";
+  let res;
+  try {
+    const r = await fetch("/api/" + m, { method: "POST", body });
+    res = await r.json().catch(() => ({ error: `${r.status} ${r.statusText}` }));
+    if (!r.ok) throw new Error(res.error);
+  } catch (e) {
+    $("out").replaceChildren(el("div", { className: "lt-empty", textContent: "No output." }));
+    throw e.message === "Failed to fetch" ? new Error("Cannot reach the local server. Is the tool still running?") : e;
+  }
+  const head = [];
+  if (res.ignored_config?.length) head.push(el("div", { className: "note", textContent: "Ignored config settings: " + res.ignored_config.join(", ") }));
+  if (m === "lint") {
+    const total = res.files.reduce((s, f) => s + f.violations.length, 0);
+    const report = new Blob([JSON.stringify(res, null, 2)], { type: "application/json" });
+    const fixBtn = btn("Fix all", () => { document.querySelector('input[value="fix"]').click(); $("go").click(); });
+    head.push(el("div", { className: "lt-bar" }, el("span", { className: "lt-status", textContent: `dialect ${res.dialect}` }),
+      ...(res.files.some((f) => f.violations.some((v) => v.fixable)) ? [fixBtn] : []), btn("Download report", () => download(report, "sqlfluff-report.json"))));
+    $("status").textContent = `${total} violation${total === 1 ? "" : "s"} in ${res.files.length} file${res.files.length > 1 ? "s" : ""} · ${fmtMs(performance.now() - t0)}`;
+  } else {
+    $("status").textContent = `${res.files.length} file${res.files.length > 1 ? "s" : ""} · ${fmtMs(performance.now() - t0)}`;
+  }
+  $("out").replaceChildren(...head, ...render[m](res));
+}
+
+$("go").onclick = () => run($("go"), $("err"), () => go());
+</script>
+</body>
+</html>

localtools_sql_formatter/ui/kit/fonts/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2020 The JetBrains Mono Project Authors (https://github.com/JetBrains/JetBrainsMono)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.