figma-cli 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d4174adfd2513d05fd36e0392d1bc2be14d6e495b26131682626cd9082046a7b
+  data.tar.gz: dfb6f841bc0f27b7a1bf9603de28b059182ff9add04ef06cf99bf857b6928bb3
+SHA512:
+  metadata.gz: 35e687e36c9398fffa59133b460944a4af0904d96b16a711a2f2f215c0e114d5e281e3572da1c61396b61ac4c8461e95dea918ac598052ec799ca643cd6676c8
+  data.tar.gz: '028e35e28a4dbed03acc3a0ba39ddda5312c48210be085d2dcf50045a99c4f8dcf516d74e281d8d4176e207a6f8c22f0a0fb7796cac4d386f27114b391b60358'

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,22 @@
+AllCops:
+  TargetRubyVersion: 3.1
+  NewCops: enable
+  SuggestExtensions: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/BlockLength:
+  Exclude:
+    - "spec/**/*"
+    - "*.gemspec"
+
+Metrics/MethodLength:
+  Exclude:
+    - "lib/figma/cli/extractors/**/*"

data/CLAUDE.md

@@ -0,0 +1,75 @@
+# figma-cli
+
+A Ruby gem CLI that extracts design tokens from Figma files via the REST API and writes them as compact YAML files to disk. Optimized for AI agent consumption (token-efficient alternative to Figma MCP).
+
+## Project docs
+
+Full design, API research, and session handoff notes are in Obsidian:
+- Path: `/Users/thommeas/Library/Mobile Documents/iCloud~md~obsidian/Documents/My vault/Claude/figma-cli/`
+- `design.md` — full design doc (architecture, commands, output format, gem structure, implementation steps)
+- `figma-api-research.md` — Figma REST API endpoints, JSON structures, rate limits, gotchas
+- `handoff.md` — session context and decisions made
+
+## Stack
+
+- Ruby gem (module: `Figma::Cli`)
+- Thor (CLI framework)
+- Faraday + faraday-retry (HTTP client with rate-limit retries)
+- RSpec + WebMock (testing)
+- RuboCop (linting)
+
+## Architecture
+
+```
+lib/figma/cli/
+  version.rb      # VERSION constant
+  errors.rb       # Error, AuthError, NotFoundError, RateLimitError, ApiError
+  client.rb       # Figma REST API client (Faraday)
+  command.rb      # Thor CLI (version, extract commands)
+  extractors/
+    color_converter.rb  # Figma 0-1 float → hex/rgb conversion
+    colors.rb           # SOLID fill → {name, hex, rgb, opacity, style_id}
+    typography.rb       # TEXT node style → {name, font_family, ...}
+    effects.rb          # Shadows/blurs → {name, type, radius, ...}
+    spacing.rb          # Auto-layout → {name, padding_*, item_spacing, ...}
+  parser.rb           # Orchestrates URL→fetch→extract pipeline
+  writer.rb           # Serializes parser output → 5 YAML files on disk
+```
+
+### Parser (`Figma::Cli::Parser`)
+- `Parser.new(client:).extract(url, node_id: nil)` → `{ metadata:, colors:, typography:, effects:, spacing: }`
+- Parses Figma URLs (`/file/` and `/design/` formats), converts `?node-id=1-2` → `1:2`
+- Styles pipeline: fetches styles → groups by type → batch-fetches nodes → dispatches extractors
+- Spacing pipeline: full document fetch → recursive tree walk for `layoutMode` nodes
+- `--node-id` scopes spacing extraction to a subtree
+
+### Writer (`Figma::Cli::Writer`)
+- `Writer.write(data, output_dir: ".figma-cli")` → array of 5 written file paths
+- Writes `metadata.yml` (flat), `colors.yml`, `typography.yml`, `effects.yml`, `spacing.yml` (wrapped arrays)
+- YAML output: no `---` header, `line_width: -1`, empty categories → `colors: []`
+- Creates output directory if missing, overwrites silently (idempotent)
+
+### Client (`Figma::Cli::Client`)
+- Auth: `FIGMA_TOKEN` env var or explicit `token:` param
+- Methods: `file(key)`, `file_meta(key)`, `styles(key)`, `nodes(key, ids:)`
+- `nodes()` auto-batches at 50 IDs per request
+- Faraday middleware handles 429 retries (max 3)
+
+## Commands
+
+```bash
+bundle exec figma-cli version
+bundle exec figma-cli extract <figma-url> [--node-id ID] [-o DIR]
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec        # 93 specs
+bundle exec rubocop      # 0 offenses
+```
+
+## Implementation Status
+
+All 8 steps complete. 126 specs, 0 RuboCop offenses.

