@lucern/graph-primitives 0.1.0-alpha.2

package/dist/ontology-matching.js

@@ -0,0 +1,346 @@
+// ../../packages/contracts/src/text-matching.contract.ts
+var TOKEN_SPLIT_REGEX = /[^a-z0-9]+/;
+var NON_ALPHANUMERIC_REGEX = /[^a-z0-9]/g;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "is",
+  "it",
+  "as",
+  "be",
+  "was",
+  "are",
+  "this",
+  "that",
+  "has",
+  "had",
+  "have",
+  "not",
+  "all",
+  "can",
+  "do",
+  "its",
+  "may",
+  "will",
+  "how",
+  "what",
+  "which",
+  "who",
+  "when",
+  "where",
+  "than",
+  "then",
+  "each",
+  "into",
+  "such",
+  "any",
+  "been",
+  "if",
+  "would",
+  "about",
+  "should",
+  "these",
+  "those",
+  "their",
+  "we",
+  "our",
+  "so"
+]);
+function tokenizeSearchText(text) {
+  return text.toLowerCase().split(TOKEN_SPLIT_REGEX).filter((token) => token.length >= 2 && !STOP_WORDS.has(token));
+}
+function stemToken(word) {
+  if (word.length <= 4) {
+    return word;
+  }
+  if (word.endsWith("ation")) {
+    return word.slice(0, -5);
+  }
+  if (word.endsWith("ment")) {
+    return word.slice(0, -4);
+  }
+  if (word.endsWith("ness")) {
+    return word.slice(0, -4);
+  }
+  if (word.endsWith("ical")) {
+    return word.slice(0, -4);
+  }
+  if (word.endsWith("tion")) {
+    return word.slice(0, -4);
+  }
+  if (word.endsWith("sion")) {
+    return word.slice(0, -4);
+  }
+  if (word.endsWith("ing")) {
+    return word.slice(0, -3);
+  }
+  if (word.endsWith("ous")) {
+    return word.slice(0, -3);
+  }
+  if (word.endsWith("ive")) {
+    return word.slice(0, -3);
+  }
+  if (word.endsWith("ity")) {
+    return word.slice(0, -3);
+  }
+  if (word.endsWith("ics")) {
+    return word.slice(0, -3);
+  }
+  if (word.endsWith("ly")) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("ed")) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("er")) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("es")) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("al")) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("ic")) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("s") && !word.endsWith("ss")) {
+    return word.slice(0, -1);
+  }
+  return word;
+}
+function tokenOverlapScore(queryTokens, textTokens) {
+  if (queryTokens.length === 0 || textTokens.length === 0) {
+    return 0;
+  }
+  const stemmedText = new Set(textTokens.map(stemToken));
+  let matchCount = 0;
+  for (const queryToken of queryTokens) {
+    const stemmedQuery = stemToken(queryToken);
+    if (stemmedText.has(stemmedQuery)) {
+      matchCount += 1;
+      continue;
+    }
+    for (const textToken of stemmedText) {
+      if (textToken.startsWith(stemmedQuery) || stemmedQuery.startsWith(textToken)) {
+        matchCount += 0.5;
+        break;
+      }
+    }
+  }
+  return matchCount / queryTokens.length;
+}
+function bigramTokenize(text) {
+  const normalized = text.toLowerCase().replace(NON_ALPHANUMERIC_REGEX, "");
+  const bigrams = /* @__PURE__ */ new Set();
+  for (let i = 0; i < normalized.length - 1; i++) {
+    bigrams.add(normalized.slice(i, i + 2));
+  }
+  return bigrams;
+}
+function wordTokenize(text) {
+  return text.toLowerCase().split(TOKEN_SPLIT_REGEX).filter((token) => token.length > 1);
+}
+function jaccardSimilarity(setA, setB) {
+  if (setA.size === 0 && setB.size === 0) {
+    return 0;
+  }
+  let intersectionSize = 0;
+  const smaller = setA.size <= setB.size ? setA : setB;
+  const larger = setA.size <= setB.size ? setB : setA;
+  for (const item of smaller) {
+    if (larger.has(item)) {
+      intersectionSize++;
+    }
+  }
+  const unionSize = setA.size + setB.size - intersectionSize;
+  return unionSize === 0 ? 0 : intersectionSize / unionSize;
+}
+function wordOverlapScore(inputWords, typeWords) {
+  if (typeWords.length === 0) {
+    return 0;
+  }
+  let matches = 0;
+  for (const word of typeWords) {
+    if (inputWords.includes(word)) {
+      matches++;
+    }
+  }
+  return matches / typeWords.length;
+}
+function prepareLexicalQuery(query) {
+  return {
+    raw: query,
+    tokens: tokenizeSearchText(query),
+    words: wordTokenize(query),
+    bigrams: bigramTokenize(query)
+  };
+}
+function scoreLexicalSignal(query, signal) {
+  const text = signal.text?.trim();
+  if (!text) {
+    return 0;
+  }
+  switch (signal.strategy ?? "tokenOverlap") {
+    case "bigramJaccard":
+      return jaccardSimilarity(query.bigrams, bigramTokenize(text));
+    case "wordOverlap":
+      return wordOverlapScore(query.words, wordTokenize(text));
+    default:
+      return tokenOverlapScore(query.tokens, tokenizeSearchText(text));
+  }
+}
+function scoreLexicalSignals(query, signals) {
+  let weightedScore = 0;
+  let totalWeight = 0;
+  for (const signal of signals) {
+    if (!signal.text?.trim() || signal.weight <= 0) {
+      continue;
+    }
+    weightedScore += scoreLexicalSignal(query, signal) * signal.weight;
+    totalWeight += signal.weight;
+  }
+  return totalWeight === 0 ? 0 : weightedScore / totalWeight;
+}
+
+// ../../packages/contracts/src/v1/ontologies/v1.ts
+var MATCH_WEIGHTS = {
+  tokenOverlap: 0.35,
+  bigramSimilarity: 0.25,
+  wordOverlap: 0.2,
+  descriptionBonus: 0.2
+};
+function scoreEntityTypeMatch(inputText, entityType) {
+  const preparedQuery = prepareLexicalQuery(inputText);
+  const labelText = `${entityType.label} ${entityType.value}`;
+  const tokenScore = scoreLexicalSignals(preparedQuery, [
+    { text: labelText, weight: 1, strategy: "tokenOverlap" }
+  ]);
+  const labelBigrams = bigramTokenize(entityType.label);
+  const bigramScore = jaccardSimilarity(preparedQuery.bigrams, labelBigrams);
+  const labelWords = wordTokenize(labelText);
+  const wordScore = wordOverlapScore(preparedQuery.words, labelWords);
+  let descScore = 0;
+  if (entityType.description) {
+    descScore = scoreLexicalSignals(preparedQuery, [
+      { text: entityType.description, weight: 1, strategy: "tokenOverlap" }
+    ]);
+  }
+  let subtypeBonus = 0;
+  if (entityType.subtypes && entityType.subtypes.length > 0) {
+    for (const subtype of entityType.subtypes) {
+      const subtypeScore = scoreLexicalSignals(preparedQuery, [
+        {
+          text: `${subtype.label} ${subtype.value} ${subtype.description || ""}`,
+          weight: 1,
+          strategy: "tokenOverlap"
+        }
+      ]);
+      subtypeBonus = Math.max(subtypeBonus, subtypeScore * 0.3);
+    }
+  }
+  const score = Math.min(
+    1,
+    tokenScore * MATCH_WEIGHTS.tokenOverlap + bigramScore * MATCH_WEIGHTS.bigramSimilarity + wordScore * MATCH_WEIGHTS.wordOverlap + descScore * MATCH_WEIGHTS.descriptionBonus + subtypeBonus
+  );
+  const reasons = [];
+  if (tokenScore > 0.3) {
+    reasons.push(`stem match: ${(tokenScore * 100).toFixed(0)}%`);
+  }
+  if (bigramScore > 0.3) {
+    reasons.push(`text similarity: ${(bigramScore * 100).toFixed(0)}%`);
+  }
+  if (wordScore > 0.3) {
+    reasons.push(`word match: ${(wordScore * 100).toFixed(0)}%`);
+  }
+  if (descScore > 0.2) {
+    reasons.push("description match");
+  }
+  if (subtypeBonus > 0.05) {
+    reasons.push("subtype match");
+  }
+  const reason = reasons.length > 0 ? reasons.join(", ") : "low similarity";
+  return {
+    entityType: entityType.value,
+    label: entityType.label,
+    score,
+    reason
+  };
+}
+function rankEntityTypeMatches(inputText, entityTypes, options) {
+  const minScore = options?.minScore ?? 0.05;
+  const limit = options?.limit ?? 10;
+  const matches = entityTypes.map((et) => scoreEntityTypeMatch(inputText, et)).filter((m) => m.score >= minScore).sort((a, b) => b.score - a.score).slice(0, limit);
+  return matches;
+}
+function scoreEntityConnection(nodeText, candidate, options) {
+  const preparedQuery = prepareLexicalQuery(nodeText);
+  const connectivityWeight = options?.connectivityWeight ?? 0.3;
+  const textWeight = 1 - connectivityWeight;
+  const candidateText = `${candidate.title} ${candidate.canonicalText}`;
+  const tokenScore = scoreLexicalSignals(preparedQuery, [
+    { text: candidateText, weight: 1, strategy: "tokenOverlap" }
+  ]);
+  const textScore = scoreLexicalSignals(preparedQuery, [
+    { text: candidateText, weight: 1, strategy: "bigramJaccard" }
+  ]);
+  const wordScore = scoreLexicalSignals(preparedQuery, [
+    { text: candidateText, weight: 1, strategy: "wordOverlap" }
+  ]);
+  const maxConnections = Math.max(
+    1,
+    candidate.connectedBeliefCount + candidate.connectedEvidenceCount
+  );
+  const connectivityScore = Math.min(1, maxConnections / 10);
+  const combinedTextScore = tokenScore * 0.45 + textScore * 0.35 + wordScore * 0.2;
+  const score = combinedTextScore * textWeight + connectivityScore * connectivityWeight;
+  const suggestedEdgeType = suggestEdgeType(candidate.entityType);
+  const reason = tokenScore > 0.3 ? `stem match: ${(tokenScore * 100).toFixed(0)}%` : textScore > 0.2 ? `name similarity: ${(textScore * 100).toFixed(0)}%` : wordScore > 0.2 ? `keyword match: ${(wordScore * 100).toFixed(0)}%` : `connectivity: ${candidate.connectedBeliefCount} beliefs`;
+  return {
+    entityNodeId: candidate.nodeId,
+    entityType: candidate.entityType,
+    title: candidate.title,
+    score,
+    suggestedEdgeType,
+    reason
+  };
+}
+function suggestEdgeType(entityType) {
+  switch (entityType) {
+    case "company":
+    case "person":
+    case "investor":
+      return "contains";
+    case "function":
+    case "value_chain":
+      return "impacts";
+    default:
+      return "contains";
+  }
+}
+function rankEntityConnections(nodeText, candidates, options) {
+  const minScore = options?.minScore ?? 0.05;
+  const limit = options?.limit ?? 10;
+  return candidates.map(
+    (c) => scoreEntityConnection(nodeText, c, {
+      connectivityWeight: options?.connectivityWeight
+    })
+  ).filter((m) => m.score >= minScore).sort((a, b) => b.score - a.score).slice(0, limit);
+}
+
+export { rankEntityConnections, rankEntityTypeMatches, scoreEntityConnection, scoreEntityTypeMatch };
+//# sourceMappingURL=ontology-matching.js.map
+//# sourceMappingURL=ontology-matching.js.map

