traceforge-pcb 1.0.0__py3-none-any.whl

traceforge/kicad_plugin/context.py

@@ -0,0 +1,257 @@
+"""The selected part as read from KiCad: from ``pcbnew`` (KiCad 7/8) or the IPC API (``kipy``).
+
+Both readers are duck-typed on the objects they are handed, so tests can pass a fake module. The
+board is a KiCad ``.kicad_pcb``; the project folder is its directory. Standard library only.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+NM_PER_MM = 1_000_000.0
+
+
+class SelectionError(RuntimeError):
+    pass
+
+
+@dataclass
+class PartContext:
+    reference: str
+    value: str = ""
+    footprint: str = ""  # library:name
+    datasheet: str = ""
+    description: str = ""
+    layer: str = ""
+    x_mm: float | None = None
+    y_mm: float | None = None
+    pad_count: int = 0
+    selected_pads: list[dict[str, str]] = field(default_factory=list)
+    fields: dict[str, str] = field(default_factory=dict)
+    board: str = ""
+    project_dir: str = ""
+    source: str = ""  # "pcbnew" | "kipy"
+    kicad_version: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+    def describe(self) -> str:
+        """Plain lines for the model; only what KiCad told us."""
+        lines = [f"reference: {self.reference}"]
+        for label, value in (
+            ("value", self.value),
+            ("footprint", self.footprint),
+            ("datasheet", self.datasheet if self.datasheet not in ("", "~") else ""),
+            ("description", self.description),
+            ("layer", self.layer),
+        ):
+            if value:
+                lines.append(f"{label}: {value}")
+        if self.x_mm is not None and self.y_mm is not None:
+            lines.append(f"board position (mm): {self.x_mm:.3f}, {self.y_mm:.3f}")
+        if self.pad_count:
+            lines.append(f"pads: {self.pad_count}")
+        if self.selected_pads:
+            pads = ", ".join(f"{p['number']}={p['net'] or '-'}" for p in self.selected_pads)
+            lines.append(f"selected pads: {pads}")
+        for key, value in self.fields.items():
+            lines.append(f"{key}: {value}")
+        if self.board:
+            lines.append(f"board file: {self.board}")
+        return "\n".join(lines)
+
+
+def _dirname(path: str) -> str:
+    import os
+
+    return os.path.dirname(os.path.abspath(path)) if path else ""
+
+
+def _call(obj: Any, *names: str, default: Any = None) -> Any:
+    """The first of several method names that exists (KiCad renames these between versions)."""
+    for name in names:
+        method = getattr(obj, name, None)
+        if callable(method):
+            try:
+                return method()
+            except Exception:  # noqa: BLE001 - a missing optional property is not an error
+                continue
+    return default
+
+
+def _properties(fp: Any) -> dict[str, str]:
+    props = _call(fp, "GetProperties", default=None)
+    out: dict[str, str] = {}
+    if props:
+        try:
+            out = {str(k): str(v) for k, v in dict(props).items()}
+        except (TypeError, ValueError):
+            out = {}
+    if not out:  # KiCad 8+: GetFields() returns PCB_FIELD objects
+        for item in _call(fp, "GetFields", default=None) or []:
+            name, text = _call(item, "GetName"), _call(item, "GetText")
+            if name:
+                out[str(name)] = str(text or "")
+    return out
+
+
+# Fields the context already carries by name; the rest go to ``fields`` (MPN, LCSC, ...).
+_KNOWN = {"reference", "value", "footprint", "datasheet", "description"}
+
+
+def _footprint_context(pcbnew: Any, board: Any, fp: Any, pads: list[dict[str, str]]) -> PartContext:
+    props = _properties(fp)
+    datasheet = next((v for k, v in props.items() if k.lower() == "datasheet"), "")
+    pos = _call(fp, "GetPosition")
+    to_mm = getattr(pcbnew, "ToMM", None)
+    x = y = None
+    if pos is not None:
+        x = float(to_mm(pos.x)) if to_mm else pos.x / NM_PER_MM
+        y = float(to_mm(pos.y)) if to_mm else pos.y / NM_PER_MM
+    layer = ""
+    try:
+        layer = str(board.GetLayerName(fp.GetLayer()))
+    except Exception:  # noqa: BLE001 - a fake or old board without layer names
+        layer = ""
+    fpid = _call(fp, "GetFPIDAsString") or ""
+    path = str(_call(board, "GetFileName") or "")
+    version = ""
+    get_version = getattr(pcbnew, "Version", None) or getattr(pcbnew, "GetMajorMinorVersion", None)
+    if callable(get_version):
+        try:
+            version = str(get_version())
+        except Exception:  # noqa: BLE001
+            version = ""
+    return PartContext(
+        reference=str(_call(fp, "GetReference") or ""),
+        value=str(_call(fp, "GetValue") or ""),
+        footprint=str(fpid),
+        datasheet=datasheet,
+        description=str(_call(fp, "GetLibDescription", "GetDescription") or ""),
+        layer=str(layer),
+        x_mm=x,
+        y_mm=y,
+        pad_count=len(_call(fp, "Pads", default=[]) or []),
+        selected_pads=pads,
+        fields={k: v for k, v in props.items() if k.lower() not in _KNOWN and v},
+        board=path,
+        project_dir=_dirname(path),
+        source="pcbnew",
+        kicad_version=version,
+    )
+
+
+def read_pcbnew_selection(pcbnew: Any, board: Any = None) -> list[PartContext]:
+    """Selected footprints (and the selected pads of each) from a ``pcbnew`` module.
+
+    A selected pad selects its footprint's context too. Raises SelectionError when nothing usable
+    is selected.
+    """
+    board = board if board is not None else pcbnew.GetBoard()
+    if board is None:
+        raise SelectionError("no board is open in the PCB editor")
+    chosen: dict[str, Any] = {}
+    pad_rows: dict[str, list[dict[str, str]]] = {}
+    for fp in board.GetFootprints():
+        ref = str(_call(fp, "GetReference") or "")
+        if bool(_call(fp, "IsSelected", default=False)):
+            chosen[ref] = fp
+        for pad in _call(fp, "Pads", default=[]) or []:
+            if bool(_call(pad, "IsSelected", default=False)):
+                chosen.setdefault(ref, fp)
+                pad_rows.setdefault(ref, []).append(
+                    {
+                        "number": str(_call(pad, "GetNumber") or ""),
+                        "net": str(_call(pad, "GetNetname") or ""),
+                    }
+                )
+    if not chosen:
+        raise SelectionError("select a footprint in the PCB editor first")
+    return [
+        _footprint_context(pcbnew, board, fp, pad_rows.get(ref, [])) for ref, fp in chosen.items()
+    ]
+
+
+def _kipy_layer(layer: Any) -> str:
+    try:
+        from kipy.board_types import BoardLayer  # type: ignore[import-not-found]
+
+        return str(BoardLayer.Name(layer)).removeprefix("BL_")
+    except Exception:  # noqa: BLE001
+        return str(layer)
+
+
+def read_kipy_selection(kicad: Any, board: Any = None) -> list[PartContext]:
+    """Selected footprints (and selected pads) through the KiCad IPC API.
+
+    ``kicad`` is a ``kipy.KiCad``; the selection is read from the open board.
+    """
+    board = board if board is not None else kicad.get_board()
+    try:
+        got = kicad.get_version()
+        version = str(getattr(got, "full_version", got))
+    except Exception:  # noqa: BLE001
+        version = ""
+    items = list(board.get_selection())
+    if not items:
+        raise SelectionError("select a footprint in the PCB editor first")
+    footprints: dict[str, Any] = {}
+    pads_by_parent: dict[str, list[dict[str, str]]] = {}
+    loose_pads: list[Any] = []
+    for item in items:
+        if hasattr(item, "reference_field"):
+            footprints[str(item.id.value)] = item
+        elif hasattr(item, "number") and hasattr(item, "net"):
+            parent = getattr(item, "parent", None)
+            row = {"number": str(item.number), "net": str(getattr(item.net, "name", "") or "")}
+            if parent is not None and getattr(parent, "value", ""):
+                pads_by_parent.setdefault(str(parent.value), []).append(row)
+            else:
+                loose_pads.append(row)
+    if pads_by_parent.keys() - footprints.keys():
+        for fp in board.get_footprints():  # a pad selected on its own: fetch its footprint
+            key = str(fp.id.value)
+            if key in pads_by_parent:
+                footprints.setdefault(key, fp)
+    if not footprints:
+        raise SelectionError("the selection has no footprint; select a part")
+    path = str(getattr(board, "name", "") or "")
+    project_dir = ""
+    try:
+        project_dir = str(board.get_project().path or "")
+    except Exception:  # noqa: BLE001 - older API builds
+        project_dir = ""
+    if not project_dir and path:
+        project_dir = _dirname(path)
+    out = []
+    for key, fp in footprints.items():
+        extra = {}
+        for item in getattr(fp, "texts_and_fields", []) or []:
+            name = getattr(item, "name", "")
+            text = getattr(getattr(item, "text", None), "value", "")
+            if name and text and name.lower() not in _KNOWN:
+                extra[str(name)] = str(text)
+        library = fp.definition.id
+        datasheet = getattr(getattr(fp.datasheet_field, "text", None), "value", "") or ""
+        out.append(
+            PartContext(
+                reference=str(fp.reference_field.text.value),
+                value=str(fp.value_field.text.value),
+                footprint=f"{library.library}:{library.name}" if library.name else "",
+                datasheet=str(datasheet),
+                description=str(getattr(getattr(fp.description_field, "text", None), "value", "")),
+                layer=_kipy_layer(fp.layer),
+                x_mm=fp.position.x / NM_PER_MM,
+                y_mm=fp.position.y / NM_PER_MM,
+                pad_count=len(fp.definition.pads),
+                selected_pads=pads_by_parent.get(key, []),
+                fields=extra,
+                board=path,
+                project_dir=project_dir,
+                source="kipy",
+                kicad_version=version,
+            )
+        )
+    return out

traceforge/kicad_plugin/discovery.py

@@ -0,0 +1,81 @@
+"""How a plugin finds the running Traceforge app: a small file the app writes at launch.
+
+``traceforge app`` publishes its local URL and session token to ``app.json`` in the Traceforge
+config folder (owner-only permissions) and removes it on exit. ``TRACEFORGE_APP_URL`` and
+``TRACEFORGE_APP_TOKEN`` override the file. Standard library only.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class Endpoint:
+    url: str
+    token: str
+    workspace: str = ""
+    pid: int = 0
+
+
+def config_dir() -> Path:
+    base = os.environ.get("XDG_CONFIG_HOME") or str(Path.home() / ".config")
+    return Path(base) / "traceforge"
+
+
+def endpoint_path() -> Path:
+    return config_dir() / "app.json"
+
+
+def publish(*, url: str, token: str, workspace: Path | str | None = None) -> Path | None:
+    """Write the endpoint file (never raises: a read-only home must not stop the app)."""
+    path = endpoint_path()
+    row = {
+        "url": url.rstrip("/"),
+        "token": token,
+        "workspace": str(workspace or ""),
+        "pid": os.getpid(),
+        "started": time.time(),
+    }
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_suffix(".tmp")
+        fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            json.dump(row, handle)
+        os.replace(tmp, path)
+        return path
+    except OSError:
+        return None
+
+
+def withdraw() -> None:
+    """Remove the endpoint file, but only if this process wrote it."""
+    path = endpoint_path()
+    try:
+        row = json.loads(path.read_text(encoding="utf-8"))
+        if row.get("pid") == os.getpid():
+            path.unlink()
+    except (OSError, ValueError):
+        pass
+
+
+def find() -> Endpoint | None:
+    """The environment's endpoint, else the published one, else None."""
+    url, token = os.environ.get("TRACEFORGE_APP_URL"), os.environ.get("TRACEFORGE_APP_TOKEN")
+    if url and token:
+        return Endpoint(url.rstrip("/"), token)
+    try:
+        row = json.loads(endpoint_path().read_text(encoding="utf-8"))
+        return Endpoint(
+            str(row["url"]).rstrip("/"),
+            str(row["token"]),
+            str(row.get("workspace") or ""),
+            int(row.get("pid") or 0),
+        )
+    except (OSError, ValueError, KeyError, TypeError):
+        return None

