@llc3233149/core 0.9.0

package/src/tools/variables.ts

@@ -0,0 +1,193 @@
+import { parseColor } from '../color'
+
+import { defineTool } from './schema'
+
+export const listVariables = defineTool({
+  name: 'list_variables',
+  description: 'List all design variables (colors, numbers, strings, booleans).',
+  params: {
+    type: {
+      type: 'string',
+      description: 'Filter by variable type',
+      enum: ['COLOR', 'FLOAT', 'STRING', 'BOOLEAN']
+    }
+  },
+  execute: (figma, args) => {
+    const vars = figma.getLocalVariables(args.type)
+    return { count: vars.length, variables: vars }
+  }
+})
+
+export const listCollections = defineTool({
+  name: 'list_collections',
+  description: 'List all variable collections.',
+  params: {},
+  execute: (figma) => {
+    const cols = figma.getLocalVariableCollections()
+    return { count: cols.length, collections: cols }
+  }
+})
+
+export const getVariable = defineTool({
+  name: 'get_variable',
+  description: 'Get a variable by ID.',
+  params: {
+    id: { type: 'string', description: 'Variable ID', required: true }
+  },
+  execute: (figma, { id }) => {
+    const v = figma.getVariableById(id)
+    if (!v) return { error: `Variable "${id}" not found` }
+    return v
+  }
+})
+
+export const findVariables = defineTool({
+  name: 'find_variables',
+  description: 'Find variables by name pattern.',
+  params: {
+    query: { type: 'string', description: 'Name substring (case-insensitive)', required: true },
+    type: {
+      type: 'string',
+      description: 'Filter by type',
+      enum: ['COLOR', 'FLOAT', 'STRING', 'BOOLEAN']
+    }
+  },
+  execute: (figma, args) => {
+    let vars = figma.getLocalVariables(args.type)
+    vars = vars.filter((v) => v.name.toLowerCase().includes(args.query.toLowerCase()))
+    return { count: vars.length, variables: vars }
+  }
+})
+
+export const createVariable = defineTool({
+  name: 'create_variable',
+  mutates: true,
+  description: 'Create a new variable in a collection.',
+  params: {
+    name: { type: 'string', description: 'Variable name', required: true },
+    type: {
+      type: 'string',
+      description: 'Variable type',
+      required: true,
+      enum: ['COLOR', 'FLOAT', 'STRING', 'BOOLEAN']
+    },
+    collection_id: { type: 'string', description: 'Collection ID', required: true },
+    value: { type: 'string', description: 'Initial value (hex for COLOR, number for FLOAT, etc.)' }
+  },
+  execute: (figma, args) => {
+    let parsedValue: unknown
+    if (args.value !== undefined) {
+      if (args.type === 'COLOR') parsedValue = parseColor(args.value)
+      else if (args.type === 'FLOAT') parsedValue = Number(args.value)
+      else if (args.type === 'BOOLEAN') parsedValue = args.value === 'true'
+      else parsedValue = args.value
+    }
+    const v = figma.createVariable(
+      args.name,
+      args.type as any,
+      args.collection_id,
+      parsedValue as any
+    )
+    return v
+  }
+})
+
+export const setVariable = defineTool({
+  name: 'set_variable',
+  mutates: true,
+  description: 'Set the value of a variable for a specific mode.',
+  params: {
+    id: { type: 'string', description: 'Variable ID', required: true },
+    mode: { type: 'string', description: 'Mode ID', required: true },
+    value: {
+      type: 'string',
+      description: 'Value (hex for COLOR, number for FLOAT, etc.)',
+      required: true
+    }
+  },
+  execute: (figma, args) => {
+    const v = figma.getVariableById(args.id)
+    if (!v) return { error: `Variable "${args.id}" not found` }
+    let parsedValue: unknown
+    if (v.type === 'COLOR') parsedValue = parseColor(args.value)
+    else if (v.type === 'FLOAT') parsedValue = Number(args.value)
+    else if (v.type === 'BOOLEAN') parsedValue = args.value === 'true'
+    else parsedValue = args.value
+    figma.setVariableValue(args.id, args.mode, parsedValue as any)
+    return { id: args.id, mode: args.mode, value: parsedValue }
+  }
+})
+
+export const deleteVariable = defineTool({
+  name: 'delete_variable',
+  mutates: true,
+  description: 'Delete a variable.',
+  params: {
+    id: { type: 'string', description: 'Variable ID', required: true }
+  },
+  execute: (figma, { id }) => {
+    figma.deleteVariable(id)
+    return { deleted: id }
+  }
+})
+
+export const bindVariable = defineTool({
+  name: 'bind_variable',
+  mutates: true,
+  description: 'Bind a variable to a node property (fills, strokes, opacity, width, height, etc.).',
+  params: {
+    node_id: { type: 'string', description: 'Node ID', required: true },
+    field: {
+      type: 'string',
+      description: 'Property field (fills, strokes, opacity, width, height, etc.)',
+      required: true
+    },
+    variable_id: { type: 'string', description: 'Variable ID', required: true }
+  },
+  execute: (figma, args) => {
+    const node = figma.getNodeById(args.node_id)
+    if (!node) return { error: `Node "${args.node_id}" not found` }
+    const v = figma.getVariableById(args.variable_id)
+    if (!v) return { error: `Variable "${args.variable_id}" not found` }
+    figma.bindVariable(args.node_id, args.field, args.variable_id)
+    return { node_id: args.node_id, field: args.field, variable_id: args.variable_id }
+  }
+})
+
+export const getCollection = defineTool({
+  name: 'get_collection',
+  description: 'Get a variable collection by ID.',
+  params: {
+    id: { type: 'string', description: 'Collection ID', required: true }
+  },
+  execute: (figma, { id }) => {
+    const c = figma.getVariableCollectionById(id)
+    if (!c) return { error: `Collection "${id}" not found` }
+    return c
+  }
+})
+
+export const createCollection = defineTool({
+  name: 'create_collection',
+  mutates: true,
+  description: 'Create a new variable collection.',
+  params: {
+    name: { type: 'string', description: 'Collection name', required: true }
+  },
+  execute: (figma, { name }) => {
+    return figma.createVariableCollection(name)
+  }
+})
+
+export const deleteCollection = defineTool({
+  name: 'delete_collection',
+  mutates: true,
+  description: 'Delete a variable collection and all its variables.',
+  params: {
+    id: { type: 'string', description: 'Collection ID', required: true }
+  },
+  execute: (figma, { id }) => {
+    figma.deleteVariableCollection(id)
+    return { deleted: id }
+  }
+})

