@fprad0/skill-master-mcp 0.0.8 → 0.0.10

package/docs/skill-candidates/v0.0.10/figma-generate-library/scripts/inspectFileStructure.js

@@ -0,0 +1,121 @@
+/**
+ * inspectFileStructure
+ *
+ * Reads the current Figma file and returns a structural inventory:
+ * all pages (with child counts), all local variable collections (with mode
+ * names and variable counts), all component sets, all local text styles,
+ * and all local effect styles.
+ *
+ * This is a read-only discovery function — it never creates or mutates nodes.
+ * Run it at the start of Phase 0 to understand what already exists before
+ * planning any creation work.
+ *
+ * @returns {Promise<{
+ *   pages: Array<{id: string, name: string, childCount: number}>,
+ *   variableCollections: Array<{
+ *     id: string,
+ *     name: string,
+ *     modes: Array<{modeId: string, name: string}>,
+ *     variableCount: number,
+ *     variableNames: string[]
+ *   }>,
+ *   componentSets: Array<{id: string, name: string, variantCount: number, pageId: string, pageName: string}>,
+ *   textStyles: Array<{id: string, name: string, fontFamily: string, fontStyle: string, fontSize: number}>,
+ *   effectStyles: Array<{id: string, name: string, effectCount: number}>
+ * }>}
+ */
+async function inspectFileStructure() {
+  const result = {
+    pages: [],
+    variableCollections: [],
+    componentSets: [],
+    textStyles: [],
+    effectStyles: [],
+  }
+
+  // --- Pages ---
+  for (const page of figma.root.children) {
+    result.pages.push({
+      id: page.id,
+      name: page.name,
+      childCount: page.children.length,
+    })
+  }
+
+  // --- Variable collections ---
+  const collections = figma.variables.getLocalVariableCollections()
+  for (const coll of collections) {
+    const variableNames = coll.variableIds
+      .map((id) => figma.variables.getVariableById(id))
+      .filter(Boolean)
+      .map((v) => v.name)
+
+    result.variableCollections.push({
+      id: coll.id,
+      name: coll.name,
+      modes: coll.modes.map((m) => ({ modeId: m.modeId, name: m.name })),
+      variableCount: coll.variableIds.length,
+      variableNames,
+    })
+  }
+
+  // --- Component sets (and standalone components) ---
+  // We need to load all pages to inspect components across the whole file.
+  const originalPage = figma.currentPage
+
+  for (const page of figma.root.children) {
+    await figma.setCurrentPageAsync(page)
+
+    const componentSetsOnPage = page.findAllWithCriteria({ types: ['COMPONENT_SET'] })
+    for (const cs of componentSetsOnPage) {
+      result.componentSets.push({
+        id: cs.id,
+        name: cs.name,
+        variantCount: cs.children.length,
+        pageId: page.id,
+        pageName: page.name,
+      })
+    }
+
+    // Also capture standalone components (not inside a component set)
+    const standaloneComponents = page
+      .findAllWithCriteria({ types: ['COMPONENT'] })
+      .filter((c) => c.parent && c.parent.type !== 'COMPONENT_SET')
+    for (const comp of standaloneComponents) {
+      result.componentSets.push({
+        id: comp.id,
+        name: comp.name,
+        variantCount: 1,
+        pageId: page.id,
+        pageName: page.name,
+      })
+    }
+  }
+
+  // Restore original page
+  await figma.setCurrentPageAsync(originalPage)
+
+  // --- Text styles ---
+  const textStyles = figma.getLocalTextStyles()
+  for (const ts of textStyles) {
+    result.textStyles.push({
+      id: ts.id,
+      name: ts.name,
+      fontFamily: ts.fontName.family,
+      fontStyle: ts.fontName.style,
+      fontSize: ts.fontSize,
+    })
+  }
+
+  // --- Effect styles ---
+  const effectStyles = figma.getLocalEffectStyles()
+  for (const es of effectStyles) {
+    result.effectStyles.push({
+      id: es.id,
+      name: es.name,
+      effectCount: es.effects.length,
+    })
+  }
+
+  return result
+}

package/docs/skill-candidates/v0.0.10/figma-generate-library/scripts/rehydrateState.js

