@rnsk/toolkits 0.0.2 → 0.0.4

package/dist/toolkits/google-sheets/tools/append-values.d.ts

@@ -0,0 +1,41 @@
+export declare const appendValues: import("ai").Tool<{
+    values: (string | number | boolean | null)[][];
+    range: string;
+    googleSheetsToken: string;
+    spreadsheetId: string;
+    valueInputOption: "RAW" | "USER_ENTERED";
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    spreadsheetId?: undefined;
+    tableRange?: undefined;
+    updatedRange?: undefined;
+    updatedRows?: undefined;
+    updatedColumns?: undefined;
+    updatedCells?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    spreadsheetId: any;
+    tableRange: any;
+    updatedRange: any;
+    updatedRows: any;
+    updatedColumns: any;
+    updatedCells: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    spreadsheetId?: undefined;
+    tableRange?: undefined;
+    updatedRange?: undefined;
+    updatedRows?: undefined;
+    updatedColumns?: undefined;
+    updatedCells?: undefined;
+}>;
+//# sourceMappingURL=append-values.d.ts.map

package/dist/toolkits/google-sheets/tools/append-values.js

@@ -0,0 +1,51 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const appendValues = tool({
+    description: 'Append rows of values to a Google Sheets spreadsheet range (e.g., adding new rows at the bottom of a table).',
+    inputSchema: z.object({
+        googleSheetsToken: z.string().describe('The Google Sheets access token'),
+        spreadsheetId: z.string().describe('The ID of the spreadsheet'),
+        range: z.string().describe('The A1 notation of a range where values should be appended (e.g., "Sheet1!A:E")'),
+        values: z.array(z.array(z.union([z.string(), z.number(), z.boolean(), z.null()]))).describe('A 2D array of row data to append (e.g., [["Alice", 30, true], ["Bob", 25, false]])'),
+        valueInputOption: z.enum(['RAW', 'USER_ENTERED']).optional().default('USER_ENTERED').describe('How the input data should be interpreted. USER_ENTERED parses values like user typing into UI.'),
+    }),
+    execute: async ({ googleSheetsToken, spreadsheetId, range, values, valueInputOption = 'USER_ENTERED' }) => {
+        try {
+            const url = `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}/values/${encodeURIComponent(range)}:append?valueInputOption=${valueInputOption}`;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${googleSheetsToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    range,
+                    majorDimension: 'ROWS',
+                    values,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to append values', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                spreadsheetId: data.spreadsheetId,
+                tableRange: data.tableRange,
+                updatedRange: data.updates?.updatedRange,
+                updatedRows: data.updates?.updatedRows,
+                updatedColumns: data.updates?.updatedColumns,
+                updatedCells: data.updates?.updatedCells,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error appending values',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=append-values.js.map

package/dist/toolkits/google-sheets/tools/clear-values.d.ts

@@ -0,0 +1,27 @@
+export declare const clearValues: import("ai").Tool<{
+    range: string;
+    googleSheetsToken: string;
+    spreadsheetId: string;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    spreadsheetId?: undefined;
+    clearedRange?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    spreadsheetId: any;
+    clearedRange: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    spreadsheetId?: undefined;
+    clearedRange?: undefined;
+}>;
+//# sourceMappingURL=clear-values.d.ts.map

package/dist/toolkits/google-sheets/tools/clear-values.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const clearValues = tool({
+    description: 'Clear values from a specific range in a Google Sheets spreadsheet, leaving cell formatting intact.',
+    inputSchema: z.object({
+        googleSheetsToken: z.string().describe('The Google Sheets access token'),
+        spreadsheetId: z.string().describe('The ID of the spreadsheet'),
+        range: z.string().describe('The A1 notation of the values to clear (e.g., "Sheet1!A1:B10")'),
+    }),
+    execute: async ({ googleSheetsToken, spreadsheetId, range }) => {
+        try {
+            const url = `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}/values/${encodeURIComponent(range)}:clear`;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${googleSheetsToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({}),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to clear values', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                spreadsheetId: data.spreadsheetId,
+                clearedRange: data.clearedRange,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error clearing values',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=clear-values.js.map

package/dist/toolkits/google-sheets/tools/create-spreadsheet.d.ts

@@ -0,0 +1,33 @@
+export declare const createSpreadsheet: import("ai").Tool<{
+    title: string;
+    googleSheetsToken: string;
+    sheetTitles?: string[] | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    spreadsheetId?: undefined;
+    spreadsheetUrl?: undefined;
+    title?: undefined;
+    sheets?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    spreadsheetId: any;
+    spreadsheetUrl: any;
+    title: any;
+    sheets: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    spreadsheetId?: undefined;
+    spreadsheetUrl?: undefined;
+    title?: undefined;
+    sheets?: undefined;
+}>;
+//# sourceMappingURL=create-spreadsheet.d.ts.map

package/dist/toolkits/google-sheets/tools/create-spreadsheet.js

@@ -0,0 +1,59 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const createSpreadsheet = tool({
+    description: 'Create a new Google Sheets spreadsheet with a specified title and optional sheet tabs.',
+    inputSchema: z.object({
+        googleSheetsToken: z.string().describe('The Google Sheets access token'),
+        title: z.string().describe('The title of the new spreadsheet'),
+        sheetTitles: z.array(z.string()).optional().describe('Optional list of initial sheet tab titles to create (e.g., ["Summary", "Data"])'),
+    }),
+    execute: async ({ googleSheetsToken, title, sheetTitles }) => {
+        try {
+            const url = 'https://sheets.googleapis.com/v4/spreadsheets';
+            const payload = {
+                properties: {
+                    title,
+                },
+            };
+            if (sheetTitles && sheetTitles.length > 0) {
+                payload.sheets = sheetTitles.map((sheetTitle) => ({
+                    properties: {
+                        title: sheetTitle,
+                    },
+                }));
+            }
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${googleSheetsToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(payload),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to create spreadsheet', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                spreadsheetId: data.spreadsheetId,
+                spreadsheetUrl: data.spreadsheetUrl,
+                title: data.properties?.title,
+                sheets: data.sheets?.map((s) => ({
+                    sheetId: s.properties?.sheetId,
+                    title: s.properties?.title,
+                    index: s.properties?.index,
+                })),
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error creating spreadsheet',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-spreadsheet.js.map

package/dist/toolkits/google-sheets/tools/index.d.ts

@@ -1,11 +1,209 @@
-import { listSpreadsheets } from './list-spreadsheets';
-import { getSpreadsheet } from './get-spreadsheet';
-import { getValues } from './get-values';
-export { listSpreadsheets, getSpreadsheet, getValues };
-export declare const googleSheetsTools: {
+import { listSpreadsheets } from './list-spreadsheets.js';
+import { getSpreadsheet } from './get-spreadsheet.js';
+import { getValues } from './get-values.js';
+import { appendValues } from './append-values.js';
+import { updateValues } from './update-values.js';
+import { clearValues } from './clear-values.js';
+import { createSpreadsheet } from './create-spreadsheet.js';
+export { listSpreadsheets, getSpreadsheet, getValues, appendValues, updateValues, clearValues, createSpreadsheet, };
+export declare const googleSheetsTools: ({
     name: string;
     description: string;
-    tool: any;
+    tool: import("ai").Tool<{
+        googleSheetsToken: string;
+        pageSize: number;
+        q?: string | undefined;
+    }, {
+        error: string;
+        details: any;
+        spreadsheets?: undefined;
+        message?: undefined;
+    } | {
+        spreadsheets: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        spreadsheets?: undefined;
+    }>;
     requiredAuth: "googleSheetsToken";
-}[];
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSheetsToken: string;
+        spreadsheetId: string;
+    }, any>;
+    requiredAuth: "googleSheetsToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        range: string;
+        googleSheetsToken: string;
+        spreadsheetId: string;
+    }, any>;
+    requiredAuth: "googleSheetsToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        values: (string | number | boolean | null)[][];
+        range: string;
+        googleSheetsToken: string;
+        spreadsheetId: string;
+        valueInputOption: "RAW" | "USER_ENTERED";
+    }, {
+        error: string;
+        details: any;
+        success?: undefined;
+        spreadsheetId?: undefined;
+        tableRange?: undefined;
+        updatedRange?: undefined;
+        updatedRows?: undefined;
+        updatedColumns?: undefined;
+        updatedCells?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        spreadsheetId: any;
+        tableRange: any;
+        updatedRange: any;
+        updatedRows: any;
+        updatedColumns: any;
+        updatedCells: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        success?: undefined;
+        spreadsheetId?: undefined;
+        tableRange?: undefined;
+        updatedRange?: undefined;
+        updatedRows?: undefined;
+        updatedColumns?: undefined;
+        updatedCells?: undefined;
+    }>;
+    requiredAuth: "googleSheetsToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        values: (string | number | boolean | null)[][];
+        range: string;
+        googleSheetsToken: string;
+        spreadsheetId: string;
+        valueInputOption: "RAW" | "USER_ENTERED";
+    }, {
+        error: string;
+        details: any;
+        success?: undefined;
+        spreadsheetId?: undefined;
+        updatedRange?: undefined;
+        updatedRows?: undefined;
+        updatedColumns?: undefined;
+        updatedCells?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        spreadsheetId: any;
+        updatedRange: any;
+        updatedRows: any;
+        updatedColumns: any;
+        updatedCells: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        success?: undefined;
+        spreadsheetId?: undefined;
+        updatedRange?: undefined;
+        updatedRows?: undefined;
+        updatedColumns?: undefined;
+        updatedCells?: undefined;
+    }>;
+    requiredAuth: "googleSheetsToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        range: string;
+        googleSheetsToken: string;
+        spreadsheetId: string;
+    }, {
+        error: string;
+        details: any;
+        success?: undefined;
+        spreadsheetId?: undefined;
+        clearedRange?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        spreadsheetId: any;
+        clearedRange: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        success?: undefined;
+        spreadsheetId?: undefined;
+        clearedRange?: undefined;
+    }>;
+    requiredAuth: "googleSheetsToken";
+    scope: "delete";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        title: string;
+        googleSheetsToken: string;
+        sheetTitles?: string[] | undefined;
+    }, {
+        error: string;
+        details: any;
+        success?: undefined;
+        spreadsheetId?: undefined;
+        spreadsheetUrl?: undefined;
+        title?: undefined;
+        sheets?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        spreadsheetId: any;
+        spreadsheetUrl: any;
+        title: any;
+        sheets: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        success?: undefined;
+        spreadsheetId?: undefined;
+        spreadsheetUrl?: undefined;
+        title?: undefined;
+        sheets?: undefined;
+    }>;
+    requiredAuth: "googleSheetsToken";
+    scope: "write";
+})[];
 //# sourceMappingURL=index.d.ts.map

package/dist/toolkits/google-sheets/tools/index.js

@@ -1,26 +1,61 @@
 // @ts-nocheck
-import { listSpreadsheets } from './list-spreadsheets';
-import { getSpreadsheet } from './get-spreadsheet';
-import { getValues } from './get-values';
-export { listSpreadsheets, getSpreadsheet, getValues };
+import { listSpreadsheets } from './list-spreadsheets.js';
+import { getSpreadsheet } from './get-spreadsheet.js';
+import { getValues } from './get-values.js';
+import { appendValues } from './append-values.js';
+import { updateValues } from './update-values.js';
+import { clearValues } from './clear-values.js';
+import { createSpreadsheet } from './create-spreadsheet.js';
+export { listSpreadsheets, getSpreadsheet, getValues, appendValues, updateValues, clearValues, createSpreadsheet, };
 export const googleSheetsTools = [
     {
         name: 'googleSheetsListSpreadsheets',
         description: 'List or search for Google Sheets spreadsheets in the user\'s Drive.',
         tool: listSpreadsheets,
         requiredAuth: 'googleSheetsToken',
+        scope: 'read',
     },
     {
         name: 'googleSheetsGetSpreadsheet',
         description: 'Get details and metadata of a specific Google Sheets spreadsheet by ID.',
         tool: getSpreadsheet,
         requiredAuth: 'googleSheetsToken',
+        scope: 'read',
     },
     {
         name: 'googleSheetsGetValues',
         description: 'Get values from a specific range in a Google Sheets spreadsheet.',
         tool: getValues,
         requiredAuth: 'googleSheetsToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleSheetsAppendValues',
+        description: 'Append rows of values to a Google Sheets spreadsheet range (e.g., adding new rows at the bottom of a table).',
+        tool: appendValues,
+        requiredAuth: 'googleSheetsToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleSheetsUpdateValues',
+        description: 'Update or overwrite values in a specific range of a Google Sheets spreadsheet.',
+        tool: updateValues,
+        requiredAuth: 'googleSheetsToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleSheetsClearValues',
+        description: 'Clear values from a specific range in a Google Sheets spreadsheet, leaving cell formatting intact.',
+        tool: clearValues,
+        requiredAuth: 'googleSheetsToken',
+        scope: 'delete',
+    },
+    {
+        name: 'googleSheetsCreateSpreadsheet',
+        description: 'Create a new Google Sheets spreadsheet with a specified title and optional sheet tabs.',
+        tool: createSpreadsheet,
+        requiredAuth: 'googleSheetsToken',
+        scope: 'write',
     },
 ];
 //# sourceMappingURL=index.js.map

package/dist/toolkits/google-sheets/tools/update-values.d.ts

@@ -0,0 +1,38 @@
+export declare const updateValues: import("ai").Tool<{
+    values: (string | number | boolean | null)[][];
+    range: string;
+    googleSheetsToken: string;
+    spreadsheetId: string;
+    valueInputOption: "RAW" | "USER_ENTERED";
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    spreadsheetId?: undefined;
+    updatedRange?: undefined;
+    updatedRows?: undefined;
+    updatedColumns?: undefined;
+    updatedCells?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    spreadsheetId: any;
+    updatedRange: any;
+    updatedRows: any;
+    updatedColumns: any;
+    updatedCells: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    spreadsheetId?: undefined;
+    updatedRange?: undefined;
+    updatedRows?: undefined;
+    updatedColumns?: undefined;
+    updatedCells?: undefined;
+}>;
+//# sourceMappingURL=update-values.d.ts.map

package/dist/toolkits/google-sheets/tools/update-values.js

@@ -0,0 +1,50 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const updateValues = tool({
+    description: 'Update or overwrite values in a specific range of a Google Sheets spreadsheet.',
+    inputSchema: z.object({
+        googleSheetsToken: z.string().describe('The Google Sheets access token'),
+        spreadsheetId: z.string().describe('The ID of the spreadsheet'),
+        range: z.string().describe('The A1 notation of the range to update (e.g., "Sheet1!A1:B2")'),
+        values: z.array(z.array(z.union([z.string(), z.number(), z.boolean(), z.null()]))).describe('A 2D array of values to write (e.g., [["Name", "Score"], ["Alice", 95]])'),
+        valueInputOption: z.enum(['RAW', 'USER_ENTERED']).optional().default('USER_ENTERED').describe('How the input data should be interpreted. USER_ENTERED parses values like user typing into UI.'),
+    }),
+    execute: async ({ googleSheetsToken, spreadsheetId, range, values, valueInputOption = 'USER_ENTERED' }) => {
+        try {
+            const url = `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}/values/${encodeURIComponent(range)}?valueInputOption=${valueInputOption}`;
+            const response = await fetch(url, {
+                method: 'PUT',
+                headers: {
+                    Authorization: `Bearer ${googleSheetsToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    range,
+                    majorDimension: 'ROWS',
+                    values,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to update values', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                spreadsheetId: data.spreadsheetId,
+                updatedRange: data.updatedRange,
+                updatedRows: data.updatedRows,
+                updatedColumns: data.updatedColumns,
+                updatedCells: data.updatedCells,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error updating values',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-values.js.map

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