@rnsk/toolkits 0.0.6 → 0.0.8

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

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

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

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

@@ -0,0 +1,26 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const getFileMetadata = tool({
+    description: 'Gets file overview (name, creator, last-modified, thumbnail, access) without the document tree.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('File or branch key from the file URL'),
+    }),
+    execute: async ({ figmaToken, fileKey }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/meta`);
+            if (!result.ok)
+                return { error: 'Failed to get file metadata', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting file metadata',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-file-metadata.js.map

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

@@ -0,0 +1,10 @@
+export declare const getFileNodes: import("ai").Tool<{
+    figmaToken: string;
+    fileKey: string;
+    ids: string | string[];
+    version?: string | undefined;
+    depth?: number | undefined;
+    geometry?: string | undefined;
+    pluginData?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-file-nodes.d.ts.map

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

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const getFileNodes = tool({
+    description: 'Fetches JSON for known node IDs without full-file payloads. Use after shallow fetches or component listings; prefer depth=1 for discovery.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('File or branch key from the file URL'),
+        ids: z.union([z.string(), z.array(z.string())]).describe("Node IDs as '1:5,1:6' or ['1:5','1:6']"),
+        depth: z.number().optional().describe('Subtree depth; depth=1 for fast discovery'),
+        version: z.string().optional().describe('Version ID; omit for current'),
+        geometry: z.string().optional().describe("Set to 'paths' for vector data"),
+        pluginData: z.string().optional().describe("Plugin IDs or 'shared' for plugin data"),
+    }),
+    execute: async ({ figmaToken, fileKey, ids, depth, version, geometry, pluginData }) => {
+        try {
+            const idsParam = Array.isArray(ids) ? ids.join(',') : ids;
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/nodes`, {
+                query: { ids: idsParam, depth, version, geometry, plugin_data: pluginData },
+            });
+            if (!result.ok)
+                return { error: 'Failed to get file nodes', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting file nodes',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-file-nodes.js.map

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

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

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

@@ -0,0 +1,26 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const getFileStyles = tool({
+    description: 'Lists published styles (fills, text, effects, grids) from a main library file. For local/unpublished styles use getFileJson instead.',
+    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}/styles`);
+            if (!result.ok)
+                return { error: 'Failed to get file styles', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting file styles',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-file-styles.js.map

package/dist/toolkits/figma/tools/get-files-in-a-project.d.ts

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

package/dist/toolkits/figma/tools/get-files-in-a-project.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const getFilesInAProject = tool({
+    description: 'Lists files in a project, optionally with branch metadata. Get project_id from the team projects list.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        projectId: z.string().describe('Project ID'),
+        branchData: z.boolean().optional().describe('Include branch metadata (default false)'),
+    }),
+    execute: async ({ figmaToken, projectId, branchData }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v1/projects/${projectId}/files`, {
+                query: { branch_data: branchData },
+            });
+            if (!result.ok)
+                return { error: 'Failed to get project files', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting project files',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-files-in-a-project.js.map

package/dist/toolkits/figma/tools/get-image-fills.d.ts

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