boardforge 0.1.0__py3-none-any.whl

boardforge/__init__.py

@@ -0,0 +1,7 @@
+"""boardforge: SKiDL circuit -> routed, manufacturable KiCad board.
+
+Keep this module free of imports: the scripts in boardforge.pcb run under KiCad's own
+Python, which imports this package but has none of boardforge's dependencies.
+"""
+
+__version__ = "0.1.0"

boardforge/analysis/__init__.py

@@ -0,0 +1,259 @@
+"""Analysis-step registry (design doc §4.7).
+
+Each step (schematic, pcb, thermal, emc, cross_verify, gerbers, release_gate) has one or
+more implementations. The default is the vendored kicad-happy script, run as a subprocess.
+Steps talk through JSON files with kicad-happy's schema
+(``skills/kicad/references/output-schema.md``), so a replacement only has to write the same
+JSON. Choose an implementation per step in boardforge.toml:
+
+    [checks.steps]
+    thermal = "boardforge"
+
+Register a replacement with ``@register("thermal", "boardforge")`` on a function
+``(ctx) -> output path``.
+"""
+
+import json
+import os
+import subprocess
+import sys
+
+VENDOR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "vendor", "kicad_happy", "skills")
+REGISTRY = {}
+
+# Steps in dependency order; each lists the outputs it reads.
+ORDER = ["schematic", "pcb", "thermal", "emc", "cross_verify", "gerbers", "release_gate"]
+
+
+def vendor_script(rel):
+    return os.path.join(VENDOR, rel)
+
+
+def register(step, impl):
+    def deco(fn):
+        REGISTRY.setdefault(step, {})[impl] = fn
+        return fn
+    return deco
+
+
+class Context:
+    """What a step needs: input files and where outputs go. ``outputs`` fills as steps run."""
+
+    def __init__(self, sch, pcb, outdir, gerber_dir=None, rail_currents=None, drc_report=None,
+                 fab_limits=None):
+        self.sch, self.pcb, self.outdir, self.gerber_dir = sch, pcb, outdir, gerber_dir
+        # {"name": "jlcpcb/multilayer", min_track, min_clearance, min_drill, annular_ring}:
+        # the fab tier the board was set up for; DFM findings are re-judged against it.
+        self.fab_limits = fab_limits
+        self.drc_report = drc_report  # kicad-cli DRC JSON: the authority on unrouted connections
+        self.rail_currents = dict(rail_currents or {})  # {KiCad net: A}
+        self.outputs = {}
+        self.loads = []  # [(regulator ref, rail, A)] patched by schematic_with_loads()
+        os.makedirs(outdir, exist_ok=True)
+
+    def out(self, step):
+        return os.path.join(self.outdir, f"{step}.json")
+
+    def schematic_with_loads(self):
+        """The schematic analysis with declared rail currents in place of kicad-happy's load
+        guesses (LDO dissipation, switcher rail loads). Same file if nothing is declared."""
+        src = self.outputs["schematic"]
+        if not self.rail_currents:
+            return src
+        with open(src) as f:
+            sch = json.load(f)
+        self.loads = apply_rail_currents(sch, self.rail_currents)
+        path = self.out("schematic_loads")
+        with open(path, "w") as f:
+            json.dump(sch, f)
+        return path
+
+
+def apply_rail_currents(sch, currents):
+    """Patch declared load currents into a kicad-happy schematic analysis, in place.
+    Returns [(regulator ref, rail, amps)] for the regulators changed."""
+    patched = []
+    for reg in sch.get("findings", []):
+        if reg.get("detector") != "detect_power_regulators":
+            continue
+        rail = reg.get("output_rail")
+        if rail not in currents:
+            continue
+        amps = float(currents[rail])
+        pd = reg.get("power_dissipation")
+        if isinstance(pd, dict) and "dropout_V" in pd:  # LDO
+            pd["estimated_iout_A"] = round(amps, 4)
+            pd["estimated_pdiss_W"] = round(pd["dropout_V"] * amps, 4)
+            pd["_iout_provenance"] = {"source": "boardforge_config", "confidence": "declared",
+                                      "basis": "checks.rail_currents"}
+        elif isinstance(pd, dict) and pd.get("efficiency_assumed") and pd.get("vout_V"):  # switcher
+            eta = pd["efficiency_assumed"]
+            pd["estimated_iout_A"] = round(amps, 4)
+            pd["estimated_pdiss_W"] = round(pd["vout_V"] * amps * (1 / eta - 1), 4)
+            pd["_iout_provenance"] = {"source": "boardforge_config", "confidence": "declared",
+                                      "basis": "checks.rail_currents"}
+        reg["estimated_iout_A"] = round(amps, 4)
+        patched.append((reg.get("ref"), rail, amps))
+    rails = sch.get("power_budget", {}).get("rails", {})
+    for rail, amps in currents.items():
+        if isinstance(rails.get(rail), dict):
+            rails[rail]["estimated_load_mA"] = round(float(amps) * 1000, 1)
+    return patched
+
+
+def _vendor(script, *args, timeout=900):
+    r = subprocess.run([sys.executable, vendor_script(script), *map(str, args)],
+                       capture_output=True, text=True, timeout=timeout)
+    if r.returncode not in (0, 1):  # some analyzers exit 1 when they report errors
+        raise RuntimeError(f"{os.path.basename(script)} exit {r.returncode}: {r.stderr.strip()[-400:]}")
+
+
+@register("schematic", "kicad_happy")
+def _schematic(ctx):
+    _vendor("kicad/scripts/analyze_schematic.py", ctx.sch, "-o", ctx.out("schematic"))
+    return ctx.out("schematic")
+
+
+@register("pcb", "kicad_happy")
+def _pcb(ctx):
+    _vendor("kicad/scripts/analyze_pcb.py", ctx.pcb, "--full", "-o", ctx.out("pcb"))
+    return ctx.out("pcb")
+
+
+@register("thermal", "kicad_happy")
+def _thermal(ctx):
+    _vendor("kicad/scripts/analyze_thermal.py", "-s", ctx.schematic_with_loads(), "-p",
+            ctx.outputs["pcb"], "-o", ctx.out("thermal"))
+    return ctx.out("thermal")
+
+
+@register("emc", "kicad_happy")
+def _emc(ctx):
+    _vendor("emc/scripts/analyze_emc.py", "-s", ctx.outputs["schematic"], "-p", ctx.outputs["pcb"],
+            "-o", ctx.out("emc"))
+    return ctx.out("emc")
+
+
+@register("cross_verify", "kicad_happy")
+def _cross(ctx):
+    args = ["-s", ctx.schematic_with_loads(), "-p", ctx.outputs["pcb"], "-o", ctx.out("cross_verify")]
+    if "thermal" in ctx.outputs:
+        args += ["-t", ctx.outputs["thermal"]]
+    _vendor("kicad/scripts/cross_verify.py", *args)
+    return ctx.out("cross_verify")
+
+
+@register("gerbers", "kicad_happy")
+def _gerbers(ctx):
+    _vendor("kicad/scripts/analyze_gerbers.py", ctx.gerber_dir, "-o", ctx.out("gerbers"))
+    return ctx.out("gerbers")
+
+
+# kicad-happy DFM-001 parameter -> the fab-tier minimum it is held to
+DFM_LIMITS = {"track_spacing": "min_clearance", "track_width": "min_track", "via_drill": "min_drill",
+              "pad_drill": "min_drill", "annular_ring": "annular_ring"}
+
+
+def dfm_for_fab(pcb, limits):
+    """Re-judge kicad-happy's DFM tier against the board's own fab tier. Its 'standard' limits
+    are JLCPCB's 1-2 layer ones (0.127 mm spacing), so a 4-layer board at JLCPCB's 0.09 mm
+    multilayer minimum was reported as needing the 'advanced' process. Findings within the
+    tier are dropped; the tier becomes 'standard' (meaning: this fab tier) when none are left.
+    Returns the parameters dropped."""
+    if not limits:
+        return []
+    dropped, keep = [], []
+    for f in pcb.get("findings", []):
+        par = f.get("parameter") if f.get("rule_id") == "DFM-001" else None
+        lim = limits.get(DFM_LIMITS.get(par, ""))
+        if lim is not None and isinstance(f.get("actual_mm"), (int, float)) and f["actual_mm"] >= lim - 1e-6:
+            dropped.append(par)
+            continue
+        keep.append(f)
+    pcb["findings"] = keep
+    left = [f for f in keep if f.get("rule_id") == "DFM-001" and f.get("parameter") in DFM_LIMITS]
+    dfm = pcb.setdefault("dfm_summary", {})
+    if dropped and not left:
+        dfm["dfm_tier"] = "standard"
+    dfm["judged_against"] = limits.get("name")
+    return dropped
+
+
+def routing_from_drc(pcb, drc_report):
+    """Replace kicad-happy's routing status with KiCad's: kicad-happy counts a net as routed
+    once it has any copper, so a partly routed net passes. Nets come from the DRC report's
+    unconnected items (``Pad 1 [NET] of U1``)."""
+    nets = sorted({i["description"].split("[", 1)[1].split("]", 1)[0]
+                   for u in drc_report.get("unconnected_items", []) for i in u.get("items", [])
+                   if "[" in i.get("description", "")})
+    conn = pcb.setdefault("connectivity", {})
+    conn["unrouted_count"] = len(nets)
+    conn["routing_complete"] = not nets
+    conn["unrouted"] = [{"net_name": n, "source": "kicad-cli DRC"} for n in nets]
+    return nets
+
+
+@register("release_gate", "kicad_happy")
+def _gate(ctx):
+    # The gate compares schematic parts with *all* PCB footprints; board-only ones
+    # (fiducials, mounting holes) have no schematic symbol, and the schematic count leaves
+    # out DNP parts, so both are left out of the count.
+    # Its DFM tier is re-judged against the board's fab tier (dfm_for_fab).
+    with open(ctx.outputs["pcb"]) as f:
+        pcb = json.load(f)
+    fps = pcb.get("footprints", [])
+    pcb.setdefault("statistics", {})["footprint_count"] = sum(
+        1 for fp in fps if not fp.get("board_only") and not fp.get("dnp"))
+    if ctx.drc_report and os.path.exists(ctx.drc_report):
+        with open(ctx.drc_report) as f:
+            routing_from_drc(pcb, json.load(f))
+    dfm_for_fab(pcb, ctx.fab_limits)
+    pcb_gate = ctx.out("pcb_for_gate")
+    with open(pcb_gate, "w") as f:
+        json.dump(pcb, f)
+    args = ["-s", ctx.outputs["schematic"], "-p", pcb_gate, "-o", ctx.out("release_gate")]
+    for step, flag in (("gerbers", "-g"), ("thermal", "-t"), ("emc", "-e")):
+        if step in ctx.outputs:
+            args += [flag, ctx.outputs[step]]
+    _vendor("kicad/scripts/fab_release_gate.py", *args)
+    return ctx.out("release_gate")
+
+
+def summarize(path, top=5):
+    """Counts by severity plus the first few errors, from kicad-happy's common envelope."""
+    with open(path) as f:
+        d = json.load(f)
+    s = d.get("summary", {}) if isinstance(d, dict) else {}
+    out = {"by_severity": s.get("by_severity")}
+    findings = [x for x in d.get("findings", []) if not x.get("suppressed")]
+    errs = [x for x in findings if x.get("severity") == "error"]
+    out["errors"] = [f"{x.get('rule_id', '?')}: {(x.get('summary') or x.get('title') or '')[:90]}"
+                     for x in errs[:top]]
+    if "overall_status" in d:  # release gate
+        out = {"status": d["overall_status"], **{k: d.get("summary", {}).get(k)
+                                                 for k in ("pass", "warn", "fail", "skip")}}
+        out["not_passed"] = [f"{c.get('status')}: {c.get('check_id')}: {c.get('message', '')[:80]}"
+                             for c in d.get("checks", []) if c.get("status") in ("warn", "fail")][:top]
+    return out
+
+
+def run_steps(ctx, steps, choice=None):
+    """Run the named steps in dependency order. A failure is recorded and later steps that
+    need its output are skipped. Returns {step: summary}."""
+    choice = choice or {}
+    results = {}
+    for step in [s for s in ORDER if s in steps]:
+        impl = choice.get(step, "kicad_happy")
+        fn = REGISTRY.get(step, {}).get(impl)
+        if fn is None:
+            results[step] = {"error": f"no implementation {impl!r}"}
+            continue
+        try:
+            path = fn(ctx)
+            ctx.outputs[step] = path
+            results[step] = summarize(path)
+        except KeyError as e:
+            results[step] = {"skipped": f"needs {e.args[0]} output"}
+        except Exception as e:  # noqa: BLE001 - recorded, run continues
+            results[step] = {"error": f"{type(e).__name__}: {str(e)[:300]}"}
+    return results

