@sarjallab09/figma-intelligence 1.0.1 → 1.2.0

package/figma-intelligence-layer/src/shared/design-system-intelligence.ts

@@ -1,131 +0,0 @@
-import {
-  componentNameVariants,
-  inferNamingRules,
-  NamingRule,
-  normalizeName,
-} from "./design-system-normalizers";
-
-export interface DSComponentSetLike {
-  id: string;
-  name: string;
-  normalizedName: string;
-  childComponentIds: string[];
-  intents: string[];
-}
-
-export interface DSComponentLike {
-  id: string;
-  name: string;
-  normalizedName: string;
-  setId?: string;
-  intents: string[];
-}
-
-export interface DSTokenLike {
-  id: string;
-  name: string;
-  semanticGroup?: string;
-}
-
-export interface DSStyleLike {
-  id: string;
-  name: string;
-}
-
-export interface DSInstanceLike {
-  id: string;
-  mainComponentId: string;
-}
-
-export interface DSVariantSchemaLike {
-  properties: Record<string, string[]>;
-  required?: string[];
-}
-
-export interface DesignSystemIntelligence {
-  aliases: Record<string, string[]>;
-  variantSchemas: Record<string, DSVariantSchemaLike>;
-  semanticTokenGroups: Record<string, string[]>;
-  preferredComponentsByIntent: Record<string, string[]>;
-  namingRules: NamingRule[];
-}
-
-export function buildDesignSystemIntelligence(args: {
-  componentSets: DSComponentSetLike[];
-  components: DSComponentLike[];
-  tokens: DSTokenLike[];
-  styles: DSStyleLike[];
-  instances: DSInstanceLike[];
-  variantSchemas: Record<string, DSVariantSchemaLike>;
-}): DesignSystemIntelligence {
-  const aliases: Record<string, string[]> = {};
-  const semanticTokenGroups: Record<string, string[]> = {};
-  const preferredComponentsByIntent: Record<string, string[]> = {};
-  const instanceCounts = new Map<string, number>();
-
-  for (const instance of args.instances) {
-    instanceCounts.set(
-      instance.mainComponentId,
-      (instanceCounts.get(instance.mainComponentId) ?? 0) + 1
-    );
-  }
-
-  for (const componentSet of args.componentSets) {
-    aliases[componentSet.id] = componentNameVariants(componentSet.name);
-  }
-
-  for (const token of args.tokens) {
-    if (!token.semanticGroup) continue;
-    if (!semanticTokenGroups[token.semanticGroup]) {
-      semanticTokenGroups[token.semanticGroup] = [];
-    }
-    semanticTokenGroups[token.semanticGroup].push(token.id);
-  }
-
-  const setUsageScores = new Map<string, number>();
-  for (const component of args.components) {
-    const usage = instanceCounts.get(component.id) ?? 0;
-    if (component.setId) {
-      setUsageScores.set(component.setId, (setUsageScores.get(component.setId) ?? 0) + usage);
-    }
-  }
-
-  for (const componentSet of args.componentSets) {
-    const candidateIntents = componentSet.intents.length > 0 ? componentSet.intents : ["component"];
-    for (const intent of candidateIntents) {
-      if (!preferredComponentsByIntent[intent]) {
-        preferredComponentsByIntent[intent] = [];
-      }
-      preferredComponentsByIntent[intent].push(componentSet.id);
-    }
-  }
-
-  for (const intent of Object.keys(preferredComponentsByIntent)) {
-    preferredComponentsByIntent[intent].sort((leftId, rightId) => {
-      const leftSet = args.componentSets.find((set) => set.id === leftId);
-      const rightSet = args.componentSets.find((set) => set.id === rightId);
-      const leftScore = setUsageScores.get(leftId) ?? 0;
-      const rightScore = setUsageScores.get(rightId) ?? 0;
-
-      if (leftScore !== rightScore) {
-        return rightScore - leftScore;
-      }
-
-      return normalizeName(leftSet?.name ?? "").localeCompare(normalizeName(rightSet?.name ?? ""));
-    });
-  }
-
-  const namingRules = inferNamingRules([
-    ...args.componentSets.map((item) => ({ kind: "component" as const, name: item.name })),
-    ...args.tokens.map((item) => ({ kind: "token" as const, name: item.name })),
-    ...args.styles.map((item) => ({ kind: "style" as const, name: item.name })),
-  ]);
-
-  return {
-    aliases,
-    variantSchemas: args.variantSchemas,
-    semanticTokenGroups,
-    preferredComponentsByIntent,
-    namingRules,
-  };
-}

package/figma-intelligence-layer/src/shared/design-system-matcher.ts

