@rnsk/toolkits 0.0.7 → 0.0.9

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

@@ -0,0 +1,110 @@
+// @ts-nocheck
+import { addCommentToAFile } from './add-comment-to-a-file.js';
+import { addReactionToAComment } from './add-reaction-to-a-comment.js';
+import { createAWebhook } from './create-a-webhook.js';
+import { createDevResources } from './create-dev-resources.js';
+import { createModifyDeleteVariables } from './create-modify-delete-variables.js';
+import { deleteAComment } from './delete-a-comment.js';
+import { deleteAReaction } from './delete-a-reaction.js';
+import { deleteAWebhook } from './delete-a-webhook.js';
+import { deleteDevResource } from './delete-dev-resource.js';
+import { designTokensToTailwind } from './design-tokens-to-tailwind.js';
+import { detectBackground } from './detect-background.js';
+import { discoverFigmaResources } from './discover-figma-resources.js';
+import { downloadFigmaImages } from './download-figma-images.js';
+import { extractDesignTokens } from './extract-design-tokens.js';
+import { extractPrototypeInteractions } from './extract-prototype-interactions.js';
+import { getActivityLogs } from './get-activity-logs.js';
+import { getAWebhook } from './get-a-webhook.js';
+import { getCommentsInAFile } from './get-comments-in-a-file.js';
+import { getComponent2 } from './get-component2.js';
+import { getComponentSet } from './get-component-set.js';
+import { getCurrentUser } from './get-current-user.js';
+import { getDevResources } from './get-dev-resources.js';
+import { getFileComponentSets } from './get-file-component-sets.js';
+import { getFileComponents } from './get-file-components.js';
+import { getFileJson } from './get-file-json.js';
+import { getFileMetadata } from './get-file-metadata.js';
+import { getFileNodes } from './get-file-nodes.js';
+import { getFileStyles } from './get-file-styles.js';
+import { getFilesInAProject } from './get-files-in-a-project.js';
+import { getImageFills } from './get-image-fills.js';
+import { getLibraryAnalyticsComponentActionData } from './get-library-analytics-component-action-data.js';
+import { getLibraryAnalyticsComponentUsageData } from './get-library-analytics-component-usage-data.js';
+import { getLibraryAnalyticsStyleActionData } from './get-library-analytics-style-action-data.js';
+import { getLibraryAnalyticsStyleUsageData } from './get-library-analytics-style-usage-data.js';
+import { getLibraryAnalyticsVariableActionData } from './get-library-analytics-variable-action-data.js';
+import { getLibraryAnalyticsVariableUsageData } from './get-library-analytics-variable-usage-data.js';
+import { getLocalVariables } from './get-local-variables.js';
+import { getPayments } from './get-payments.js';
+import { getProjectsInATeam } from './get-projects-in-a-team.js';
+import { getPublishedVariables } from './get-published-variables.js';
+import { getReactionsForAComment } from './get-reactions-for-a-comment.js';
+import { getScimServiceProviderConfig } from './get-scim-service-provider-config.js';
+import { getStyle } from './get-style.js';
+import { getTeamComponentSets } from './get-team-component-sets.js';
+import { getTeamComponents } from './get-team-components.js';
+import { getTeamStyles } from './get-team-styles.js';
+import { getTeamWebhooks } from './get-team-webhooks.js';
+import { getVersionsOfAFile } from './get-versions-of-a-file.js';
+import { getWebhookRequests } from './get-webhook-requests.js';
+import { renderImagesOfFileNodes } from './render-images-of-file-nodes.js';
+import { updateAWebhook } from './update-a-webhook.js';
+import { updateDevResources } from './update-dev-resources.js';
+export { addCommentToAFile, addReactionToAComment, createAWebhook, createDevResources, createModifyDeleteVariables, deleteAComment, deleteAReaction, deleteAWebhook, deleteDevResource, designTokensToTailwind, detectBackground, discoverFigmaResources, downloadFigmaImages, extractDesignTokens, extractPrototypeInteractions, getActivityLogs, getAWebhook, getCommentsInAFile, getComponent2, getComponentSet, getCurrentUser, getDevResources, getFileComponentSets, getFileComponents, getFileJson, getFileMetadata, getFileNodes, getFileStyles, getFilesInAProject, getImageFills, getLibraryAnalyticsComponentActionData, getLibraryAnalyticsComponentUsageData, getLibraryAnalyticsStyleActionData, getLibraryAnalyticsStyleUsageData, getLibraryAnalyticsVariableActionData, getLibraryAnalyticsVariableUsageData, getLocalVariables, getPayments, getProjectsInATeam, getPublishedVariables, getReactionsForAComment, getScimServiceProviderConfig, getStyle, getTeamComponentSets, getTeamComponents, getTeamStyles, getTeamWebhooks, getVersionsOfAFile, getWebhookRequests, renderImagesOfFileNodes, updateAWebhook, updateDevResources, };
+const auth = 'figmaToken';
+export const figmaTools = [
+    { name: 'figmaAddCommentToAFile', description: 'Posts a comment to a file or branch, optionally replying to a root comment.', tool: addCommentToAFile, requiredAuth: auth, scope: 'write' },
+    { name: 'figmaAddReactionToAComment', description: 'Posts an emoji reaction to a comment.', tool: addReactionToAComment, requiredAuth: auth, scope: 'write' },
+    { name: 'figmaCreateAWebhook', description: 'Creates a team/project/file webhook for Figma events.', tool: createAWebhook, requiredAuth: auth, scope: 'write' },
+    { name: 'figmaCreateDevResources', description: 'Attaches dev resources (Jira, GitHub, docs) to file nodes.', tool: createDevResources, requiredAuth: auth, scope: 'write' },
+    { name: 'figmaCreateModifyDeleteVariables', description: 'Batch creates, updates, or deletes variables, collections, modes, and values.', tool: createModifyDeleteVariables, requiredAuth: auth, scope: 'write' },
+    { name: 'figmaDeleteAComment', description: 'Deletes your comment from a file or branch.', tool: deleteAComment, requiredAuth: auth, scope: 'delete' },
+    { name: 'figmaDeleteAReaction', description: 'Removes your emoji reaction from a comment.', tool: deleteAReaction, requiredAuth: auth, scope: 'delete' },
+    { name: 'figmaDeleteAWebhook', description: 'Permanently deletes a webhook. Irreversible.', tool: deleteAWebhook, requiredAuth: auth, scope: 'delete' },
+    { name: 'figmaDeleteDevResource', description: 'Deletes a dev resource from a main file.', tool: deleteDevResource, requiredAuth: auth, scope: 'delete' },
+    { name: 'figmaDesignTokensToTailwind', description: 'Converts extracted design tokens into a Tailwind config plus font CSS. No auth needed.', tool: designTokensToTailwind, scope: 'read' },
+    { name: 'figmaDetectBackground', description: 'Finds background candidates behind target nodes with confidence scores.', tool: detectBackground, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaDiscoverFigmaResources', description: 'Extracts IDs from any Figma URL and traverses team → projects → files → nodes.', tool: discoverFigmaResources, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaDownloadFigmaImages', description: 'Renders nodes and downloads image bytes (base64) in PNG/SVG/JPG/PDF.', tool: downloadFigmaImages, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaExtractDesignTokens', description: 'Extracts colors, typography, spacing, radii, and shadows from a file.', tool: extractDesignTokens, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaExtractPrototypeInteractions', description: 'Extracts prototype flows, interactions, animations, and variant states.', tool: extractPrototypeInteractions, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetActivityLogs', description: 'Retrieves org activity log events with filters and pagination.', tool: getActivityLogs, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetAWebhook', description: 'Retrieves a webhook by ID.', tool: getAWebhook, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetCommentsInAFile', description: 'Retrieves all comments from a file or branch.', tool: getCommentsInAFile, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetComponent2', description: 'Fetches published component metadata by component key.', tool: getComponent2, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetComponentSet', description: 'Fetches published component set metadata by set key.', tool: getComponentSet, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetCurrentUser', description: 'Returns the authenticated user details.', tool: getCurrentUser, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetDevResources', description: 'Lists dev resources on a main file, optionally filtered to nodes.', tool: getDevResources, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetFileComponentSets', description: 'Lists published component sets from a main library file.', tool: getFileComponentSets, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetFileComponents', description: 'Lists published components from a main library file.', tool: getFileComponents, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetFileJson', description: 'Gets a Design file document tree, optionally scoped to nodes and depth.', tool: getFileJson, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetFileMetadata', description: 'Gets file overview without the document tree.', tool: getFileMetadata, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetFileNodes', description: 'Fetches JSON for known node IDs without full-file payloads.', tool: getFileNodes, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetFileStyles', description: 'Lists published styles from a main library file.', tool: getFileStyles, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetFilesInAProject', description: 'Lists files in a project, optionally with branch metadata.', tool: getFilesInAProject, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetImageFills', description: 'Returns temporary download URLs for all image fills in a file.', tool: getImageFills, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetLibraryAnalyticsComponentActionData', description: 'Weekly component insertions/detachments for a library.', tool: getLibraryAnalyticsComponentActionData, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetLibraryAnalyticsComponentUsageData', description: 'Component usage totals for a library.', tool: getLibraryAnalyticsComponentUsageData, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetLibraryAnalyticsStyleActionData', description: 'Weekly style insertions/detachments for a library.', tool: getLibraryAnalyticsStyleActionData, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetLibraryAnalyticsStyleUsageData', description: 'Style usage totals for a library.', tool: getLibraryAnalyticsStyleUsageData, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetLibraryAnalyticsVariableActionData', description: 'Weekly variable insertions/detachments for a library.', tool: getLibraryAnalyticsVariableActionData, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetLibraryAnalyticsVariableUsageData', description: 'Variable usage totals for a library.', tool: getLibraryAnalyticsVariableUsageData, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetLocalVariables', description: 'Gets all local/remote variables with mode-specific values.', tool: getLocalVariables, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetPayments', description: 'Checks a user payment status for your plugin, widget, or Community file.', tool: getPayments, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetProjectsInATeam', description: 'Lists projects in a team.', tool: getProjectsInATeam, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetPublishedVariables', description: 'Gets published variables from a main library file.', tool: getPublishedVariables, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetReactionsForAComment', description: 'Lists reactions on a comment with pagination.', tool: getReactionsForAComment, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetScimServiceProviderConfig', description: 'Returns SCIM capabilities for account provisioning.', tool: getScimServiceProviderConfig, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetStyle', description: 'Fetches published style metadata by style key.', tool: getStyle, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetTeamComponentSets', description: 'Lists published component sets in a team library.', tool: getTeamComponentSets, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetTeamComponents', description: 'Lists published components in a team library.', tool: getTeamComponents, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetTeamStyles', description: 'Lists published styles in a team library.', tool: getTeamStyles, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetTeamWebhooks', description: 'Lists webhooks for a team, project, or file context.', tool: getTeamWebhooks, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetVersionsOfAFile', description: 'Retrieves version history for a file or branch.', tool: getVersionsOfAFile, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaGetWebhookRequests', description: 'Shows 7-day delivery history for a webhook.', tool: getWebhookRequests, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaRenderImagesOfFileNodes', description: 'Renders nodes as images and returns temporary URLs.', tool: renderImagesOfFileNodes, requiredAuth: auth, scope: 'read' },
+    { name: 'figmaUpdateAWebhook', description: 'Updates a webhook event type, endpoint, passcode, status, or description.', tool: updateAWebhook, requiredAuth: auth, scope: 'write' },
+    { name: 'figmaUpdateDevResources', description: 'Updates dev resource names and URLs by ID.', tool: updateDevResources, requiredAuth: auth, scope: 'write' },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/figma/tools/library-analytics-shared.d.ts

@@ -0,0 +1,4 @@
+export declare function libraryAnalyticsTool(label: string, resource: 'component' | 'style' | 'variable', metric: 'actions' | 'usages', groupBy: string[], withDates: boolean): import("ai").Tool<{
+    [x: string]: any;
+}, any>;
+//# sourceMappingURL=library-analytics-shared.d.ts.map

package/dist/toolkits/figma/tools/library-analytics-shared.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export function libraryAnalyticsTool(label, resource, metric, groupBy, withDates) {
+    const schema = {
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('Published Enterprise library file key'),
+        groupBy: z.enum(groupBy).describe('Grouping dimension; shapes the rows'),
+        cursor: z.string().optional().describe('Pagination cursor; omit for first page'),
+    };
+    if (withDates) {
+        schema.startDate = z.string().optional().describe('Range start YYYY-MM-DD (defaults to one year prior)');
+        schema.endDate = z.string().optional().describe('Range end YYYY-MM-DD (defaults to latest week)');
+    }
+    return tool({
+        description: `${label} for an Enterprise library. Requires library_analytics:read.`,
+        inputSchema: z.object(schema),
+        execute: async ({ figmaToken, fileKey, groupBy, cursor, startDate, endDate }) => {
+            try {
+                if (startDate && endDate && endDate < startDate) {
+                    return { error: 'endDate must not be before startDate' };
+                }
+                const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/analytics/${resource}/${metric}`, {
+                    query: { group_by: groupBy, cursor, start_date: startDate, end_date: endDate },
+                });
+                if (!result.ok)
+                    return { error: `Failed to get ${label}`, details: result.error };
+                return result.data;
+            }
+            catch (error) {
+                return {
+                    error: `Error getting ${label}`,
+                    message: error instanceof Error ? error.message : 'Unknown error',
+                };
+            }
+        },
+    });
+}
+//# sourceMappingURL=library-analytics-shared.js.map

package/dist/toolkits/figma/tools/render-images-of-file-nodes.d.ts

@@ -0,0 +1,15 @@
+export declare const renderImagesOfFileNodes: import("ai").Tool<{
+    figmaToken: string;
+    fileKey: string;
+    ids: string;
+    version?: string | undefined;
+    scale?: number | undefined;
+    format?: "svg" | "png" | "jpg" | "pdf" | undefined;
+    svgIncludeId?: boolean | undefined;
+    svgOutlineText?: boolean | undefined;
+    svgSimplifyStroke?: boolean | undefined;
+    contentsOnly?: boolean | undefined;
+    useAbsoluteBounds?: boolean | undefined;
+    svgIncludeNodeId?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=render-images-of-file-nodes.d.ts.map

package/dist/toolkits/figma/tools/render-images-of-file-nodes.js

@@ -0,0 +1,49 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const renderImagesOfFileNodes = tool({
+    description: 'Renders nodes as PNG/JPG/SVG/PDF and returns temporary (30-day) image URLs keyed by node ID. Null means that node failed (bad ID, invisible, 0% opacity). Capped at 32MP — lower scale for large nodes.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('File or branch key from the file URL'),
+        ids: z.string().describe("Comma-separated node IDs, e.g. '1:2,1:3'"),
+        format: z.enum(['jpg', 'pdf', 'png', 'svg']).optional().describe('Output format (default png)'),
+        scale: z.number().min(0.01).max(4).optional().describe('PNG/JPG scale 0.01-4 (ignored for SVG/PDF)'),
+        version: z.string().optional().describe('Version ID; omit for current'),
+        contentsOnly: z.boolean().optional().describe('Exclude overlapping content (default true)'),
+        useAbsoluteBounds: z.boolean().optional().describe('Full node dimensions, avoids text cropping'),
+        svgIncludeId: z.boolean().optional(),
+        svgOutlineText: z.boolean().optional(),
+        svgIncludeNodeId: z.boolean().optional(),
+        svgSimplifyStroke: z.boolean().optional(),
+    }),
+    execute: async ({ figmaToken, fileKey, ids, format, scale, version, contentsOnly, useAbsoluteBounds, svgIncludeId, svgOutlineText, svgIncludeNodeId, svgSimplifyStroke }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/images`, {
+                query: {
+                    ids,
+                    format,
+                    scale,
+                    version,
+                    contents_only: contentsOnly,
+                    use_absolute_bounds: useAbsoluteBounds,
+                    svg_include_id: svgIncludeId,
+                    svg_outline_text: svgOutlineText,
+                    svg_include_node_id: svgIncludeNodeId,
+                    svg_simplify_stroke: svgSimplifyStroke,
+                },
+            });
+            if (!result.ok)
+                return { error: 'Failed to render node images', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error rendering node images',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=render-images-of-file-nodes.js.map

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

@@ -0,0 +1,10 @@
+export declare const updateAWebhook: import("ai").Tool<{
+    figmaToken: string;
+    webhookId: string;
+    status?: "ACTIVE" | "PAUSED" | undefined;
+    description?: string | undefined;
+    eventType?: "FILE_COMMENT" | "FILE_DELETE" | "FILE_UPDATE" | "FILE_VERSION_UPDATE" | "LIBRARY_PUBLISH" | "PING" | undefined;
+    endpoint?: string | undefined;
+    passcode?: string | undefined;
+}, any>;
+//# sourceMappingURL=update-a-webhook.d.ts.map

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

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const updateAWebhook = tool({
+    description: 'Updates a webhook event type, endpoint, passcode, status, or description. Only provided fields change.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        webhookId: z.string().describe('Webhook ID to update'),
+        eventType: z.enum(['FILE_COMMENT', 'FILE_DELETE', 'FILE_UPDATE', 'FILE_VERSION_UPDATE', 'LIBRARY_PUBLISH', 'PING']).optional(),
+        endpoint: z.string().optional().describe('New HTTPS endpoint (max 2048 chars)'),
+        passcode: z.string().optional().describe('New secret (max 100 chars)'),
+        status: z.enum(['ACTIVE', 'PAUSED']).optional(),
+        description: z.string().optional().describe('New description (max 140 chars; empty string removes)'),
+    }),
+    execute: async ({ figmaToken, webhookId, eventType, endpoint, passcode, status, description }) => {
+        try {
+            const body = {};
+            if (eventType)
+                body.event_type = eventType;
+            if (endpoint)
+                body.endpoint = endpoint;
+            if (passcode)
+                body.passcode = passcode;
+            if (status)
+                body.status = status;
+            if (description !== undefined)
+                body.description = description;
+            const result = await figmaRequest(figmaToken, `/v2/webhooks/${webhookId}`, {
+                method: 'PUT',
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to update webhook', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error updating webhook',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-a-webhook.js.map

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

@@ -0,0 +1,10 @@
+export declare const updateDevResources: import("ai").Tool<{
+    figmaToken: string;
+    fileKey: string;
+    devResources: {
+        id: string;
+        url?: string | undefined;
+        name?: string | undefined;
+    }[];
+}, any>;
+//# sourceMappingURL=update-dev-resources.d.ts.map

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

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { figmaRequest, figmaTokenField } from './client.js';
+export const updateDevResources = tool({
+    description: 'Updates the name and/or URL of dev resources by ID. Omitted fields are retained.',
+    inputSchema: z.object({
+        figmaToken: figmaTokenField,
+        fileKey: z.string().describe('Main file key containing the resources'),
+        devResources: z.array(z.object({
+            id: z.string().describe('Dev resource ID to update'),
+            name: z.string().optional().describe('New name'),
+            url: z.string().optional().describe('New URL'),
+        })).min(1),
+    }),
+    execute: async ({ figmaToken, fileKey, devResources }) => {
+        try {
+            const result = await figmaRequest(figmaToken, `/v1/files/${fileKey}/dev_resources`, {
+                method: 'PUT',
+                body: { dev_resources: devResources },
+            });
+            if (!result.ok)
+                return { error: 'Failed to update dev resources', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error updating dev resources',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-dev-resources.js.map

package/dist/toolkits/gitlab/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const GITLAB_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map

package/dist/toolkits/gitlab/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg width="800px" height="800px" viewBox="0 0 32 32" xmlns="http://www.w3.org/2000/svg"><title>file_type_gitlab</title><polygon points="16 28.896 16 28.896 21.156 13.029 10.844 13.029 16 28.896" style="fill:#e24329"/><polygon points="16 28.896 10.844 13.029 3.619 13.029 16 28.896" style="fill:#fc6d26"/><path d="M3.619,13.029h0L2.052,17.851a1.067,1.067,0,0,0,.388,1.193L16,28.9,3.619,13.029Z" style="fill:#fca326"/><path d="M3.619,13.029h7.225L7.739,3.473a.534.534,0,0,0-1.015,0L3.619,13.029Z" style="fill:#e24329"/><polygon points="16 28.896 21.156 13.029 28.381 13.029 16 28.896" style="fill:#fc6d26"/><path d="M28.381,13.029h0l1.567,4.822a1.067,1.067,0,0,1-.388,1.193L16,28.9,28.381,13.029Z" style="fill:#fca326"/><path d="M28.381,13.029H21.156l3.105-9.557a.534.534,0,0,1,1.015,0l3.105,9.557Z" style="fill:#e24329"/></svg>`;
+export const GITLAB_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/gitlab/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/gitlab/manifest.js

@@ -0,0 +1,36 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { GITLAB_ICON } from './icon.js';
+import { gitlabTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'gitlab',
+    displayName: 'GitLab',
+    shortDescription: 'Projects, issues, merge requests, pipelines, and repositories.',
+    category: 'Developer Tools & DevOps',
+    icon: GITLAB_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'gitlabToken',
+        provider: {
+            slug: 'gitlab',
+            env: { clientId: 'GITLAB_CLIENT_ID', clientSecret: 'GITLAB_CLIENT_SECRET' },
+            authorizeUrl: 'https://gitlab.com/oauth/authorize',
+            tokenUrl: 'https://gitlab.com/oauth/token',
+            scopes: ['api', 'read_user'],
+            exchangeStyle: 'form',
+            connectDescription: 'Connect GitLab to manage projects, issues, merge requests, pipelines, and repositories.',
+            callbackPath: '/api/auth/gitlab/callback',
+            stateCookie: 'gitlab_oauth_state',
+        },
+    },
+    allowedHosts: ['gitlab.com'],
+    tools: gitlabTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope ?? inferToolScope(entry.name),
+    })),
+    meta: { since: '0.0.9' },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/gitlab/tools/client.d.ts

@@ -0,0 +1,7 @@
+export declare function encodeId(id: string | number): string;
+export declare function gitlabRequest(gitlabToken: string | undefined, path: string, options?: {
+    method?: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+}): Promise<any>;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,45 @@
+// @ts-nocheck
+const GITLAB_API_BASE = 'https://gitlab.com/api/v4';
+export function encodeId(id) {
+    return encodeURIComponent(String(id));
+}
+export async function gitlabRequest(gitlabToken, path, options = {}) {
+    if (!gitlabToken) {
+        return { error: 'GitLab token is required. Connect GitLab first.' };
+    }
+    const params = new URLSearchParams();
+    if (options.query) {
+        for (const [key, value] of Object.entries(options.query)) {
+            if (value !== undefined && value !== null && value !== '') {
+                params.append(key, String(value));
+            }
+        }
+    }
+    const queryString = params.toString();
+    const url = `${GITLAB_API_BASE}${path}${queryString ? `?${queryString}` : ''}`;
+    try {
+        const response = await fetch(url, {
+            method: options.method ?? 'GET',
+            headers: {
+                Authorization: `Bearer ${gitlabToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: options.body !== undefined ? JSON.stringify(options.body) : undefined,
+        });
+        if (!response.ok) {
+            const details = await response.json().catch(() => ({}));
+            return { error: `GitLab API request failed with status ${response.status}`, details };
+        }
+        if (response.status === 204) {
+            return { success: true };
+        }
+        return await response.json();
+    }
+    catch (error) {
+        return {
+            error: 'Error calling GitLab API',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+//# sourceMappingURL=client.js.map