@wix/web5-core 1.56.0

package/dist/cjs/patternAnalyzer/mergeDetector.js

@@ -0,0 +1,505 @@
+"use strict";
+
+exports.__esModule = true;
+exports.detectMergeOpportunities = detectMergeOpportunities;
+var _lexer = require("../patternValidator/lexer");
+var _parser = require("../patternValidator/parser");
+var _patternValidator = require("../patternValidator");
+var _testUtils = require("../testUtils");
+var _markdownGenerator = require("./markdownGenerator");
+var _patternWriter = require("./patternWriter");
+// ─── Quantifier utilities ─────────────────────────────────────────────────────
+
+function quantifierEqual(q1, q2) {
+  if (!q1 && !q2) {
+    return true;
+  }
+  if (!q1 || !q2) {
+    return false;
+  }
+  if (q1.type !== q2.type) {
+    return false;
+  }
+  return q1.min === q2.min && q1.max === q2.max;
+}
+function mergeQuantifiers(q1, q2) {
+  // Convert to [min, max] where undefined max = Infinity
+  function toRange(q) {
+    if (!q) {
+      return [1, 1];
+    } // no quantifier means exactly 1
+    switch (q.type) {
+      case 'exact':
+        return [q.min, q.min];
+      case 'range':
+        return [q.min ?? 0, q.max];
+      case 'optional':
+        return [0, 1];
+      case 'plus':
+        return [1, undefined];
+      case 'star':
+        return [0, undefined];
+    }
+  }
+  const [min1, max1] = toRange(q1);
+  const [min2, max2] = toRange(q2);
+  const newMin = Math.min(min1, min2);
+  const newMax = max1 === undefined || max2 === undefined ? undefined : Math.max(max1, max2);
+  if (newMin === 0 && newMax === 1) {
+    return {
+      type: 'optional',
+      min: 0,
+      max: 1
+    };
+  }
+  if (newMin === 0 && newMax === undefined) {
+    return {
+      type: 'star',
+      min: 0
+    };
+  }
+  if (newMin === 1 && newMax === undefined) {
+    return {
+      type: 'plus',
+      min: 1
+    };
+  }
+  if (newMin === newMax && newMax !== undefined) {
+    return {
+      type: 'exact',
+      min: newMin,
+      max: newMin
+    };
+  }
+  return {
+    type: 'range',
+    min: newMin,
+    max: newMax
+  };
+}
+function formatQuantifier(q) {
+  if (!q) {
+    return '(exactly 1)';
+  }
+  switch (q.type) {
+    case 'exact':
+      return `[${q.min}]`;
+    case 'range':
+      return q.max === undefined ? `[${q.min ?? 0}-]` : `[${q.min ?? 0}-${q.max}]`;
+    case 'optional':
+      return '?';
+    case 'plus':
+      return '+';
+    case 'star':
+      return '*';
+  }
+}
+
+// ─── Structural diff ──────────────────────────────────────────────────────────
+
+function structuralDiff(n1, n2, path = []) {
+  if (n1.kind !== n2.kind) {
+    // Special case: both could be sequences with one extra element
+    if (n1.kind === 'sequence' && n2.kind === 'sequence') {
+      return diffSequences(n1.children, n2.children, path, false);
+    }
+    return {
+      diffType: 'incompatible'
+    };
+  }
+  switch (n1.kind) {
+    case 'element':
+      {
+        const n2e = n2;
+        if (n1.element !== n2e.element) {
+          return {
+            diffType: 'incompatible'
+          };
+        }
+        if (!quantifierEqual(n1.quantifier, n2e.quantifier)) {
+          return {
+            diffType: 'quantifier',
+            path,
+            q1: n1.quantifier,
+            q2: n2e.quantifier,
+            field: 'quantifier'
+          };
+        }
+        // We don't diff attribute selectors — that's too complex
+        return {
+          diffType: 'none'
+        };
+      }
+    case 'sequence':
+      {
+        const n2s = n2;
+        return diffSequences(n1.children, n2s.children, path, false);
+      }
+    case 'alternation':
+      {
+        const n2a = n2;
+        if (!quantifierEqual(n1.quantifier, n2a.quantifier)) {
+          return {
+            diffType: 'quantifier',
+            path,
+            q1: n1.quantifier,
+            q2: n2a.quantifier,
+            field: 'quantifier'
+          };
+        }
+        const set1 = n1.choices.map(c => (0, _patternWriter.serializePatternNode)(c));
+        const set2 = n2a.choices.map(c => (0, _patternWriter.serializePatternNode)(c));
+        const sameChoices = set1.length === set2.length && set1.every(s => set2.includes(s));
+        if (sameChoices) {
+          return {
+            diffType: 'none'
+          };
+        }
+        return {
+          diffType: 'alternation',
+          path,
+          set1,
+          set2,
+          n1choices: n1.choices,
+          n2choices: n2a.choices,
+          altQuantifier: n1.quantifier
+        };
+      }
+    case 'group':
+      {
+        const n2g = n2;
+        if (!quantifierEqual(n1.quantifier, n2g.quantifier)) {
+          return {
+            diffType: 'quantifier',
+            path,
+            q1: n1.quantifier,
+            q2: n2g.quantifier,
+            field: 'quantifier'
+          };
+        }
+        return structuralDiff(n1.pattern, n2g.pattern, [...path, 0]);
+      }
+    case 'list':
+      {
+        const n2l = n2;
+        if (!quantifierEqual(n1.quantifier, n2l.quantifier)) {
+          return {
+            diffType: 'quantifier',
+            path,
+            q1: n1.quantifier,
+            q2: n2l.quantifier,
+            field: 'quantifier'
+          };
+        }
+        if (!quantifierEqual(n1.itemCount, n2l.itemCount)) {
+          return {
+            diffType: 'quantifier',
+            path: [...path, -1],
+            // -1 sentinel = itemCount field
+            q1: n1.itemCount,
+            q2: n2l.itemCount,
+            field: 'itemCount'
+          };
+        }
+        return {
+          diffType: 'none'
+        };
+      }
+  }
+}
+function diffSequences(children1, children2, path, _unused) {
+  if (children1.length === children2.length) {
+    const diffs = children1.map((c, i) => structuralDiff(c, children2[i], [...path, i]));
+    const nonNone = diffs.filter(d => d.diffType !== 'none');
+    if (nonNone.length === 0) {
+      return {
+        diffType: 'none'
+      };
+    }
+    if (nonNone.length === 1) {
+      return nonNone[0];
+    }
+    return {
+      diffType: 'incompatible'
+    };
+  }
+  const lenDiff = Math.abs(children1.length - children2.length);
+  if (lenDiff !== 1) {
+    return {
+      diffType: 'incompatible'
+    };
+  }
+  const [shorter, longer, extraInAst2] = children1.length < children2.length ? [children1, children2, true] : [children2, children1, false];
+
+  // Try removing each element from the longer sequence to see if it matches the shorter
+  for (let insertPos = 0; insertPos < longer.length; insertPos++) {
+    const candidate = longer.filter((_, i) => i !== insertPos);
+    if (candidate.length !== shorter.length) {
+      continue;
+    }
+    const diffs = candidate.map((c, i) => structuralDiff(c, shorter[i], [...path, i]));
+    if (diffs.every(d => d.diffType === 'none')) {
+      return {
+        diffType: 'optional_element',
+        path: [...path, insertPos],
+        extraIndex: insertPos,
+        extraNode: longer[insertPos],
+        extraInAst2
+      };
+    }
+  }
+  return {
+    diffType: 'incompatible'
+  };
+}
+
+// ─── AST path-based modification ─────────────────────────────────────────────
+
+/**
+ * Navigate to a node at the given path and apply a transform.
+ * Path semantics:
+ *   - For sequence: path[i] is the index in children[]
+ *   - For group: path[0] navigates into pattern
+ *   - For list: path[-1] (sentinel) means apply transform to the list node itself
+ *   - For alternation: path[i] is the index in choices[]
+ */
+function applyAtPath(ast, path, transform) {
+  if (path.length === 0) {
+    return transform(ast);
+  }
+  const [head, ...rest] = path;
+  switch (ast.kind) {
+    case 'sequence':
+      {
+        if (head < 0) {
+          return transform(ast);
+        } // sentinel → transform this node
+        const newChildren = ast.children.map((c, i) => i === head ? applyAtPath(c, rest, transform) : c);
+        return {
+          ...ast,
+          children: newChildren
+        };
+      }
+    case 'group':
+      return {
+        ...ast,
+        pattern: applyAtPath(ast.pattern, rest, transform)
+      };
+    case 'list':
+      if (head === -1) {
+        return transform(ast);
+      } // itemCount sentinel
+      return ast;
+    case 'alternation':
+      {
+        if (head < 0) {
+          return transform(ast);
+        }
+        const newChoices = ast.choices.map((c, i) => i === head ? applyAtPath(c, rest, transform) : c);
+        return {
+          ...ast,
+          choices: newChoices
+        };
+      }
+    default:
+      return ast;
+  }
+}
+
+// ─── Build merged pattern string ─────────────────────────────────────────────
+
+function buildMergedPattern(ast1, ast2, diff) {
+  if (diff.diffType === 'none' || diff.diffType === 'incompatible') {
+    return null;
+  }
+  switch (diff.diffType) {
+    case 'quantifier':
+      {
+        const merged = mergeQuantifiers(diff.q1, diff.q2);
+        const newAst = applyAtPath(ast1, diff.path, node => {
+          if (diff.field === 'itemCount' && node.kind === 'list') {
+            return {
+              ...node,
+              itemCount: merged
+            };
+          }
+          // For element/group/alternation/list (outer quantifier)
+          return {
+            ...node,
+            quantifier: merged
+          };
+        });
+        return (0, _patternWriter.serializePatternNode)(newAst);
+      }
+    case 'alternation':
+      {
+        const existingSer = new Set(diff.set1);
+        const extraChoices = diff.n2choices.filter(c => !existingSer.has((0, _patternWriter.serializePatternNode)(c)));
+        const unionChoices = [...diff.n1choices, ...extraChoices];
+        const merged = {
+          kind: 'alternation',
+          choices: unionChoices,
+          quantifier: diff.altQuantifier
+        };
+        const newAst = applyAtPath(ast1, diff.path, () => merged);
+        return (0, _patternWriter.serializePatternNode)(newAst);
+      }
+    case 'optional_element':
+      {
+        // Make the extra element optional in the longer AST
+        const isAst1Longer = ast1.kind === 'sequence' && ast2.kind === 'sequence' ? ast1.children.length > ast2.children.length : !diff.extraInAst2;
+        const longerAst = isAst1Longer ? ast1 : ast2;
+        const newAst = applyAtPath(longerAst, diff.path, node => ({
+          ...node,
+          quantifier: {
+            type: 'optional',
+            min: 0,
+            max: 1
+          }
+        }));
+        return (0, _patternWriter.serializePatternNode)(newAst);
+      }
+  }
+}
+
+// ─── Subsumption check ────────────────────────────────────────────────────────
+
+/**
+ * Sample-based subsumption: checks if all generated samples of p1 are also matched by p2.
+ * Returns true if L(p1) ⊆ L(p2) based on the generated sample set.
+ */
+function isSubsumedBy(p1, p2) {
+  const samples = (0, _markdownGenerator.generateMarkdownVariants)(p1);
+  if (samples.length === 0) {
+    return false;
+  }
+  return samples.every(markdown => {
+    const nodes = (0, _testUtils.parseMarkdownToAst)(markdown).children;
+    return (0, _patternValidator.validatePattern)(nodes, p2).valid;
+  });
+}
+
+// ─── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Detect intra-definition merge opportunities: pairs of patterns within a single
+ * definition that could be combined into one.
+ *
+ * Checks (in order):
+ * 1. Subsumption: L(P1) ⊆ L(P2) or vice-versa — one pattern is redundant
+ * 2. Structural diff: single-point divergence classified as:
+ *    - quantifier_widening: same structure but differing quantifier
+ *    - alternation_extension: same structure but differing alternation choices
+ *    - optional_element: one pattern is the other + one extra element
+ */
+function detectMergeOpportunities(definitions) {
+  const opportunities = [];
+  for (const entry of definitions) {
+    const patterns = entry.definition.patterns;
+    if (patterns.length < 2) {
+      continue;
+    }
+    for (let i = 0; i < patterns.length; i++) {
+      for (let j = i + 1; j < patterns.length; j++) {
+        const p1 = patterns[i];
+        const p2 = patterns[j];
+
+        // 1. Check for subsumption (cheapest check)
+        if (isSubsumedBy(p1, p2)) {
+          opportunities.push({
+            sectionType: entry.sectionType,
+            pattern1: p1,
+            pattern2: p2,
+            kind: 'subsumption',
+            suggestedPattern: p2,
+            rationale: `All generated samples of P1 are also matched by P2. P1 may be redundant.`
+          });
+          continue;
+        }
+        if (isSubsumedBy(p2, p1)) {
+          opportunities.push({
+            sectionType: entry.sectionType,
+            pattern1: p1,
+            pattern2: p2,
+            kind: 'subsumption',
+            suggestedPattern: p1,
+            rationale: `All generated samples of P2 are also matched by P1. P2 may be redundant.`
+          });
+          continue;
+        }
+
+        // 2. Structural diff
+        let ast1, ast2;
+        try {
+          ast1 = (0, _parser.parse)((0, _lexer.tokenize)(p1));
+          ast2 = (0, _parser.parse)((0, _lexer.tokenize)(p2));
+        } catch {
+          continue;
+        }
+        const diff = structuralDiff(ast1, ast2);
+        if (diff.diffType === 'none') {
+          // Identical patterns — one is fully redundant
+          opportunities.push({
+            sectionType: entry.sectionType,
+            pattern1: p1,
+            pattern2: p2,
+            kind: 'subsumption',
+            suggestedPattern: p1,
+            rationale: `Patterns are structurally identical. One can be removed.`
+          });
+          continue;
+        }
+        if (diff.diffType === 'incompatible') {
+          continue;
+        }
+        const suggestedPattern = buildMergedPattern(ast1, ast2, diff);
+        if (!suggestedPattern) {
+          continue;
+        }
+        switch (diff.diffType) {
+          case 'quantifier':
+            {
+              const fieldLabel = diff.field === 'itemCount' ? 'item count' : 'quantifier';
+              opportunities.push({
+                sectionType: entry.sectionType,
+                pattern1: p1,
+                pattern2: p2,
+                kind: 'quantifier_widening',
+                suggestedPattern,
+                rationale: `Patterns differ only in ${fieldLabel}: ${formatQuantifier(diff.q1)} vs ${formatQuantifier(diff.q2)}. Merge to ${formatQuantifier(mergeQuantifiers(diff.q1, diff.q2))}.`
+              });
+              break;
+            }
+          case 'alternation':
+            {
+              const newChoices = [...new Set([...diff.set1, ...diff.set2])];
+              opportunities.push({
+                sectionType: entry.sectionType,
+                pattern1: p1,
+                pattern2: p2,
+                kind: 'alternation_extension',
+                suggestedPattern,
+                rationale: `Patterns differ only in alternation choices: (${diff.set1.join(' | ')}) vs (${diff.set2.join(' | ')}). Union: (${newChoices.join(' | ')}).`
+              });
+              break;
+            }
+          case 'optional_element':
+            {
+              const extraStr = (0, _patternWriter.serializePatternNode)(diff.extraNode);
+              opportunities.push({
+                sectionType: entry.sectionType,
+                pattern1: p1,
+                pattern2: p2,
+                kind: 'optional_element',
+                suggestedPattern,
+                rationale: `One pattern has an extra element \`${extraStr}\` not in the other. Making it optional merges both patterns.`
+              });
+              break;
+            }
+        }
+      }
+    }
+  }
+  return opportunities;
+}
+//# sourceMappingURL=mergeDetector.js.map