@@ -1,184 +0,0 @@
-import Fuse from "fuse.js";
-import { ComponentManifest } from "./types";
-import { DSComponentSet, DesignSystemContext } from "./design-system-context";
-import { normalizeName } from "./design-system-normalizers";
-
-export interface DSMatchRequest {
-  componentType?: string;
-  textContent?: string | null;
-  variants?: Record<string, string | undefined>;
-  estimatedRadius?: number;
-  estimatedSpacing?: number;
-  estimatedFontSize?: number;
-  interactiveElement?: boolean;
-}
-
-export interface DesignSystemMatchResult {
-  component: DSComponentSet | null;
-  confidence: number;
-  fallbackSuggestion: string | null;
-  scores: {
-    name: number;
-    intent: number;
-    variant: number;
-    usage: number;
-  };
-}
-
-function inferRequestIntents(request: DSMatchRequest): string[] {
-  const corpus = normalizeName(
-    [request.componentType, request.textContent, request.interactiveElement ? "interactive" : ""]
-      .filter(Boolean)
-      .join(" ")
-  );
-  const intents = new Set<string>();
-
-  if (/\bbutton|cta|submit|confirm\b/.test(corpus)) intents.add("button");
-  if (/\bprimary\b/.test(corpus)) intents.add("primary-action");
-  if (/\bsecondary|ghost|tertiary\b/.test(corpus)) intents.add("secondary-action");
-  if (/\binput|field|textbox|search\b/.test(corpus)) intents.add("input-field");
-  if (/\bnav|menu|tab|navigation\b/.test(corpus)) intents.add("navigation-item");
-  if (/\bmodal|dialog|sheet\b/.test(corpus)) intents.add("modal");
-  if (/\bcard|tile|panel\b/.test(corpus)) intents.add("card");
-  if (/\bheader|hero|title\b/.test(corpus)) intents.add("page-header");
-
-  return Array.from(intents);
-}
-
-function buildFuseIndex(componentSets: DSComponentSet[]): Fuse<DSComponentSet> {
-  return new Fuse(componentSets, {
-    keys: ["name", "description", "normalizedName", "intents"],
-    threshold: 0.45,
-    includeScore: true,
-    minMatchCharLength: 2,
-  });
-}
-
-function variantCompatibilityScore(
-  requestVariants: Record<string, string | undefined> | undefined,
-  schema: DSComponentSet["variantSchema"]
-): number {
-  if (!requestVariants || Object.keys(requestVariants).length === 0) return 0.5;
-  if (!schema || Object.keys(schema.properties).length === 0) return 0.2;
-
-  const scores = Object.entries(requestVariants).map(([property, value]) => {
-    const expected = value ? normalizeName(value) : "";
-    const allowed = schema.properties[normalizeName(property)] ?? [];
-    if (!expected) return 0.5;
-    if (allowed.includes(expected)) return 1;
-    if (allowed.some((candidate) => candidate.includes(expected) || expected.includes(candidate))) {
-      return 0.75;
-    }
-    return 0;
-  });
-
-  return scores.reduce<number>((sum, value) => sum + value, 0) / scores.length;
-}
-
-function usageScore(componentSet: DSComponentSet, ctx: DesignSystemContext, requestIntents: string[]): number {
-  const intentScores = requestIntents
-    .map((intent) => ctx.intelligence.preferredComponentsByIntent[intent] ?? [])
-    .flat();
-
-  if (intentScores.length === 0) return 0.5;
-
-  const ranking = unique(intentScores);
-  const index = ranking.indexOf(componentSet.id);
-  if (index === -1) return 0;
-  if (ranking.length === 1) return 1;
-  return 1 - index / (ranking.length - 1);
-}
-
-function unique(values: string[]): string[] {
-  return Array.from(new Set(values));
-}
-
-export function matchComponentInContext(
-  request: DSMatchRequest,
-  ctx: DesignSystemContext,
-  threshold = 0.7
-): DesignSystemMatchResult {
-  const componentSets = ctx.inventory.componentSets;
-  if (componentSets.length === 0) {
-    return {
-      component: null,
-      confidence: 0,
-      fallbackSuggestion: null,
-      scores: { name: 0, intent: 0, variant: 0, usage: 0 },
-    };
-  }
-
-  const query = [request.componentType, request.textContent].filter(Boolean).join(" ").trim();
-  const requestIntents = inferRequestIntents(request);
-  const fuse = buildFuseIndex(componentSets);
-  const fuseResults = query ? fuse.search(query) : [];
-  const searchResults = fuseResults.length > 0
-    ? fuseResults
-    : componentSets.map((item) => ({ item, score: 1 }));
-
-  const scored = searchResults
-    .map((result) => {
-      const item = result.item;
-      const nameScore = result.score != null ? 1 - result.score : 0.5;
-      const intentScore = requestIntents.length === 0
-        ? 0.5
-        : requestIntents.filter((intent) => item.intents.includes(intent)).length / requestIntents.length;
-      const variantScore = variantCompatibilityScore(request.variants, item.variantSchema);
-      const preferredBoost = usageScore(item, ctx, requestIntents);
-      const confidence =
-        nameScore * 0.45 +
-        intentScore * 0.25 +
-        variantScore * 0.15 +
-        preferredBoost * 0.15;
-
-      return {
-        item,
-        confidence,
-        scores: {
-          name: nameScore,
-          intent: intentScore,
-          variant: variantScore,
-          usage: preferredBoost,
-        },
-      };
-    })
-    .sort((left, right) => right.confidence - left.confidence);
-
-  const best = scored[0];
-  if (!best) {
-    return {
-      component: null,
-      confidence: 0,
-      fallbackSuggestion: query ? `Consider creating a "${query}" component` : null,
-      scores: { name: 0, intent: 0, variant: 0, usage: 0 },
-    };
-  }
-
-  if (best.confidence >= threshold) {
-    return {
-      component: best.item,
-      confidence: best.confidence,
-      fallbackSuggestion: null,
-      scores: best.scores,
-    };
-  }
-
-  return {
-    component: null,
-    confidence: best.confidence,
-    fallbackSuggestion: `Closest match: "${best.item.name}" (${(best.confidence * 100).toFixed(0)}% confidence)`,
-    scores: best.scores,
-  };
-}
-
-export function manifestToDSMatchRequest(manifest: ComponentManifest): DSMatchRequest {
-  return {
-    componentType: [manifest.dsBestMatch, manifest.componentType].filter(Boolean).join(" ").trim(),
-    textContent: manifest.textContent ?? null,
-    variants: manifest.variants,
-    estimatedRadius: manifest.estimatedRadius,
-    estimatedSpacing: manifest.estimatedSpacing,
-    estimatedFontSize: manifest.estimatedFontSize,
-    interactiveElement: manifest.interactiveElement,
-  };
-}

