@h2loop/autosar 1.5.3 → 1.6.0

package/python/ecuc_engine/arxml_edit.py

@@ -31,6 +31,10 @@ from .model import Project
 from .xmltree import Node, escape, escape_attr, line_indent, parse
 
 
+_PRED = re.compile(r"""^([A-Za-z][\w-]*)\[\s*(?:@?[\w-]*\s*=\s*)?['"]?([^'"\]]*)['"]?\s*\]$""")
+_SHORT = re.compile(r"[A-Za-z][A-Za-z0-9_]*\Z")
+
+
 class ArxmlEditError(Exception):
     pass
 
@@ -102,6 +106,10 @@ class ArxmlEditor:
         self.added_tags: dict = {}  # path -> tag of elements added in this call
         self.created_packages: list = []
         self.new_files: list = []
+        self.notes: list = []
+        self._tags: Optional[set] = None
+        self._typed: Optional[str] = None
+        self._idtags: set = set()
 
     # ---------- files / lookup ----------
     def tree_for(self, path: str) -> tuple:
@@ -144,15 +152,144 @@ class ArxmlEditor:
         raise ArxmlEditError("a new top-level package needs \"file\" (which ARXML file to put it in); one of: "
                              + ", ".join(self.p.rel(c) for c in cands[:20]))
 
