@rnsk/toolkits 0.0.3 → 0.0.5

package/dist/toolkits/google-drive/tools/move-file.js

@@ -0,0 +1,51 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const moveFile = tool({
+    description: 'Move a file or folder to a different parent folder in Google Drive.',
+    inputSchema: z.object({
+        googleDriveToken: z.string().describe('The Google Drive access token'),
+        fileId: z.string().describe('The ID of the file or folder to move'),
+        newParentId: z.string().describe('The ID of the destination folder'),
+        removeParentId: z.string().optional().describe('Parent folder ID to remove (auto-detected if omitted)'),
+    }),
+    execute: async ({ googleDriveToken, fileId, newParentId, removeParentId }) => {
+        try {
+            let removeParents = removeParentId;
+            if (!removeParents) {
+                const metaUrl = `https://www.googleapis.com/drive/v3/files/${fileId}?fields=parents`;
+                const metaResponse = await fetch(metaUrl, {
+                    headers: { Authorization: `Bearer ${googleDriveToken}` },
+                });
+                if (!metaResponse.ok) {
+                    const error = await metaResponse.json();
+                    return { error: 'Failed to get file parents', details: error };
+                }
+                const meta = await metaResponse.json();
+                removeParents = meta.parents?.[0];
+            }
+            const url = new URL(`https://www.googleapis.com/drive/v3/files/${fileId}`);
+            url.searchParams.set('addParents', newParentId);
+            if (removeParents) {
+                url.searchParams.set('removeParents', removeParents);
+            }
+            url.searchParams.set('fields', 'id,name,parents');
+            const response = await fetch(url.toString(), {
+                method: 'PATCH',
+                headers: { Authorization: `Bearer ${googleDriveToken}` },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to move file', details: error };
+            }
+            return await response.json();
+        }
+        catch (error) {
+            return {
+                error: 'Error moving file',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=move-file.js.map

package/dist/toolkits/google-drive/tools/search-files.d.ts

@@ -0,0 +1,21 @@
+export declare const searchFiles: import("ai").Tool<{
+    q: string;
+    pageSize: number;
+    googleDriveToken: string;
+}, {
+    error: string;
+    details: any;
+    files?: undefined;
+    message?: undefined;
+} | {
+    files: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    files?: undefined;
+}>;
+//# sourceMappingURL=search-files.d.ts.map

package/dist/toolkits/google-drive/tools/search-files.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const searchFiles = tool({
+    description: 'Search for files and folders in Google Drive using a Drive query.',
+    inputSchema: z.object({
+        googleDriveToken: z.string().describe('The Google Drive access token'),
+        q: z.string().describe('Drive search query (e.g. "name contains \'report\'" or "mimeType=\'application/pdf\'")'),
+        pageSize: z.number().optional().default(20).describe('Maximum number of results to return'),
+    }),
+    execute: async ({ googleDriveToken, q, pageSize = 20 }) => {
+        try {
+            const url = new URL('https://www.googleapis.com/drive/v3/files');
+            const query = `trashed = false and (${q})`;
+            url.searchParams.set('q', query);
+            url.searchParams.set('pageSize', String(pageSize));
+            url.searchParams.set('fields', 'files(id,name,mimeType,modifiedTime,parents,webViewLink)');
+            const response = await fetch(url.toString(), {
+                headers: { Authorization: `Bearer ${googleDriveToken}` },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to search files', details: error };
+            }
+            const data = await response.json();
+            return { files: data.files ?? [] };
+        }
+        catch (error) {
+            return {
+                error: 'Error searching files',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=search-files.js.map

package/dist/toolkits/google-drive/tools/update-file.d.ts

@@ -0,0 +1,7 @@
+export declare const updateFile: import("ai").Tool<{
+    googleDriveToken: string;
+    fileId: string;
+    description?: string | undefined;
+    name?: string | undefined;
+}, any>;
+//# sourceMappingURL=update-file.d.ts.map

package/dist/toolkits/google-drive/tools/update-file.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const updateFile = tool({
+    description: 'Update file metadata in Google Drive (rename, description).',
+    inputSchema: z.object({
+        googleDriveToken: z.string().describe('The Google Drive access token'),
+        fileId: z.string().describe('The ID of the file to update'),
+        name: z.string().optional().describe('New file name'),
+        description: z.string().optional().describe('New file description'),
+    }),
+    execute: async ({ googleDriveToken, fileId, name, description }) => {
+        try {
+            const metadata = {};
+            if (name !== undefined)
+                metadata.name = name;
+            if (description !== undefined)
+                metadata.description = description;
+            if (Object.keys(metadata).length === 0) {
+                return { error: 'At least one of name or description must be provided' };
+            }
+            const response = await fetch(`https://www.googleapis.com/drive/v3/files/${fileId}`, {
+                method: 'PATCH',
+                headers: {
+                    Authorization: `Bearer ${googleDriveToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(metadata),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to update file', details: error };
+            }
+            return await response.json();
+        }
+        catch (error) {
+            return {
+                error: 'Error updating file',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-file.js.map

package/dist/toolkits/google-drive/tools/upload-file.d.ts

@@ -0,0 +1,8 @@
+export declare const uploadFile: import("ai").Tool<{
+    content: string;
+    name: string;
+    googleDriveToken: string;
+    mimeType: string;
+    parentId?: string | undefined;
+}, any>;
+//# sourceMappingURL=upload-file.d.ts.map

package/dist/toolkits/google-drive/tools/upload-file.js

@@ -0,0 +1,58 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const uploadFile = tool({
+    description: 'Upload a file to Google Drive using multipart upload.',
+    inputSchema: z.object({
+        googleDriveToken: z.string().describe('The Google Drive access token'),
+        name: z.string().describe('File name'),
+        mimeType: z.string().describe('MIME type of the file (e.g. text/plain, application/pdf)'),
+        content: z.string().describe('Base64-encoded file content'),
+        parentId: z.string().optional().describe('Parent folder ID (defaults to root)'),
+    }),
+    execute: async ({ googleDriveToken, name, mimeType, content, parentId }) => {
+        try {
+            const metadata = { name };
+            if (parentId) {
+                metadata.parents = [parentId];
+            }
+            const boundary = '-------rnsk_drive_upload';
+            const metadataPart = JSON.stringify(metadata);
+            const contentBuffer = Buffer.from(content, 'base64');
+            const body = [
+                `--${boundary}`,
+                'Content-Type: application/json; charset=UTF-8',
+                '',
+                metadataPart,
+                `--${boundary}`,
+                `Content-Type: ${mimeType}`,
+                '',
+            ].join('\r\n');
+            const bodyBuffer = Buffer.concat([
+                Buffer.from(body, 'utf-8'),
+                contentBuffer,
+                Buffer.from(`\r\n--${boundary}--`, 'utf-8'),
+            ]);
+            const response = await fetch('https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart&fields=id,name,mimeType,webViewLink', {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${googleDriveToken}`,
+                    'Content-Type': `multipart/related; boundary=${boundary}`,
+                },
+                body: bodyBuffer,
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to upload file', details: error };
+            }
+            return await response.json();
+        }
+        catch (error) {
+            return {
+                error: 'Error uploading file',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=upload-file.js.map

package/dist/toolkits/google-sheets/manifest.js

@@ -13,12 +13,7 @@ export default defineToolkit({
         tokenField: 'googleSheetsToken',
         provider: {
             slug: 'google-sheets',
-            env: {
-                clientId: 'GOOGLE_CLIENT_ID',
-                clientSecret: 'GOOGLE_CLIENT_SECRET',
-                clientIdFallback: 'GMAIL_CLIENT_ID',
-                clientSecretFallback: 'GMAIL_CLIENT_SECRET',
-            },
+            env: { clientId: 'GOOGLE_SHEET_CLIENT_ID', clientSecret: 'GOOGLE_SHEET_CLIENT_SECRET' },
             authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
             tokenUrl: 'https://oauth2.googleapis.com/token',
             scopes: [

package/dist/toolkits/linear/manifest.js

@@ -3,6 +3,11 @@ import { LINEAR_ICON } from './icon.js';
 import { linearSearchIssues } from './tools/search-issues.js';
 import { linearCreateIssue } from './tools/create-issue.js';
 import { linearListTeams } from './tools/list-teams.js';
+import { linearGetIssue } from './tools/get-issue.js';
+import { linearUpdateIssue } from './tools/update-issue.js';
+import { linearListProjects } from './tools/list-projects.js';
+import { linearListWorkflowStates } from './tools/list-workflow-states.js';
+import { linearAddComment } from './tools/add-comment.js';
 export default defineToolkit({
     id: 'linear',
     displayName: 'Linear',
@@ -45,6 +50,36 @@ export default defineToolkit({
             requiredAuth: 'linearToken',
             scope: 'read',
         }),
+        defineTool({
+            name: 'linearGetIssue',
+            tool: linearGetIssue,
+            requiredAuth: 'linearToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'linearUpdateIssue',
+            tool: linearUpdateIssue,
+            requiredAuth: 'linearToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'linearListProjects',
+            tool: linearListProjects,
+            requiredAuth: 'linearToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'linearListWorkflowStates',
+            tool: linearListWorkflowStates,
+            requiredAuth: 'linearToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'linearAddComment',
+            tool: linearAddComment,
+            requiredAuth: 'linearToken',
+            scope: 'write',
+        }),
     ],
     meta: { since: '0.0.1' },
 });

package/dist/toolkits/linear/tools/add-comment.d.ts

@@ -0,0 +1,6 @@
+export declare const linearAddComment: import("ai").Tool<{
+    issueId: string;
+    body: string;
+    linearToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=add-comment.d.ts.map

package/dist/toolkits/linear/tools/add-comment.js

@@ -0,0 +1,52 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const linearAddComment = tool({
+    description: 'Add a comment to a Linear issue.',
+    inputSchema: z.object({
+        issueId: z.string().describe('Linear issue UUID'),
+        body: z.string().describe('Comment body (markdown supported)'),
+        linearToken: z.string().optional().describe('Linear API token (injected by system)'),
+    }),
+    execute: async ({ issueId, body, linearToken }) => {
+        const graphqlQuery = {
+            query: `
+        mutation CreateComment($input: CommentCreateInput!) {
+          commentCreate(input: $input) {
+            success
+            comment {
+              id
+              body
+              url
+              createdAt
+              user { id name }
+            }
+          }
+        }
+      `,
+            variables: {
+                input: {
+                    issueId,
+                    body,
+                },
+            },
+        };
+        const response = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${linearToken}`,
+            },
+            body: JSON.stringify(graphqlQuery),
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            return { error: 'Failed to add Linear comment', details: error };
+        }
+        const data = await response.json();
+        if (data.errors?.length) {
+            return { error: 'Linear GraphQL error', details: data.errors };
+        }
+        return data.data.commentCreate;
+    },
+});
+//# sourceMappingURL=add-comment.js.map

package/dist/toolkits/linear/tools/get-issue.d.ts

@@ -0,0 +1,6 @@
+export declare const linearGetIssue: import("ai").Tool<{
+    linearToken?: string | undefined;
+    issueId?: string | undefined;
+    identifier?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-issue.d.ts.map

package/dist/toolkits/linear/tools/get-issue.js

@@ -0,0 +1,117 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const linearGetIssue = tool({
+    description: 'Get a single Linear issue by UUID or identifier (e.g. ENG-123). Returns title, description, status, assignee, priority, and URL.',
+    inputSchema: z.object({
+        issueId: z
+            .string()
+            .optional()
+            .describe('Linear issue UUID. Use linearSearchIssues if you only have a title or keyword.'),
+        identifier: z
+            .string()
+            .optional()
+            .describe('Human-readable issue identifier, e.g. ENG-123 (team key + number).'),
+        linearToken: z.string().optional().describe('Linear API token (injected by system)'),
+    }),
+    execute: async ({ issueId, identifier, linearToken }) => {
+        if (!issueId && !identifier) {
+            return { error: 'Provide either issueId (UUID) or identifier (e.g. ENG-123).' };
+        }
+        if (issueId) {
+            const graphqlQuery = {
+                query: `
+          query GetIssue($id: String!) {
+            issue(id: $id) {
+              id
+              identifier
+              title
+              description
+              priority
+              url
+              createdAt
+              updatedAt
+              state { id name type }
+              assignee { id name email }
+              team { id name key }
+              project { id name }
+              labels { nodes { id name color } }
+            }
+          }
+        `,
+                variables: { id: issueId },
+            };
+            const response = await fetch('https://api.linear.app/graphql', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${linearToken}`,
+                },
+                body: JSON.stringify(graphqlQuery),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to get Linear issue', details: error };
+            }
+            const data = await response.json();
+            if (data.errors?.length) {
+                return { error: 'Linear GraphQL error', details: data.errors };
+            }
+            return data.data.issue;
+        }
+        const match = identifier.match(/^([A-Za-z]+)-(\d+)$/);
+        if (!match) {
+            return { error: 'identifier must look like TEAM-123 (team key and issue number).' };
+        }
+        const [, teamKey, numberStr] = match;
+        const number = Number(numberStr);
+        const graphqlQuery = {
+            query: `
+        query IssueByIdentifier($teamKey: String!, $number: Float!) {
+          issues(filter: {
+            team: { key: { eq: $teamKey } }
+            number: { eq: $number }
+          }, first: 1) {
+            nodes {
+              id
+              identifier
+              title
+              description
+              priority
+              url
+              createdAt
+              updatedAt
+              state { id name type }
+              assignee { id name email }
+              team { id name key }
+              project { id name }
+              labels { nodes { id name color } }
+            }
+          }
+        }
+      `,
+            variables: { teamKey, number },
+        };
+        const response = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${linearToken}`,
+            },
+            body: JSON.stringify(graphqlQuery),
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            return { error: 'Failed to get Linear issue', details: error };
+        }
+        const data = await response.json();
+        if (data.errors?.length) {
+            return { error: 'Linear GraphQL error', details: data.errors };
+        }
+        const issue = data.data.issues.nodes[0];
+        if (!issue) {
+            return { error: `No issue found for identifier ${identifier}` };
+        }
+        return issue;
+    },
+});
+//# sourceMappingURL=get-issue.js.map

package/dist/toolkits/linear/tools/list-projects.d.ts

@@ -0,0 +1,4 @@
+export declare const linearListProjects: import("ai").Tool<{
+    linearToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-projects.d.ts.map

package/dist/toolkits/linear/tools/list-projects.js

@@ -0,0 +1,46 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const linearListProjects = tool({
+    description: 'List Linear projects. Returns project IDs, names, status, and associated teams.',
+    inputSchema: z.object({
+        linearToken: z.string().optional().describe('Linear API token (injected by system)'),
+    }),
+    execute: async ({ linearToken }) => {
+        const graphqlQuery = {
+            query: `
+        query {
+          projects(first: 50) {
+            nodes {
+              id
+              name
+              description
+              state
+              url
+              startDate
+              targetDate
+              teams { nodes { id name key } }
+            }
+          }
+        }
+      `,
+        };
+        const response = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${linearToken}`,
+            },
+            body: JSON.stringify(graphqlQuery),
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            return { error: 'Failed to list Linear projects', details: error };
+        }
+        const data = await response.json();
+        if (data.errors?.length) {
+            return { error: 'Linear GraphQL error', details: data.errors };
+        }
+        return data.data.projects.nodes;
+    },
+});
+//# sourceMappingURL=list-projects.js.map

package/dist/toolkits/linear/tools/list-workflow-states.d.ts

@@ -0,0 +1,26 @@
+export declare const linearListWorkflowStates: import("ai").Tool<{
+    teamId: string;
+    linearToken?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    teamId?: undefined;
+    teamName?: undefined;
+    teamKey?: undefined;
+    states?: undefined;
+} | {
+    error: string;
+    details?: undefined;
+    teamId?: undefined;
+    teamName?: undefined;
+    teamKey?: undefined;
+    states?: undefined;
+} | {
+    teamId: any;
+    teamName: any;
+    teamKey: any;
+    states: any;
+    error?: undefined;
+    details?: undefined;
+}>;
+//# sourceMappingURL=list-workflow-states.d.ts.map

package/dist/toolkits/linear/tools/list-workflow-states.js

@@ -0,0 +1,59 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const linearListWorkflowStates = tool({
+    description: 'List workflow states (statuses) for a Linear team. Use state IDs with linearUpdateIssue to move issues (e.g. Todo → In Progress → Done).',
+    inputSchema: z.object({
+        teamId: z.string().describe('Team UUID. Use linearListTeams to find team IDs.'),
+        linearToken: z.string().optional().describe('Linear API token (injected by system)'),
+    }),
+    execute: async ({ teamId, linearToken }) => {
+        const graphqlQuery = {
+            query: `
+        query TeamWorkflowStates($teamId: String!) {
+          team(id: $teamId) {
+            id
+            name
+            key
+            states {
+              nodes {
+                id
+                name
+                type
+                color
+                position
+              }
+            }
+          }
+        }
+      `,
+            variables: { teamId },
+        };
+        const response = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${linearToken}`,
+            },
+            body: JSON.stringify(graphqlQuery),
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            return { error: 'Failed to list Linear workflow states', details: error };
+        }
+        const data = await response.json();
+        if (data.errors?.length) {
+            return { error: 'Linear GraphQL error', details: data.errors };
+        }
+        const team = data.data.team;
+        if (!team) {
+            return { error: `Team not found: ${teamId}` };
+        }
+        return {
+            teamId: team.id,
+            teamName: team.name,
+            teamKey: team.key,
+            states: team.states.nodes,
+        };
+    },
+});
+//# sourceMappingURL=list-workflow-states.js.map

package/dist/toolkits/linear/tools/update-issue.d.ts

@@ -0,0 +1,11 @@
+export declare const linearUpdateIssue: import("ai").Tool<{
+    issueId: string;
+    description?: string | undefined;
+    title?: string | undefined;
+    linearToken?: string | undefined;
+    stateId?: string | undefined;
+    assigneeId?: string | null | undefined;
+    priority?: number | undefined;
+    projectId?: string | undefined;
+}, any>;
+//# sourceMappingURL=update-issue.d.ts.map