@@ -0,0 +1,92 @@
+/**
+ * Scans the entire Figma file for nodes tagged with dsb_* pluginData
+ * and returns a complete state map for session recovery.
+ *
+ * Use this at the start of every new session, after context truncation,
+ * or when resuming an interrupted build.
+ *
+ * @param {string} runId - The run ID to filter by (optional — if omitted, returns ALL dsb-tagged nodes)
+ * @returns {{ runId: string, taggedNodes: Object<string, {nodeId: string, type: string, name: string, phase: string}>, variableCollections: Array, variables: Array, styles: Array }}
+ */
+async function rehydrateState(runId) {
+  const taggedNodes = {}
+  const variableCollections = []
+  const variables = []
+  const styles = []
+
+  // Scan all pages for dsb-tagged scene nodes
+  for (const page of figma.root.children) {
+    await figma.setCurrentPageAsync(page)
+
+    // Check the page itself
+    const pageRunId = page.getPluginData('dsb_run_id')
+    const pageKey = page.getPluginData('dsb_key')
+    if (pageKey && (!runId || pageRunId === runId)) {
+      taggedNodes[pageKey] = {
+        nodeId: page.id,
+        type: page.type,
+        name: page.name,
+        phase: page.getPluginData('dsb_phase') || 'unknown',
+      }
+    }
+
+    // Scan all descendants
+    page.findAll((node) => {
+      const nodeRunId = node.getPluginData('dsb_run_id')
+      const nodeKey = node.getPluginData('dsb_key')
+      if (nodeKey && (!runId || nodeRunId === runId)) {
+        taggedNodes[nodeKey] = {
+          nodeId: node.id,
+          type: node.type,
+          name: node.name,
+          phase: node.getPluginData('dsb_phase') || 'unknown',
+        }
+      }
+      return false // don't collect, just scan
+    })
+  }
+
+  // Inventory variable collections (variables don't support pluginData — use name-based lookup)
+  const collections = figma.variables.getLocalVariableCollections()
+  for (const coll of collections) {
+    variableCollections.push({
+      id: coll.id,
+      name: coll.name,
+      modes: coll.modes.map((m) => ({ modeId: m.modeId, name: m.name })),
+      variableCount: coll.variableIds.length,
+    })
+  }
+
+  // Inventory variables (name + collection for idempotency key)
+  const allVars = figma.variables.getLocalVariables()
+  for (const v of allVars) {
+    variables.push({
+      id: v.id,
+      name: v.name,
+      collectionId: v.variableCollectionId,
+      resolvedType: v.resolvedType,
+    })
+  }
+
+  // Inventory styles
+  for (const s of figma.getLocalTextStyles()) {
+    styles.push({ id: s.id, name: s.name, type: 'TEXT' })
+  }
+  for (const s of figma.getLocalEffectStyles()) {
+    styles.push({ id: s.id, name: s.name, type: 'EFFECT' })
+  }
+  for (const s of figma.getLocalPaintStyles()) {
+    styles.push({ id: s.id, name: s.name, type: 'PAINT' })
+  }
+
+  return {
+    runId: runId || 'all',
+    taggedNodes,
+    taggedNodeCount: Object.keys(taggedNodes).length,
+    variableCollections,
+    variableCount: variables.length,
+    variables,
+    styleCount: styles.length,
+    styles,
+  }
+}

package/docs/skill-candidates/v0.0.10/figma-generate-library/scripts/validateCreation.js

