@rnsk/toolkits 0.0.4 → 0.0.6

package/dist/toolkits/google-docs/tools/delete-content.d.ts

@@ -0,0 +1,28 @@
+export declare const deleteContent: import("ai").Tool<{
+    googleDocsToken: string;
+    documentId: string;
+    startIndex: number;
+    endIndex: number;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    documentId?: undefined;
+    replies?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    documentId: string;
+    replies: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    documentId?: undefined;
+    replies?: undefined;
+}>;
+//# sourceMappingURL=delete-content.d.ts.map

package/dist/toolkits/google-docs/tools/delete-content.js

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const deleteContent = tool({
+    description: 'Delete a range of content from a Google Docs document.',
+    inputSchema: z.object({
+        googleDocsToken: z.string().describe('The Google Docs access token'),
+        documentId: z.string().describe('The ID of the document'),
+        startIndex: z.number().describe('Start index of the range to delete (inclusive)'),
+        endIndex: z.number().describe('End index of the range to delete (exclusive)'),
+    }),
+    execute: async ({ googleDocsToken, documentId, startIndex, endIndex }) => {
+        try {
+            const response = await fetch(`https://docs.googleapis.com/v1/documents/${documentId}:batchUpdate`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${googleDocsToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    requests: [
+                        {
+                            deleteContentRange: {
+                                range: { startIndex, endIndex },
+                            },
+                        },
+                    ],
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to delete content', details: error };
+            }
+            const data = await response.json();
+            return { success: true, documentId, replies: data.replies };
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting content',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-content.js.map

package/dist/toolkits/google-docs/tools/delete-document.d.ts

@@ -0,0 +1,23 @@
+export declare const deleteDocument: import("ai").Tool<{
+    googleDocsToken: string;
+    documentId: string;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    documentId?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    documentId: string;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    documentId?: undefined;
+}>;
+//# sourceMappingURL=delete-document.d.ts.map

package/dist/toolkits/google-docs/tools/delete-document.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const deleteDocument = tool({
+    description: 'Delete a Google Docs document (moves to trash).',
+    inputSchema: z.object({
+        googleDocsToken: z.string().describe('The Google Docs access token'),
+        documentId: z.string().describe('The ID of the document to delete'),
+    }),
+    execute: async ({ googleDocsToken, documentId }) => {
+        try {
+            const response = await fetch(`https://www.googleapis.com/drive/v3/files/${documentId}`, {
+                method: 'DELETE',
+                headers: { Authorization: `Bearer ${googleDocsToken}` },
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({ message: response.statusText }));
+                return { error: 'Failed to delete document', details: error };
+            }
+            return { success: true, documentId };
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting document',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-document.js.map

package/dist/toolkits/google-docs/tools/get-document-text.d.ts

@@ -0,0 +1,26 @@
+export declare const getDocumentText: import("ai").Tool<{
+    googleDocsToken: string;
+    documentId: string;
+}, {
+    error: string;
+    details: any;
+    documentId?: undefined;
+    title?: undefined;
+    text?: undefined;
+    message?: undefined;
+} | {
+    documentId: any;
+    title: any;
+    text: string;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    documentId?: undefined;
+    title?: undefined;
+    text?: undefined;
+}>;
+//# sourceMappingURL=get-document-text.d.ts.map

package/dist/toolkits/google-docs/tools/get-document-text.js

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { extractPlainText } from './utils.js';
+export const getDocumentText = tool({
+    description: 'Get the plain text content of a Google Docs document.',
+    inputSchema: z.object({
+        googleDocsToken: z.string().describe('The Google Docs access token'),
+        documentId: z.string().describe('The ID of the document'),
+    }),
+    execute: async ({ googleDocsToken, documentId }) => {
+        try {
+            const response = await fetch(`https://docs.googleapis.com/v1/documents/${documentId}`, {
+                headers: { Authorization: `Bearer ${googleDocsToken}` },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to get document', details: error };
+            }
+            const document = await response.json();
+            return {
+                documentId: document.documentId,
+                title: document.title,
+                text: extractPlainText(document),
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting document text',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-document-text.js.map

package/dist/toolkits/google-docs/tools/get-document.d.ts

@@ -0,0 +1,5 @@
+export declare const getDocument: import("ai").Tool<{
+    googleDocsToken: string;
+    documentId: string;
+}, any>;
+//# sourceMappingURL=get-document.d.ts.map

package/dist/toolkits/google-docs/tools/get-document.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const getDocument = tool({
+    description: 'Get the full Google Docs document structure including title and body content.',
+    inputSchema: z.object({
+        googleDocsToken: z.string().describe('The Google Docs access token'),
+        documentId: z.string().describe('The ID of the document'),
+    }),
+    execute: async ({ googleDocsToken, documentId }) => {
+        try {
+            const response = await fetch(`https://docs.googleapis.com/v1/documents/${documentId}`, {
+                headers: { Authorization: `Bearer ${googleDocsToken}` },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to get document', details: error };
+            }
+            return await response.json();
+        }
+        catch (error) {
+            return {
+                error: 'Error getting document',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-document.js.map

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

@@ -0,0 +1,299 @@
+import { listDocuments } from './list-documents.js';
+import { getDocument } from './get-document.js';
+import { getDocumentText } from './get-document-text.js';
+import { createDocument } from './create-document.js';
+import { insertText } from './insert-text.js';
+import { appendText } from './append-text.js';
+import { replaceText } from './replace-text.js';
+import { deleteContent } from './delete-content.js';
+import { copyDocument } from './copy-document.js';
+import { deleteDocument } from './delete-document.js';
+export { listDocuments, getDocument, getDocumentText, createDocument, insertText, appendText, replaceText, deleteContent, copyDocument, deleteDocument, };
+export declare const googleDocsTools: ({
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        pageSize: number;
+        googleDocsToken: string;
+        q?: string | undefined;
+    }, {
+        error: string;
+        details: any;
+        documents?: undefined;
+        message?: undefined;
+    } | {
+        documents: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        documents?: undefined;
+    }>;
+    requiredAuth: "googleDocsToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleDocsToken: string;
+        documentId: string;
+    }, any>;
+    requiredAuth: "googleDocsToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleDocsToken: string;
+        documentId: string;
+    }, {
+        error: string;
+        details: any;
+        documentId?: undefined;
+        title?: undefined;
+        text?: undefined;
+        message?: undefined;
+    } | {
+        documentId: any;
+        title: any;
+        text: string;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        documentId?: undefined;
+        title?: undefined;
+        text?: undefined;
+    }>;
+    requiredAuth: "googleDocsToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        title: string;
+        googleDocsToken: string;
+    }, {
+        error: string;
+        details: any;
+        documentId?: undefined;
+        title?: undefined;
+        revisionId?: undefined;
+        message?: undefined;
+    } | {
+        documentId: any;
+        title: any;
+        revisionId: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        documentId?: undefined;
+        title?: undefined;
+        revisionId?: undefined;
+    }>;
+    requiredAuth: "googleDocsToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        text: string;
+        googleDocsToken: string;
+        documentId: string;
+        index: number;
+    }, {
+        error: string;
+        details: any;
+        success?: undefined;
+        documentId?: undefined;
+        replies?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        documentId: string;
+        replies: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        success?: undefined;
+        documentId?: undefined;
+        replies?: undefined;
+    }>;
+    requiredAuth: "googleDocsToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        text: string;
+        googleDocsToken: string;
+        documentId: string;
+    }, {
+        error: string;
+        details: any;
+        success?: undefined;
+        documentId?: undefined;
+        index?: undefined;
+        replies?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        documentId: string;
+        index: number;
+        replies: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        success?: undefined;
+        documentId?: undefined;
+        index?: undefined;
+        replies?: undefined;
+    }>;
+    requiredAuth: "googleDocsToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleDocsToken: string;
+        documentId: string;
+        findText: string;
+        replaceText: string;
+        matchCase: boolean;
+    }, {
+        error: string;
+        details: any;
+        success?: undefined;
+        documentId?: undefined;
+        occurrencesChanged?: undefined;
+        replies?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        documentId: string;
+        occurrencesChanged: any;
+        replies: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        success?: undefined;
+        documentId?: undefined;
+        occurrencesChanged?: undefined;
+        replies?: undefined;
+    }>;
+    requiredAuth: "googleDocsToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleDocsToken: string;
+        documentId: string;
+        startIndex: number;
+        endIndex: number;
+    }, {
+        error: string;
+        details: any;
+        success?: undefined;
+        documentId?: undefined;
+        replies?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        documentId: string;
+        replies: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        success?: undefined;
+        documentId?: undefined;
+        replies?: undefined;
+    }>;
+    requiredAuth: "googleDocsToken";
+    scope: "delete";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleDocsToken: string;
+        documentId: string;
+        name?: string | undefined;
+    }, {
+        error: string;
+        details: any;
+        documentId?: undefined;
+        name?: undefined;
+        webViewLink?: undefined;
+        message?: undefined;
+    } | {
+        documentId: any;
+        name: any;
+        webViewLink: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        documentId?: undefined;
+        name?: undefined;
+        webViewLink?: undefined;
+    }>;
+    requiredAuth: "googleDocsToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleDocsToken: string;
+        documentId: string;
+    }, {
+        error: string;
+        details: any;
+        success?: undefined;
+        documentId?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        documentId: string;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        success?: undefined;
+        documentId?: undefined;
+    }>;
+    requiredAuth: "googleDocsToken";
+    scope: "delete";
+})[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,85 @@
+// @ts-nocheck
+import { listDocuments } from './list-documents.js';
+import { getDocument } from './get-document.js';
+import { getDocumentText } from './get-document-text.js';
+import { createDocument } from './create-document.js';
+import { insertText } from './insert-text.js';
+import { appendText } from './append-text.js';
+import { replaceText } from './replace-text.js';
+import { deleteContent } from './delete-content.js';
+import { copyDocument } from './copy-document.js';
+import { deleteDocument } from './delete-document.js';
+export { listDocuments, getDocument, getDocumentText, createDocument, insertText, appendText, replaceText, deleteContent, copyDocument, deleteDocument, };
+export const googleDocsTools = [
+    {
+        name: 'googleDocsListDocuments',
+        description: 'List Google Docs documents in the user\'s Drive.',
+        tool: listDocuments,
+        requiredAuth: 'googleDocsToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleDocsGetDocument',
+        description: 'Get the full Google Docs document structure including title and body content.',
+        tool: getDocument,
+        requiredAuth: 'googleDocsToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleDocsGetDocumentText',
+        description: 'Get the plain text content of a Google Docs document.',
+        tool: getDocumentText,
+        requiredAuth: 'googleDocsToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleDocsCreateDocument',
+        description: 'Create a new blank Google Docs document with a title.',
+        tool: createDocument,
+        requiredAuth: 'googleDocsToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleDocsInsertText',
+        description: 'Insert text at a specific index in a Google Docs document.',
+        tool: insertText,
+        requiredAuth: 'googleDocsToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleDocsAppendText',
+        description: 'Append text to the end of a Google Docs document.',
+        tool: appendText,
+        requiredAuth: 'googleDocsToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleDocsReplaceText',
+        description: 'Find and replace all occurrences of text in a Google Docs document.',
+        tool: replaceText,
+        requiredAuth: 'googleDocsToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleDocsDeleteContent',
+        description: 'Delete a range of content from a Google Docs document.',
+        tool: deleteContent,
+        requiredAuth: 'googleDocsToken',
+        scope: 'delete',
+    },
+    {
+        name: 'googleDocsCopyDocument',
+        description: 'Copy a Google Docs document.',
+        tool: copyDocument,
+        requiredAuth: 'googleDocsToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleDocsDeleteDocument',
+        description: 'Delete a Google Docs document (moves to trash).',
+        tool: deleteDocument,
+        requiredAuth: 'googleDocsToken',
+        scope: 'delete',
+    },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/google-docs/tools/insert-text.d.ts

@@ -0,0 +1,28 @@
+export declare const insertText: import("ai").Tool<{
+    text: string;
+    googleDocsToken: string;
+    documentId: string;
+    index: number;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    documentId?: undefined;
+    replies?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    documentId: string;
+    replies: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    documentId?: undefined;
+    replies?: undefined;
+}>;
+//# sourceMappingURL=insert-text.d.ts.map

package/dist/toolkits/google-docs/tools/insert-text.js

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const insertText = tool({
+    description: 'Insert text at a specific index in a Google Docs document.',
+    inputSchema: z.object({
+        googleDocsToken: z.string().describe('The Google Docs access token'),
+        documentId: z.string().describe('The ID of the document'),
+        text: z.string().describe('Text to insert'),
+        index: z.number().optional().default(1).describe('Character index where text should be inserted (default: 1)'),
+    }),
+    execute: async ({ googleDocsToken, documentId, text, index = 1 }) => {
+        try {
+            const response = await fetch(`https://docs.googleapis.com/v1/documents/${documentId}:batchUpdate`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${googleDocsToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    requests: [{ insertText: { location: { index }, text } }],
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to insert text', details: error };
+            }
+            const data = await response.json();
+            return { success: true, documentId, replies: data.replies };
+        }
+        catch (error) {
+            return {
+                error: 'Error inserting text',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=insert-text.js.map