+    # ---------- path dialects ----------
+    # Agents write XML/XPath-style paths ("/AR-PACKAGE/AR-PACKAGE[2]/APPLICATION-SW-COMPONENT-TYPE[SHORT-NAME='X']/
+    # PORTS", "/PT/Swc/TqLim/PORTS", ".../I-SIGNAL-TO-I-PDU-MAPPING/m/TRANSFER-PROPERTY"). 124 arxml_edit errors in 30
+    # held-out Qwen runs were mostly these. An AUTOSAR path is SHORT-NAMEs only: tag segments are dropped, a
+    # [SHORT-NAME='x'] predicate gives x, and a trailing collection tag is kept as the collection to add into.
+    def known_tags(self) -> set:
+        if self._tags is None:
+            tags = {"AUTOSAR", "ELEMENT"}
+            for f in self.p.sources.input + self.p.sources.config:
+                try:
+                    ft = self.load(f)
+                except Exception:  # noqa: BLE001
+                    continue
+                for n in ft.root.iter():
+                    tags.add(n.tag.upper())
+                    if n.short_name is not None:
+                        self._idtags.add(n.tag.upper())
+            self._tags = tags
+        return self._tags
+
+    def normalize(self, raw: str) -> tuple:
+        """(SHORT-NAME path, trailing collection tag or None, changed?) for an XML/XPath-style path."""
+        out, trailing, changed = [], None, False
+        self._typed = None
+        tags = self.known_tags()
+        for seg in [x for x in raw.strip().strip("/").split("/") if x]:
+            m = _PRED.match(seg)
+            if m:
+                inner = m.group(2).strip()
+                changed = True
+                if not inner or inner.isdigit():
+                    raise ArxmlEditError(f"path segment {seg!r} selects by position; name the element by its SHORT-NAME "
+                                         "instead (e.g. /PT/Swc/CruiseCtl)")
+                out.append(inner)
+                trailing = None
+                continue
+            if seg.upper() in tags or "-" in seg:
+                changed = True
+                if seg.upper() in self._idtags:     # an element type (APPLICATION-SW-COMPONENT-TYPE): not a collection
+                    self._typed, trailing = seg.upper(), None
+                else:                               # a collection (PORTS) or wrapper: add into it, if it fits
+                    trailing = seg.upper() if (out or self._typed) else None
+                continue
+            out.append(seg)
+            trailing = None
+        return "/" + "/".join(out), trailing, changed
+
+    def suggest(self, path: str, k: int = 5) -> list:
+        names = [x for x in path.strip("/").split("/") if x and _SHORT.match(x)]
+        if not names:
+            return []
+        known = set(self.p.identifiables) | {q for ft in self.files.values() for q in ft.by_path}
+        last = names[-1]
+        hits = [q for q in known if q.rsplit("/", 1)[-1] == last] or \
+               [q for q in known if q.rsplit("/", 1)[-1].lower() == last.lower()]
+        hits.sort(key=lambda q: (-sum(n in q.split("/") for n in names), len(q)))
+        return hits[:k]
+
+    def not_found(self, raw: str, norm: Optional[str]) -> str:
+        msg = f"no ARXML element at {raw}"
+        if norm and norm != raw:
+            msg += f" (read as {norm}, which does not exist either)"
+        msg += (". An AUTOSAR path is the SHORT-NAMEs joined by '/', e.g. /PT/Swc/TqLim: no XML tags (AR-PACKAGE, "
+                "ELEMENTS, PORTS, APPLICATION-SW-COMPONENT-TYPE), no [SHORT-NAME='x'] predicates.")
+        sugg = self.suggest(norm or raw)
+        if sugg:
+            msg += " Did you mean: " + ", ".join(sugg)
+        return msg
+
+    def by_type(self, tag: str, file: Optional[str]) -> list:
+        trees = []
+        if file:
+            f = os.path.normpath(os.path.join(self.p.root, file))
+            for cand in self.p.sources.input + self.p.sources.config + list(self.files):
+                if os.path.realpath(cand) == os.path.realpath(f):
+                    trees = [self.load(cand)]
+                    break
+        else:
+            trees = [self.load(f) for f in self.p.sources.input]
+        return sorted({q for ft in trees for q, n in ft.by_path.items() if n.tag == tag})
+
+    def resolve(self, raw: str, what: str, file: Optional[str] = None) -> tuple:
+        """(FileTree, node, SHORT-NAME path, collection hint) for a path in any of the dialects above."""
+        p = raw.rstrip("/")
+        try:
+            ft, node = self.tree_for(p)
+            return ft, node, p, None
+        except ArxmlEditError:
+            pass
+        norm, trailing, changed = self.normalize(p)
+        if changed and norm != "/":
+            try:
+                ft, node = self.tree_for(norm)
+                self.notes.append(f"{what} {raw!r} read as {norm!r}" + (f" (collection {trailing})" if trailing else ""))
+                return ft, node, norm, trailing
+            except ArxmlEditError:
+                pass
+        # only tags ("/AR-PACKAGES/AR-PACKAGE/ELEMENTS/APPLICATION-SW-COMPONENT-TYPE/PORTS"): the one element of that type
+        if changed and norm == "/" and self._typed:
+            hits = self.by_type(self._typed, file)
+            if len(hits) == 1:
+                ft, node = self.tree_for(hits[0])
+                self.notes.append(f"{what} {raw!r} read as {hits[0]!r} (the only {self._typed}"
+                                  + (f" in {file}" if file else "") + ")" + (f" (collection {trailing})" if trailing else ""))
+                return ft, node, hits[0], trailing
+            if hits:
+                raise ArxmlEditError(f"{raw} names no element, and there are several {self._typed}: {', '.join(hits[:8])}; "
+                                     "give the SHORT-NAME path of the one you mean")
+        # package names left out ("/ExtLightCtrl/PpLightStatus"): accept the one element whose path ends that way
+        tail = "/" + norm.strip("/") if changed else "/" + p.strip("/")
+        if tail != "/":
+            known = set(self.p.identifiables) | {q for ft in self.files.values() for q in ft.by_path}
+            hits = sorted(q for q in known if q == tail or q.endswith(tail))
+            if len(hits) == 1:
+                ft, node = self.tree_for(hits[0])
+                self.notes.append(f"{what} {raw!r} read as {hits[0]!r} (the only element whose path ends with {tail})"
+                                  + (f" (collection {trailing})" if trailing else ""))
+                return ft, node, hits[0], trailing
+            if len(hits) > 1:
+                raise ArxmlEditError(f"{raw} is ambiguous: several elements end with {tail}: {', '.join(hits[:8])}; give the full path")
+        raise ArxmlEditError(self.not_found(raw, norm if changed else None))
+
     def parent_for(self, parent_path: str, file: Optional[str]) -> tuple:
