code-constraints 0.1.0__py3-none-any.whl

code_constraints/core/keys.py

@@ -0,0 +1,105 @@
+"""Stable, human-quotable identifiers for a reported issue.
+
+Every issue that any of the three engines reports carries a *key*: a short
+token like ``V-1A2B3C4D`` that identifies the issue and nothing else. The key is
+what makes the review workflow work — a human (or an agent) can read a report,
+mark a line, and say "allow this one" without describing the violation again.
+
+Two properties matter, and they drive the whole design:
+
+  * **Stable across runs.** Re-running a check over an unchanged tree must
+    produce identical keys, so a review file stays valid and an agent can round-
+    trip report → decision → `cdec baseline allow`.
+  * **Stable across unrelated edits.** The key is derived from the *identity* of
+    the issue (engine, rule, qualified name, discriminating detail) and never
+    from a file offset or line number. Inserting an import above a class must
+    not invalidate a waiver granted for that class.
+
+The flip side of the second property is deliberate: a key names an *equivalence
+class* of issues, not a physical line. Two identical violations of one rule on
+one element share a key, and waiving it waives both. That is the intended
+semantic — the reviewer is accepting a fact about the code, not a coordinate.
+
+The prefix letter records which *engine* produced the issue, so a key alone is
+enough to route it. Every engine now runs under the single `cdec check` command,
+but the prefixes are unchanged — they name the engine, not the command, which is
+what keeps a waiver written before the CLI was unified still valid after it:
+
+    V-  configured architectural rules  (Engine A — drift)
+    F-  source-tag conformance          (Engine B — implementation obeys its tags)
+    L-  implementation locks            (Engine C — frozen body changed)
+    R-  reference-architecture gate     (structural deviation from reference.xmi)
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+
+# Engine name -> key prefix letter. Engine names are internal identities that
+# outlive CLI command names, so a recorded waiver survives a CLI reshuffle.
+ENGINE_PREFIX: dict[str, str] = {
+    "check": "V",
+    "enforce": "F",
+    "lock": "L",
+    "reference": "R",
+}
+PREFIX_ENGINE: dict[str, str] = {v: k for k, v in ENGINE_PREFIX.items()}
+
+# 8 hex chars = 32 bits. At a thousand issues in one report the odds of any
+# collision are ~1 in 8500, and a collision only ever merges two issues of the
+# same engine into one waiver — annoying, never unsound.
+_KEY_HEX_LEN = 8
+
+KEY_RE = re.compile(r"\b([VFLR])-([0-9A-F]{%d})\b" % _KEY_HEX_LEN)
+
+
+class UnknownEngine(ValueError):
+    pass
+
+
+def make_key(engine: str, rule: str, qualified_name: str, detail: str = "") -> str:
+    """Compute the stable key for one issue.
+
+    `detail` is the per-engine discriminator that separates two issues of the
+    same rule on the same element — the `signature` for a lint violation, an
+    explicit detail string for a conformance finding. Pass "" when the rule can
+    only fire once per element.
+    """
+    prefix = ENGINE_PREFIX.get(engine)
+    if prefix is None:
+        raise UnknownEngine(f"unknown engine: {engine!r}")
+    raw = "|".join((engine, rule, qualified_name, detail or ""))
+    digest = hashlib.sha256(raw.encode("utf-8")).hexdigest()[:_KEY_HEX_LEN]
+    return f"{prefix}-{digest.upper()}"
+
+
+def engine_of(key: str) -> str | None:
+    """The engine that produced `key`, or None if it isn't a well-formed key."""
+    match = KEY_RE.fullmatch(key.strip())
+    if match is None:
+        return None
+    return PREFIX_ENGINE.get(match.group(1))
+
+
+def is_key(text: str) -> bool:
+    return KEY_RE.fullmatch(text.strip()) is not None
+
+
+def find_keys(text: str) -> list[str]:
+    """Every key appearing in `text`, in order, de-duplicated."""
+    seen: list[str] = []
+    for match in KEY_RE.finditer(text):
+        key = match.group(0)
+        if key not in seen:
+            seen.append(key)
+    return seen
+
+
+def normalize_key(text: str) -> str:
+    """Accept a key the way a human might retype it (lowercase hex, missing
+    hyphen) and return the canonical form. Returns "" if it isn't a key."""
+    candidate = text.strip().upper().replace(" ", "")
+    if candidate and "-" not in candidate and len(candidate) == _KEY_HEX_LEN + 1:
+        candidate = f"{candidate[0]}-{candidate[1:]}"
+    return candidate if is_key(candidate) else ""

