@testgorilla/tgo-ui 8.12.0 → 8.13.0

package/mcp/server.mjs

@@ -21634,7 +21634,7 @@ function registerListStoriesWithDesignLinksTool(server, store) {
 function registerGetIconForFigmaNameTool(server, resolver) {
   server.tool(
     "get_icon_for_figma_name",
-    'Resolve a Figma icon name (as exported by Figma Dev Mode) to a Canopy `<ui-icon>` name + svg path. Returns null when no match is found at any level. The `match` field tells you how the resolution happened: "exact" (after case/punctuation normalization), "alias" (manual entry in mcp/icon-aliases.json), or "fuzzy" (substring match \u2014 verify visually before relying on it).',
+    'Resolve a Figma icon name (as exported by Figma Dev Mode, e.g. "Assessment/Timer") to a Canopy `<ui-icon>` name + svg path. The Figma "Category/" prefix is stripped automatically. Returns null when no match is found at any level. The `match` field tells you how the resolution happened: "mapped" (curated entry in mcp/icon-figma-map.json), "exact" (after prefix/case/punctuation normalization), "alias" (generic synonym in the same file), or "fuzzy" (substring match). The `confident` boolean is true for exact/alias and false for fuzzy \u2014 treat a non-confident result as "needs a human mapping decision" and verify visually before relying on it.',
     {
       figmaIconName: external_exports.string().describe('Icon name from Figma (e.g., "checkmark", "Arrow-down", "Eye Open"). Case- and punctuation-insensitive.')
     },
@@ -21647,6 +21647,41 @@ function registerGetIconForFigmaNameTool(server, resolver) {
   );
 }
 
+// src/icons/icon-report.ts
+function buildIconNameReport(resolver, names) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = names.filter((n) => {
+    const key = n.trim().toLowerCase();
+    if (!key || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  const verdicts = unique.map((n) => resolver.classify(n));
+  return {
+    total: verdicts.length,
+    confident: verdicts.filter((v) => v.status === "confident").length,
+    knownGaps: verdicts.filter((v) => v.status === "known-gap").length,
+    review: verdicts.filter((v) => v.status === "review")
+  };
+}
+
+// src/tools/check-icon-names.ts
+function registerCheckIconNamesTool(server, resolver) {
+  server.tool(
+    "check_icon_names",
+    'Batch-audit icon names and return only the ones that need a human mapping decision. Input is a list of names \u2014 Figma export names (e.g. "Assessment/Timer") and/or free-form / natural-language icon words (e.g. "trash", "gear"). The response has counts for `confident` (safe to use) and `knownGaps` (intentionally no code icon \u2014 already decided), plus a `review` array of the actionable names: low-confidence fuzzy guesses and outright misses, each with a `reason`. Use this to flag unresolved icons for review rather than rendering a wrong guess. To resolve a single name to a concrete `<ui-icon>`, use get_icon_for_figma_name instead.',
+    {
+      names: external_exports.array(external_exports.string()).describe("Icon names to check (Figma export names and/or natural-language icon words).")
+    },
+    async ({ names }) => {
+      const report = buildIconNameReport(resolver, names);
+      return {
+        content: [{ type: "text", text: JSON.stringify(report, null, 2) }]
+      };
+    }
+  );
+}
+
 // src/tools/get-design-tokens.ts
 function handleGetDesignTokens(tokens, params) {
   if (!params.category) return tokens;
@@ -21708,41 +21743,113 @@ var IconResolver = class {
   byNormalized = /* @__PURE__ */ new Map();
   aliasMap;
   unmapped;
+  figmaMap;
   icons;
-  constructor(icons, aliases = {}, unmapped = []) {
+  constructor(icons, aliases = {}, unmapped = [], figmaMap = {}) {
     this.icons = icons;
     for (const icon of icons) {
       this.byNormalized.set(normalize(icon.name), icon);
     }
+    for (const icon of icons) {
+      const base = normalize(stripVariantSuffix(icon.name));
+      if (!this.byNormalized.has(base)) {
+        this.byNormalized.set(base, icon);
+      }
+    }
     this.aliasMap = /* @__PURE__ */ new Map();
     for (const [from, to] of Object.entries(aliases)) {
       this.aliasMap.set(normalize(from), to);
     }
     this.unmapped = new Set(unmapped.map(normalize));
+    this.figmaMap = /* @__PURE__ */ new Map();
+    for (const [figmaName, entry] of Object.entries(figmaMap)) {
+      this.figmaMap.set(normalize(figmaName), entry);
+    }
   }
   resolve(figmaName) {
-    const normalized = normalize(figmaName);
+    const curated = this.figmaMap.get(normalize(figmaName));
+    if (curated) {
+      if (curated.status === "mapped" && curated.canopy) {
+        const target = this.byNormalized.get(normalize(curated.canopy));
+        if (target) {
+          return { canopyIconName: target.name, svgPath: target.svgPath, match: "mapped", confident: true };
+        }
+      }
+      return null;
+    }
+    const normalized = normalize(stripCategoryPrefix(figmaName));
     if (!normalized) return null;
     const exact = this.byNormalized.get(normalized);
     if (exact) {
-      return { canopyIconName: exact.name, svgPath: exact.svgPath, match: "exact" };
+      return { canopyIconName: exact.name, svgPath: exact.svgPath, match: "exact", confident: true };
     }
     const aliasTarget = this.aliasMap.get(normalized);
     if (aliasTarget) {
       const target = this.byNormalized.get(normalize(aliasTarget));
       if (target) {
-        return { canopyIconName: target.name, svgPath: target.svgPath, match: "alias" };
+        return { canopyIconName: target.name, svgPath: target.svgPath, match: "alias", confident: true };
       }
     }
     if (this.unmapped.has(normalized)) return null;
     if (normalized.length >= MIN_FUZZY_QUERY_LENGTH) {
       const best = this.bestFuzzyMatch(normalized);
       if (best) {
-        return { canopyIconName: best.name, svgPath: best.svgPath, match: "fuzzy" };
+        return { canopyIconName: best.name, svgPath: best.svgPath, match: "fuzzy", confident: false };
       }
     }
     return null;
   }
+  /**
+   * Classify a name for Layer-1 reporting: is it safe to use, does it need a
+   * human mapping decision, or is it an already-decided gap? Used by
+   * `check_icon_names` to surface only the names worth a human's attention —
+   * works for Figma export names AND free-form / natural-language icon words.
+   */
+  classify(figmaName) {
+    const curated = this.figmaMap.get(normalize(figmaName));
+    if (curated) {
+      if (curated.status === "mapped" && curated.canopy) {
+        const target = this.byNormalized.get(normalize(curated.canopy));
+        if (target) {
+          return {
+            name: figmaName,
+            status: "confident",
+            match: "mapped",
+            canopyIconName: target.name,
+            svgPath: target.svgPath,
+            reason: "curated map"
+          };
+        }
+      }
+      const reason = curated.status === "figma-only" ? "Figma-only by design (no code icon)" : curated.status === "add-to-canopy" ? "not built in Canopy yet" : "curated entry has no resolvable target";
+      return { name: figmaName, status: "known-gap", canopyIconName: null, svgPath: null, reason };
+    }
+    const r = this.resolve(figmaName);
+    if (r && r.confident) {
+      return {
+        name: figmaName,
+        status: "confident",
+        match: r.match,
+        canopyIconName: r.canopyIconName,
+        svgPath: r.svgPath,
+        reason: r.match
+      };
+    }
+    if (r && r.match === "fuzzy") {
+      return {
+        name: figmaName,
+        status: "review",
+        match: "fuzzy",
+        canopyIconName: r.canopyIconName,
+        svgPath: r.svgPath,
+        reason: `low-confidence guess (${r.canopyIconName}) \u2014 verify or add a mapping`
+      };
+    }
+    if (this.unmapped.has(normalize(stripCategoryPrefix(figmaName)))) {
+      return { name: figmaName, status: "known-gap", canopyIconName: null, svgPath: null, reason: "no Canopy equivalent (unmapped)" };
+    }
+    return { name: figmaName, status: "review", canopyIconName: null, svgPath: null, reason: "no match found \u2014 needs a mapping or a new icon" };
+  }
   /**
    * Pick the best fuzzy candidate rather than the first one in iteration order.
    * Among icons whose normalized name contains (or is contained by) the query,
@@ -21773,6 +21880,13 @@ function compareFuzzyRank(a, b) {
 function stripSvgExtension(name) {
   return name.toLowerCase().endsWith(".svg") ? name.slice(0, -".svg".length) : name;
 }
+function stripCategoryPrefix(name) {
+  const slash = name.lastIndexOf("/");
+  return slash >= 0 ? name.slice(slash + 1) : name;
+}
+function stripVariantSuffix(name) {
+  return name.replace(/-(filled|in-line)$/i, "");
+}
 function normalize(name) {
   return stripSvgExtension(name).toLowerCase().replace(/[^a-z0-9]/g, "");
 }
@@ -21796,6 +21910,12 @@ var CatalogSchema = external_exports.object({
   icons: external_exports.array(external_exports.object({ name: external_exports.string(), svgPath: external_exports.string() })).optional().default([]),
   iconAliases: external_exports.record(external_exports.string()).optional().default({}),
   iconUnmapped: external_exports.array(external_exports.string()).optional().default([]),
+  iconFigmaMap: external_exports.record(external_exports.object({
+    canopy: external_exports.string().nullable(),
+    node: external_exports.string().optional(),
+    status: external_exports.enum(["mapped", "figma-only", "add-to-canopy"]),
+    note: external_exports.string().optional()
+  })).optional().default({}),
   tokens: external_exports.array(external_exports.object({ name: external_exports.string(), value: external_exports.string(), category: external_exports.string() })).optional().default([]),
   // Foundations additions (Phase G.1.d). Same default-to-empty pattern.
   typography: external_exports.array(external_exports.object({
@@ -21830,8 +21950,9 @@ function createStaticMcpServer(catalog) {
   registerGetComponentTypesTool(server, store);
   registerGetQueryGuideTool(server, store);
   registerListStoriesWithDesignLinksTool(server, store);
-  const iconResolver = new IconResolver(catalog.icons ?? [], catalog.iconAliases ?? {}, catalog.iconUnmapped ?? []);
+  const iconResolver = new IconResolver(catalog.icons ?? [], catalog.iconAliases ?? {}, catalog.iconUnmapped ?? [], catalog.iconFigmaMap ?? {});
   registerGetIconForFigmaNameTool(server, iconResolver);
+  registerCheckIconNamesTool(server, iconResolver);
   registerGetDesignTokensTool(server, catalog.tokens ?? []);
   registerListTypographyClassesTool(server, catalog.typography ?? []);
   registerListColorPalettesTool(server, catalog.colorPalettes ?? []);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testgorilla/tgo-ui",
-  "version": "8.12.0",
+  "version": "8.13.0",
   "license": "proprietary-license",
   "lint-staged": {
     "{projects,components}/**/*.ts": [