@supericons/mcp 0.4.6

package/runtime/icon-taxonomy-seed.js

@@ -0,0 +1,461 @@
+export const JOB_LIBRARY_PREFIX = 'job:';
+
+export const JOB_CATEGORY_DEFINITIONS = [
+  {
+    id: 'ai-agent-workflows',
+    label: 'AI & Automation',
+    description: 'Curated icons for models, prompts, orchestration, retrieval, and agent runtime surfaces.',
+    sidebarGlyph: 'smart_toy',
+  },
+  {
+    id: 'navigation-wayfinding',
+    label: 'Navigation & Wayfinding',
+    description: 'Core app-shell icons for menus, routing, layout, movement, and dashboard wayfinding.',
+    sidebarGlyph: 'dashboard',
+  },
+  {
+    id: 'actions-controls',
+    label: 'Actions & Controls',
+    description: 'Common commands for creating, editing, deleting, uploading, downloading, sorting, and changing settings.',
+    sidebarGlyph: 'touch_app',
+  },
+  {
+    id: 'status-feedback',
+    label: 'Status & Feedback',
+    description: 'Signals for success, warning, progress, trust, notifications, and user feedback states.',
+    sidebarGlyph: 'task_alt',
+  },
+  {
+    id: 'people-accounts',
+    label: 'People & Accounts',
+    description: 'Users, profiles, teams, contacts, identity, roles, and account surfaces.',
+    sidebarGlyph: 'person',
+  },
+  {
+    id: 'communication',
+    label: 'Communication',
+    description: 'Messages, mail, chat, comments, calls, announcements, and language tools.',
+    sidebarGlyph: 'chat',
+  },
+  {
+    id: 'files-content',
+    label: 'Files & Content',
+    description: 'Files, folders, documents, images, attachments, archives, and clipboard flows.',
+    sidebarGlyph: 'folder',
+  },
+  {
+    id: 'data-analytics',
+    label: 'Data & Analytics',
+    description: 'Databases, tables, charts, metrics, reports, dashboards, and trend analysis.',
+    sidebarGlyph: 'bar_chart',
+  },
+  {
+    id: 'commerce-finance',
+    label: 'Commerce & Finance',
+    description: 'Shopping, checkout, billing, payments, receipts, invoices, wallets, and currencies.',
+    sidebarGlyph: 'credit_card',
+  },
+  {
+    id: 'security-access',
+    label: 'Security & Access',
+    description: 'Locks, keys, shields, verification, privacy, scanning, identity checks, and blocked states.',
+    sidebarGlyph: 'shield',
+  },
+  {
+    id: 'media-playback',
+    label: 'Media & Playback',
+    description: 'Audio, video, camera, gallery, image, music, volume, and playback controls.',
+    sidebarGlyph: 'play_circle',
+  },
+  {
+    id: 'devices-hardware',
+    label: 'Devices & Hardware',
+    description: 'Phones, computers, screens, printers, chips, servers, batteries, plugs, and hardware.',
+    sidebarGlyph: 'devices',
+  },
+  {
+    id: 'code-development',
+    label: 'Code & Development',
+    description: 'Code, terminals, APIs, packages, branches, bugs, deployment, and developer tooling.',
+    sidebarGlyph: 'code',
+  },
+  {
+    id: 'design-editing',
+    label: 'Design & Editing',
+    description: 'Color, drawing, typography, crop, align, layers, swatches, and creative editing tools.',
+    sidebarGlyph: 'palette',
+  },
+  {
+    id: 'maps-places-travel',
+    label: 'Maps, Places & Travel',
+    description: 'Maps, pins, location, routes, compass, buildings, transport, and global places.',
+    sidebarGlyph: 'map',
+  },
+  {
+    id: 'time-calendar',
+    label: 'Time & Calendar',
+    description: 'Clocks, calendars, schedules, timers, history, reminders, and alarms.',
+    sidebarGlyph: 'calendar_month',
+  },
+  {
+    id: 'brands-social',
+    label: 'Brands & Social',
+    description: 'Company marks, product logos, social networks, and platform icons.',
+    sidebarGlyph: 'hub',
+  },
+  {
+    id: 'nature-weather-lifestyle',
+    label: 'Nature, Weather & Lifestyle',
+    description: 'Weather, nature, food, health, sport, lifestyle, and everyday world objects.',
+    sidebarGlyph: 'wb_sunny',
+  },
+];
+
+const NAVIGATION_ICON_IDS = [
+  'material:menu',
+  'material:close',
+  'material:arrow_back',
+  'material:arrow_forward',
+  'material:chevron_left',
+  'material:chevron_right',
+  'material:expand_more',
+  'material:expand_less',
+  'material:home',
+  'material:search',
+  'material:settings',
+  'material:more_vert',
+  'material:more_horiz',
+  'material:apps',
+  'material:fullscreen',
+  'material:filter_list',
+  'material:sort',
+  'material:refresh',
+  'material:tab',
+  'material:drag_indicator',
+  'material:arrow_upward',
+  'material:arrow_downward',
+  'material:swap_vert',
+  'material:swap_horiz',
+  'material:undo',
+  'material:redo',
+  'material:menu_open',
+  'material:segment',
+  'material:density_medium',
+  'material:view_sidebar',
+  'material:dock_to_right',
+  'material:dock_to_left',
+  'material:grid_view',
+  'material:view_list',
+  'material:view_module',
+  'material:dashboard',
+  'material:splitscreen',
+  'material:picture_in_picture_alt',
+  'material:open_in_new',
+  'material:open_in_full',
+  'material:zoom_in',
+  'material:zoom_out',
+  'material:first_page',
+  'material:last_page',
+  'material:unfold_more',
+  'material:unfold_less',
+  'material:fullscreen_exit',
+  'material:double_arrow',
+  'material:subdirectory_arrow_right',
+  'material:launch',
+];
+
+const STATUS_ICON_IDS = [
+  'tabler:circle-check',
+  'tabler:circle-x',
+  'tabler:alert-triangle',
+  'tabler:info-circle',
+  'tabler:help-circle',
+  'tabler:ban',
+  'tabler:clock',
+  'tabler:hourglass',
+  'tabler:loader-2',
+  'tabler:refresh',
+  'tabler:progress-check',
+  'tabler:bell',
+  'tabler:eye',
+  'tabler:eye-off',
+  'tabler:thumb-up',
+  'tabler:thumb-down',
+  'tabler:star',
+  'tabler:shield-check',
+  'tabler:trophy',
+  'tabler:sparkles',
+  'tabler:power',
+  'tabler:toggle-right',
+  'tabler:bookmark',
+  'tabler:pinned',
+  'tabler:flag',
+  'tabler:archive',
+  'tabler:trash',
+  'tabler:send',
+  'tabler:cloud-check',
+  'tabler:wifi',
+  'tabler:bolt',
+  'tabler:flame',
+  'tabler:link',
+  'tabler:lock',
+  'tabler:lock-open',
+  'tabler:key',
+  'tabler:mail-check',
+  'tabler:message-check',
+  'tabler:list-check',
+  'tabler:filter',
+  'tabler:sort-ascending',
+  'tabler:trending-up',
+  'tabler:trending-down',
+  'tabler:mood-smile',
+  'tabler:mood-sad',
+  'tabler:circle-dot',
+  'tabler:clipboard-check',
+  'tabler:rosette-discount-check',
+  'tabler:heart',
+  'tabler:alert-circle',
+];
+
+const AI_AGENT_ICON_IDS = [
+  'material:smart_toy',
+  'material:robot',
+  'material:psychology',
+  'material:psychology_alt',
+  'material:memory',
+  'material:memory_alt',
+  'material:database',
+  'material:database_search',
+  'material:webhook',
+  'material:workflow',
+  'material:prompt_suggestion',
+  'material:model_training',
+  'material:network_intelligence',
+  'material:network_intelligence_history',
+  'material:network_intelligence_update',
+  'material:hub',
+  'material:schema',
+  'material:data_object',
+  'material:account_tree',
+  'material:auto_awesome',
+  'material:generating_tokens',
+  'material:token',
+  'material:dataset',
+  'material:dataset_linked',
+  'material:terminal',
+  'lucide:brain-circuit',
+  'lucide:brain-cog',
+  'lucide:brain',
+  'lucide:bot-message-square',
+  'lucide:messages-square',
+  'lucide:message-square-code',
+  'lucide:message-circle-code',
+  'lucide:scan-search',
+  'lucide:scan-eye',
+  'lucide:search-code',
+  'lucide:file-search',
+  'lucide:folder-search',
+  'lucide:workflow',
+  'lucide:circuit-board',
+  'lucide:waypoints',
+  'lucide:layers-3',
+  'lucide:blocks',
+  'lucide:binary',
+  'lucide:code-xml',
+  'lucide:database-zap',
+  'lucide:server-cog',
+  'lucide:network',
+  'lucide:router',
+  'lucide:plug-zap',
+  'lucide:wand-sparkles',
+];
+
+function sourceLibraryFromIconId(iconId) {
+  return String(iconId).split(':')[0];
+}
+
+function buildEntries(jobCategory, iconIds, secondaryCategories) {
+  return iconIds.map((iconId, index) => ({
+    iconId,
+    sourceLibrary: sourceLibraryFromIconId(iconId),
+    jobCategory,
+    secondaryCategories: [...secondaryCategories],
+    rank: index + 1,
+  }));
+}
+
+export const JOB_ICON_TAXONOMY_SEED = [
+  ...buildEntries('ai-agent-workflows', AI_AGENT_ICON_IDS, ['ai', 'agents', 'automation']),
+  ...buildEntries('navigation-wayfinding', NAVIGATION_ICON_IDS, ['navigation', 'wayfinding', 'layout']),
+  ...buildEntries('status-feedback', STATUS_ICON_IDS, ['status', 'feedback', 'signals']),
+];
+
+function normalizeIconText(value) {
+  return String(value || '')
+    .toLowerCase()
+    .replace(/[_:]+/g, ' ')
+    .replace(/[^a-z0-9\s-]/g, ' ')
+    .replace(/-/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function iconText(icon = {}) {
+  return normalizeIconText([
+    icon.lib,
+    icon.id,
+    icon.name,
+    icon.style,
+    icon.type,
+  ].filter(Boolean).join(' '));
+}
+
+const PURPOSE_INFERENCE_RULES = [
+  {
+    jobCategory: 'brands-social',
+    sourceLibraries: ['simpleicons'],
+    secondaryCategories: ['brands', 'logos', 'social'],
+  },
+  {
+    jobCategory: 'ai-agent-workflows',
+    patterns: [/\b(ai|bot|robot|brain|model|prompt|token|memory|dataset|workflow|webhook|neural|automation)\b/],
+    secondaryCategories: ['ai', 'automation', 'agents'],
+  },
+  {
+    jobCategory: 'navigation-wayfinding',
+    patterns: [/\b(home|menu|arrow|chevron|sidebar|dashboard|grid|layout|route|compass|navigate|waypoint|tab|fullscreen|search|filter|sort)\b/],
+    secondaryCategories: ['navigation', 'layout', 'wayfinding'],
+  },
+  {
+    jobCategory: 'actions-controls',
+    patterns: [/\b(add|plus|edit|pencil|delete|trash|remove|upload|download|refresh|reload|sync|settings|cog|sliders|play|pause|stop|undo|redo|copy|save|share|send)\b/],
+    secondaryCategories: ['actions', 'controls', 'commands'],
+  },
+  {
+    jobCategory: 'status-feedback',
+    patterns: [/\b(check|success|alert|warning|error|info|loader|loading|progress|bell|notification|star|heart|favorite|thumb|badge|flag|pin|power|toggle)\b/],
+    secondaryCategories: ['status', 'feedback', 'signals'],
+  },
+  {
+    jobCategory: 'people-accounts',
+    patterns: [/\b(user|users|person|people|profile|account|avatar|contact|team|group|id|identity|face|smile|frown)\b/],
+    secondaryCategories: ['people', 'accounts', 'identity'],
+  },
+  {
+    jobCategory: 'communication',
+    patterns: [/\b(message|messages|mail|email|chat|comment|phone|call|mic|microphone|megaphone|announcement|language|translate|inbox)\b/],
+    secondaryCategories: ['communication', 'messages', 'calls'],
+  },
+  {
+    jobCategory: 'files-content',
+    patterns: [/\b(file|folder|document|clipboard|archive|paperclip|attachment|image|photo|text|book|newspaper|note|receipt|pdf)\b/],
+    secondaryCategories: ['files', 'content', 'documents'],
+  },
+  {
+    jobCategory: 'data-analytics',
+    patterns: [/\b(database|table|chart|graph|analytics|metric|report|trend|activity|gauge|pie|area|server|stack)\b/],
+    secondaryCategories: ['data', 'analytics', 'reports'],
+  },
+  {
+    jobCategory: 'commerce-finance',
+    patterns: [/\b(cart|shop|store|bag|basket|payment|credit|card|receipt|invoice|wallet|cash|money|bank|currency|dollar|euro|yen|pound|rupee|discount|tag|ticket)\b/],
+    secondaryCategories: ['commerce', 'finance', 'billing'],
+  },
+  {
+    jobCategory: 'security-access',
+    patterns: [/\b(lock|unlock|key|shield|security|privacy|fingerprint|scan|verified|ban|blocked|access|safe|danger|virus|bug)\b/],
+    secondaryCategories: ['security', 'access', 'trust'],
+  },
+  {
+    jobCategory: 'media-playback',
+    patterns: [/\b(play|pause|video|audio|camera|image|photo|gallery|music|volume|speaker|film|tv|radio|podcast|headphone)\b/],
+    secondaryCategories: ['media', 'playback', 'audio-video'],
+  },
+  {
+    jobCategory: 'devices-hardware',
+    patterns: [/\b(phone|mobile|desktop|laptop|monitor|tablet|printer|cpu|chip|server|battery|plug|wifi|bluetooth|keyboard|mouse|device|hardware|watch)\b/],
+    secondaryCategories: ['devices', 'hardware', 'technology'],
+  },
+  {
+    jobCategory: 'code-development',
+    patterns: [/\b(code|terminal|api|package|branch|git|github|webhook|deploy|deployment|bug|server|database|binary|braces|command|script|xml|json)\b/],
+    secondaryCategories: ['code', 'development', 'engineering'],
+  },
+  {
+    jobCategory: 'design-editing',
+    patterns: [/\b(palette|brush|pen|pencil|crop|align|typography|type|layer|layers|swatch|color|wand|sparkles|ruler|scissors|paint)\b/],
+    secondaryCategories: ['design', 'editing', 'creative'],
+  },
+  {
+    jobCategory: 'maps-places-travel',
+    patterns: [/\b(map|pin|location|compass|route|building|office|home|store|truck|car|plane|train|bus|globe|earth|world|flag)\b/],
+    secondaryCategories: ['maps', 'places', 'travel'],
+  },
+  {
+    jobCategory: 'time-calendar',
+    patterns: [/\b(clock|calendar|date|time|timer|history|alarm|schedule|hourglass|watch)\b/],
+    secondaryCategories: ['time', 'calendar', 'schedule'],
+  },
+  {
+    jobCategory: 'nature-weather-lifestyle',
+    patterns: [/\b(sun|moon|cloud|rain|snow|snowflake|leaf|tree|flower|food|coffee|heart|health|sport|game|shirt|home|gift|cake|smile|thermometer)\b/],
+    secondaryCategories: ['nature', 'weather', 'lifestyle'],
+  },
+];
+
+function inferTaxonomyEntry(icon, index = 0) {
+  const text = iconText(icon);
+  if (!text) return null;
+
+  for (const rule of PURPOSE_INFERENCE_RULES) {
+    if (rule.sourceLibraries?.includes(icon.lib)) {
+      return {
+        iconId: `${icon.lib}:${icon.id}`,
+        sourceLibrary: icon.lib,
+        jobCategory: rule.jobCategory,
+        secondaryCategories: [...(rule.secondaryCategories || [])],
+        rank: 5000 + index,
+      };
+    }
+
+    if ((rule.patterns || []).some((pattern) => pattern.test(text))) {
+      return {
+        iconId: `${icon.lib}:${icon.id}`,
+        sourceLibrary: icon.lib,
+        jobCategory: rule.jobCategory,
+        secondaryCategories: [...(rule.secondaryCategories || [])],
+        rank: 5000 + index,
+      };
+    }
+  }
+
+  return null;
+}
+
+export function buildJobLibraryId(jobCategoryId) {
+  return `${JOB_LIBRARY_PREFIX}${jobCategoryId}`;
+}
+
+export function parseJobLibraryId(value) {
+  if (typeof value !== 'string' || !value.startsWith(JOB_LIBRARY_PREFIX)) {
+    return null;
+  }
+  return value.slice(JOB_LIBRARY_PREFIX.length);
+}
+
+export function createIconTaxonomyMap(icons = []) {
+  const map = new Map(JOB_ICON_TAXONOMY_SEED.map((entry) => [entry.iconId, entry]));
+
+  for (const [index, icon] of icons.entries()) {
+    const iconId = `${icon.lib}:${icon.id}`;
+    if (map.has(iconId)) continue;
+    const inferred = inferTaxonomyEntry(icon, index);
+    if (inferred) map.set(iconId, inferred);
+  }
+
+  return map;
+}
+
+export function createJobCategoryMap() {
+  return new Map(JOB_CATEGORY_DEFINITIONS.map((category) => [category.id, category]));
+}

package/runtime/public-metadata-sanitizer.js

@@ -0,0 +1,171 @@
+const STRIP_COMMENT_PATTERNS = [
+  /\bgenerated by\b/i,
+  /\busing\b/i,
+  /\bsource:\b/i,
+  /\bbuilt with\b/i,
+  /\bcurated from\b/i,
+  /\bdesign rule\b/i,
+  /\bmotion vocabulary\b/i,
+  /\bsocratic design\b/i,
+  /\bsocratic method\b/i,
+  /\banimation story\b/i,
+  /\bconcept:\s*/i,
+  /\bstory:\s*/i,
+  /\bevery keyframe is purpose-built\b/i,
+  /\bwhat real-world thing\?.*\bsame at rest\?/i,
+  /\bvisioncortex\b/i,
+  /\bvtracer\b/i,
+  /\bvectorizer\b/i,
+  /\bgoogle fonts cdn\b/i,
+];
+
+const STRIP_BLOCK_START_PATTERNS = [
+  /\bgenerated by\b/i,
+  /\busing\b/i,
+  /\bsource:\b/i,
+  /\bbuilt with\b/i,
+  /\bcurated from\b/i,
+  /\bdesign rule\b/i,
+  /\bmotion vocabulary\b/i,
+  /\bsocratic design\b/i,
+  /\bsocratic method\b/i,
+  /\banimation story\b/i,
+  /\bconcept:\s*/i,
+  /\bstory:\s*/i,
+  /\bwhat real-world thing\?.*\bsame at rest\?/i,
+];
+
+const PRESERVE_COMMENT_PATTERNS = [
+  /^\s*supericons motion lab\s*$/i,
+];
+
+function normalizeCommentText(commentText) {
+  return String(commentText || '').replace(/\s+/g, ' ').trim();
+}
+
+function shouldStripCommentLine(lineText, context = {}) {
+  const normalized = normalizeCommentText(lineText);
+  if (!normalized) return false;
+
+  if (context.preserveBranding !== false) {
+    if (PRESERVE_COMMENT_PATTERNS.some((pattern) => pattern.test(normalized))) {
+      return false;
+    }
+  }
+
+  return STRIP_COMMENT_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+
+function normalizeSanitizedText(text) {
+  return String(text || '')
+    .replace(/(?:\r?\n){3,}/g, '\n\n')
+    .trimStart();
+}
+
+function isSeparatorLikeLine(lineText) {
+  const normalized = normalizeCommentText(lineText);
+  if (!normalized) return false;
+  return !/[A-Za-z0-9]/.test(normalized);
+}
+
+function looksLikeIconCommentTitle(lineText) {
+  const normalized = normalizeCommentText(lineText);
+  if (!normalized) return false;
+  return /(?:^|\s)(?:\d+\.\s*)?[A-Z0-9][A-Z0-9\s\-&/]+(?:\s|$)/.test(normalized);
+}
+
+export function shouldStripExportMetadataComment(commentText, context = {}) {
+  const normalized = normalizeCommentText(commentText);
+  if (!normalized) return false;
+
+  if (context.preserveBranding !== false) {
+    if (PRESERVE_COMMENT_PATTERNS.some((pattern) => pattern.test(normalized))) {
+      return false;
+    }
+  }
+
+  return shouldStripCommentLine(normalized, context);
+}
+
+export function stripXmlComments(text, context = {}) {
+  if (!text) return text;
+  const stripped = String(text).replace(/<!--([\s\S]*?)-->/g, (fullMatch, innerText) => (
+    shouldStripExportMetadataComment(innerText, context) ? '' : fullMatch
+  ));
+  return normalizeSanitizedText(stripped);
+}
+
+function sanitizeCssCommentBody(commentText, context = {}) {
+  const lines = String(commentText || '').split(/\r?\n/);
+  const keptLines = [];
+  let strippingContinuation = false;
+
+  for (const line of lines) {
+    const normalized = normalizeCommentText(line);
+
+    if (strippingContinuation) {
+      if (isSeparatorLikeLine(line)) {
+        strippingContinuation = false;
+        keptLines.push(line);
+      }
+      continue;
+    }
+
+    if (shouldStripCommentLine(line, context)) {
+      strippingContinuation = STRIP_BLOCK_START_PATTERNS.some((pattern) => pattern.test(normalized));
+      continue;
+    }
+
+    keptLines.push(line);
+  }
+
+  const trimmedKeptLines = keptLines.filter((line, index) => {
+    const normalized = normalizeCommentText(line);
+    if (!normalized || normalized.includes(':')) return true;
+
+    const previousLine = keptLines.slice(0, index).reverse().find((value) => normalizeCommentText(value));
+    const nextLine = keptLines.slice(index + 1).find((value) => normalizeCommentText(value));
+
+    if (!previousLine || !nextLine) return true;
+    if (!looksLikeIconCommentTitle(previousLine)) return true;
+    if (!isSeparatorLikeLine(nextLine)) return true;
+
+    return false;
+  });
+
+  if (!trimmedKeptLines.some((line) => normalizeCommentText(line))) {
+    return '';
+  }
+
+  return trimmedKeptLines.join('\n');
+}
+
+export function stripCssComments(text, context = {}) {
+  if (!text) return text;
+  const stripped = String(text).replace(/\/\*([\s\S]*?)\*\//g, (fullMatch, innerText) => {
+    const sanitizedBody = sanitizeCssCommentBody(innerText, context);
+    if (sanitizedBody === innerText) {
+      return fullMatch;
+    }
+
+    if (!sanitizedBody) return '';
+
+    return `/*${sanitizedBody}*/`;
+  });
+  return normalizeSanitizedText(stripped);
+}
+
+export function sanitizeSvgExportMarkup(svgText, context = {}) {
+  if (!svgText) return svgText;
+
+  let sanitized = stripXmlComments(svgText, context);
+  sanitized = sanitized.replace(/<style([^>]*)>([\s\S]*?)<\/style>/gi, (fullMatch, attrs, cssText) => {
+    const cleanCss = stripCssComments(cssText, context);
+    return `<style${attrs}>${cleanCss}</style>`;
+  });
+  return sanitized;
+}
+
+export function sanitizeCssCommentMetadata(cssText, context = {}) {
+  return stripCssComments(cssText, context);
+}