@atlaskit/editor-plugin-autocomplete 0.1.0 → 0.3.0

package/dist/cjs/pm-plugins/scoring-pipeline.js

@@ -0,0 +1,256 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rankCandidates = rankCandidates;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _combined_l2_l3_pos_tags = _interopRequireDefault(require("./data/combined_l2_l3_pos_tags.json"));
+var _ghost_pos_tags = _interopRequireDefault(require("./data/ghost_pos_tags.json"));
+var _grammar_transitions_10k = _interopRequireDefault(require("./data/grammar_transitions_10k.json"));
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; } /**
+ * Scoring Pipeline: Stage 1 (Semantic + Frequency), Grammar Filter, Stage 2 (LM Re-ranking).
+ *
+ * Operates synchronously on pre-loaded data. Each stage gracefully degrades
+ * when its required data isn't available (cold → warm → full warm).
+ */
+// ─── Types ──────────────────────────────────────────────────
+
+/** Metadata returned by the grammar filter for debug logging in the caller. */
+
+// ─── Scoring Constants ──────────────────────────────────────
+
+var ALPHA = 0.5;
+var BETA = 0.5;
+var NEUTRAL_SCORE = 0.5;
+var STAGE1_WEIGHT = 0.6;
+var STAGE2_WEIGHT = 0.4;
+var MIN_STAGE1_SCORE = 0.35;
+var L1_SESSION_CAP = 1.2;
+
+// ─── Grammar Data (loaded once on import) ───────────────────
+
+var posTags = new Map(Object.entries(_combined_l2_l3_pos_tags.default));
+var grammarTransitions = _grammar_transitions_10k.default;
+
+/**
+ * Precomputed map from each POS tag to the set of allowed next POS tags.
+ * Built once at module load from grammarTransitions so applyGrammarFilter
+ * never re-iterates the transition rules per call.
+ */
+var precomputedAllowedByPos = new Map(Object.entries(grammarTransitions.transitions).map(function (_ref) {
+  var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+    pos = _ref2[0],
+    rule = _ref2[1];
+  return [pos, new Set(rule.allowed)];
+}));
+
+// ─── Math ───────────────────────────────────────────────────
+
+function cosineSimilarity(a, b) {
+  var dot = 0;
+  var normA = 0;
+  var normB = 0;
+  for (var i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  var dNormA = Math.sqrt(normA);
+  var dNormB = Math.sqrt(normB);
+  if (dNormA === 0 || dNormB === 0) {
+    return NEUTRAL_SCORE;
+  }
+  return (1 + dot / (dNormA * dNormB)) / 2;
+}
+
+// ─── Stage 1: Semantic + Frequency ──────────────────────────
+
+function scoreStage1(candidate, contextVector, getWordVector, maxTenantFreq) {
+  // 1. Calculate Base Global Score (Normalized Log)
+  var maxPossibleLog = Math.log10(maxTenantFreq + 1);
+
+  // Diversity Adjustment
+  var diversityRaw = (Math.log10(candidate.tenantFreq + 1) * 0.50 + Math.log10(candidate.docFreq + 1) * 0.25 + Math.log10(candidate.authorFreq + 1) * 0.25) / maxPossibleLog;
+  var sessionMultiplier = candidate.sessionFreq > 0 ? 1 + Math.log10(candidate.sessionFreq + 1) * 2.5 : 1;
+
+  // Apply multiplier; capped at L1_SESSION_CAP (default 1.2) to prevent excessive over-indexing
+  var freqScore = Math.min(diversityRaw * sessionMultiplier, L1_SESSION_CAP);
+
+  // 3. Semantic Scoring
+  var semanticScore = NEUTRAL_SCORE;
+  if (contextVector) {
+    var wordVec = getWordVector(candidate.word);
+    semanticScore = wordVec ? cosineSimilarity(contextVector, wordVec) : NEUTRAL_SCORE;
+  }
+  return {
+    semanticScore: semanticScore,
+    freqScore: freqScore,
+    stage1Score: ALPHA * semanticScore + BETA * freqScore
+  };
+}
+
+// ─── Grammar Filter ─────────────────────────────────────────
+
+/**
+ * GHOST POS DICTIONARY
+ * A hardcoded mapping of common structural English words that were stripped 
+ * from the main domain vocabulary. This allows the grammar filter to understand 
+ * context without suggesting these words to the user.
+ */
+var ghostPosTags = _ghost_pos_tags.default;
+function applyGrammarFilter(candidates, previousWord) {
+  if (!previousWord) return {
+    filtered: candidates,
+    grammarMeta: null
+  };
+  var lowerPrev = previousWord.toLowerCase();
+  var prevTags = ghostPosTags[lowerPrev] || posTags.get(lowerPrev);
+  if (!prevTags || prevTags.length === 0) {
+    return {
+      filtered: candidates,
+      grammarMeta: null
+    };
+  }
+  var allowedNextTags;
+  if (prevTags.length === 1) {
+    var _precomputedAllowedBy;
+    // Common case: single POS tag — reuse the precomputed Set directly (no allocation)
+    allowedNextTags = (_precomputedAllowedBy = precomputedAllowedByPos.get(prevTags[0])) !== null && _precomputedAllowedBy !== void 0 ? _precomputedAllowedBy : new Set();
+  } else {
+    allowedNextTags = new Set();
+    var _iterator = _createForOfIteratorHelper(prevTags),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var pt = _step.value;
+        var allowed = precomputedAllowedByPos.get(pt);
+        if (allowed) allowed.forEach(function (tag) {
+          return allowedNextTags.add(tag);
+        });
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  var filtered = [];
+  var dropped = [];
+  var _iterator2 = _createForOfIteratorHelper(candidates),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var entry = _step2.value;
+      var candidateTags = posTags.get(entry.candidate.word.toLowerCase());
+
+      // If candidate has no tags (unknown word), let it pass to be safe
+      if (!candidateTags || candidateTags.length === 0) {
+        filtered.push(entry);
+        continue;
+      }
+      if (candidateTags.some(function (ct) {
+        return allowedNextTags.has(ct);
+      })) {
+        filtered.push(entry);
+      } else {
+        dropped.push(entry.candidate.word);
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  var finalFiltered = filtered.length > 0 ? filtered : candidates;
+  return {
+    filtered: finalFiltered,
+    grammarMeta: {
+      prevWord: lowerPrev,
+      prevTags: prevTags,
+      before: candidates.length,
+      after: finalFiltered.length,
+      dropped: filtered.length > 0 ? dropped : []
+    }
+  };
+}
+
+// ─── Stage 2: LM Re-ranking ────────────────────────────────
+function getLmScore(word, lmLogits) {
+  if (!lmLogits) return 0;
+
+  // Look up the word directly! No more tokens.
+  var val = lmLogits[word.toLowerCase()];
+  if (typeof val === 'number') {
+    return val;
+  }
+  return 0;
+}
+
+// ─── Public API ─────────────────────────────────────────────
+
+function rankCandidates(candidates, contextVector, getWordVector, lmLogits, maxTenantFreq, previousWord) {
+  // Stage 1
+  var stage1Results = candidates.map(function (candidate) {
+    var _scoreStage = scoreStage1(candidate, contextVector, getWordVector, maxTenantFreq),
+      semanticScore = _scoreStage.semanticScore,
+      freqScore = _scoreStage.freqScore,
+      stage1Score = _scoreStage.stage1Score;
+    return {
+      candidate: candidate,
+      semanticScore: semanticScore,
+      freqScore: freqScore,
+      stage1Score: stage1Score
+    };
+  });
+  var stage1Survivors = stage1Results.filter(function (entry) {
+    return entry.stage1Score >= MIN_STAGE1_SCORE;
+  });
+
+  // Grammar Filter
+  var _applyGrammarFilter = applyGrammarFilter(stage1Survivors, previousWord),
+    filtered = _applyGrammarFilter.filtered,
+    grammarMeta = _applyGrammarFilter.grammarMeta;
+
+  // Stage 2 + final assembly
+  var lmMax = 0;
+  if (lmLogits && Object.keys(lmLogits).length > 0) {
+    var values = Object.values(lmLogits);
+    lmMax = Math.max.apply(Math, values);
+  }
+  var scored = filtered.map(function (entry) {
+    var lmScore = 0;
+    var finalScore = entry.stage1Score;
+    if (lmLogits && Object.keys(lmLogits).length > 0) {
+      var rawLm = getLmScore(entry.candidate.word, lmLogits);
+      if (rawLm !== 0) {
+        // The word was in the top_k! Score it normally.
+        var logitDiff = Math.log(rawLm) - Math.log(lmMax);
+        lmScore = Math.exp(logitDiff);
+      } else {
+        lmScore = 0.05;
+      }
+      finalScore = STAGE1_WEIGHT * entry.stage1Score + STAGE2_WEIGHT * lmScore;
+    }
+    return {
+      word: entry.candidate.word,
+      freqScore: entry.freqScore,
+      semanticScore: entry.semanticScore,
+      lmScore: lmScore,
+      finalScore: finalScore
+    };
+  });
+  scored.sort(function (a, b) {
+    if (b.finalScore !== a.finalScore) {
+      return b.finalScore - a.finalScore;
+    }
+    return a.word.length - b.word.length;
+  });
+  return {
+    candidates: scored,
+    grammarMeta: grammarMeta
+  };
+}

package/dist/cjs/pm-plugins/slow-lane-client.js

@@ -0,0 +1,199 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setDefaultSlowLaneClient = exports.isWordBoundary = exports.getStoredLmLogits = exports.getStoredContextVector = exports.createSlowLaneClient = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+/**
+ * Slow Lane Client: Backend context encoding for autocomplete.
+ *
+ * Fires a BE request on word boundaries to encode document context.
+ * Expects the typeahead-encodings API format:
+ *   Request:  { text, session_id }
+ *   Response: { semantic_vector: number[], lm_logits: Record<string, number> }
+ */
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+/** Request payload for typeahead-encodings endpoint. */
+
+/** Response from typeahead-encodings endpoint. */
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+// eslint-disable-next-line require-unicode-regexp
+var WORD_BOUNDARY_CHARS = /[\s.,;:!?]/;
+var DEFAULT_DEBOUNCE_MS = 300;
+
+/**
+ * Check if text ends with a word boundary character (space or punctuation).
+ */
+var isWordBoundary = exports.isWordBoundary = function isWordBoundary(text) {
+  if (!text || text.length === 0) {
+    return false;
+  }
+  var lastChar = text[text.length - 1];
+  return WORD_BOUNDARY_CHARS.test(lastChar);
+};
+
+// ─── Slow Lane Client ────────────────────────────────────────────────────────
+
+var createSlowLaneClient = exports.createSlowLaneClient = function createSlowLaneClient(config) {
+  var baseUrl = config.baseUrl,
+    configSessionId = config.sessionId,
+    _config$productKey = config.productKey,
+    productKey = _config$productKey === void 0 ? 'confluence' : _config$productKey,
+    _config$endpoint = config.endpoint,
+    endpoint = _config$endpoint === void 0 ? '/gateway/api/v1/autocomplete/typeahead-encodings' : _config$endpoint,
+    _config$debounceMs = config.debounceMs,
+    debounceMs = _config$debounceMs === void 0 ? DEFAULT_DEBOUNCE_MS : _config$debounceMs,
+    _config$fetchFn = config.fetchFn,
+    fetchFn = _config$fetchFn === void 0 ? fetch : _config$fetchFn,
+    onUpdate = config.onUpdate;
+  var sessionId = configSessionId !== null && configSessionId !== void 0 ? configSessionId : crypto.randomUUID();
+  var headers = {
+    'Content-Type': 'application/json',
+    'x-experience-id': 'confluence-smart-typeahead-encodings',
+    'x-product': productKey
+  };
+  var debounceTimer = null;
+  var lastRequestedText = '';
+  var storedContextVector = null;
+  var storedLmLogits = null;
+  var doUpdateContext = /*#__PURE__*/function () {
+    var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(text) {
+      var url, payload, res, data;
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!(!text || text.trim().length === 0)) {
+              _context.next = 2;
+              break;
+            }
+            return _context.abrupt("return");
+          case 2:
+            // eslint-disable-next-line require-unicode-regexp
+            url = "".concat(baseUrl.replace(/\/$/, '')).concat(endpoint);
+            payload = {
+              text: text,
+              session_id: sessionId
+            }; // Log the exact payload being sent so the comment/reply structure is visible
+            // eslint-disable-next-line no-console
+            console.groupCollapsed("%c[SlowLane] %c\uD83D\uDCE4 Sending context | ".concat(text.length, " chars"), 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
+            text.split('\n').forEach(function (line, i, arr) {
+              // eslint-disable-next-line no-console
+              console.log("  ".concat(i === arr.length - 1 ? '▶' : ' ', " ").concat(line));
+            });
+            // eslint-disable-next-line no-console
+            console.groupEnd();
+            _context.prev = 7;
+            _context.next = 10;
+            return fetchFn(url, {
+              method: 'POST',
+              headers: headers,
+              body: JSON.stringify(payload)
+            });
+          case 10:
+            res = _context.sent;
+            if (res.ok) {
+              _context.next = 16;
+              break;
+            }
+            storedContextVector = null;
+            storedLmLogits = null;
+            // eslint-disable-next-line no-console
+            console.log("%c[SlowLane] %c\u274C Request failed (".concat(res.status, ")"), 'color: #9c27b0; font-weight: bold;', 'color: #f44336;');
+            return _context.abrupt("return");
+          case 16:
+            _context.next = 18;
+            return res.json();
+          case 18:
+            data = _context.sent;
+            if (data.semantic_vector && Array.isArray(data.semantic_vector)) {
+              storedContextVector = new Float32Array(data.semantic_vector);
+            } else {
+              storedContextVector = null;
+            }
+            if (data.lm_logits && (0, _typeof2.default)(data.lm_logits) === 'object') {
+              storedLmLogits = data.lm_logits;
+            } else {
+              storedLmLogits = null;
+            }
+
+            // Log what came back so it can be correlated with the next prediction group
+            // eslint-disable-next-line no-console
+            console.groupCollapsed("%c[SlowLane] %c\uD83D\uDCE5 Response received", 'color: #9c27b0; font-weight: bold;', 'color: inherit;');
+            // eslint-disable-next-line no-console
+            console.log(storedContextVector ? "\u2705 semantic_vector: ".concat(storedContextVector.length, " dims") : '❌ No semantic_vector');
+            // eslint-disable-next-line no-console
+            console.log(storedLmLogits ? "\u2705 lm_logits: ".concat(Object.keys(storedLmLogits).length, " tokens") : '❌ No lm_logits');
+            // eslint-disable-next-line no-console
+            console.groupEnd();
+            onUpdate === null || onUpdate === void 0 || onUpdate({
+              textLength: text.length,
+              hasVector: storedContextVector !== null,
+              hasLmLogits: storedLmLogits !== null
+            });
+            // eslint-disable-next-line no-unused-vars
+            _context.next = 33;
+            break;
+          case 28:
+            _context.prev = 28;
+            _context.t0 = _context["catch"](7);
+            storedContextVector = null;
+            storedLmLogits = null;
+            // eslint-disable-next-line no-console
+            console.log('%c[SlowLane] %c❌ Network error — context cleared', 'color: #9c27b0; font-weight: bold;', 'color: #f44336;');
+          case 33:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[7, 28]]);
+    }));
+    return function doUpdateContext(_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  var updateContextDebounced = function updateContextDebounced(text) {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    lastRequestedText = text;
+    debounceTimer = setTimeout(function () {
+      debounceTimer = null;
+      doUpdateContext(lastRequestedText);
+    }, debounceMs);
+  };
+  return {
+    updateContext: updateContextDebounced,
+    getContextVector: function getContextVector() {
+      return storedContextVector;
+    },
+    getLmLogits: function getLmLogits() {
+      return storedLmLogits;
+    },
+    setContextVector: function setContextVector(vector) {
+      storedContextVector = vector;
+    },
+    setLmLogits: function setLmLogits(logits) {
+      storedLmLogits = logits;
+    },
+    isWordBoundary: isWordBoundary
+  };
+};
+var defaultSlowLaneClient = null;
+var setDefaultSlowLaneClient = exports.setDefaultSlowLaneClient = function setDefaultSlowLaneClient(client) {
+  defaultSlowLaneClient = client;
+};
+var getStoredContextVector = exports.getStoredContextVector = function getStoredContextVector() {
+  var _defaultSlowLaneClien, _defaultSlowLaneClien2;
+  return (_defaultSlowLaneClien = (_defaultSlowLaneClien2 = defaultSlowLaneClient) === null || _defaultSlowLaneClien2 === void 0 ? void 0 : _defaultSlowLaneClien2.getContextVector()) !== null && _defaultSlowLaneClien !== void 0 ? _defaultSlowLaneClien : null;
+};
+var getStoredLmLogits = exports.getStoredLmLogits = function getStoredLmLogits() {
+  var _defaultSlowLaneClien3, _defaultSlowLaneClien4;
+  return (_defaultSlowLaneClien3 = (_defaultSlowLaneClien4 = defaultSlowLaneClient) === null || _defaultSlowLaneClien4 === void 0 ? void 0 : _defaultSlowLaneClien4.getLmLogits()) !== null && _defaultSlowLaneClien3 !== void 0 ? _defaultSlowLaneClien3 : null;
+};