package/dist/ontology-matching.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../packages/contracts/src/text-matching.contract.ts","../../../packages/contracts/src/v1/ontologies/v1.ts"],"names":[],"mappings":"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","file":"ontology-matching.js","sourcesContent":["/**\n * Shared lexical matching primitives used across MCP handlers and graph utilities.\n *\n * The goal is not to replace downstream LLM scoring. It provides a fast,\n * deterministic substrate for candidate generation, reranking, and light\n * classification across belief/question/evidence/entity surfaces.\n */\n\nexport type LexicalStrategy = \"tokenOverlap\" | \"bigramJaccard\" | \"wordOverlap\";\n\nexport type PreparedLexicalQuery = {\n  raw: string;\n  tokens: string[];\n  words: string[];\n  bigrams: Set<string>;\n};\n\nexport type LexicalSignal = {\n  strategy?: LexicalStrategy;\n  text: string | null | undefined;\n  weight: number;\n};\n\nexport type LexicalRerankOptions = {\n  lexicalWeight?: number;\n  rankWeight?: number;\n};\n\nconst TOKEN_SPLIT_REGEX = /[^a-z0-9]+/;\nconst NON_ALPHANUMERIC_REGEX = /[^a-z0-9]/g;\n\n/** Stop words that add noise to scoring. */\nconst STOP_WORDS = new Set([\n  \"the\",\n  \"a\",\n  \"an\",\n  \"and\",\n  \"or\",\n  \"but\",\n  \"in\",\n  \"on\",\n  \"at\",\n  \"to\",\n  \"for\",\n  \"of\",\n  \"with\",\n  \"by\",\n  \"from\",\n  \"is\",\n  \"it\",\n  \"as\",\n  \"be\",\n  \"was\",\n  \"are\",\n  \"this\",\n  \"that\",\n  \"has\",\n  \"had\",\n  \"have\",\n  \"not\",\n  \"all\",\n  \"can\",\n  \"do\",\n  \"its\",\n  \"may\",\n  \"will\",\n  \"how\",\n  \"what\",\n  \"which\",\n  \"who\",\n  \"when\",\n  \"where\",\n  \"than\",\n  \"then\",\n  \"each\",\n  \"into\",\n  \"such\",\n  \"any\",\n  \"been\",\n  \"if\",\n  \"would\",\n  \"about\",\n  \"should\",\n  \"these\",\n  \"those\",\n  \"their\",\n  \"we\",\n  \"our\",\n  \"so\",\n]);\n\n/** Tokenize a string into lowercase words, removing stop words. */\nexport function tokenizeSearchText(text: string): string[] {\n  return text\n    .toLowerCase()\n    .split(TOKEN_SPLIT_REGEX)\n    .filter((token) => token.length >= 2 && !STOP_WORDS.has(token));\n}\n\n/** Simple stemmer: strip common English suffixes for fuzzy matching. */\nexport function stemToken(word: string): string {\n  if (word.length <= 4) {\n    return word;\n  }\n  if (word.endsWith(\"ation\")) {\n    return word.slice(0, -5);\n  }\n  if (word.endsWith(\"ment\")) {\n    return word.slice(0, -4);\n  }\n  if (word.endsWith(\"ness\")) {\n    return word.slice(0, -4);\n  }\n  if (word.endsWith(\"ical\")) {\n    return word.slice(0, -4);\n  }\n  if (word.endsWith(\"tion\")) {\n    return word.slice(0, -4);\n  }\n  if (word.endsWith(\"sion\")) {\n    return word.slice(0, -4);\n  }\n  if (word.endsWith(\"ing\")) {\n    return word.slice(0, -3);\n  }\n  if (word.endsWith(\"ous\")) {\n    return word.slice(0, -3);\n  }\n  if (word.endsWith(\"ive\")) {\n    return word.slice(0, -3);\n  }\n  if (word.endsWith(\"ity\")) {\n    return word.slice(0, -3);\n  }\n  if (word.endsWith(\"ics\")) {\n    return word.slice(0, -3);\n  }\n  if (word.endsWith(\"ly\")) {\n    return word.slice(0, -2);\n  }\n  if (word.endsWith(\"ed\")) {\n    return word.slice(0, -2);\n  }\n  if (word.endsWith(\"er\")) {\n    return word.slice(0, -2);\n  }\n  if (word.endsWith(\"es\")) {\n    return word.slice(0, -2);\n  }\n  if (word.endsWith(\"al\")) {\n    return word.slice(0, -2);\n  }\n  if (word.endsWith(\"ic\")) {\n    return word.slice(0, -2);\n  }\n  if (word.endsWith(\"s\") && !word.endsWith(\"ss\")) {\n    return word.slice(0, -1);\n  }\n  return word;\n}\n\n/** Compute token overlap score between query tokens and text tokens. */\nexport function tokenOverlapScore(\n  queryTokens: string[],\n  textTokens: string[]\n): number {\n  if (queryTokens.length === 0 || textTokens.length === 0) {\n    return 0;\n  }\n\n  const stemmedText = new Set(textTokens.map(stemToken));\n  let matchCount = 0;\n\n  for (const queryToken of queryTokens) {\n    const stemmedQuery = stemToken(queryToken);\n\n    if (stemmedText.has(stemmedQuery)) {\n      matchCount += 1;\n      continue;\n    }\n\n    for (const textToken of stemmedText) {\n      if (\n        textToken.startsWith(stemmedQuery) ||\n        stemmedQuery.startsWith(textToken)\n      ) {\n        matchCount += 0.5;\n        break;\n      }\n    }\n  }\n\n  return matchCount / queryTokens.length;\n}\n\n/**\n * Extract character bigrams from text. Normalizes to lowercase, removes\n * non-alphanumeric characters, and generates overlapping pairs.\n */\nexport function bigramTokenize(text: string): Set<string> {\n  const normalized = text.toLowerCase().replace(NON_ALPHANUMERIC_REGEX, \"\");\n  const bigrams = new Set<string>();\n  for (let i = 0; i < normalized.length - 1; i++) {\n    bigrams.add(normalized.slice(i, i + 2));\n  }\n  return bigrams;\n}\n\n/**\n * Extract word-level tokens from text (for coarser matching).\n * Normalizes to lowercase, splits on non-alphanumeric.\n */\nexport function wordTokenize(text: string): string[] {\n  return text\n    .toLowerCase()\n    .split(TOKEN_SPLIT_REGEX)\n    .filter((token) => token.length > 1);\n}\n\n/** Jaccard similarity between two sets: |A ∩ B| / |A ∪ B|. */\nexport function jaccardSimilarity(\n  setA: Set<string>,\n  setB: Set<string>\n): number {\n  if (setA.size === 0 && setB.size === 0) {\n    return 0;\n  }\n\n  let intersectionSize = 0;\n  const smaller = setA.size <= setB.size ? setA : setB;\n  const larger = setA.size <= setB.size ? setB : setA;\n\n  for (const item of smaller) {\n    if (larger.has(item)) {\n      intersectionSize++;\n    }\n  }\n\n  const unionSize = setA.size + setB.size - intersectionSize;\n  return unionSize === 0 ? 0 : intersectionSize / unionSize;\n}\n\n/** Exact word overlap score: fraction of type words found in input text. */\nexport function wordOverlapScore(\n  inputWords: string[],\n  typeWords: string[]\n): number {\n  if (typeWords.length === 0) {\n    return 0;\n  }\n  let matches = 0;\n  for (const word of typeWords) {\n    if (inputWords.includes(word)) {\n      matches++;\n    }\n  }\n  return matches / typeWords.length;\n}\n\n/** Pre-compute reusable lexical structures for a query. */\nexport function prepareLexicalQuery(query: string): PreparedLexicalQuery {\n  return {\n    raw: query,\n    tokens: tokenizeSearchText(query),\n    words: wordTokenize(query),\n    bigrams: bigramTokenize(query),\n  };\n}\n\n/** Score a single lexical signal against a prepared query. */\nexport function scoreLexicalSignal(\n  query: PreparedLexicalQuery,\n  signal: LexicalSignal\n): number {\n  const text = signal.text?.trim();\n  if (!text) {\n    return 0;\n  }\n\n  switch (signal.strategy ?? \"tokenOverlap\") {\n    case \"bigramJaccard\":\n      return jaccardSimilarity(query.bigrams, bigramTokenize(text));\n    case \"wordOverlap\":\n      return wordOverlapScore(query.words, wordTokenize(text));\n    default:\n      return tokenOverlapScore(query.tokens, tokenizeSearchText(text));\n  }\n}\n\n/** Weighted lexical score across multiple textual signals. */\nexport function scoreLexicalSignals(\n  query: PreparedLexicalQuery,\n  signals: LexicalSignal[]\n): number {\n  let weightedScore = 0;\n  let totalWeight = 0;\n\n  for (const signal of signals) {\n    if (!signal.text?.trim() || signal.weight <= 0) {\n      continue;\n    }\n    weightedScore += scoreLexicalSignal(query, signal) * signal.weight;\n    totalWeight += signal.weight;\n  }\n\n  return totalWeight === 0 ? 0 : weightedScore / totalWeight;\n}\n\n/** Map a candidate's original rank position into a 0..1 prior. */\nexport function rankWindowScore(index: number, total: number): number {\n  if (total <= 1) {\n    return 1;\n  }\n  const clampedIndex = Math.max(0, Math.min(index, total - 1));\n  return 1 - clampedIndex / (total - 1);\n}\n\n/** Rerank a candidate window by lexical overlap while preserving original-rank prior. */\nexport function rerankLexicalWindow<T>(\n  query: string,\n  items: T[],\n  getText: (item: T) => string | null | undefined,\n  options?: LexicalRerankOptions\n): T[] {\n  const preparedQuery = prepareLexicalQuery(query);\n  if (preparedQuery.tokens.length === 0 || items.length <= 1) {\n    return items;\n  }\n\n  const lexicalWeight = options?.lexicalWeight ?? 0.65;\n  const rankWeight = options?.rankWeight ?? 0.35;\n\n  return items\n    .map((item, index) => {\n      const lexicalScore = scoreLexicalSignals(preparedQuery, [\n        { text: getText(item) ?? \"\", weight: 1, strategy: \"tokenOverlap\" },\n      ]);\n      const rankScore = rankWindowScore(index, items.length);\n\n      return {\n        item,\n        combinedScore: lexicalScore * lexicalWeight + rankScore * rankWeight,\n      };\n    })\n    .sort((left, right) => right.combinedScore - left.combinedScore)\n    .map(({ item }) => item);\n}\n","/**\n * @lucern/contracts — OntologiesV1 namespace (resource contracts)\n *\n * Ontology Matching Engine — L0 entity type classification and similarity scoring.\n * Provides bigram-based text similarity for matching free text against\n * ontology entity types. Domain-agnostic: works identically for companies,\n * molecules, code modules, or any tenant-defined entity vocabulary.\n *\n * Moved from src/ontology-matching.contract.ts in EK-16 T1 PR 2.\n * Compat shim remains at the old path until the Lucern 1.0.0 cut.\n */\n\nimport {\n  bigramTokenize,\n  jaccardSimilarity,\n  prepareLexicalQuery,\n  scoreLexicalSignals,\n  wordOverlapScore,\n  wordTokenize,\n} from \"../../text-matching.contract\";\n\n// =============================================================================\n// TYPES\n// =============================================================================\n\n/** An entity type definition from a resolved ontology version. */\nexport type OntologyEntityType = {\n  value: string;\n  label: string;\n  description?: string;\n  subtypes?: Array<{ value: string; label: string; description?: string }>;\n};\n\n/** A scored match between input text and an entity type. */\nexport type EntityTypeMatch = {\n  entityType: string;\n  label: string;\n  score: number;\n  reason: string;\n};\n\n/** A candidate entity node that can be matched against a target node. */\nexport type EntityMatchCandidate = {\n  nodeId: string;\n  entityType: string;\n  title: string;\n  canonicalText: string;\n  connectedBeliefCount: number;\n  connectedEvidenceCount: number;\n};\n\n/** A scored entity match with suggested bridge edge type. */\nexport type EntityConnectionMatch = {\n  entityNodeId: string;\n  entityType: string;\n  title: string;\n  score: number;\n  suggestedEdgeType: string;\n  reason: string;\n};\n\n// =============================================================================\n// ENTITY TYPE SCORING\n// =============================================================================\n\n/** Weights for combining scoring signals. */\nconst MATCH_WEIGHTS = {\n  tokenOverlap: 0.35,\n  bigramSimilarity: 0.25,\n  wordOverlap: 0.2,\n  descriptionBonus: 0.2,\n} as const;\n\n/**\n * Score how well input text matches a single entity type definition.\n * Combines bigram Jaccard similarity, word overlap, and description matching.\n */\nexport function scoreEntityTypeMatch(\n  inputText: string,\n  entityType: OntologyEntityType\n): EntityTypeMatch {\n  const preparedQuery = prepareLexicalQuery(inputText);\n  const labelText = `${entityType.label} ${entityType.value}`;\n\n  const tokenScore = scoreLexicalSignals(preparedQuery, [\n    { text: labelText, weight: 1, strategy: \"tokenOverlap\" },\n  ]);\n\n  // Score against the type label (primary signal)\n  const labelBigrams = bigramTokenize(entityType.label);\n  const bigramScore = jaccardSimilarity(preparedQuery.bigrams, labelBigrams);\n\n  // Word overlap with label + value\n  const labelWords = wordTokenize(labelText);\n  const wordScore = wordOverlapScore(preparedQuery.words, labelWords);\n\n  // Description matching bonus (if description exists)\n  let descScore = 0;\n  if (entityType.description) {\n    descScore = scoreLexicalSignals(preparedQuery, [\n      { text: entityType.description, weight: 1, strategy: \"tokenOverlap\" },\n    ]);\n  }\n\n  // Check subtypes for additional matches\n  let subtypeBonus = 0;\n  if (entityType.subtypes && entityType.subtypes.length > 0) {\n    for (const subtype of entityType.subtypes) {\n      const subtypeScore = scoreLexicalSignals(preparedQuery, [\n        {\n          text: `${subtype.label} ${subtype.value} ${subtype.description || \"\"}`,\n          weight: 1,\n          strategy: \"tokenOverlap\",\n        },\n      ]);\n      subtypeBonus = Math.max(subtypeBonus, subtypeScore * 0.3); // up to 30% subtype bonus\n    }\n  }\n\n  const score = Math.min(\n    1.0,\n    tokenScore * MATCH_WEIGHTS.tokenOverlap +\n      bigramScore * MATCH_WEIGHTS.bigramSimilarity +\n      wordScore * MATCH_WEIGHTS.wordOverlap +\n      descScore * MATCH_WEIGHTS.descriptionBonus +\n      subtypeBonus\n  );\n\n  // Generate human-readable reason\n  const reasons: string[] = [];\n  if (tokenScore > 0.3) {\n    reasons.push(`stem match: ${(tokenScore * 100).toFixed(0)}%`);\n  }\n  if (bigramScore > 0.3) {\n    reasons.push(`text similarity: ${(bigramScore * 100).toFixed(0)}%`);\n  }\n  if (wordScore > 0.3) {\n    reasons.push(`word match: ${(wordScore * 100).toFixed(0)}%`);\n  }\n  if (descScore > 0.2) {\n    reasons.push(\"description match\");\n  }\n  if (subtypeBonus > 0.05) {\n    reasons.push(\"subtype match\");\n  }\n  const reason = reasons.length > 0 ? reasons.join(\", \") : \"low similarity\";\n\n  return {\n    entityType: entityType.value,\n    label: entityType.label,\n    score,\n    reason,\n  };\n}\n\n/**\n * Rank all entity types in an ontology against input text.\n * Returns matches sorted by score (descending), filtered to score > minScore.\n */\nexport function rankEntityTypeMatches(\n  inputText: string,\n  entityTypes: OntologyEntityType[],\n  options?: { minScore?: number; limit?: number }\n): EntityTypeMatch[] {\n  const minScore = options?.minScore ?? 0.05;\n  const limit = options?.limit ?? 10;\n\n  const matches = entityTypes\n    .map((et) => scoreEntityTypeMatch(inputText, et))\n    .filter((m) => m.score >= minScore)\n    .sort((a, b) => b.score - a.score)\n    .slice(0, limit);\n\n  return matches;\n}\n\n// =============================================================================\n// ENTITY DISCOVERY SCORING\n// =============================================================================\n\n/**\n * Score how well a node's text matches an entity candidate.\n * Used by discover_entity_connections to suggest missing bridge edges.\n */\nexport function scoreEntityConnection(\n  nodeText: string,\n  candidate: EntityMatchCandidate,\n  options?: { connectivityWeight?: number }\n): EntityConnectionMatch {\n  const preparedQuery = prepareLexicalQuery(nodeText);\n  const connectivityWeight = options?.connectivityWeight ?? 0.3;\n  const textWeight = 1.0 - connectivityWeight;\n  const candidateText = `${candidate.title} ${candidate.canonicalText}`;\n  const tokenScore = scoreLexicalSignals(preparedQuery, [\n    { text: candidateText, weight: 1, strategy: \"tokenOverlap\" },\n  ]);\n  const textScore = scoreLexicalSignals(preparedQuery, [\n    { text: candidateText, weight: 1, strategy: \"bigramJaccard\" },\n  ]);\n  const wordScore = scoreLexicalSignals(preparedQuery, [\n    { text: candidateText, weight: 1, strategy: \"wordOverlap\" },\n  ]);\n\n  // Connectivity signal (normalized externally by caller)\n  const maxConnections = Math.max(\n    1,\n    candidate.connectedBeliefCount + candidate.connectedEvidenceCount\n  );\n  const connectivityScore = Math.min(1.0, maxConnections / 10); // soft-cap at 10\n\n  const combinedTextScore =\n    tokenScore * 0.45 + textScore * 0.35 + wordScore * 0.2;\n  const score =\n    combinedTextScore * textWeight + connectivityScore * connectivityWeight;\n\n  // Suggest edge type based on entity type\n  const suggestedEdgeType = suggestEdgeType(candidate.entityType);\n\n  const reason =\n    tokenScore > 0.3\n      ? `stem match: ${(tokenScore * 100).toFixed(0)}%`\n      : textScore > 0.2\n        ? `name similarity: ${(textScore * 100).toFixed(0)}%`\n        : wordScore > 0.2\n          ? `keyword match: ${(wordScore * 100).toFixed(0)}%`\n          : `connectivity: ${candidate.connectedBeliefCount} beliefs`;\n\n  return {\n    entityNodeId: candidate.nodeId,\n    entityType: candidate.entityType,\n    title: candidate.title,\n    score,\n    suggestedEdgeType,\n    reason,\n  };\n}\n\n/**\n * Suggest the most appropriate bridge edge type for an entity type.\n */\nfunction suggestEdgeType(entityType: string): string {\n  switch (entityType) {\n    case \"company\":\n    case \"person\":\n    case \"investor\":\n      return \"contains\";\n    case \"function\":\n    case \"value_chain\":\n      return \"impacts\";\n    default:\n      return \"contains\";\n  }\n}\n\n/**\n * Rank entity candidates against a node's text.\n * Returns sorted matches above the minimum score threshold.\n */\nexport function rankEntityConnections(\n  nodeText: string,\n  candidates: EntityMatchCandidate[],\n  options?: { minScore?: number; limit?: number; connectivityWeight?: number }\n): EntityConnectionMatch[] {\n  const minScore = options?.minScore ?? 0.05;\n  const limit = options?.limit ?? 10;\n\n  return candidates\n    .map((c) =>\n      scoreEntityConnection(nodeText, c, {\n        connectivityWeight: options?.connectivityWeight,\n      })\n    )\n    .filter((m) => m.score >= minScore)\n    .sort((a, b) => b.score - a.score)\n    .slice(0, limit);\n}\n"]}