package/src/tools/vector.ts

@@ -0,0 +1,311 @@
+import { defineTool, nodeSummary } from './schema'
+
+const CHUNK_SIZE = 0x8000
+
+function uint8ArrayToBase64(bytes: Uint8Array): string {
+  if (typeof Buffer !== 'undefined') {
+    return Buffer.from(bytes).toString('base64')
+  }
+  let binary = ''
+  for (let i = 0; i < bytes.length; i += CHUNK_SIZE) {
+    const chunk = bytes.subarray(i, i + CHUNK_SIZE)
+    binary += String.fromCharCode.apply(null, chunk as unknown as number[])
+  }
+  return btoa(binary)
+}
+
+export const booleanUnion = defineTool({
+  name: 'boolean_union',
+  mutates: true,
+  description: 'Union (combine) multiple nodes.',
+  params: {
+    ids: { type: 'string[]', description: 'Node IDs to union', required: true }
+  },
+  execute: (figma, { ids }) => {
+    const result = figma.booleanOperation('UNION', ids)
+    return nodeSummary(result)
+  }
+})
+
+export const booleanSubtract = defineTool({
+  name: 'boolean_subtract',
+  mutates: true,
+  description: 'Subtract the second node from the first.',
+  params: {
+    ids: { type: 'string[]', description: 'Node IDs (first minus rest)', required: true }
+  },
+  execute: (figma, { ids }) => {
+    const result = figma.booleanOperation('SUBTRACT', ids)
+    return nodeSummary(result)
+  }
+})
+
+export const booleanIntersect = defineTool({
+  name: 'boolean_intersect',
+  mutates: true,
+  description: 'Intersect multiple nodes.',
+  params: {
+    ids: { type: 'string[]', description: 'Node IDs to intersect', required: true }
+  },
+  execute: (figma, { ids }) => {
+    const result = figma.booleanOperation('INTERSECT', ids)
+    return nodeSummary(result)
+  }
+})
+
+export const booleanExclude = defineTool({
+  name: 'boolean_exclude',
+  mutates: true,
+  description: 'Exclude (XOR) multiple nodes.',
+  params: {
+    ids: { type: 'string[]', description: 'Node IDs to exclude', required: true }
+  },
+  execute: (figma, { ids }) => {
+    const result = figma.booleanOperation('EXCLUDE', ids)
+    return nodeSummary(result)
+  }
+})
+
+export const pathGet = defineTool({
+  name: 'path_get',
+  description: 'Get vector path data of a node.',
+  params: {
+    id: { type: 'string', description: 'Node ID', required: true }
+  },
+  execute: (figma, { id }) => {
+    const raw = figma.graph.getNode(id)
+    if (!raw) return { error: `Node "${id}" not found` }
+    if (!raw.vectorNetwork) return { error: `Node "${id}" has no vector data` }
+    return { id, vectorNetwork: raw.vectorNetwork }
+  }
+})
+
+export const pathSet = defineTool({
+  name: 'path_set',
+  mutates: true,
+  description: 'Set vector path data on a node. Provide a VectorNetwork JSON.',
+  params: {
+    id: { type: 'string', description: 'Node ID', required: true },
+    path: { type: 'string', description: 'VectorNetwork JSON', required: true }
+  },
+  execute: (figma, args) => {
+    const raw = figma.graph.getNode(args.id)
+    if (!raw) return { error: `Node "${args.id}" not found` }
+    const network = JSON.parse(args.path)
+    figma.graph.updateNode(args.id, { vectorNetwork: network } as any)
+    return { id: args.id }
+  }
+})
+
+export const pathScale = defineTool({
+  name: 'path_scale',
+  mutates: true,
+  description: 'Scale vector path from center.',
+  params: {
+    id: { type: 'string', description: 'Node ID', required: true },
+    factor: { type: 'number', description: 'Scale factor (e.g. 2 for double)', required: true }
+  },
+  execute: (figma, { id, factor }) => {
+    const raw = figma.graph.getNode(id)
+    if (!raw) return { error: `Node "${id}" not found` }
+    if (!raw.vectorNetwork) return { error: `Node "${id}" has no vector data` }
+    const vn = structuredClone(raw.vectorNetwork)
+    const cx = raw.width / 2
+    const cy = raw.height / 2
+    for (const v of vn.vertices) {
+      v.x = cx + (v.x - cx) * factor
+      v.y = cy + (v.y - cy) * factor
+    }
+    for (const s of vn.segments) {
+      s.tangentStart.x *= factor
+      s.tangentStart.y *= factor
+      s.tangentEnd.x *= factor
+      s.tangentEnd.y *= factor
+    }
+    figma.graph.updateNode(id, { vectorNetwork: vn } as any)
+    return { id, factor }
+  }
+})
+
+export const pathFlip = defineTool({
+  name: 'path_flip',
+  mutates: true,
+  description: 'Flip vector path horizontally or vertically.',
+  params: {
+    id: { type: 'string', description: 'Node ID', required: true },
+    axis: {
+      type: 'string',
+      description: 'Flip axis',
+      required: true,
+      enum: ['horizontal', 'vertical']
+    }
+  },
+  execute: (figma, { id, axis }) => {
+    const raw = figma.graph.getNode(id)
+    if (!raw) return { error: `Node "${id}" not found` }
+    if (!raw.vectorNetwork) return { error: `Node "${id}" has no vector data` }
+    const vn = structuredClone(raw.vectorNetwork)
+    const w = raw.width
+    const h = raw.height
+    for (const v of vn.vertices) {
+      if (axis === 'horizontal') v.x = w - v.x
+      else v.y = h - v.y
+    }
+    for (const s of vn.segments) {
+      if (axis === 'horizontal') s.tangentStart.x = -s.tangentStart.x
+      else s.tangentStart.y = -s.tangentStart.y
+      if (axis === 'horizontal') s.tangentEnd.x = -s.tangentEnd.x
+      else s.tangentEnd.y = -s.tangentEnd.y
+    }
+    figma.graph.updateNode(id, { vectorNetwork: vn } as any)
+    return { id, axis }
+  }
+})
+
+export const pathMove = defineTool({
+  name: 'path_move',
+  mutates: true,
+  description: 'Move all path points by an offset.',
+  params: {
+    id: { type: 'string', description: 'Node ID', required: true },
+    dx: { type: 'number', description: 'X offset', required: true },
+    dy: { type: 'number', description: 'Y offset', required: true }
+  },
+  execute: (figma, { id, dx, dy }) => {
+    const raw = figma.graph.getNode(id)
+    if (!raw) return { error: `Node "${id}" not found` }
+    if (!raw.vectorNetwork) return { error: `Node "${id}" has no vector data` }
+    const vn = structuredClone(raw.vectorNetwork)
+    for (const v of vn.vertices) {
+      v.x += dx
+      v.y += dy
+    }
+    figma.graph.updateNode(id, { vectorNetwork: vn } as any)
+    return { id, dx, dy }
+  }
+})
+
+export const viewportGet = defineTool({
+  name: 'viewport_get',
+  description: 'Get current viewport position and zoom level.',
+  params: {},
+  execute: (figma) => {
+    return figma.viewport
+  }
+})
+
+export const viewportSet = defineTool({
+  name: 'viewport_set',
+  mutates: true,
+  description: 'Set viewport position and zoom.',
+  params: {
+    x: { type: 'number', description: 'Center X', required: true },
+    y: { type: 'number', description: 'Center Y', required: true },
+    zoom: { type: 'number', description: 'Zoom level', required: true, min: 0.01 }
+  },
+  execute: (figma, { x, y, zoom }) => {
+    figma.viewport = { center: { x, y }, zoom }
+    return { x, y, zoom }
+  }
+})
+
+export const viewportZoomToFit = defineTool({
+  name: 'viewport_zoom_to_fit',
+  mutates: true,
+  description: 'Zoom viewport to fit specified nodes.',
+  params: {
+    ids: { type: 'string[]', description: 'Node IDs to fit in view', required: true }
+  },
+  execute: (figma, { ids }) => {
+    let minX = Infinity
+    let minY = Infinity
+    let maxX = -Infinity
+    let maxY = -Infinity
+    for (const id of ids) {
+      const node = figma.getNodeById(id)
+      if (!node) continue
+      const bounds = node.absoluteBoundingBox
+      minX = Math.min(minX, bounds.x)
+      minY = Math.min(minY, bounds.y)
+      maxX = Math.max(maxX, bounds.x + bounds.width)
+      maxY = Math.max(maxY, bounds.y + bounds.height)
+    }
+    if (minX === Infinity) return { error: 'No valid nodes found' }
+    const cx = (minX + maxX) / 2
+    const cy = (minY + maxY) / 2
+    figma.viewport = { center: { x: cx, y: cy }, zoom: 1 }
+    return {
+      center: { x: cx, y: cy },
+      bounds: { x: minX, y: minY, width: maxX - minX, height: maxY - minY }
+    }
+  }
+})
+
+export const exportSvg = defineTool({
+  name: 'export_svg',
+  description: 'Export nodes as SVG markup. Returns the SVG string.',
+  params: {
+    ids: {
+      type: 'string[]',
+      description: 'Node IDs to export. Omit to export all top-level nodes on the current page.'
+    }
+  },
+  execute: async (figma, args) => {
+    const { renderNodesToSVG } = await import('../svg-export/index.js')
+    const pageId = figma.currentPageId
+    const ids =
+      args.ids && args.ids.length > 0
+        ? args.ids
+        : figma.currentPage.children.map((n) => n.id)
+    const svg = renderNodesToSVG(figma.graph, pageId, ids)
+    if (!svg) return { error: 'No visible nodes to export' }
+    return { svg }
+  }
+})
+
+export const exportImage = defineTool({
+  name: 'export_image',
+  description:
+    'Export nodes as a raster image (PNG, JPG, or WEBP). Returns base64-encoded image data. Use to visually verify designs.',
+  params: {
+    ids: {
+      type: 'string[]',
+      description: 'Node IDs to export. Omit to export all top-level nodes on the current page.'
+    },
+    format: {
+      type: 'string',
+      description: 'Image format',
+      enum: ['PNG', 'JPG', 'WEBP'],
+      default: 'PNG'
+    },
+    scale: {
+      type: 'number',
+      description: 'Export scale multiplier (default: 1)',
+      default: 1,
+      min: 0.1,
+      max: 4
+    }
+  },
+  execute: async (figma, args) => {
+    if (!figma.exportImage) {
+      return { error: 'Image export is not available in this environment' }
+    }
+    const ids =
+      args.ids && args.ids.length > 0
+        ? args.ids
+        : figma.currentPage.children.map((n) => n.id)
+    const format = (args.format ?? 'PNG').toUpperCase() as 'PNG' | 'JPG' | 'WEBP'
+    const data = await figma.exportImage(ids, {
+      scale: args.scale ?? 1,
+      format
+    })
+    if (!data || data.length === 0) return { error: 'No visible nodes to export' }
+    const base64 = uint8ArrayToBase64(data)
+    const mimeMap = { PNG: 'image/png', JPG: 'image/jpeg', WEBP: 'image/webp' } as const
+    return {
+      mimeType: mimeMap[format],
+      base64,
+      byteLength: data.length
+    }
+  }
+})