-        """(FileTree, node) of parent_path, creating missing AR-PACKAGEs below the deepest existing package."""
+        """(FileTree, node, path, collection hint) of parent_path; creates missing AR-PACKAGEs below the deepest
+        existing package, but only for a plain SHORT-NAME path (never from a tag-style or mistyped path)."""
         pp = parent_path.rstrip("/")
+        if pp and pp != "/" and self.normalize(pp)[0] == "/" and not self._typed:   # "/AUTOSAR/AR-PACKAGES": the root
+            self.notes.append(f"parent_path {parent_path!r} read as the file's top level")
+            pp = ""
         if pp == "":
-            return self.root_of(file)
+            ft, node = self.root_of(file)
+            return ft, node, "", None
         try:
-            return self.tree_for(pp)
-        except ArxmlEditError:
-            pass
+            return self.resolve(pp, "parent_path", file)
+        except ArxmlEditError as miss:
+            segs = [x for x in pp.split("/") if x]
+            if not segs or not all(_SHORT.match(x) for x in segs) or segs[0].upper() == "AUTOSAR":
+                raise miss
         segs = [s for s in pp.split("/") if s]
         anc, k = "", 0
         for i in range(len(segs) - 1, 0, -1):
@@ -170,7 +307,8 @@ class ArxmlEditor:
             self.op_add({"parent_path": anc or "/", "element": "AR-PACKAGE", "short_name": s, "file": file})
             anc = f"{anc}/{s}"
             self.created_packages.append(anc)
-        return self.tree_for(pp)
+        ft, node = self.tree_for(pp)
+        return ft, node, pp, None
 
     def load(self, f: str) -> FileTree:
         if f not in self.files:
@@ -218,8 +356,14 @@ class ArxmlEditor:
         for k in keys:
             v = values[k]
             for one in (v if isinstance(v, list) else [v]):
-                sub = etype.find_sub_element(k, version) if etype is not None else None
-                if isinstance(one, dict) and "ref" not in one:
+                try:
+                    sub = etype.find_sub_element(k, version) if etype is not None else None
+                except Exception:  # noqa: BLE001 -- autosar-data rejects a name that is no AUTOSAR tag at all
+                    raise ArxmlEditError(f"{k!r} is not an AUTOSAR element name (sub-elements of {tag}: "
+                                         f"{', '.join(o for o in order if o != 'SHORT-NAME')[:500]})") from None
+                is_ref = k.endswith(("-REF", "-TREF", "-IREF")) and isinstance(one, dict) and \
+                    any(x in one for x in ("ref", "$ref", "REF", "DEST", "dest"))
+                if isinstance(one, dict) and not is_ref:
                     sn = one.get("SHORT-NAME")
                     lines.extend(self.render(k, sn, one, sub, version, depth + 1))
                 else:
@@ -228,6 +372,10 @@ class ArxmlEditor:
         return lines
 
     def leaf(self, tag: str, v) -> str:
+        if isinstance(v, dict) and not ("ref" in v) and any(k in v for k in ("$ref", "REF", "path", "#text", "value")) \
+                and (tag.endswith("-REF") or tag.endswith("-TREF") or tag.endswith("-IREF")):
+            ref = v.get("$ref") or v.get("REF") or v.get("path") or v.get("#text") or v.get("value")
+            v = {"ref": str(ref).lstrip("->").strip(), "dest": v.get("dest") or v.get("DEST")}
         if isinstance(v, dict) and "ref" in v:
             target, dest = str(v["ref"]), v.get("dest") or self.dest_of(str(v["ref"]))
             if not dest:
@@ -267,10 +415,22 @@ class ArxmlEditor:
         if not parent_path or not tag:
             raise ArxmlEditError("add needs parent_path (the package or element to add under) and element (the XML "
                                  "tag), e.g. " + ADD_EXAMPLE)
