@h2loop/autosar 1.0.1 → 1.2.0

package/python/ecuc_engine/defs.py

@@ -76,6 +76,11 @@ class DefNode:
     refs: list = field(default_factory=list)  # child ref def paths
     parent: Optional[str] = None
     module: Optional[str] = None  # module def path
+    # Config classes per IMPLEMENTATION-CONFIG-VARIANT ({"VARIANT-PRE-COMPILE": "PRE-COMPILE", ...}).
+    config_classes: Optional[dict] = None  # VALUE-CONFIG-CLASSES (params/refs)
+    mult_classes: Optional[dict] = None  # MULTIPLICITY-CONFIG-CLASSES (containers, params)
+    requires_symbolic: bool = False  # REQUIRES-SYMBOLIC-NAME-VALUE (refs)
+    variants: Optional[list] = None  # SUPPORTED-CONFIG-VARIANTS (module defs)
 
     @property
     def is_container(self) -> bool:
@@ -218,6 +223,13 @@ def _make_def(el, tag: str, sn: str, path: str, path_file: str) -> DefNode:
         d.upper = None
     else:
         d.upper = _int(direct["UPPER-MULTIPLICITY"].text if "UPPER-MULTIPLICITY" in direct else None, 1)
+    for wrap, attr in (("VALUE-CONFIG-CLASSES", "config_classes"), ("MULTIPLICITY-CONFIG-CLASSES", "mult_classes")):
+        w = direct.get(wrap)
+        if w is not None:
+            setattr(d, attr, _config_classes(w))
+    sv = direct.get("SUPPORTED-CONFIG-VARIANTS")
+    if sv is not None:
+        d.variants = [(c.text or "").strip() for c in sv if _local(c.tag) == "SUPPORTED-CONFIG-VARIANT"]
     tr = direct.get("RELATED-TRACE-ITEM-REF")
     if tr is not None:
         d.trace = (tr.text or "").strip()
@@ -256,9 +268,27 @@ def _make_def(el, tag: str, sn: str, path: str, path_file: str) -> DefNode:
             d.with_auto = txt.lower() == "true"
         elif t == "SYMBOLIC-NAME-VALUE":
             d.symbolic_name = txt.lower() == "true"
+        elif t == "REQUIRES-SYMBOLIC-NAME-VALUE":
+            d.requires_symbolic = txt.lower() == "true"
     return d
 
 
+def _config_classes(wrapper) -> dict:
+    """<VALUE-CONFIG-CLASSES>/<MULTIPLICITY-CONFIG-CLASSES> -> {CONFIG-VARIANT: CONFIG-CLASS}."""
+    out = {}
+    for c in wrapper:
+        cls = var = None
+        for f in c:
+            t = _local(f.tag)
+            if t == "CONFIG-CLASS":
+                cls = (f.text or "").strip()
+            elif t == "CONFIG-VARIANT":
+                var = (f.text or "").strip()
+        if cls and var:
+            out[var] = cls
+    return out
+
+
 def load_defs(paths: list[str], use_cache: bool = True) -> DefIndex:
     idx = DefIndex()
     for p in paths:

package/python/ecuc_engine/ecucjson.py

@@ -8,6 +8,10 @@ Keyed by def names, not XML structure:
                                         "ComSignal:DoorLatch": {...}}}}}
 A container key is "<DefName>:<ShortName>", shortened to "<ShortName>" when the two are equal.
 Multi-valued parameters are arrays. References are "->/AUTOSAR/path".