package/dist/ontologyApproval-Ba0Jjk1k.d.ts

@@ -0,0 +1,26 @@
+declare const getPendingForProject: any;
+declare const getPendingForNode: any;
+declare const getThemeOntologyMatches: any;
+declare const createPendingLink: any;
+declare const approve: any;
+declare const reject: any;
+declare const bulkApprove: any;
+declare const bulkApproveHighConfidence: any;
+declare const createNeo4jEdge: any;
+declare const batchCreatePendingLinks: any;
+
+declare const ontologyApproval_approve: typeof approve;
+declare const ontologyApproval_batchCreatePendingLinks: typeof batchCreatePendingLinks;
+declare const ontologyApproval_bulkApprove: typeof bulkApprove;
+declare const ontologyApproval_bulkApproveHighConfidence: typeof bulkApproveHighConfidence;
+declare const ontologyApproval_createNeo4jEdge: typeof createNeo4jEdge;
+declare const ontologyApproval_createPendingLink: typeof createPendingLink;
+declare const ontologyApproval_getPendingForNode: typeof getPendingForNode;
+declare const ontologyApproval_getPendingForProject: typeof getPendingForProject;
+declare const ontologyApproval_getThemeOntologyMatches: typeof getThemeOntologyMatches;
+declare const ontologyApproval_reject: typeof reject;
+declare namespace ontologyApproval {
+  export { ontologyApproval_approve as approve, ontologyApproval_batchCreatePendingLinks as batchCreatePendingLinks, ontologyApproval_bulkApprove as bulkApprove, ontologyApproval_bulkApproveHighConfidence as bulkApproveHighConfidence, ontologyApproval_createNeo4jEdge as createNeo4jEdge, ontologyApproval_createPendingLink as createPendingLink, ontologyApproval_getPendingForNode as getPendingForNode, ontologyApproval_getPendingForProject as getPendingForProject, ontologyApproval_getThemeOntologyMatches as getThemeOntologyMatches, ontologyApproval_reject as reject };
+}
+
+export { getPendingForNode as a, getThemeOntologyMatches as b, createPendingLink as c, approve as d, bulkApprove as e, bulkApproveHighConfidence as f, getPendingForProject as g, createNeo4jEdge as h, batchCreatePendingLinks as i, ontologyApproval as o, reject as r };

