@rnsk/toolkits 0.0.6 → 0.0.8

package/dist/toolkits/figma/tools/client.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { z } from 'zod';
+export const FIGMA_API_BASE = 'https://api.figma.com';
+export const FIGMA_SCIM_BASE = 'https://www.figma.com/scim/v2';
+export const figmaTokenField = z.string().describe('Figma OAuth access token (sent as Bearer)');
+export function buildQuery(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined)
+            search.set(key, String(value));
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : '';
+}
+export async function figmaRequest(figmaToken, path, options) {
+    const base = options?.base ?? FIGMA_API_BASE;
+    const url = `${base}${path}${buildQuery(options?.query ?? {})}`;
+    const response = await fetch(url, {
+        method: options?.method ?? 'GET',
+        headers: {
+            Authorization: `Bearer ${figmaToken}`,
+            ...(options?.body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+        },
+        body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+    });
+    if (!response.ok) {
+        const details = await response.json().catch(() => ({}));
+        return { ok: false, error: details };
+    }
+    if (response.status === 204) {
+        return { ok: true, data: { success: true } };
+    }
+    const data = await response.json().catch(() => ({}));
+    return { ok: true, data };
+}
+//# sourceMappingURL=client.js.map

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

@@ -0,0 +1,12 @@
+export declare const createAWebhook: import("ai").Tool<{
+    eventType: "FILE_COMMENT" | "FILE_DELETE" | "FILE_UPDATE" | "FILE_VERSION_UPDATE" | "LIBRARY_PUBLISH";
+    endpoint: string;
+    figmaToken: string;
+    passcode: string;
+    status?: "ACTIVE" | "PAUSED" | undefined;
+    description?: string | undefined;
+    teamId?: string | undefined;
+    context?: "team" | "file" | "project" | undefined;
+    contextId?: string | undefined;
+}, any>;
+//# sourceMappingURL=create-a-webhook.d.ts.map

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

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+const eventType = z.enum(['FILE_COMMENT', 'FILE_DELETE', 'FILE_UPDATE', 'FILE_VERSION_UPDATE', 'LIBRARY_PUBLISH']);
+export const createAWebhook = tool({
+    description: 'Creates a team/project/file webhook. Figma PINGs the endpoint on creation unless PAUSED. Extract team/project/file IDs from Figma URLs or discoverFigmaResources.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        eventType: eventType.describe('Event that triggers the webhook'),
+        endpoint: z.string().describe('Public HTTPS URL receiving Figma POSTs (max 2048 chars)'),
+        passcode: z.string().describe('Secret for verifying Figma requests (max 100 chars)'),
+        context: z.enum(['team', 'project', 'file']).optional().describe('Scope; use with contextId'),
+        contextId: z.string().optional().describe('Team, project, or file ID to monitor'),
+        teamId: z.string().optional().describe('DEPRECATED: use context=team with contextId'),
+        status: z.enum(['ACTIVE', 'PAUSED']).optional().describe('Initial status (default ACTIVE)'),
+        description: z.string().optional().describe('Human-readable purpose (max 150 chars)'),
+    }),
+    execute: async ({ figmaToken, eventType, endpoint, passcode, context, contextId, teamId, status, description }) => {
+        try {
+            const body = { event_type: eventType, endpoint, passcode };
+            if (context)
+                body.context = context;
+            if (contextId)
+                body.context_id = contextId;
+            if (teamId)
+                body.team_id = teamId;
+            if (status)
+                body.status = status;
+            if (description)
+                body.description = description;
+            const result = await figmaRequest(figmaToken, '/v2/webhooks', { method: 'POST', body });
+            if (!result.ok)
+                return { error: 'Failed to create webhook', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error creating webhook',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-a-webhook.js.map

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

@@ -0,0 +1,28 @@
+export declare const createDevResources: import("ai").Tool<{
+    figmaToken: string;
+    devResources: {
+        url: string;
+        name: string;
+        fileKey: string;
+        nodeId: string;
+    }[];
+}, {
+    error: string;
+    details: unknown[];
+    links_created?: undefined;
+    errors?: undefined;
+    message?: undefined;
+} | {
+    links_created: unknown[];
+    errors: unknown[];
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    links_created?: undefined;
+    errors?: undefined;
+}>;
+//# sourceMappingURL=create-dev-resources.d.ts.map

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

@@ -0,0 +1,53 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const createDevResources = tool({
+    description: 'Attaches uniquely-URLed dev resources (Jira, GitHub, docs) to file nodes, up to 10 per node. Grouped per file automatically.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        devResources: z.array(z.object({
+            name: z.string().describe('Visible name in Figma'),
+            url: z.string().describe('Resource URL'),
+            fileKey: z.string().describe('File key for attachment'),
+            nodeId: z.string().describe("Node ID for attachment, e.g. '123:456'"),
+        })).min(1).describe('Dev resources to create'),
+    }),
+    execute: async ({ figmaToken, devResources }) => {
+        try {
+            const byFile = new Map();
+            for (const r of devResources) {
+                const list = byFile.get(r.fileKey) ?? [];
+                list.push({ name: r.name, url: r.url, file_key: r.fileKey, node_id: r.nodeId });
+                byFile.set(r.fileKey, list);
+            }
+            const linksCreated = [];
+            const errors = [];
+            for (const [fileKey, items] of byFile) {
+                const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/dev_resources`, {
+                    method: 'POST',
+                    body: { dev_resources: items },
+                });
+                if (!result.ok) {
+                    errors.push({ fileKey, error: result.error });
+                    continue;
+                }
+                const data = result.data;
+                linksCreated.push(...(data.links_created ?? []));
+                if (data.errors)
+                    errors.push(...data.errors);
+            }
+            if (linksCreated.length === 0 && errors.length > 0) {
+                return { error: 'Failed to create dev resources', details: errors };
+            }
+            return { links_created: linksCreated, errors };
+        }
+        catch (error) {
+            return {
+                error: 'Error creating dev resources',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-dev-resources.js.map

package/dist/toolkits/figma/tools/create-modify-delete-variables.d.ts

@@ -0,0 +1,9 @@
+export declare const createModifyDeleteVariables: import("ai").Tool<{
+    figmaToken: string;
+    fileKey: string;
+    variableCollections?: Record<string, any>[] | undefined;
+    variableModes?: Record<string, any>[] | undefined;
+    variables?: Record<string, any>[] | undefined;
+    variableModeValues?: Record<string, any>[] | undefined;
+}, any>;
+//# sourceMappingURL=create-modify-delete-variables.d.ts.map

package/dist/toolkits/figma/tools/create-modify-delete-variables.js

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+const changeSchema = z.record(z.any()).describe('Mutation object with action CREATE/UPDATE/DELETE plus relevant fields');
+export const createModifyDeleteVariables = tool({
+    description: 'Batch creates, updates, or deletes variable collections, modes, variables, and mode values. Use temp IDs to link new items in one request; values must match resolvedType.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('File or branch key to modify variables in'),
+        variableCollections: z.array(changeSchema).optional().describe('Collection mutations'),
+        variableModes: z.array(changeSchema).optional().describe('Mode mutations (max 40 per collection)'),
+        variables: z.array(changeSchema).optional().describe('Variable mutations (max 5000 per collection)'),
+        variableModeValues: z.array(changeSchema).optional().describe('Value assignments {variableId, modeId, value}'),
+    }),
+    execute: async ({ figmaToken, fileKey, variableCollections, variableModes, variables, variableModeValues }) => {
+        try {
+            const body = {};
+            if (variableCollections)
+                body.variableCollections = variableCollections;
+            if (variableModes)
+                body.variableModes = variableModes;
+            if (variables)
+                body.variables = variables;
+            if (variableModeValues)
+                body.variableModeValues = variableModeValues;
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/variables`, {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to mutate variables', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error mutating variables',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-modify-delete-variables.js.map

package/dist/toolkits/figma/tools/delete-a-comment.d.ts

@@ -0,0 +1,6 @@
+export declare const deleteAComment: import("ai").Tool<{
+    commentId: string;
+    figmaToken: string;
+    fileKey: string;
+}, any>;
+//# sourceMappingURL=delete-a-comment.d.ts.map

package/dist/toolkits/figma/tools/delete-a-comment.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const deleteAComment = tool({
+    description: 'Deletes a comment from a file or branch. Only the original author can delete it.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('File or branch key from the file URL'),
+        commentId: z.string().describe('Comment ID (from listing or creation response)'),
+    }),
+    execute: async ({ figmaToken, fileKey, commentId }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/comments/${commentId}`, {
+                method: 'DELETE',
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete comment', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting comment',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-a-comment.js.map

package/dist/toolkits/figma/tools/delete-a-reaction.d.ts

@@ -0,0 +1,7 @@
+export declare const deleteAReaction: import("ai").Tool<{
+    emoji: string;
+    commentId: string;
+    figmaToken: string;
+    fileKey: string;
+}, any>;
+//# sourceMappingURL=delete-a-reaction.d.ts.map

package/dist/toolkits/figma/tools/delete-a-reaction.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const deleteAReaction = tool({
+    description: 'Removes your emoji reaction from a comment. You must have created the reaction; the emoji must match exactly.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('File or branch key from the file URL'),
+        commentId: z.string().describe('Comment ID to remove the reaction from'),
+        emoji: z.string().describe('Exact emoji character of your existing reaction, e.g. ❤️'),
+    }),
+    execute: async ({ figmaToken, fileKey, commentId, emoji }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/comments/${commentId}/reactions`, {
+                method: 'DELETE',
+                query: { emoji },
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete reaction', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting reaction',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-a-reaction.js.map

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

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

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

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const deleteAWebhook = tool({
+    description: 'Permanently and irreversibly deletes a webhook by ID.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        webhookId: z.string().describe('Webhook ID to delete'),
+    }),
+    execute: async ({ figmaToken, webhookId }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v2/webhooks/${webhookId}`, {
+                method: 'DELETE',
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete webhook', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting webhook',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-a-webhook.js.map

package/dist/toolkits/figma/tools/delete-dev-resource.d.ts

@@ -0,0 +1,6 @@
+export declare const deleteDevResource: import("ai").Tool<{
+    figmaToken: string;
+    fileKey: string;
+    devResourceId: string;
+}, any>;
+//# sourceMappingURL=delete-dev-resource.d.ts.map

package/dist/toolkits/figma/tools/delete-dev-resource.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const deleteDevResource = tool({
+    description: 'Deletes a dev resource from a main file (not a branch).',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('Main file key'),
+        devResourceId: z.string().describe('Dev resource ID to delete'),
+    }),
+    execute: async ({ figmaToken, fileKey, devResourceId }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/dev_resources/${devResourceId}`, {
+                method: 'DELETE',
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete dev resource', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting dev resource',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-dev-resource.js.map

package/dist/toolkits/figma/tools/design-tokens-to-tailwind.d.ts

@@ -0,0 +1,26 @@
+export declare const designTokensToTailwind: import("ai").Tool<{
+    tokens: Record<string, any>;
+    prefix?: string | undefined;
+    configFormat?: string | undefined;
+    includeFontImports?: boolean | undefined;
+}, {
+    config_content: string;
+    globals_css: string | undefined;
+    token_summary: {
+        colors: number;
+        fontFamilies: number;
+        spacing: number;
+        borderRadius: number;
+        boxShadow: number;
+        total: number;
+    };
+    error?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    config_content?: undefined;
+    globals_css?: undefined;
+    token_summary?: undefined;
+}>;
+//# sourceMappingURL=design-tokens-to-tailwind.d.ts.map

package/dist/toolkits/figma/tools/design-tokens-to-tailwind.js

@@ -0,0 +1,119 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+function sanitizeName(name, prefix) {
+    return `${prefix}${name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-')}`.replace(/^-+|-+$/g, '') || `${prefix}token`;
+}
+function rgbaToCss(color) {
+    if (typeof color === 'string')
+        return color;
+    const c = (color ?? {});
+    const to255 = (v) => Math.round((v ?? 0) * 255);
+    const a = c.a ?? 1;
+    if (a >= 1) {
+        const hex = [to255(c.r), to255(c.g), to255(c.b)].map((v) => v.toString(16).padStart(2, '0')).join('');
+        return `#${hex}`;
+    }
+    return `rgba(${to255(c.r)}, ${to255(c.g)}, ${to255(c.b)}, ${a})`;
+}
+function shadowToCss(shadow) {
+    const color = rgbaToCss(shadow.color);
+    const offset = (shadow.offset ?? {});
+    const x = offset.x ?? shadow.x ?? 0;
+    const y = offset.y ?? shadow.y ?? 0;
+    const blur = (shadow.radius ?? shadow.blur ?? 0);
+    const inset = shadow.type === 'INNER_SHADOW' ? 'inset ' : '';
+    return `${inset}${x}px ${y}px ${blur}px ${color}`;
+}
+export const designTokensToTailwind = tool({
+    description: 'Converts extracted design tokens (from extractDesignTokens) into a tailwind.config (ts/js) with theme extensions plus optional globals.css font imports. Pure computation — no auth needed.',
+    inputSchema: z.object({
+        tokens: z.record(z.any()).describe('DesignTokens object from extractDesignTokens'),
+        prefix: z.string().optional().describe("Prefix for token names, e.g. 'brand-'"),
+        configFormat: z.string().optional().describe("Output format 'ts' (default) or 'js'"),
+        includeFontImports: z.boolean().optional().describe('Add Google Fonts @imports (default true)'),
+    }),
+    execute: async ({ tokens, prefix, configFormat, includeFontImports }) => {
+        try {
+            const p = prefix ?? '';
+            const format = configFormat === 'js' ? 'js' : 'ts';
+            const withFonts = includeFontImports !== false;
+            const colors = {};
+            for (const c of (tokens.colors ?? [])) {
+                colors[sanitizeName(String(c.name ?? 'color'), p)] = rgbaToCss(c.value);
+                if (typeof c.opacity === 'number' && c.opacity < 1 && typeof c.value === 'string') {
+                    colors[sanitizeName(String(c.name ?? 'color'), p)] = c.value;
+                }
+            }
+            const fontFamily = {};
+            const fontSize = {};
+            const fontWeight = {};
+            const lineHeight = {};
+            const letterSpacing = {};
+            const googleFonts = new Set();
+            for (const t of (tokens.typography ?? [])) {
+                const base = sanitizeName(String(t.name ?? 'text'), p);
+                if (t.font_family) {
+                    const family = String(t.font_family);
+                    fontFamily[base] = [family, 'sans-serif'];
+                    googleFonts.add(family);
+                }
+                if (typeof t.font_size === 'number')
+                    fontSize[base] = `${t.font_size}px`;
+                if (typeof t.font_weight === 'number')
+                    fontWeight[base] = t.font_weight;
+                if (typeof t.line_height === 'number')
+                    lineHeight[base] = `${t.line_height}px`;
+                if (typeof t.letter_spacing === 'number')
+                    letterSpacing[base] = `${t.letter_spacing}px`;
+            }
+            const spacing = {};
+            for (const s of (tokens.spacing ?? [])) {
+                if (typeof s.value === 'number')
+                    spacing[sanitizeName(String(s.name ?? 'space'), p)] = `${s.value}px`;
+            }
+            const borderRadius = {};
+            for (const b of (tokens.border_radius ?? [])) {
+                const v = b.value;
+                borderRadius[sanitizeName(String(b.name ?? 'radius'), p)] =
+                    typeof v === 'number' ? `${v}px` : JSON.stringify(v);
+            }
+            const boxShadow = {};
+            for (const s of (tokens.shadows ?? [])) {
+                const parts = (s.shadows ?? []).map(shadowToCss);
+                if (parts.length > 0)
+                    boxShadow[sanitizeName(String(s.name ?? 'shadow'), p)] = parts.join(', ');
+            }
+            const theme = { colors, fontFamily, fontSize, fontWeight, lineHeight, letterSpacing, spacing, borderRadius, boxShadow };
+            const exportKw = format === 'ts' ? 'export default' : 'module.exports =';
+            const typeAnn = format === 'ts' ? ': import("tailwindcss").Config' : '';
+            const configContent = `${exportKw} {\n  theme: {\n    extend: ${JSON.stringify(theme, null, 2)}\n  }\n}${typeAnn};\n`;
+            let globalsCss;
+            if (withFonts && googleFonts.size > 0) {
+                globalsCss = [...googleFonts]
+                    .map((f) => `@import url('https://fonts.googleapis.com/css2?family=${f.replace(/\s+/g, '+')}:wght@400;500;600;700&display=swap');`)
+                    .join('\n');
+            }
+            const tokenSummary = {
+                colors: Object.keys(colors).length,
+                fontFamilies: Object.keys(fontFamily).length,
+                spacing: Object.keys(spacing).length,
+                borderRadius: Object.keys(borderRadius).length,
+                boxShadow: Object.keys(boxShadow).length,
+                total: Object.keys(colors).length +
+                    Object.keys(fontFamily).length +
+                    Object.keys(spacing).length +
+                    Object.keys(borderRadius).length +
+                    Object.keys(boxShadow).length,
+            };
+            return { config_content: configContent, globals_css: globalsCss, token_summary: tokenSummary };
+        }
+        catch (error) {
+            return {
+                error: 'Error converting tokens to Tailwind',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=design-tokens-to-tailwind.js.map

package/dist/toolkits/figma/tools/detect-background.d.ts

@@ -0,0 +1,27 @@
+export declare const detectBackground: import("ai").Tool<{
+    figmaToken: string;
+    fileKey: string;
+    targetNodeIds: string[];
+    searchDepth?: number | undefined;
+}, {
+    error: string;
+    details: any;
+    backgrounds?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details?: undefined;
+    backgrounds?: undefined;
+    message?: undefined;
+} | {
+    backgrounds: Record<string, Record<string, unknown>[]>;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    backgrounds?: undefined;
+}>;
+//# sourceMappingURL=detect-background.d.ts.map