+Every container carries "@at" (file:line of the container element). Every value is followed by
+"@at:<Param>" = file:line of its VALUE / VALUE-REF element, and integer-typed values by "@hex:<Param>"
+(and "@dec:<Param>" when the ARXML text is not decimal), so citations and base conversions are never guessed.
+Keys starting with "@" are metadata; ecuc_edit ignores them.
 """
 from __future__ import annotations
 
@@ -16,7 +20,7 @@ from typing import Optional
 from . import defs as D
 from .model import Elem, Project
 from .validate import _resolve_def
-from .values import to_json
+from .values import int_forms, to_json
 
 
 def key_of(e: Elem) -> str:
@@ -24,27 +28,55 @@ def key_of(e: Elem) -> str:
     return e.name if dn == e.name else f"{dn}:{e.name}"
 
 
+def value_at(project: Project, e: Elem, pv) -> str:
+    """file:line of a parameter's VALUE / VALUE-REF element (not its container)."""
+    n = pv.value_node if pv.value_node is not None else pv.node
+    return f"{project.rel(e.file)}:{n.line}"
+
+
+def value_info(project: Project, e: Elem, pv) -> dict:
+    """One configured value with its exact location and, for integers, both bases."""
+    pd = _resolve_def(project.defs, pv.def_ref)
+    numerical = pv.tag == "ECUC-NUMERICAL-PARAM-VALUE"
+    out = {"value": to_json(pd, pv.value, pv.is_ref, numerical), "at": value_at(project, e, pv)}
+    nums = int_forms(pd, pv.value, pv.is_ref, numerical, pv.def_dest)
+    if nums:
+        out.update(nums)
+    return out
+
+
+def _put(out: dict, name: str, items: list, multi: bool):
+    one = lambda xs: xs if multi else xs[0]  # noqa: E731
+    out[name] = one([x["value"] for x in items])
+    out[f"@at:{name}"] = one([x["at"] for x in items])
+    if any("hex" in x for x in items):
+        out[f"@hex:{name}"] = one([x.get("hex") for x in items])
+        if any("dec" in x and x["value"] != x["dec"] for x in items):
+            out[f"@dec:{name}"] = one([x.get("dec") for x in items])
+
+
+def annotated_values(project: Project, group: list) -> dict:
+    """{param: value, "@at:param": file:line, "@hex:param": ...} for the params of one element (all its files)."""
+    items: dict = {}
+    multi: dict = {}
+    for e in group:
+        for pv in e.params:
+            pd = _resolve_def(project.defs, pv.def_ref)
+            items.setdefault(pv.name, []).append(value_info(project, e, pv))
+            multi[pv.name] = multi.get(pv.name, False) or (pd is not None and (pd.upper is None or pd.upper > 1))
+    out: dict = {}
+    for name, xs in items.items():
+        _put(out, name, xs, multi[name] or len(xs) > 1)
+    return out
+
+
 def render(project: Project, group: list, depth: int, top: bool = True) -> dict:
-    defs = project.defs
     e0 = group[0]
     out: dict = {"@path": e0.path}
     if top:
         out["@def"] = e0.def_ref
-        out["@at"] = ", ".join(f"{project.rel(e.file)}:{e.line}" for e in group)
-    vals: dict = {}
-    for e in group:
-        for pv in e.params:
-            pd = _resolve_def(defs, pv.def_ref)
-            v = to_json(pd, pv.value, pv.is_ref, pv.tag == "ECUC-NUMERICAL-PARAM-VALUE")
-            name = pv.name
-            multi = pd is not None and (pd.upper is None or pd.upper > 1)
-            if name in vals:
-                if not isinstance(vals[name], list) or not multi:
-                    vals[name] = vals[name] if isinstance(vals[name], list) else [vals[name]]
-                vals[name].append(v)
-            else:
-                vals[name] = [v] if multi else v
-    out.update(vals)
+    out["@at"] = ", ".join(f"{project.rel(e.file)}:{e.line}" for e in group)
+    out.update(annotated_values(project, group))
     seen = set()
     for e in group:
         for c in e.children:
@@ -61,6 +93,24 @@ def render(project: Project, group: list, depth: int, top: bool = True) -> dict:
     return out
 
 
+def value_sites(project: Project, paths: list) -> dict:
+    """AUTOSAR path -> {"at": container file:line, "values": {param: {value, at, dec?, hex?} | [..]}} from the
+    local ECUC, or None when the element is not in the local checkout."""
+    out: dict = {}
+    for p in paths:
+        g = project.find(p)
+        if not g:
+            out[p] = None
+            continue
+        vals: dict = {}
+        for e in g:
+            for pv in e.params:
+                vals.setdefault(pv.name, []).append(value_info(project, e, pv))
+        out[p] = {"at": ", ".join(f"{project.rel(e.file)}:{e.line}" for e in g),
+                  "values": {k: (v[0] if len(v) == 1 else v) for k, v in vals.items()}}
+    return out
+
+
 def read(project: Project, path: Optional[str], depth: int = 2, schema: bool = False) -> dict:
     res: dict = {"defsLoaded": len(project.defs.modules)}
     if project.warnings:
@@ -101,12 +151,15 @@ def read(project: Project, path: Optional[str], depth: int = 2, schema: bool = F
     parent, _, last = path.rstrip("/").rpartition("/")
     pg = project.find(parent)
     if pg:
-        hits = [pv for e in pg for pv in e.params if pv.name == last]
+        hits = [(e, pv) for e in pg for pv in e.params if pv.name == last]
         if hits:
-            pd = _resolve_def(project.defs, hits[0].def_ref)
-            res["param"] = {"@path": path, "@def": hits[0].def_ref,
-                            "@at": [f"{project.rel(hits[0].node and pg[0].file)}:{h.node.line}" for h in hits],
-                            "value": [to_json(pd, h.value, h.is_ref, h.tag == "ECUC-NUMERICAL-PARAM-VALUE") for h in hits]}
+            pd = _resolve_def(project.defs, hits[0][1].def_ref)
+            info = [value_info(project, e, pv) for e, pv in hits]
+            res["param"] = {"@path": path, "@def": hits[0][1].def_ref,
+                            "@at": [x["at"] for x in info], "value": [x["value"] for x in info]}
+            if any("hex" in x for x in info):
+                res["param"]["dec"] = [x.get("dec") for x in info]
+                res["param"]["hex"] = [x.get("hex") for x in info]
             if pd is not None:
                 res["schema"] = D.describe(pd, project.defs)
             return res

package/python/ecuc_engine/find.py

@@ -0,0 +1,164 @@
+"""Structured ECUC queries (ecuc_find) and per-module cross-check tables (ecuc_crosscheck)."""
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+from .model import Project
+from .values import parse_int
+
+import operator
+
+CMP = {">": operator.gt, "<": operator.lt, ">=": operator.ge, "<=": operator.le}
+OPS = re.compile(r"^\s*([A-Za-z_]\w*)\s*(!=|>=|<=|=|>|<|~)\s*(.*?)\s*$")
+
+
+def _where(where) -> list:
+    if not where:
+        return []
+    if isinstance(where, dict):
+        return [(k, "=", v) for k, v in where.items()]
+    out = []
+    for part in re.split(r"\s*(?:,|&&|\band\b)\s*", str(where)):
+        m = OPS.match(part)
+        if m:
+            out.append((m.group(1), m.group(2), m.group(3)))
+    return out
+
+
+def _cmp(vals: list, op: str, want) -> bool:
+    w = str(want)
+    w = w[2:] if w.startswith("->") else w
+    for v in vals:
+        s = (v or "").strip()
+        if op == "=" and (s == w or s.lower() == w.lower()):
+            return True
+        if op == "!=" and s != w:
+            return True
+        if op == "~" and re.search(w, s):
+            return True
+        if op in (">", "<", ">=", "<="):
+            a, b = parse_int(s), parse_int(w)
+            if a is not None and b is not None and CMP[op](a, b):
+                return True
+    return op == "!=" and not vals
+
+
+def _own(project: Project, e) -> dict:
+    vals: dict = {}
+    for g in project.find(e.path):
+        for pv in g.params:
+            vals.setdefault(pv.name, []).append(pv.value)
+    return vals
+
+
+def _refs(project: Project, e, depth: int) -> set:
+    """Reference targets of e, following references up to ``depth`` hops."""
+    out, frontier = set(), [e]
+    for _ in range(depth):
+        nxt = []
+        for x in frontier:
+            for g in project.find(x.path):
+                for pv in g.params:
+                    if pv.is_ref and pv.value:
+                        t = pv.value.strip()
+                        if t not in out:
+                            out.add(t)
+                            hit = project.find(t)
+                            if hit:
+                                nxt.append(hit[0])
+        frontier = nxt
+    return out
+
+
+def find(project: Project, module: Optional[str] = None, container_def: Optional[str] = None, where=None,
+         ref_to: Optional[str] = None, referenced_by: Optional[str] = None, limit: int = 50, depth: int = 2) -> dict:
+    from .ecucjson import annotated_values, resolve
+    conds = _where(where)
+    targets = None
+    if ref_to:
+        r = resolve(project, ref_to)
+        if isinstance(r, dict):
+            sys = project.system.get(ref_to)
+            if sys is None:
+                return {"error": r["error"], "didYouMean": r.get("didYouMean", [])}
+            r = ref_to
+        targets = r
+    owner_refs = None
+    if referenced_by:
+        r = resolve(project, referenced_by)
+        if isinstance(r, dict):
+            return {"error": r["error"], "didYouMean": r.get("didYouMean", [])}
+        owner_refs = _refs(project, project.find(r)[0], 1)
+    hits = []
+    total = 0
+    for path, group in project.by_path.items():
+        e = group[0]
+        if e.kind != "container":
+            continue
+        dname = (e.def_ref or "").rsplit("/", 1)[-1]
+        if container_def and not (dname == container_def or (e.def_ref or "").endswith("/" + container_def.strip("/"))):
+            continue
+        if module:
+            m = e
+            while m.parent is not None:
+                m = m.parent
+            if module not in (m.name, (m.def_ref or "").rsplit("/", 1)[-1]):
+                continue
+        if owner_refs is not None and path not in owner_refs:
+            continue
+        own = _own(project, e)
+        if any(not _cmp(own.get(k, []), op, v) for k, op, v in conds):
+            continue
+        if targets is not None:
+            refs = _refs(project, e, depth)
+            if not any(t == targets or t.startswith(targets + "/") for t in refs):
+                continue
+        total += 1
+        if len(hits) < limit:
+            hits.append({"path": path, "def": dname, "at": ", ".join(f"{project.rel(x.file)}:{x.line}" for x in group),
+                         "values": annotated_values(project, group)})
+    return {"count": total, "returned": len(hits), "matches": hits,
+            "legend": "at = container element; values[\"@at:P\"] = file:line of P's VALUE element; "
+                      "@hex:/@dec: = the same integer in the other base"}
+
+
+ELEMENTS = {
+    "Com": ["Com/ComConfig/ComSignal", "Com/ComConfig/ComIPdu"],
+    "PduR": ["PduR/PduRRoutingPaths/PduRRoutingPath"],
+    "EcuC": ["EcuC/EcucConfigSet/EcucPduCollection/Pdu"],
+    "NvM": ["NvM/NvMBlockDescriptor"],
+    "Fee": ["Fee/FeeBlockConfiguration"],
+    "Ea": ["Ea/EaBlockConfiguration"],
+    "CanIf": ["CanIf/CanIfInitCfg/CanIfTxPduCfg", "CanIf/CanIfInitCfg/CanIfRxPduCfg"],
+    "Dem": ["Dem/DemConfigSet/DemEventParameter"],
+}
+
+
+def crosscheck(project: Project, module: str, limit: int = 200) -> dict:
+    from .rules import RuleContext, run_rules
+    mods = [m for m in project.modules if module in (m.name, (m.def_ref or "").rsplit("/", 1)[-1])]
+    if not mods:
+        return {"error": f"module {module!r} is not configured (modules: {', '.join(sorted({m.name for m in project.modules}))})"}
+    roots = [m.path for m in mods]
+    diags = [d for d in run_rules(project) if any(d["path"] == r or d["path"].startswith(r + "/") for r in roots)
+             or d["rule"].endswith("-000")]
+    ctx = RuleContext(project)
+    kinds = ELEMENTS.get((mods[0].def_ref or "").rsplit("/", 1)[-1] or module, [])
+    rows, counts = [], {"checked": 0, "findings": 0}
+    by_path: dict = {}
+    for d in diags:
+        by_path.setdefault(d["path"], []).append(d)
+    for k in kinds:
+        for e in ctx.containers(k):
+            counts["checked"] += 1
+            f = by_path.get(e.path, [])
+            if f:
+                counts["findings"] += 1
+                rows.append({"element": e.path, "def": k.rsplit("/", 1)[-1], "at": f"{project.rel(e.file)}:{e.line}",
+                             "status": "FINDING", "findings": [f"{x['rule']} {x['severity']}: {x['message']}" for x in f]})
+    notes = [d["message"] for d in diags if d["severity"] == "info"]
+    other = [d for d in diags if d["severity"] != "info" and not any(r["element"] == d["path"] for r in rows)]
+    return {"module": module, "elementKinds": [k.rsplit("/", 1)[-1] for k in kinds], "counts": counts,
+            "rows": rows[:limit], "otherFindings": other[:limit], "notes": notes,
+            "summary": f"{counts['checked']} element(s) checked, {counts['findings']} with findings"}

package/python/ecuc_engine/gen.py

@@ -0,0 +1,105 @@
+"""H2L-GEN-001: is the generated code up to date with the configuration?
+
+Runs the project's configured `generate` command in a scratch copy (never in place), then compares the
+copy with the tree. Every file the generator would change is reported with a short diff summary.
+"""
+from __future__ import annotations
+
+import difflib
+import os
+import shutil
+import subprocess
+import tempfile
+import time
+
+from . import paths
+
+DEFAULT_TIMEOUT = 300
+AUTO_LIMIT = 5 * 1024 * 1024  # on by default only when the configuration is smaller than this
+
+
+def generate_cmd(cfg: dict):
+    g = cfg.get("generate")
+    if isinstance(g, str):
+        return g, None, DEFAULT_TIMEOUT
+    if isinstance(g, dict) and g.get("command"):
+        return g["command"], g.get("cwd"), int(g.get("timeoutSec") or DEFAULT_TIMEOUT)
+    return None, None, 0
+
+
+def default_on(project, cfg: dict) -> bool:
+    if "checkGenerated" in cfg:
+        return bool(cfg["checkGenerated"])
+    if not generate_cmd(cfg)[0]:
+        return False
+    return sum(os.path.getsize(f) for f in project.files) < AUTO_LIMIT
+
+
+def _snapshot(root: str) -> dict:
+    out = {}
+    for dp, dns, fns in os.walk(root):
+        dns[:] = [d for d in dns if d not in paths.TOOLING_DIRS]
+        for fn in fns:
+            f = os.path.join(dp, fn)
+            try:
+                st = os.stat(f)
+            except OSError:
+                continue
+            out[os.path.relpath(f, root)] = (st.st_size, st.st_mtime_ns)
+    return out
+
+
+def check(project, cfg: dict, timeout: int = 0) -> list:
+    cmd, cwd, tmo = generate_cmd(cfg)
+    if not cmd:
+        return [_d("info", "", 0, "no `generate` command in .hydron/autosar.json; stale-Output check skipped")]
+    tmo = timeout or tmo
+    root = project.root
+    before = _snapshot(root)
+    t0 = time.time()
+    with tempfile.TemporaryDirectory(prefix="h2l-gen-") as tmp:
+        scratch = os.path.join(tmp, "proj")
+        shutil.copytree(root, scratch, symlinks=True, ignore=shutil.ignore_patterns(*paths.TOOLING_DIRS))
+        try:
+            r = subprocess.run(cmd, shell=True, cwd=os.path.join(scratch, cwd) if cwd else scratch,
+                               capture_output=True, text=True, timeout=tmo)
+        except subprocess.TimeoutExpired:
+            return [_d("info", "", 0, f"NOT CHECKED: generate command timed out after {tmo}s in a scratch copy: {cmd}")]
+        if r.returncode != 0:
+            tail = (r.stderr or r.stdout).strip().splitlines()[-5:]
+            return [_d("warning", "", 0, f"generate command failed in a scratch copy (exit {r.returncode}): {cmd}: "
+                                         + " | ".join(tail) + " — the configuration may not be generatable")]
+        after = _snapshot(scratch)
+        out = []
+        for rel in sorted(set(before) | set(after)):
+            if rel in before and rel not in after:
+                continue  # build artefacts removed by the generator are not staleness
+            a, b = os.path.join(root, rel), os.path.join(scratch, rel)
+            if rel not in before:
+                out.append(_d("error", rel, 0, f"{rel}: the generator creates this file but it is missing from the tree"))
+                continue
+            try:
+                x, y = open(a, "rb").read(), open(b, "rb").read()
+            except OSError:
+                continue
+            if x == y:
+                continue
+            xl = x.decode("utf-8", "replace").splitlines()
+            yl = y.decode("utf-8", "replace").splitlines()
+            diff = [ln for ln in difflib.unified_diff(xl, yl, "tree", "regenerated", n=0, lineterm="")
+                    if ln.startswith(("+", "-")) and not ln.startswith(("+++", "---"))]
+            plus = sum(1 for ln in diff if ln.startswith("+"))
+            minus = len(diff) - plus
+            first = next((i for i, (p, q) in enumerate(zip(xl, yl)) if p != q), min(len(xl), len(yl))) + 1
+            sample = "; ".join(ln[:120] for ln in diff[:4])
+            out.append(_d("error", rel, first, f"{rel} is stale: regenerating changes {minus} line(s) / adds {plus} "
+                                               f"(e.g. {sample})"))
+        if not out:
+            out.append(_d("info", "", 0, f"generated files are up to date (regenerated in {time.time() - t0:.1f}s in a scratch copy)"))
+        return out
+
+
+def _d(sev, file, line, msg):
+    return {"file": file, "line": line, "path": "", "rule": "H2L-GEN-001", "severity": sev,
+            "message": msg + " [TR_Methodology: generated BSW configuration must be regenerated after ECUC changes]",
+            "defRef": None}

package/python/ecuc_engine/history.py

@@ -0,0 +1,146 @@
+"""Git-history-lite: "similar past changes" for a SW-C, without embeddings.
+
+Takes ``git log`` (a bounded number of commits) touching the SW-C's ARXML and C files and those of similar
+SW-Cs, summarises each commit as an ARXML delta (the semantic ``arxml_diff`` of the before/after blobs) plus the
+C diff hunks, and ranks by overlap with the task's terms (ports, data elements, words of the task) and recency.
+Everything is bounded: commits scanned, hunks per commit, characters per summary, results returned.
+"""
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+import tempfile
+from typing import Optional
+
+MAX_COMMITS = 60
+MAX_HUNK_CHARS = 1500
+MAX_DELTA_ITEMS = 12
+MAX_COMMIT_CHARS = 4000  # all C hunks of one commit together
+MAX_FILES_PER_COMMIT = 6
+
+
+def _git(root: str, *args, timeout: int = 60) -> Optional[str]:
+    try:
+        r = subprocess.run(["git", "-C", root, *args], capture_output=True, timeout=timeout)
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    return r.stdout.decode("utf-8", "replace") if r.returncode == 0 else None
+
+
+def is_repo(root: str) -> bool:
+    return (_git(root, "rev-parse", "--is-inside-work-tree") or "").strip() == "true"
+
+
+def terms_of(text: str) -> set:
+    """Identifier-ish terms, with CamelCase / snake_case parts, lower-cased; short noise words dropped."""
+    out = set()
+    for tok in re.findall(r"[A-Za-z_][A-Za-z0-9_]{2,}", text or ""):
+        out.add(tok.lower())
+        for part in re.findall(r"[A-Z]+(?![a-z])|[A-Z]?[a-z]+|\d+", tok):
+            if len(part) >= 3:
+                out.add(part.lower())
+    return out - STOP
+
+
+STOP = {"the", "and", "for", "with", "from", "this", "that", "into", "when", "add", "use", "new", "void", "rte",
+        "std", "returntype", "uint8", "uint16", "uint32", "boolean", "return", "data", "static", "const", "then",
+        "should", "must", "set", "get", "true", "false", "null", "ptr", "null_ptr", "not", "are", "has", "its"}
+
+
+def _blob(root: str, rev: str, rel: str) -> Optional[bytes]:
+    try:
+        r = subprocess.run(["git", "-C", root, "show", f"{rev}:./{rel}"], capture_output=True, timeout=60)
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    return r.stdout if r.returncode == 0 else None
+
+
+def arxml_delta(root: str, commit: str, rel: str) -> dict:
+    """Semantic delta of one ARXML file across ``commit`` (parent -> commit), via diff.diff on temp copies."""
+    from .diff import diff
+    before, after = _blob(root, f"{commit}^", rel), _blob(root, commit, rel)
+    if before is None and after is None:
+        return {"file": rel, "error": "blob not readable"}
+    if before is None or after is None:
+        return {"file": rel, "status": "added" if before is None else "deleted"}
+    with tempfile.TemporaryDirectory(prefix="h2l-hist-") as tmp:
+        a, b = os.path.join(tmp, "a.arxml"), os.path.join(tmp, "b.arxml")
+        open(a, "wb").write(before)
+        open(b, "wb").write(after)
+        try:
+            d = diff(a, b, root=tmp)
+        except Exception as ex:  # noqa: BLE001
+            return {"file": rel, "error": f"arxml_diff failed: {ex}"}
+    items = [f"+ {x['path']} ({x['tag']})" for x in d["added"]] + [f"- {x['path']} ({x['tag']})" for x in d["removed"]]
+    for x in d["changed"]:
+        vals = x.get("values")
+        items.append(f"~ {x['path']}" + (": " + ", ".join(f"{k} {v[0]}->{v[1]}" for k, v in sorted(vals.items()))
+                                          if vals else " (content)"))
+    return {"file": rel, "summary": d["summary"], "items": items[:MAX_DELTA_ITEMS],
+            "more": max(0, len(items) - MAX_DELTA_ITEMS)}
+
+
+def c_hunks(root: str, commit: str, rel: str) -> str:
+    out = _git(root, "show", "--format=", "--no-color", "--no-ext-diff", "-U2", commit, "--", rel) or ""
+    body = "\n".join(ln for ln in out.splitlines() if not ln.startswith(("diff --git", "index ", "--- ", "+++ ")))
+    return body if len(body) <= MAX_HUNK_CHARS else body[:MAX_HUNK_CHARS] + "\n… (hunk truncated)"
+
+
+def similar_changes(root: str, files: list, related: list, task_terms: set, limit: int = 5,
+                    max_commits: int = MAX_COMMITS) -> dict:
+    """files: the SW-C's own ARXML/C files (abs); related: those of similar SW-Cs. -> {changes, scanned, notes}."""
+    if not is_repo(root):
+        return {"changes": [], "scanned": 0, "notes": ["not a git repository; no history"]}
+    rels = sorted({os.path.relpath(f, root) for f in files + related if f and os.path.exists(f)})
+    own = {os.path.relpath(f, root) for f in files if f}
+    if not rels:
+        return {"changes": [], "scanned": 0, "notes": ["no files to look up in history"]}
+    log = _git(root, "log", f"-n{max_commits}", "--format=%x1e%H%x1f%ct%x1f%s", "--name-only", "--", *rels) or ""
+    commits = []
+    for chunk in log.split("\x1e"):
+        if not chunk.strip():
+            continue
+        head, *names = chunk.strip("\n").split("\n")
+        h, ct, subj = (head.split("\x1f") + ["", ""])[:3]
+        commits.append((h, int(ct or 0), subj, [n for n in names if n.strip() in rels]))
+    scored = []
+    for i, (h, ct, subj, touched) in enumerate(commits):
+        text = subj + "\n" + "\n".join(touched)
+        overlap = terms_of(text) & task_terms
+        scored.append((i, h, ct, subj, touched, overlap))
+    # cheap first pass by subject/file overlap + recency; expensive deltas only for the best candidates
+    pre = sorted(scored, key=lambda x: (-(len(x[5]) * 2 + (1 if set(x[4]) & own else 0)), x[0]))[:limit * 3]
+    out = []
+    for i, h, ct, subj, touched, _ov in pre:
+        deltas, hunks = [], []
+        budget = MAX_COMMIT_CHARS
+        # the SW-C's own files first, then the rest, at most MAX_FILES_PER_COMMIT
+        touched = sorted(touched, key=lambda r: (r not in own, r))[:MAX_FILES_PER_COMMIT]
+        for rel in touched:
+            if rel.lower().endswith(".arxml"):
+                deltas.append(arxml_delta(root, h, rel))
+            elif rel.lower().endswith((".c", ".h")) and budget > 0:
+                d = c_hunks(root, h, rel)
+                if len(d) > budget:
+                    d = d[:budget] + "\n… (commit diff truncated)"
+                budget -= len(d)
+                hunks.append({"file": rel, "diff": d})
+        full = subj + "\n" + "\n".join(json_lines(deltas)) + "\n" + "\n".join(x["diff"] for x in hunks)
+        overlap = sorted(terms_of(full) & task_terms)
+        recency = 1.0 / (1 + i)
+        score = round(len(overlap) + recency + (0.5 if set(touched) & own else 0.0), 4)
+        out.append({"commit": h[:12], "subject": subj, "score": score, "overlap": overlap[:20],
+                    "ownFiles": sorted(set(touched) & own), "arxml": deltas, "c": hunks, "_order": i})
+    out.sort(key=lambda x: (-x["score"], x["_order"]))
+    for x in out:
+        x.pop("_order")
+    return {"changes": out[:limit], "scanned": len(commits), "notes": []}
+
+
+def json_lines(deltas: list) -> list:
+    lines = []
+    for d in deltas:
+        lines.append(d.get("file", ""))
+        lines.extend(d.get("items", []))
+    return lines

package/python/ecuc_engine/model.py

@@ -283,9 +283,12 @@ class Project:
             self._load(f)
         self.foreign: dict = {}
         self.input_loaded = False
+        from .sysmodel import SystemIndex
+        self.system = SystemIndex()
         if load_input:
             for f in self.sources.input:
-                self.foreign.update(index_identifiables(f))
+                self.system.add_file(f)
+            self.foreign = self.system.foreign()
             self.input_loaded = bool(self.sources.input)
         self.reindex()