code_constraints/core/model.py

@@ -0,0 +1,294 @@
+"""Language-agnostic UML data model.
+
+All parsers (Python AST, C# tree-sitter) produce a `Project`; all consumers
+(XMI writer, DOT emitter, diff engine) operate on `Project`.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from hashlib import sha1
+from typing import Iterator, Literal, get_args
+
+
+class DiffStatus(str, Enum):
+    UNCHANGED = "unchanged"
+    ADDED = "added"
+    REMOVED = "removed"
+    CHANGED = "changed"
+
+
+class Visibility(str, Enum):
+    PUBLIC = "public"
+    PROTECTED = "protected"
+    PRIVATE = "private"
+    PACKAGE = "package"
+
+
+ClassKind = Literal["class", "interface", "abstract", "enum", "struct", "record", "static"]
+ActivityNodeKind = Literal[
+    "initial", "final", "action", "decision", "merge", "fork", "join"
+]
+
+
+@dataclass
+class SourceLocation:
+    file: str
+    start_line: int
+    end_line: int
+
+
+@dataclass
+class Layout:
+    """Optional persisted canvas layout for an element. `None` means the
+    renderer should auto-place the element. Coordinates are in canvas units
+    (pixels) with origin at top-left."""
+    x: float = 0.0
+    y: float = 0.0
+    width: float = 0.0
+    height: float = 0.0
+    collapsed: bool = False
+
+
+@dataclass
+class EdgeLayout:
+    """Per-edge layout: a list of waypoints the edge routes through, in canvas
+    units. Empty means the renderer routes the edge itself."""
+    waypoints: list[tuple[float, float]] = field(default_factory=list)
+
+
+@dataclass
+class RuleAnnotation:
+    """An architectural-rule tag attached to a Class or Operation.
+
+    `name` is the canonical catalog id (e.g. "no-instantiation"). `args` and
+    `kwargs` hold the decorator/attribute argument *source text* so the value
+    round-trips verbatim and dataclass equality gives exact diff comparison."""
+    name: str
+    args: list[str] = field(default_factory=list)
+    kwargs: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+class Parameter:
+    name: str
+    type: str = ""
+    default: str | None = None
+
+    def signature(self) -> str:
+        return f"{self.name}:{self.type}"
+
+
+@dataclass
+class Attribute:
+    name: str
+    type: str = ""
+    visibility: Visibility = Visibility.PUBLIC
+    is_static: bool = False
+    is_readonly: bool = False
+    default: str | None = None
+    description: str | None = None
+    status: DiffStatus = DiffStatus.UNCHANGED
+
+    def signature(self) -> str:
+        return f"{self.name}:{self.type}"
+
+
+@dataclass
+class Operation:
+    name: str
+    parameters: list[Parameter] = field(default_factory=list)
+    return_type: str = ""
+    visibility: Visibility = Visibility.PUBLIC
+    is_static: bool = False
+    is_abstract: bool = False
+    description: str | None = None
+    rules: list[RuleAnnotation] = field(default_factory=list)
+    status: DiffStatus = DiffStatus.UNCHANGED
+
+    def signature(self) -> str:
+        params = ",".join(p.signature() for p in self.parameters)
+        return f"{self.name}({params}):{self.return_type}"
+
+
+@dataclass
+class Class:
+    name: str
+    qualified_name: str
+    kind: ClassKind = "class"
+    attributes: list[Attribute] = field(default_factory=list)
+    operations: list[Operation] = field(default_factory=list)
+    bases: list[str] = field(default_factory=list)
+    location: SourceLocation | None = None
+    layout: Layout | None = None
+    description: str | None = None
+    rules: list[RuleAnnotation] = field(default_factory=list)
+    status: DiffStatus = DiffStatus.UNCHANGED
+    # Raw type-name strings referenced inside method bodies (no type
+    # resolution). Consumers resolve these via `associations.resolve_association`
+    # to draw "uses" edges and count incoming references. Empty for pre-existing
+    # XMI and for parsers that don't scan bodies.
+    dependencies: list[str] = field(default_factory=list)
+
+    def stable_id(self) -> str:
+        return _stable_id("Class", self.qualified_name)
+
+
+@dataclass
+class Package:
+    name: str
+    qualified_name: str
+    classes: list[Class] = field(default_factory=list)
+    sub_packages: list[Package] = field(default_factory=list)
+    layout: Layout | None = None
+    description: str | None = None
+    status: DiffStatus = DiffStatus.UNCHANGED
+
+    def stable_id(self) -> str:
+        return _stable_id("Package", self.qualified_name)
+
+
+@dataclass
+class ActivityNode:
+    id: str
+    kind: ActivityNodeKind
+    label: str = ""
+    layout: Layout | None = None
+    status: DiffStatus = DiffStatus.UNCHANGED
+
+
+@dataclass
+class ActivityEdge:
+    source: str
+    target: str
+    guard: str = ""
+    edge_layout: EdgeLayout | None = None
+    status: DiffStatus = DiffStatus.UNCHANGED
+
+
+@dataclass
+class Activity:
+    name: str
+    nodes: list[ActivityNode] = field(default_factory=list)
+    edges: list[ActivityEdge] = field(default_factory=list)
+    location: SourceLocation | None = None
+    granularity: Literal["control-flow", "statement", "calls"] = "control-flow"
+    status: DiffStatus = DiffStatus.UNCHANGED
+
+    def stable_id(self) -> str:
+        return _stable_id("Activity", self.name)
+
+
+@dataclass
+class Lifeline:
+    name: str
+    represents: str = ""  # type name the lifeline represents
+    column_x: float | None = None  # canvas-units; None = auto-layout
+    status: DiffStatus = DiffStatus.UNCHANGED
+
+
+@dataclass
+class Message:
+    sender: str  # lifeline name
+    receiver: str
+    label: str
+    is_return: bool = False
+    # Optional guard condition, e.g. "result == 'ok'" — set by the parser when
+    # the call sits inside an `if` branch so the renderer can prefix the
+    # message label with `[guard]` (UML combined-fragment shorthand).
+    guard: str = ""
+    status: DiffStatus = DiffStatus.UNCHANGED
+
+
+@dataclass
+class Fragment:
+    """A UML combined fragment covering a contiguous range of message rows.
+
+    `start_row` and `end_row` are inclusive indices into `Sequence.messages`.
+    `kind` mirrors the standard UML operators ("alt", "opt", "loop"); the
+    parsers currently emit "alt" per if-branch (one for the if, one for the
+    else if present) and reserve "opt" / "loop" for future extensions.
+    `label` is the guard / interaction-operator argument text — e.g. the
+    `if` condition for an alt fragment.
+    """
+    kind: Literal["alt", "opt", "loop"]
+    label: str
+    start_row: int
+    end_row: int
+    status: DiffStatus = DiffStatus.UNCHANGED
+
+
+@dataclass
+class Sequence:
+    name: str
+    lifelines: list[Lifeline] = field(default_factory=list)
+    messages: list[Message] = field(default_factory=list)
+    fragments: list[Fragment] = field(default_factory=list)
+    location: SourceLocation | None = None
+    status: DiffStatus = DiffStatus.UNCHANGED
+
+    def stable_id(self) -> str:
+        return _stable_id("Sequence", self.name)
+
+
+@dataclass
+class Association:
+    """Explicit association between two classes (by qualified name).
+
+    Parsers do not produce these — attribute-typed references already cover the
+    code-derived case via `resolve_association`. The editor uses Association to
+    let users draw "bare" relationships that don't correspond to any field.
+    """
+    source: str
+    target: str
+    name: str | None = None
+    source_multiplicity: str | None = None
+    target_multiplicity: str | None = None
+    source_role: str | None = None
+    target_role: str | None = None
+    status: DiffStatus = DiffStatus.UNCHANGED
+
+
+SourceLanguage = Literal[
+    "python", "csharp", "typescript", "svelte", "odin", "lua", "julia"
+]
+
+# The single source of truth for "which languages does this build support".
+# Derived from the type so the runtime check and the type check can never
+# disagree; every dispatch site validates against this rather than repeating
+# the tuple. Note that support is layered — a language always has a UML parser
+# here, but `cdec enforce` and `cdec lock` additionally need a conformance
+# analyzer and an AST fingerprinter (TypeScript and Svelte have neither yet, and
+# say so when asked).
+SUPPORTED_LANGUAGES: tuple[str, ...] = get_args(SourceLanguage)
+
+
+@dataclass
+class Project:
+    source_language: SourceLanguage
+    packages: list[Package] = field(default_factory=list)
+    activities: list[Activity] = field(default_factory=list)
+    sequences: list[Sequence] = field(default_factory=list)
+    associations: list[Association] = field(default_factory=list)
+    root_path: str = ""
+
+    def iter_classes(self) -> Iterator[Class]:
+        for pkg in _walk_packages(self.packages):
+            yield from pkg.classes
+
+
+def _walk_packages(packages: list[Package]) -> Iterator[Package]:
+    for pkg in packages:
+        yield pkg
+        yield from _walk_packages(pkg.sub_packages)
+
+
+def _stable_id(kind: str, qualified_name: str) -> str:
+    """Deterministic ID for cross-revision matching.
+
+    sha1 is used purely as a hash (no security implications); the prefix keeps
+    IDs readable in the XMI.
+    """
+    h = sha1(f"{kind}|{qualified_name}".encode("utf-8")).hexdigest()[:16]
+    return f"{kind.lower()}-{h}"

code_constraints/core/model_io.py

@@ -0,0 +1,65 @@
+"""Extension-dispatched model persistence.
+
+The on-disk source of truth stays XMI 2.1, but a `Project` can equally be
+stored as the editor-bridge JSON shape (`editor_io.project_to_json`) under a
+`.json` extension. JSON is far easier for humans and AI agents to author and
+review than XMI, so every CLI command that reads or writes a model file goes
+through `load_model` / `save_model` instead of calling the XMI codec directly.
+
+The JSON document is exactly the wire format the web editor uses — one schema,
+three consumers (CLI files, editor drafts, proposal endpoint).
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from code_constraints.core.editor_io import project_from_json, project_to_json
+from code_constraints.core.model import Project
+from code_constraints.core.xmi_reader import read_project
+from code_constraints.core.xmi_writer import write_project
+
+MODEL_SUFFIXES = (".xmi", ".json")
+
+
+class UnsupportedModelFormat(ValueError):
+    pass
+
+
+def _codec(path: Path) -> str:
+    suffix = path.suffix.lower()
+    if suffix not in MODEL_SUFFIXES:
+        raise UnsupportedModelFormat(
+            f"unsupported model file extension {suffix!r} for {path} "
+            f"(expected one of: {', '.join(MODEL_SUFFIXES)})"
+        )
+    return suffix
+
+
+def load_model(path: Path | str) -> Project:
+    """Read a Project from `.xmi` (XMI 2.1) or `.json` (editor JSON)."""
+    path = Path(path)
+    if _codec(path) == ".json":
+        with path.open(encoding="utf-8") as fh:
+            data = json.load(fh)
+        if not isinstance(data, dict):
+            raise ValueError(f"{path}: top-level JSON value must be an object")
+        return project_from_json(data)
+    return read_project(path)
+
+
+def save_model(project: Project, path: Path | str) -> None:
+    """Write a Project to `.xmi` or `.json`, chosen by the file extension."""
+    path = Path(path)
+    if _codec(path) == ".json":
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(
+            json.dumps(project_to_json(project), indent=2, sort_keys=False) + "\n",
+            encoding="utf-8",
+        )
+        return
+    write_project(project, path)
+
+
+__all__ = ["load_model", "save_model", "MODEL_SUFFIXES", "UnsupportedModelFormat"]

