@sigloch/se-engine 1.6.1 → 1.7.0

package/dist/fix-templates.js

@@ -183,10 +183,161 @@ function edgeToMentioned(opts) {
         return null;
     };
 }
+/**
+ * Kante zu einem Ziel aus `context.candidate_targets` — der zweite Kandidatenweg (CR-SM-342).
+ *
+ * `edgeToMentioned` sucht im ELEMENTTEXT. Das traegt, wo der Text das Ziel nennt (CR-Text nennt
+ * seine FUNC), und traegt nicht, wo die Regel den Kandidatenkreis ohnehin schon mitliefert.
+ * Gemessen an einem vollen Spezifikationslauf: R-02 (86 Befunde), RD-01 (71), R-31 (42) und
+ * R-30 (40) tragen ihre `candidate_targets` zu 100 % — 239 Befunde, fuer die ein Template
+ * nichts SUCHEN muss. Es gab nur keins.
+ *
+ * Die Kandidaten kommen aus `toCandidates` und sind bereits nach Token-Ueberlappung mit dem
+ * Fund-Element sortiert: der erste, der alle Riegel passiert, gewinnt. Die Riegel sind
+ * dieselben wie im Textweg, in derselben Reihenfolge — eine Vorschlagsquelle mehr, kein
+ * zweiter Legalitaetsbegriff.
+ *
+ * WARUM DER KINDS-RIEGEL HIER TRAEGT, nicht nur formal: fuer `satisfy` FUNC→REQ laesst das
+ * Muster nur {functional, postcondition, precondition} zu. Am selben Modell gemessen sind
+ * 42 von 80 REQ nicht-funktional — eine Vorlage, die blind den erstbesten Kandidaten nimmt,
+ * haette in 53 % der Faelle die Kante vorgeschlagen, die R-18 sofort abweist. Das war im Lauf
+ * bereits die groesste Ablehnungsklasse (39 von 118 Fehlern); sie zu automatisieren haette
+ * den Waste nicht gesenkt, sondern vervielfacht.
+ */
+function edgeToCandidate(opts) {
+    return (v, g) => {
+        const cands = v.context?.candidate_targets;
+        if (!Array.isArray(cands) || cands.length === 0)
+            return null;
+        const el = byId(g, v.element_id);
+        if (!el)
+            return null;
+        for (const cand of cands) {
+            const other = byId(g, cand.id);
+            if (!other || other.id === el.id)
+                continue;
+            if (opts.types && !opts.types.includes(other.type))
+                continue;
+            const source = opts.direction === 'out' ? el : other;
+            const target = opts.direction === 'out' ? other : el;
+            if (hasTrace(g, source.id, target.id, opts.traceType))
+                continue;
+            if (!isValidTrace({
+                source: source.type, target: target.type, type: opts.traceType,
+                sourceKinds: source.kinds, targetKinds: target.kinds,
+            }))
+                continue;
+            const retire = retireFor(g, source, target, opts.traceType);
+            if (retire === 'blocked')
+                continue;
+            const file = retire ? realFileOf(source) : undefined;
+            return {
+                op: 'add-trace',
+                source: source.id,
+                target: target.id,
+                type: opts.traceType,
+                rationale: `${other.id} ist der bestplatzierte Kandidat des Befunds und die Kante ` +
+                    `${source.type} -${opts.traceType}-> ${target.type} ist zulaessig`,
+                ...(retire ? { retire } : {}),
+                ...(retire && file ? { codeImpact: { file, targetModule: target.id } } : {}),
+            };
+        }
+        return null;
+    };
+}
+/**
+ * Die abgewiesene Kante reparieren — UMHAENGEN, nicht anhaengen (CR-SM-342).
+ *
+ * Eine illegale Kante verschwindet nicht dadurch, dass eine legale danebengelegt wird: der
+ * Befund bliebe stehen. Deshalb traegt jeder Vorschlag hier ein `retire` auf genau die
+ * beanstandete Kante — Anwendung als EIN Batch [delete, add], wie CR-GC-435 es fuer die
+ * Kardinalitaet schon eingefuehrt hat.
+ *
+ * NUR EINDEUTIGE FAELLE. Nennt der Grund mehr als eine Alternative, ist die Wahl eine
+ * Entscheidung und kein Zug — dann `null`, und der Fund bleibt Fund-Ebene. Das ist dieselbe
+ * Linie wie R-23s fehlender `uniqueFallback`: lieber keine Empfehlung als eine geratene.
+ *
+ * Der kinds-Fall hat eine Ausnahme, die KEINE Raterei ist: schlaegt `satisfy` einer FUNC an
+ * einem nicht-funktionalen REQ fehl und ist MOD eine zulaessige Quelle, dann ist das Modul
+ * der FUNC der Traeger — `FUNC -allocate-> MOD` steht im Graphen und macht die Wahl
+ * deterministisch. Gemessen war das die groesste Einzelklasse des Laufs (39 von 118).
+ */
+function rejectedEdgeFix(rej, v, g) {
+    if (!rej)
+        return null;
+    const el = byId(g, v.element_id);
+    if (!el)
+        return null;
+    // Quelle und Ziel stehen BEIDE am Befund (CR-SM-342): `element_id` ist die Quelle,
+    // `target_id` das Ziel. Die Kante im Graphen zu suchen waere falsch — bei einem dryRun,
+    // der sie gerade abgelehnt hat, steht sie im Arbeitsgraphen gar nicht.
+    const target = byId(g, rej.target_id);
+    if (!target)
+        return null;
+    const retire = {
+        source: el.id,
+        target: target.id,
+        type: rej.trace_type,
+        rationale: `${el.id} -${rej.trace_type}-> ${target.id} ist unzulaessig (${rej.reason}) und muss weichen`,
+    };
+    if (rej.reason === 'no-pattern') {
+        if (rej.candidate_trace_types.length !== 1)
+            return null;
+        const typ = rej.candidate_trace_types[0];
+        if (hasTrace(g, el.id, target.id, typ))
+            return null;
+        return {
+            op: 'add-trace', source: el.id, target: target.id, type: typ,
+            rationale: `${rej.source_type} → ${rej.target_type} kennt genau einen Kantentyp: ${typ}`,
+            retire,
+        };
+    }
+    // kinds-mismatch / kinds-undeclared: die Kante ist richtig, die QUELLE ist es nicht.
+    if (rej.candidate_sources.length === 0)
+        return null;
+    const traeger = g.traces
+        .filter((t) => t.source === el.id && t.type === 'allocate')
+        .map((t) => byId(g, t.target))
+        .filter((m) => !!m && rej.candidate_sources.includes(m.type));
+    if (traeger.length !== 1)
+        return null;
+    const neu = traeger[0];
+    if (hasTrace(g, neu.id, target.id, rej.trace_type))
+        return null;
+    if (!isValidTrace({
+        source: neu.type, target: target.type, type: rej.trace_type,
+        sourceKinds: neu.kinds, targetKinds: target.kinds,
+    }))
+        return null;
+    return {
+        op: 'add-trace', source: neu.id, target: target.id, type: rej.trace_type,
+        rationale: `${target.id} traegt ${rej.field} {${(rej.declared ?? []).join(', ')}} — das Muster ` +
+            `${rej.source_type} → ${rej.target_type} laesst das nicht zu, ${neu.id} (${neu.type}) schon, ` +
+            `und ${el.id} ist genau dorthin alloziert`,
+        retire,
+    };
+}
 export const FIX_TEMPLATES = {
     // CR-SM-295: SCHEMA gehoert zum Umfang — ein CR, der nur einen Datenvertrag aendert,
     // ist ein vollstaendiger CR. Die Liste ist woertlich SCOPE_TYPES aus cr-quality-rules.
     'CR-R01': relationToMentioned(['UC', 'REQ', 'FUNC', 'MOD', 'SCHEMA']),
+    // --- Kandidaten-Operatoren (CR-SM-342) -------------------------------------
+    // Die vier teuersten Operator-Regeln des gemessenen Laufs. `CLASS_MAP` fuehrte sie
+    // laengst als mechanisch loesbar, ihre Befunde tragen ihre Kandidaten zu 100 %, und
+    // keine hatte eine Vorlage: 239 Befunde ohne ausfuehrbare Empfehlung.
+    // FUNC ohne satisfy → das bestplatzierte REQ, dessen kinds das Muster zulaesst.
+    // Der kinds-Riegel ist hier der ganze Punkt, nicht Formsache (s. edgeToCandidate).
+    'R-02': edgeToCandidate({ traceType: 'satisfy', direction: 'out', types: ['REQ'] }),
+    // REQ ohne Aufloesung → dieselbe satisfy-Kante, aber der Fund sitzt am REQ:
+    // die Kandidaten sind die Quellen (FUNC/MOD/…), also laeuft die Kante herein.
+    'RD-01': edgeToCandidate({ traceType: 'satisfy', direction: 'in' }),
+    // FUNC ohne io → der FLOW, den der Befund nennt. Richtung aus der Kante selbst:
+    // `isValidTrace` kennt beide Muster (FUNC→FLOW und FLOW→FUNC), und 'out' probiert
+    // FUNC→FLOW zuerst; passt nur die Gegenrichtung, faellt der Kandidat durch und der
+    // naechste kommt dran — kein Raten ueber die Richtung.
+    'R-31': edgeToCandidate({ traceType: 'io', direction: 'out', types: ['FLOW'] }),
+    // FUNC ohne Wirkkette → compose von der FCHAIN herein (einziges legales Muster).
+    'R-30': edgeToCandidate({ traceType: 'compose', direction: 'in', types: ['FCHAIN'] }),
     // --- Architektur-Operatoren (CR-SM-241) ------------------------------------
     // Ohne sie hat auf `layer: 'arch'` — graphcodes DEFAULT-Messebene — jeder
     // Template-Edit Δm = 0, weil CR/MS/UC gar nicht im Teilgraphen liegen.
@@ -223,6 +374,14 @@ export const FIX_TEMPLATES = {
      * durchgesetzte Untergrenze dazu, traegt dieses Template sie ohne Aenderung.
      */
     'R-18': (v, g) => {
+        // CR-SM-342: R-18 hat vier Beine, und bis hierher bediente das Template genau eins.
+        // Gemessen an einem vollen Lauf: 48 von 56 Befunden kamen aus der KANTEN-GRAMMATIK und
+        // fielen in der Zeile darueber heraus, weil sie kein `candidate_targets` tragen — die
+        // Regel mit den meisten Ablehnungen war die einzige ohne Empfehlung. Seit CR-SM-341
+        // traegt sie ihren Grund als `context.trace_rejection`; hier wird er bedient.
+        const rej = v.context?.trace_rejection;
+        if (rej)
+            return rejectedEdgeFix(rej, v, g);
         if (!Array.isArray(v.context?.candidate_targets))
             return null;
         const el = byId(g, v.element_id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigloch/se-engine",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",