traceforge/kicad_plugin/install.py

@@ -0,0 +1,203 @@
+"""Install and remove the KiCad plugins in the user's plugin folders.
+
+KiCad 7 and 8 load action plugins (Python packages) from ``<data>/<version>/scripting/plugins``;
+KiCad 9 and 10 load IPC API plugins (a folder with ``plugin.json``) from ``<data>/<version>/plugins``.
+KiCad 9 still loads action plugins, so it gets both. The user data folder depends on the OS:
+
+* Linux: ``$XDG_DATA_HOME/kicad`` (``~/.local/share/kicad``), or the Flatpak's data folder
+* macOS: ``~/Documents/KiCad`` (the version is detected from ``~/Library/Preferences/kicad``)
+* Windows: ``%APPDATA%\\kicad`` for action plugins, ``Documents\\KiCad`` for IPC plugins
+
+The installed plugin copies the standard-library modules of this package next to it, because
+KiCad's Python does not have Traceforge installed. A marker file lets ``uninstall`` remove only
+what this command wrote.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import sys
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+
+from . import PLUGIN_VERSION
+
+HERE = Path(__file__).parent
+ACTION_PACKAGE = "traceforge_kicad"
+IPC_IDENTIFIER = "org.traceforge.kicad"
+MARKER = ".traceforge-plugin"
+CORE_MODULES = ("actions", "client", "context", "discovery", "overlay", "views")
+KNOWN_VERSIONS = ("7.0", "8.0", "9.0", "10.0")
+ACTION_VERSIONS = {7, 8, 9}  # SWIG action plugins are loaded by KiCad 7, 8 and 9
+IPC_VERSIONS = {9, 10}  # the IPC API exists from KiCad 9
+
+
+class PluginInstallError(RuntimeError):
+    pass
+
+
+@dataclass(frozen=True)
+class Target:
+    kind: str  # "action" | "ipc"
+    version: str  # "8.0"
+    folder: Path  # the plugins folder
+
+    @property
+    def path(self) -> Path:
+        return self.folder / (ACTION_PACKAGE if self.kind == "action" else IPC_IDENTIFIER)
+
+    def to_dict(self) -> dict[str, str]:
+        return {"kind": self.kind, "kicad": self.version, "path": str(self.path)}
+
+
+def _major(version: str) -> int:
+    return int(version.split(".")[0])
+
+
+def _norm_version(value: str) -> str:
+    match = re.fullmatch(r"(\d+)(?:\.(\d+))?", value.strip())
+    if not match:
+        raise PluginInstallError(f"not a KiCad version: {value!r} (use 8 or 8.0)")
+    return f"{match.group(1)}.{match.group(2) or '0'}"
+
+
+def version_roots(
+    platform: str | None = None,
+    home: Path | None = None,
+    env: Mapping[str, str] | None = None,
+) -> list[tuple[Path, Path, Path]]:
+    """``(config root, action-plugin root, ipc-plugin root)`` per candidate location.
+
+    A KiCad version counts as installed when ``<config root>/<version>`` exists.
+    """
+    platform = platform or sys.platform
+    home = home or Path.home()
+    env = os.environ if env is None else env
+    if platform == "win32":
+        appdata = Path(env.get("APPDATA") or home / "AppData" / "Roaming")
+        documents = Path(env.get("USERPROFILE") or home) / "Documents" / "KiCad"
+        return [(appdata / "kicad", appdata / "kicad", documents)]
+    if platform == "darwin":
+        documents = home / "Documents" / "KiCad"
+        return [(home / "Library" / "Preferences" / "kicad", documents, documents)]
+    data = Path(env.get("XDG_DATA_HOME") or home / ".local" / "share") / "kicad"
+    flatpak = home / ".var" / "app" / "org.kicad.KiCad" / "data" / "kicad"
+    return [(data, data, data), (flatpak, flatpak, flatpak)]
+
+
+def targets_for(version: str, root: tuple[Path, Path, Path]) -> list[Target]:
+    major = _major(version)
+    found = []
+    if major in ACTION_VERSIONS:
+        found.append(Target("action", version, root[1] / version / "scripting" / "plugins"))
+    if major in IPC_VERSIONS:
+        found.append(Target("ipc", version, root[2] / version / "plugins"))
+    return found
+
+
+def detect_targets(
+    version: str | None = None,
+    *,
+    platform: str | None = None,
+    home: Path | None = None,
+    env: Mapping[str, str] | None = None,
+) -> list[Target]:
+    """Plugin folders of every installed KiCad (or of ``version``, even if KiCad is not found)."""
+    roots = version_roots(platform, home, env)
+    if version:
+        wanted = _norm_version(version)
+        if _major(wanted) not in ACTION_VERSIONS | IPC_VERSIONS:
+            raise PluginInstallError(f"KiCad {wanted} has no plugin support here (7 to 10)")
+        # Prefer the location that already exists; else the first (the OS's normal one).
+        root = next((r for r in roots if (r[0] / wanted).is_dir()), roots[0])
+        return targets_for(wanted, root)
+    out: list[Target] = []
+    for root in roots:
+        for found in KNOWN_VERSIONS:
+            if (root[0] / found).is_dir():
+                out += targets_for(found, root)
+    if not out:
+        raise PluginInstallError(
+            "no KiCad user folder found; start KiCad once, or pass --kicad-version 8 "
+            "(or --dest <plugins folder> --type action|ipc)"
+        )
+    return out
+
+
+def custom_targets(dest: Path, kind: str) -> list[Target]:
+    if kind not in ("action", "ipc"):
+        raise PluginInstallError("with --dest, say --type action or --type ipc")
+    return [Target(kind, "custom", dest)]
+
+
+# ----------------------------------------------------------------------- payload files
+
+
+def _core_files() -> dict[str, str]:
+    return {f"{m}.py": (HERE / f"{m}.py").read_text(encoding="utf-8") for m in CORE_MODULES}
+
+
+def action_files() -> dict[str, str]:
+    files = _core_files()
+    files["__init__.py"] = (HERE / "payload" / "action_plugin.py").read_text(encoding="utf-8")
+    return files
+
+
+def ipc_files() -> dict[str, str]:
+    """Paths relative to the plugin folder."""
+    files = {f"{ACTION_PACKAGE}/{name}": text for name, text in _core_files().items()}
+    files[f"{ACTION_PACKAGE}/__init__.py"] = (
+        '"""Traceforge KiCad plugin modules (standard library only)."""\n'
+    )
+    for name, target in (
+        ("plugin.json", "plugin.json"),
+        ("requirements.txt", "requirements.txt"),
+        ("ipc_main.py", "main.py"),
+    ):
+        files[target] = (HERE / "payload" / name).read_text(encoding="utf-8")
+    return files
+
+
+def _owned(path: Path) -> bool:
+    return (path / MARKER).is_file()
+
+
+def install_one(target: Target, *, force: bool = False) -> Path:
+    path = target.path
+    if path.exists():
+        if not _owned(path) and not force:
+            raise PluginInstallError(
+                f"{path} exists and was not installed by traceforge; use --force to replace it"
+            )
+        shutil.rmtree(path)
+    files = action_files() if target.kind == "action" else ipc_files()
+    for name, text in files.items():
+        out = path / name
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(text, encoding="utf-8", newline="\n")
+    (path / MARKER).write_text(
+        json.dumps({"version": PLUGIN_VERSION, "kind": target.kind}), encoding="utf-8"
+    )
+    return path
+
+
+def uninstall_one(target: Target) -> bool:
+    """Remove the plugin; False when it was not installed. Refuses folders it did not write."""
+    path = target.path
+    if not path.exists():
+        return False
+    if not _owned(path):
+        raise PluginInstallError(f"{path} was not installed by traceforge; not removing it")
+    shutil.rmtree(path)
+    return True
+
+
+def status(targets: list[Target]) -> list[dict[str, object]]:
+    rows = []
+    for t in targets:
+        rows.append({**t.to_dict(), "installed": t.path.exists(), "ours": _owned(t.path)})
+    return rows

traceforge/kicad_plugin/overlay.py

@@ -0,0 +1,60 @@
+"""The chat overlay's logic, without a toolkit: the plugins' dialogs are thin views over this.
+
+An :class:`Overlay` holds the selected parts and the conversation shown in the dialog. Each
+action or question goes to the app's chat tab, so the answer also appears in the app window and
+the thread continues there. Standard library only.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from . import actions
+from .client import Answer, AppClient, PluginError
+from .context import PartContext
+
+
+@dataclass
+class Turn:
+    role: str  # "you" | "traceforge" | "error"
+    text: str
+
+
+@dataclass
+class Overlay:
+    parts: list[PartContext]
+    client: AppClient = field(default_factory=AppClient)
+    index: int = 0
+    turns: list[Turn] = field(default_factory=list)
+
+    @property
+    def part(self) -> PartContext | None:
+        return self.parts[self.index] if self.parts else None
+
+    def titles(self) -> list[str]:
+        return [f"{p.reference}  {p.value}".strip() for p in self.parts]
+
+    def run(self, action_id: str, question: str = "") -> Answer:
+        """Ask the app; the turn list records what was shown. Never raises for app errors."""
+        part = self.part
+        try:
+            prompt = actions.build_prompt(action_id, part, question)
+        except actions.ActionError as exc:
+            self.turns.append(Turn("error", str(exc)))
+            return Answer("", error=str(exc))
+        label = actions.get(action_id).label
+        self.turns.append(Turn("you", f"{label}: {question}" if question.strip() else label))
+        try:
+            answer = self.client.ask(prompt, project=part.project_dir if part else "")
+        except PluginError as exc:
+            self.turns.append(Turn("error", str(exc)))
+            return Answer("", error=str(exc))
+        if answer.error:
+            self.turns.append(Turn("error", answer.error))
+        else:
+            self.turns.append(Turn("traceforge", answer.text or "(no answer)"))
+        return answer
+
+    def transcript(self) -> str:
+        labels = {"you": "You", "traceforge": "Traceforge", "error": "Error"}
+        return "\n\n".join(f"{labels[t.role]}: {t.text}" for t in self.turns)

