quickdbd-cli 0.1.2__tar.gz → 0.1.3__tar.gz

{quickdbd_cli-0.1.2 → quickdbd_cli-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: quickdbd-cli
-Version: 0.1.2
+Version: 0.1.3
 Summary: Compile QuickDBD-syntax schema files into interactive HTML ER diagrams, with no table limit.
 Project-URL: Homepage, https://github.com/MarkPhamm/quickdbd-cli
 Author: Minh (Mark) Pham
@@ -62,6 +62,26 @@ Not affiliated with QuickDBD. It reads the same text syntax, so schemas move fre
 - **Pip-only install:** no Graphviz, Node or browser needed. Layout uses [ELK](https://eclipse.dev/elk/), running in an embedded V8.
 - **CI-friendly:** builds are deterministic, and errors are `file:line: error: …` with exit code 1.
 
+## From a dbt project
+
+```bash
+dbt docs generate                                   # optional: adds real column types (catalog.json)
+qdbd import dbt target/manifest.json -o erd/        # one .txt per folder (staging, marts, sources, ...)
+qdbd build erd/ -o erd.html
+```
+
+- **Tables:** models, seeds and snapshots of your project, plus sources.
+- **Relationships:** `relationships` tests (including dbt_utils `relationships_where`) and `foreign_key` constraints.
+- **Primary keys:** `primary_key` constraints, or else a column with both `unique` and `not_null` tests.
+- **Docs:** model and column descriptions become doc comments, shown as tooltips.
+- **Options:**
+  - `--select 'marts.*'` narrows by name, fqn or path (repeatable)
+  - `--package all` includes installed packages
+  - `--no-sources` drops sources
+  - `-o schema.txt` writes a single file
+
+Re-running the import overwrites the generated files. Table positions survive because they live in the layout file, keyed by table name.
+
 ## Commands
 
 ```bash
@@ -70,6 +90,7 @@ qdbd build  PATH... -o diagram.html            # shareable interactive HTML (pos
 qdbd serve  PATH... [--port 8765]              # live editor + drag-to-arrange
 qdbd export PATH... -o out.png [--focus Customer --depth 1]   # PNG or SVG image
 qdbd layout PATH... [--reset]                  # (re)write the layout file
+qdbd import dbt target/manifest.json -o erd/   # generate schema files from a dbt project
 ```
 
 `PATH` is a `.txt` file or a folder. Every `*.txt` under a folder is read recursively.

{quickdbd_cli-0.1.2 → quickdbd_cli-0.1.3}/README.md

@@ -37,6 +37,26 @@ Not affiliated with QuickDBD. It reads the same text syntax, so schemas move fre
 - **Pip-only install:** no Graphviz, Node or browser needed. Layout uses [ELK](https://eclipse.dev/elk/), running in an embedded V8.
 - **CI-friendly:** builds are deterministic, and errors are `file:line: error: …` with exit code 1.
 
+## From a dbt project
+
+```bash
+dbt docs generate                                   # optional: adds real column types (catalog.json)
+qdbd import dbt target/manifest.json -o erd/        # one .txt per folder (staging, marts, sources, ...)
+qdbd build erd/ -o erd.html
+```
+
+- **Tables:** models, seeds and snapshots of your project, plus sources.
+- **Relationships:** `relationships` tests (including dbt_utils `relationships_where`) and `foreign_key` constraints.
+- **Primary keys:** `primary_key` constraints, or else a column with both `unique` and `not_null` tests.
+- **Docs:** model and column descriptions become doc comments, shown as tooltips.
+- **Options:**
+  - `--select 'marts.*'` narrows by name, fqn or path (repeatable)
+  - `--package all` includes installed packages
+  - `--no-sources` drops sources
+  - `-o schema.txt` writes a single file
+
+Re-running the import overwrites the generated files. Table positions survive because they live in the layout file, keyed by table name.
+
 ## Commands
 
 ```bash
@@ -45,6 +65,7 @@ qdbd build  PATH... -o diagram.html            # shareable interactive HTML (pos
 qdbd serve  PATH... [--port 8765]              # live editor + drag-to-arrange
 qdbd export PATH... -o out.png [--focus Customer --depth 1]   # PNG or SVG image
 qdbd layout PATH... [--reset]                  # (re)write the layout file
+qdbd import dbt target/manifest.json -o erd/   # generate schema files from a dbt project
 ```
 
 `PATH` is a `.txt` file or a folder. Every `*.txt` under a folder is read recursively.

{quickdbd_cli-0.1.2 → quickdbd_cli-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "quickdbd-cli"
-version = "0.1.2"
+version = "0.1.3"
 description = "Compile QuickDBD-syntax schema files into interactive HTML ER diagrams, with no table limit."
 readme = "README.md"
 license = "Apache-2.0"

quickdbd_cli-0.1.3/src/quickdbd_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.3"

{quickdbd_cli-0.1.2 → quickdbd_cli-0.1.3}/src/quickdbd_cli/assets/render.js

@@ -99,7 +99,7 @@
           '" font-family="' + FONT + '" font-size="' + st.badgeSize + '">' + esc(b.t) + "</text>");
         bx += b.w + st.badgeGap;
       });
-      if (c.pk) out.push(keyIcon(w - st.padX - c.typeW - st.keyW + 1, cy));
+      if (c.pk) out.push(keyIcon(w - st.padX - c.typeW - st.keyW, cy));
       out.push('<text x="' + (w - st.padX) + '" y="' + base + '" text-anchor="end" fill="' + C.type + '" font-family="' + FONT +
         '" font-size="' + st.rowSize + '">' + esc(c.type) + "</text>");
       out.push("</g>");

{quickdbd_cli-0.1.2 → quickdbd_cli-0.1.3}/src/quickdbd_cli/cli.py

@@ -103,6 +103,43 @@ def cmd_layout(args) -> int:
     return 0
 
 
+def cmd_import_dbt(args) -> int:
+    from .dbt import DbtImportError, import_dbt, write_result
+    from .parser import compile_sources
+
+    out = Path(args.output)
+    split = out.suffix != ".txt"
+    try:
+        result = import_dbt(
+            Path(args.manifest),
+            Path(args.catalog) if args.catalog else None,
+            packages=args.package,
+            select=args.select,
+            sources=not args.no_sources,
+            split=split,
+        )
+    except DbtImportError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+    # Self-check: the generated text must compile cleanly.
+    schema = compile_sources([(name, text) for name, text in result.files.items()])
+    if schema.errors:
+        for d in schema.errors:
+            print(d.format(), file=sys.stderr)
+        print("error: generated schema did not compile (please report this as a bug)", file=sys.stderr)
+        return 1
+    written = write_result(result, out)
+    for s in result.skipped:
+        print(f"skipped: {s}", file=sys.stderr)
+    where = str(out) if not split else f"{out}/ ({len(written)} files)"
+    print(f"Wrote {where}: {result.tables} tables, {result.relationships} relationships")
+    if result.tables and not result.relationships:
+        print(
+            "hint: no relationships found; add `relationships` tests or foreign_key constraints in dbt", file=sys.stderr
+        )
+    return 0
+
+
 def cmd_serve(args) -> int:
     from .serve import serve
 
@@ -147,6 +184,28 @@ def build_parser() -> argparse.ArgumentParser:
     sp.add_argument("--layout")
     sp.set_defaults(func=cmd_layout)
 
+    sp = sub.add_parser("import", help="generate QuickDBD schema files from another source")
+    isub = sp.add_subparsers(dest="source", required=True)
+    dp = isub.add_parser(
+        "dbt",
+        help="from a dbt project's target/manifest.json",
+        description="Tables from models/seeds/snapshots/sources, relationships from `relationships` tests and "
+        "foreign_key constraints, types from catalog.json (run `dbt docs generate` first for types).",
+    )
+    dp.add_argument("manifest", help="path to manifest.json (or the target/ directory)")
+    dp.add_argument("-o", "--output", default="schema.txt", help="a .txt file, or a directory for one file per folder")
+    dp.add_argument("--catalog", help="catalog.json for column types (default: next to the manifest, if present)")
+    dp.add_argument(
+        "--package",
+        action="append",
+        help="dbt package(s) to include (default: the root project; 'all' for every package)",
+    )
+    dp.add_argument(
+        "--select", action="append", help="glob on model name, fqn (a.b.c) or file path, e.g. 'marts.*' (repeatable)"
+    )
+    dp.add_argument("--no-sources", action="store_true", help="leave out dbt sources")
+    dp.set_defaults(func=cmd_import_dbt)
+
     sp = sub.add_parser("serve", help="live editor: reload on save, drag tables to arrange")
     paths(sp)
     sp.add_argument("--port", type=int, default=8765)

quickdbd_cli-0.1.3/src/quickdbd_cli/dbt.py

@@ -0,0 +1,412 @@
+"""`qdbd import dbt`: turn a dbt project's manifest.json (+ optional catalog.json) into QuickDBD text.
+
+- Tables: models, seeds and snapshots of the selected packages, plus sources.
+- Columns: documented columns, catalog columns (with real types) and columns used by tests.
+- Primary keys: `primary_key` constraints, else the first column with both `unique` and
+  `not_null` tests. Other `unique` columns get UNIQUE.
+- Relationships: `relationships` tests (incl. dbt_utils `relationships_where`) and
+  `foreign_key` constraints. A unique child column gives one-to-one (`-`), otherwise many-to-one (`>-`).
+- Descriptions become QuickDBD doc comments.
+"""
+
+from __future__ import annotations
+
+import fnmatch
+import json
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+HEADER = "# Generated by qdbd import dbt"
+TABLE_TYPES = ("model", "seed", "snapshot")
+REL_TESTS = ("relationships", "relationships_where")
+_IDENT = re.compile(r"^[A-Za-z0-9_]+$")
+_REF = re.compile(
+    r"""^\s*ref\(\s*['"]([^'"]+)['"]\s*(?:,\s*['"]([^'"]+)['"]\s*)?(?:,\s*v(?:ersion)?\s*=\s*\S+\s*)?\)\s*$"""
+)
+_SOURCE = re.compile(r"""^\s*source\(\s*['"]([^'"]+)['"]\s*,\s*['"]([^'"]+)['"]\s*\)\s*$""")
+_TYPE_ALIASES = {
+    "character varying": "varchar",
+    "timestamp without time zone": "timestamp",
+    "timestamp with time zone": "timestamptz",
+    "time without time zone": "time",
+    "time with time zone": "timetz",
+    "double precision": "double",
+}
+
+
+class DbtImportError(Exception):
+    pass
+
+
+@dataclass
+class Col:
+    name: str
+    type: str | None = None
+    description: str = ""
+    pk: bool = False
+    unique: bool = False
+    not_null: bool = False
+    fk: tuple[str, str, str] | None = None  # (op, parent table uid, parent column)
+    order: int = 10_000
+
+
+@dataclass
+class Tbl:
+    uid: str
+    name: str  # display name in the .txt
+    group: str
+    description: str = ""
+    cols: dict[str, Col] = field(default_factory=dict)
+
+    def col(self, name: str) -> Col:
+        key = name.lower()
+        for k, c in self.cols.items():
+            if k.lower() == key:
+                return c
+        c = self.cols[name] = Col(name)
+        return c
+
+
+@dataclass
+class ImportResult:
+    files: dict[str, str]  # file name -> text
+    tables: int
+    relationships: int
+    skipped: list[str]
+
+
+def _strip_quotes(s: str) -> str:
+    s = s.strip()
+    if len(s) >= 2 and s[0] == s[-1] and s[0] in "\"'`[":
+        return s[1:-1]
+    if s.startswith("[") and s.endswith("]"):
+        return s[1:-1]
+    return s
+
+
+def norm_type(t: str | None) -> str | None:
+    if not t:
+        return None
+    t = t.strip()
+    low = t.lower()
+    for long, short in _TYPE_ALIASES.items():
+        if low.startswith(long):
+            t = short + t[len(long) :]
+            break
+    t = re.sub(r"\s*,\s*", ",", t)
+    t = re.sub(r"\s*\(\s*", "(", t)
+    t = re.sub(r"\s*\)", ")", t)
+    t = re.sub(r"\s+", "_", t)
+    return t.replace("=", ":").replace("#", "").replace('"', "")
+
+
+def quote(name: str) -> str:
+    name = name.replace('"', "'")
+    return name if _IDENT.match(name) else f'"{name}"'
+
+
+def _comment_lines(text: str) -> list[str]:
+    out = []
+    for line in (text or "").replace("\r", "").split("\n"):
+        line = " ".join(line.split()).replace("#", "＃")
+        if line:
+            out.append(f"# {line}")
+    return out
+
+
+class _Importer:
+    def __init__(
+        self, manifest: dict, catalog: dict | None, packages: list[str] | None, select: list[str], sources: bool
+    ):
+        self.m = manifest
+        self.catalog = catalog or {}
+        self.select = select
+        self.sources = sources
+        root = (manifest.get("metadata") or {}).get("project_name")
+        if packages and "all" in packages:
+            self.packages = None
+        elif packages:
+            self.packages = set(packages)
+        else:
+            self.packages = {root} if root else None
+        self.tables: dict[str, Tbl] = {}
+        self.skipped: list[str] = []
+        self.by_name: dict[str, list[str]] = {}
+
+    # -- selection ----------------------------------------------------------
+    def _wanted(self, node: dict) -> bool:
+        if self.packages is not None and node.get("package_name") not in self.packages:
+            return False
+        if not self.select:
+            return True
+        cands = [node.get("name", ""), ".".join(node.get("fqn", [])), node.get("original_file_path", "")]
+        return any(fnmatch.fnmatch(c, pat) for pat in self.select for c in cands)
+
+    @staticmethod
+    def _group(node: dict) -> str:
+        rt = node["resource_type"]
+        if rt == "source":
+            return "sources"
+        if rt != "model":
+            return rt + "s"
+        fqn = node.get("fqn", [])
+        return fqn[1] if len(fqn) > 2 else "models"
+
+    def collect(self) -> None:
+        nodes = [n for n in self.m.get("nodes", {}).values() if n.get("resource_type") in TABLE_TYPES]
+        if self.sources:
+            nodes += list(self.m.get("sources", {}).values())
+        nodes = [n for n in nodes if self._wanted(n)]
+        names: dict[str, int] = {}
+        for n in nodes:
+            names[self._base_name(n)] = names.get(self._base_name(n), 0) + 1
+        for n in sorted(nodes, key=lambda n: n["unique_id"]):
+            name = self._base_name(n)
+            if names[name] > 1:  # same name in two packages
+                name = f"{n.get('package_name')}.{name}"
+            t = Tbl(n["unique_id"], name, self._group(n), n.get("description") or "")
+            self._columns(t, n)
+            self.tables[t.uid] = t
+            self.by_name.setdefault(n.get("name", "").lower(), []).append(t.uid)
+            if n.get("resource_type") == "source":
+                self.by_name.setdefault(f"source:{n['source_name']}.{n['name']}".lower(), []).append(t.uid)
+
+    @staticmethod
+    def _base_name(n: dict) -> str:
+        if n.get("resource_type") == "source":
+            return f"{n['source_name']}.{n['name']}"
+        return n.get("name", "")
+
+    def _columns(self, t: Tbl, n: dict) -> None:
+        cat = (self.catalog.get("sources" if n["resource_type"] == "source" else "nodes") or {}).get(n["unique_id"])
+        if cat:
+            for cname, c in cat.get("columns", {}).items():
+                col = t.col(c.get("name") or cname)
+                col.type = c.get("type")
+                col.order = int(c.get("index") or col.order)
+        for i, (cname, c) in enumerate(n.get("columns", {}).items()):
+            col = t.col(c.get("name") or cname)
+            col.description = c.get("description") or ""
+            col.type = col.type or c.get("data_type")
+            if not cat:
+                col.order = i
+            for con in c.get("constraints") or []:
+                self._constraint(t, col, con)
+        for con in n.get("constraints") or []:
+            cols = con.get("columns") or []
+            if con.get("type") == "primary_key":
+                for cn in cols:
+                    t.col(cn).pk = True
+            elif con.get("type") == "unique" and len(cols) == 1:
+                t.col(cols[0]).unique = True
+            elif con.get("type") == "foreign_key" and len(cols) == 1:
+                self._constraint(t, t.col(cols[0]), con)
+
+    def _constraint(self, t: Tbl, col: Col, con: dict) -> None:
+        kind = con.get("type")
+        if kind == "primary_key":
+            col.pk = True
+        elif kind == "unique":
+            col.unique = True
+        elif kind == "not_null":
+            col.not_null = True
+        elif kind == "foreign_key":
+            target, tcol = con.get("to"), (con.get("to_columns") or [None])[0]
+            if not target and con.get("expression"):  # "other_table (id)"
+                m = re.match(r"\s*([\w.\"`]+)\s*\(\s*([\w\"`]+)\s*\)", con["expression"])
+                if m:
+                    target, tcol = m.group(1).split(".")[-1].strip('"`'), m.group(2).strip('"`')
+            # Resolved in link(): the target table may not have been collected yet.
+            self._constraint_fks.append((t.uid, col.name, target or "", tcol or ""))
+
+    _pending: list[tuple[str, str, str, str]]
+    _constraint_fks: list[tuple[str, str, str, str]]
+
+    def _resolve(self, text: str) -> str | None:
+        m = _REF.match(text)
+        if m:
+            name = (m.group(2) or m.group(1)).lower()
+        else:
+            s = _SOURCE.match(text)
+            name = f"source:{s.group(1)}.{s.group(2)}".lower() if s else text.strip().lower()
+        uids = self.by_name.get(name, [])
+        return uids[0] if len(uids) == 1 else None
+
+    # -- tests --------------------------------------------------------------
+    def tests(self) -> None:
+        uniq: dict[tuple[str, str], bool] = {}
+        notnull: dict[tuple[str, str], bool] = {}
+        for n in self.m.get("nodes", {}).values():
+            if n.get("resource_type") != "test":
+                continue
+            meta = n.get("test_metadata") or {}
+            kw = meta.get("kwargs") or {}
+            name = meta.get("name")
+            child = n.get("attached_node") or self._child_from_kwargs(kw)
+            colname = _strip_quotes(kw.get("column_name") or n.get("column_name") or "")
+            if not child or child not in self.tables or not colname:
+                continue
+            if name == "unique":
+                uniq[(child, colname.lower())] = True
+            elif name == "not_null":
+                notnull[(child, colname.lower())] = True
+            elif name in REL_TESTS:
+                deps = [d for d in (n.get("depends_on") or {}).get("nodes", []) if d != child]
+                parent = deps[0] if deps else (self._resolve(kw.get("to", "")) or child)
+                field_name = _strip_quotes(kw.get("field") or "")
+                if parent not in self.tables:
+                    self.skipped.append(f"{self.tables[child].name}.{colname}: parent {parent} not in selection")
+                    continue
+                if field_name:
+                    self._pending.append((child, colname, parent, field_name))
+        for (uid, cname), _ in uniq.items():
+            self.tables[uid].col(cname).unique = True
+        for (uid, cname), _ in notnull.items():
+            self.tables[uid].col(cname).not_null = True
+        for t in self.tables.values():  # implied primary key: unique + not_null
+            if any(c.pk for c in t.cols.values()):
+                continue
+            for c in sorted(t.cols.values(), key=lambda c: c.order):
+                if c.unique and c.not_null:
+                    c.pk = True
+                    break
+        for t in self.tables.values():
+            for c in t.cols.values():
+                if c.pk:
+                    c.unique = False
+
+    def _child_from_kwargs(self, kw: dict) -> str | None:
+        m = re.search(r"(ref\([^)]*\)|source\([^)]*\))", kw.get("model") or "")
+        return self._resolve(m.group(1)) if m else None
+
+    def link(self) -> int:
+        for child, ccol, target, tcol in self._constraint_fks:
+            parent = self._resolve(target) if target else None
+            if parent and tcol:
+                self._pending.append((child, ccol, parent, tcol))
+            else:
+                self.skipped.append(f"{self.tables[child].name}.{ccol}: foreign_key target '{target}' not found")
+        count = 0
+        seen = set()
+        for child, ccol, parent, pcol in self._pending:
+            key = (child, ccol.lower(), parent, pcol.lower())
+            if key in seen:
+                continue
+            seen.add(key)
+            c = self.tables[child].col(ccol)
+            p = self.tables[parent].col(pcol)
+            op = "-" if (c.unique or c.pk) else ">-"
+            if c.fk is None:
+                c.fk = (op, parent, p.name)
+            elif p.fk is None:  # one FK per column line: put the second one on the parent side
+                p.fk = ({"-": "-", ">-": "-<"}[op], child, c.name)
+            else:
+                self.skipped.append(
+                    f"{self.tables[child].name}.{ccol} -> {self.tables[parent].name}.{pcol}: "
+                    "column already has a relationship"
+                )
+                continue
+            count += 1
+        return count
+
+    # -- output -------------------------------------------------------------
+    def render_table(self, t: Tbl) -> list[str]:
+        lines = _comment_lines(t.description)
+        lines += [quote(t.name), "-"]
+        for c in sorted(t.cols.values(), key=lambda c: (c.order, c.name.lower())):
+            lines += _comment_lines(c.description)
+            parts = [quote(c.name)]
+            if c.pk:
+                parts.append("PK")
+            ty = norm_type(c.type)
+            if ty:
+                parts.append(ty)
+            if c.unique:
+                parts.append("UNIQUE")
+            if c.fk:
+                op, uid, pcol = c.fk
+                parts += ["FK", op, f"{quote(self.tables[uid].name)}.{quote(pcol)}"]
+            lines.append(" ".join(parts))
+        return lines
+
+    def run(self) -> tuple[dict[str, list[Tbl]], int]:
+        self._pending = []
+        self._constraint_fks = []
+        self.collect()
+        self.tests()
+        rels = self.link()
+        groups: dict[str, list[Tbl]] = {}
+        for t in sorted(self.tables.values(), key=lambda t: (t.group, t.name.lower())):
+            groups.setdefault(t.group, []).append(t)
+        return groups, rels
+
+
+def load_json(path: Path) -> dict:
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        raise DbtImportError(f"no such file: {path}") from None
+    except json.JSONDecodeError as e:
+        raise DbtImportError(f"{path}: not valid JSON ({e})") from None
+
+
+def import_dbt(
+    manifest_path: Path,
+    catalog_path: Path | None = None,
+    packages: list[str] | None = None,
+    select: list[str] | None = None,
+    sources: bool = True,
+    split: bool = False,
+) -> ImportResult:
+    if manifest_path.is_dir():
+        manifest_path = manifest_path / "manifest.json"
+    manifest = load_json(manifest_path)
+    if "nodes" not in manifest:
+        raise DbtImportError(f"{manifest_path}: not a dbt manifest (no 'nodes')")
+    if catalog_path is None and (manifest_path.parent / "catalog.json").exists():
+        catalog_path = manifest_path.parent / "catalog.json"
+    catalog = load_json(catalog_path) if catalog_path else None
+    imp = _Importer(manifest, catalog, packages, select or [], sources)
+    groups, rels = imp.run()
+    project = (manifest.get("metadata") or {}).get("project_name") or "dbt"
+    head = [
+        f"{HEADER} from {manifest_path.name} (project {project}).",
+        "# Re-run the import to refresh; manual edits will be overwritten.",
+        "",
+    ]
+    files: dict[str, str] = {}
+    if split:
+        for g, tables in groups.items():
+            body: list[str] = list(head)
+            for t in tables:
+                body += imp.render_table(t) + [""]
+            files[f"{g}.txt"] = "\n".join(body).rstrip("\n") + "\n"
+    else:
+        body = list(head)
+        for tables in groups.values():
+            for t in tables:
+                body += imp.render_table(t) + [""]
+        files["schema.txt"] = "\n".join(body).rstrip("\n") + "\n"
+    return ImportResult(files, len(imp.tables), rels, imp.skipped)
+
+
+def write_result(result: ImportResult, out: Path) -> list[Path]:
+    """Write to a .txt file, or into a directory (one file per group). Stale generated files are removed."""
+    written: list[Path] = []
+    if out.suffix == ".txt":
+        if len(result.files) != 1:
+            raise DbtImportError("--split needs a directory for -o")
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(next(iter(result.files.values())), encoding="utf-8")
+        return [out]
+    out.mkdir(parents=True, exist_ok=True)
+    for name, text in result.files.items():
+        p = out / name
+        p.write_text(text, encoding="utf-8")
+        written.append(p)
+    keep = {p.name for p in written}
+    for old in out.glob("*.txt"):
+        if old.name not in keep and old.read_text(encoding="utf-8").startswith(HEADER):
+            old.unlink()
+    return written

{quickdbd_cli-0.1.2 → quickdbd_cli-0.1.3}/src/quickdbd_cli/measure.py

@@ -20,7 +20,7 @@ STYLE = {
     "rowSize": 12,
     "padX": 12,
     "gap": 20,
-    "keyW": 16,
+    "keyW": 19,
     "badgeSize": 9,
     "badgePad": 4,
     "badgeGap": 4,