KiCad - the KiCad Bridge

@@ -427,6 +427,33 @@ def add_symbol(kicad_info: dict, symbol_text: str) -> dict:                          f"({len(rebuilt)} < {len(nodes)}); the library on disk was "                          "NOT touched. This is a bridge bug - report it."} +    # THE KICAD GATE (wiki #71, 2026-09-03). The balance check above is OUR+    # parser. KiCad's parser refused a library our reader called clean, and+    # one refused symbol hides the WHOLE library in the Symbol Editor. So ask+    # KiCad (kicad-cli sym export svg on a temp copy) before touching the file:+    # first the incoming symbols alone, so the error names the upload and not+    # the user's library; then the merged result. No kicad-cli = no verdict,+    # and we say so instead of pretending it passed.+    from handlers import kicad_parse_check as _kpc+    incoming_v = _kpc.verdict_text(kicad_info, _kpc.wrap_symbol_blocks([b for _n, b in incoming_symbols]))+    if incoming_v.get("available") and not incoming_v.get("ok"):+        return {"success": False, "errorCode": "kicad_refuses_symbol",+                "kicadParser": incoming_v,+                "error": (f"KiCad's own parser refuses the uploaded symbol(s) {added_names}: "+                          f"{incoming_v.get('error')}. The library on disk was NOT touched, because one "+                          f"refused symbol makes KiCad drop the whole library."),+                "_hint": ("Fix the .kicad_sym so `kicad-cli sym export svg` accepts it (common: bare "+                          "`hide yes` inside (effects ...) instead of `(hide yes)`, or a pre-20231120 "+                          "shape). kicad_lint_library reports KiCad's verdict as kicadParser.")}+    merged_v = _kpc.verdict_text(kicad_info, new_text)+    if merged_v.get("available") and not merged_v.get("ok"):+        return {"success": False, "errorCode": "kicad_refuses_merged_library",+                "kicadParser": merged_v,+                "error": (f"KiCad's parser accepts the upload alone but refuses the merged library: "+                          f"{merged_v.get('error')}. Nothing was written. The existing library is "+                          f"probably already refused by KiCad; run kicad_adom_library_status "+                          f"(kicadParser) and kicad_adom_library_heal mode:prune to drop the culprit.")}+     # One-generation backup beside the library, then an atomic-ish replace.     try:         lib_path.with_suffix(".kicad_sym.bak").write_text(existing_text, encoding="utf-8")@@ -438,6 +465,9 @@ def add_symbol(kicad_info: dict, symbol_text: str) -> dict:         "success": True,         "added": added_names,         "lib_path": str(lib_path),+        "kicadParser": ({"available": True, "ok": True, "symbols": merged_v.get("symbols"), "units": merged_v.get("units")}+                        if merged_v.get("available") else+                        {"available": False, "ok": None, "note": "kicad-cli not found; KiCad's verdict was not obtained"}),     }  @@ -544,6 +574,46 @@ def heal_split(kicad_info: dict, mode: str = "merge", dry_run: bool = False) ->     Never runs on its own: the bridge cannot know which of two libraries is the     user's real one. This exists because a human said which."""     rep = library_split_report(kicad_info)+    if mode == "prune":+        # wiki #71 (2026-09-03): KiCad drops a WHOLE library when one symbol in+        # it is malformed, and the bridge's own reader does not notice. prune+        # asks KiCad about each symbol alone and rebuilds the registered file+        # from the ones it accepts; the original is kept as .kicad_sym.pruned.bak.+        from handlers import kicad_parse_check as _kpc+        reg = rep.get("registeredPath")+        if not reg or not Path(reg).exists():+            return {"success": False, "error": "no registered Adom library file to prune", "report": rep}+        text = Path(reg).read_text(encoding="utf-8")+        whole = _kpc.verdict_file(kicad_info, reg)+        if not whole.get("available"):+            return {"success": False, "error": whole.get("error"), "kicadParser": whole}+        blocks, notes = _extract_symbols_tolerant(text)+        if whole.get("ok"):+            return {"success": True, "healed": False, "mode": "prune", "dryRun": dry_run,+                    "kicadParser": whole, "dropped": [], "kept": [n for n, _ in blocks],+                    "_hint": "KiCad already loads this library; nothing to prune."}+        per = _kpc.refused_symbols(kicad_info, blocks)+        kept = [(n, b) for n, b in blocks if n in per["accepted"]]+        out = {"success": True, "mode": "prune", "dryRun": dry_run, "registeredPath": reg,+               "kicadParserBefore": whole, "dropped": per["refused"], "kept": [n for n, _ in kept],+               "sourceNotes": notes}+        if dry_run:+            out["healed"] = False+            out["_hint"] = (f"Would rebuild {reg} with {len(kept)} symbol(s) KiCad accepts and drop "+                            f"{len(per['refused'])} it refuses (names in dropped). Nothing written.")+            return out+        new_text = _kpc.wrap_symbol_blocks([b for _n, b in kept]).replace('"adom-parse-check"', '"adom-desktop"')+        after = _kpc.verdict_text(kicad_info, new_text)+        if not after.get("ok"):+            return {**out, "success": False, "healed": False, "kicadParserAfter": after,+                    "error": "the pruned library is STILL refused by KiCad; nothing written (report this with the file)"}+        Path(reg + ".pruned.bak").write_text(text, encoding="utf-8")+        Path(reg).write_text(new_text, encoding="utf-8")+        out.update({"healed": True, "kicadParserAfter": after, "backup": reg + ".pruned.bak",+                    "_hint": (f"Rebuilt with {len(kept)} symbol(s) KiCad accepts; dropped {len(per['refused'])} "+                              f"(see dropped, with KiCad's reason each). Original saved beside it. KiCad sees "+                              f"the change after its next library load.")})+        return out     if not rep.get("split"):         return {"success": True, "healed": False, "reason": "no split", **rep}     registered = Path(rep["registeredPath"])@@ -562,7 +632,7 @@ def heal_split(kicad_info: dict, mode: str = "merge", dry_run: bool = False) ->                 "rowNowPointsAt": str(orphan).replace("\\", "/"),                 "_hint": "KiCad reads the repointed file after its next library load (restart)."}     if mode != "merge":-        return {"success": False, "error": f"unknown mode {mode!r}", "allowed": ["merge", "repoint"]}+        return {"success": False, "error": f"unknown mode {mode!r}", "allowed": ["merge", "repoint", "prune"]}     try:         orphan_text = orphan.read_text(encoding="utf-8")     except Exception as e:  # pylint: disable=broad-except

