@sangheepark/figma-ds-mcp 0.1.2 → 0.2.0

package/dist/index.js

@@ -14,6 +14,7 @@ import { registerModeTools } from './tools/mode-tools.js';
 import { registerVariableTools } from './tools/variable-tools.js';
 import { registerStyleTools } from './tools/style-tools.js';
 import { registerDataTools } from './tools/data-tools.js';
+import { registerPipelineTools } from './tools/pipeline-tools.js';
 // Create the WebSocket bridge to Figma
 const bridge = new FigmaBridge();
 // Create MCP server
@@ -28,6 +29,7 @@ registerModeTools(server, bridge);
 registerVariableTools(server, bridge);
 registerStyleTools(server, bridge);
 registerDataTools(server, bridge);
+registerPipelineTools(server);
 // Connect to Claude Code via stdio
 async function main() {
     const transport = new StdioServerTransport();

package/dist/tools/data-tools.js

@@ -1,9 +1,97 @@
 /**
- * Data management tools: fetch_component_sets, export_style_guide, export_icons
+ * Data management tools: search_components, fetch_component_sets, export_style_guide, export_icons
  * Phase 4 — Design system data update automation
  */
 import { z } from 'zod';
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
 export function registerDataTools(server, bridge) {
+    // search_components — Search local component-sets data by name/keyword (no bridge needed)
+    server.tool('search_components', 'Search component sets by name or keyword in local blueprint data. No Figma connection needed. Returns matching components with key, variants, properties, and contains. Use this during code analysis to check if a library component exists before writing specs.', {
+        query: z.string().describe('Component name or keyword to search (case-insensitive partial match)'),
+        library: z.string().optional().describe('Library name (e.g., "chakra-ui", "web-ui"). Omit to search all libraries.'),
+    }, async ({ query, library }) => {
+        try {
+            const dataDir = join(process.cwd(), '.claude', 'blueprint', 'data');
+            let files;
+            if (library) {
+                files = [`${library}-component-sets.json`];
+            }
+            else {
+                files = readdirSync(dataDir).filter(f => f.endsWith('-component-sets.json'));
+            }
+            const results = [];
+            const queryLower = query.toLowerCase();
+            for (const file of files) {
+                const libName = file.replace('-component-sets.json', '');
+                const filePath = join(dataDir, file);
+                const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+                for (const [name, entry] of Object.entries(data)) {
+                    if (name.toLowerCase().includes(queryLower)) {
+                        const e = entry;
+                        const result = {
+                            name,
+                            library: libName,
+                            key: e.key,
+                        };
+                        if (e.variants)
+                            result.variants = e.variants;
+                        if (e.properties)
+                            result.properties = e.properties;
+                        if (e.contains)
+                            result.contains = e.contains;
+                        results.push(result);
+                    }
+                }
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            query,
+                            library: library || 'all',
+                            matchCount: results.length,
+                            results,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: false, error: msg }, null, 2),
+                    }],
+                isError: true,
+            };
+        }
+    });
+    // inspect_component — Inspect a library ComponentSet structure via Plugin API (requires bridge)
+    server.tool('inspect_component', 'Inspect a library ComponentSet by its key. Returns variant axes (names, options, defaults), component properties (text, boolean, instance-swap), variant count, and default variant. Requires the Bridge plugin to be connected. Use this after search_components to understand the exact structure before writing specs.', {
+        key: z.string().describe('The library component key (from search_components or preset data)'),
+    }, async ({ key }) => {
+        try {
+            const result = await bridge.send('bridge-inspect-component', { key });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: false, error: msg }, null, 2),
+                    }],
+                isError: true,
+            };
+        }
+    });
     // fetch_component_sets — Fetch component sets from Figma REST API (server-side, no bridge)
     server.tool('fetch_component_sets', 'Fetch component sets from a Figma library file via REST API. Requires a Figma Personal Access Token (PAT) and file key. Returns component set names, keys, and node IDs.', {
         fileKey: z.string().describe('Figma file key (from URL: figma.com/design/{fileKey}/...)'),
@@ -45,9 +133,11 @@ export function registerDataTools(server, bridge) {
         }
     });
     // export_style_guide — Export styles, variables, and components from the current Figma file
