@supericons/mcp 0.4.8 → 0.4.10

package/search.js

@@ -38,6 +38,8 @@ const multilingualSearchAliases = existsSync(multilingualAliasesPath)
   : [];
 const multilingualExpansionTerms = [...cjkSearchTerms, ...multilingualSearchAliases];
 const iconSearchMetadataCache = new WeakMap();
+const LOGO_INTENT_TOKENS = new Set(['logo', 'logos', 'icon', 'icons', 'brand', 'brands', 'mark', 'marks', 'symbol', 'symbols']);
+const GENERIC_AI_LOGO_TOKENS = new Set(['ai', 'artificial', 'intelligence']);
 
 /** Inline Levenshtein distance (capped early for performance) */
 function editDistance(a, b) {
@@ -78,6 +80,60 @@ function getIconSemanticAliases(icon) {
   return iconSemanticAliasMap.get(iconKey(icon)) || null;
 }
 
+function collectIconSearchValues(icon) {
+  const values = [
+    icon.name,
+    icon.id,
+    iconKey(icon),
+    icon.meaning,
+    icon.jobCategory,
+    icon.aiCategory,
+    icon.aiCategoryLabel,
+    icon.assetType,
+    icon.pack,
+    icon.access,
+  ];
+
+  for (const field of [
+    'semanticTags',
+    'synonyms',
+    'aliases',
+    'searchTerms',
+    'filterTags',
+    'aiFilterTags',
+    'secondaryCategories',
+    'variants',
+  ]) {
+    if (Array.isArray(icon[field])) {
+      values.push(...icon[field]);
+    }
+  }
+
+  return values.filter((value) => typeof value === 'string' && value.trim());
+}
+
+function getMeaningfulQueryWords(queryWords) {
+  const withoutLogoIntent = queryWords.filter((word) => !LOGO_INTENT_TOKENS.has(word));
+  const candidateWords = withoutLogoIntent.length > 0 ? withoutLogoIntent : queryWords;
+  const withoutGenericAi = candidateWords.length > 1
+    ? candidateWords.filter((word) => !GENERIC_AI_LOGO_TOKENS.has(word))
+    : candidateWords;
+  return withoutGenericAi.length > 0 ? withoutGenericAi : candidateWords;
+}
+
+function hasLogoIntent(queryWords) {
+  return queryWords.some((word) => LOGO_INTENT_TOKENS.has(word));
+}
+
+function isSupericonsBrandLogo(icon) {
+  return icon.lib === 'si'
+    && (
+      icon.assetType === 'brand-logo'
+      || icon.aiFilterTags?.includes('brand-logo')
+      || icon.filterTags?.includes('brand-logo')
+    );
+}
+
 function getIconSearchMetadata(icon) {
   const cached = iconSearchMetadataCache.get(icon);
   if (cached) return cached;
@@ -91,9 +147,10 @@ function getIconSearchMetadata(icon) {
     ...tokenizeSemanticText(icon.name),
     ...tokenizeSemanticText(icon.id),
     ...tokenizeSemanticText(iconKey(icon)),
+    ...collectIconSearchValues(icon).flatMap((value) => tokenizeSemanticText(value)),
   ]);
   const segments = lowerId.split(/[-_]/).concat(lowerName.split(/[\s\-_]/));
-  const aliases = (getIconSemanticAliases(icon) || [])
+  const aliases = [...(getIconSemanticAliases(icon) || []), ...collectIconSearchValues(icon)]
     .map((alias) => {
       const normalized = normalizeSemanticText(alias);
       return normalized
@@ -120,10 +177,11 @@ function getDirectSearchScore(icon, normalizedQuery, queryWords) {
   if (!normalizedQuery) return 0;
 
   const { name, id, fullId, tokens } = getIconSearchMetadata(icon);
-
-  if (name === normalizedQuery || id === normalizedQuery || fullId === normalizedQuery) {
-    return 320;
-  }
+  const meaningfulQueryWords = getMeaningfulQueryWords(queryWords);
+
+  if (name === normalizedQuery || id === normalizedQuery || fullId === normalizedQuery) {
+    return 320;
+  }
 
   if (normalizedQuery.length > 2 && (
     name.includes(normalizedQuery)
@@ -133,14 +191,14 @@ function getDirectSearchScore(icon, normalizedQuery, queryWords) {
     return 250;
   }
 
-  if (queryWords.length > 0 && queryWords.every((word) => tokens.has(word))) {
-    return 190;
-  }
-
-  if (queryWords.length > 0 && queryWords.every((word) => (
-    name.includes(word) || id.includes(word) || fullId.includes(word)
-  ))) {
-    return 150;
+  if (meaningfulQueryWords.length > 0 && meaningfulQueryWords.every((word) => tokens.has(word))) {
+    return 190;
+  }
+
+  if (meaningfulQueryWords.length > 0 && meaningfulQueryWords.every((word) => (
+    name.includes(word) || id.includes(word) || fullId.includes(word)
+  ))) {
+    return 150;
   }
 
   return 0;
@@ -153,6 +211,9 @@ function getCuratedAliasScore(icon, normalizedQuery, queryWords) {
   if (!aliases?.length) return 0;
 
   let bestScore = 0;
+  const meaningfulQueryWords = getMeaningfulQueryWords(queryWords);
+  const meaningfulQuery = meaningfulQueryWords.join(' ');
+  const shouldBoostBrandLogo = hasLogoIntent(queryWords) && isSupericonsBrandLogo(icon);
 
   for (const alias of aliases) {
     const { normalized: normalizedAlias, tokens: aliasTokens } = alias;
@@ -163,25 +224,30 @@ function getCuratedAliasScore(icon, normalizedQuery, queryWords) {
       continue;
     }
 
-    if (normalizedQuery.length > 3 && normalizedAlias.includes(normalizedQuery)) {
-      bestScore = Math.max(bestScore, 360);
-      continue;
-    }
-
-    if (queryWords.length > 1 && queryWords.every((word) => aliasTokens.has(word))) {
-      bestScore = Math.max(bestScore, 320);
-      continue;
-    }
-
-    if (queryWords.length === 1 && aliasTokens.has(queryWords[0])) {
-      bestScore = Math.max(bestScore, 260);
-      continue;
-    }
-
-    if (queryWords.length > 0 && queryWords.every((word) => normalizedAlias.includes(word))) {
-      bestScore = Math.max(bestScore, 220);
-    }
-  }
+    if (normalizedQuery.length > 3 && normalizedAlias.includes(normalizedQuery)) {
+      bestScore = Math.max(bestScore, 360);
+      continue;
+    }
+
+    if (meaningfulQuery.length > 3 && normalizedAlias.includes(meaningfulQuery)) {
+      bestScore = Math.max(bestScore, shouldBoostBrandLogo ? 520 : 350);
+      continue;
+    }
+
+    if (meaningfulQueryWords.length > 1 && meaningfulQueryWords.every((word) => aliasTokens.has(word))) {
+      bestScore = Math.max(bestScore, shouldBoostBrandLogo ? 490 : 320);
+      continue;
+    }
+
+    if (meaningfulQueryWords.length === 1 && aliasTokens.has(meaningfulQueryWords[0])) {
+      bestScore = Math.max(bestScore, shouldBoostBrandLogo ? 460 : 260);
+      continue;
+    }
+
+    if (meaningfulQueryWords.length > 0 && meaningfulQueryWords.every((word) => normalizedAlias.includes(word))) {
+      bestScore = Math.max(bestScore, shouldBoostBrandLogo ? 420 : 220);
+    }
+  }
 
   return bestScore;
 }

package/semantic-registry.js

@@ -2,15 +2,40 @@ import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { getBaseSemanticIdsForVariant } from './variant-support.js';
 
-const PUBLIC_SEMANTIC_FIELDS = Object.freeze([
-  'label',
-  'source_name',
-  'depicts',
-  'semantic_tags',
-  'synonyms',
-  'use_when',
-  'avoid_when',
-]);
+const PUBLIC_SEMANTIC_FIELDS = Object.freeze([
+  'id',
+  'source_library',
+  'label',
+  'name',
+  'slug',
+  'source_name',
+  'purpose',
+  'category',
+  'asset_type',
+  'pack',
+  'source_url',
+  'source_trust',
+  'meaning',
+  'depicts',
+  'semantic_tags',
+  'ai_category',
+  'ai_category_label',
+  'ai_filter_tags',
+  'job_category',
+  'secondary_categories',
+  'synonyms',
+  'aliases',
+  'search_terms',
+  'filter_tags',
+  'use_when',
+  'avoid_when',
+  'rights',
+  'variants',
+  'quality_status',
+  'access',
+]);
+const LOGO_INTENT_TOKENS = new Set(['logo', 'logos', 'icon', 'icons', 'brand', 'brands', 'mark', 'marks', 'symbol', 'symbols']);
+const GENERIC_AI_TOKENS = new Set(['ai', 'artificial', 'intelligence']);
 
 function normalizeText(value) {
   return String(value || '')
@@ -22,10 +47,95 @@ function normalizeText(value) {
     .trim();
 }
 
-function tokenize(value) {
-  const normalized = normalizeText(value);
-  return normalized ? normalized.split(' ') : [];
-}
+function tokenize(value) {
+  const normalized = normalizeText(value);
+  return normalized ? normalized.split(' ') : [];
+}
+
+function uniqueStrings(values = []) {
+  const seen = new Set();
+  const output = [];
+
+  for (const value of values) {
+    if (typeof value !== 'string') continue;
+    const normalized = normalizeText(value);
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    output.push(normalized);
+  }
+
+  return output;
+}
+
+function getMeaningfulQueryTokens(queryTokens) {
+  const withoutLogoIntent = queryTokens.filter((token) => !LOGO_INTENT_TOKENS.has(token));
+  const candidateTokens = withoutLogoIntent.length > 0 ? withoutLogoIntent : queryTokens;
+  const withoutGenericAi = candidateTokens.length > 1
+    ? candidateTokens.filter((token) => !GENERIC_AI_TOKENS.has(token))
+    : candidateTokens;
+
+  return withoutGenericAi.length > 0 ? withoutGenericAi : candidateTokens;
+}
+
+function buildQueryPhraseVariants(queryTokens, meaningfulTokens) {
+  const variants = [
+    queryTokens.join(' '),
+    meaningfulTokens.join(' '),
+  ];
+
+  for (let size = Math.min(4, meaningfulTokens.length); size >= 2; size -= 1) {
+    for (let index = 0; index <= meaningfulTokens.length - size; index += 1) {
+      variants.push(meaningfulTokens.slice(index, index + size).join(' '));
+    }
+  }
+
+  return uniqueStrings(variants).filter((variant) => variant.length > 2);
+}
+
+function scoreSemanticValue(value, weight, phraseVariants, meaningfulTokens) {
+  const normalized = normalizeText(value);
+  if (!normalized) return 0;
+
+  let score = 0;
+
+  for (const phrase of phraseVariants) {
+    if (normalized === phrase) {
+      score = Math.max(score, weight * 4);
+      continue;
+    }
+
+    if (phrase.length > 2 && normalized.includes(phrase)) {
+      score = Math.max(score, weight * 2.6);
+      continue;
+    }
+
+    if (normalized.length > 2 && phrase.includes(normalized) && tokenize(normalized).length > 1) {
+      score = Math.max(score, weight * 1.6);
+    }
+  }
+
+  if (meaningfulTokens.length > 0) {
+    const valueTokens = new Set(tokenize(normalized));
+    const exactHits = meaningfulTokens.filter((token) => valueTokens.has(token)).length;
+    const includesHits = meaningfulTokens.filter((token) => normalized.includes(token)).length;
+
+    if (exactHits === meaningfulTokens.length) {
+      score = Math.max(score, weight * 1.8);
+    } else if (includesHits > 0) {
+      score += includesHits * weight * 0.35;
+    }
+  }
+
+  return score;
+}
+
+function scoreSemanticValues(values, weight, phraseVariants, meaningfulTokens) {
+  if (!Array.isArray(values)) return 0;
+  return values.reduce(
+    (total, value) => total + scoreSemanticValue(value, weight, phraseVariants, meaningfulTokens),
+    0,
+  );
+}
 
 function buildPossibleRegistryIds(library, id) {
   return getBaseSemanticIdsForVariant({ library, id });
@@ -88,49 +198,60 @@ export function attachSemanticPayload(target, semanticMap, iconOrLibrary, maybeI
   return semantic ? { ...target, semantic } : target;
 }
 
-export function scoreSemanticAlignment(query, semanticRecord) {
-  if (!semanticRecord) return 0;
-
-  const queryTokens = tokenize(query);
-  if (queryTokens.length === 0) return 0;
-
-  const weightedSources = [
-    { value: semanticRecord.label, weight: 6 },
-    { value: semanticRecord.source_name, weight: 5 },
-    { value: semanticRecord.depicts, weight: 4 },
-    { value: semanticRecord.use_when, weight: 3 },
-    { value: semanticRecord.avoid_when, weight: 2 },
-  ];
-
-  let score = 0;
-
-  for (const tag of semanticRecord.semantic_tags || []) {
-    const normalized = normalizeText(tag);
-    for (const token of queryTokens) {
-      if (normalized === token) score += 8;
-      else if (normalized.includes(token)) score += 5;
-    }
-  }
-
-  for (const synonym of semanticRecord.synonyms || []) {
-    const normalized = normalizeText(synonym);
-    for (const token of queryTokens) {
-      if (normalized === token) score += 7;
-      else if (normalized.includes(token)) score += 4;
-    }
-  }
-
-  for (const source of weightedSources) {
-    const normalized = normalizeText(source.value);
-    if (!normalized) continue;
-    for (const token of queryTokens) {
-      if (normalized === token) score += source.weight + 2;
-      else if (normalized.includes(token)) score += source.weight;
-    }
-  }
-
-  return score;
-}
+export function scoreSemanticAlignment(query, semanticRecord) {
+  if (!semanticRecord) return 0;
+
+  const queryTokens = tokenize(query);
+  if (queryTokens.length === 0) return 0;
+
+  const meaningfulTokens = getMeaningfulQueryTokens(queryTokens);
+  const phraseVariants = buildQueryPhraseVariants(queryTokens, meaningfulTokens);
+  const hasLogoIntent = queryTokens.some((token) => LOGO_INTENT_TOKENS.has(token));
+  const isSupericonsBrandLogo = semanticRecord.source_library === 'si'
+    && (
+      semanticRecord.asset_type === 'brand-logo'
+      || semanticRecord.ai_filter_tags?.includes('brand-logo')
+      || semanticRecord.filter_tags?.includes('brand-logo')
+    );
+  let score = 0;
+
+  score += scoreSemanticValue(semanticRecord.label, 24, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValue(semanticRecord.name, 24, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValue(semanticRecord.source_name, 22, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValues(semanticRecord.aliases, 22, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValues(semanticRecord.synonyms, 21, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValues(semanticRecord.semantic_tags, 19, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValues(semanticRecord.search_terms, 18, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValue(semanticRecord.meaning, 16, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValue(semanticRecord.purpose, 15, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValues(semanticRecord.ai_filter_tags, 14, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValues(semanticRecord.filter_tags, 13, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValues(semanticRecord.secondary_categories, 12, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValue(semanticRecord.ai_category_label, 10, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValue(semanticRecord.job_category, 10, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValue(semanticRecord.category, 8, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValue(semanticRecord.depicts, 8, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValue(semanticRecord.use_when, 8, phraseVariants, meaningfulTokens);
+  score += scoreSemanticValue(semanticRecord.avoid_when, 1, phraseVariants, meaningfulTokens);
+
+  if (hasLogoIntent && isSupericonsBrandLogo) {
+    score += 10;
+  }
+
+  const identityValues = uniqueStrings([
+    semanticRecord.label,
+    semanticRecord.name,
+    semanticRecord.source_name,
+    ...(semanticRecord.aliases || []),
+    ...(semanticRecord.synonyms || []),
+  ]);
+  const meaningfulQuery = meaningfulTokens.join(' ');
+  if (hasLogoIntent && identityValues.some((value) => value === meaningfulQuery)) {
+    score += 80;
+  }
+
+  return score;
+}
 
 export function chooseSemanticCandidate(query, icons, semanticMap) {
   const scored = icons

package/server.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/curlymolelabs/supericons",
     "source": "github"
   },
-  "version": "0.4.7",
+  "version": "0.4.10",
   "remotes": [
     {
       "type": "streamable-http",
@@ -18,7 +18,7 @@
     {
       "registryType": "npm",
       "identifier": "@supericons/mcp",
-      "version": "0.4.7",
+      "version": "0.4.10",
       "transport": {
         "type": "stdio"
       }