package/src/types.ts

@@ -0,0 +1,32 @@
+export interface GUID {
+  sessionID: number
+  localID: number
+}
+
+export interface Color {
+  r: number
+  g: number
+  b: number
+  a: number
+}
+
+export interface Vector {
+  x: number
+  y: number
+}
+
+export interface Matrix {
+  m00: number
+  m01: number
+  m02: number
+  m10: number
+  m11: number
+  m12: number
+}
+
+export interface Rect {
+  x: number
+  y: number
+  width: number
+  height: number
+}

package/src/undo.ts

@@ -0,0 +1,126 @@
+import type { SceneNode, SceneGraph } from './scene-graph'
+
+export interface UndoEntry {
+  label: string
+  forward: () => void
+  inverse: () => void
+}
+
+export class UndoManager {
+  private undoStack: UndoEntry[] = []
+  private redoStack: UndoEntry[] = []
+  private batchEntries: UndoEntry[] | null = null
+  private batchLabel = ''
+
+  apply(entry: UndoEntry): void {
+    entry.forward()
+    if (this.batchEntries) {
+      this.batchEntries.push(entry)
+    } else {
+      this.undoStack.push(entry)
+      this.redoStack = []
+    }
+  }
+
+  push(entry: UndoEntry): void {
+    if (this.batchEntries) {
+      this.batchEntries.push(entry)
+    } else {
+      this.undoStack.push(entry)
+      this.redoStack = []
+    }
+  }
+
+  undo(): string | null {
+    const entry = this.undoStack.pop()
+    if (!entry) return null
+    entry.inverse()
+    this.redoStack.push(entry)
+    return entry.label
+  }
+
+  redo(): string | null {
+    const entry = this.redoStack.pop()
+    if (!entry) return null
+    entry.forward()
+    this.undoStack.push(entry)
+    return entry.label
+  }
+
+  beginBatch(label: string): void {
+    this.batchLabel = label
+    this.batchEntries = []
+  }
+
+  commitBatch(): void {
+    if (!this.batchEntries || this.batchEntries.length === 0) {
+      this.batchEntries = null
+      return
+    }
+    const entries = this.batchEntries
+    const label = this.batchLabel
+    this.batchEntries = null
+
+    this.undoStack.push({
+      label,
+      forward: () => entries.forEach((e) => e.forward()),
+      inverse: () => [...entries].reverse().forEach((e) => e.inverse())
+    })
+    this.redoStack = []
+  }
+
+  clear(): void {
+    this.undoStack = []
+    this.redoStack = []
+    this.batchEntries = null
+  }
+
+  get canUndo(): boolean {
+    return this.undoStack.length > 0
+  }
+
+  get canRedo(): boolean {
+    return this.redoStack.length > 0
+  }
+
+  get undoLabel(): string | null {
+    return this.undoStack.at(-1)?.label ?? null
+  }
+
+  get redoLabel(): string | null {
+    return this.redoStack.at(-1)?.label ?? null
+  }
+
+  get undoEntries(): ReadonlyArray<{ label: string }> {
+    return this.undoStack.map((e) => ({ label: e.label }))
+  }
+
+  get redoEntries(): ReadonlyArray<{ label: string }> {
+    return this.redoStack.map((e) => ({ label: e.label }))
+  }
+
+  get undoCount(): number {
+    return this.undoStack.length
+  }
+
+  get redoCount(): number {
+    return this.redoStack.length
+  }
+}
+
+export function createPropertyChange(
+  graph: SceneGraph,
+  node: SceneNode,
+  changes: Partial<SceneNode>,
+  label: string
+): UndoEntry {
+  const previous = Object.fromEntries(
+    (Object.keys(changes) as (keyof SceneNode)[]).map((key) => [key, node[key]])
+  ) as Partial<SceneNode>
+
+  return {
+    label,
+    forward: () => graph.updateNode(node.id, changes),
+    inverse: () => graph.updateNode(node.id, previous)
+  }
+}