boardforge/cli.py

@@ -0,0 +1,280 @@
+"""boardforge command line.
+
+    boardforge run [-C DIR] [--from c3] [--to c6]   physical pipeline C1-C6 (or a range)
+    boardforge sch|board|place|route|check|fab       one stage (C1 ... C6)
+    boardforge review                                B4 gate: constraints.json against the design
+    boardforge datasheets status|sync|add|check|show|publish|paths
+                                                     part-fact cache (datasheet PDFs, extractions)
+    boardforge render [--side top|bottom|both]       pictures of the current board (to check placement)
+    boardforge status                                stage results from pipeline_state.json
+    boardforge doctor                                check KiCad, Freerouting, config
+
+Output is a short summary per stage; details are in <project>/build/reports/.
+"""
+
+import argparse
+import json
+import os
+import sys
+
+from boardforge import __version__, fabs, routers
+from boardforge.config import Project
+from boardforge.state import STAGES, TITLES, State
+
+ALIASES = {"sch": "c1", "board": "c2", "place": "c3", "route": "c4", "check": "c5", "fab": "c6"}
+
+
+def _print_stage(res, verbose):
+    s = res["summary"]
+    print(f"[{res['stage']}] {TITLES[res['stage']]}: {res['status']} ({res['seconds']} s)")
+    text = json.dumps(s, indent=1 if verbose else None, default=str)
+    print("  " + (text if verbose else text[:600] + ("..." if len(text) > 600 else "")))
+    for w in res["warnings"][:12]:
+        print(f"  ! {w}")
+    if len(res["warnings"]) > 12:
+        print(f"  ! ... {len(res['warnings']) - 12} more (pipeline_state.json)")
+
+
+def cmd_run(args, stages):
+    from boardforge.physical import Pipeline
+
+    from boardforge.physical import StageError
+
+    pipe = Pipeline(Project.load(args.dir))
+    for w in pipe.k.warnings:
+        print(f"! {w}")
+    failed = False
+    try:
+        results = pipe.run(stages)
+    except StageError as e:
+        print(f"! {e}")
+        return 1
+    for res in results:
+        _print_stage(res, args.verbose)
+        failed |= res["status"] == "failed"
+    return 1 if failed else 0
+
+
+def cmd_review(args):
+    from boardforge.review.gate import review
+
+    rep = review(Project.load(args.dir))
+    print(f"[review] {rep['status']}: {rep['counts']} (reports/review.json)")
+    for r in rep["results"]:
+        detail = (f"{r['gain_db']} dB at {r['at_hz']:g} Hz, limit {r['limit']}" if "gain_db" in r
+                  else r["why"] if r["status"] == "NOT CHECKED" and r.get("why")
+                  else ",".join(r.get("refs", [])) or r.get("why", ""))
+        print(f"  {r['status']:11} {r['tag']:7} {r['id']}: {detail}")
+        for f in r.get("findings", []):
+            if args.verbose or f["severity"] != "info":
+                print(f"      {f['severity']}: {f['detail']}")
+        if args.verbose:
+            for n in r.get("notes", []):
+                print(f"      {n}")
+    for p in rep["problems"]:
+        print(f"  ! {p}")
+    return 1 if rep["status"] == "FAIL" else 0
+
+
+def cmd_datasheets(args):
+    import os
+
+    from boardforge import datasheets as ds
+
+    proj = Project.load(args.dir)
+    try:
+        if args.action == "status":
+            rows = ds.status(proj)
+            shown = [r for r in rows if r["wanted"] or args.all]
+            print(f"{'MPN':28} {'refs':14} pdf extracted quality cache")
+            for r in shown:
+                refs = ",".join(r["refs"][:3]) + ("..." if len(r["refs"]) > 3 else "")
+                ext = ("stale" if r["stale"] else "yes") if r["extracted"] else "-"
+                print(f"{r['mpn'][:28]:28} {refs[:14]:14} {'yes' if r['pdf'] else '-':3} "
+                      f"{ext:9} {r['quality'] if r['quality'] is not None else '-':7} "
+                      f"{'yes' if r['in_cache'] else '-'}")
+            no_pdf = sum(not r["pdf"] for r in shown)
+            todo = sum(r["pdf"] and (not r["extracted"] or bool(r["stale"])) for r in shown)
+            print(f"{len(shown)} parts ({len(rows) - len(shown)} passives etc. hidden; --all shows them): "
+                  f"{no_pdf} without a PDF, {todo} to extract")
+            return 0
+        if args.action == "paths":
+            project, shared = ds.stores(proj)
+            print(f"project: {project.root}\nshared cache: {shared.root if shared else '(none)'}\n"
+                  f"prompts: {os.path.join(ds.SKILL, 'prompts')}\nschemas: {ds.SCHEMAS}\n"
+                  f"references: {os.path.join(ds.SKILL, 'references')}\n"
+                  f"examples: {os.path.join(ds.SKILL, 'examples')}")
+            return 0
+        if args.action in ("add", "check", "show") and not args.mpn:
+            raise ValueError(f"datasheets {args.action} needs MPNs")
+        if args.action == "add":
+            if len(args.mpn) != 2:
+                raise ValueError("datasheets add MPN FILE_OR_URL")
+            print(f"  added {ds.add(proj, args.mpn[0], args.mpn[1], force=args.force)}")
+            return 0
+        if args.action == "check":
+            bad = 0
+            for r in ds.check(proj, args.mpn):
+                ok = not r["problems"]
+                bad += not ok
+                print(f"{r['mpn']}: {'ok' if ok else 'INVALID'}, quality {r['quality']}")
+                for x in r["problems"]:
+                    print(f"  ! schema {x}")
+                for x in r["issues"]:
+                    print(f"  ? {x}")
+            return 1 if bad else 0
+        if args.action == "show":
+            project, shared = ds.stores(proj)
+            for mpn in args.mpn:
+                ex = project.extraction(mpn) or (shared.extraction(mpn) if shared else None)
+                print(ds.summary(ex) if ex else f"! {mpn}: no extraction (run the librarian)")
+            return 0
+        if args.action == "sync":
+            res = ds.sync(proj, fresh=args.fresh, download=not args.offline)
+        else:
+            res = ds.publish(proj, force=args.force)
+    except (FileNotFoundError, ValueError) as e:
+        print(f"! {e}")
+        return 1
+    for k, v in res.items():
+        print(f"  {k}: {len(v)}{' ' + ', '.join(v) if v else ''}")
+    return 0
+
+
+def cmd_render(args):
+    from boardforge.kicad import Kicad
+    from boardforge.render import render
+
+    proj = Project.load(args.dir)
+    sides = ("top", "bottom") if args.side == "both" else (args.side,)
+    try:
+        for f in render(proj, Kicad.find(proj.cfg["kicad"]), sides, pours=args.pours):
+            print(f"  {os.path.relpath(f, proj.root)}")
+    except FileNotFoundError as e:
+        print(f"! {e}")
+        return 1
+    return 0
+
+
+def cmd_status(args):
+    proj = Project.load(args.dir)
+    st = State(proj.state_file)
+    for sid in STAGES:
+        s = st.stage(sid)
+        if s:
+            print(f"[{sid}] {TITLES[sid]}: {s['status']} ({s.get('seconds')} s, {s.get('finished')}), "
+                  f"{len(s.get('warnings', []))} warnings")
+        else:
+            print(f"[{sid}] {TITLES[sid]}: not run")
+    return 0
+
+
+def cmd_doctor(args):
+    from boardforge.kicad import Kicad, KicadError
+
+    ok = True
+    try:
+        proj = Project.load(args.dir)
+        cfg = proj.cfg
+        print(f"config: {proj.root}/boardforge.toml (design {cfg['design']['file']})")
+    except (ValueError, FileNotFoundError) as e:
+        print(f"config: {e} (checking machine settings only)")
+        from boardforge.config import DEFAULTS
+
+        cfg = DEFAULTS
+    try:
+        k = Kicad.find(cfg["kicad"])
+        print(f"kicad-cli: {k.cli} ({k.version})")
+        print(f"KiCad python: {k.python}")
+        print(f"symbols: {k.symbol_dir}\nfootprints: {k.footprint_dir}")
+        for w in k.warnings:
+            print(f"! {w}")
+            ok = False
+    except KicadError as e:
+        print(f"! {e}")
+        ok = False
+    for name in cfg["routing"]["chain"]:
+        good, msg = routers.get(name).available(cfg)
+        print(f"router {name}: {'ok' if good else 'MISSING'} {msg}")
+        ok &= good
+    from boardforge.review.spice_path import find_ngspice
+
+    ng = find_ngspice(cfg.get("review", {}).get("ngspice", ""))
+    print(f"ngspice: {ng or 'MISSING (the review gate reports SPICE checks as not checked)'}")
+    try:
+        f = fabs.get(cfg["fab"]["name"], cfg["fab"].get("tier"))
+        print(f"fab: {f.name} tier {f.tier_name}")
+    except ValueError as e:
+        print(f"! {e}")
+        ok = False
+    # Look the packages up without importing them: importing SKiDL creates .log/.erc files in
+    # the current directory.
+    from importlib import metadata, util
+
+    for pkg in ("skidl", "schematizer"):
+        if util.find_spec(pkg) is None:
+            print(f"! {pkg} is not installed")
+            ok = False
+            continue
+        try:
+            print(f"{pkg} {metadata.version(pkg)}")
+        except metadata.PackageNotFoundError:
+            print(f"{pkg} (version unknown)")
+    import os
+    import shutil
+
+    cache = cfg.get("datasheets", {}).get("cache", "")
+    print(f"datasheet cache: {os.path.expanduser(cache) if cache else '(none)'}")
+    print(f"pdftotext: {shutil.which('pdftotext') or 'MISSING (downloaded PDFs are not identity-checked)'}")
+    if util.find_spec("jsonschema") is None:
+        print("jsonschema: MISSING (datasheets publish can't validate extractions; "
+              "pip install 'boardforge[analysis]')")
+    return 0 if ok else 1
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="boardforge", description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--version", action="version", version=__version__)
+    ap.add_argument("-C", "--dir", default=".", help="project directory (has boardforge.toml)")
+    ap.add_argument("-v", "--verbose", action="store_true", help="full stage summaries")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    r = sub.add_parser("run", help="run the physical pipeline")
+    r.add_argument("--from", dest="start", default="c1", choices=STAGES)
+    r.add_argument("--to", dest="end", default="c6", choices=STAGES)
+    for alias, sid in ALIASES.items():
+        sub.add_parser(alias, help=f"stage {sid}: {TITLES[sid]}")
+    sub.add_parser("review", help="B4 gate: check constraints.json")
+    d = sub.add_parser("datasheets", help="part-fact cache: status, sync, add, check, show, publish, paths")
+    d.add_argument("action", choices=("status", "sync", "add", "check", "show", "publish", "paths"))
+    d.add_argument("mpn", nargs="*", help="add: MPN FILE_OR_URL; check/show: MPNs")
+    d.add_argument("--all", action="store_true", help="status: include passives")
+    d.add_argument("--fresh", action="store_true", help="sync: don't copy from the shared cache")
+    d.add_argument("--offline", action="store_true", help="sync: don't download PDFs")
+    d.add_argument("--force", action="store_true",
+                   help="publish: replace shared entries; add: skip the part-name check")
+    r2 = sub.add_parser("render", help="SVG/PNG of the current board (placed or routed)")
+    r2.add_argument("--side", choices=("top", "bottom", "both"), default="top")
+    r2.add_argument("--pours", action="store_true", help="keep copper pours (hide tracks under them)")
+    sub.add_parser("status", help="show stage results")
+    sub.add_parser("doctor", help="check the environment")
+    args = ap.parse_args(argv)
+
+    if args.cmd == "run":
+        i, j = STAGES.index(args.start), STAGES.index(args.end)
+        return cmd_run(args, STAGES[i:j + 1])
+    if args.cmd in ALIASES:
+        return cmd_run(args, (ALIASES[args.cmd],))
+    if args.cmd == "status":
+        return cmd_status(args)
+    if args.cmd == "render":
+        return cmd_render(args)
+    if args.cmd == "review":
+        return cmd_review(args)
+    if args.cmd == "datasheets":
+        return cmd_datasheets(args)
+    return cmd_doctor(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())