package/dist/ontologyApproval.d.ts

@@ -0,0 +1 @@
+export { d as approve, i as batchCreatePendingLinks, e as bulkApprove, f as bulkApproveHighConfidence, h as createNeo4jEdge, c as createPendingLink, a as getPendingForNode, g as getPendingForProject, b as getThemeOntologyMatches, r as reject } from './ontologyApproval-Ba0Jjk1k.js';

package/dist/ontologyApproval.js

@@ -0,0 +1,78 @@
+import { v } from 'convex/values';
+import { componentsGeneric, queryGeneric, mutationGeneric, internalMutationGeneric } from 'convex/server';
+
+// src/ontologyApproval.ts
+componentsGeneric();
+var internalMutation = internalMutationGeneric;
+var mutation = mutationGeneric;
+var query = queryGeneric;
+var permissiveReturn = v.optional(v.any());
+var looseJsonObject = v.record(v.string(), v.any());
+var looseJsonArray = v.array(v.any());
+v.union(
+  v.string(),
+  v.number(),
+  v.boolean(),
+  v.null(),
+  looseJsonObject,
+  looseJsonArray
+);
+
+// src/ontologyApproval.ts
+var getPendingForProject = query({
+  args: v.any(),
+  returns: permissiveReturn,
+  handler: async () => ({ total: 0, bySource: [] })
+});
+var getPendingForNode = query({
+  args: v.any(),
+  returns: permissiveReturn,
+  handler: async () => []
+});
+var getThemeOntologyMatches = query({
+  args: v.any(),
+  returns: permissiveReturn,
+  handler: async () => []
+});
+var createPendingLink = mutation({
+  args: v.any(),
+  returns: permissiveReturn,
+  handler: async () => null
+});
+var approve = mutation({
+  args: v.any(),
+  returns: permissiveReturn,
+  handler: async () => ({ success: true })
+});
+var reject = mutation({
+  args: v.any(),
+  returns: permissiveReturn,
+  handler: async () => ({ success: true })
+});
+var bulkApprove = mutation({
+  args: v.any(),
+  returns: permissiveReturn,
+  handler: async (ctx, args) => ({
+    approved: 0,
+    total: Array.isArray(args.linkIds) ? args.linkIds.length : 0
+  })
+});
+var bulkApproveHighConfidence = mutation({
+  args: v.any(),
+  returns: permissiveReturn,
+  handler: async () => ({ approved: 0 })
+});
+var createNeo4jEdge = internalMutation({
+  args: v.any(),
+  returns: permissiveReturn,
+  handler: async () => ({ success: true })
+});
+var batchCreatePendingLinks = internalMutation({
+  args: v.any(),
+  returns: permissiveReturn,
+  handler: async () => ({ created: 0, autoApproved: 0 })
+});
+
+export { approve, batchCreatePendingLinks, bulkApprove, bulkApproveHighConfidence, createNeo4jEdge, createPendingLink, getPendingForNode, getPendingForProject, getThemeOntologyMatches, reject };
+//# sourceMappingURL=ontologyApproval.js.map
+//# sourceMappingURL=ontologyApproval.js.map