traceforge/kicad_plugin/payload/action_plugin.py

@@ -0,0 +1,65 @@
+"""Traceforge action plugins for KiCad 7 and 8 (Tools > External Plugins).
+
+Installed as ``traceforge_kicad/__init__.py`` by ``traceforge kicad-plugin install``. Each action
+reads the selected footprint from the PCB editor, asks the running Traceforge app (start it with
+``traceforge app <project folder>``) and shows the answer in a dialog with a chat box. KiCad
+imports this file inside its own Python; only the standard library is needed besides ``pcbnew``.
+"""
+
+from __future__ import annotations
+
+import pcbnew
+
+from . import actions, context, views
+from .overlay import Overlay
+
+CATEGORY = "Traceforge"
+
+
+def run_action(action_id: str, view: object = None, board: object = None) -> str:
+    """Read the selection, open the overlay, return the conversation text."""
+    try:
+        parts = context.read_pcbnew_selection(pcbnew, board)
+    except context.SelectionError as exc:
+        return _notify(str(exc))
+    overlay = Overlay(parts)
+    return (view or views.choose_view("wx")).show(overlay, action_id)
+
+
+def _notify(message: str) -> str:
+    try:
+        import wx
+
+        wx.MessageBox(message, "Traceforge")
+    except Exception:  # noqa: BLE001 - no GUI toolkit: the text is returned to the caller
+        pass
+    return message
+
+
+def _make(action: actions.Action) -> type:
+    class _Plugin(pcbnew.ActionPlugin):
+        action_id = action.id
+
+        def defaults(self) -> None:
+            self.name = f"Traceforge: {action.label}"
+            self.category = CATEGORY
+            self.description = f"{action.label} for the selected part, answered by Traceforge"
+            self.show_toolbar_button = False
+
+        def Run(self) -> None:  # noqa: N802 - KiCad's name
+            run_action(self.action_id)
+
+    _Plugin.__name__ = f"Traceforge_{action.id}"
+    return _Plugin
+
+
+PLUGINS = [_make(a) for a in actions.ACTIONS]
+
+
+def register_all() -> None:
+    for cls in PLUGINS:
+        cls().register()
+
+
+register_all()
+__all__ = ["PLUGINS", "register_all", "run_action"]