-    server.tool('export_style_guide', 'Export the style guide (variables, styles, components) from the currently open Figma file. Returns both JSON (for import/preset) and Markdown (for AI context). Requires the Bridge plugin to be connected.', {}, async () => {
+    server.tool('export_style_guide', 'Export the style guide (variables, styles, components) from the currently open Figma file. Returns both JSON (for import/preset) and Markdown (for AI context). Requires the Bridge plugin to be connected. Use "section" to export only a specific part (fill-styles, text-styles, effect-styles, variables, components, library-components).', {
+        section: z.enum(['fill-styles', 'text-styles', 'effect-styles', 'variables', 'components', 'library-components']).optional().describe('Optional: export only a specific section of the style guide'),
+    }, async ({ section }) => {
         try {
-            const result = await bridge.send('bridge-export-style-guide', {});
+            const result = await bridge.send('bridge-export-style-guide', { section });
             return {
                 content: [{
                         type: 'text',

package/dist/tools/mode-tools.js

@@ -1,5 +1,5 @@
 /**
- * Mode tools: set_style_mode, load_preset, get_presets
+ * Mode tools: set_style_mode, load_preset, set_active_presets, get_presets
  */
 import { z } from 'zod';
 export function registerModeTools(server, bridge) {
@@ -37,8 +37,9 @@ After setting "library" mode, you should also call load_preset to load a library
         }
     });
     // load_preset — Load a library preset (required for library mode)
-    server.tool('load_preset', `Load a library preset by ID. Use get_presets first to see available presets.
-Loading a preset provides variable names, style names, and library component keys for use in specs.`, {
+    server.tool('load_preset', `Load a single library preset by ID. Use get_presets first to see available presets.
+Loading a preset provides variable names, style names, and library component keys for use in specs.
+WARNING: This replaces any previously active presets. For multi-library projects, use set_active_presets instead.`, {
         presetId: z.string().describe('Preset ID from get_presets list'),
     }, async ({ presetId }) => {
         try {
@@ -68,6 +69,41 @@ Loading a preset provides variable names, style names, and library component key
             };
         }
     });
+    // set_active_presets — Set multiple active presets for multi-library projects
+    server.tool('set_active_presets', `Set multiple library presets as active simultaneously. Use this when a project requires components, styles, or variables from multiple libraries (e.g., text styles from web-ui + components from chakra-ui).
+
+The primary preset takes priority for overlapping keys. Secondary presets fill in missing keys.
+Use get_presets first to see available preset IDs.`, {
+        presetIds: z.array(z.string()).describe('Array of preset IDs to activate'),
+        primaryId: z.string().optional().describe('Primary preset ID (takes priority for overlapping keys). Defaults to first in array.'),
+    }, async ({ presetIds, primaryId }) => {
+        try {
+            const result = await bridge.send('bridge-set-active-presets', {
+                presetIds,
+                primaryId: primaryId || null,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            presets: result.presets || [],
+                            primaryId: result.primaryId || null,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: false, error: msg }, null, 2),
+                    }],
+                isError: true,
+            };
+        }
+    });
     // get_presets — List available library presets
     server.tool('get_presets', 'List all available library presets bundled in the plugin. Returns preset IDs, names, and descriptions.', {}, async () => {
         try {

package/dist/tools/pipeline-tools.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerPipelineTools(server: McpServer): void;

package/dist/tools/pipeline-tools.js

@@ -0,0 +1,430 @@
+/**
+ * Pipeline tools: validate_traversal, enrich_spec, spec_to_tree, gate_check
+ * Phase 2 결정적 파이프라인 도구. Figma 연결 불필요 (순수 JSON 변환).
+ */
+import { z } from 'zod';
+import { writeFileSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+// Layout 허용 key 목록
+// 주의: schema.ts (src/plugin/parser/schema.ts)의 layoutSchema와 동기화 필요.
+// 별도 패키지이므로 import 불가 — schema.ts에 key 추가 시 여기도 수동 업데이트.
+const LAYOUT_KEYS = new Set([
+    'direction', 'gap', 'padding', 'align-items', 'justify-content',
+    'width', 'height', 'positioning', 'x', 'y', 'wrap', 'wrap-gap',
+    'z-order', 'clip-content', 'rotation',
+    'min-width', 'max-width', 'min-height', 'max-height',
+]);
+// emoji 감지 정규식 (surrogate pairs + common symbols)
+const EMOJI_PATTERN = /[\u{1F300}-\u{1F9FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{FE00}-\u{FE0F}\u{200D}\u{20E3}\u{E0020}-\u{E007F}▶♡►◄●○■□★☆♪♫✓✗←→↑↓]/u;
+// CSS font-weight name → number
+const FONT_WEIGHT_MAP = {
+    thin: '100', hairline: '100',
+    extralight: '200', ultralight: '200',
+    light: '300',
+    normal: '400', regular: '400',
+    medium: '500',
+    semibold: '600', demibold: '600',
+    bold: '700',
+    extrabold: '800', ultrabold: '800',
+    black: '900', heavy: '900',
+};
+// --- B2.5: validate_traversal ---
+function validateTraversal(traversal) {
+    const warnings = [];
+    const errors = [];
+    function walk(node, path) {
+        // type 필수
+        if (!node.type) {
+            errors.push(`${path}: missing "type" field`);
+            return;
+        }
+        // instance는 _ds 필수
+        if (node.type === 'instance' && !node._ds) {
+            errors.push(`${path}: instance node missing "_ds" field`);
+        }
+        // instance에 library-key가 직접 포함되면 안 됨
+        if (node['library-key']) {
+            warnings.push(`${path}: "library-key" should not be in traversal output — use "_ds" instead`);
+        }
+        // text 노드 emoji 감지
+        if (node.type === 'text' && node.content && EMOJI_PATTERN.test(node.content)) {
+            warnings.push(`${path}: text content contains emoji pattern "${node.content.slice(0, 20)}" — should this be an instance with _ds?`);
+        }
+        // layout key 검증
+        if (node.layout) {
+            for (const key of Object.keys(node.layout)) {
+                if (!LAYOUT_KEYS.has(key)) {
+                    warnings.push(`${path}: layout contains non-layout key "${key}" — should be in style`);
+                }
+            }
+        }
+        // children 재귀
+        if (node.children) {
+            node.children.forEach((child, i) => {
+                walk(child, `${path}.children[${i}]`);
+            });
+        }
+    }
+    walk(traversal, 'root');
+    return { warnings, errors };
+}
+// --- B3: enrich_spec ---
+function enrichSpec(traversal, mapping) {
+    const errors = [];
+    function deepClone(obj) {
+        return JSON.parse(JSON.stringify(obj));
+    }
+    const spec = deepClone(traversal);
+    function walk(node, path) {
+        // Step 0: 속성 위치 교정 (layout에 있으면 안 되는 key → style로 이동)
+        if (node.layout) {
+            const keysToMove = [];
+            for (const key of Object.keys(node.layout)) {
+                if (!LAYOUT_KEYS.has(key)) {
+                    keysToMove.push(key);
+                }
+            }
+            if (keysToMove.length > 0) {
+                node.style = node.style || {};
+                for (const key of keysToMove) {
+                    node.style[key] = node.layout[key];
+                    delete node.layout[key];
+                }
+            }
+        }
+        // Step 1: _ds → library-key (D9: components에서 통합 검색, 아이콘도 포함)
+        if (node._ds) {
+            const dsName = node._ds;
+            const component = mapping.components?.[dsName];
+            if (component) {
+                node['library-key'] = component['library-key'];
+                // Step 2: _ds_props → variant-props + overrides 분리
+                if (node._ds_props) {
+                    const variantProps = {};
+                    const overrides = {};
+                    for (const [key, value] of Object.entries(node._ds_props)) {
+                        if (component.variants && key in component.variants) {
+                            // variant axis에 해당하는 prop
+                            if (typeof value === 'string' && component.defaults?.[key] !== value) {
+                                variantProps[key] = value;
+                            }
+                        }
+                        else {
+                            // variant가 아닌 prop → overrides (text, boolean, swap)
+                            overrides[key] = value;
+                        }
+                    }
+                    if (Object.keys(variantProps).length > 0) {
+                        node['variant-props'] = variantProps;
+                    }
+                    if (Object.keys(overrides).length > 0) {
+                        node['overrides'] = overrides;
+                    }
+                }
+                // _overrides → overrides에 병합
+                if (node._overrides) {
+                    const existing = node['overrides'];
+                    node['overrides'] = { ...existing, ...node._overrides };
+                    delete node._overrides;
+                }
+                delete node._ds;
+                delete node._ds_props;
+            }
+            else {
+                errors.push(`${path}: _ds "${dsName}" not found in mapping components`);
+            }
+        }
+        // Step 3: 색상 토큰 치환 (style의 HEX → {variable})
+        if (node.style && mapping.tokens) {
+            for (const [key, value] of Object.entries(node.style)) {
+                if (typeof value === 'string' && value.startsWith('#')) {
+                    const token = mapping.tokens[value.toUpperCase()] || mapping.tokens[value];
+                    if (token) {
+                        node.style[key] = token;
+                    }
+                }
+            }
+        }
+        // Step 4: text-style 치환
+        if (node.type === 'text' && node.style && mapping.textStyles) {
+            const fontSize = node.style['font-size'];
+            let fontWeight = node.style['font-weight'];
+            // font-weight: number → string, name → number
+            if (typeof fontWeight === 'number')
+                fontWeight = String(fontWeight);
+            if (typeof fontWeight === 'string') {
+                const normalized = FONT_WEIGHT_MAP[fontWeight.toLowerCase()];
+                if (normalized)
+                    fontWeight = normalized;
+            }
+            if (fontSize && fontWeight) {
+                const key = `${fontSize}/${fontWeight}`;
+                const textStyle = mapping.textStyles[key];
+                if (textStyle) {
+                    node.style['text-style'] = textStyle;
+                    delete node.style['font-size'];
+                    delete node.style['font-weight'];
+                    delete node.style['font-family'];
+                }
+            }
+        }
+        // Step 5: 규칙 적용
+        if (node.style) {
+            // font-weight → string (number→string + name→number)
+            const fw = node.style['font-weight'];
+            if (typeof fw === 'number') {
+                node.style['font-weight'] = String(fw);
+            }
+            else if (typeof fw === 'string') {
+                const normalized = FONT_WEIGHT_MAP[fw.toLowerCase()];
+                if (normalized) {
+                    node.style['font-weight'] = normalized;
+                }
+            }
+            // line-height 정규화: 숫자 배수 → 퍼센트
+            const lh = node.style['line-height'];
+            if (typeof lh === 'number') {
+                node.style['line-height'] = `${Math.round(lh * 100)}%`;
+            }
+        }
+        // children 재귀
+        if (node.children) {
+            node.children.forEach((child, i) => {
+                walk(child, `${path}.children[${i}]`);
+            });
+        }
+    }
+    walk(spec, 'root');
+    return { spec, errors };
+}
+// --- B4: spec_to_tree ---
+function specToTree(node, depth = 0, isLast = true) {
+    const lines = [];
+    // prefix 생성
+    function getPrefix(d, last) {
+        if (d === 0)
+            return '';
+        const parts = [];
+        for (let i = 1; i < d; i++) {
+            parts.push('│   ');
+        }
+        parts.push(last ? '└── ' : '├── ');
+        return parts.join('');
+    }
+    const prefix = getPrefix(depth, isLast);
+    const nodeAny = node;
+    switch (node.type) {
+        case 'frame':
+        case 'component': {
+            const parts = [];
+            if (node.layout?.direction)
+                parts.push(node.layout.direction);
+            if (node.layout?.width)
+                parts.push(`w:${node.layout.width}`);
+            if (node.layout?.height)
+                parts.push(`h:${node.layout.height}`);
+            const layoutStr = parts.length > 0 ? ` (${parts.join(', ')})` : '';
+            lines.push(`${prefix}${node.name || '(unnamed)'}${layoutStr}`);
+            break;
+        }
+        case 'instance': {
+            const key = nodeAny['library-key'];
+            const ds = node._ds;
+            if (key) {
+                const name = node.name || key.slice(0, 8) + '...';
+                lines.push(`${prefix}library: ${name}`);
+            }
+            else if (ds) {
+                lines.push(`${prefix}_ds: ${ds} (미해결)`);
+            }
+            else {
+                lines.push(`${prefix}instance: (unknown)`);
+            }
+            break;
+        }
+        case 'text': {
+            const content = node.content || '';
+            const truncated = content.length > 20 ? content.slice(0, 20) + '...' : content;
+            lines.push(`${prefix}text: "${truncated}"`);
+            break;
+        }
+        default:
+            lines.push(`${prefix}${node.name || node.type}`);
+    }
+    // children 재귀
+    if (node.children) {
+        node.children.forEach((child, i) => {
+            lines.push(specToTree(child, depth + 1, i === node.children.length - 1));
+        });
+    }
+    return lines.join('\n');
+}
+// --- B5: gate_check ---
+function gateCheck(spec) {
+    const results = [];
+    const failures = [];
+    // G1: placeholder 미포함
+    const placeholderIssues = [];
+    function checkPlaceholders(node, path) {
+        // text content에서 placeholder 감지
+        if (node.content) {
+            if (EMOJI_PATTERN.test(node.content)) {
+                placeholderIssues.push(`${path}: emoji in text "${node.content.slice(0, 20)}"`);
+            }
+            if (/TBD|TODO|NOT FOUND|validate first|\?\?/i.test(node.content)) {
+                placeholderIssues.push(`${path}: placeholder text "${node.content.slice(0, 30)}"`);
+            }
+        }
+        // _ds가 남아있으면 미해결
+        if (node._ds) {
+            placeholderIssues.push(`${path}: unresolved _ds "${node._ds}"`);
+        }
+        node.children?.forEach((child, i) => checkPlaceholders(child, `${path}[${i}]`));
+    }
+    checkPlaceholders(spec, 'root');
+    results.push({
+        gate: 'G1: placeholder 미포함',
+        pass: placeholderIssues.length === 0,
+        details: placeholderIssues.length > 0 ? placeholderIssues.join('; ') : undefined,
+    });
+    // G2: library-key 40자 해시
+    const keyIssues = [];
+    function checkKeys(node, path) {
+        const nodeAny = node;
+        if (nodeAny['library-key']) {
+            const key = nodeAny['library-key'];
+            if (!/^[a-f0-9]{40,}$/.test(key)) {
+                keyIssues.push(`${path}: invalid library-key "${key.slice(0, 20)}..."`);
+            }
+        }
+        node.children?.forEach((child, i) => checkKeys(child, `${path}[${i}]`));
+    }
+    checkKeys(spec, 'root');
+    results.push({
+        gate: 'G2: library-key 40자 해시',
+        pass: keyIssues.length === 0,
+        details: keyIssues.length > 0 ? keyIssues.join('; ') : undefined,
+    });
+    // G3: 제거됨 — 단일 Component는 variant 없을 수 있어 코드로 pass/fail 판단 불가.
+    // ComponentSet 여부는 mapping 데이터에 의존하므로 gate_check 단독으로 검증 불가.
+    // enrichment Step 2에서 variant-props 변환 시 mapping.variants 존재 여부로 이미 처리.
+    // G4: 컨테이너에 direction 명시
+    const directionIssues = [];
+    function checkDirection(node, path) {
+        if ((node.type === 'frame' || node.type === 'component') && node.children && node.children.length > 0) {
+            if (!node.layout?.direction) {
+                directionIssues.push(`${path}: "${node.name || '(unnamed)'}" has children but no direction`);
+            }
+        }
+        node.children?.forEach((child, i) => checkDirection(child, `${path}[${i}]`));
+    }
+    checkDirection(spec, 'root');
+    results.push({
+        gate: 'G4: 컨테이너 direction 명시',
+        pass: directionIssues.length === 0,
+        details: directionIssues.length > 0 ? directionIssues.join('; ') : undefined,
+    });
+    // G5: layout warning 체크 (analyzeLayoutWarnings 로직 재사용)
+    const layoutWarnings = [];
+    function checkFillChain(node, ancestors) {
+        for (const axis of ['width', 'height']) {
+            const size = node.layout?.[axis];
+            if (size === 'fill') {
+                for (const ancestor of ancestors) {
+                    const ancestorSize = ancestor.layout?.[axis];
+                    if (!ancestorSize || ancestorSize === 'hug') {
+                        layoutWarnings.push(`"${node.name || '(unnamed)'}": ${axis}=fill but ancestor "${ancestor.name || '(unnamed)'}" has no explicit ${axis}`);
+                        break;
+                    }
+                }
+            }
+        }
+        node.children?.forEach(child => checkFillChain(child, [...ancestors, node]));
+    }
+    checkFillChain(spec, []);
+    results.push({
+        gate: 'G5: layout warning 0건',
+        pass: layoutWarnings.length === 0,
+        details: layoutWarnings.length > 0 ? layoutWarnings.join('; ') : undefined,
+    });
+    const pass = results.every(r => r.pass);
+    return { pass, results };
+}
+// --- Tool Registration ---
+export function registerPipelineTools(server) {
+    // validate_traversal — B2.5
+    server.tool('validate_traversal', 'Validate traversal JSON output structure. Checks: type field presence, _ds on instances, emoji in text, layout key validation. Run after code-traversal, before enrich_spec.', {
+        traversal: z.record(z.unknown()).describe('Traversal JSON root node'),
+    }, async ({ traversal }) => {
+        const result = validateTraversal(traversal);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        valid: result.errors.length === 0,
+                        errors: result.errors,
+                        warnings: result.warnings,
+                    }, null, 2),
+                }],
+        };
+    });
+    // enrich_spec — B3
+    server.tool('enrich_spec', `Enrich traversal JSON with mapping data to produce a build-ready spec.
+6 steps: (0) layout→style key correction, (1) _ds→library-key, (2) _ds_props→variant-props+overrides, (3) HEX→token, (4) text-style, (5) format rules.
+Run after validate_traversal. If outputPath is provided, spec is saved to file and not included in response (saves context).`, {
+        traversal: z.record(z.unknown()).describe('Validated traversal JSON root node'),
+        mapping: z.record(z.unknown()).describe('mapping.json data (components, tokens, textStyles)'),
+        outputPath: z.string().optional().describe('File path to save spec.json. If provided, spec is not returned in response.'),
+    }, async ({ traversal, mapping, outputPath }) => {
+        const result = enrichSpec(traversal, mapping);
+        if (outputPath && result.errors.length === 0) {
+            mkdirSync(dirname(outputPath), { recursive: true });
+            writeFileSync(outputPath, JSON.stringify(result.spec, null, 2));
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            savedTo: outputPath,
+                            errors: [],
+                        }, null, 2),
+                    }],
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: result.errors.length === 0,
+                        spec: result.spec,
+                        errors: result.errors,
+                    }, null, 2),
+                }],
+        };
+    });
+    // spec_to_tree — B4
+    server.tool('spec_to_tree', 'Convert a spec JSON to ASCII tree view for human review. Frames show layout, instances show component names, text shows content.', {
+        spec: z.record(z.unknown()).describe('Spec JSON root node'),
+    }, async ({ spec }) => {
+        const tree = specToTree(spec);
+        return {
+            content: [{
+                    type: 'text',
+                    text: tree,
+                }],
+        };
+    });
+    // gate_check — B5
+    server.tool('gate_check', `Run Gate checks on a spec before building. Checks: G1(no placeholders/emoji), G2(library-key 40-char hex), G4(container direction), G5(layout warnings). Returns pass/fail with details.`, {
+        spec: z.record(z.unknown()).describe('Spec JSON root node to validate'),
+    }, async ({ spec }) => {
+        const result = gateCheck(spec);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                }],
+        };
+    });
+}
+//# sourceMappingURL=pipeline-tools.js.map