data/README.md

@@ -0,0 +1,128 @@
+# figma-cli
+
+A Ruby gem CLI that extracts design tokens from Figma files via the REST API and writes them as compact YAML files to disk. Optimized for AI agent consumption (token-efficient alternative to Figma MCP).
+
+## Installation
+
+```bash
+gem install figma-cli
+```
+
+Or add to your Gemfile:
+
+```ruby
+gem "figma-cli"
+```
+
+## Setup
+
+Set your Figma personal access token as an environment variable:
+
+```bash
+export FIGMA_TOKEN=your-token-here
+```
+
+You can generate a personal access token in [Figma account settings](https://help.figma.com/hc/en-us/articles/8085703771159-Manage-personal-access-tokens).
+
+## Usage
+
+```bash
+# Extract tokens from a Figma file
+figma-cli extract <figma-url>
+
+# Scope to a specific node/frame
+figma-cli extract <figma-url> --node-id 123:456
+
+# Custom output directory (default: .figma-cli/)
+figma-cli extract <figma-url> -o design-tokens/
+
+# Show version
+figma-cli version
+```
+
+## Output
+
+Writes 5 YAML files to `.figma-cli/` (or custom directory via `-o`):
+
+```
+.figma-cli/
+  metadata.yml
+  colors.yml
+  typography.yml
+  effects.yml
+  spacing.yml
+```
+
+### metadata.yml
+
+```yaml
+file_name: "Design System"
+file_key: "abc123"
+last_modified: "2026-03-02T12:00:00Z"
+extracted_at: "2026-03-02T15:30:00Z"
+version: "v456"
+```
+
+### colors.yml
+
+```yaml
+colors:
+  - name: "Primary/Blue"
+    hex: "#3366CC"
+    rgb: [51, 102, 204]
+    opacity: 1.0
+    style_id: "S:abc123"
+```
+
+### typography.yml
+
+```yaml
+typography:
+  - name: "Heading/XL"
+    font_family: "Inter"
+    font_weight: 700
+    font_size: 32
+    line_height: 40
+    letter_spacing: 0
+    style_id: "S:ghi789"
+```
+
+### effects.yml
+
+```yaml
+effects:
+  - name: "Shadow/Medium"
+    type: "DROP_SHADOW"
+    offset_x: 0
+    offset_y: 2
+    radius: 8
+    spread: 0
+    color_hex: "#0000001A"
+    style_id: "S:jkl012"
+```
+
+### spacing.yml
+
+```yaml
+spacing:
+  - name: "Card/Container"
+    padding_top: 24
+    padding_right: 24
+    padding_bottom: 24
+    padding_left: 24
+    item_spacing: 16
+    layout_mode: "VERTICAL"
+    node_id: "123:456"
+```
+
+Re-running the same command skips extraction if the Figma file version hasn't changed.
+
+## Development
+
+```bash
+git clone https://github.com/Wethre/figma-cli.git
+cd figma-cli
+bundle install
+bundle exec rspec        # run tests
+bundle exec rubocop      # lint
+```

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/exe/figma-cli

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "figma/cli"
+
+Figma::Cli::Command.start(ARGV)

data/lib/figma/cli/client.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/retry"
+
+module Figma
+  module Cli
+    class Client
+      BASE_URL = "https://api.figma.com"
+
+      BATCH_SIZE = 50
+
+      def initialize(token: ENV.fetch("FIGMA_TOKEN", nil))
+        raise AuthError, "Missing FIGMA_TOKEN. Set it via: export FIGMA_TOKEN=your-token" if token.nil? || token.empty?
+
+        @token = token
+      end
+
+      def file(file_key)
+        get("/v1/files/#{file_key}")
+      end
+
+      def file_meta(file_key)
+        get("/v1/files/#{file_key}", depth: 1)
+      end
+
+      def styles(file_key)
+        get("/v1/files/#{file_key}/styles")
+      end
+
+      def nodes(file_key, ids:)
+        ids.each_slice(BATCH_SIZE).with_object({}) do |batch, merged|
+          response = get("/v1/files/#{file_key}/nodes", ids: batch.join(","))
+          merged.merge!(response["nodes"])
+        end
+      end
+
+      private
+
+      def connection
+        @connection ||= Faraday.new(url: BASE_URL) do |f|
+          f.headers["X-Figma-Token"] = @token
+          f.request :retry, max: 3, interval: 1, retry_statuses: [429]
+          f.response :json
+        end
+      end
+
+      def get(path, params = {})
+        response = connection.get(path, params)
+        handle_response(response)
+      end
+
+      def handle_response(response)
+        case response.status
+        when 200 then response.body
+        when 403 then raise AuthError, "Access denied (403). Check your FIGMA_TOKEN permissions."
+        when 404 then raise NotFoundError, "Resource not found (404). Check the file key or node IDs."
+        when 429 then raise RateLimitError, "Rate limited (429). Retries exhausted."
+        else raise ApiError, "Figma API error (#{response.status})"
+        end
+      end
+    end
+  end
+end

data/lib/figma/cli/command.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "thor"
+require "yaml"
+
+module Figma
+  module Cli
+    class Command < Thor
+      desc "version", "Print figma-cli version"
+      def version
+        puts "figma-cli #{VERSION}"
+      end
+
+      desc "extract URL", "Extract design tokens from a Figma file"
+      option :node_id, type: :string, desc: "Figma node ID to scope extraction"
+      option :output, aliases: "-o", type: :string, default: ".figma-cli", desc: "Output directory"
+      def extract(url) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        client = Client.new
+        parser = Parser.new(client: client)
+
+        # Check cache: skip if local version matches remote
+        version_info = parser.file_version(url)
+        metadata_path = File.join(options[:output], "metadata.yml")
+        if File.exist?(metadata_path)
+          local = YAML.safe_load_file(metadata_path)
+          if local && local["version"] == version_info[:version]
+            warn "Up to date (version #{version_info[:version]}), skipping."
+            return
+          end
+        end
+
+        data = parser.extract(url, node_id: options[:node_id])
+        paths = Writer.write(data, output_dir: options[:output])
+        warn "Wrote #{paths.size} files to #{options[:output]}/"
+        paths.each { |p| warn "  #{p}" }
+      rescue Error => e
+        warn "Error: #{e.message}"
+        exit 1
+      end
+
+      def self.exit_on_failure?
+        true
+      end
+    end
+  end
+end

data/lib/figma/cli/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Figma
+  module Cli
+    class Error < StandardError; end
+    class AuthError < Error; end
+    class NotFoundError < Error; end
+    class RateLimitError < Error; end
+    class ApiError < Error; end
+  end
+end

data/lib/figma/cli/extractors/color_converter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Figma
+  module Cli
+    module Extractors
+      module ColorConverter
+        def self.to_hex(color)
+          r, g, b = to_rgb(color)
+          format("#%<r>02X%<g>02X%<b>02X", r: r, g: g, b: b)
+        end
+
+        def self.to_hex_alpha(color)
+          r, g, b = to_rgb(color)
+          a = (color["a"] * 255).round
+          format("#%<r>02X%<g>02X%<b>02X%<a>02X", r: r, g: g, b: b, a: a)
+        end
+
+        def self.to_rgb(color)
+          [(color["r"] * 255).round, (color["g"] * 255).round, (color["b"] * 255).round]
+        end
+      end
+    end
+  end
+end

data/lib/figma/cli/extractors/colors.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Figma
+  module Cli
+    module Extractors
+      module Colors
+        def self.extract(document, style_name:, style_id:)
+          fills = document.fetch("fills", [])
+          fills.select { |f| f["type"] == "SOLID" }.map do |fill|
+            {
+              name: style_name,
+              hex: ColorConverter.to_hex(fill["color"]),
+              rgb: ColorConverter.to_rgb(fill["color"]),
+              opacity: fill.fetch("opacity", 1.0).to_f,
+              style_id: style_id
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/figma/cli/extractors/effects.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Figma
+  module Cli
+    module Extractors
+      module Effects
+        SHADOW_TYPES = %w[DROP_SHADOW INNER_SHADOW].freeze
+        BLUR_TYPES = %w[LAYER_BLUR BACKGROUND_BLUR].freeze
+
+        def self.extract(document, style_name:, style_id:)
+          effects = document.fetch("effects", [])
+          effects.select { |e| e["visible"] }.map do |effect|
+            if SHADOW_TYPES.include?(effect["type"])
+              extract_shadow(effect, style_name: style_name, style_id: style_id)
+            elsif BLUR_TYPES.include?(effect["type"])
+              extract_blur(effect, style_name: style_name, style_id: style_id)
+            end
+          end.compact
+        end
+
+        def self.extract_shadow(effect, style_name:, style_id:)
+          offset = effect.fetch("offset", {})
+          {
+            name: style_name,
+            type: effect["type"],
+            offset_x: offset.fetch("x", 0),
+            offset_y: offset.fetch("y", 0),
+            radius: effect.fetch("radius", 0),
+            spread: effect.fetch("spread", 0),
+            color_hex: ColorConverter.to_hex_alpha(effect["color"]),
+            style_id: style_id
+          }
+        end
+        private_class_method :extract_shadow
+
+        def self.extract_blur(effect, style_name:, style_id:)
+          {
+            name: style_name,
+            type: effect["type"],
+            radius: effect.fetch("radius", 0),
+            style_id: style_id
+          }
+        end
+        private_class_method :extract_blur
+      end
+    end
+  end
+end

data/lib/figma/cli/extractors/spacing.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Figma
+  module Cli
+    module Extractors
+      module Spacing
+        def self.extract(document, node_name:, node_id:)
+          return nil unless document["layoutMode"]
+
+          {
+            name: node_name,
+            padding_top: document.fetch("paddingTop", 0),
+            padding_right: document.fetch("paddingRight", 0),
+            padding_bottom: document.fetch("paddingBottom", 0),
+            padding_left: document.fetch("paddingLeft", 0),
+            item_spacing: document.fetch("itemSpacing", 0),
+            layout_mode: document["layoutMode"],
+            node_id: node_id
+          }
+        end
+      end
+    end
+  end
+end

data/lib/figma/cli/extractors/typography.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Figma
+  module Cli
+    module Extractors
+      module Typography
+        def self.extract(document, style_name:, style_id:)
+          style = document["style"]
+          return nil unless style
+
+          {
+            name: style_name,
+            font_family: style["fontFamily"],
+            font_weight: style.fetch("fontWeight", 0),
+            font_size: style.fetch("fontSize", 0),
+            line_height: style.fetch("lineHeightPx", 0),
+            letter_spacing: style.fetch("letterSpacing", 0),
+            style_id: style_id
+          }
+        end
+      end
+    end
+  end
+end

data/lib/figma/cli/parser.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "uri"
+require "time"
+
+module Figma
+  module Cli
+    class Parser
+      URL_PATTERN = %r{\Ahttps?://[^/]+/(file|design)/([^/]+)}
+      STYLE_TYPES = %w[FILL TEXT EFFECT].freeze
+
+      def initialize(client:)
+        @client = client
+        @cached_meta = nil
+      end
+
+      def extract(url, node_id: nil)
+        parsed = parse_url(url)
+        file_key = parsed[:file_key]
+        node_id ||= parsed[:node_id]
+        metadata = fetch_metadata(file_key)
+        styles = extract_styles(file_key)
+        { metadata: metadata, **styles, spacing: extract_spacing(file_key, node_id: node_id) }
+      end
+
+      def file_version(url)
+        parsed = parse_url(url)
+        file_key = parsed[:file_key]
+        @cached_meta = @client.file_meta(file_key)
+        { file_key: file_key, version: @cached_meta["version"] }
+      end
+
+      private
+
+      def parse_url(url)
+        match = URL_PATTERN.match(url)
+        raise Error, "Invalid Figma URL: #{url}" unless match
+
+        { file_key: match[2], node_id: parse_node_id(url) }
+      end
+
+      def parse_node_id(url)
+        query = URI.parse(url).query
+        return nil unless query
+
+        URI.decode_www_form(query).to_h["node-id"]&.tr("-", ":")
+      end
+
+      def fetch_metadata(file_key)
+        meta = @cached_meta || @client.file_meta(file_key)
+        @cached_meta = nil
+        { file_name: meta["name"], file_key: file_key, last_modified: meta["lastModified"],
+          extracted_at: Time.now.utc.iso8601, version: meta["version"] }
+      end
+
+      def extract_styles(file_key)
+        all = @client.styles(file_key).dig("meta", "styles") || []
+        grouped = all.group_by { |s| s["style_type"] }.slice(*STYLE_TYPES)
+        return empty_styles if grouped.empty?
+
+        known = grouped.values.flatten
+        nodes = fetch_style_nodes(file_key, known)
+        build_style_results(grouped, nodes)
+      end
+
+      def fetch_style_nodes(file_key, styles)
+        @client.nodes(file_key, ids: styles.map { |s| s["node_id"] }.uniq)
+      end
+
+      def build_style_results(grouped, nodes)
+        { colors: run_extractor(grouped["FILL"], nodes),
+          typography: run_extractor(grouped["TEXT"], nodes),
+          effects: run_extractor(grouped["EFFECT"], nodes) }
+      end
+
+      def run_extractor(styles, nodes)
+        return [] unless styles
+
+        styles.flat_map do |s|
+          doc = nodes.dig(s["node_id"], "document")
+          doc ? dispatch(s, doc) : nil
+        end.compact
+      end
+
+      def dispatch(style, doc)
+        n, k = style.values_at("name", "key")
+        case style["style_type"]
+        when "FILL" then Extractors::Colors.extract(doc, style_name: n, style_id: k)
+        when "TEXT" then Extractors::Typography.extract(doc, style_name: n, style_id: k)
+        when "EFFECT" then Extractors::Effects.extract(doc, style_name: n, style_id: k)
+        end
+      end
+
+      def extract_spacing(file_key, node_id: nil)
+        root = @client.file(file_key)["document"]
+        tree = node_id ? find_subtree(root, node_id) : root
+        tree ? collect_spacing(tree) : []
+      end
+
+      def find_subtree(node, target_id)
+        return node if node["id"] == target_id
+
+        node.fetch("children", []).each do |child|
+          found = find_subtree(child, target_id)
+          return found if found
+        end
+        nil
+      end
+
+      def collect_spacing(node)
+        results = []
+        token = Extractors::Spacing.extract(node, node_name: node["name"], node_id: node["id"])
+        results << token if token
+        node.fetch("children", []).each { |child| results.concat(collect_spacing(child)) }
+        results
+      end
+
+      def empty_styles
+        { colors: [], typography: [], effects: [] }
+      end
+    end
+  end
+end

data/lib/figma/cli/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Figma
+  module Cli
+    VERSION = "0.1.0"
+  end
+end

data/lib/figma/cli/writer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Figma
+  module Cli
+    module Writer
+      CATEGORIES = %i[colors typography effects spacing].freeze
+
+      def self.write(data, output_dir: ".figma-cli")
+        FileUtils.mkdir_p(output_dir)
+        paths = []
+
+        # metadata (flat)
+        paths << write_file(File.join(output_dir, "metadata.yml"), format_yaml(stringify_keys(data[:metadata])))
+
+        # token categories (wrapped)
+        CATEGORIES.each do |cat|
+          content = { cat.to_s => data[cat].map { |h| stringify_keys(h) } }
+          paths << write_file(File.join(output_dir, "#{cat}.yml"), format_yaml(content))
+        end
+
+        paths
+      end
+
+      def self.write_file(path, content)
+        File.write(path, content)
+        path
+      end
+
+      def self.format_yaml(data)
+        YAML.dump(data, line_width: -1).sub(/\A---\n/, "")
+      end
+
+      def self.stringify_keys(hash)
+        hash.transform_keys(&:to_s)
+      end
+
+      private_class_method :write_file, :format_yaml, :stringify_keys
+    end
+  end
+end

data/lib/figma/cli.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "cli/version"
+require_relative "cli/errors"
+require_relative "cli/client"
+require_relative "cli/parser"
+require_relative "cli/writer"
+require_relative "cli/command"
+require_relative "cli/extractors/color_converter"
+require_relative "cli/extractors/colors"
+require_relative "cli/extractors/typography"
+require_relative "cli/extractors/effects"
+require_relative "cli/extractors/spacing"
+
+module Figma
+  module Cli
+  end
+end

data/sig/figma/cli.rbs

@@ -0,0 +1,6 @@
+module Figma
+  module Cli
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: figma-cli
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Thom Meas
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-03-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-retry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: A CLI tool that extracts design tokens (colors, typography, spacing,
+  effects) from Figma files via the REST API and writes them as compact YAML files
+  to disk. Optimized for AI agent consumption.
+email:
+- thom.meas@gmail.com
+executables:
+- figma-cli
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CLAUDE.md
+- README.md
+- Rakefile
+- exe/figma-cli
+- lib/figma/cli.rb
+- lib/figma/cli/client.rb
+- lib/figma/cli/command.rb
+- lib/figma/cli/errors.rb
+- lib/figma/cli/extractors/color_converter.rb
+- lib/figma/cli/extractors/colors.rb
+- lib/figma/cli/extractors/effects.rb
+- lib/figma/cli/extractors/spacing.rb
+- lib/figma/cli/extractors/typography.rb
+- lib/figma/cli/parser.rb
+- lib/figma/cli/version.rb
+- lib/figma/cli/writer.rb
+- sig/figma/cli.rbs
+homepage: https://github.com/Wethre/figma-cli
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Wethre/figma-cli
+  source_code_uri: https://github.com/Wethre/figma-cli
+  changelog_uri: https://github.com/Wethre/figma-cli/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Extract Figma design tokens to YAML files on disk
+test_files: []