package/dist/ontologyApproval.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/convex.ts","../../schema-management/src/validators.ts","../src/ontologyApproval.ts"],"names":["v"],"mappings":"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","file":"ontologyApproval.js","sourcesContent":["import {\n  actionGeneric,\n  anyApi,\n  componentsGeneric,\n  httpActionGeneric,\n  internalActionGeneric,\n  internalMutationGeneric,\n  internalQueryGeneric,\n  mutationGeneric,\n  queryGeneric,\n} from \"convex/server\";\nimport type { GenericId } from \"convex/values\";\n\nexport const api = anyApi as any;\nexport const components = componentsGeneric() as any;\nexport const internal = anyApi as any;\n\nexport type TableNames = string;\nexport type Id<TableName extends TableNames = string> = GenericId<TableName>;\nexport type Doc<TableName extends TableNames = string> = any;\nexport type DataModel = any;\nexport type ActionCtx = any;\nexport type DatabaseReader = any;\nexport type DatabaseWriter = any;\nexport type MutationCtx = any;\nexport type QueryCtx = any;\n\nexport const action = actionGeneric as any;\nexport const httpAction = httpActionGeneric as any;\nexport const internalAction = internalActionGeneric as any;\nexport const internalMutation = internalMutationGeneric as any;\nexport const internalQuery = internalQueryGeneric as any;\nexport const mutation = mutationGeneric as any;\nexport const query = queryGeneric as any;\n","/**\n * validators module implementation.\n */\n\nimport { v } from \"convex/values\";\n\n/**\n * Permissive return validator used while contracts are tightened.\n */\nexport const permissiveReturn: any = v.optional(v.any());\n\n/**\n * Shallow JSON validators for dynamic payloads.\n */\nexport const looseJsonObject = v.record(v.string(), v.any());\nexport const looseJsonArray = v.array(v.any());\nexport const looseJsonValue = v.union(\n  v.string(),\n  v.number(),\n  v.boolean(),\n  v.null(),\n  looseJsonObject,\n  looseJsonArray\n);\n","// DORMANT: Ontology approval UI stubbed in EK-16.1c. Re-enable when approval workflow ships.\n\nimport { v } from \"convex/values\";\nimport { internalMutation, mutation, query } from \"./convex\";\nimport { permissiveReturn } from \"@lucern/schema-management/validators\";\n\nexport const getPendingForProject = query({\n  args: v.any(),\n  returns: permissiveReturn,\n  handler: async () => ({ total: 0, bySource: [] }),\n});\n\nexport const getPendingForNode = query({\n  args: v.any(),\n  returns: permissiveReturn,\n  handler: async () => [],\n});\n\nexport const getThemeOntologyMatches = query({\n  args: v.any(),\n  returns: permissiveReturn,\n  handler: async () => [],\n});\n\nexport const createPendingLink = mutation({\n  args: v.any(),\n  returns: permissiveReturn,\n  handler: async () => null,\n});\n\nexport const approve = mutation({\n  args: v.any(),\n  returns: permissiveReturn,\n  handler: async () => ({ success: true }),\n});\n\nexport const reject = mutation({\n  args: v.any(),\n  returns: permissiveReturn,\n  handler: async () => ({ success: true }),\n});\n\nexport const bulkApprove = mutation({\n  args: v.any(),\n  returns: permissiveReturn,\n  handler: async (ctx, args) => ({\n    approved: 0,\n    total: Array.isArray((args as { linkIds?: unknown[] }).linkIds)\n      ? (args as { linkIds: unknown[] }).linkIds.length\n      : 0,\n  }),\n});\n\nexport const bulkApproveHighConfidence = mutation({\n  args: v.any(),\n  returns: permissiveReturn,\n  handler: async () => ({ approved: 0 }),\n});\n\nexport const createNeo4jEdge = internalMutation({\n  args: v.any(),\n  returns: permissiveReturn,\n  handler: async () => ({ success: true }),\n});\n\nexport const batchCreatePendingLinks = internalMutation({\n  args: v.any(),\n  returns: permissiveReturn,\n  handler: async () => ({ created: 0, autoApproved: 0 }),\n});\n"]}