@@ -0,0 +1,83 @@
+/**
+ * validateCreation
+ *
+ * Verifies that a set of nodes exist and match expected structural properties.
+ * Designed to run immediately after a creation script to catch partial failures
+ * before proceeding to the next build phase.
+ *
+ * Each check specifies a node ID and any combination of expected properties.
+ * A check passes when all specified expectations are met; it fails (with a
+ * reason string) as soon as any expectation is violated.
+ *
+ * @param {Array<{
+ *   nodeId: string,
+ *   expectedChildCount?: number,
+ *   expectedName?: string,
+ *   expectedType?: NodeType
+ * }>} checks
+ *   - `nodeId`: The Figma node ID to look up via figma.getNodeById.
+ *   - `expectedChildCount`: If set, the node must have exactly this many direct children.
+ *     Applies to any node with a `children` property (frames, component sets, etc.).
+ *   - `expectedName`: If set, the node's `.name` must exactly match this string.
+ *   - `expectedType`: If set, the node's `.type` must exactly match this string.
+ * @returns {{
+ *   passed: string[],
+ *   failed: Array<{nodeId: string, reason: string}>
+ * }}
+ *   `passed`: Array of nodeIds that passed all checks.
+ *   `failed`: Array of objects with the nodeId and a human-readable reason string.
+ */
+function validateCreation(checks) {
+  const passed = []
+  const failed = []
+
+  for (const check of checks) {
+    const node = figma.getNodeById(check.nodeId)
+
+    // Node must exist
+    if (!node) {
+      failed.push({
+        nodeId: check.nodeId,
+        reason: `Node not found. It may not have been created, or was deleted.`,
+      })
+      continue
+    }
+
+    const reasons = []
+
+    // Type check
+    if (check.expectedType !== undefined && node.type !== check.expectedType) {
+      reasons.push(`type is "${node.type}", expected "${check.expectedType}"`)
+    }
+
+    // Name check
+    if (check.expectedName !== undefined && node.name !== check.expectedName) {
+      reasons.push(`name is "${node.name}", expected "${check.expectedName}"`)
+    }
+
+    // Child count check
+    if (check.expectedChildCount !== undefined) {
+      if (!('children' in node)) {
+        reasons.push(
+          `node type "${node.type}" does not have children, but expectedChildCount=${check.expectedChildCount} was specified`,
+        )
+      } else {
+        const actualCount = node.children.length
+        if (actualCount !== check.expectedChildCount) {
+          reasons.push(`has ${actualCount} children, expected ${check.expectedChildCount}`)
+        }
+      }
+    }
+
+    if (reasons.length > 0) {
+      failed.push({
+        nodeId: check.nodeId,
+        reason: reasons.join('; '),
+      })
+    } else {
+      passed.push(check.nodeId)
+    }
+  }
+
+  return { passed, failed }
+}

package/docs/skill-candidates/v0.0.10/figma-implement-design/LICENSE.txt