package/dist/tools/spec-tools.js

@@ -35,7 +35,8 @@ const styleSchema = z.object({
     opacity: z.number().optional(),
     'font-family': z.string().optional(),
     'font-size': z.string().optional(),
-    'font-weight': z.string().optional(),
+    'font-weight': z.union([z.string(), z.number()]).optional()
+        .transform(v => v != null && typeof v === 'number' ? String(v) : v),
     color: z.string().optional(),
     'text-align': z.enum(['left', 'center', 'right', 'justify']).optional(),
     'line-height': z.string().optional(),

package/dist/tools/utility-tools.js

@@ -79,7 +79,7 @@ export function registerUtilityTools(server, bridge) {
         try {
             // Pre-create layout analysis (runs locally, no Figma needed)
             const layoutWarnings = analyzeLayoutWarnings(spec);
-            // Plugin-side validation (semantic: styles, variables, library-keys)
+            // Plugin-side validation (structure only — zod schema)
             const result = await bridge.send('bridge-validate-spec', { spec });
             const response = {
                 valid: true,
@@ -89,9 +89,6 @@ export function registerUtilityTools(server, bridge) {
             if (layoutWarnings.length > 0) {
                 response.layoutWarnings = layoutWarnings;
             }
-            if (result.semanticWarnings && result.semanticWarnings.length > 0) {
-                response.semanticWarnings = result.semanticWarnings;
-            }
             return {
                 content: [{
                         type: 'text',
@@ -137,6 +134,33 @@ export function registerUtilityTools(server, bridge) {
             };
         }
     });
+    // diagnose_variables — Diagnose variable import capability
+    server.tool('diagnose_variables', 'Diagnose variable import capability in the current Figma file. Tests: local variables, teamLibrary access, library variable collections, and optionally imports a single variable by key to test.', {
+        variableKey: z.string().optional().describe('Optional: a specific variable key to test importing'),
+    }, async ({ variableKey }) => {
+        try {
+            const params = {};
+            if (variableKey)
+                params.variableKey = variableKey;
+            const result = await bridge.send('bridge-diagnose-variables', params);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: false, error: msg }, null, 2),
+                    }],
+                isError: true,
+            };
+        }
+    });
     // generate_from_yaml — Legacy YAML passthrough for compatibility
     server.tool('generate_from_yaml', 'Generate Figma components from YAML text (legacy passthrough). Prefer using create_from_spec with JSON instead.', {
         yaml: z.string().describe('YAML spec text'),

package/dist/ws-bridge.js

@@ -3,7 +3,7 @@
  * Provides request/response correlation via requestId.
  */
 import { WebSocketServer, WebSocket } from 'ws';
-const WS_PORT = 3055;
+const WS_PORT = parseInt(process.env.FIGMA_DS_PORT || '3055', 10);
 const REQUEST_TIMEOUT = 180_000; // 180 seconds (font/library loading can be very slow)
 export class FigmaBridge {
     wss;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sangheepark/figma-ds-mcp",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "MCP server for Code to Figma Bridge — bridges Claude Code to Figma plugin via WebSocket",
   "type": "module",
   "main": "dist/index.js",
@@ -14,7 +14,7 @@
   ],
   "scripts": {
     "build": "tsc",
-    "prepublishOnly": "tsc",
+    "prepublishOnly": "tsc && chmod +x dist/index.js",
     "start": "node dist/index.js",
     "dev": "tsc && node dist/index.js"
   },