@rnsk/toolkits 0.0.7 → 0.0.9

package/dist/toolkits/figma/tools/extract-design-tokens.js

@@ -0,0 +1,146 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+function rgbaToHex(color) {
+    const to255 = (v) => Math.round(Number(v ?? 0) * 255);
+    const hex = [to255(color.r), to255(color.g), to255(color.b)].map((v) => v.toString(16).padStart(2, '0')).join('');
+    return `#${hex}`;
+}
+function walk(node, visit) {
+    visit(node);
+    for (const child of (node.children ?? []))
+        walk(child, visit);
+}
+export const extractDesignTokens = tool({
+    description: 'Extracts colors, typography, spacing, radii, and shadows from styles, variables (optional), and node properties. Only style/variable-backed values are captured. Feed output into designTokensToTailwind.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('File key from the file URL'),
+        includeVariables: z.boolean().optional().describe('Include variables (use getLocalVariables for full mode/alias coverage)'),
+        includeLocalStyles: z.boolean().optional().describe('Include local styles (default true)'),
+        extractFromNodes: z.boolean().optional().describe('Extract from node properties (default true)'),
+    }),
+    execute: async ({ figmaToken, fileKey, includeVariables, includeLocalStyles, extractFromNodes }) => {
+        try {
+            const colors = new Map();
+            const typography = new Map();
+            const spacing = new Map();
+            const borderRadius = new Map();
+            const shadows = new Map();
+            const sources = { style: 0, variable: 0, extracted: 0 };
+            const bump = (map, key) => {
+                const entry = map.get(key);
+                if (entry)
+                    entry.usage_count += 1;
+            };
+            if (includeLocalStyles !== false) {
+                const res = await figmaRequest(figmaToken, `/v1/files/${fileKey}/styles`);
+                if (res.ok) {
+                    const styles = (res.data.meta?.styles ?? []);
+                    for (const s of styles) {
+                        sources.style += 1;
+                        const name = String(s.name ?? 'style');
+                        if (s.style_type === 'TEXT') {
+                            typography.set(name, { name, source: 'style', usage_count: 0 });
+                        }
+                        else {
+                            colors.set(name, { name, value: '#000000', source: 'style', usage_count: 0 });
+                        }
+                    }
+                }
+            }
+            if (includeVariables === true) {
+                const res = await figmaRequest(figmaToken, `/v1/files/${fileKey}/variables/local`);
+                if (res.ok) {
+                    const meta = res.data.meta;
+                    for (const v of Object.values(meta?.variables ?? {})) {
+                        sources.variable += 1;
+                        const name = String(v.name ?? 'variable');
+                        if (v.resolvedType === 'COLOR') {
+                            const modes = (v.valuesByMode ?? {});
+                            const first = Object.values(modes)[0];
+                            colors.set(name, { name, value: first && typeof first === 'object' ? rgbaToHex(first) : '#000000', source: 'variable', usage_count: 0 });
+                        }
+                    }
+                }
+            }
+            if (extractFromNodes !== false) {
+                const res = await figmaRequest(figmaToken, `/v1/files/${fileKey}`, { query: { depth: 4 } });
+                if (!res.ok)
+                    return { error: 'Failed to fetch file for token extraction', details: res.error };
+                const doc = res.data.document;
+                if (doc) {
+                    walk(doc, (n) => {
+                        for (const fill of (n.fills ?? [])) {
+                            if (fill.type === 'SOLID' && fill.color && fill.visible !== false) {
+                                const hex = rgbaToHex(fill.color);
+                                const existing = colors.get(hex);
+                                if (existing)
+                                    bump(colors, hex);
+                                else {
+                                    colors.set(hex, { name: hex, value: hex, source: 'extracted', usage_count: 1 });
+                                    sources.extracted += 1;
+                                }
+                            }
+                        }
+                        if (typeof n.cornerRadius === 'number' && n.cornerRadius > 0) {
+                            const key = `radius-${n.cornerRadius}`;
+                            const existing = borderRadius.get(key);
+                            if (existing)
+                                existing.usage_count += 1;
+                            else {
+                                borderRadius.set(key, { name: key, value: n.cornerRadius, source: 'extracted', usage_count: 1 });
+                                sources.extracted += 1;
+                            }
+                        }
+                        const style = n.style;
+                        if (n.type === 'TEXT' && style?.fontFamily) {
+                            const key = `${style.fontFamily}-${style.fontSize ?? ''}-${style.fontWeight ?? ''}`;
+                            const existing = typography.get(key);
+                            if (existing)
+                                existing.usage_count += 1;
+                            else {
+                                typography.set(key, { name: String(style.fontFamily), source: 'extracted', font_size: style.fontSize, font_family: style.fontFamily, font_weight: style.fontWeight, line_height: style.lineHeight, letter_spacing: style.letterSpacing, usage_count: 1 });
+                                sources.extracted += 1;
+                            }
+                        }
+                        for (const effect of (n.effects ?? [])) {
+                            if ((effect.type === 'DROP_SHADOW' || effect.type === 'INNER_SHADOW') && effect.visible !== false) {
+                                const key = `shadow-${effect.offset?.x ?? 0}-${effect.offset?.y ?? 0}-${effect.radius ?? 0}`;
+                                const existing = shadows.get(key);
+                                if (existing)
+                                    existing.usage_count += 1;
+                                else {
+                                    shadows.set(key, { name: key, source: 'extracted', shadows: [{ type: effect.type, color: effect.color, offset: effect.offset, radius: effect.radius, visible: true }], usage_count: 1 });
+                                    sources.extracted += 1;
+                                }
+                            }
+                        }
+                    });
+                }
+            }
+            const colorList = [...colors.values()];
+            const typoList = [...typography.values()];
+            const spacingList = [...spacing.values()];
+            const radiusList = [...borderRadius.values()];
+            const shadowList = [...shadows.values()];
+            return {
+                colors: colorList,
+                typography: typoList,
+                spacing: spacingList,
+                border_radius: radiusList,
+                shadows: shadowList,
+                total_tokens: colorList.length + typoList.length + spacingList.length + radiusList.length + shadowList.length,
+                sources,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error extracting design tokens',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=extract-design-tokens.js.map

package/dist/toolkits/figma/tools/extract-prototype-interactions.d.ts

@@ -0,0 +1,38 @@
+export declare const extractPrototypeInteractions: import("ai").Tool<{
+    figmaToken: string;
+    fileKey: string;
+    analyzeComponents?: boolean | undefined;
+    includeAnimations?: boolean | undefined;
+}, {
+    error: string;
+    details: any;
+    interactions?: undefined;
+    component_states?: undefined;
+    prototype_flows?: undefined;
+    total_interactions?: undefined;
+    animation_types_used?: undefined;
+    message?: undefined;
+} | {
+    interactions: Record<string, unknown>[];
+    component_states: Record<string, unknown>[];
+    prototype_flows: {
+        name: string;
+        starting_node_id: string;
+        nodes_in_flow: string[];
+    }[];
+    total_interactions: number;
+    animation_types_used: string[];
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    interactions?: undefined;
+    component_states?: undefined;
+    prototype_flows?: undefined;
+    total_interactions?: undefined;
+    animation_types_used?: undefined;
+}>;
+//# sourceMappingURL=extract-prototype-interactions.d.ts.map

package/dist/toolkits/figma/tools/extract-prototype-interactions.js

@@ -0,0 +1,80 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+function walk(node, visit) {
+    visit(node);
+    for (const child of (node.children ?? []))
+        walk(child, visit);
+}
+export const extractPrototypeInteractions = tool({
+    description: 'Extracts prototype flows, node interactions (triggers, actions, transitions), and component variant states from a file.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('File key from the file URL'),
+        analyzeComponents: z.boolean().optional().describe('Extract component variant states (default true)'),
+        includeAnimations: z.boolean().optional().describe('Include transition animation data (default true)'),
+    }),
+    execute: async ({ figmaToken, fileKey, analyzeComponents, includeAnimations }) => {
+        try {
+            const withAnims = includeAnimations !== false;
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}`, { query: { depth: 6 } });
+            if (!result.ok)
+                return { error: 'Failed to fetch file for prototype extraction', details: result.error };
+            const data = result.data;
+            const interactions = [];
+            const animationTypes = new Set();
+            if (data.document) {
+                walk(data.document, (n) => {
+                    const nodeInteractions = (n.interactions ?? n.prototypeInteractions);
+                    if (!Array.isArray(nodeInteractions) || nodeInteractions.length === 0)
+                        return;
+                    const actions = nodeInteractions.flatMap((i) => (i.actions ?? []).map((a) => {
+                        const transition = (a.transition ?? a).transition;
+                        const t = (transition ?? a);
+                        if (withAnims && typeof t.type === 'string')
+                            animationTypes.add(t.type);
+                        return {
+                            type: a.type,
+                            navigation: a.navigation,
+                            destination_id: a.destinationId,
+                            url: a.url,
+                            transition: withAnims ? (transition ?? undefined) : undefined,
+                        };
+                    }));
+                    interactions.push({
+                        node_id: n.id,
+                        node_name: n.name,
+                        trigger: nodeInteractions.map((i) => i.trigger),
+                        actions,
+                    });
+                });
+            }
+            const componentStates = [];
+            if (analyzeComponents !== false) {
+                for (const [id, set] of Object.entries(data.componentSets ?? {})) {
+                    componentStates.push({ component_id: id, name: set.name, variants: [], default_variant: undefined });
+                }
+            }
+            const prototypeFlows = (data.prototypeStartingPoints ?? []).map((p) => ({
+                name: p.name ?? '',
+                starting_node_id: p.nodeId ?? '',
+                nodes_in_flow: [],
+            }));
+            return {
+                interactions,
+                component_states: componentStates,
+                prototype_flows: prototypeFlows,
+                total_interactions: interactions.length,
+                animation_types_used: [...animationTypes],
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error extracting prototype interactions',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=extract-prototype-interactions.js.map

package/dist/toolkits/figma/tools/get-a-webhook.d.ts

@@ -0,0 +1,5 @@
+export declare const getAWebhook: import("ai").Tool<{
+    figmaToken: string;
+    webhookId: string;
+}, any>;
+//# sourceMappingURL=get-a-webhook.d.ts.map

package/dist/toolkits/figma/tools/get-a-webhook.js

@@ -0,0 +1,26 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const getAWebhook = tool({
+    description: 'Retrieves a webhook by ID, if it exists and is accessible.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        webhookId: z.string().describe('Webhook ID'),
+    }),
+    execute: async ({ figmaToken, webhookId }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v2/webhooks/${webhookId}`);
+            if (!result.ok)
+                return { error: 'Failed to get webhook', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting webhook',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-a-webhook.js.map

package/dist/toolkits/figma/tools/get-activity-logs.d.ts

@@ -0,0 +1,10 @@
+export declare const getActivityLogs: import("ai").Tool<{
+    figmaToken: string;
+    limit?: number | undefined;
+    order?: "asc" | "desc" | undefined;
+    events?: string | undefined;
+    startTime?: number | undefined;
+    endTime?: number | undefined;
+    cursor?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-activity-logs.d.ts.map

package/dist/toolkits/figma/tools/get-activity-logs.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const getActivityLogs = tool({
+    description: 'Retrieves org activity log events with type, time-range, and pagination filters. Defaults: last year to now, 1000 per page, ascending.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        events: z.string().optional().describe("Comma-separated event types, e.g. 'file_viewed,file_commented'"),
+        startTime: z.number().optional().describe('Unix timestamp lower bound (default one year ago)'),
+        endTime: z.number().optional().describe('Unix timestamp upper bound (default now)'),
+        limit: z.number().optional().describe('Events per page (default 1000)'),
+        order: z.enum(['asc', 'desc']).optional().describe('Sort by timestamp (default asc)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ figmaToken, events, startTime, endTime, limit, order, cursor }) => {
+        try {
+            const result = await figmaRequest(figmaToken, '/v1/activity_logs', {
+                query: { events, start_time: startTime, end_time: endTime, limit, order, cursor },
+            });
+            if (!result.ok)
+                return { error: 'Failed to get activity logs', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting activity logs',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-activity-logs.js.map

package/dist/toolkits/figma/tools/get-comments-in-a-file.d.ts

@@ -0,0 +1,6 @@
+export declare const getCommentsInAFile: import("ai").Tool<{
+    figmaToken: string;
+    fileKey: string;
+    asMd?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=get-comments-in-a-file.d.ts.map

package/dist/toolkits/figma/tools/get-comments-in-a-file.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const getCommentsInAFile = tool({
+    description: 'Retrieves all comments (content, author, position, reactions) from a file or branch. Set asMd for Markdown content.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('File or branch key from the file URL'),
+        asMd: z.boolean().optional().describe('Return content as Markdown (default rich text)'),
+    }),
+    execute: async ({ figmaToken, fileKey, asMd }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/comments`, {
+                query: { as_md: asMd },
+            });
+            if (!result.ok)
+                return { error: 'Failed to get comments', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting comments',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-comments-in-a-file.js.map

package/dist/toolkits/figma/tools/get-component-set.d.ts

@@ -0,0 +1,5 @@
+export declare const getComponentSet: import("ai").Tool<{
+    key: string;
+    figmaToken: string;
+}, any>;
+//# sourceMappingURL=get-component-set.d.ts.map

package/dist/toolkits/figma/tools/get-component-set.js

@@ -0,0 +1,26 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const getComponentSet = tool({
+    description: 'Fetches published component set metadata by set key.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        key: z.string().describe('Unique component set key'),
+    }),
+    execute: async ({ figmaToken, key }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v1/component_sets/${key}`);
+            if (!result.ok)
+                return { error: 'Failed to get component set', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting component set',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-component-set.js.map

package/dist/toolkits/figma/tools/get-component2.d.ts

@@ -0,0 +1,5 @@
+export declare const getComponent2: import("ai").Tool<{
+    key: string;
+    figmaToken: string;
+}, any>;
+//# sourceMappingURL=get-component2.d.ts.map

package/dist/toolkits/figma/tools/get-component2.js

@@ -0,0 +1,26 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const getComponent2 = tool({
+    description: 'Fetches published component metadata by component key. Use for team library components.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        key: z.string().describe('Unique component key'),
+    }),
+    execute: async ({ figmaToken, key }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v1/components/${key}`);
+            if (!result.ok)
+                return { error: 'Failed to get component', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting component',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-component2.js.map

package/dist/toolkits/figma/tools/get-current-user.d.ts

@@ -0,0 +1,4 @@
+export declare const getCurrentUser: import("ai").Tool<{
+    figmaToken: string;
+}, any>;
+//# sourceMappingURL=get-current-user.d.ts.map

package/dist/toolkits/figma/tools/get-current-user.js

@@ -0,0 +1,25 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const getCurrentUser = tool({
+    description: 'Returns the authenticated user (id, handle, avatar, email). No parameters needed.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+    }),
+    execute: async ({ figmaToken }) => {
+        try {
+            const result = await figmaRequest(figmaToken, '/v1/me');
+            if (!result.ok)
+                return { error: 'Failed to get current user', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting current user',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-current-user.js.map

package/dist/toolkits/figma/tools/get-dev-resources.d.ts

@@ -0,0 +1,6 @@
+export declare const getDevResources: import("ai").Tool<{
+    figmaToken: string;
+    fileKey: string;
+    nodeIds?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-dev-resources.d.ts.map

package/dist/toolkits/figma/tools/get-dev-resources.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const getDevResources = tool({
+    description: 'Lists dev resources (Jira/GitHub links) on a main file, optionally filtered to nodes.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('Main file key (not a branch)'),
+        nodeIds: z.string().optional().describe("Comma-separated node IDs, e.g. '1:2,100:54'"),
+    }),
+    execute: async ({ figmaToken, fileKey, nodeIds }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/dev_resources`, {
+                query: { node_ids: nodeIds },
+            });
+            if (!result.ok)
+                return { error: 'Failed to get dev resources', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting dev resources',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-dev-resources.js.map

package/dist/toolkits/figma/tools/get-file-component-sets.d.ts

@@ -0,0 +1,5 @@
+export declare const getFileComponentSets: import("ai").Tool<{
+    figmaToken: string;
+    fileKey: string;
+}, any>;
+//# sourceMappingURL=get-file-component-sets.d.ts.map

package/dist/toolkits/figma/tools/get-file-component-sets.js

@@ -0,0 +1,26 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const getFileComponentSets = tool({
+    description: 'Lists published component sets from a main library file (not a branch).',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('Main file key from the file URL'),
+    }),
+    execute: async ({ figmaToken, fileKey }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/component_sets`);
+            if (!result.ok)
+                return { error: 'Failed to get file component sets', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting file component sets',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-file-component-sets.js.map

package/dist/toolkits/figma/tools/get-file-components.d.ts

@@ -0,0 +1,5 @@
+export declare const getFileComponents: import("ai").Tool<{
+    figmaToken: string;
+    fileKey: string;
+}, any>;
+//# sourceMappingURL=get-file-components.d.ts.map

package/dist/toolkits/figma/tools/get-file-components.js

@@ -0,0 +1,26 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const getFileComponents = tool({
+    description: 'Lists published components from a main library file (not a branch). Empty list means nothing published.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('Main file key from the file URL'),
+    }),
+    execute: async ({ figmaToken, fileKey }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/components`);
+            if (!result.ok)
+                return { error: 'Failed to get file components', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting file components',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-file-components.js.map

package/dist/toolkits/figma/tools/get-file-json.d.ts

@@ -0,0 +1,12 @@
+export declare const getFileJson: import("ai").Tool<{
+    figmaToken: string;
+    fileKey: string;
+    version?: string | undefined;
+    ids?: string | undefined;
+    depth?: number | undefined;
+    geometry?: string | undefined;
+    branchData?: boolean | undefined;
+    pluginData?: string | undefined;
+    responseDetail?: "minimal" | "full" | undefined;
+}, any>;
+//# sourceMappingURL=get-file-json.d.ts.map

package/dist/toolkits/figma/tools/get-file-json.js

@@ -0,0 +1,49 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const getFileJson = tool({
+    description: 'Gets a Design file document tree. Design files only — FigJam/Slides return 400. Use ids for subtrees and depth to bound size; large files without scope can time out.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('File key from figma.com/design/FILE_KEY/... or figma.com/file/FILE_KEY/...'),
+        ids: z.string().optional().describe('Comma-separated node IDs for subtrees (hyphen URL form must be converted to colons, e.g. 1-2 → 1:2)'),
+        depth: z.number().optional().describe('Traversal depth; omit only for small files'),
+        version: z.string().optional().describe('Version ID; omit for current'),
+        geometry: z.string().optional().describe("Set to 'paths' for vector data"),
+        branchData: z.boolean().optional().describe('Include branch metadata'),
+        pluginData: z.string().optional().describe('Comma-separated plugin IDs for plugin data'),
+        responseDetail: z.enum(['minimal', 'full']).optional().describe('Minimal returns raw API JSON (simplification happens client-side)'),
+    }),
+    execute: async ({ figmaToken, fileKey, ids, depth, version, geometry, branchData, pluginData }) => {
+        try {
+            if (ids) {
+                const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/nodes`, {
+                    query: { ids, depth, version, geometry, plugin_data: pluginData },
+                });
+                if (!result.ok)
+                    return { error: 'Failed to get file nodes', details: result.error };
+                return result.data;
+            }
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}`, {
+                query: {
+                    depth,
+                    version,
+                    geometry,
+                    branch_data: branchData,
+                    plugin_data: pluginData,
+                },
+            });
+            if (!result.ok)
+                return { error: 'Failed to get file JSON', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting file JSON',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-file-json.js.map