@@ -0,0 +1,2 @@
+Use of these Figma skills and related files ("Materials") is governed by the Figma Developer Terms (available at https://www.figma.com/legal/developer-terms/). By accessing, downloading, or using these Materials — including through automated systems or AI agents — you agree to the Figma Developer Terms.
+These Materials are currently offered as a Beta feature. Figma may modify, suspend, or discontinue them at any time without notice.

package/docs/skill-candidates/v0.0.10/figma-implement-design/SKILL.md

@@ -0,0 +1,258 @@
+---
+name: figma-implement-design
+description: Translates Figma designs into production-ready application code with 1:1 visual fidelity. Use when implementing UI code from Figma files, when user mentions "implement design", "generate code", "implement component", provides Figma URLs, or asks to build components matching Figma specs. For Figma canvas writes via `use_figma`, use `figma-use`.
+---
+
+# Implement Design
+
+## Overview
+
+This skill provides a structured workflow for translating Figma designs into production-ready code with pixel-perfect accuracy. It ensures consistent integration with the Figma MCP server, proper use of design tokens, and 1:1 visual parity with designs.
+
+## Skill Boundaries
+
+- Use this skill when the deliverable is code in the user's repository.
+- If the user asks to create/edit/delete nodes inside Figma itself, switch to [figma-use](../figma-use/SKILL.md).
+- If the user asks to build or update a full-page screen in Figma from code or a description, switch to [figma-generate-design](../figma-generate-design/SKILL.md).
+- If the user asks only for Code Connect mappings, switch to [figma-code-connect-components](../figma-code-connect-components/SKILL.md).
+- If the user asks to author reusable agent rules (`CLAUDE.md`/`AGENTS.md`), switch to [figma-create-design-system-rules](../figma-create-design-system-rules/SKILL.md).
+
+## Prerequisites
+
+- Figma MCP server must be connected and accessible
+- User must provide a Figma URL in the format: `https://figma.com/design/:fileKey/:fileName?node-id=1-2`
+  - `:fileKey` is the file key
+  - `1-2` is the node ID (the specific component or frame to implement)
+- **OR** when using `figma-desktop` MCP: User can select a node directly in the Figma desktop app (no URL required)
+- Project should have an established design system or component library (preferred)
+
+## Required Workflow
+
+**Follow these steps in order. Do not skip steps.**
+
+### Step 1: Get Node ID
+
+#### Option A: Parse from Figma URL
+
+When the user provides a Figma URL, extract the file key and node ID to pass as arguments to MCP tools.
+
+**URL format:** `https://figma.com/design/:fileKey/:fileName?node-id=1-2`
+
+**Extract:**
+
+- **File key:** `:fileKey` (the segment after `/design/`)
+- **Node ID:** `1-2` (the value of the `node-id` query parameter)
+
+**Note:** When using the local desktop MCP (`figma-desktop`), `fileKey` is not passed as a parameter to tool calls. The server automatically uses the currently open file, so only `nodeId` is needed.
+
+**Example:**
+
+- URL: `https://figma.com/design/kL9xQn2VwM8pYrTb4ZcHjF/DesignSystem?node-id=42-15`
+- File key: `kL9xQn2VwM8pYrTb4ZcHjF`
+- Node ID: `42-15`
+
+#### Option B: Use Current Selection from Figma Desktop App (figma-desktop MCP only)
+
+When using the `figma-desktop` MCP and the user has NOT provided a URL, the tools automatically use the currently selected node from the open Figma file in the desktop app.
+
+**Note:** Selection-based prompting only works with the `figma-desktop` MCP server. The remote server requires a link to a frame or layer to extract context. The user must have the Figma desktop app open with a node selected.
+
+### Step 2: Fetch Design Context
+
+Run `get_design_context` with the extracted file key and node ID.
+
+```
+get_design_context(fileKey=":fileKey", nodeId="1-2")
+```
+
+This provides the structured data including:
+
+- Layout properties (Auto Layout, constraints, sizing)
+- Typography specifications
+- Color values and design tokens
+- Component structure and variants
+- Spacing and padding values
+
+**If the response is too large or truncated:**
+
+1. Run `get_metadata(fileKey=":fileKey", nodeId="1-2")` to get the high-level node map
+2. Identify the specific child nodes needed from the metadata
+3. Fetch individual child nodes with `get_design_context(fileKey=":fileKey", nodeId=":childNodeId")`
+
+### Step 3: Capture Visual Reference
+
+Run `get_screenshot` with the same file key and node ID for a visual reference.
+
+```
+get_screenshot(fileKey=":fileKey", nodeId="1-2")
+```
+
+This screenshot serves as the source of truth for visual validation. Keep it accessible throughout implementation.
+
+### Step 4: Download Required Assets
+
+Download any assets (images, icons, SVGs) returned by the Figma MCP server.
+
+**IMPORTANT:** Follow these asset rules:
+
+- If the Figma MCP server returns a `localhost` source for an image or SVG, use that source directly
+- DO NOT import or add new icon packages - all assets should come from the Figma payload
+- DO NOT use or create placeholders if a `localhost` source is provided
+- Assets are served through the Figma MCP server's built-in assets endpoint
+
+### Step 5: Translate to Project Conventions
+
+Translate the Figma output into this project's framework, styles, and conventions.
+
+**Key principles:**
+
+- Treat the Figma MCP output (typically React + Tailwind) as a representation of design and behavior, not as final code style
+- Replace Tailwind utility classes with the project's preferred utilities or design system tokens
+- Reuse existing components (buttons, inputs, typography, icon wrappers) instead of duplicating functionality
+- Use the project's color system, typography scale, and spacing tokens consistently
+- Respect existing routing, state management, and data-fetch patterns
+
+### Step 6: Achieve 1:1 Visual Parity
+
+Strive for pixel-perfect visual parity with the Figma design.
+
+**Guidelines:**
+
+- Prioritize Figma fidelity to match designs exactly
+- Avoid hardcoded values - use design tokens from Figma where available
+- When conflicts arise between design system tokens and Figma specs, prefer design system tokens but adjust spacing or sizes minimally to match visuals
+- Follow WCAG requirements for accessibility
+- Add component documentation as needed
+
+### Step 7: Validate Against Figma
+
+Before marking complete, validate the final UI against the Figma screenshot.
+
+**Validation checklist:**
+
+- [ ] Layout matches (spacing, alignment, sizing)
+- [ ] Typography matches (font, size, weight, line height)
+- [ ] Colors match exactly
+- [ ] Interactive states work as designed (hover, active, disabled)
+- [ ] Responsive behavior follows Figma constraints
+- [ ] Assets render correctly
+- [ ] Accessibility standards met
+
+## Implementation Rules
+
+### Component Organization
+
+- Place UI components in the project's designated design system directory
+- Follow the project's component naming conventions
+- Avoid inline styles unless truly necessary for dynamic values
+
+### Design System Integration
+
+- ALWAYS use components from the project's design system when possible
+- Map Figma design tokens to project design tokens
+- When a matching component exists, extend it rather than creating a new one
+- Document any new components added to the design system
+
+### Code Quality
+
+- Avoid hardcoded values - extract to constants or design tokens
+- Keep components composable and reusable
+- Add TypeScript types for component props
+- Include JSDoc comments for exported components
+
+## Examples
+
+### Example 1: Implementing a Button Component
+
+User says: "Implement this Figma button component: https://figma.com/design/kL9xQn2VwM8pYrTb4ZcHjF/DesignSystem?node-id=42-15"
+
+**Actions:**
+
+1. Parse URL to extract fileKey=`kL9xQn2VwM8pYrTb4ZcHjF` and nodeId=`42-15`
+2. Run `get_design_context(fileKey="kL9xQn2VwM8pYrTb4ZcHjF", nodeId="42-15")`
+3. Run `get_screenshot(fileKey="kL9xQn2VwM8pYrTb4ZcHjF", nodeId="42-15")` for visual reference
+4. Download any button icons from the assets endpoint
+5. Check if project has existing button component
+6. If yes, extend it with new variant; if no, create new component using project conventions
+7. Map Figma colors to project design tokens (e.g., `primary-500`, `primary-hover`)
+8. Validate against screenshot for padding, border radius, typography
+
+**Result:** Button component matching Figma design, integrated with project design system.
+
+### Example 2: Building a Dashboard Layout
+
+User says: "Build this dashboard: https://figma.com/design/pR8mNv5KqXzGwY2JtCfL4D/Dashboard?node-id=10-5"
+
+**Actions:**
+
+1. Parse URL to extract fileKey=`pR8mNv5KqXzGwY2JtCfL4D` and nodeId=`10-5`
+2. Run `get_metadata(fileKey="pR8mNv5KqXzGwY2JtCfL4D", nodeId="10-5")` to understand the page structure
+3. Identify main sections from metadata (header, sidebar, content area, cards) and their child node IDs
+4. Run `get_design_context(fileKey="pR8mNv5KqXzGwY2JtCfL4D", nodeId=":childNodeId")` for each major section
+5. Run `get_screenshot(fileKey="pR8mNv5KqXzGwY2JtCfL4D", nodeId="10-5")` for the full page
+6. Download all assets (logos, icons, charts)
+7. Build layout using project's layout primitives
+8. Implement each section using existing components where possible
+9. Validate responsive behavior against Figma constraints
+
+**Result:** Complete dashboard matching Figma design with responsive layout.
+
+## Best Practices
+
+### Always Start with Context
+
+Never implement based on assumptions. Always fetch `get_design_context` and `get_screenshot` first.
+
+### Incremental Validation
+
+Validate frequently during implementation, not just at the end. This catches issues early.
+
+### Document Deviations
+
+If you must deviate from the Figma design (e.g., for accessibility or technical constraints), document why in code comments.
+
+### Reuse Over Recreation
+
+Always check for existing components before creating new ones. Consistency across the codebase is more important than exact Figma replication.
+
+### Design System First
+
+When in doubt, prefer the project's design system patterns over literal Figma translation.
+
+## Common Issues and Solutions
+
+### Issue: Figma output is truncated
+
+**Cause:** The design is too complex or has too many nested layers to return in a single response.
+**Solution:** Use `get_metadata` to get the node structure, then fetch specific nodes individually with `get_design_context`.
+
+### Issue: Design doesn't match after implementation
+
+**Cause:** Visual discrepancies between the implemented code and the original Figma design.
+**Solution:** Compare side-by-side with the screenshot from Step 3. Check spacing, colors, and typography values in the design context data.
+
+### Issue: Assets not loading
+
+**Cause:** The Figma MCP server's assets endpoint is not accessible or the URLs are being modified.
+**Solution:** Verify the Figma MCP server's assets endpoint is accessible. The server serves assets at `localhost` URLs. Use these directly without modification.
+
+### Issue: Design token values differ from Figma
+
+**Cause:** The project's design system tokens have different values than those specified in the Figma design.
+**Solution:** When project tokens differ from Figma values, prefer project tokens for consistency but adjust spacing/sizing to maintain visual fidelity.
+
+## Understanding Design Implementation
+
+The Figma implementation workflow establishes a reliable process for translating designs to code:
+
+**For designers:** Confidence that implementations will match their designs with pixel-perfect accuracy.
+**For developers:** A structured approach that eliminates guesswork and reduces back-and-forth revisions.
+**For teams:** Consistent, high-quality implementations that maintain design system integrity.
+
+By following this workflow, you ensure that every Figma design is implemented with the same level of care and attention to detail.
+
+## Additional Resources
+
+- [Figma MCP Server Documentation](https://developers.figma.com/docs/figma-mcp-server/)
+- [Figma MCP Server Tools and Prompts](https://developers.figma.com/docs/figma-mcp-server/tools-and-prompts/)
+- [Figma Variables and Design Tokens](https://help.figma.com/hc/en-us/articles/15339657135383-Guide-to-variables-in-Figma)

package/docs/skill-candidates/v0.0.10/figma-implement-design/agents/openai.yaml

@@ -0,0 +1,14 @@
+interface:
+  display_name: "Figma Implement Design"
+  short_description: "Turn Figma designs into production-ready code"
+  icon_small: "./assets/figma-small.svg"
+  icon_large: "./assets/figma.png"
+  default_prompt: "Use $figma-implement-design to implement this Figma design in this codebase, matching layout, states, and responsive behavior."
+
+dependencies:
+  tools:
+    - type: "mcp"
+      value: "figma"
+      description: "Figma MCP server"
+      transport: "streamable_http"
+      url: "https://mcp.figma.com/mcp"

package/docs/skill-candidates/v0.0.10/figma-implement-design/assets/figma-small.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" viewBox="0 0 16 16">
+  <path fill="currentColor" fill-rule="evenodd" d="M4.994 5.986a2.014 2.014 0 1 0 0 4.028h2.069V5.986H4.994Zm5.063-.98h.055a2.014 2.014 0 1 0 0-4.026h-2.07v4.027h2.015Zm1.697.49A2.994 2.994 0 0 0 10.112 0H4.994a2.994 2.994 0 0 0-1.642 5.498A2.99 2.99 0 0 0 2 8a2.99 2.99 0 0 0 1.352 2.503A2.99 2.99 0 0 0 2 13.007C2 14.663 3.358 16 5.008 16c1.665 0 3.035-1.349 3.035-3.02v-2.765a2.984 2.984 0 0 0 2.014.778h.055a2.994 2.994 0 0 0 1.642-5.496Zm-1.642.49h-.055a2.014 2.014 0 1 0 0 4.028h.055a2.014 2.014 0 1 0 0-4.028Zm-7.132 7.02c0-1.111.902-2.013 2.014-2.013h2.069v1.987c0 1.123-.924 2.04-2.055 2.04a2.026 2.026 0 0 1-2.028-2.013Zm4.083-8H4.994a2.014 2.014 0 1 1 0-4.026h2.069v4.027Z" clip-rule="evenodd"/>
+</svg>

package/docs/skill-candidates/v0.0.10/figma-implement-design/assets/icon.svg

@@ -0,0 +1,28 @@
+<svg
+  width="400"
+  height="400"
+  viewBox="0 0 400 400"
+  fill="none"
+  xmlns="http://www.w3.org/2000/svg"
+>
+  <path
+    d="M97.5 302.5C97.5 274.195 120.445 251.25 148.75 251.25H200V302.5C200 330.805 177.055 353.75 148.75 353.75C120.445 353.75 97.5 330.805 97.5 302.5Z"
+    fill="#0ACF83"
+  />
+  <path
+    d="M200 200C200 171.696 222.945 148.75 251.25 148.75C279.554 148.75 302.5 171.695 302.5 200C302.5 228.305 279.554 251.25 251.25 251.25C222.945 251.25 200 228.304 200 200Z"
+    fill="#1ABCFE"
+  />
+  <path
+    d="M97.5 200C97.5 228.305 120.445 251.25 148.75 251.25H200V148.75H148.75C120.445 148.75 97.5 171.695 97.5 200Z"
+    fill="#A259FF"
+  />
+  <path
+    d="M200 46.25V148.75H251.25C279.555 148.75 302.5 125.805 302.5 97.5C302.5 69.1954 279.555 46.25 251.25 46.25H200Z"
+    fill="#FF7262"
+  />
+  <path
+    d="M97.5 97.5C97.5 125.805 120.445 148.75 148.75 148.75H200V46.25L148.75 46.25C120.445 46.25 97.5 69.1954 97.5 97.5Z"
+    fill="#F24E1E"
+  />
+</svg>

package/docs/skill-candidates/v0.0.10/figma-use/LICENSE.TXT

@@ -0,0 +1,2 @@
+Use of these Figma skills and related files ("Materials") is governed by the Figma Developer Terms (available at https://www.figma.com/legal/developer-terms/). By accessing, downloading, or using these Materials — including through automated systems or AI agents — you agree to the Figma Developer Terms.
+These Materials are currently offered as a Beta feature. Figma may modify, suspend, or discontinue them at any time without notice.