-        ft, parent = self.parent_for(parent_path, op.get("file"))
+        if tag.upper() == "SHORT-NAME":
+            raise ArxmlEditError("SHORT-NAME is not an element to add: give short_name on the add of the element itself; "
+                                 "to rename an element use {op:'set', path:<element path>, element:'SHORT-NAME', value:<new>}")
+        ft, parent, parent_path, coll_hint = self.parent_for(parent_path, op.get("file"))
+        if tag.upper().startswith("ECUC-") or parent.tag.startswith("ECUC-"):
+            raise ArxmlEditError(
+                "this is ECUC configuration: use ecuc_edit, not arxml_edit, e.g. {op:'add', path:'" + (parent_path or "/<Pkg>/<Module>")
+                + "', container:'<ContainerDef>:<ShortName>', values:{<ParamDef>: <value>}} (ecuc_read schema=true lists "
+                "the containers and params that may be added there)")
         version = _version(ft.data)
         ptype = _etype(ft.chain(parent), version)
         coll = op.get("collection")
+        if coll is None and coll_hint and ptype is not None:
+            hold = ptype.find_sub_element(coll_hint, version)
+            if hold is not None and hold.find_sub_element(tag, version) is not None:
+                coll = coll_hint
         if coll is None and ptype is not None:
             if ptype.find_sub_element(tag, version) is None:
                 for c in _order(ptype):
@@ -278,6 +438,21 @@ class ArxmlEditor:
                     if ct is not None and ct.find_sub_element(tag, version) is not None:
                         coll = c
                         break
+                if coll is None and parent_path:
+                    holders = []
+                    for q, n in ft.by_path.items():
+                        if not q.startswith(parent_path + "/") or n is parent:
+                            continue
+                        nt = _etype(ft.chain(n), version)
+                        if nt is None:
+                            continue
+                        if nt.find_sub_element(tag, version) is not None or any(
+                                (ct := nt.find_sub_element(c, version)) is not None and ct.find_sub_element(tag, version) is not None
+                                for c in _order(nt)):
+                            holders.append(q)
+                    if len(holders) == 1:
+                        self.notes.append(f"{tag} cannot go directly under {parent_path}; added under {holders[0]}")
+                        return self.op_add(dict(op, parent_path=holders[0], collection=None))
                 if coll is None:
                     raise ArxmlEditError(f"{tag} cannot be placed under {parent.tag} {parent_path} in this schema; "
                                          f"{parent.tag} takes: {', '.join(_placeable(ptype, version))[:600]}")
@@ -360,8 +535,9 @@ class ArxmlEditor:
     def op_set(self, op: dict):
         path, tag = op.get("path"), op.get("element")
         if not path or not tag or "value" not in op:
-            raise ArxmlEditError("set needs path, element and value")
-        ft, node = self.tree_for(path.rstrip("/"))
+            raise ArxmlEditError("set needs path (the element that holds the value), element (the XML tag of the value) "
+                                 "and value, e.g. {op:'set', path:'/PT/Com/ISignals/ENG_TEMP', element:'LENGTH', value:8}")
+        ft, node, _, _ = self.resolve(path, "path")
         leaf = self.own_child(node, tag)
         text = self.leaf(tag, op["value"]).encode("utf-8")
         if leaf is None:
@@ -385,7 +561,9 @@ class ArxmlEditor:
 
     def op_remove(self, op: dict):
         path = (op.get("path") or "").rstrip("/")
-        ft, node = self.tree_for(path)
+        if not path:
+            raise ArxmlEditError("remove needs path (the element to remove)")
+        ft, node, _, _ = self.resolve(path, "path")
         start = node.start
         if line_indent(ft.data, start) is not None:
             nl = ft.data.rfind(b"\n", 0, start)
@@ -444,16 +622,28 @@ def _placeable(ptype, version) -> list:
     return out
 
 
+_TAG_ANYCASE = re.compile(r"[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)+\Z|[A-Za-z]+\Z")
+
+
+def _upper_keys(v):
+    """Upper-case element-name keys of a values tree ("Init-Value" -> INIT-VALUE); '@'/'$' keys and ref dicts stay."""
+    if isinstance(v, list):
+        return [_upper_keys(x) for x in v]
+    if not isinstance(v, dict) or "ref" in v or "$ref" in v:
+        return v
+    return {(k.upper() if _TAG_ANYCASE.match(k) and k not in ("ref", "dest") else k): _upper_keys(x) for k, x in v.items()}
+
+
 def normalize(op: dict, notes: list, i: int) -> dict:
-    """Accept the shapes agents mix up (ecuc_edit's path/container, name/tag) for add; note each rewrite."""
-    if op.get("op") != "add":
+    """Accept the shapes agents mix up (ecuc_edit's path/container/param, name/tag, any-case tags); note each rewrite."""
+    if op.get("op") not in ("add", "set"):
         return op
     op = dict(op)
-    if not op.get("parent_path") and op.get("path"):
+    if op.get("op") == "add" and not op.get("parent_path") and op.get("path"):
         op["parent_path"] = op.pop("path")
         notes.append(f"op {i}: 'path' read as parent_path")
     cont = op.get("container")
-    if not op.get("element") and isinstance(cont, str):
+    if op.get("op") == "add" and not op.get("element") and isinstance(cont, str):
         tag, _, sn = cont.partition(":")
         if _TAG.match(tag):
             op.pop("container")
@@ -465,6 +655,15 @@ def normalize(op: dict, notes: list, i: int) -> dict:
         if alias in op and not op.get(key):
             op[key] = op.pop(alias)
             notes.append(f"op {i}: {alias!r} read as {key!r}")
+    if op.get("op") == "set" and not op.get("element") and op.get("param"):
+        op["element"] = op.pop("param")
+        notes.append(f"op {i}: 'param' read as 'element'")
+    el = op.get("element")
+    if isinstance(el, str) and _TAG_ANYCASE.match(el) and el != el.upper():
+        op["element"] = el.upper()
+        notes.append(f"op {i}: element {el!r} read as {el.upper()!r} (AUTOSAR tags are upper case)")
+    if isinstance(op.get("values"), dict):
+        op["values"] = _upper_keys(op["values"])
     vals = op.get("values")
     if isinstance(vals, dict) and "SHORT-NAME" in vals and not op.get("short_name"):
         vals = dict(vals)
@@ -483,6 +682,7 @@ def arxml_edit(project: Project, ops, dry_run: bool = False) -> dict:
     created = []
     notes: list = []
     ops = [normalize(o, notes, i) for i, o in enumerate(ops)]
+    ed.notes = notes
     try:
         for i, op in enumerate(ops):
             kind = op.get("op")
@@ -499,6 +699,9 @@ def arxml_edit(project: Project, ops, dry_run: bool = False) -> dict:
                     raise ArxmlEditError(f"unknown op {kind!r} (new_file/add/set/remove)")
             except ArxmlEditError as e:
                 raise ArxmlEditError(f"op {i} ({kind} {op.get('path') or op.get('parent_path') or op.get('file')}): {e}") from None
+            except Exception as e:  # noqa: BLE001 -- never let a library error escape as a bare engine failure
+                raise ArxmlEditError(f"op {i} ({kind} {op.get('path') or op.get('parent_path') or op.get('file')}): "
+                                     f"{type(e).__name__}: {e}") from None
     except ArxmlEditError as e:
         return {"ok": False, "error": str(e), "written": False, "notes": notes}
     problems = ed.check()

package/python/ecuc_engine/cli.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import re
 import os
 import sys
 import time
@@ -15,16 +16,44 @@ import time
 from . import ENGINE_VERSION
 
 