package/dist/cjs/patternAnalyzer/mergeDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_lexer","require","_parser","_patternValidator","_testUtils","_markdownGenerator","_patternWriter","quantifierEqual","q1","q2","type","min","max","mergeQuantifiers","toRange","q","undefined","min1","max1","min2","max2","newMin","Math","newMax","formatQuantifier","structuralDiff","n1","n2","path","kind","diffSequences","children","diffType","n2e","element","quantifier","field","n2s","n2a","set1","choices","map","c","serializePatternNode","set2","sameChoices","length","every","s","includes","n1choices","n2choices","altQuantifier","n2g","pattern","n2l","itemCount","children1","children2","_unused","diffs","i","nonNone","filter","d","lenDiff","abs","shorter","longer","extraInAst2","insertPos","candidate","_","extraIndex","extraNode","applyAtPath","ast","transform","head","rest","newChildren","newChoices","buildMergedPattern","ast1","ast2","diff","merged","newAst","node","existingSer","Set","extraChoices","has","unionChoices","isAst1Longer","longerAst","isSubsumedBy","p1","p2","samples","generateMarkdownVariants","markdown","nodes","parseMarkdownToAst","validatePattern","valid","detectMergeOpportunities","definitions","opportunities","entry","patterns","definition","j","push","sectionType","pattern1","pattern2","suggestedPattern","rationale","parse","tokenize","fieldLabel","join","extraStr"],"sources":["../../../src/patternAnalyzer/mergeDetector.ts"],"sourcesContent":["import { tokenize } from '../patternValidator/lexer';\nimport { parse } from '../patternValidator/parser';\nimport { validatePattern } from '../patternValidator';\nimport { parseMarkdownToAst } from '../testUtils';\nimport { generateMarkdownVariants } from './markdownGenerator';\nimport { serializePatternNode } from './patternWriter';\nimport type { DefinitionEntry, MergeOpportunity } from './types';\nimport type { PatternNode, Quantifier } from '../patternValidator/types';\nimport type { RootContent } from 'mdast';\n\n// ─── Quantifier utilities ─────────────────────────────────────────────────────\n\nfunction quantifierEqual(q1?: Quantifier, q2?: Quantifier): boolean {\n  if (!q1 && !q2) {\n    return true;\n  }\n  if (!q1 || !q2) {\n    return false;\n  }\n  if (q1.type !== q2.type) {\n    return false;\n  }\n  return q1.min === q2.min && q1.max === q2.max;\n}\n\nfunction mergeQuantifiers(\n  q1: Quantifier | undefined,\n  q2: Quantifier | undefined,\n): Quantifier {\n  // Convert to [min, max] where undefined max = Infinity\n  function toRange(q?: Quantifier): [number, number | undefined] {\n    if (!q) {\n      return [1, 1];\n    } // no quantifier means exactly 1\n    switch (q.type) {\n      case 'exact':\n        return [q.min!, q.min!];\n      case 'range':\n        return [q.min ?? 0, q.max];\n      case 'optional':\n        return [0, 1];\n      case 'plus':\n        return [1, undefined];\n      case 'star':\n        return [0, undefined];\n    }\n  }\n\n  const [min1, max1] = toRange(q1);\n  const [min2, max2] = toRange(q2);\n\n  const newMin = Math.min(min1, min2);\n  const newMax =\n    max1 === undefined || max2 === undefined ? undefined : Math.max(max1, max2);\n\n  if (newMin === 0 && newMax === 1) {\n    return { type: 'optional', min: 0, max: 1 };\n  }\n  if (newMin === 0 && newMax === undefined) {\n    return { type: 'star', min: 0 };\n  }\n  if (newMin === 1 && newMax === undefined) {\n    return { type: 'plus', min: 1 };\n  }\n  if (newMin === newMax && newMax !== undefined) {\n    return { type: 'exact', min: newMin, max: newMin };\n  }\n  return { type: 'range', min: newMin, max: newMax };\n}\n\nfunction formatQuantifier(q?: Quantifier): string {\n  if (!q) {\n    return '(exactly 1)';\n  }\n  switch (q.type) {\n    case 'exact':\n      return `[${q.min}]`;\n    case 'range':\n      return q.max === undefined\n        ? `[${q.min ?? 0}-]`\n        : `[${q.min ?? 0}-${q.max}]`;\n    case 'optional':\n      return '?';\n    case 'plus':\n      return '+';\n    case 'star':\n      return '*';\n  }\n}\n\n// ─── Structural diff ──────────────────────────────────────────────────────────\n\ntype DiffResult =\n  | { diffType: 'none' }\n  | {\n      diffType: 'quantifier';\n      /** Path into the AST to the node with the differing quantifier */\n      path: number[];\n      q1: Quantifier | undefined;\n      q2: Quantifier | undefined;\n      /** Which quantifier field: 'quantifier' (default) or 'itemCount' (for list nodes) */\n      field: 'quantifier' | 'itemCount';\n    }\n  | {\n      diffType: 'alternation';\n      path: number[];\n      set1: string[];\n      set2: string[];\n      n1choices: PatternNode[];\n      n2choices: PatternNode[];\n      altQuantifier: Quantifier | undefined;\n    }\n  | {\n      diffType: 'optional_element';\n      path: number[];\n      extraIndex: number;\n      extraNode: PatternNode;\n      /** true if the extra element is in ast2, false if in ast1 */\n      extraInAst2: boolean;\n    }\n  | { diffType: 'incompatible' };\n\nfunction structuralDiff(\n  n1: PatternNode,\n  n2: PatternNode,\n  path: number[] = [],\n): DiffResult {\n  if (n1.kind !== n2.kind) {\n    // Special case: both could be sequences with one extra element\n    if (n1.kind === 'sequence' && n2.kind === 'sequence') {\n      return diffSequences(n1.children, n2.children, path, false);\n    }\n    return { diffType: 'incompatible' };\n  }\n\n  switch (n1.kind) {\n    case 'element': {\n      const n2e = n2 as Extract<PatternNode, { kind: 'element' }>;\n      if (n1.element !== n2e.element) {\n        return { diffType: 'incompatible' };\n      }\n      if (!quantifierEqual(n1.quantifier, n2e.quantifier)) {\n        return {\n          diffType: 'quantifier',\n          path,\n          q1: n1.quantifier,\n          q2: n2e.quantifier,\n          field: 'quantifier',\n        };\n      }\n      // We don't diff attribute selectors — that's too complex\n      return { diffType: 'none' };\n    }\n\n    case 'sequence': {\n      const n2s = n2 as Extract<PatternNode, { kind: 'sequence' }>;\n      return diffSequences(n1.children, n2s.children, path, false);\n    }\n\n    case 'alternation': {\n      const n2a = n2 as Extract<PatternNode, { kind: 'alternation' }>;\n      if (!quantifierEqual(n1.quantifier, n2a.quantifier)) {\n        return {\n          diffType: 'quantifier',\n          path,\n          q1: n1.quantifier,\n          q2: n2a.quantifier,\n          field: 'quantifier',\n        };\n      }\n      const set1 = n1.choices.map((c) => serializePatternNode(c));\n      const set2 = n2a.choices.map((c) => serializePatternNode(c));\n      const sameChoices =\n        set1.length === set2.length && set1.every((s) => set2.includes(s));\n      if (sameChoices) {\n        return { diffType: 'none' };\n      }\n      return {\n        diffType: 'alternation',\n        path,\n        set1,\n        set2,\n        n1choices: n1.choices,\n        n2choices: n2a.choices,\n        altQuantifier: n1.quantifier,\n      };\n    }\n\n    case 'group': {\n      const n2g = n2 as Extract<PatternNode, { kind: 'group' }>;\n      if (!quantifierEqual(n1.quantifier, n2g.quantifier)) {\n        return {\n          diffType: 'quantifier',\n          path,\n          q1: n1.quantifier,\n          q2: n2g.quantifier,\n          field: 'quantifier',\n        };\n      }\n      return structuralDiff(n1.pattern, n2g.pattern, [...path, 0]);\n    }\n\n    case 'list': {\n      const n2l = n2 as Extract<PatternNode, { kind: 'list' }>;\n      if (!quantifierEqual(n1.quantifier, n2l.quantifier)) {\n        return {\n          diffType: 'quantifier',\n          path,\n          q1: n1.quantifier,\n          q2: n2l.quantifier,\n          field: 'quantifier',\n        };\n      }\n      if (!quantifierEqual(n1.itemCount, n2l.itemCount)) {\n        return {\n          diffType: 'quantifier',\n          path: [...path, -1], // -1 sentinel = itemCount field\n          q1: n1.itemCount,\n          q2: n2l.itemCount,\n          field: 'itemCount',\n        };\n      }\n      return { diffType: 'none' };\n    }\n  }\n}\n\nfunction diffSequences(\n  children1: PatternNode[],\n  children2: PatternNode[],\n  path: number[],\n  _unused: boolean,\n): DiffResult {\n  if (children1.length === children2.length) {\n    const diffs = children1.map((c, i) =>\n      structuralDiff(c, children2[i], [...path, i]),\n    );\n    const nonNone = diffs.filter((d) => d.diffType !== 'none');\n    if (nonNone.length === 0) {\n      return { diffType: 'none' };\n    }\n    if (nonNone.length === 1) {\n      return nonNone[0];\n    }\n    return { diffType: 'incompatible' };\n  }\n\n  const lenDiff = Math.abs(children1.length - children2.length);\n  if (lenDiff !== 1) {\n    return { diffType: 'incompatible' };\n  }\n\n  const [shorter, longer, extraInAst2] =\n    children1.length < children2.length\n      ? [children1, children2, true]\n      : [children2, children1, false];\n\n  // Try removing each element from the longer sequence to see if it matches the shorter\n  for (let insertPos = 0; insertPos < longer.length; insertPos++) {\n    const candidate = longer.filter((_, i) => i !== insertPos);\n    if (candidate.length !== shorter.length) {\n      continue;\n    }\n\n    const diffs = candidate.map((c, i) =>\n      structuralDiff(c, shorter[i], [...path, i]),\n    );\n    if (diffs.every((d) => d.diffType === 'none')) {\n      return {\n        diffType: 'optional_element',\n        path: [...path, insertPos],\n        extraIndex: insertPos,\n        extraNode: longer[insertPos],\n        extraInAst2,\n      };\n    }\n  }\n\n  return { diffType: 'incompatible' };\n}\n\n// ─── AST path-based modification ─────────────────────────────────────────────\n\n/**\n * Navigate to a node at the given path and apply a transform.\n * Path semantics:\n *   - For sequence: path[i] is the index in children[]\n *   - For group: path[0] navigates into pattern\n *   - For list: path[-1] (sentinel) means apply transform to the list node itself\n *   - For alternation: path[i] is the index in choices[]\n */\nfunction applyAtPath(\n  ast: PatternNode,\n  path: number[],\n  transform: (node: PatternNode) => PatternNode,\n): PatternNode {\n  if (path.length === 0) {\n    return transform(ast);\n  }\n\n  const [head, ...rest] = path;\n\n  switch (ast.kind) {\n    case 'sequence': {\n      if (head < 0) {\n        return transform(ast);\n      } // sentinel → transform this node\n      const newChildren = ast.children.map((c, i) =>\n        i === head ? applyAtPath(c, rest, transform) : c,\n      );\n      return { ...ast, children: newChildren };\n    }\n    case 'group':\n      return { ...ast, pattern: applyAtPath(ast.pattern, rest, transform) };\n    case 'list':\n      if (head === -1) {\n        return transform(ast);\n      } // itemCount sentinel\n      return ast;\n    case 'alternation': {\n      if (head < 0) {\n        return transform(ast);\n      }\n      const newChoices = ast.choices.map((c, i) =>\n        i === head ? applyAtPath(c, rest, transform) : c,\n      );\n      return { ...ast, choices: newChoices };\n    }\n    default:\n      return ast;\n  }\n}\n\n// ─── Build merged pattern string ─────────────────────────────────────────────\n\nfunction buildMergedPattern(\n  ast1: PatternNode,\n  ast2: PatternNode,\n  diff: DiffResult,\n): string | null {\n  if (diff.diffType === 'none' || diff.diffType === 'incompatible') {\n    return null;\n  }\n\n  switch (diff.diffType) {\n    case 'quantifier': {\n      const merged = mergeQuantifiers(diff.q1, diff.q2);\n      const newAst = applyAtPath(ast1, diff.path, (node) => {\n        if (diff.field === 'itemCount' && node.kind === 'list') {\n          return { ...node, itemCount: merged };\n        }\n        // For element/group/alternation/list (outer quantifier)\n        return { ...node, quantifier: merged } as PatternNode;\n      });\n      return serializePatternNode(newAst);\n    }\n\n    case 'alternation': {\n      const existingSer = new Set(diff.set1);\n      const extraChoices = diff.n2choices.filter(\n        (c) => !existingSer.has(serializePatternNode(c)),\n      );\n      const unionChoices = [...diff.n1choices, ...extraChoices];\n\n      const merged: PatternNode = {\n        kind: 'alternation',\n        choices: unionChoices,\n        quantifier: diff.altQuantifier,\n      };\n      const newAst = applyAtPath(ast1, diff.path, () => merged);\n      return serializePatternNode(newAst);\n    }\n\n    case 'optional_element': {\n      // Make the extra element optional in the longer AST\n      const isAst1Longer =\n        ast1.kind === 'sequence' && ast2.kind === 'sequence'\n          ? ast1.children.length > ast2.children.length\n          : !diff.extraInAst2;\n      const longerAst = isAst1Longer ? ast1 : ast2;\n\n      const newAst = applyAtPath(longerAst, diff.path, (node) => ({\n        ...node,\n        quantifier: { type: 'optional' as const, min: 0, max: 1 },\n      }));\n      return serializePatternNode(newAst);\n    }\n  }\n}\n\n// ─── Subsumption check ────────────────────────────────────────────────────────\n\n/**\n * Sample-based subsumption: checks if all generated samples of p1 are also matched by p2.\n * Returns true if L(p1) ⊆ L(p2) based on the generated sample set.\n */\nfunction isSubsumedBy(p1: string, p2: string): boolean {\n  const samples = generateMarkdownVariants(p1);\n  if (samples.length === 0) {\n    return false;\n  }\n  return samples.every((markdown) => {\n    const nodes = parseMarkdownToAst(markdown).children as RootContent[];\n    return validatePattern(nodes, p2).valid;\n  });\n}\n\n// ─── Public API ──────────────────────────────────────────────────────────────\n\n/**\n * Detect intra-definition merge opportunities: pairs of patterns within a single\n * definition that could be combined into one.\n *\n * Checks (in order):\n * 1. Subsumption: L(P1) ⊆ L(P2) or vice-versa — one pattern is redundant\n * 2. Structural diff: single-point divergence classified as:\n *    - quantifier_widening: same structure but differing quantifier\n *    - alternation_extension: same structure but differing alternation choices\n *    - optional_element: one pattern is the other + one extra element\n */\nexport function detectMergeOpportunities(\n  definitions: DefinitionEntry[],\n): MergeOpportunity[] {\n  const opportunities: MergeOpportunity[] = [];\n\n  for (const entry of definitions) {\n    const patterns = entry.definition.patterns;\n    if (patterns.length < 2) {\n      continue;\n    }\n\n    for (let i = 0; i < patterns.length; i++) {\n      for (let j = i + 1; j < patterns.length; j++) {\n        const p1 = patterns[i];\n        const p2 = patterns[j];\n\n        // 1. Check for subsumption (cheapest check)\n        if (isSubsumedBy(p1, p2)) {\n          opportunities.push({\n            sectionType: entry.sectionType,\n            pattern1: p1,\n            pattern2: p2,\n            kind: 'subsumption',\n            suggestedPattern: p2,\n            rationale: `All generated samples of P1 are also matched by P2. P1 may be redundant.`,\n          });\n          continue;\n        }\n        if (isSubsumedBy(p2, p1)) {\n          opportunities.push({\n            sectionType: entry.sectionType,\n            pattern1: p1,\n            pattern2: p2,\n            kind: 'subsumption',\n            suggestedPattern: p1,\n            rationale: `All generated samples of P2 are also matched by P1. P2 may be redundant.`,\n          });\n          continue;\n        }\n\n        // 2. Structural diff\n        let ast1: PatternNode, ast2: PatternNode;\n        try {\n          ast1 = parse(tokenize(p1));\n          ast2 = parse(tokenize(p2));\n        } catch {\n          continue;\n        }\n\n        const diff = structuralDiff(ast1, ast2);\n\n        if (diff.diffType === 'none') {\n          // Identical patterns — one is fully redundant\n          opportunities.push({\n            sectionType: entry.sectionType,\n            pattern1: p1,\n            pattern2: p2,\n            kind: 'subsumption',\n            suggestedPattern: p1,\n            rationale: `Patterns are structurally identical. One can be removed.`,\n          });\n          continue;\n        }\n\n        if (diff.diffType === 'incompatible') {\n          continue;\n        }\n\n        const suggestedPattern = buildMergedPattern(ast1, ast2, diff);\n        if (!suggestedPattern) {\n          continue;\n        }\n\n        switch (diff.diffType) {\n          case 'quantifier': {\n            const fieldLabel =\n              diff.field === 'itemCount' ? 'item count' : 'quantifier';\n            opportunities.push({\n              sectionType: entry.sectionType,\n              pattern1: p1,\n              pattern2: p2,\n              kind: 'quantifier_widening',\n              suggestedPattern,\n              rationale: `Patterns differ only in ${fieldLabel}: ${formatQuantifier(\n                diff.q1,\n              )} vs ${formatQuantifier(diff.q2)}. Merge to ${formatQuantifier(\n                mergeQuantifiers(diff.q1, diff.q2),\n              )}.`,\n            });\n            break;\n          }\n\n          case 'alternation': {\n            const newChoices = [...new Set([...diff.set1, ...diff.set2])];\n            opportunities.push({\n              sectionType: entry.sectionType,\n              pattern1: p1,\n              pattern2: p2,\n              kind: 'alternation_extension',\n              suggestedPattern,\n              rationale: `Patterns differ only in alternation choices: (${diff.set1.join(\n                ' | ',\n              )}) vs (${diff.set2.join(' | ')}). Union: (${newChoices.join(\n                ' | ',\n              )}).`,\n            });\n            break;\n          }\n\n          case 'optional_element': {\n            const extraStr = serializePatternNode(diff.extraNode);\n            opportunities.push({\n              sectionType: entry.sectionType,\n              pattern1: p1,\n              pattern2: p2,\n              kind: 'optional_element',\n              suggestedPattern,\n              rationale: `One pattern has an extra element \\`${extraStr}\\` not in the other. Making it optional merges both patterns.`,\n            });\n            break;\n          }\n        }\n      }\n    }\n  }\n\n  return opportunities;\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/patternAnalyzer/parserValidator.js