@@ -0,0 +1,125 @@+"""KiCad's OWN verdict on a symbol library, via `kicad-cli sym export svg`.++Why this module exists (wiki #71, 2026-09-03, measured on ConfRoomROG):+the bridge's structural reader (`adom_library`, `kicad_lint_library`) said a+five-symbol Adom.kicad_sym "parsed cleanly", while KiCad itself answered+"Unable to load library" and the Symbol Editor showed the Adom library EMPTY.+Three minimal test symbols carried `hide yes` as bare tokens inside+`(effects ...)`; our reader only balances parentheses, KiCad's parser does+not accept the tokens, and ONE bad symbol makes KiCad drop the WHOLE library.+The two well-formed symbols alone loaded fine.++So: our parser is not KiCad's parser. Anything that writes into a library+KiCad reads must ask KiCad first. `sym export svg` is the one kicad-cli+command that parses a .kicad_sym read-only (the `upgrade` command rewrites+the file) and prints one "Plotting symbol 'NAME' unit N" line per unit it+loaded, so it doubles as a symbol inventory from KiCad's point of view.+"""+from __future__ import annotations++import os+import re+import shutil+import subprocess+import tempfile+import time+from pathlib import Path++_PLOT_RE = re.compile(r"Plotting symbol '([^']+)' unit (\d+)")+++def cli_exe(kicad_info: dict) -> str | None:+    cli = (kicad_info or {}).get("kicad_cli_exe")+    if cli and Path(cli).exists():+        return cli+    base = (kicad_info or {}).get("base_dir")+    if base:+        for cand in (Path(base) / "bin" / "kicad-cli.exe", Path(base) / "bin" / "kicad-cli"):+            if cand.exists():+                return str(cand)+    return None+++def verdict_file(kicad_info: dict, lib_path: str | Path, timeout_s: float = 60.0) -> dict:+    """KiCad's verdict on an existing .kicad_sym.++    Returns {available, ok, symbols[], units, error, exitCode, durationMs}.+    available=False means kicad-cli was not found: no verdict either way, and+    callers must SAY that rather than treat it as a pass."""+    cli = cli_exe(kicad_info)+    if not cli:+        return {"available": False, "ok": None, "symbols": [], "units": 0,+                "error": "kicad-cli not found; KiCad's parser could not be asked"}+    lib_path = str(lib_path)+    if not Path(lib_path).exists():+        return {"available": True, "ok": False, "symbols": [], "units": 0,+                "error": f"file not found: {lib_path}"}+    out_dir = tempfile.mkdtemp(prefix="adom-kicad-parse-")+    t0 = time.monotonic()+    try:+        proc = subprocess.run([cli, "sym", "export", "svg", "-o", out_dir, lib_path],+                              capture_output=True, text=True, timeout=timeout_s,+                              creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0))+        text = (proc.stdout or "") + "\n" + (proc.stderr or "")+        names: list[str] = []+        units = 0+        for m in _PLOT_RE.finditer(text):+            units += 1+            if m.group(1) not in names:+                names.append(m.group(1))+        ok = proc.returncode == 0+        err = ""+        if not ok:+            lines = [ln.strip() for ln in text.splitlines() if ln.strip() and not _PLOT_RE.search(ln)]+            err = " | ".join(lines[:3])[:400] or f"kicad-cli exit {proc.returncode}"+        return {"available": True, "ok": ok, "symbols": names, "units": units,+                "error": err, "exitCode": proc.returncode,+                "durationMs": int((time.monotonic() - t0) * 1000)}+    except subprocess.TimeoutExpired:+        return {"available": True, "ok": False, "symbols": [], "units": 0,+                "error": f"kicad-cli did not answer within {timeout_s:.0f}s"}+    except Exception as e:  # pylint: disable=broad-except+        return {"available": True, "ok": False, "symbols": [], "units": 0,+                "error": f"{type(e).__name__}: {e}"[:300]}+    finally:+        shutil.rmtree(out_dir, ignore_errors=True)+++def verdict_text(kicad_info: dict, lib_text: str, timeout_s: float = 60.0) -> dict:+    """Same verdict for library TEXT that has not been written anywhere yet:+    the gate an install runs BEFORE it touches the user's file."""+    fd, tmp = tempfile.mkstemp(suffix=".kicad_sym", prefix="adom-candidate-")+    os.close(fd)+    try:+        Path(tmp).write_text(lib_text, encoding="utf-8")+        return verdict_file(kicad_info, tmp, timeout_s)+    finally:+        try:+            os.unlink(tmp)+        except OSError:+            pass+++def wrap_symbol_blocks(blocks: list[str]) -> str:+    return ('(kicad_symbol_lib (version 20231120) (generator "adom-parse-check")\n'+            + "\n".join(blocks) + "\n)\n")+++def refused_symbols(kicad_info: dict, symbol_blocks: list[tuple[str, str]],+                    timeout_s: float = 60.0) -> dict:+    """Which of these (name, block) symbols does KiCad refuse ON THEIR OWN?++    One bad symbol hides a whole library, so this is how a repair finds the+    culprit(s): each block is wrapped as a one-symbol library and parsed alone.+    Returns {available, accepted[], refused{name: error}}."""+    cli = cli_exe(kicad_info)+    if not cli:+        return {"available": False, "accepted": [], "refused": {}}+    accepted, refused = [], {}+    for name, blk in symbol_blocks:+        v = verdict_text(kicad_info, wrap_symbol_blocks([blk]), timeout_s)+        if v.get("ok"):+            accepted.append(name)+        else:+            refused[name] = v.get("error") or "refused"+    return {"available": True, "accepted": accepted, "refused": refused}