package/figma-intelligence-layer/src/shared/design-system-normalizers.ts

@@ -1,196 +0,0 @@
-import { ComponentSet, FigmaNode, Token } from "./types.js";
-
-export interface DSVariantSchema {
-  properties: Record<string, string[]>;
-  required?: string[];
-}
-
-export interface NamingRuleInput {
-  kind: "component" | "token" | "style";
-  name: string;
-}
-
-export interface NamingRule {
-  kind: "component" | "token" | "style";
-  pattern: string;
-  examples: string[];
-}
-
-const INTENT_RULES: Array<{ intent: string; patterns: RegExp[] }> = [
-  { intent: "primary-action", patterns: [/\bprimary\b/, /\bcta\b/, /\bsubmit\b/, /\bconfirm\b/] },
-  { intent: "secondary-action", patterns: [/\bsecondary\b/, /\bghost\b/, /\btertiary\b/] },
-  { intent: "input-field", patterns: [/\binput\b/, /\bfield\b/, /\btextbox\b/, /\btext field\b/] },
-  { intent: "navigation-item", patterns: [/\bnav\b/, /\bnavigation\b/, /\bmenu\b/, /\btab\b/] },
-  { intent: "modal", patterns: [/\bmodal\b/, /\bdialog\b/, /\bsheet\b/] },
-  { intent: "card", patterns: [/\bcard\b/, /\bpanel\b/, /\btile\b/] },
-  { intent: "page-header", patterns: [/\bheader\b/, /\bhero\b/, /\bpage title\b/] },
-  { intent: "icon", patterns: [/\bicon\b/, /\blogo\b/, /\bglyph\b/, /\bsymbol\b/] },
-  { intent: "button", patterns: [/\bbutton\b/, /\bbtn\b/] },
-];
-
-export function normalizeName(name: string): string {
-  return name
-    .toLowerCase()
-    .replace(/[\/:,_=-]+/g, " ")
-    .replace(/\s+/g, " ")
-    .trim();
-}
-
-export function parseVariantPropsFromName(name: string): Record<string, string> {
-  const entries = name
-    .split(",")
-    .map((part) => part.trim())
-    .filter(Boolean)
-    .map((part) => {
-      const [key, value] = part.split("=").map((piece) => piece.trim());
-      return key && value ? [normalizeName(key), normalizeName(value)] : null;
-    })
-    .filter((entry): entry is [string, string] => entry !== null);
-
-  return Object.fromEntries(entries);
-}
-
-function pushUnique(values: string[], nextValue: string) {
-  if (!values.includes(nextValue)) {
-    values.push(nextValue);
-  }
-}
-
-export function inferVariantSchema(componentSet: ComponentSet): DSVariantSchema | undefined {
-  const properties = new Map<string, string[]>();
-
-  for (const [name, property] of Object.entries(componentSet.variantGroupProperties || {})) {
-    const normalizedProperty = normalizeName(name);
-    const values = Array.isArray(property?.values) ? property.values : [];
-    if (!properties.has(normalizedProperty)) {
-      properties.set(normalizedProperty, []);
-    }
-    for (const value of values) {
-      const normalizedValue = normalizeName(value);
-      if (normalizedValue) {
-        pushUnique(properties.get(normalizedProperty) ?? [], normalizedValue);
-      }
-    }
-  }
-
-  for (const child of componentSet.children || []) {
-    const variantProps = parseVariantPropsFromName(child.name);
-    for (const [property, value] of Object.entries(variantProps)) {
-      if (!properties.has(property)) {
-        properties.set(property, []);
-      }
-      pushUnique(properties.get(property) ?? [], value);
-    }
-  }
-
-  if (properties.size === 0) {
-    return undefined;
-  }
-
-  return {
-    properties: Object.fromEntries(
-      Array.from(properties.entries()).map(([property, values]) => [property, values.sort()])
-    ),
-  };
-}
-
-export function inferComponentIntents(name: string, description?: string): string[] {
-  const corpus = `${normalizeName(name)} ${normalizeName(description ?? "")}`.trim();
-  const intents = new Set<string>();
-
-  for (const rule of INTENT_RULES) {
-    if (rule.patterns.some((pattern) => pattern.test(corpus))) {
-      intents.add(rule.intent);
-    }
-  }
-
-  if (corpus.includes("primary")) {
-    intents.add("button");
-  }
-
-  return Array.from(intents);
-}
-
-export function inferTokenSemanticGroup(token: Token): string | undefined {
-  const normalized = normalizeName(token.name);
-
-  if (/\b(background|surface|bg)\b/.test(normalized)) return "color.background";
-  if (/\b(text|foreground|fg)\b/.test(normalized)) return "color.text";
-  if (/\b(border|stroke|outline|separator|divider)\b/.test(normalized)) return "color.border";
-  if (token.type === "COLOR") return "color.generic";
-  if (/\b(space|spacing|gap|padding|margin|inset)\b/.test(normalized)) return "space";
-  if (/\b(radius|rounded|corner)\b/.test(normalized)) return "radius";
-  if (/\b(font family|font-family|typeface)\b/.test(normalized)) return "typography.fontFamily";
-  if (/\b(font size|font-size|size)\b/.test(normalized) && token.type === "FLOAT") {
-    return "typography.fontSize";
-  }
-  if (/\b(line height|leading)\b/.test(normalized)) return "typography.lineHeight";
-  if (/\b(letter spacing|tracking)\b/.test(normalized)) return "typography.letterSpacing";
-
-  return undefined;
-}
-
-export function inferStyleSemanticGroup(name: string, styleType: string): string | undefined {
-  const normalized = normalizeName(name);
-
-  if (styleType === "TEXT") {
-    if (/\bheading|title|display\b/.test(normalized)) return "typography.heading";
-    if (/\bbody|paragraph|copy\b/.test(normalized)) return "typography.body";
-    return "typography";
-  }
-
-  if (styleType === "PAINT") {
-    if (/\b(background|surface)\b/.test(normalized)) return "color.background";
-    if (/\b(border|stroke|outline)\b/.test(normalized)) return "color.border";
-    return "color";
-  }
-
-  if (styleType === "EFFECT") return "effect";
-  if (styleType === "GRID") return "layout.grid";
-
-  return undefined;
-}
-
-function inferPattern(name: string): string {
-  if (name.includes("/")) return "slash";
-  if (name.includes(",")) return "variant-csv";
-  if (name.includes("_")) return "snake_case";
-  if (name.includes("-")) return "kebab-case";
-  return "space";
-}
-
-export function inferNamingRules(inputs: NamingRuleInput[]): NamingRule[] {
-  const grouped = new Map<string, string[]>();
-
-  for (const input of inputs) {
-    const key = `${input.kind}:${inferPattern(input.name)}`;
-    const examples = grouped.get(key) ?? [];
-    if (examples.length < 3) {
-      examples.push(input.name);
-      grouped.set(key, examples);
-    }
-  }
-
-  return Array.from(grouped.entries()).map(([key, examples]) => {
-    const [kind, pattern] = key.split(":") as [NamingRule["kind"], string];
-    return { kind, pattern, examples };
-  });
-}
-
-export function componentNameVariants(name: string): string[] {
-  const normalized = normalizeName(name);
-  const compact = normalized.replace(/\s+/g, "");
-  const variants = new Set<string>([normalized, compact]);
-
-  for (const token of normalized.split(" ")) {
-    if (token) {
-      variants.add(token);
-    }
-  }
-
-  return Array.from(variants);
-}
-
-export function firstComponentChildId(node: FigmaNode[] | undefined): string | undefined {
-  return node?.[0]?.id;
-}