wingbot 3.67.18 → 3.67.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.67.18",
+  "version": "3.67.20",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "type": "commonjs",

package/src/AiMatching.js

@@ -650,6 +650,7 @@ class AiMatching {
 
         const allOptional = wantedEntities.every((e) => e.optional
             && (!e.op || useEntities.every((n) => n.entity !== e.entity)));
+
         if (entitiesScore <= 0 && !allOptional) {
             return { score: 0, entities: [] };
         }
@@ -698,6 +699,8 @@ class AiMatching {
         let fromState = 0;
         let metl = 0;
 
+        let optHandicap = 0;
+
         for (const wanted of wantedEntities) {
             const usedIndexes = occurences.has(wanted.entity)
                 ? occurences.get(wanted.entity)
@@ -754,14 +757,21 @@ class AiMatching {
             }
 
             if (!matching) { // && optional && !entityExists
-                handicap += this.redundantEntityHandicap;
+                if (optHandicap < this.redundantEntityHandicap) {
+                    handicap += this.redundantEntityHandicap;
+                } else {
+                    handicap += this.optionalHandicap;
+                }
+                optHandicap += this.redundantEntityHandicap;
                 continue;
             }
 
             if (wanted.optional) {
-                handicap += wanted.op
+                const oph = wanted.op
                     ? this.optionalEqualityHandicap
                     : this.optionalHandicap;
+
+                handicap += oph;
             }
 
             if (wanted.op === COMPARE.NOT_EQUAL) {

package/src/Tester.js

@@ -19,7 +19,7 @@ const Router = require('./Router'); // eslint-disable-line no-unused-vars
 const ReducerWrapper = require('./ReducerWrapper'); // eslint-disable-line no-unused-vars
 const { FEATURE_TEXT } = require('./features');
 
-/** @typedef {import('./Processor').ProcessorOptions} ProcessorOptions */
+/** @typedef {import('./Processor').ProcessorOptions<Router>} ProcessorOptions */
 
 /**
  * Utility for testing requests

package/src/fuzzy/factoryFuzzySearch.js

@@ -5,7 +5,7 @@
 
 const { shortArrayIndex, splitToNgrams, cleanup } = require('./fuzzyUtils');
 const {
-    relativeLevenshtein, SEED_FUZZY, SEED_FUZZY_MULTIPLICATOR, WORD_HANDICAP_K_FUZZY
+    multiwordLevenshtein, SEED_FUZZY, SEED_FUZZY_MULTIPLICATOR, WORD_HANDICAP_K_FUZZY
 } = require('./levenshtein');
 
 const LOWER_DUPLICATES = 0.9;
@@ -93,7 +93,7 @@ function searchFnFactory (indexMap, ngramCounts, entities, maxIdf, {
                 const [, entityIndex, cleanText] = ngramCounts[id];
                 const [entity, value] = entities[entityIndex];
                 const relIdf = (idf / cnt) / maxIdf;
-                let score = relativeLevenshtein(
+                let score = multiwordLevenshtein(
                     cleanText,
                     cleanQuery,
                     levenshteinSeed,
@@ -103,7 +103,7 @@ function searchFnFactory (indexMap, ngramCounts, entities, maxIdf, {
 
                 if (cleanQuery.match(/^[^\s]{1,3}\s+.{6,}$/)) {
                     const without = cleanQuery.replace(/^[^\s]{1,3}\s+/, '');
-                    const altScore = relativeLevenshtein(
+                    const altScore = multiwordLevenshtein(
                         cleanText,
                         without,
                         levenshteinSeed,

package/src/fuzzy/levenshtein.js

@@ -128,42 +128,68 @@ function addSeed (seed, len, value, base = seed) {
     return base + (((len - value) / len) * (1 - seed));
 }
 
+function numStats (left, right) {
+    const len = Math.max(left.length, right.length);
+    const leftNum = left.replace(/[^0-9]+/g, '');
+    const rightNum = right.replace(/[^0-9]+/g, '');
+    const numLen = Math.max(leftNum.length, rightNum.length);
+    const numLev = numLen ? levenshtein(leftNum, rightNum) * NUMERIC_KOEF : 0;
+    const numRelLen = len ? numLen / len : 0;
+
+    return {
+        len,
+        leftNum,
+        rightNum,
+        numLen,
+        numLev,
+        numRelLen
+    };
+}
+
+const STRING_REPLACER = /[^\s-]+/g;
+const STRING_SPLITTER = /\s+/g;
+
 /**
  *
  * @param {string} left - training data
  * @param {string} right - query
  * @param {number} [seed]
  * @param {number} [wordKoef]
+ * @param {object} [nums]
  * @returns {number}
  */
 function relativeLevenshtein (
     left,
     right,
     seed = SEED_DEFAULT,
-    wordKoef = WORD_HANDICAP_K_DEFAULT
+    wordKoef = WORD_HANDICAP_K_DEFAULT,
+    nums = numStats(left, right)
 ) {
-    const len = Math.max(left.length, right.length);
-    if (!len) {
+    if (nums.len === 0) {
         return 0;
     }
     let stemLen = Math.min(left.length, right.length);
 
-    const leftWordCount = (left.match(/[^\s]+/g) || ['']).length;
-    const rightWordCount = (right.match(/[^\s]+/g) || ['']).length;
+    const leftWordCount = (left.match(STRING_REPLACER) || ['']).length;
+    const rightWordCount = (right.match(STRING_REPLACER) || ['']).length;
 
     const wordDiff = Math.max(0, rightWordCount - leftWordCount);
     const wordHandicap = (wordKoef ** wordDiff);
 
-    const leftNum = left.replace(/[^0-9]+/g, '');
-    const rightNum = right.replace(/[^0-9]+/g, '');
-    const numLen = Math.max(leftNum.length, rightNum.length);
-    const numLev = numLen ? levenshtein(leftNum, rightNum) * NUMERIC_KOEF : 0;
+    const l = levenshtein(left, right);
+
+    if (nums.numRelLen >= 0.5) {
+        const max = nums.len * 0.2; // 1/5 allowed error
+        const s = (l / max) * 0.25;
+
+        return Math.max(0, 1 - s) * wordHandicap;
+    }
 
     if (stemLen < 3) {
-        return addSeed(seed, len + numLen, levenshtein(left, right) + numLev) * wordHandicap;
+        return addSeed(seed, nums.len + nums.numLen, l + nums.numLev) * wordHandicap;
     }
 
-    let diff = len - stemLen;
+    let diff = nums.len - stemLen;
 
     if (diff <= 2) {
         diff += 2;
@@ -184,7 +210,7 @@ function relativeLevenshtein (
         diffWeight = (diff - 1) * SUFFIX_WEIGHT;
     }
 
-    const vStem = addSeed(seed, stemLen + numLen, stemLev + numLev, seed - diffWeight);
+    const vStem = addSeed(seed, stemLen + nums.numLen, stemLev + nums.numLev, seed - diffWeight);
     const vSuffix = addSeed(1 - diffWeight, diff, suffLev, 0);
 
     const r = (vStem + vSuffix) * wordHandicap;
@@ -200,18 +226,35 @@ function relativeLevenshtein (
  * @param {number} [wordKoef]
  * @returns {number}
  */
-function multiwordLevenshtein (left, right, seed, wordKoef = undefined) {
-    const leftSplit = `${left}`.split(/\s+/g);
-    const rightSplit = `${right}`.split(/\s+/g);
+function multiwordLevenshtein (left, right, seed = SEED_DEFAULT, wordKoef = undefined) {
+    const leftSplit = `${left}`.split(STRING_SPLITTER);
+    const rightSplit = `${right}`.split(STRING_SPLITTER);
 
     let sum = 0;
+    let sumNums = 0;
+    let cntNums = 0;
 
     const max = Math.max(leftSplit.length, rightSplit.length, 1);
     for (let i = 0; i < max; i++) {
-        sum += relativeLevenshtein(leftSplit[i] || '', rightSplit[i] || '', seed, wordKoef);
+        const ls = leftSplit[i] || '';
+        const rs = rightSplit[i] || '';
+        const nums = numStats(ls, rs);
+
+        const l = relativeLevenshtein(ls, rs, seed, wordKoef, nums);
+
+        if (nums.numRelLen >= 0.25) {
+            cntNums++;
+            sumNums += l;
+            sum += Math.max(0.85, l);
+        } else {
+            sum += l;
+        }
     }
 
-    return sum / max;
+    const total = sum / max;
+    const numeric = cntNums ? (sumNums / cntNums) : 1;
+
+    return total * numeric;
 }
 
 module.exports = {

package/src/testTools/AnyResponseAssert.js

@@ -116,6 +116,35 @@ class AnyResponseAssert {
         return this;
     }
 
+    /**
+     * Checks for missing quick response text
+     *
+     * @param {string} search
+     * @returns {this}
+     *
+     * @memberOf ResponseAssert
+     */
+    quickReplyTextNotContains (search) {
+        const ok = this.responses
+            .every((res) => !asserts.quickReplyText(res, search, false));
+
+        if (!ok) {
+            const actual = this.responses
+                .map((res) => asserts.getQuickReplies(res))
+                .filter((replies) => !!replies)
+                .reduce((a, replies) => {
+                    for (const { title } of replies) {
+                        if (title) {
+                            a.push(title);
+                        }
+                    }
+                    return a;
+                }, []);
+            assert.fail(m('Quick reply should not be found', search, actual));
+        }
+        return this;
+    }
+
     /**
      * Checks template type
      *