@corva/ui 3.78.0-15 → 3.78.0-16

package/mcp-server/server.mjs

@@ -246,9 +246,9 @@ const validateDsn = dsn => {
   return url.href;
 };
 
-const MCP_SERVER_VERSION = '1.7.0';
+const MCP_SERVER_VERSION = '1.8.0';
 
-var version = "3.78.0-15";
+var version = "3.78.0-16";
 
 const CORVA_UI_VERSION = version;
 
@@ -1055,6 +1055,8 @@ const SEARCH_CONFIG = {
     exactMatch: 100,
     startsWith: 50,
     contains: 30,
+    // Above keywordExact: a query word that names the entry beats one its keywords merely carry.
+    nameWord: 25,
     keywordExact: 20,
     keywordContains: 10,
     description: 5,
@@ -1064,7 +1066,9 @@ const SEARCH_CONFIG = {
     v2Component: 10
   },
   defaults: {
-    maxResults: 10
+    maxResults: 10,
+    // Outside `limit`: the fallback answers "does the other version have it", not "show more".
+    maxFallbackResults: 5
   }
 };
 
@@ -21548,6 +21552,35 @@ const withTimeout = async (promise, ms) => {
  */
 const singleLine = text => text.replace(/\s+/g, ' ').trim();
 
+const parseQuery = queryLower => {
+  const rawWords = queryLower.trim().split(/\s+/);
+  const queryWords = rawWords.filter(w => w.length > 1);
+  const isMultiWord = rawWords.length >= 2 && queryWords.length >= 2;
+  // When the query has filler words around a single meaningful word (e.g. "a button"),
+  // the single-word path should match against just that word instead of the whole query.
+  const singleWordQuery = !isMultiWord && queryWords.length === 1 ? queryWords[0] : queryLower;
+  return {
+    queryWords,
+    isMultiWord,
+    singleWordQuery
+  };
+};
+
+/**
+ * Whether the name equals the query or starts with it — the query read the way the name scorers
+ * read it: filler words dropped, a multi-word query collapsed ("date picker" → "datepicker").
+ * Only such a match proves the version holds what was asked for; a keyword or prose hit does not.
+ */
+const hasNameMatch = (name, query) => {
+  const {
+    queryWords,
+    isMultiWord,
+    singleWordQuery
+  } = parseQuery(query.toLowerCase());
+  const needle = (isMultiWord ? queryWords.join('') : singleWordQuery).trim();
+  return needle.length > 0 && name.toLowerCase().startsWith(needle);
+};
+
 /**
  * "icon" says which kind of result is wanted, not what it shows: against an icon it would match
  * every name, so "plus add icon" ranked arrows above PlusIcon. Other kinds keep the word —
@@ -21568,6 +21601,13 @@ const withoutIconStopWords = queryLower => queryLower.trim().split(/\s+/).filter
  */
 const isBuriedIcon = (entry, queryLower) => entry.type === 'icon' && entry.isDeprecated === true && entry.name.toLowerCase() !== withoutIconStopWords(queryLower);
 
+/**
+ * Whole-word match for prose: a substring would let "table" hit "editable", and such weak matches
+ * would keep the V1/V2 fallback from ever showing the real `Table`. `_` is a boundary because
+ * keywords carry constant names like `asset_types`. Both arguments are lower case.
+ */
+const includesWord = (textLower, word) => new RegExp(`(?<![a-z0-9])${word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![a-z0-9])`).test(textLower);
+
 /**
  * The best a keyword list can do for ONE query word. The single-word branch of `handleSearch` used
  * to SUM over every keyword, so the score measured how long a keyword list is — `corvaAPI`'s 369
@@ -21581,12 +21621,12 @@ const scoreKeywordMatch = (keywords, word, weights) => keywords.reduce((best, ke
 }, 0);
 
 /**
- * Split camelCase or PascalCase string into words
- * e.g., "CustomGradient" -> ["custom", "gradient"]
+ * The lower-case words of an entry name, for matching query words against. Acronym- and
+ * `_`-aware — `NPT` → `npt`, `ASSET_TYPES` → `asset`, `types` — where the extractors'
+ * `splitCamelCase` cuts at every capital and would leave such names no word to match. One-letter
+ * pieces are dropped: a query word is never that short.
  */
-const splitCamelCase = name => {
-  return name.replace(/([A-Z])/g, ' $1').toLowerCase().trim().split(/\s+/).filter(w => w.length > 0);
-};
+const nameWords = name => (name.match(/[A-Z]+(?![a-z])|[A-Z]?[a-z]+|\d+/g) ?? []).map(word => word.toLowerCase()).filter(word => word.length > 1);
 
 const scoreMultiWordQuery = (entry, queryWords, weights) => {
   let score = 0;
@@ -21605,7 +21645,7 @@ const scoreMultiWordQuery = (entry, queryWords, weights) => {
 
   // 2. All-words-in-name-parts matching
   let namePartsScore = 0;
-  const nameParts = splitCamelCase(entry.name).filter(part => part.length > 1);
+  const nameParts = nameWords(entry.name);
   const allWordsInName = queryWords.every(word => nameParts.some(part => part === word));
   if (allWordsInName) {
     namePartsScore = weights.contains;
@@ -21614,19 +21654,19 @@ const scoreMultiWordQuery = (entry, queryWords, weights) => {
   // Take max of collapsed and name-parts
   score += Math.max(collapsedNameScore, namePartsScore);
 
-  // 3. Per-word keyword scoring
+  // 3. Per-word scoring: the best keyword per word, never a sum — unless the word is a word of the
+  // name, which outweighs any keyword. Otherwise "map layers toggle" scores LayersIcon like every
+  // icon that only has "toggle" as a keyword, and file order decides.
   const descriptionLower = entry.description.toLowerCase();
-
-  // Behaviour-identical to the inline loop this replaced: the best keyword per word, never a sum.
-  score += queryWords.reduce((keywordScore, word) => keywordScore + scoreKeywordMatch(entry.keywords, word, weights), 0);
+  score += queryWords.reduce((wordScore, word) => wordScore + Math.max(nameParts.includes(word) ? weights.nameWord : 0, scoreKeywordMatch(entry.keywords, word, weights)), 0);
 
   // 4. All-words-in-description
-  if (queryWords.every(word => descriptionLower.includes(word))) {
+  if (queryWords.every(word => includesWord(descriptionLower, word))) {
     score += weights.description;
   }
 
   // 5. All-words-in-searchText
-  if (queryWords.every(word => entry.searchText.includes(word))) {
+  if (queryWords.every(word => includesWord(entry.searchText, word))) {
     score += weights.fullText;
   }
   return score;
@@ -21641,19 +21681,6 @@ const deprecationOrder = entry => entry.isDeprecated ? 1 : 0;
  * fell to generation order before, an accident of extractor discovery.
  */
 const compareScoredEntries = queryLower => (a, b) => Number(isBuriedIcon(a.entry, queryLower)) - Number(isBuriedIcon(b.entry, queryLower)) || b.score - a.score || deprecationOrder(a.entry) - deprecationOrder(b.entry);
-const parseQuery = queryLower => {
-  const rawWords = queryLower.trim().split(/\s+/);
-  const queryWords = rawWords.filter(w => w.length > 1);
-  const isMultiWord = rawWords.length >= 2 && queryWords.length >= 2;
-  // When the query has filler words around a single meaningful word (e.g. "a button"),
-  // the single-word path should match against just that word instead of the whole query.
-  const singleWordQuery = !isMultiWord && queryWords.length === 1 ? queryWords[0] : queryLower;
-  return {
-    queryWords,
-    isMultiWord,
-    singleWordQuery
-  };
-};
 const rankEntries = (entries, query) => {
   const {
     weights,
@@ -21690,10 +21717,10 @@ const rankEntries = (entries, query) => {
 
       // One word, one keyword payment — the same rule the multi-word branch applies per word.
       score += scoreKeywordMatch(entry.keywords, singleWordQuery, weights);
-      if (entry.description.toLowerCase().includes(singleWordQuery)) {
+      if (includesWord(entry.description.toLowerCase(), singleWordQuery)) {
         score += weights.description;
       }
-      if (entry.searchText.includes(singleWordQuery)) {
+      if (includesWord(entry.searchText, singleWordQuery)) {
         score += weights.fullText;
       }
     }
@@ -21748,12 +21775,12 @@ Examples:
 - "date picker" - find date/time components
 - "useSubscriptions" - find specific hook
 
-When category is 'v2' or 'v1' and the requested version has no match, the response surfaces a labeled fallback block from the other version so a single search still discovers a candidate. The agent should still prefer V2 when both versions match.`;
+When category is 'v2' or 'v1', type is 'all' or 'component', and no component of the requested version is named by the query (its name equals or starts with it), up to 5 matching components of the other version follow the results, labeled, so a single search still discovers a candidate. The agent should still prefer V2 when both versions match.`;
 const searchToolSchema = {
   query: z.string().describe('Search query - component name, use case, or description'),
   type: z.enum(SEARCH_TYPES).optional().describe('Filter by type (default: all)'),
   category: z.enum(['all', 'v2', 'v1']).optional().describe('For components: v2 (modern) or v1 (default: all)'),
-  limit: z.number().optional().describe('Maximum results to return (default: 10)')
+  limit: z.number().optional().describe('Maximum results to return (default: 10); a V1/V2 fallback adds up to 5 more')
 };
 const handleSearch = args => {
   const {
@@ -21784,7 +21811,10 @@ const handleSearch = args => {
   }
   const matchesRequested = entry => requestedCategory === null || entry.type !== COMPONENT_TYPE || entry.category === requestedCategory;
   const primary = ranked.filter(matchesRequested).slice(0, limit);
-  const fallback = requestedCategory && primary.length === 0 ? ranked.filter(entry => entry.type === COMPONENT_TYPE && entry.category !== requestedCategory).slice(0, limit) : [];
+  // Weak matches — a keyword, a word of prose, an icon — do not prove the requested version has the
+  // component, so they must not hide the other version's. Read before `limit` cuts the list.
+  const requestedHasName = ranked.some(entry => entry.type === COMPONENT_TYPE && entry.category === requestedCategory && hasNameMatch(entry.name, query));
+  const fallback = requestedCategory && (type === 'all' || type === COMPONENT_TYPE) && !requestedHasName ? ranked.filter(entry => entry.type === COMPONENT_TYPE && entry.category !== requestedCategory).slice(0, SEARCH_CONFIG.defaults.maxFallbackResults) : [];
   if (primary.length === 0 && fallback.length === 0) {
     return {
       response: createToolResponse(`No results found for ${echoedQuery}. Try:\n- A different search term\n- Using list_corva_ui to see available items`),
@@ -21801,20 +21831,24 @@ const handleSearch = args => {
     const fields = [notice, singleLine(r.description) || NO_DESCRIPTION, ...importLines(r)];
     return [`**${r.name}**${categoryLabel} - ${r.type}`, ...fields.filter(Boolean).map(field => `${INDENT}${field}`)].join('\n');
   };
-  if (primary.length > 0) {
-    const formatted = primary.map(formatEntry).join('\n\n');
+  const formatted = [...primary, ...fallback].map(formatEntry).join('\n\n');
+  const resultCount = primary.length + fallback.length;
+  if (fallback.length === 0) {
     return {
       response: createToolResponse(`Found ${primary.length} result(s) for ${echoedQuery}:\n\n${formatted}`),
-      resultCount: primary.length
+      resultCount
     };
   }
   const requestedVersion = requestedCategory.replace(COMPONENTS_CATEGORY_PREFIX, '').toUpperCase();
   const fallbackVersion = requestedVersion === 'V2' ? 'V1' : 'V2';
   const preferenceHint = requestedVersion === 'V2' ? ' V2 is preferred when available; consider these only if no V2 alternative exists.' : '';
-  const formatted = fallback.map(formatEntry).join('\n\n');
+  // The label lives in the preamble, not in a block of its own: the blank line separates results
+  // and nothing else, so a consumer can still count and split them. Each fallback block carries
+  // its version in its heading.
+  const preamble = primary.length === 0 ? `No ${requestedVersion} matches for ${echoedQuery}. ${fallbackVersion} fallback — ${fallbackVersion} components that match the query.` : `Found ${primary.length} result(s) for ${echoedQuery}, but no ${requestedVersion} component name equals or starts with it. The last ${fallback.length} result(s) are the ${fallbackVersion} fallback — ${fallbackVersion} components that match the query.`;
   return {
-    response: createToolResponse(`No ${requestedVersion} matches for ${echoedQuery}. ${fallbackVersion} fallback — ${fallbackVersion} components that match the query.${preferenceHint}\n\n${formatted}`),
-    resultCount: fallback.length
+    response: createToolResponse(`${preamble}${preferenceHint}\n\n${formatted}`),
+    resultCount
   };
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@corva/ui",
-  "version": "3.78.0-15",
+  "version": "3.78.0-16",
   "license": "UNLICENSED",
   "description": "Shared components/utils for Corva ui projects",
   "repository": {