code_constraints/core/receivers.py

@@ -0,0 +1,34 @@
+"""Receiver resolution for languages that declare operations outside their type.
+
+Odin (`proc(inv: ^Invoice, …)`) and Julia (`f(inv::Invoice, …)`) both model an
+operation's owner as the type of its first parameter. Three consumers need that
+answer to agree exactly — the UML parser, the `cdec lock` fingerprinter, and the
+`cdec enforce` analyzer — because a target name an agent reads from one has to be
+the target the others accept. The lookup *policy* lives here so there is one
+definition of it rather than three.
+"""
+
+from __future__ import annotations
+
+from typing import TypeVar
+
+T = TypeVar("T")
+
+
+def resolve_owner(
+    name: str, package_qn: str, index: dict[tuple[str, str], T]
+) -> T | None:
+    """Find the type `name` refers to from within `package_qn`.
+
+    Same package first — the normal case, and the only one a compiler would
+    resolve without imports. Falling back to a project-wide match by bare name
+    is the best a syntactic parse can do; it is deliberately skipped when the
+    name is ambiguous, so a wrong owner is never guessed.
+    """
+    if not name:
+        return None
+    same_package = index.get((package_qn, name))
+    if same_package is not None:
+        return same_package
+    matches = [value for (_pkg, other), value in index.items() if other == name]
+    return matches[0] if len(matches) == 1 else None