+REPAIRED: list = []
+
+
+def _loads(text: str):
+    """json.loads, then the slips models make in long hand-written JSON: trailing commas, missing commas between
+    objects/values, Python literals (True/None, single quotes). The first error is re-raised if nothing parses."""
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError as first:
+        fixed = re.sub(r",\s*([}\]])", r"\1", text)
+        fixed = re.sub(r"([}\]\"])\s*\n?\s*([{\"])", lambda m: m.group(1) + ("," if m.group(2) in "{\"" else "") + m.group(2), fixed) \
+            if fixed.count('"') % 2 == 0 else fixed
+        for cand in (fixed, ):
+            try:
+                v = json.loads(cand)
+                REPAIRED.append(f"ops JSON had a syntax error ({first.msg} at char {first.pos}) and was repaired; check the result")
+                return v
+            except json.JSONDecodeError:
+                pass
+        try:
+            import ast
+            v = ast.literal_eval(text.replace("true", "True").replace("false", "False").replace("null", "None"))
+            REPAIRED.append(f"ops were not strict JSON ({first.msg} at char {first.pos}) and were read as a literal")
+            return v
+        except Exception:  # noqa: BLE001
+            raise first from None
+
+
 def _ops(arg: str):
     if arg.startswith("@"):
         with open(arg[1:]) as f:
             arg = f.read()
     if arg == "-":
         arg = sys.stdin.read()
-    ops = json.loads(arg)
+    ops = _loads(arg)
     for _ in range(3):  # tolerate JSON that was encoded more than once ("[{...}]" as a string)
         if isinstance(ops, str):
-            ops = json.loads(ops)
+            ops = _loads(ops)
     if isinstance(ops, dict) and isinstance(ops.get("ops"), (list, str)):
         return _ops(json.dumps(ops["ops"]))
     return ops if isinstance(ops, list) else [ops]
@@ -78,6 +107,14 @@ def main(argv=None) -> int:
     an.add_argument("--dry-run", action="store_true")
     ac = sub.add_parser("arxml-check", help="verify non-ECUC ARXML: strict schema + every reference and its DEST")
     ac.add_argument("--file", action="append", default=[], help="limit to files whose path contains this")
+    al = sub.add_parser("add-like", help="add a new X like an existing Y: clone its chain across all ARXML, renamed")
+    al.add_argument("--like", required=True, help="name stem of the template (e.g. BCM_DoorStatus)")
+    al.add_argument("--name", required=True, help="the new stem (e.g. BCM_SettingsAck)")
+    al.add_argument("--seed", help="one element of the template chain, when several chains carry the stem")
+    al.add_argument("--also", help='JSON {"template member stem": "new stem"}, e.g. {"DrvDoorOpenSts": "SettingsAckCounter"}')
+    al.add_argument("--set", dest="set_values", help='JSON {"ParamDef"|"XML-TAG"|"Owner:key": value}')
+    al.add_argument("--keep-members", action="store_true")
+    al.add_argument("--dry-run", action="store_true")
     fd = sub.add_parser("find")
     fd.add_argument("--module")
     fd.add_argument("--container-def", dest="container_def")
@@ -123,7 +160,7 @@ def main(argv=None) -> int:
     bc.add_argument("--task", required=True, help="task text, @file, or - for stdin")
     bc.add_argument("--budget-tokens", dest="budget_tokens", type=int, default=24000)
     bc.add_argument("--no-history", dest="history", action="store_false")
-    for p in (r, e, v, d, au, so, vs, si, fd, cx, ae, an, ac, asg, cg, cd, ra, vr, bc):  # allow --json after the subcommand too
+    for p in (r, e, v, d, au, so, vs, si, fd, cx, ae, an, ac, al, asg, cg, cd, ra, vr, bc):  # allow --json after the subcommand too
         p.add_argument("--json", action="store_true", help=argparse.SUPPRESS)
     a = ap.parse_args(argv)
     t0 = time.time()
@@ -193,7 +230,7 @@ def run(a) -> dict:
         from .specids import check_ids
         return check_ids(os.path.abspath(a.root), a.ids, docs=a.docs)
     from .model import Project
-    project = Project(a.root, config_files=a.config, def_files=a.defs, load_input=a.cmd in ("validate", "edit", "find", "crosscheck", "signal-owners", "arxml-edit", "add-signal", "arxml-check"))
+    project = Project(a.root, config_files=a.config, def_files=a.defs, load_input=a.cmd in ("validate", "edit", "find", "crosscheck", "signal-owners", "arxml-edit", "add-signal", "arxml-check", "add-like"))
     if a.cmd == "add-signal":
         from .add_signal import AddSignalError, add_signal
         try:
@@ -202,12 +239,27 @@ def run(a) -> dict:
                               transfer_property=a.transfer_property, dry_run=a.dry_run)
         except AddSignalError as ex:
             return {"error": str(ex), "written": False}
+    if a.cmd == "add-like":
+        from .add_like import AddLikeError, add_like
+        try:
+            also = _loads(a.also) if a.also else None
+            sv = _loads(a.set_values) if a.set_values else None
+        except json.JSONDecodeError as ex:
+            return {"ok": False, "error": f"also/set is not valid JSON: {ex}"}
+        try:
+            return add_like(project, a.like, a.name, seed=a.seed, set_values=sv, keep_members=a.keep_members,
+                            dry_run=a.dry_run, also=also)
+        except AddLikeError as ex:
+            return {"ok": False, "error": str(ex)}
     if a.cmd == "arxml-check":
         from .arxml_edit import arxml_check
         return arxml_check(project, a.file or None)
     if a.cmd == "arxml-edit":
         from .arxml_edit import arxml_edit
-        return arxml_edit(project, a.ops, dry_run=a.dry_run)
+        res = arxml_edit(project, a.ops, dry_run=a.dry_run)
+        if REPAIRED:
+            res.setdefault("notes", []).extend(REPAIRED)
+        return res
     if a.cmd == "find":
         from .find import find
         where = a.where

package/skills/autosar/SKILL.md

@@ -71,6 +71,7 @@ grounding, no tools, no exploring the project.
 | Verify ALL ARXML (ECUC rules + extract/SWC schema, references, DEST) | `ecuc_validate` (unfiltered) |
 | Edit System extract / SWC / interface XML | `arxml_edit` (DEST inferred, schema-ordered, refs checked) |
 | Add a signal end to end (ECUC + extract + DBC) | `autosar_add_signal` |
+| Add a new message / port / runnable+event / Dem event / NvM block / interface **like an existing one**, in every file at once | `autosar_add_like like=<existing stem> name=<new stem> also={member: new} set={...}` |
 | What may be set/added here (types, ranges, literals, multiplicity) | `ecuc_read path=… schema=true`, or a def path `/AUTOSAR/EcucDefs/<Mod>/…` |
 | Change config | `ecuc_edit ops=[…]` (`dry_run` first for large edits) |
 | Check config | `ecuc_validate` |
@@ -123,6 +124,20 @@ Do not decide what to change from memory or from the prompt alone. Each change g
    (unvalidated edits, failing validation, unverified C, changed elements not yet checked against the documents)
    until it is resolved.
 
+## A new thing that resembles an existing one: autosar_add_like (preferred)
+Most changes add something the project already has one of: a message, a port, a runnable with its timing event, a
+Dem event with its DTC, an NvM block with its Fee block. Do not build those op by op. Pick the existing one most like
+the new one (same direction, bus, kind), then:
+1. `autosar_add_like like=<its stem> name=<new stem> dry_run=true`: read the Created list (every file it touches)
+   and the "Not copied" / "single-valued" lists.
+2. Name the members you want too: `also={"DrvDoorOpenSts": "SettingsAckCounter"}` gives the new message one signal
+   cloned from that one.
+3. Set the values the request gives with `set` (ECUC param name, XML tag, or `Owner:key` when several clones have
+   it): CAN id (`IDENTIFIER`, `CanIfTxPduCanId`), lengths (`PduLength`, `FRAME-LENGTH`, `I-SIGNAL-I-PDU:LENGTH`),
+   period (`ComTxModeTimePeriod`), signal layout (`<sig>:ComBitPosition`, `<sig>:ComBitSize`, `START-POSITION`) ...
+4. Run it without dry_run. It validates and rolls back on any new finding. Then fix what is listed as single-valued
+   (e.g. the S/R-to-signal mapping of a new port) with arxml_edit, and verify as below.
+
 ## New ARXML file (SWC, interface, data types, extract) from nothing
 1. ONE `arxml_edit` call. Its first op creates the file:
    `{op:"new_file", file:"Input/SWC_X.arxml", packages:["/DataTypes", "/Interfaces", "/Swcs"]}` (R25-11 header and empty