package/dist/ontologyDefinitions.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Ontology Definition Mutations & Queries
+ *
+ * CRUD operations for first-class ontology definition objects.
+ * Follows the packDefinitions + packVersions two-table pattern from Master Control.
+ *
+ * Pure helper functions live in ontologyHelpers.ts for unit testing.
+ *
+ * @module graph-primitives/ontologyDefinitions
+ */
+/**
+ * Get an ontology definition by ID.
+ */
+declare const getOntologyDefinition: any;
+/**
+ * Get an ontology definition by ontologyKey (optionally scoped by tenant).
+ */
+declare const getOntologyDefinitionByKey: any;
+/**
+ * List ontology definitions with optional filters.
+ */
+declare const listOntologyDefinitions: any;
+/**
+ * Get a specific version by ontologyId + version string.
+ */
+declare const getOntologyVersion: any;
+/**
+ * List versions for an ontology, optionally filtered by status.
+ */
+declare const listOntologyVersions: any;
+/**
+ * Get the latest published version for an ontology.
+ */
+declare const getPublishedVersion: any;
+/**
+ * Resolve the effective ontology by composing parent chain.
+ * Walks parentOntologyId chain (max depth 3) and merges additively.
+ */
+declare const resolveEffectiveOntology: any;
+/**
+ * Create a new ontology definition.
+ */
+declare const createOntologyDefinition: any;
+/**
+ * Update an ontology definition (name, description, status).
+ * Only allowed while draft or active.
+ */
+declare const updateOntologyDefinition: any;
+/**
+ * Archive an ontology definition.
+ */
+declare const archiveOntologyDefinition: any;
+/**
+ * Create a new version snapshot for an ontology.
+ */
+declare const createOntologyVersion: any;
+/**
+ * Update a draft version (entityTypes, edgeTypes, releaseNotes).
+ * Only allowed while version is in "draft" status.
+ */
+declare const updateDraftVersion: any;
+/**
+ * Publish a version — freezes it (status → "published").
+ * If the parent definition is "draft", promotes it to "active".
+ */
+declare const publishOntologyVersion: any;
+/**
+ * Deprecate a published version.
+ */
+declare const deprecateOntologyVersion: any;
+
+export { archiveOntologyDefinition, createOntologyDefinition, createOntologyVersion, deprecateOntologyVersion, getOntologyDefinition, getOntologyDefinitionByKey, getOntologyVersion, getPublishedVersion, listOntologyDefinitions, listOntologyVersions, publishOntologyVersion, resolveEffectiveOntology, updateDraftVersion, updateOntologyDefinition };