code_constraints/core/rules.py

@@ -0,0 +1,177 @@
+"""Canonical catalog of architectural-rule tags.
+
+Single source of truth shared by the parsers (recognition), the web app
+(presentation), and both enforcement engines (`cdec check` drift rules and the
+`cdec enforce` conformance command). Add a rule here once; every other module
+looks it up by id / python name / csharp name rather than hard-coding strings.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+Target = Literal["class", "operation"]
+Enforcement = Literal["drift", "architectural", "implementation", "lock"]
+
+
+@dataclass(frozen=True)
+class RuleSpec:
+    id: str  # canonical kebab-case id, e.g. "no-instantiation"
+    python_name: str  # decorator name as imported from the shim, e.g. "no_instantiation"
+    csharp_name: str  # attribute name without the "Attribute" suffix, e.g. "NoInstantiation"
+    targets: frozenset[Target]
+    params: tuple[str, ...] = ()  # recognised keyword parameter names
+    enforcement: Enforcement = "drift"
+    summary: str = ""
+    # Julia macro name without the leading `@`, e.g. "no_instantiation".
+    julia_name: str = ""
+    # Name used in the `---@cdec <name>(...)` / `//@cdec <name>(...)` annotation
+    # comments that carry tags in Lua and Odin (neither language has a
+    # user-extensible decorator/attribute syntax — see the annotation note below).
+    annotation_name: str = ""
+
+    def __post_init__(self) -> None:
+        # The Julia macro and the Lua/Odin annotation keyword both default to the
+        # Python decorator name; every language then spells one vocabulary.
+        if not self.julia_name:
+            object.__setattr__(self, "julia_name", self.python_name)
+        if not self.annotation_name:
+            object.__setattr__(self, "annotation_name", self.python_name)
+
+
+_SPECS: tuple[RuleSpec, ...] = (
+    RuleSpec(
+        id="no-instantiation",
+        python_name="no_instantiation",
+        csharp_name="NoInstantiation",
+        targets=frozenset({"class", "operation"}),
+        params=("allow",),
+        enforcement="implementation",
+        summary="May not construct objects (except types listed in `allow`).",
+    ),
+    RuleSpec(
+        id="no-side-effects",
+        python_name="no_side_effects",
+        csharp_name="NoSideEffects",
+        targets=frozenset({"operation"}),
+        params=("allow",),
+        enforcement="drift",
+        summary="Must be free of side effects (body analysis deferred; tag is captured + frozen).",
+    ),
+    RuleSpec(
+        id="sealed",
+        python_name="sealed",
+        csharp_name="Sealed",
+        targets=frozenset({"class"}),
+        enforcement="implementation",
+        summary="May not be subclassed (composition over inheritance).",
+    ),
+    RuleSpec(
+        id="immutable",
+        python_name="immutable",
+        csharp_name="Immutable",
+        targets=frozenset({"class"}),
+        enforcement="implementation",
+        summary="Fields may not be reassigned after construction.",
+    ),
+    RuleSpec(
+        id="factory",
+        python_name="factory",
+        csharp_name="Factory",
+        targets=frozenset({"class", "operation"}),
+        params=("creates",),
+        enforcement="implementation",
+        summary="Designated constructor of the types in `creates`; instantiation elsewhere is forbidden.",
+    ),
+    RuleSpec(
+        id="locked",
+        python_name="locked",
+        csharp_name="Locked",
+        targets=frozenset({"class", "operation"}),
+        params=("reason", "owner"),
+        enforcement="lock",
+        summary=(
+            "Implementation is frozen: any semantic change to the body fails "
+            "`cdec lock check` until a lead re-baselines it."
+        ),
+    ),
+    RuleSpec(
+        id="layer",
+        python_name="layer",
+        csharp_name="Layer",
+        targets=frozenset({"class"}),
+        params=("name",),
+        enforcement="architectural",
+        summary="Assigns the class to an architectural layer for dependency-direction checks.",
+    ),
+)
+
+RULE_CATALOG: dict[str, RuleSpec] = {spec.id: spec for spec in _SPECS}
+_BY_PYTHON: dict[str, RuleSpec] = {spec.python_name: spec for spec in _SPECS}
+_BY_CSHARP: dict[str, RuleSpec] = {spec.csharp_name: spec for spec in _SPECS}
+_BY_JULIA: dict[str, RuleSpec] = {spec.julia_name: spec for spec in _SPECS}
+_BY_ANNOTATION: dict[str, RuleSpec] = {spec.annotation_name: spec for spec in _SPECS}
+
+
+def by_id(rule_id: str) -> RuleSpec | None:
+    return RULE_CATALOG.get(rule_id)
+
+
+def by_python_name(name: str) -> RuleSpec | None:
+    return _BY_PYTHON.get(name)
+
+
+def by_csharp_name(name: str) -> RuleSpec | None:
+    """Look up by attribute name, tolerating the optional `Attribute` suffix."""
+    spec = _BY_CSHARP.get(name)
+    if spec is None and name.endswith("Attribute"):
+        spec = _BY_CSHARP.get(name[: -len("Attribute")])
+    return spec
+
+
+def by_julia_name(name: str) -> RuleSpec | None:
+    """Look up by Julia macro name, with or without the leading `@`."""
+    return _BY_JULIA.get(name.lstrip("@"))
+
+
+def by_annotation_name(name: str) -> RuleSpec | None:
+    """Look up by the keyword used in a `@cdec` annotation comment (Lua, Odin)."""
+    return _BY_ANNOTATION.get(name)
+
+
+# Module names the Python shim is published under; the parser only treats a
+# decorator as a rule when its base name was imported from one of these.
+PYTHON_SHIM_MODULES: frozenset[str] = frozenset({"cdec_rules", "code_constraints.rules"})
+# `using` namespace that gates C# attribute recognition.
+CSHARP_SHIM_NAMESPACE = "CodeConstraints.Rules"
+# Julia module the macro shim is published as; a `@macro` counts as a rule only
+# when the file brings this module into scope (`using`/`import CdecRules`).
+JULIA_SHIM_MODULES: frozenset[str] = frozenset({"CdecRules"})
+
+# Lua and Odin have no user-extensible decorator or attribute syntax — Lua has
+# no declaration modifiers at all, and the Odin compiler rejects any `@(...)`
+# attribute it doesn't know, so a no-op `@(cdec_sealed)` would fail to build.
+# Both therefore carry tags in a namespaced *annotation comment* placed directly
+# above the declaration, in the slot a decorator would occupy:
+#
+#     ---@cdec sealed                 -- Lua  (LuaCATS-style `---@` comment)
+#     ---@cdec layer("domain")
+#     local Invoice = {}
+#
+#     //@cdec sealed                  // Odin
+#     //@cdec layer("domain")
+#     Invoice :: struct { ... }
+#
+# The `@cdec` prefix is the namespace, so it plays the gating role that the shim
+# import plays in Python/C#/Julia: an unrelated annotation can never false-match.
+ANNOTATION_MARKER = "@cdec"
+
+# Shim files copied into a target project by `cdec init`. They declare the tag
+# vocabulary as no-op functions, which would otherwise parse as a module of
+# operations and show up as a class in the user's own diagrams. Parsers skip
+# them by name. (Python and C# need no entry: their shims declare only
+# functions / attribute classes that never reach the model.)
+SHIM_FILENAMES: frozenset[str] = frozenset(
+    {"cdec_rules.lua", "cdec_rules.odin", "CdecRules.jl"}
+)