@@ -0,0 +1,56 @@
+"use strict";
+
+exports.__esModule = true;
+exports.validateAllParsers = validateAllParsers;
+var _specHelpers = require("../component/componentDefinitions/specHelpers");
+var _markdownGenerator = require("./markdownGenerator");
+/**
+ * For each definition × pattern:
+ * 1. Generate markdown variants that should match the pattern
+ * 2. Call parseWithDefinition() for each variant
+ * 3. Collect failures where parse() returned null or threw
+ *
+ * Note: parse() returning null may be intentional for some definitions
+ * (e.g. BlogSectionDefinition requires ≥2 posts).
+ * These are flagged for manual review, not necessarily bugs.
+ */
+function validateAllParsers(definitions) {
+  const reports = [];
+  for (const entry of definitions) {
+    for (const pattern of entry.definition.patterns) {
+      const samples = (0, _markdownGenerator.generateMarkdownVariants)(pattern);
+      let passCount = 0;
+      const failures = [];
+      for (const markdown of samples) {
+        try {
+          const result = (0, _specHelpers.parseWithDefinition)(entry.definition, markdown);
+          if (result === null) {
+            failures.push({
+              markdown,
+              generatedFrom: pattern,
+              error: 'parse_returned_null'
+            });
+          } else {
+            passCount++;
+          }
+        } catch (e) {
+          failures.push({
+            markdown,
+            generatedFrom: pattern,
+            error: 'parse_threw',
+            detail: e instanceof Error ? e.message : String(e)
+          });
+        }
+      }
+      reports.push({
+        sectionType: entry.sectionType,
+        pattern,
+        failures,
+        samplesTestedCount: samples.length,
+        samplesPassedCount: passCount
+      });
+    }
+  }
+  return reports;
+}
+//# sourceMappingURL=parserValidator.js.map

