yarramate 1.36.0 → 1.37.0

package/dist/interrogate-command.d.ts

@@ -19,7 +19,7 @@ import type { Diagnostic, ResolvedProfileContext, SemanticGraph, WorkspaceSource
  * a fixture and fails if evaluation moves without this bumping, so the rule is
  * enforced rather than remembered.
  */
-export declare const INTERROGATION_SEMANTICS_VERSION = "1";
+export declare const INTERROGATION_SEMANTICS_VERSION = "2";
 export interface CatalogueSelector {
     /**
      * Kinds to select. Absent selects every concept, which is what a

package/dist/interrogate-command.js

@@ -22,7 +22,7 @@ import { validateCatalogue } from './schema-validation.js';
  * a fixture and fails if evaluation moves without this bumping, so the rule is
  * enforced rather than remembered.
  */
-export const INTERROGATION_SEMANTICS_VERSION = '1';
+export const INTERROGATION_SEMANTICS_VERSION = '2';
 const indexGraph = (graph) => {
     const relationshipIds = new Set(graph.subjects
         .filter(({ type }) => type === 'relationship')

package/dist/subject-identity.js

@@ -72,11 +72,20 @@ export const normalizeLabel = (label) => label
     .split(/[^a-z0-9]+/)
     .filter((token) => token.length > 0)
     .map(singularize);
+// Only the trailing run is stripped, because a role noun qualifies the name
+// it follows: `order-gateway`, `orders-service`, `payment-api`. A type word
+// anywhere else is part of the name rather than a label on it, and stripping
+// it deletes the very thing that tells two subjects apart:
+// `visual-session-server-source` and `visual-session-store-source` disagree
+// on precisely one word, and removing it from both scored them identical.
+//
 // Removing every token would erase a subject genuinely called "Gateway", so
 // a label that is nothing but type nouns keeps them.
 export const headTokens = (tokens) => {
-    const head = tokens.filter((token) => !typeTokens.has(token));
-    return head.length === 0 ? tokens : head;
+    let end = tokens.length;
+    while (end > 0 && typeTokens.has(tokens[end - 1]))
+        end -= 1;
+    return end === 0 ? tokens : tokens.slice(0, end);
 };
 const levenshtein = (left, right) => {
     if (left === right)
@@ -116,11 +125,61 @@ const jaccard = (left, right) => {
 // agree before the question opens.
 export const strongLexicalThreshold = 0.95;
 export const moderateLexicalThreshold = 0.8;
+/**
+ * Pair the two token lists one-to-one, strongest first. Two tokens correspond
+ * when they are the same word: identical after normalization, or close enough
+ * that the difference reads as a misspelling ("component" beside
+ * "componant"). The bar is `moderateLexicalThreshold` rather than a second
+ * published number, because the judgment is the one the threshold already
+ * names, asked of a shorter string.
+ *
+ * Greedy is enough and optimal pairing is not worth its cost: ties break on
+ * position, so the result is the same on any machine.
+ */
+const correspondence = (left, right) => {
+    const candidates = [];
+    for (const [leftIndex, leftToken] of left.entries()) {
+        for (const [rightIndex, rightToken] of right.entries()) {
+            const score = similarity(leftToken, rightToken);
+            if (score >= moderateLexicalThreshold) {
+                candidates.push({ score, left: leftIndex, right: rightIndex });
+            }
+        }
+    }
+    candidates.sort((first, second) => second.score - first.score ||
+        first.left - second.left ||
+        first.right - second.right);
+    const leftTaken = new Set();
+    const rightTaken = new Set();
+    for (const candidate of candidates) {
+        if (leftTaken.has(candidate.left) || rightTaken.has(candidate.right)) {
+            continue;
+        }
+        leftTaken.add(candidate.left);
+        rightTaken.add(candidate.right);
+    }
+    return { leftMatched: leftTaken.size, rightMatched: rightTaken.size };
+};
 const labelScore = (left, right) => {
     const leftHead = headTokens(normalizeLabel(left));
     const rightHead = headTokens(normalizeLabel(right));
     if (leftHead.length === 0 || rightHead.length === 0)
         return 0;
+    const pairing = correspondence(leftHead, rightHead);
+    // Each side says a word the other never says. That is a family naming its
+    // members apart, not one subject recorded twice: "Add command" beside "Ask
+    // command", `session-server` beside `session-store`, `likec4-check-result`
+    // beside `likec4-diagnostic-result`. Character overlap between such labels
+    // measures how elaborate the shared convention is rather than how alike the
+    // subjects are, and the more disciplined the naming the higher it scores,
+    // so the pair is never offered however close the strings look.
+    if (pairing.leftMatched < leftHead.length &&
+        pairing.rightMatched < rightHead.length) {
+        return 0;
+    }
+    // One list is the other, or the other plus words. Same words means the same
+    // subject named twice; extra words are what a copy looks like
+    // (`payment-batch-processor` beside `payment-batch-processor-v2`).
     return Math.max(jaccard(new Set(leftHead), new Set(rightHead)), similarity(leftHead.join(' '), rightHead.join(' ')));
 };
 // The best matching pair of labels decides, because any one alias matching