package/dist/cjs/patternAnalyzer/parserValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_specHelpers","require","_markdownGenerator","validateAllParsers","definitions","reports","entry","pattern","definition","patterns","samples","generateMarkdownVariants","passCount","failures","markdown","result","parseWithDefinition","push","generatedFrom","error","e","detail","Error","message","String","sectionType","samplesTestedCount","length","samplesPassedCount"],"sources":["../../../src/patternAnalyzer/parserValidator.ts"],"sourcesContent":["import { parseWithDefinition } from '../component/componentDefinitions/specHelpers';\nimport { generateMarkdownVariants } from './markdownGenerator';\nimport type {\n  DefinitionEntry,\n  ParserValidationReport,\n  ValidationFailure,\n} from './types';\n\n/**\n * For each definition × pattern:\n * 1. Generate markdown variants that should match the pattern\n * 2. Call parseWithDefinition() for each variant\n * 3. Collect failures where parse() returned null or threw\n *\n * Note: parse() returning null may be intentional for some definitions\n * (e.g. BlogSectionDefinition requires ≥2 posts).\n * These are flagged for manual review, not necessarily bugs.\n */\nexport function validateAllParsers(\n  definitions: DefinitionEntry[],\n): ParserValidationReport[] {\n  const reports: ParserValidationReport[] = [];\n\n  for (const entry of definitions) {\n    for (const pattern of entry.definition.patterns) {\n      const samples = generateMarkdownVariants(pattern);\n      let passCount = 0;\n      const failures: ValidationFailure[] = [];\n\n      for (const markdown of samples) {\n        try {\n          const result = parseWithDefinition(entry.definition, markdown);\n          if (result === null) {\n            failures.push({\n              markdown,\n              generatedFrom: pattern,\n              error: 'parse_returned_null',\n            });\n          } else {\n            passCount++;\n          }\n        } catch (e) {\n          failures.push({\n            markdown,\n            generatedFrom: pattern,\n            error: 'parse_threw',\n            detail: e instanceof Error ? e.message : String(e),\n          });\n        }\n      }\n\n      reports.push({\n        sectionType: entry.sectionType,\n        pattern,\n        failures,\n        samplesTestedCount: samples.length,\n        samplesPassedCount: passCount,\n      });\n    }\n  }\n\n  return reports;\n}\n"],"mappings":";;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,kBAAA,GAAAD,OAAA;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASE,kBAAkBA,CAChCC,WAA8B,EACJ;EAC1B,MAAMC,OAAiC,GAAG,EAAE;EAE5C,KAAK,MAAMC,KAAK,IAAIF,WAAW,EAAE;IAC/B,KAAK,MAAMG,OAAO,IAAID,KAAK,CAACE,UAAU,CAACC,QAAQ,EAAE;MAC/C,MAAMC,OAAO,GAAG,IAAAC,2CAAwB,EAACJ,OAAO,CAAC;MACjD,IAAIK,SAAS,GAAG,CAAC;MACjB,MAAMC,QAA6B,GAAG,EAAE;MAExC,KAAK,MAAMC,QAAQ,IAAIJ,OAAO,EAAE;QAC9B,IAAI;UACF,MAAMK,MAAM,GAAG,IAAAC,gCAAmB,EAACV,KAAK,CAACE,UAAU,EAAEM,QAAQ,CAAC;UAC9D,IAAIC,MAAM,KAAK,IAAI,EAAE;YACnBF,QAAQ,CAACI,IAAI,CAAC;cACZH,QAAQ;cACRI,aAAa,EAAEX,OAAO;cACtBY,KAAK,EAAE;YACT,CAAC,CAAC;UACJ,CAAC,MAAM;YACLP,SAAS,EAAE;UACb;QACF,CAAC,CAAC,OAAOQ,CAAC,EAAE;UACVP,QAAQ,CAACI,IAAI,CAAC;YACZH,QAAQ;YACRI,aAAa,EAAEX,OAAO;YACtBY,KAAK,EAAE,aAAa;YACpBE,MAAM,EAAED,CAAC,YAAYE,KAAK,GAAGF,CAAC,CAACG,OAAO,GAAGC,MAAM,CAACJ,CAAC;UACnD,CAAC,CAAC;QACJ;MACF;MAEAf,OAAO,CAACY,IAAI,CAAC;QACXQ,WAAW,EAAEnB,KAAK,CAACmB,WAAW;QAC9BlB,OAAO;QACPM,QAAQ;QACRa,kBAAkB,EAAEhB,OAAO,CAACiB,MAAM;QAClCC,kBAAkB,EAAEhB;MACtB,CAAC,CAAC;IACJ;EACF;EAEA,OAAOP,OAAO;AAChB","ignoreList":[]}